forgecad 0.10.5 → 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
@@ -358,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
 ```
@@ -395,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. |

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/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). *(64 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. *(28 functions)*
-- **[C11: Parameterization & UI](#c11-parameterization-ui)** — Declare user-facing controls that drive model geometry. *(6 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)*
@@ -182,6 +182,11 @@ Convert a 2D profile into a 3D solid (extrude, revolve, loft, sweep).
 - `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)
@@ -282,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)
 
 ---