@metamesh/modeling 0.13.0 → 0.14.0

package/dist/engine/pattern-operations.js

@@ -1,7 +1,7 @@
 import { gridPatternPlan, linearPatternPlan, pathPatternPlan, radialPatternPlan, } from "../geometry/patterns/placements.js";
 import { assertSamplingCount } from "../geometry/sampling-limits.js";
+import { restrictTransform3 } from "../geometry/transform2.js";
 import { IDENTITY_TRANSFORM3 } from "../geometry/transform3.js";
-import { sectionPatternTransform } from "./pattern-transform.js";
 /** Private pattern owner; all copies use the shared transform/metadata/lifetime path. */
 export function createPatternOperations(environment, transforms) {
     const apply = (source, makePlan, operation) => {
@@ -32,7 +32,7 @@ export function createPatternOperations(environment, transforms) {
             copies.push(matrix.every((value, i) => value === IDENTITY_TRANSFORM3[i])
                 ? shape
                 : kind === "section"
-                    ? transforms.operations.transform(shape, sectionPatternTransform(matrix, operation))
+                    ? transforms.operations.transform(shape, restrictTransform3(matrix))
                     : transforms.operations.transform(shape, matrix));
         }
         return copies;

package/dist/engine/primitive-profiles.js

@@ -187,6 +187,7 @@ export function correspondingPrimitiveProfiles(sources, options, limits) {
                         const edgeLength = Math.min(original.maxSegmentLength ?? Infinity, target.maxSegmentLength ?? Infinity) /
                             scale;
                         const resolution = {
+                            sizing: source.faceSizing ? "face" : "vertex",
                             maxChordError: Math.min(original.maxChordError, target.maxChordError) / scale,
                             maximumSegments: Math.min(original.maximumSegments, target.maximumSegments),
                             minimumSegments: Math.min(Math.max(original.minimumSegments, target.minimumSegments), Math.min(original.maximumSegments, target.maximumSegments)),

package/dist/engine/recipe-realization.js

@@ -1,36 +1,35 @@
 import { GeometryError } from "../geometry/errors.js";
+import { isImmutableMathValue } from "../geometry/math/immutable-value.js";
+import { geometryRecipe, isGeometryRecipe } from "../model/geometry-recipes.js";
 import { immutableBufferView, isImmutableBuffer } from "../model/immutable-buffer.js";
-import { geometryRecipe, isGeometryRecipe, } from "./geometry-recipes.js";
 /**
- * Resolves session recipes within one revision. These maps memoize borrowed native handles;
+ * Evaluates immutable recipes within one host revision. These maps memoize borrowed native handles;
  * the execution scope still owns allocation and cleanup, including handles restored from cache.
  */
 export class RecipeRealization {
-    owner;
+    session;
     native;
     duringNative;
     restoreNative;
+    accessible = new WeakSet();
     realized = new Map();
     operands = new Set();
     resolvedCalls = new Map();
     nativeContexts = new Map();
-    constructor(owner, native, duringNative, restoreNative) {
-        this.owner = owner;
+    constructor(session, native, duringNative, restoreNative) {
+        this.session = session;
         this.native = native;
         this.duringNative = duringNative;
         this.restoreNative = restoreNative;
     }
-    /** Rejects foreign recipes before declaration, without realizing any geometry. */
-    assertOwned(values) {
-        for (const shape of recipeShapes(values))
-            this.assertRecipeOwner(geometryRecipe(shape));
-    }
-    /** Runs an observation or operation with captured inputs and its declaring resolution. */
+    /** Explicit recipe settings override this host's defaults; unspecified settings remain inherited. */
     invoke(call) {
-        let context = this.nativeContexts.get(call.resolution);
+        const resolution = call.resolution;
+        let context = this.nativeContexts.get(resolution);
         if (context === undefined) {
-            context = this.native().withResolution(call.resolution);
-            this.nativeContexts.set(call.resolution, context);
+            const host = this.native();
+            context = resolution === undefined ? host : host.withResolution(resolution);
+            this.nativeContexts.set(resolution, context);
         }
         const operation = context[call.method];
         const args = this.resolveValue(call.args, true);
@@ -53,15 +52,20 @@ export class RecipeRealization {
         const shapes = new Set(recipeShapes(values));
         return [...shapes].sort((left, right) => Number(this.operands.has(right)) - Number(this.operands.has(left)));
     }
-    assertRecipeOwner(recipe) {
-        if (recipe.owner !== this.owner)
-            throw new GeometryError("INVALID_ARGUMENT", "Geometry belongs to another model session.", {
-                operation: "generate",
-            });
+    /** Validate the complete graph before any retained native parent can bypass its operands. */
+    assertAccessible(shape) {
+        if (this.accessible.has(shape))
+            return;
+        const recipe = geometryRecipe(shape);
+        if (recipe.observedSession !== undefined && recipe.observedSession !== this.session)
+            throw new GeometryError("INVALID_ARGUMENT", "Observed components can only be evaluated in the model session that selected them.", { operation: "components" });
+        for (const operand of recipeShapes(recipe.call.args))
+            this.assertAccessible(operand);
+        this.accessible.add(shape);
     }
     realizeShape(shape) {
         const recipe = geometryRecipe(shape);
-        this.assertRecipeOwner(recipe);
+        this.assertAccessible(shape);
         if (this.realized.has(shape))
             return this.realized.get(shape);
         // Restoring a retained value avoids replay but still borrows through this revision's scope.
@@ -84,6 +88,8 @@ export class RecipeRealization {
                 this.operands.add(value);
             return this.realizeShape(value);
         }
+        if (typeof value === "object" && value !== null && isImmutableMathValue(value))
+            return value;
         if (typeof value !== "object" ||
             value === null ||
             ArrayBuffer.isView(value) ||
@@ -113,7 +119,9 @@ function* recipeShapes(values, seen = new Set()) {
         seen.add(value);
         if (isGeometryRecipe(value))
             yield value;
-        else if (!isImmutableBuffer(value) && !ArrayBuffer.isView(value))
+        else if (!isImmutableBuffer(value) &&
+            !ArrayBuffer.isView(value) &&
+            !isImmutableMathValue(value))
             yield* recipeShapes(Object.values(value), seen);
     }
 }

package/dist/engine/section-operations.js

@@ -1,4 +1,5 @@
 import { assertSamplingCount } from "../geometry/sampling-limits.js";
+import { strokePathContours } from "../geometry/stroke-path.js";
 import { preflightSvgRegion } from "../geometry/svg-import.js";
 import { parseSvgPath } from "../geometry/svg/index.js";
 import { sampleTextContours } from "../geometry/text-contours.js";
@@ -35,6 +36,14 @@ export function createSectionOperations(environment, transforms) {
             if (typeof input !== "object" || input === null)
                 throwGeometryError("INVALID_ARGUMENT", "polygon", "Use an outline or polygon options.");
             const options = input;
+            if ("polygons" in options) {
+                if ("outer" in options ||
+                    "holes" in options ||
+                    "contours" in options ||
+                    "fillRule" in options)
+                    throwGeometryError("INVALID_ARGUMENT", "polygon", "Serialized polygons exclude other polygon options.");
+                return wrapSection(kernel.regionToCrossSection(scope, options.polygons, limits));
+            }
             if ("outer" in options) {
                 if ("contours" in options || "fillRule" in options)
                     throwGeometryError("INVALID_ARGUMENT", "polygon", "Explicit topology excludes compound fill options.");
@@ -44,11 +53,18 @@ export function createSectionOperations(environment, transforms) {
                 throwGeometryError("INVALID_ARGUMENT", "polygon", "Compound fill requires contours without explicit holes.");
             return fromContours(options.contours, options.fillRule);
         },
-        fromRegion: (region) => {
+        stroke: (path, value) => {
             assertActive();
-            return wrapSection(kernel.regionToCrossSection(scope, region, limits));
+            const contours = strokePathContours(path, withResolutionDefaults(value));
+            if (contours.length === 0)
+                throwGeometryError("DEGENERATE_GEOMETRY", "stroke", "The sampled stroke path has no visible length.");
+            const batches = [];
+            for (let i = 0; i < contours.length; i += 1000) {
+                batches.push(nativeSection(fromContours(contours.slice(i, i + 1000))));
+            }
+            return ownSection(module.CrossSection.union(batches));
         },
-        toRegion: (handle) => {
+        toRegionData: (handle) => {
             const profile = environment.sectionProfileFor(handle);
             const copiedLoop = (points) => Object.freeze(points.map(([x, y]) => Object.freeze([x, y])));
             return Object.freeze(profile.components.map((component) => Object.freeze({

package/dist/engine/session-graph.js

@@ -1,6 +1,6 @@
 import { GeometryError } from "../geometry/errors.js";
 import { GenerationError, } from "../model/generation.js";
-import { captureGenerationDependencies, captureGenerationValue, compareGenerationValues, generationDataEntries, } from "./immutable-generation-data.js";
+import { captureGenerationDependencies, captureGenerationValue, compareGenerationValues, generationDataEntries, } from "../model/immutable-generation-data.js";
 import { createModelDependencies } from "./model-dependencies.js";
 import { assertSynchronousScopeResult } from "./native/ownership.js";
 function reusableEntry(node) {

package/dist/engine/session-native.js

@@ -1,4 +1,4 @@
-import { generationValueBytes } from "./immutable-generation-data.js";
+import { generationValueBytes } from "../model/immutable-generation-data.js";
 function disposeValues(values) {
     const errors = [];
     for (const value of new Set(values)) {

package/dist/engine/session-snapshot.js

@@ -1,4 +1,5 @@
 import { GeometryError } from "../geometry/errors.js";
+import { vector3Data } from "../geometry/math/vector-value.js";
 import { isImmutableBuffer } from "../model/immutable-buffer.js";
 import { createGeometryFinalizer, rememberSnapshotPart, } from "./finalization.js";
 import { createModelSummary } from "./model-summary.js";
@@ -8,8 +9,8 @@ function invalid(message) {
     throw new GeometryError("INVALID_ARGUMENT", message, { operation: "generate" });
 }
 const vector = (value) => {
-    const result = value ?? [0, 0, 0];
-    if (!Array.isArray(result) || result.length !== 3 || !result.every(Number.isFinite))
+    const result = value === undefined ? [0, 0, 0] : vector3Data(value);
+    if (!result.every(Number.isFinite))
         invalid("Part placement requires three finite coordinates.");
     return Object.freeze([...result]);
 };

package/dist/engine/session.js

@@ -1,8 +1,8 @@
 import { GeometryError } from "../geometry/errors.js";
 import { resolveModelingLimits } from "../geometry/model-limits.js";
 import { bindModelContext } from "../model/execution-binding.js";
+import { captureGenerationValue, generationValueBytes, } from "../model/immutable-generation-data.js";
 import { createDeferredContext } from "./deferred-context.js";
-import { captureGenerationValue, generationValueBytes } from "./immutable-generation-data.js";
 import { createGenerationGraph } from "./session-graph.js";
 import { createNativeGeometryCache } from "./session-native.js";
 import { createSnapshotCache } from "./session-snapshot.js";
@@ -96,10 +96,10 @@ class SessionRevision {
         this.session = session;
     }
     execute(input, native, mode) {
-        const { owner, options, limits, caches } = this.session;
+        const { owner, limits, caches } = this.session;
         const revision = caches.graph.begin(input, () => this.assertDeclarationAllowed());
         this.revision = revision;
-        const deferred = createDeferredContext(owner, () => native().context, limits, options.resolution ?? {}, (callback) => this.evaluateNative(callback), revision.assertActive, (shape) => {
+        const deferred = createDeferredContext(owner, () => native().context, limits, (callback) => this.evaluateNative(callback), revision.assertActive, (shape) => {
             const retained = caches.geometry.get(shape);
             if (retained !== undefined)
                 return native().restoreNative(retained);

package/dist/engine/shape-anchors.js

@@ -1,6 +1,6 @@
 import { createAnchor3 } from "../geometry/anchors.js";
 import { GeometryError } from "../geometry/errors.js";
-import { applyTransformDirection3, applyTransformPoint3, inverseTransform3, } from "../geometry/transform3.js";
+import { applyInverseTranspose3, applyTransformDirection3, applyTransformPoint3, inverseLinearTransform3, } from "../geometry/transform3.js";
 const maximumAnchors = 128;
 function fail(operation, message) {
     throw new GeometryError("INVALID_ARGUMENT", message, { operation });
@@ -27,13 +27,7 @@ function unit(vector) {
 }
 /** Maps positions affinely, outward normals by inverse transpose, and roll tangents linearly. */
 function transformedAnchor(anchor, matrix, inverse) {
-    const normal = anchor.direction;
-    const direction = [
-        inverse[0] * normal[0] + inverse[4] * normal[1] + inverse[8] * normal[2],
-        inverse[1] * normal[0] + inverse[5] * normal[1] + inverse[9] * normal[2],
-        inverse[2] * normal[0] + inverse[6] * normal[1] + inverse[10] * normal[2],
-    ];
-    return createAnchor3(applyTransformPoint3(matrix, anchor.position), unit(direction), unit(applyTransformDirection3(matrix, anchor.up)));
+    return createAnchor3(applyTransformPoint3(matrix, anchor.position), applyInverseTranspose3(inverse, anchor.direction), unit(applyTransformDirection3(matrix, anchor.up)));
 }
 /** Run-owned immutable anchor metadata. Geometry operations acquire metadata only deliberately. */
 export function createShapeAnchorOwner(assertShape, aliasShape) {
@@ -80,7 +74,7 @@ export function createShapeAnchorOwner(assertShape, aliasShape) {
             const definitions = anchors.get(source);
             if (definitions === undefined)
                 return result;
-            const inverse = inverseTransform3(matrix);
+            const inverse = inverseLinearTransform3(matrix);
             return remember(result, Object.fromEntries(Object.entries(definitions).map(([name, value]) => [
                 name,
                 transformedAnchor(value, matrix, inverse),

package/dist/engine/transform-operations.js

@@ -1,6 +1,9 @@
 import { attachTransform } from "../geometry/anchors.js";
+import { vector2Data, vector3Data, } from "../geometry/math/vector-value.js";
 import { assertPrimitiveOptions } from "../geometry/primitive-resolvers.js";
-import { eulerTransform3, scaleTransform3, translationTransform3 } from "../geometry/transform3.js";
+import { transform2, transform3, } from "../geometry/transform-chain.js";
+import { readTransformMatrix } from "../geometry/transform-matrix.js";
+import { eulerTransform3, scaleTransform3, translationTransform3, validateTransform3, } from "../geometry/transform3.js";
 import * as kernel from "./native/index.js";
 import { transformPrimitiveSectionProfile } from "./primitive-profiles.js";
 /** Internal host-bound transform operations. */
@@ -30,25 +33,24 @@ export function createTransformOperations(environment) {
             ? result
             : environment.rememberPrimitiveProfile(result, transformPrimitiveSectionProfile(profile, matrix));
     };
-    const translate = ((value, offset) => {
+    const translate = ((value, supplied) => {
         const native = resolveHandle(value);
+        const offset = native.kind === "section"
+            ? vector2Data(supplied)
+            : vector3Data(supplied);
         validateCoordinates(offset, native.kind === "section" ? 2 : 3, "translate");
         return native.kind === "section"
-            ? preserveProfile(value, ownSection(native.value.translate(offset)), [
-                1,
-                0,
-                offset[0],
-                0,
-                1,
-                offset[1],
-                0,
-                0,
-                1,
-            ])
+            ? preserveProfile(value, ownSection(native.value.translate(offset)), [1, 0, offset[0], 0, 1, offset[1], 0, 0, 1])
             : environment.preserveAnchors(value, wrapSolid(kernel.translate(scope, native.value, offset)), translationTransform3(offset));
     });
-    const rotate = ((value, degrees) => {
+    const rotate = ((value, supplied, options) => {
         const native = resolveHandle(value);
+        const degrees = typeof supplied === "number" ? supplied : vector3Data(supplied);
+        if (options !== undefined) {
+            return native.kind === "section"
+                ? transform(value, transform2().rotate(degrees, options))
+                : transform(value, transform3().rotate(degrees, options));
+        }
         if (native.kind === "section") {
             if (typeof degrees !== "number")
                 return throwGeometryError("INVALID_ARGUMENT", "rotate", "Section rotation requires a scalar angle.");
@@ -71,13 +73,26 @@ export function createTransformOperations(environment) {
         validateCoordinates(degrees, 3, "rotate");
         return environment.preserveAnchors(value, wrapSolid(kernel.rotate(scope, native.value, degrees)), eulerTransform3(degrees));
     });
-    const scale = ((value, factors) => {
+    const scale = ((value, supplied, options) => {
         const native = resolveHandle(value);
-        const values = typeof factors === "number" ? [factors] : factors;
+        const factors = typeof supplied === "number"
+            ? supplied
+            : native.kind === "section"
+                ? vector2Data(supplied)
+                : vector3Data(supplied);
+        if (options !== undefined) {
+            return native.kind === "section"
+                ? transform(value, transform2().scale(factors, options))
+                : transform(value, transform3().scale(factors, options));
+        }
         if (typeof factors !== "number")
             validateCoordinates(factors, native.kind === "section" ? 2 : 3, "scale");
-        if (!values.every(Number.isFinite) || values.some((factor) => factor === 0))
-            throwGeometryError("SINGULAR_TRANSFORM", "scale", "Scale factors must be finite and nonzero.");
+        const scaleMatrix = scaleTransform3(typeof factors === "number"
+            ? [factors, factors, native.kind === "section" ? 1 : factors]
+            : native.kind === "section"
+                ? [factors[0], factors[1], 1]
+                : factors);
+        validateTransform3(scaleMatrix);
         return native.kind === "section"
             ? preserveProfile(value, ownSection(native.value.scale(factors)), [
                 typeof factors === "number" ? factors : factors[0],
@@ -90,10 +105,13 @@ export function createTransformOperations(environment) {
                 0,
                 1,
             ])
-            : environment.preserveAnchors(value, wrapSolid(kernel.scale(scope, native.value, factors)), scaleTransform3(typeof factors === "number" ? [factors, factors, factors] : factors));
+            : environment.preserveAnchors(value, wrapSolid(kernel.scale(scope, native.value, factors)), scaleMatrix);
     });
-    const mirror = ((value, normal) => {
+    const mirror = ((value, supplied) => {
         const native = resolveHandle(value);
+        const normal = native.kind === "section"
+            ? vector2Data(supplied)
+            : vector3Data(supplied);
         validateCoordinates(normal, native.kind === "section" ? 2 : 3, "mirror");
         if (normal.every((coordinate) => coordinate === 0))
             throwGeometryError("INVALID_ARGUMENT", "mirror", "Mirror normal must be nonzero.");
@@ -139,18 +157,17 @@ export function createTransformOperations(environment) {
                 ]);
             })();
     });
-    const transform = ((value, matrix) => {
+    const transform = ((value, placement) => {
         const native = resolveHandle(value);
+        const matrix = native.kind === "solid"
+            ? transform3(readTransformMatrix(placement, 3)).toMatrix()
+            : transform2(readTransformMatrix(placement, 2)).toMatrix();
         if (native.kind === "solid") {
             validateCoordinates(matrix, 16, "transform");
             return environment.preserveAnchors(value, wrapSolid(kernel.transform(scope, native.value, matrix)), matrix);
         }
         validateCoordinates(matrix, 9, "transform");
         const m = matrix;
-        if (m[6] !== 0 || m[7] !== 0 || m[8] !== 1)
-            throwGeometryError("INVALID_ARGUMENT", "transform", "Section transform must be affine.");
-        if (m[0] * m[4] - m[1] * m[3] === 0)
-            throwGeometryError("SINGULAR_TRANSFORM", "transform", "Section transform must be nonsingular.");
         const columnMajor = [m[0], m[3], m[6], m[1], m[4], m[7], m[2], m[5], m[8]];
         return preserveProfile(value, ownSection(native.value.transform(columnMajor)), m);
     });

package/dist/geometry/index.js

@@ -12,7 +12,10 @@ export { defaultGeometrySamplingLimits, resolveGeometrySamplingLimits, } from ".
 export { GeometryError, isGeometryError, } from "./errors.js";
 export { resolveExtrusionDivisions, } from "./extrusion.js";
 export { extrudeMesh, loftMesh, triangulateContour, } from "./loft/loft.js";
-export { add3, cross3, dot3, length3, lerp3, normalize3, projectOntoPlane3, rotateAroundAxis3, scale3, subtract3, } from "./math/vector3.js";
+export { transform2, transform3, } from "./transform-chain.js";
+export { vector2, vector3, } from "./math/vector-value.js";
+export { add2, subtract2, scale2, dot2, cross2, length2, distance2, normalize2, lerp2, rotate2, } from "./math/vector2.js";
+export { add3, cross3, dot3, length3, distance3, lerp3, normalize3, projectOntoPlane3, scale3, subtract3, } from "./math/vector3.js";
 export { minimumCylindricalGearToothCountWithoutUndercut, resolveCylindricalGear, resolveCylindricalGearPair, resolveRackPitch, sampleCylindricalGearOutline, sampleInternalCylindricalGearSpaceOutline, sampleRackToothPath, } from "./mechanical/gears.js";
 export { measureInternalCylindricalGearPairMotion, } from "./mechanical/gear-motion.js";
 export { METRIC_FASTENER_STANDARDS, getMetricClearanceHole, getMetricFastenerStandard, } from "./mechanical/standards.js";
@@ -28,6 +31,7 @@ export { analyzeTriangleMeshQuality, } from "./mesh/mesh-quality.js";
 export { computeClosedParallelTransportFrames, computeParallelTransportFrames, } from "./paths/frames.js";
 export { sampleHelix } from "./paths/helix.js";
 export { cumulativePathLengths, pathLength } from "./paths/path.js";
+export { closestPointOnPath, } from "./paths/closest-point.js";
 export { distributeAlongPath, roundClosedPolylinePath, } from "./paths/planar.js";
 export { circleContour, rectangleContour, regularPolygonContour, starContour, } from "./profiles/profiles.js";
 export { closeToAxis, sampleSideProfile, } from "./profiles/side-profile.js";
@@ -41,7 +45,7 @@ export { preflightSvgRegion, } from "./svg-import.js";
 export { strokePathRegion, } from "./stroke-path.js";
 export { sweepMesh } from "./sweeps/sweep-mesh.js";
 export { DEFAULT_GEOMETRY_TOLERANCE, resolveGeometryTolerance, } from "./tolerance.js";
-export { transformContour, transformPath2, transformPath3, transformRegion, } from "./transform-geometry.js";
+export { transformContour, transformPath2, transformPath3, transformRegionData, } from "./transform-geometry.js";
 export { IDENTITY_TRANSFORM3, applyTransformDirection3, applyTransformPoint3, composeTransform3, eulerTransform3, frameTransform3, inverseTransform3, rotationTransform3, scaleTransform3, transformDeterminant3, translationTransform3, validateTransform3, } from "./transform3.js";
 export { sampleTextContours } from "./text-contours.js";
 export { sampleCurve2, sampleCurve3 } from "./curves/sampling.js";

package/dist/geometry/math/immutable-value.js

@@ -0,0 +1,20 @@
+// A versioned realm protocol lets separately bundled authoring values cross the host boundary.
+const immutableMath = Symbol.for("@metamesh/modeling/immutable-math/6");
+/**
+ * Brands and freezes only this constructor's prototype. Pure-annotated callers let bundlers
+ * discard unused classes without dropping initialization for classes that remain reachable.
+ */
+export function immutableMathClass(constructor) {
+    Object.defineProperty(constructor.prototype, immutableMath, { value: true });
+    Object.freeze(constructor.prototype);
+    return constructor;
+}
+/** Math values are atomic immutable inputs, rather than enumerable recipe data. */
+export function isImmutableMathValue(value) {
+    const prototype = Object.getPrototypeOf(value);
+    return (Object.isFrozen(value) &&
+        typeof prototype === "object" &&
+        prototype !== null &&
+        Object.isFrozen(prototype) &&
+        Object.getOwnPropertyDescriptor(prototype, immutableMath)?.value === true);
+}

package/dist/geometry/math/vector-value.js

@@ -0,0 +1,168 @@
+import { GeometryError } from "../errors.js";
+import { immutableMathClass } from "./immutable-value.js";
+import { add2, cross2, distance2, dot2, length2, lerp2, normalize2, scale2, subtract2, } from "./vector2.js";
+import { add3, cross3, distance3, dot3, length3, lerp3, normalize3, scale3, subtract3, } from "./vector3.js";
+const finite = (value, operation) => {
+    if (!Number.isFinite(value)) {
+        throw new GeometryError("NON_FINITE_VALUE", "Vector coordinates and results must be finite.", {
+            operation,
+        });
+    }
+    return value;
+};
+const validateCoordinates = (values, operation) => {
+    for (const coordinate of values)
+        finite(coordinate, operation);
+};
+const operand2 = (input, operation) => {
+    const values = vector2Data(input);
+    validateCoordinates(values, operation);
+    return values;
+};
+const operand3 = (input, operation) => {
+    const values = vector3Data(input);
+    validateCoordinates(values, operation);
+    return values;
+};
+function invalidVector(dimensions) {
+    throw new GeometryError("INVALID_ARGUMENT", `Expected a ${dimensions}D vector or coordinate tuple.`, {
+        operation: `vector${dimensions}`,
+    });
+}
+const tupleData = (input, dimensions) => {
+    if (typeof input !== "object" || input === null)
+        return invalidVector(dimensions);
+    let values = input;
+    if (!Array.isArray(input)) {
+        const method = Reflect.get(input, "toArray");
+        if (typeof method !== "function")
+            return invalidVector(dimensions);
+        values = Reflect.apply(method, input, []);
+    }
+    if (!Array.isArray(values) || values.length !== dimensions)
+        return invalidVector(dimensions);
+    return values;
+};
+/** Internal tuple view; validates dimension and shape without allocating or checking finiteness. */
+export const vector2Data = (input) => tupleData(input, 2);
+/** Internal tuple view; validates dimension and shape without allocating or checking finiteness. */
+export const vector3Data = (input) => tupleData(input, 3);
+const PlanarVector = /* @__PURE__ */ immutableMathClass(class PlanarVector {
+    values;
+    constructor(values, operation = "vector2") {
+        this.values = values;
+        validateCoordinates(values, operation);
+        Object.freeze(values);
+        Object.freeze(this);
+    }
+    get x() {
+        return this.values[0];
+    }
+    get y() {
+        return this.values[1];
+    }
+    add(other) {
+        return new PlanarVector(add2(this.values, operand2(other, "vector2.add")), "vector2.add");
+    }
+    subtract(other) {
+        return new PlanarVector(subtract2(this.values, operand2(other, "vector2.subtract")), "vector2.subtract");
+    }
+    scale(factor) {
+        return new PlanarVector(scale2(this.values, finite(factor, "vector2.scale")), "vector2.scale");
+    }
+    normalize(epsilon) {
+        return new PlanarVector(normalize2(this.values, epsilon), "vector2.normalize");
+    }
+    lerp(other, t) {
+        return new PlanarVector(lerp2(this.values, operand2(other, "vector2.lerp"), finite(t, "vector2.lerp")), "vector2.lerp");
+    }
+    dot(other) {
+        return finite(dot2(this.values, operand2(other, "vector2.dot")), "vector2.dot");
+    }
+    cross(other) {
+        return finite(cross2(this.values, operand2(other, "vector2.cross")), "vector2.cross");
+    }
+    length() {
+        return finite(length2(this.values), "vector2.length");
+    }
+    distance(other) {
+        return finite(distance2(this.values, operand2(other, "vector2.distance")), "vector2.distance");
+    }
+    toArray() {
+        return this.values;
+    }
+});
+const SpatialVector = /* @__PURE__ */ immutableMathClass(class SpatialVector {
+    values;
+    constructor(values, operation = "vector3") {
+        this.values = values;
+        validateCoordinates(values, operation);
+        Object.freeze(values);
+        Object.freeze(this);
+    }
+    get x() {
+        return this.values[0];
+    }
+    get y() {
+        return this.values[1];
+    }
+    get z() {
+        return this.values[2];
+    }
+    add(other) {
+        return new SpatialVector(add3(this.values, operand3(other, "vector3.add")), "vector3.add");
+    }
+    subtract(other) {
+        return new SpatialVector(subtract3(this.values, operand3(other, "vector3.subtract")), "vector3.subtract");
+    }
+    scale(factor) {
+        return new SpatialVector(scale3(this.values, finite(factor, "vector3.scale")), "vector3.scale");
+    }
+    normalize(epsilon) {
+        return new SpatialVector(normalize3(this.values, epsilon), "vector3.normalize");
+    }
+    lerp(other, t) {
+        return new SpatialVector(lerp3(this.values, operand3(other, "vector3.lerp"), finite(t, "vector3.lerp")), "vector3.lerp");
+    }
+    dot(other) {
+        return finite(dot3(this.values, operand3(other, "vector3.dot")), "vector3.dot");
+    }
+    cross(other) {
+        return new SpatialVector(cross3(this.values, operand3(other, "vector3.cross")), "vector3.cross");
+    }
+    length() {
+        return finite(length3(this.values), "vector3.length");
+    }
+    distance(other) {
+        return finite(distance3(this.values, operand3(other, "vector3.distance")), "vector3.distance");
+    }
+    toArray() {
+        return this.values;
+    }
+});
+/**
+ * Creates immutable XY arithmetic from a finite tuple or vector, snapshotting the coordinates.
+ * Values and results are finite. Invalid dimensions throw `INVALID_ARGUMENT`; nonfinite coordinates
+ * and overflow throw `NON_FINITE_VALUE` GeometryError.
+ * Use transform2().applyDirection(value) for rotations and nonuniform scaling.
+ */
+export function vector2(input) {
+    const values = operand2(input, "vector2");
+    return new PlanarVector([values[0], values[1]]);
+}
+/**
+ * Creates immutable XYZ arithmetic from a finite tuple or vector, snapshotting the coordinates.
+ * Values and results are finite. Invalid dimensions throw `INVALID_ARGUMENT`; nonfinite coordinates
+ * and overflow throw `NON_FINITE_VALUE` GeometryError.
+ * Use transform3().applyDirection(value) for rotations and nonuniform scaling.
+ *
+ * @example
+ * ```ts
+ * const direction = vector3([1, 2, 3]).add([4, 0, 0]).normalize().scale(10);
+ * const alignment = direction.dot([0, 0, 1]);
+ * ```
+ */
+export function vector3(input) {
+    const values = operand3(input, "vector3");
+    return new SpatialVector([values[0], values[1], values[2]]);
+}