MCP command reference

CoCAD serves six generic MCP tools — list_commands, execute, query, undo, redo and get_screenshot — and everything else is a command those tools reach. That is the design, not a limitation: the command registry is the product, so an AI has full parity with the UI by construction, and a new feature is a new command, never a new tool an agent has to wait for.

The one list that is always right is the running program’s own: call list_commands (which walks query.commands) and you get every command the connected build registers, each with its JSON Schema. Read that at runtime rather than trusting any written list — this page included, because gated commands exist only where their library is linked. What this page adds is a readable, linkable copy of that registry for the shipping configuration, regenerated from the repository on every build.

360 commands, read verbatim from the registry's own query.commands on windows-kernel-solver (the configuration CoCAD ships), as of 2026-11-04. This page is generated from that table on every build — it is never written by hand, and the build fails rather than publish a row it cannot parse.

Gates

Some commands exist only where their library is linked. The gate column below means:

desktop — needs the CoCAD desktop app. The installed app has it.
dxf — needs the DXF library. The shipping build has it.
pixels — needs image support. The shipping build has it.
not the fixture — present in the real app, and left out of the test build.
every build — registered in every configuration of the core.
kernel — needs the geometry kernel (OCCT). The shipping build has it.
solver — needs the sketch constraint solver (PlaneGCS). The shipping build has it.
fonts — needs font support (stb_truetype). The shipping build has it.
--allow-remote-shutdown — available only when the core was launched with this flag.

Documents & timeline

Creating, saving and opening documents, and walking the shared undo timeline — yours and any connected AI’s steps sit in one history.

Detail

Copy this document and every part it links to into one folder, with the copied recipe pointing at the copies - so the whole assembly can be sent to somebody else, or moved to another drive, and still open. path names the .cocad to write and its folder is where everything lands; each linked part is copied beside it under its own filename, and the copy's recipe stores that bare filename, which means beside this file on any machine. Parts linked by those parts are copied too, and their recipes are pointed at the copies in the same way, so a two-deep assembly arrives whole. A part linked twice is copied once. Two different parts that happen to share a filename get a -2, -3 suffix, because one folder cannot hold both names. It COPIES and never moves: the originals are left exactly where they are, and this document goes on reading them - a pack is not a save, so it does not change which file this document belongs to, does not clear unsaved changes and does not appear in your recent files. Lock sidecars and .bak files are not copied: a lock describes the machine you are on and a backup is a history that is not travelling. If any linked file is missing the whole pack is refused and nothing is written, because a folder with a part missing from it is worse than no folder at all - call query.links first to see what a document needs. Packing where files of the same names already exist is refused too, unless overwrite is true.

`doc.recover`

Rebuild the document from a crashed session's recording, replacing the current document.

Detail

Rebuild the document from a crashed session's recording, replacing the current document. The recorded commands are replayed in order, exactly as doc.open replays a saved file, so the recovered document has the same timeline - undo included - that was lost. Nothing changes unless the replay produces a document. The recording is left where it is: it is still the only copy until the recovered document is saved.

`doc.redo`

Re-apply the change undo last reversed, restoring its original entity IDs.

Detail

Re-apply the change undo last reversed, restoring its original entity IDs.

Open one of this document's branches in place of the one that is open: its recipe is replayed in order, exactly as doc.open replays a file, so the part, its timeline and its undo history become that branch's. The branch you leave is kept as it stood, rollback marker included, and the document keeps its name, its file and its tab. Nothing changes unless the replay produces a document; a replay that did not finish is reported in firstFailure and the branch's recipe is kept whole, so a later save loses nothing. Switching to the branch already open answers changed false. Not a step and not undoable - switch back to reverse it; doc.undo after a switch undoes that branch's own newest step. A feature made after a switch takes a number no branch of this document has, so features keep their identity across branches.

`doc.undo`

Reverse the most recent change.

Detail

Copy sketch curves at a fixed distance from the ones they came from — lines, circles and arcs only.

Detail

Copy sketch curves at a fixed distance from the ones they came from — lines, circles and arcs only. distance is signed: positive is to the left of the curve's own direction of travel, so a positive offset of a circle or an arc — which always run counter-clockwise — makes a smaller one. Each curve is offset on its own: the copies are not joined to each other and no corners are trimmed. The copies keep the construction and centerline flags of the curves they came from, and they carry no constraints — to make a copy move with its original, follow this call with sketch.constrain offset, the one constraint kind that relates a curve to the copy this command made of it, passing the same group so the two are one undo. Set preview true to be told what the copies would be without making them.

`feature.corner_relief` `kernel`

Cut the corner relief where two bend lines of a sheet-metal part cross - the notch a shop makes in the flat before folding, so the two bends have somewhere to go.

Detail

Cut the corner relief where two bend lines of a sheet-metal part cross - the notch a shop makes in the flat before folding, so the two bends have somewhere to go. Name the two flange ENDS that face each other across the corner with faces, exactly as feature.close_corner does (query.tree lists a body's faces; each end is the flat face that closes a flange's section at the corner). The notch is square or round - whichever the body's sheet-metal rule names - and reaches the rule's relief depth back from each fold line, cutting the wall's corner away and setting both flange ends back with it. Send relief to cut a different shape for this corner only. A rule whose relief is a tear cuts nothing and is refused by name. Both ends must belong to one sheet-metal body and must face each other at a right angle across an open corner; anything else is refused and says why.

`feature.crease_cage` `kernel`

Crease or smooth edges of a SUBDIV (freeform) body's control cage.

Detail

Crease or smooth edges of a SUBDIV (freeform) body's control cage. A creased edge stays sharp in the smooth surface - the surface folds along it, so a freeform part can have a hard edge, a seam or a flat-bottomed base - and sharpness 0 smooths a creased edge again (an uncrease). Between 0 and 10 the crease is soft: sharp for that many subdivision levels, then rounding off. Every other edge keeps the sharpness it had, and no face, point or id moves. On a body with a symmetry (feature.symmetry_cage) each edge's partners - its mirror image, or its copies round the axis - get the same sharpness, listed under followed. One step, one undo, a timeline feature; when every edge named already has that sharpness, nothing is recorded and the reply says so (changed is empty). Refused, by name: an id that is not a cage edge, edges of two bodies, a body that is not a subdiv body, an edge the cage no longer has, an edge on the cage's open rim (always sharp), and a soft crease sharp for more levels than the cage can be drawn at (the refusal names the largest that fits).

`feature.decimate_mesh` `kernel`

Reduce a MESH body's triangle count where it stands, keeping its shape - the step that makes a dense scan light enough to work with.

Detail

Reduce a MESH body's triangle count where it stands, keeping its shape - the step that makes a dense scan light enough to work with. Edges are collapsed cheapest first by how far each collapse would move the surface (quadric error), so flat regions melt to the few triangles their outline needs while creases and corners are kept. Give the size as targetTriangles or as ratio (the fraction to keep), exactly one. Corners on an open edge or on an edge a repair would call faulty are never moved, so a hole keeps its rim and a fault is left for feature.repair_mesh; no collapse is made that would fold the surface or change whether it closes, so a closed scan stays closed. The target is a ceiling and the reply says whether it was reached. The body keeps its ID, name, material and appearance, and one undo takes the decimation back. If nothing could be collapsed the reply says changed false and NOTHING is recorded. An exact body is refused.

`feature.delete_cage` `kernel`

Detail

Delete faces of a SUBDIV (freeform) body's control cage, leaving a HOLE: the faces round it keep their shape and their ids, and the edges of the hole become the cage's open rim (the smooth surface ends there), listed under rim - a closed body becomes an open one, as a Freeform Plane is. The way to open a body before bridging two holes into a handle, or to cut away the half of a body you mean to mirror. Every deleted face's id (cf:) is RETIRED and never reused; a cage point no face uses any more is retired too (listed under points). A crease on an edge of the hole goes with it. On a body with a symmetry (feature.symmetry_cage) each face's partners are deleted too, listed under followed - set the symmetry to none first to cut one side away. One step, one undo, a timeline feature. Refused, by name: an id that is not a cage face, faces of two bodies, a body that is not a subdiv body, a face already deleted, every face the cage has (delete the body instead), and a hole that would leave two parts of the cage touching at a point by a corner alone.

`feature.delete_face` `kernel`

Remove faces from a SOLID body and heal the openings - the direct edit that defeatures a part.

Detail

Remove faces from a SOLID body and heal the openings - the direct edit that defeatures a part. Name faces of ONE body in faces; the neighbouring faces stretch along their own surfaces to close each opening, so a fillet, a boss or a hole's wall vanishes as if it had never been cut - the natural way to simplify an IMPORTED body that has no feature to suppress (on a native body, feature.suppress is the parametric door and keeps the feature recoverable). No new side wall is ever invented: an opening the neighbours cannot close is refused (a plain box's Top has nothing to close it, for example). The body keeps its ID and name; a removal that severs the body keeps every piece, the largest by volume keeping the ID.

Detail

Extrude faces of a SUBDIV (freeform) body's control cage - the first step of shaping one: the chosen faces move out by distance, and a wall of new cage faces grows from every edge around them, so the smooth surface bulges out into an arm, a leg, a spout. Faces that share an edge move together as one patch along that patch's own outward direction; faces that do not, each along their own. The extruded faces keep their ids (cf:<body>.<n>), so the same selection can be extruded again; the reply lists the new wall faces under walls. One step, one undo, a timeline feature. Refused, by name: a face that is not a cage face, faces of two bodies, a body that is not a subdiv body, a distance of 0, every face of a closed cage (that would only move the body), faces that point opposite ways, and faces that touch at a point by a corner alone.

`feature.fillet` `kernel`

Round the named edges of one body.

Detail

Round the named edges of one body. Each edge carries its own size, so a uniform round is one number repeated and a stepped one costs nothing extra. A round that VARIES along its edge is a stops law instead of a radius — at least two {position, radius} stops, positions running 0 to 1 along the contour — and each edge states exactly one of the two, though different edges in one call may state different ones. The body keeps its ID, its name and its place in the tree — a fillet edits the body it was given and creates nothing — and every edge named must belong to that one body.

`feature.finger_joint` `kernel`

Detail

Join two plates at a square corner with a finger joint (a box joint): the corner is cut into an odd number of equal fingers that interleave, the first plate taking the two end fingers and every second one between, the second plate keeping the rest - so the two press together like a laser-cut box and both outside faces show the fingers. The plates are two exact solids where the first's END face lies against the second's SIDE (a butt corner, or a T); the shared face is found. Each finger the first plate gains is the second plate's own material, through its whole thickness, and the second plate's socket is the finger grown by clearance on every side. Give fingers (odd) or fingerWidth, or neither for fingers about twice the second plate's thickness. Nothing else is made. Refused, each with details.reason, when the plates share no flat face (noSharedFace), when the faces do not overlap (noOverlap), when the first's face on the plane is not smaller than the second's - the order is reversed, or the pieces are a plate cut straight across (notACorner), when the shared region is not a full rectangle (notRectangular), when the second plate is not one even thickness behind it (uneven, with at), when a finger would be narrower than 1 mm once the clearance is taken (tooFine, with step and needed), and when the sockets would cut the second plate in two (severs). One feature, one undo; both bodies keep their IDs. The reply gives the direction along the joint, the joint's corner (origin), its length, width and depth (the second plate's thickness), and the fingers and their width.

`feature.fit` `kernel`

State what round holes or pins are sized FOR - "this hole is a press fit for a 5 mm pin" - so the fit lives in the model rather than in somebody's head.

Detail

State what round holes or pins are sized FOR - "this hole is a press fit for a 5 mm pin" - so the fit lives in the model rather than in somebody's head. It is a timeline feature that changes no geometry: it records the intent, and query.design_check then judges each named round against it using the fit calibration you name, reporting the diameter the printer is predicted to make, the diameter the fit wants, and suggested - the diameter to DRAW so this machine prints it right. Nothing is ever changed for you: resize the hole yourself (feature.edit on the feature that made it). nominal is the MATING size (the 5 of a 5 mm pin), never read off the drawing, because the drawn size is what you will change to compensate a printer. Give the band as an ISO 286 class in designation ("H7" for a hole, "p6" for a pin; query.fits shows what one means) or as two plain deviations from nominal in lower and upper - an FDM press fit on a hole is typically a little below nominal, a slip fit a little above, and your own printer's numbers are the right ones. Every face must be a round (a cylindrical face that closes on itself) of one body, all holes or all pins - which side a round is on is read off the geometry, never sent. A round carries one fit; feature.edit changes it and feature.suppress switches it off.

Detail

Insert an EDGE LOOP into a SUBDIV (freeform) body's control cage: a new row of cage faces running ACROSS the named edge, so the smooth surface can be shaped there - extruded, creased, pulled - without disturbing it anywhere else, and a loop near an edge holds the surface tighter to it. The loop crosses every four-sided face of the named edge's ring, cutting each in two; it runs all the way round when the ring closes (round a box's waist), and a face where the ring ends that is not four-sided (a sphere's pole triangle) takes the new point as one more corner. Every edge the loop crosses is split, and its id is RETIRED - never reused (the reply lists them under split); the new edges are numbered after every edge that already was, the loop's own listed under loopEdges. Every face keeps its id - the half of each cut face on the side of the named edge's first point keeps it, and the other half is added (under faces). A crease on a split edge stays on both halves. One step, one undo, a timeline feature. Refused, by name: an id that is not a cage edge, edges of two bodies, a body that is not a subdiv body, an edge the cage no longer has, an edge with no four-sided face on either side, a ring that would cross one face twice, and a cut that would leave a soft crease too deep to draw.

`feature.jog` `kernel`

Detail

Step a flat wall of a sheet-metal part sideways about a line drawn on it - the offset in a bracket, the lap in a panel, any place one part of a wall has to sit parallel to the rest and a fixed distance off it. Name the wall with face and the line with line (a straight sketch curve lying over that face; query.sketch lists them), and height says how far the moving side steps. It is TWO bends: one turns the metal off the wall by angle, a flat run carries it across, and the second turns it back, so the moving side ends up parallel to the wall it came from. The line is the jog's CENTRE LINE and the flat it consumes straddles it. fixedSide says which side stays put - "left" or "right" of the line, looking at the face you picked from outside and walking the line from its start to its end - and direction says which way the step goes. The stock, the bend radius and the K-factor come from the BODY's sheet-metal rule; bendRadius and kFactor override them for this jog only. The metal the line runs through has to be a plain rectangle of that stock - a hole or another wall inside the strip is refused and says so.

Detail

Repeat one body (body) or one component placement (occurrence) under a rigid motion — in a line (type rectangular), about an axis (type circular), or along a run of curves (type path, spaced by arc length, each copy carried on the path's own frame or kept parallel with orientation fixed). count includes the original, so count 4 makes three copies, and what is being patterned is never modified. With body, the copies can be kept as a body of their own or joined to / cut from / intersected with the bodies they meet, and they act as ONE tool, which is what makes a bolt circle of holes a single cut. With occurrence, each copy is another placement of the same component — so a parts list counts one part eight times rather than eight parts — and operation, targets and name do not apply. skipInstances leaves individual copies out without moving the ones that stay, so a row of holes can have a gap in it. There is no geometric refusal: a rigid motion is an isometry, so copies that overlap each other, or the original, are ordinary. A mesh body (a scan made a body) is patterned too, rectangular or circular, into one new mesh body holding the copies; its join, cut and intersect are refused, because combining triangles needs mesh booleans.

`feature.press_pull` `kernel`

Press or pull faces of a SOLID body - the direct edit also called offset face.

Detail

Press or pull faces of a SOLID body - the direct edit also called offset face. Name faces of ONE body in faces and a distance in mm; side "front" (the default) moves them along their own normals - a solid's normals point OUT, so front GROWS the body and "back" presses in, removing material. The neighbouring faces stretch or shrink along their own surfaces to stay joined; no new side wall is ever invented, and a press the neighbours cannot close is refused (to add material WITH walls, feature.extrude on the face's profile is the door). The body keeps its ID and name and the pressed faces keep theirs; a press that severs the body keeps every piece, the largest by volume keeping the ID.

Detail

State a requirement the part must keep meeting - "an M3 passes through this hole", "every wall at least 1.6 mm", "the lid clears the base by 0.5 mm", "fits a 256 mm bed" - as a check CoCAD re-runs against the current model whenever query.requirements is read. It is a timeline feature that changes no geometry: statement is the sentence, and quantity, entities and atLeast/atMost are the check you compiled it into. Six quantities, each measured by the read you would call yourself: diameter of a round (query.measure; "an M3 passes through" is atLeast 3.2, or whatever clearance your shop uses), distance between two things (query.measure's between; "clears by 0.5" is atLeast 0.5), wallThickness of a body (query.wall_thickness), size along an axis (query.build_fit's extent; "fits a 256 mm bed" is two requirements, x and y, atMost 256), volume and mass (query.mass_properties). The reply is the requirement's first check - status pass, fail or unmeasured, the measured number and the read that produced it - so you see at once whether the part already meets it. A requirement may be stated before the part meets it, or before it can be measured at all (a mass before doc.set_material): it is recorded and reported unmeasured with the reason. What is refused is a malformed check and anything the read itself refuses, such as a body that does not exist. Nothing ever refuses because a requirement fails. feature.edit changes one; feature.suppress switches it off.

`feature.revolve` `kernel`

Turn a closed sketch region about an axis into a solid.

Detail

Turn a closed sketch region about an axis into a solid. Take the profile ID from query.profiles, and name the axis as a line in the same sketch — an ordinary line, a construction line or a centerline — or as a construction axis (construct.axis), or as a straight edge of a body (query.edges); the last two must lie in the profile's own plane. The whole infinite line is the axis, not just the drawn segment, and the profile must not cross it, though touching it is how a sphere or a cone is made. The extent is two signed angles in degrees: end is required and start defaults to where the profile was drawn, and the sign is the direction, so there is no flip flag. A full turn is start 0 and end 360 and has no end caps at all. operation says what becomes of the turned solid: a body of its own, or joined to / cut from / intersected with the bodies it meets, which keep their IDs and names. thin turns only a wall along the profile's boundary rather than its whole area — a vessel, a tube, a funnel or a lampshade. surface: true turns a SURFACE instead of a solid (ADR 0301): the boundary's swept walls with no caps, answering a SHEET body — sheet: true on the reply and the tree row, and no volume to measure until feature.thicken gives it one. Its operand is profiles (one skin per boundary loop) or curves (an open or closed run of sketch curves from one sketch — a swept band, or a closed skin when the run closes), exactly one of the two; the axis and the angles read exactly as for a solid, and operation and thin are refused beside it.

`feature.rib` `kernel`

Stand a thin wall up along an OPEN run of sketch curves until it meets the part it stiffens — a rib inside a moulded housing, a web under a boss.

Detail

Stand a thin wall up along an OPEN run of sketch curves until it meets the part it stiffens — a rib inside a moulded housing, a web under a boss. Name the run with spine (sketch curves from ONE sketch, query.sketch lists them) and how thick the wall is with thickness; the material sits half either side of the curves you drew. The order you name them in does not matter — they are joined end to end by where they actually meet — and a run that branches, has a gap in it, or closes into a loop is refused. There is no depth to give: the rib grows both ways along the sketch plane's normal and stops at the first material it meets each way, and an end that meets nothing stays flat on the plane you drew on. It always joins what it meets, which keeps that body's ID, name and visibility; targets narrows which bodies it may join and which it looks at for its stopping point.

Detail

Grow a cantilever snap-fit from a flat face: a beam length long standing square to the face, thickness thick the way it bends and width wide, with a hook at its tip that stands hook proud of the beam - a lead-in ramp at insertAngle from the beam's axis (default 30) and a retaining face at retainAngle (default 90, a permanent catch). The beam is joined to the face's body, at the face's centre unless at says where, its hook pointing across the face's long axis unless direction says which way. With catchBodyId - the mating part, placed where it sits when snapped in - the window the hook catches in is cut through it where the hook is, clearance bigger than the hook on every side. The reply reports the beam's strain when it bends the hook's depth to go in, 1.5 x thickness x hook / length^2 (0.02 is 2%), as a number and never a verdict: compare it with the material's allowable strain - a beam that strains too much is not refused. Refused, each with details.reason, when the beam's footprint is not wholly on the face (offFace, with at), when the hook leaves no beam to bend (tooShort, with needed - the length the beam must exceed), when the window would not reach the catch body (missesCatch) and when it would cut the catch body in two (severs); and a face that is not flat, or a direction square to it, by name. One feature, one undo; both bodies keep their IDs. The reply gives the beam's root (origin, the middle of its footprint), the face's normal, the hook's direction, where the retaining face meets the beam (catchAt, from the root) and the strain.

`feature.split` `kernel`

Divide a SOLID body into separate bodies along a cutting tool, keeping every piece.

Detail

Divide a SOLID body into separate bodies along a cutting tool, keeping every piece. Name the body in body and a cutting tool as exactly ONE of plane/face/constructionPlane (an unbounded plane), tool (a sheet body - bounded), or profile (a sketch region extended perpendicular to its sketch into a fence). The largest piece by volume keeps the ID and name; the rest become new bodies in the same step. The tool is never consumed, and a tool that does not pass clean through is refused - a split that leaves one piece would change nothing. To remove solid material instead, use feature.combine with "cut"; to cut pieces off a sheet, feature.trim. A mesh body (a scan made with body.from_reference_mesh) is split by a plane only - plane, face or constructionPlane - provided it closes up into a solid (feature.repair_mesh first if not); every piece stays a mesh body, capped flat where the plane passed.

`feature.split_face` `kernel`

Divide the named faces of a SOLID body along a cutting tool, without cutting the body itself - the direct edit that draws a real, nameable boundary onto a face.

Detail

Divide the named faces of a SOLID body along a cutting tool, without cutting the body itself - the direct edit that draws a real, nameable boundary onto a face. Name faces of ONE body in faces and a cutting tool as exactly ONE of plane/face/constructionPlane (an unbounded plane), tool (a sheet body - bounded), or profile (a sketch region extended perpendicular to its sketch into a fence). Each named face is replaced by its pieces and EVERY piece is kept - there is nothing to remove here; the body keeps its ID, its name and its shape, and the new edges come back in edgeIds ready for a fillet, a draft or a press-pull on one piece alone. The tool is never consumed. A tool that crosses none of the named faces is refused - an imprint that changes nothing does not journal. To divide the BODY into separate bodies, use feature.split; to imprint a sketch onto a sheet, feature.project_curve.

`feature.stitch` `kernel`

Sew two or more SHEET bodies (ADR 0301 - surfaces with no enclosed material) into ONE body.

Detail

Sew two or more SHEET bodies (ADR 0301 - surfaces with no enclosed material) into ONE body. The FIRST body named survives with its ID and name; the rest are consumed and named in removedBodyIds. Gaps up to tolerance are closed. A result that closes into a shell with no free boundary is promoted to a SOLID automatically - the sheet flag simply disappears, exactly as feature.thicken's does - unless surface: true keeps it a sheet. A stitch that would leave separate shells is refused whole rather than consuming bodies it could not attach. Solids are refused: feature.combine is where solids join, and feature.unstitch is the inverse door.

Detail

Give a SUBDIV (freeform) body's control cage a SYMMETRY that its point moves keep, so one side is shaped and the other follows: a MIRROR across a plane (a bottle, a car body, a face) or a CIRCULAR symmetry of count copies round an axis (a knob, a rosette). From then on feature.move_cage moves every named point's partners too - the mirror image of the move, or the move turned round the axis - and keeps a point on the plane or the axis on it. The partners are found on every move, not stored: a point lands on a partner when the symmetry sends it within a millionth of the cage's size of one, so a later extrusion on one side simply has no partners until the other side has its twin (query.cage's symmetry lists the points that have none). Every other cage edit keeps the symmetry. type none removes it. One step, one undo, a timeline feature; asking for the symmetry the cage already has records nothing. Refused, by name: a body that is not a subdiv body, a plane or axis with no direction, an argument that belongs to the other type, and a symmetry under which no point of the cage has a partner (the cage is not symmetric there).

`feature.texture_mesh` `kernel`

Detail

Press a surface texture into a MESH body, where it stands - a knurl, ribs, scales, leather grain or a picture - by moving every corner of its surface along its own normal by the pattern's height there. size is one repeat of the pattern and depth its full height; mode raise stands the texture on the surface (material added) and mode cut sinks it in so the surface is the texture's top (material taken away, the part keeps its size). mapping box (the default) lays the pattern on any shape from the side each part of it faces; cylinder wraps it round an axis with a whole number of repeats so it closes with no seam; plane projects it along an axis. region limits it to a box. A texture needs triangles finer than itself - on average at most a quarter of size - so give edgeLength to even the surface out first in the same step (an eighth of size is a good choice); without it a coarse surface is refused, naming the length that works. Corners in one place move together, so a closed body stays closed unless the texture folds it through itself, which is not refused - the reply says whether it still closes and its volume. The body keeps its ID, name, material and appearance; one undo takes the texture back. Refused: an exact body (turn it into a mesh with body.to_mesh first), an axis missing for cylinder or plane or given for box, a canvas missing for the image pattern or given for another, a region holding none of the body, and a surface too coarse. preview: true works it all out and changes nothing. If nothing moved the reply says changed false and NOTHING is recorded.

Bodies created directly, without a sketch.

`body.box` `kernel`

Create a rectangular box body.

Detail

Create a rectangular box body. Dimensions in millimetres along X, Y and Z.

`body.chain` `kernel`

Make a print-in-place chain of ball-and-socket links along a path - a flexi chain, snake or tail that prints as one part and moves when it comes off the bed.

Detail

Make a print-in-place chain of ball-and-socket links along a path - a flexi chain, snake or tail that prints as one part and moves when it comes off the bed. The links are spaced pitch apart in a straight line along the path (each link is rigid, so it spans a chord) and each one is a hollow socket with a neck running to a ball that sits inside the next link's socket, clearance all round. Every size of a link follows from ballDiameter and clearance, and the reply states them. A joint can bend only so far before the neck meets the socket's rim (swing, in degrees, in the reply): a path that bends more than that between two links is REFUSED and says where - use a gentler curve, a shorter pitch, or a smaller clearance. Two links that are not neighbours but come close enough to print fused (a tight spiral, a path that crosses itself) are refused too, naming both. The answer is ONE body holding every link as a separate solid, so it exports as one file; the links touch nothing. The path does not have to be used up: the chain stops at the last whole link and leftover says how much path was not reached. A CLOSED path makes a ring (closed: true in the reply): the pitch is adjusted to the nearest one that divides the ring into whole links - never below minPitch - so the last ball sits in the first socket, and the reply's pitch is the adjusted one beside requestedPitch. With joint hinge each link is instead a centre knuckle with a pin through it at one end and a bored fork at the other, so the chain bends in one plane (a band or a tread): a path that leaves its plane is refused naming the first link that does. A ball chain's neck can be your own section - profile, a closed region of a sketch - in place of the round one. Set preview true to see the plan without building anything.

`body.composite_curve` `kernel`

Join sketch curves and body edges into one WIRE body: a single chain of curves with no faces and no material, which is what a sweep, a loft's centerline or a pattern follows.

Detail

Join sketch curves and body edges into one WIRE body: a single chain of curves with no faces and no material, which is what a sweep, a loft's centerline or a pattern follows. This is the only place the two kinds may be MIXED - a sweep's own path is all sketch curves of one sketch or all edges of one body, and this command's answer is one run in one identity world, so a path that starts on a drawing and carries on along a part is named here first. The curves may come from any number of sketches and any number of bodies, in any mixture, and a helix counts. THE ORDER YOU NAME THEM IN DOES NOT MATTER: they are chained by where their ends actually meet, and a run that branches, has a gap in it, or names the same curve twice is refused and says which. A single circle, ellipse, closed spline or closed edge is a whole chain on its own and makes a ring. The answer is a COPY - it does not move when the curves it was made from move, and deleting them does not delete it. A wire body has no volume, no mass and no mesh: query.edges draws it, query.measure answers its length, and the commands that need material or faces refuse it by name. The reply's edgeIds are what to name as a path.

`body.cylinder` `kernel`

Create a cylinder body, axis along +Z from its origin.

Detail

Create a cylinder body, axis along +Z from its origin.

`body.derive` `kernel`

Detail

Derive bodies from another CoCAD document - the file's own recipe is replayed and the bodies it builds arrive HERE as plain bodies in the Bodies folder, under one timeline feature, so you can cut, fillet, shell, combine or pattern them like any body: a mould from a part, a cover from a board, a fixture from an assembly. Nothing becomes a component or a placement - if the file is an assembly, its parts arrive flat, at the coordinates they stand at there, and the reply's flattened says how many placements that was. bodies names which of the source's bodies to take, by the names its tree shows; leave it out for every body, and read the reply's sourceBodies to see what it holds. at takes the source as its timeline stood just after one of its features, ft:N - the part before the later features were added - instead of as it ends. By default the geometry is EMBEDDED - this document keeps its own copy of the source and opens anywhere. Send link if you want this document to follow the source: it is then re-read from its path every time this document opens or rebuilds, query.links reports it, assembly.relink repoints it when the file moves, and doc.pack carries it; to read a linked file again NOW, without reopening, send assembly.relink with from and to both its path. Use assembly.insert_component instead when the file should stay a PART with an identity of its own - a parts-list row, joints, further placements.

Create a SUBDIV body (a freeform, smooth body) from a box-shaped control cage: a Catmull-Clark cage of width x depth x height, centred on origin, cut into widthFaces, depthFaces and heightFaces faces along X, Y and Z (2 each by default). The body is the cage's smooth LIMIT surface, which lies inside the cage and rounds off every corner and edge - more faces along a side keep the surface closer to that side. The cage is what is stored; query.tessellate draws the surface. A subdiv body has no exact faces, so exact modelling commands refuse it: convert it with body.from_subdiv for an exact solid. The reply's cageBoundingBox is the cage's box, which the surface lies inside.

`body.subdiv_cylinder` `kernel`

Create a SUBDIV body (a freeform, smooth body) from a CYLINDER cage about Z: radius and height, centred on origin.

Detail

Create a SUBDIV body (a freeform, smooth body) from a CYLINDER cage about Z: radius and height, centred on origin. Each cap is cut into diameterFaces x diameterFaces faces laid onto a disc, so 4 x diameterFaces faces run round the wall, and the wall is cut into heightFaces faces along Z (2 each by default). Every face is a four-sided quad, so it shapes cleanly. The body is the cage's smooth LIMIT surface, a rounded column lying inside the cage - not an exact cylinder (use body.cylinder for that). The cage is what is stored; query.tessellate draws the surface. A subdiv body has no exact faces, so exact modelling commands refuse it: convert it with body.from_subdiv for an exact solid. The reply's cageBoundingBox is the cage's box, which the surface lies inside.

Detail

Create a SUBDIV body (a freeform, smooth body) from a UV SPHERE cage about Z: longitudeFaces faces round Z (8 by default) and latitudeFaces from pole to pole (4 by default), every cage point on a sphere of radius about origin. The bands between the rings are four-sided quads and each pole is a fan of three-sided faces - a globe's lines, for a shape pulled out along its axis; for a ball of quads only, use body.subdiv_quadball. The body is the cage's smooth LIMIT surface, a near-sphere lying inside the cage - not an exact sphere (use body.sphere for that). The cage is what is stored; query.tessellate draws the surface. A subdiv body has no exact faces, so exact modelling commands refuse it: convert it with body.from_subdiv for an exact solid. The reply's cageBoundingBox is the cage's box, which the surface lies inside.

Named values on the document, written as expressions that may refer to each other. The whole set is evaluated before anything is stored, so a document never holds an expression that cannot be read.

`param.create`

Add a named user parameter to this document.

Detail

Add a named user parameter to this document. Its expression may refer to other parameters by name, in any order. The whole set is evaluated before anything is stored, so a document never holds an expression that cannot be read. Undoable.

`param.delete`

Remove a parameter.

Detail

Remove a parameter. Refused when another parameter's expression refers to it, or when a recorded operation stands on it, naming which of each - deleting it would leave an expression nobody can read. query.parameters answers both lists before you try. Undoable.

`param.set`

Change a parameter's expression, its kind, or its name.

Detail

Change a parameter's expression, its kind, or its name. Renaming rewrites every other expression that referred to it, so no reference is ever left dangling. The whole set is evaluated before anything is stored. Undoable.

`param.set_intent`

Say WHY a parameter is the value it is - "0.4 mm nozzle, so 3 mm is seven perimeters", "the bearing's outer diameter, from the datasheet".

Detail

Say WHY a parameter is the value it is - "0.4 mm nozzle, so 3 mm is seven perimeters", "the bearing's outer diameter, from the datasheet". The note sits beside the parameter and is an input to nothing: it changes no value, no expression and no rebuild, which is what lets it be a sentence rather than a number. A parameter's note is its OWN, never the note on a feature that reads it - many features read one parameter, and a reason about the value must not vanish when one of them is deleted. Dated and attributed automatically, so a note an AI wrote can be told from one a person wrote. entities are the ids the sentence is about and must exist when the note is written; query.parameters later reports each one as still alive or not. Send intent as null to clear the note - required either way. Read them back on query.parameters. A rename keeps the note. Saved with the file, and undoable in one step.

`param.set_many`

Detail

Re-point a construction plane at another base, or an angled plane at another edge, and recompute its frame from the same construction.

Detail

Re-point a construction plane at another base, or an angled plane at another edge, and recompute its frame from the same construction. This is the repair for a plane whose baseIssue or edgeIssue says what it was built from was split or consumed: pass one of the candidates it names. The plane keeps its ID, its name, its type and its distance or angle, so everything that refers to it goes on referring to it. Re-pointing at what the plane is already built from changes nothing and records no history step.

Queries

Read-only questions about the document, the session and the registry itself — how an AI (or any client) sees what it is doing.

`query.activity`

Whether anyone else is changing the document right now, what they are running, who they are, and which document (documentId) it is in.

Detail

Whether anyone else is changing the document right now, what they are running, who they are, and which document (documentId) it is in. The same fields the ai.activity_changed event carries, so a client that connected in the middle of a long command can ask once and then listen.

`query.axis` `kernel`

One construction axis: where it is, which way it runs, and what it was built from.

Detail

One construction axis: where it is, which way it runs, and what it was built from. The line is infinite - a point on it plus a unit direction - so a caller that wants to draw it picks its own length. cylinderIssue is null while the face the axis was built from still resolves, and carries a code plus any candidates when an edit split or consumed it; the axis keeps its stored line either way.

`query.backups`

List the kept previous versions of a document, newest first.

Detail

List the kept previous versions of a document, newest first. Every doc.save that replaces an existing file keeps the bytes it was about to destroy as a stamped sibling, the newest files.backupCount of them. Each one is a complete .cocad, so restoring a version is doc.open on the path reported here - there is no separate restore command. Answers an empty list when there are none, including when the document itself is gone.

`query.bends` `kernel`

Every bend in one body, measured off the part itself - the bend table a shop reads and the first thing a flat pattern is built from.

Detail

Every bend in one body, measured off the part itself - the bend table a shop reads and the first thing a flat pattern is built from. A bend is found as a pair of cylindrical faces sharing an axis and a swept angle: innerFace and outerFace are their fc: ids, radius is the INSIDE bend radius in millimetres and angle is how far the metal turns, in DEGREES. thickness is the stock at that bend, measured as the outer radius less the inner one rather than read from the body's sheet-metal rule - so comparing it with the rule's own thickness is how you find a part that is no longer the stock it says it is. length is how far the bend runs along its axis, and axis is a point on that axis (at the middle of the run) with a unit direction, both in document millimetres. walls lists the flat faces the bend joins, normally two; fewer means a wall has been cut away. bendAllowance is the flat metal the bend consumes - angle in radians times (radius + kFactor x thickness), the number you add between two walls when laying the part out flat - and kFactor is the body's own, from its sheet-metal rule. BOTH ARE NULL when the body carries no sheet-metal rule: where the neutral axis sits inside the metal is a property of the alloy and the tooling and cannot be measured off the finished shape, so set a rule with feature.base_flange or doc.set_sheet_metal_rule and ask again. A body with no bends answers an empty list, which is an answer and not an error - a box, an unfolded blank and a turned shaft all come back that way. Nothing is changed, nothing is recorded: this is a read.

`query.board_layout` `kernel`

Read a circuit board as GEOMETRY, for building a case around it: the board's two faces (top and bottom, by face id) and thickness, its FRAME (origin, x, y, z: z points out of the top face, and the board fills 0..width by 0..depth by 0..thickness in it, so every number below is a size), its outline's width and depth (the plan box - a notched or round board is read as its box; the top face's edges are the true outline), its through HOLES largest first (diameter, at - the centre on the top face in world coordinates, plan - the same in the frame; mounting holes are usually the largest), every PART on it (body, side top or bottom - where most of its height is, so a through-hole part with pins below is top - height above that face, its box in the frame, and its gaps to the four outline sides minX, maxX, minY, maxY, negative when it overhangs), the PORTS - one row per part and side it comes within portGap of, with the opening's centre and outward normal in world coordinates, its width along the side and height, and the same span in the frame - and the ENVELOPE, the box the board and its parts fill in the frame (a case's inside must hold it).

Detail

`query.bom`

The parts list - one row per component definition, with its item number, the quantity placed across the whole nested tree and the part-metadata record as the row's columns.

Detail

The parts list - one row per component definition, with its item number, the quantity placed across the whole nested tree and the part-metadata record as the row's columns. item is the row's position in the partsOnly order - 1 for the first listed definition - and it is the number a drawing's balloon prints, so a balloon and the table can never disagree; a definition that appears at two levels of the structured tree carries one item at both, because an item names the part. partsOnly, the default, is the flattened rollup a person prints: every definition once, however deep its placements sit. structured is the indented tree: rows carry children, and a child row's quantity counts inside all instances of its parent row together - a sentence that stays true even when one instance has been edited apart from its siblings. A part is a definition: a mirrored component is its own row, and so is each member definition a nested placement materializes, because a placement's content is a self-contained replay. A definition whose record carries excludeFromBom loses its row in both modes and is disclosed in excluded - the omission is never silent, and the entry names the component so one query.metadata call shows the flag. Loose bodies are not rows: the BOM of a loose-body part file is empty, and empty is an answer - the document's own record is a title block's, not a row. Never journaled - asking for a parts list is not a modelling step.

Detail

Every linked component this document holds, in the order its recipe names them, and whether the file each one points at is still there. A linked component is one inserted with link true: the part is not embedded, so the file is re-read every time this document opens, and moving or renaming that file is what breaks it. Each row gives the path exactly as the recipe stores it, where that path points from this document today, the name the part goes by, the command that made the link, the ft: id of the timeline feature that made it (null when the recipe records no number, which a hand-written file will not), and issue - null when the file is there, or an object naming what is wrong with it. A stored path may be relative, which means beside this document's own file: resolvedPath is where it lands, and it is the same string as path for an absolute one. resolvedPath is null only when the path is relative and this document has never been saved, so there is no folder to measure it from - the issue code for that is UNRESOLVED_PATH, and the remedy is to save the document rather than to go looking for the part. The other code is INVALID_PATH, the same code the open itself refuses with, meaning there is no file where the path points. The check is about the FILE and not about the document: a link can be broken while the part is still on screen, because the file was moved after this document opened, and a broken link blocks nothing - the rest of the document goes on working exactly as it did. Embedded components are not listed and do not need to be: their bytes are in this document, so there is nothing outside it to lose. A suppressed insert is not listed either, because a suppressed record does not re-read its file. Nothing here is stored: the answer is computed where it is asked, so a file put back where it belongs reads healthy on the next call with no repair step at all.

`query.mass_properties` `kernel`

Detail

The full engineering mass-properties report: per body, the volume (mm³), surface area (mm²), centre of gravity (mm, world, the VOLUME centroid), the moments and products of inertia, the principal axes and moments, and the radii of gyration — plus a combined rollup over everything named, which is how an assembly is weighed. entities is optional: absent means every body in the document; a bd: names one body and an oc: names a component placement, contributing every body it owns, nested placements included. Each body is weighed at the density it HAS: the call's density argument if one is sent (it overrides everything, which is how "weigh it all in aluminium" is asked), else the material assigned to that body with doc.set_material, else nothing — and every row says which number fed it in its own density key (g/cm³, or null). With a density, mass is answered in GRAMS and the inertia moments in g·mm²; without one those keys are NULL: assign a material or send a density, because a made-up number would be worse than a missing one. Rows may legitimately differ — a steel pin in an ABS housing — and combined then carries the true mass-weighted rollup with a null density of its own, because there is no single number to name. combined's mass is null unless EVERY solid row had a density: a sum missing one body reads as the whole assembly's mass and is not. The density-free half is answered either way: the principal AXES and the radii of gyration do not depend on a uniform density at all (a radius of gyration is sqrt(I/m), and the density cancels). frame chooses where the inertia tensor is taken: "com" (the default) is about each body's own centre of mass in world axes — the rollup's about the combined one; "world" is about the document origin in world axes; a cs: ID is about that coordinate system's origin in ITS axes. A construction plane is refused by name: its in-plane axes derive from its normal by convention, so a tensor in them would be nine numbers about axes nobody chose — construct.coordinate_system is how a chosen frame becomes something this argument takes. Principal properties are always about the centre of mass whatever frame says, because they are the frame-free half of the report. Convention: ixx is the MOMENT ∫(y²+z²)dm and ixy is the PRODUCT ∫xy·dm — positive integrals, the numbers a handbook tabulates; the inertia TENSOR's off-diagonals are their negatives. A sheet or wire body answers solid: false with every measurement null — it has no enclosed material, so it has no mass properties; measure a sheet's area or a wire's length with query.measure. A mesh body (a scan made a body with body.from_reference_mesh) is weighed off its own triangles, exactly for what they are, when they close into one consistently wound surface, and joins combined like any solid; an open or inconsistently wound one answers solid: false, as a sheet does. combined sums the solid rows only and says so: count is every row, measured is how many fed the sums. Nothing is changed, nothing is recorded: this is a read.

`query.materials`

Detail

Every material this build knows - a small engineering set, each row a name, a density in grams per cubic centimetre, its provenance in ref, and a default appearance as r, g and b fractions between 0 and 1. The library is a vocabulary rather than a dependency (ADR 0324): a document never references these rows - a caller reads one and sends the numbers themselves, so a saved model can never depend on which machine opened it or on later edits to this table. density is in the unit query.mass_properties takes; nothing here is converted, scaled or rounded. source on each row reads built-in, user, or built-in, overridden - saying whether that row is this build's own or came from your materials.json, which adds materials and changes shipped ones by name. appearance is absent on a row that names no default look, and absent never means black. version names the shipped table's shape rather than your file's. It says nothing about the open document and never fails.

`query.mcp_setup`

How an AI client connects to THIS install of CoCAD, worked out from what is on this machine rather than described in general.

Detail

How an AI client connects to THIS install of CoCAD, worked out from what is on this machine rather than described in general. snippet is the text to paste into an MCP client's configuration file - the whole mcpServers object, so it lands at the right nesting level - and serverKey is the name CoCAD is filed under inside it, which is what a person means when they tell an AI to use cocad. server says whether this build could find its MCP server at all: command and args are absolute paths that exist, layout is installed (beside the core) or repo (a development checkout), and env carries COCAD_CORE_PATH so a client that starts before CoCAD does can launch a core instead of refusing. When found is false, problem is one sentence saying what is missing and searched lists every path that was looked at, in order, so the answer can be checked rather than believed. clients is the clients this build knows how to set up here, each with its configPath, whether that file exists yet, and its transport: a stdio row launches CoCAD with the snippet above and its own snippet is null, while an http row connects to a running cocad-mcp --http and its snippet is that client's own spelling with <url> and <token> left where the server's address and bearer token go. The list is open and being absent from it means only that nobody has verified that client - every MCP-capable client works with the same snippet. Nothing here is guessed: a path in this reply is a path this build looked at. It says nothing about the open document and never fails.

Detail

Every named view this document holds, in the order they were made - each giving its camera (the five channels view.set_camera takes), its display style, the section and explode states it shows (null meaning uncut/assembled), and the entities it hides. Applying one is a composition: view.set_camera with the camera, doc.set_visible for the hidden set. Nothing here says which view is showing: that belongs to whoever is looking, exactly as a camera does.

`query.open_with` `desktop`

Detail

List the programs this computer offers to open a kind of file - its own Open with list for an extension, so for 3mf or stl usually the slicers installed here (Bambu Studio, PrusaSlicer, OrcaSlicer...) and for step the CAD packages. Each handler has an id, the name the desktop shows, and default: true on the one a double-click uses. Hand an id back as openWith on export.3mf, export.stl, export.obj, export.gltf, export.step or export.iges to write the file and open it in that program rather than the default. CoCAD keeps no list of programs of its own: this is the desktop's list, so it is empty on a machine with nothing registered for the type and on platforms where the desktop does not list handlers (canChoose: false) - open: true still opens the default there. Reading the list starts nothing.

Detail

Which axes does a body repeat itself about, and how many times - and, for a broken or partly missing part, how much of it still does? A flange with six lugs repeats six times about its centre; a sprocket with a tooth gone still repeats twenty times, minus the tooth. The surface is sampled evenly by area; for a count n, each of the turns k * 360 / n is tried, and coverage is the share of the surface area whose turned image lands on the surface within tolerance, facing the same way, averaged over every turn of the pattern (1 is a perfect repeat; a part with a piece broken off matches less, and the axis is found from the part that survived, so the missing piece does not pull it off). count is the LARGEST count that matches as well as the best (a part that repeats six times also repeats three times and twice), at most 100. An axis about which the part matches under ANY turn - a revolved part, a cylinder, a ball - is round: true, with count and angle null. deviation is the root mean square gap of the matched points, and matchedArea / unmatchedArea are in square millimetres. Axes covering less than 60% are not reported, and only the best axis in any one direction is; best first. Each axis is spelled for feature.pattern's circular type: direction (a unit vector, its largest component positive) and origin (the point of the axis nearest the middle of the surface) are its axis, count its count and angle its angle. To complete a broken part from what survives, pattern the body about the axis with that count and angle, operation join and targets the body itself - every copy fills in what another lost. An exact body's axis is placed exactly on a whole round face of it (a bore, a hub, a pin) when it lies along one, so the copies meet the original exactly. A mesh body (a scan) is measured off its own triangles, whichever way they are wound; an exact body off a tessellation finer than the tolerance. Nothing is changed, nothing is recorded: this is a read.

`query.section_states`

Detail

Every section state this document holds, in the order they were made, each giving its cutting plane as a point on the plane and a unit normal - millimetres in the document's own axes, the normal pointing at the material the cut removes. Nothing here says which state is showing: that belongs to whoever is looking, exactly as a camera does.

`query.selection`

The shared selection: which entities the human and any connected AI are pointing at, in order, in the document this connection is on.

Detail

The shared selection: which entities the human and any connected AI are pointing at, in order, in the document this connection is on. Session state, not document state — it is never saved and never undone.

`query.shape_search` `kernel`

Detail

Find parts shaped like one body: every other body in the open document and in the .cocad files paths names (a folder is searched whole, every .cocad under it) is ranked by how close its SHAPE is to body's, closest first. Shape is compared by the D2 shape distribution - the distances between a thousand points scattered evenly over each surface - so where a part sits and how it is turned change nothing, and SIZE is divided out: a 10 mm cube and a 30 mm cube are the same shape. It tells proportions apart well and fine detail weakly - two blocks of one size with different holes read as close. Each match carries distance (0 is the same shape, a cube and a ball are about 0.016 apart, a cube and a 10:1 bar about 0.27; never more than 3), size (the body's mean point-to-point distance, mm) and sizeRatio (its size over body's, so 3 is three times as big), with path null for a body in the open document. Each file is rebuilt from its recorded steps, as doc.open would, without opening it - once: what a rebuild found is kept in a per-user shape index, so a later search answers a file whose size and write time have not changed without rebuilding it again (filesFromIndex counts those; the answer is the same either way). A file that does not read or rebuild is listed in skipped with why (message, in English, with messageId and messageArgs naming that sentence in CoCAD's message catalogue when it has one), and the search goes on. A body with no surface to compare - a curve, or a subdiv or field body not yet converted - is listed in notCompared. compared counts the bodies ranked. More than 1000 files under paths is refused: name a narrower folder. No document is changed and nothing is recorded: this is a read.

Detail

Declare this connection able to draw images.

Detail

Declare this connection able to draw images. The core then routes view.screenshot to it (ADR 0007), and view.render to it when it says it can path-trace.

`view.render`

Path-trace the shared camera to a PNG — the photographic picture, where view.screenshot is the working one.

Detail

Path-trace the shared camera to a PNG — the photographic picture, where view.screenshot is the working one. Name a view instead to get that orientation framed on the whole model; name an explode or section state exactly as a screenshot does. Lit by a studio environment alone: a CoCAD document holds no lights. Costs seconds to minutes, not milliseconds, and the picture is a function of samples and bounces — the same numbers always give the same bytes. Served by a render provider that declares the render capability; the core never draws it itself.

`view.screenshot`

Render the shared camera to a PNG — set the view with view.set_camera, then shoot it.

Detail

Render the shared camera to a PNG — set the view with view.set_camera, then shoot it. Name a view instead to get that orientation framed on the whole model. Name an explode state to get the assembly drawn pulled apart; omitted, the model is drawn assembled. Name a section state to get the model drawn cut open at its saved plane; omitted, the model is drawn whole. The two compose: offsets first, then the plane cuts where the bodies are drawn. Served by whatever render provider is connected; the core never draws it itself. With no document open there is nothing to draw and the call is refused, rather than answered with an empty frame.

`view.set_camera`

Point the shared camera — the one view the human and every connected AI looking at this document look through.

Detail

Take the write lock on the file this document was opened from, for a person who has checked that nobody else has it.

Detail

Detail

Re-aim a saved view - replace fields of a named view, field by field. A field you send is replaced whole (the camera always arrives as all five channels); a field you leave out is kept, because a view's fields are independent facts and re-aiming the camera says nothing about the hidden set. Clearing is an explicit value, never an absence: section null makes the view uncut, explode null makes it assembled, hiddenIds [] makes it hide nothing. Sending the same call twice changes nothing the second time. Saved with the file; not undoable and not in the timeline, for the reason the view itself is not.

Drawings

Sheets, views, dimensions, annotations, balloons and GD&T symbols.

`drawing.add_annotation` `kernel`

Put an annotation on a drawing view - the marks a shop reads beside the numbers.

Detail

Put an annotation on a drawing view - the marks a shop reads beside the numbers. Eight kinds, chosen with kind: a NOTE (the default) is words, a CENTRE MARK is the cross at a round feature's centre, a CENTRELINE is the chain line between two corners, a SURFACE FINISH is the check-mark symbol with its value beside it, a WELD is the reference line and arrow with the weld's designation on the arrow side - the two symbols drawn the way the drawing's standard draws them, with the words stored exactly as sent - and a CALLOUT is the hole or thread callout, the one kind whose words are DERIVED: it names a feature.hole or feature.thread ("ft:<n>") and prints what that record says ("4X ⌀6.6 ↧12", "M6×1") on every read, so it can never state a hole the part does not have; a BALLOON is the circled item number of an assembly drawing, the second derived kind - it names one corner of a part and prints that part's row number from query.bom, so it can never disagree with the parts list; and a BEND CALLOUT is the third, the UP or DOWN, the angle and the inside radius written beside a fold line on a flat-pattern view - it names the bend's inner face ("fc:<body>.<n>") and reads the words off the blank's own bend line, so it says exactly what the bend chart says. A note's TEXT IS STORED EXACTLY AS SENT, which is the deliberate opposite of a dimension: a dimension's number is a measurement of the part and is worked out afresh on every read, where a note is a statement you made and there is nothing in the model to derive it from. A note points at as many corners of the part as you like, with a leader line running to each - or at NONE at all, which is a general note, the kind that sits in a drawing's corner saying how the whole print is to be read; a centre mark takes exactly one corner and a centreline exactly two, and neither takes any text, because both draw themselves from the corners they name. The corners are named in the MODEL - "vx:<body>.<n>" - and not in the picture, which is what makes the mark survive a recompute; a corner removed later leaves it in place, marked dangling and still carrying its own words, to be reattached rather than vanishing off the sheet. x and y are where the text sits, in the view's own millimetres. Undoable, and it is not a modelling step: it adds nothing to the timeline and changes no geometry, no mass and no export.

`drawing.add_balloons` `kernel`

Balloon a whole view at once - the auto-balloon of an assembly drawing, and P5B-6's add_balloons.

Detail

Balloon a whole view at once - the auto-balloon of an assembly drawing, and P5B-6's add_balloons. One balloon per PLACEMENT the view draws that is on the parts list and has no balloon yet, each pointing at that placement's topmost corner in the picture and standing off it up and to the right by standoff millimetres ON THE SHEET (10 by default, converted by the view's scale, because a standoff is a drafting distance and not a model one). Two placements of one part get two balloons with one number, which is how an assembly print reads. A placement already ballooned on this view is left alone, so sending this twice fills in what a person did by hand and moves nothing; a part excluded from the BOM gets none, because a balloon with nothing to say is not worth minting; loose bodies are not placements and get none. Each balloon is an ordinary annotation afterwards - drag it with drawing.set_annotation, remove it with drawing.remove_annotation - and the whole set is ONE undo step. A view with nothing to balloon answers an empty list and is not an error.

`drawing.add_dimension` `kernel`

Detail

Measure the part on a drawing view - the number a shop cuts to: between two corners (aligned, horizontal or vertical), a corner's signed coordinate from an origin corner (ordinate_x, ordinate_y - a baseline set is several of the linear kinds sharing their first corner), a circular edge's radius or diameter, or the angle at a corner between two others (angular, in degrees). THE VALUE IS NEVER STORED: the dimension records what it measures, and query.view_geometry works the number out afresh every time it is asked, so editing the model moves the print with nothing to regenerate and a drawing can never state a length the part does not have. The operands are named in the MODEL - "vx:<body>.<n>" corners, or an "eg:<body>.<n>" edge: a circular one for a radius or diameter, a STRAIGHT one named alone on a linear kind as a shorthand for its two ends, or two straight edges meeting at a corner on an angular kind as a shorthand for the three corners - and not in the picture, which is what makes the dimension survive a recompute; one removed later leaves the dimension in place and marked dangling, to be reattached, rather than vanishing off the sheet. x and y are where the text sits, in the view's own millimetres. A tolerance (±0.1, +0.1/-0.05, the two limits, or an ISO 286 class such as H7 whose deviations the table gives at the measured size) and a decimal precision may be stated with it - both are STORED, because nothing in the model knows how much a shop may miss by - and query.view_geometry answers the label they produce, in the document's own unit (query.documents' units), with the other system's number bracketed beside it when dualUnits is true. Undoable, and it is not a modelling step: it adds nothing to the timeline and changes no geometry, no mass and no export.

`drawing.add_gdt` `kernel`

Detail

Put a GD&T symbol on a drawing view - a DATUM feature symbol (the boxed letter on a leader ending in a triangle at the feature it names) or a FEATURE CONTROL FRAME (the row of boxes a shop reads as a geometric tolerance: the characteristic's symbol, the tolerance zone with ⌀ for a cylindrical one and Ⓜ or Ⓛ after it, then up to three datum references). Everything it says is STORED - the letter, the characteristic, the tolerance in millimetres, the modifiers, the references - because every one is a person's claim about the part and nothing in the model could derive it; what query.view_geometry adds is where each leader lands, whether it still resolves, the printed cells and which referenced datum letters the drawing carries no symbol for. The fourteen characteristics decide the grammar: form tolerances take no datum, orientation and runout require one, a ⌀ zone and a material-condition modifier are legal only where the standards allow them - a frame that can never be right is refused saying why. A datum references by LETTER: a frame may name datum B before a datum B exists, and prints that cell amber until it does. A datum names exactly one corner ("vx:<body>.<n>") and a frame any number or none - a frame beside a dimension is the commonest placement on a print. x and y are where the box's lower-left corner sits, in the view's own millimetres. Undoable, and it is not a modelling step: it adds nothing to the timeline and changes no geometry, no mass and no export.

`drawing.add_sheet`

Add a sheet to a drawing - one page of the print, the thing views get placed on.

Detail

Add a sheet to a drawing - one page of the print, the thing views get placed on. Say which size, either by name from query.sheet_sizes ("iso-a3", "ansi-b") or as width and height in millimetres for a size that is not listed; left out, it is A4 landscape. orientation says which of the two lengths is the width, so a size and an orientation together describe any page. A sheet stores the two lengths rather than a size name, so its page can never change because a machine's size table did. scale is the sheet's default drawing scale as one number - the drawn length over the model length, 1 for full size, 0.5 for 1:2, 2 for 2:1 - and it is what views placed here will use unless they say otherwise. The sheet is added at the end; drawing.set_sheet moves it. Undoable, and it is not a modelling step: it adds nothing to the timeline and changes no geometry.

Detail

Place a DETAIL view - an enlarged picture of one circular region of a view already on the sheet, the way a print shows a small groove or a thread relief that the main view draws too small to dimension. It looks exactly where the view it enlarges looks and follows that view when it is turned, but it is PLACED rather than aligned: x and y put it anywhere on the sheet, as a base view is put, because both drafting standards let a detail sit wherever there is room and the detail's name is the link. detail is the window - the centre and radius of the circle drawn on the view it enlarges, in THAT view's own millimetres, the same coordinates query.view_geometry answers its curves in; left out, a circle in the middle of what that view draws. The picture is what lies inside the circle, worked out with a real boolean along the line of sight, so a body behind a neighbour is still hidden by it and a detail of a SECTION view shows the cut and answers the cut's outline clipped to the circle. scale left out is TWICE the scale of the view it enlarges, live - rescale that view and the detail follows. Nothing projects off a detail, and a detail of a detail is refused: enlarge the first one's window instead. Undoable, and it is not a modelling step - a detail is a picture of the part, so no geometry, no mass and no export changes.

`drawing.export` `kernel`

CoCAD Pro only.

Detail

CoCAD Pro only. Write one drawing sheet to a file - the PDF a shop prints or the DXF another CAD or a plotter reads. The sheet is drawn exactly as the sheet canvas shows it: every view's visible edges (and its hidden edges, where the view draws them), a section's cut face outlined heavy and hatched, the section line and arrows on the view it was cut from, every dimension with its extension lines, arrowheads and number, every note, symbol, callout and balloon with its leader, every parts list with its rules and cells, and each view's caption. The PDF page is the sheet's own size in millimetres, so a 1:2 view prints at 1:2 with a rule laid on the paper - print to scale needs no dialog. The DXF puts the ink on named layers (VISIBLE, HIDDEN, CUT, HATCH, CENTER, SECTION, DIMENSIONS, ANNOTATIONS, TABLE, the sheet's edge on 0), in paper millimetres with the sheet's lower-left at the origin; dimensions are lines and text rather than DIMENSION entities, so a receiving CAD cannot re-measure the paper and print the wrong number. A dangling dimension prints ? and a dangling annotation prints its words, both in amber, so a print with a lost reference says so. Exporting changes nothing and cannot be undone; the file is written atomically and the reply says where the bytes landed and what was drawn. Set preview true to be told how big the file would be and what it would hold without writing anything. A CoCAD Free copy prints "CoCAD Free - non-commercial use" along the bottom of every sheet it exports.

`drawing.flat_pattern_view` `kernel`

Put the FLAT PATTERN of one sheet-metal part on a drawing sheet - the blank it is cut from, before anybody folds it, with a line down the middle of every bend.

Detail

Put the FLAT PATTERN of one sheet-metal part on a drawing sheet - the blank it is cut from, before anybody folds it, with a line down the middle of every bend. This is the drawing a laser or a punch works from, where drawing.place_view gives the drawing a person reads the folded part from. Say which sheet and which body; x and y put it on the page in millimetres from the sheet's lower-left corner, and left out it goes in the middle. scale is the drawn length over the model length and defaults to the SHEET's. There is no direction to choose: a blank is not a picture of the part from anywhere, so query.view_geometry answers direction null and says under flatPattern which FACE of the metal it is seen from. There is no hiddenLines or tangentEdges either - a blank is flat, and a developed sheet has no fillet to run out into anything. The part must carry a sheet-metal rule, because how much flat a bend eats depends on where the neutral axis sits inside the metal: build it with feature.base_flange or set one with doc.set_sheet_metal_rule. THE PICTURE IS NOT STORED: the blank is worked out from the part every time it is asked for, exactly as query.flat_pattern does and from the same code, so the sheet, the DXF and the read can never describe three different parts. Undoable, and it is not a modelling step: it adds nothing to the timeline and changes no geometry, no mass and no export.

`drawing.insert_bend_table` `kernel`

Detail

Put a bend chart on a flat-pattern view - the table a press brake operator works from: one row per bend in the blank, numbered in the flat pattern's own order, each with whether the metal folds UP or DOWN away from the face you are looking at, the angle in degrees, the inside bend radius and the bend allowance. THE ROWS ARE NEVER STORED: the table records only where it sits on the page and which way it reads, and query.view_geometry works every row out afresh from the view's own bend lines, so changing a flange angle changes the print with nothing to regenerate. Every bend in the picture is also numbered beside its fold line. It must go on a FLAT-PATTERN view - place one with drawing.flat_pattern_view - because nothing else has bends to list, and because a flat-pattern view already names exactly one part. x and y are where the table's header row sits in the SHEET's millimetres - left out, the upper-left corner 10 mm in, rows reading down. Undoable, and it is not a modelling step: it adds nothing to the timeline and changes no geometry.

`drawing.insert_bom`

Place a parts list - a BOM table - on a sheet.

Detail

Place a parts list - a BOM table - on a sheet. The table is a recipe, never a copy: it says where its header sits, which way its rows stack, which of query.bom's two modes it prints and which columns, and the rows are query.bom's on every read, so the table on the print can never disagree with the parts list the document answers and a balloon always names the row it points at. Left out, it prints partsOnly with item, quantity, partNumber, description and material, rows stacking upward from the header, in the sheet's lower-right corner 10 mm in from the right edge and clear of the title block's room - where a parts list sits over the title block, whether or not the sheet carries one yet. The reply's layout gives every column's printed label and paper width and the row height, which is what a client draws from. Undoable, and it is not a modelling step: it adds nothing to the timeline and changes no geometry.

`import.3mf` `kernel`

Read a 3MF package into this document as REFERENCE geometry - a mesh you can see, measure against and model over, and cannot edit.

Detail

Read a 3MF package into this document as REFERENCE geometry - a mesh you can see, measure against and model over, and cannot edit. It never becomes a body: a 3MF carries triangles rather than surfaces, and CoCAD does not pretend otherwise, so a reference mesh cannot be filleted, combined or exported as STEP. 3MF is what modern slicers and printers exchange, so this is how a print you have been sent comes in to be measured or modelled around. Send path for a file on disk, or content for base64 3MF bytes - exactly one of the two. Every object placed in the file's build arrives as one reference mesh, laid out where the file puts it, so a plate of six parts keeps its arrangement. Unlike STL and OBJ a 3MF states its own unit, and CoCAD honours it, so the size is right without being told - scale is there only to correct a file whose declared unit is wrong.

`import.dxf` `dxf`

Read a DXF drawing into this document as a new sketch.

Detail

Read a DXF drawing into this document as a new sketch. DXF is what laser cutters, waterjets, plotters and every 2D CAD package exchange, so this is how a profile somebody drew elsewhere becomes geometry you can extrude. Send path for a file on disk, or content for base64 DXF bytes - exactly one of the two - plus the plane, face or construction plane the drawing lands on. Lines, arcs, circles, ellipses, splines, points and polylines become sketch curves in the drawing's own coordinates; blocks are exploded; text, hatches and dimensions are annotation and are reported in skipped rather than imported. The drawing's declared unit is honoured, so an inch drawing arrives at the right size. The sketch and its curves arrive as one undoable step.

Read an STL file into this document as REFERENCE geometry - a mesh you can see, measure against and model over, and cannot edit.

Detail

Read an STL file into this document as REFERENCE geometry - a mesh you can see, measure against and model over, and cannot edit. It never becomes a body: an STL carries triangles rather than surfaces, and CoCAD does not pretend otherwise, so a reference mesh cannot be filleted, combined or exported as STEP. This is how a 3D scan, a downloaded part or a mesh from another tool comes in to be worked around. Send path for a file on disk, or content for base64 STL bytes - exactly one of the two; both encodings are read and neither has to be named. An STL records no unit anywhere, so send scale to say what the numbers mean - and send preview true first to see the size before you decide. A facet with two corners in one place cannot be drawn and is left out as the file is read; the reply's skippedFacets says how many, so its triangle count and the file's own facet count always add up.

Export

Writing a document out to other formats. Commands marked CoCAD Pro only need a License File.

`export.3mf` `kernel`

Write bodies to a 3MF file - the modern 3D-printing format, and what slicers and print services increasingly ask for in place of STL.

Detail

Write bodies to a 3MF file - the modern 3D-printing format, and what slicers and print services increasingly ask for in place of STL. Like STL and OBJ this writes triangles rather than exact surfaces, so tolerance is how closely they follow the model. What 3MF adds is that the file says what its numbers MEAN: the unit is written into it, so a 30 mm bracket arrives 30 mm instead of depending on what the reader assumes. Each body arrives as its own named object a consumer can select, hide and print separately, so the names you gave them and the boundaries between them both survive. Every object is checked to be a closed, correctly-oriented mesh before it is written, and a body that is not one is refused rather than written - a bad mesh's next reader is somebody's printer. Each body's colour - its own appearance, else its material's look - is written as a base material named for its material (or Colour 1, Colour 2 for paint alone), so a multi-material printer's slicer opens the plate with filaments already assigned; bodies sharing a material and colour share one entry. The reply's materials lists what was written with the colour the file holds, and noMaterialBodyIds names the bodies written with none - a body with no colour anywhere, which doc.set_appearance fixes. Face and placement colours are not written. Writes every body in the document unless bodies names a subset - hidden ones included, because hiding a body is a way of looking at the document rather than a change to it. The model is written as modelled, Z up, which is the format's own convention. The reply says how many triangles were written, and carries the same watertight and notWatertightBodyIds fields the other mesh exports do - but on this format they are always true and empty on success, because 3MF refuses a body without a closed surface where STL, OBJ and glTF write it with a warning. A mesh body - one made from a scan - is written as the triangles it holds, and tolerance does not apply to it; its triangles must close up into one consistently wound surface, or it is refused for the same reason. Exporting changes nothing and cannot be undone; the file is written atomically, and the reply says where the bytes landed. Set preview true to be told how many triangles and how many bytes it would be, without writing anything. Send slice to have a slicer installed here (PrusaSlicer, Bambu Studio or OrcaSlicer, chosen from query.open_with) slice the written file with profiles exported from it, into G-code or a sliced 3MF a printer prints; the reply's slice says whether it worked. Add send to slice to then send the sliced file to a printer query.printers lists and, if you say so, start it.

`export.build_instructions` `kernel`

CoCAD Pro only.

Detail

CoCAD Pro only. Write the model's build instructions: a multi-page A4 PDF that shows how the part is made, step by step. The first page is the finished part with its parts list (every visible body, its name and material); then one page per step of the timeline that made geometry - "Step 3 of 7: Extrude 1" - showing the model REBUILT to that step, with the faces that step made drawn in amber over a thin drawing of the rest, captioned with the feature's intent note when it has one (feature.set_intent). Undone steps are left out; sketches, construction planes, parameters and notes make no geometry and get no page; a step that made no face of its own (a move, say) is listed in skipped with the reason. Every step page shares one scale so the part grows on the paper. The pictures are hidden-line drawings, so a mesh, subdiv or field body is not drawn and is named in undrawn. Name an explode state (explode) to end the booklet with the finished part drawn pulled apart. At most 100 steps; each is one rebuild, so a long timeline takes a while. Exporting changes nothing and cannot be undone; the file is written atomically. Set preview true to rebuild and draw everything without writing, and open true to open the PDF once written.

`export.dxf` `not the fixture`

CoCAD Pro only.

Detail

CoCAD Pro only. Write one sketch, or one flat face of a solid, to a DXF file - the format laser cutters, waterjets, plotters, CNC routers and every 2D CAD package read, so this is how a profile you drew in CoCAD gets cut. Lines, arcs, circles, ellipses, splines and points are written exactly, with no tolerance and nothing sampled. The drawing is the sketch's - or the face's - OWN plane seen flat, never world space, because a 2D tool is the point of this format: a sketch on an inclined face arrives as an ordinary flat drawing. Millimetres are declared in the file, so the receiving program knows what the numbers mean. Construction geometry goes on a CONSTRUCTION layer and centrelines on CENTERLINE, with everything else on layer 0, so a cutter can leave the guides out - and import.dxf reads those same layers back. What a DXF cannot hold is not written: dimensions, constraints and the link a projected curve keeps to the edge it came from all stay in CoCAD. Exporting changes nothing and cannot be undone; the file is written atomically, and the reply says where the bytes landed. Set preview true to be told how big the drawing would be, and how big each part on a sheet came out, without writing anything. A face is exported as its own boundary and holes: exactly the drawing you would get by sketching on that face and projecting it, so the two agree curve for curve. Set kerf to your cutter's width and what comes out is the CUTTING PATH instead - every loop moved half a kerf away from the material - so the part comes off the machine the size it is in CoCAD.

`export.flat_pattern` `kernel`

CoCAD Pro only.

Detail

CoCAD Pro only. Write one sheet-metal part's flat pattern to a DXF file - the blank it is cut from, ready for a laser, a waterjet or a turret punch, with the bend lines the brake operator needs on their own layers. The outline and every hole go on layer 0, exactly where export.dxf puts a flat face, so a cutter reads a blank the way it already reads a part. Each bend line runs down the MIDDLE of the band of flat that bend eats, on layer BEND_UP when the metal folds towards the side the blank is seen from and BEND_DOWN when it folds away - which is the one fact a DXF has nowhere else to keep, so it is kept in the layer name. Only the layers actually used are declared, so a part with no bends offers no bend layer. Lines, arcs, circles, ellipses and splines are written exactly, with no tolerance and nothing sampled; millimetres are declared in the file, and the blank's minimum corner sits at the origin so width and height in the reply are the piece of stock it needs. Nothing is unfolded and nothing is stored: the layout is derived from the part every time you ask, so the file and the model can never disagree. The part must carry a sheet-metal rule, because how much flat a bend eats depends on where the neutral axis sits inside the metal - set one with feature.base_flange or doc.set_sheet_metal_rule. Use query.flat_pattern for the same layout as numbers, and query.bends for the bend table that goes beside it. Exporting changes nothing and cannot be undone; the file is written atomically and the reply says where the bytes landed and what was drawn. Set preview true to be told how big the file would be and what it would hold without writing anything.

CoCAD Pro only.

Detail

CoCAD Pro only. Write a video of the model as a looping animated GIF, which plays in any browser, chat or slide deck. kind turntable (the default) takes the camera once round the part: every frame is a screenshot through your own camera (point it with view.set_camera first; type fit frames the whole model) with only its bearing turned, drawn by the same render provider view.screenshot uses, so the video looks exactly like the window; explode and section draw every frame pulled apart or cut open. kind replay plays the timeline back - one frame per step that made a feature or a body, each the model rebuilt to that step and drawn through your camera unturned, so the part builds itself, resting on the finished part at the end; it is drawn by a cocad-render worker (CoCAD starts one when none is connected) and holds at most 100 steps. A GIF holds at most 256 colours, so smooth shading bands a little. The frames are drawn one after another - sixty take about as long as sixty screenshots - and nothing is written if any of them fails. Exporting changes nothing and cannot be undone; the file is written atomically. Set preview true to draw and encode without writing, and open true to open the GIF once written.

`export.viewer` `kernel`

Detail

Write the model as ONE web page anyone can open in a browser and turn round - drag to turn, right-drag to move, scroll or pinch to zoom - with no CoCAD, no install, no account and no internet: the page loads nothing from anywhere, so it works offline, from a USB stick or attached to an email. It is how a part is SHOWN to somebody. Each body is drawn exactly as CoCAD's own window draws it - the same triangles query.tessellate answers and the same edges query.edges answers, at the body's own display density - in its colour (its appearance, else its material's look), and listed by name so the viewer can show or hide it; a hidden body is in the page, hidden. Scans, freeform and field bodies are drawn too. Every page says Made with CoCAD. Writes every body unless bodies names a subset. The page is for looking at: its numbers are single precision and it is not an exchange format - send STEP to somebody who will machine the part. Exporting changes nothing and cannot be undone; the file is written atomically. Set preview true to be told how many triangles, edges and bytes it would be without writing anything, and open true to open the page in this computer's browser once written.

MCP command reference

Gates

Documents & timeline

doc.branch

doc.close

doc.create_folder

doc.create_timeline_group

doc.delete

doc.delete_branch

doc.delete_folder

doc.delete_timeline_group

doc.move_to_folder

doc.move_to_timeline_group

doc.new

doc.open

doc.pack

doc.recover

doc.redo

doc.rename

doc.save

doc.set_appearance

doc.set_canvas_frame

doc.set_material

doc.set_metadata

doc.set_opacity

doc.set_sheet_metal_rule

doc.set_step

doc.set_units

doc.set_visible

doc.switch_branch

doc.undo

Sketching

sketch.break

sketch.centerline

sketch.chamfer

sketch.constrain solver

sketch.construction

sketch.delete

sketch.draw

sketch.edit_spline

sketch.extend

sketch.fillet

sketch.mirror

sketch.move

sketch.new

sketch.offset

sketch.pattern

sketch.project kernel

sketch.reattach

sketch.section kernel

sketch.set_constraint solver

sketch.trim

sketch.unconstrain

sketch.unlink

Solid features

feature.align kernel

feature.base_flange kernel

feature.bend kernel

feature.boundary_fill kernel

feature.bridge_cage kernel

feature.chamfer kernel

feature.close_corner kernel

feature.combine kernel

feature.configuration

feature.contour_flange kernel

feature.corner_relief kernel

feature.crease_cage kernel

feature.decimate_mesh kernel

feature.delete_cage kernel

feature.delete_face kernel

feature.dovetail kernel

feature.dowel kernel

feature.draft kernel

feature.drain_hole kernel

feature.edge_flange kernel

feature.edit kernel

feature.emboss kernel

feature.extend kernel

feature.extrude kernel

feature.extrude_cage kernel

`doc.branch`

`doc.close`

`doc.create_folder`

`doc.create_timeline_group`

`doc.delete`

`doc.delete_branch`

`doc.delete_folder`

`doc.delete_timeline_group`

`doc.move_to_folder`

`doc.move_to_timeline_group`

`doc.new`

`doc.open`

`doc.pack`

`doc.recover`

`doc.redo`

`doc.rename`

`doc.save`

`doc.set_appearance`

`doc.set_canvas_frame`

`doc.set_material`

`doc.set_metadata`

`doc.set_opacity`

`doc.set_sheet_metal_rule`

`doc.set_step`

`doc.set_units`

`doc.set_visible`

`doc.switch_branch`

`doc.undo`

`sketch.break`

`sketch.centerline`

`sketch.chamfer`

`sketch.constrain` `solver`

`sketch.construction`

`sketch.delete`

`sketch.draw`

`sketch.edit_spline`

`sketch.extend`

`sketch.fillet`

`sketch.mirror`

`sketch.move`

`sketch.new`

`sketch.offset`

`sketch.pattern`

`sketch.project` `kernel`

`sketch.reattach`

`sketch.section` `kernel`

`sketch.set_constraint` `solver`

`sketch.trim`

`sketch.unconstrain`

`sketch.unlink`

`feature.align` `kernel`

`feature.base_flange` `kernel`

`feature.bend` `kernel`

`feature.boundary_fill` `kernel`

`feature.bridge_cage` `kernel`

`feature.chamfer` `kernel`

`feature.close_corner` `kernel`

`feature.combine` `kernel`

`feature.configuration`

`feature.contour_flange` `kernel`

`feature.corner_relief` `kernel`

`feature.crease_cage` `kernel`

`feature.decimate_mesh` `kernel`

`feature.delete_cage` `kernel`

`feature.delete_face` `kernel`

`feature.dovetail` `kernel`

`feature.dowel` `kernel`

`feature.draft` `kernel`

`feature.drain_hole` `kernel`

`feature.edge_flange` `kernel`

`feature.edit` `kernel`

`feature.emboss` `kernel`

`feature.extend` `kernel`

`feature.extrude` `kernel`

`feature.extrude_cage` `kernel`

`feature.fillet` `kernel`

`feature.finger_joint` `kernel`

`feature.fit` `kernel`

`feature.flexify` `kernel`

`feature.flip_normal` `kernel`