forgecad 0.10.4 → 0.11.0

package/dist/docs-raw/AI/usage.md

@@ -50,7 +50,6 @@ forgecad studio .
 
 ```bash
 npm install -g forgecad
-forgecad login
 mkdir enclosure-bracket
 cd enclosure-bracket
 forgecad project init "Enclosure Bracket" --visibility private
@@ -58,7 +57,7 @@ forgecad new bracket --template part
 forgecad studio .
 ```
 
-`forgecad project init` creates the remote project, writes `forgecad.json`, and uploads existing local model files, helper code, Markdown notes, SVG/DXF assets, and other supported text project files. After that, `forgecad project push` syncs local changes to the hosted project.
+`forgecad project init` writes local project metadata to `forgecad.json`; it does not create anything on the server. After local validation, run `forgecad login` and `forgecad project push`. The first push creates the hosted project if needed, uploads local model files, helper code, Markdown notes, SVG/DXF assets, and other supported text project files, then records server file IDs. Later pushes sync local changes to the hosted project.
 
 `forgecad project push` does not initialize a random folder. If the folder has no `forgecad.json`, the command fails and tells you to run `forgecad project init` or `forgecad project clone <slug>` first.
 
@@ -97,7 +96,7 @@ To verify installation, ask the agent:
 What ForgeCAD skills are available?
 ```
 
-You should see `forgecad` plus companion skills such as `forgecad-build-model`, `forgecad-inspect-model`, `forgecad-design-spec`, and `forgecad-project-sync`.
+You should see `forgecad` plus companion skills such as `forgecad-build-model`, `forgecad-project-sync`, and `forgecad-reconstruct-cad-file`.
 
 If you only want the core modeling skill without companion workflows:
 
@@ -206,13 +205,12 @@ For the full command reference, see [ForgeCAD CLI](../CLI.md).
 | Skill | Use it for |
 |---|---|
 | `forgecad` | Core model authoring, editing, debugging, imports, assembly, render/export commands, and CLI validation. |
-| `forgecad-design-spec` | Designing in a git-reviewed document before code: fuzzy-request intake and process choice, the HLD (requirements, alternatives, decisions), and the LLD (exact dimensions, constraints, parameters, verification). |
-| `forgecad-build-model` | Creating a new `.forge.js` model in the active ForgeCAD project, including multi-part assembly discipline and validation. |
+| `forgecad-build-model` | Creating a new `.forge.js` model in the active ForgeCAD project with design-first planning, staged files, multi-part assembly discipline, and validation. |
 | `forgecad-reconstruct-cad-file` | Reconstructing a readable parametric ForgeCAD model from an existing STL, OBJ, 3MF, STEP, or STP file. |
 | `forgecad-reconstruct-from-images` | Recreating an object from reference images as real ForgeCAD geometry through camera-calibrated render/compare/iterate loops. |
-| `forgecad-inspect-model` | Generating and interpreting `forgecad inspect <family> <mode>` bundles for fit interference, wall thickness, connectivity, masks, depth, normals, and sections. |
-| `forgecad-grade-model` | Reviewing and scoring a model against a requirement, brief, prompt, reference, or acceptance criteria. |
-| `forgecad-verify-mujoco` | Verifying MJCF exports in MuJoCo with dynamics, contacts, controls, joint travel, and rendered evidence. |
+| `forgecad-build-model` inspection feedback reference | Generating and interpreting `forgecad inspect <family> <mode>` bundles for fit interference, wall thickness, connectivity, masks, depth, normals, and sections. |
+| `forgecad-build-model` readiness review reference | Reviewing a model against a requirement, brief, prompt, reference, or acceptance criteria with evidence. |
+| `forgecad-build-model` simulation feedback reference | Verifying MJCF exports in MuJoCo with dynamics, contacts, controls, joint travel, FEA, and rendered evidence. |
 | `forgecad-image-prompt` | Producing builder-honest image prompts from a concrete model, HLD, LLD, or build brief. |
 | `forgecad-project-sync` | Managing forgecad.io projects from the CLI: init, clone, pull, push, file commands, members, publish, and shares. |
 

package/dist/docs-raw/CLI.md

@@ -13,8 +13,7 @@ Create projects, open local studios, run, inspect, export, publish, and sync `.f
 # 1. Install
 npm install -g forgecad
 
-# 2. Sign in and create a dedicated project folder
-forgecad login
+# 2. Create a dedicated local project folder
 mkdir spool-adapter
 cd spool-adapter
 forgecad project init "Spool Adapter" --visibility private
@@ -25,14 +24,15 @@ forgecad new adapter --template part
 # 4. Open the local editor
 forgecad studio .
 
-# 5. Validate, export, and push to the browser
+# 5. Validate, export, sign in, and push to the browser
 forgecad run adapter.forge.js
 forgecad export stl adapter.forge.js
+forgecad login
 forgecad project push
 forgecad project open
 ```
 
-Local modeling, inspection, export, and skill-install commands do not require a ForgeCAD account. Hosted project sync, publishing, token management, and license activation require sign-in: run `forgecad login` and choose email/password or API token (for GitHub/Google accounts, create a token in Settings > API Tokens first). Use `FORGECAD_TOKEN=fc_pat_... forgecad <hosted-command>` only for CI/CD and one-off automation. `forgecad studio` always requires an explicit project path; use `.` for the current project.
+Local modeling, project initialization, inspection, export, and skill-install commands do not require a ForgeCAD account. Hosted project sync, publishing, token management, and license activation require sign-in: run `forgecad login` and choose email/password or API token (for GitHub/Google accounts, create a token in Settings > API Tokens first). Use `FORGECAD_TOKEN=fc_pat_... forgecad <hosted-command>` only for CI/CD and one-off automation. `forgecad studio` always requires an explicit project path; use `.` for the current project.
 
 You can also start from the hosted starter project with `forgecad project clone start-here`, then `cd start-here` and `forgecad studio .`.
 
@@ -74,7 +74,7 @@ The fast validation command: runs the script with the real geometry kernel (no b
 
 A bare `forgecad run` skips expensive diagnostics. Opt in with `--details` (volumes/bounds), `--history` (construction tree), `--features` (feature tallies), `--solver-profile` (constraint solver timing), or `--connectivity` (physical connected components — bbox contact is evidence, exact geometry is checked by default). `--quality live|default|high` selects the same geometry quality profile as the editor and export tools; `live` is fastest for large models.
 
-Direct `.stl`/`.obj`/`.3mf`/`.step`/`.stp` inputs are imported automatically; STEP/STP auto-selects OCCT unless you pass `--backend`. For deeper confidence gates, prefer `inspect mechanical-integrity`, `check print`, or `inspect fit interference` instead of turning `run` into a catch-all audit command.
+Direct `.stl`/`.obj`/`.3mf`/`.step`/`.stp` inputs are imported automatically; STEP/STP auto-selects OCCT unless you pass `--backend`. Use `--project-root <dir>` when running a file inside a larger uninitialized folder and you intentionally want relative imports to resolve against that root. For deeper confidence gates, prefer `inspect mechanical-integrity`, `check print`, or `inspect fit interference` instead of turning `run` into a catch-all audit command.
 
 ```bash
 forgecad run model.forge.js
@@ -136,7 +136,8 @@ Inspect a model by asking for one explicit kind of evidence.
 - `inspect surface zebra|roughness` — surface continuity and roughness evidence
 - `inspect physical components|floating|gaps` — physical component graph evidence
 - `inspect fit interference` — positive-volume overlap evidence
-- `inspect manufacture thickness` — wall-thickness evidence
+- `inspect manufacture thickness|through-thickness` — wall-thickness and minimum solid span evidence
+- `inspect structural stress` — solver-produced structural stress scalar-field evidence
 - `inspect compare overlay` — candidate-vs-reference visual mismatch evidence
 - `inspect sections at|stack|sample` — exact section evidence for precise cuts, dense scans, or sparse samples
 - `inspect mechanical-integrity` — model-focused integrity audit for generated assemblies
@@ -292,6 +293,7 @@ Export to every format you need.
 | `export svg` | SVG | 2D vector output from sketches |
 | `export sketch-pdf` **\[Production\]** | PDF | Sketch with dimensions and constraints |
 | `export step` **\[Production\]** | STEP | CAD interchange (exact geometry) |
+| `export fea` **\[Production\]** | FEA package | Exact STEP plus authored structural load-case metadata |
 | `export brep` **\[Production\]** | BREP | Boundary representation |
 | `export 3mf` | 3MF | 3D printing (color, multi-part) |
 | `export stl` | STL | 3D printing |
@@ -356,16 +358,16 @@ Script-backed exports accept repeatable `--param Key=Value` overrides before the
 
 ForgeCAD has a hosted platform at [forgecad.io](https://forgecad.io). The CLI connects a dedicated local project folder to it.
 
-A project is a local folder linked to the hosted app by `forgecad.json`. Use `forgecad project clone <slug>` to download an existing hosted project into a local folder, or run `forgecad project init` inside a folder that should become a new ForgeCAD project. Open local projects with `forgecad studio <project-path>`.
+A project is a local folder marked by `forgecad.json`; after the first push, that same file also links it to the hosted app. Use `forgecad project clone <slug>` to download an existing hosted project into a local folder, or run `forgecad project init` inside a folder that should become a new ForgeCAD project. Open local projects with `forgecad studio <project-path>`.
 
 Keep the project root small and intentional. Do not run the editor from `~`, downloads, desktop, or a huge source tree. ForgeCAD scans project files such as `.forge.js`, `.js`, `.svg`, and `.dxf`; broad roots make local workflows and AI-agent context slow and confusing.
 
-First-time setup (login, init, studio) is the [Quick Start](#quick-start) sequence above. `forgecad project init` creates the remote project, writes `forgecad.json`, pushes any existing local source files, and records server file IDs. `forgecad project push` syncs an already initialized project; it does not create a remote project from an arbitrary folder.
+First-time setup (init, studio, login, push) is the [Quick Start](#quick-start) sequence above. `forgecad project init` writes a local `forgecad.json` with the project name, slug, server, and visibility. It does not contact the server. The first `forgecad project push` creates the hosted project if `forgecad.json` has no project ID yet, uploads local source files, and records server file IDs. Later pushes sync the already linked hosted project. `forgecad project push` still requires `forgecad.json`; it does not initialize a random folder.
 
 ### Sync
 
 ```bash
-forgecad project push          # Upload local changes
+forgecad project push          # Create hosted project if needed; upload changes
 forgecad project pull          # Download remote changes
 forgecad project status        # See what's different
 ```
@@ -393,10 +395,10 @@ Shares are live references — always the current version, not a snapshot.
 
 | Command | Description |
 |---------|-------------|
-| `project init` | Initialize the current directory as a ForgeCAD project and create it on the server. |
+| `project init` | Initialize the current directory as a local ForgeCAD project. |
 | `project clone` | Download a remote project into a new local directory. |
 | `project pull` | Download remote changes into the current project. |
-| `project push` | Upload local changes to the remote project. |
+| `project push` | Create the hosted project if needed, then upload local changes. |
 | `project status` | Show differences between local and remote project files. |
 | `project list` | List your remote projects. |
 | `project open` | Open the current project in the browser. |
@@ -543,7 +545,7 @@ The CLI is free for personal non-commercial use. Pro covers human-operated comme
 
 | Free | Production outputs | Pro | Enterprise |
 |------|--------------------|-----|------------|
-| `run`, `dev`, `studio`, `render 3d`, `export stl`, `export 3mf`, `export svg`, `compare 3d`, `check print`, `inspect fit interference`, `inspect mechanical-integrity` for personal non-commercial use | `cut-list`, `export sketch-pdf`, `export step`, `export brep`, `export gcode`, `export implicit`, `export sdf`, `export mjcf`, `export urdf`, `export usd`, `export report`, `export cutting-layout` are free to run for personal non-commercial use; Pro covers human-operated commercial CAD work | `render hq`, `capture gif`, `capture mp4` plus commercial coverage for client/customer work | Backend, hosted, embedded, or application workflows that call ForgeCAD automatically |
+| `run`, `dev`, `studio`, `render 3d`, `export stl`, `export 3mf`, `export svg`, `compare 3d`, `check print`, `inspect fit interference`, `inspect mechanical-integrity` for personal non-commercial use | `cut-list`, `export sketch-pdf`, `export step`, `export fea`, `export brep`, `export gcode`, `export implicit`, `export sdf`, `export mjcf`, `export urdf`, `export usd`, `export report`, `export cutting-layout` are free to run for personal non-commercial use; Pro covers human-operated commercial CAD work | `render hq`, `capture gif`, `capture mp4` plus commercial coverage for client/customer work | Backend, hosted, embedded, or application workflows that call ForgeCAD automatically |
 
 ```bash
 forgecad license                    # Check local license status

package/dist/docs-raw/component-model.md

@@ -5,7 +5,7 @@ skill-order: 4
 
 # The Component Model
 
-Long-form rationale for ForgeCAD's multi-part architecture. The public rule sheet is embedded where agents need it: `forgecad-build-model` for authoring and `forgecad-grade-model` for review caps. Connector and joint mechanics (frame semantics, mating, mirrored-revolute handedness) live in the assembly JSDoc, surfaced in `docs/skill/generated/assembly.md`.
+Long-form rationale for ForgeCAD's multi-part architecture. The public rule sheet is embedded where agents need it: `forgecad-build-model` for authoring and readiness review. Connector and joint mechanics (frame semantics, mating, mirrored-revolute handedness) live in the assembly JSDoc, surfaced in `docs/skill/generated/assembly.md`.
 
 ## The Principle
 
@@ -19,20 +19,39 @@ ForgeCAD applies the same principle to mechanical design. Before: parts compute
 
 Data flows in one direction, from parent (assembly) to children (parts):
 
-- **Props flow down.** The assembly owns the cross-cutting decisions (base height, wall thickness, servo model) and passes them to parts as `require()` param overrides.
-- **Metadata flows up.** Parts return shape + connectors + any computed data siblings need (`return { shape, boltPattern, pinionZ }`).
+- **Props flow down.** The assembly owns `param()` calls and cross-cutting decisions (base height, wall thickness, servo model), then passes ordinary values into child builder functions.
+- **Builders are the child contract.** Reusable part files return builder functions such as `return { buildMount }`. When opened directly, they may define preview-only params inside `if (require.main === module)`.
+- **Metadata flows up.** Builders return shape + connectors + any computed data siblings need (`return { shape, boltPattern, pinionZ }`).
 - **Siblings never import each other.** The cover plate doesn't import the motor mount to read bolt positions; the assembly reads the mount's bolt pattern and passes it to the cover plate. The parent mediates all sibling communication.
 
 ```js
-const mount = require('./motor-mount.forge.js', { Wall: wall });
-const cover = require('./cover-plate.forge.js', {
-  BoltPattern: mount.boltPattern,  // parent routes mount's data to a sibling
+const mountModule = require('./motor-mount.forge.js');
+const coverModule = require('./cover-plate.forge.js');
+
+const mount = mountModule.buildMount({ wall });
+const cover = coverModule.buildCover({
+  wall,
+  boltPattern: mount.boltPattern,  // parent routes mount's data to a sibling
 });
 ```
 
+```js
+// motor-mount.forge.js
+function buildMount({ wall }) {
+  const shape = box(80, 40, wall);
+  return { shape, boltPattern: { dia: 5.3, positions: [[-25, 0], [25, 0]] } };
+}
+
+if (require.main === module) {
+  return buildMount({ wall: param('Wall', 3) }).shape;
+}
+
+return { buildMount };
+```
+
 ## Why This Matters
 
-**For humans.** Each part file tells a complete story: geometry, connectors, parameters, verifications — no chasing imports across eight files, no 266-line shared-dims.js to internalize. Modifying one part doesn't break siblings, because connectors are the contract: change the mount's internal cavity and nothing else moves, as long as the flange connector stays put.
+**For humans.** Each part file tells a complete story: geometry, connectors, preview controls, verifications — no chasing imports across eight files, no 266-line shared-dims.js to internalize. Modifying one part doesn't break siblings, because connectors are the contract: change the mount's internal cavity and nothing else moves, as long as the flange connector stays put.
 
 **For AIs.** Each part file is self-contained context. An agent generates `base-body.forge.js` without reading `jaw-unit.forge.js`. The assembly file is a high-level plan generatable from a natural-language description, and props are an explicit interface contract — the agent knows exactly what each part needs and provides.
 
@@ -40,8 +59,8 @@ const cover = require('./cover-plate.forge.js', {
 
 ## File Granularity
 
-One file per project-specific assembly is the default because it maximizes locality: parts as comment-separated sections, shared data as plain variables, the whole design visible by scrolling. Eight 40-line files are worse than one 300-line file — the context-switching cost destroys exactly the locality this model exists to create. Split only for genuine cross-project reuse or when a file outgrows ~300 lines (the binding rule is in the skill).
+Complex models should be expressible as a tree of small, independently previewable modules. A reusable `.forge.js` module returns builder functions or a module interface; direct-run preview controls live under `if (require.main === module)`. The system entry point, usually `main.forge.js`, composes high-level modules instead of importing every leaf file.
 
 ## Enforcement
 
-The anti-pattern list and design gate are enforced by the public build and grading skills; every multi-part example and agent-built assembly must pass that gate.
+The anti-pattern list and design gate are enforced by the public build-model workflow; every multi-part example and agent-built assembly must pass that gate.

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

@@ -27,12 +27,14 @@ Assembly-owned links, constraints, connectors, solved poses, and source-level si
 
 #### `Sim.body(options: SimBodyOptions): SimBodyDef` — Describe one assembly part as a physical body with mass/density, material, collider intent, and optional contact surfaces.
 
-**`SimBodyOptions`**: `massKg?: number`, `densityKgM3?: number`, `material?: SimMaterialDef`, `collider?: SimColliderDef`, `contacts?: Record<string, SimContactDef>`
+**`SimBodyOptions`**: `massKg?: number`, `densityKgM3?: number`, `material?: SimMaterialDef`, `collider?: SimColliderDef`, `contacts?: Record<string, SimContactDef>`, `motion?: SimMotionDef`
 
-`SimColliderDef`: `{ kind: "collider", mode: SimColliderMode, reason?: string }`
+`SimColliderDef`: `{ kind: "collider", mode: SimColliderMode, reason?: string, sdfResolution?: number }`
 
 `SimContactDef`: `{ kind: "wheelSurface" | "gripperSurface", connectorName: string }`
 
+`SimMotionDef`: `{ kind: "motion", mode: SimMotionMode }`
+
 
 `SimBodyDef`: `{ kind: "body" }`
 
@@ -41,8 +43,15 @@ Assembly-owned links, constraints, connectors, solved poses, and source-level si
 - `Sim.collider.convexHull(): SimColliderDef` — Use a generated collision mesh for the part. This is the default fast rigid-body collider for irregular parts.
 - `Sim.collider.boundingBox(): SimColliderDef` — Use the part bounding box as the collision geometry. This is fastest and works well for chassis and simple blocks.
 - `Sim.collider.visualMesh(): SimColliderDef` — Use the visual mesh as collision geometry. This is exact but usually slower in physics engines.
+- `Sim.collider.sdfMesh: (options?: { resolution?: number` — Use an SDF mesh collider for complex concave contact geometry. Exporters warn when their target cannot encode it.
 - `Sim.collider.none(reason: string): SimColliderDef` — Disable collision for a part with an explicit reason, such as a sensor-only or decorative object.
 
+#### `Sim.motion` — Body motion-state intent for simulation export. Dynamic is the default when omitted.
+
+- `Sim.motion.dynamic(): SimMotionDef` — Simulate this body as a normal dynamic rigid body with mass and inertia.
+- `Sim.motion.kinematic(): SimMotionDef` — Simulate this body as kinematic: moved by the simulator/user, but not force-integrated.
+- `Sim.motion.static(): SimMotionDef` — Keep this body fixed in the world as a static collision/environment body.
+
 #### `Sim.drive` — Joint-drive intent constructors for passive or powered assembly joints.
 
 - `Sim.drive.passive(options?: SimPassiveDriveOptions): SimDriveDef` — Mark a joint as passive while preserving damping and friction metadata for simulation export.
@@ -75,6 +84,60 @@ Assembly-owned links, constraints, connectors, solved poses, and source-level si
 
 `SimDiffDriveControllerDef`: `{ kind: "diffDrive" }`
 
+#### `Fea.material(name: string, options: FeaMaterialOptions): FeaMaterialDef` — Create a named linear-elastic structural material for static stress studies.
+
+#### `Fea.body(options: FeaBodyOptions): FeaBodyDef` — Mark one assembly part as a structural body with a `Fea.material(...)` value.
+
+#### `Fea.region` — Stable explicit region references for solver package manifests.
+
+- `Fea.region.face(partName: string, faceName: string): FeaPartFaceRegionRef` — Reference a named face on a named assembly part without relying on object identity.
+- `Fea.region.plane(partName: string, faceName: string, options: FeaPlaneRegionOptions): FeaPartPlaneRegionRef` — Reference a planar face by a point on the face and its outward normal in part-local coordinates.
+
+`FeaPartFaceRegionRef`: `{ kind: "fea-region-face", partName: string, faceName: string }`
+
+`FeaPlaneRegionOptions`: `{ center: Vec3, normal: Vec3 }`
+
+`FeaPartPlaneRegionRef`: `{ kind: "fea-region-plane", partName: string, faceName: string, center: Vec3, normal: Vec3 }`
+
+#### `Fea.fix` — Fixture constructors over authored face/region references.
+
+- `Fea.fix.fixed(region: FeaRegionRef): FeaFixedFixtureDef` — Fully fix all translational degrees of freedom on a face/region.
+
+`FeaFixedFixtureDef`: `{ kind: "fixed", region: FeaRegionRef }`
+
+#### `Fea.load` — Load constructors over authored face/region references.
+
+- `Fea.load.force(region: FeaRegionRef, options: FeaForceLoadOptions): FeaForceLoadDef` — Apply a force with magnitude in newtons along the given direction vector.
+
+`FeaForceLoadOptions`: `{ newtons: number, direction: Vec3 }`
+
+
+`FeaForceLoadDef`: `{ kind: "force", region: FeaRegionRef }`
+
+#### `Fea.target` — Study target constructors used by feedback and pass/fail gates.
+
+- `Fea.target.minSafetyFactor(value: number): FeaMinSafetyFactorTargetDef` — Require the solved minimum safety factor to be at least `value`.
+
+`FeaMinSafetyFactorTargetDef`: `{ kind: "minSafetyFactor", value: number }`
+
+#### `Fea.mesh` — Volume mesh intent. V1 structural stress uses second-order tetrahedra only.
+
+- `Fea.mesh.quadraticTets(options: FeaQuadraticTetMeshOptions): FeaQuadraticTetMeshDef` — Request quadratic tetrahedral C3D10 elements with a maximum size in mm.
+
+`FeaQuadraticTetMeshOptions`: `{ maxSizeMm: number, minQuality?: number }`
+
+
+`FeaQuadraticTetMeshDef`: `{ kind: "quadraticTets", order: 2, element: "C3D10" }`
+
+#### `Fea.study` — Study constructors.
+
+- `Fea.study.staticStress(name: string, options: FeaStaticStressStudyOptions): FeaStaticStressStudyDef` — Create a linear static structural stress study.
+
+`FeaStaticStressStudyOptions`: `{ fixtures: FeaFixtureDef[], loads: FeaLoadDef[], target?: FeaTargetDef, mesh: FeaMeshDef }`
+
+
+`FeaStaticStressStudyDef`: `{ kind: "staticStress", name: string }`
+
 #### `assembly(name?: string): Assembly` — Create an assembly container with named parts, connectors, and kinematic links.
 
 **Use this from iteration 1 for any model with moving parts.** Do not build one static pose and retrofit motion later.
@@ -208,7 +271,7 @@ const housing = group(
 assembly.addPart("Base Assembly", housing);
 ```
 
-**`PartOptions`**: `transform?: TransformInput`, `metadata?: PartMetadata`, `sim?: SimBodyDef`, `mate?: AssemblyPartMateInput | AssemblyPartMateInput[]`, `bindToFrame?: string`
+**`PartOptions`**: `transform?: TransformInput`, `metadata?: PartMetadata`, `sim?: SimBodyDef`, `fea?: FeaBodyDef`, `mate?: AssemblyPartMateInput | AssemblyPartMateInput[]`, `bindToFrame?: string`
 
 **`PartMetadata`**
 
@@ -218,6 +281,12 @@ assembly.addPart("Base Assembly", housing);
 
 Also: `material?: string`, `process?: string`, `tolerance?: string`, `qty?: number`, `notes?: string`, `densityKgM3?: number`, `massKg?: number`.
 
+`FeaBodyDef`: `{ kind: "fea-body", material: FeaMaterialDef }`
+
+`FeaMaterialOptions`: `{ densityKgM3: number, youngsModulusMPa: number, poissonRatio: number, yieldStrengthMPa: number }`
+
+`FeaMaterialDef`: `{ kind: "fea-material", name: string }`
+
 **`AssemblyPartMateInput`**
 - `connector: string` — Name of a connector declared on the part (via `withConnectors()`).
 - `toLink: string` — Name of the link this connector's origin is pinned to.
@@ -377,6 +446,10 @@ Use this after adding physical parts and joints. Robot-body profiles require `ro
 
 `SimAssemblySimulationOptions`: `{ profile: SimProfileDef, rootPart?: string, controllers?: SimControllerDef[] }`
 
+#### `withFeaStudy(study: FeaStudyDef): Assembly` — Attach a structural FEA study to this assembly.
+
+The study is authored with `Fea.study.staticStress(...)` and consumed by `forgecad export fea`. This records load-case intent only; ForgeCAD refuses to invent fixtures, loads, mesh order, or region tags during export.
+
 #### `edgeBetweenFrames(a: string, b: string, options?: AssemblyFrameEdgeOptions): Assembly` — Add a visual skeleton edge between two rig frame origins.
 
 Frame edges follow the solved frame poses produced by `fixedJoint()`, `revoluteJoint()`, and `prismaticJoint()`. They do not add constraints, degrees of freedom, parts, or geometry; use them to make a frame-only rig readable in the Motion/rig inspection overlay.

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

@@ -7,14 +7,14 @@ Every public API function belongs to one of 16 fundamental concepts. This is an
 - **[C1: Primitive Construction](#c1-primitive-construction)** — Create geometry from parameters — no input geometry required. *(66 functions)*
 - **[C2: Boolean Combination](#c2-boolean-combination)** — Combine same-dimension geometry using CSG set operations. *(6 functions)*
 - **[C3: Rigid Transform](#c3-rigid-transform)** — Reposition or reorient geometry without changing its shape. *(0 functions)*
-- **[C4: Dimensional Promotion](#c4-dimensional-promotion)** — Convert a 2D profile into a 3D solid (extrude, revolve, loft, sweep). *(50 functions)*
+- **[C4: Dimensional Promotion](#c4-dimensional-promotion)** — Convert a 2D profile into a 3D solid (extrude, revolve, loft, sweep). *(69 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. *(4 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. *(1 functions)*
 - **[C9: Spatial Placement](#c9-spatial-placement)** — Position geometry relative to other geometry using semantic anchors. *(6 functions)*
-- **[C10: Assembly & Kinematics](#c10-assembly-kinematics)** — Compose parts with joints for kinematic simulation. *(15 functions)*
-- **[C11: Parameterization & UI](#c11-parameterization-ui)** — Declare user-facing controls that drive model geometry. *(6 functions)*
+- **[C10: Assembly & Kinematics](#c10-assembly-kinematics)** — Compose parts with joints for kinematic simulation. *(28 functions)*
+- **[C11: Parameterization & UI](#c11-parameterization-ui)** — Declare user-facing controls that drive model geometry. *(10 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). *(14 functions)*
 - **[C14: Visual & Debugging](#c14-visual-debugging)** — Control viewport appearance and debugging aids. *(39 functions)*
@@ -123,12 +123,21 @@ Convert a 2D profile into a 3D solid (extrude, revolve, loft, sweep).
 
 - `Curve.Blend(start, end)` — Create an exact G1 blend curve between two directed endpoints. → [curves](/docs/curves#curve)
 - `Curve.BlendG2(start, end)` — Create an exact G2 blend curve between two directed endpoints. → [curves](/docs/curves#curve)
+- `Curve.Bridge(options)` — Bridge two existing curve endpoints with inferred tangent or curvature continuity. → [curves](/docs/curves#curve)
 - `Curve.Arc(options)` — Create an exact circular 3D arc from start, end, and start tangent. → [curves](/docs/curves#curve)
 - `Curve.Line(start, end)` — Create an exact straight 3D NURBS line segment. → [curves](/docs/curves#curve)
 - `Curve.Nurbs(points, options?)` — Create an exact NURBS 3D curve from control points, weights, knots, and degree. → [curves](/docs/curves#curve)
 - `Curve.Fit(points, options?)` — Fit a non-rational NURBS curve that interpolates every input point. → [curves](/docs/curves#curve)
+- `Curve.ProjectOnSurface(curve, sheet, options?)` — Project a curve onto a `Sheet` along the surface normal and return the exact NURBS foot curve. → [curves](/docs/curves#curve)
+- `Curve.Intersect(sheetA, sheetB, options?)` — Intersect two `Sheet` surfaces and return the exact NURBS intersection branches. → [curves](/docs/curves#curve)
 - `Curve.Trim(curve, start, end)` — Extract an exact curve segment from normalized parameter `start` to `end`. → [curves](/docs/curves#curve)
 - `Curve.Reverse(curve)` — Reverse an exact curve without changing its geometry. → [curves](/docs/curves#curve)
+- `Curve.closestParameter(curve, point, options?)` — Find the normalized parameter on an exact curve closest to a world point. → [curves](/docs/curves#curve)
+- `Curve.join(curves, options?)` — Join touching curve segments into one sampled sweep path. → [curves](/docs/curves#curve)
+- `Curve.placeOnXY(path, z?, options?)` — Place a 2D path onto the XY plane at world Z. → [curves](/docs/curves#curve)
+- `Curve.placeOnXZ(path, y?, options?)` — Place a 2D path onto the XZ plane at world Y. → [curves](/docs/curves#curve)
+- `Curve.placeOnYZ(path, x?, options?)` — Place a 2D path onto the YZ plane at world X. → [curves](/docs/curves#curve)
+- `Curve.placeOnPlane(path, options)` — Place a 2D path onto an arbitrary world plane. → [curves](/docs/curves#curve)
 - `Curve.Route` — Build analytic 3D line/arc routes for sweeps. → [curves](/docs/curves#curve)
 - `Curve.Helix(options)` — Build helical paths and swept coils. → [curves](/docs/curves#curve)
 - `Loft.station(profile, position)` — Create a loft station from a 2D profile and an axis position. → [curves](/docs/curves#curves-surfacing)
@@ -148,19 +157,23 @@ Convert a 2D profile into a 3D solid (extrude, revolve, loft, sweep).
 - `Analysis.CurvatureComb(input, options?)` → [curves](/docs/curves#analysis)
 - `Analysis.SurfaceHealth(shape, options?)` → [curves](/docs/curves#analysis)
 - `Analysis.BRepValidity(shape, options?)` — Validate B-rep/shell/solid structure and return closedness, manifoldness, orientation, and issue diagnostics. → [curves](/docs/curves#analysis)
-- `Blend.Edge(options)` → [curves](/docs/curves#blend)
+- `Blend.Edge(options)` — Fillet one or more edges with constant or variable radius. → [curves](/docs/curves#blend)
 - `Blend.Surface(options)` → [curves](/docs/curves#blend)
 - `Blend.Bridge(edgeA, edgeB)` — Build a transition strip between two `Surface.Net` sheet edges. → [curves](/docs/curves#blend)
+- `Blend.Face(options)` — Fillet every edge SHARED by a pair of faces — a "face fillet". → [curves](/docs/curves#blend)
+- `Blend.FullRound(options)` — 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). → [curves](/docs/curves#blend)
 - `Surface.Plane(options)` — Create a finite analytic plane sheet that can be trimmed, sewn, thickened, or used as a low-level face. → [curves](/docs/curves#surface)
 - `Surface.Cylinder(options)` — Create a finite analytic cylindrical sheet, optionally bounded by start/end angles. → [curves](/docs/curves#surface)
 - `Surface.Cone(options)` — Create a finite analytic conical or frustum sheet, optionally bounded by start/end angles. → [curves](/docs/curves#surface)
 - `Surface.Sphere(options)` — Create a finite analytic spherical sheet bounded by longitude and latitude ranges. → [curves](/docs/curves#surface)
 - `Surface.Torus(options)` — Create a finite analytic torus sheet bounded by major and tube angle ranges. → [curves](/docs/curves#surface)
+- `Surface.Sweep(profile, spine, options?)` — Sweep an open 2D profile path along a 3D spine to create an open surface sheet. → [curves](/docs/curves#surface)
+- `Surface.Loft(input)` — Loft an open surface sheet through ordered profile stations. → [curves](/docs/curves#surface)
 - `Surface.Nurbs(controlGrid, options?)` — Create an exact NURBS surface from a grid of control points. → [curves](/docs/curves#surface)
 - `Surface.Ruled(curveA, curveB, options?)` → [curves](/docs/curves#surface)
 - `Surface.Patch(curves, options?)` — Create a smooth open surface sheet from 4 boundary curves (Coons patch). → [curves](/docs/curves#surface)
 - `Surface.Boundary(input)` → [curves](/docs/curves#surface)
-- `Surface.Fill(input)` → [curves](/docs/curves#surface)
+- `Surface.Fill(input)` — Create an n-sided open surface sheet from 3 or more boundary curves (energy-minimizing constrained fill). → [curves](/docs/curves#surface)
 - `Surface.Sew(shapes, options?)` → [curves](/docs/curves#surface)
 - `Surface.Solid(input, options?)` — Sew surface faces or consume an existing sewn shell and make a solid B-rep. → [curves](/docs/curves#surface)
 - `Surface.Extend(shape, options)` → [curves](/docs/curves#surface)
@@ -168,6 +181,12 @@ Convert a 2D profile into a 3D solid (extrude, revolve, loft, sweep).
 - `Surface.Split(shape, tool)` → [curves](/docs/curves#surface)
 - `Surface.Match(shape, options)` → [curves](/docs/curves#surface)
 - `Surface.Net()` — Begin a curve-network (Gordon) surface — the class-A keystone. → [curves](/docs/curves#surface)
+- `Surface.BoundaryNet()` — Begin a **Boundary Surface** — the canonical class-A surfacing primitive (SolidWorks "Boundary Boss/Base", Onshape "Boundary surface", Rhino NetworkSrf). → [curves](/docs/curves#surface)
+- `Thickness.constant(thickness)` — Use the same wall thickness everywhere on the sheet. → [curves](/docs/curves#thickness)
+- `Thickness.alongU(profile)` — Vary wall thickness across the sheet U direction. → [curves](/docs/curves#thickness)
+- `Thickness.alongV(profile)` — Vary wall thickness across the sheet V direction. → [curves](/docs/curves#thickness)
+- `Thickness.grid(values, options?)` — Bilinearly interpolate wall thickness from a rectangular UV grid. → [curves](/docs/curves#thickness)
+- `Thickness.nurbs(values, options?)` — Interpolate wall thickness from a scalar tensor-product B-spline over sheet UV. → [curves](/docs/curves#thickness)
 - `loft(profiles, heights, options?)` — Loft between multiple sketches along Z stations. → [curves](/docs/curves#loft)
 - `sweep(profile, path, options?)` → [curves](/docs/curves#sweep)
 - `variableSweep(spine, sections, options?)` — Sweep a variable cross-section along a 3D spine curve. → [curves](/docs/curves#variablesweep)
@@ -233,12 +252,25 @@ Position geometry relative to other geometry using semantic anchors.
 
 Compose parts with joints for kinematic simulation.
 
+- `Fea.material(name, options)` — Create a named linear-elastic structural material for static stress studies. → [assembly](/docs/assembly#assembly-joints)
+- `Fea.body(options)` — Mark one assembly part as a structural body with a `Fea.material(...)` value. → [assembly](/docs/assembly#assembly-joints)
+- `Fea.region.face(partName, faceName)` — Reference a named face on a named assembly part without relying on object identity. → [assembly](/docs/assembly#assembly-joints)
+- `Fea.region.plane(partName, faceName, options)` — Reference a planar face by a point on the face and its outward normal in part-local coordinates. → [assembly](/docs/assembly#assembly-joints)
+- `Fea.fix.fixed(region)` — Fully fix all translational degrees of freedom on a face/region. → [assembly](/docs/assembly#assembly-joints)
+- `Fea.load.force(region, options)` — Apply a force with magnitude in newtons along the given direction vector. → [assembly](/docs/assembly#assembly-joints)
+- `Fea.target.minSafetyFactor(value)` — Require the solved minimum safety factor to be at least `value`. → [assembly](/docs/assembly#assembly-joints)
+- `Fea.mesh.quadraticTets(options)` — Request quadratic tetrahedral C3D10 elements with a maximum size in mm. → [assembly](/docs/assembly#assembly-joints)
+- `Fea.study.staticStress(name, options)` — Create a linear static structural stress study. → [assembly](/docs/assembly#assembly-joints)
 - `Sim.material(name, options?)` — Create a named physical material with density and contact coefficients for simulation export and checks. → [assembly](/docs/assembly#assembly-joints)
 - `Sim.body(options)` — Describe one assembly part as a physical body with mass/density, material, collider intent, and optional contact surfaces. → [assembly](/docs/assembly#assembly-joints)
 - `Sim.collider.convexHull()` — Use a generated collision mesh for the part. → [assembly](/docs/assembly#assembly-joints)
 - `Sim.collider.boundingBox()` — Use the part bounding box as the collision geometry. → [assembly](/docs/assembly#assembly-joints)
 - `Sim.collider.visualMesh()` — Use the visual mesh as collision geometry. → [assembly](/docs/assembly#assembly-joints)
+- `Sim.collider.sdfMesh` — Use an SDF mesh collider for complex concave contact geometry. → [assembly](/docs/assembly#assembly-joints)
 - `Sim.collider.none(reason)` — Disable collision for a part with an explicit reason, such as a sensor-only or decorative object. → [assembly](/docs/assembly#assembly-joints)
+- `Sim.motion.dynamic()` — Simulate this body as a normal dynamic rigid body with mass and inertia. → [assembly](/docs/assembly#assembly-joints)
+- `Sim.motion.kinematic()` — Simulate this body as kinematic: moved by the simulator/user, but not force-integrated. → [assembly](/docs/assembly#assembly-joints)
+- `Sim.motion.static()` — Keep this body fixed in the world as a static collision/environment body. → [assembly](/docs/assembly#assembly-joints)
 - `Sim.drive.passive(options?)` — Mark a joint as passive while preserving damping and friction metadata for simulation export. → [assembly](/docs/assembly#assembly-joints)
 - `Sim.drive.velocity(options)` — Mark a revolute joint as velocity-driven with torque and speed limits. → [assembly](/docs/assembly#assembly-joints)
 - `Sim.contact.wheelSurface(connectorName)` — Mark a connector as the wheel tread contact surface for offline checks and downstream simulation metadata. → [assembly](/docs/assembly#assembly-joints)
@@ -255,11 +287,15 @@ Compose parts with joints for kinematic simulation.
 
 Declare user-facing controls that drive model geometry.
 
+- `Param.anchor` — Viewport anchor builders for spatial parameter editing. → [core](/docs/core#parameters)
 - `Param.number(name, defaultValue, opts?)` — Declare a numeric parameter that renders as a slider in the UI. → [core](/docs/core#parameters)
 - `Param.string(name, defaultValue, opts?)` — Declare a string parameter that renders as a text input in the UI. → [core](/docs/core#parameters)
-- `Param.bool(name, defaultValue)` — Declare a boolean parameter that renders as a checkbox in the UI. → [core](/docs/core#parameters)
-- `Param.choice(name, defaultValue, choices)` — Declare a choice parameter that renders as a dropdown in the UI. → [core](/docs/core#parameters)
+- `Param.bool(name, defaultValue, opts?)` — Declare a boolean parameter that renders as a checkbox in the UI. → [core](/docs/core#parameters)
+- `Param.choice(name, defaultValue, choices, opts?)` — Declare a choice parameter that renders as a dropdown in the UI. → [core](/docs/core#parameters)
 - `Param.list(name, defaultItems, opts)` — Declare a list parameter — an array of struct items with per-field UI controls. → [core](/docs/core#parameters)
+- `Param.path2d(name, defaultPoints, opts?)` — Declare an editable 2D path parameter. → [core](/docs/core#parameters)
+- `Param.spline2d(name, defaultPoints, opts?)` — Declare an editable 2D spline parameter. → [core](/docs/core#parameters)
+- `Param.placement2d(name, spec)` — Declare an editable 2D placement sheet parameter. → [core](/docs/core#parameters)
 - `dim(line, opts?)` — Add a dimension annotation between two points, or along an entity. → [output](/docs/output#dim)
 
 ---