@metamesh/modeling 0.19.0 → 0.20.0

package/dist/engine/shape-anchors.js

@@ -1,6 +1,6 @@
-import { anchor3 } from "../geometry/anchors.js";
 import { GeometryError } from "../geometry/errors.js";
-import { applyInverseTranspose3, applyTransformDirection3, applyTransformPoint3, inverseLinearTransform3, } from "../geometry/transform3.js";
+import { applyInverseTranspose3, applyValidatedTransformDirection3, applyValidatedTransformPoint3, inverseLinearTransform3, validateTransform3, } from "../geometry/transforms/affine3.js";
+import { anchor3 } from "../geometry/transforms/anchors.js";
 const maximumAnchors = 128;
 function fail(operation, message) {
     throw new GeometryError("INVALID_ARGUMENT", message, { operation });
@@ -15,7 +15,7 @@ function copyAnchor(anchor, operation) {
     for (const vector of [anchor.position, anchor.direction, anchor.up])
         if (!Array.isArray(vector) || vector.length !== 3 || !vector.every(Number.isFinite))
             fail(operation, "Anchor vectors must contain exactly three finite coordinates.");
-    return anchor3(anchor.position, anchor.direction, anchor.up);
+    return anchor3({ position: anchor.position, direction: anchor.direction, up: anchor.up });
 }
 function unit(vector) {
     const maximum = Math.max(...vector.map(Math.abs));
@@ -27,7 +27,11 @@ function unit(vector) {
 }
 /** Maps positions affinely, outward normals by inverse transpose, and roll tangents linearly. */
 function transformedAnchor(anchor, matrix, inverse) {
-    return anchor3(applyTransformPoint3(matrix, anchor.position), applyInverseTranspose3(inverse, anchor.direction), unit(applyTransformDirection3(matrix, anchor.up)));
+    return anchor3({
+        position: applyValidatedTransformPoint3(matrix, anchor.position),
+        direction: applyInverseTranspose3(inverse, anchor.direction),
+        up: unit(applyValidatedTransformDirection3(matrix, anchor.up)),
+    });
 }
 /** Run-owned immutable anchor metadata. Geometry operations acquire metadata only deliberately. */
 export function createShapeAnchorOwner(assertShape, aliasShape) {
@@ -75,10 +79,13 @@ export function createShapeAnchorOwner(assertShape, aliasShape) {
             if (definitions === undefined)
                 return result;
             const inverse = inverseLinearTransform3(matrix);
-            return remember(result, Object.fromEntries(Object.entries(definitions).map(([name, value]) => [
+            validateTransform3(matrix);
+            // Names and inputs already belong to this owner; transformedAnchor returns frozen values.
+            anchors.set(result, Object.freeze(Object.fromEntries(Object.entries(definitions).map(([name, value]) => [
                 name,
                 transformedAnchor(value, matrix, inverse),
-            ])));
+            ]))));
+            return result;
         },
         dispose() {
             anchors.clear();

package/dist/export/3mf.js

@@ -1,6 +1,6 @@
 import { Zip, ZipDeflate } from "fflate";
 import { GeometryError } from "../geometry/errors.js";
-import { MeshViewCache } from "../geometry/mesh/mesh-view-cache.js";
+import { MeshViewCache } from "../geometry/mesh/view-cache.js";
 import { captureExport } from "./capture.js";
 import { collectExport, createExportWriter } from "./writer.js";
 const coreNamespace = "http://schemas.microsoft.com/3dmanufacturing/core/2015/02";
@@ -130,6 +130,9 @@ function* modelXml(captured) {
  * names, combined with appearance through multiproperties; display colors never select filament.
  * Captures mutable inputs before awaiting and awaits each owned output chunk for backpressure.
  * The host owns destination closing and cleanup of partial output after rejection.
+ *
+ * @param parts - Closed, outward-wound parts in output order.
+ * @param sink - Receives each chunk; return a promise to pause writing.
  */
 export async function write3mf(parts, sink, options = {}) {
     const captured = captureExport(parts, options, "3mf");
@@ -184,7 +187,11 @@ export async function write3mf(parts, sink, options = {}) {
         zip.terminate();
     }
 }
-/** Serializes selected completed meshes as an owned 3MF file without initializing an engine. */
+/**
+ * Serializes selected completed meshes as an owned 3MF file without initializing an engine.
+ *
+ * @param parts - Closed, outward-wound parts in output order, with local geometry in millimetres.
+ */
 export async function export3mf(parts, options = {}) {
     return collectExport((sink) => write3mf(parts, sink, options));
 }

package/dist/export/capture.js

@@ -1,9 +1,9 @@
 import { GeometryError } from "../geometry/errors.js";
 import { immutableBufferView, isImmutableBuffer } from "../geometry/immutable-buffer.js";
-import { analyzeSolidMesh } from "../geometry/mesh/mesh-solid.js";
-import { MeshViewCache } from "../geometry/mesh/mesh-view-cache.js";
-import { analyzeTriangleMesh, transformTriangleMesh, } from "../geometry/mesh/mesh.js";
-import { IDENTITY_TRANSFORM3, validateRigidTransform3 } from "../geometry/transform3.js";
+import { analyzeTriangleMesh, transformTriangleMesh, } from "../geometry/mesh/operations.js";
+import { analyzeSolidMesh } from "../geometry/mesh/solid.js";
+import { MeshViewCache } from "../geometry/mesh/view-cache.js";
+import { IDENTITY_TRANSFORM3, validateRigidTransform3 } from "../geometry/transforms/affine3.js";
 import { resolveExportLimits } from "./limits.js";
 // Array.isArray's any[] predicate must not erase the already typed public contracts below.
 const isArray = Array.isArray;
@@ -65,7 +65,12 @@ export function captureExport(parts, options, format) {
         bytes += source.byteLength;
         if (bytes > limits.maxBytes)
             throw new GeometryError("COMPLEXITY_LIMIT", "Export snapshot exceeds maxBytes.");
-        const captured = immutable ? source : source.slice();
+        // Typed-array methods and species are caller-overridable; constructors guarantee an owned copy.
+        const captured = immutable
+            ? source
+            : (source instanceof Float32Array
+                ? new Float32Array(source)
+                : new Uint32Array(source));
         if (ranges === undefined) {
             ranges = new Map();
             viewKeys.set(source.buffer, ranges);
@@ -172,7 +177,6 @@ export function captureExport(parts, options, format) {
         materials: Object.freeze(materials),
         name,
         limits,
-        meshValidation,
         ...(signal === undefined ? {} : { signal }),
     });
 }

package/dist/export/glb.js

@@ -1,5 +1,5 @@
 import { GeometryError } from "../geometry/errors.js";
-import { renderMesh } from "../geometry/mesh/mesh-render.js";
+import { renderValidatedMesh } from "../geometry/mesh/render-buffers.js";
 import { captureExport } from "./capture.js";
 import { collectExport, createExportWriter } from "./writer.js";
 const alignedLength = (length) => Math.ceil(length / 4) * 4;
@@ -16,6 +16,8 @@ function baseColor(color) {
  * Serializes captured local meshes as uncompressed glTF 2.0 binary, in metres and Y-up.
  * Preserves named parts, placement, shared geometry and display appearance. Authored normals take
  * precedence over crease-aware shading; no engine, renderer or optional compression codec is loaded.
+ *
+ * @param parts - Parts in output order, with local geometry in millimetres and Z-up.
  */
 export function exportGlb(parts, options = {}) {
     return collectExport((sink) => writeGlb(parts, sink, options));
@@ -24,6 +26,9 @@ export function exportGlb(parts, options = {}) {
  * Writes owned GLB chunks with backpressure, cancellation and explicit output limits.
  * Plans accessor and container lengths before writing, then emits bounded binary chunks.
  * Hosts own sink completion, scheduling and recovery after a partially written failure.
+ *
+ * @param parts - Parts in output order; mutable geometry is copied before writing.
+ * @param sink - Receives each chunk; return a promise to pause writing.
  */
 export async function writeGlb(parts, sink, options = {}) {
     const captured = captureExport(parts, options, "glb");
@@ -74,7 +79,7 @@ export async function writeGlb(parts, sink, options = {}) {
         let geometry = geometryAccessors.get(part.geometry);
         if (geometry === undefined) {
             const rendered = part.geometry.normals === undefined
-                ? renderMesh(part.geometry, { creaseAngle })
+                ? renderValidatedMesh(part.geometry, creaseAngle)
                 : { ...part.geometry, normals: part.geometry.normals };
             const min = [Infinity, Infinity, Infinity];
             const max = [-Infinity, -Infinity, -Infinity];

package/dist/export/stl.js

@@ -1,4 +1,5 @@
 import { GeometryError } from "../geometry/errors.js";
+import { IDENTITY_TRANSFORM3 } from "../geometry/transforms/affine3.js";
 import { captureExport } from "./capture.js";
 import { collectExport, createExportWriter } from "./writer.js";
 const TRIANGLES_PER_CHUNK = 1_024;
@@ -6,6 +7,8 @@ const TRIANGLES_PER_CHUNK = 1_024;
  * Serializes a captured model as binary STL in millimetres and Z-up coordinates.
  * Placement is baked into triangles. Diagnostics describe dropped names, appearance and materials.
  * Mutable input is captured before the first await; no engine or renderer is needed.
+ *
+ * @param parts - Parts in output order, with local geometry in millimetres.
  */
 export function exportStl(parts, options = {}) {
     return collectExport((sink) => writeStl(parts, sink, options));
@@ -13,6 +16,9 @@ export function exportStl(parts, options = {}) {
 /**
  * Writes owned binary STL chunks to a sink, awaiting backpressure after each bounded chunk.
  * The host owns sink completion and recovery after failure. Honors cancellation and output limits.
+ *
+ * @param parts - Parts in output order; mutable geometry is copied before writing.
+ * @param sink - Receives each chunk; return a promise to pause writing.
  */
 export async function writeStl(parts, sink, options = {}) {
     const captured = captureExport(parts, options, "stl");
@@ -35,19 +41,28 @@ export async function writeStl(parts, sink, options = {}) {
     for (const part of captured.parts) {
         const { positions, indices } = part.geometry;
         const matrix = part.transform;
+        const identity = matrix.every((value, index) => Object.is(value, IDENTITY_TRANSFORM3[index]));
         for (let offset = 0; offset < indices.length; offset += 3) {
             for (let corner = 0; corner < 3; corner += 1) {
                 const index = indices[offset + corner] * 3;
                 const x = positions[index];
                 const y = positions[index + 1];
                 const z = positions[index + 2];
-                for (let axis = 0; axis < 3; axis += 1) {
-                    const row = axis * 4;
-                    const value = Math.fround(matrix[row] * x + matrix[row + 1] * y + matrix[row + 2] * z + matrix[row + 3]);
-                    if (!Number.isFinite(value))
-                        throw new GeometryError("NON_FINITE_VALUE", "Placed STL positions must fit finite Float32 coordinates.", { operation: "exportStl" });
-                    triangle[corner * 3 + axis] = value;
+                if (identity) {
+                    // Capture already validated these Float32 values. Match the identity dot product's
+                    // positive zero without repeating its arithmetic for every indexed triangle corner.
+                    triangle[corner * 3] = x === 0 ? 0 : x;
+                    triangle[corner * 3 + 1] = y === 0 ? 0 : y;
+                    triangle[corner * 3 + 2] = z === 0 ? 0 : z;
                 }
+                else
+                    for (let axis = 0; axis < 3; axis += 1) {
+                        const row = axis * 4;
+                        const value = Math.fround(matrix[row] * x + matrix[row + 1] * y + matrix[row + 2] * z + matrix[row + 3]);
+                        if (!Number.isFinite(value))
+                            throw new GeometryError("NON_FINITE_VALUE", "Placed STL positions must fit finite Float32 coordinates.", { operation: "exportStl" });
+                        triangle[corner * 3 + axis] = value;
+                    }
             }
             const ux = triangle[3] - triangle[0];
             const uy = triangle[4] - triangle[1];

package/dist/geometry/{bounds.js → bounds/operations.js}

@@ -1,4 +1,4 @@
-import { GeometryError } from "./errors.js";
+import { GeometryError } from "../errors.js";
 function fail(operation, message) {
     throw new GeometryError("INVALID_ARGUMENT", message, { operation });
 }
@@ -81,6 +81,8 @@ export function fitBounds(source, target, options = {}) {
  *
  * Each minimum Y/Z becomes zero, and the first minimum X becomes zero. Supply bounds after
  * any intended part rotation; translations apply to those bounds. An empty input returns [].
+ *
+ * @param bounds - XYZ bounds in row order, after any part rotation.
  */
 export function layoutRow(bounds, options = {}) {
     const operation = "layoutRow";

package/dist/geometry/{bounds-value.js → bounds/value.js}

@@ -1,7 +1,7 @@
-import { boundsCenter, boundsSize, containsBounds, validateBounds } from "./bounds.js";
-import { GeometryError, isGeometryError } from "./errors.js";
-import { immutableMathClass } from "./math/immutable-value.js";
-import { vector2, vector2Data, vector3, vector3Data, } from "./math/vector-value.js";
+import { GeometryError, isGeometryError } from "../errors.js";
+import { immutableMathClass } from "../math/immutable-value.js";
+import { vector2, vector2Data, vector3, vector3Data, } from "../math/vector-value.js";
+import { boundsCenter, boundsSize, containsBounds, validateBounds } from "./operations.js";
 function fail(dimension, message) {
     throw new GeometryError("INVALID_ARGUMENT", message, { operation: `bounds${dimension}` });
 }
@@ -64,19 +64,19 @@ const PlanarBounds = /* @__PURE__ */ immutableMathClass(class PlanarBounds {
     min;
     max;
     constructor(data) {
-        this.#data = data;
-        this.min = data.min;
-        this.max = data.max;
+        this.min = vector2(data.min);
+        this.max = vector2(data.max);
+        this.#data = Object.freeze({ min: this.min.toData(), max: this.max.toData() });
         Object.freeze(this);
     }
     size() {
-        return vector2(boundsSize(this));
+        return vector2(boundsSize(this.#data));
     }
     center() {
-        return vector2(boundsCenter(this));
+        return vector2(boundsCenter(this.#data));
     }
     containsBounds(other) {
-        return containsBounds(this, other);
+        return containsBounds(this.#data, snapshot(other, 2));
     }
     toData() {
         return this.#data;
@@ -87,19 +87,19 @@ const SpatialBounds = /* @__PURE__ */ immutableMathClass(class SpatialBounds {
     min;
     max;
     constructor(data) {
-        this.#data = data;
-        this.min = data.min;
-        this.max = data.max;
+        this.min = vector3(data.min);
+        this.max = vector3(data.max);
+        this.#data = Object.freeze({ min: this.min.toData(), max: this.max.toData() });
         Object.freeze(this);
     }
     size() {
-        return vector3(boundsSize(this));
+        return vector3(boundsSize(this.#data));
     }
     center() {
-        return vector3(boundsCenter(this));
+        return vector3(boundsCenter(this.#data));
     }
     containsBounds(other) {
-        return containsBounds(this, other);
+        return containsBounds(this.#data, snapshot(other, 3));
     }
     toData() {
         return this.#data;
@@ -113,6 +113,8 @@ const SpatialBounds = /* @__PURE__ */ immutableMathClass(class SpatialBounds {
  * 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 memo data require
  * the current Modeling runtime.
+ *
+ * @param input - Ordered extrema, nonnegative size, or an existing XY bounds value to snapshot.
  */
 export function bounds2(input) {
     return new PlanarBounds(snapshot(input, 2));
@@ -125,6 +127,8 @@ export function bounds2(input) {
  * 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 memo data require
  * the current Modeling runtime.
+ *
+ * @param input - Ordered extrema, nonnegative size, or an existing XYZ bounds value to snapshot.
  */
 export function bounds3(input) {
     return new SpatialBounds(snapshot(input, 3));

package/dist/geometry/curves/evaluation.js

@@ -1,6 +1,6 @@
 import { GeometryError } from "../errors.js";
 // This parameter-space probe only resolves stationary tangent direction; it does not control
-// geometric sampling tolerance or move output points. Retain its established one-sided behavior.
+// geometric sampling tolerance or move output points.
 const STATIONARY_TANGENT_PROBE = 0.000001;
 /** @internal Shared structured failures for evaluation and sampling. */
 export function curveFailure(code, message) {
@@ -34,7 +34,7 @@ export function curveDistance(a, b) {
         curveFailure("NON_FINITE_VALUE", "Curve extent exceeds finite arithmetic.");
     return result;
 }
-/** @internal Weighted interpolation preserves finite large coordinates and the existing operation order. */
+/** @internal Weighted interpolation avoids overflow between finite large coordinates. */
 export function interpolateCurvePoint(a, b, t, result) {
     result[0] = a[0] * (1 - t) + b[0] * t;
     result[1] = a[1] * (1 - t) + b[1] * t;
@@ -59,7 +59,7 @@ export function curveDirection(a, b, result) {
     result[2] = b[2] - a[2];
     normalizeCurveDirection(result, result);
 }
-/** @internal Bounding distance to the finite chord, using the existing arithmetic order. */
+/** @internal Bounds deviation from the finite chord rather than its infinite supporting line. */
 export function distanceToCurveChord(point, start, end) {
     const extent = curveDistance(start, end);
     if (extent === 0)
@@ -120,8 +120,7 @@ export class CubicEvaluator {
         interpolateCurvePoint(this.#d, this.#e, t, result);
     }
     tangent(t, point, result) {
-        // Profile correspondence needs points only. Tangent-bearing curves calculate these once,
-        // retaining the established derivative arithmetic without allocating unused controls.
+        // Profile correspondence needs points only; calculate derivative controls only for tangents.
         const control = this.#control;
         const derivative = (this.#derivative ??= [
             [control[1][0] - control[0][0], control[1][1] - control[0][1], control[1][2] - control[0][2]],
@@ -136,7 +135,7 @@ export class CubicEvaluator {
             return;
         }
         // At stationary endpoints or cusps, use an outgoing one-sided secant when available.
-        // A fixed small parameter probe retains the previous fallback without an output-spacing dependency.
+        // A fixed parameter probe keeps the fallback independent of output spacing.
         if (t < 1) {
             this.point(Math.min(1, t + STATIONARY_TANGENT_PROBE), this.#probe);
             if (curveDistance(point, this.#probe) > 0) {

package/dist/geometry/curves/sampling.js

@@ -1,5 +1,5 @@
-import { resolveArcSegments, resolveGeometryResolution, } from "../resolution.js";
-import { assertSamplingCount, resolveGeometrySamplingLimits } from "../sampling-limits.js";
+import { assertSamplingCount, resolveGeometrySamplingLimits } from "../sampling/limits.js";
+import { resolveArcSegments, resolveGeometryResolution, } from "../sampling/resolution.js";
 import { CubicEvaluator, curveDirection, curveDistance, curveFailure, distanceToCurveChord, interpolateCurvePoint, liftPointTo3D, normalizeCurveDirection, planarCubicControl, splitCubicControl, validateCurvePoint3, } from "./evaluation.js";
 /** @internal Final planar results never create a discarded immutable 3D snapshot. */
 export function createPlanarSampleWriter() {
@@ -125,8 +125,8 @@ function sampleArc(curve, options, maximum, createWriter) {
     }
     return writer.finish();
 }
-/** @internal The control hull bounds curve deviation and each sampled edge's physical length. */
-export function cubicControlMeetsPolicy(control, policy) {
+// The control hull bounds curve deviation and each sampled edge's physical length.
+function cubicControlMeetsPolicy(control, policy) {
     const length = curveDistance(control[0], control[1]) +
         curveDistance(control[1], control[2]) +
         curveDistance(control[2], control[3]);
@@ -134,7 +134,8 @@ export function cubicControlMeetsPolicy(control, policy) {
     return (flat <= policy.maxChordError &&
         (policy.maxSegmentLength === undefined || length <= policy.maxSegmentLength));
 }
-/** @internal Profiles use a checked uniform parameter grid instead of an adaptive leaf count.
+/**
+ * @internal Profiles use a checked uniform parameter grid instead of an adaptive leaf count.
  * Every control interval must meet the physical policy, including flatter regions subdivided to
  * match curved ones. The depth-first traversal retains only one bounded stack, without output points.
  */
@@ -192,6 +193,20 @@ function resolveCubicParameters(control, options, maximum) {
     }
     return parameters;
 }
+/** @internal Point-only cubic sampling reuses physical subdivision without discarded tangent calculations. */
+export function sampleCubicControlPoints(control, options, append) {
+    for (const point of control)
+        validateCurvePoint3(point);
+    const parameters = resolveCubicParameters(control, options, resolveSamplingBudget(options));
+    const evaluator = new CubicEvaluator(control);
+    const point = [0, 0, 0];
+    // The caller already retains this span's first waypoint.
+    for (let index = 1; index < parameters.length; index++) {
+        const t = parameters[index];
+        evaluator.point(t, point);
+        append(point, t === 1);
+    }
+}
 function sampleCubicBezier(curve, options, maximum, createWriter) {
     const control = [
         validateCurvePoint3(curve.start),
@@ -226,6 +241,10 @@ function sampleCurve(curve, options, createWriter) {
 }
 /**
  * Samples a spatial curve, preserving endpoints and directed unit tangents.
+ *
+ * @param curve - XYZ curve in millimetres; arc angles use degrees.
+ * @param options - Physical sampling or an exact interval count, within vertex limits.
+ *
  * @remarks Exact counts use uniform curve parameters, not equal physical distances. Adaptive cubics
  * bound the full control hull. Full-circle arcs repeat their endpoint; closed polylines do not.
  * @example
@@ -236,7 +255,12 @@ function sampleCurve(curve, options, createWriter) {
 export function sampleCurve3(curve, options = {}) {
     return sampleCurve(curve, options, createSpatialSampleWriter);
 }
-/** Samples a planar curve with the same guarantees and policy as spatial sampling.
+/**
+ * Samples a planar curve with the same guarantees and policy as spatial sampling.
+ *
+ * @param curve - XY curve in millimetres; arc angles use degrees.
+ * @param options - Physical sampling or an exact interval count, within vertex limits.
+ *
  * @remarks Returned planar points and tangents are copied and frozen. At stationary tangents, outgoing secants are preferred and endpoints use a backward fallback.
  * @example
  * ```ts

package/dist/geometry/{extrusion.js → extrusion/controls.js}

@@ -1,12 +1,27 @@
-import { GeometryError } from "./errors.js";
-import { vector2Data } from "./math/vector-value.js";
-import { assertPositivePrimitive, assertPrimitiveOptions } from "./primitive-resolvers.js";
-import { resolveGeometryResolution } from "./resolution.js";
-import { assertSamplingCount, resolveGeometrySamplingLimits } from "./sampling-limits.js";
+import { GeometryError } from "../errors.js";
+import { vector2Data } from "../math/vector-value.js";
+import { assertPositivePrimitive, assertPrimitiveOptions } from "../primitives/resolvers.js";
+import { assertSamplingCount, resolveGeometrySamplingLimits } from "../sampling/limits.js";
+import { resolveGeometryResolution } from "../sampling/resolution.js";
 const isArray = (value) => Array.isArray(value);
+const extrusionKeys = new Set([
+    "height",
+    "center",
+    "ends",
+    "slices",
+    "limits",
+    "resolution",
+    "scale",
+    "twist",
+]);
 /** @internal Validates shared extrusion controls and expands top scale before kernel allocation. */
 export function resolveExtrusionControls(height, options, operation) {
     assertPrimitiveOptions(options, operation);
+    for (const key of Object.keys(options))
+        if (!extrusionKeys.has(key))
+            throw new GeometryError("INVALID_ARGUMENT", `Unsupported extrusion option: ${key}.`, {
+                operation,
+            });
     assertPositivePrimitive(height, "height", operation);
     if (options.center !== undefined && typeof options.center !== "boolean") {
         throw new GeometryError("INVALID_ARGUMENT", "center must be boolean when supplied.", {
@@ -17,40 +32,46 @@ export function resolveExtrusionControls(height, options, operation) {
     if (!Number.isFinite(twist)) {
         throw new GeometryError("NON_FINITE_VALUE", "twist must be finite.", { operation });
     }
-    const scaleTop = options.scaleTop ?? 1;
-    const values = typeof scaleTop === "number" ? [scaleTop, scaleTop] : vector2Data(scaleTop);
+    const scale = options.scale ?? 1;
+    const values = typeof scale === "number" ? [scale, scale] : vector2Data(scale);
     const scales = [values[0], values[1]];
     if (!Number.isFinite(scales[0]) || !Number.isFinite(scales[1])) {
-        throw new GeometryError("NON_FINITE_VALUE", "scaleTop values must be finite.", { operation });
+        throw new GeometryError("NON_FINITE_VALUE", "scale values must be finite.", { operation });
     }
-    if (options.divisions !== undefined &&
-        (!Number.isSafeInteger(options.divisions) || options.divisions < 0)) {
-        throw new GeometryError("INVALID_ARGUMENT", "divisions must be a nonnegative safe integer.", {
+    if (scales.some((value) => value < 0) || (scales[0] === 0) !== (scales[1] === 0))
+        throw new GeometryError("INVALID_ARGUMENT", "scale must be positive on both axes or zero on both axes for an apex.", { operation });
+    if (options.slices !== undefined &&
+        (!Number.isSafeInteger(options.slices) || options.slices < 1)) {
+        throw new GeometryError("INVALID_ARGUMENT", "slices must be a positive safe integer.", {
             operation,
         });
     }
-    if (options.divisions !== undefined)
-        assertSamplingCount(options.divisions + 2, operation, resolveGeometrySamplingLimits(options.limits).maxPathPoints);
+    if (options.slices !== undefined)
+        assertSamplingCount(options.slices + 1, operation, resolveGeometrySamplingLimits(options.limits).maxPathPoints);
     return { scales, twist, center: options.center ?? false };
 }
 /**
- * Resolves intermediate profile copies for linear extrusion from physical curve resolution.
+ * Resolves longitudinal intervals for ordinary linear extrusion from physical curve resolution.
  *
  * Accepts one XY loop or a filled XY region, including every hole and disconnected component.
- * Exact `divisions`, including zero, override physical sampling. Otherwise chord error bounds
+ * End treatments are unsupported; native finishing inserts its own treatment stations.
+ * Explicit positive `slices` override physical sampling. Otherwise chord error bounds
  * the triangulated side surface, including rotation across each profile edge. Optional segment
- * length bounds station travel including Z. Straight extrusions need no intermediate copies by default.
+ * length bounds station travel including Z. Straight extrusions use one interval by default.
  * Exceeding the selected maxPathPoints ceiling raises `COMPLEXITY_LIMIT` instead of reducing fidelity.
  *
  * @param profile - Ordered XY millimetre contours with implicit closing edges.
  * @param height - Positive extrusion height in millimetres.
- * @param options - Twist, scale, exact divisions, and physical resolution controls.
- * @returns Number of intermediate copies, excluding the two end profiles.
+ * @param options - Twist, scale, exact slices, and physical resolution controls.
+ * @returns Positive interval count, creating one more profile layer than intervals.
  */
-export function resolveExtrusionDivisions(profile, height, options = {}) {
+export function resolveExtrusionSlices(profile, height, options = {}) {
+    assertPrimitiveOptions(options, "resolveExtrusionSlices");
+    if ("ends" in options)
+        throw new GeometryError("INVALID_ARGUMENT", "resolveExtrusionSlices does not support end treatments.", { operation: "resolveExtrusionSlices" });
     if (!isArray(profile) || profile.length === 0)
         throw new GeometryError("INVALID_ARGUMENT", "Extrusion sampling needs an XY loop or region.", {
-            operation: "resolveExtrusionDivisions",
+            operation: "resolveExtrusionSlices",
         });
     const contours = [];
     if (Array.isArray(profile[0]))
@@ -64,25 +85,25 @@ export function resolveExtrusionDivisions(profile, height, options = {}) {
                 !isArray(component.outer) ||
                 !isArray(component.holes))
                 throw new GeometryError("INVALID_ARGUMENT", "Extrusion regions need outer and hole contours.", {
-                    operation: "resolveExtrusionDivisions",
+                    operation: "resolveExtrusionSlices",
                 });
-            assertSamplingCount(count + 3 * (component.holes.length + 1), "resolveExtrusionDivisions", maximum);
+            assertSamplingCount(count + 3 * (component.holes.length + 1), "resolveExtrusionSlices", maximum);
             for (const contour of [component.outer, ...component.holes]) {
                 if (!isArray(contour) || contour.length < 3)
                     throw new GeometryError("INVALID_ARGUMENT", "Extrusion contours need at least three XY points.", {
-                        operation: "resolveExtrusionDivisions",
+                        operation: "resolveExtrusionSlices",
                     });
                 count += contour.length;
-                assertSamplingCount(count, "resolveExtrusionDivisions", maximum);
+                assertSamplingCount(count, "resolveExtrusionSlices", maximum);
                 contours.push(contour);
             }
         }
     }
-    return resolveExtrusionContourDivisions(contours, height, options);
+    return resolveExtrusionContourSlices(contours, height, options);
 }
 /** @internal Shared sampling preflight over explicit contours, without rebuilding filled topology. */
-export function resolveExtrusionContourDivisions(contours, height, options) {
-    const operation = "resolveExtrusionDivisions";
+export function resolveExtrusionContourSlices(contours, height, options) {
+    const operation = "resolveExtrusionSlices";
     const { scales, twist } = resolveExtrusionControls(height, options, operation);
     const limits = resolveGeometrySamplingLimits(options.limits);
     let radius = 0, maximumEdgeLength = 0, profileCount = 0;
@@ -109,8 +130,8 @@ export function resolveExtrusionContourDivisions(contours, height, options) {
             maximumEdgeLength = Math.max(maximumEdgeLength, Math.hypot(next[0] - point[0], next[1] - point[1]));
         }
     }
-    if (options.divisions !== undefined)
-        return options.divisions;
+    if (options.slices !== undefined)
+        return options.slices;
     const policy = resolveGeometryResolution(options.resolution, options.limits);
     const angle = (Math.abs(twist) * Math.PI) / 180;
     const maximumScale = Math.max(1, Math.abs(scales[0]), Math.abs(scales[1]));
@@ -122,11 +143,13 @@ export function resolveExtrusionContourDivisions(contours, height, options) {
     // Uniform untwisted taper is planar. Anisotropic taper can introduce a
     // mixed edge/station derivative even when the vertex trajectories are straight.
     b = (maximumEdgeLength * (maximumScale * angle + Math.abs(scales[0] - scales[1]))) / 4;
-    const chordSegments = policy.circularSegments === undefined
-        ? Math.max(1, Math.ceil((b + Math.hypot(b, 2 * Math.sqrt(a * policy.maxChordError))) /
-            (2 * policy.maxChordError)), Math.ceil((policy.minSegments * Math.abs(twist)) / 360))
-        : Math.max(1, Math.ceil((policy.circularSegments * Math.abs(twist)) / 360));
-    const angularCap = Math.max(1, scales[0] === scales[1] ? 0 : policy.maxSegments, Math.ceil((policy.maxSegments * Math.abs(twist)) / 360));
+    const physicalSlices = Math.max(1, Math.ceil((b + Math.hypot(b, 2 * Math.sqrt(a * policy.maxChordError))) / (2 * policy.maxChordError)));
+    const angularSlices = Math.max(1, Math.ceil(((policy.circularSegments ?? policy.minSegments) * Math.abs(twist)) / 360));
+    // An exact angular schedule does not waive the surface error caused by changing scale.
+    const chordSegments = policy.circularSegments === undefined || scaleChange > 0
+        ? Math.max(physicalSlices, angularSlices)
+        : angularSlices;
+    const angularCap = Math.max(1, scaleChange === 0 ? 0 : policy.maxSegments, Math.ceil((policy.maxSegments * Math.abs(twist)) / 360));
     if (chordSegments > angularCap) {
         throw new GeometryError("COMPLEXITY_LIMIT", "Extrusion surface refinement exceeds the full-circle interval safety limit.", {
             operation,
@@ -143,5 +166,5 @@ export function resolveExtrusionContourDivisions(contours, height, options) {
     const lengthSegments = policy.maxSegmentLength === undefined ? 1 : Math.ceil(travel / policy.maxSegmentLength);
     const segments = Math.max(1, chordSegments, lengthSegments);
     assertSamplingCount(segments + 1, operation, resolveGeometrySamplingLimits(options.limits).maxPathPoints);
-    return segments - 1;
+    return segments;
 }