@metamesh/modeling 0.15.0 → 0.16.0

package/dist/geometry/mechanical/thread-solids.js

@@ -96,11 +96,30 @@ export const resolveCompensatedThreadSolidMesh = (options, role) => {
     });
 };
 const preflightCompensatedThreadSolid = (options, role) => preflightHelicalThreadSolidMesh(resolveCompensatedThreadSolidMesh(options, role).meshOptions);
-/** Preflights the exact compensated direct mesh used by the threaded rod constructor. */
+/**
+ * Resolves compensated rod dimensions and checks conservative mesh estimates against output limits.
+ *
+ * This pure operation uses explicit resolution and limits or package defaults, without an active
+ * host execution. It creates planning data without mesh buffers or native objects; returned row
+ * and triangle counts are estimates. Mesh validity and native construction are checked later.
+ *
+ * @see {@link preflightHelicalThreadSolidMesh}
+ * @see {@link helicalThreadSolidMesh}
+ */
 export function preflightThreadedRodSolid(options) {
     return preflightCompensatedThreadSolid(options, "male");
 }
-/** Preflights the exact extended mesh used by the internal thread cutter constructor. */
+/**
+ * Resolves compensated cutter dimensions and checks extended mesh estimates against output limits.
+ *
+ * This pure operation uses explicit resolution and limits or package defaults, without an active
+ * host execution. It includes the cutter's one-pitch extension beyond each requested face and
+ * creates planning data without mesh buffers or native objects. Row and triangle counts are
+ * estimates; mesh validity and native construction are checked later.
+ *
+ * @see {@link preflightHelicalThreadSolidMesh}
+ * @see {@link helicalThreadSolidMesh}
+ */
 export function preflightInternalThreadCutterSolid(options) {
     return preflightCompensatedThreadSolid(options, "female");
 }
@@ -222,8 +241,14 @@ export const resolveThreadedNutSolid = (options, operation) => {
     });
 };
 /**
- * Resolves a nut's exact body/cutter chamfer and preflights its extended thread mesh without
- * allocating Manifold WASM objects.
+ * Checks nut dimensions, chamfers, end-face wall, and the extended compensated cutter's allocation plan.
+ *
+ * This pure operation uses explicit resolution and limits or package defaults, without an active
+ * host execution. It resolves body/cutter dimensions without mesh buffers or native objects.
+ * `thread` contains conservative cutter estimates, excluding the body and Boolean result.
+ * Successful preflight leaves mesh validity, native construction, and manufacturing fit to later checks.
+ *
+ * @see {@link preflightHelicalThreadSolidMesh}
  */
 export function preflightThreadedNutSolid(options) {
     return resolveThreadedNutSolid(options, "preflightThreadedNutSolid").preflight;

package/dist/geometry/mesh/mesh-centroid.js

@@ -2,6 +2,7 @@ import { GeometryError } from "../errors.js";
 import { analyzeTriangleMesh } from "./mesh.js";
 /**
  * Computes the uniform-density volume centroid of an oriented closed solid, including cavity shells.
+ *
  * Coordinates are millimetres. Indexed closure and positive aggregate volume are required; callers
  * may use validateSolidMesh first when geometric intersections and shell orientation are untrusted.
  * Fresh mutable input is inspected on every call, and buffers are never changed.

package/dist/geometry/mesh/mesh-solid.js

@@ -7,6 +7,7 @@ const MAXIMUM_TRIANGLES = 200_000;
 const MAXIMUM_TESTS = 2_000_000;
 /**
  * Checks closed indexed topology, triangle intersections, and alternating nested shell orientation.
+ *
  * Outward exterior shells and inward cavity shells are accepted. Separate shells must not touch,
  * intersect, or overlap as material. Indexed neighbours may share their own vertex or edge.
  *

package/dist/geometry/paths/frames.js

@@ -50,6 +50,7 @@ const transportNormal = (normal, previousTangent, tangent) => {
 };
 /**
  * Builds rotation-minimizing frames by parallel-transporting the previous normal.
+ *
  * This avoids the sudden profile flips produced by picking a fresh up-vector per ring.
  * Paths exceeding maxPathPoints (default 100000) reject before frame allocation or guide evaluation.
  * Requires open path values; raw tuples are interpreted as an open path. Invalid paths throw GeometryError.

package/dist/geometry/paths/helix.js

@@ -2,6 +2,7 @@ import { GeometryError } from "../errors.js";
 import { assertSamplingCount, resolveGeometrySamplingLimits, } from "../sampling-limits.js";
 /**
  * Creates `segments + 1` points including exact helix endpoints from finite positive dimensions.
+ *
  * Integrated weights must remain finite. The maxPathPoints ceiling defaults to 100000; excessive
  * exact counts reject before evaluating axial weights or allocating sample arrays.
  * Invalid inputs use GeometryError; exceptions thrown by axialWeight propagate unchanged.

package/dist/geometry/paths/path-value.js

@@ -1,10 +1,11 @@
+import { bounds2, bounds3 } from "../bounds-value.js";
 import { GeometryError } from "../errors.js";
 import { immutableMathClass } from "../math/immutable-value.js";
 import { vector2, vector2Data, vector3, vector3Data, } from "../math/vector-value.js";
 import { assertSamplingCount, resolveGeometrySamplingLimits, } from "../sampling-limits.js";
 import { transformPath2, transformPath3 } from "../transform-geometry.js";
 import { closestPointOnValidatedPath } from "./closest-point.js";
-import { resamplePath2Data, resamplePath3Data } from "./resampling.js";
+import { resamplePath2Points, resamplePath3Points } from "./resampling.js";
 const fail = (message, code = "INVALID_ARGUMENT") => {
     throw new GeometryError(code, message, { operation: "path" });
 };
@@ -19,9 +20,13 @@ function freezePoints(points) {
         Object.freeze(point);
     return Object.freeze(points);
 }
-function frozenArray(owner) {
+function frozenData(owner) {
     const state = stateOf(owner);
-    return (state.array ??= freezePoints(state.points.map((point) => [...point])));
+    return (state.data ??= Object.freeze({
+        dimension: owner.dimension,
+        closed: owner.closed,
+        points: freezePoints(state.points.map((point) => [...point])),
+    }));
 }
 function closedOption(closed) {
     if (closed !== undefined && typeof closed !== "boolean")
@@ -60,23 +65,25 @@ function validateClosure(points, closed) {
 function pathSource(input, closed, dimension) {
     if (Array.isArray(input))
         return { points: input, closed: closedOption(closed) };
-    if (typeof input !== "object" ||
-        input === null ||
-        !("toArray" in input) ||
-        typeof input.toArray !== "function" ||
-        !("closed" in input) ||
-        !("dimension" in input) ||
-        input.dimension !== dimension)
-        return fail("Expected a path or an array of coordinate tuples or vectors.");
-    if (typeof input.closed !== "boolean")
-        fail("Path closure metadata must be a boolean.");
-    const sourceClosed = input.closed;
+    if (typeof input !== "object" || input === null)
+        return fail("Expected a path value, path data, or an array of vectors.");
+    const own = pathStates.get(input);
+    const method = Reflect.get(input, "toData");
+    const data = own !== undefined
+        ? input
+        : typeof method === "function"
+            ? Reflect.apply(method, input, [])
+            : input;
+    if (typeof data !== "object" || data === null)
+        return fail("Expected complete path data.");
+    const sourceDimension = Reflect.get(data, "dimension");
+    const sourceClosed = Reflect.get(data, "closed");
+    const points = own?.points ?? Reflect.get(data, "points");
+    if (sourceDimension !== dimension || typeof sourceClosed !== "boolean" || !Array.isArray(points))
+        return fail("Path data requires matching dimension, boolean closure, and an array of vectors.");
     if (closed !== undefined && closedOption(closed) !== sourceClosed)
         fail("The closed option conflicts with the path's closure.");
-    const points = pathStates.get(input)?.points ?? input.toArray();
-    if (!Array.isArray(points))
-        fail("Path points must be an array of coordinate tuples or vectors.");
-    return { points, closed: sourceClosed };
+    return { points: points, closed: sourceClosed };
 }
 function measuredLength(owner) {
     const state = stateOf(owner);
@@ -106,7 +113,9 @@ function measuredBounds(points) {
             max[axis] = Math.max(max[axis], point[axis]);
         }
     }
-    return Object.freeze({ min: Object.freeze(min), max: Object.freeze(max) });
+    return min.length === 2
+        ? bounds2({ min: [min[0], min[1]], max: [max[0], max[1]] })
+        : bounds3({ min: [min[0], min[1], min[2]], max: [max[0], max[1], max[2]] });
 }
 function samplingOptions(options, closed) {
     if (typeof options !== "object" || options === null || Array.isArray(options))
@@ -123,8 +132,8 @@ const PlanarPath = /* @__PURE__ */ immutableMathClass(class PlanarPath {
         pathStates.set(this, { points });
         Object.freeze(this);
     }
-    toArray() {
-        return frozenArray(this);
+    toData() {
+        return frozenData(this);
     }
     length() {
         return measuredLength(this);
@@ -144,7 +153,7 @@ const PlanarPath = /* @__PURE__ */ immutableMathClass(class PlanarPath {
     }
     resample(options = {}) {
         const policy = samplingOptions(options, this.closed);
-        return new PlanarPath(resamplePath2Data(points2(this), policy), this.closed);
+        return new PlanarPath(resamplePath2Points(points2(this), policy), this.closed);
     }
 });
 const SpatialPath = /* @__PURE__ */ immutableMathClass(class SpatialPath {
@@ -155,8 +164,8 @@ const SpatialPath = /* @__PURE__ */ immutableMathClass(class SpatialPath {
         pathStates.set(this, { points });
         Object.freeze(this);
     }
-    toArray() {
-        return frozenArray(this);
+    toData() {
+        return frozenData(this);
     }
     length() {
         return measuredLength(this);
@@ -176,16 +185,19 @@ const SpatialPath = /* @__PURE__ */ immutableMathClass(class SpatialPath {
     }
     resample(options = {}) {
         const policy = samplingOptions(options, this.closed);
-        return new SpatialPath(resamplePath3Data(points3(this), policy), this.closed);
+        return new SpatialPath(resamplePath3Points(points3(this), policy), this.closed);
     }
 });
 /**
  * Snapshots finite XY coordinates as an immutable sampled path, independent of engine initialization.
+ *
  * Open paths may be empty or have one point; closed paths need three vertices and omit a duplicated
  * seam. Repeated adjacent vertices are retained. No winding normalization or filling is performed.
  * Malformed dimensions or topology throw INVALID_ARGUMENT; nonfinite coordinates or measurement
  * overflow throw NON_FINITE_VALUE; exhausted allocation ceilings throw COMPLEXITY_LIMIT GeometryError.
  * A path input retains its closure. Limits bound construction only; resampling takes its own limits.
+ *
+ * Use `toData()` for a frozen record that restores coordinates, closure, and dimension together.
  */
 export function path2(input, options = {}) {
     validateOptions(options);
@@ -198,6 +210,10 @@ export function path2(input, options = {}) {
 /**
  * Snapshots finite XYZ coordinates as an immutable sampled path with the same closure, seam,
  * allocation and error rules as path2. Analytic curves must be sampled explicitly first.
+ *
+ * Use `toData()` for a frozen record that restores coordinates, closure, and dimension together.
+ *
+ * @see {@link path2} for shared construction rules.
  */
 export function path3(input, options = {}) {
     validateOptions(options);
@@ -233,7 +249,7 @@ export function path2InputData(input, closed, limits) {
     assertSamplingCount(source.points.length, "path", policy.maxPathPoints);
     return {
         points: input instanceof PlanarPath
-            ? input.toArray()
+            ? input.toData().points
             : freezePoints(snapshot(source.points, 2, policy)),
         closed: source.closed,
     };
@@ -245,7 +261,7 @@ export function path3InputData(input, closed, limits) {
     assertSamplingCount(source.points.length, "path", policy.maxPathPoints);
     return {
         points: input instanceof SpatialPath
-            ? input.toArray()
+            ? input.toData().points
             : freezePoints(snapshot(source.points, 3, policy)),
         closed: source.closed,
     };

package/dist/geometry/paths/resampling.js

@@ -126,7 +126,7 @@ export function resamplePolyline2(path, options = {}) {
     return resamplePolyline(path, 2, options, createPlanarSampleWriter);
 }
 /** Internal points-only writer; Path2 owns these mutable coordinates and freezes public interchange. */
-export function resamplePath2Data(path, options) {
+export function resamplePath2Points(path, options) {
     const points = [];
     return resamplePolyline(path, 2, options, () => ({
         append: (point) => {
@@ -136,7 +136,7 @@ export function resamplePath2Data(path, options) {
     }), false);
 }
 /** Internal points-only writer; avoids calculating and allocating tangents discarded by Path3. */
-export function resamplePath3Data(path, options) {
+export function resamplePath3Points(path, options) {
     const points = [];
     return resamplePolyline(path, 3, options, () => ({
         append: (point) => {

package/dist/geometry/patterns/placements.js

@@ -28,9 +28,9 @@ const finite = (value, operation) => {
 const coordinates = (input, operation) => {
     const value = typeof input === "object" &&
         input !== null &&
-        "toArray" in input &&
-        typeof input.toArray === "function"
-        ? input.toArray()
+        "toData" in input &&
+        typeof input.toData === "function"
+        ? input.toData()
         : input;
     if (!Array.isArray(value) || (value.length !== 2 && value.length !== 3))
         fail(operation, "Pattern vectors require exact XY or XYZ coordinates.");

package/dist/geometry/patterns.js

@@ -16,7 +16,9 @@ export function gridPatternTransforms(options) {
     return transforms(gridPatternPlan(options));
 }
 /**
- * Equal physical arc-length placements along a sampled XYZ path. Tangent orientation maps +Z
+ * Equal physical arc-length placements along a sampled XYZ path.
+ *
+ * Tangent orientation maps +Z
  * onto the local path tangent; fixed orientation only translates. Closed paths omit a repeated seam.
  * Explicit sampling ceilings bound both input points and output placements.
  */

package/dist/geometry/profiles/contour.js

@@ -9,6 +9,7 @@ function invalid(message) {
 }
 /**
  * Samples 2–32 connected line/cubic segments into a simple, nonzero-area, immutable CCW XY loop.
+ *
  * Physical scaling precedes adaptive curve sampling; the final end must repeat start exactly.
  * Shared anchors and the closing seam are emitted once. Winding normalization may change the
  * starting vertex. The sampled loop is checked for self-intersection and degeneracy by

package/dist/geometry/profiles/matched.js

@@ -64,6 +64,7 @@ const contours = (component) => [
 ];
 /**
  * Explicitly matches identified component/contour/span topology across a family.
+ *
  * Every paired span uses the maximum physical subdivision count requested by any member.
  * Cubics share a checked uniform parameter grid, including grids selected by exact paired requests.
  * Input order and winding are preserved. Collapsed spans retain repeated logical slots, which

package/dist/geometry/profiles/rectangle.js

@@ -79,7 +79,11 @@ export function rectangleCornerSegments(corner, limits) {
     }) / 4);
 }
 /**
- * Creates an immutable CCW rectangle loop. Round radius zero is square; tangent saturated endpoints occur once.
+ * Creates an immutable sampled CCW rectangle boundary. Round radius zero is square; tangent saturated endpoints occur once.
+ *
+ * Use [rectangle](/docs/reference/model/rectangle) for a filled Section.
+ *
+ * @see {@link rectangleProfile} for identified edge/corner spans used by matchProfiles.
  *
  * @example Rounded rectangle outline
  * ```ts
@@ -148,6 +152,11 @@ export function rectangleContour(options) {
 /**
  * Creates an identified rectangle whose edge/corner spans survive zero and saturated round radii. Outer winding is CCW.
  *
+ * Use [rectangle](/docs/reference/model/rectangle) for a filled Section.
+ *
+ * @see {@link matchProfiles} to sample a family with shared landmark correspondence.
+ * @see {@link rectangleContour} for sampled boundary coordinates.
+ *
  * @example Retain rectangle landmarks
  * ```ts
  * rectangleProfile({ size: [30, 20], treatment: { kind: "round", radius: 3 } });

package/dist/geometry/profiles/side-profile.js

@@ -23,6 +23,7 @@ function distanceToChord(point, start, end) {
 }
 /**
  * Samples 1–31 line/cubic segments into a deeply immutable open [radius,height] polyline.
+ *
  * Anchors must progress strictly upward; nonnegative-radius cubic controls must have ordered
  * heights between their endpoints. Cubics use de Casteljau subdivision with a conservative
  * control-hull chord-error bound. Lines also obey the optional physical edge-length ceiling.
@@ -138,6 +139,7 @@ export function sampleSideProfile(curve, options = {}) {
 }
 /**
  * Closes an open, strictly upward [radius, height] side outline to the radius-zero axis.
+ *
  * Adds horizontal bottom/top edges at the endpoint heights, retaining axis endpoints once.
  * Returns a counterclockwise filled-boundary contour without a repeated seam vertex.
  * Radii must be nonnegative; the result must enclose nonzero area without touching itself.

package/dist/geometry/svg-import.js

@@ -476,7 +476,7 @@ function measureSvgRegion(region) {
  *
  * @param svg - Complete SVG XML source, limited to 256 KiB of UTF-8.
  * @param options - Physical flattening and viewport-origin controls.
- * @returns The exact normalized region used for import plus bounded review metrics and repairs.
+ * @returns The normalized sampled region plus bounded review metrics and repairs.
  * @throws {@link GeometryError} When XML, supported-feature, geometry, or complexity checks fail.
  */
 function createSvgRegionPreflight(svg, options = {}) {
@@ -643,11 +643,17 @@ function createSvgRegionPreflight(svg, options = {}) {
     });
 }
 /**
- * Preflights bounded SVG geometry without browser or Manifold dependencies.
+ * Parses and validates bounded SVG input, constructing its normalized sampled region and diagnostics.
+ *
+ * This pure operation performs curve flattening, fill and stroke construction, and polygon union;
+ * it needs no browser or engine. Geometry counts measure the returned region at the selected
+ * resolution, rather than predicting later mesh allocation. The region may be empty; tiny-island
+ * and short-edge indicators do not establish manufacturability or later solid validity.
  *
  * @param svg - Complete SVG XML source, limited to 256 KiB of UTF-8.
  * @param options - Physical flattening and viewport-origin controls.
  * @returns The canonical normalized region plus bounded source, topology, and safe-repair facts.
+ * @throws {@link GeometryError} When XML, supported-feature, geometry, or complexity checks fail.
  */
 export function preflightSvgRegion(svg, options = {}) {
     return createSvgRegionPreflight(svg, options);

package/dist/geometry/sweeps/options.js

@@ -18,7 +18,7 @@ export function resolveSweepScales(scale, stationCount) {
     };
     if (scale === undefined ||
         typeof scale === "number" ||
-        (typeof scale === "object" && scale !== null && "toArray" in scale) ||
+        (typeof scale === "object" && scale !== null && "toData" in scale) ||
         (Array.isArray(scale) && typeof scale[0] === "number")) {
         const value = pair(scale ?? 1);
         return Array.from({ length: stationCount }, () => value);

package/dist/geometry/text-fitting.js

@@ -6,6 +6,7 @@ function fail(message) {
 }
 /**
  * Uniformly fits visible text ink inside finite XY bounds, centering it on the target.
+ *
  * Transforms retained vector paths before sampling, so later textSection/sampleTextContours
  * resolution remains in final millimetres. Logical advances scale without translation;
  * line count is unchanged. The input layout is preserved.

package/dist/geometry/transform-matrix.js

@@ -2,7 +2,7 @@ import { GeometryError } from "./errors.js";
 export function readTransformMatrix(input, dimension) {
     let matrix = input;
     if (typeof input === "object" && input !== null && !Array.isArray(input)) {
-        const method = Reflect.get(input, "toMatrix");
+        const method = Reflect.get(input, "toData");
         if (typeof method === "function")
             matrix = Reflect.apply(method, input, []);
     }

package/dist/geometry/{transform-chain.js → transform-value.js}

@@ -89,7 +89,7 @@ const Placement3 = /* @__PURE__ */ immutableMathClass(class Placement3 {
     applyNormal(normal) {
         return vector3(applyNormal(this, this.matrix, vector3Data(normal)));
     }
-    toMatrix() {
+    toData() {
         return this.matrix;
     }
     to2D() {
@@ -101,7 +101,7 @@ const Placement2 = /* @__PURE__ */ immutableMathClass(class Placement2 {
     matrix;
     constructor(spatial) {
         this.spatial = spatial;
-        this.matrix = restrictTransform3(spatial.toMatrix());
+        this.matrix = restrictTransform3(spatial.toData());
         Object.freeze(this);
     }
     translate(offset) {
@@ -124,15 +124,15 @@ const Placement2 = /* @__PURE__ */ immutableMathClass(class Placement2 {
         return new Placement2(this.spatial.inverse());
     }
     applyPoint(point) {
-        return vector2(xy(applyValidatedTransformPoint3(this.spatial.toMatrix(), xyz(vector2Data(point)))));
+        return vector2(xy(applyValidatedTransformPoint3(this.spatial.toData(), xyz(vector2Data(point)))));
     }
     applyDirection(direction) {
-        return vector2(xy(applyValidatedTransformDirection3(this.spatial.toMatrix(), xyz(vector2Data(direction)))));
+        return vector2(xy(applyValidatedTransformDirection3(this.spatial.toData(), xyz(vector2Data(direction)))));
     }
     applyNormal(normal) {
-        return vector2(xy(applyNormal(this, this.spatial.toMatrix(), xyz(vector2Data(normal)))));
+        return vector2(xy(applyNormal(this, this.spatial.toData(), xyz(vector2Data(normal)))));
     }
-    toMatrix() {
+    toData() {
         return this.matrix;
     }
     to3D() {
@@ -140,33 +140,42 @@ const Placement2 = /* @__PURE__ */ immutableMathClass(class Placement2 {
     }
 });
 /**
- * Creates an immutable XY transform, identity by default. Matrices are copied and validated.
+ * Creates an immutable XY transform, identity by default.
+ *
+ * Values and data are copied and validated.
  * Pass it directly to Section.transform() and planar data helpers; to3D() explicitly crosses into XYZ.
  * Zero scales and singular matrices throw GeometryError; negative scales reflect.
  *
+ * Use `toData()` for frozen matrix interchange.
+ *
  * @example
  * ```ts
  * const placement = transform2().rotate(90).translate([10, 0]);
- * placement.applyPoint([1, 0]).toArray(); // approximately [10, 1]
+ * placement.applyPoint([1, 0]).toData(); // approximately [10, 1]
  * ```
  */
-export function transform2(matrix) {
-    return new Placement2(matrix === undefined
+export function transform2(input) {
+    return new Placement2(input === undefined
         ? new Placement3(IDENTITY_TRANSFORM3)
-        : new Placement3(embedTransform2(matrix)));
+        : new Placement3(embedTransform2(readTransformMatrix(input, 2))));
 }
 /**
- * Creates an immutable XYZ transform, identity by default. Matrices are copied and validated.
+ * Creates an immutable XYZ transform, identity by default.
+ *
+ * Values and data are copied and validated.
  * Calls apply in written order; rotations use degrees and pivots use current world coordinates.
  * Zero scales, singular matrices, nonfinite inputs and zero rotation axes throw GeometryError.
  * Use frameTransform3(frame) as the input for existing orthonormal frame placement.
  *
+ * Use `toData()` for frozen matrix interchange.
+ * [composeTransform3](/docs/reference/geometry/composeTransform3) takes matrices in after, before order.
+ *
  * @example
  * ```ts
  * const placement = transform3().rotate([0, 0, 90]).translate([10, 0, 0]);
- * placement.applyPoint([1, 0, 0]).toArray(); // approximately [10, 1, 0]
+ * placement.applyPoint([1, 0, 0]).toData(); // approximately [10, 1, 0]
  * ```
  */
-export function transform3(matrix = IDENTITY_TRANSFORM3) {
-    return new Placement3(snapshotTransform3(matrix));
+export function transform3(input = IDENTITY_TRANSFORM3) {
+    return new Placement3(snapshotTransform3(readTransformMatrix(input, 3)));
 }

package/dist/index.js

@@ -1,5 +1,6 @@
 /** Immutable modeling recipes and math values; the host owns geometry evaluation. @packageDocumentation */
-export { transform2, transform3, } from "./geometry/transform-chain.js";
+export { bounds2, bounds3, } from "./geometry/bounds-value.js";
+export { transform2, transform3, } from "./geometry/transform-value.js";
 export { vector2, vector3, } from "./geometry/math/vector-value.js";
 export { path2, path3, } from "./geometry/paths/path-value.js";
 export * from "./model/operations.js";

package/dist/model/execution-binding.js

@@ -1,7 +1,7 @@
 import { GeometryError } from "../geometry/errors.js";
 // One protocol key lets locally bundled operation wrappers resolve the host's execution
 // without depending on package instances, class identity, or initializing a native runtime.
-const executionKey = Symbol.for("@metamesh/modeling/execution/7");
+const executionKey = Symbol.for("@metamesh/modeling/execution/8");
 const bindings = globalThis;
 /** Internal host binding. Executable callbacks are synchronous and may not nest executions. */
 export function bindModelContext(context, build) {

package/dist/model/geometry-recipes.js

@@ -1,7 +1,7 @@
 import { createSectionHandle, createSolidHandle } from "./shape-handles.js";
 // One realm protocol lets bundled authoring code declare recipes before a host is initialized.
 // The payload contains no native handles and the engine remains responsible for realization.
-const recipeKey = Symbol.for("@metamesh/modeling/recipe/7");
+const recipeKey = Symbol.for("@metamesh/modeling/recipe/8");
 /** Reads private recipe metadata without requiring an execution context. */
 export const geometryRecipe = (value) => Object.getOwnPropertyDescriptor(value, recipeKey)?.value;
 /** Recognizes only opaque recipe handles issued by this engine. */

package/dist/model/immutable-generation-data.js

@@ -185,18 +185,10 @@ export function compareGenerationValues(left, right) {
     return compare(left, right);
 }
 function mathValueData(value) {
-    for (const name of ["toArray", "toMatrix"]) {
-        const method = Reflect.get(value, name);
-        if (typeof method === "function") {
-            const data = Reflect.apply(method, value, []);
-            // Closure and dimension change path behavior; tuple interchange omits both for empty paths.
-            const closed = Reflect.get(value, "closed");
-            return typeof closed === "boolean"
-                ? { dimension: Reflect.get(value, "dimension"), points: data, closed }
-                : data;
-        }
-    }
-    throw new TypeError("Immutable math values must expose their canonical numeric data.");
+    const method = Reflect.get(value, "toData");
+    if (typeof method !== "function")
+        throw new TypeError("Immutable math values must expose canonical data through toData().");
+    return Reflect.apply(method, value, []);
 }
 function captureValue(value, mode, readerAllowed = () => false, validated) {
     const recipeInputs = mode === "recipe";

package/dist/model/knuckle-hinge.js

@@ -0,0 +1 @@
+export {};