forgecad 0.6.3 → 0.8.0

package/dist-skill/docs/generated/concepts.md

@@ -1,2112 +0,0 @@
-# API by Concept
-
-> **Auto-generated** from `@concept` tags in `src/forge/forge-public-api.ts`. Do not edit by hand — run `npm run gen:docs` to regenerate.
-
-Every public API function belongs to one of 16 fundamental concepts. This document groups them by concept rather than by module, making it easy to see the full set of operations for each idea.
-
-## Concepts
-
-- **[C1: Primitive Construction](#c1-primitive-construction)** — Create geometry from parameters — no input geometry required. *(19 functions)*
-- **[C2: Boolean Combination](#c2-boolean-combination)** — Combine same-dimension geometry using CSG set operations. *(3 functions)*
-- **[C3: Rigid Transform](#c3-rigid-transform)** — Reposition or reorient geometry without changing its shape. *(3 functions)*
-- **[C4: Dimensional Promotion](#c4-dimensional-promotion)** — Convert a 2D profile into a 3D solid (extrude, revolve, loft, sweep). *(12 functions)*
-- **[C5: Topology Query](#c5-topology-query)** — Select or inspect named faces and edges on a shape. *(3 functions)*
-- **[C6: Edge Feature](#c6-edge-feature)** — Modify edges of a solid — fillets, chamfers, draft, offset. *(7 functions)*
-- **[C7: Pattern Replication](#c7-pattern-replication)** — Duplicate geometry in regular arrangements (linear, circular, mirror). *(6 functions)*
-- **[C8: Constraint Solving](#c8-constraint-solving)** — Define geometry by relationships and let a solver find positions. *(7 functions)*
-- **[C9: Spatial Placement](#c9-spatial-placement)** — Position geometry relative to other geometry using semantic anchors. *(0 functions)*
-- **[C10: Assembly & Kinematics](#c10-assembly-kinematics)** — Compose parts with joints for kinematic simulation. *(4 functions)*
-- **[C11: Parameterization & UI](#c11-parameterization-ui)** — Declare user-facing controls that drive model geometry. *(6 functions)*
-- **[C12: Dimensional Demotion](#c12-dimensional-demotion)** — Extract 2D geometry from a 3D solid (section, projection). *(3 functions)*
-- **[C13: Export & Output](#c13-export-output)** — Convert geometry to external formats (STL, 3MF, SVG, DXF, G-code, PDF). *(5 functions)*
-- **[C14: Visual & Debugging](#c14-visual-debugging)** — Control viewport appearance and debugging aids. *(5 functions)*
-- **[C15: Import & Composition](#c15-import-composition)** — Bring external geometry or other ForgeCAD modules into the current script. *(1 functions)*
-- **[C16: Part Library](#c16-part-library)** — Pre-built parametric parts accessible via `lib.*`. *(0 functions)*
-
----
-
-## C1: Primitive Construction
-
-Create geometry from parameters — no input geometry required.
-
-#### `arcBridgeBetweenRects()`
-
-```ts
-arcBridgeBetweenRects(rectA: RectAreaArg, rectB: RectAreaArg, segments?: number): Shape
-```
-
-Build an arc bridge between two rectangular areas.
-
-#### `circle2d()`
-
-```ts
-circle2d(radius: number, segments?: number): Sketch
-```
-
-Create a 2D circle centered at the origin. Use segments for lower-poly approximations.
-
-#### `ellipse()`
-
-```ts
-ellipse(rx: number, ry: number, segments?: number): Sketch
-```
-
-Create a 2D ellipse centered at the origin with the given X and Y radii.
-
-#### `loadFont()`
-
-```ts
-loadFont(source: string | ArrayBuffer, cacheKey?: string): opentype$1.Font
-```
-
-Load and cache a font. - A built-in font name: `'sans-serif'` or `'inter'` (works everywhere) - A file path to a TTF/OTF/WOFF file (CLI/Node only) - An ArrayBuffer of font data (works everywhere)
-
-#### `ngon()`
-
-```ts
-ngon(sides: number, radius: number): Sketch
-```
-
-Create a regular polygon (equilateral triangle, hexagon, etc.) inscribed in a circle of the given radius.
-
-#### `path()`
-
-```ts
-path(): PathBuilder
-```
-
-Create a path builder for constructing 2D outlines.
-
-#### `polar()`
-
-```ts
-polar(length: number, angleDeg: number, from?: [ number, number ]): [ number, number ]
-```
-
-Compute a point by moving a given distance at a given angle from a start point. Angle is in degrees, measured CCW from the +X axis (standard math convention). Returns `[x, y]`. ```js polar(10, 45)            // [7.07, 7.07] — from origin polar(10, 45, [5, 5])    // [12.07, 12.07] — from (5,5) ```
-
-#### `polygon()`
-
-```ts
-polygon(points: ([ number, number ] | Point2D)[]): Sketch
-```
-
-Create a 2D polygon from an array of [x, y] points or Point2D objects. Winding is normalized to CCW.
-
-#### `polygonVertices()`
-
-```ts
-polygonVertices(sides: number, radius: number, options?: PolygonVerticesOptions): LayoutPoint[]
-```
-
-Compute the vertex positions of a regular polygon. Default orientation places the first vertex at the top (90 degrees), matching the convention used by `ngon()`. Eliminates manual Math.sqrt(3) for triangles, pentagon vertex math, etc: ```js // Before — manual equilateral triangle const v1 = [center.x - r/2, center.y + r * Math.sqrt(3)/2]; const v2 = [center.x - r/2, center.y - r * Math.sqrt(3)/2]; const v3 = [center.x + r, center.y]; // After — declarative const [v1, v2, v3] = polygonVertices(3, r); ```
-
-<details><summary><code>PolygonVerticesOptions</code></summary>
-
-```ts
-interface PolygonVerticesOptions {
-  /** Angle of the first vertex in degrees (default: 90 = top). */
-  startDeg?: number;
-  /** Center X coordinate (default: 0). */
-  centerX?: number;
-  /** Center Y coordinate (default: 0). */
-  centerY?: number;
-}
-```
-
-</details>
-
-<details><summary><code>LayoutPoint</code></summary>
-
-```ts
-interface LayoutPoint {
-  x: number;
-  y: number;
-}
-```
-
-</details>
-
-#### `rect()`
-
-```ts
-rect(width: number, height: number, center?: boolean): Sketch
-```
-
-Create a 2D rectangle. When center is true, the origin is at the rectangle center; otherwise at the bottom-left corner.
-
-#### `arcSlot()`
-
-```ts
-arcSlot(pitchRadius: number, sweepDeg: number, thickness: number): Sketch
-```
-
-Create an arc-shaped slot (banana/annular sector) centered at the origin. The slot is symmetric about the +X axis. ```js arcSlot(135, 74, 40)  // pitch R135, 74° sweep, 40mm wide ```
-
-#### `routePerimeter()`
-
-```ts
-routePerimeter(steps: PerimeterStep[]): Sketch
-```
-
-Route a smooth closed perimeter around a sequence of construction circles, connected by tangent fillet arcs. Steps must alternate: circle, fillet, circle, fillet, ... The sequence wraps — the last fillet connects back to the first circle. ```js const outline = routePerimeter([ { center: [0, 0], radius: 45 }, { fillet: 5 }, { center: polar(60, 60), radius: 18 }, { fillet: 17 }, { center: polar(60, 120), radius: 18 }, { fillet: 5 }, ]) ```
-
-#### `roundedRect()`
-
-```ts
-roundedRect(width: number, height: number, radius: number, center?: boolean): Sketch
-```
-
-Create a 2D rectangle with rounded corners. The radius is clamped to fit within the dimensions.
-
-#### `slot()`
-
-```ts
-slot(length: number, width: number): Sketch
-```
-
-Create a slot (stadium/discorectangle) — a rectangle with semicircular ends, centered at origin.
-
-#### `spline2d()`
-
-```ts
-spline2d(points: Vec2[], options?: Spline2DOptions): Sketch
-```
-
-Build a smooth Catmull-Rom spline sketch from 2D control points. A closed spline (default) returns a filled profile. An open spline requires a strokeWidth option to produce a solid sketch. Use tension (0..1, default 0.5) to control curve tightness.
-
-<details><summary><code>Spline2DOptions</code></summary>
-
-```ts
-interface Spline2DOptions {
-  /** Closed loop (default true). */
-  closed?: boolean;
-  /** Catmull-Rom tension in [0, 1]. 0 = very round, 1 = linear-ish. Default 0.5. */
-  tension?: number;
-  /** Samples per segment (minimum 3). Default 16. */
-  samplesPerSegment?: number;
-  /** For open splines, provide stroke width to return a solid Sketch. If omitted for open splines, an error is thrown. */
-  strokeWidth?: number;
-  /** Stroke join for open splines. Default 'Round'. */
-  join?: "Round" | "Square";
-}
-```
-
-</details>
-
-#### `star()`
-
-```ts
-star(points: number, outerR: number, innerR: number): Sketch
-```
-
-Create a star shape with alternating outer and inner radii.
-
-#### `stroke()`
-
-```ts
-stroke(points: [ number, number ][], width: number, join?: "Round" | "Square"): Sketch
-```
-
-Create a stroked polyline sketch from an array of 2D points.
-
-#### `text2d()`
-
-```ts
-text2d(content: string, options?: TextOptions): Sketch
-```
-
-Build a 2-D filled Sketch from a text string. The Sketch origin is at the left end of the text baseline by default (see `align` and `baseline` options to adjust placement). Text is rendered using the bundled Inter font by default, or any TTF/OTF/WOFF font you provide. // Extruded nameplate text2d('FORGE CAD', { size: 8 }).extrude(1.2) // Centered label on the XY plane text2d('V 2.0', { size: 6, align: 'center', baseline: 'center' })
-
-<details><summary><code>TextOptions</code></summary>
-
-```ts
-interface TextOptions {
-  /** Cap height of the text in model units. All other dimensions (stroke weight, spacing) scale proportionally. */
-  size?: number;
-  /** Extra space between characters in model units. Negative values tighten the tracking. */
-  letterSpacing?: number;
-  /** Horizontal alignment relative to x = 0. - `'left'`   — left edge at x = 0 (default) - `'center'` — centred on x = 0 - `'right'`  — right edge at x = 0 */
-  align?: "left" | "center" | "right";
-  /** Vertical alignment relative to y = 0. - `'baseline'` — y = 0 is the text baseline (bottom of capital letters) - `'center'`   — y = 0 is the vertical midpoint of the cap height - `'top'`      — y = 0 is the top of capital letters */
-  baseline?: "baseline" | "center" | "top";
-  /** Font to use for text rendering. - `'sans-serif'` or `'inter'` — bundled Inter font (works everywhere, including browser) - **file path** — path to a TTF, OTF, or WOFF font file (CLI/Node only) - **Font object** — a previously loaded opentype.js Font (from `loadFont()`) - **omitted** — uses the bundled Inter font (same as `'sans-serif'`) text2d('Hello World', { size: 10 })                          // default Inter text2d('Custom Font', { size: 10, font: '/path/to/font.ttf' }) */
-  font?: string | opentype$1.Font;
-  /** Bezier flattening tolerance in model units. Smaller = more polygon segments = smoother curves. */
-  flattenTolerance?: number;
-}
-```
-
-</details>
-
-#### `textWidth()`
-
-```ts
-textWidth(content: string, options?: Pick<TextOptions, "size" | "letterSpacing" | "font">): number
-```
-
-Returns the rendered width of a string in model units (same options as text2d).
-
----
-
-## C2: Boolean Combination
-
-Combine same-dimension geometry using CSG set operations.
-
-#### `difference2d()`
-
-```ts
-difference2d(...inputs: SketchOperandInput[]): Sketch
-```
-
-Subtract 2D sketches from a base sketch. The first sketch is the base; all others are subtracted.
-
-#### `intersection2d()`
-
-```ts
-intersection2d(...inputs: SketchOperandInput[]): Sketch
-```
-
-Keep only the overlapping area of the input sketches (intersection boolean).
-
-#### `union2d()`
-
-```ts
-union2d(...inputs: SketchOperandInput[]): Sketch
-```
-
-Combine 2D sketches into a single profile (additive boolean). Accepts individual sketches or arrays.
-
----
-
-## C3: Rigid Transform
-
-Reposition or reorient geometry without changing its shape.
-
-#### `degrees()`
-
-```ts
-degrees(deg: number): number
-```
-
-Convert degrees to degrees (identity — for readability in scripts)
-
-#### `radians()`
-
-```ts
-radians(rad: number): number
-```
-
-Convert radians to degrees
-
-#### `composeChain()`
-
-```ts
-composeChain(...steps: TransformInput[]): Transform
-```
-
-Compose transforms in chain order. Equivalent to Transform.identity().mul(a).mul(b).mul(c)...
-
----
-
-## C4: Dimensional Promotion
-
-Convert a 2D profile into a 3D solid (extrude, revolve, loft, sweep).
-
-#### `connectEdges()`
-
-```ts
-connectEdges(edgeA: EdgeSegment, edgeB: EdgeSegment, options?: ConnectEdgesOptions): Shape
-```
-
-<details><summary><code>EdgeSegment</code></summary>
-
-```ts
-interface EdgeSegment {
-  /** Stable index within the extraction (deterministic for a given mesh). */
-  index: number;
-  start: Vec3;
-  end: Vec3;
-  midpoint: Vec3;
-  /** Normalized direction from start → end. */
-  direction: Vec3;
-  length: number;
-  /** Dihedral angle in degrees (0 = coplanar, 180 = knife edge). */
-  dihedralAngle: number;
-  /** true = outside corner (convex), false = inside corner (concave). */
-  convex: boolean;
-  /** Normal of first adjacent face. */
-  normalA: Vec3;
-  /** Normal of second adjacent face (same as normalA for boundary edges). */
-  normalB: Vec3;
-  /** true if this is a boundary (unmatched) edge — unusual for closed solids. */
-  boundary: boolean;
-}
-```
-
-</details>
-
-<details><summary><code>TransitionCurveOptions</code></summary>
-
-```ts
-interface TransitionCurveOptions {
-  /** Weight for the start edge. Controls tangent magnitude at the start. - 1.0 (default): balanced transition - > 1.0: curve follows start edge longer before turning - < 1.0: curve turns sooner at the start */
-  weightA?: number;
-  /** Weight for the end edge. Controls tangent magnitude at the end. - 1.0 (default): balanced transition - > 1.0: curve follows end edge longer before turning - < 1.0: curve turns sooner at the end */
-  weightB?: number;
-  /** Number of sample points for the output polyline. Default 64. Higher values give smoother curves at the cost of more geometry. */
-  samples?: number;
-}
-```
-
-</details>
-
-<details><summary><code>TransitionSurfaceOptions</code> extends TransitionCurveOptions</summary>
-
-```ts
-interface TransitionSurfaceOptions extends TransitionCurveOptions {
-  /** Cross-section profile to sweep along the transition curve. If omitted, a circular profile with `radius` is used. */
-  profile?: Sketch;
-  /** Radius of circular cross-section (used when `profile` is omitted). Default: 5% of chord length. */
-  radius?: number;
-  width: number;
-  height: number;
-  /** Preferred up vector for the sweep frame. Default: auto-detected. */
-  up?: Vec3$7;
-  /** Edge length for level-set meshing. Smaller = finer. */
-  edgeLength?: number;
-  /** Extra bounds padding for level-set meshing. */
-  boundsPadding?: number;
-}
-```
-
-</details>
-
-<details><summary><code>ConnectEdgesOptions</code> extends TransitionSurfaceOptions</summary>
-
-```ts
-interface ConnectEdgesOptions extends TransitionSurfaceOptions {
-  /** Which end of edge A to connect. Default: 'start'. */
-  endA?: EdgeEnd;
-  /** Which end of edge B to connect. Default: 'start'. */
-  endB?: EdgeEnd;
-  /** Tangent mode for edge A. Default: 'along'. */
-  tangentModeA?: TangentMode;
-  /** Tangent mode for edge B. Default: 'along'. */
-  tangentModeB?: TangentMode;
-  /** Explicit tangent for edge A. */
-  tangentA?: Vec3$7;
-  /** Explicit tangent for edge B. */
-  tangentB?: Vec3$7;
-  /** Flip tangent A. */
-  flipA?: boolean;
-  /** Flip tangent B. */
-  flipB?: boolean;
-}
-```
-
-</details>
-
-#### `hermiteTransition()`
-
-```ts
-hermiteTransition(a: EdgeEndpoint, b: EdgeEndpoint): HermiteCurve3D
-```
-
-Create a Hermite transition curve between two edge endpoints. The curve starts at `a.point` tangent to `a.tangent` and ends at `b.point` tangent to `b.tangent`, with smooth G1-continuous interpolation. Weight controls: - weight = 1.0 (default): balanced transition - weight > 1.0: curve follows this edge's direction longer before turning - weight < 1.0: curve turns sooner, shorter tangent influence
-
-<details><summary><code>EdgeEndpoint</code></summary>
-
-```ts
-interface EdgeEndpoint {
-  /** Connection point on the edge */
-  point: Vec3$5;
-  /** Tangent direction along the edge at the connection point */
-  tangent: Vec3$5;
-  /** Surface normal at the connection point (optional, for future G2 support) */
-  normal?: Vec3$5;
-  /** Weight controlling how far the curve follows this edge's tangent. Default 1.0. */
-  weight?: number;
-}
-```
-
-</details>
-
-#### `hermiteTransitionG2()`
-
-```ts
-hermiteTransitionG2(a: QuinticHermiteCurveEndpoint, b: QuinticHermiteCurveEndpoint): QuinticHermiteCurve3D
-```
-
-Create a quintic Hermite transition curve between two edge endpoints (G2 continuity). The curve starts at `a.point` tangent to `a.tangent` with curvature `a.curvature`, and ends at `b.point` tangent to `b.tangent` with curvature `b.curvature`, with smooth G2-continuous interpolation matching position, tangent, and curvature.
-
-<details><summary><code>QuinticHermiteCurveEndpoint</code></summary>
-
-```ts
-interface QuinticHermiteCurveEndpoint {
-  /** Position */
-  point: Vec3$5;
-  /** Tangent direction (will be normalized internally) */
-  tangent: Vec3$5;
-  /** Second derivative / curvature vector. Default [0, 0, 0]. */
-  curvature?: Vec3$5;
-  /** Weight: scales tangent magnitude relative to chord length. Default 1.0. */
-  weight?: number;
-}
-```
-
-</details>
-
-#### `loft()`
-
-```ts
-loft(profiles: Sketch[], heights: number[], options?: LoftOptions): Shape
-```
-
-Loft between multiple sketches along Z stations. Profiles can differ in topology and vertex count: interpolation is done on signed-distance fields and meshed with level-set extraction. Heights must be strictly increasing. Compatible loft stacks can export through the OCCT exact route. Performance note: loft is significantly heavier than primitive/extrude/revolve. If the part is axis-symmetric (bottles, vases, knobs), prefer revolve().
-
-<details><summary><code>LoftOptions</code></summary>
-
-```ts
-interface LoftOptions {
-  /** Marching-grid edge length for level-set meshing. Smaller = finer. */
-  edgeLength?: number;
-  /** Optional extra bounds padding. */
-  boundsPadding?: number;
-}
-```
-
-</details>
-
-#### `loftAlongSpine()`
-
-```ts
-loftAlongSpine(profiles: Sketch[], spine: Curve3D | Vec3$4[], tValues: number[], options?: LoftAlongSpineOptions): Shape
-```
-
-Loft between multiple profiles positioned along an arbitrary 3D spine curve. Unlike loft() which only supports Z heights, loftAlongSpine() places each profile at a position along a 3D spine, oriented perpendicular to the spine tangent. This enables lofting along curved paths — e.g., a wing root-to-tip transition that follows a swept-back leading edge. The tValues array specifies where each profile sits along the spine (0 = start, 1 = end). Must have the same length as profiles and be in [0, 1]. Internally uses variableSweep infrastructure with SDF interpolation. Performance note: uses level-set meshing, heavier than simple loft().
-
-<details><summary><code>LoftAlongSpineOptions</code></summary>
-
-```ts
-interface LoftAlongSpineOptions {
-  /** Number of samples when spine is a Curve3D. Default 48. */
-  samples?: number;
-  /** Marching-grid edge length for level-set meshing. Smaller = finer. */
-  edgeLength?: number;
-  /** Optional extra bounds padding. */
-  boundsPadding?: number;
-  /** Preferred "up" vector for local profile frame. Auto fallback is used near parallel segments. */
-  up?: Vec3$4;
-}
-```
-
-</details>
-
-#### `spline3d()`
-
-```ts
-spline3d(points: Vec3$4[], options?: Spline3DOptions): Curve3D
-```
-
-Create a reusable 3D spline curve object (Catmull-Rom). The returned Curve3D provides sample(), pointAt(t), tangentAt(t), and length() for downstream use in sweep() or manual path operations.
-
-<details><summary><code>Spline3DOptions</code></summary>
-
-```ts
-interface Spline3DOptions {
-  /** Closed loop (default false). */
-  closed?: boolean;
-  /** Catmull-Rom tension in [0, 1]. 0 = very round, 1 = linear-ish. Default 0.5. */
-  tension?: number;
-}
-```
-
-</details>
-
-#### `surfacePatch()`
-
-```ts
-surfacePatch(curves: { ... }, options?: SurfacePatchOptions): Shape
-```
-
-Create a smooth surface patch from 4 boundary curves (Coons patch). The four curves form the boundary of a quadrilateral patch: - bottom: u=0..1 at v=0 (from corner00 to corner10) - top: u=0..1 at v=1 (from corner01 to corner11) - left: v=0..1 at u=0 (from corner00 to corner01) - right: v=0..1 at u=1 (from corner10 to corner11) The interior is filled using bilinear Coons patch interpolation: P(u,v) = Lc(u,v) + Ld(u,v) - B(u,v) The result is a thin solid created by offsetting the surface mesh along its normals by the specified thickness. Note: curves should meet at corners. Small gaps are tolerated.
-
-<details><summary><code>SurfacePatchOptions</code></summary>
-
-```ts
-interface SurfacePatchOptions {
-  /** Number of samples along each direction. Default 24. */
-  resolution?: number;
-  /** Thickness of the generated solid. Default 0.5. */
-  thickness?: number;
-}
-```
-
-</details>
-
-#### `sweep()`
-
-```ts
-sweep(profile: Sketch, path: Curve3D | Vec3$4[], options?: SweepOptions): Shape
-```
-
-Sweep a 2D profile along a 3D path to create a solid. Path can be a Curve3D from spline3d() or an array of [x,y,z] points (polyline). The profile is interpreted in the local frame normal plane. Compatible sweeps can export through the OCCT exact route using the canonical path representation. Performance note: sweep uses level-set meshing internally. Prefer direct primitives/extrude/revolve when they can express the same shape.
-
-<details><summary><code>SweepOptions</code></summary>
-
-```ts
-interface SweepOptions {
-  /** Number of samples when path is a Curve3D. Default 48. */
-  samples?: number;
-  /** Marching-grid edge length for level-set meshing. Smaller = finer. */
-  edgeLength?: number;
-  /** Optional extra bounds padding. */
-  boundsPadding?: number;
-  /** Preferred "up" vector for local profile frame. Auto fallback is used near parallel segments. */
-  up?: Vec3$4;
-}
-```
-
-</details>
-
-#### `variableSweep()`
-
-```ts
-variableSweep(spine: Curve3D | Vec3$4[], sections: VariableSweepSection[], options?: VariableSweepOptions): Shape
-```
-
-Sweep a variable cross-section along a 3D spine curve. Unlike sweep(), which uses a single constant profile, variableSweep() interpolates between multiple profiles at different stations along the spine. This enables organic shapes like tapering tubes, bone-like structures, and sculptural forms. Each section specifies a t parameter (0 = start, 1 = end of spine) and a 2D profile sketch. The SDF-based level-set mesher smoothly blends between profiles at intermediate positions. Performance note: like sweep(), this uses level-set meshing internally.
-
-<details><summary><code>VariableSweepSection</code></summary>
-
-```ts
-interface VariableSweepSection {
-  /** Parameter along the spine (0 = start, 1 = end). */
-  t: number;
-  /** Cross-section profile at this station. */
-  profile: Sketch;
-}
-```
-
-</details>
-
-<details><summary><code>VariableSweepOptions</code></summary>
-
-```ts
-interface VariableSweepOptions {
-  /** Number of samples when spine is a Curve3D. Default 48. */
-  samples?: number;
-  /** Marching-grid edge length for level-set meshing. Smaller = finer. */
-  edgeLength?: number;
-  /** Optional extra bounds padding. */
-  boundsPadding?: number;
-  /** Preferred "up" vector for local profile frame. Auto fallback is used near parallel segments. */
-  up?: Vec3$4;
-}
-```
-
-</details>
-
-#### `transitionCurve()`
-
-```ts
-transitionCurve(edgeA: TransitionEdge, edgeB: TransitionEdge, options?: TransitionCurveOptions): HermiteCurve3D
-```
-
-Create a smooth transition curve between two edges. Returns a `HermiteCurve3D` that starts at `edgeA.point` tangent to `edgeA.tangent` and ends at `edgeB.point` tangent to `edgeB.tangent`. The curve maintains G1 continuity (matching tangent direction) at both endpoints. Weight parameters control the shape of the transition. ```js // Connect two edges with a balanced transition const curve = transitionCurve( { point: [0, 0, 0], tangent: [1, 0, 0] }, { point: [10, 5, 0], tangent: [1, 0, 0] }, ); // Weighted: curve hugs edge A longer const weighted = transitionCurve( { point: [0, 0, 0], tangent: [1, 0, 0] }, { point: [10, 5, 0], tangent: [1, 0, 0] }, { weightA: 2.0, weightB: 0.5 }, ); ```
-
-<details><summary><code>TransitionEdge</code></summary>
-
-```ts
-interface TransitionEdge {
-  /** Connection point on the edge. Can be any point along the edge where the transition should connect. */
-  point: Vec3$7;
-  /** Tangent direction at the connection point. This is the direction the curve should initially follow when leaving this edge. For a straight edge, this is typically the edge direction pointing "outward" (away from the body of the edge, toward the other edge). */
-  tangent: Vec3$7;
-  /** Surface normal at the connection point (optional). Used as a hint for the sweep frame's up vector. */
-  normal?: Vec3$7;
-}
-```
-
-</details>
-
-#### `transitionCurveFromPoints()`
-
-```ts
-transitionCurveFromPoints(startPoint: Vec3$7, startTangent: Vec3$7, endPoint: Vec3$7, endTangent: Vec3$7, options?: TransitionCurveOptions): HermiteCurve3D
-```
-
-Convenience: create a transition curve from raw coordinate data. Useful when you have endpoints and directions as plain arrays without constructing TransitionEdge objects.
-
-#### `transitionSurface()`
-
-```ts
-transitionSurface(edgeA: TransitionEdge, edgeB: TransitionEdge, options?: TransitionSurfaceOptions): Shape
-```
-
-Create a solid transition surface between two edges by sweeping a profile along a Hermite transition curve. This produces a watertight solid that smoothly connects the two edges. Works with both Manifold and OCCT backends. ```js // Circular tube connecting two edges const tube = transitionSurface( { point: [0, 0, 0], tangent: [1, 0, 0] }, { point: [10, 5, 3], tangent: [0, 1, 0] }, { radius: 0.5 }, ); // Custom profile with weights const custom = transitionSurface( { point: [0, 0, 0], tangent: [1, 0, 0] }, { point: [10, 5, 3], tangent: [0, 1, 0] }, { profile: mySketch, weightA: 1.5, weightB: 0.8 }, ); ```
-
----
-
-## C5: Topology Query
-
-Select or inspect named faces and edges on a shape.
-
-#### `coalesceEdges()`
-
-```ts
-coalesceEdges(segments: EdgeSegment[], tolerance?: number): EdgeSegment[]
-```
-
-Coalesce collinear edge segments into longer logical edges. Multiple short mesh segments along the same line (e.g. from tessellation) are merged into a single EdgeSegment spanning the full extent. The `tolerance` controls how far endpoints can deviate from collinearity.
-
-<details><summary><code>EdgeSegment</code></summary>
-
-```ts
-interface EdgeSegment {
-  /** Stable index within the extraction (deterministic for a given mesh). */
-  index: number;
-  start: Vec3;
-  end: Vec3;
-  midpoint: Vec3;
-  /** Normalized direction from start → end. */
-  direction: Vec3;
-  length: number;
-  /** Dihedral angle in degrees (0 = coplanar, 180 = knife edge). */
-  dihedralAngle: number;
-  /** true = outside corner (convex), false = inside corner (concave). */
-  convex: boolean;
-  /** Normal of first adjacent face. */
-  normalA: Vec3;
-  /** Normal of second adjacent face (same as normalA for boundary edges). */
-  normalB: Vec3;
-  /** true if this is a boundary (unmatched) edge — unusual for closed solids. */
-  boundary: boolean;
-}
-```
-
-</details>
-
-#### `selectEdge()`
-
-```ts
-selectEdge(shape: Shape, query?: EdgeQuery): EdgeSegment
-```
-
-Select the single best-matching edge from a shape. When `near` is specified, returns the closest matching edge. Otherwise returns the first matching edge (by mesh order). Throws if no edges match.
-
-<details><summary><code>EdgeQuery</code></summary>
-
-```ts
-interface EdgeQuery {
-  /** Sort by proximity to this point (closest first). */
-  near?: Vec3;
-  /** Filter: edge direction approximately parallel to this vector. */
-  parallel?: Vec3;
-  /** Filter: edge direction approximately perpendicular to this vector. */
-  perpendicular?: Vec3;
-  /** Filter: only convex (outside corner) edges. */
-  convex?: boolean;
-  /** Filter: only concave (inside corner) edges. */
-  concave?: boolean;
-  /** Filter: minimum dihedral angle in degrees. */
-  minAngle?: number;
-  /** Filter: maximum dihedral angle in degrees. */
-  maxAngle?: number;
-  /** Filter: minimum edge length. */
-  minLength?: number;
-  /** Filter: maximum edge length. */
-  maxLength?: number;
-  /** Filter: edge midpoint must be within this bounding region. */
-  within?: BoundingRegion;
-  /** Shorthand: edge midpoint Z ≈ this value (within tolerance). */
-  atZ?: number;
-  /** Tolerance for approximate matches (default: 1.0). */
-  tolerance?: number;
-  /** Angular tolerance in degrees for parallel/perpendicular (default: 10). */
-  angleTolerance?: number;
-}
-```
-
-</details>
-
-<details><summary><code>BoundingRegion</code></summary>
-
-```ts
-interface BoundingRegion {
-  xMin?: number;
-  xMax?: number;
-  yMin?: number;
-  yMax?: number;
-  zMin?: number;
-  zMax?: number;
-}
-```
-
-</details>
-
-#### `selectEdges()`
-
-```ts
-selectEdges(shape: Shape, query?: EdgeQuery): EdgeSegment[]
-```
-
-Select all edges from a shape that match the given query. Extracts sharp edges from the mesh (dihedral angle > 1°), applies filters, and returns the matching EdgeSegment array.
-
----
-
-## C6: Edge Feature
-
-Modify edges of a solid — fillets, chamfers, draft, offset.
-
-#### `filletEdgeSegment()`
-
-```ts
-filletEdgeSegment(shape: Shape, segment: EdgeSegment, radius: number, segments?: number): Shape
-```
-
-Apply a fillet (rounded edge) to a mesh-selected edge. Works on any straight edge of any shape — not limited to tracked box edges. The edge must have been obtained from selectEdge() / selectEdges().
-
-<details><summary><code>EdgeSegment</code></summary>
-
-```ts
-interface EdgeSegment {
-  /** Stable index within the extraction (deterministic for a given mesh). */
-  index: number;
-  start: Vec3;
-  end: Vec3;
-  midpoint: Vec3;
-  /** Normalized direction from start → end. */
-  direction: Vec3;
-  length: number;
-  /** Dihedral angle in degrees (0 = coplanar, 180 = knife edge). */
-  dihedralAngle: number;
-  /** true = outside corner (convex), false = inside corner (concave). */
-  convex: boolean;
-  /** Normal of first adjacent face. */
-  normalA: Vec3;
-  /** Normal of second adjacent face (same as normalA for boundary edges). */
-  normalB: Vec3;
-  /** true if this is a boundary (unmatched) edge — unusual for closed solids. */
-  boundary: boolean;
-}
-```
-
-</details>
-
-#### `chamferEdgeSegment()`
-
-```ts
-chamferEdgeSegment(shape: Shape, segment: EdgeSegment, size: number): Shape
-```
-
-Apply a chamfer (beveled edge) to a mesh-selected edge. Works on any straight edge of any shape — not limited to tracked box edges.
-
-#### `chamfer()`
-
-```ts
-chamfer(shape: Shape, size: number, edges?: EdgeSelector): Shape
-```
-
-Apply chamfers (beveled edges) to one or more edges of a shape. Works on both straight and curved edges. Supports OCCT and Manifold backends. // Chamfer all edges chamfer(myShape, 1) // Chamfer vertical edges only chamfer(myShape, 2, { parallel: [0, 0, 1] })
-
-#### `draft()`
-
-```ts
-draft(shape: Shape, angleDeg: number, pullDirection?: [ number, number, number ], neutralPlaneOffset?: number): Shape
-```
-
-Apply a draft angle (taper) to all faces of a solid for mold extraction. Draft angle is a manufacturing feature that adds taper to the vertical faces of a solid so that it can be extracted from a mold. The neutral plane is where the draft angle is zero — faces above and below are tapered symmetrically. Requires the OCCT backend. Throws on Manifold. // Add 3° draft to a box for injection molding draft(myBox, 3) // Draft with custom pull direction and neutral plane draft(myShape, 2, [0, 0, 1], 10)
-
-#### `fillet()`
-
-```ts
-fillet(shape: Shape, radius: number, edges?: EdgeSelector, segments?: number): Shape
-```
-
-Apply fillets (rounded edges) to one or more edges of a shape. Works on both straight and curved edges. Supports OCCT and Manifold backends. When using OCCT, all edges are filleted in a single kernel operation for best quality. When using Manifold, edges are filleted sequentially. - EdgeSegment: a single edge from selectEdge() - EdgeSegment[]: multiple edges from selectEdges() - EdgeQuery: inline query (same options as selectEdges) - undefined: all sharp edges on the shape // Fillet all edges fillet(myShape, 2) // Fillet edges at the top fillet(myShape, 1.5, { atZ: 20, convex: true }) // Fillet specific edges const edges = selectEdges(myShape, { parallel: [0, 0, 1] }) fillet(myShape, 3, edges)
-
-#### `offsetSolid()`
-
-```ts
-offsetSolid(shape: Shape, thickness: number): Shape
-```
-
-Uniformly offset all surfaces of a solid inward or outward by a thickness value. Unlike shell(), which hollows a solid, offsetSolid() produces a new solid whose surfaces are all shifted by the given thickness. Positive = outward, negative = inward. Requires the OCCT backend. Throws on Manifold. // Grow a box outward by 1mm on all sides offsetSolid(myBox, 1) // Shrink a shape inward by 0.5mm offsetSolid(myShape, -0.5)
-
-#### `filletCorners()`
-
-```ts
-filletCorners(points: PointInput[], corners: FilletCornerSpec[]): Sketch
-```
-
-Create a polygon from points with specified corners rounded to arc fillets. Each corner spec identifies a vertex index and radius.
-
-<details><summary><code>FilletCornerSpec</code></summary>
-
-```ts
-interface FilletCornerSpec {
-  index: number;
-  radius: number;
-  segments?: number;
-}
-```
-
-</details>
-
----
-
-## C7: Pattern Replication
-
-Duplicate geometry in regular arrangements (linear, circular, mirror).
-
-#### `circularLayout()`
-
-```ts
-circularLayout(count: number, radius: number, options?: CircularLayoutOptions): LayoutPoint[]
-```
-
-Compute evenly-spaced positions around a circle. Eliminates the most common trig pattern in CAD scripts: ```js // Before — manual trig for (let i = 0; i < 12; i++) { const angle = i * 30 * Math.PI / 180; markers.push(marker.translate(r * Math.cos(angle), r * Math.sin(angle), 0)); } // After — declarative for (const {x, y} of circularLayout(12, r)) { markers.push(marker.translate(x, y, 0)); } ```
-
-<details><summary><code>CircularLayoutOptions</code></summary>
-
-```ts
-interface CircularLayoutOptions {
-  /** Angle of the first element in degrees (default: 0 = +X axis). */
-  startDeg?: number;
-  /** Center X coordinate (default: 0). */
-  centerX?: number;
-  /** Center Y coordinate (default: 0). */
-  centerY?: number;
-}
-```
-
-</details>
-
-<details><summary><code>LayoutPoint</code></summary>
-
-```ts
-interface LayoutPoint {
-  x: number;
-  y: number;
-}
-```
-
-</details>
-
-#### `circularPattern()`
-
-```ts
-circularPattern(shape: Shape, count: number, centerXOrOpts?: number | CircularPatternOptions, centerY?: number): Shape
-```
-
-Repeat a shape in a circular pattern around an axis and union the copies. Simple usage (Z axis, matches legacy signature): circularPattern(shape, 6) circularPattern(shape, 6, 10, 20)           // centerX=10, centerY=20 Advanced usage (arbitrary axis): circularPattern(shape, 6, { axis: [1, 0, 0], origin: [0, 0, 50] })
-
-<details><summary><code>CircularPatternOptions</code></summary>
-
-```ts
-interface CircularPatternOptions {
-  /** Center X of the rotation (default: 0). Used when axis is Z (legacy mode). */
-  centerX?: number;
-  /** Center Y of the rotation (default: 0). Used when axis is Z (legacy mode). */
-  centerY?: number;
-}
-```
-
-</details>
-
-#### `circularPattern2d()`
-
-```ts
-circularPattern2d(sketch: Sketch, count: number, centerXOrOpts?: number | { centerX?: number; centerY?: number; startDeg?: number; }, centerY?: number): Sketch
-```
-
-Repeat a sketch in a circular pattern around a center point
-
-#### `linearPattern()`
-
-```ts
-linearPattern(shape: Shape, count: number, dx: number, dy: number, dz?: number): Shape
-```
-
-Repeat a shape in a linear pattern along a direction vector and union the copies.
-
-#### `linearPattern2d()`
-
-```ts
-linearPattern2d(sketch: Sketch, count: number, dx: number, dy?: number): Sketch
-```
-
-Repeat a sketch in a linear pattern
-
-#### `mirrorCopy()`
-
-```ts
-mirrorCopy(shape: Shape, normal: [ number, number, number ]): Shape
-```
-
-Mirror a shape across a plane defined by its normal and union the mirror with the original.
-
----
-
-## C8: Constraint Solving
-
-Define geometry by relationships and let a solver find positions.
-
-#### `addPolygon()`
-
-```ts
-addPolygon(sk: ConstrainedSketchBuilder, options: PolygonOptions): ConstrainedPolygon
-```
-
-Add a general polygon concept to the builder. Creates n vertices and n sides (CCW: `sides[i]` from `vertices[i]` → `vertices[(i+1) % n]`). Applies a `ccw` constraint to enforce winding. The user is responsible for all dimensional constraints. ```ts const sk = constrainedSketch(); const tri = addPolygon(sk, { points: [[0,0],[100,0],[50,80]] }); sk.fix(tri.vertex(0), 0, 0); sk.length(tri.side(0), 100); ```
-
-<details><summary><code>PolygonOptions</code></summary>
-
-```ts
-interface PolygonOptions {
-  /** Whether to register a closed loop for sketch generation. Default: true. */
-  addLoop?: boolean;
-  /** Prevent 180° rotation (ensures first edge maintains its initial direction). Default: false. */
-  blockRotation?: boolean;
-}
-```
-
-</details>
-
-<details><summary><code>ConstrainedPolygon</code></summary>
-
-```ts
-interface ConstrainedPolygon {
-  /** CCW-ordered PointIds. */
-  vertices: PointId[];
-  /** CCW-ordered LineIds. `sides[i]` runs from `vertices[i]` → `vertices[(i+1) % n]`. */
-  sides: LineId[];
-  /** ShapeId for `shapeWidth`, `shapeHeight`, `shapeArea`, `shapeCentroidX/Y`. */
-  shape: ShapeId;
-}
-```
-
-</details>
-
-#### `addRect()`
-
-```ts
-addRect(sk: ConstrainedSketchBuilder, options?: RectOptions): ConstrainedRect
-```
-
-Add an axis-aligned rectangle concept to the builder. Creates 4 vertices (CCW: bl→br→tr→tl), 4 sides, applies 4 structural constraints (`horizontal`/`vertical` on each side), enforces CCW winding, registers a loop and a shape, and returns a `ConstrainedRect` handle. ```ts const sk = constrainedSketch(); const rect = addRect(sk, { x: 0, y: 0, width: 100, height: 50 }); sk.fix(rect.bottomLeft, 0, 0); sk.length(rect.bottom, 120); ```
-
-<details><summary><code>RectOptions</code></summary>
-
-```ts
-interface RectOptions {
-  /** Bottom-left x coordinate. Default: 0. */
-  x?: number;
-  /** Bottom-left y coordinate. Default: 0. */
-  y?: number;
-  /** Width (along x). Default: 10. */
-  width?: number;
-  /** Height (along y). Default: 10. */
-  height?: number;
-  /** Prevent 180° rotation (ensures bottom edge points rightward). Default: false. */
-  blockRotation?: boolean;
-}
-```
-
-</details>
-
-<details><summary><code>ConstrainedRect</code></summary>
-
-```ts
-interface ConstrainedRect {
-  bottomLeft: PointId;
-  bottomRight: PointId;
-  topRight: PointId;
-  topLeft: PointId;
-  /** bottom-left → bottom-right */
-  bottom: LineId;
-  /** bottom-right → top-right */
-  right: LineId;
-  /** top-right → top-left */
-  top: LineId;
-  /** top-left → bottom-left */
-  left: LineId;
-  /** Center point constrained to the geometric center via `midpoint` on the diagonal. Can be used in further constraints: `sk.fix(rect.center, 0, 0)`, `sk.coincident(rect.center, other)`. */
-  center: PointId;
-  /** ShapeId for `shapeWidth`, `shapeHeight`, `shapeArea`, `shapeCentroidX/Y`. */
-  shape: ShapeId;
-}
-```
-
-</details>
-
-#### `addRegularPolygon()`
-
-```ts
-addRegularPolygon(sk: ConstrainedSketchBuilder, options: RegularPolygonOptions): ConstrainedRegularPolygon
-```
-
-Add a regular n-gon concept to the builder. Vertices are placed at `(cx + r·cos(startAngle + i·2π/n), cy + r·sin(...))`. Equal-side constraints enforce regularity. The center point is constrained to the centroid via midpoint constraints on the first diagonal. ```ts const sk = constrainedSketch(); const hex = addRegularPolygon(sk, { sides: 6, radius: 25, cx: 0, cy: 0 }); sk.fix(hex.center, 0, 0); sk.length(hex.side(0), 30);  // changes all sides (equal constraint) ```
-
-<details><summary><code>RegularPolygonOptions</code></summary>
-
-```ts
-interface RegularPolygonOptions {
-  /** Number of sides (minimum 3). */
-  sides: number;
-  /** Circumradius — distance from center to vertex. Default: 10. */
-  radius?: number;
-  /** Center x coordinate. Default: 0. */
-  cx?: number;
-  /** Center y coordinate. Default: 0. */
-  cy?: number;
-  /** Angle (in degrees) of vertex[0] measured from the +X axis (CCW positive). Default: 0 (rightmost vertex). */
-  startAngle?: number;
-  /** Prevent 180° rotation (ensures first edge maintains its initial direction). Default: false. */
-  blockRotation?: boolean;
-}
-```
-
-</details>
-
-
-<details><summary><code>ConstrainedRegularPolygon</code> extends ConstrainedPolygon</summary>
-
-```ts
-interface ConstrainedRegularPolygon extends ConstrainedPolygon {
-  /** Center point. Use `sk.fix(poly.center, x, y)` to pin location, or `sk.coincident(poly.center, other)` to align with other geometry. */
-  center: PointId;
-}
-```
-
-</details>
-
-#### `circle()`
-
-```ts
-circle(cx: number, cy: number, radius: number): Circle2D
-```
-
-Create an analytic 2D circle for measurement, construction, and extrusion. Provides diameter, circumference, area, and toSketch().
-
-#### `constrainedSketch()`
-
-```ts
-constrainedSketch(options?: ConstrainedSketchOptions): ConstrainedSketchBuilder
-```
-
-Build a parametric 2D sketch with geometric constraints solved by the built-in constraint solver.
-
-<details><summary><code>ConstrainedSketchOptions</code></summary>
-
-```ts
-interface ConstrainedSketchOptions {
-  /** When true, adding a constraint that cannot be satisfied throws instead of silently discarding it. */
-  strict?: boolean;
-}
-```
-
-</details>
-
-#### `line()`
-
-```ts
-line(x1: number, y1: number, x2: number, y2: number): Line2D
-```
-
-Create an analytic 2D line segment between two points. Provides length, midpoint, angle, intersection, and parallel helpers.
-
-#### `point()`
-
-```ts
-point(x: number, y: number): Point2D
-```
-
-Create an analytic 2D point for measurement and construction geometry.
-
----
-
-## C9: Spatial Placement
-
-Position geometry relative to other geometry using semantic anchors.
-
-*No free functions — see class methods (Shape, Sketch, ConstrainedSketchBuilder).*
-
----
-
-## C10: Assembly & Kinematics
-
-Compose parts with joints for kinematic simulation.
-
-#### `assembly()`
-
-```ts
-assembly(name?: string): Assembly
-```
-
-Create an assembly container with named parts and joints for kinematic mechanisms. Build with addPart(), addJoint(), addJointCoupling(), addGearCoupling(), then solve() to get positioned parts. Supports revolute, prismatic, and fixed joint types.
-
-#### `bomToCsv()`
-
-```ts
-bomToCsv(rows: BomRow[]): string
-```
-
-Convert BOM rows from a solved assembly into a CSV string.
-
-<details><summary><code>BomRow</code></summary>
-
-```ts
-interface BomRow {
-  part: string;
-  qty: number;
-  material?: string;
-  process?: string;
-  tolerance?: string;
-  notes?: string;
-  metadata?: PartMetadata;
-}
-```
-
-</details>
-
-<details><summary><code>PartMetadata</code></summary>
-
-```ts
-interface PartMetadata {
-  material?: string;
-  process?: string;
-  tolerance?: string;
-  qty?: number;
-  notes?: string;
-  densityKgM3?: number;
-  massKg?: number;
-}
-```
-
-</details>
-
-#### `joint()`
-
-```ts
-joint(name: string, shape: Shape, pivot: [ number, number, number ], opts?: RevoluteJointOpts): Shape
-```
-
-Create a revolute (hinge) joint. Auto-creates a param slider and rotates the shape.
-
-<details><summary><code>RevoluteJointOpts</code></summary>
-
-```ts
-interface RevoluteJointOpts {
-  min?: number;
-  max?: number;
-  default?: number;
-  unit?: string;
-  reverse?: boolean;
-}
-```
-
-</details>
-
-#### `jointsView()`
-
-```ts
-jointsView(options?: JointsViewOptions): void
-```
-
-Configure runtime joint controls that animate object transforms in the viewport without re-running the script.
-
-<details><summary><code>JointsViewOptions</code></summary>
-
-```ts
-interface JointsViewOptions {
-  enabled?: boolean;
-  joints?: JointViewInput[];
-  couplings?: JointViewCouplingInput[];
-  animations?: JointViewAnimationInput[];
-  defaultAnimation?: string;
-}
-```
-
-</details>
-
-<details><summary><code>JointViewInput</code></summary>
-
-```ts
-interface JointViewInput {
-  name: string;
-  child: string;
-  parent?: string;
-  type?: JointViewType;
-  axis?: JointViewAxis;
-  min?: number;
-  max?: number;
-  default?: number;
-  unit?: string;
-  hidden?: boolean;
-}
-```
-
-</details>
-
-<details><summary><code>JointViewCouplingInput</code></summary>
-
-```ts
-interface JointViewCouplingInput {
-  joint: string;
-  terms: JointViewCouplingTermInput[];
-  offset?: number;
-}
-```
-
-</details>
-
-<details><summary><code>JointViewCouplingTermInput</code></summary>
-
-```ts
-interface JointViewCouplingTermInput {
-  joint: string;
-  ratio?: number;
-}
-```
-
-</details>
-
-<details><summary><code>JointViewAnimationInput</code></summary>
-
-```ts
-interface JointViewAnimationInput {
-  name: string;
-  duration?: number;
-  loop?: boolean;
-  continuous?: boolean;
-  keyframes: JointViewAnimationKeyframeInput[];
-}
-```
-
-</details>
-
-<details><summary><code>JointViewAnimationKeyframeInput</code></summary>
-
-```ts
-interface JointViewAnimationKeyframeInput {
-  /** Timeline position [0, 1]. If omitted from ALL keyframes, positions are auto-computed from tick weights. */
-  at?: number;
-  /** Relative weight of the segment from this keyframe to the next (default 1). Only used in tick-based mode (when `at` is omitted). Last keyframe's ticks value is ignored. */
-  ticks?: number;
-  values: Record<string, number>;
-}
-```
-
-</details>
-
----
-
-## C11: Parameterization & UI
-
-Declare user-facing controls that drive model geometry.
-
-#### `boolParam()`
-
-```ts
-boolParam(name: string, defaultValue: boolean): boolean
-```
-
-Declare a boolean parameter. Returns the current boolean value. Renders as a checkbox in the UI.
-
-#### `choiceParam()`
-
-```ts
-choiceParam(name: string, defaultValue: string, choices: string[]): string
-```
-
-Declare a choice parameter. Returns the selected string label. Renders as a dropdown in the UI. `defaultValue` must match one of the supplied `choices`. Overrides may be passed either as the choice label or as a numeric index, but labels are preferred because they are clearer in CLI/import usage.
-
-#### `listParam()`
-
-```ts
-listParam<T extends Record<string, number | boolean | string>>(name: string, defaultItems: T[], opts: { ... }): T[]
-```
-
-Declare a list parameter — an array of struct items with per-field controls. Returns the current list of items (with overrides applied). Each item is an object whose fields match the keys in defaultItems. Boolean fields (marked with `boolean: true` in field defs) return as booleans. Choice fields (marked with `choices: [...]` in field defs) return as strings. All other fields return as numbers.
-
-<details><summary><code>ListParamFieldDef</code></summary>
-
-```ts
-interface ListParamFieldDef {
-  min?: number;
-  max?: number;
-  step?: number;
-  unit?: string;
-  integer?: boolean;
-  boolean?: boolean;
-  choices?: string[];
-}
-```
-
-</details>
-
-#### `param()`
-
-```ts
-param(name: string, defaultValue: number, opts?: { min?: number; max?: number; step?: number; unit?: string; integer?: boolean; reverse?: boolean; }): number
-```
-
-Declare a parameter. Returns the current value (default or overridden). Each call registers the param for UI generation.
-
-#### `dim()`
-
-```ts
-dim(from: PointArg$1, to: PointArg$1, opts?: DimOpts): void
-```
-
-Add a dimension annotation between two points.
-
-<details><summary><code>DimOpts</code></summary>
-
-```ts
-interface DimOpts {
-  offset?: number;
-  label?: string;
-  color?: string;
-  component?: string | string[];
-  currentComponent?: boolean;
-}
-```
-
-</details>
-
-#### `dimLine()`
-
-```ts
-dimLine(l: Line2D, opts?: DimOpts): void
-```
-
-Add a dimension annotation along a Line2D.
-
----
-
-## C12: Dimensional Demotion
-
-Extract 2D geometry from a 3D solid (section, projection).
-
-#### `faceProfile()`
-
-```ts
-faceProfile(shape: Shape, face: FaceSelector): Sketch
-```
-
-#### `intersectWithPlane()`
-
-```ts
-intersectWithPlane(shape: Shape, plane: PlaneSpec): Sketch
-```
-
-Cross-section: slice a 3D shape with a plane and return the intersection as a 2D Sketch.
-
-#### `projectToPlane()`
-
-```ts
-projectToPlane(shape: Shape, plane: PlaneSpec): Sketch
-```
-
-Orthographically project a 3D shape onto a plane and return the silhouette as a 2D Sketch.
-
----
-
-## C13: Export & Output
-
-Convert geometry to external formats (STL, 3MF, SVG, DXF, G-code, PDF).
-
-#### `bom()`
-
-```ts
-bom(quantity: number, description: string, opts?: BomOpts): void
-```
-
-Add a bill-of-materials entry.
-
-<details><summary><code>BomOpts</code></summary>
-
-```ts
-interface BomOpts {
-  /** Quantity unit label, e.g. "mm", "pieces", "kg". Default: "pieces" */
-  unit?: string;
-  /** Optional explicit grouping key used during report aggregation. */
-  key?: string;
-}
-```
-
-</details>
-
-#### `robotExport()`
-
-```ts
-robotExport(options: RobotExportOptions): CollectedRobotExport
-```
-
-Declare that the current script should export an assembly as a robot package for the SDF CLI. Configures inertial properties, joint limits, and optional plugins (e.g. diff-drive for Gazebo).
-
-<details><summary><code>RobotExportOptions</code></summary>
-
-```ts
-interface RobotExportOptions {
-  assembly: Assembly;
-  modelName?: string;
-  state?: JointState;
-  static?: boolean;
-  selfCollide?: boolean;
-  allowAutoDisable?: boolean;
-  links?: Record<string, RobotLinkExportOptions>;
-  joints?: Record<string, RobotJointExportOptions>;
-  diffDrive?: RobotDiffDrivePluginOptions;
-  jointStatePublisher?: RobotJointStatePublisherOptions;
-  world?: RobotWorldOptions;
-}
-```
-
-</details>
-
-<details><summary><code>RobotLinkExportOptions</code></summary>
-
-```ts
-interface RobotLinkExportOptions {
-  massKg?: number;
-  densityKgM3?: number;
-  collision?: "visual" | "convex" | "box" | "none";
-}
-```
-
-</details>
-
-<details><summary><code>RobotJointExportOptions</code></summary>
-
-```ts
-interface RobotJointExportOptions {
-  effort?: number;
-  velocity?: number;
-  damping?: number;
-  friction?: number;
-}
-```
-
-</details>
-
-<details><summary><code>RobotDiffDrivePluginOptions</code></summary>
-
-```ts
-interface RobotDiffDrivePluginOptions {
-  leftJoints: string[];
-  rightJoints: string[];
-  wheelSeparationMm: number;
-  wheelRadiusMm: number;
-  topic?: string;
-  odomTopic?: string;
-  tfTopic?: string;
-  frameId?: string;
-  odomFrameId?: string;
-  maxLinearVelocity?: number;
-  maxAngularVelocity?: number;
-  linearAcceleration?: number;
-  angularAcceleration?: number;
-}
-```
-
-</details>
-
-<details><summary><code>RobotJointStatePublisherOptions</code></summary>
-
-```ts
-interface RobotJointStatePublisherOptions {
-  enabled?: boolean;
-  joints?: string[];
-  topic?: string;
-  updateRate?: number;
-}
-```
-
-</details>
-
-<details><summary><code>RobotWorldOptions</code></summary>
-
-```ts
-interface RobotWorldOptions {
-  name?: string;
-  generateDemoWorld?: boolean;
-  spawnPose?: RobotPose6;
-  keyboardTeleop?: RobotWorldKeyboardTeleopOptions;
-}
-```
-
-</details>
-
-<details><summary><code>RobotWorldKeyboardTeleopOptions</code></summary>
-
-```ts
-interface RobotWorldKeyboardTeleopOptions {
-  enabled?: boolean;
-  linearStep?: number;
-  angularStep?: number;
-}
-```
-
-</details>
-
-<details><summary><code>CollectedRobotExport</code></summary>
-
-```ts
-interface CollectedRobotExport {
-  modelName: string;
-  assembly: AssemblyDefinition;
-  state: JointState;
-  static: boolean;
-  selfCollide: boolean;
-  allowAutoDisable: boolean;
-  links: Record<string, RobotLinkExportOptions>;
-  joints: Record<string, RobotJointExportOptions>;
-  diffDrive?: RobotDiffDrivePluginOptions;
-  jointStatePublisher?: RobotJointStatePublisherOptions;
-  world: RobotWorldOptions | null;
-}
-```
-
-</details>
-
-<details><summary><code>AssemblyDefinition</code></summary>
-
-```ts
-interface AssemblyDefinition {
-  name: string;
-  parts: AssemblyPartDef[];
-  joints: AssemblyJointDef[];
-  jointCouplings: AssemblyJointCouplingDef[];
-}
-```
-
-</details>
-
-<details><summary><code>AssemblyPartDef</code></summary>
-
-```ts
-interface AssemblyPartDef {
-  name: string;
-  part: AssemblyPart;
-  base: Transform;
-  metadata?: PartMetadata;
-}
-```
-
-</details>
-
-<details><summary><code>PartMetadata</code></summary>
-
-```ts
-interface PartMetadata {
-  material?: string;
-  process?: string;
-  tolerance?: string;
-  qty?: number;
-  notes?: string;
-  densityKgM3?: number;
-  massKg?: number;
-}
-```
-
-</details>
-
-<details><summary><code>AssemblyJointDef</code></summary>
-
-```ts
-interface AssemblyJointDef {
-  name: string;
-  type: JointType;
-  parent: string;
-  child: string;
-  frame: Transform;
-  axis: Vec3;
-  min?: number;
-  max?: number;
-  defaultValue: number;
-  unit?: string;
-  effort?: number;
-  velocity?: number;
-  damping?: number;
-  friction?: number;
-}
-```
-
-</details>
-
-<details><summary><code>AssemblyJointCouplingDef</code></summary>
-
-```ts
-interface AssemblyJointCouplingDef {
-  joint: string;
-  terms: JointCouplingTermRecord[];
-  offset: number;
-}
-```
-
-</details>
-
-<details><summary><code>JointCouplingTermRecord</code></summary>
-
-```ts
-interface JointCouplingTermRecord {
-  joint: string;
-  ratio: number;
-}
-```
-
-</details>
-
-#### `sheetMetal()`
-
-```ts
-sheetMetal(options: SheetMetalOptions): SheetMetalPart
-```
-
-Create a sheet-metal part with flanges, bend allowances, and flat pattern unfolding. Define the base panel, thickness, bend radius, and K-factor, then chain .flange() and .cutout() calls. Materialize with .folded() or .flatPattern().
-
-<details><summary><code>SheetMetalOptions</code></summary>
-
-```ts
-interface SheetMetalOptions {
-  width: number;
-  height: number;
-  thickness: number;
-  bendRadius: number;
-  kFactor: number;
-  kind?: "rect";
-  size: number;
-}
-```
-
-</details>
-
-#### `sketchToDxf()`
-
-```ts
-sketchToDxf(sketch: Sketch, options?: SketchDxfOptions): string
-```
-
-Export a 2D sketch as a DXF string (R12/AC1009 — maximally compatible). For regular sketches, each polygon loop becomes a closed LWPOLYLINE. For constraint sketches, exports LINE, CIRCLE, and ARC entities from the constraint edge geometry.
-
-<details><summary><code>SketchDxfOptions</code></summary>
-
-```ts
-interface SketchDxfOptions {
-  /** DXF layer name. Default: "0" */
-  layer?: string;
-  /** DXF color index (1–255, AutoCAD ACI). Default: 7 (white/black) */
-  colorIndex?: number;
-}
-```
-
-</details>
-
-#### `sketchToSvg()`
-
-```ts
-sketchToSvg(sketch: Sketch, options?: SketchSvgOptions): string
-```
-
-Export a 2D sketch as an SVG string. For regular sketches, exports filled polygon regions. For constraint sketches, exports line/arc/circle edge geometry. The SVG uses the sketch's native coordinate system (Y-up) with a transform that flips Y so the output renders correctly in SVG's Y-down space. Coordinates are in sketch units (typically mm).
-
-<details><summary><code>SketchSvgOptions</code></summary>
-
-```ts
-interface SketchSvgOptions {
-  /** Stroke color. Default: "black" */
-  stroke?: string;
-  /** Stroke width in sketch units. Default: 0.5 */
-  strokeWidth?: number;
-  /** Fill color. Default: "none" */
-  fill?: string;
-  /** Padding around the sketch bounding box in sketch units. Default: 2 */
-  padding?: number;
-  /** If set, scale so 1 sketch-unit = this many px. Otherwise auto-fit. */
-  pixelsPerUnit?: number;
-}
-```
-
-</details>
-
----
-
-## C14: Visual & Debugging
-
-Control viewport appearance and debugging aids.
-
-#### `explodeView()`
-
-```ts
-explodeView(options?: ExplodeViewOptions): void
-```
-
-Configure viewport exploded-view behavior for the current script execution. Multiple calls merge; later values override earlier ones.
-
-<details><summary><code>ExplodeViewOptions</code></summary>
-
-```ts
-interface ExplodeViewOptions {
-  /** Set false to disable viewport explode offsets for this script output. */
-  enabled?: boolean;
-  /** Scales the UI explode amount. Default: 1 */
-  amountScale?: number;
-  /** Per-depth stage multipliers (depth 1 = first level). If depth exceeds this array, the last value is reused. Default when omitted: reciprocal depth (1, 1/2, 1/3, ...) */
-  stages?: number[];
-  /** Global direction mode fallback. Default: 'radial' */
-  mode?: ExplodeViewDirection;
-  /** Global axis lock fallback. */
-  axisLock?: ExplodeAxis;
-  /** Per-object overrides by final object name. */
-  byName?: Record<string, ExplodeViewDirective>;
-  /** Per-tree-path overrides using slash-separated object tree segments. */
-  byPath?: Record<string, ExplodeViewDirective>;
-}
-```
-
-</details>
-
-<details><summary><code>ExplodeDirective</code></summary>
-
-```ts
-interface ExplodeDirective {
-  /** Multiplier applied to `amount` for this node */
-  stage?: number;
-  /** Direction mode for this node */
-  direction?: ExplodeDirection;
-  /** Optional axis lock after direction is resolved */
-  axisLock?: ExplodeAxis;
-}
-```
-
-</details>
-
-<details><summary><code>ExplodeViewDirective</code> extends ExplodeDirective</summary>
-
-```ts
-interface ExplodeViewDirective extends ExplodeDirective {
-}
-```
-
-</details>
-
-#### `cutPlane()`
-
-```ts
-cutPlane(name: string, normal: [ number, number, number ], options?: CutPlaneOptions): void
-```
-
-<details><summary><code>CutPlaneOptions</code></summary>
-
-```ts
-interface CutPlaneOptions {
-  /** Optional offset along the plane normal (primarily for object-form overload). */
-  offset?: number;
-  /** Object names to keep uncut for this plane. */
-  exclude?: CutPlaneExcludeInput;
-}
-```
-
-</details>
-
-#### `scene()`
-
-```ts
-scene(options: SceneOptions): void
-```
-
-Configure the scene environment for the current script execution. Controls camera, lighting, background, fog, and post-processing. Multiple calls merge; later values override earlier ones. ```js scene({ background: '#0a0a0a', camera: { position: [200, 100, 150], target: [0, 0, 30], fov: 60 }, lights: [ { type: 'ambient', color: '#1a1a2e', intensity: 0.2 }, { type: 'point', position: [0, 0, 100], color: '#ff6b35', intensity: 2 }, ], fog: { color: '#0a0a0a', near: 100, far: 500 }, postProcessing: { bloom: { intensity: 1.5, threshold: 0.8, radius: 0.4 }, }, }); ```
-
-<details><summary><code>SceneOptions</code></summary>
-
-```ts
-interface SceneOptions {
-  background?: string | SceneBackgroundGradient;
-  camera?: SceneCameraConfig;
-  lights?: SceneLightConfig[];
-  environment?: SceneEnvironmentConfig;
-  fog?: SceneFogConfig;
-  postProcessing?: ScenePostProcessingConfig;
-  ground?: SceneGroundConfig;
-  /** Default capture parameters for `forgecad capture` — CLI flags override these. */
-  capture?: SceneCaptureConfig;
-}
-```
-
-</details>
-
-<details><summary><code>SceneBackgroundGradient</code></summary>
-
-```ts
-interface SceneBackgroundGradient {
-  top: string;
-  bottom: string;
-}
-```
-
-</details>
-
-<details><summary><code>SceneCameraConfig</code></summary>
-
-```ts
-interface SceneCameraConfig {
-  fov?: number;
-  type?: "perspective" | "orthographic";
-}
-```
-
-</details>
-
-<details><summary><code>SceneLightConfig</code></summary>
-
-```ts
-interface SceneLightConfig {
-  type: SceneLightType;
-  color?: string;
-  intensity?: number;
-  /** Ground color for hemisphere lights */
-  groundColor?: string;
-  /** Sky color alias for hemisphere lights (same as color) */
-  skyColor?: string;
-  /** Spot light cone angle in radians */
-  angle?: number;
-  /** Spot light penumbra (0–1) */
-  penumbra?: number;
-  /** Point/spot light decay */
-  decay?: number;
-  /** Point/spot light distance (0 = infinite) */
-  distance?: number;
-  /** Whether this light casts shadows */
-  castShadow?: boolean;
-}
-```
-
-</details>
-
-<details><summary><code>SceneEnvironmentConfig</code></summary>
-
-```ts
-interface SceneEnvironmentConfig {
-  /** Built-in preset name or 'none' to disable */
-  preset?: "studio" | "sunset" | "dawn" | "warehouse" | "forest" | "apartment" | "lobby" | "city" | "park" | "night" | "none";
-  /** Environment map intensity */
-  intensity?: number;
-  /** Use environment map as scene background */
-  background?: boolean;
-}
-```
-
-</details>
-
-<details><summary><code>SceneFogConfig</code></summary>
-
-```ts
-interface SceneFogConfig {
-  color?: string;
-  /** Linear fog near distance */
-  near?: number;
-  /** Linear fog far distance */
-  far?: number;
-  /** Exponential fog density (if set, uses FogExp2 instead of linear Fog) */
-  density?: number;
-}
-```
-
-</details>
-
-<details><summary><code>ScenePostProcessingConfig</code></summary>
-
-```ts
-interface ScenePostProcessingConfig {
-  bloom?: SceneBloomConfig;
-  vignette?: SceneVignetteConfig;
-  grain?: SceneGrainConfig;
-  toneMappingExposure?: number;
-}
-```
-
-</details>
-
-<details><summary><code>SceneBloomConfig</code></summary>
-
-```ts
-interface SceneBloomConfig {
-  intensity?: number;
-  threshold?: number;
-  radius?: number;
-}
-```
-
-</details>
-
-<details><summary><code>SceneVignetteConfig</code></summary>
-
-```ts
-interface SceneVignetteConfig {
-  darkness?: number;
-  offset?: number;
-}
-```
-
-</details>
-
-<details><summary><code>SceneGrainConfig</code></summary>
-
-```ts
-interface SceneGrainConfig {
-  intensity?: number;
-}
-```
-
-</details>
-
-<details><summary><code>SceneGroundConfig</code></summary>
-
-```ts
-interface SceneGroundConfig {
-  /** Show a ground plane */
-  visible?: boolean;
-  /** Ground color */
-  color?: string;
-  /** Offset below the model's bounding box minimum Z. Default 0 (flush with model bottom). */
-  offset?: number;
-  /** Receive shadows on the ground */
-  receiveShadow?: boolean;
-}
-```
-
-</details>
-
-<details><summary><code>SceneCaptureConfig</code></summary>
-
-```ts
-interface SceneCaptureConfig {
-  /** Frames for one full orbit rotation (default: 72) */
-  framesPerTurn?: number;
-  /** Frozen frames before motion starts (default: 6) */
-  holdFrames?: number;
-  /** Orbit pitch angle in degrees (default: auto from camera) */
-  pitchDeg?: number;
-  /** Output frame rate (default: 24) */
-  fps?: number;
-  /** Output frame size in pixels (default: 960) */
-  size?: number;
-  /** Canvas background color for capture (default: '#252526') */
-  background?: string;
-}
-```
-
-</details>
-
-#### `viewConfig()`
-
-```ts
-viewConfig(options?: ViewConfigOptions): void
-```
-
-Configure runtime viewport visuals for the current script execution. Multiple calls merge; later values override earlier ones.
-
-<details><summary><code>ViewConfigOptions</code></summary>
-
-```ts
-interface ViewConfigOptions {
-  jointOverlay?: JointOverlayViewConfigOptions;
-}
-```
-
-</details>
-
-<details><summary><code>JointOverlayViewConfigOptions</code></summary>
-
-```ts
-interface JointOverlayViewConfigOptions {
-  enabled?: boolean;
-  axisColor?: string;
-  axisCoreColor?: string;
-  arcColor?: string;
-  zeroColor?: string;
-  arcVisualLimitDeg?: number;
-  axisLengthScale?: number;
-  axisLengthMin?: number;
-  axisLineRadiusScale?: number;
-  axisLineRadiusMin?: number;
-  axisLineRadiusMax?: number;
-  spokeLineRadiusScale?: number;
-  spokeLineRadiusMin?: number;
-  spokeLineRadiusMax?: number;
-  arcLineRadiusScale?: number;
-  arcLineRadiusMin?: number;
-  arcLineRadiusMax?: number;
-  axisDotRadiusScale?: number;
-  axisDotRadiusMin?: number;
-  axisArrowRadiusScale?: number;
-  axisArrowRadiusMin?: number;
-  axisArrowLengthScale?: number;
-  axisArrowLengthMin?: number;
-  axisArrowOffsetFactor?: number;
-  arcRadiusScale?: number;
-  arcRadiusMin?: number;
-  arcDotRadiusScale?: number;
-  arcDotRadiusMin?: number;
-  arcArrowRadiusScale?: number;
-  arcArrowRadiusMin?: number;
-  arcArrowLengthScale?: number;
-  arcArrowLengthMin?: number;
-  arcArrowOffsetFactor?: number;
-  arcStepDeg?: number;
-  arcMinSteps?: number;
-  arcTubeSegmentsMin?: number;
-  arcTubeSegmentsFactor?: number;
-  arcTubeRadialSegments?: number;
-}
-```
-
-</details>
-
-#### `spec()`
-
-```ts
-spec(name: string, checkFn: (...args: any[]) => void): Spec
-```
-
-Create a named spec — a reusable bundle of verification checks. ```js const fitSpec = spec("Fits enclosure", (shape) => { verify.lessThan("Width",  shape.boundingBox().max[0] - shape.boundingBox().min[0], 200); verify.notEmpty("Has geometry", shape); }); fitSpec.check(myShape);   // grouped as "Fits enclosure" in the Checks panel fitSpec.check(otherShape); // can be reused on multiple shapes ``` calls `verify.*` methods. Any verify calls made inside this function are tagged with the spec name for grouped display.
-
-<details><summary><code>Spec</code></summary>
-
-```ts
-interface Spec {
-  /** The display name of this spec */
-  name: string;
-}
-```
-
-</details>
-
----
-
-## C15: Import & Composition
-
-Bring external geometry or other ForgeCAD modules into the current script.
-
-#### `group()`
-
-```ts
-group(...items: GroupInput[]): ShapeGroup
-```
-
-Group multiple shapes/sketches for joint transforms without merging into a single mesh. Unlike union(), colors and individual identities are preserved. Children can be plain shapes, named descriptors ({ name, shape/sketch/group }), or nested groups. The returned ShapeGroup supports all Shape transforms (translate, rotate, etc.).
-
----
-
-## C16: Part Library
-
-Pre-built parametric parts accessible via `lib.*`.
-
-*No free functions — see class methods (Shape, Sketch, ConstrainedSketchBuilder).*
-
----