@metamesh/modeling 0.16.0 → 0.18.0

package/dist/engine/operations/hole-cutter.js

@@ -0,0 +1,148 @@
+import { convexContourOffsets } from "../../geometry/convex-offset.js";
+import { GeometryError } from "../../geometry/errors.js";
+import { assertPrimitiveOptions } from "../../geometry/primitive-resolvers.js";
+/** Composes cutters inside the evaluating host, retaining deferred Section and sampling ownership. */
+export function createHoleCutterOperation(environment, operations) {
+    return (options) => {
+        environment.assertActive();
+        assertPrimitiveOptions(options, "holeCutter");
+        const fail = (message) => {
+            throw new GeometryError("INVALID_ARGUMENT", message, { operation: "holeCutter" });
+        };
+        const positive = (value, name) => {
+            if (!Number.isFinite(value) || value <= 0)
+                fail(`${name} must be finite and positive.`);
+            return value;
+        };
+        const nonnegative = (value, name) => {
+            if (!Number.isFinite(value) || value < 0)
+                fail(`${name} must be finite and nonnegative.`);
+            return value;
+        };
+        const height = positive(options.height, "height");
+        const circular = options.diameter !== undefined;
+        if (circular === (options.profile !== undefined))
+            fail("Specify exactly one diameter or Section profile.");
+        if (!circular &&
+            (options.recess !== undefined ||
+                options.segments !== undefined ||
+                options.sizing !== undefined))
+            fail("Circular recess, segments and sizing options require a diameter.");
+        if (options.recess !== undefined && options.entryChamfer !== undefined)
+            fail("A recess and entryChamfer are mutually exclusive.");
+        const face = options.face ?? "top";
+        if (face !== "top" && face !== "bottom")
+            fail("face must be top or bottom.");
+        if (options.overrun !== undefined)
+            assertPrimitiveOptions(options.overrun, "holeCutter");
+        const bottom = nonnegative(options.overrun?.bottom ?? 0, "overrun.bottom");
+        const top = nonnegative(options.overrun?.top ?? 0, "overrun.top");
+        const length = positive(height + bottom + top, "extended height");
+        const chamfer = nonnegative(options.entryChamfer ?? 0, "entryChamfer");
+        if (chamfer >= height)
+            fail("entryChamfer must be smaller than height.");
+        const selected = environment.withResolutionDefaults(options);
+        const sampling = { resolution: selected.resolution, limits: selected.limits };
+        if (circular)
+            positive(options.diameter, "diameter");
+        if (options.recess !== undefined) {
+            const recess = options.recess;
+            assertPrimitiveOptions(recess, "holeCutter");
+            positive(recess.diameter, "recess.diameter");
+            if (recess.diameter <= options.diameter)
+                fail("The recess diameter must exceed the bore diameter.");
+            let depth;
+            if (recess.kind === "counterbore")
+                depth = positive(recess.depth, "recess.depth");
+            else if (recess.kind === "countersink") {
+                if (!Number.isFinite(recess.includedAngle) ||
+                    recess.includedAngle <= 0 ||
+                    recess.includedAngle >= 180)
+                    fail("Countersink includedAngle must be between zero and 180 degrees.");
+                depth = positive((recess.diameter - options.diameter) /
+                    (2 * Math.tan((recess.includedAngle * Math.PI) / 360)), "recess depth");
+            }
+            else
+                return fail("Unsupported recess kind.");
+            if (depth > height)
+                fail("The recess must fit within height.");
+            const segments = environment.resolveCircularSegments(recess.diameter / 2, options);
+            const common = { ...sampling, segments, sizing: options.sizing ?? "vertex", center: false };
+            const bore = operations.translate(operations.cylinder({ ...common, diameter: options.diameter, height: length }), [0, 0, -bottom]);
+            const seat = operations.translate(operations.cylinder({
+                ...common,
+                diameter: recess.kind === "counterbore"
+                    ? recess.diameter
+                    : face === "top"
+                        ? [options.diameter, recess.diameter]
+                        : [recess.diameter, options.diameter],
+                height: depth,
+            }), [0, 0, face === "top" ? height - depth : 0]);
+            const excess = face === "top" ? top : bottom;
+            return operations.union([
+                bore,
+                seat,
+                ...(excess === 0
+                    ? []
+                    : [
+                        operations.translate(operations.cylinder({
+                            ...common,
+                            diameter: recess.diameter,
+                            height: excess,
+                        }), [0, 0, face === "top" ? height : -bottom]),
+                    ]),
+            ]);
+        }
+        if (circular) {
+            const openingOverrun = face === "top" ? top : bottom;
+            const segments = environment.resolveCircularSegments(options.diameter / 2 + chamfer + (chamfer === 0 ? 0 : openingOverrun), options);
+            const common = { ...sampling, segments, sizing: options.sizing ?? "vertex", center: false };
+            const bore = operations.translate(operations.cylinder({
+                ...common,
+                diameter: options.diameter,
+                height: length,
+            }), [0, 0, -bottom]);
+            if (chamfer === 0)
+                return bore;
+            // Circular entries retain nominal radial dimensions. Section entries below instead
+            // offset their supplied polygon edges; their faceted envelope remains authoritative.
+            const mouth = options.diameter + 2 * (chamfer + openingOverrun);
+            const entry = operations.translate(operations.cylinder({
+                ...common,
+                diameter: face === "top" ? [options.diameter, mouth] : [mouth, options.diameter],
+                height: chamfer + openingOverrun,
+            }), [0, 0, face === "top" ? height - chamfer : -bottom]);
+            return operations.union([bore, entry]);
+        }
+        const profile = options.profile;
+        if (chamfer === 0)
+            return operations.translate(operations.extrude(profile, { ...sampling, height: length }), [
+                0,
+                0,
+                -bottom,
+            ]);
+        const source = environment.sectionProfileFor(profile);
+        if (source.components.length !== 1 || source.components[0].holes.length !== 0)
+            fail("Entry chamfers require one strictly convex contour without holes.");
+        const component = source.components[0];
+        const offset = convexContourOffsets(component.outer.points, "holeCutter").offset;
+        const rows = face === "top"
+            ? [
+                { z: -bottom, inset: 0 },
+                { z: height - chamfer, inset: 0 },
+                { z: height + top, inset: -chamfer - top },
+            ]
+            : [
+                { z: -bottom, inset: -chamfer - bottom },
+                { z: chamfer, inset: 0 },
+                { z: height + top, inset: 0 },
+            ];
+        const stations = rows.map(({ z, inset }) => ({
+            z,
+            profile: {
+                components: [{ ...component, outer: { ...component.outer, points: offset(inset) } }],
+            },
+        }));
+        return operations.loft(stations, sampling);
+    };
+}

package/dist/engine/{inspection-operations.js → operations/inspection.js}

@@ -1,13 +1,13 @@
-import { vector3Data } from "../geometry/math/vector-value.js";
-import { ownScopedManifoldValue } from "./native/context.js";
-import { copiedMeshViews } from "./native/copied-views.js";
-import { measureSolidDistance } from "./native/distance.js";
-import { assertNativeSolidStatus } from "./native/status.js";
+import { vector3Data } from "../../geometry/math/vector-value.js";
+import { ownScopedManifoldValue } from "../native/context.js";
+import { copiedMeshViews } from "../native/copied-views.js";
+import { measureSolidDistance } from "../native/distance.js";
+import { assertNativeSolidStatus } from "../native/status.js";
 /** Internal host-bound inspection operations. */
 export function createInspectionOperations(environment) {
     const { scope, throwGeometryError, nativeSolid, resolveHandle, ownSolid, ownSection, wrapSolid, wrapSection, validateFiniteNumber, requirePositiveNumber, validateCoordinates, analyzedMeshFor, solidInspectionFor, sectionInspectionFor, solidComponentsFor, sectionComponentsFor, } = environment;
     const operations = {
-        toTriangleMesh: (value) => copiedMeshViews(analyzedMeshFor(value).mesh, new Map()),
+        toMesh: (value) => copiedMeshViews(analyzedMeshFor(value).mesh, new Map()),
         inspectSection: sectionInspectionFor,
         inspectSolid: solidInspectionFor,
         isEmpty: (handle) => {

package/dist/engine/operations/knuckle-hinge.js

@@ -0,0 +1,128 @@
+import { GeometryError } from "../../geometry/errors.js";
+import { resolveKnuckleHinge } from "../../geometry/mechanical/knuckle-hinge.js";
+import { assertPrimitiveOptions } from "../../geometry/primitive-resolvers.js";
+import { assertSamplingCount } from "../../geometry/sampling-limits.js";
+/** Composes existing scoped operations after resolving both halves against one host policy. */
+export function createKnuckleHingeOperation(environment, operations) {
+    return (options) => {
+        environment.assertActive();
+        assertPrimitiveOptions(options, "knuckleHinge");
+        const resolved = environment.withResolutionDefaults(options);
+        const d = resolveKnuckleHinge(options, resolved);
+        assertSamplingCount(d.segments * d.spec.knuckleCount * 2, "knuckleHinge", resolved.limits.maxVertices);
+        const invalid = (message) => {
+            throw new GeometryError("INVALID_ARGUMENT", message, { operation: "knuckleHinge" });
+        };
+        const validateHalf = (half = {}) => {
+            assertPrimitiveOptions(half, "knuckleHinge");
+            const chamfer = half.chamfer ?? 0;
+            if (!Number.isFinite(chamfer) ||
+                chamfer < 0 ||
+                2 * chamfer >= d.knuckleLength ||
+                chamfer >= d.minimumBarrelWall)
+                invalid("chamfer must be nonnegative and leave a positive axial band and faceted barrel wall.");
+            const web = half.web;
+            if (web !== undefined) {
+                assertPrimitiveOptions(web, "knuckleHinge");
+                if (web.direction !== "positive-y" && web.direction !== "negative-y")
+                    invalid("Unknown web direction.");
+                if (!Number.isFinite(web.reach) ||
+                    web.reach <= 0 ||
+                    !Number.isFinite(web.thickness) ||
+                    web.thickness <= 0 ||
+                    !Number.isFinite(web.zMin) ||
+                    !Number.isFinite(web.zMin + web.thickness))
+                    invalid("Web dimensions must be finite, with positive reach and thickness.");
+                if (2 * chamfer >= web.thickness ||
+                    2 * Math.SQRT2 * chamfer >= Math.min(d.knuckleLength, web.reach))
+                    invalid("chamfer must leave a positive web band and noncollapsed end contours.");
+                const innerRadius = d.barrelRadius * Math.cos(Math.PI / d.segments);
+                if (web.zMin >= innerRadius || web.zMin + web.thickness <= -innerRadius)
+                    invalid("A web must overlap the interior of its barrel.");
+            }
+            return { chamfer, web };
+        };
+        // Validate both attachments before allocating either half.
+        const a = validateHalf(options.halfA);
+        const b = validateHalf(options.halfB);
+        const axial = (radius, start, length, bore = false, chamfer = 0) => operations.translate(operations.rotate(operations.cylinder({
+            radius,
+            height: length,
+            center: false,
+            segments: d.segments,
+            sizing: bore ? "face" : "vertex",
+            ...(chamfer === 0
+                ? {}
+                : {
+                    ends: {
+                        bottom: { kind: "chamfer", distance: chamfer },
+                        top: { kind: "chamfer", distance: chamfer },
+                    },
+                }),
+        }), [0, 90, 0]), [start, 0, 0]);
+        const buildHalf = (side, { chamfer, web }) => {
+            const features = [];
+            // Use the web bottom as the shared Float32 datum for barrel, web, and mounting bevels.
+            const baseZ = chamfer > 0 && web !== undefined ? web.zMin : 0;
+            const atBase = (solid) => operations.translate(solid, [0, 0, -baseZ]);
+            const webProfile = (web, inset) => {
+                // Parallel offsets finish the exposed tip; the two root corners stay square.
+                const corner = { kind: "chamfer", distance: chamfer + (Math.SQRT2 - 2) * inset };
+                const profile = operations.rectangle({
+                    size: [d.knuckleLength - 2 * inset, web.reach - inset],
+                    center: false,
+                    treatment: [corner, corner, { kind: "square" }, { kind: "square" }],
+                });
+                return operations.scale(operations.translate(profile, [inset, 0]), [
+                    1,
+                    web.direction === "positive-y" ? 1 : -1,
+                ]);
+            };
+            for (const interval of d.knuckles) {
+                if (interval.side !== side)
+                    continue;
+                features.push(atBase(axial(d.barrelRadius, interval.start, interval.length, false, chamfer)));
+                if (web !== undefined) {
+                    features.push(chamfer === 0
+                        ? operations.translate(operations.box({
+                            size: [interval.length, web.reach, web.thickness],
+                            center: false,
+                        }), [
+                            interval.start,
+                            web.direction === "positive-y" ? 0 : -web.reach,
+                            web.zMin - baseZ,
+                        ])
+                        : operations.loft([
+                            [chamfer, 0],
+                            [0, chamfer],
+                            [0, web.thickness - chamfer],
+                            [chamfer, web.thickness],
+                        ].map(([inset, z]) => ({
+                            profile: webProfile(web, inset),
+                            frame: {
+                                origin: [interval.start, 0, z],
+                                xAxis: [1, 0, 0],
+                                yAxis: [0, 1, 0],
+                                zAxis: [0, 0, 1],
+                            },
+                        }))));
+                }
+            }
+            if (side === "a" && d.pin !== null)
+                features.push(atBase(axial(d.pinRadius, d.pin.start, d.pin.length)));
+            // Match the kernel cylinders to the same mesh precision as the explicit web stations.
+            const solid = operations.union(features.map((feature) => chamfer === 0 || web === undefined
+                ? feature
+                : operations.solidFromMesh(environment.analyzedMeshFor(feature).mesh)));
+            // Overtravel is numerical cutter extent, independent of the physical radial/axial allowances.
+            const overtravel = Math.min(d.knuckleLength, d.barrelRadius) * 0.01;
+            const result = side === "a" && d.pin !== null
+                ? solid
+                : operations.subtract(solid, [
+                    atBase(axial(d.boreRadius, -d.spec.length / 2 - overtravel, d.spec.length + 2 * overtravel, true)),
+                ]);
+            return operations.translate(result, [0, 0, baseZ]);
+        };
+        return Object.freeze({ halfA: buildHalf("a", a), halfB: buildHalf("b", b), axis: d.axis });
+    };
+}

package/dist/engine/{loft-operations.js → operations/loft.js}

@@ -1,13 +1,16 @@
-import { GeometryError } from "../geometry/errors.js";
-import { loftProfilePointCount, pointLoftProfile, prepareLoftGeometry, } from "../geometry/loft/loft-geometry.js";
-import { loftFrame, resolveLoftControls } from "../geometry/loft/loft-options.js";
-import { simpleLoftMesh } from "../geometry/loft/loft-simple-mesh.js";
-import { analyzeTriangleMesh } from "../geometry/mesh/mesh.js";
-import { capturePath2Input, path2InputData, } from "../geometry/paths/path-value.js";
-import { assertSamplingCount } from "../geometry/sampling-limits.js";
-import { correspondingPrimitiveProfiles, rectangularPrimitiveFamily, } from "./primitive-profiles.js";
-import { buildProfileLoftMesh } from "./profile-mesh.js";
-const explicitProfile = (value) => typeof value === "object" && value !== null && "components" in value;
+import { GeometryError } from "../../geometry/errors.js";
+import { loftProfilePointCount, pointLoftProfile, prepareLoftGeometry, } from "../../geometry/loft/loft-geometry.js";
+import { loftFrame, resolveLoftControls } from "../../geometry/loft/loft-options.js";
+import { simpleLoftMesh } from "../../geometry/loft/loft-simple-mesh.js";
+import { analyzeTriangleMesh } from "../../geometry/mesh/mesh.js";
+import { capturePath2Input, path2InputData, } from "../../geometry/paths/path-value.js";
+import { assertSamplingCount, } from "../../geometry/sampling-limits.js";
+import { buildProfileLoftMesh } from "./primitives/profile-mesh.js";
+import { correspondingPrimitiveProfiles, rectangularPrimitiveFamily, } from "./primitives/profiles.js";
+const explicitProfile = (value) => typeof value === "object" &&
+    value !== null &&
+    "components" in value &&
+    Array.isArray(value.components);
 const pointProfile = (value) => Array.isArray(value) || (typeof value === "object" && value !== null && "toData" in value);
 const fail = (message) => {
     throw new GeometryError("INVALID_ARGUMENT", message, { operation: "loft" });
@@ -124,8 +127,6 @@ export function createLoftOperation(environment, solidFromMesh) {
             selected = environment.withResolutionDefaults({ ...value, limits: sampling });
             recipeSampled = sources.map((source) => source !== undefined);
             const known = sources.every((source) => source !== undefined);
-            if (value.correspondence === undefined && !known)
-                fail("Arbitrary Sections and point loops require an explicit correspondence method for loft.");
             const family = value.correspondence === undefined && known
                 ? sources.every((source) => source.family === sources[0].family)
                     ? sources

package/dist/engine/{mechanical-operations.js → operations/mechanical.js}

@@ -1,5 +1,5 @@
-import { createKnuckleHingeOperation } from "./knuckle-hinge-operation.js";
-import * as kernel from "./native/index.js";
+import * as kernel from "../native/index.js";
+import { createKnuckleHingeOperation } from "./knuckle-hinge.js";
 /** Internal host-bound mechanical operations. */
 export function createMechanicalOperations(environment, construction) {
     const { resolution } = environment;

package/dist/engine/{pattern-operations.js → operations/patterns.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 { 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";
 /** Private pattern owner; all copies use the shared transform/metadata/lifetime path. */
 export function createPatternOperations(environment, transforms) {
     const apply = (source, makePlan, operation) => {

package/dist/engine/{primitive-anchors.js → operations/primitives/anchors.js}

@@ -1,9 +1,13 @@
-import { anchor3, boxAnchor3 } from "../geometry/anchors.js";
-import { resolveCylinderRadii } from "../geometry/cylinder.js";
+import { anchor3, boxAnchor3 } from "../../../geometry/anchors.js";
+import { resolveCylinderRadii } from "../../../geometry/cylinder.js";
+import { vector3Data } from "../../../geometry/math/vector-value.js";
+import { resolveTubeRadii } from "../../../geometry/primitive-resolvers.js";
 const faces = ["left", "right", "back", "front", "bottom", "top"];
 /** Nominal primitive datums; construction validates dimensions before these factories run. */
 export function boxAnchors(options) {
-    const size = typeof options.size === "number" ? [options.size, options.size, options.size] : options.size;
+    const size = typeof options.size === "number"
+        ? [options.size, options.size, options.size]
+        : vector3Data(options.size);
     const center = options.center === false ? [size[0] / 2, size[1] / 2, size[2] / 2] : [0, 0, 0];
     return {
         center: anchor3(center, [0, 0, 1]),
@@ -39,7 +43,8 @@ export function cylinderAnchors(options) {
 }
 /** Tube cap centers lie on the nominal cap planes, including the central opening. */
 export function tubeAnchors(options) {
-    return axialAnchors([options.outerRadius, options.outerRadius], options.height, options.center ?? true);
+    const { outerRadius } = resolveTubeRadii(options);
+    return axialAnchors([outerRadius, outerRadius], options.height, options.center ?? true);
 }
 /** Sphere principal surface points and its origin reference. */
 export function sphereAnchors(options) {

package/dist/engine/{primitive-operations.js → operations/primitives/construction.js}

@@ -1,16 +1,19 @@
-import { resolveCylinderRadii } from "../geometry/cylinder.js";
-import { resolveModelingLimits } from "../geometry/model-limits.js";
-import { assertPrimitiveOptions } from "../geometry/primitive-resolvers.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";
-import { ellipticalSectionProfile, polygonSectionProfile, rectangleSectionProfile, } from "./primitive-profiles.js";
+import { resolveCircularSampling } from "../../../geometry/circular-sampling.js";
+import { resolveCylinderRadii } from "../../../geometry/cylinder.js";
+import { vector2Data } from "../../../geometry/math/vector-value.js";
+import { resolveModelingLimits } from "../../../geometry/model-limits.js";
+import { assertPrimitiveOptions } from "../../../geometry/primitive-resolvers.js";
+import { ellipseContour } from "../../../geometry/profiles/primitives/ellipse.js";
+import { rectangleContour, resolveRectangle, } from "../../../geometry/profiles/primitives/rectangle.js";
+import { regularPolygonContour } from "../../../geometry/profiles/primitives/regular-polygon.js";
+import { starContour } from "../../../geometry/profiles/primitives/star.js";
+import { requireProfileVertexCount } from "../../../geometry/profiles/validation.js";
+import * as kernel from "../../native/index.js";
+import { boxAnchors, cylinderAnchors, originAnchor, planarAnchors, sphereAnchors, torusAnchors, tubeAnchors, } from "./anchors.js";
+import { ellipticalSectionProfile, polygonSectionProfile, rectangleSectionProfile, } from "./profiles.js";
 /** Internal host-bound primitive operations. */
 export function createPrimitiveOperations(environment, transforms, sections) {
-    const { module, scope, assertActive, throwGeometryError, ownSection, validateFiniteNumber, requirePositiveNumber, validateCoordinates, withResolutionDefaults, resolveCircularSegments, } = environment;
+    const { module, scope, assertActive, throwGeometryError, ownSection, requirePositiveNumber, validateCoordinates, withResolutionDefaults, resolveCircularSegments, } = environment;
     const { placedSolid, placedSection } = transforms;
     const fromContours = (contours) => sections.polygon({ contours });
     const operations = {
@@ -48,7 +51,15 @@ export function createPrimitiveOperations(environment, transforms, sections) {
             if (value.sizing !== "face")
                 return placedSolid(value, () => kernel.cylinder(scope, resolved), () => cylinderAnchors(value));
             const radii = resolveCylinderRadii(value);
-            const count = resolveCircularSegments(Math.max(...radii), value), correction = 1 / Math.cos(Math.PI / count);
+            const maximumRadius = Math.max(...radii);
+            const sampling = resolveCircularSampling({
+                radius: maximumRadius,
+                sizing: "face",
+                ...(resolved.segments === undefined ? {} : { segments: resolved.segments }),
+                resolution: resolved.resolution,
+                limits: resolved.limits,
+            });
+            const count = sampling.segments, correction = sampling.vertexRadius / maximumRadius;
             return placedSolid(value, () => kernel.cylinder(scope, {
                 height: resolved.height,
                 radius: [radii[0] * correction, radii[1] * correction],
@@ -93,7 +104,7 @@ export function createPrimitiveOperations(environment, transforms, sections) {
                     }),
             };
             const points = rectangleContour(options);
-            const dimensions = typeof value.size === "number" ? [value.size, value.size] : value.size;
+            const dimensions = typeof value.size === "number" ? [value.size, value.size] : vector2Data(value.size);
             const section = setbacks.every((pair) => pair.every((distance) => distance === 0))
                 ? ownSection(module.CrossSection.square(dimensions, value.center ?? true))
                 : fromContours([points]);
@@ -106,19 +117,24 @@ export function createPrimitiveOperations(environment, transforms, sections) {
                 throwGeometryError("INVALID_ARGUMENT", "circle", "Specify exactly one radius or diameter.");
             const radius = value.radius ?? value.diameter / 2;
             requirePositiveNumber(radius, "circle");
-            const count = resolveCircularSegments(radius, value);
-            requireProfileVertexCount(count, 3, "circle", withResolutionDefaults(value).limits);
-            if (value.sizing !== undefined && value.sizing !== "vertex" && value.sizing !== "face")
-                throwGeometryError("INVALID_ARGUMENT", "circle", "sizing must be vertex or face.");
-            const section = ownSection(module.CrossSection.circle(value.sizing === "face" ? radius / Math.cos(Math.PI / count) : radius, count));
             const resolved = withResolutionDefaults(value);
+            const { segments: count, vertexRadius } = resolveCircularSampling({
+                radius,
+                sizing: value.sizing ?? "vertex",
+                ...(resolved.segments === undefined ? {} : { segments: resolved.segments }),
+                resolution: resolved.resolution,
+                limits: resolved.limits,
+            });
+            requireProfileVertexCount(count, 3, "circle", resolved.limits);
+            const section = ownSection(module.CrossSection.circle(vertexRadius, count));
             environment.rememberAnchors(section, planarAnchors([2 * radius, 2 * radius]));
             return environment.rememberPrimitiveProfile(section, ellipticalSectionProfile([radius, radius], value, resolved.resolution, resolved.limits, value.sizing === "face"));
         }),
         ellipse: (value) => placedSection(value, () => {
             if ((value.radius === undefined) === (value.size === undefined))
                 throwGeometryError("INVALID_ARGUMENT", "ellipse", "Specify exactly one radius or size tuple.");
-            const radii = value.radius ?? [value.size[0] / 2, value.size[1] / 2];
+            const dimensions = vector2Data(value.radius ?? value.size);
+            const radii = value.radius === undefined ? [dimensions[0] / 2, dimensions[1] / 2] : dimensions;
             validateCoordinates(radii, 2, "ellipse");
             const resolved = withResolutionDefaults(value);
             const section = fromContours([
@@ -137,12 +153,8 @@ 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.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),
-                x * Math.sin(angle) + y * Math.cos(angle),
-            ]);
+            const loop = starContour({ ...value, limits: resolved.limits });
             const section = environment.rememberAnchors(fromContours([loop]), originAnchor());
             return environment.rememberPrimitiveProfile(section, polygonSectionProfile(`star-${value.points}`, loop, resolved.resolution, resolved.limits));
         }),

package/dist/engine/{primitive-correspondence.js → operations/primitives/correspondence.js}

@@ -1,7 +1,7 @@
-import { GeometryError } from "../geometry/errors.js";
-import { matchProfiles, } from "../geometry/profiles/matched.js";
-import { createProfileSpanSampler } from "../geometry/profiles/span-sampling.js";
-import { assertSamplingCount } from "../geometry/sampling-limits.js";
+import { GeometryError } from "../../../geometry/errors.js";
+import { matchProfiles, } from "../../../geometry/profiles/match-profiles.js";
+import { createProfileSpanSampler } from "../../../geometry/profiles/span-sampling.js";
+import { assertSamplingCount, } from "../../../geometry/sampling-limits.js";
 /** Primitive exact counts describe physical facets; identified user Profile counts describe analytic grids. */
 export function samplePrimitiveFamily(sources, profiles, resolution, limits) {
     const matched = matchProfiles(profiles, { resolution, limits });

package/dist/engine/{profile-mesh.js → operations/primitives/profile-mesh.js}

@@ -1,15 +1,15 @@
-import { GeometryError } from "../geometry/errors.js";
-import { loftFrame } from "../geometry/loft/loft-options.js";
-import { assertMeshAllocationWithinLimits } from "../geometry/model-limits.js";
-import { writeMeshVertex } from "../geometry/numeric.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";
-import { planSweepStations, refineSweepStations } from "../geometry/sweeps/stations.js";
-import { normalizeSweepPath } from "../geometry/sweeps/validation.js";
-import { resolveGeometryTolerance } from "../geometry/tolerance.js";
-import { frameTransform3 } from "../geometry/transform3.js";
+import { GeometryError } from "../../../geometry/errors.js";
+import { loftFrame } from "../../../geometry/loft/loft-options.js";
+import { assertMeshAllocationWithinLimits } from "../../../geometry/model-limits.js";
+import { writeMeshVertex } from "../../../geometry/numeric.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";
+import { planSweepStations, refineSweepStations } from "../../../geometry/sweeps/stations.js";
+import { normalizeSweepPath } from "../../../geometry/sweeps/validation.js";
+import { resolveGeometryTolerance } from "../../../geometry/tolerance.js";
+import { frameTransform3 } from "../../../geometry/transform3.js";
 const fail = (message) => {
     throw new GeometryError("INVALID_ARGUMENT", message, { operation: "loft" });
 };

package/dist/engine/{primitive-profiles.js → operations/primitives/profiles.js}

@@ -1,10 +1,10 @@
-import { planarCubicControl } from "../geometry/curves/evaluation.js";
-import { resolveLineSegmentCount, resolveUniformCubicSegments, } from "../geometry/curves/sampling.js";
-import { GeometryError } from "../geometry/errors.js";
-import {} from "../geometry/profiles/matched.js";
-import { rectangleProfile, resolveRectangle, } from "../geometry/profiles/rectangle.js";
-import { resolveArcSegments, resolveGeometryResolution, } from "../geometry/resolution.js";
-import { samplePrimitiveFamily } from "./primitive-correspondence.js";
+import { planarCubicControl } from "../../../geometry/curves/evaluation.js";
+import { resolveLineSegmentCount, resolveUniformCubicSegments, } from "../../../geometry/curves/sampling.js";
+import { GeometryError } from "../../../geometry/errors.js";
+import {} from "../../../geometry/profiles/match-profiles.js";
+import { rectangleProfile, resolveRectangle, } from "../../../geometry/profiles/primitives/rectangle.js";
+import { resolveArcSegments, resolveGeometryResolution, } from "../../../geometry/resolution.js";
+import { samplePrimitiveFamily } from "./correspondence.js";
 const identity = [1, 0, 0, 0, 1, 0, 0, 0, 1];
 const cornerIds = ["top-right", "top-left", "bottom-left", "bottom-right"];
 /** Captures rectangle landmarks separately from its existing native filled geometry. */

package/dist/engine/{section-operations.js → operations/sections.js}

@@ -1,11 +1,11 @@
-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";
+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;
@@ -118,7 +118,7 @@ export function createSectionOperations(environment, transforms) {
         },
         svgSection: (svg, value = {}) => {
             let result = wrapSection(kernel.regionToCrossSection(scope, preflightSvgRegion(svg, { ...withResolutionDefaults(value), origin: "document" }).region, limits));
-            if ((value.origin ?? "center") === "center") {
+            if (value.fit === undefined && (value.origin ?? "center") === "center") {
                 const bounds = nativeSection(result).bounds();
                 result = translate(result, [
                     -(bounds.min[0] + bounds.max[0]) / 2,

package/dist/engine/{transform-operations.js → operations/transforms.js}

@@ -1,11 +1,11 @@
-import { attachmentTransform3 } from "../geometry/anchors.js";
-import { vector2Data, vector3Data, } from "../geometry/math/vector-value.js";
-import { assertPrimitiveOptions } from "../geometry/primitive-resolvers.js";
-import { readTransformMatrix } from "../geometry/transform-matrix.js";
-import { transform2, transform3, } from "../geometry/transform-value.js";
-import { eulerTransform3, scaleTransform3, translationTransform3, validateTransform3, } from "../geometry/transform3.js";
-import * as kernel from "./native/index.js";
-import { transformPrimitiveSectionProfile } from "./primitive-profiles.js";
+import { attachmentTransform3 } from "../../geometry/anchors.js";
+import { vector2Data, vector3Data, } from "../../geometry/math/vector-value.js";
+import { assertPrimitiveOptions } from "../../geometry/primitive-resolvers.js";
+import { readTransformMatrix } from "../../geometry/transform-matrix.js";
+import { transform2, transform3, } from "../../geometry/transform-value.js";
+import { eulerTransform3, scaleTransform3, translationTransform3, validateTransform3, } from "../../geometry/transform3.js";
+import * as kernel from "../native/index.js";
+import { transformPrimitiveSectionProfile } from "./primitives/profiles.js";
 /** Internal host-bound transform operations. */
 export function createTransformOperations(environment) {
     const { scope, throwGeometryError, resolveHandle, nativeSolid, wrapSolid, ownSection, validateFiniteNumber, validateCoordinates, } = environment;

package/dist/engine/placement.js

@@ -1,11 +1,10 @@
 import { validateAnalyzedSolidMesh } from "../geometry/mesh/mesh-solid.js";
 import { analyzeTriangleMesh } from "../geometry/mesh/mesh.js";
-import { composeTransform3, eulerTransform3, translationTransform3, } from "../geometry/transform3.js";
+import { IDENTITY_TRANSFORM3 } from "../geometry/transform3.js";
 /** Places already validated immutable geometry once, retaining its indexed topology. */
-export function placeFinalizedGeometry(source, position, rotation, meshValidation) {
-    if ([...position, ...rotation].every((value) => value === 0))
+export function placeFinalizedGeometry(source, matrix, meshValidation) {
+    if (matrix.every((value, index) => value === IDENTITY_TRANSFORM3[index]))
         return source;
-    const matrix = composeTransform3(translationTransform3(position), eulerTransform3(rotation));
     const positions = new Float32Array(source.positions.length);
     for (let offset = 0; offset < positions.length; offset += 3) {
         const x = source.positions[offset], y = source.positions[offset + 1], z = source.positions[offset + 2];