@metamesh/modeling 0.17.0 → 0.19.0

package/dist/model/diagnostic-path.js

@@ -0,0 +1,26 @@
+/** Captures a bounded relative field location without reading array accessors. */
+export function captureDiagnosticPath(path) {
+    if (path === undefined)
+        return undefined;
+    const invalid = () => {
+        throw new TypeError("Diagnostic path must contain at most 32 field names or nonnegative safe indices; field names need 1–120 characters.");
+    };
+    if (!Array.isArray(path) || path.length > 32 || Reflect.ownKeys(path).length !== path.length + 1)
+        invalid();
+    const captured = [];
+    for (let index = 0; index < path.length; index++) {
+        const field = Object.getOwnPropertyDescriptor(path, String(index));
+        if (field === undefined || !("value" in field))
+            return invalid();
+        const segment = field.value;
+        if (typeof segment === "string"
+            ? segment.length === 0 || segment.length > 120
+            : typeof segment !== "number" ||
+                !Number.isSafeInteger(segment) ||
+                segment < 0 ||
+                Object.is(segment, -0))
+            invalid();
+        captured.push(segment);
+    }
+    return Object.freeze(captured);
+}

package/dist/model/execution-binding.js

@@ -1,7 +1,7 @@
 import { GeometryError } from "../geometry/errors.js";
 // One protocol key lets locally bundled operation wrappers resolve the host's execution
 // without depending on package instances, class identity, or initializing a native runtime.
-const executionKey = Symbol.for("@metamesh/modeling/execution/9");
+const executionKey = Symbol.for("@metamesh/modeling/execution/12");
 const bindings = globalThis;
 /** Internal host binding. Executable callbacks are synchronous and may not nest executions. */
 export function bindModelContext(context, build) {
@@ -10,7 +10,7 @@ export function bindModelContext(context, build) {
             operation: "build",
         });
     }
-    bindings[executionKey] = { version: 7, context };
+    bindings[executionKey] = { version: 12, context };
     try {
         return build();
     }
@@ -31,5 +31,5 @@ export function currentModelContext(operation) {
 /** Reads an optional binding without initializing an engine or creating ambient authoring state. */
 export function activeModelContext() {
     const binding = bindings[executionKey];
-    return binding?.version === 7 ? binding.context : undefined;
+    return binding?.version === 12 ? binding.context : undefined;
 }

package/dist/model/generation.js

@@ -1,4 +1,5 @@
-/** A user-correctable assertion failure. Successful computation caches never retain failures. */
+import { captureDiagnosticPath } from "./diagnostic-path.js";
+/** A user-correctable assertion failure. Successful memo caches never retain failures. */
 export class GenerationError extends Error {
     /** Issues reached in normal JavaScript order, ending with the first failed assertion. */
     diagnostics;
@@ -6,11 +7,16 @@ export class GenerationError extends Error {
     constructor(diagnostics) {
         super(diagnostics.at(-1)?.message ?? "Generation failed.");
         this.name = "GenerationError";
-        this.diagnostics = Object.freeze(diagnostics.map((issue) => Object.freeze({ ...issue })));
+        this.diagnostics = Object.freeze(diagnostics.map((issue) => Object.freeze({
+            ...issue,
+            ...(issue.path === undefined ? {} : { path: captureDiagnosticPath(issue.path) }),
+        })));
     }
 }
 /**
- * Defines a typed model without executing it. Use `computed` only for work worth reusing.
+ * Defines a typed model without executing it. Parameters are an object map of capturable data;
+ * runtime capture rejects arrays at the root, ordinary class instances, mutable buffers, and functions.
+ * Supply live capabilities through services. Use `memo` only for work worth reusing.
  *
  * @example A simple model
  * ```ts

package/dist/model/geometry-recipes.js

@@ -1,7 +1,7 @@
 import { createSectionHandle, createSolidHandle } from "./shape-handles.js";
 // One realm protocol lets bundled authoring code declare recipes before a host is initialized.
 // The payload contains no native handles and the engine remains responsible for realization.
-const recipeKey = Symbol.for("@metamesh/modeling/recipe/9");
+const recipeKey = Symbol.for("@metamesh/modeling/recipe/10");
 /** Reads private recipe metadata without requiring an execution context. */
 export const geometryRecipe = (value) => Object.getOwnPropertyDescriptor(value, recipeKey)?.value;
 /** Recognizes only opaque recipe handles issued by this engine. */

package/dist/model/immutable-generation-data.js

@@ -1,14 +1,45 @@
 import { GeometryError } from "../geometry/errors.js";
+import { adoptImmutableBuffer, immutableBuffer, immutableBufferView, isImmutableBuffer, } from "../geometry/immutable-buffer.js";
 import { isImmutableMathValue } from "../geometry/math/immutable-value.js";
 import { geometryRecipe, isGeometryRecipe } from "./geometry-recipes.js";
-import { adoptImmutableBuffer, immutableBuffer, immutableBufferView, isImmutableBuffer, } from "./immutable-buffer.js";
-const mutableBufferMessage = "Generation data cannot contain mutable typed arrays or raw ArrayBuffers. Use immutableBuffer(array) or immutableMesh(mesh) before caching them or declaring dependencies.";
+const mutableBufferMessage = "Generation data cannot contain mutable typed arrays or raw ArrayBuffers. Use immutableBuffer(array) or mesh.immutable(mesh) before passing them to memo or capturing generation data.";
 const capturedMetadata = new WeakMap();
+const immutableInputs = new WeakSet();
 const noChildren = Object.freeze([]);
 /** Reuses field accounting only for containers captured or deeply validated by this owner. */
 export function generationDataMetadata(value) {
     return capturedMetadata.get(value);
 }
+/** Identity reuse is safe only for owned values or completely frozen plain-data graphs. */
+export function isImmutableGenerationValue(value) {
+    if (typeof value !== "object" || value === null)
+        return typeof value !== "function";
+    const seen = new Set();
+    const immutable = (input) => {
+        if (typeof input !== "object" || input === null)
+            return typeof input !== "function";
+        if (immutableInputs.has(input) ||
+            capturedMetadata.has(input) ||
+            isGeometryRecipe(input) ||
+            isImmutableMathValue(input) ||
+            isImmutableBuffer(input))
+            return true;
+        if (!Object.isFrozen(input))
+            return false;
+        if (seen.has(input))
+            return true;
+        seen.add(input);
+        for (const [, field] of generationDataEntries(input))
+            if (!immutable(field))
+                return false;
+        return true;
+    };
+    if (!immutable(value))
+        return false;
+    for (const input of seen)
+        immutableInputs.add(input);
+    return true;
+}
 const scalarBytes = (value) => (typeof value === "string" ? value.length * 2 : 8);
 /** Iterates plain fields; recipe capture may read each enumerable accessor once. */
 export function* generationDataEntries(value, captureAccessors = false) {
@@ -20,7 +51,7 @@ export function* generationDataEntries(value, captureAccessors = false) {
             continue;
         const descriptor = Object.getOwnPropertyDescriptor(value, key);
         if (!captureAccessors && !("value" in descriptor))
-            throw new GeometryError("INVALID_ARGUMENT", "Generation data requires own data fields, not accessors.", { operation: "computed" });
+            throw new GeometryError("INVALID_ARGUMENT", "Generation data requires own data fields, not accessors.", { operation: "memo" });
         if (typeof key !== "string" || !descriptor.enumerable)
             throw new TypeError("Generation data requires enumerable string-keyed fields.");
         yield [
@@ -190,13 +221,13 @@ function mathValueData(value) {
         throw new TypeError("Immutable math values must expose canonical data through toData().");
     return Reflect.apply(method, value, []);
 }
-function captureValue(value, mode, readerAllowed = () => false, validated) {
+function captureValue(value, mode, validated) {
     const recipeInputs = mode === "recipe";
     const seen = new Map();
     const metadata = new Map();
     const copy = (input) => {
-        if (typeof input === "function" && !recipeInputs && !readerAllowed(input))
-            throw new GeometryError("INVALID_ARGUMENT", "Computed values and dependencies cannot contain arbitrary function closures.", { operation: "computed" });
+        if (typeof input === "function" && !recipeInputs)
+            throw new GeometryError("INVALID_ARGUMENT", "Memo arguments and results cannot contain arbitrary function closures.", { operation: "memo" });
         if (typeof input !== "object" ||
             input === null ||
             isGeometryRecipe(input) ||
@@ -230,7 +261,7 @@ function captureValue(value, mode, readerAllowed = () => false, validated) {
         };
         if (mode === "dependency") {
             if (!Object.isFrozen(input))
-                throw new GeometryError("INVALID_ARGUMENT", "Computed dependencies require deeply immutable objects and arrays. Read params inside the callback, use a computed value, or depend on individual scalar values.", { operation: "computed" });
+                throw new GeometryError("INVALID_ARGUMENT", "Memo arguments require deeply immutable objects and arrays. Pass params directly, use a memo result, or pass individual scalar values.", { operation: "memo" });
             seen.set(input, input);
             for (const [key, field] of entries) {
                 copy(field);
@@ -266,22 +297,22 @@ function captureValue(value, mode, readerAllowed = () => false, validated) {
         capturedMetadata.set(value, entry);
     return result;
 }
-/** Validates while capturing immutable data; only explicitly allowed session readers may be functions. */
-export function captureGenerationValue(value, readerAllowed) {
-    return captureValue(value, "data", readerAllowed);
+/** Captures immutable ordinary generation data; arbitrary function closures are invalid. */
+export function captureGenerationValue(value) {
+    return captureValue(value, "data");
 }
 /** Snapshots the list, preserving immutable entry identities and validating each object only once. */
-export function captureGenerationDependencies(values, readerAllowed, validated) {
+export function captureGenerationArguments(values, validated) {
     const inputs = [];
     for (const [key, value] of generationDataEntries(values)) {
         if (key !== String(inputs.length))
-            throw new TypeError("Computed dependencies must be a dense array without extra fields.");
+            throw new TypeError("Memo arguments must be a dense array without extra fields.");
         inputs.push(value);
     }
     if (inputs.length !== values.length)
-        throw new TypeError("Computed dependencies must be a dense array without extra fields.");
+        throw new TypeError("Memo arguments must be a dense array without extra fields.");
     const result = Object.freeze(inputs);
-    captureValue(result, "dependency", readerAllowed, validated);
+    captureValue(result, "dependency", validated);
     return result;
 }
 /** Captures ordinary inputs once, including accessor values and mutable numeric arrays. */

package/dist/model/join.js

@@ -0,0 +1 @@
+export {};

package/dist/model/operations.js

@@ -1,10 +1,4 @@
-import { GeometryError } from "../geometry/errors.js";
 import { invokeModelOperation as invoke } from "./operation-dispatch.js";
-function requireProfile(shape, operation) {
-    if (typeof shape !== "object" || shape === null || !("components" in shape)) {
-        throw new GeometryError("INVALID_ARGUMENT", `${operation}() requires a CorrespondingProfile. Use section.${operation}() for a Section.`, { operation });
-    }
-}
 /**
  * Axis-aligned box with uniform or disjoint named edge/group treatments.
  *
@@ -16,6 +10,26 @@ function requireProfile(shape, operation) {
 export function box(options) {
     return invoke("box", [options]);
 }
+/**
+ * Fuses two positioned solids with a dimensioned transition at the feature's source datum.
+ *
+ * Requires a local straight feature collar and a continuous support patch single-valued along
+ * that collar's axis. Angled and curved sampled supports are admitted when those proofs hold.
+ * Width is a parallel-edge offset; height is axial rise above local contact, both in millimetres.
+ * The default smooth profile matches tangents; kind "straight" gives a linear bevel profile.
+ * Neither operand moves, loses material, or changes sampling. The result has no inherited anchors.
+ * This operation promises neither a circular radius, a constant bevel angle, nor global curvature continuity.
+ *
+ * @example Join a mounting boss
+ * ```ts
+ * const base = box({ size: [50, 40, 6] });
+ * const feature = cylinder({ diameter: 12, height: 14, center: false }).translate([0, 0, 2]);
+ * base.join(feature, { source: "bottom", transition: { width: 2, height: 3 } });
+ * ```
+ */
+export function join(base, feature, options) {
+    return invoke("join", [base, feature, options]);
+}
 /**
  * +Z cylinder or frustum. Face sizing compensates polygon faceting.
  *
@@ -34,13 +48,15 @@ export function cylinder(options) {
 }
 /**
  * Declares a +Z hole or blind-pocket cutter with explicit end overrun in millimetres.
+ *
+ * @remarks
  * Choose exactly one circular diameter or existing Section. A 45-degree entry chamfer
  * supports one strictly convex contour without holes; plain profiles may have any topology.
  * Circular entries retain nominal frustum radii; profile entries offset the supplied polygon edges.
  * Circular head recesses are mutually exclusive with entryChamfer. Both overrun ends default
  * to zero, so the nominal bottom remains at Z=0 and blind pocket floors are preserved.
  * Existing Section samples are authoritative; limits and unspecified circular sampling belong
- * to the evaluating host. Compiled packages require runtime major 9.
+ * to the evaluating host.
  *
  * @example A blind hex pocket with an open top
  * ```ts
@@ -92,52 +108,6 @@ export function union(shapes) {
 export function intersect(shapes) {
     return invoke("intersect", [shapes]);
 }
-/**
- * Splits a solid into [inside the cutter, outside the cutter].
- *
- * The first result is the intersection; the second is the subtraction. The cutter itself
- * is not returned. Either result may be empty or contain multiple disconnected components.
- *
- * @example Keep the plug and the surrounding body
- * ```ts
- * const body = box({ size: [30, 20, 8] });
- * const cutter = cylinder({ height: 10, diameter: 8 });
- * const [plug, remainder] = split(body, cutter);
- * // Move the plug beside the body to show both results.
- * union([plug.translate([0, -20, 0]), remainder]);
- * ```
- */
-export function split(solid, cutter) {
-    return invoke("split", [solid, cutter]);
-}
-/**
- * Splits a solid into [positive-normal side, negative side] at a world-space plane.
- *
- * The nonzero normal is normalized; offset is the signed distance from the origin in
- * millimetres, defaulting to zero. Both cut faces are closed. Select either tuple result
- * to retain one side; either result may be empty.
- *
- * @example Separate two halves at X = 0
- * ```ts
- * const body = box({ size: [30, 20, 8] });
- * const [right, left] = splitByPlane(body, { normal: [1, 0, 0] });
- * // The gap is only for display; the cut itself removes no material.
- * union([right.translate([4, 0, 0]), left.translate([-4, 0, 0])]);
- * ```
- *
- * @example Keep only the positive half
- * ```ts
- * const [right] = splitByPlane(box({ size: [30, 20, 8] }), { normal: [1, 0, 0] });
- * right;
- * ```
- */
-export function splitByPlane(solid, plane) {
-    return invoke("splitByPlane", [solid, plane]);
-}
-/** Combines disjoint components without resolving overlap. */
-export function compose(solids) {
-    return invoke("compose", [solids]);
-}
 export function hull(options) {
     return invoke("hull", [options]);
 }
@@ -151,27 +121,16 @@ export function minkowskiSum(a, b) {
  * @example Mesh import
  * ```ts
  * import { solidFromMesh } from "@metamesh/modeling";
- * import { extrudeMesh, rectangleContour } from "@metamesh/modeling/geometry";
+ * import * as mesh from "@metamesh/modeling/geometry/mesh";
+ * import { rectangleContour } from "@metamesh/modeling/geometry";
  *
- * const mesh = extrudeMesh(rectangleContour({ size: [20, 12] }), { height: 6 });
- * solidFromMesh(mesh);
+ * const plate = mesh.extrude(rectangleContour({ size: [20, 12] }), { height: 6 });
+ * solidFromMesh(plate);
  * ```
  */
 export function solidFromMesh(mesh) {
     return invoke("solidFromMesh", [mesh]);
 }
-/**
- * Reads a copied, immutable named anchor from this exact active generation.
- *
- * @example Read the top datum
- * ```ts
- * const plate = box({ size: [30, 20, 6] });
- * anchor(plate, "top"); // position [0, 0, 3], direction [0, 0, 1]
- * ```
- */
-export function anchor(shape, name) {
-    return invoke("anchor", [shape, name]);
-}
 /**
  * Fills one closed millimetre XY outline, explicit outer/hole topology, or compound contours.
  *
@@ -260,8 +219,8 @@ export function star(options) {
     return invoke("star", [options]);
 }
 /**
- * Extrudes explicit corresponding contours along +Z with degree twist and top scaling.
- * Filled Sections use `section.extrude(options)`.
+ * Extrudes a filled Section or explicit corresponding contours along +Z with degree twist and top scaling.
+ * Use `section.extrude(options)` in fluent sequences, or this function for generic profile inputs.
  *
  * @example Extrude
  * ```ts
@@ -273,12 +232,11 @@ export function star(options) {
  * ```
  */
 export function extrude(shape, options) {
-    requireProfile(shape, "extrude");
     return invoke("extrude", [shape, options]);
 }
 /**
- * Revolves explicit corresponding radial/Z contours around +Z, with caps for partial sweeps.
- * Filled Sections use `section.revolve(options)`.
+ * Revolves a filled Section or explicit corresponding radial/Z contours around +Z, with caps for partial sweeps.
+ * Use `section.revolve(options)` in fluent sequences, or this function for generic profile inputs.
  *
  * @example Revolve
  * ```ts
@@ -291,7 +249,6 @@ export function extrude(shape, options) {
  * ```
  */
 export function revolve(shape, options) {
-    requireProfile(shape, "revolve");
     return invoke("revolve", [shape, options]);
 }
 export function loft(stations, options) {
@@ -305,8 +262,8 @@ export function matchProfiles(profiles, options) {
     return invoke("matchProfiles", [profiles, options]);
 }
 /**
- * Sweeps explicit corresponding contours using the selected frame policy.
- * Filled Sections use `section.sweep(path, options)`.
+ * Sweeps a filled Section or explicit corresponding contours using the selected frame policy.
+ * Use `section.sweep(path, options)` in fluent sequences, or this function for generic profile inputs.
  *
  * @example Sweep
  * ```ts
@@ -320,75 +277,8 @@ export function matchProfiles(profiles, options) {
  * ```
  */
 export function sweep(shape, path, options) {
-    requireProfile(shape, "sweep");
     return invoke("sweep", [shape, path, options]);
 }
-/**
- * Copies lightweight section measurements.
- *
- * @example Check filled area
- * ```ts
- * const facts = inspectSection(rectangle({ size: [20, 10] }));
- * facts.area; // 200 mm²
- * ```
- */
-export function inspectSection(section) {
-    return invoke("inspectSection", [section]);
-}
-/**
- * Reads immutable native facts once per solid; temporary components are owned by the build.
- *
- * @example Check dimensions and volume
- * ```ts
- * const facts = inspectSolid(box({ size: [30, 20, 6] }));
- * facts.volume; // 3600 mm³
- * ```
- */
-export function inspectSolid(solid) {
-    return invoke("inspectSolid", [solid]);
-}
-/**
- * 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.
- *
- * @example Check a missed intersection
- * ```ts
- * const body = box({ size: 10 });
- * const distant = box({ size: 10 }).translate([30, 0, 0]);
- * const empty = intersect([body, distant]);
- * const missed = isEmpty(empty); // true
- * ```
- */
-export function isEmpty(shape) {
-    return invoke("isEmpty", [shape]);
-}
-/**
- * Measures the minimum separation between two nonempty solids in millimetres.
- *
- * 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 geometry and component selections from another session reject. Results follow native numeric precision.
- *
- * @example Measure the gap between two blocks
- * ```ts
- * const left = box({ size: 10 });
- * const right = box({ size: 10 }).translate([13, 0, 0]);
- * const gap = distance(left, right); // 3 mm
- * ```
- */
-export function distance(solid, other) {
-    return invoke("distance", [solid, other]);
-}
-/** Copies intersections along the finite directed origin-to-endpoint segment. */
-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.
  * The retained callback must capture independent immutable inputs, not live session readers or parameters.
@@ -439,7 +329,7 @@ export function threadRidge(options) {
  * Each half's `chamfer` bevels its barrel outer rims and all web edges. Consumers own plates, screw holes,
  * pin retention, fit policy, and part placement. Added mounting material must preserve the bores.
  * No opening range or collision freedom is implied for arbitrary caller attachments.
- * Compiled Generator packages using this operation require runtime 9.0.0 or newer in major 9.
+ * Compiled Generator packages using this operation require runtime 10.0.0 or newer in major 10.
  *
  * @example Integral-pin hinge with two mounting webs
  * ```ts

package/dist/model/recipe-declaration.js

@@ -17,10 +17,10 @@ const operationBehaviors = {
     heightfield: "solid",
     implicit: "solid",
     extrude: "solid",
+    join: "solid",
     revolve: "solid",
     loft: "solid",
     sweep: "solid",
-    compose: "solid",
     minkowskiSum: "solid",
     solidFromMesh: "solid",
     withTolerance: "solid",
@@ -54,7 +54,7 @@ const operationBehaviors = {
     intersect: "preserve",
     subtract: "preserve",
     hull: "preserve",
-    toTriangleMesh: "observation",
+    toMesh: "observation",
     toRegionData: "observation",
     inspectSection: "observation",
     inspectSolid: "observation",
@@ -97,6 +97,11 @@ export function declareRecipeOperation(operation, resolution, supplied, declarat
     if (behavior === "pattern")
         return declarePattern(operation, resolution, supplied, declaration);
     const args = captureRecipeInputs(supplied);
+    if ((operation === "union" || operation === "intersect") &&
+        (!Array.isArray(args[0]) || args[0].length === 0))
+        throw new GeometryError("INVALID_ARGUMENT", `${operation} requires at least one shape.`, {
+            operation,
+        });
     const call = { method: operation, args, resolution };
     if (behavior === "observation")
         return requireRealization(declaration, operation).invoke(call);

package/dist/model/shape-handles.js

@@ -4,11 +4,23 @@ const dispatchers = new WeakMap();
 // 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]);
+        return invoke(this, name, [this, ...args]);
+    };
+}
+function invoke(receiver, name, args) {
+    const dispatch = dispatchers.get(receiver);
+    if (dispatch !== undefined)
+        return dispatch(name, args);
+    const context = currentModelContext(name);
+    return Reflect.apply(context[name], undefined, args);
+}
+/** Receiver and collection forms share one batch operation and preserve declared operand order. */
+function booleanMethod(name) {
+    return function (operand) {
+        const operands = Array.isArray(operand) ? operand : [operand];
+        if (operands.length === 0)
+            return this;
+        return invoke(this, name, name === "subtract" ? [this, operands] : [[this, ...operands]]);
     };
 }
 function prototype(methods) {
@@ -20,17 +32,28 @@ const common = {
     scale: forward("scale"),
     mirror: forward("mirror"),
     transform: forward("transform"),
-    subtract: forward("subtract"),
+    union: booleanMethod("union"),
+    intersect: booleanMethod("intersect"),
+    subtract: booleanMethod("subtract"),
     simplify: forward("simplify"),
     withAnchors: forward("withAnchors"),
+    isEmpty: forward("isEmpty"),
+    components: forward("components"),
+    anchor: forward("anchor"),
 };
 const solidPrototype = prototype({
     ...common,
-    toTriangleMesh: forward("toTriangleMesh"),
+    join: forward("join"),
+    toMesh: forward("toMesh"),
     attach: forward("attach"),
     withTolerance: forward("withTolerance"),
     projectSection: forward("projectSection"),
     sliceSection: forward("sliceSection"),
+    inspect: forward("inspectSolid"),
+    distance: forward("distance"),
+    castSegment: forward("castSegment"),
+    split: forward("split"),
+    splitByPlane: forward("splitByPlane"),
 });
 const sectionPrototype = prototype({
     ...common,
@@ -39,6 +62,7 @@ const sectionPrototype = prototype({
     extrude: forward("extrude"),
     revolve: forward("revolve"),
     sweep: forward("sweep"),
+    inspect: forward("inspectSection"),
 });
 /** Creates only the immutable public facade; the caller owns its private geometry identity. */
 export function createSolidHandle(dispatch, properties) {

package/dist/text/index.js

@@ -1,7 +1,7 @@
 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. */
+/** Maximum input font size in bytes, checked before parsing or shaping untrusted font data. */
 export const MAX_VECTOR_FONT_BYTES = 16 * 1024 * 1024;
 function fail(message, code = "INVALID_ARGUMENT") {
     throw new GeometryError(code, message, { operation: "prepareVectorFont" });