@metamesh/modeling 0.0.0-bootstrap.0 → 0.6.0

package/dist/geometry/tolerance.js

@@ -0,0 +1,53 @@
+import { GeometryError } from "./errors.js";
+/** Default absolute, relative, and angular tolerances for millimetre-scale models. */
+export const DEFAULT_GEOMETRY_TOLERANCE = Object.freeze({
+    /** Default absolute distance floor in model units. */
+    absolute: 1e-9,
+    /** Default angular comparison threshold in radians. */
+    angular: 1e-10,
+    /** Default dimensionless model-scale multiplier. */
+    relative: 1e-12,
+});
+const positiveFinite = (value, label) => {
+    if (!Number.isFinite(value) || !(value > 0)) {
+        throw new GeometryError("INVALID_TOLERANCE", `${label} must be finite and greater than zero.`);
+    }
+    return value;
+};
+/**
+ * Resolves comparison tolerances for a characteristic model scale.
+ *
+ * The effective linear tolerance is `max(absolute, relative * abs(scale))`.
+ * Supplying a scale of zero therefore retains the absolute floor. The function
+ * returns a new frozen value with finite distance and area thresholds and never mutates `options`.
+ *
+ * @param scale - Finite characteristic size in model units.
+ * @param options - Optional policy overrides.
+ * @returns A complete tolerance policy including the scale-resolved distance.
+ * @throws {@link GeometryError} When a scale or override is invalid.
+ */
+export function resolveGeometryTolerance(scale = 1, options = {}) {
+    if (!Number.isFinite(scale)) {
+        throw new GeometryError("INVALID_TOLERANCE", "Geometry tolerance scale must be finite.");
+    }
+    const absolute = positiveFinite(options.absolute ?? DEFAULT_GEOMETRY_TOLERANCE.absolute, "Absolute geometry tolerance");
+    const angular = positiveFinite(options.angular ?? DEFAULT_GEOMETRY_TOLERANCE.angular, "Angular geometry tolerance");
+    const relative = options.relative ?? DEFAULT_GEOMETRY_TOLERANCE.relative;
+    if (!Number.isFinite(relative) || relative < 0) {
+        throw new GeometryError("INVALID_TOLERANCE", "Relative geometry tolerance must be finite and non-negative.");
+    }
+    const linear = Math.max(absolute, relative * Math.abs(scale));
+    const area = linear * linear;
+    if (!Number.isFinite(linear) || !Number.isFinite(area)) {
+        throw new GeometryError("INVALID_TOLERANCE", "Resolved geometry tolerances must be finite.", {
+            operation: "resolveGeometryTolerance",
+        });
+    }
+    return Object.freeze({
+        absolute,
+        angular,
+        area,
+        linear,
+        relative,
+    });
+}

package/dist/geometry/transform-geometry.js

@@ -0,0 +1,41 @@
+import { GeometryError } from "./errors.js";
+import { normalizeLoop2, normalizeRegion2, signedAreaLoop2 } from "./regions.js";
+import { resolveGeometryTolerance } from "./tolerance.js";
+import { applyTransformPoint3, validateTransform3 } from "./transform3.js";
+/** Applies an affine transform to a 3D path without mutating its points. */
+export function transformPath3(path, transform) {
+    validateTransform3(transform);
+    return Object.freeze(path.map((point) => Object.freeze(applyTransformPoint3(transform, point))));
+}
+const transformPoint2 = (point, transform, tolerance) => {
+    const transformed = applyTransformPoint3(transform, [point[0], point[1], 0]);
+    const resolved = resolveGeometryTolerance(Math.max(1, Math.abs(transformed[0]), Math.abs(transformed[1])), tolerance);
+    if (Math.abs(transformed[2]) > resolved.linear) {
+        throw new GeometryError("INVALID_ARGUMENT", "A 2D transform must preserve the XY plane.", {
+            operation: "transformPath2",
+        });
+    }
+    return Object.freeze([transformed[0], transformed[1]]);
+};
+/** Applies an XY-plane-preserving affine transform to a 2D path. */
+export function transformPath2(path, transform, tolerance = {}) {
+    validateTransform3(transform, tolerance);
+    return Object.freeze(path.map((point) => transformPoint2(point, transform, tolerance)));
+}
+/**
+ * Transforms a closed loop and preserves its original winding convention.
+ *
+ * Reflections reverse the point order automatically through normalization.
+ */
+export function transformLoop2(loop, transform, tolerance = {}) {
+    const counterClockwise = signedAreaLoop2(loop) > 0;
+    const normalized = normalizeLoop2(loop, counterClockwise, tolerance);
+    return normalizeLoop2(transformPath2(normalized, transform, tolerance), counterClockwise, tolerance);
+}
+/** Transforms an explicit outer/hole region with reflection-safe winding correction. */
+export function transformRegion2(region, transform, tolerance = {}) {
+    return normalizeRegion2(region.map((polygon) => ({
+        holes: polygon.holes.map((hole) => transformLoop2(hole, transform, tolerance)),
+        outer: transformLoop2(polygon.outer, transform, tolerance),
+    })), tolerance);
+}

package/dist/geometry/transform3.js

@@ -0,0 +1,340 @@
+import { GeometryError } from "./errors.js";
+import { resolveGeometryTolerance } from "./tolerance.js";
+const finiteVector = (vector, label) => {
+    if (!vector.every(Number.isFinite)) {
+        throw new GeometryError("NON_FINITE_VALUE", `${label} coordinates must be finite.`);
+    }
+};
+const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+const cross = (a, b) => [
+    a[1] * b[2] - a[2] * b[1],
+    a[2] * b[0] - a[0] * b[2],
+    a[0] * b[1] - a[1] * b[0],
+];
+const length = (vector) => Math.hypot(vector[0], vector[1], vector[2]);
+const normalized = (vector, label, tolerance) => {
+    finiteVector(vector, label);
+    const magnitude = length(vector);
+    if (magnitude <= tolerance) {
+        throw new GeometryError("DEGENERATE_GEOMETRY", `${label} must have non-zero length.`);
+    }
+    return [vector[0] / magnitude, vector[1] / magnitude, vector[2] / magnitude];
+};
+const frozenTransform = (values) => Object.freeze([...values]);
+/** Identity transform, safe to share because it is frozen. */
+export const IDENTITY_TRANSFORM3 = frozenTransform([
+    1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1,
+]);
+/**
+ * Validates that a transform is finite, affine, and non-singular.
+ *
+ * @param transform - Row-major matrix to validate.
+ * @param tolerance - Optional comparison overrides.
+ * @returns The original transform after successful validation.
+ * @throws {@link GeometryError} For non-finite, non-affine, or singular matrices.
+ */
+export function validateTransform3(transform, tolerance = {}) {
+    if (transform.length !== 16 || !transform.every(Number.isFinite)) {
+        throw new GeometryError("NON_FINITE_VALUE", "Transforms require sixteen finite values.");
+    }
+    const scale = Math.max(Math.abs(transform[0]), Math.abs(transform[1]), Math.abs(transform[2]), Math.abs(transform[4]), Math.abs(transform[5]), Math.abs(transform[6]), Math.abs(transform[8]), Math.abs(transform[9]), Math.abs(transform[10]));
+    const resolved = resolveGeometryTolerance(scale, tolerance);
+    if (Math.abs(transform[12]) > resolved.angular ||
+        Math.abs(transform[13]) > resolved.angular ||
+        Math.abs(transform[14]) > resolved.angular ||
+        Math.abs(transform[15] - 1) > resolved.angular) {
+        throw new GeometryError("INVALID_ARGUMENT", "Transform final row must be [0, 0, 0, 1].");
+    }
+    const determinant = transform[0] * (transform[5] * transform[10] - transform[6] * transform[9]) -
+        transform[1] * (transform[4] * transform[10] - transform[6] * transform[8]) +
+        transform[2] * (transform[4] * transform[9] - transform[5] * transform[8]);
+    const determinantScale = Math.hypot(transform[0], transform[1], transform[2]) *
+        Math.hypot(transform[4], transform[5], transform[6]) *
+        Math.hypot(transform[8], transform[9], transform[10]);
+    if (!Number.isFinite(determinant) || !Number.isFinite(determinantScale)) {
+        throw new GeometryError("NON_FINITE_VALUE", "Transform magnitude exceeds stable floating-point evaluation.");
+    }
+    if (Math.abs(determinant) <= determinantScale * resolved.angular) {
+        throw new GeometryError("SINGULAR_TRANSFORM", "Transform linear component is singular.");
+    }
+    return transform;
+}
+/**
+ * Creates an immutable translation transform.
+ *
+ * @param offset - Finite XYZ translation in model units.
+ * @returns A frozen row-major transform.
+ */
+export function translationTransform3(offset) {
+    finiteVector(offset, "Translation");
+    return frozenTransform([1, 0, 0, offset[0], 0, 1, 0, offset[1], 0, 0, 1, offset[2], 0, 0, 0, 1]);
+}
+/**
+ * Creates an immutable axis-aligned scale transform.
+ *
+ * Negative components are reflections. Zero components are rejected because
+ * they collapse volume and cannot be inverted.
+ *
+ * @param factors - Finite, non-zero XYZ scale factors.
+ * @returns A frozen row-major transform.
+ */
+export function scaleTransform3(factors) {
+    finiteVector(factors, "Scale");
+    if (factors.some((factor) => factor === 0)) {
+        throw new GeometryError("SINGULAR_TRANSFORM", "Scale factors must be non-zero.");
+    }
+    return frozenTransform([
+        factors[0],
+        0,
+        0,
+        0,
+        0,
+        factors[1],
+        0,
+        0,
+        0,
+        0,
+        factors[2],
+        0,
+        0,
+        0,
+        0,
+        1,
+    ]);
+}
+/**
+ * Creates a right-handed axis-angle rotation transform.
+ *
+ * @param axis - Rotation axis; normalization is performed internally.
+ * @param angle - Finite right-handed angle with exactly one explicit unit.
+ * @param tolerance - Optional zero-length comparison overrides.
+ * @returns A frozen row-major transform.
+ */
+export function rotationTransform3(axis, angle, tolerance = {}) {
+    if (typeof angle !== "object" || angle === null || "degrees" in angle === "radians" in angle) {
+        throw new GeometryError("INVALID_ARGUMENT", "Rotation requires exactly one of degrees or radians.", {
+            operation: "rotationTransform3",
+        });
+    }
+    const radians = "degrees" in angle ? (angle.degrees / 180) * Math.PI : angle.radians;
+    if (!Number.isFinite(radians)) {
+        throw new GeometryError("NON_FINITE_VALUE", "Rotation angle must be finite.");
+    }
+    const resolved = resolveGeometryTolerance(length(axis), tolerance);
+    const [x, y, z] = normalized(axis, "Rotation axis", resolved.linear);
+    const cosine = Math.cos(radians);
+    const sine = Math.sin(radians);
+    const inverse = 1 - cosine;
+    return frozenTransform([
+        cosine + x * x * inverse,
+        x * y * inverse - z * sine,
+        x * z * inverse + y * sine,
+        0,
+        y * x * inverse + z * sine,
+        cosine + y * y * inverse,
+        y * z * inverse - x * sine,
+        0,
+        z * x * inverse - y * sine,
+        z * y * inverse + x * sine,
+        cosine + z * z * inverse,
+        0,
+        0,
+        0,
+        0,
+        1,
+    ]);
+}
+/**
+ * Creates an immutable right-handed XYZ Euler rotation transform.
+ *
+ * Rotations are applied about global X first, then Y, then Z. This matches the
+ * degree-based Euler convention used by the Manifold adapters.
+ *
+ * @param rotationDegrees - Finite `[x, y, z]` rotation angles in degrees.
+ * @returns A frozen row-major transform.
+ * @throws {@link GeometryError} When an angle is non-finite.
+ */
+export function eulerTransform3(rotationDegrees) {
+    finiteVector(rotationDegrees, "Euler rotation");
+    const x = (rotationDegrees[0] * Math.PI) / 180;
+    const y = (rotationDegrees[1] * Math.PI) / 180;
+    const z = (rotationDegrees[2] * Math.PI) / 180;
+    return composeTransform3(rotationTransform3([0, 0, 1], { radians: z }), composeTransform3(rotationTransform3([0, 1, 0], { radians: y }), rotationTransform3([1, 0, 0], { radians: x })));
+}
+/**
+ * Composes two affine transforms without mutating either matrix.
+ *
+ * `composeTransform3(after, before)` applies `before` first and `after` second.
+ *
+ * @param after - Transform applied second.
+ * @param before - Transform applied first.
+ * @returns A new frozen transform equal to `after * before`.
+ */
+export function composeTransform3(after, before) {
+    validateTransform3(after);
+    validateTransform3(before);
+    const values = new Array(16).fill(0);
+    for (let row = 0; row < 4; row += 1) {
+        for (let column = 0; column < 4; column += 1) {
+            let value = 0;
+            for (let inner = 0; inner < 4; inner += 1) {
+                value += after[row * 4 + inner] * before[inner * 4 + column];
+            }
+            values[row * 4 + column] = value;
+        }
+    }
+    const composed = frozenTransform(values);
+    validateTransform3(composed);
+    return composed;
+}
+/**
+ * Applies an affine transform to a point, including translation.
+ *
+ * @param transform - Valid row-major affine transform.
+ * @param point - Finite XYZ point.
+ * @returns A fresh transformed point.
+ */
+export function applyTransformPoint3(transform, point) {
+    validateTransform3(transform);
+    finiteVector(point, "Point");
+    return [
+        transform[0] * point[0] + transform[1] * point[1] + transform[2] * point[2] + transform[3],
+        transform[4] * point[0] + transform[5] * point[1] + transform[6] * point[2] + transform[7],
+        transform[8] * point[0] + transform[9] * point[1] + transform[10] * point[2] + transform[11],
+    ];
+}
+/**
+ * Applies only the linear component of an affine transform to a direction.
+ *
+ * The result is not normalized, preserving scale information.
+ *
+ * @param transform - Valid row-major affine transform.
+ * @param direction - Finite XYZ direction.
+ * @returns A fresh transformed direction.
+ */
+export function applyTransformDirection3(transform, direction) {
+    validateTransform3(transform);
+    finiteVector(direction, "Direction");
+    return [
+        transform[0] * direction[0] + transform[1] * direction[1] + transform[2] * direction[2],
+        transform[4] * direction[0] + transform[5] * direction[1] + transform[6] * direction[2],
+        transform[8] * direction[0] + transform[9] * direction[1] + transform[10] * direction[2],
+    ];
+}
+/**
+ * Returns the determinant of a transform's linear 3x3 component.
+ *
+ * A negative result identifies a reflection; zero is rejected as singular.
+ *
+ * @param transform - Valid affine transform.
+ * @returns Signed linear determinant.
+ */
+export function transformDeterminant3(transform) {
+    validateTransform3(transform);
+    return (transform[0] * (transform[5] * transform[10] - transform[6] * transform[9]) -
+        transform[1] * (transform[4] * transform[10] - transform[6] * transform[8]) +
+        transform[2] * (transform[4] * transform[9] - transform[5] * transform[8]));
+}
+/**
+ * Inverts a finite, non-singular affine transform.
+ *
+ * @param transform - Transform to invert.
+ * @returns A new frozen transform whose composition with the input is identity.
+ */
+export function inverseTransform3(transform) {
+    validateTransform3(transform);
+    const a = transform[0];
+    const b = transform[1];
+    const c = transform[2];
+    const d = transform[4];
+    const e = transform[5];
+    const f = transform[6];
+    const g = transform[8];
+    const h = transform[9];
+    const i = transform[10];
+    const determinant = transformDeterminant3(transform);
+    const inverseLinear = [
+        (e * i - f * h) / determinant,
+        (c * h - b * i) / determinant,
+        (b * f - c * e) / determinant,
+        (f * g - d * i) / determinant,
+        (a * i - c * g) / determinant,
+        (c * d - a * f) / determinant,
+        (d * h - e * g) / determinant,
+        (b * g - a * h) / determinant,
+        (a * e - b * d) / determinant,
+    ];
+    const translation = [transform[3], transform[7], transform[11]];
+    const inverseTranslation = [
+        -dot([inverseLinear[0], inverseLinear[1], inverseLinear[2]], translation),
+        -dot([inverseLinear[3], inverseLinear[4], inverseLinear[5]], translation),
+        -dot([inverseLinear[6], inverseLinear[7], inverseLinear[8]], translation),
+    ];
+    const inverse = frozenTransform([
+        inverseLinear[0],
+        inverseLinear[1],
+        inverseLinear[2],
+        inverseTranslation[0],
+        inverseLinear[3],
+        inverseLinear[4],
+        inverseLinear[5],
+        inverseTranslation[1],
+        inverseLinear[6],
+        inverseLinear[7],
+        inverseLinear[8],
+        inverseTranslation[2],
+        0,
+        0,
+        0,
+        1,
+    ]);
+    validateTransform3(inverse);
+    return inverse;
+}
+/**
+ * Converts a right-handed orthonormal frame into a local-to-world transform.
+ *
+ * @param frame - Frame whose axes become the transform columns.
+ * @param tolerance - Optional orthonormality comparison overrides.
+ * @returns A frozen rigid transform.
+ * @throws {@link GeometryError} When axes are non-unit, non-orthogonal, or left-handed.
+ */
+export function frameTransform3(frame, tolerance = {}) {
+    finiteVector(frame.origin, "Frame origin");
+    const resolved = resolveGeometryTolerance(1, tolerance);
+    const xLength = length(frame.xAxis);
+    const yLength = length(frame.yAxis);
+    const zLength = length(frame.zAxis);
+    if (Math.abs(xLength - 1) > resolved.angular ||
+        Math.abs(yLength - 1) > resolved.angular ||
+        Math.abs(zLength - 1) > resolved.angular) {
+        throw new GeometryError("INVALID_ARGUMENT", "Frame axes must have unit length.");
+    }
+    const x = normalized(frame.xAxis, "Frame X axis", resolved.linear);
+    const y = normalized(frame.yAxis, "Frame Y axis", resolved.linear);
+    const z = normalized(frame.zAxis, "Frame Z axis", resolved.linear);
+    if (Math.abs(dot(x, y)) > resolved.angular ||
+        Math.abs(dot(x, z)) > resolved.angular ||
+        Math.abs(dot(y, z)) > resolved.angular ||
+        dot(cross(x, y), z) < 1 - resolved.angular) {
+        throw new GeometryError("INVALID_ARGUMENT", "Frame axes must be right-handed and mutually orthogonal.");
+    }
+    return frozenTransform([
+        x[0],
+        y[0],
+        z[0],
+        frame.origin[0],
+        x[1],
+        y[1],
+        z[1],
+        frame.origin[1],
+        x[2],
+        y[2],
+        z[2],
+        frame.origin[2],
+        0,
+        0,
+        0,
+        1,
+    ]);
+}

package/dist/geometry/types.js

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

package/dist/index.js

@@ -0,0 +1 @@
+export * from "./model/operations.js";

package/dist/model/execution-binding.js

@@ -0,0 +1,30 @@
+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/2");
+const bindings = globalThis;
+/** Internal host binding. Executable callbacks are synchronous and may not nest executions. */
+export function bindModelContext(context, build) {
+    if (bindings[executionKey] !== undefined) {
+        throw new GeometryError("INVALID_ARGUMENT", "Model builds cannot nest.", {
+            operation: "build",
+        });
+    }
+    bindings[executionKey] = { version: 2, context };
+    try {
+        return build();
+    }
+    finally {
+        delete bindings[executionKey];
+    }
+}
+/** Resolves only the current live build; imported functions carry no native state themselves. */
+export function currentModelContext(operation) {
+    const binding = bindings[executionKey];
+    if (binding?.version !== 2) {
+        throw new GeometryError("INVALID_ARGUMENT", "Modeling functions can only run inside build().", {
+            operation,
+        });
+    }
+    return binding.context;
+}

package/dist/model/operations.js

@@ -0,0 +1,152 @@
+import { currentModelContext } from "./execution-binding.js";
+function operation(name) {
+    const invoke = (...args) => {
+        const context = currentModelContext(name);
+        const method = context[name];
+        if (typeof method !== "function")
+            throw new Error(`Unknown modeling operation "${name}".`);
+        return Reflect.apply(method, undefined, args);
+    };
+    return invoke;
+}
+/** Matches an explicit profile family using the current build's physical resolution. */
+export const matchProfiles = 
+/* @__PURE__ */ operation("matchProfiles");
+/** Copies intersections along a finite directed ray segment during the active build. */
+export const rayCast = /* @__PURE__ */ operation("rayCast");
+/** Returns bound local operations, optionally with derived resolution, without changing imported operations. */
+export function modelingFunctions(resolution) {
+    const context = currentModelContext("modelingFunctions");
+    return resolution === undefined ? context : context.withResolution(resolution);
+}
+/** Host-bound box operation. Valid only during a synchronous build. */
+export const box = /* @__PURE__ */ operation("box");
+/** Constructs a closed regularly sampled heightfield during the active synchronous build. */
+export const heightfield = /* @__PURE__ */ operation("heightfield");
+/** Returns an immutable copy with the explicit native millimetre tolerance. */
+export const setTolerance = 
+/* @__PURE__ */ operation("setTolerance");
+/** Host-bound cylinder operation. Valid only during a synchronous build. */
+export const cylinder = /* @__PURE__ */ operation("cylinder");
+/** Host-bound tube operation. Valid only during a synchronous build. */
+export const tube = /* @__PURE__ */ operation("tube");
+/** Host-bound sphere operation. Valid only during a synchronous build. */
+export const sphere = /* @__PURE__ */ operation("sphere");
+/** Host-bound torus operation. Valid only during a synchronous build. */
+export const torus = /* @__PURE__ */ operation("torus");
+/** Host-bound union operation. Valid only during a synchronous build. */
+export const union = /* @__PURE__ */ operation("union");
+/** Host-bound subtract operation. Valid only during a synchronous build. */
+export const subtract = /* @__PURE__ */ operation("subtract");
+/** Host-bound intersect operation. Valid only during a synchronous build. */
+export const intersect = /* @__PURE__ */ operation("intersect");
+/** Host-bound compose operation. Valid only during a synchronous build. */
+export const compose = /* @__PURE__ */ operation("compose");
+/** Host-bound hull operation. Valid only during a synchronous build. */
+export const hull = /* @__PURE__ */ operation("hull");
+/** Host-bound minkowskiSum operation. Valid only during a synchronous build. */
+export const minkowskiSum = 
+/* @__PURE__ */ operation("minkowskiSum");
+/** Host-bound solidFromMesh operation. Valid only during a synchronous build. */
+export const solidFromMesh = 
+/* @__PURE__ */ operation("solidFromMesh");
+/** Host-bound toTriangleMesh operation. Valid only during a synchronous build. */
+export const toTriangleMesh = 
+/* @__PURE__ */ operation("toTriangleMesh");
+/** Host-bound translate operation. Valid only during a synchronous build. */
+export const translate = /* @__PURE__ */ operation("translate");
+/** Host-bound rotate operation. Valid only during a synchronous build. */
+export const rotate = /* @__PURE__ */ operation("rotate");
+/** Host-bound scale operation. Valid only during a synchronous build. */
+export const scale = /* @__PURE__ */ operation("scale");
+/** Host-bound mirror operation. Valid only during a synchronous build. */
+export const mirror = /* @__PURE__ */ operation("mirror");
+/** Host-bound transform operation. Valid only during a synchronous build. */
+export const transform = /* @__PURE__ */ operation("transform");
+/** Host-bound fromRegion operation. Valid only during a synchronous build. */
+export const fromRegion = /* @__PURE__ */ operation("fromRegion");
+/** Host-bound toRegion operation. Valid only during a synchronous build. */
+export const toRegion = /* @__PURE__ */ operation("toRegion");
+/** Host-bound rectangle operation. Valid only during a synchronous build. */
+export const rectangle = /* @__PURE__ */ operation("rectangle");
+/** Host-bound circle operation. Valid only during a synchronous build. */
+export const circle = /* @__PURE__ */ operation("circle");
+/** Host-bound regularPolygon operation. Valid only during a synchronous build. */
+export const regularPolygon = 
+/* @__PURE__ */ operation("regularPolygon");
+/** Host-bound star operation. Valid only during a synchronous build. */
+export const star = /* @__PURE__ */ operation("star");
+/** Host-bound extrude operation. Valid only during a synchronous build. */
+export const extrude = /* @__PURE__ */ operation("extrude");
+/** Host-bound revolve operation. Valid only during a synchronous build. */
+export const revolve = /* @__PURE__ */ operation("revolve");
+/** Host-bound projectSection operation. Valid only during a synchronous build. */
+export const projectSection = 
+/* @__PURE__ */ operation("projectSection");
+/** Host-bound sliceSection operation. Valid only during a synchronous build. */
+export const sliceSection = 
+/* @__PURE__ */ operation("sliceSection");
+/** Host-bound loft operation. Valid only during a synchronous build. */
+export const loft = /* @__PURE__ */ operation("loft");
+/** Host-bound sweep operation. Valid only during a synchronous build. */
+export const sweep = /* @__PURE__ */ operation("sweep");
+/** Host-bound inspectSection operation. Valid only during a synchronous build. */
+export const inspectSection = 
+/* @__PURE__ */ operation("inspectSection");
+/** Host-bound inspectSolid operation. Valid only during a synchronous build. */
+export const inspectSolid = 
+/* @__PURE__ */ operation("inspectSolid");
+/** Host-bound components operation. Valid only during a synchronous build. */
+export const components = /* @__PURE__ */ operation("components");
+/** Host-bound simplify operation. Valid only during a synchronous build. */
+export const simplify = /* @__PURE__ */ operation("simplify");
+/** Host-bound implicit operation. Valid only during a synchronous build. */
+export const implicit = /* @__PURE__ */ operation("implicit");
+/** Host-bound linearPattern operation. Valid only during a synchronous build. */
+export const linearPattern = 
+/* @__PURE__ */ operation("linearPattern");
+/** Host-bound radialPattern operation. Valid only during a synchronous build. */
+export const radialPattern = 
+/* @__PURE__ */ operation("radialPattern");
+/** Host-bound gridPattern operation. Valid only during a synchronous build. */
+export const gridPattern = /* @__PURE__ */ operation("gridPattern");
+/** Host-bound pathPattern operation. Valid only during a synchronous build. */
+export const pathPattern = /* @__PURE__ */ operation("pathPattern");
+/** Host-bound threadRidge operation. Valid only during a synchronous build. */
+export const threadRidge = /* @__PURE__ */ operation("threadRidge");
+/** Host-bound threadedRod operation. Valid only during a synchronous build. */
+export const threadedRod = /* @__PURE__ */ operation("threadedRod");
+/** Host-bound internalThreadCutter operation. Valid only during a synchronous build. */
+export const internalThreadCutter = 
+/* @__PURE__ */ operation("internalThreadCutter");
+/** Host-bound threadedNut operation. Valid only during a synchronous build. */
+export const threadedNut = /* @__PURE__ */ operation("threadedNut");
+/** Host-bound preflightThreadedRod operation. Valid only during a synchronous build. */
+export const preflightThreadedRod = 
+/* @__PURE__ */ operation("preflightThreadedRod");
+/** Host-bound preflightThreadedNut operation. Valid only during a synchronous build. */
+export const preflightThreadedNut = 
+/* @__PURE__ */ operation("preflightThreadedNut");
+/** Host-bound textSection operation. Valid only during a synchronous build. */
+export const textSection = /* @__PURE__ */ operation("textSection");
+/** Host-bound svgSection operation. Valid only during a synchronous build. */
+export const svgSection = /* @__PURE__ */ operation("svgSection");
+/** Host-bound svgPathSection operation. Valid only during a synchronous build. */
+export const svgPathSection = 
+/* @__PURE__ */ operation("svgPathSection");
+/** Host-bound attach operation. Valid only during a synchronous build. */
+export const attach = /* @__PURE__ */ operation("attach");
+/** Reads one immutable named anchor from a shape in the active build. */
+export const anchor = /* @__PURE__ */ operation("anchor");
+/** Returns a new same-build shape handle with explicit copied named anchors. */
+export const withAnchors = /* @__PURE__ */ operation("withAnchors");
+/** Host-bound sectionFromContours operation. Valid only during a synchronous build. */
+export const sectionFromContours = 
+/* @__PURE__ */ operation("sectionFromContours");
+/** Host-bound ellipse operation. Valid only during a synchronous build. */
+export const ellipse = /* @__PURE__ */ operation("ellipse");
+/** Host-bound offset operation. Valid only during a synchronous build. */
+export const offset = /* @__PURE__ */ operation("offset");
+/** Host-bound preflightInternalThreadCutter operation. Valid only during a synchronous build. */
+export const preflightInternalThreadCutter = 
+/* @__PURE__ */ operation("preflightInternalThreadCutter");

package/dist/model/options.js

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

package/dist/model/types.js

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