@metamesh/modeling 0.14.0 → 0.15.0

package/dist/engine/native/transforms.js

@@ -1,4 +1,4 @@
-import { attachTransform } from "../../geometry/anchors.js";
+import { attachmentTransform3 } from "../../geometry/anchors.js";
 import { GeometryError } from "../../geometry/errors.js";
 import { assertScopedManifoldValue, ownScopedManifoldValue, } from "./context.js";
 const finiteVector = (value, name, operation) => {
@@ -100,17 +100,15 @@ export function transform(context, solid, matrix) {
 }
 /** Moves a local source anchor onto a world-space target anchor. */
 export function attach(context, solid, source, target, options = {}) {
-    if (options.spinDegrees !== undefined && !Number.isFinite(options.spinDegrees)) {
-        throw new GeometryError("NON_FINITE_VALUE", "spinDegrees must be finite.", {
+    if (options.spin !== undefined && !Number.isFinite(options.spin)) {
+        throw new GeometryError("NON_FINITE_VALUE", "spin must be finite.", {
             operation: "attach",
         });
     }
-    return transform(context, solid, attachTransform(source, target, {
+    return transform(context, solid, attachmentTransform3(source, target, {
         ...(options.alignment === undefined ? {} : { alignment: options.alignment }),
         ...(options.gap === undefined ? {} : { gap: options.gap }),
-        ...(options.spinDegrees === undefined
-            ? {}
-            : { spinRadians: (options.spinDegrees * Math.PI) / 180 }),
+        ...(options.spin === undefined ? {} : { spin: options.spin }),
         ...(options.tolerance === undefined ? {} : { tolerance: options.tolerance }),
     }));
 }

package/dist/engine/operation-environment.js

@@ -9,8 +9,8 @@ export function createOperationEnvironment(owner, resolution) {
             ...value,
             resolution: {
                 ...resolution,
-                maximumSegments: Math.min(resolution.maximumSegments ?? limits.maxCircularSegments, limits.maxCircularSegments),
-                minimumSegments: Math.min(resolution.minimumSegments ?? 16, limits.maxCircularSegments),
+                maxSegments: Math.min(resolution.maxSegments ?? limits.maxCircularSegments, limits.maxCircularSegments),
+                minSegments: Math.min(resolution.minSegments ?? 16, limits.maxCircularSegments),
                 ...value.resolution,
             },
             limits,

package/dist/engine/pattern-operations.js

@@ -28,7 +28,7 @@ export function createPatternOperations(environment, transforms) {
             const shape = typeof source === "function" ? source(index) : source;
             if (typeof source === "function")
                 budget(shape, 1);
-            const matrix = plan.transformAt(index);
+            const matrix = plan.transformAt(index, kind === "section" ? 2 : 3);
             copies.push(matrix.every((value, i) => value === IDENTITY_TRANSFORM3[i])
                 ? shape
                 : kind === "section"

package/dist/engine/placement.js

@@ -1,5 +1,5 @@
 import { validateAnalyzedSolidMesh } from "../geometry/mesh/mesh-solid.js";
-import { measureTriangleMesh } from "../geometry/mesh/mesh.js";
+import { analyzeTriangleMesh } from "../geometry/mesh/mesh.js";
 import { composeTransform3, eulerTransform3, translationTransform3, } from "../geometry/transform3.js";
 /** Places already validated immutable geometry once, retaining its indexed topology. */
 export function placeFinalizedGeometry(source, position, rotation, meshValidation) {
@@ -16,7 +16,7 @@ export function placeFinalizedGeometry(source, position, rotation, meshValidatio
     const mesh = { positions, indices: source.indices };
     // Rigid placement preserves indexed connectivity. Measure actual Float32 world output to keep
     // exact bounds/volume/area without another topology or kernel pass under the default policy.
-    const measurements = Object.freeze({ ...source.measurements, ...measureTriangleMesh(mesh) });
+    const measurements = Object.freeze({ ...source.measurements, ...analyzeTriangleMesh(mesh) });
     // Float32 placement can close gaps between shells even when the local mesh passed validation.
     if (meshValidation === "solid")
         validateAnalyzedSolidMesh(mesh, measurements);

package/dist/engine/primitive-anchors.js

@@ -1,4 +1,4 @@
-import { boxAnchor3, createAnchor3 } from "../geometry/anchors.js";
+import { anchor3, boxAnchor3 } from "../geometry/anchors.js";
 import { resolveCylinderRadii } from "../geometry/cylinder.js";
 const faces = ["left", "right", "back", "front", "bottom", "top"];
 /** Nominal primitive datums; construction validates dimensions before these factories run. */
@@ -6,7 +6,7 @@ export function boxAnchors(options) {
     const size = typeof options.size === "number" ? [options.size, options.size, options.size] : options.size;
     const center = options.center === false ? [size[0] / 2, size[1] / 2, size[2] / 2] : [0, 0, 0];
     return {
-        center: createAnchor3(center, [0, 0, 1]),
+        center: anchor3(center, [0, 0, 1]),
         ...Object.fromEntries(faces.map((face) => [
             face,
             boxAnchor3({
@@ -24,13 +24,13 @@ function axialAnchors(radii, height, centered) {
     const radius = (radii[0] + radii[1]) / 2;
     const slope = (radii[1] - radii[0]) / height;
     return {
-        center: createAnchor3([0, 0, middle], [0, 0, 1]),
-        ...(radii[0] === 0 ? {} : { bottom: createAnchor3([0, 0, bottom], [0, 0, -1]) }),
-        ...(radii[1] === 0 ? {} : { top: createAnchor3([0, 0, bottom + height], [0, 0, 1]) }),
-        right: createAnchor3([radius, 0, middle], [1, 0, -slope], [0, 0, 1]),
-        left: createAnchor3([-radius, 0, middle], [-1, 0, -slope], [0, 0, 1]),
-        front: createAnchor3([0, radius, middle], [0, 1, -slope], [0, 0, 1]),
-        back: createAnchor3([0, -radius, middle], [0, -1, -slope], [0, 0, 1]),
+        center: anchor3([0, 0, middle], [0, 0, 1]),
+        ...(radii[0] === 0 ? {} : { bottom: anchor3([0, 0, bottom], [0, 0, -1]) }),
+        ...(radii[1] === 0 ? {} : { top: anchor3([0, 0, bottom + height], [0, 0, 1]) }),
+        right: anchor3([radius, 0, middle], [1, 0, -slope], [0, 0, 1]),
+        left: anchor3([-radius, 0, middle], [-1, 0, -slope], [0, 0, 1]),
+        front: anchor3([0, radius, middle], [0, 1, -slope], [0, 0, 1]),
+        back: anchor3([0, -radius, middle], [0, -1, -slope], [0, 0, 1]),
     };
 }
 /** Cylinder and frustum cap anchors omit an end whose nominal radius is zero. */
@@ -55,16 +55,16 @@ export function torusAnchors(options) {
 export function planarAnchors(size, centered = true) {
     const x = centered ? 0 : size[0] / 2, y = centered ? 0 : size[1] / 2;
     return {
-        center: createAnchor3([x, y, 0], [0, 0, 1]),
-        top: createAnchor3([x, y, 0], [0, 0, 1]),
-        bottom: createAnchor3([x, y, 0], [0, 0, -1]),
-        right: createAnchor3([x + size[0] / 2, y, 0], [1, 0, 0], [0, 0, 1]),
-        left: createAnchor3([x - size[0] / 2, y, 0], [-1, 0, 0], [0, 0, 1]),
-        front: createAnchor3([x, y + size[1] / 2, 0], [0, 1, 0], [0, 0, 1]),
-        back: createAnchor3([x, y - size[1] / 2, 0], [0, -1, 0], [0, 0, 1]),
+        center: anchor3([x, y, 0], [0, 0, 1]),
+        top: anchor3([x, y, 0], [0, 0, 1]),
+        bottom: anchor3([x, y, 0], [0, 0, -1]),
+        right: anchor3([x + size[0] / 2, y, 0], [1, 0, 0], [0, 0, 1]),
+        left: anchor3([x - size[0] / 2, y, 0], [-1, 0, 0], [0, 0, 1]),
+        front: anchor3([x, y + size[1] / 2, 0], [0, 1, 0], [0, 0, 1]),
+        back: anchor3([x, y - size[1] / 2, 0], [0, -1, 0], [0, 0, 1]),
     };
 }
 /** A construction-origin reference for primitives without meaningful principal side datums. */
 export const originAnchor = () => ({
-    center: createAnchor3([0, 0, 0], [0, 0, 1]),
+    center: anchor3([0, 0, 0], [0, 0, 1]),
 });

package/dist/engine/primitive-operations.js

@@ -137,7 +137,7 @@ export function createPrimitiveOperations(environment, transforms, sections) {
             return environment.rememberPrimitiveProfile(section, polygonSectionProfile(`polygon-${value.sides}`, loop, resolved.resolution, resolved.limits));
         }),
         star: (value) => placedSection(value, () => {
-            const angle = (validateFiniteNumber(value.rotationDegrees ?? 0, "star") * Math.PI) / 180;
+            const angle = (validateFiniteNumber(value.rotation ?? 0, "star") * Math.PI) / 180;
             const resolved = withResolutionDefaults(value);
             const loop = starContour(value.outerRadius, value.points, value.innerRadius, resolved.limits).map(([x, y]) => [
                 x * Math.cos(angle) - y * Math.sin(angle),

package/dist/engine/primitive-profiles.js

@@ -44,8 +44,8 @@ export function ellipticalSectionProfile(radii, options, resolution, limits, fac
                                 kind: "arc",
                                 center: [0, 0],
                                 radius,
-                                startDegrees: 0,
-                                sweepDegrees: 360,
+                                startAngle: 0,
+                                sweepAngle: 360,
                                 ...(segments === undefined ? {} : { segments }),
                             },
                         ],
@@ -181,16 +181,16 @@ export function correspondingPrimitiveProfiles(sources, options, limits) {
                         const policy = source.spanResolution?.[span.id] ?? source.resolution;
                         const original = resolveGeometryResolution({
                             ...policy,
-                            maximumSegments: Math.min(policy.maximumSegments ?? selected.maxCircularSegments, selected.maxCircularSegments),
-                            minimumSegments: Math.min(policy.minimumSegments ?? 16, selected.maxCircularSegments),
+                            maxSegments: Math.min(policy.maxSegments ?? selected.maxCircularSegments, selected.maxCircularSegments),
+                            minSegments: Math.min(policy.minSegments ?? 16, selected.maxCircularSegments),
                         }, selected);
                         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)),
+                            maxSegments: Math.min(original.maxSegments, target.maxSegments),
+                            minSegments: Math.min(Math.max(original.minSegments, target.minSegments), Math.min(original.maxSegments, target.maxSegments)),
                             ...(Number.isFinite(edgeLength) ? { maxSegmentLength: edgeLength } : {}),
                             ...(target.circularSegments === undefined
                                 ? {}
@@ -199,7 +199,7 @@ export function correspondingPrimitiveProfiles(sources, options, limits) {
                         const segments = span.kind === "arc"
                             ? span.radius === 0
                                 ? 1
-                                : resolveArcSegments(span.radius, Math.abs(span.sweepDegrees), resolution, selected)
+                                : resolveArcSegments(span.radius, Math.abs(span.sweepAngle), resolution, selected)
                             : span.kind === "line"
                                 ? resolveLineSegmentCount(Math.hypot(span.end[0] - span.start[0], span.end[1] - span.start[1]), resolution.maxSegmentLength)
                                 : resolveUniformCubicSegments(planarCubicControl(span), resolveGeometryResolution(resolution, selected), selected.maxProfilePoints);

package/dist/engine/profile-mesh.js

@@ -42,12 +42,12 @@ function profileMeshAllocation(first, stationCount, limits, closed) {
             fail("Matched contours require at least three logical points and paired span identities.");
         logicalCount += contour.points.length;
     }
-    const maximumVertices = logicalCount * stationCount;
+    const maxVertices = logicalCount * stationCount;
     const capTriangles = 2 * (logicalCount + firstContours.length * 2);
     const maximumTriangles = (closed ? stationCount : stationCount - 1) * logicalCount * 2 + (closed ? 0 : capTriangles);
     assertSamplingCount(logicalCount, "loft", limits.maxProfilePoints);
-    assertMeshAllocationWithinLimits(maximumVertices, maximumTriangles, 12 * (maximumVertices + maximumTriangles), "loft", limits);
-    return { firstContours, maximumVertices, maximumTriangles };
+    assertMeshAllocationWithinLimits(maxVertices, maximumTriangles, 12 * (maxVertices + maximumTriangles), "loft", limits);
+    return { firstContours, maxVertices, maximumTriangles };
 }
 /** Internal native hole-cap triangulation over copied, explicit matched logical slots. */
 export function buildProfileLoftMesh(module, stations, limits, closed = false, seamProfileOffset = 0, positionFor) {
@@ -55,8 +55,8 @@ export function buildProfileLoftMesh(module, stations, limits, closed = false, s
         fail("Profile lofts require a bounded station array with two stations, or three for a closed path.");
     assertSamplingCount(stations.length, "loft", limits.maxPathPoints);
     const first = stations[0].profile;
-    const { firstContours, maximumVertices, maximumTriangles } = profileMeshAllocation(first, stations.length, limits, closed);
-    const positions = new Float32Array(maximumVertices * 3);
+    const { firstContours, maxVertices, maximumTriangles } = profileMeshAllocation(first, stations.length, limits, closed);
+    const positions = new Float32Array(maxVertices * 3);
     const indices = new Uint32Array(maximumTriangles * 3);
     let vertexCount = 0, cursor = 0;
     const physicalStations = stations.map((station, stationIndex) => {
@@ -205,9 +205,9 @@ export function buildProfileSweepMesh(module, profile, inputPath, options, limit
     assertSamplingCount(contourList(profile).reduce((count, contour) => count + contour.points.length, 0), "sweep", limits.maxSweepProfilePoints);
     profileMeshAllocation(profile, path.length, limits, closed);
     let scales = resolveSweepScales(options.scale, path.length);
-    const twist = options.twistDegrees ?? 0;
+    const twist = options.twist ?? 0;
     if (!Number.isFinite(twist))
-        fail("Sweep twistDegrees must be finite.");
+        fail("Sweep twist must be finite.");
     const seamProfileOffset = options.seamProfileOffset ?? 0;
     if (!Number.isSafeInteger(seamProfileOffset) || (!closed && seamProfileOffset !== 0))
         fail("A finite integer seamProfileOffset requires a closed path.");

package/dist/engine/recipe-realization.js

@@ -2,6 +2,7 @@ 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 { generationDataMetadata } from "../model/immutable-generation-data.js";
 /**
  * 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.
@@ -117,6 +118,11 @@ function* recipeShapes(values, seen = new Set()) {
         if (typeof value !== "object" || value === null || seen.has(value))
             continue;
         seen.add(value);
+        const metadata = generationDataMetadata(value);
+        if (metadata !== undefined) {
+            yield* recipeShapes(metadata.children, seen);
+            continue;
+        }
         if (isGeometryRecipe(value))
             yield value;
         else if (!isImmutableBuffer(value) &&

package/dist/engine/section-operations.js

@@ -1,22 +1,33 @@
+import { path2InputData, path2InputPointCount, } from "../geometry/paths/path-value.js";
 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";
 import * as kernel from "./native/index.js";
+import { MAX_AGGREGATE_CONTOURS } from "./native/regions.js";
 /** Internal host-bound section operations. */
 export function createSectionOperations(environment, transforms) {
     const { module, limits, scope, assertActive, throwGeometryError, nativeSolid, nativeSection, wrapSection, ownSection, validateFiniteNumber, validateCoordinates, assertOperandCount, withResolutionDefaults, resolveCircularSegments, } = environment;
     const { translate } = transforms.operations;
-    const fromContours = (contours, fillRule = "nonzero") => {
-        assertActive();
-        assertOperandCount(contours, "polygon", 0);
+    const preflightContours = (contours) => {
         let count = 0;
-        const copied = Array.from(contours, (contour) => {
-            if (!Array.isArray(contour) || contour.length < 3)
+        for (const contour of contours) {
+            const points = path2InputPointCount(contour, true);
+            if (points < 3)
                 throwGeometryError("INVALID_ARGUMENT", "polygon", "Each contour needs at least three points.");
-            count += contour.length;
+            count += points;
             assertSamplingCount(count, "polygon", limits.maxProfilePoints);
+        }
+    };
+    const fromContours = (contours, fillRule = "nonzero") => {
+        assertActive();
+        assertOperandCount(contours, "polygon", 0);
+        preflightContours(contours);
+        const copied = Array.from(contours, (input) => {
+            const contour = path2InputData(input, true, {
+                maxPathPoints: limits.maxProfilePoints,
+            }).points;
             return Array.from(contour, (point) => {
                 validateCoordinates(point, 2, "polygon");
                 return [point[0], point[1]];
@@ -31,7 +42,8 @@ export function createSectionOperations(environment, transforms) {
     const operations = {
         polygon: (input) => {
             assertActive();
-            if (Array.isArray(input))
+            if (Array.isArray(input) ||
+                (typeof input === "object" && input !== null && "toArray" in input))
                 return fromContours([input]);
             if (typeof input !== "object" || input === null)
                 throwGeometryError("INVALID_ARGUMENT", "polygon", "Use an outline or polygon options.");
@@ -47,7 +59,20 @@ export function createSectionOperations(environment, transforms) {
             if ("outer" in options) {
                 if ("contours" in options || "fillRule" in options)
                     throwGeometryError("INVALID_ARGUMENT", "polygon", "Explicit topology excludes compound fill options.");
-                return wrapSection(kernel.regionToCrossSection(scope, [{ outer: options.outer, holes: options.holes === undefined ? [] : options.holes }], limits));
+                const holes = options.holes ?? [];
+                const holesArray = Array.isArray(holes);
+                if (!holesArray)
+                    throwGeometryError("INVALID_ARGUMENT", "polygon", "Polygon holes must be an array.");
+                assertSamplingCount(holes.length + 1, "polygon", MAX_AGGREGATE_CONTOURS);
+                preflightContours([options.outer, ...holes]);
+                return wrapSection(kernel.regionToCrossSection(scope, [
+                    {
+                        outer: path2InputData(options.outer, true, {
+                            maxPathPoints: limits.maxProfilePoints,
+                        }).points,
+                        holes: holes.map((hole) => path2InputData(hole, true, { maxPathPoints: limits.maxProfilePoints }).points),
+                    },
+                ], limits));
             }
             if (!("contours" in options) || "holes" in options)
                 throwGeometryError("INVALID_ARGUMENT", "polygon", "Compound fill requires contours without explicit holes.");

package/dist/engine/session-snapshot.js

@@ -65,7 +65,11 @@ function capturePart(id, geometry, placement, worldGeometry) {
     return part;
 }
 /** Isolates a snapshot's lifetime from the cache transaction that produced it. */
-function createSnapshot(parts, { bounds, stats }, diagnostics, dependencies) {
+function createSnapshot(parts, { bounds, stats }, diagnostics, dependencies, generationStartedAt) {
+    const completedStats = Object.freeze({
+        ...stats,
+        generationMs: performance.now() - generationStartedAt,
+    });
     let ownedParts = Object.freeze(parts);
     const requireParts = () => ownedParts ?? invalid("This model snapshot has been disposed.");
     return Object.freeze({
@@ -78,7 +82,7 @@ function createSnapshot(parts, { bounds, stats }, diagnostics, dependencies) {
         },
         get stats() {
             requireParts();
-            return stats;
+            return completedStats;
         },
         diagnostics: Object.freeze([...diagnostics]),
         dependencies,
@@ -98,7 +102,7 @@ export function createSnapshotCache(options, limits) {
     let resourceCache = new Map();
     let placedCache = new Map();
     return {
-        capture({ output, native, deferred, startedAt, builtAt, diagnostics, readDependencies, }) {
+        capture({ output, native, deferred, startedAt, builtAt, generationStartedAt, diagnostics, readDependencies, }) {
             const nextResources = new Map();
             const nextPlaced = new Map();
             const worldParts = [];
@@ -131,8 +135,14 @@ export function createSnapshotCache(options, limits) {
                 summary.add(placed);
                 worldParts.push(capturePart(descriptor.id, resource.public, placement, placed));
             }
+            const model = summary.finish(startedAt, builtAt);
+            const dependencies = readDependencies();
+            let snapshot;
             return {
-                snapshot: createSnapshot(worldParts, summary.finish(startedAt, builtAt), diagnostics, readDependencies()),
+                // Publish only after retention, native cleanup and cache commit have succeeded.
+                get snapshot() {
+                    return (snapshot ??= createSnapshot(worldParts, model, diagnostics, dependencies, generationStartedAt));
+                },
                 retainedValues: [
                     ...nextResources.keys(),
                     ...[...nextResources.values()].map((resource) => resource.geometry),

package/dist/engine/session.js

@@ -41,6 +41,7 @@ export function createSession(program, suppliedOptions, engineLimits, transactio
     let disposed = false;
     let running = false;
     function execute(input, mode) {
+        const startedAt = performance.now();
         if (disposed)
             invalid("This model session has been disposed.");
         if (running)
@@ -48,14 +49,14 @@ export function createSession(program, suppliedOptions, engineLimits, transactio
         if (typeof input !== "object" || input === null || Array.isArray(input))
             invalid("Parameters must be a plain object.");
         running = true;
-        const revision = new SessionRevision(context);
+        const revision = new SessionRevision(context, startedAt);
+        let completed;
         try {
-            const completed = transaction(options, (native) => revision.execute(input, native, mode));
+            completed = transaction(options, (native) => revision.execute(input, native, mode));
             if (completed.kind === "validation")
                 return completed.diagnostics;
             // Nothing becomes reusable until geometry validation AND native cleanup have succeeded.
             revision.commit();
-            return completed.snapshot;
         }
         finally {
             try {
@@ -65,6 +66,7 @@ export function createSession(program, suppliedOptions, engineLimits, transactio
                 running = false;
             }
         }
+        return completed.capture.snapshot;
     }
     return Object.freeze({
         run: (params) => execute(params, "run"),
@@ -89,11 +91,13 @@ export function createSession(program, suppliedOptions, engineLimits, transactio
  */
 class SessionRevision {
     session;
+    startedAt;
     revision;
     cacheCandidate;
     nativeDepth = 0;
-    constructor(session) {
+    constructor(session, startedAt) {
         this.session = session;
+        this.startedAt = startedAt;
     }
     execute(input, native, mode) {
         const { owner, limits, caches } = this.session;
@@ -119,11 +123,12 @@ class SessionRevision {
             deferred,
             startedAt,
             builtAt: performance.now(),
+            generationStartedAt: this.startedAt,
             diagnostics: revision.diagnostics,
             readDependencies: () => revision.dependencies(output),
         });
         this.prepareNativeCache(revision, captured, deferred, native);
-        return { kind: "snapshot", snapshot: captured.snapshot };
+        return { kind: "snapshot", capture: captured };
     }
     /** Retention is optional: an over-budget revision still produces a valid uncached snapshot. */
     prepareNativeCache(revision, captured, deferred, native) {

package/dist/engine/shape-anchors.js

@@ -1,4 +1,4 @@
-import { createAnchor3 } from "../geometry/anchors.js";
+import { anchor3 } from "../geometry/anchors.js";
 import { GeometryError } from "../geometry/errors.js";
 import { applyInverseTranspose3, applyTransformDirection3, applyTransformPoint3, inverseLinearTransform3, } from "../geometry/transform3.js";
 const maximumAnchors = 128;
@@ -15,7 +15,7 @@ function copyAnchor(anchor, operation) {
     for (const vector of [anchor.position, anchor.direction, anchor.up])
         if (!Array.isArray(vector) || vector.length !== 3 || !vector.every(Number.isFinite))
             fail(operation, "Anchor vectors must contain exactly three finite coordinates.");
-    return createAnchor3(anchor.position, anchor.direction, anchor.up);
+    return anchor3(anchor.position, anchor.direction, anchor.up);
 }
 function unit(vector) {
     const maximum = Math.max(...vector.map(Math.abs));
@@ -27,7 +27,7 @@ function unit(vector) {
 }
 /** Maps positions affinely, outward normals by inverse transpose, and roll tangents linearly. */
 function transformedAnchor(anchor, matrix, inverse) {
-    return createAnchor3(applyTransformPoint3(matrix, anchor.position), applyInverseTranspose3(inverse, anchor.direction), unit(applyTransformDirection3(matrix, anchor.up)));
+    return anchor3(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) {

package/dist/engine/transform-operations.js

@@ -1,4 +1,4 @@
-import { attachTransform } from "../geometry/anchors.js";
+import { attachmentTransform3 } from "../geometry/anchors.js";
 import { vector2Data, vector3Data, } from "../geometry/math/vector-value.js";
 import { assertPrimitiveOptions } from "../geometry/primitive-resolvers.js";
 import { transform2, transform3, } from "../geometry/transform-chain.js";
@@ -171,29 +171,29 @@ export function createTransformOperations(environment) {
         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);
     });
-    const placementMatrix = (placement, shape) => {
-        if (placement === undefined)
+    const attachmentMatrix = (attachment, shape) => {
+        if (attachment === undefined)
             return undefined;
-        if (typeof placement !== "object" || placement === null || Array.isArray(placement))
-            throwGeometryError("INVALID_ARGUMENT", "placement", "placement must be an explicit source/target anchor object.");
-        const source = typeof placement.source === "string"
+        if (typeof attachment !== "object" || attachment === null || Array.isArray(attachment))
+            throwGeometryError("INVALID_ARGUMENT", "attachment", "attachment must be an explicit source/target anchor object.");
+        const source = typeof attachment.source === "string"
             ? shape === undefined
-                ? throwGeometryError("INVALID_ARGUMENT", "placement", "Named source anchors require a constructed shape.")
-                : environment.anchor(shape, placement.source)
-            : placement.source;
-        for (const anchor of [source, placement.target]) {
+                ? throwGeometryError("INVALID_ARGUMENT", "attachment", "Named source anchors require a constructed shape.")
+                : environment.anchor(shape, attachment.source)
+            : attachment.source;
+        for (const anchor of [source, attachment.target]) {
             if (typeof anchor !== "object" || anchor === null)
-                throwGeometryError("INVALID_ARGUMENT", "placement", "Placement requires explicit source and target anchors.");
-            validateCoordinates(anchor.position, 3, "placement");
-            validateCoordinates(anchor.direction, 3, "placement");
-            validateCoordinates(anchor.up, 3, "placement");
+                throwGeometryError("INVALID_ARGUMENT", "attachment", "Attachment requires explicit source and target anchors.");
+            validateCoordinates(anchor.position, 3, "attachment");
+            validateCoordinates(anchor.direction, 3, "attachment");
+            validateCoordinates(anchor.up, 3, "attachment");
         }
-        const spinDegrees = validateFiniteNumber(placement.spinDegrees ?? 0, "placement");
-        return attachTransform(source, placement.target, {
-            ...(placement.alignment === undefined ? {} : { alignment: placement.alignment }),
-            ...(placement.gap === undefined ? {} : { gap: placement.gap }),
-            ...(placement.tolerance === undefined ? {} : { tolerance: placement.tolerance }),
-            spinRadians: (spinDegrees * Math.PI) / 180,
+        const spin = validateFiniteNumber(attachment.spin ?? 0, "attachment");
+        return attachmentTransform3(source, attachment.target, {
+            ...(attachment.alignment === undefined ? {} : { alignment: attachment.alignment }),
+            ...(attachment.gap === undefined ? {} : { gap: attachment.gap }),
+            ...(attachment.tolerance === undefined ? {} : { tolerance: attachment.tolerance }),
+            spin,
         });
     };
     const placedSolid = (value, create, anchors) => {
@@ -201,17 +201,17 @@ export function createTransformOperations(environment) {
         const solid = wrapSolid(create());
         if (anchors !== undefined)
             environment.rememberAnchors(solid, anchors());
-        const matrix = placementMatrix(value.placement, solid);
+        const matrix = attachmentMatrix(value.attachment, solid);
         return matrix === undefined ? solid : transform(solid, matrix);
     };
     const placedSection = (value, create) => {
         assertPrimitiveOptions(value, "primitive");
         const section = create();
-        const matrix = placementMatrix(value.placement, section);
+        const matrix = attachmentMatrix(value.attachment, section);
         if (matrix === undefined)
             return section;
         if (Math.abs(matrix[8]) > 1e-10 || Math.abs(matrix[9]) > 1e-10 || Math.abs(matrix[11]) > 1e-10)
-            throwGeometryError("INVALID_ARGUMENT", "placement", "Section placement must preserve the XY plane.");
+            throwGeometryError("INVALID_ARGUMENT", "attachment", "Section attachment must preserve the XY plane.");
         const xy = [
             matrix[0],
             matrix[1],
@@ -234,7 +234,7 @@ export function createTransformOperations(environment) {
         transform,
         attach: (value, source, target, valueOptions) => {
             nativeSolid(value);
-            const matrix = placementMatrix({ ...valueOptions, source, target }, value);
+            const matrix = attachmentMatrix({ ...valueOptions, source, target }, value);
             return transform(value, matrix);
         },
     };