@metamesh/modeling 0.19.0 → 0.20.0

package/dist/docs/guides/profiles-and-extrusion.md

@@ -2,8 +2,16 @@
 
 Choose primitives, extrude filled outlines, revolve radial profiles, and finish their rims.
 
-Start with a primitive when it already describes the material. For a plate, gasket, cup, or knob,
-solve the filled cross section first, then add depth or revolve it around an axis.
+Start with a primitive when it already describes the material.
+
+
+
+**Solve the cross section first**
+
+For a plate or gasket, make the filled outline and add depth. For a cup or knob, describe its
+  radial section and revolve it. Keep the simplest representation until you need the next dimension.
+
+
 
 Run the examples in a [Studio code Project](https://metamesh.studio/docs/develop/code-projects), where Studio supplies
 typed controls and prepared services. For a local model, follow the
@@ -18,7 +26,8 @@ separate named part so you can inspect it in the interactive preview.
 
 
 ```ts
-import { ellipse, regularPolygon, sphere, star, torus, transform3, tube } from "@metamesh/modeling";
+import { ellipse, regularPolygon, sphere, star, torus, tube } from "@metamesh/modeling";
+import { transform3 } from "@metamesh/modeling/geometry";
 import { generate } from "@metamesh/project";
 
 export default generate(({ part }) => {
@@ -90,7 +99,7 @@ export default generate(({ part }) => {
   // Positive offset expands material: the outer edge grows and the hole shrinks.
   const rimmedPlate = plate.subtract(hole).offset(1.2);
   // Keep the plate centered about Z = 0 for later symmetric placement.
-  return [part("model", rimmedPlate.extrude({ height: 5, center: true }))];
+  return part("model", rimmedPlate.extrude({ height: 5, center: true }));
 });
 ```
 
@@ -104,8 +113,15 @@ must have the same dimension. Use collection `union(shapes)` or `intersect(shape
 `section.offset(distance)` offsets the filled material. `section.extrude({ height })` preserves
 holes and places the bottom at zero unless `center: true` is requested.
 
-Ordinary extrusion also accepts `twist` and `scaleTop`. Keep those operations separate from
-enabled end treatments, which require a straight extrusion.
+`twist` rotates the top around +Z in degrees. `scale` sets its final scale factor: `0.5` finishes at half
+size, while `[0.5, 1]` halves profile-local X and preserves Y. Scale factors interpolate from one
+with height and apply before twist. Uniform `scale: 0` closes a single simple outline at an apex; holes
+and disconnected islands cannot share that apex. Negative scales and a pair with only one zero
+component reject.
+
+Use physical `resolution` for ordinary quality control. Explicit `slices: 20` selects 20 longitudinal
+intervals and 21 layers before end treatments. Chamfered ends can follow a twist; enabled end
+treatments require unit `scale` and insert additional rings where needed.
 
 Positive offset grows material on every boundary: this example grows the outside by `1.2 mm` and
 reduces the hole radius from `4 mm` to `2.8 mm`. If the final bore must remain `8 mm` in diameter,
@@ -138,7 +154,7 @@ export default generate(({ part }) => {
     [0, 4],
   ]);
   // A full revolution creates the floor, tapered wall, and open top together.
-  return [part("model", wall.revolve())];
+  return part("model", wall.revolve());
 });
 ```
 
@@ -183,7 +199,7 @@ export default generate(({ part }) => {
     spacing: [13, 12],
   });
   // Mirror the completed housing across the plane with normal +X.
-  return [part("model", housing.subtract(perforations).mirror([1, 0, 0]))];
+  return part("model", housing.subtract(perforations).mirror([1, 0, 0]));
 });
 ```
 
@@ -202,7 +218,87 @@ feature can remain in the options object when switched off.
 The bores use `diameter: [8, 6]` and `13 × 12 mm` spacing to leave material between them. Check
 the widest cutter diameter and the outer wall when changing either value. In this example the
 tool's top chamfer lies above the housing; it shapes the cutter end, not the finished hole's rim.
-Use an explicitly shaped cutting profile if the finished mouth needs a countersink.
+Use `holeCutter.openings` when the finished mouth needs a roundover, chamfer, or screw seat.
+
+## Shape openings and local edges
+
+
+
+```ts
+import { box, cornerCutter, edgeCutter, holeCutter, tube } from "@metamesh/modeling";
+import { transform3 } from "@metamesh/modeling/geometry";
+import { generate } from "@metamesh/project";
+
+const treatment = { kind: "round", radius: 2 } as const;
+const edge = (length: number) => edgeCutter({ length, treatment });
+
+// Three matching edges and their corner share the positive XYZ material octant.
+const plate = box({ size: [40, 24, 8], center: false }).subtract([
+  edge(8),
+  edge(40).rotate([0, -90, 0]).translate([40, 0, 0]),
+  edge(24).rotate([90, 0, 0]).translate([0, 24, 0]),
+  cornerCutter({ treatment }),
+  holeCutter({
+    diameter: 10,
+    height: 8,
+    sizing: "face",
+    openings: {
+      top: { kind: "round", radius: 1 },
+      bottom: { kind: "smooth", distance: 0.5 },
+    },
+    // Numerical overlap is independent of the nominal bore and mouth dimensions.
+    overrun: { top: 0.05, bottom: 0.05 },
+  }).translate([24, 12, 0]),
+]);
+
+const sleeve = tube({
+  outerDiameter: 20,
+  innerDiameter: 12,
+  height: 8,
+  center: false,
+  ends: {
+    top: { kind: "round", radius: 0.75 },
+    bottom: { kind: "chamfer", distance: 0.4 },
+  },
+});
+
+export default generate(({ part }) => [
+  part("plate", { geometry: plate, transform: transform3().translate([-20, -12, 0]) }),
+  part("sleeve", { geometry: sleeve, transform: transform3().translate([32, 0, 0]) }),
+]);
+```
+
+Opening treatments widen the mouth while preserving the bore. Explicit edge and corner cutters remove local material; tube ends finish both rims.
+
+
+
+`holeCutter` accepts a circular `diameter` or an existing Section `profile`. Its nominal interval
+is Z=0 to `height`. Set `openings.top` and `openings.bottom` independently with the shared
+`round`, `chamfer`, `smooth`, or sampled `profile` treatments. Circular openings also accept
+`counterbore` and `countersink`, using explicit seat dimensions. Each end accepts one treatment.
+For blind pockets, leave the floor end plain and extend only the open end.
+
+The first treatment setback widens the mouth; the second reaches into the hole along its axis.
+Both opening depths must leave a positive untreated throat. Circular roundovers use a radius
+in the radial/axial section. Treated Section pockets require one strictly convex contour without
+holes; plain and zero-treated pockets accept arbitrary Section topology.
+
+`overrun` extends the terminal cross section beyond the nominal end without changing the
+opening dimensions. Both extensions default to zero. Set overrun independently from the
+clearance already included in the bore or pocket dimensions.
+
+`edgeCutter` places the sharp reference edge at XY=0 and runs along +Z from zero to `length`.
+The material wedge runs counterclockwise from +X through `angle` degrees (default 90).
+Use existing transforms, anchors, and patterns to position the cutter, then subtract it.
+`cornerCutter` complements matching cuts where three perpendicular material faces meet in the
+positive XYZ octant. It accepts a spherical `round` or equal-setback `chamfer`; arbitrary edge
+profiles do not define a unique three-face corner surface. Numerical `excess` extends outside
+the reference faces and defaults to 0.05 mm, independently of the finished treatment.
+Perpendicular round edges and spherical corners use a common native sampling lattice. Matching
+treatments meet on the same vertices; full-circle facet requests round up to a multiple of four.
+
+These cutters use explicit construction datums. They do not select edges in an existing mesh or
+infer the mating surface. Keep each complete treatment inside the intended local material.
 
 ## Finish a profile with a hole
 
@@ -240,13 +336,65 @@ Finishing options share `round` (radius), `chamfer` (setbacks), `smooth` (cubic
 `profile` points:
 
 - Boxes select disjoint named edges or groups; rectangles select individual corners.
-- Cylinder/frustum and straight extrusion rims use independent `ends.bottom` and `ends.top`.
+- Cylinder/frustum, tube, and straight extrusion rims use independent `ends.bottom` and `ends.top`.
+  Tube end treatments finish both the outer rim and bore mouth and must retain a positive wall.
 - Straight extrusions admit concave outlines, holes, and disconnected material components when
   every source boundary survives the treatment without contact, collapse, or topology changes.
   One treatment applies to every material boundary at that end; inward material trimming expands
-  hole mouths. Enabled treatments exclude twist, top scaling, and exact divisions.
+  hole mouths. Enabled treatments require unit `scale`. Explicit `slices` controls the base
+  longitudinal grid; treatment and refinement rings may increase the final layer count.
 - Zero radius, zero chamfer/smooth distance, or an all-zero distance pair leaves a feature untreated.
   Other setback pairs require two positive values; negative and nonfinite amounts reject.
 - Disabled extrusion end treatments retain ordinary support, including holes and twist.
 
 For a local connection between completed solids, use [solid joins](solid-joins.md).
+
+## Chamfer a twisted extrusion
+
+
+
+```ts
+import { rectangle } from "@metamesh/modeling";
+import { transform3 } from "@metamesh/modeling/geometry";
+import { generate } from "@metamesh/project";
+
+const core = rectangle({ size: 20 });
+const sleeve = rectangle({ size: 27 }).subtract(rectangle({ size: 20.7 }));
+const chamfer = { kind: "chamfer", distance: 0.7 } as const;
+const options = {
+  height: 70,
+  twist: 180,
+  slices: 20,
+  ends: { bottom: chamfer, top: chamfer },
+  resolution: { maxChordError: 0.025 },
+};
+
+export default generate(({ part }) => [
+  part("core", { geometry: core.extrude(options), color: "#E9B45D" }),
+  part("sleeve", {
+    geometry: sleeve.extrude(options),
+    color: "#2D8490",
+    transform: transform3().translate([40, 0, 0]),
+  }),
+]);
+```
+
+Chamfer the finished twisted rims, including the sleeve bore, through the same extrusion options.
+
+
+
+Build the sleeve's complete filled section before extrusion. The same `ends` options finish its
+outside and bore, preserving matching corners without separate cutters or independently offset lofts.
+
+For a chamfer, `distance: 0.7` sets equal setbacks on the cap and the finished wall. A pair sets
+`[cap, wall]`. The wall distance is measured from the rim in a normal section through the helical
+wall; it is a straight-line distance, rather than axial depth or surface arc length. Equal distances
+give 45° on perpendicular walls; a twisted wall can give a different angle around the rim.
+
+Twisted ends support `chamfer`. Rounded, smooth, and custom-profile ends require zero twist.
+Use `maxChordError` and optional `maxSegmentLength` for physical sampling. `slices` selects the
+base longitudinal intervals; additional treatment rings and physical refinement resolve the rim.
+Without explicit `slices`, extrusion resolution chooses the base schedule. This example requests
+20 intervals and lets the chamfer add the rings it needs.
+Keep enough material between the two ends and between neighboring boundaries. Large twists over
+a short chamfer collar can fold normal sections and reject; reduce the twist or the setback.

package/dist/docs/guides/recipes.md

@@ -1,35 +1,128 @@
 # Modeling recipes
 
-Choose a worked modeling technique for profiles, sweeps, placement, joins, SVG, text, or inspection.
+Choose an illustrated construction technique by the part you want to make.
 
-Choose the result you want to make, then open its worked guide. Illustrated examples pair a
-rendered model with the source executed by the optional interactive preview.
+Choose the shape or feature you need. Each guide pairs rendered geometry with the checked source
+that creates it, explains the important constraints, and links to the exact API.
 
-Run the examples in a [Studio code Project](https://metamesh.studio/docs/develop/code-projects), where Studio supplies
-controls and prepared services. For local execution, follow the
-[standalone workflow](standalone-model.md) and use its host entry point.
+New to Modeling? [Start with a complete part](https://metamesh.studio/docs/modeling#start-with-one-part), then return here
+when you want to build a different shape.
 
 ## Choose a technique
 
-| You want to                                                          | Start with                                                                              |
-| -------------------------------------------------------------------- | --------------------------------------------------------------------------------------- |
-| Choose between filled shapes, boundary points, and matching profiles | [Geometry values and representations](geometry-values.md)                    |
-| Make a plate, gasket, cup, or treated housing                        | [Profiles, primitives, extrusion, and revolution](profiles-and-extrusion.md) |
-| Route a tube, connect cross sections, or build a relief              | [Sweeps, lofts, and heightfields](sweeps-and-lofts.md)                       |
-| Place repeated features or align mating parts                        | [Transforms, patterns, and anchors](transforms-and-placement.md)             |
-| Blend or bevel a mounting feature into a base                        | [Solid joins](solid-joins.md)                                                |
-| Turn artwork or lettering into material                              | [SVG and exact-font text](svg-and-text.md)                                   |
-| Choose curve detail and check dimensions or topology                 | [Resolution and inspection](resolution-and-inspection.md)                    |
-| Make a threaded rod and matching nut                                 | [Printable threads](https://metamesh.studio/docs/develop/printable-threads)                                    |
-| Coordinate a pinion, wheel, or rack                                  | [Gear geometry](https://metamesh.studio/docs/develop/gear-geometry)                                            |
-
-## Adapt and check
-
-All dimensions are millimetres, angles are degrees, and +Z is up. Begin with ordinary synchronous
-generation, then add [memoization](generation.md#reuse-unchanged-work) when
-expensive work can stay unchanged across parameter edits.
-
-Connect the source to [controls and validation](https://metamesh.studio/docs/develop/parameters-and-validation). Check
-the default, supported extremes, and optional features; inspect the latest result before
-[exporting it](https://metamesh.studio/docs/use/export-3mf). For manufacturing fit, verify a representative part with
-the material and process you intend to use.
+
+
+
+### [Profiles and extrusion](profiles-and-extrusion.md)
+
+Outline → solid
+
+Extrude plates and gaskets, revolve cups, and finish housings and rims.
+
+![A tapered cup with an open top and closed floor](https://metamesh.studio/docs/develop/section-revolve.webp)
+
+
+
+
+
+### [Sweeps, lofts, and reliefs](sweeps-and-lofts.md)
+
+Path or stations → solid
+
+Route a ribbon, blend changing profiles, or sample a surface over an XY grid.
+
+![A transition between rounded rectangular sections](https://metamesh.studio/docs/develop/section-loft.webp)
+
+
+
+
+
+### [Transforms and placement](transforms-and-placement.md)
+
+One feature → coordinated parts
+
+Repeat features, share placements, and align parts by their anchors.
+
+![A radial hub with six repeated arms](https://metamesh.studio/docs/develop/primitive-array.webp)
+
+
+
+
+
+### [Solid joins](solid-joins.md)
+
+Base + feature → connection
+
+Connect a separately modeled boss or rib with a smooth or straight transition.
+
+![A mounting boss blended into a flat base](https://metamesh.studio/docs/develop/solid-join.webp)
+
+
+
+
+
+### [SVG and lettering](svg-and-text.md)
+
+Artwork → material
+
+Extrude painted SVG shapes or exact-font lettering and fit the visible outlines.
+
+![A scalloped badge with a star-shaped opening](https://metamesh.studio/docs/develop/svg-document-extrusion.webp)
+
+
+
+
+
+### [Printable threads](https://metamesh.studio/docs/develop/printable-threads)
+
+Shared dimensions → mating parts
+
+Make a threaded rod and nut with shared profiles, end treatments, and fit allowances.
+
+![A threaded rod and matching nut](https://metamesh.studio/docs/modeling-guides/printable-threads/threaded-parts.webp)
+
+
+
+
+
+### [Gear geometry](https://metamesh.studio/docs/develop/gear-geometry)
+
+Pitch + tooth count → gear pair
+
+Resolve dimensions, sample tooth outlines, and place a pinion, wheel, or rack.
+
+![A golden pinion and blue wheel with meshing teeth](https://metamesh.studio/docs/develop/gear-pair.webp)
+
+
+
+
+
+### [Resolution and inspection](resolution-and-inspection.md)
+
+Model → checked result
+
+Choose physical curve detail, understand preflight guarantees, and inspect completed geometry.
+
+![A sampled relief tile with a rippled surface](https://metamesh.studio/docs/develop/heightfield.webp)
+
+
+
+
+For vectors, sampled
+boundaries, and profile correspondence, read [geometry values](geometry-values.md).
+
+## Run and adapt an example
+
+The guides identify their execution host. Most use a [Studio code Project](https://metamesh.studio/docs/develop/code-projects),
+where Studio supplies typed controls and prepared services. A [standalone model](standalone-model.md)
+uses the same shape operations with generation imported from `@metamesh/modeling`.
+
+1. Read the model beside its source, then inspect its optional interactive preview when orientation
+   or separate parts matter.
+2. Adapt the dimensions and connect them to [controls and validation](https://metamesh.studio/docs/develop/parameters-and-validation).
+3. Check the defaults, supported extremes, and optional features with
+   [resolution and inspection](resolution-and-inspection.md) before [exporting](https://metamesh.studio/docs/use/export-3mf).
+
+Keep expensive unchanged work in [memoized helpers](generation.md#reuse-unchanged-work)
+once the basic construction works. Mechanical fit needs a representative physical test as well as
+valid generated geometry.

package/dist/docs/guides/resolution-and-inspection.md

@@ -10,8 +10,8 @@ does not establish a suitable manufacturing fit.
 
 MetaMesh uses a right-handed coordinate system with **+Z up**. Authored dimensions and curve
 tolerances are millimetres; angular arguments such as `rotate` use degrees.
-Pure [`rotate2`](../reference/geometry/rotate2.md) and transform-value rotations also take degrees.
-The low-level [`rotationTransform3`](../reference/geometry/rotationTransform3.md) constructor
+Pure [`rotate2`](../reference/math/rotate2.md) and transform-value rotations also take degrees.
+The low-level [`rotationTransform3`](../reference/math/rotationTransform3.md) constructor
 requires an explicit `{ degrees }` or `{ radians }` angle.
 
 `GeometryResolution` controls sampled curves in physical space. Defaults are a `0.05 mm` maximum
@@ -44,21 +44,31 @@ different things, so read what its report covers:
   SVG geometry, returning a normalized region and import diagnostics. Its counts measure the region
   at the selected resolution; they do not predict later mesh allocation.
 
-The `/geometry` and `mesh` preflights run without an engine and use explicit options or package defaults.
-The root [`preflightThreadedRod`](../reference/model/preflightThreadedRod.md),
-[`preflightInternalThreadCutter`](../reference/model/preflightInternalThreadCutter.md), and
-[`preflightThreadedNut`](../reference/model/preflightThreadedNut.md) require active synchronous
-model execution and use the host's resolution and limits.
+Preflights are pure calculations: they run without an engine and use explicit options or package
+defaults. Threaded-part preflights live in `/geometry/mechanical`, including
+[`preflightThreadedRod`](../reference/mechanical/preflightThreadedRod.md),
+[`preflightInternalThreadCutter`](../reference/mechanical/preflightInternalThreadCutter.md), and
+[`preflightThreadedNut`](../reference/mechanical/preflightThreadedNut.md).
 
-Passing a preflight covers only its documented checks. Construction can still fail while running
-callbacks, meshing, or evaluating native geometry. Constructors enforce their limits even when
-you skip a preflight; use one when its plan or diagnostics help you make a decision.
+Inside generation, pass the callback's effective `resolution` and `limits` to a preflight or
+[`matchProfiles`](../reference/geometry/matchProfiles.md) when its sampling and work budget must
+agree with the host. A pure helper never reads an ambient session.
+
+
+
+**Preflight is a plan, not a finished part**
+
+Passing covers only the report's documented checks. Callbacks, meshing, or native evaluation can
+  still fail. Run representative inputs and inspect the completed geometry.
+
+
+
+Constructors enforce their limits even when you skip preflight. Use a report when its sampling
+plan or diagnostics help you make a decision.
 
 ## Lifecycle and inspection
 
-Studio or your standalone host handles initialization, cleanup, finalization, Worker recovery,
-preview, and file delivery. Don't manually delete `Section` or `Solid` values. Use
-`shape.inspect()` for bounds, topology counts, area, and volume.
+Use `shape.inspect()` for bounds, topology counts, area, and volume.
 Its immutable extrema are nested under `facts.bounds.min` and `facts.bounds.max`.
 Native `componentCount` counts disconnected material components. Mesh analysis and signatures use
 `shellCount` for surfaces connected by shared indexed edges: one sealed hollow body has one material
@@ -88,21 +98,25 @@ same queries inside its synchronous generation callback:
 
 
 ```ts
-import { box } from "@metamesh/modeling";
+import { box, cylinder } from "@metamesh/modeling";
 import { generate } from "@metamesh/project";
 
 export default generate(({ part }) => {
-  const result = box({ size: [40, 30, 5] });
-  const measurements = result.inspect();
+  const plate = box({ size: [40, 30, 5] });
+  const bore = cylinder({ diameter: 10, height: 7 });
+  const result = plate.subtract(bore);
+  const facts = result.inspect();
 
-  if (measurements.bounds.min[2] < -2.5 || measurements.componentCount !== 1) {
-    throw new Error("Unexpected placement or disconnected result.");
+  if (facts.bounds.min[2] !== -2.5 || facts.componentCount !== 1) {
+    throw new Error("Expected one connected plate centered on Z.");
   }
 
-  return [part("model", result)];
+  return part("plate", result);
 });
 ```
 
+Inspect the cut block during generation, then return the same checked geometry as a part.
+
 
 
 Use [`layoutRow`](../reference/geometry/layoutRow.md) to arrange pieces along +X with an explicit
@@ -112,21 +126,27 @@ returned translations in `part` placement options so you can reuse the geometry.
 
 
 ```ts
-import { box, generate, transform3 } from "@metamesh/modeling";
-import { layoutRow } from "@metamesh/modeling/geometry";
+import { box, generate } from "@metamesh/modeling";
+import { layoutRow, transform3 } from "@metamesh/modeling/geometry";
 
-export const rowModel = generate<Record<never, never>>(({ part }) => {
+export default generate<Record<never, never>>(({ part }) => {
   const pieces = [box({ size: [20, 10, 6] }), box({ size: [12, 16, 8] })];
   const positions = layoutRow(
     pieces.map((piece) => piece.inspect().bounds),
     { gap: 4 }
   );
   return pieces.map((geometry, index) =>
-    part(`piece-${index}`, { geometry, transform: transform3().translate(positions[index]!) })
+    part(`piece-${index}`, {
+      geometry,
+      transform: transform3().translate(positions[index]!),
+      color: index === 0 ? "#f6ad55" : "#60a5fa",
+    })
   );
 });
 ```
 
+Use each part’s evaluated bounds to place its geometry along +X with a deliberate gap.
+
 
 
 Check the default, smallest and largest supported dimensions, and every optional feature after

package/dist/docs/guides/solid-joins.md

@@ -31,7 +31,7 @@ const feature = cylinder({
     cylinder({ diameter: 4, height: 16, center: false }).rotate([90, 0, 0]).translate([0, 8, 12])
   )
   // Boolean geometry defines its own datum; the collar below the cross-bore stays straight.
-  .withAnchors({ mount: anchor3([0, 0, 2], [0, 0, -1]) });
+  .withAnchors({ mount: anchor3({ position: [0, 0, 2], direction: [0, 0, -1] }) });
 
 const mount = base.join(feature, {
   source: "mount",
@@ -50,6 +50,15 @@ and a straight collar remains below the cross-bore. The Boolean-composed feature
 `mount` datum with its outward normal pointing toward the base. `source: "mount"` resolves that
 datum when the join evaluates, so the completed recipe can be declared before an engine exists.
 
+
+
+**Place the feature before joining**
+
+A join adds the root transition to an already positioned feature. Check the collar and support
+  requirements below; joining does not close a gap or move the feature into place.
+
+
+
 The result has no inherited anchors. Define result datums with `withAnchors` when later work needs them.
 
 ## Define the connection
@@ -83,7 +92,8 @@ must be positive, or both zero to disable added blending while still validating
 
 
 ```ts
-import { box, transform3 } from "@metamesh/modeling";
+import { box } from "@metamesh/modeling";
+import { transform3 } from "@metamesh/modeling/geometry";
 import { generate } from "@metamesh/project";
 
 const base = box({ size: [24, 20, 4] });

package/dist/docs/guides/standalone-model.md

@@ -22,6 +22,8 @@ export default generate<Record<never, never>>(({ part }) => {
 });
 ```
 
+The centered 6 mm plate is cut by an 8 mm tall cylinder so the hole crosses both faces.
+
 
 
 The cutter extends beyond both faces of the centered plate. `part("plate", ...)` gives the output
@@ -29,7 +31,7 @@ a stable ID so you can identify the plate in the result. This model takes an emp
 
 ## Check and run
 
-With [Modeling and the CLI installed](https://metamesh.studio/docs/develop/agent-authoring#install-and-discover-the-environment),
+With [Modeling and the CLI installed](https://metamesh.studio/docs/develop/cli#install-and-discover-the-environment),
 check the source and generate a captured result:
 
 ```bash
@@ -37,7 +39,7 @@ pnpm exec metamesh typecheck model.ts --kind model
 pnpm exec metamesh run model.ts --kind model
 ```
 
-Continue with [inspection and rendering](https://metamesh.studio/docs/develop/agent-authoring#inspect-the-captured-result),
+Continue with [inspection and rendering](https://metamesh.studio/docs/develop/cli#inspect-the-captured-result),
 or [host the program in your application](hosting.md).
 When you're ready for a different shape, the
 [construction chooser](recipes.md#choose-a-technique) helps you pick an approach.