@metamesh/modeling 0.16.0 → 0.17.0

package/dist/docs/reference/text/VectorFont.md

@@ -30,7 +30,7 @@ Shape horizontal lines or one circular line; bounded to 512 UTF-16 units and sup
 
   Em size in millimetres, greater than zero and at most 10000; not the visible glyph height.
 
-- [`align`](VectorTextLayoutOptions.md#align) · `"left"` \| `"right"` \| `"center"` · Optional
+- [`align`](VectorTextLayoutOptions.md#align) · `"center"` \| `"left"` \| `"right"` · Optional
 
   Place the advance's start, midpoint or end at the datum; defaults to center on arcs, otherwise left.
 
@@ -42,7 +42,7 @@ Shape horizontal lines or one circular line; bounded to 512 UTF-16 units and sup
 
   Baseline spacing in ems, 0.5–5; omitted uses the selected face's natural vertical metrics.
 
-- [`verticalAlign`](VectorTextLayoutOptions.md#verticalalign) · `"top"` \| `"bottom"` \| `"center"` \| `"baseline"` · Optional
+- [`verticalAlign`](VectorTextLayoutOptions.md#verticalalign) · `"center"` \| `"top"` \| `"bottom"` \| `"baseline"` · Optional
 
   Place the first baseline or complete ink bounds at Y=0; arcs only accept baseline.
 
@@ -88,7 +88,7 @@ Measure the same cached vector layout; all returned lengths are in millimetres.
 
   Em size in millimetres, greater than zero and at most 10000; not the visible glyph height.
 
-- [`align`](VectorTextLayoutOptions.md#align) · `"left"` \| `"right"` \| `"center"` · Optional
+- [`align`](VectorTextLayoutOptions.md#align) · `"center"` \| `"left"` \| `"right"` · Optional
 
   Place the advance's start, midpoint or end at the datum; defaults to center on arcs, otherwise left.
 
@@ -100,7 +100,7 @@ Measure the same cached vector layout; all returned lengths are in millimetres.
 
   Baseline spacing in ems, 0.5–5; omitted uses the selected face's natural vertical metrics.
 
-- [`verticalAlign`](VectorTextLayoutOptions.md#verticalalign) · `"top"` \| `"bottom"` \| `"center"` \| `"baseline"` · Optional
+- [`verticalAlign`](VectorTextLayoutOptions.md#verticalalign) · `"center"` \| `"top"` \| `"bottom"` \| `"baseline"` · Optional
 
   Place the first baseline or complete ink bounds at Y=0; arcs only accept baseline.
 
@@ -146,7 +146,7 @@ Serialize visible horizontal or circular outlines as bounded path-only SVG in ph
 
   Em size in millimetres, greater than zero and at most 10000; not the visible glyph height.
 
-- [`align`](VectorTextLayoutOptions.md#align) · `"left"` \| `"right"` \| `"center"` · Optional
+- [`align`](VectorTextLayoutOptions.md#align) · `"center"` \| `"left"` \| `"right"` · Optional
 
   Place the advance's start, midpoint or end at the datum; defaults to center on arcs, otherwise left.
 
@@ -158,7 +158,7 @@ Serialize visible horizontal or circular outlines as bounded path-only SVG in ph
 
   Baseline spacing in ems, 0.5–5; omitted uses the selected face's natural vertical metrics.
 
-- [`verticalAlign`](VectorTextLayoutOptions.md#verticalalign) · `"top"` \| `"bottom"` \| `"center"` \| `"baseline"` · Optional
+- [`verticalAlign`](VectorTextLayoutOptions.md#verticalalign) · `"center"` \| `"top"` \| `"bottom"` \| `"baseline"` · Optional
 
   Place the first baseline or complete ink bounds at Y=0; arcs only accept baseline.
 
@@ -183,4 +183,4 @@ Serialize visible horizontal or circular outlines as bounded path-only SVG in ph
 - [VectorTextLayoutOptions](VectorTextLayoutOptions.md)
 - [VectorTextMetrics](VectorTextMetrics.md)
 
-Package: `@metamesh/modeling@0.16.0`.
+Package: `@metamesh/modeling@0.17.0`.

package/dist/docs/reference/text/VectorFontOptions.md

@@ -14,4 +14,4 @@ Identifies the actual weight of a static face, without synthesizing a different
 
 Actual weight of a static face, 1–1000; defaults to 400.
 
-Package: `@metamesh/modeling@0.16.0`.
+Package: `@metamesh/modeling@0.17.0`.

package/dist/docs/reference/text/VectorTextArcBaseline.md

@@ -50,4 +50,4 @@ Alignment datum in degrees counterclockwise from +X; defaults to 90.
 
 Reading direction around the circle; defaults to clockwise.
 
-Package: `@metamesh/modeling@0.16.0`.
+Package: `@metamesh/modeling@0.17.0`.

package/dist/docs/reference/text/VectorTextLayout.md

@@ -31,4 +31,4 @@ Exact measurements of these paths and their logical text layout.
 
 - [VectorTextMetrics](VectorTextMetrics.md)
 
-Package: `@metamesh/modeling@0.16.0`.
+Package: `@metamesh/modeling@0.17.0`.

package/dist/docs/reference/text/VectorTextLayoutOptions.md

@@ -12,7 +12,7 @@ Text bounded to 512 UTF-16 units: horizontal lines or one circular line without
 
 
 
-`readonly` `optional` **align?**: `"left"` \| `"right"` \| `"center"`
+`readonly` `optional` **align?**: `"center"` \| `"left"` \| `"right"`
 
 
 
@@ -48,7 +48,7 @@ Baseline spacing in ems, 0.5–5; omitted uses the selected face's natural verti
 
 
 
-`readonly` `optional` **verticalAlign?**: `"top"` \| `"bottom"` \| `"center"` \| `"baseline"`
+`readonly` `optional` **verticalAlign?**: `"center"` \| `"top"` \| `"bottom"` \| `"baseline"`
 
 
 
@@ -108,4 +108,4 @@ Tracking between glyph clusters in millimetres, -100–100; defaults to zero.
 - [VectorTextArcBaseline](VectorTextArcBaseline.md)
 - [VectorTextOptions](VectorTextOptions.md)
 
-Package: `@metamesh/modeling@0.16.0`.
+Package: `@metamesh/modeling@0.17.0`.

package/dist/docs/reference/text/VectorTextMetrics.md

@@ -91,4 +91,4 @@ Number of lines, including empty and trailing lines; empty text occupies one lin
 
 - [Bounds2Data](Bounds2Data.md)
 
-Package: `@metamesh/modeling@0.16.0`.
+Package: `@metamesh/modeling@0.17.0`.

package/dist/docs/reference/text/VectorTextOptions.md

@@ -47,4 +47,4 @@ Tracking between glyph clusters in millimetres, -100–100; defaults to zero.
 
 - [VectorTextLayoutOptions](VectorTextLayoutOptions.md)
 
-Package: `@metamesh/modeling@0.16.0`.
+Package: `@metamesh/modeling@0.17.0`.

package/dist/docs/reference/text/categories/font-preparation.md

@@ -37,4 +37,4 @@ Layout returns immutable paths and metrics in Y-up millimetres. Pass the prepare
 | --- | --- |
 | [MAX_VECTOR_FONT_BYTES](../MAX_VECTOR_FONT_BYTES.md) | Limits apply before parsing or shaping untrusted font data. |
 
-Package: `@metamesh/modeling@0.16.0`.
+Package: `@metamesh/modeling@0.17.0`.

package/dist/docs/reference/text/prepareVectorFont.md

@@ -43,4 +43,4 @@ async function prepareLabel(fontBytes: Uint8Array) {
 - [VectorFont](VectorFont.md)
 - [VectorFontOptions](VectorFontOptions.md)
 
-Package: `@metamesh/modeling@0.16.0`.
+Package: `@metamesh/modeling@0.17.0`.

package/dist/docs/reference/text.md

@@ -20,4 +20,4 @@ Paths and metrics use Y-up millimetres and a baseline origin. Empty layouts can
 
 - [Font preparation](text/categories/font-preparation.md) — Prepare bounded exact font bytes and reusable vector layouts.
 
-Package: `@metamesh/modeling@0.16.0`.
+Package: `@metamesh/modeling@0.17.0`.

package/dist/engine/extrusion-finishing.js

@@ -1,3 +1,4 @@
+import { convexContourOffsets } from "../geometry/convex-offset.js";
 import { edgeTreatmentPointCount, edgeTreatmentSetbacks, sampleEdgeTreatment, } from "../geometry/edge-finishing.js";
 import { GeometryError } from "../geometry/errors.js";
 import { resolveExtrusionControls } from "../geometry/extrusion.js";
@@ -19,22 +20,7 @@ export function buildFinishedExtrusion(module, profile, options) {
     if (profile.components.length !== 1 || profile.components[0].holes.length !== 0)
         fail("End treatments require one convex contour without holes; use explicit loft profiles for other topology.");
     const contour = profile.components[0].outer, points = contour.points;
-    const edges = points.map((point, index) => {
-        const next = points[(index + 1) % points.length], dx = next[0] - point[0], dy = next[1] - point[1];
-        const length = Math.hypot(dx, dy);
-        if (!(length > 0) || !Number.isFinite(length))
-            fail("End treatment contours must have distinct finite vertices.");
-        return [dx / length, dy / length];
-    });
-    const miters = edges.map((edge, index) => {
-        const previous = edges[(index + edges.length - 1) % edges.length];
-        const turn = previous[0] * edge[1] - previous[1] * edge[0];
-        if (!(turn > 1e-12))
-            fail("End treatments require a strictly convex counterclockwise contour without collinear vertices.");
-        const denominator = 1 + previous[0] * edge[0] + previous[1] * edge[1];
-        return [(-previous[1] - edge[1]) / denominator, (previous[0] + edge[0]) / denominator];
-    });
-    const magnification = miters.reduce((maximum, [x, y]) => Math.max(maximum, Math.hypot(x, y)), 1);
+    const { magnification, offset } = convexContourOffsets(points, "extrude");
     const sampling = {
         resolution: options.resolution,
         limits: options.limits,
@@ -58,19 +44,6 @@ export function buildFinishedExtrusion(module, profile, options) {
         ...bottomPoints.map(([inset, depth]) => ({ inset, z: depth })),
         ...[...topPoints].reverse().map(([inset, depth]) => ({ inset, z: options.height - depth })),
     ];
-    const offset = (inset) => {
-        const result = points.map(([x, y], index) => [
-            x + miters[index][0] * inset,
-            y + miters[index][1] * inset,
-        ]);
-        for (let index = 0; index < result.length; index++) {
-            const point = result[index], next = result[(index + 1) % result.length], edge = edges[index];
-            if (!point.every(Number.isFinite) ||
-                !((next[0] - point[0]) * edge[0] + (next[1] - point[1]) * edge[1] > 0))
-                fail("End treatment inset collapses or reverses a contour edge.");
-        }
-        return result;
-    };
     offset(Math.max(bottomSize[0], topSize[0])); // fit fails before allocating the full station family
     const stations = rows.map(({ inset, z }) => ({
         z: controls.center ? z - options.height / 2 : z,

package/dist/engine/hole-cutter-operation.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/knuckle-hinge-operation.js

@@ -15,12 +15,12 @@ export function createKnuckleHingeOperation(environment, operations) {
         };
         const validateHalf = (half = {}) => {
             assertPrimitiveOptions(half, "knuckleHinge");
-            const chamfer = half.barrelChamfer ?? 0;
+            const chamfer = half.chamfer ?? 0;
             if (!Number.isFinite(chamfer) ||
                 chamfer < 0 ||
                 2 * chamfer >= d.knuckleLength ||
                 chamfer >= d.minimumBarrelWall)
-                invalid("barrelChamfer must be nonnegative and leave a positive axial band and faceted barrel wall.");
+                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");
@@ -33,6 +33,9 @@ export function createKnuckleHingeOperation(environment, operations) {
                     !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.");
@@ -59,26 +62,66 @@ export function createKnuckleHingeOperation(environment, operations) {
         }), [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(axial(d.barrelRadius, interval.start, interval.length, false, chamfer));
-                if (web !== undefined)
-                    features.push(operations.translate(operations.box({
-                        size: [interval.length, web.reach, web.thickness],
-                        center: false,
-                    }), [interval.start, web.direction === "positive-y" ? 0 : -web.reach, web.zMin]));
+                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(axial(d.pinRadius, d.pin.start, d.pin.length));
-            const solid = operations.union(features);
+                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;
-            return side === "a" && d.pin !== null
+            const result = side === "a" && d.pin !== null
                 ? solid
                 : operations.subtract(solid, [
-                    axial(d.boreRadius, -d.spec.length / 2 - overtravel, d.spec.length + 2 * overtravel, true),
+                    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/modeling-context.js

@@ -1,5 +1,6 @@
 import { resolveGeometryResolution } from "../geometry/resolution.js";
 import { createConstructionOperations } from "./construction-operations.js";
+import { createHoleCutterOperation } from "./hole-cutter-operation.js";
 import { createInspectionOperations } from "./inspection-operations.js";
 import { createMechanicalOperations } from "./mechanical-operations.js";
 import { createOperationEnvironment } from "./operation-environment.js";
@@ -18,6 +19,10 @@ export function createModelingContext(owner, initialResolution) {
         const mechanical = createMechanicalOperations(environment, {
             cylinder: primitives.cylinder,
             box: primitives.box,
+            rectangle: primitives.rectangle,
+            scale: transforms.operations.scale,
+            solidFromMesh: construction.solidFromMesh,
+            loft: construction.loft,
             union: construction.union,
             rotate: transforms.operations.rotate,
             translate: transforms.operations.translate,
@@ -34,6 +39,13 @@ export function createModelingContext(owner, initialResolution) {
             ...sections,
             ...primitives,
             ...construction,
+            holeCutter: createHoleCutterOperation(environment, {
+                cylinder: primitives.cylinder,
+                extrude: construction.extrude,
+                loft: construction.loft,
+                translate: transforms.operations.translate,
+                union: construction.union,
+            }),
             ...mechanical,
             ...patterns,
             ...inspection,

package/dist/engine/primitive-operations.js

@@ -1,3 +1,4 @@
+import { resolveCircularSampling } from "../geometry/circular-sampling.js";
 import { resolveCylinderRadii } from "../geometry/cylinder.js";
 import { resolveModelingLimits } from "../geometry/model-limits.js";
 import { assertPrimitiveOptions } from "../geometry/primitive-resolvers.js";
@@ -48,7 +49,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],
@@ -106,12 +115,16 @@ 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"));
         }),

package/dist/engine/section-operations.js

@@ -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/geometry/bounds-value.js

@@ -6,20 +6,46 @@ function fail(dimension, message) {
     throw new GeometryError("INVALID_ARGUMENT", message, { operation: `bounds${dimension}` });
 }
 function snapshot(input, dimension) {
-    if (typeof input !== "object" || input === null)
-        fail(dimension, "Bounds require minimum and maximum coordinate tuples.");
-    const { min, max } = input;
+    if (typeof input !== "object" || input === null || Array.isArray(input))
+        fail(dimension, "Bounds require extrema or size.");
+    const { size, center } = input;
+    let min, max;
+    // Existing immutable bounds expose size()/center(); only a size value selects construction.
+    if ("size" in input && typeof size !== "function") {
+        if ("min" in input || "max" in input)
+            fail(dimension, "Supply size or min/max, never both.");
+        if (!Array.isArray(size) || size.length !== dimension)
+            fail(dimension, `Size requires ${dimension}D coordinates.`);
+        if (center !== undefined && typeof center !== "boolean")
+            fail(dimension, "center must be boolean.");
+        const coordinates = size;
+        const dimensions = Array.from({ length: dimension }, (_, axis) => {
+            const value = coordinates[axis];
+            if (typeof value !== "number" || !Number.isFinite(value) || value < 0)
+                fail(dimension, "Size must be finite and nonnegative.");
+            return value;
+        });
+        const centered = center ?? true;
+        min = dimensions.map((value) => (centered ? -value / 2 : 0));
+        max = dimensions.map((value) => (centered ? value / 2 : value));
+    }
+    else {
+        if (center !== undefined && typeof center !== "function")
+            fail(dimension, "center requires size construction.");
+        const extrema = input;
+        min = extrema.min;
+        max = extrema.max;
+    }
     if (!Array.isArray(min) ||
         !Array.isArray(max) ||
         min.length !== dimension ||
         max.length !== dimension)
         fail(dimension, `Bounds require matching ${dimension}D minimum and maximum tuples.`);
-    const minimum = min, maximum = max;
     const copy = (source) => Object.freeze(Array.from({ length: dimension }, (_, axis) => {
         const value = source[axis];
         return value === 0 ? 0 : value;
     }));
-    const data = Object.freeze({ min: copy(minimum), max: copy(maximum) });
+    const data = Object.freeze({ min: copy(min), max: copy(max) });
     validateBounds(data, `bounds${dimension}`);
     return data;
 }
@@ -70,23 +96,25 @@ const SpatialBounds = /* @__PURE__ */ immutableMathClass(class SpatialBounds {
     }
 });
 /**
- * Snapshots finite ordered XY bounds in millimetres as an immutable fluent value.
+ * Constructs immutable finite XY bounds from ordered extrema or nonnegative size in millimetres.
  *
  * Zero extents are valid. Invalid dimensions, nonfinite coordinates, reversed bounds and
  * overflowing extents throw `INVALID_ARGUMENT` GeometryError. Use `toData()` for plain records.
+ * Size construction centers on the origin unless `center` is false. Size and extrema are exclusive.
  * Compiled Generator packages passing these values to host recipes or computed data require
- * runtime 8.0.0 or newer in major 8.
+ * runtime 9.0.0 or newer in major 9.
  */
 export function bounds2(input) {
     return new PlanarBounds(snapshot(input, 2));
 }
 /**
- * Snapshots finite ordered XYZ bounds in millimetres as an immutable fluent value.
+ * Constructs immutable finite XYZ bounds from ordered extrema or nonnegative size in millimetres.
  *
  * Zero extents are valid. Invalid dimensions, nonfinite coordinates, reversed bounds and
  * overflowing extents throw `INVALID_ARGUMENT` GeometryError. Use `toData()` for plain records.
+ * Size construction centers on the origin unless `center` is false. Size and extrema are exclusive.
  * Compiled Generator packages passing these values to host recipes or computed data require
- * runtime 8.0.0 or newer in major 8.
+ * runtime 9.0.0 or newer in major 9.
  */
 export function bounds3(input) {
     return new SpatialBounds(snapshot(input, 3));

package/dist/geometry/bounds.js

@@ -37,23 +37,6 @@ function size(bounds) {
 function center(bounds) {
     return bounds.min.map((value, axis) => value / 2 + bounds.max[axis] / 2);
 }
-export function boundsFromSize(dimensions, options = {}) {
-    const operation = "boundsFromSize";
-    if (!isArray(dimensions) ||
-        (dimensions.length !== 2 && dimensions.length !== 3) ||
-        Array.from(dimensions).some((value) => !Number.isFinite(value) || value < 0))
-        fail(operation, "Bounds dimensions require two or three finite nonnegative values.");
-    if (typeof options !== "object" ||
-        options === null ||
-        isArray(options) ||
-        (options.center !== undefined && typeof options.center !== "boolean"))
-        fail(operation, "Bounds placement requires an optional boolean center value.");
-    const centered = options.center ?? true;
-    return Object.freeze({
-        min: vector(dimensions.map((value) => (centered ? -value / 2 : 0)), operation),
-        max: vector(dimensions.map((value) => (centered ? value / 2 : value)), operation),
-    });
-}
 export function boundsSize(bounds) {
     validateBounds(bounds, "boundsSize");
     return vector(size(bounds), "boundsSize");