@metamesh/modeling 0.13.0 → 0.15.0

package/dist/engine/native/material-components.js

@@ -0,0 +1,305 @@
+import { GeometryError } from "../../geometry/errors.js";
+import { triangleSolidAngle } from "../../geometry/mesh/mesh-solid-intersections.js";
+import { assertMeshAllocationWithinLimits, } from "../../geometry/model-limits.js";
+import { ownScopedManifoldValue, scopedManifoldModule, } from "./context.js";
+import { assertNativeSolidStatus } from "./status.js";
+const MAXIMUM_CONTAINMENT_TESTS = 2_000_000;
+/** Certifies the native sign only when its floating-point error cannot reach zero. */
+function certifiedNativeOrientation(volume, bounds, triangles) {
+    const magnitudes = bounds.min.map((value, axis) => Math.max(Math.abs(value), Math.abs(bounds.max[axis])));
+    const ranges = bounds.min.map((value, axis) => bounds.max[axis] - value);
+    const magnitude = Math.max(...magnitudes);
+    // Pinned Manifold 3.5.4 src/properties.cpp:245-270 computes edge-cross/dot/6
+    // terms q followed by s'=fl(s+q), c+=fl(fl(s-s')+q). In exact algebra the
+    // compensation cancels the running-sum errors. For u=2^-53 and n*u<1/4,
+    // remaining summation error is <=(6u+7n^2*u^2)*sum(abs(q)). For
+    // P=sum(Mi*Rj*Rk), each triangle's absolute product sum is <=P/3 and its
+    // arithmetic error is <=64uP. Their total is <80*u*n*P*(1+n^2*u);
+    // 512 also covers rounding of ranges/P. This selects arithmetic, never size.
+    // These windows keep the bound finite/normal and absolute subnormal errors
+    // below its spare margin; coordinates outside them use exact arithmetic.
+    if (!Number.isFinite(volume) ||
+        triangles < 4 ||
+        triangles >= 2 ** 31 ||
+        magnitude < 2 ** -300 ||
+        magnitude > 2 ** 300 ||
+        ranges.some((range) => range < 2 ** -300 || range > 2 ** 300))
+        return undefined;
+    const productSum = magnitudes[0] * ranges[1] * ranges[2] +
+        magnitudes[1] * ranges[0] * ranges[2] +
+        magnitudes[2] * ranges[0] * ranges[1];
+    const unitRoundoff = Number.EPSILON / 2;
+    const error = 512 * unitRoundoff * triangles * productSum * (1 + triangles * triangles * unitRoundoff);
+    if (!Number.isFinite(error))
+        return undefined;
+    return Math.abs(volume) > error ? (volume < 0 ? -1 : 1) : undefined;
+}
+/** Observes native coordinates and topology without converting geometry to Float32. */
+function nativeShellMesh(scope, shell, limits) {
+    const vertices = shell.numVert();
+    const properties = shell.numPropVert();
+    const triangles = shell.numTri();
+    // Both native observation work and copied topology stay within the host's mesh limits.
+    // Charge the Float64 coordinates, Float32 property mesh, index map and triangle indices.
+    assertMeshAllocationWithinLimits(Math.max(vertices, properties), triangles, vertices * 24 + properties * (shell.numProp() + 4) * 4 + triangles * 12, "components", limits);
+    const coordinates = new Float64Array(vertices * 3);
+    const encoded = ownScopedManifoldValue(scope, shell.warpBatch((positions, count) => {
+        coordinates.set(positions);
+        for (let vertex = 0; vertex < count; vertex++) {
+            // Exact Float32-safe IDs recover native indices even when property vertices
+            // are duplicated or reordered by getMesh(). The original coordinates stay Float64.
+            positions[vertex * 3] = vertex % 65536;
+            positions[vertex * 3 + 1] = Math.floor(vertex / 65536);
+            positions[vertex * 3 + 2] = 0;
+        }
+    }));
+    assertNativeSolidStatus(encoded, "components");
+    if (encoded.numVert() !== vertices || encoded.numTri() !== triangles)
+        throw new GeometryError("INVALID_TOPOLOGY", "Native observation changed shell topology.", {
+            operation: "components",
+        });
+    const mesh = encoded.getMesh();
+    if (mesh.numVert !== properties || mesh.numTri !== triangles)
+        throw new GeometryError("INVALID_TOPOLOGY", "Native observation changed property topology.", {
+            operation: "components",
+        });
+    const indices = new Uint32Array(properties);
+    for (let vertex = 0; vertex < properties; vertex++) {
+        const offset = vertex * mesh.numProp;
+        const low = mesh.vertProperties[offset];
+        const high = mesh.vertProperties[offset + 1];
+        const index = low + high * 65536;
+        if (!Number.isInteger(low) ||
+            low < 0 ||
+            low >= 65536 ||
+            !Number.isInteger(high) ||
+            high < 0 ||
+            !Number.isSafeInteger(index) ||
+            index >= vertices ||
+            mesh.vertProperties[offset + 2] !== 0)
+            throw new GeometryError("INVALID_TOPOLOGY", "Native observation lost a vertex identity.", {
+                operation: "components",
+            });
+        indices[vertex] = index;
+    }
+    return { coordinates, vertexIndices: indices, triangles: mesh.triVerts };
+}
+/** Computes signed enclosed volume without rounding, including folded contact boundaries. */
+function nativeShellOrientation(mesh) {
+    const { coordinates, vertexIndices, triangles } = mesh;
+    const bits = new DataView(new ArrayBuffer(8));
+    const fractionMask = (1n << 52n) - 1n;
+    const representation = (value) => {
+        bits.setFloat64(0, value);
+        return bits.getBigUint64(0);
+    };
+    let minimumExponent = 2047;
+    for (const value of coordinates) {
+        if (!Number.isFinite(value))
+            throw new GeometryError("NON_FINITE_VALUE", "Native coordinates must be finite.", {
+                operation: "components",
+            });
+        if (value !== 0)
+            minimumExponent = Math.min(minimumExponent, Number((representation(value) >> 52n) & 2047n) || 1);
+    }
+    // One common binary scale makes each coefficient exact while avoiding thousands
+    // of unnecessary zero bits for ordinary millimetre coordinates.
+    const integer = (value) => {
+        if (value === 0)
+            return 0n;
+        const encodedValue = representation(value);
+        const exponent = Number((encodedValue >> 52n) & 2047n);
+        const significand = (encodedValue & fractionMask) | (exponent === 0 ? 0n : 1n << 52n);
+        const magnitude = significand << BigInt((exponent || 1) - minimumExponent);
+        return encodedValue >> 63n === 0n ? magnitude : -magnitude;
+    };
+    const origin = [integer(coordinates[0]), integer(coordinates[1]), integer(coordinates[2])];
+    const pointAt = (propertyVertex) => {
+        const offset = vertexIndices[propertyVertex] * 3;
+        return [
+            integer(coordinates[offset]) - origin[0],
+            integer(coordinates[offset + 1]) - origin[1],
+            integer(coordinates[offset + 2]) - origin[2],
+        ];
+    };
+    let volume = 0n;
+    for (let triangle = 0; triangle < triangles.length; triangle += 3) {
+        const a = pointAt(triangles[triangle]);
+        const b = pointAt(triangles[triangle + 1]);
+        const c = pointAt(triangles[triangle + 2]);
+        volume +=
+            a[0] * (b[1] * c[2] - b[2] * c[1]) +
+                a[1] * (b[2] * c[0] - b[0] * c[2]) +
+                a[2] * (b[0] * c[1] - b[1] * c[0]);
+    }
+    return volume < 0n ? -1 : volume > 0n ? 1 : 0;
+}
+/** Internal material decomposition; inward boundary shells stay with their enclosing exterior. */
+export function solidMaterialComponents(scope, solid, limits) {
+    assertNativeSolidStatus(solid, "components");
+    assertMeshAllocationWithinLimits(Math.max(solid.numVert(), solid.numPropVert()), solid.numTri(), solid.numPropVert() * (solid.numProp() + 3) * 4 + solid.numTri() * 12, "components", limits);
+    const shells = solid.decompose().map((shell) => ownScopedManifoldValue(scope, shell));
+    const boundaries = shells
+        .map((shell) => ({ shell, volume: shell.volume(), bounds: shell.boundingBox() }))
+        .filter(({ bounds }) => {
+        // Coplanar Boolean contact can leave native boundary shells without any material.
+        // Exact collapsed native bounds identify axis-aligned contacts cheaply. Do not
+        // use volume, an epsilon or Float32 mesh tests: any of them could
+        // discard a thin positive piece or an inward shell enclosing a real cavity.
+        return bounds.min.every((value, axis) => value !== bounds.max[axis]);
+    })
+        .map((entry) => ({
+        ...entry,
+        orientation: certifiedNativeOrientation(entry.volume, entry.bounds, entry.shell.numTri()),
+    }));
+    const uncertain = boundaries.filter(({ orientation }) => orientation === undefined);
+    if (uncertain.length > 0) {
+        let vertices = 0;
+        let properties = 0;
+        let triangles = 0;
+        let bytes = 0;
+        for (const { shell } of uncertain) {
+            vertices += shell.numVert();
+            properties += shell.numPropVert();
+            triangles += shell.numTri();
+            bytes +=
+                shell.numVert() * 24 +
+                    shell.numPropVert() * (shell.numProp() + 4) * 4 +
+                    shell.numTri() * 12;
+        }
+        assertMeshAllocationWithinLimits(Math.max(vertices, properties), triangles, bytes, "components", limits);
+    }
+    const meshes = new Map();
+    let observedVertices = 0;
+    let observedProperties = 0;
+    let observedTriangles = 0;
+    let observedBytes = 0;
+    const meshFor = (shell) => {
+        const cached = meshes.get(shell);
+        if (cached !== undefined)
+            return cached;
+        const vertices = observedVertices + shell.numVert();
+        const properties = observedProperties + shell.numPropVert();
+        const triangles = observedTriangles + shell.numTri();
+        const bytes = observedBytes +
+            shell.numVert() * 24 +
+            shell.numPropVert() * (shell.numProp() + 4) * 4 +
+            shell.numTri() * 12;
+        assertMeshAllocationWithinLimits(Math.max(vertices, properties), triangles, bytes, "components", limits);
+        const mesh = nativeShellMesh(scope, shell, limits);
+        meshes.set(shell, mesh);
+        observedVertices = vertices;
+        observedProperties = properties;
+        observedTriangles = triangles;
+        observedBytes = bytes;
+        return mesh;
+    };
+    const entries = boundaries
+        .map((entry) => ({
+        ...entry,
+        orientation: entry.orientation ?? nativeShellOrientation(meshFor(entry.shell)),
+    }))
+        .filter(({ orientation }) => orientation !== 0);
+    let tests = 0;
+    const spend = (count = 1) => {
+        tests += count;
+        if (tests > MAXIMUM_CONTAINMENT_TESTS)
+            throw new GeometryError("COMPLEXITY_LIMIT", "Material component containment exceeds its work ceiling.", {
+                operation: "components",
+                details: { required: tests, allowed: MAXIMUM_CONTAINMENT_TESTS },
+            });
+    };
+    const exteriors = entries.filter(({ orientation }) => orientation > 0);
+    const cavities = entries.filter(({ orientation }) => orientation < 0);
+    if (exteriors.length === 0)
+        return Object.freeze([]);
+    if (cavities.length === 0)
+        return Object.freeze(exteriors.map(({ shell }) => shell));
+    const pointAt = (mesh, index) => {
+        const offset = mesh.vertexIndices[index] * 3;
+        return [
+            mesh.coordinates[offset],
+            mesh.coordinates[offset + 1],
+            mesh.coordinates[offset + 2],
+        ];
+    };
+    const candidates = [...exteriors].sort((left, right) => Math.abs(left.volume) - Math.abs(right.volume));
+    const enclosingExterior = (entry) => {
+        return candidates.find((candidate) => {
+            spend();
+            if (candidate === entry ||
+                entry.bounds.min.some((value, axis) => value < candidate.bounds.min[axis]) ||
+                entry.bounds.max.some((value, axis) => value > candidate.bounds.max[axis]))
+                return false;
+            const childMesh = meshFor(entry.shell);
+            const point = pointAt(childMesh, childMesh.triangles[0]);
+            const mesh = meshFor(candidate.shell);
+            let angle = 0;
+            for (let triangle = 0; triangle < mesh.triangles.length; triangle += 3) {
+                spend();
+                angle += triangleSolidAngle(point, [
+                    pointAt(mesh, mesh.triangles[triangle]),
+                    pointAt(mesh, mesh.triangles[triangle + 1]),
+                    pointAt(mesh, mesh.triangles[triangle + 2]),
+                ]);
+            }
+            return Math.abs(angle) > 2 * Math.PI;
+        });
+    };
+    const module = scopedManifoldModule(scope);
+    const enclosedCavities = cavities.map((cavity) => ({
+        cavity,
+        parent: enclosingExterior(cavity),
+    }));
+    const orphanedCavity = enclosedCavities.some(({ parent }) => parent === undefined);
+    if (exteriors.length === 1 && entries.length === shells.length && !orphanedCavity)
+        return Object.freeze([solid]);
+    if (entries.length !== shells.length || orphanedCavity) {
+        // Selecting from the original would retain contact sheets inside a sealed cavity.
+        // Rebuild only this exceptional case from its material boundaries. The JS kernel's
+        // compose aliases union, so turn inward shells into positive native cutters instead.
+        const cutters = new Map(exteriors.map(({ shell }) => [shell, []]));
+        for (const { cavity, parent } of enclosedCavities) {
+            // An inward shell removes positive occupancy only inside an exterior. A lone
+            // inward contact remnant cannot define a bounded piece of material.
+            if (parent === undefined)
+                continue;
+            // Warp preserves winding while native mirror reverses it. The two exact X sign
+            // changes restore all Float64 coordinates without a mesh round-trip or tolerance.
+            spend(cavity.shell.numVert());
+            const reflected = ownScopedManifoldValue(scope, cavity.shell.warpBatch((vertices, count) => {
+                for (let vertex = 0; vertex < count; vertex++) {
+                    vertices[vertex * 3] = -vertices[vertex * 3];
+                }
+            }));
+            const cutter = ownScopedManifoldValue(scope, reflected.mirror([1, 0, 0]));
+            assertNativeSolidStatus(cutter, "components");
+            cutters.get(parent.shell).push(cutter);
+        }
+        return Object.freeze(exteriors.map(({ shell }) => {
+            const holes = cutters.get(shell);
+            const component = holes.length === 0
+                ? shell
+                : ownScopedManifoldValue(scope, module.Manifold.difference([shell, ...holes]));
+            assertNativeSolidStatus(component, "components");
+            return component;
+        }));
+    }
+    const children = new Map(exteriors.map(({ shell }) => [shell, []]));
+    for (const exterior of exteriors) {
+        const parent = enclosingExterior(exterior);
+        if (parent !== undefined)
+            children.get(parent.shell).push(exterior.shell);
+    }
+    // The JS kernel aliases compose to union, which fills independently supplied inward shells.
+    // Select from the original material instead, retaining its native precision and cavity winding.
+    return Object.freeze(exteriors.map(({ shell }) => {
+        const selected = ownScopedManifoldValue(scope, solid.intersect(shell));
+        const nested = children.get(shell);
+        const component = nested.length === 0
+            ? selected
+            : ownScopedManifoldValue(scope, module.Manifold.difference([selected, ...nested]));
+        assertNativeSolidStatus(component, "components");
+        return component;
+    }));
+}

package/dist/engine/native/regions.js

@@ -2,7 +2,8 @@ import { GeometryError } from "../../geometry/errors.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;
+/** @internal One contour ceiling shared with authored input normalization preflights. */
+export const MAX_AGGREGATE_CONTOURS = 25_000;
 const assertRegionBounds = (regions, operation, limits = {}) => {
     const hasArrayShape = Array.isArray(regions);
     if (!hasArrayShape) {

package/dist/engine/native/threads.js

@@ -1,10 +1,10 @@
-import { buildHelicalThreadRidgeMesh, buildHelicalThreadSolidMesh, } from "../../geometry/mechanical/index.js";
+import { helicalThreadRidgeMesh, helicalThreadSolidMesh } from "../../geometry/mechanical/index.js";
 import { resolveCompensatedThreadSolidMesh, resolveThreadedNutSolid, } from "../../geometry/mechanical/thread-solids.js";
 import { triangleMeshToManifold } from "./adapter.js";
 export { preflightThreadedRodSolid, preflightInternalThreadCutterSolid, preflightThreadedNutSolid, } from "../../geometry/mechanical/thread-solids.js";
 /** Converts the runtime-neutral ridge mesh into a scope-owned Manifold solid. */
 export function threadRidgeSolid(module, options, scope) {
-    return triangleMeshToManifold(module, buildHelicalThreadRidgeMesh(options), scope);
+    return triangleMeshToManifold(module, helicalThreadRidgeMesh(options), scope);
 }
 const compensatedThreadSolid = (module, options, role, scope) => {
     const resolved = resolveCompensatedThreadSolidMesh(options, role);
@@ -12,7 +12,7 @@ const compensatedThreadSolid = (module, options, role, scope) => {
 };
 const compensatedThreadSolidFromResolved = (module, resolved, scope) => {
     const { axialExtension, meshOptions } = resolved;
-    const combined = triangleMeshToManifold(module, buildHelicalThreadSolidMesh(meshOptions), scope);
+    const combined = triangleMeshToManifold(module, helicalThreadSolidMesh(meshOptions), scope);
     return axialExtension === 0 ? combined : scope.own(combined.translate([0, 0, -axialExtension]));
 };
 /** Creates a compensated, scope-owned external threaded rod along +Z. */

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) => {
@@ -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",
         });
@@ -95,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

@@ -1,7 +1,7 @@
 import { gridPatternPlan, linearPatternPlan, pathPatternPlan, radialPatternPlan, } from "../geometry/patterns/placements.js";
 import { assertSamplingCount } from "../geometry/sampling-limits.js";
+import { restrictTransform3 } from "../geometry/transform2.js";
 import { IDENTITY_TRANSFORM3 } from "../geometry/transform3.js";
-import { sectionPatternTransform } from "./pattern-transform.js";
 /** Private pattern owner; all copies use the shared transform/metadata/lifetime path. */
 export function createPatternOperations(environment, transforms) {
     const apply = (source, makePlan, operation) => {
@@ -28,11 +28,11 @@ 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"
-                    ? transforms.operations.transform(shape, sectionPatternTransform(matrix, operation))
+                    ? transforms.operations.transform(shape, restrictTransform3(matrix))
                     : transforms.operations.transform(shape, matrix));
         }
         return copies;

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,15 +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
                                 ? {}
@@ -198,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.");