forgecad 0.10.3 → 0.10.5

package/dist/docs-raw/generated/curves.md

@@ -15,6 +15,7 @@ Smooth curves, lofted surfaces, swept solids, splines, and high-level product sk
 - [Route3D](#route3d)
 - [NurbsCurve3D](#nurbscurve3d)
 - [NurbsSurface](#nurbssurface)
+- [Sheet](#sheet)
 - [PathBuilder](#pathbuilder) — Line Segments, Arcs, Curves, Closing & Output
 - [ProductSkin](#productskin)
 - [ProductSurfaceRef](#productsurfaceref)
@@ -78,6 +79,34 @@ const rail = Curve.BlendG2(
 **`CurveBlendG2Endpoint`** extends CurveBlendEndpoint
 - `curvature?: Vec3` — Optional endpoint curvature/second-derivative vector. Default is zero.
 
+#### `Curve.Bridge(options: CurveBridgeOptions): NurbsCurve3D` — Bridge two existing curve endpoints with inferred tangent or curvature continuity.
+
+This is the Onshape-style "select two curves and bridge them" primitive: ForgeCAD reads the endpoint positions, tangent directions, and NURBS curvature from the selected curves so callers do not hand-author tangent vectors. Use `continuity: 'G1'` for a cubic tangent bridge or the default `G2` for a quintic curvature bridge.
+
+```js
+const leftRim = Curve.Fit([[20, -12, 0], [0, -18, 2], [-30, -14, 1]]);
+const rightRim = Curve.Fit([[20, 12, 0], [0, 18, 2], [-30, 14, 1]]);
+const roundedNose = Curve.Bridge({
+  from: { curve: leftRim, at: 'end' },
+  to: { curve: rightRim, at: 'end' },
+  continuity: 'G2',
+});
+```
+
+**`CurveBridgeOptions`**
+
+| Option | Type | Description |
+|--------|------|-------------|
+| `from` | `CurveBridgeEndpoint` | Endpoint where the bridge starts. |
+| `to` | `CurveBridgeEndpoint` | Endpoint where the bridge ends. |
+| `continuity?` | `CurveBridgeContinuity` | Continuity target. Default `G2`. |
+| `weight?` | `number` | Tangent reach relative to bridge chord. Default 0.6. |
+
+**`CurveBridgeEndpoint`**
+- `curve: CurveTrimInput` — Existing curve endpoint to bridge from or to.
+- `at?: CurveBridgeEndpointAt` — Which endpoint of the curve to use. Default is `end`.
+- `weight?: number` — Tangent reach relative to bridge chord. Overrides `CurveBridgeOptions.weight` for this side.
+
 #### `Curve.Arc(options: CurveArcOptions): NurbsCurve3D` — Create an exact circular 3D arc from start, end, and start tangent.
 
 The returned curve is a rational quadratic `NurbsCurve3D`, split into stable spans when needed, so it can feed `sweep` without sampling the authoring intent away.
@@ -142,6 +171,52 @@ const loop = Curve.Fit(
 - `tolerance?: number` — Maximum allowed interpolation residual in model units. Default 1e-7.
 - `closed?: boolean` — Interpolate a closed periodic loop through the points. The loop closes from the last point back to the first automatically — do not repeat the first point at the end.
 
+#### `Curve.ProjectOnSurface(curve: NurbsCurve3D | Vec3[], sheet: Sheet, options?: CurveProjectOnSurfaceOptions): NurbsCurve3D` — Project a curve onto a `Sheet` along the surface normal and return the exact NURBS foot curve.
+
+This is the "drape a curve onto a surface" primitive: each sampled point of the source curve is inverted onto the sheet (closest surface point via the analytic jet), and the foot points are fitted with `Curve.Fit`. Use it to trace a planned trim line, seam, or graphic onto a freeform panel, then sweep or trim from the real on-surface curve.
+
+The source may be an exact `NurbsCurve3D` or a `Vec3[]` polyline (for example a placed 2D path). With `{ closed: true }` the result is a periodic loop, for draping a closed boundary onto the sheet. Set `maxGap` to require that every sample lands within a distance of the surface; the call throws if any sample misses (no silent fallback).
+
+```js
+const panel = Surface.Net().cage(cage);
+const guide = Curve.Line([-20, 0, 30], [20, 0, 30]);
+const seam = Curve.ProjectOnSurface(guide, panel);
+const bead = sweep(circle2d(0.6), seam);
+```
+
+**`CurveProjectOnSurfaceOptions`**
+
+| Option | Type | Description |
+|--------|------|-------------|
+| `samples?` | `number` | Coarse samples taken along the source curve before per-sample projection. Default 64. |
+| `refineIterations?` | `number` | Newton refinement iterations of the (u, v) foot-point per sample. Default 8. |
+| `tolerance?` | `number` | Interpolation tolerance passed to Curve.Fit for the result. Default 1e-4. |
+| `closed?` | `boolean` | Fit a closed periodic loop (use when the source curve is a closed loop). Default false. |
+| `maxGap?` | `number` | Max allowed projection gap; throws if any sample lands farther than this from the surface foot. Default Infinity (no gate). |
+
+#### `Curve.Intersect(sheetA: Sheet, sheetB: Sheet, options?: CurveIntersectOptions): NurbsCurve3D[]` — Intersect two `Sheet` surfaces and return the exact NURBS intersection branches.
+
+This is curve-following surface-surface intersection (SSI): a transversal marcher follows each intersection branch using the analytic surface jets (the intersection tangent is `cross(normalA, normalB)`), converging every step onto both surfaces, then fits each branch with `Curve.Fit`. A single pair of sheets can intersect in several disjoint curves, so the result is an array (empty when the sheets do not meet).
+
+Only transversal intersections (where the surfaces cross and the intersection tangent `cross(normalA, normalB)` is well defined) are detected. A tangential / grazing contact (where the surface normals are parallel and the tangent is undefined) is not marched and may be reported as no-intersection (an empty array) — tangential SSI is a documented follow-on, not a silent fallback.
+
+```js
+const wing = Surface.Net().cage(wingCage);
+const rib = Surface.Net().cage(ribCage);
+const [seam] = Curve.Intersect(wing, rib);
+const weld = sweep(circle2d(0.5), seam);
+```
+
+**`CurveIntersectOptions`**
+
+| Option | Type | Description |
+|--------|------|-------------|
+| `samples?` | `number` | Grid resolution per axis for seeding the marcher (samples x samples on sheetA). Default 48. |
+| `step?` | `number` | Marching step as a fraction of sheetA's average sample spacing. Default 0.5. |
+| `refineIterations?` | `number` | Newton iterations to converge each marched point onto both surfaces. Default 12. |
+| `tolerance?` | `number` | Convergence/coincidence tolerance in model units. Default 1e-4. |
+| `fitTolerance?` | `number` | Fit tolerance passed to Curve.Fit. Default 1e-3. |
+
 #### `Curve.Trim<T extends CurveTrimInput>(curve: T, start: number, end: number): CurveTrimOutput<T>` — Extract an exact curve segment from normalized parameter `start` to `end`.
 
 `NurbsCurve3D` inputs are trimmed with exact knot insertion/subdomain extraction. Polyline point arrays are trimmed by arclength over their exact line segments. Sampled `Curve3D` splines are rejected until ForgeCAD has a tolerance-controlled rebuild path.
@@ -150,6 +225,68 @@ const loop = Curve.Fit(
 
 `NurbsCurve3D` inputs reverse control points, weights, and knots. Polyline point arrays are cloned and reversed. Sampled `Curve3D` splines are rejected until ForgeCAD has a tolerance-controlled rebuild path.
 
+#### `Curve.closestParameter(curve: CurveClosestParameterInput, point: Vec3, options?: CurveClosestParameterOptions): number` — Find the normalized parameter on an exact curve closest to a world point.
+
+This is the query companion to `Curve.Trim()`: use it to locate where a construction point lands on an existing rail, surface boundary, or edge curve, then trim/sweep from that real geometric station instead of copying the original construction points.
+
+`NurbsCurve3D` inputs are searched by curve parameter with coarse sampling plus local refinement. Polyline point arrays are projected onto their exact line segments and return an arclength-normalized parameter.
+
+```js
+const start = Curve.closestParameter(sheet.frontCurve, [-20, -12, 4]);
+const end = Curve.closestParameter(sheet.frontCurve, [20, -12, 4]);
+const rimRail = Curve.Trim(sheet.frontCurve, start, end);
+```
+
+**`CurveClosestParameterOptions`**
+- `samples?: number` — Coarse samples before local refinement. Default 96.
+
+#### `Curve.join(curves: CurveJoinInput[], options?: CurveJoinOptions): Vec3[]` — Join touching curve segments into one sampled sweep path.
+
+This is the composite-curve primitive for downstream features that need to follow several real edges as one path: rolled rims, seam beads, trim strips, weld beads, and surface-boundary inlays. ForgeCAD validates that adjacent segment endpoints touch; it will not silently reverse or bridge gaps.
+
+```js
+const rimPath = Curve.join([
+  Curve.Reverse(Curve.Trim(sheet.frontCurve, 0, u)),
+  sheet.leftCurve,
+  Curve.Trim(sheet.rearCurve, 0, u),
+]);
+const rim = sweep(ellipse(0.8, 0.35), rimPath);
+```
+
+**`CurveJoinOptions`**
+- `samples?: number` — Points sampled per exact curve segment. Default 32.
+- `tolerance?: number` — Maximum allowed gap between adjacent segment endpoints. Default 1e-6.
+
+#### `Curve.placeOnXY(path: CurvePath2D, z?: number, options?: CurvePathPlacementOptions): Vec3[]` — Place a 2D path onto the XY plane at world Z.
+
+The returned 3D point array can feed `Surface.Net`, `Curve.Fit`, `sweep`, `Curve.Trim`, and any other curve consumer that accepts points.
+
+```js
+const rail = Curve.placeOnXY(path().moveTo(0, 0).bezierTo(30, 8, 60, -4, 90, 0), 12);
+const smoothRail = Curve.Fit(rail);
+```
+
+**`CurvePathPlacementOptions`**
+- `samples?: number` — Optional sample count when [`path`](/docs/sketch#path) is a path-like object.
+
+#### `Curve.placeOnXZ(path: CurvePath2D, y?: number, options?: CurvePathPlacementOptions): Vec3[]` — Place a 2D path onto the XZ plane at world Y.
+
+The path's first coordinate becomes X and the second becomes Z.
+
+#### `Curve.placeOnYZ(path: CurvePath2D, x?: number, options?: CurvePathPlacementOptions): Vec3[]` — Place a 2D path onto the YZ plane at world X.
+
+The path's first coordinate becomes Y and the second becomes Z. This is the direct "sketch cross-sections on offset planes" primitive for surface nets.
+
+#### `Curve.placeOnPlane(path: CurvePath2D, options: CurvePlanePlacementOptions): Vec3[]` — Place a 2D path onto an arbitrary world plane.
+
+`origin` is the 2D sketch origin in world space. `xAxis` and `yAxis` are perpendicular world directions for the local sketch axes.
+
+
+**`CurvePlanePlacementOptions`** extends CurvePathPlacementOptions
+- `origin: Vec3` — World-space origin of the 2D sketch plane.
+- `xAxis: Vec3` — World-space direction for the sketch X axis.
+- `yAxis: Vec3` — World-space direction for the sketch Y axis.
+
 #### `Curve.Route: typeof Route3D` — Build analytic 3D line/arc routes for sweeps.
 
 `Curve.Route.fromPolyline()` is the canonical route API. It returns a `Route3D` value object, preserving exact route segments, named port frames, and the lowerable `route3d` sweep compile plan.
@@ -250,7 +387,7 @@ A closed spline (default) returns a filled profile. An open spline requires a st
 | `strokeWidth?` | `number` | For open splines, provide stroke width to return a solid Sketch. If omitted for open splines, an error is thrown. |
 | `join?` | `"Round" \| "Square"` | Stroke join for open splines. Default 'Round'. |
 
-#### `loft(profiles: Sketch[], heights: number[], options?: LoftOptions): Shape` — Loft between multiple sketches along Z stations.
+#### `loft(profiles: Sketch[], heights: (number | EndCondition)[], 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 also stay on the maintained export-backend path.
 
@@ -258,6 +395,8 @@ The surface is smooth through 3+ stations (C1 spanwise interpolation, like CAD l
 
 Performance note: loft is significantly heavier than primitive/extrude/revolve. If the part is axis-symmetric (bottles, vases, knobs), prefer revolve().
 
+`EndCondition` — defined in [sketch](/docs/sketch).
+
 #### `sweep(profile: Sketch, path: SweepPathInput, options?: SweepOptions): Shape`
 
 **`SweepOptions`**
@@ -437,6 +576,91 @@ Uses Algorithm A2.3 basis-function derivatives with the rational quotient rule,
 
 #### `tessellate(resU?: number, resV?: number): { positions: Vec3[]; normals: Vec3[]; indices: number[]; }` — Tessellate the surface into a triangle mesh. Returns positions, normals, and triangle indices.
 
+### `Sheet`
+
+A parametric open surface value (control grid + knots + analytic differential geometry).
+
+**Properties:**
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `surface` | `BSplineSurface` | — |
+
+**Methods:**
+
+#### `get frontEdge(): SheetEdge` — Edge naming follows parameter direction (documented): front=v0, rear=v1, left=u0, right=u1.
+
+#### `get frontCurve(): NurbsCurve3D` — Exact curve along the front boundary (`v = 0`).
+
+#### `get rearCurve(): NurbsCurve3D` — Exact curve along the rear boundary (`v = 1`).
+
+#### `get leftCurve(): NurbsCurve3D` — Exact curve along the left boundary (`u = 0`).
+
+#### `get rightCurve(): NurbsCurve3D` — Exact curve along the right boundary (`u = 1`).
+
+#### `curveAlong(edge: SheetEdge): NurbsCurve3D` — Extract an exact NURBS iso-curve from one of this sheet's boundary edges.
+
+Use this when a downstream feature should be driven by the actual sheet boundary, such as a swept rim, seam bead, trim strip, or adjacent blend.
+
+`SheetEdge` — defined in [core](/docs/core).
+
+#### `curveAlongU(vInput: number): NurbsCurve3D` — Extract an exact NURBS iso-curve in the sheet U direction at fixed `v`.
+
+Use this for centerline rails, ribs, beads, and trim features that live on the interior of a freeform sheet instead of on a boundary edge.
+
+#### `curveAlongV(uInput: number): NurbsCurve3D` — Extract an exact NURBS iso-curve in the sheet V direction at fixed `u`.
+
+Use this for cross-surface rails, seam lines, straps, and inspection paths that should be driven by the sheet parameterization rather than global axes.
+
+#### `pathAlong(edge: SheetEdge, options?: SheetPathAlongOptions): Vec3[]` — Sample a world-space path along a sheet boundary edge.
+
+Use this when a downstream feature should follow the real surface edge but does not need to stay an exact NURBS curve, for example a lip, gasket bead, trim strip, weld seam, or inlay lifted off the surface by `normalOffset`.
+
+`SheetPathAlongOptions` — defined in [core](/docs/core).
+
+#### `pathAlongBoundary(spans: SheetBoundaryPathSpan[], options?: SheetBoundaryPathOptions): Vec3[]` — Sample one connected path across ordered sheet boundary edge spans.
+
+This is the composite-boundary primitive for rolled rims, weld beads, gaskets, trim strips, and inlays that follow several sheet edges as one continuous rail. Span `start` / `end` values may be normalized parameters or world points; world points are resolved to the closest point on that edge so callers do not have to manually invoke `Curve.closestParameter()`.
+
+`SheetBoundaryPathSpan` — defined in [core](/docs/core).
+
+`SheetBoundaryPathOptions` — defined in [core](/docs/core).
+
+#### `pathAlongU(vInput: number, options?: SheetPathAlongOptions): Vec3[]` — Sample a world-space path in the sheet U direction at fixed `v`.
+
+Unlike `curveAlongU()`, this can lift points along the analytic normal with `normalOffset`, which is the common path for swept ribs, inlays, and raised details on a freeform carrier surface.
+
+#### `pathAlongV(uInput: number, options?: SheetPathAlongOptions): Vec3[]` — Sample a world-space path in the sheet V direction at fixed `u`.
+
+Use this for lifted cross-surface features where a sampled path is more useful than an exact iso-curve, for example straps, grooves, or probes.
+
+#### `frameAt(uInput: number, vInput: number, options?: SheetFrameOptions): SheetFrame` — Build an orthonormal local work frame on the sheet.
+
+This is the "construct tangent plane/frame on a surface" primitive for downstream sketches, profiles, fixtures, inspection probes, and features that must be oriented from the sheet itself rather than global axes.
+
+`SheetFrameOptions` — defined in [core](/docs/core).
+
+#### `framePerpendicularToU(uInput: number, vInput: number, options?: SheetFrameOptions): SheetFrame` — Build a section work frame perpendicular to the sheet's U direction.
+
+This is the "plane normal to path" primitive for ribs, raised handles, bosses, and other details whose cross-sections should be sketched across a carrier surface while marching along the surface U direction. The returned frame can be passed directly to `Shape.sliceOnFrame()`.
+
+#### `framePerpendicularToV(uInput: number, vInput: number, options?: SheetFrameOptions): SheetFrame` — Build a section work frame perpendicular to the sheet's V direction.
+
+Use this when the guide path runs in the surface V direction and the sketch profile should span the U direction while its height follows the surface normal. The returned frame can be passed directly to `Shape.sliceOnFrame()`.
+
+#### `toShape(options?: { resolution?: number; }): Shape` — Return this open sheet as a renderable surface Shape.
+
+#### `thicken(wall: number, options?: { resolution?: number; }): Shape` — Offset the sheet along its analytic normals into a watertight solid shell of the given wall thickness. Throws if the wall would self-intersect on a concave region (no silent degenerate solid).
+
+#### `matchEdge(edge: SheetEdge): MatchEdgeBuilder` — Per-edge continuity match against a neighbor (returns a NEW Sheet).
+
+- `get rearEdge(): SheetEdge`
+- `get leftEdge(): SheetEdge`
+- `get rightEdge(): SheetEdge`
+- `pointAt(u: number, v: number): Vec3`
+- `normalAt(u: number, v: number): Vec3`
+- `curvatureAt(u: number, v: number): SurfaceCurvature`
+
 ### `PathBuilder`
 
 **Line Segments**
@@ -1132,7 +1356,7 @@ Canonical exact/smooth 3D curve constructors.
 
 `Curve.*` is the public home for reference curves and route centerlines that feed `sweep`, `variableSweep`, route visualization, and future path consumers. Standalone 3D curve constructors have been collapsed into this namespace.
 
-Members (full entries under [Curves & Surfacing](#curves-surfacing)): `Curve.Blend`, `Curve.BlendG2`, `Curve.Arc`, `Curve.Line`, `Curve.Nurbs`, `Curve.Fit`, `Curve.Trim`, `Curve.Reverse`, `Curve.Route`, `Curve.Helix`.
+Members (full entries under [Curves & Surfacing](#curves-surfacing)): `Curve.Blend`, `Curve.BlendG2`, `Curve.Bridge`, `Curve.Arc`, `Curve.Line`, `Curve.Nurbs`, `Curve.Fit`, `Curve.ProjectOnSurface`, `Curve.Intersect`, `Curve.Trim`, `Curve.Reverse`, `Curve.closestParameter`, `Curve.join`, `Curve.placeOnXY`, `Curve.placeOnXZ`, `Curve.placeOnYZ`, `Curve.placeOnPlane`, `Curve.Route`, `Curve.Helix`.
 
 ### `Surface`
 
@@ -1141,6 +1365,31 @@ Members (full entries under [Curves & Surfacing](#curves-surfacing)): `Curve.Ble
 - `Cone(options: SurfaceConeOptions): Shape` — Create a finite analytic conical or frustum sheet, optionally bounded by start/end angles.
 - `Sphere(options: SurfaceSphereOptions): Shape` — Create a finite analytic spherical sheet bounded by longitude and latitude ranges.
 - `Torus(options: SurfaceTorusOptions): Shape` — Create a finite analytic torus sheet bounded by major and tube angle ranges.
+- `Sweep(profile: SurfaceSweepProfileInput, spine: SweepPathInput, options?: SurfaceSweepOptions): Sheet` — Sweep an open 2D profile path along a 3D spine to create an open surface sheet.
+
+  This is the surface-first counterpart to the solid `sweep()` function. Use it for class-A/product workflows where the shape starts as an infinitely thin carrier sheet, then becomes physical material with `.thicken(...)`. The profile's local X axis maps across the sheet, local Y maps along the swept frame's up/normal direction, and the spine direction becomes sheet U.
+
+  ```js
+  const sideProfile = Curve.Fit(Curve.placeOnXZ(path().moveTo(0, 0).bezierTo(40, -8, 90, 8, 140, 3)));
+  const crossSection = path().moveTo(-20, 2).bezierTo(-8, -4, 8, -4, 20, 2);
+  const sheet = Surface.Sweep(crossSection, sideProfile);
+  const thinPart = sheet.thicken(1.2);
+  ```
+- `Loft(input: SurfaceLoftInput): Sheet` — Loft an open surface sheet through ordered profile stations.
+
+  This is the surface-first counterpart to solid lofts: profiles are open 2D section curves, point stations intentionally collapse a smooth tip, and guide curves can pin named connection landmarks such as rims or low points. The result is an open `Sheet`; call `.thicken(...)` to make physical material.
+
+  ```js
+  const sheet = Surface.Loft({
+    axis: 'X',
+    profiles: [
+      { at: -40, point: [-40, 0, 0] },
+      { at: 0, profile: path().moveTo(-12, 2).bezierTo(-4, -4, 4, -4, 12, 2) },
+      { at: 40, profile: path().moveTo(-5, 0).lineTo(5, 0) },
+    ],
+    connections: [{ name: 'lowPoint', profileParameter: 0.5 }],
+  });
+  ```
 - `Nurbs(controlGrid: Vec3[][], options?: NurbsSurfaceOptions): Shape` — Create an exact NURBS surface from a grid of control points.
 
   The control grid is indexed as `controlGrid[u][v]` — each row is a curve in the V direction, and columns trace curves in the U direction. With default options this builds a bicubic non-rational B-spline sheet with uniform clamped knots; `NurbsSurfaceOptions` controls degrees, weights, knots, trim loops, tessellation, domain, and an optional `thickness` to return a thin solid instead of an open sheet.
@@ -1166,20 +1415,109 @@ Members (full entries under [Curves & Surfacing](#curves-surfacing)): `Curve.Ble
   const panel = Surface.Patch({ bottom, top, left, right }).thicken(1.5);
   ```
 - `Boundary(input: SurfaceBoundaryInput): Shape`
-- `Fill(input: SurfaceFillInput): Shape`
+- `Fill(input: SurfaceFillInput): Shape` — Create an n-sided open surface sheet from 3 or more boundary curves (energy-minimizing constrained fill).
+
+  Boundaries form a closed loop of any size (n >= 3). They are exact by default: pass `NurbsCurve3D` values or `Shape.edge()` refs, or set `{ approximate: true }` to accept sampled `Curve3D`/`Vec3[]` boundaries. Use `match` to make a named boundary G0/G1/G2-tangent to a neighboring face. The result is an open sheet — call `.thicken(t)` for a thin solid.
+
+  Two optional fields pull the fill onto interior features (OCCT backend only; the Truck/SDF backends reject them):
+
+  - `through` — interior constraint curves the surface must pass through (not part of the boundary loop). These are matched positionally (G0) only; G1/G2 on a free interior curve is not honored, so a non-`'G0'` `continuity` throws.
+  - `points` — isolated interior points the surface must interpolate.
+
+  ```js
+  const skin = Surface.Fill({
+    boundaries: [
+      { name: 'a', curve: edgeA }, { name: 'b', curve: edgeB },
+      { name: 'c', curve: edgeC }, { name: 'd', curve: edgeD }, { name: 'e', curve: edgeE },
+    ],
+    match: { a: { target: neighbor.edge('top'), continuity: 'G1' } },
+    through: [{ curve: interiorSpine }], // pull the fill onto an internal feature line
+    points: [[10, 10, 4]],               // pin an interior bump
+  });
+  ```
 - `Sew(shapes: Shape[], options?: { tolerance?: number; }): Shape`
 - `Solid(input: Shape | Shape[], options?: SurfaceSolidOptions): Shape` — Sew surface faces or consume an existing sewn shell and make a solid B-rep.
 - `Extend(shape: Shape, options: SurfaceExtendOptions): Shape`
 - `Trim(shape: Shape, tool: Shape | SurfacePlaneOp): Shape`
 - `Split(shape: Shape, tool: Shape | SurfacePlaneOp): [ Shape, Shape ]`
 - `Match(shape: Shape, options: { edge: "u0" | "u1" | "v0" | "v1"; target: EdgeRef; continuity?: SurfaceContinuity; }): Shape`
-- `Net(): CurveNet` — Begin a curve-network (Gordon) surface — the class-A keystone. Chain `.lengthwise(...)/.crosswise(...)` (or `.alongRails(a,b).sections(...)`, or `.cage(grid)`), then `.thicken(wall)` to get a solid Shape. Returns a fluent [`Sheet`](/docs/core#sheet) builder with analytic point/normal/curvature queries and named edges.
+- `Net(): CurveNet` — Begin a curve-network (Gordon) surface — the class-A keystone. Chain `.lengthwise(...)/.crosswise(...)` (or `.alongRails(a,b).sections(...)`, or `.cage(grid)`), then `.thicken(wall)` to get a solid Shape. Returns a fluent `Sheet` builder with analytic point/normal/curvature queries and named edges.
+- `BoundaryNet(): CurveNet` — Begin a **Boundary Surface** — the canonical class-A surfacing primitive (SolidWorks "Boundary Boss/Base", Onshape "Boundary surface", Rhino NetworkSrf). It fills a curve cage exactly like `Net` (same Gordon interior), then adds the two foundational boundary capabilities a real boundary surface has:
+
+  1. **Per-side continuity** — `.matchStartU/.matchEndU/.matchStartV/.matchEndV` enforce G0/G1/G2 across a side, either matching an adjacent sheet's edge (tangent/curvature) or imposing an explicit cross-boundary tangent.
+  2. **Closed / periodic form** — `.closedU()/.closedV()` weld a direction's two ends into a tangent-continuous loop, so a closed-rim surface (e.g. a bowl's around-rim seam) is smooth with NO G0 kink.
+
+  Returns the same fluent builder as `Net` (cage/families/degree plus the new boundary methods); finish with `.toSheet()` or `.thicken(wall)`. Verify a matched seam with `Analysis.EdgeMatch`.
+
+  ```js
+  // Smooth closed-rim dished bowl: a closed rim + radial sections, welded.
+  const bowl = Surface.BoundaryNet()
+    .lengthwise(...radialSections)   // rim -> center, one per around-rim station
+    .closedV()                       // weld the around-rim seam (no kink)
+    .thicken(1.2);
+  ```
+
+  ```js
+  // Match a fender panel to the hood with curvature (G2) continuity.
+  const fender = Surface.BoundaryNet()
+    .lengthwise(sill, belt, crown)
+    .crosswise(nose, aPillar)
+    .matchStartV({ edge: hood.rearEdge, continuity: 2 })
+    .toSheet();
+  ```
+
+  U-sides then V-sides, so clean continuity is guaranteed along edge interiors, not exactly at the four corners (same limitation as `Sheet.matchEdge`).
 
 ### `Blend`
 
-- `Edge(options: BlendEdgeOptions): Shape`
+- `Edge(options: BlendEdgeOptions): Shape` — Fillet one or more edges with constant or variable radius.
+
+  Pass `variableRadius` for a tapered or station-law blend — it overrides the constant `radius`. Variable radius requires `--backend occt`.
+
+  Orientation caveat: for a linear `{ start, end }` taper, `start` maps to the matched edge's first vertex (u=0), whose orientation is not guaranteed to match the named edge's start. If the taper runs the wrong way, pass a `stations` law (explicit `at` positions) or swap `start`/`end`.
+
+  ```js
+  // Constant radius
+  let b = box(40, 20, 10)
+  b = Blend.Edge({ edges: [b.edge('top-front')], radius: 3 })
+  ```
+
+  ```js
+  // Linear taper from 1mm to 5mm along the edge
+  b = Blend.Edge({ edges: [b.edge('top-front')], variableRadius: { start: 1, end: 5 } })
+  ```
+
+  ```js
+  // Station law — bulge in the middle
+  b = Blend.Edge({ edges: [b.edge('top-front')], variableRadius: {
+    stations: [{ at: 0, radius: 1 }, { at: 0.5, radius: 4 }, { at: 1, radius: 1 }] } })
+  ```
 - `Surface(options: BlendSurfaceOptions): Shape`
-- `Bridge(edgeA: SheetEdge, edgeB: SheetEdge): BridgeBuilder` — Build a transition strip between two `Surface.Net` sheet edges. Chain `.bulge(a, b)` then `.g0()/.g1()/.g2()` for the continuity order. Returns a [`Sheet`](/docs/core#sheet); verify the seam with `Analysis.EdgeMatch`.
+- `Bridge(edgeA: SheetEdge, edgeB: SheetEdge): BridgeBuilder` — Build a transition strip between two `Surface.Net` sheet edges. Chain `.bulge(a, b)` then `.g0()/.g1()/.g2()` for the continuity order. Returns a `Sheet`; verify the seam with `Analysis.EdgeMatch`.
+- `Face(options: BlendFaceOptions): Shape` — Fillet every edge SHARED by a pair of faces — a "face fillet". Resolves the shared edges of the two faces and rolls a constant or variable-radius blend along all of them. Requires `--backend occt`.
+
+  ```js
+  let body = box(80, 50, 30).faces({ lid: 'top', wall: 'side-left' })
+  body = Blend.Face({ faces: [body.face('lid'), body.face('wall')], radius: 4 })
+  ```
+
+  ```js
+  // Variable radius along the shared edges
+  body = Blend.Face({ faces: [body.face('lid'), body.face('wall')],
+    variableRadius: { start: 2, end: 6 } })
+  ```
+- `FullRound(options: BlendFullRoundOptions): Shape` — Full round — roll a blend over a narrow center face so it is consumed and its two neighbouring faces meet tangentially (classic 3-face full round). The radius defaults to half the center-face span. Requires `--backend occt`.
+
+  ```js
+  let bar = box(60, 8, 20).faces({ topRail: 'top', left: 'side-left', right: 'side-right' })
+  bar = Blend.FullRound({ centerFace: bar.face('topRail') })
+  ```
+
+  ```js
+  // Explicit neighbours
+  bar = Blend.FullRound({ centerFace: bar.face('topRail'),
+    sideFaces: [bar.face('left'), bar.face('right')] })
+  ```
 
 ### `Analysis`
 

package/dist/docs-raw/generated/runtime-names.md

@@ -18,18 +18,18 @@ activateBackend, Analysis, arcSlot, assembly, Assembly, Blend, bom, box
 cameraTrajectory, Carrier, chamfer, circle2d, Circle2D, circularLayout, circularPattern, circularPattern2d
 coalesceEdges, compareWith, connector, console, constrainedSketch, Curve, Curve3D, cutPlane
 cylinder, difference, difference2d, dim, draft, ellipse, explodeView, faceProfile
-fillet, Function, gcode, GCodeBuilder, getActiveBackend, global, globalThis, group
-Import, ImportedAssembly, initKernel, intersection, intersection2d, intersectWithPlane, joint, Laser
-lib, Line2D, linearPattern, linearPattern2d, loadFont, loft, Loft, mirrorCopy
-mock, ngon, NurbsCurve3D, NurbsSurface, offsetSolid, param, Param, path
-Point2D, Points, polygon, polygonVertices, port, Product, ProductPanelBuilder, ProductRibbonBuilder
-ProductSkin, ProductSkinBuilder, ProductStationBuilder, ProductSurfaceBuilder, ProductSurfaceRef, projectToPlane, queueMicrotask, rect
-Rectangle2D, roundedRect, Route3D, scene, Sculpt, sdf, SdfShape, selectEdge
-selectEdges, self, setActiveBackend, setImmediate, setInterval, setTimeout, Shape, ShapeGroup
-sheetMetal, SheetMetalPart, sheetStock, Sim, Sketch, sketchToDxf, sketchToSvg, slot
-SolvedAssembly, spec, sphere, spline2d, stroke, Surface, SurfaceBody, SurfaceMembers
-sweep, text2d, textWidth, torus, toShape, Transform, union, union2d
-variableSweep, verify, Viewport, window, Wood
+Fea, fillet, Function, gcode, GCodeBuilder, getActiveBackend, global, globalThis
+group, Import, ImportedAssembly, initKernel, intersection, intersection2d, intersectWithPlane, joint
+Laser, lib, Line2D, linearPattern, linearPattern2d, loadFont, loft, Loft
+mirrorCopy, mock, ngon, NurbsCurve3D, NurbsSurface, offsetSolid, param, Param
+path, Point2D, Points, polygon, polygonVertices, port, Product, ProductPanelBuilder
+ProductRibbonBuilder, ProductSkin, ProductSkinBuilder, ProductStationBuilder, ProductSurfaceBuilder, ProductSurfaceRef, projectToPlane, queueMicrotask
+rect, Rectangle2D, roundedRect, Route3D, scene, Sculpt, sdf, SdfShape
+selectEdge, selectEdges, self, setActiveBackend, setImmediate, setInterval, setTimeout, Shape
+ShapeGroup, sheetMetal, SheetMetalPart, sheetStock, Sim, Sketch, sketchToDxf, sketchToSvg
+slot, SolvedAssembly, spec, sphere, spline2d, stroke, Surface, SurfaceBody
+SurfaceMembers, sweep, text2d, textWidth, torus, toShape, Transform, union
+union2d, variableSweep, verify, Viewport, window, Wood, Wrap
 ```
 
 <!-- forgecad-skill:exclude-start symbol="compatibility runtime names" reason="Compatibility-only renamed runtime globals." -->

package/dist/docs-raw/generated/sketch.md

@@ -391,7 +391,22 @@ donut.region([40, 0]).extrude(10); // seed at radius 40, inside the ring
 
 **Promotion**
 
-#### `extrude(height: number, opts?: { twist?: number; divisions?: number; scaleTop?: number | Vec2; }): Shape` — Extrude this 2D sketch along Z to create a 3D solid. Supports twist and scale tapering.
+#### `extrude(extent: number | EndCondition, opts?: { twist?: number; divisions?: number; scaleTop?: number | Vec2; }): Shape` — Extrude this 2D sketch along Z to create a 3D solid. Supports twist and scale tapering. The extent may be a numeric height or an `EndCondition` (up to a face, plane, or vertex).
+
+**`EndCondition`**
+
+| Option | Type | Description |
+|--------|------|-------------|
+| `upToFace?` | `FaceRef \| SketchFaceTarget` | Terminate flush with a planar face perpendicular to the feature direction. |
+| `upToPlane?` | `PlaneOp` | Terminate at an arbitrary plane (ray-plane intersection along the direction). |
+| `upToVertex?` | `Vec3` | Terminate at the plane through this point, perpendicular to the direction. |
+| `offset?` | `number` | Signed offset PAST the resolved surface in the travel direction (default 0). |
+
+`FaceRef` — defined in [core](/docs/core).
+
+**`PlaneOp`**
+- `normal: Vec3` — Plane normal. Need not be unit length; it is normalized internally.
+- `offset?: number` — Signed offset of the plane along its normal from the world origin (default 0).
 
 #### `revolve(degrees?: number, segments?: number): Shape` — Revolve this 2D sketch around the world Z axis. Sketch X is radius; sketch Y becomes world Z height. Keep the profile at X > 0 unless it intentionally touches the axis.
 
@@ -412,8 +427,6 @@ const shifted = rect(4, 70).attachTo(plate, 'bottom-left', 'top-left', [5, 0]);
 
 Use this when a 2D profile should be oriented onto a 3D face before extrusion or other downstream operations.
 
-`FaceRef` — defined in [core](/docs/core).
-
 **Labels**
 
 #### `labelEdge(name: string): Sketch` — Label the single boundary edge (for circles, single-loop profiles). Returns a new sketch.

package/dist/docs-raw/guides/inspection-bundles.md

@@ -5,21 +5,21 @@ skill-order: 2
 
 # Inspection Bundles — Evidence Contract
 
-`forgecad inspect <family> <mode>` writes a deterministic bundle: evidence PNGs under `evidence/<type>/` plus a root `manifest.json`. **The manifest is the authoritative contract** — take file paths, encodings, per-view ranges, thresholds, tolerances, and identity maps from it; never hard-code bundle layout or infer object identity from object order. The PNGs are a visual index for locating findings, not standalone artifacts. Command tree, flags, and `--focus`/`--hide` filtering live in `docs/skill/CLI.md` and `forgecad inspect evidence`; the inspection workflow lives in the `forgecad-render-inspect` skill. Model-authored `scene()` background, lights, fog, and exposure are ignored for inspection captures so evidence stays stable; named scene views remain available via `--view`.
+`forgecad inspect <family> <mode>` writes a deterministic bundle: evidence PNGs under `evidence/<type>/` plus a root `manifest.json`. **The manifest is the authoritative contract** — take file paths, encodings, per-view ranges, thresholds, tolerances, and identity maps from it; never hard-code bundle layout or infer object identity from object order. The PNGs are a visual index for locating findings, not standalone artifacts. Command tree, flags, and `--focus`/`--hide` filtering live in `docs/skill/CLI.md` and `forgecad inspect evidence`; the inspection workflow lives in the `forgecad-inspect-model` skill. Model-authored `scene()` background, lights, fog, and exposure are ignored for inspection captures so evidence stays stable; named scene views remain available via `--view`.
 
 Manifest evidence keys are evidence-oriented and stable for bundle readers: e.g. `fit interference` writes `manifest.evidence.collisions`, `physical components` writes `manifest.evidence.connectivity`.
 
 ## Reading Rules
 
 - **Identity evidence** (`objects`, `connectivity`, `distance`, `collisions`): colors are bundle-local labels. Resolve every color through the manifest; the same color never carries universal meaning across bundles. Edge pixels may be antialiased blends — match solid interior colors.
-- **Metric evidence** (`depth`, `thickness`, `roughness`, `distance`, `comparison`): read manifest thresholds, ranges, object summaries, and warnings before judging a PNG by eye.
+- **Metric evidence** (`depth`, `thickness`, `throughThickness`, `roughness`, `distance`, `comparison`): read manifest thresholds, ranges, object summaries, and warnings before judging a PNG by eye.
 - Black pixels are background = `null` (in `floating`, black also means ground-reachable geometry).
 - Treat unexpected collisions, critical thin regions, high unresolved thickness, wrong component counts, floating bodies, or surprising gaps as **model bugs to fix and reinspect** — not rendering noise.
 - Use section evidence to inspect hidden internals; never turn the production model into a permanent cutaway.
 
 ## The Physical-Contact Model
 
-Connectivity, floating, distance, and thickness all share one contact model:
+Connectivity, floating, distance, thickness, and minimum-solid-span (`throughThickness`) all share one contact model:
 
 - **Bbox is broadphase only.** Bbox overlap or bbox face contact never merges separate scene objects and is never support evidence.
 - Mesh surfaces within the contact tolerance (see manifest) count as **physically connected**.
@@ -62,6 +62,8 @@ normal = normalize((rgb / 255) * 2 - 1)
 
 **thickness** — area-weighted surface point samples cast through the object along their normals; red = below min, orange = below warn, green = acceptable, blue = above max (thresholds in manifest; override via CLI flags). Contact-seam rule: rays crossing into a direct physical-contact neighbor skip hits within contact tolerance and continue to the next surface, so a modeled micro-gap between touching parts doesn't read as a paper-thin wall. **Gray/unresolved area means the heatmap is incomplete, NOT that the model is safe** — open meshes, concave geometry, coarse tessellation, or low sample counts leave unresolved regions. A mesh/raycast approximation, not FEA. Also writes `evidence/thickness/point-cloud.json` with per-sample object identity, local position, normal, thickness, class, color, and represented area.
 
+**throughThickness** — minimum solid span from each surface point. Instead of casting only along the local normal, it searches for the closest opposite boundary reachable by a segment that leaves the surface into occupied material; nearby exterior air gaps are rejected. This catches diagonal choke points and edge-near weak zones that normal thickness can miss. Uses the same threshold/color options as `thickness` in v1 and writes `evidence/through-thickness/point-cloud.json`.
+
 **sections** — exact 2D contour slices, three explicit modes:
 
 - `sections at` — one exact cut through a localized feature (`--plane yz --offset 12.5`).