@metamesh/modeling 0.14.0 → 0.16.0

package/dist/geometry/svg-import.js

@@ -429,7 +429,7 @@ function measureSvgRegion(region) {
     let minEdgeLength = Number.POSITIVE_INFINITY;
     let minX = Number.POSITIVE_INFINITY;
     let minY = Number.POSITIVE_INFINITY;
-    let shortEdges = 0;
+    let shortEdgeCount = 0;
     let vertices = 0;
     for (const polygon of region) {
         for (const loop of [polygon.outer, ...polygon.holes]) {
@@ -443,7 +443,7 @@ function measureSvgRegion(region) {
             for (const length of loopEdgeLengths(loop)) {
                 minEdgeLength = Math.min(minEdgeLength, length);
                 if (length < SHORT_EDGE_LENGTH_MM)
-                    shortEdges += 1;
+                    shortEdgeCount += 1;
             }
         }
     }
@@ -456,13 +456,13 @@ function measureSvgRegion(region) {
     return Object.freeze({
         area: regionArea(region),
         bounds,
-        components: region.length,
-        contours: region.length + holes,
-        holes,
+        componentCount: region.length,
+        contourCount: region.length + holes,
+        holeCount: holes,
         minEdgeLength: Number.isFinite(minEdgeLength) ? minEdgeLength : null,
-        shortEdges,
-        tinyIslands: region.filter((polygon) => polygonArea(polygon) < TINY_ISLAND_AREA_MM2).length,
-        vertices,
+        shortEdgeCount,
+        tinyIslandCount: region.filter((polygon) => polygonArea(polygon) < TINY_ISLAND_AREA_MM2).length,
+        vertexCount: vertices,
     });
 }
 /**
@@ -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 = {}) {
@@ -498,10 +498,10 @@ function createSvgRegionPreflight(svg, options = {}) {
     const stack = [];
     const geometry = [];
     let elementCount = 0;
-    let emptyElements = 0;
+    let emptyElementCount = 0;
     let expandedGeometryVertices = 0;
-    let implicitFilledClosures = 0;
-    let invisibleElements = 0;
+    let implicitFilledClosureCount = 0;
+    let invisibleElementCount = 0;
     let nodeCount = 0;
     let rootSeen = false;
     let strokeConstructionVertices = 0;
@@ -582,9 +582,9 @@ function createSvgRegionPreflight(svg, options = {}) {
             const paintedStroke = isPainted(paint.stroke, paint.strokeOpacity) && paint.strokeWidth > 0;
             const elementGeometry = [];
             if (!paintedFill && !paintedStroke)
-                invisibleElements += 1;
+                invisibleElementCount += 1;
             if (paintedFill) {
-                implicitFilledClosures += subpaths.filter((subpath) => !subpath.closed && subpath.points.length >= 3).length;
+                implicitFilledClosureCount += subpaths.filter((subpath) => !subpath.closed && subpath.points.length >= 3).length;
                 appendGeometry(elementGeometry, fillGeometry(subpaths, paint.fillRule), "element fill output");
             }
             if (paintedStroke) {
@@ -606,7 +606,7 @@ function createSvgRegionPreflight(svg, options = {}) {
                 }
             }
             if ((paintedFill || paintedStroke) && elementGeometry.every((value) => value.length === 0)) {
-                emptyElements += 1;
+                emptyElementCount += 1;
             }
             geometry.push(...elementGeometry);
         }
@@ -628,26 +628,32 @@ function createSvgRegionPreflight(svg, options = {}) {
         geometry: measureSvgRegion(region),
         region,
         repairs: Object.freeze({
-            emptyElements,
-            implicitFilledClosures,
-            invisibleElements,
-            removedDuplicateVertices: budget.removedDuplicateCount,
-            removedSeamVertices: budget.removedSeamCount,
+            emptyElementCount,
+            implicitFilledClosureCount,
+            invisibleElementCount,
+            removedDuplicateVertexCount: budget.removedDuplicateCount,
+            removedSeamVertexCount: budget.removedSeamCount,
         }),
         source: Object.freeze({
-            bytes,
-            elements: elementCount,
-            emittedVertices: budget.emittedCount,
-            parsedVertices: budget.parsedCount,
+            byteCount: bytes,
+            elementCount,
+            emittedVertexCount: budget.emittedCount,
+            parsedVertexCount: budget.parsedCount,
         }),
     });
 }
 /**
- * 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

@@ -1,4 +1,5 @@
 import { GeometryError } from "../errors.js";
+import { vector2Data } from "../math/vector-value.js";
 /** @internal Validates local scales before any manufacturing buffer allocation. */
 export function resolveSweepScales(scale, stationCount) {
     const fail = () => {
@@ -10,14 +11,14 @@ export function resolveSweepScales(scale, stationCount) {
                 fail();
             return [value, value];
         }
-        if (!Array.isArray(value) ||
-            value.length !== 2 ||
-            !value.every((n) => typeof n === "number" && Number.isFinite(n) && n > 0))
+        const coordinates = vector2Data(value);
+        if (!coordinates.every((n) => typeof n === "number" && Number.isFinite(n) && n > 0))
             fail();
-        return value;
+        return coordinates;
     };
     if (scale === undefined ||
         typeof scale === "number" ||
+        (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/sweeps/orientation.js

@@ -14,7 +14,7 @@ export function validateSweepOptions(options) {
         "limits",
         "orientation",
         "resolution",
-        "twistDegrees",
+        "twist",
         "twistBy",
         "scale",
         "seamProfileOffset",
@@ -27,8 +27,8 @@ export function validateSweepOptions(options) {
         options.twistBy !== "length" &&
         options.twistBy !== "stations")
         fail("Sweep twistBy must be length or stations.");
-    if (!Number.isFinite(options.twistDegrees ?? 0))
-        throw new GeometryError("NON_FINITE_VALUE", "Sweep twistDegrees must be finite.", {
+    if (!Number.isFinite(options.twist ?? 0))
+        throw new GeometryError("NON_FINITE_VALUE", "Sweep twist must be finite.", {
             operation: "sweep",
         });
     const policy = options.orientation;
@@ -58,8 +58,8 @@ export function validateSweepOptions(options) {
     if (Object.keys(policy).some((key) => !keys.includes(key)))
         fail("Unsupported field for the selected sweep orientation.");
 }
-function directedNormal(value, tangent, label) {
-    validateSweepNormal(value, "sweep");
+function directedNormal(input, tangent, label) {
+    const value = validateSweepNormal(input, "sweep");
     const maximum = Math.max(...value.map(Math.abs));
     const unit = normalize3([value[0] / maximum, value[1] / maximum, value[2] / maximum]);
     const projected = projectOntoPlane3(unit, tangent);

package/dist/geometry/sweeps/stations.js

@@ -65,14 +65,14 @@ function frameRotation(from, to) {
 export function planSweepStations(contours, path, scales, options, frames) {
     const closed = options.closed ?? false;
     const segmentCount = closed ? path.length : path.length - 1;
-    const twist = ((options.twistDegrees ?? 0) / 180) * Math.PI;
-    if (!Number.isFinite(twist))
-        throw new GeometryError("NON_FINITE_VALUE", "Sweep twistDegrees must be finite.", {
+    const twistRadians = ((options.twist ?? 0) / 180) * Math.PI;
+    if (!Number.isFinite(twistRadians))
+        throw new GeometryError("NON_FINITE_VALUE", "Sweep twist must be finite.", {
             operation: "sweep",
         });
     const intervals = [];
     const progress = sweepProgress(path, options);
-    if (twist === 0)
+    if (twistRadians === 0)
         return { intervals: Array(segmentCount).fill(1), stationCount: path.length, progress };
     const resolution = resolveGeometryResolution(options.resolution, options.limits);
     const limits = resolveGeometrySamplingLimits(options.limits);
@@ -92,7 +92,7 @@ export function planSweepStations(contours, path, scales, options, frames) {
     let stationCount = closed ? 0 : 1;
     for (let i = 0; i < segmentCount; i++) {
         const next = (i + 1) % path.length;
-        const twistStep = Math.abs(twist * (progress[i + 1] - progress[i]));
+        const twistStep = Math.abs(twistRadians * (progress[i + 1] - progress[i]));
         const frameAngle = frames === undefined ? 0 : frameRotation(frames[i], frames[next]).angle;
         const angle = frameAngle + twistStep;
         const maximumScale = Math.max(...scales[i], ...scales[next]);
@@ -104,9 +104,9 @@ export function planSweepStations(contours, path, scales, options, frames) {
         const a = curvature / 8, b = (edgeLength * (maximumScale * angle + scaleChange)) / 4;
         const requiredAngular = resolution.circularSegments === undefined
             ? Math.max(1, Math.ceil((b + Math.hypot(b, 2 * Math.sqrt(a * resolution.maxChordError))) /
-                (2 * resolution.maxChordError)), Math.ceil((resolution.minimumSegments * angle) / (2 * Math.PI)))
+                (2 * resolution.maxChordError)), Math.ceil((resolution.minSegments * angle) / (2 * Math.PI)))
             : Math.max(1, Math.ceil((resolution.circularSegments * angle) / (2 * Math.PI)));
-        const allowedAngular = Math.max(1, scaleChange === 0 ? 0 : resolution.maximumSegments, Math.ceil((resolution.maximumSegments * angle) / (2 * Math.PI)));
+        const allowedAngular = Math.max(1, scaleChange === 0 ? 0 : resolution.maxSegments, Math.ceil((resolution.maxSegments * angle) / (2 * Math.PI)));
         if (requiredAngular > allowedAngular)
             throw new GeometryError("COMPLEXITY_LIMIT", `Sweep surface refinement requires ${requiredAngular} intervals; the selected circular ceiling allows ${allowedAngular}.`, {
                 operation: "sweep",
@@ -126,7 +126,7 @@ export function planSweepStations(contours, path, scales, options, frames) {
 }
 /** Inserts twist samples without calling authored guides again or changing original station meaning. */
 export function refineSweepStations(path, scales, frames, options, plan) {
-    const twist = ((options.twistDegrees ?? 0) / 180) * Math.PI;
+    const twistRadians = ((options.twist ?? 0) / 180) * Math.PI;
     const segmentCount = plan.intervals.length;
     const points = [], sampledScales = [], sampledFrames = [], twists = [];
     for (let i = 0; i < segmentCount; i++) {
@@ -148,14 +148,14 @@ export function refineSweepStations(path, scales, frames, options, plan) {
                     binormal: rotateAroundAxis3Radians(frames[i].binormal, rotation.axis, rotation.angle * amount),
                     tangent: rotateAroundAxis3Radians(frames[i].tangent, rotation.axis, rotation.angle * amount),
                 });
-            twists.push(twist * (plan.progress[i] + (plan.progress[i + 1] - plan.progress[i]) * amount));
+            twists.push(twistRadians * (plan.progress[i] + (plan.progress[i + 1] - plan.progress[i]) * amount));
         }
     }
     if (options.closed !== true) {
         points.push(path.at(-1));
         sampledScales.push(scales.at(-1));
         sampledFrames.push(frames.at(-1));
-        twists.push(twist);
+        twists.push(twistRadians);
     }
     return { path: points, scales: sampledScales, frames: sampledFrames, twists };
 }

package/dist/geometry/sweeps/sweep-closed.js

@@ -20,9 +20,9 @@ export const buildClosedSweepMesh = (profile, path, options = {}) => {
             operation,
         });
     }
-    const twistRadians = ((options.twistDegrees ?? 0) / 180) * Math.PI;
+    const twistRadians = ((options.twist ?? 0) / 180) * Math.PI;
     if (!Number.isFinite(twistRadians)) {
-        throw new GeometryError("NON_FINITE_VALUE", "Sweep twistDegrees must be finite.", {
+        throw new GeometryError("NON_FINITE_VALUE", "Sweep twist must be finite.", {
             operation,
         });
     }

package/dist/geometry/sweeps/sweep-mesh.js

@@ -1,4 +1,6 @@
 import { GeometryError } from "../errors.js";
+import { resolveModelingLimits } from "../model-limits.js";
+import { path2InputData, path3InputData, } from "../paths/path-value.js";
 import { validateSweepOptions } from "./orientation.js";
 import { buildClosedSweepMesh } from "./sweep-closed.js";
 import { buildOpenSweepMesh } from "./sweep-open.js";
@@ -15,12 +17,16 @@ import { buildOpenSweepMesh } from "./sweep-open.js";
  */
 export function sweepMesh(profile, path, options = {}) {
     validateSweepOptions(options);
-    if (options.closed === true) {
-        return buildClosedSweepMesh(profile, path, options);
+    const limits = resolveModelingLimits(options.limits);
+    const outline = path2InputData(profile, true, { maxPathPoints: limits.maxProfilePoints }).points;
+    const data = path3InputData(path, options.closed, limits);
+    const selected = { ...options, closed: data.closed };
+    if (data.closed) {
+        return buildClosedSweepMesh(outline, data.points, selected);
     }
     if ((options.seamProfileOffset ?? 0) !== 0)
         throw new GeometryError("INVALID_ARGUMENT", "A seamProfileOffset requires a closed path.", {
             operation: "sweep",
         });
-    return buildOpenSweepMesh(profile, path, options);
+    return buildOpenSweepMesh(outline, data.points, selected);
 }

package/dist/geometry/sweeps/sweep-open.js

@@ -13,7 +13,7 @@ export const buildOpenSweepMesh = (profile, path, options = {}) => {
     path = normalizeSweepPath(path, false, operation, options.limits);
     assertSweepAllocation(path.length, profile.length, false, operation, options.limits);
     let scales = resolveSweepScales(options.scale, path.length);
-    const twistRadians = ((options.twistDegrees ?? 0) / 180) * Math.PI;
+    const twistRadians = ((options.twist ?? 0) / 180) * Math.PI;
     if (twistRadians !== 0) {
         const plan = planSweepStations([profile], path, scales, options);
         assertSweepAllocation(plan.stationCount, profile.length, false, operation, options.limits);

package/dist/geometry/sweeps/validation.js

@@ -1,4 +1,5 @@
 import { GeometryError } from "../errors.js";
+import { vector3Data } from "../math/vector-value.js";
 import { assertMeshAllocationWithinLimits, resolveModelingLimits, } from "../model-limits.js";
 import { writeMeshVertex } from "../numeric.js";
 import { normalizeContour } from "../regions.js";
@@ -97,13 +98,8 @@ export function writeSweepVertex(positions, offset, point, operation) {
     writeMeshVertex(positions, offset, point, operation);
 }
 /** @internal Checks user-provided orientation controls before vector normalization. */
-export function validateSweepNormal(normal, operation) {
-    const hasArrayShape = Array.isArray(normal);
-    if (!hasArrayShape || normal.length !== 3) {
-        throw new GeometryError("INVALID_ARGUMENT", "Sweep normals must be exact XYZ tuples.", {
-            operation,
-        });
-    }
+export function validateSweepNormal(input, operation) {
+    const normal = vector3Data(input);
     if (![normal[0], normal[1], normal[2]].every(Number.isFinite)) {
         throw new GeometryError("NON_FINITE_VALUE", "Sweep normal coordinates must be finite XYZ values.", { operation });
     }
@@ -112,4 +108,5 @@ export function validateSweepNormal(normal, operation) {
             operation,
         });
     }
+    return normal;
 }

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-geometry.js

@@ -3,35 +3,28 @@ import { normalizeContour, normalizeRegion, signedContourArea } from "./regions.
 import { readTransformMatrix } from "./transform-matrix.js";
 import { embedTransform2 } from "./transform2.js";
 import { applyValidatedTransformPoint3, validateTransform3 } from "./transform3.js";
-/** Applies an affine transform to a 3D path without mutating its points. */
+/** Internal owned coordinates for a Path3 result; no mutable coordinates escape the path value. */
 export function transformPath3(path, placement) {
     const transform = readTransformMatrix(placement, 3);
     validateTransform3(transform);
-    return Object.freeze(path.map((point) => Object.freeze(applyValidatedTransformPoint3(transform, point))));
+    return path.map((point) => applyValidatedTransformPoint3(transform, point));
 }
 const transformPoint2 = (point, transform) => {
     const values = vector2Data(point);
     const transformed = applyValidatedTransformPoint3(transform, [values[0], values[1], 0]);
-    return Object.freeze([transformed[0], transformed[1]]);
+    return [transformed[0], transformed[1]];
 };
-const transformPlanarPath = (path, transform) => Object.freeze(path.map((point) => transformPoint2(point, transform)));
-/** Applies a canonical affine XY transform to a 2D path without changing point order. */
+const transformPlanarPath = (path, transform) => Object.freeze(path.map((point) => Object.freeze(transformPoint2(point, transform))));
+/** Internal owned XY coordinates preserving path traversal; public interchange is frozen by Path2. */
 export function transformPath2(path, transform, tolerance = {}) {
-    return transformPlanarPath(path, embedTransform2(readTransformMatrix(transform, 2), tolerance));
+    const matrix = embedTransform2(readTransformMatrix(transform, 2), tolerance);
+    return path.map((point) => transformPoint2(point, matrix));
 }
 const transformContourWithMatrix = (loop, transform, tolerance) => {
     const counterClockwise = signedContourArea(loop) > 0;
     const normalized = normalizeContour(loop, counterClockwise, tolerance);
     return normalizeContour(transformPlanarPath(normalized, transform), counterClockwise, tolerance);
 };
-/**
- * Applies a canonical affine XY transform to a closed loop and preserves its original winding.
- *
- * Reflections reverse the point order automatically through normalization.
- */
-export function transformContour(loop, transform, tolerance = {}) {
-    return transformContourWithMatrix(loop, embedTransform2(readTransformMatrix(transform, 2), tolerance), tolerance);
-}
 /**
  * Transforms serialized polygon data with reflection-safe winding, without an engine.
  * Use Section.transform(placement) when authoring filled geometry; this utility serves pure data preparation.

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,6 +1,8 @@
 /** 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";
 export * from "./model/generation.js";
 export { immutableBuffer, immutableMesh } from "./model/immutable-buffer.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/6");
+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) {
@@ -10,7 +10,7 @@ export function bindModelContext(context, build) {
             operation: "build",
         });
     }
-    bindings[executionKey] = { version: 6, context };
+    bindings[executionKey] = { version: 7, context };
     try {
         return build();
     }
@@ -31,5 +31,5 @@ export function currentModelContext(operation) {
 /** Reads an optional binding without initializing an engine or creating ambient authoring state. */
 export function activeModelContext() {
     const binding = bindings[executionKey];
-    return binding?.version === 6 ? binding.context : undefined;
+    return binding?.version === 7 ? binding.context : undefined;
 }

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/6");
+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. */