@metamesh/modeling 0.18.0 → 0.19.0

package/CHANGELOG.md

@@ -1,5 +1,38 @@
 # @metamesh/modeling
 
+## 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,34 @@ 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, edge treatments, 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.
 
 ## 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 +80,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.
+
+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 computed data. Primitive contour constructors
-return frozen arrays of frozen points, suitable for explicit `computed` dependencies. To edit a
+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 +111,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
 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,13 +144,29 @@ 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/hosting.mdx#export-the-completed-result)
+covers saving files and choosing a format.
+
 ## API discovery and ownership
 
 | Import                                                                                                                                       | Responsibility                                                                                     |
@@ -159,7 +174,8 @@ for dependency rules, immutable data, and session ownership.
 | [`@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/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

package/dist/api/engine.d.ts

@@ -1,5 +1,4 @@
 import type { ImmutableTriangleMesh } from "@metamesh/modeling/geometry";
-import type { TriangleMeshInput } from "@metamesh/modeling/geometry";
 import type {
   Bounds3Data,
   GenerationDiagnostic,
@@ -147,22 +146,22 @@ export interface ModelResult {
 }
 /** Known dependencies for inspection; plain JavaScript bindings do not reveal their parameter origin. */
 export interface ModelDependencies {
-  /** Parameter keys read outside computed callbacks, affecting structure or ordinary code. */
+  /** Parameter keys read outside memo functions, affecting structure or ordinary code. */
   readonly modelParameters: readonly string[];
   /** Direct dependencies recorded by successfully evaluated computations. */
   readonly computations: readonly {
-    /** Session-local computation identity. */
+    /** Revision-local diagnostic memo identity; it is not a cache key. */
     readonly id: string;
     /** Direct top-level parameter reads. */
     readonly parameters: readonly string[];
-    /** Direct computed-reader dependencies. */
+    /** Known object-value dependencies between memo calls; scalar origins are not observable. */
     readonly computations: readonly string[];
   }[];
-  /** Part reader roots and known transitive parameter dependencies. */
+  /** Known memo origins of part geometry and placement, and their parameter dependencies. */
   readonly parts: readonly {
     /** Stable semantic output part identity. */
     readonly id: string;
-    /** Computed readers supplied as geometry or placement roots. */
+    /** Memo calls known to contribute object values to geometry or placement. */
     readonly computations: readonly string[];
     /** Known transitive parameter dependencies through these roots. */
     readonly parameters: readonly string[];
@@ -187,26 +186,6 @@ export interface ModelSession<P extends object> {
   /** Releases session ownership; idempotent, returned results remain usable. */
   dispose(): void;
 }
-/**
- * Manufacturing buffers accepted by the standalone mesh exporter.
- */
-export type ExportMeshPart = TriangleMeshInput & {
-  /** Stable canonical lowercase identity; unique within the containing topology or output. */
-  readonly id: string;
-  /** Optional six-digit hex RGB display color. */
-  readonly color?: string;
-};
-/**
- * Completed-mesh serialization settings; filename selection belongs to the host.
- */
-export interface Export3mfOptions {
-  /** Trusted export allocation and aggregate output ceilings; omitted fields use package defaults. */
-  readonly limits?: Partial<ModelingLimits>;
-  /** Optional bounded geometric solid checks on captured buffers; defaults to indexed topology validation. */
-  readonly meshValidation?: "topology" | "solid";
-  /** Document display name; defaults to MetaMesh model. */
-  readonly name?: string;
-}
 /** Kernel asset initialization. Networking and Worker ownership remain with the host. */
 export interface ModelEngineOptions {
   /** Fixed kernel WASM asset URL; defaults to the package asset. Browser hosts supply their emitted URL. */
@@ -215,27 +194,7 @@ export interface ModelEngineOptions {
   readonly limits?: Partial<ModelingLimits>;
 }
 
-/**
- * Serializes captured manufacturing meshes as millimetre 3MF without initializing an engine.
- * Captures input arrays and options before awaiting; later mutations, runs and session cleanup
- * cannot change the exported geometry. Trusted limits default to the package output ceilings.
- *
- * @example Export a pure mesh without an engine
- * ```ts
- * import { export3mf } from "@metamesh/modeling/engine";
- * import * as mesh from "@metamesh/modeling/geometry/mesh";
- * import { rectangleContour } from "@metamesh/modeling/geometry";
- * const plate = mesh.extrude(rectangleContour({ size: [30, 20] }), { height: 6 });
- * const bytes = await export3mf([{ id: "plate", ...plate }], { name: "Plate" });
- * ```
- */
-export declare function export3mf(
-  parts: readonly ExportMeshPart[],
-  options?: Export3mfOptions,
-): Promise<ArrayBuffer>;
-
 export { defaultModelingLimits };
-
 /** URL of the package's pinned WASM asset; browser bundlers may replace it with their emitted URL. */
 export declare const modelingWasmUrl: string;
 
@@ -255,7 +214,8 @@ export declare function checkModel<P extends object, S>(
  * @example Build a box in a host application
  * ```ts
  * import { box, generate } from "@metamesh/modeling";
- * import { createModelEngine, export3mf } from "@metamesh/modeling/engine";
+ * import { createModelEngine } from "@metamesh/modeling/engine";
+ * import { export3mf } from "@metamesh/modeling/export";
  *
  * const engine = await createModelEngine();
  * const model = generate<Record<never, never>>(({ part }) => [part("body", box({ size: [30, 20, 8] }))]);

package/dist/api/export-3mf.d.ts

@@ -0,0 +1,2 @@
+export { export3mf, write3mf } from "./export.js";
+export type { ExportDiagnostic, ExportFormat, ExportGeometry, ExportLimits, ExportMaterial, ExportOptions, ExportPart, ExportReport, ExportedFile, ExportSink, Export3mfOptions } from "./export.js";

package/dist/api/export-glb.d.ts

@@ -0,0 +1,2 @@
+export { exportGlb, writeGlb } from "./export.js";
+export type { ExportDiagnostic, ExportFormat, ExportGeometry, ExportLimits, ExportMaterial, ExportOptions, ExportPart, ExportReport, ExportedFile, ExportSink, ExportGlbOptions } from "./export.js";

package/dist/api/export-stl.d.ts

@@ -0,0 +1,2 @@
+export { exportStl, writeStl } from "./export.js";
+export type { ExportDiagnostic, ExportFormat, ExportGeometry, ExportLimits, ExportMaterial, ExportOptions, ExportPart, ExportReport, ExportedFile, ExportSink, ExportStlOptions } from "./export.js";

package/dist/api/export.d.ts

@@ -0,0 +1,160 @@
+import type {
+  ImmutableBuffer,
+  TriangleMeshInput,
+  Transform3Data,
+} from "@metamesh/modeling/geometry";
+
+/** Local millimetre, Z-up indexed geometry; optional unit normals describe display shading only. */
+export type ExportGeometry = TriangleMeshInput & {
+  /** One finite unit XYZ normal per position; omitted normals are derived for GLB. */
+  readonly normals?: Float32Array | ImmutableBuffer<Float32Array>;
+};
+/** A semantic part referencing reusable local geometry, with placement and appearance kept separate. */
+export interface ExportPart {
+  /** Unique canonical lowercase kebab-case identity, at most 64 characters. */
+  readonly id: string;
+  /** Local geometry; engine results and decoded Worker parts are accepted directly. */
+  readonly geometry: ExportGeometry;
+  /** Proper rigid row-major local-to-world matrix; translations are millimetres. Defaults to identity. */
+  readonly transform?: Transform3Data;
+  /** Six-digit sRGB display color; overrides the assigned material's suggested display color. */
+  readonly color?: string;
+  /** Stable print material identity from options.materials; never inferred from display color. */
+  readonly materialId?: string;
+}
+/** Portable print material intent. Equal display colors do not merge different identities. */
+export interface ExportMaterial {
+  /** Unique canonical lowercase kebab-case identity, preserved by 3MF as the base-material name. */
+  readonly id: string;
+  /** Suggested six-digit sRGB display color; does not select filament, extruder, or physical tray. */
+  readonly color: string;
+}
+/** Supported completed-mesh file formats. */
+export type ExportFormat = "3mf" | "stl" | "glb";
+/** Independent trusted export ceilings; output limits also apply to streaming writers. */
+export interface ExportLimits {
+  /** Maximum selected semantic parts. */
+  readonly maxParts: number;
+  /** Maximum aggregate input vertices across selected instances. */
+  readonly maxVertices: number;
+  /** Maximum aggregate input triangles across selected instances. */
+  readonly maxTriangles: number;
+  /** Maximum captured unique numeric buffer-view bytes, including authored normals. */
+  readonly maxBytes: number;
+  /** Maximum encoded file bytes; defaults to 512 MiB. */
+  readonly maxOutputBytes: number;
+}
+/** Shared serialization policy; hosts own scheduling, filenames, and delivery. */
+export interface ExportOptions {
+  /** Display name, one through 1024 valid XML characters; defaults to MetaMesh model. */
+  readonly name?: string;
+  /** Explicit export ceilings, independent of engine/session configuration. */
+  readonly limits?: Partial<ExportLimits>;
+  /** Topology validation by default; solid additionally checks bounded intersections and shell nesting. */
+  readonly meshValidation?: "topology" | "solid";
+  /** Portable material identities referenced by parts. No slicer or device mapping is implied. */
+  readonly materials?: readonly ExportMaterial[];
+  /** Cancellation checked between bounded writing tasks; browser hosts should schedule CPU work in a Worker. */
+  readonly signal?: AbortSignal;
+}
+/** 3MF serialization of closed manufacturing meshes in millimetres; colored output uses the standard Materials extension. */
+export type Export3mfOptions = ExportOptions;
+/** Binary STL serialization in millimetres; open triangle surfaces are permitted by default. */
+export type ExportStlOptions = ExportOptions;
+/** Uncompressed glTF 2.0 binary serialization; converts millimetres/Z-up to metres/Y-up. */
+export interface ExportGlbOptions extends ExportOptions {
+  /** Normal smoothing threshold in degrees from zero through 180; defaults to 20. Authored normals take precedence. */
+  readonly creaseAngle?: number;
+}
+/** Expected information loss imposed by the selected file format. */
+export interface ExportDiagnostic {
+  /** Stable category; human-readable wording is not an API contract. */
+  readonly code:
+    | "APPEARANCE_DROPPED"
+    | "MATERIAL_ASSIGNMENTS_DROPPED"
+    | "PART_NAMES_DROPPED";
+  /** Description of the information the selected format cannot preserve. */
+  readonly message: string;
+  /** Affected semantic part identities, in input order. */
+  readonly partIds: readonly string[];
+}
+/** Completed writer metadata; successful completion means the sink accepted every chunk. */
+export interface ExportReport {
+  /** Registered file media type. */
+  readonly mediaType: string;
+  /** File extension without a leading dot. */
+  readonly extension: ExportFormat;
+  /** Expected format losses; invalid input and failed delivery reject instead. */
+  readonly diagnostics: readonly ExportDiagnostic[];
+  /** Encoded bytes delivered to the sink. */
+  readonly byteLength: number;
+}
+/** Owned file bytes and format metadata, usable in both Node and browsers. */
+export interface ExportedFile extends ExportReport {
+  /** Fresh mutable bytes; never aliases the input snapshot. */
+  readonly bytes: Uint8Array<ArrayBuffer>;
+}
+/** Receives owned chunks in order. Writers await each call for backpressure; the host closes its destination. */
+export type ExportSink = (chunk: Uint8Array) => void | Promise<void>;
+
+/** Default standalone export policy: 64 parts, one million vertices, two million triangles, 96 MiB input, 512 MiB output. */
+export declare const defaultExportLimits: ExportLimits;
+
+/**
+ * Serializes a captured model as binary STL in millimetres and Z-up coordinates.
+ * Placement is baked into triangles. Diagnostics describe dropped names, appearance and materials.
+ * Mutable input is captured before the first await; no engine or renderer is needed.
+ */
+export declare function exportStl(
+  parts: readonly ExportPart[],
+  options?: ExportStlOptions,
+): Promise<ExportedFile>;
+/**
+ * Writes owned binary STL chunks to a sink, awaiting backpressure after each bounded chunk.
+ * The host owns sink completion and recovery after failure. Honors cancellation and output limits.
+ */
+export declare function writeStl(
+  parts: readonly ExportPart[],
+  sink: ExportSink,
+  options?: ExportStlOptions,
+): Promise<ExportReport>;
+
+/**
+ * Writes 3MF with local mesh reuse, semantic parts, rigid placement, and standard color groups.
+ * Colored output requires the Materials extension. Explicit material IDs remain distinct base-material
+ * names, combined with appearance through multiproperties; display colors never select filament.
+ * Captures mutable inputs before awaiting and awaits each owned output chunk for backpressure.
+ * The host owns destination closing and cleanup of partial output after rejection.
+ */
+export declare function write3mf(
+  parts: readonly ExportPart[],
+  sink: ExportSink,
+  options?: Export3mfOptions,
+): Promise<ExportReport>;
+/** Serializes selected completed meshes as an owned 3MF file without initializing an engine. */
+export declare function export3mf(
+  parts: readonly ExportPart[],
+  options?: Export3mfOptions,
+): Promise<ExportedFile>;
+
+/**
+ * Serializes captured local meshes as uncompressed glTF 2.0 binary, in metres and Y-up.
+ * Preserves named parts, placement, shared geometry and display appearance. Authored normals take
+ * precedence over crease-aware shading; no engine, renderer or optional compression codec is loaded.
+ */
+export declare function exportGlb(
+  parts: readonly ExportPart[],
+  options?: ExportGlbOptions,
+): Promise<ExportedFile>;
+/**
+ * Writes owned GLB chunks with backpressure, cancellation and explicit output limits.
+ * Plans accessor and container lengths before writing, then emits bounded binary chunks.
+ * Hosts own sink completion, scheduling and recovery after a partially written failure.
+ */
+export declare function writeGlb(
+  parts: readonly ExportPart[],
+  sink: ExportSink,
+  options?: ExportGlbOptions,
+): Promise<ExportReport>;
+
+/** Runtime-independent completed-mesh export. All input coordinates are millimetres, right-handed, and Z-up. @packageDocumentation */

package/dist/api/geometry.d.ts

@@ -229,8 +229,8 @@ export declare interface Bounds2 extends Bounds2Data {
  * Zero extents are valid. Invalid dimensions, nonfinite coordinates, reversed bounds and
  * overflowing extents throw `INVALID_ARGUMENT` GeometryError. Use `toData()` for plain records.
  * Size construction centers on the origin unless `center` is false. Size and extrema are exclusive.
- * Compiled Generator packages passing these values to host recipes or computed data require
- * runtime 10.0.0 or newer in major 10.
+ * Compiled Generator packages passing these values to host recipes or memo data require
+ * the current Modeling runtime.
  */
 export declare function bounds2(input: Bounds2Options | Bounds2): Bounds2;
 
@@ -286,8 +286,8 @@ export declare interface Bounds3 extends Bounds3Data {
  * Zero extents are valid. Invalid dimensions, nonfinite coordinates, reversed bounds and
  * overflowing extents throw `INVALID_ARGUMENT` GeometryError. Use `toData()` for plain records.
  * Size construction centers on the origin unless `center` is false. Size and extrema are exclusive.
- * Compiled Generator packages passing these values to host recipes or computed data require
- * runtime 10.0.0 or newer in major 10.
+ * Compiled Generator packages passing these values to host recipes or memo data require
+ * the current Modeling runtime.
  */
 export declare function bounds3(input: Bounds3Options | Bounds3): Bounds3;
 
@@ -1078,7 +1078,7 @@ export declare type EllipseContourOptions = CircularPrimitiveOptions &
   );
 
 /**
- * Independent inward finishing on primitive or straight convex extrusion ends.
+ * Independent inward finishing on primitive or source-corresponding straight extrusion ends.
  * Zero amounts leave the end untreated, including when all ends are disabled.
  */
 export declare interface EndTreatments {
@@ -1114,7 +1114,7 @@ export declare interface ExtrudeMeshOptions extends ExtrusionSamplingOptions {
 
 /** Native +Z extrusion with optional inward end treatments. */
 export declare interface ExtrudeOptions extends ExtrudeMeshOptions {
-  /** Independent inward end treatments on straight convex single-contour extrusions. */
+  /** Independent inward treatments on every material rim of a straight, topology-preserving extrusion. */
   readonly ends?: EndTreatments;
 }
 
@@ -1440,7 +1440,7 @@ export declare function immutableBuffer<T extends NumericArray>(
 
 declare const immutableBufferBrand: unique symbol;
 
-/** Immutable local XYZ positions and triangle indices, suitable for a computed value or part. */
+/** Immutable local XYZ positions and triangle indices, suitable for a memo result or part. */
 export declare interface ImmutableTriangleMesh {
   /** Packed XYZ coordinates in millimetres. */
   readonly positions: ImmutableBuffer<Float32Array>;