@metamesh/modeling 0.12.0 → 0.14.0

package/dist/engine/native/regions.js

@@ -1,5 +1,5 @@
 import { GeometryError } from "../../geometry/errors.js";
-import { loopContainsPoint, normalizeLoop2, normalizeRegion2, signedAreaLoop2, } from "../../geometry/regions.js";
+import { contourContainsPoint, normalizeContour, normalizeRegion, signedContourArea, } from "../../geometry/regions.js";
 import { assertSamplingCount, resolveGeometrySamplingLimits, } from "../../geometry/sampling-limits.js";
 import { assertScopedManifoldValue, ownScopedManifoldValue, scopedManifoldModule, } from "./context.js";
 const MAX_AGGREGATE_CONTOURS = 25_000;
@@ -75,7 +75,7 @@ const contoursFromRegion = (region) => region
  */
 export function regionToCrossSection(context, region, limits = {}) {
     assertRegionBounds([region], "regionToCrossSection", limits);
-    const normalized = normalizeRegion2(region);
+    const normalized = normalizeRegion(region);
     const module = scopedManifoldModule(context);
     if (normalized.length === 0)
         return ownScopedManifoldValue(context, module.CrossSection.union([]));
@@ -83,11 +83,11 @@ export function regionToCrossSection(context, region, limits = {}) {
 }
 const regionFromLoops = (loops) => {
     const outers = loops
-        .filter((loop) => signedAreaLoop2(loop) > 0)
-        .map((outer) => ({ outer: normalizeLoop2(outer, true), holes: [] }));
+        .filter((loop) => signedContourArea(loop) > 0)
+        .map((outer) => ({ outer: normalizeContour(outer, true), holes: [] }));
     const holes = loops
-        .filter((loop) => signedAreaLoop2(loop) < 0)
-        .map((hole) => normalizeLoop2(hole, false));
+        .filter((loop) => signedContourArea(loop) < 0)
+        .map((hole) => normalizeContour(hole, false));
     if (outers.length === 0 && loops.length > 0) {
         throw new GeometryError("INVALID_TOPOLOGY", "CrossSection did not contain an exterior contour.");
     }
@@ -113,15 +113,15 @@ const regionFromLoops = (loops) => {
                 x <= bounds.maximumX &&
                 y >= bounds.minimumY &&
                 y <= bounds.maximumY &&
-                loopContainsPoint(polygon.outer, hole[0]));
+                contourContainsPoint(polygon.outer, hole[0]));
         })
-            .sort((a, b) => Math.abs(signedAreaLoop2(a.outer)) - Math.abs(signedAreaLoop2(b.outer)))[0];
+            .sort((a, b) => Math.abs(signedContourArea(a.outer)) - Math.abs(signedContourArea(b.outer)))[0];
         if (owner === undefined) {
             throw new GeometryError("INVALID_TOPOLOGY", "CrossSection hole had no containing exterior.");
         }
         owner.holes.push(hole);
     }
-    return normalizeRegion2(outers.map(({ outer, holes }) => ({ outer, holes: Object.freeze(holes) })));
+    return normalizeRegion(outers.map(({ outer, holes }) => ({ outer, holes: Object.freeze(holes) })));
 };
 /** Copies a robust CrossSection into MetaMesh's explicit outer/hole topology. */
 export function crossSectionToRegion(context, section, limits = {}) {

package/dist/engine/native/transforms.js

@@ -33,7 +33,12 @@ export function rotate(context, solid, xyzDegrees) {
 export function scale(context, solid, factors) {
     assertScopedManifoldValue(context, solid);
     const values = typeof factors === "number" ? [factors] : factors;
-    if (!values.every(Number.isFinite) || values.some((value) => value === 0)) {
+    if (!values.every(Number.isFinite)) {
+        throw new GeometryError("NON_FINITE_VALUE", "Scale factors must be finite.", {
+            operation: "scale",
+        });
+    }
+    if (values.some((value) => value === 0)) {
         throw new GeometryError("SINGULAR_TRANSFORM", "Scale factors must be finite and non-zero.", {
             operation: "scale",
         });

package/dist/engine/pattern-operations.js

@@ -1,36 +1,47 @@
+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 { gridPatternPlan, linearPatternPlan, pathPatternPlan, radialPatternPlan, } from "./pattern-placements.js";
 /** Private pattern owner; all copies use the shared transform/metadata/lifetime path. */
 export function createPatternOperations(environment, transforms) {
     const apply = (source, makePlan, operation) => {
         environment.assertActive();
         const plan = makePlan();
         let vertices = 0, triangles = 0;
-        const budget = (solid, multiplier) => {
-            const native = environment.nativeSolid(solid);
-            vertices += native.numVert() * multiplier;
-            triangles += native.numTri() * multiplier;
+        let kind;
+        const budget = (shape, multiplier) => {
+            const native = environment.resolveHandle(shape);
+            if (kind !== undefined && native.kind !== kind)
+                environment.throwGeometryError("INVALID_ARGUMENT", operation, "Pattern factories must return one shape dimension.");
+            kind = native.kind;
+            vertices += native.value.numVert() * multiplier;
+            if (native.kind === "solid")
+                triangles += native.value.numTri() * multiplier;
+            else
+                assertSamplingCount(vertices, operation, environment.limits.maxProfilePoints);
             environment.assertMeshAllocation(vertices, triangles, (vertices + triangles) * 12, operation);
         };
         if (typeof source !== "function")
             budget(source, plan.count);
         const copies = [];
         for (let index = 0; index < plan.count; index++) {
-            const solid = typeof source === "function" ? source(index) : source;
+            const shape = typeof source === "function" ? source(index) : source;
             if (typeof source === "function")
-                budget(solid, 1);
+                budget(shape, 1);
             const matrix = plan.transformAt(index);
             copies.push(matrix.every((value, i) => value === IDENTITY_TRANSFORM3[i])
-                ? solid
-                : transforms.operations.transform(solid, matrix));
+                ? shape
+                : kind === "section"
+                    ? transforms.operations.transform(shape, restrictTransform3(matrix))
+                    : transforms.operations.transform(shape, matrix));
         }
         return copies;
     };
     const operations = {
-        linearPattern: (source, options) => apply(source, () => linearPatternPlan(options), "linearPattern"),
-        radialPattern: (source, options) => apply(source, () => radialPatternPlan(options), "radialPattern"),
-        gridPattern: (source, options) => apply(source, () => gridPatternPlan(options), "gridPattern"),
-        pathPattern: (source, path, options) => apply(source, () => pathPatternPlan(path, options, environment.limits), "pathPattern"),
+        linearPattern: ((source, options) => apply(source, () => linearPatternPlan(options), "linearPattern")),
+        radialPattern: ((source, options) => apply(source, () => radialPatternPlan(options), "radialPattern")),
+        gridPattern: ((source, options) => apply(source, () => gridPatternPlan(options), "gridPattern")),
+        pathPattern: ((source, path, options) => apply(source, () => pathPatternPlan(path, options, environment.limits), "pathPattern")),
     };
     return operations;
 }

package/dist/engine/placement.js

@@ -1,5 +1,5 @@
-import { validateAnalyzedSolidMesh } from "../geometry/mesh-solid.js";
-import { measureTriangleMesh } from "../geometry/mesh.js";
+import { validateAnalyzedSolidMesh } from "../geometry/mesh/mesh-solid.js";
+import { measureTriangleMesh } 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) {

package/dist/engine/primitive-operations.js

@@ -1,9 +1,9 @@
 import { resolveCylinderRadii } from "../geometry/cylinder.js";
 import { resolveModelingLimits } from "../geometry/model-limits.js";
 import { assertPrimitiveOptions } from "../geometry/primitive-resolvers.js";
-import { regularPolygonLoop, starLoop } from "../geometry/profiles/profiles.js";
-import { rectangleLoop, resolveRectangle, } from "../geometry/profiles/rectangle.js";
-import { ellipseLoop } from "../geometry/profiles/shapes.js";
+import { regularPolygonContour, starContour } from "../geometry/profiles/profiles.js";
+import { rectangleContour, resolveRectangle, } from "../geometry/profiles/rectangle.js";
+import { ellipseContour } from "../geometry/profiles/shapes.js";
 import { requireProfileVertexCount } from "../geometry/profiles/validation.js";
 import * as kernel from "./native/index.js";
 import { boxAnchors, cylinderAnchors, originAnchor, planarAnchors, sphereAnchors, torusAnchors, tubeAnchors, } from "./primitive-anchors.js";
@@ -12,7 +12,7 @@ import { ellipticalSectionProfile, polygonSectionProfile, rectangleSectionProfil
 export function createPrimitiveOperations(environment, transforms, sections) {
     const { module, scope, assertActive, throwGeometryError, ownSection, validateFiniteNumber, requirePositiveNumber, validateCoordinates, withResolutionDefaults, resolveCircularSegments, } = environment;
     const { placedSolid, placedSection } = transforms;
-    const fromContours = sections.sectionFromContours;
+    const fromContours = (contours) => sections.polygon({ contours });
     const operations = {
         box: (value) => {
             assertActive();
@@ -74,7 +74,7 @@ export function createPrimitiveOperations(environment, transforms, sections) {
         rectangle: (value) => placedSection(value, () => {
             assertActive();
             const resolved = withResolutionDefaults(value);
-            resolveRectangle(resolved, "rectangle");
+            const { setbacks } = resolveRectangle(resolved, "rectangle");
             const treatment = value.treatment;
             const resolvedCorner = (corner) => corner.kind === "round" || corner.kind === "smooth"
                 ? withResolutionDefaults({
@@ -92,9 +92,9 @@ export function createPrimitiveOperations(environment, transforms, sections) {
                             : resolvedCorner(treatment),
                     }),
             };
-            const points = rectangleLoop(options);
+            const points = rectangleContour(options);
             const dimensions = typeof value.size === "number" ? [value.size, value.size] : value.size;
-            const section = treatment === undefined
+            const section = setbacks.every((pair) => pair.every((distance) => distance === 0))
                 ? ownSection(module.CrossSection.square(dimensions, value.center ?? true))
                 : fromContours([points]);
             environment.rememberAnchors(section, planarAnchors(dimensions, value.center ?? true));
@@ -122,7 +122,7 @@ export function createPrimitiveOperations(environment, transforms, sections) {
             validateCoordinates(radii, 2, "ellipse");
             const resolved = withResolutionDefaults(value);
             const section = fromContours([
-                ellipseLoop({
+                ellipseContour({
                     radius: radii,
                     segments: resolveCircularSegments(Math.max(...radii), value),
                     limits: resolved.limits,
@@ -132,14 +132,14 @@ export function createPrimitiveOperations(environment, transforms, sections) {
             return environment.rememberPrimitiveProfile(section, ellipticalSectionProfile(radii, value, resolved.resolution, resolved.limits));
         }),
         regularPolygon: (value) => placedSection(value, () => {
-            const resolved = withResolutionDefaults(value), loop = regularPolygonLoop(resolved);
+            const resolved = withResolutionDefaults(value), loop = regularPolygonContour(resolved);
             const section = environment.rememberAnchors(fromContours([loop]), originAnchor());
             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 resolved = withResolutionDefaults(value);
-            const loop = starLoop(value.outerRadius, value.points, value.innerRadius, resolved.limits).map(([x, y]) => [
+            const loop = starContour(value.outerRadius, value.points, value.innerRadius, resolved.limits).map(([x, y]) => [
                 x * Math.cos(angle) - y * Math.sin(angle),
                 x * Math.sin(angle) + y * Math.cos(angle),
             ]);

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/profile-mesh.js

@@ -1,8 +1,8 @@
 import { GeometryError } from "../geometry/errors.js";
-import { loftFrame } from "../geometry/loft-options.js";
+import { loftFrame } from "../geometry/loft/loft-options.js";
 import { assertMeshAllocationWithinLimits } from "../geometry/model-limits.js";
 import { writeMeshVertex } from "../geometry/numeric.js";
-import { normalizeRegion2, signedAreaLoop2 } from "../geometry/regions.js";
+import { normalizeRegion, signedContourArea } from "../geometry/regions.js";
 import { assertSamplingCount } from "../geometry/sampling-limits.js";
 import { resolveSweepScales } from "../geometry/sweeps/options.js";
 import { computeSweepFrames, validateSweepOptions } from "../geometry/sweeps/orientation.js";
@@ -127,17 +127,17 @@ export function buildProfileLoftMesh(module, stations, limits, closed = false, s
         let contourIndex = 0;
         const region = profile.components.map((component) => {
             const outer = physical[contourIndex++];
-            if (!intermediateWorldGrid && !(signedAreaLoop2(outer.points) > 0))
+            if (!intermediateWorldGrid && !(signedContourArea(outer.points) > 0))
                 fail("Matched outer contours must retain CCW winding.");
             const holes = component.holes.map(() => {
                 const hole = physical[contourIndex++];
-                if (!intermediateWorldGrid && !(signedAreaLoop2(hole.points) < 0))
+                if (!intermediateWorldGrid && !(signedContourArea(hole.points) < 0))
                     fail("Matched hole contours must retain CW winding.");
                 return hole.points;
             });
             return { outer: outer.points, holes };
         });
-        const normalized = intermediateWorldGrid ? [] : normalizeRegion2(region);
+        const normalized = intermediateWorldGrid ? [] : normalizeRegion(region);
         normalized.forEach((component, index) => {
             if (component.outer.length !== region[index].outer.length ||
                 component.holes.some((hole, holeIndex) => hole.length !== region[index].holes[holeIndex].length))
@@ -163,7 +163,7 @@ export function buildProfileLoftMesh(module, stations, limits, closed = false, s
             const paired = upper[contourIndex];
             for (let index = 0; index < contour.slots.length; index += 1) {
                 const next = (index + 1) % contour.slots.length;
-                const advance = signedAreaLoop2(paired.points) < 0 ? -seamProfileOffset : seamProfileOffset;
+                const advance = signedContourArea(paired.points) < 0 ? -seamProfileOffset : seamProfileOffset;
                 const offset = closed && station === stations.length - 1
                     ? ((advance % paired.slots.length) + paired.slots.length) % paired.slots.length
                     : 0;
@@ -217,7 +217,7 @@ export function buildProfileSweepMesh(module, profile, inputPath, options, limit
         for (const contour of contourList(profile)) {
             const extent = contour.points.reduce((maximum, [x, y]) => Math.max(maximum, Math.abs(x * scaleX), Math.abs(y * scaleY)), 1);
             const tolerance = resolveGeometryTolerance(extent).linear;
-            const advance = signedAreaLoop2(contour.points) < 0 ? -seamProfileOffset : seamProfileOffset;
+            const advance = signedContourArea(contour.points) < 0 ? -seamProfileOffset : seamProfileOffset;
             const offset = ((advance % contour.points.length) + contour.points.length) % contour.points.length;
             for (let index = 0; index < contour.points.length; index++) {
                 const [x, y] = contour.points[index], target = contour.points[(index + offset) % contour.points.length];

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";
@@ -7,37 +8,63 @@ import * as kernel from "./native/index.js";
 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, value = {}) => {
+    const fromContours = (contours, fillRule = "nonzero") => {
         assertActive();
-        if (typeof value !== "object" || value === null || Array.isArray(value))
-            throwGeometryError("INVALID_ARGUMENT", "sectionFromContours", "Options must be an object.");
-        assertOperandCount(contours, "sectionFromContours", 0);
+        assertOperandCount(contours, "polygon", 0);
         let count = 0;
         const copied = Array.from(contours, (contour) => {
             if (!Array.isArray(contour) || contour.length < 3)
-                throwGeometryError("INVALID_ARGUMENT", "sectionFromContours", "Each contour needs at least three points.");
+                throwGeometryError("INVALID_ARGUMENT", "polygon", "Each contour needs at least three points.");
             count += contour.length;
-            assertSamplingCount(count, "sectionFromContours", limits.maxProfilePoints);
+            assertSamplingCount(count, "polygon", limits.maxProfilePoints);
             return Array.from(contour, (point) => {
-                validateCoordinates(point, 2, "sectionFromContours");
+                validateCoordinates(point, 2, "polygon");
                 return [point[0], point[1]];
             });
         });
-        if (value.fillRule !== undefined &&
-            value.fillRule !== "nonzero" &&
-            value.fillRule !== "evenodd")
-            throwGeometryError("INVALID_ARGUMENT", "sectionFromContours", "Unsupported fill rule.");
+        if (fillRule !== "nonzero" && fillRule !== "evenodd")
+            throwGeometryError("INVALID_ARGUMENT", "polygon", "Unsupported fill rule.");
         if (copied.length === 0)
             return ownSection(module.CrossSection.union([]));
-        return ownSection(new module.CrossSection(copied, value.fillRule === "evenodd" ? "EvenOdd" : "NonZero"));
+        return ownSection(new module.CrossSection(copied, fillRule === "evenodd" ? "EvenOdd" : "NonZero"));
     };
     const operations = {
-        sectionFromContours: fromContours,
-        fromRegion: (region) => {
+        polygon: (input) => {
             assertActive();
-            return wrapSection(kernel.regionToCrossSection(scope, region, limits));
+            if (Array.isArray(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));
+            }
+            if (!("contours" in options) || "holes" in options)
+                throwGeometryError("INVALID_ARGUMENT", "polygon", "Compound fill requires contours without explicit holes.");
+            return fromContours(options.contours, options.fillRule);
+        },
+        stroke: (path, value) => {
+            assertActive();
+            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({
@@ -77,7 +104,7 @@ export function createSectionOperations(environment, transforms) {
         },
         svgPathSection: (path, value = {}) => {
             const parsed = parseSvgPath(path, withResolutionDefaults(value));
-            const filled = parsed.groups.map((group) => fromContours(group.contours, { fillRule: group.fillRule }));
+            const filled = parsed.groups.map((group) => fromContours(group.contours, group.fillRule));
             let result = ownSection(module.CrossSection.union(filled.map(nativeSection)));
             if ((value.origin ?? "center") === "center") {
                 const bounds = nativeSection(result).bounds();

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) {
@@ -384,18 +384,20 @@ export function createGenerationGraph(options, maxParts) {
                     // Catching an assertion does not turn its revision into a successful snapshot.
                     assertNoFailedAssertion();
                     declaring = false;
-                    if (!isArray(output) || output.length === 0)
+                    const parts = isArray(output) ? output : [output];
+                    if (parts.length === 0)
                         invalid("Generation must return at least one declared part.");
-                    if (output.length > maxParts)
+                    if (parts.length > maxParts)
                         throw new GeometryError("COMPLEXITY_LIMIT", `Output exceeds ${maxParts} parts.`, {
                             operation: "generate",
                         });
                     const returnedIds = new Set();
-                    for (const descriptor of output) {
+                    for (const descriptor of parts) {
                         if (!declaredParts.has(descriptor) || returnedIds.has(descriptor.id))
                             invalid("Return each declared output part at most once.");
                         returnedIds.add(descriptor.id);
                     }
+                    return parts;
                 },
                 dependencies(output) {
                     return createModelDependencies(output, modelParameters, new Map([...computations.nodes].map(([id, node]) => [id, reusableEntry(node)])), readerIds);

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);
@@ -110,8 +110,7 @@ class SessionRevision {
     generate(revision, deferred, native, mode) {
         const { program, services, caches } = this.session;
         const startedAt = performance.now();
-        const output = program.generate({ ...revision.context, services });
-        revision.finish(output);
+        const output = revision.finish(program.generate({ ...revision.context, services }));
         if (mode === "validate")
             return { kind: "validation", diagnostics: Object.freeze([...revision.diagnostics]) };
         const captured = caches.snapshots.capture({

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),