@metamesh/modeling 0.18.0 → 0.20.0

package/CHANGELOG.md

@@ -1,5 +1,87 @@
 # @metamesh/modeling
 
+## 0.20.0
+
+### Minor Changes
+
+- fe33c89: Give modeling operations, pure geometry values, numerical kernels, and mechanical calculations distinct public entry points. Import fluent values from `/geometry`, tuple and matrix kernels from `/geometry/math`, and mechanical calculations from `/geometry/mechanical`. Remove root geometry factory re-exports and ambient `matchProfiles` and thread-preflight wrappers; pure preparation accepts explicit resolution and limits exposed by the generation context.
+
+  Bounds extrema and pattern/attachment placements return fluent values. Construct anchors with one options object, project fluent vectors onto planes, and multiply raw matrices with `multiplyTransform3(left, right)`. Remove retired exports and update the SDK, CLI, Studio authoring environment, and consumers without compatibility aliases.
+
+- d5dd213: Evaluate deep Solid and Section recipe graphs with an explicit work stack, preserving native cache reuse and session ownership checks without exhausting the JavaScript call stack. Index memo output containment for dependency diagnostics instead of scanning unrelated computations. Separate parameter snapshots and part declarations from the session's memo cache state machine, remove repeated contour measurements and temporary native-coordinate copy views, and clarify allocation ownership. Align private geometry helper names with their Contour and Path representations. Restore the Engine benchmark with deep-recipe and dependency-scaling measurements.
+
+  Resolve region sampling limits once per import batch, including empty regions, and clarify memo transaction and matched-profile mesh flow.
+
+- d5dd213: Add arc-length distance/fraction stations, directed splitting and trimming, corner-preserving subdivision, and physically bounded centripetal spline paths. Unify traversal so exact interior vertices use their outgoing edge, including tangent-oriented patterns; open final endpoints retain their incoming edge. Preserve interpolation endpoints, prevent guided frame flips at bends, and reject resampling that would repeat a closed seam. Separate path distribution and rounding owners without compatibility aliases.
+
+  Preserve authored terminal vertices during endpoint queries, splitting, and trimming when a short edge falls below cumulative arc-length precision.
+
+- 52e4e07: Replace the single hole entry and screw-recess options with independent `holeCutter.openings`.
+  Share round, chamfer, smooth, and sampled profile treatments across supported construction and
+  opening geometry; add tube end finishing and reusable straight-edge/perpendicular-corner cutters.
+  Cutters preserve nominal dimensions, explicit placement, physical sampling, and host-owned limits.
+  Perpendicular round edge and corner cutters share native circular coordinates and refinement,
+  avoiding mismatched boundaries and thin Boolean stitching triangles.
+  Adaptive spheres and uniform spherical box roundovers now budget complete triangle error and edge
+  length instead of only their equatorial curves; explicit faceting overrides remain authoritative.
+- 5654590: Give every public declaration exactly one import path. Shared types remain available from their owning module; consuming entries reference those types without re-exporting them. Import all export writers from `@metamesh/modeling/export`; remove the format subpaths. Import SDK font selections from `/fonts` and Generator presets from the SDK root. Remove alternate import metadata and enforce unique source and published declaration ownership without compatibility aliases.
+- 382d312: Sweep accepts a positional path or transform array: `sweep(profile, route, options?)` or `profile.sweep(route, options?)`. Transform-driven sweeps accept only `closed` and `limits` to connect exactly the supplied affine placements without inferring rotation or refining stations. Loft stations accept exactly one `z` or `transform`; `transform` replaces `frame`.
+
+  Closed path sweeps now derive and verify cyclic seam alignment for every profile boundary. Remove `seamProfileOffset` from callers; incompatible closure still rejects.
+
+  Construct deeply immutable plain coordinate frames with `frame3({ origin, xAxis, yAxis, zAxis })`. `Transform3Input` accepts frames, affine values, and matrices through one conversion pipeline, including explicit sweep placements. Use `transform3(frame)` when affine methods are needed. Frames retain right-handed orthonormal validation, parts retain rigid-only placement, and malformed or non-finite coordinates reject before construction.
+
+- 6455ccf: Support chamfered ends on twisted extrusions, measuring normal-section setbacks on the finished
+  helical walls and preserving corner and hole correspondence. Ordinary extrusions retain their
+  native fast path. Enabled twisted end treatments support chamfers; other treatments and taper
+  with ends remain unsupported.
+
+  Breaking: replace extrusion `scaleTop` with `scale` and `divisions` with positive `slices`, counting
+  longitudinal intervals. Loft `slices` also counts intervals per supplied gap. End treatments add
+  required rings to the extrusion's requested grid. Open sweep scalar and XY `scale` now taper from
+  one to the final scale by path length; station arrays retain explicit scale control. Scale in the
+  profile's local axes before twisting, and refine untwisted sweep deformation by physical resolution.
+
+  Compiled Generators require execution protocol and runtime major 13. Rebuild packages for the new
+  binding; package format 5 is unchanged.
+
+### Patch Changes
+
+- ae34a4f: Build round stroke caps directly into their end segments to prevent clipping seams on thin diagonal lines. Sample each semicircle with the shared arc policy and account for its actual construction vertices in pure, native, and SVG strokes.
+
+## 0.19.0
+
+### Minor Changes
+
+- c9de510: Extend straight extrusion end finishing to concave outlines, holes, and disconnected regions.
+  Add independent-solid `join` with a feature datum and a smooth (default) or straight width/height
+  transition against validated planar, angled, and curved sampled support patches. Both profiles use
+  the same support, collar, and whole-volume containment proofs.
+
+  Breaking: compiled Generators require Modeling runtime major 12. Rebuild packages for the new
+  host contract; old compiled runtimes are rejected. Joining preserves the supplied operands and
+  does not promise a circular fillet radius or perform automatic placement.
+
+  Replace named lazy `computed` readers with eager `memo(fn, ...args)` values. Stable pure helpers
+  reuse immutable arguments and tracked current params/context reads, with bounded recent histories
+  and native geometry retention. Update Studio diagnostics to warn about fresh function identities.
+  All authored and compiled callers must use the new API; there is no compatibility surface.
+
+- de3d234: Add runtime-neutral STL, 3MF, and GLB export under `@metamesh/modeling/export`, with isolated
+  format entry points and backpressure-aware streaming writers. All formats consume captured local
+  geometry, placement, and appearance, with independent limits, cancellation, and structured
+  information-loss diagnostics. Standard 3MF color groups carry appearance, while base materials
+  and multiproperties retain explicit material identities independently of RGB values. These
+  properties do not assign slicer filaments or physical device trays. Add `mesh.render()` for
+  shared crease-aware display buffers that preserve exact triangle coordinates.
+
+  Breaking: remove `export3mf` and export types from `/engine`, remove SDK export request protocols
+  and `toWorldMeshes`, and return owned `Uint8Array` bytes with format metadata from the shared
+  exporters. Studio uses one export worker for every format. CLI captures use format version 3;
+  replace `run --export-3mf` with `metamesh export RUN_DIRECTORY --format 3mf --output model.3mf`.
+  Captured-run export also supports STL and GLB without rerunning source. No legacy export paths
+  or capture readers are retained.
+
 ## 0.18.0
 
 ### Minor Changes

package/README.md

@@ -1,7 +1,8 @@
 # `@metamesh/modeling`
 
-Build parametric 3D models in TypeScript. Compose immutable shapes with a fluent API, run them in
-Node or browser Workers, and work with the resulting geometry in your own application.
+Build parametric 3D models in TypeScript. Combine shapes, add holes and threads, and change the
+dimensions without rewriting the model. Run it in Node.js or a browser Worker. Use the resulting
+meshes in your own application or export them for printing.
 
 > **Preview:** `0.x` minor releases may break compatibility. Patches remain compatible within the
 > same minor line.
@@ -16,12 +17,14 @@ The package publishes ES modules only. Use Node.js 24 or newer. TypeScript consu
 TypeScript 6.0 or newer, `strict` checking, and `NodeNext` or `Bundler` module resolution.
 Browser hosts need an ES2023-compatible runtime and WebAssembly; run the engine in a Worker.
 
-Modeling works independently of Studio and the Generator SDK. Add the SDK when you need Generator
-controls and presets, Testkit for testing helpers, or the CLI for local authoring tools.
+Use Modeling on its own, or add the [Generator SDK](https://github.com/JasonKoolman/metamesh/blob/main/packages/generator-sdk/README.md)
+for controls and presets, [Testkit](https://github.com/JasonKoolman/metamesh/blob/main/packages/testkit/README.md)
+for tests, and the [CLI](https://github.com/JasonKoolman/metamesh/blob/main/packages/cli/README.md)
+to check, run, and render local source. Studio isn't required.
 
 ## Start modeling
 
-Define a plate with an adjustable width and a through hole, then build it with the engine:
+This Node.js example builds a plate with an adjustable width and a through hole:
 
 ```ts
 import { box, cylinder, generate } from "@metamesh/modeling";
@@ -39,42 +42,41 @@ const result = engine.run(model, { width: 30 }, { resolution: { maxChordError: 0
 console.log(result.bounds, result.stats.signedVolume, result.stats.generateMs);
 ```
 
-`generate` receives typed parameters and returns named parts. Use ordinary TypeScript functions,
-conditionals, and loops to organize the model. `result.parts` contains its manufacturing meshes,
-placement, colors, and measurements; `result.part("plate")` looks up a part by its semantic ID.
-Authored output uses `PartDeclaration`; completed engine output uses `ModelPart` and `ModelResult`
-from `/engine`. A completed part's top-level buffers are in world coordinates; `part.geometry`
-holds reusable local geometry.
-`stats.byteCount` counts finalized world-space position and index buffer bytes, counting shared
-buffers once; it does not measure local resources, transfer size, or total working memory.
-Both local and world-space completed measurements include `shellCount` and `edgeCount`;
-unlike optional topology analysis of arbitrary meshes, these counts are always available.
-
-Lengths use millimetres and rotations use degrees. Mesh and aggregate measurements use
-`signedVolume` in mm³ and `surfaceArea` in mm². Engine durations use `buildMs`, `finalizeMs`,
-and `generateMs`; `generateMs` includes cleanup. Physical curve resolution applies to both
-preview and manufacturing output. Browser hosts also configure the WASM asset; see the
+The generation callback reads typed values through `params` and returns named parts. Organize the
+model with ordinary TypeScript functions, conditionals, and loops. `result.part("plate")` finds the plate by its ID;
+`result.parts` contains all the completed parts, with their meshes, placement, colors, and measurements.
+
+Lengths use millimetres and rotations use degrees. `maxChordError` controls physical curve
+sampling in both preview and manufacturing output. Browser hosts also configure the WebAssembly
+asset and run the engine in a Worker; see the
 [hosting guide](https://github.com/JasonKoolman/metamesh/blob/main/apps/web/content/docs/engine/hosting.mdx).
 
 ## Modeling capabilities
 
-| Area                  | Capabilities                                                                                                          |
-| --------------------- | --------------------------------------------------------------------------------------------------------------------- |
-| Shapes and sections   | Solid primitives, filled 2D shapes with holes, Booleans, hulls, 2D offsets, splitting, and primitive edge treatments. |
-| Sweeps and surfaces   | Extrusion, revolution, sweeps, lofts with explicit profile correspondence, heightfields, and implicit surfaces.       |
-| Paths and placement   | Immutable vectors, paths, transforms, and bounds; anchors, layout, and linear, radial, grid, and path patterns.       |
-| SVG and text          | Bounded SVG fills and strokes, prepared font outlines, and vector text layout.                                        |
-| Mechanical geometry   | Printable threads, knuckle joints, gear profiles, fastener standards, and fit calculations.                           |
-| Meshes and inspection | Indexed mesh construction and conversion, measurements, spatial queries, topology checks, and bounded preflight.      |
+| Area                  | Capabilities                                                                                                                                                 |
+| --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Shapes and sections   | Solid primitives, filled 2D shapes with holes, Booleans, hulls, 2D offsets, splitting, shared edge treatments, reusable cutters, and controlled solid joins. |
+| Sweeps and surfaces   | Extrusion, revolution, sweeps, lofts with explicit profile correspondence, heightfields, and implicit surfaces.                                              |
+| Paths and placement   | Immutable vectors, paths, transforms, and bounds; anchors, layout, and linear, radial, grid, and path patterns.                                              |
+| SVG and text          | Bounded SVG fills and strokes, prepared font outlines, and vector text layout.                                                                               |
+| Mechanical geometry   | Printable threads, knuckle joints, gear profiles, fastener standards, and fit calculations.                                                                  |
+| Meshes and inspection | Indexed mesh construction and conversion, measurements, spatial queries, topology checks, and bounded preflight.                                             |
 
-The [concepts guide](https://github.com/JasonKoolman/metamesh/blob/main/apps/web/content/docs/develop/geometry-package.mdx)
+The [geometry values guide](https://github.com/JasonKoolman/metamesh/blob/main/apps/web/content/docs/develop/geometry-values.mdx)
 helps you choose a representation. The [recipes](https://github.com/JasonKoolman/metamesh/blob/main/apps/web/content/docs/develop/geometry-recipes.mdx)
 show how these capabilities fit together.
 
+Finish bodies during construction with `treatment` or `ends`. Use `holeCutter` for a bore or
+blind pocket with independent `openings.top` and `openings.bottom`: round, chamfer, smooth, or
+sampled profile treatments; circular bores also support counterbores and countersinks.
+`edgeCutter` and `cornerCutter` create explicitly placed local cuts. All cutters are ordinary
+Solid recipes for reuse with transforms, patterns, and subtraction. Keep numerical overrun
+separate from physical clearance.
+
 ## Pure triangle meshes
 
-Import the mesh module as `mesh` from `@metamesh/modeling/geometry/mesh` to construct and process triangle
-buffers without an engine:
+Use `@metamesh/modeling/geometry/mesh` when you want to construct and process triangle buffers
+without an engine:
 
 ```ts
 import { rectangleContour, transform3 } from "@metamesh/modeling/geometry";
@@ -85,24 +87,25 @@ const positioned = mesh.transform(plate, transform3().translate([10, 0, 0]));
 const facts = mesh.analyze(positioned, { requireClosed: true });
 ```
 
-Constructors return ordinary `TriangleMesh` values with `positions` and `indices`.
-`mesh.join` concatenates meshes; overlapping geometry remains overlapping.
-`mesh.optimizePlanarPatches` returns the optimized mesh and its report.
-Use `mesh.threadRidge` for a helical ridge, `mesh.threadSolid` for a complete threaded cylinder,
-and `mesh.preflightThreadSolid` for its conservative sampling and allocation estimate.
-`mesh.loft(stations)` uses direct correspondence by default, retaining the supplied seams and vertices.
+Constructors return `TriangleMesh` values with `positions` and `indices`. `mesh.join` concatenates
+buffers; it doesn't perform a solid union, so overlapping geometry remains overlapping.
+`mesh.loft(stations)` retains the supplied seams and vertices through direct correspondence by default.
+`mesh.optimizePlanarPatches` returns an optimized mesh together with its report.
 
-Use `mesh.immutable` to capture mesh buffers in computed data. Primitive contour constructors
-return frozen arrays of frozen points, suitable for explicit `computed` dependencies. To edit a
+For threads, use `mesh.threadRidge` for a helical ridge or `mesh.threadSolid` for a complete threaded
+cylinder. `mesh.preflightThreadSolid` estimates sampling and allocation before construction.
+
+Use `mesh.immutable` to capture mesh buffers in memoized data. Primitive contour constructors
+return frozen arrays of frozen points, suitable for `memo` arguments. To edit a
 contour, create owned points first: `contour.map(([x, y]) => [x, y])`.
 
 Import the mesh module directly so bundlers can remove unused operations and their dependencies.
 
 ## Reuse unchanged work
 
-Shape constructors and fluent methods create immutable recipes; they leave their inputs unchanged.
-Construction needs no engine. Generation and geometry observations run synchronously in a host
-execution, which owns native allocations and cleanup.
+Shape constructors and fluent methods create immutable recipes, leaving their inputs unchanged.
+You can declare shapes before creating an engine. The engine evaluates them during a synchronous
+run and manages native allocations and cleanup.
 
 Use shape methods for fluent modeling: `body.union(boss).subtract(bore).intersect(envelope)`.
 Each Boolean method accepts one same-dimensional shape or a readonly array; an empty array preserves
@@ -115,28 +118,31 @@ Prefer `section.extrude(options)` in a modeling sequence. Imported `extrude(prof
 `Section | CorrespondingProfile` for reusable profile functions; `revolve` and `sweep` follow the same
 convention. Use `mesh.extrude(contour, options)` for pure triangle-buffer construction.
 
-Use `engine.run()` for an isolated build and `engine.createSession()` for repeated edits that reuse
-computations. `computed` caches expensive geometry or data: read parameters inside its callback for
-automatic tracking, and list changing outer captures explicitly. Keep final part placement separate
-from local geometry to move instances without rebuilding them. Both run methods return durable
-immutable results; dispose only reusable sessions when finished. Existing results remain usable.
+Use `engine.run()` for a single build and `engine.createSession()` for repeated edits.
+Inside generation, `memo(fn, ...args)` reuses expensive pure calculations. Define helpers outside
+generation, pass immutable inputs, and pass the current `params` to track the fields a helper reads.
+Keep final part placement separate from local geometry so moving a part can reuse its mesh.
+Results are immutable and remain usable after later runs. Call `session.dispose()` when you're
+finished with a session; individual results need no disposal.
 
 Use `part(id, { geometry, transform: transform3().rotate([0, 0, 90]).translate([20, 0, 0]) })`
-for final placement. The transform accepts a fluent value or row-major 16-number matrix, including
+for final placement. The transform accepts a plain `Frame3`, fluent value, or row-major 16-number matrix, including
 pattern and attachment outputs; omission means identity. Only translation and proper rotation are
 allowed. Completed parts expose the copied frozen matrix as `part.transform`.
 
-Parameters and computed results expose `ImmutableValue<T>`: nested objects, arrays, and tuples are
-readonly, matching their captured runtime data. Copy data before editing it; fluent value methods
-and explicit buffer `copy()` methods retain their ordinary return types.
+### Parameters and validation
+
+Parameters and memo results use `ImmutableValue<T>`: nested objects, arrays, and tuples are
+readonly. Copy data before editing it. Fluent methods and explicit buffer `copy()` methods keep
+their ordinary return types.
 
 Parameters use an object map; named interfaces and nested arrays or tuples remain supported.
 Each run recaptures mutable caller data, including mutable children of frozen objects. Sessions
 reuse unchanged complex parameter identities only when their complete data graph is immutable.
-Execution checks that values are capturable data. Ordinary class instances such as `Date`, functions,
+Values must be data the engine can capture. Ordinary class instances such as `Date`, functions,
 and mutable typed arrays reject at runtime; use scalar dates, prepared services, or explicit
-`immutableBuffer` captures as appropriate. TypeScript's structural object constraint rejects scalar
-parameter types but does not prove that an arbitrary object has a plain-data prototype.
+`immutableBuffer` captures as appropriate. TypeScript types alone don't establish that an object
+contains supported data.
 
 The context's `assert` reports generation diagnostics; it does not act as a TypeScript narrowing
 assertion. When narrowing is needed, use a conditional guard such as
@@ -145,22 +151,48 @@ assertion. When narrowing is needed, use a conditional guard such as
 Use `session.check(parameters)` or standalone `checkModel(program, parameters)` to check declarations
 and reached assertions without finalizing output. Use `run()` to evaluate and finalize geometry.
 Checks return expected assertion errors and warnings; unexpected execution and geometry failures throw.
-Export captured parts with standalone `export3mf(parts, options)` from `/engine`; it needs no engine
-and never blocks generation. Export limits are explicit. Immutable result buffers support standard
-iteration and `.at(index)` for reads, or `.copy()` for owned typed arrays.
 
 See [generation and caching](https://github.com/JasonKoolman/metamesh/blob/main/apps/web/content/docs/develop/code-project-contract.mdx)
 for dependency rules, immutable data, and session ownership.
 
+## Inspect and export parts
+
+Authored parts use `PartDeclaration`; completed output uses `ModelPart` and `ModelResult` from
+`/engine`. A completed part's top-level buffers contain world coordinates; `part.geometry` holds
+reusable local geometry. Read immutable buffers through iteration or `.at(index)`, or use `.copy()`
+to get an owned typed array.
+
+Local and world-space measurements include `signedVolume` in mm³, `surfaceArea` in mm²,
+`shellCount`, and `edgeCount`. Completed parts always include the topology counts, even when
+optional topology analysis of an arbitrary mesh would omit them.
+
+Result statistics include `buildMs`, `finalizeMs`, and `generateMs`; `generateMs` includes cleanup.
+`stats.byteCount` counts finalized world-space position and index buffer bytes, counting shared
+buffers once. It doesn't measure local resources, transfer size, or total working memory.
+
+Export `result.parts` as STL, 3MF, or GLB with `@metamesh/modeling/export`. Export needs no engine.
+The [hosting guide](https://github.com/JasonKoolman/metamesh/blob/main/apps/web/content/docs/engine/exporting.mdx)
+covers saving files and choosing a format.
+
 ## API discovery and ownership
 
-| Import                                                                                                                                       | Responsibility                                                                                     |
-| -------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------- |
-| [`@metamesh/modeling`](https://github.com/JasonKoolman/metamesh/blob/main/apps/web/content/reference/generated/model/index.mdx)              | Shapes, fluent values, modeling operations, and generation programs.                               |
-| [`@metamesh/modeling/geometry`](https://github.com/JasonKoolman/metamesh/blob/main/apps/web/content/reference/generated/geometry/index.mdx)  | Pure TypeScript geometry, sampling, numerical helpers, and mesh contracts without a native engine. |
-| [`@metamesh/modeling/geometry/mesh`](https://github.com/JasonKoolman/metamesh/blob/main/apps/web/content/reference/generated/mesh/index.mdx) | Triangle mesh construction, processing, and inspection through direct `mesh.*` imports.            |
-| [`@metamesh/modeling/engine`](https://github.com/JasonKoolman/metamesh/blob/main/apps/web/content/reference/generated/engine/index.mdx)      | Host initialization, execution, resource limits, and 3MF export.                                   |
-| [`@metamesh/modeling/text`](https://github.com/JasonKoolman/metamesh/blob/main/apps/web/content/reference/generated/text/index.mdx)          | Optional font preparation and reusable vector layouts from supplied bytes.                         |
+Every public type and function has one import path. Import shared types from their owning entry;
+other entries reference those types in signatures without re-exporting them.
+
+Constructor-specific options such as `BoxOptions` live at the root. Shared pattern options such
+as `GridPatternOptions` live in `/geometry`; thread options such as `ThreadedRodOptions` live in
+`/geometry/mechanical`. Shape recipes and pure helpers consume the same shared contracts.
+
+| Import                                                                                                                                                   | Responsibility                                                                                     |
+| -------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------- |
+| [`@metamesh/modeling`](https://github.com/JasonKoolman/metamesh/blob/main/apps/web/content/reference/generated/model/index.mdx)                          | Solid and Section recipes, modeling operations, and generation programs.                           |
+| [`@metamesh/modeling/geometry`](https://github.com/JasonKoolman/metamesh/blob/main/apps/web/content/reference/generated/geometry/index.mdx)              | Immutable values, plain descriptors, profiles, regions, placement, and sampling without an engine. |
+| [`@metamesh/modeling/geometry/math`](https://github.com/JasonKoolman/metamesh/blob/main/apps/web/content/reference/generated/math/index.mdx)             | Tuple arithmetic and affine matrix kernels.                                                        |
+| [`@metamesh/modeling/geometry/mechanical`](https://github.com/JasonKoolman/metamesh/blob/main/apps/web/content/reference/generated/mechanical/index.mdx) | Pure mechanical dimensions, fit policies, standards, and preflight calculations.                   |
+| [`@metamesh/modeling/geometry/mesh`](https://github.com/JasonKoolman/metamesh/blob/main/apps/web/content/reference/generated/mesh/index.mdx)             | Triangle mesh construction, processing, and inspection through direct `mesh.*` imports.            |
+| [`@metamesh/modeling/engine`](https://github.com/JasonKoolman/metamesh/blob/main/apps/web/content/reference/generated/engine/index.mdx)                  | Host initialization, execution, and resource limits.                                               |
+| [`@metamesh/modeling/export`](https://github.com/JasonKoolman/metamesh/blob/main/apps/web/content/reference/generated/export/index.mdx)                  | STL, 3MF, and GLB export.                                                                          |
+| [`@metamesh/modeling/text`](https://github.com/JasonKoolman/metamesh/blob/main/apps/web/content/reference/generated/text/index.mdx)                      | Optional font preparation and reusable vector layouts from supplied bytes.                         |
 
 Font preparation requires the optional `fontkit` peer; add `woff2-encoder` for WOFF2 input. Models
 consume prepared layouts without fetching fonts during generation. Your host owns viewing,