fluidcad 0.0.33 → 0.0.34

package/llm-docs/api/edge-filter.md

@@ -0,0 +1,57 @@
+---
+id: api/edge-filter
+title: edge() — edge filter builder
+summary: Chainable predicate builder for selecting edges by shape, orientation, position, or parent face/object. Like `face()`, chained calls AND together and `.notX()` negates.
+tags: [api, selection, filter]
+symbols: [edge]
+seeAlso: [api/face-filter, api/select]
+---
+
+# edge filter
+
+Imported from `fluidcad/filters`.
+
+```ts
+edge(): EdgeFilterBuilder
+```
+
+Returns a chainable edge filter. Chained predicates AND together.
+
+## By shape
+
+- `.line(length?)` / `.notLine(...)`
+- `.circle(diameter?)` / `.notCircle(...)`
+- `.arc(radius?)` / `.notArc(...)`
+
+## By orientation
+
+- `.parallelTo(plane)` / `.notParallelTo(...)`
+- `.verticalTo(plane)` / `.notVerticalTo(...)` — perpendicular to the plane
+
+## By position
+
+- `.onPlane(plane, offset?)` — accepts `{ offset, bothDirections, partial }`
+- `.above(plane, offset?)`
+- `.below(plane, offset?)`
+- `.intersectsWith(sceneObject)` — edges that cross another scene
+  object's edges
+
+## By parent
+
+- `.belongsToFace(...filtersOrObjects)`
+- `.from(...sceneObjects)`
+
+## Example
+
+```fluid.js
+import { extrude, fillet, rect, select, sketch } from "fluidcad/core";
+import { edge } from "fluidcad/filters";
+
+sketch("xy", () => rect(60, 60).centered());
+const e = extrude(20);
+select(edge().verticalTo("xy"));        // the 4 vertical corner edges
+fillet(2);
+```
+
+See [[api/face-filter]] for the face counterpart and [[api/select]] for
+how filters land in the implicit selection.

package/llm-docs/api/ellipse.md

@@ -0,0 +1,34 @@
+---
+id: api/ellipse
+title: ellipse(rx, ry)
+summary: Draws an ellipse using semi-radii (half-widths) along the sketch plane's X and Y axes.
+tags: [api, 2d, primitive]
+symbols: [ellipse]
+seeAlso: [api/circle, api/sketch]
+---
+
+# ellipse
+
+Imported from `fluidcad/core`.
+
+```ts
+ellipse(rx, ry)
+ellipse(center, rx, ry)
+ellipse(targetPlane, rx, ry)
+ellipse(targetPlane, center, rx, ry)
+```
+
+`rx` and `ry` are **semi-radii** — half-widths along the plane's X and Y
+axes. (Compare `circle`, which takes a diameter.) Returns
+`ExtrudableGeometry`.
+
+## Example
+
+```fluid.js
+import { ellipse, extrude, sketch } from "fluidcad/core";
+
+sketch("xy", () => ellipse(60, 30));
+extrude(8);
+```
+
+See [[api/circle]] for the symmetric case.

package/llm-docs/api/extrude.md

@@ -0,0 +1,74 @@
+---
+id: api/extrude
+title: extrude(distance, target?)
+summary: Pulls the last sketch (or an explicit one) along the sketch plane normal. Auto-fuses with any solid it touches.
+tags: [api, solid, primitive, 3d]
+symbols: [extrude]
+seeAlso: [api/sketch, api/fillet, concepts/last-selection]
+---
+
+# extrude
+
+Imported from `fluidcad/core`.
+
+```ts
+extrude(target?: SceneObject)                 // default distance (25)
+extrude(distance: number, target?)
+extrude(distance1, distance2, target?)        // two distances → asymmetric extrude
+extrude(face, target?)                        // extrude up to a face
+extrude("first-face", ...filters, target?)    // up to nearest intersecting face
+extrude("last-face", ...filters, target?)     // up to farthest intersecting face
+```
+
+Returns `Extrude` (extends `BooleanOperation`). Pulls the last sketch along
+its plane normal. With no `target`, auto-fuses with anything it touches.
+
+## Chain methods
+
+- `.symmetric()` — extrude equally in both directions; `extrude(30).symmetric()` gives total span 60.
+- `.draft(angle | [start, end])` — taper. Positive expands outward, negative tapers inward.
+- `.endOffset(d)` — shift the end face by `d` along the extrusion direction.
+- `.thin(offset)` / `.thin(o1, o2)` — thin-walled solid from the profile edges.
+- `.drill(bool)` — `true` (default) treats inner closed regions as holes.
+- `.pick(...points)` — restrict to specific regions of a multi-region sketch.
+- `.add()` / `.new()` / `.remove()` / `.scope(...)` — boolean scope controls.
+
+## Direct accessors
+
+```js
+const e = extrude(30);
+e.startFaces(); e.endFaces(); e.sideFaces();
+e.startEdges(); e.endEdges(); e.sideEdges();
+e.internalFaces(); e.internalEdges();
+e.capFaces(); e.capEdges();   // for thin extrudes from open profiles
+```
+
+Each accessor takes numeric indices and/or `FaceFilterBuilder` /
+`EdgeFilterBuilder` to scope the selection:
+
+```js
+e.sideFaces(0);                     // first side face
+e.sideFaces(face().cylinder());     // only cylindrical side faces
+e.endEdges(0, 2);                   // by index
+```
+
+## Examples
+
+```fluid.js
+import { circle, extrude, rect, select, sketch } from "fluidcad/core";
+import { face } from "fluidcad/filters";
+
+sketch("xy", () => rect(100, 60).centered());
+extrude(30);  // simple box
+
+sketch("xy", () => circle(50));
+extrude(30).symmetric().draft(5);   // bidirectional tapered cylinder
+
+extrude(30).thin(-2);               // thin-walled (2mm inward)
+
+const target = select(face().onPlane("xy", 100));
+extrude(target);                    // extrude up to that face
+```
+
+See [[api/fillet]] for follow-up edge filleting, [[api/sketch]] for sketch
+inputs, and [[concepts/last-selection]] for the implicit consumption model.

package/llm-docs/api/face-filter.md

@@ -0,0 +1,61 @@
+---
+id: api/face-filter
+title: face() — face filter builder
+summary: Chainable predicate builder for selecting faces by shape, orientation, position, topology, or source. Each chained call narrows the set (AND). Every predicate has a `.notX()` counterpart.
+tags: [api, selection, filter]
+symbols: [face]
+seeAlso: [api/edge-filter, api/select, concepts/last-selection]
+---
+
+# face filter
+
+Imported from `fluidcad/filters`.
+
+```ts
+face(): FaceFilterBuilder
+```
+
+Returns a chainable filter builder. Chain calls narrow the candidate set
+(AND). Negate any criterion with the `not...` form.
+
+## By shape
+
+- `.planar()` / `.notPlanar()`
+- `.cylinder(diameter?)` / `.notCylinder(...)`
+- `.cylinderCurve(diameter?)` — faces bounded by cylindrical curves
+- `.cone()` / `.notCone()`
+- `.torus(majorRadius?, minorRadius?)`
+- `.circle(diameter?)` — flat disc faces
+
+## By orientation & position
+
+- `.onPlane(plane, offset?)` / `.notOnPlane(...)`
+- `.parallelTo(plane)` / `.notParallelTo(...)`
+- `.above(plane, offset?)` — entirely above
+- `.below(plane, offset?)`
+- `.intersectsWith(plane)` — faces that cross the plane
+
+## By topology
+
+- `.edgeCount(n)`
+- `.hasEdge(...filtersOrObjects)`
+
+## By source
+
+- `.from(...sceneObjects)` — restrict to faces from those objects
+  (recurses into containers).
+
+## Example
+
+```fluid.js
+import { extrude, fillet, rect, select, sketch } from "fluidcad/core";
+import { face } from "fluidcad/filters";
+
+sketch("xy", () => rect(100, 80).centered());
+const e = extrude(30);
+select(face().planar().onPlane("xy", 30));   // top face only
+fillet(4);
+```
+
+See [[api/edge-filter]] for the edge counterpart and [[api/select]] for
+how filters are consumed.

package/llm-docs/api/fillet.md

@@ -0,0 +1,51 @@
+---
+id: api/fillet
+title: fillet(radius, ...edges?)
+summary: Rounds 3D edges (or 2D corners). Defaults to the last selection if no edges are passed.
+tags: [api, solid, edges, 3d]
+symbols: [fillet]
+seeAlso: [api/extrude, concepts/last-selection]
+---
+
+# fillet
+
+Imported from `fluidcad/core`.
+
+```ts
+fillet(radius?: number)                   // uses last selection, default radius 1
+fillet(radius, ...sceneObjects)
+
+// 2D variants:
+fillet(objects: Geometry[])
+fillet(objects: Geometry[], radius)
+fillet(radius, ...objects: Geometry[])
+```
+
+Returns a `SceneObject`. Operates on the **last selection** when no edges
+are passed — pair with `select()` or a direct accessor like `e.endEdges()`.
+
+## Common patterns
+
+```fluid.js
+import { extrude, fillet, rect, sketch } from "fluidcad/core";
+
+sketch("xy", () => rect(40, 40).centered());
+const e = extrude(30);
+fillet(5, e.endEdges());                  // round top edges only
+```
+
+```js
+fillet(3, e.endEdges(), e.startEdges());  // round top and bottom
+
+select(edge().verticalTo("xy"));
+fillet(2);                                // last-selection form
+```
+
+## When to reach for chamfer instead
+
+For a manufacturing edge break, `chamfer` is usually faster computationally
+and easier to spec from a drawing. Reach for `fillet` when the part is
+visually styled or the round is structurally meaningful (stress relief).
+
+See [[api/extrude]] for the geometry produced upstream, and
+[[concepts/last-selection]] for the selection-driven calling convention.

package/llm-docs/api/index.json

@@ -0,0 +1,139 @@
+{
+  "schemaVersion": 1,
+  "generatedAt": "2026-05-23T14:34:43.886Z",
+  "symbols": {
+    "arc": "api/arc",
+    "axis": "api/axis",
+    "bezier": "api/bezier",
+    "fuse": "api/booleans",
+    "subtract": "api/booleans",
+    "common": "api/booleans",
+    "chamfer": "api/chamfer",
+    "circle": "api/circle",
+    "color": "api/color",
+    "connect": "api/connect",
+    "outside": "api/constraint-qualifiers",
+    "enclosed": "api/constraint-qualifiers",
+    "enclosing": "api/constraint-qualifiers",
+    "unqualified": "api/constraint-qualifiers",
+    "copy": "api/copy",
+    "hLine": "api/cursor-lines",
+    "vLine": "api/cursor-lines",
+    "aLine": "api/cursor-lines",
+    "move": "api/cursor-move",
+    "hMove": "api/cursor-move",
+    "vMove": "api/cursor-move",
+    "rMove": "api/cursor-move",
+    "pMove": "api/cursor-move",
+    "center": "api/cursor-move",
+    "cut": "api/cut",
+    "draft": "api/draft",
+    "edge": "api/edge-filter",
+    "ellipse": "api/ellipse",
+    "extrude": "api/extrude",
+    "face": "api/face-filter",
+    "fillet": "api/fillet",
+    "line": "api/line",
+    "load": "api/load",
+    "local": "api/local",
+    "loft": "api/loft",
+    "mirror": "api/mirror",
+    "offset": "api/offset",
+    "part": "api/part",
+    "plane": "api/plane",
+    "polygon": "api/polygon",
+    "sphere": "api/primitive-solids",
+    "cylinder": "api/primitive-solids",
+    "project": "api/project-intersect",
+    "intersect": "api/project-intersect",
+    "rect": "api/rect",
+    "remove": "api/remove",
+    "repeat": "api/repeat",
+    "revolve": "api/revolve",
+    "rib": "api/rib",
+    "rotate": "api/rotate",
+    "select": "api/select",
+    "shell": "api/shell",
+    "sketch": "api/sketch",
+    "slot": "api/slot",
+    "split": "api/split-trim",
+    "trim": "api/split-trim",
+    "sweep": "api/sweep",
+    "tArc": "api/tarc",
+    "tCircle": "api/tcircle",
+    "tLine": "api/tline",
+    "translate": "api/translate",
+    "ALine": "api/types/aline",
+    "IALine": "api/types/aline",
+    "ArcAngles": "api/types/arc-angles",
+    "IArcAngles": "api/types/arc-angles",
+    "ArcPoints": "api/types/arc-points",
+    "IArcPoints": "api/types/arc-points",
+    "AxisLike": "api/types/axis-like",
+    "AxisObjectBase": "api/types/axis-like",
+    "Axis": "api/types/axis",
+    "IAxis": "api/types/axis",
+    "BooleanOperation": "api/types/boolean-operation",
+    "IBooleanOperation": "api/types/boolean-operation",
+    "CircularRepeatOptions": "api/types/circular-repeat-options",
+    "Common": "api/types/common",
+    "ICommon": "api/types/common",
+    "Cut": "api/types/cut",
+    "ICut": "api/types/cut",
+    "Draft": "api/types/draft",
+    "IDraft": "api/types/draft",
+    "ExtrudableGeometry": "api/types/extrudable-geometry",
+    "IExtrudableGeometry": "api/types/extrudable-geometry",
+    "Extrude": "api/types/extrude",
+    "IExtrude": "api/types/extrude",
+    "Geometry": "api/types/geometry",
+    "IGeometry": "api/types/geometry",
+    "HLine": "api/types/hline",
+    "IHLine": "api/types/hline",
+    "LinearRepeatOptions": "api/types/linear-repeat-options",
+    "Loft": "api/types/loft",
+    "ILoft": "api/types/loft",
+    "Mirror": "api/types/mirror",
+    "IMirror": "api/types/mirror",
+    "Offset": "api/types/offset",
+    "IOffset": "api/types/offset",
+    "PlaneLike": "api/types/plane-like",
+    "PlaneObjectBase": "api/types/plane-like",
+    "PlaneTransformOptions": "api/types/plane-transform-options",
+    "PlaneRenderableOptions": "api/types/plane-transform-options",
+    "Plane": "api/types/plane",
+    "IPlane": "api/types/plane",
+    "PointLike": "api/types/point-like",
+    "Point2DLike": "api/types/point2dlike",
+    "Polygon": "api/types/polygon",
+    "IPolygon": "api/types/polygon",
+    "Rect": "api/types/rect",
+    "IRect": "api/types/rect",
+    "Revolve": "api/types/revolve",
+    "IRevolve": "api/types/revolve",
+    "Rib": "api/types/rib",
+    "IRib": "api/types/rib",
+    "SceneObject": "api/types/scene-object",
+    "ISceneObject": "api/types/scene-object",
+    "Select": "api/types/select",
+    "ISelect": "api/types/select",
+    "Shell": "api/types/shell",
+    "IShell": "api/types/shell",
+    "Slot": "api/types/slot",
+    "ISlot": "api/types/slot",
+    "Sweep": "api/types/sweep",
+    "ISweep": "api/types/sweep",
+    "TangentArcTwoObjects": "api/types/tangent-arc-two-objects",
+    "ITangentArcTwoObjects": "api/types/tangent-arc-two-objects",
+    "Transformable": "api/types/transformable",
+    "ITransformable": "api/types/transformable",
+    "Trim": "api/types/trim",
+    "ITrim": "api/types/trim",
+    "TwoObjectsTangentLine": "api/types/two-objects-tangent-line",
+    "ITwoObjectsTangentLine": "api/types/two-objects-tangent-line",
+    "Vertex": "api/types/vertex",
+    "LazyVertex": "api/types/vertex",
+    "VLine": "api/types/vline",
+    "IVLine": "api/types/vline"
+  }
+}

package/llm-docs/api/line.md

@@ -0,0 +1,42 @@
+---
+id: api/line
+title: line(end) / line(start, end)
+summary: Straight 2D line on the active sketch plane. The single-argument form draws from the cursor to `end`.
+tags: [api, 2d, primitive]
+symbols: [line]
+seeAlso: [api/sketch, api/connect, api/arc]
+---
+
+# line
+
+Imported from `fluidcad/core`.
+
+```ts
+line(end: Point2D)
+line(start: Point2D, end: Point2D)
+line(targetPlane, end)
+```
+
+Returns `Geometry`. The one-argument form draws from the cursor to `end`;
+the cursor advances to `end` afterward.
+
+For axis-aligned segments use `hLine` / `vLine`; for angle-relative
+segments use `aLine`. Those keep your intent ("horizontal segment of
+length 30") visible and let the solver resolve targets like
+`hLine(targetCircle)`.
+
+## Example
+
+```fluid.js
+import { extrude, line, sketch } from "fluidcad/core";
+
+sketch("xy", () => {
+  line([0, 0], [40, 0]);
+  line([40, 30]);             // continues from the previous cursor
+  line([0, 30]);
+  line([0, 0]);
+});
+extrude(5);
+```
+
+See [[api/connect]] for closing a path back to its start.

package/llm-docs/api/load.md

@@ -0,0 +1,37 @@
+---
+id: api/load
+title: load(fileName)
+summary: Imports a 3D model file (STEP, STL, etc.) from the project folder. Returns a Transformable SceneObject.
+tags: [api, utility, io]
+symbols: [load]
+seeAlso: [api/translate, api/rotate]
+---
+
+# load
+
+Imported from `fluidcad/core`.
+
+```ts
+load(fileName: string)
+```
+
+Imports an external 3D file by relative filename. Returns a SceneObject
+you can transform like any other (`.translate(...)`, `.rotate(...)`,
+`.mirror(...)`).
+
+Supported formats include STEP and STL. The returned `ILoadFile` may
+expose `.noColors()`, `.include(...)`, and `.exclude(...)` to control
+sub-shape selection and STEP colour import — consult the codebase for
+exact behaviour.
+
+## Example
+
+```js
+load("bracket.step")
+  .translate(0, 0, 50)
+  .rotate("z", 90);
+```
+
+(Skipped from runtime testing — requires a workspace file.)
+
+See [[api/translate]] / [[api/rotate]] for follow-up positioning.

package/llm-docs/api/local.md

@@ -0,0 +1,38 @@
+---
+id: api/local
+title: local("x" | "y" | "z")
+summary: Returns an axis interpreted against the active sketch's plane, not the world. Use whenever you mean "this sketch's X axis" rather than world X.
+tags: [api, reference, geometry, 2d]
+symbols: [local]
+seeAlso: [api/axis, api/plane, concepts/coordinate-system]
+---
+
+# local
+
+Imported from `fluidcad/core`.
+
+```ts
+local("x" | "y" | "z")
+```
+
+`"x"` / `"y"` / `"z"` always refer to **world axes**, even inside a
+sketch on a tilted plane. `local("x")` resolves to the active sketch's
+local X instead. Reach for it whenever you'd otherwise write
+`mirror("x")` and find it mirrors across the world axis rather than the
+sketch axis.
+
+## Example
+
+```fluid.js
+import { extrude, local, mirror, plane, rect, sketch } from "fluidcad/core";
+
+const tilted = plane("xy", { rotateX: 30 });
+sketch(tilted, () => {
+  rect(40, 20).centered();
+  mirror(local("x"));        // mirror the rect across the sketch's local X
+});
+extrude(4);
+```
+
+See [[concepts/coordinate-system]] for the full world-vs-local rule, and
+[[api/axis]] for non-local axes.

package/llm-docs/api/loft.md

@@ -0,0 +1,37 @@
+---
+id: api/loft
+title: loft(...profiles)
+summary: Builds a smooth solid that blends between two or more profile sketches at different positions.
+tags: [api, 3d, solid]
+symbols: [loft]
+seeAlso: [api/sketch, api/sweep, api/extrude]
+---
+
+# loft
+
+Imported from `fluidcad/core`.
+
+```ts
+loft(...profiles: SceneObject[])
+```
+
+Returns `Loft` (extends `BooleanOperation`). Each profile is typically a
+sketch on a different plane (or a face selection). The solid interpolates
+between them in order.
+
+Chain: `.thin()`, plus the boolean scope methods. Direct accessors:
+`startFaces`, `endFaces`, `sideFaces`, `startEdges`, `endEdges`,
+`sideEdges`, `internalFaces`, `internalEdges`, `capFaces`, `capEdges`.
+
+## Example
+
+```fluid.js
+import { circle, loft, plane, rect, sketch } from "fluidcad/core";
+
+const bottom = sketch("xy", () => circle(40));
+const top = sketch(plane("xy", { offset: 100 }), () => rect(60, 60).centered());
+loft(bottom, top);
+```
+
+See [[api/sweep]] for path-driven solids and [[api/extrude]] for the
+straight-pull case.

package/llm-docs/api/mirror.md

@@ -0,0 +1,44 @@
+---
+id: api/mirror
+title: mirror(plane | axis | line, ...targets?)
+summary: Reflects sketch geometry across a line/axis or 3D solids across a plane. World-axis strings stay world-axis even inside a sketch — use `local("x")` for the sketch's local X.
+tags: [api, 2d, 3d, transform]
+symbols: [mirror]
+seeAlso: [api/translate, api/rotate, concepts/coordinate-system]
+---
+
+# mirror
+
+Imported from `fluidcad/core`.
+
+```ts
+// 2D (inside a sketch)
+mirror(line: SceneObject)
+mirror(axis: AxisLike)
+mirror(line, ...geometries)
+mirror(axis, ...geometries)
+
+// 3D
+mirror(plane: PlaneLike, ...objects)
+```
+
+Inside a sketch, reflects geometry across a line or axis. Outside a
+sketch, reflects solids across a plane. The 3D form returns `Mirror`
+(extends `BooleanOperation`) and supports `.exclude(...objects)` to
+skip specific objects.
+
+**`"x"` is the world X axis, even inside a sketch.** To mirror across
+the sketch plane's local X, use `mirror(local("x"))`. See
+[[concepts/coordinate-system]] for the full convention.
+
+## Example
+
+```fluid.js
+import { extrude, mirror, rect, sketch } from "fluidcad/core";
+
+sketch("xy", () => rect(40, 30).centered());
+const block = extrude(20).new();
+mirror("yz", block);                             // mirror across the YZ plane
+```
+
+See [[api/translate]] / [[api/rotate]] for non-reflective transforms.

package/llm-docs/api/offset.md

@@ -0,0 +1,36 @@
+---
+id: api/offset
+title: offset(distance?, removeOriginal?)
+summary: Offsets the current sketch wire outward (positive) or inward (negative). Use `.close()` to cap an open offset.
+tags: [api, 2d, modifier]
+symbols: [offset]
+seeAlso: [api/sketch, api/extrude]
+---
+
+# offset
+
+Imported from `fluidcad/core`.
+
+```ts
+offset(distance?, removeOriginal?)
+offset(targetPlane, distance, removeOriginal, ...sourceGeometries)
+```
+
+Returns `Offset`. Default distance is `1`. Chain `.close()` to cap an
+open offset into a closed wire ready for extrusion. Positive distances
+push outward (relative to wire winding); negative pushes inward.
+
+## Example
+
+```fluid.js
+import { extrude, offset, rect, sketch } from "fluidcad/core";
+
+sketch("xy", () => {
+  rect(60, 40).centered();
+  offset(5);                  // 5mm outward offset
+});
+extrude(4);
+```
+
+See [[api/sketch]] for the parent context and [[api/extrude]] for the
+typical follow-up.