@metamesh/modeling 0.13.0 → 0.15.0

package/dist/model/operations.js

@@ -139,10 +139,6 @@ export function minkowskiSum(a, b) {
 export function solidFromMesh(mesh) {
     return invoke("solidFromMesh", [mesh]);
 }
-/** Copies a handle to manufacturing mesh buffers. */
-export function toTriangleMesh(solid) {
-    return invoke("toTriangleMesh", [solid]);
-}
 /**
  * Reads a copied, immutable named anchor from this exact active generation.
  *
@@ -168,13 +164,20 @@ export function anchor(shape, name) {
 export function polygon(input) {
     return invoke("polygon", [input]);
 }
-/** Imports explicit region topology once. */
-export function fromRegion(region) {
-    return invoke("fromRegion", [region]);
-}
-/** Explicit copied topology inspection; not needed for section operations. */
-export function toRegion(section) {
-    return invoke("toRegion", [section]);
+/**
+ * Creates a centered-width native Section along a sampled XY path.
+ *
+ * Shares caps, joins and physical sampling with Geometry's strokeRegionData. Native union
+ * resolves overlapping stroke primitives. Session resolution and resource ceilings apply;
+ * closed paths omit the duplicated seam. Returns an immutable deferred recipe.
+ *
+ * @example Extrude a rounded track
+ * ```ts
+ * stroke([[0, 0], [20, 0], [20, 10]], { width: 3, join: "round", cap: "round" }).extrude({ height: 2 });
+ * ```
+ */
+export function stroke(path, options) {
+    return invoke("stroke", [path, options]);
 }
 /**
  * Filled rectangular section with uniform or independently treated corners.
@@ -259,7 +262,7 @@ export function extrude(shape, options) {
  *
  * // Contour coordinates are [radius, Z].
  * const [profile] = matchProfiles([rectangleProfile({ size: [4, 16], center: false })]);
- * revolve(profile!, { revolveDegrees: 270 });
+ * revolve(profile!, { degrees: 270 });
  * ```
  */
 export function revolve(shape, options) {
@@ -269,7 +272,10 @@ export function revolve(shape, options) {
 export function loft(stations, options) {
     return invoke("loft", [stations, options]);
 }
-/** Explicit family matching on a shared physical span grid using session or operation resolution. */
+/**
+ * Matches a profile family using operation settings over host resolution and limits.
+ * Requires active synchronous model execution. Use Geometry's matchProfiles for standalone preparation.
+ */
 export function matchProfiles(profiles, options) {
     return invoke("matchProfiles", [profiles, options]);
 }
@@ -317,7 +323,7 @@ export function inspectSolid(solid) {
     return invoke("inspectSolid", [solid]);
 }
 /**
- * Checks whether a same-session solid or filled section contains no geometry.
+ * Checks whether a solid or filled section contains no geometry during host execution.
  *
  * Accepts a 3D Solid or 2D Section handle, not a finalized model or raw triangle mesh.
  * Useful after a Boolean operation whose inputs may not overlap; no mesh is extracted.
@@ -339,7 +345,7 @@ export function isEmpty(shape) {
  * Uses actual geometry, not bounding-box separation or distance between object origins.
  * Contact or overlapping material returns zero, including one solid inside another.
  * The kernel's search range is managed internally; the result is not capped at a caller limit.
- * Empty, expired or foreign-build handles reject. Results follow native numeric precision.
+ * Empty geometry and component selections from another session reject. Results follow native numeric precision.
  *
  * @example Measure the gap between two blocks
  * ```ts
@@ -352,19 +358,23 @@ export function distance(solid, other) {
     return invoke("distance", [solid, other]);
 }
 /** Copies intersections along the finite directed origin-to-endpoint segment. */
-export function rayCast(solid, origin, endpoint) {
-    return invoke("rayCast", [solid, origin, endpoint]);
+export function castSegment(solid, origin, endpoint) {
+    return invoke("castSegment", [solid, origin, endpoint]);
 }
 export function components(shape) {
     return invoke("components", [shape]);
 }
-/** Bounded positive-inside implicit field constructor. */
+/**
+ * Bounded positive-inside implicit field constructor.
+ * The retained callback must capture independent immutable inputs, not live session readers or parameters.
+ */
 export function implicit(options) {
     return invoke("implicit", [options]);
 }
 /**
  * Closed rectilinear top above a flat base, with uniform or explicit XY coordinates.
  * Samples each grid height once; center-error triangulation also samples each cell centre.
+ * The retained callback must capture independent immutable inputs, not live session readers or parameters.
  *
  * @example Heightfield
  * ```ts
@@ -377,17 +387,17 @@ export function implicit(options) {
 export function heightfield(options) {
     return invoke("heightfield", [options]);
 }
-export function linearPattern(source, options) {
-    return invoke("linearPattern", [source, options]);
+export function linearPattern(...args) {
+    return invoke("linearPattern", args);
 }
-export function radialPattern(source, options) {
-    return invoke("radialPattern", [source, options]);
+export function radialPattern(...args) {
+    return invoke("radialPattern", args);
 }
-export function gridPattern(source, options) {
-    return invoke("gridPattern", [source, options]);
+export function gridPattern(...args) {
+    return invoke("gridPattern", args);
 }
-export function pathPattern(source, path, options) {
-    return invoke("pathPattern", [source, path, options]);
+export function pathPattern(...args) {
+    return invoke("pathPattern", args);
 }
 /** Helical ridge mesh construction. */
 export function threadRidge(options) {
@@ -399,9 +409,9 @@ export function threadRidge(options) {
  * @example Threaded rod
  * ```ts
  * import { threadedRod } from "@metamesh/modeling";
- * import { createThreadProfile } from "@metamesh/modeling/geometry";
+ * import { threadProfile } from "@metamesh/modeling/geometry";
  *
- * const profile = createThreadProfile({ kind: "triangular", pitch: 1.75 });
+ * const profile = threadProfile({ kind: "triangular", pitch: 1.75 });
  * threadedRod({ nominalMajorDiameter: 12, length: 24, profile, fit: "normal" });
  * ```
  */
@@ -414,8 +424,8 @@ export function threadedRod(options) {
  * @example Internal thread
  * ```ts
  * import { cylinder, internalThreadCutter } from "@metamesh/modeling";
- * import { createThreadProfile } from "@metamesh/modeling/geometry";
- * const profile = createThreadProfile({ kind: "triangular", pitch: 1.75 });
+ * import { threadProfile } from "@metamesh/modeling/geometry";
+ * const profile = threadProfile({ kind: "triangular", pitch: 1.75 });
  * const body = cylinder({ diameter: 20, height: 12, center: false });
  * const cutter = internalThreadCutter({ nominalMajorDiameter: 12, length: 12, profile });
  * body.subtract([cutter]);
@@ -430,24 +440,24 @@ export function internalThreadCutter(options) {
  * @example Threaded nut
  * ```ts
  * import { threadedNut } from "@metamesh/modeling";
- * import { createThreadProfile } from "@metamesh/modeling/geometry";
+ * import { threadProfile } from "@metamesh/modeling/geometry";
  *
- * const profile = createThreadProfile({ kind: "triangular", pitch: 1.75 });
+ * const profile = threadProfile({ kind: "triangular", pitch: 1.75 });
  * threadedNut({ nominalMajorDiameter: 12, thickness: 8, width: 20, shape: "hex", profile, fit: "normal" });
  * ```
  */
 export function threadedNut(options) {
     return invoke("threadedNut", [options]);
 }
-/** Allocation-free external-thread facts. */
+/** External-thread facts using host resolution and limits; requires active synchronous model execution. */
 export function preflightThreadedRod(options) {
     return invoke("preflightThreadedRod", [options]);
 }
-/** Allocation-free internal-thread facts. */
+/** Internal-thread facts using host resolution and limits; requires active synchronous model execution. */
 export function preflightInternalThreadCutter(options) {
     return invoke("preflightInternalThreadCutter", [options]);
 }
-/** Allocation-free nut/cutter facts. */
+/** Nut/cutter facts using host resolution and limits; requires active synchronous model execution. */
 export function preflightThreadedNut(options) {
     return invoke("preflightThreadedNut", [options]);
 }

package/dist/model/recipe-declaration.js

@@ -0,0 +1,199 @@
+import { GeometryError } from "../geometry/errors.js";
+import { defaultModelingLimits } from "../geometry/model-limits.js";
+import { gridPatternPlan, linearPatternPlan, pathPatternPlan, radialPatternPlan, } from "../geometry/patterns/placements.js";
+import { restrictTransform3 } from "../geometry/transform2.js";
+import { geometryRecipe, recordGeometryRecipe, } from "./geometry-recipes.js";
+import { captureRecipeInputs } from "./immutable-generation-data.js";
+// Every public operation must explicitly choose its realization and result behavior.
+const operationBehaviors = {
+    withResolution: "resolution",
+    box: "solid",
+    cylinder: "solid",
+    tube: "solid",
+    sphere: "solid",
+    torus: "solid",
+    heightfield: "solid",
+    implicit: "solid",
+    extrude: "solid",
+    revolve: "solid",
+    loft: "solid",
+    sweep: "solid",
+    compose: "solid",
+    minkowskiSum: "solid",
+    solidFromMesh: "solid",
+    withTolerance: "solid",
+    threadRidge: "solid",
+    threadedRod: "solid",
+    threadedNut: "solid",
+    internalThreadCutter: "solid",
+    polygon: "section",
+    stroke: "section",
+    rectangle: "section",
+    circle: "section",
+    ellipse: "section",
+    regularPolygon: "section",
+    star: "section",
+    projectSection: "section",
+    sliceSection: "section",
+    textSection: "section",
+    svgSection: "section",
+    svgPathSection: "section",
+    translate: "preserve",
+    rotate: "preserve",
+    scale: "preserve",
+    mirror: "preserve",
+    transform: "preserve",
+    offset: "preserve",
+    simplify: "preserve",
+    withAnchors: "preserve",
+    attach: "preserve",
+    union: "preserve",
+    intersect: "preserve",
+    subtract: "preserve",
+    hull: "preserve",
+    toTriangleMesh: "observation",
+    toRegionData: "observation",
+    inspectSection: "observation",
+    inspectSolid: "observation",
+    isEmpty: "observation",
+    distance: "observation",
+    castSegment: "observation",
+    anchor: "observation",
+    matchProfiles: "observation",
+    preflightThreadedRod: "observation",
+    preflightInternalThreadCutter: "observation",
+    preflightThreadedNut: "observation",
+    split: "split",
+    splitByPlane: "split",
+    components: "components",
+    linearPattern: "pattern",
+    radialPattern: "pattern",
+    gridPattern: "pattern",
+    pathPattern: "pattern",
+};
+/**
+ * Creates the shared declaration surface for portable recipes or one active revision.
+ * Handles retain captured inputs; native results remain private to the host realization owner.
+ */
+export function createRecipeContext(resolution, declaration) {
+    return Object.freeze(Object.fromEntries(Object.keys(operationBehaviors).map((key) => [
+        key,
+        (...supplied) => declareRecipeOperation(key, resolution, supplied, declaration),
+    ])));
+}
+/** Captures and validates inputs before deciding whether an operation needs native geometry now. */
+export function declareRecipeOperation(operation, resolution, supplied, declaration) {
+    declaration.assertActive?.();
+    const behavior = operationBehaviors[operation];
+    if (behavior === "observation" || behavior === "components")
+        requireRealization(declaration, operation);
+    if (behavior === "resolution") {
+        const nextResolution = Object.freeze({ ...resolution, ...supplied[0] });
+        return createRecipeContext(nextResolution, declaration);
+    }
+    if (behavior === "pattern")
+        return declarePattern(operation, resolution, supplied, declaration);
+    const args = captureRecipeInputs(supplied);
+    const call = { method: operation, args, resolution };
+    if (behavior === "observation")
+        return requireRealization(declaration, operation).invoke(call);
+    const recipe = {
+        kind: resultKind(behavior, args[0]),
+        call,
+    };
+    if (behavior === "split")
+        return Object.freeze([
+            recordGeometryRecipe({ ...recipe, index: 0 }, declaration.dispatch),
+            recordGeometryRecipe({ ...recipe, index: 1 }, declaration.dispatch),
+        ]);
+    if (behavior === "components") {
+        // Cardinality and ordering are observations of this session's sampled geometry.
+        // Retain native precision rather than baking the selected component through mesh interchange.
+        const realization = requireRealization(declaration, operation);
+        const values = realization.evaluate(call);
+        return Object.freeze(values.map((_value, index) => recordGeometryRecipe({ ...recipe, index, observedSession: realization.session }, declaration.dispatch)));
+    }
+    return recordGeometryRecipe(recipe, declaration.dispatch);
+}
+/** Declares a portable recipe without resolving an engine, resolution or session identity. */
+export function declarePortableOperation(operation, args, dispatch) {
+    return declareRecipeOperation(operation, undefined, args, {
+        limits: defaultModelingLimits,
+        dispatch,
+    });
+}
+function requireRealization(declaration, operation) {
+    if (declaration.realization === undefined)
+        throw new GeometryError("INVALID_ARGUMENT", "Geometry observations require an active model execution.", { operation });
+    return declaration.realization;
+}
+function resultKind(behavior, input) {
+    if (behavior === "section")
+        return "section";
+    if (behavior === "preserve" || behavior === "components")
+        return inputKind(input);
+    return "solid";
+}
+function inputKind(value) {
+    if (Array.isArray(value))
+        return inputKind(value[0]);
+    if (typeof value !== "object" || value === null)
+        return "solid";
+    const recipe = geometryRecipe(value);
+    if (recipe !== undefined)
+        return recipe.kind;
+    if ("sections" in value)
+        return "section";
+    if ("points" in value && Array.isArray(value.points) && pointDimension(value.points[0]) === 2)
+        return "section";
+    return "solid";
+}
+function pointDimension(value) {
+    if (Array.isArray(value))
+        return value.length;
+    if (typeof value !== "object" || value === null || !("toArray" in value))
+        return undefined;
+    const method = value.toArray;
+    const points = typeof method === "function" ? Reflect.apply(method, value, []) : undefined;
+    return Array.isArray(points) ? points.length : undefined;
+}
+/** Runs every factory during declaration; each placed copy stays deferred until it is used. */
+function declarePattern(operation, resolution, supplied, declaration) {
+    const plan = patternPlan(operation, supplied, declaration.limits);
+    if (plan.count > declaration.limits.maxVertices)
+        throw new GeometryError("COMPLEXITY_LIMIT", "Pattern declaration exceeds execution limits.", {
+            operation,
+        });
+    const source = supplied[0];
+    const copies = [];
+    let kind;
+    for (let index = 0; index < plan.count; index++) {
+        const shape = typeof source === "function"
+            ? source(index)
+            : source;
+        const currentKind = inputKind(shape);
+        if (kind !== undefined && kind !== currentKind)
+            throw new GeometryError("INVALID_ARGUMENT", "Pattern factories must return one shape dimension.", {
+                operation,
+            });
+        kind = currentKind;
+        const matrix = plan.transformAt(index, kind === "section" ? 2 : 3);
+        copies.push(declareRecipeOperation("transform", resolution, [shape, kind === "section" ? restrictTransform3(matrix) : matrix], declaration));
+    }
+    return Object.freeze(copies);
+}
+function patternPlan(operation, supplied, limits) {
+    const options = supplied[1];
+    switch (operation) {
+        case "linearPattern":
+            return linearPatternPlan(options);
+        case "radialPattern":
+            return radialPatternPlan(options);
+        case "gridPattern":
+            return gridPatternPlan(options);
+        case "pathPattern":
+            return pathPatternPlan(options, supplied[2], limits);
+        default:
+            throw new Error(`Operation ${operation} does not declare a pattern.`);
+    }
+}

package/dist/model/shape-handles.js

@@ -1,8 +1,12 @@
 import { currentModelContext } from "./execution-binding.js";
+const dispatchers = new WeakMap();
 // Resolve the current transaction on every call: cached recipes outlive the revision that
 // created them. Neither instances nor these shared methods retain an execution or native value.
 function forward(name) {
     return function (...args) {
+        const dispatch = dispatchers.get(this);
+        if (dispatch !== undefined)
+            return dispatch(name, [this, ...args]);
         const context = currentModelContext(name);
         return Reflect.apply(context[name], undefined, [this, ...args]);
     };
@@ -22,23 +26,31 @@ const common = {
 };
 const solidPrototype = prototype({
     ...common,
+    toTriangleMesh: forward("toTriangleMesh"),
     attach: forward("attach"),
-    setTolerance: forward("setTolerance"),
+    withTolerance: forward("withTolerance"),
     projectSection: forward("projectSection"),
     sliceSection: forward("sliceSection"),
 });
 const sectionPrototype = prototype({
     ...common,
+    toRegionData: forward("toRegionData"),
     offset: forward("offset"),
     extrude: forward("extrude"),
     revolve: forward("revolve"),
     sweep: forward("sweep"),
 });
 /** Creates only the immutable public facade; the caller owns its private geometry identity. */
-export function createSolidHandle() {
-    return Object.freeze(Object.create(solidPrototype));
+export function createSolidHandle(dispatch, properties) {
+    const handle = Object.freeze(Object.create(solidPrototype, properties ?? {}));
+    if (dispatch !== undefined)
+        dispatchers.set(handle, dispatch);
+    return handle;
 }
 /** Creates only the immutable public facade; the caller owns its private geometry identity. */
-export function createSectionHandle() {
-    return Object.freeze(Object.create(sectionPrototype));
+export function createSectionHandle(dispatch, properties) {
+    const handle = Object.freeze(Object.create(sectionPrototype, properties ?? {}));
+    if (dispatch !== undefined)
+        dispatchers.set(handle, dispatch);
+    return handle;
 }

package/dist/text/index.js

@@ -1,14 +1,15 @@
 import { SVGPathData, SVGPathDataTransformer } from "svg-pathdata";
+import { GeometryError } from "../geometry/errors.js";
 import { createVectorTextLayout } from "./vector-text-layout.js";
 /** Limits apply before parsing or shaping untrusted font data. */
 export const MAX_VECTOR_FONT_BYTES = 16 * 1024 * 1024;
-function fail(message) {
-    throw new Error(message);
+function fail(message, code = "INVALID_ARGUMENT") {
+    throw new GeometryError(code, message, { operation: "prepareVectorFont" });
 }
 function serializeVectorText({ paths, metrics }) {
     const bounds = metrics.bounds;
     if (bounds === null || paths.length === 0)
-        fail("The selected font produced no visible glyph outlines.");
+        throw new GeometryError("DEGENERATE_GEOMETRY", "The selected font produced no visible glyph outlines.", { operation: "VectorFont.toSvg" });
     const d = paths
         .map((path) => new SVGPathData(path).transform(SVGPathDataTransformer.MATRIX(1, 0, 0, -1, 0, 0)).encode())
         .join(" ");
@@ -16,11 +17,12 @@ function serializeVectorText({ paths, metrics }) {
     const height = Math.max(0.001, bounds.max[1] - bounds.min[1]);
     const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${width}mm" height="${height}mm" viewBox="${bounds.min[0]} ${-bounds.max[1]} ${width} ${height}"><path fill="black" fill-rule="nonzero" d="${d}"/></svg>`;
     if (svg.length > 256 * 1024)
-        fail("Text outlines exceed 256 KiB. Use fewer characters or a simpler font.");
+        throw new GeometryError("COMPLEXITY_LIMIT", "Text outlines exceed 256 KiB. Use fewer characters or a simpler font.", { operation: "VectorFont.toSvg" });
     return svg;
 }
 /**
  * Parses bounded font bytes using optional fontkit and WOFF2 peers; no font fetching occurs here.
+ * Argument and resource failures use GeometryError; parser and decoder exceptions propagate unchanged.
  *
  * @example Prepare a label before building geometry
  * ```ts
@@ -31,20 +33,24 @@ function serializeVectorText({ paths, metrics }) {
  * ```
  */
 export async function prepareVectorFont(bytes, options = {}) {
-    if (bytes.byteLength === 0 || bytes.byteLength > MAX_VECTOR_FONT_BYTES)
+    if (bytes.byteLength === 0)
         fail("Font files must be non-empty and at most 16 MiB.");
+    if (bytes.byteLength > MAX_VECTOR_FONT_BYTES)
+        fail("Font files must be non-empty and at most 16 MiB.", "COMPLEXITY_LIMIT");
     const staticWeight = options.staticWeight ?? 400;
     if (!Number.isInteger(staticWeight) || staticWeight < 1 || staticWeight > 1000)
-        fail("staticWeight must be an integer from 1 through 1000.");
+        fail("staticWeight must be an integer from 1 through 1000.", Number.isFinite(staticWeight) ? "INVALID_ARGUMENT" : "NON_FINITE_VALUE");
     // Own the original bytes: a caller mutating its buffer must not change later lazy font reads.
     let decoded = Uint8Array.from(bytes);
     if (bytes[0] === 0x77 && bytes[1] === 0x4f && bytes[2] === 0x46 && bytes[3] === 0x32) {
-        const { default: decompress } = await import("woff2-encoder/decompress").catch(() => fail("Install woff2-encoder to prepare WOFF2 fonts with @metamesh/modeling/text."));
+        const { default: decompress } = await import("woff2-encoder/decompress");
         decoded = await decompress(decoded);
-        if (decoded.byteLength === 0 || decoded.byteLength > 32 * 1024 * 1024)
+        if (decoded.byteLength === 0)
             fail("The decoded font must be non-empty and at most 32 MiB.");
+        if (decoded.byteLength > 32 * 1024 * 1024)
+            fail("The decoded font must be non-empty and at most 32 MiB.", "COMPLEXITY_LIMIT");
     }
-    const fontkit = await import("fontkit").catch(() => fail("Install fontkit to prepare fonts with @metamesh/modeling/text."));
+    const fontkit = await import("fontkit");
     const font = fontkit.create(decoded);
     if (!("layout" in font))
         fail("Font collections are not supported.");

package/dist/text/vector-text-layout.js

@@ -1,19 +1,20 @@
 import { SVGPathData, SVGPathDataTransformer } from "svg-pathdata";
+import { GeometryError } from "../geometry/errors.js";
 const MAX_TEXT_LENGTH = 512;
 const MAX_TEXT_LINES = 16;
 const MAX_TEXT_GLYPHS = 2048;
 const MAX_TEXT_COMMANDS = 32000;
 const MAX_TEXT_PATH_BYTES = 1024 * 1024;
 const supportedText = /^[\p{Script=Latin}\p{Script=Greek}\p{Script=Cyrillic}\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Common}\p{Script=Inherited}]*$/u;
-function fail(message) {
-    throw new Error(message);
+function fail(message, code = "INVALID_ARGUMENT") {
+    throw new GeometryError(code, message, { operation: "VectorFont.layout" });
 }
 function checkText(text) {
     if (text.length > MAX_TEXT_LENGTH)
-        fail("Text must contain at most 512 characters and 16 lines.");
+        fail("Text must contain at most 512 characters and 16 lines.", "COMPLEXITY_LIMIT");
     const lines = text.replaceAll("\r\n", "\n").replaceAll("\r", "\n").split("\n");
     if (lines.length > MAX_TEXT_LINES)
-        fail("Text must contain at most 512 characters and 16 lines.");
+        fail("Text must contain at most 512 characters and 16 lines.", "COMPLEXITY_LIMIT");
     if (!supportedText.test(text) ||
         /\p{Emoji_Presentation}|\p{Variation_Selector}|[\u200c-\u200f\u202a-\u202e\u2066-\u2069]/u.test(text))
         fail("This writing system or text direction is not supported yet. Use Latin, Greek, Cyrillic, or horizontal CJK text.");
@@ -27,9 +28,9 @@ function normalizeControls(options, staticWeight) {
         if (typeof baseline !== "object" || baseline === null || baseline.kind !== "arc")
             fail("Invalid text baseline; use an arc or omit baseline for horizontal text.");
         if (!Number.isFinite(baseline.radius) || baseline.radius <= 0 || baseline.radius > 10000)
-            fail("Arc baseline radius must be positive and at most 10000 mm.");
-        if (baseline.centerAngleDegrees !== undefined && !Number.isFinite(baseline.centerAngleDegrees))
-            fail("Arc baseline centerAngleDegrees must be finite.");
+            fail("Arc baseline radius must be positive and at most 10000 mm.", Number.isFinite(baseline.radius) ? "INVALID_ARGUMENT" : "NON_FINITE_VALUE");
+        if (baseline.centerAngle !== undefined && !Number.isFinite(baseline.centerAngle))
+            fail("Arc baseline centerAngle must be finite.", "NON_FINITE_VALUE");
         if (baseline.direction !== undefined &&
             baseline.direction !== "clockwise" &&
             baseline.direction !== "counterclockwise")
@@ -46,18 +47,18 @@ function normalizeControls(options, staticWeight) {
             ? undefined
             : {
                 radius: baseline.radius,
-                centerAngleDegrees: (((baseline.centerAngleDegrees ?? 90) % 360) + 360) % 360,
+                centerAngle: (((baseline.centerAngle ?? 90) % 360) + 360) % 360,
                 direction: baseline.direction ?? "clockwise",
             },
     };
     if (!Number.isFinite(controls.fontSize) || controls.fontSize <= 0 || controls.fontSize > 10000)
-        fail("fontSize must be positive and at most 10000 mm.");
+        fail("fontSize must be positive and at most 10000 mm.", Number.isFinite(controls.fontSize) ? "INVALID_ARGUMENT" : "NON_FINITE_VALUE");
     if (!Number.isInteger(controls.fontWeight) ||
         controls.fontWeight < 1 ||
         controls.fontWeight > 1000)
-        fail("fontWeight must be an integer from 1 through 1000.");
+        fail("fontWeight must be an integer from 1 through 1000.", Number.isFinite(controls.fontWeight) ? "INVALID_ARGUMENT" : "NON_FINITE_VALUE");
     if (!Number.isFinite(controls.letterSpacing) || Math.abs(controls.letterSpacing) > 100)
-        fail("letterSpacing must be finite and between -100 and 100 mm.");
+        fail("letterSpacing must be finite and between -100 and 100 mm.", Number.isFinite(controls.letterSpacing) ? "INVALID_ARGUMENT" : "NON_FINITE_VALUE");
     if (controls.align !== "left" && controls.align !== "center" && controls.align !== "right")
         fail("Invalid text alignment.");
     if (controls.verticalAlign !== "baseline" &&
@@ -69,7 +70,7 @@ function normalizeControls(options, staticWeight) {
         fail("Arc text requires baseline vertical alignment.");
     if (controls.lineHeight !== undefined &&
         (!Number.isFinite(controls.lineHeight) || controls.lineHeight < 0.5 || controls.lineHeight > 5))
-        fail("lineHeight must be between 0.5 and 5.");
+        fail("lineHeight must be between 0.5 and 5.", Number.isFinite(controls.lineHeight) ? "INVALID_ARGUMENT" : "NON_FINITE_VALUE");
     return controls;
 }
 function selectFont(font, weight, staticWeight) {
@@ -130,8 +131,10 @@ function shapeLines(font, lines, controls) {
         // CSS tracking disables optional ligatures, retaining required shaping and combining marks.
         const run = font.layout(line, controls.letterSpacing === 0 ? undefined : { liga: false, clig: false });
         glyphs += run.glyphs.length;
-        if (run.glyphs.length !== run.positions.length || glyphs > MAX_TEXT_GLYPHS)
-            fail("The font returned an invalid or excessive glyph run.");
+        if (run.glyphs.length !== run.positions.length)
+            fail("The font returned an invalid glyph run.");
+        if (glyphs > MAX_TEXT_GLYPHS)
+            fail("The font returned an excessive glyph run.", "COMPLEXITY_LIMIT");
         let advance = 0;
         let spacingSteps = -1;
         for (let index = 0; index < run.glyphs.length; index++) {
@@ -139,14 +142,14 @@ function shapeLines(font, lines, controls) {
                 fail("The selected font shaped a missing glyph.");
             const position = run.positions[index];
             if (![position.xAdvance, position.yAdvance, position.xOffset, position.yOffset].every(Number.isFinite))
-                fail("The font returned a non-finite glyph position.");
+                fail("The font returned a non-finite glyph position.", "NON_FINITE_VALUE");
             if (index === 0 || position.xAdvance !== 0)
                 spacingSteps++;
             advance += position.xAdvance;
         }
         const advanceWidth = advance * scale + Math.max(0, spacingSteps) * controls.letterSpacing;
         if (!Number.isFinite(advanceWidth) || advanceWidth < 0)
-            fail("The shaped text advance must be finite and non-negative after letter spacing.");
+            fail("The shaped text advance must be finite and non-negative after letter spacing.", Number.isFinite(advanceWidth) ? "INVALID_ARGUMENT" : "NON_FINITE_VALUE");
         return { run, advanceWidth };
     });
 }
@@ -158,8 +161,10 @@ function convertCommand({ command, args }) {
             : command === "bezierCurveTo"
                 ? 6
                 : 2;
-    if (args.length !== argumentCount || !args.every(Number.isFinite))
+    if (args.length !== argumentCount)
         fail("The font returned invalid glyph path coordinates.");
+    if (!args.every(Number.isFinite))
+        fail("The font returned invalid glyph path coordinates.", "NON_FINITE_VALUE");
     switch (command) {
         case "moveTo":
             return { type: SVGPathData.MOVE_TO, relative: false, x: args[0], y: args[1] };
@@ -234,23 +239,23 @@ function buildLayout(font, fontMetrics, lines, controls) {
             const source = run.glyphs[index].path.commands;
             commands += source.length;
             if (commands > MAX_TEXT_COMMANDS)
-                fail("Text outlines exceed the supported complexity. Use fewer characters or a simpler font.");
+                fail("Text outlines exceed the supported complexity. Use fewer characters or a simpler font.", "COMPLEXITY_LIMIT");
             if (source.length > 0) {
                 // Preserve full precision: fontkit's toSVG() rounds before scaling and reparsing it wastes work.
                 const path = new SVGPathData(source.map(convertCommand)).transform(SVGPathDataTransformer.MATRIX(scale, 0, 0, scale, (x + position.xOffset) * scale + spacingSteps * controls.letterSpacing + lineX, (y + position.yOffset) * scale - lineIndex * lineHeight));
                 let bounds = path.getBounds();
                 if (![bounds.minX, bounds.minY, bounds.maxX, bounds.maxY].every(Number.isFinite))
-                    fail("The font returned invalid glyph outline bounds.");
+                    fail("The font returned invalid glyph outline bounds.", "NON_FINITE_VALUE");
                 if (controls.baseline !== undefined) {
-                    const { radius, centerAngleDegrees, direction } = controls.baseline;
+                    const { radius, centerAngle, direction } = controls.baseline;
                     const clockwise = direction === "clockwise";
                     if (clockwise ? radius + bounds.minY <= 0 : radius - bounds.maxY <= 0)
                         fail("Arc glyph outlines cross the circle's center axis. Increase the radius or reduce text size.");
-                    const angle = (centerAngleDegrees * Math.PI) / 180 + ((clockwise ? -1 : 1) * groupCenter) / radius;
-                    const rotation = angle + (clockwise ? -Math.PI / 2 : Math.PI / 2);
-                    const cosine = Math.cos(rotation);
-                    const sine = Math.sin(rotation);
-                    path.transform(SVGPathDataTransformer.MATRIX(cosine, sine, -sine, cosine, radius * Math.cos(angle) - cosine * groupCenter, radius * Math.sin(angle) - sine * groupCenter));
+                    const angleRadians = (centerAngle * Math.PI) / 180 + ((clockwise ? -1 : 1) * groupCenter) / radius;
+                    const rotationRadians = angleRadians + (clockwise ? -Math.PI / 2 : Math.PI / 2);
+                    const cosine = Math.cos(rotationRadians);
+                    const sine = Math.sin(rotationRadians);
+                    path.transform(SVGPathDataTransformer.MATRIX(cosine, sine, -sine, cosine, radius * Math.cos(angleRadians) - cosine * groupCenter, radius * Math.sin(angleRadians) - sine * groupCenter));
                     bounds = path.getBounds();
                 }
                 minX = Math.min(minX, bounds.minX);
@@ -278,7 +283,7 @@ function buildLayout(font, fontMetrics, lines, controls) {
         // Path commands and finite numeric coordinates are ASCII, so length is the encoded byte count.
         bytes += result.length;
         if (bytes > MAX_TEXT_PATH_BYTES)
-            fail("Text outlines exceed 1 MiB. Use fewer characters or a simpler font.");
+            fail("Text outlines exceed 1 MiB. Use fewer characters or a simpler font.", "COMPLEXITY_LIMIT");
         return result;
     });
     const metrics = Object.freeze({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metamesh/modeling",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "description": "Scoped solid modeling and pure geometry foundations for Node and browsers.",
   "license": "Apache-2.0",
   "repository": {