@metamesh/modeling 0.18.0 → 0.20.0

package/dist/api/engine.d.ts

@@ -1,19 +1,129 @@
-import type { ImmutableTriangleMesh } from "@metamesh/modeling/geometry";
-import type { TriangleMeshInput } from "@metamesh/modeling/geometry";
 import type {
+  Anchor3,
+  AttachOptions,
+  Bounds2Data,
+  Bounds3,
   Bounds3Data,
-  GenerationDiagnostic,
+  Bounds3Input,
+  ChamferedEdgeTreatment,
+  CircularPrimitiveOptions,
+  Contour,
+  CurveSamplingOptions,
+  EdgeTreatment,
+  ExtrusionSamplingOptions,
+  Frame3,
   GeometryResolution,
+  GeometrySamplingLimits,
+  GeometryToleranceOptions,
+  ImmutableBuffer,
   ModelingLimits,
-  ModelProgram,
+  NumericArray,
+  Path3,
+  Path3Data,
+  Path3Input,
+  PathLocation,
+  PathNormalGuide,
+  PathResamplingOptions,
+  PathStation,
+  PathSubdivisionOptions,
+  Pivot2Options,
+  Pivot3Options,
+  PolygonData,
+  ProfiledEdgeTreatment,
+  RegionData,
+  ResolvedGeometryResolution,
+  RoundedEdgeTreatment,
+  SmoothEdgeTreatment,
+  Transform2,
+  Transform2Data,
+  Transform2Input,
+  Transform3,
   Transform3Data,
-  TriangleMeshTopologyAnalysis,
+  Transform3Input,
+  Vector2,
+  Vector2Data,
+  Vector2Input,
+  Vector3,
+  Vector3Data,
+  Vector3Input,
+} from "@metamesh/modeling/geometry";
+import type {
+  DiagnosticOptions,
+  EndTreatments,
+  ExtrudeOptions,
+  GenerateCallback,
+  GenerateContext,
+  GenerationDiagnostic,
+  ImmutableValue,
+  JoinOptions,
+  JoinTransition,
+  Memo,
+  ModelProgram,
+  PartDeclaration,
+  PartGeometry,
+  PartOptions,
+  PlaneOptions,
+  RevolveOptions,
+  Section,
+  SectionInspection,
+  SectionOffsetJoin,
+  SectionOffsetOptions,
+  Solid,
+  SolidInspection,
+  SolidSegmentHit,
+  SweepOptions,
+  SweepOrientation,
+  SweepTransformOptions,
 } from "@metamesh/modeling";
-/** Default host resource ceilings for parts, vertices, triangles, and transferable bytes. */
-declare const defaultModelingLimits: Readonly<ModelingLimits>;
+import type {
+  ExtrudeMeshOptions,
+  ImmutableTriangleMesh,
+  TriangleMesh,
+  TriangleMeshAnalysis,
+  TriangleMeshMeasurements,
+  TriangleMeshTopologyAnalysis,
+} from "@metamesh/modeling/geometry/mesh";
+
+/**
+ * Runs declaration and immediate assertions without initializing a kernel or finalizing parts.
+ * Returns reached assertion errors and warnings; unexpected execution failures throw.
+ * Returned geometry is not realized or validated.
+ * Geometry observations require an initialized session's `check` method instead.
+ *
+ * @param program - Model declaration to check without evaluating geometry.
+ * @param args - Parameters, then session options; include any required services.
+ */
+export declare function checkModel<P extends object, S>(
+  program: ModelProgram<P, S>,
+  ...args: ModelRunArguments<P, S, SessionOptions<S>>
+): readonly GenerationDiagnostic[];
+
+/**
+ * Initializes one host kernel; runs and sessions own native cleanup.
+ *
+ * @param options - WASM URL and engine resource limits.
+ *
+ * @example Build a box in a host application
+ * ```ts
+ * import { box, generate } from "@metamesh/modeling";
+ * 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] }))]);
+ * const result = engine.run(model);
+ * await export3mf(result.parts);
+ * ```
+ */
+export declare function createModelEngine(
+  options?: ModelEngineOptions,
+): Promise<ModelEngine>;
+
+/** Default engine ceilings, shared with predictable pure mesh constructor preflights. */
+export declare const defaultModelingLimits: ModelingLimits;
 
 /** Execution settings supplied by the host, independently of generator metadata. */
-export interface GenerationOptions {
+export declare interface GenerationOptions {
   /** Optional bounded intersection and nested-shell checks; defaults to indexed topology validation. */
   readonly meshValidation?: "topology" | "solid";
   /** Per-build limits, no larger than the configured engine ceilings. */
@@ -23,10 +133,45 @@ export interface GenerationOptions {
   /** Optional bounded planar cleanup; unsupported candidates preserve the original part. */
   readonly meshTopologyMode?: "original" | "optimized";
 }
-/**
- * Host engine. No native values or manually disposable handles are exposed.
- */
-export interface ModelEngine {
+
+/** Validated local geometry resource with stable immutable numeric storage. */
+export declare interface GeometryResource extends ImmutableTriangleMesh {
+  /** Session-scoped immutable resource identity, stable while geometry is reused. */
+  readonly id: string;
+  /** Immutable resource revision; a new resource receives a new identity. */
+  readonly revision: number;
+  /** Facts and indexed topology counts for the exact local manufacturing buffers. */
+  readonly measurements: TriangleMeshTopologyAnalysis;
+}
+
+declare const immutableBufferBrand: unique symbol;
+
+/** Known dependencies for inspection; plain JavaScript bindings do not reveal their parameter origin. */
+export declare interface ModelDependencies {
+  /** 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 {
+    /** Revision-local diagnostic memo identity; it is not a cache key. */
+    readonly id: string;
+    /** Direct top-level parameter reads. */
+    readonly parameters: readonly string[];
+    /** Known object-value dependencies between memo calls; scalar origins are not observable. */
+    readonly computations: readonly string[];
+  }[];
+  /** Known memo origins of part geometry and placement, and their parameter dependencies. */
+  readonly parts: readonly {
+    /** Stable semantic output part identity. */
+    readonly id: string;
+    /** 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[];
+  }[];
+}
+
+/** Host engine. No native values or manually disposable handles are exposed. */
+export declare interface ModelEngine {
   /** Immutable resource ceilings selected when this engine was initialized. */
   readonly limits: ModelingLimits;
   /** Runs once with isolated ownership and returns durable immutable data; no disposal is required. */
@@ -46,54 +191,18 @@ export interface ModelEngine {
         ]
   ): ModelSession<P>;
 }
-/** Generation policy and prepared synchronous capabilities for one host execution. */
-export interface ModelRunOptions<
-  S = Record<never, never>,
-> extends GenerationOptions {
-  /** Host-owned synchronous capabilities, required when declared by the program. The original
-   * environment is retained; its behavior and assets must remain deterministic and fixed for
-   * this session. Equivalent function wrappers do not constitute an asset revision.
-   */
-  readonly services?: S;
-}
-/** Fixed argument positions; infer parameters from the program, allow empty maps to be omitted, and require declared services. */
-export type ModelRunArguments<
-  P extends object,
-  S,
-  Options extends ModelRunOptions<S> = ModelRunOptions<S>,
-> = keyof S extends never
-  ? Record<never, never> extends P
-    ? [parameters?: NoInfer<Readonly<P>>, options?: Options]
-    : [parameters: NoInfer<Readonly<P>>, options?: Options]
-  : [
-      parameters:
-        | NoInfer<Readonly<P>>
-        | (Record<never, never> extends P ? undefined : never),
-      options: Options & {
-        /** Prepared synchronous capabilities required by this program. */
-        readonly services: S;
-      },
-    ];
-/** Fixed generation policy and reusable computation caches for one model session. */
-export interface SessionOptions<
-  S = Record<never, never>,
-> extends ModelRunOptions<S> {
-  /** Enables reuse; defaults to true. Set false for uncached output equivalence checks. */
-  readonly cache?: boolean;
-  /** Development-only cache-hit probe: reruns pure callbacks and compares bounded data/recipes.
-   * Unsupported closures or large results fail explicitly; this cannot prove arbitrary JavaScript.
-   */
-  readonly verifyCache?: boolean;
-}
-/** Validated local geometry resource with stable immutable numeric storage. */
-export interface GeometryResource extends ImmutableTriangleMesh {
-  /** Session-scoped immutable resource identity, stable while geometry is reused. */
-  readonly id: string;
-  /** Immutable resource revision; a new resource receives a new identity. */
-  readonly revision: number;
-  /** Facts and indexed topology counts for the exact local manufacturing buffers. */
-  readonly measurements: TriangleMeshTopologyAnalysis;
+
+/** Kernel asset initialization. Networking and Worker ownership remain with the host. */
+export declare interface ModelEngineOptions {
+  /** Fixed kernel WASM asset URL; defaults to the package asset. Browser hosts supply their emitted URL. */
+  readonly wasmUrl?: string;
+  /** Trusted application ceilings. Builds may lower them; generators receive no engine. */
+  readonly limits?: Partial<ModelingLimits>;
 }
+
+/** URL of the package's pinned WASM asset; browser bundlers may replace it with their emitted URL. */
+export declare const modelingWasmUrl: string;
+
 /**
  * A world-space manufacturing part plus its reusable local renderer resource.
  * Top-level positions and indices already include transform; do not apply it again.
@@ -101,7 +210,7 @@ export interface GeometryResource extends ImmutableTriangleMesh {
  *
  * Buffer properties are stable immutable values. Use copy() explicitly for mutable storage.
  */
-export interface ModelPart extends ImmutableTriangleMesh {
+export declare interface ModelPart extends ImmutableTriangleMesh {
   /** Stable semantic identity. */
   readonly id: string;
   /** Optional six-digit hexadecimal display color. */
@@ -113,8 +222,9 @@ export interface ModelPart extends ImmutableTriangleMesh {
   /** Immutable rigid local-to-world row-major 4x4 matrix; translation uses millimetres. */
   readonly transform: Transform3Data;
 }
+
 /** Durable immutable generation data, independent of session lifetime. */
-export interface ModelResult {
+export declare interface ModelResult {
   /** Exact axis-aligned world bounds in millimetres. */
   readonly bounds: Bounds3Data;
   /** Aggregate manufacturing facts in millimetres and engine execution timings in milliseconds. */
@@ -145,31 +255,39 @@ export interface ModelResult {
   /** Known dependency graph; outer reads remain conservative model-wide dependencies. */
   readonly dependencies: ModelDependencies;
 }
-/** 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. */
-  readonly modelParameters: readonly string[];
-  /** Direct dependencies recorded by successfully evaluated computations. */
-  readonly computations: readonly {
-    /** Session-local computation identity. */
-    readonly id: string;
-    /** Direct top-level parameter reads. */
-    readonly parameters: readonly string[];
-    /** Direct computed-reader dependencies. */
-    readonly computations: readonly string[];
-  }[];
-  /** Part reader roots and known transitive parameter dependencies. */
-  readonly parts: readonly {
-    /** Stable semantic output part identity. */
-    readonly id: string;
-    /** Computed readers supplied as geometry or placement roots. */
-    readonly computations: readonly string[];
-    /** Known transitive parameter dependencies through these roots. */
-    readonly parameters: readonly string[];
-  }[];
+
+/** Fixed argument positions; infer parameters from the program, allow empty maps to be omitted, and require declared services. */
+export declare type ModelRunArguments<
+  P extends object,
+  S,
+  Options extends ModelRunOptions<S> = ModelRunOptions<S>,
+> = keyof S extends never
+  ? Record<never, never> extends P
+    ? [parameters?: NoInfer<Readonly<P>>, options?: Options]
+    : [parameters: NoInfer<Readonly<P>>, options?: Options]
+  : [
+      parameters:
+        | NoInfer<Readonly<P>>
+        | (Record<never, never> extends P ? undefined : never),
+      options: Options & {
+        /** Prepared synchronous capabilities required by this program. */
+        readonly services: S;
+      },
+    ];
+
+/** Generation policy and prepared synchronous capabilities for one host execution. */
+export declare interface ModelRunOptions<
+  S = Record<never, never>,
+> extends GenerationOptions {
+  /** Host-owned synchronous capabilities, required when declared by the program. The original
+   * environment is retained; its behavior and assets must remain deterministic and fixed for
+   * this session. Equivalent function wrappers do not constitute an asset revision.
+   */
+  readonly services?: S;
 }
+
 /** Stateful execution owner; a failed revision cannot change previously returned results. */
-export interface ModelSession<P extends object> {
+export declare interface ModelSession<P extends object> {
   /** Generates durable immutable data or throws; parameters are copied and frozen. Empty parameters may be omitted. */
   run(
     ...args: Record<never, never> extends P
@@ -187,83 +305,21 @@ 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. */
-  readonly wasmUrl?: string;
-  /** Trusted application ceilings. Builds may lower them; generators receive no engine. */
-  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>;
+declare const sectionBrand: unique symbol;
 
-export { defaultModelingLimits };
+/** Fixed generation policy and reusable computation caches for one model session. */
+export declare interface SessionOptions<
+  S = Record<never, never>,
+> extends ModelRunOptions<S> {
+  /** Enables reuse; defaults to true. Set false for uncached output equivalence checks. */
+  readonly cache?: boolean;
+  /** Development-only cache-hit probe: reruns pure callbacks and compares bounded data/recipes.
+   * Unsupported closures or large results fail explicitly; this cannot prove arbitrary JavaScript.
+   */
+  readonly verifyCache?: boolean;
+}
 
-/** URL of the package's pinned WASM asset; browser bundlers may replace it with their emitted URL. */
-export declare const modelingWasmUrl: string;
+declare const solidBrand: unique symbol;
 
-/**
- * Runs declaration and immediate assertions without initializing a kernel or finalizing parts.
- * Returns reached assertion errors and warnings; unexpected execution failures throw.
- * Returned geometry is not realized or validated.
- * Geometry observations require an initialized session's `check` method instead.
- */
-export declare function checkModel<P extends object, S>(
-  program: ModelProgram<P, S>,
-  ...args: ModelRunArguments<P, S, SessionOptions<S>>
-): readonly GenerationDiagnostic[];
-/**
- * Initializes one host kernel and returns a lifecycle-safe engine. No generator initializes WASM.
- *
- * @example Build a box in a host application
- * ```ts
- * import { box, generate } from "@metamesh/modeling";
- * import { createModelEngine, export3mf } from "@metamesh/modeling/engine";
- *
- * const engine = await createModelEngine();
- * const model = generate<Record<never, never>>(({ part }) => [part("body", box({ size: [30, 20, 8] }))]);
- * const result = engine.run(model);
- * await export3mf(result.parts);
- * ```
- */
-export declare function createModelEngine(
-  options?: ModelEngineOptions,
-): Promise<ModelEngine>;
-export type { ModelingLimits };
+export {};

package/dist/api/export.d.ts

@@ -0,0 +1,204 @@
+import type {
+  ImmutableBuffer,
+  NumericArray,
+  Transform3Data,
+} from "@metamesh/modeling/geometry";
+import type {
+  ImmutableTriangleMesh,
+  TriangleMesh,
+  TriangleMeshInput,
+} from "@metamesh/modeling/geometry/mesh";
+/** Runtime-independent completed-mesh export. All input coordinates are millimetres, right-handed, and Z-up. @packageDocumentation */
+
+/** Default standalone export policy: 64 parts, one million vertices, two million triangles, 96 MiB input, 512 MiB output. */
+export declare const defaultExportLimits: ExportLimits;
+
+/**
+ * Serializes selected completed meshes as an owned 3MF file without initializing an engine.
+ *
+ * @param parts - Closed, outward-wound parts in output order, with local geometry in millimetres.
+ */
+export declare function export3mf(
+  parts: readonly ExportPart[],
+  options?: Export3mfOptions,
+): Promise<ExportedFile>;
+
+/** 3MF serialization of closed manufacturing meshes in millimetres; colored output uses the standard Materials extension. */
+export declare type Export3mfOptions = ExportOptions;
+
+/** Expected information loss imposed by the selected file format. */
+export declare 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[];
+}
+
+/** Owned file bytes and format metadata, usable in both Node and browsers. */
+export declare interface ExportedFile extends ExportReport {
+  /** Fresh mutable bytes; never aliases the input snapshot. */
+  readonly bytes: Uint8Array<ArrayBuffer>;
+}
+
+/** Supported completed-mesh file formats. */
+export declare type ExportFormat = "3mf" | "stl" | "glb";
+
+/** Local millimetre, Z-up indexed geometry; optional unit normals describe display shading only. */
+export declare type ExportGeometry = TriangleMeshInput & {
+  /** One finite unit XYZ normal per position; omitted normals are derived for GLB. */
+  readonly normals?: Float32Array | ImmutableBuffer<Float32Array>;
+};
+
+/**
+ * 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.
+ *
+ * @param parts - Parts in output order, with local geometry in millimetres and Z-up.
+ */
+export declare function exportGlb(
+  parts: readonly ExportPart[],
+  options?: ExportGlbOptions,
+): Promise<ExportedFile>;
+
+/** Uncompressed glTF 2.0 binary serialization; converts millimetres/Z-up to metres/Y-up. */
+export declare interface ExportGlbOptions extends ExportOptions {
+  /** Normal smoothing threshold in degrees from zero through 180; defaults to 20. Authored normals take precedence. */
+  readonly creaseAngle?: number;
+}
+
+/** Independent trusted export ceilings; output limits also apply to streaming writers. */
+export declare 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;
+}
+
+/** Portable print material intent. Equal display colors do not merge different identities. */
+export declare 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;
+}
+
+/** Shared serialization policy; hosts own scheduling, filenames, and delivery. */
+export declare 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;
+}
+
+/** A semantic part referencing reusable local geometry, with placement and appearance kept separate. */
+export declare 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;
+}
+
+/** Completed writer metadata; successful completion means the sink accepted every chunk. */
+export declare 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;
+}
+
+/**
+ * Receives chunks in order. Writers await each call; the host closes its destination.
+ *
+ * @param chunk - Bytes the sink owns and may retain or transfer.
+ */
+export declare type ExportSink = (chunk: Uint8Array) => void | Promise<void>;
+
+/**
+ * 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.
+ *
+ * @param parts - Parts in output order, with local geometry in millimetres.
+ */
+export declare function exportStl(
+  parts: readonly ExportPart[],
+  options?: ExportStlOptions,
+): Promise<ExportedFile>;
+
+/** Binary STL serialization in millimetres; open triangle surfaces are permitted by default. */
+export declare type ExportStlOptions = ExportOptions;
+
+declare const immutableBufferBrand: unique symbol;
+
+/**
+ * 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.
+ *
+ * @param parts - Closed, outward-wound parts in output order.
+ * @param sink - Receives each chunk; return a promise to pause writing.
+ */
+export declare function write3mf(
+  parts: readonly ExportPart[],
+  sink: ExportSink,
+  options?: Export3mfOptions,
+): Promise<ExportReport>;
+
+/**
+ * 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.
+ *
+ * @param parts - Parts in output order; mutable geometry is copied before writing.
+ * @param sink - Receives each chunk; return a promise to pause writing.
+ */
+export declare function writeGlb(
+  parts: readonly ExportPart[],
+  sink: ExportSink,
+  options?: ExportGlbOptions,
+): Promise<ExportReport>;
+
+/**
+ * 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.
+ *
+ * @param parts - Parts in output order; mutable geometry is copied before writing.
+ * @param sink - Receives each chunk; return a promise to pause writing.
+ */
+export declare function writeStl(
+  parts: readonly ExportPart[],
+  sink: ExportSink,
+  options?: ExportStlOptions,
+): Promise<ExportReport>;
+
+export {};