@metamesh/modeling 0.13.0 → 0.15.0

package/dist/engine/recipe-realization.js

@@ -1,36 +1,36 @@
 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";
+import { generationDataMetadata } from "../model/immutable-generation-data.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 +53,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 +89,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) ||
@@ -111,9 +118,16 @@ 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) && !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,21 +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]];
@@ -30,25 +42,54 @@ 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.");
             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.");
-                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.");
             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]);
 };
@@ -64,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({
@@ -77,7 +82,7 @@ function createSnapshot(parts, { bounds, stats }, diagnostics, dependencies) {
         },
         get stats() {
             requireParts();
-            return stats;
+            return completedStats;
         },
         diagnostics: Object.freeze([...diagnostics]),
         dependencies,
@@ -97,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 = [];
@@ -130,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

@@ -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";
@@ -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,17 +91,19 @@ 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, 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);
@@ -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,6 +1,6 @@
-import { createAnchor3 } from "../geometry/anchors.js";
+import { anchor3 } 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 });
@@ -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,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 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) {
@@ -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 { attachmentTransform3 } 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,44 +157,43 @@ 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);
     });
-    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) => {
@@ -184,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],
@@ -217,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);
         },
     };