@code3d/core 0.0.1-alpha.0 → 0.0.1-alpha.2

package/bld/library/runtime.js

@@ -1,2954 +0,0 @@
-import { captureModelMaterial } from './material.js';
-import { inspectShapeTopology, } from './topology-inspection.js';
-import { assembleWire, basicFaceExtrusion, BoundingBox, genericSweep, getOC, makeBSplineApproximation, makeBezierCurve, makeCircle, makeCylinder, makeFace, makeHelix, makeLine, makeSphere, makeThreePointArc, makeVertex, sketchCircle, sketchEllipse, sketchPolysides, sketchRectangle, Vector, } from 'replicad';
-import { castOwnedShape, castOwnedShape3D, centeredBoxShape, shapeSubshapes, transformShape, } from './kernel-shapes.js';
-import { addVectors, composeTransforms, frameFromYAxis, identityRigidTransform, invertTransform, rotateVector, origin, negateVector, quaternionAxisAngle, relativeTransform, rotation, rotationAround, translation, } from './spatial.js';
-import { axisRotation, solveBodies, } from './relation-solver.js';
-import { edgeGeometry, faceGeometry, transformGeometry, } from './alignment-geometry.js';
-import { shellWithTopology } from './shell.js';
-import { beginKernelOperationEvaluation, evaluateKernelOperation, kernelOperationKey, findKernelOperation, acceptKernelOperation, } from './kernel-cache.js';
-import { loftWithTopology } from './loft.js';
-import { estimateRetainedBytes } from './retained-memory.js';
-import { extrudeWithTopology } from './extrude.js';
-import { sketchRegionFace } from './sketch-face.js';
-import { formatTopologyId } from './topology-id.js';
-import { booleanWithTopology, chamferEdges, filletEdges, initialShapeTopology, preserveShapeTopology, resolveEdgeSelection, resolveTopologySelection, stableEdgeGroups, stableSurfaceGroups, stableVertexData, topologyEdgeDirections, topologySurfaceDirections, topologyVertexPoints, topologyChildren, withTopologyShape, } from './topology.js';
-import { sketch } from './sketch.js';
-import { encodeKernelArtifact, decodeKernelArtifact, } from './kernel-artifact-codec.js';
-let activeRelate;
-// Geometry and relations are persistent model values. Source provenance belongs
-// only to the evaluation that observed them, including models cached by packages.
-let valueTraces = new WeakMap();
-let operationTraces = new WeakMap();
-/**
- * Start a fresh, serial tooling evaluation without invalidating model geometry.
- * Finish in finally after snapshotting to retain this evaluation's kernel work.
- * An optional cancellation check may throw before any kernel operation starts;
- * complete results survive cancellation, and cleanup removes the check.
- */
-export function beginModelEvaluation(checkCancelled) {
-    valueTraces = new WeakMap();
-    operationTraces = new WeakMap();
-    return beginKernelOperationEvaluation(checkCancelled);
-}
-function valueTrace(value) {
-    let trace = valueTraces.get(value);
-    if (!trace) {
-        trace = { sourceRefs: [], parameters: [] };
-        valueTraces.set(value, trace);
-    }
-    return trace;
-}
-function transformSolveContext(context, transform) {
-    return {
-        poses: new Map([...context.poses].map(([model, pose]) => [
-            model,
-            composeTransforms(transform, pose),
-        ])),
-    };
-}
-const unitScale = [1, 1, 1];
-let nextNodeId = 1;
-let nextConstraintId = 1;
-let nextOperationId = 1;
-const combineModels = Symbol('combineModels');
-const loftModels = Symbol('loftModels');
-const modelElementKinds = {
-    solid: 'frame',
-    face: 'face',
-    edge: 'line',
-    vertex: 'point',
-    group: 'frame',
-};
-const defaultModelNames = {
-    solid: 'Solid',
-    face: 'Face',
-    edge: 'Edge',
-    vertex: 'Vertex',
-    group: 'Group',
-};
-const anchorKind = Symbol('anchorKind');
-const anchorReferenceValue = Symbol('anchorReference');
-const modelFamily = Symbol('modelFamily');
-const modelNamedElements = Symbol('modelNamedElements');
-const boundKind = Symbol('boundKind');
-class ModelAnchor {
-    elementKind;
-    [anchorReferenceValue];
-    constructor(reference) {
-        this[anchorReferenceValue] = reference;
-        this.elementKind = this[anchorReferenceValue].kind;
-        for (const [name, member] of Object.entries(reference.members ?? {})) {
-            const pointMember = ['center', 'start', 'midpoint', 'end'].includes(name);
-            if (name in this &&
-                !pointMember &&
-                !(name === 'id' && reference.topology?.selection.kind === 'solid')) {
-                throw new Error(`The exposed member ${name} conflicts with the topology API.`);
-            }
-            Object.defineProperty(this, name, {
-                value: modelAnchor(reference.model, `${reference.name}.${name}`, member),
-            });
-        }
-    }
-    get up() {
-        return directionalBound(this[anchorReferenceValue], 'up');
-    }
-    get down() {
-        return directionalBound(this[anchorReferenceValue], 'down');
-    }
-    get left() {
-        return directionalBound(this[anchorReferenceValue], 'left');
-    }
-    get right() {
-        return directionalBound(this[anchorReferenceValue], 'right');
-    }
-    get front() {
-        return directionalBound(this[anchorReferenceValue], 'front');
-    }
-    get back() {
-        return directionalBound(this[anchorReferenceValue], 'back');
-    }
-    flip() {
-        const ref = this[anchorReferenceValue];
-        const facing = -(ref.bound?.facing ?? ref.facing ?? 1);
-        return modelAnchor(ref.model, ref.name, {
-            ...ref,
-            facing,
-            bound: ref.bound ? { ...ref.bound, facing } : undefined,
-        });
-    }
-    reverse() {
-        const ref = this[anchorReferenceValue];
-        return modelAnchor(ref.model, ref.name, {
-            ...ref,
-            direction: -(ref.direction ?? 1),
-        });
-    }
-    on(target) {
-        return Constraint.create(this[anchorReferenceValue], boundReference(target));
-    }
-    align(target) {
-        return Constraint.create(this[anchorReferenceValue], anchorReference(target), 'align');
-    }
-}
-class ModelTopologyElement extends ModelAnchor {
-    get kind() {
-        return this.#topology.selection.kind;
-    }
-    get id() {
-        const selection = this.#topology.selection;
-        return selection.kind === 'solid' ? undefined : selection.id;
-    }
-    get #topology() {
-        return this[anchorReferenceValue].topology;
-    }
-    get center() {
-        const geometry = this.#topology.source[modelGeometry]();
-        return this.#pointAnchor('center', topologyCenter(geometry, this.#topology.selection));
-    }
-    get start() {
-        return this.#curvePoint('start', 0);
-    }
-    get midpoint() {
-        return this.#curvePoint('midpoint', 0.5);
-    }
-    get end() {
-        return this.#curvePoint('end', 1);
-    }
-    #curvePoint(name, parameter) {
-        const geometry = this.#topology.source[modelGeometry]().value;
-        const basis = geometry.referenceBasis;
-        const element = withTopologyShape(basis?.shape ?? geometry.shape, basis?.topology ?? geometry.topology, this.#topology.selection, shape => curveAnchor(shape, parameter));
-        return this.#pointAnchor(name, basis ? topologyTransform(basis, element.transform) : element.transform);
-    }
-    #pointAnchor(name, transform) {
-        return modelAnchor(this[anchorReferenceValue].model, `${this[anchorReferenceValue].name}.${name}`, {
-            kind: 'point',
-            transform: topologyTransform(this.#topology, transform),
-        });
-    }
-    vertex(id) {
-        return this.vertices([id])[0];
-    }
-    vertices(ids) {
-        return this.#select('vertex', ids);
-    }
-    edge(id) {
-        return this.edges([id])[0];
-    }
-    edges(ids) {
-        return this.#select('edge', ids);
-    }
-    surface(id) {
-        return this.surfaces([id])[0];
-    }
-    surfaces(ids) {
-        return this.#select('surface', ids);
-    }
-    #select(kind, ids) {
-        const geometry = this.#topology.source[modelGeometry]().value;
-        const selected = topologyChildren(geometry.shape, geometry.topology, this.#topology.selection, kind, ids);
-        return topologyReferences(this[anchorReferenceValue].model, `${this[anchorReferenceValue].name}.`, this.#topology, kind, selected);
-    }
-}
-const topologyElementKinds = {
-    solid: 'frame',
-    vertex: 'point',
-    edge: 'line',
-    surface: 'face',
-};
-export function modelElementReference(value) {
-    if (!(value instanceof ModelAnchor))
-        return undefined;
-    return {
-        model: value[anchorReferenceValue].model,
-        name: value[anchorReferenceValue].name,
-        kind: value[anchorReferenceValue].kind,
-        transform: toTransform(value[anchorReferenceValue].transform),
-        bound: value[anchorReferenceValue].bound,
-        facing: value[anchorReferenceValue].facing ?? 1,
-        direction: value[anchorReferenceValue].direction ?? 1,
-    };
-}
-export function modelTopologyReference(value) {
-    if (!(value instanceof ModelTopologyElement))
-        return undefined;
-    const topology = value[anchorReferenceValue].topology;
-    return {
-        model: value[anchorReferenceValue].model,
-        geometry: topology.source,
-        transform: {
-            ...topology.transform,
-            scale: [topology.scale, topology.scale, topology.scale],
-        },
-        ...topology.selection,
-    };
-}
-export function modelTopologyIds(value, kind) {
-    const topology = value instanceof ModelTopologyElement
-        ? value[anchorReferenceValue].topology
-        : undefined;
-    const source = isModelObject(value)
-        ? value
-        : value instanceof ConstraintExpression
-            ? value.self()
-            : topology?.source;
-    const geometry = source?.[modelGeometry]()?.value;
-    if (!geometry)
-        return undefined;
-    return topologyChildren(geometry.shape, geometry.topology, topology?.selection ?? { kind: 'solid' }, kind);
-}
-/** Traceable relation values, including unfinished pivot and axis selections. */
-export class ConstraintExpression {
-    kind;
-    source;
-    target;
-    displacement;
-    rotations;
-    context;
-    constraintId;
-    get sourceRefs() {
-        return valueTrace(this).sourceRefs;
-    }
-    get parameters() {
-        return valueTrace(this).parameters;
-    }
-    spatialOperation;
-    constructor(kind, source, target, displacement, rotations, context, constraintId, previous) {
-        this.kind = kind;
-        this.source = source;
-        this.target = target;
-        this.displacement = displacement;
-        this.rotations = rotations;
-        this.context = context;
-        this.constraintId = constraintId;
-        valueTraces.set(this, {
-            sourceRefs: [...(previous ? valueTrace(previous).sourceRefs : [])],
-            parameters: [...(previous ? valueTrace(previous).parameters : [])],
-        });
-    }
-    /** @internal */
-    attachSource(sourceRef) {
-        const refs = this.sourceRefs;
-        if (!refs.some(ref => ref.file === sourceRef.file &&
-            ref.start === sourceRef.start &&
-            ref.end === sourceRef.end))
-            refs.push(sourceRef);
-    }
-    /** @internal */
-    attachParameters(parameters) {
-        appendUniqueParameters(this.parameters, parameters);
-    }
-    /** @internal */
-    self() {
-        return this.context?.self;
-    }
-    /** @internal */
-    traceReference() {
-        const rebind = (model) => model === this.context?.original ? this.context.self : model;
-        return {
-            constraintId: this.constraintId,
-            source: rebind(this.source.model),
-            target: rebind(this.target.model),
-            self: this.context?.self,
-        };
-    }
-    /** @internal */
-    storeFor(model, original) {
-        const isSelf = (candidate) => candidate === model || candidate === original;
-        if (!isSelf(this.source.model) && !isSelf(this.target.model))
-            throw new Error('The constraint returned by relate() must involve self or the original receiver.');
-        const bind = (reference) => ({
-            ...reference,
-            model: isSelf(reference.model) ? undefined : reference.model,
-        });
-        const stored = {
-            id: this.constraintId,
-            kind: this.kind,
-            source: bind(this.source),
-            target: bind(this.target),
-            offset: this.displacement,
-            rotations: this.rotations.map(action => ({
-                ...action,
-                pivot: action.pivot.kind === 'around'
-                    ? { ...action.pivot, axis: bind(action.pivot.axis) }
-                    : action.pivot,
-            })),
-        };
-        valueTraces.set(stored, {
-            sourceRefs: [...this.sourceRefs],
-            parameters: [...this.parameters],
-        });
-        return stored;
-    }
-    /** @internal */
-    preview() {
-        if (!this.context)
-            return undefined;
-        const pivot = this.spatialOperation?.pivot;
-        const selection = pivot?.kind === 'around'
-            ? {
-                ...this.spatialOperation,
-                pivot: {
-                    ...pivot,
-                    axis: {
-                        ...pivot.axis,
-                        model: pivot.axis.model === this.context.self ||
-                            pivot.axis.model === this.context.original
-                            ? undefined
-                            : pivot.axis.model,
-                    },
-                },
-            }
-            : this.spatialOperation;
-        return this.context.original[relationPreview](this.context.self.nodeId, this.storeFor(this.context.self, this.context.original), selection);
-    }
-}
-export class Constraint extends ConstraintExpression {
-    constructor(kind, source, target, displacement = undefined, rotations = [], context = activeRelate, constraintId = `constraint-${nextConstraintId++}`, previous, spatialOperation) {
-        super(kind, source, target, displacement, rotations, context, constraintId, previous);
-        this.spatialOperation = spatialOperation;
-    }
-    /** @internal */
-    static create(source, target, kind = 'on') {
-        if (kind === 'on')
-            source.model[referenceBounds](source, identityRigidTransform);
-        else if (source.kind === 'frame' || target.kind === 'frame')
-            throw new Error('align() requires points, curves, or surfaces; select geometry on a solid or group.');
-        return new Constraint(kind, source, target);
-    }
-    /**
-     * In the target reference axes, on() pins matching bound centers; align()
-     * translates self after alignment, retaining the relation's free modes.
-     * Explicit zero pins tangential coordinates for on() only.
-     * @code3d.param x {kind: 'length', label: 'ΔX'}
-     * @code3d.param y {kind: 'length', label: 'ΔY'}
-     * @code3d.param z {kind: 'length', label: 'ΔZ'}
-     */
-    offset(x, y, z) {
-        assertFiniteVector('offset', [x, y, z]);
-        return new Constraint(this.kind, this.source, this.target, addVectors(this.displacement ?? origin, [x, y, z]), this.rotations, this.context, this.constraintId, this);
-    }
-    /**
-     * Select this rotation's pivot in self's local coordinates.
-     * @code3d.param x {kind: 'length', label: 'Pivot X'}
-     * @code3d.param y {kind: 'length', label: 'Pivot Y'}
-     * @code3d.param z {kind: 'length', label: 'Pivot Z'}
-     */
-    pivot([x, y, z]) {
-        assertFiniteVector('pivot', [x, y, z]);
-        return new ConstraintPivotChain(this, { kind: 'pivot', point: [x, y, z] });
-    }
-    /** @code3d.param id {kind: 'vertex', label: 'Pivot vertex'} */
-    pivotVertex(id) {
-        return new ConstraintPivotChain(this, { kind: 'pivotVertex', id });
-    }
-    /** Select a positioned axis in the composition. */
-    around(axis) {
-        const reference = anchorReference(axis);
-        if (reference.kind !== 'line')
-            throw new Error('around() requires an axis or straight edge.');
-        const geometry = reference.topology?.source[modelGeometry]()?.value ??
-            (reference.whole ? reference.model[modelGeometry]()?.value : undefined);
-        if (geometry) {
-            const straight = reference.topology
-                ? withTopologyShape(geometry.shape, geometry.topology, reference.topology.selection, shape => shape.geomType === 'LINE')
-                : geometry.shape.geomType === 'LINE';
-            if (!straight)
-                throw new Error('around() requires a straight axis; curved edges do not define one rotation axis.');
-        }
-        return new ConstraintAroundChain(this, { kind: 'around', axis: reference });
-    }
-    /**
-     * Rotate about self's origin and local X, Y, then Z axes, in degrees.
-     * @code3d.param x {kind: 'angle', label: 'Rotate X'}
-     * @code3d.param y {kind: 'angle', label: 'Rotate Y'}
-     * @code3d.param z {kind: 'angle', label: 'Rotate Z'}
-     */
-    rotate(x, y, z) {
-        return this.withRotation({ kind: 'pivot', point: origin }, [x, y, z], this);
-    }
-    /** @internal */
-    withRotation(pivot, angles, previous) {
-        assertFiniteVector('rotate', typeof angles === 'number' ? [angles, 0, 0] : angles);
-        return new Constraint(this.kind, this.source, this.target, this.displacement, [...this.rotations, { pivot, angles }], this.context, this.constraintId, previous, { kind: 'rotate', pivot });
-    }
-    /** @internal */
-    chainArguments() {
-        return [
-            this.kind,
-            this.source,
-            this.target,
-            this.displacement,
-            this.rotations,
-            this.context,
-            this.constraintId,
-            this,
-        ];
-    }
-}
-export class ConstraintPivotChain extends ConstraintExpression {
-    constraint;
-    selection;
-    /** @internal */
-    constructor(constraint, selection) {
-        super(...constraint.chainArguments());
-        this.constraint = constraint;
-        this.selection = selection;
-        this.spatialOperation = { kind: selection.kind, pivot: selection };
-    }
-    /**
-     * @code3d.param x {kind: 'angle', label: 'Rotate X'}
-     * @code3d.param y {kind: 'angle', label: 'Rotate Y'}
-     * @code3d.param z {kind: 'angle', label: 'Rotate Z'}
-     */
-    rotate(x, y, z) {
-        return this.constraint.withRotation(this.selection, [x, y, z], this);
-    }
-}
-export class ConstraintAroundChain extends ConstraintExpression {
-    constraint;
-    selection;
-    /** @internal */
-    constructor(constraint, selection) {
-        super(...constraint.chainArguments());
-        this.constraint = constraint;
-        this.selection = selection;
-        this.spatialOperation = { kind: selection.kind, pivot: selection };
-    }
-    /** @code3d.param angle {kind: 'angle', label: 'Rotate'} */
-    rotate(angle) {
-        return this.constraint.withRotation(this.selection, angle, this);
-    }
-}
-const modelGeometry = Symbol('modelGeometry');
-const referenceBounds = Symbol('referenceBounds');
-const referenceBoundsParts = Symbol('referenceBoundsParts');
-const modelSnapshotQueries = Symbol('modelSnapshotQueries');
-const relationPreview = Symbol('relationPreview');
-export class ModelObject {
-    /** @internal */
-    elementKind;
-    /** @internal */
-    nodeId;
-    /** @internal */
-    kind;
-    /** @internal */
-    name;
-    /** @internal */
-    materialSnapshot;
-    /** @internal */
-    children;
-    /** @internal */
-    get sourceRefs() {
-        return valueTrace(this).sourceRefs;
-    }
-    /** @internal */
-    get parameters() {
-        return valueTrace(this).parameters;
-    }
-    geometry;
-    assembly;
-    meshTolerance;
-    geometryAnchor;
-    elements;
-    constraints;
-    operation;
-    /** @internal */
-    [modelGeometry]() {
-        return this.geometry;
-    }
-    constructor(init) {
-        if (init.kind !== 'group' && !init.geometry) {
-            throw new Error('A geometric model object must contain an OpenCascade shape.');
-        }
-        this.nodeId = init.nodeId ?? `node-${nextNodeId++}`;
-        this.kind = init.kind;
-        this.elementKind = modelElementKinds[init.kind];
-        this.geometry = init.geometry;
-        this.geometryAnchor = init.geometryAnchor ?? {
-            kind: this.elementKind,
-            transform: identityRigidTransform,
-        };
-        this.meshTolerance = init.meshTolerance ?? 0.2;
-        this.name = init.name ?? defaultModelNames[init.kind];
-        this.materialSnapshot = init.material;
-        this.children = init.children ?? [];
-        this.assembly =
-            init.assembly ??
-                (this.kind === 'group'
-                    ? ModelObject.createAssembly(this.children)
-                    : undefined);
-        this.constraints = [...(init.constraints ?? [])];
-        valueTraces.set(this, {
-            sourceRefs: [...(init.sourceRefs ?? [])],
-            parameters: [...(init.parameters ?? [])],
-        });
-        this.operation = init.operation;
-        const elements = init.elements ??
-            (this.kind === 'solid' && this.geometry
-                ? solidElements(this.geometry.value.localBounds)
-                : {});
-        this.elements = this.geometry
-            ? {
-                center: {
-                    kind: 'point',
-                    transform: translation(boundsCenter(this.geometry.value.localBounds)),
-                },
-                ...elements,
-            }
-            : elements;
-        for (const [name, element] of Object.entries(this.elements)) {
-            if (name in this) {
-                throw new Error(`The element name ${name} conflicts with the model API.`);
-            }
-            Object.defineProperty(this, name, {
-                value: modelAnchor(this, name, element),
-            });
-        }
-    }
-    /** @internal */
-    static create(init) {
-        return new ModelObject(init);
-    }
-    get up() {
-        return directionalBound(this.relationAnchorReference(), 'up');
-    }
-    get down() {
-        return directionalBound(this.relationAnchorReference(), 'down');
-    }
-    get left() {
-        return directionalBound(this.relationAnchorReference(), 'left');
-    }
-    get right() {
-        return directionalBound(this.relationAnchorReference(), 'right');
-    }
-    get front() {
-        return directionalBound(this.relationAnchorReference(), 'front');
-    }
-    get back() {
-        return directionalBound(this.relationAnchorReference(), 'back');
-    }
-    on(target) {
-        return Constraint.create(this.relationAnchorReference(), boundReference(target));
-    }
-    /** @internal */
-    relationAnchorReference() {
-        return { model: this, name: 'geometry', ...this.geometryAnchor, whole: true };
-    }
-    align(target) {
-        return Constraint.create(this.relationAnchorReference(), anchorReference(target), 'align');
-    }
-    reverse() {
-        return this.edges()[0].reverse();
-    }
-    flip() {
-        return this.surfaces()[0].flip();
-    }
-    relate(build) {
-        const operation = storedOperation('relate', [
-            { model: this, role: 'source', index: 0 },
-        ]);
-        const related = this.copy({}, operation);
-        const previous = activeRelate;
-        activeRelate = { self: related, original: this };
-        let built;
-        try {
-            built = build(related);
-        }
-        finally {
-            activeRelate = previous;
-        }
-        const constraints = Array.isArray(built)
-            ? built
-            : [built];
-        const stored = constraints.map(constraint => {
-            if (!(constraint instanceof Constraint))
-                throw new Error('relate() requires a completed Constraint; finish pivot/around with rotate().');
-            return constraint.storeFor(related, this);
-        });
-        related.constraints.push(...stored);
-        operation.inputs.push(...uniqueModels(stored.flatMap(constraintReferences)).map((model, index) => ({
-            model,
-            role: 'reference',
-            index,
-        })));
-        return related;
-    }
-    expose(sources) {
-        const entries = Object.entries(sources);
-        const elements = this.localElements(entries.map(([, source]) => source));
-        const exposed = Object.fromEntries(entries.map(([name], index) => [name, elements[index]]));
-        const references = entries.map(([, source]) => anchorReference(source).model);
-        const operation = storedOperation('expose', [
-            { model: this, role: 'source', index: 0 },
-            ...uniqueModels(references)
-                .filter(model => model !== this)
-                .map((model, index) => ({
-                model,
-                role: 'reference',
-                index,
-            })),
-        ]);
-        return this.copy({ elements: { ...this.elements, ...exposed } }, operation);
-    }
-    /** Resolve both own and occurrence references into this model's local frame. */
-    localElements(sources) {
-        const members = this.memberPoses();
-        const external = sources
-            .map(source => anchorReference(source).model)
-            .filter(model => !members.has(model));
-        const context = external.length
-            ? ModelObject.createSolveContext([this, ...external])
-            : undefined;
-        return sources.map(source => {
-            const reference = anchorReference(source);
-            const { kind, transform: frame, topology, members: nested, bound, facing, } = source instanceof ModelObject ? source.exposedElement() : reference;
-            const memberPose = members.get(reference.model);
-            if (memberPose === null)
-                throw new Error("The point or element belongs to multiple occurrences. Expose it through the intended child model's named reference.");
-            const transform = memberPose ??
-                relativeTransform(reference.model.solvePose(context), this.solvePose(context));
-            return transformElement({ kind, transform: frame, topology, members: nested, bound, facing }, transform);
-        });
-    }
-    vertex(id) {
-        return this.vertices([id])[0];
-    }
-    vertices(ids) {
-        return this.selectTopology('vertex', ids);
-    }
-    edge(id) {
-        return this.edges([id])[0];
-    }
-    edges(ids) {
-        return this.selectTopology('edge', ids);
-    }
-    surface(id) {
-        return this.surfaces([id])[0];
-    }
-    surfaces(ids) {
-        return this.selectTopology('surface', ids);
-    }
-    selectTopology(kind, ids) {
-        const geometry = this.requireGeometry().value;
-        const selected = topologyChildren(geometry.shape, geometry.topology, { kind: 'solid' }, kind, ids);
-        return topologyReferences(this, '', { source: this, transform: identityRigidTransform, scale: 1 }, kind, selected);
-    }
-    /** @internal */
-    exposedElement() {
-        if (this.kind === 'group')
-            return { ...this.geometryAnchor, members: this.elements };
-        const geometry = this.requireGeometry().value;
-        const kind = (this.kind === 'face' ? 'surface' : this.kind);
-        const selection = kind === 'solid'
-            ? { kind }
-            : {
-                kind,
-                id: geometry.topology[kind === 'surface'
-                    ? 'surfaces'
-                    : kind === 'edge'
-                        ? 'edges'
-                        : 'vertices'].ids[0],
-            };
-        const context = {
-            source: this,
-            transform: identityRigidTransform,
-            scale: 1,
-        };
-        const anchor = selection.kind === 'solid'
-            ? this.geometryAnchor
-            : topologyReferences(this, '', context, selection.kind, [
-                selection.id,
-            ])[0][anchorReferenceValue];
-        return {
-            kind: anchor.kind,
-            transform: anchor.transform,
-            members: this.elements,
-            topology: {
-                ...context,
-                selection,
-            },
-        };
-    }
-    material(material) {
-        return this.copy({ material: captureModelMaterial(material) }, storedOperation('material', [{ model: this, role: 'source', index: 0 }]));
-    }
-    originOffset(dx, dy, dz) {
-        const offset = [dx, dy, dz];
-        assertFiniteVector('originOffset', offset);
-        return this.withOrigin(offset, { kind: 'originOffset' });
-    }
-    originPoint(point) {
-        const reference = anchorReference(point);
-        if (reference.kind !== 'point')
-            throw new Error('originPoint() requires a point reference.');
-        const [element] = this.localElements([point]);
-        return this.withOrigin(element.transform.position, {
-            kind: 'originPoint',
-            model: reference.model,
-        });
-    }
-    originVertex(id) {
-        const geometry = this.requireGeometry().value;
-        const [{ position }] = topologyVertexPoints(geometry.shape, geometry.topology.vertices, [id]);
-        return this.withOrigin(position, { kind: 'originVertex', id });
-    }
-    originCenter() {
-        this.requireGeometry();
-        const position = this.elements.center.transform.position;
-        return this.withOrigin(position, { kind: 'originCenter' });
-    }
-    withOrigin(offset, selection) {
-        const transform = translation(negateVector(offset));
-        const operation = storedOperation(selection.kind, [
-            { model: this, role: 'source', index: 0 },
-        ]);
-        if (selection.kind === 'originPoint' && selection.model !== this)
-            operation.inputs.push({
-                model: selection.model,
-                role: 'reference',
-                index: 0,
-            });
-        operation.spatial = { origin, vector: offset };
-        if (selection.kind === 'originVertex') {
-            operation.selections.push({
-                kind: 'vertex',
-                input: this,
-                ids: [selection.id],
-                transform,
-            });
-        }
-        return this.transformed(transform, operation);
-    }
-    rotate(x, y, z) {
-        const angles = [x, y, z];
-        assertFiniteVector('rotate', angles);
-        const operation = storedOperation('rotate', [
-            { model: this, role: 'source', index: 0 },
-        ]);
-        operation.spatial = { origin, vector: angles };
-        return this.transformed(rotationAround(origin, angles), operation);
-    }
-    transformed(transform, operation) {
-        const overrides = {
-            geometryAnchor: transformElement(this.geometryAnchor, transform),
-            elements: Object.fromEntries(Object.entries(this.elements).map(([name, element]) => [
-                name,
-                transformElement(element, transform),
-            ])),
-            constraints: this.mapConstraintGeometry(element => transformElement(element, transform), point => composeTransforms(transform, translation(point)).position),
-        };
-        if (this.assembly)
-            return this.copy({
-                ...overrides,
-                assembly: transformSolveContext(this.assembly, transform),
-            }, operation);
-        const source = this.requireGeometry();
-        const geometry = evaluateModelGeometry('transform', [transform.position, transform.quaternion], [source], () => {
-            const shape = shapeWithTransform(source.value.shape, transform);
-            try {
-                return {
-                    shape,
-                    topology: preserveShapeTopology(shape, source.value.topology),
-                    referenceBasis: transformedReferenceBasis(source, transform, 1),
-                };
-            }
-            catch (error) {
-                shape.delete();
-                throw error;
-            }
-        });
-        return this.copyWithGeometry(geometry, overrides, operation);
-    }
-    mapConstraintGeometry(mapElement, mapPoint) {
-        const mapReference = (reference) => reference.model ? reference : { ...reference, ...mapElement(reference) };
-        return this.constraints.map(constraint => {
-            const mapped = {
-                ...constraint,
-                source: mapReference(constraint.source),
-                target: mapReference(constraint.target),
-                rotations: constraint.rotations.map(action => ({
-                    ...action,
-                    pivot: action.pivot.kind === 'around'
-                        ? { ...action.pivot, axis: mapReference(action.pivot.axis) }
-                        : action.pivot.kind === 'pivot'
-                            ? { ...action.pivot, point: mapPoint(action.pivot.point) }
-                            : action.pivot,
-                })),
-            };
-            valueTraces.set(mapped, valueTrace(constraint));
-            return mapped;
-        });
-    }
-    scaled(factor) {
-        assertPositive('scale', factor);
-        const source = this.requireGeometry();
-        const geometry = evaluateModelGeometry('scaled', [factor], [source], () => {
-            const shape = shapeWithScale(source.value.shape, factor);
-            try {
-                return {
-                    shape,
-                    topology: preserveShapeTopology(shape, source.value.topology),
-                    referenceBasis: transformedReferenceBasis(source, identityRigidTransform, factor),
-                };
-            }
-            catch (error) {
-                shape.delete();
-                throw error;
-            }
-        });
-        return this.copyWithGeometry(geometry, {
-            geometryAnchor: scaleElement(this.geometryAnchor, factor),
-            elements: scaleElements(this.elements, factor),
-            constraints: this.mapConstraintGeometry(element => scaleElement(element, factor), point => scaleFrame(translation(point), factor).position),
-        }, storedOperation('scaled', [{ model: this, role: 'source', index: 0 }]));
-    }
-    extrude(distance) {
-        if (this.kind !== 'face')
-            throw new Error('extrude requires a single face model.');
-        if (!Number.isFinite(distance) || distance === 0)
-            throw new Error('Extrusion distance must be finite and non-zero.');
-        const source = this.requireGeometry();
-        const direction = rotateVector([0, distance, 0], this.geometryAnchor.transform.quaternion);
-        const geometry = evaluateSolidGeometry('extrude', [direction], [source], () => extrudeWithTopology({
-            shape: source.value.shape,
-            topology: source.value.topology,
-            index: 1,
-        }, direction));
-        return ModelObject.create({
-            kind: 'solid',
-            name: 'Extrude',
-            geometry,
-            material: this.materialSnapshot,
-            constraints: this.constraints,
-            sourceRefs: this.sourceRefs,
-            parameters: this.allParameters(),
-            meshTolerance: this.meshTolerance,
-            operation: storedOperation('extrude', [{ model: this, role: 'receiver', index: 0 }], {
-                dimensions: {
-                    distance: {
-                        origin: this.elements.center.transform.position,
-                        vector: direction,
-                    },
-                },
-            }),
-        });
-    }
-    cut(tools) {
-        return cut(this, tools);
-    }
-    fillet(radius, edgeIds) {
-        assertPositive('radius', radius);
-        const source = this.requireSolidGeometry();
-        const selectedEdgeIds = resolveEdgeSelection(source.value.topology.edges, edgeIds);
-        const geometry = evaluateSolidGeometry('fillet', [radius, selectedEdgeIds], [source], () => {
-            const result = filletEdges(source.value.shape, source.value.topology, radius, selectedEdgeIds);
-            return { shape: result.shape, topology: result.topology };
-        });
-        return this.copyWithGeometry(geometry, {}, storedOperation('fillet', [{ model: this, role: 'source', index: 0 }], {
-            selections: [
-                {
-                    kind: 'edge',
-                    input: this,
-                    ids: selectedEdgeIds,
-                    transform: identityRigidTransform,
-                },
-            ],
-        }));
-    }
-    chamfer(distance, edgeIds) {
-        assertPositive('distance', distance);
-        const source = this.requireSolidGeometry();
-        const selectedEdgeIds = resolveEdgeSelection(source.value.topology.edges, edgeIds);
-        const geometry = evaluateSolidGeometry('chamfer', [distance, selectedEdgeIds], [source], () => {
-            const result = chamferEdges(source.value.shape, source.value.topology, distance, selectedEdgeIds);
-            return { shape: result.shape, topology: result.topology };
-        });
-        return this.copyWithGeometry(geometry, {}, storedOperation('chamfer', [{ model: this, role: 'source', index: 0 }], {
-            selections: [
-                {
-                    kind: 'edge',
-                    input: this,
-                    ids: selectedEdgeIds,
-                    transform: identityRigidTransform,
-                },
-            ],
-        }));
-    }
-    shell(thickness, removedSurfaceIds = []) {
-        if (!Number.isFinite(thickness) || thickness === 0) {
-            throw new Error('thickness must be a nonzero finite number.');
-        }
-        const source = this.requireSolidGeometry();
-        const selectedIds = resolveTopologySelection('surface', source.value.topology.surfaces, removedSurfaceIds);
-        const geometry = evaluateSolidGeometry('shell', [thickness, selectedIds], [source], () => shellWithTopology(source.value.shape, source.value.topology, thickness, selectedIds));
-        return this.copyWithGeometry(geometry, {}, storedOperation('shell', [{ model: this, role: 'source', index: 0 }], {
-            selections: [
-                {
-                    kind: 'surface',
-                    input: this,
-                    ids: selectedIds,
-                    transform: identityRigidTransform,
-                },
-            ],
-        }));
-    }
-    /** @internal */
-    attachSource(sourceRef) {
-        const previous = this.sourceRefs.at(-1);
-        if (previous?.file !== sourceRef.file ||
-            previous.start !== sourceRef.start ||
-            previous.end !== sourceRef.end) {
-            this.sourceRefs.push(sourceRef);
-        }
-    }
-    /** @internal */
-    attachParameters(parameters) {
-        appendUniqueParameters(this.parameters, parameters);
-    }
-    /** @internal */
-    attachOperationTrace(siteId, execution, order, sourceRef) {
-        if (operationTraces.has(this.operation)) {
-            return;
-        }
-        operationTraces.set(this.operation, { siteId, execution, order, sourceRef });
-    }
-    /** @internal */
-    relatedObjects() {
-        return [
-            ...this.children,
-            ...this.operation.inputs.map(input => input.model),
-            ...this.constraints.flatMap(constraintReferences),
-        ];
-    }
-    /** @internal */
-    toSnapshot(meshCache = new Map()) {
-        const solveContext = ModelObject.createSolveContext([this]);
-        return this.snapshotNode(meshCache, solveContext);
-    }
-    snapshotNode(meshCache, solveContext, inComposition = false, overrideMaterial) {
-        const material = overrideMaterial ?? this.materialSnapshot;
-        const pose = this.solvePose(solveContext);
-        const constraints = this.constraints.map(constraint => this.constraintSnapshot(constraint, solveContext));
-        const parameters = uniqueParameters([
-            ...this.parameters,
-            ...this.constraints.flatMap(constraint => valueTrace(constraint).parameters),
-        ]);
-        const common = {
-            nodeId: this.nodeId,
-            kind: this.kind,
-            name: this.name,
-            material,
-            compositionTransform: toTransform(pose),
-            transform: toTransform(inComposition ? pose : identityRigidTransform),
-            constraints,
-            origin,
-            elements: snapshotElements({
-                ...this.elements,
-                ...(this.geometry || this.children.length
-                    ? Object.fromEntries(Object.keys(boundDirections).map(direction => [
-                        direction,
-                        anchorReference(this[direction]),
-                    ]))
-                    : {}),
-            }),
-            sourceRefs: [...this.sourceRefs],
-            parameters,
-            operation: this.operationSnapshot(meshCache),
-        };
-        if (this.kind === 'group') {
-            const childContext = this.assembly;
-            return {
-                ...common,
-                children: this.children.map(child => child.snapshotNode(meshCache, childContext, true, material)),
-            };
-        }
-        const geometry = this.requireGeometry();
-        return {
-            ...common,
-            children: [],
-            mesh: renderMesh(geometry, geometry.value.shape, meshCache, this.meshTolerance, geometry.value.topology),
-        };
-    }
-    /** @internal */
-    disposeShape(disposed) {
-        const shapes = [
-            ...(this.geometry ? [this.geometry.value.shape] : []),
-            ...(this.geometry?.value.referenceBasis
-                ? [this.geometry.value.referenceBasis.shape]
-                : []),
-            ...this.operation.regions.map(region => region.artifact.value),
-        ];
-        for (const shape of shapes) {
-            if (!disposed.has(shape)) {
-                disposed.add(shape);
-                shape.delete();
-            }
-        }
-        this.children.forEach(child => child.disposeShape(disposed));
-    }
-    /** @internal */
-    [loftModels](others, spine, ruled) {
-        const sections = [this, ...others];
-        const solveContext = ModelObject.createSolveContext([
-            ...sections,
-            ...(spine ? [spine] : []),
-        ]);
-        const resultPose = this.solvePose(solveContext);
-        const sectionInputs = sections.map(section => ({
-            model: section,
-            geometry: section.requireGeometry(),
-            transform: relativeTransform(section.solvePose(solveContext), resultPose),
-        }));
-        const spineInput = spine
-            ? {
-                model: spine,
-                geometry: spine.requireGeometry(),
-                transform: relativeTransform(spine.solvePose(solveContext), resultPose),
-            }
-            : undefined;
-        const geometry = evaluateSolidGeometry(spine ? 'spine-loft' : 'loft', [
-            ruled,
-            sectionInputs.map(input => [
-                input.transform.position,
-                input.transform.quaternion,
-            ]),
-            spineInput
-                ? [spineInput.transform.position, spineInput.transform.quaternion]
-                : null,
-        ], [
-            ...sectionInputs.map(input => input.geometry),
-            ...(spineInput ? [spineInput.geometry] : []),
-        ], () => buildLoftGeometry(sectionInputs, spineInput, ruled));
-        const inputs = [...sections, ...(spine ? [spine] : [])];
-        return ModelObject.create({
-            kind: 'solid',
-            name: 'Loft',
-            geometry,
-            material: this.materialSnapshot,
-            constraints: this.constraints,
-            sourceRefs: inputs.flatMap(input => input.sourceRefs),
-            parameters: uniqueParameters(inputs.flatMap(input => input.allParameters())),
-            meshTolerance: Math.min(...inputs.map(input => input.meshTolerance)),
-            operation: storedOperation('loft', [
-                { model: this, role: 'receiver', index: 0 },
-                ...others.map((model, index) => ({
-                    model,
-                    role: 'section',
-                    index: index + 1,
-                })),
-                ...(spine
-                    ? [{ model: spine, role: 'spine', index: sections.length }]
-                    : []),
-            ]),
-        });
-    }
-    /** @internal */
-    [combineModels](operation, others) {
-        const evaluation = this.evaluateBoolean(operation, others);
-        let transferred = false;
-        try {
-            const combined = ModelObject.create({
-                kind: 'solid',
-                geometryAnchor: this.geometryAnchor,
-                geometry: evaluation.geometry,
-                name: this.name,
-                material: this.materialSnapshot,
-                constraints: this.constraints,
-                sourceRefs: [this, ...others].flatMap(model => model.sourceRefs),
-                parameters: uniqueParameters([this, ...others].flatMap(model => model.allParameters())),
-                meshTolerance: Math.min(this.meshTolerance, ...others.map(model => model.meshTolerance)),
-                operation: storedOperation(operation === 'fuse' ? 'union' : operation, [
-                    { model: this, role: 'receiver', index: 0 },
-                    ...others.map((model, index) => ({
-                        model,
-                        role: operation === 'cut' ? 'tool' : 'operand',
-                        index: index + 1,
-                    })),
-                ], { regions: evaluation.regions }),
-            });
-            transferred = true;
-            return combined;
-        }
-        finally {
-            if (!transferred) {
-                disposeModelGeometryValue(evaluation.geometry.value);
-                evaluation.regions.forEach(region => region.artifact.value.delete());
-            }
-        }
-    }
-    evaluateBoolean(operation, others) {
-        const solveContext = ModelObject.createSolveContext([this, ...others]);
-        const targetPose = this.solvePose(solveContext);
-        let geometry = this.requireSolidGeometry();
-        let temporaryGeometry;
-        const regions = [];
-        let evaluated = false;
-        try {
-            for (const [otherIndex, other] of others.entries()) {
-                const otherGeometry = other.requireSolidGeometry();
-                const transform = relativeTransform(other.solvePose(solveContext), targetPose);
-                const operand = evaluateKernelShape('transform', [transform.position, transform.quaternion], [otherGeometry], () => shapeWithTransform(otherGeometry.value.shape, transform));
-                try {
-                    if (operation === 'cut' || operation === 'fuse') {
-                        regions.push({
-                            kind: 'intersection',
-                            input: other,
-                            frame: this,
-                            artifact: evaluateKernelShape('boolean-intersection-region', [], [geometry, operand], () => geometry.value.shape.intersect(operand.value)),
-                        });
-                    }
-                    if (operation === 'fuse') {
-                        regions.push({
-                            kind: 'section',
-                            input: other,
-                            frame: this,
-                            artifact: evaluateKernelShape('boolean-section-region', [], [geometry, operand], () => unionSectionShape(geometry.value.shape, operand.value)),
-                        });
-                    }
-                    const nextGeometry = evaluateSolidGeometry(`boolean-${operation}`, [otherIndex], [geometry, operand], () => {
-                        const result = booleanWithTopology({
-                            shape: geometry.value.shape,
-                            topology: geometry.value.topology,
-                            index: otherIndex === 0 ? 1 : undefined,
-                        }, {
-                            shape: operand.value,
-                            topology: otherGeometry.value.topology,
-                            index: otherIndex + 2,
-                        }, operation);
-                        return { shape: result.shape, topology: result.topology };
-                    });
-                    temporaryGeometry?.value.shape.delete();
-                    temporaryGeometry = nextGeometry;
-                    geometry = nextGeometry;
-                }
-                finally {
-                    operand.value.delete();
-                }
-            }
-            evaluated = true;
-            return { geometry, regions };
-        }
-        finally {
-            if (!evaluated) {
-                temporaryGeometry?.value.shape.delete();
-                regions.forEach(region => region.artifact.value.delete());
-            }
-        }
-    }
-    allParameters() {
-        return uniqueParameters([
-            ...this.parameters,
-            ...this.constraints.flatMap(constraint => valueTrace(constraint).parameters),
-        ]);
-    }
-    solvePose(context) {
-        return context.poses.get(this);
-    }
-    memberPoses() {
-        const members = new Map([
-            [this, identityRigidTransform],
-        ]);
-        if (this.children.length) {
-            const context = this.assembly;
-            for (const child of this.children) {
-                const pose = child.solvePose(context);
-                for (const [member, localPose] of child.memberPoses()) {
-                    members.set(member, members.has(member) || localPose === null
-                        ? null
-                        : composeTransforms(pose, localPose));
-                }
-            }
-        }
-        return members;
-    }
-    /** Bounds of the selected finite geometry after a rigid transform. */
-    [referenceBoundsParts](reference, transform) {
-        if (reference.bound) {
-            const frame = composeTransforms(transform, reference.transform);
-            const [x, z] = reference.bound.size;
-            return [
-                {
-                    bounds: pointBounds([-1, 1].flatMap(a => [-1, 1].map(b => composeTransforms(frame, translation([(a * x) / 2, 0, (b * z) / 2])).position))),
-                },
-            ];
-        }
-        if (reference.whole) {
-            if (this.geometry)
-                return [boundsQuery(this.geometry, transform)];
-            const context = this.assembly;
-            return this.children.flatMap(child => child[referenceBoundsParts](child.relationAnchorReference(), composeTransforms(transform, child.solvePose(context))));
-        }
-        if (reference.topology) {
-            const topology = reference.topology;
-            return [
-                boundsQuery(topology.source.requireGeometry(), composeTransforms(transform, topology.transform), topology.selection, topology.scale),
-            ];
-        }
-        if (reference.kind === 'point') {
-            const point = composeTransforms(transform, reference.transform).position;
-            return [{ bounds: [point, point] }];
-        }
-        throw new Error(`The reference ${reference.name} has no finite geometry. Select a model, vertex, edge, or surface for on().`);
-    }
-    /** Bounds of the selected finite geometry after a rigid transform. */
-    [referenceBounds](reference, transform) {
-        const bounds = this[referenceBoundsParts](reference, transform).map(part => 'bounds' in part
-            ? part.bounds
-            : evaluateSnapshotQuery(part));
-        return bounds.length === 1 ? bounds[0] : combineBounds(bounds);
-    }
-    /** Pure query collection: it never substitutes geometry or runs author code. */
-    [modelSnapshotQueries]() {
-        const result = [];
-        if (this.geometry || this.children.length) {
-            for (const direction of Object.values(boundDirections)) {
-                const transform = invertTransform(rotation(frameFromYAxis(origin, direction).quaternion));
-                for (const part of this[referenceBoundsParts](this.relationAnchorReference(), transform))
-                    if (!('bounds' in part))
-                        result.push(part);
-            }
-        }
-        if (this.geometry)
-            result.push(meshQuery(this.geometry, this.geometry.value.shape, this.meshTolerance, this.geometry.value.topology));
-        for (const region of this.operation.regions)
-            result.push(meshQuery(region.artifact, region.artifact.value, this.meshTolerance));
-        return result;
-    }
-    alignmentGeometry(reference) {
-        if (reference.kind === 'point')
-            return {
-                kind: 'point',
-                point: reference.whole
-                    ? this.requireGeometry().value.shape.asTuple()
-                    : reference.transform.position,
-            };
-        const read = (shape) => reference.kind === 'line'
-            ? edgeGeometry(shape, reference.direction ?? 1)
-            : faceGeometry(shape, reference.facing ?? reference.bound?.facing ?? 1);
-        if (reference.topology) {
-            const topology = reference.topology, geometry = topology.source.requireGeometry().value;
-            return withTopologyShape(geometry.shape, geometry.topology, topology.selection, shape => {
-                const scaled = topology.scale === 1
-                    ? shape
-                    : shapeWithScale(shape, topology.scale);
-                try {
-                    return transformGeometry(read(scaled), topology.transform);
-                }
-                finally {
-                    if (scaled !== shape)
-                        scaled.delete();
-                }
-            });
-        }
-        if (reference.whole)
-            return read(this.requireGeometry().value.shape);
-        const direction = rotateVector([
-            0,
-            reference.kind === 'line'
-                ? (reference.direction ?? 1)
-                : (reference.facing ?? reference.bound?.facing ?? 1),
-            0,
-        ], reference.transform.quaternion);
-        return reference.kind === 'line'
-            ? { kind: 'line', point: reference.transform.position, direction }
-            : { kind: 'plane', point: reference.transform.position, normal: direction };
-    }
-    relationElement(reference) {
-        const element = reference.whole
-            ? {
-                ...this.exposedElement(),
-                name: reference.name,
-                direction: reference.direction,
-                facing: reference.facing,
-            }
-            : reference;
-        const topology = element.topology;
-        let arrow;
-        if (reference.kind === 'line' && topology) {
-            const geometry = topology.source.requireGeometry().value;
-            arrow = withTopologyShape(geometry.shape, geometry.topology, topology.selection, shape => {
-                const edge = shape;
-                const position = (reference.direction ?? 1) === 1 ? 1 : 0;
-                const point = edge.pointAt(position), tangent = edge.tangentAt(position);
-                try {
-                    return topologyTransform(topology, frameFromYAxis(point.toTuple(), tangent
-                        .toTuple()
-                        .map(v => v * (reference.direction ?? 1))));
-                }
-                finally {
-                    point.delete();
-                    tangent.delete();
-                }
-            });
-        }
-        return {
-            ...snapshotElements({ [reference.name]: element })[0],
-            arrow,
-        };
-    }
-    bodyRotations(constraint, indices) {
-        return constraint.rotations.map(({ pivot, angles }) => {
-            if (pivot.kind === 'around') {
-                return pivot.axis.model
-                    ? {
-                        body: indices.get(pivot.axis.model),
-                        axis: pivot.axis.transform,
-                        angle: angles * (pivot.axis.direction ?? 1),
-                    }
-                    : {
-                        local: axisRotation(pivot.axis.transform, angles * (pivot.axis.direction ?? 1)),
-                    };
-            }
-            const frame = translation(pivot.kind === 'pivot'
-                ? pivot.point
-                : anchorReference(this.vertex(pivot.id)).transform.position);
-            return {
-                local: composeTransforms(composeTransforms(frame, rotationAround(origin, angles)), invertTransform(frame)),
-            };
-        });
-    }
-    /** @internal */
-    [relationPreview](nodeId, constraint, selection) {
-        // This expression starts from the relate receiver, before sibling constraints
-        // are returned and committed to self. Geometry and node identity stay shared.
-        const owner = this.copy({ nodeId, constraints: [...this.constraints, constraint] }, this.operation);
-        const context = ModelObject.createSolveContext([
-            owner,
-            ...(selection?.pivot.kind === 'around' && selection.pivot.axis.model
-                ? [selection.pivot.axis.model]
-                : []),
-        ]);
-        return {
-            object: {
-                nodeId,
-                compositionTransform: toTransform(owner.solvePose(context)),
-                constraints: owner.constraints.map(value => owner.constraintSnapshot(value, context)),
-            },
-            spatial: selection
-                ? owner.constraintSpatial(constraint, selection, context)
-                : undefined,
-        };
-    }
-    constraintSpatial(constraint, selection, context) {
-        const models = [...context.poses.keys()];
-        const actions = this.bodyRotations(constraint, new Map(models.map((model, i) => [model, i])));
-        const stage = actions.length - (selection.kind === 'rotate' ? 1 : 0);
-        const finalPose = this.solvePose(context);
-        let before = finalPose;
-        for (let i = actions.length - 1; i >= stage; i--) {
-            const action = actions[i];
-            before =
-                'local' in action
-                    ? composeTransforms(before, invertTransform(action.local))
-                    : composeTransforms(axisRotation(composeTransforms(models[action.body].solvePose(context), action.axis), -action.angle), before);
-        }
-        const pivot = selection.pivot;
-        let frame;
-        if (pivot.kind === 'around') {
-            frame = composeTransforms(pivot.axis.model ? pivot.axis.model.solvePose(context) : before, (pivot.axis.direction ?? 1) === 1
-                ? pivot.axis.transform
-                : composeTransforms(pivot.axis.transform, rotation([1, 0, 0, 0])));
-        }
-        else {
-            const local = translation(pivot.kind === 'pivot'
-                ? pivot.point
-                : anchorReference(this.vertex(pivot.id)).transform.position);
-            frame = composeTransforms(before, local);
-        }
-        const angles = constraint.rotations[stage]?.angles ?? origin;
-        const rotationVector = typeof angles === 'number' ? [0, angles, 0] : angles;
-        const localFrame = relativeTransform(frame, finalPose);
-        return {
-            nodeId: this.nodeId,
-            kind: selection.kind,
-            spatial: {
-                origin: localFrame.position,
-                vector: selection.kind === 'rotate'
-                    ? rotationVector
-                    : pivot.kind === 'pivot'
-                        ? pivot.point
-                        : origin,
-                frame: localFrame,
-                rotation: rotationVector,
-                axisOnly: pivot.kind === 'around',
-            },
-        };
-    }
-    /** Fix the assembly frame once, using only its direct member origins. */
-    static createAssembly(children) {
-        const context = ModelObject.createSolveContext(children);
-        const center = children.length
-            ? boundsCenter(pointBounds(children.map(child => child.solvePose(context).position)))
-            : origin;
-        return transformSolveContext(context, translation(negateVector(center)));
-    }
-    static createSolveContext(roots) {
-        const models = [];
-        const indices = new Map();
-        const collect = (model) => {
-            if (indices.has(model))
-                return;
-            indices.set(model, models.length);
-            models.push(model);
-            model.constraints.flatMap(constraintReferences).forEach(collect);
-        };
-        roots.forEach(collect);
-        const poses = solveBodies(models.map((model) => ({
-            name: model.name,
-            relations: model.constraints.map(constraint => constraint.kind === 'align'
-                ? {
-                    kind: 'align',
-                    id: constraint.id,
-                    source: {
-                        body: indices.get(constraint.source.model ?? model),
-                        geometry: (constraint.source.model ?? model).alignmentGeometry(constraint.source),
-                        transform: constraint.source.transform,
-                    },
-                    target: {
-                        body: indices.get(constraint.target.model ?? model),
-                        geometry: (constraint.target.model ?? model).alignmentGeometry(constraint.target),
-                        transform: constraint.target.transform,
-                    },
-                    offset: constraint.offset,
-                    rotations: model.bodyRotations(constraint, indices),
-                }
-                : {
-                    kind: 'on',
-                    id: constraint.id,
-                    source: {
-                        body: indices.get(constraint.source.model ?? model),
-                        key: constraint.source.name,
-                        bounds: (orientation) => (constraint.source.model ?? model)[referenceBounds](constraint.source, rotation(orientation)),
-                    },
-                    target: {
-                        body: indices.get(constraint.target.model ?? model),
-                        transform: constraint.target.transform,
-                        facing: constraint.target.bound.facing,
-                    },
-                    offset: constraint.offset,
-                    rotations: model.bodyRotations(constraint, indices),
-                }),
-        })));
-        return {
-            poses: new Map(models.map((model, index) => [model, poses[index]])),
-        };
-    }
-    constraintSnapshot(constraint, context) {
-        const source = constraint.source.model ?? this;
-        const target = constraint.target.model ?? this;
-        const models = [...context.poses.keys()];
-        const actions = this.bodyRotations(constraint, new Map(models.map((model, i) => [model, i])));
-        let before = this.solvePose(context);
-        for (const action of [...actions].reverse()) {
-            before =
-                'local' in action
-                    ? composeTransforms(before, invertTransform(action.local))
-                    : composeTransforms(axisRotation(composeTransforms(models[action.body].solvePose(context), action.axis), -action.angle), before);
-        }
-        const sourcePose = source === this ? before : source.solvePose(context);
-        const targetPose = target === this ? before : target.solvePose(context);
-        let offsetFrame = composeTransforms(targetPose, constraint.target.transform);
-        if (constraint.kind === 'align') {
-            for (const action of actions)
-                if ('body' in action)
-                    offsetFrame = composeTransforms(axisRotation(composeTransforms(models[action.body].solvePose(context), action.axis), action.angle), offsetFrame);
-            return {
-                id: constraint.id,
-                kind: 'align',
-                source: anchorSnapshot(source, constraint.source),
-                target: anchorSnapshot(target, constraint.target),
-                sourceElement: source.relationElement(constraint.source),
-                targetElement: target.relationElement(constraint.target),
-                offsetDirection: 1,
-                offset: constraint.offset ?? origin,
-                offsetFrame: toTransform(offsetFrame),
-                sourceRefs: [...valueTrace(constraint).sourceRefs],
-                parameters: [...valueTrace(constraint).parameters],
-            };
-        }
-        const orientation = composeTransforms(invertTransform(rotation(offsetFrame.quaternion)), rotation(sourcePose.quaternion)).quaternion;
-        const bounds = source[referenceBounds](constraint.source, rotation(orientation));
-        const center = [
-            (bounds[0][0] + bounds[1][0]) / 2,
-            bounds[constraint.target.bound.facing === 1 ? 0 : 1][1],
-            (bounds[0][2] + bounds[1][2]) / 2,
-        ];
-        const sourceFrame = relativeTransform({
-            position: addVectors(sourcePose.position, rotateVector(center, offsetFrame.quaternion)),
-            quaternion: offsetFrame.quaternion,
-        }, sourcePose);
-        const sourceSize = [
-            bounds[1][0] - bounds[0][0],
-            bounds[1][1] - bounds[0][1],
-            bounds[1][2] - bounds[0][2],
-        ];
-        for (const action of actions) {
-            if ('body' in action)
-                offsetFrame = composeTransforms(axisRotation(composeTransforms(models[action.body].solvePose(context), action.axis), action.angle), offsetFrame);
-        }
-        return {
-            id: constraint.id,
-            kind: constraint.kind,
-            source: anchorSnapshot(source, constraint.source),
-            target: anchorSnapshot(target, constraint.target),
-            sourceBounds: {
-                size: sourceSize,
-                transform: toTransform(composeTransforms(sourceFrame, {
-                    position: [
-                        0,
-                        (constraint.target.bound.facing * sourceSize[1]) / 2,
-                        0,
-                    ],
-                    quaternion: [0, 0, 0, 1],
-                })),
-            },
-            sourceElement: {
-                name: `${constraint.source.name}:bound`,
-                kind: 'face',
-                transform: toTransform(sourceFrame),
-                bound: {
-                    size: [sourceSize[0], sourceSize[2]],
-                    facing: constraint.target.bound.facing === 1 ? -1 : 1,
-                },
-            },
-            targetElement: {
-                name: constraint.target.name,
-                kind: 'face',
-                transform: toTransform(constraint.target.transform),
-                bound: constraint.target.bound,
-            },
-            offsetDirection: source === this ? 1 : -1,
-            offset: constraint.offset ?? origin,
-            offsetFrame: toTransform(offsetFrame),
-            sourceRefs: [...valueTrace(constraint).sourceRefs],
-            parameters: [...valueTrace(constraint).parameters],
-        };
-    }
-    requireGeometry() {
-        if (!this.geometry) {
-            throw new Error('This operation requires geometry and cannot act on a group.');
-        }
-        return this.geometry;
-    }
-    requireSolidGeometry() {
-        if (this.kind !== 'solid') {
-            throw new Error('This operation requires a solid model.');
-        }
-        return this.requireGeometry();
-    }
-    operationSnapshot(meshCache) {
-        const { kind, inputs, regions, selections } = this.operation;
-        const { siteId, execution, order, sourceRef } = operationTraces.get(this.operation) ?? {};
-        return {
-            id: storedOperationId(this.operation),
-            siteId,
-            execution,
-            kind,
-            order,
-            outputNodeId: this.nodeId,
-            inputs: inputs.map(({ model, role, index }) => ({
-                nodeId: model.nodeId,
-                role,
-                index,
-            })),
-            regions: regions.map(region => ({
-                kind: region.kind,
-                inputNodeId: region.input.nodeId,
-                frameNodeId: region.frame.nodeId,
-                mesh: renderMesh(region.artifact, region.artifact.value, meshCache, this.meshTolerance),
-            })),
-            selections: selections.map(selection => ({
-                kind: selection.kind,
-                inputNodeId: selection.input.nodeId,
-                ids: [...selection.ids],
-                transform: toTransform(selection.transform),
-            })),
-            sourceRef,
-            spatial: this.operation.spatial,
-            dimensions: this.operation.dimensions,
-        };
-    }
-    copyWithGeometry(geometry, overrides, operation) {
-        try {
-            return this.copy({ ...overrides, geometry }, operation);
-        }
-        catch (error) {
-            disposeModelGeometryValue(geometry.value);
-            throw error;
-        }
-    }
-    copy(overrides, operation) {
-        return ModelObject.create({
-            kind: this.kind,
-            geometry: this.geometry,
-            geometryAnchor: this.geometryAnchor,
-            name: this.name,
-            material: this.materialSnapshot,
-            children: this.children,
-            assembly: this.assembly,
-            constraints: this.constraints,
-            elements: this.elements,
-            sourceRefs: this.sourceRefs,
-            parameters: this.parameters,
-            meshTolerance: this.meshTolerance,
-            operation,
-            ...overrides,
-        });
-    }
-}
-export function circle(radius = 5) {
-    assertPositive('radius', radius);
-    return planarFaceModel('circle', 'Circle', [radius], () => sketchCircle(radius, { plane: 'XZ' }));
-}
-export function ellipse(xRadius = 5, zRadius = 3) {
-    assertPositive('xRadius', xRadius);
-    assertPositive('zRadius', zRadius);
-    return planarFaceModel('ellipse', 'Ellipse', [xRadius, zRadius], () => sketchEllipse(xRadius, zRadius, { plane: 'XZ' }));
-}
-export function rectangle(x = 10, z = 10) {
-    assertPositive('x', x);
-    assertPositive('z', z);
-    return planarFaceModel('rectangle', 'Rectangle', [x, z], () => sketchRectangle(x, z, { plane: 'XZ' }));
-}
-export function regularPolygon(radius = 5, sides = 6, rotation = 0) {
-    assertPositive('radius', radius);
-    if (!Number.isInteger(sides) || sides < 3) {
-        throw new Error('sides must be an integer greater than or equal to 3.');
-    }
-    if (!Number.isFinite(rotation)) {
-        throw new Error('rotation must be a finite number.');
-    }
-    return planarFaceModel('regularPolygon', `${sides}-sided polygon`, [radius, sides, rotation], () => sketchPolysides(radius, sides, 0, { plane: 'XZ' }), face => rotation === 0 ? face : face.rotate(rotation, toPoint(origin), [0, 1, 0]));
-}
-/**
- * @code3d.param x {kind: 'length', label: 'X'}
- * @code3d.param y {kind: 'length', label: 'Y'}
- * @code3d.param z {kind: 'length', label: 'Z'}
- */
-export function point([x, y, z] = origin) {
-    const position = [x, y, z];
-    assertFiniteVector('point', position);
-    const geometry = evaluateModelGeometry('point', [position], [], () => ({
-        shape: makeVertex(toPoint(position)),
-    }));
-    return ModelObject.create({
-        kind: 'vertex',
-        name: 'Point',
-        geometry,
-        geometryAnchor: { kind: 'point', transform: translation(position) },
-        operation: storedOperation('point'),
-    });
-}
-export function line(startOrEnd, end) {
-    const start = end ? startOrEnd : origin;
-    end ??= startOrEnd;
-    assertCurvePoints('line', [start, end], 2);
-    return curveModel('line', 'Line', [start, end], () => makeLine(toPoint(start), toPoint(end)));
-}
-export function arc(start, middle, end) {
-    assertCurvePoints('arc', [start, middle, end], 3);
-    return curveModel('arc', 'Arc', [start, middle, end], () => makeThreePointArc(toPoint(start), toPoint(middle), toPoint(end)));
-}
-export function bezier(points) {
-    assertCurvePoints('bezier', points, 2);
-    return curveModel('bezier', 'Bezier curve', points, () => makeBezierCurve(points.map(toPoint)));
-}
-export function spline(points) {
-    assertCurvePoints('spline', points, 2);
-    return curveModel('spline', 'Spline', points, () => makeBSplineApproximation(points.map(toPoint)));
-}
-export function loft(sections, { spine, ruled = false } = {}) {
-    if (sections.length < 2) {
-        throw new Error('loft requires at least two planar sections.');
-    }
-    const runtimeSections = sections.map(section => requireModelKind(section, 'face', 'Every loft section must be a planar face model.'));
-    const runtimeSpine = spine
-        ? requireModelKind(spine, 'edge', 'A loft spine must be a curve model.')
-        : undefined;
-    const [first, ...others] = runtimeSections;
-    return first[loftModels](others, runtimeSpine, ruled);
-}
-export function box(x = 10, y = 10, z = 10) {
-    assertPositive('x', x);
-    assertPositive('y', y);
-    assertPositive('z', z);
-    return ModelObject.create({
-        kind: 'solid',
-        name: 'Box',
-        geometry: evaluateSolidGeometry('box', [x, y, z], [], () => ({
-            shape: centeredBoxShape(x, y, z),
-        })),
-        elements: solidElements([
-            [0, -y / 2, 0],
-            [0, y / 2, 0],
-        ]),
-        operation: storedOperation('box', [], {
-            dimensions: {
-                x: { origin: [-x / 2, -y / 2, -z / 2], vector: [x, 0, 0] },
-                y: { origin: [-x / 2, -y / 2, -z / 2], vector: [0, y, 0] },
-                z: { origin: [-x / 2, -y / 2, -z / 2], vector: [0, 0, z] },
-            },
-        }),
-    });
-}
-export function cylinder(radius = 5, y = 10) {
-    assertPositive('radius', radius);
-    assertPositive('y', y);
-    return ModelObject.create({
-        kind: 'solid',
-        name: 'Cylinder',
-        geometry: evaluateSolidGeometry('cylinder', [radius, y], [], () => ({
-            shape: makeCylinder(radius, y, [0, -y / 2, 0], [0, 1, 0]),
-        })),
-        elements: solidElements([
-            [0, -y / 2, 0],
-            [0, y / 2, 0],
-        ]),
-        operation: storedOperation('cylinder'),
-    });
-}
-export function tube(outerRadius = 5, innerRadius = 3, y = 10) {
-    assertPositive('outerRadius', outerRadius);
-    assertPositive('innerRadius', innerRadius);
-    assertPositive('y', y);
-    if (innerRadius >= outerRadius) {
-        throw new Error('innerRadius must be smaller than outerRadius.');
-    }
-    return ModelObject.create({
-        kind: 'solid',
-        name: 'Tube',
-        geometry: evaluateSolidGeometry('tube', [outerRadius, innerRadius, y], [], () => {
-            const outer = sketchCircle(outerRadius, {
-                plane: 'XZ',
-                origin: [0, -y / 2, 0],
-            });
-            const inner = sketchCircle(innerRadius, {
-                plane: 'XZ',
-                origin: [0, -y / 2, 0],
-            });
-            // Hole wires run opposite to the outer boundary.
-            inner.wire.wrapped.Reverse();
-            const section = makeFace(outer.wire, [inner.wire]);
-            const direction = new Vector([0, y, 0]);
-            try {
-                return { shape: basicFaceExtrusion(section, direction) };
-            }
-            finally {
-                direction.delete();
-                section.delete();
-                inner.delete();
-                outer.delete();
-            }
-        }),
-        elements: solidElements([
-            [0, -y / 2, 0],
-            [0, y / 2, 0],
-        ]),
-        operation: storedOperation('tube'),
-    });
-}
-export function coil(coilRadius = 5, wireRadius = 1, pitch = 3, turns = 3) {
-    assertPositive('coilRadius', coilRadius);
-    assertPositive('wireRadius', wireRadius);
-    assertPositive('pitch', pitch);
-    assertPositive('turns', turns);
-    if (wireRadius >= coilRadius) {
-        throw new Error('wireRadius must be smaller than coilRadius.');
-    }
-    if (pitch <= 2 * wireRadius) {
-        throw new Error('pitch must be greater than the wire diameter.');
-    }
-    assertCoilClearance(coilRadius, wireRadius, pitch, turns);
-    const y = pitch * turns;
-    assertPositive('pitch * turns', y);
-    const geometry = evaluateSolidGeometry('coil', [coilRadius, wireRadius, pitch, turns], [], () => {
-        const spine = makeHelix(pitch, y, coilRadius, [0, -y / 2, 0], [0, 1, 0]);
-        const start = spine.pointAt(0);
-        const tangent = spine.tangentAt(0);
-        const circle = makeCircle(wireRadius, start, tangent);
-        const section = assembleWire([circle]);
-        try {
-            return { shape: genericSweep(section, spine, { frenet: true }) };
-        }
-        finally {
-            section.delete();
-            circle.delete();
-            tangent.delete();
-            start.delete();
-            spine.delete();
-        }
-    });
-    // A fractional turn has asymmetric X/Z bounds, but its axis is still Y.
-    // The circular end sections extend beyond the centerline's Y interval.
-    const circumference = 2 * Math.PI * coilRadius;
-    const halfHeight = y / 2 + wireRadius * (circumference / Math.hypot(circumference, pitch));
-    return ModelObject.create({
-        kind: 'solid',
-        name: 'Coil',
-        geometry,
-        elements: solidElements([
-            [0, -halfHeight, 0],
-            [0, halfHeight, 0],
-        ]),
-        operation: storedOperation('coil'),
-    });
-}
-function assertCoilClearance(radius, wireRadius, pitch, turns) {
-    // Neighboring turns approach obliquely: pitch alone overestimates clearance.
-    // For angular separation t, squared centerline distance is
-    // 2 R² (1 - cos(t)) + (pitch * t / 2π)². Its only possible minimum
-    // between half a turn and a full turn lies after the derivative's minimum.
-    // Beyond a full turn, the Y separation already exceeds the wire diameter.
-    if (turns <= 0.5)
-        return;
-    const fullTurn = 2 * Math.PI;
-    const slopeSquared = (pitch / (fullTurn * radius)) ** 2;
-    if (slopeSquared >= 1)
-        return;
-    let lower = fullTurn - Math.acos(-slopeSquared);
-    if (Math.sin(lower) + slopeSquared * lower >= 0)
-        return;
-    let upper = fullTurn;
-    for (let iteration = 0; iteration < 48; iteration += 1) {
-        const middle = (lower + upper) / 2;
-        if (Math.sin(middle) + slopeSquared * middle < 0)
-            lower = middle;
-        else
-            upper = middle;
-    }
-    const separation = Math.min(fullTurn * turns, (lower + upper) / 2);
-    const distance = Math.hypot(2 * radius * Math.sin(separation / 2), (pitch * separation) / fullTurn);
-    if (distance <= 2 * wireRadius) {
-        throw new Error('Coil turns must not touch or overlap; increase pitch or decrease wireRadius.');
-    }
-}
-export function sphere(radius = 5) {
-    assertPositive('radius', radius);
-    return ModelObject.create({
-        kind: 'solid',
-        name: 'Sphere',
-        geometry: evaluateSolidGeometry('sphere', [radius], [], () => ({
-            shape: makeSphere(radius),
-        })),
-        elements: solidElements([
-            [0, -radius, 0],
-            [0, radius, 0],
-        ]),
-        operation: storedOperation('sphere'),
-    });
-}
-export function frustum(bottomRadius = 5, topRadius = 3, y = 10) {
-    assertPositive('bottomRadius', bottomRadius);
-    assertPositive('topRadius', topRadius);
-    assertPositive('y', y);
-    return ModelObject.create({
-        kind: 'solid',
-        name: 'Frustum',
-        geometry: evaluateSolidGeometry('frustum', [bottomRadius, topRadius, y], [], () => {
-            const bottom = sketchCircle(bottomRadius, {
-                plane: 'XZ',
-                origin: [0, -y / 2, 0],
-            });
-            const top = sketchCircle(topRadius, {
-                plane: 'XZ',
-                origin: [0, y / 2, 0],
-            });
-            return { shape: bottom.loftWith(top, { ruled: true }) };
-        }),
-        elements: solidElements([
-            [0, -y / 2, 0],
-            [0, y / 2, 0],
-        ]),
-        operation: storedOperation('frustum'),
-    });
-}
-export function regularPrism(radius = 5, y = 10, sides = 6, rotation = 0) {
-    assertPositive('radius', radius);
-    assertPositive('y', y);
-    if (!Number.isInteger(sides) || sides < 3) {
-        throw new Error('sides must be an integer greater than or equal to 3.');
-    }
-    if (!Number.isFinite(rotation)) {
-        throw new Error('rotation must be a finite number.');
-    }
-    return ModelObject.create({
-        kind: 'solid',
-        name: `${sides}-sided prism`,
-        geometry: evaluateSolidGeometry('regular-prism', [radius, y, sides, rotation], [], () => {
-            const sketch = sketchPolysides(radius, sides, 0, {
-                plane: 'XZ',
-                origin: [0, -y / 2, 0],
-            });
-            let shape = sketch.extrude(y, {
-                extrusionDirection: [0, 1, 0],
-            });
-            if (rotation !== 0) {
-                shape = shape.rotate(rotation, [0, 0, 0], [0, 1, 0]);
-            }
-            return { shape };
-        }),
-        elements: solidElements([
-            [0, -y / 2, 0],
-            [0, y / 2, 0],
-        ]),
-        operation: storedOperation('regularPrism'),
-    });
-}
-/** @internal */
-export function modelFromReplicadSolid(shape) {
-    let solid;
-    try {
-        solid = normalizeReplicadSolid(shape);
-    }
-    catch (error) {
-        shape.delete();
-        throw error;
-    }
-    // The builder still executes on every call. Cache its actual output, not its
-    // arguments: captured state may change the geometry between invocations.
-    let adopted = false;
-    let geometry;
-    try {
-        geometry = evaluateSolidGeometry('replicad-solid', [solid.serialize()], [], () => {
-            adopted = true;
-            return { shape: solid };
-        });
-    }
-    finally {
-        // A hit returns an independently owned cached copy; discard this output.
-        // A miss transfers ownership to evaluateSolidGeometry, including on error.
-        if (!adopted)
-            solid.delete();
-    }
-    return ModelObject.create({
-        kind: 'solid',
-        name: 'Custom primitive',
-        geometry,
-        operation: storedOperation('primitive'),
-    });
-}
-function normalizeReplicadSolid(shape) {
-    const oc = getOC();
-    const type = shape.wrapped.ShapeType();
-    if (type === oc.TopAbs_ShapeEnum.TopAbs_SOLID)
-        return shape;
-    if (type !== oc.TopAbs_ShapeEnum.TopAbs_COMPSOLID &&
-        type !== oc.TopAbs_ShapeEnum.TopAbs_COMPOUND) {
-        throw new Error('A primitive builder must return exactly one OpenCascade solid.');
-    }
-    const containmentLayers = [
-        [oc.TopAbs_ShapeEnum.TopAbs_SHELL, oc.TopAbs_ShapeEnum.TopAbs_SOLID],
-        [oc.TopAbs_ShapeEnum.TopAbs_FACE, oc.TopAbs_ShapeEnum.TopAbs_SHELL],
-        [oc.TopAbs_ShapeEnum.TopAbs_WIRE, oc.TopAbs_ShapeEnum.TopAbs_FACE],
-        [oc.TopAbs_ShapeEnum.TopAbs_EDGE, oc.TopAbs_ShapeEnum.TopAbs_WIRE],
-        [oc.TopAbs_ShapeEnum.TopAbs_VERTEX, oc.TopAbs_ShapeEnum.TopAbs_EDGE],
-    ];
-    for (const [find, avoid] of containmentLayers) {
-        const outsideSolid = new oc.TopExp_Explorer(shape.wrapped, find, avoid);
-        try {
-            if (outsideSolid.More()) {
-                throw new Error('A primitive builder must return exactly one OpenCascade solid.');
-            }
-        }
-        finally {
-            outsideSolid.delete();
-        }
-    }
-    const solids = new oc.TopExp_Explorer(shape.wrapped, oc.TopAbs_ShapeEnum.TopAbs_SOLID);
-    let solid;
-    try {
-        if (!solids.More()) {
-            throw new Error('A primitive builder must return exactly one OpenCascade solid.');
-        }
-        solid = castOwnedShape3D(solids.Current());
-        solids.Next();
-        if (solids.More()) {
-            solid.delete();
-            solid = undefined;
-            throw new Error('A primitive builder must return exactly one OpenCascade solid.');
-        }
-    }
-    finally {
-        solids.delete();
-    }
-    shape.delete();
-    return solid;
-}
-export function group(children, name = 'Group') {
-    const runtimeChildren = children.map(child => requireModelObject(child, 'Every group child must be a model.'));
-    return ModelObject.create({
-        kind: 'group',
-        name,
-        children: runtimeChildren,
-        operation: storedOperation('group', runtimeChildren.map((model, index) => ({
-            model,
-            role: 'child',
-            index,
-        }))),
-    });
-}
-export function union(operands) {
-    const { first, others } = booleanOperands('union', operands);
-    return first[combineModels]('fuse', others);
-}
-/**
- * Extrudes a single face; use faces.map(face => extrude(face, distance)) for multiple regions.
- * @code3d.param distance {kind: 'length', label: 'Extrusion distance'}
- */
-export function extrude(face, distance) {
-    return requireModelKind(face, 'face', 'extrude requires a single face model.').extrude(distance);
-}
-export function cut(stock, tools) {
-    const runtimeStock = requireModelKind(stock, 'solid', 'The cut stock must be a solid model.');
-    if (tools.length === 0) {
-        throw new Error('cut requires at least one tool.');
-    }
-    const runtimeTools = tools.map(tool => requireModelKind(tool, 'solid', 'Every cut tool must be a solid model.'));
-    return runtimeStock[combineModels]('cut', runtimeTools);
-}
-export function intersect(operands) {
-    const { first, others } = booleanOperands('intersect', operands);
-    return first[combineModels]('intersect', others);
-}
-export function isModelObject(value) {
-    return value instanceof ModelObject;
-}
-export function isConstraint(value) {
-    return value instanceof Constraint;
-}
-export function isConstraintExpression(value) {
-    return value instanceof ConstraintExpression;
-}
-export function constraintPreview(value) {
-    return value.preview();
-}
-export function instrumentConstraint(constraint, sourceRef, parameters) {
-    constraint.attachSource(sourceRef);
-    constraint.attachParameters(parameters);
-}
-export function instrumentModelOperation(object, instrumentation) {
-    object.attachSource(instrumentation.sourceRef);
-    object.attachParameters(instrumentation.parameters);
-    object.attachOperationTrace(instrumentation.siteId, instrumentation.execution, instrumentation.order, instrumentation.sourceRef);
-}
-export function constraintTraceReference(constraint) {
-    return constraint.traceReference();
-}
-export function modelObjectRuntimeInfo(object) {
-    return {
-        nodeId: object.nodeId,
-        name: object.name,
-        sourceRefs: object.sourceRefs,
-    };
-}
-export function relatedModelObjects(object) {
-    return object.relatedObjects();
-}
-function boundsQuery(geometry, transform, selection = { kind: 'solid' }, scale = 1) {
-    return {
-        inputId: geometry.id,
-        geometry: { shape: geometry.value.shape, topology: geometry.value.topology },
-        query: {
-            kind: 'bounds',
-            transform,
-            selection,
-            scale,
-            key: kernelOperationKey('transformed-bounds', [
-                transform.position,
-                transform.quaternion,
-                selection.kind,
-                selection.kind === 'solid' ? null : selection.id,
-                scale,
-            ], [geometry]),
-        },
-    };
-}
-function meshQuery(artifact, shape, tolerance, topology) {
-    return {
-        inputId: artifact.id,
-        geometry: { shape, topology },
-        query: {
-            kind: 'mesh',
-            tolerance,
-            topology: topology !== undefined,
-            key: kernelOperationKey('render-mesh', [tolerance, 0.2, topology !== undefined], [artifact]),
-        },
-    };
-}
-const queryLifecycle = {
-    estimateBytes: estimateRetainedBytes,
-    retain: value => value,
-    instantiate: value => value,
-    release: () => { },
-};
-function computeSnapshotQuery(geometry, query) {
-    return query.kind === 'bounds'
-        ? computeTransformedBounds(geometry, query)
-        : computeRenderMesh(geometry.shape, query.tolerance, query.topology ? geometry.topology : undefined);
-}
-function evaluateSnapshotQuery(input) {
-    const cached = findKernelOperation(input.query.key, queryLifecycle);
-    if (cached)
-        return cached.value;
-    let value;
-    if (input.query.kind === 'mesh') {
-        // Mesh from the serialized input in every execution mode. BinTools can
-        // renormalize a plane axis by a few ULPs, changing Delaunay diagonal ties.
-        // A local query and a remote query must therefore consume the same BREP.
-        executeSnapshotQueryBatch(input.inputId, encodeKernelArtifact(input.inputId, input.geometry), [input.query], () => { }, (_, result) => {
-            value = result;
-        });
-    }
-    else
-        value = computeSnapshotQuery(input.geometry, input.query);
-    acceptKernelOperation(input.query.key, queryLifecycle, value);
-    return value;
-}
-export function planModelSnapshotQueries(objects) {
-    const visited = new Set();
-    const keys = new Map();
-    const batches = new Map();
-    function collect(object) {
-        if (visited.has(object))
-            return;
-        visited.add(object);
-        for (const input of object[modelSnapshotQueries]()) {
-            const { query, inputId } = input;
-            const signature = keys.get(query.key.id);
-            if (signature) {
-                if (signature !== query.key.signature)
-                    throw new Error(`Kernel operation cache identity collision: ${query.key.id}`);
-                continue;
-            }
-            keys.set(query.key.id, query.key.signature);
-            if (findKernelOperation(query.key, queryLifecycle))
-                continue;
-            let batch = batches.get(inputId);
-            if (!batch) {
-                batch = { input, queries: [], sourceRef: object.sourceRefs.at(-1) };
-                batches.set(inputId, batch);
-            }
-            batch.queries.push(query);
-        }
-        object.children.forEach(collect);
-    }
-    objects.forEach(collect);
-    return [...batches].map(([id, { input, queries, sourceRef }]) => ({
-        id,
-        queries,
-        sourceRef,
-        weight: (1 +
-            (input.geometry.topology?.edges.ids.length ?? 0) +
-            (input.geometry.topology?.surfaces.ids.length ?? 0)) *
-            queries.length,
-        encode: () => encodeKernelArtifact(id, input.geometry),
-        accept: (query, value) => acceptKernelOperation(query.key, queryLifecycle, value),
-    }));
-}
-/** Each batch owns its restored shape; completed results leave before cancellation checks. */
-export function executeSnapshotQueryBatch(id, bytes, queries, checkCancelled, onResult, onRestore) {
-    const started = performance.now();
-    const geometry = decodeKernelArtifact(bytes, id);
-    try {
-        onRestore?.(performance.now() - started);
-        for (const query of queries) {
-            checkCancelled();
-            onResult(query, computeSnapshotQuery(geometry, query));
-        }
-    }
-    finally {
-        geometry.shape.delete();
-    }
-}
-export function createModelSnapshotter() {
-    const meshCache = new Map();
-    return object => object.toSnapshot(meshCache);
-}
-export function disposeModelObjects(objects) {
-    const disposed = new Set();
-    for (const object of objects) {
-        object.disposeShape(disposed);
-    }
-}
-export function retainModelGeometry(objects) {
-    const retained = new Map();
-    const shapes = new Map();
-    const topologies = new Map();
-    const dispose = () => {
-        for (const shape of retained.values())
-            shape.delete();
-        retained.clear();
-        shapes.clear();
-        topologies.clear();
-    };
-    try {
-        for (const object of objects) {
-            const geometry = object[modelGeometry]()?.value;
-            const original = geometry?.shape;
-            if (!original)
-                continue;
-            let shape = retained.get(original);
-            if (!shape) {
-                shape = original.clone();
-                retained.set(original, shape);
-            }
-            shapes.set(object.nodeId, shape);
-            topologies.set(object.nodeId, geometry.topology);
-        }
-        return {
-            shapes,
-            dispose,
-            inspect(nodeId, options) {
-                const shape = shapes.get(nodeId);
-                const topology = topologies.get(nodeId);
-                if (!shape || !topology)
-                    throw new Error('The model geometry snapshot is unavailable.');
-                return inspectShapeTopology(shape, topology, options);
-            },
-        };
-    }
-    catch (error) {
-        dispose();
-        throw error;
-    }
-}
-export const authoringApi = Object.freeze({
-    sketch,
-    circle,
-    ellipse,
-    extrude,
-    rectangle,
-    regularPolygon,
-    point,
-    line,
-    arc,
-    bezier,
-    spline,
-    loft,
-    box,
-    cylinder,
-    tube,
-    coil,
-    sphere,
-    frustum,
-    regularPrism,
-    group,
-    union,
-    cut,
-    intersect,
-});
-function storedOperation(kind, inputs = [], options = {}) {
-    return {
-        runtimeId: `operation-${nextOperationId++}`,
-        kind,
-        inputs: [...inputs],
-        regions: [...(options.regions ?? [])],
-        selections: [...(options.selections ?? [])],
-        dimensions: options.dimensions,
-    };
-}
-function storedOperationId(operation) {
-    const trace = operationTraces.get(operation);
-    return trace
-        ? `${trace.siteId}:execution:${trace.execution}`
-        : operation.runtimeId;
-}
-const shapeLifecycle = {
-    estimateBytes: () => 64,
-    retain: shape => shape.clone(),
-    instantiate: shape => shape.clone(),
-    release: shape => shape.delete(),
-};
-const modelGeometryLifecycle = {
-    estimateBytes: geometry => 128 +
-        estimateRetainedBytes([
-            geometry.topology,
-            geometry.localBounds,
-            geometry.referenceBasis?.topology,
-            geometry.referenceBasis?.transform,
-        ]),
-    retain: cloneModelGeometryValue,
-    instantiate: cloneModelGeometryValue,
-    release: disposeModelGeometryValue,
-};
-function cloneModelGeometryValue(geometry) {
-    return {
-        ...geometry,
-        shape: geometry.shape.clone(),
-        referenceBasis: geometry.referenceBasis
-            ? {
-                ...geometry.referenceBasis,
-                shape: geometry.referenceBasis.shape.clone(),
-            }
-            : undefined,
-    };
-}
-function disposeModelGeometryValue(geometry) {
-    geometry.shape.delete();
-    geometry.referenceBasis?.shape.delete();
-}
-function evaluateKernelShape(operation, arguments_, inputs, compute) {
-    return evaluateKernelOperation(operation, arguments_, inputs, shapeLifecycle, compute);
-}
-function evaluateModelGeometry(operation, arguments_, inputs, compute) {
-    return evaluateKernelOperation(operation, arguments_, inputs, modelGeometryLifecycle, () => {
-        const result = compute();
-        return {
-            ...createModelGeometryValue(result.shape, result.topology),
-            referenceBasis: result.referenceBasis,
-        };
-    });
-}
-function createModelGeometryValue(shape, topology) {
-    try {
-        return {
-            shape,
-            topology: topology ?? initialShapeTopology(shape),
-            localBounds: shapeBounds(shape),
-        };
-    }
-    catch (error) {
-        shape.delete();
-        throw error;
-    }
-}
-function evaluateSolidGeometry(operation, arguments_, inputs, compute) {
-    return evaluateModelGeometry(operation, arguments_, inputs, compute);
-}
-function renderMesh(artifact, shape, cache, tolerance, topology) {
-    const cached = cache.get(shape);
-    if (cached) {
-        return cached;
-    }
-    const mesh = evaluateSnapshotQuery(meshQuery(artifact, shape, tolerance, topology));
-    cache.set(shape, mesh);
-    return mesh;
-}
-function computeRenderMesh(shape, tolerance, topology) {
-    const surface = shape.mesh({ tolerance, angularTolerance: 0.2 });
-    const wire = shape.meshEdges({ tolerance, angularTolerance: 0.2 });
-    const vertexData = topology
-        ? stableVertexData(shape, topology.vertices)
-        : { positions: new Float32Array(), ids: [] };
-    return {
-        vertices: new Float32Array(surface.vertices),
-        normals: new Float32Array(surface.normals),
-        uvs: meshUVs(shape, surface.vertices.length / 3),
-        triangles: new Uint32Array(surface.triangles),
-        edges: new Float32Array(wire.lines),
-        topologyVertices: vertexData.positions,
-        vertexIds: vertexData.ids,
-        surfaceGroups: topology
-            ? stableSurfaceGroups(shape, topology.surfaces, surface.faceGroups)
-            : surface.faceGroups.map((group, index) => ({
-                start: group.start,
-                count: group.count,
-                surfaceId: index + 1,
-            })),
-        edgeGroups: topology
-            ? stableEdgeGroups(shape, topology.edges, wire.edgeGroups)
-            : wire.edgeGroups.map((group, index) => ({
-                start: group.start,
-                count: group.count,
-                // Context-region edges have their own traversal namespace, just
-                // like the surfaces above. Native handle hashes change on restore.
-                edgeId: index + 1,
-            })),
-    };
-}
-function meshUVs(shape, vertexCount) {
-    if (!vertexCount)
-        return undefined;
-    const faces = shape.faces;
-    const location = new (getOC().TopLoc_Location)();
-    const uvs = new Float32Array(vertexCount * 2);
-    let offset = 0;
-    try {
-        // Match the native mesh extractor's face/node traversal exactly.
-        for (const face of faces) {
-            const triangulation = getOC().BRep_Tool.Triangulation(face.wrapped, location, 0);
-            try {
-                if (triangulation.isNull())
-                    continue;
-                if (!triangulation.HasUVNodes())
-                    return undefined;
-                const count = triangulation.NbNodes();
-                let minU = Infinity, minV = Infinity, maxU = -Infinity, maxV = -Infinity;
-                for (let index = 0; index < count; index++) {
-                    const uv = triangulation.UVNode(index + 1);
-                    try {
-                        const u = uv.X(), v = uv.Y();
-                        uvs[(offset + index) * 2] = u;
-                        uvs[(offset + index) * 2 + 1] = v;
-                        minU = Math.min(minU, u);
-                        maxU = Math.max(maxU, u);
-                        minV = Math.min(minV, v);
-                        maxV = Math.max(maxV, v);
-                    }
-                    finally {
-                        uv.delete();
-                    }
-                }
-                for (let index = 0; index < count; index++) {
-                    const base = (offset + index) * 2;
-                    uvs[base] = maxU === minU ? 0 : (uvs[base] - minU) / (maxU - minU);
-                    uvs[base + 1] =
-                        maxV === minV ? 0 : (uvs[base + 1] - minV) / (maxV - minV);
-                }
-                offset += count;
-            }
-            finally {
-                triangulation.delete();
-            }
-        }
-        return uvs;
-    }
-    finally {
-        location.delete();
-        faces.forEach(face => face.delete());
-    }
-}
-/** Internal bridge from the kernel-independent sketch definition to model geometry. */
-export function sketchFaceModel(region) {
-    const curves = [region.outer, ...region.holes].map(loop => loop.map(curve => curve.kind === 'line'
-        ? ['line', curve.points]
-        : curve.kind === 'circle'
-            ? ['circle', curve.center, curve.radius]
-            : ['arc', curve.center, curve.radius, curve.start, curve.sweep]));
-    const geometry = evaluateModelGeometry('sketchFace', curves, [], () => ({
-        shape: sketchRegionFace(region),
-    }));
-    const plane = {
-        kind: 'face',
-        transform: identityRigidTransform,
-    };
-    return ModelObject.create({
-        kind: 'face',
-        name: 'Sketch face',
-        geometry,
-        geometryAnchor: plane,
-        elements: { plane },
-        operation: storedOperation('sketchFace'),
-    });
-}
-function planarFaceModel(operation, name, arguments_, buildSketch, transform) {
-    const geometry = evaluateModelGeometry(operation, arguments_, [], () => {
-        const sketch = buildSketch();
-        try {
-            const face = sketch.face();
-            return { shape: transform?.(face) ?? face };
-        }
-        finally {
-            sketch.delete();
-        }
-    });
-    const plane = {
-        kind: 'face',
-        transform: identityRigidTransform,
-    };
-    return ModelObject.create({
-        kind: 'face',
-        name,
-        geometry,
-        geometryAnchor: plane,
-        elements: {
-            plane,
-        },
-        operation: storedOperation(operation),
-    });
-}
-function curveModel(operation, name, arguments_, build) {
-    const geometry = evaluateModelGeometry(operation, arguments_, [], () => ({
-        shape: build(),
-    }));
-    const elements = curveElements(geometry.value.shape);
-    return ModelObject.create({
-        kind: 'edge',
-        name,
-        geometry,
-        geometryAnchor: { ...elements.start, kind: 'line' },
-        elements,
-        operation: storedOperation(operation),
-    });
-}
-function curveElements(curve) {
-    return {
-        start: curveAnchor(curve, 0),
-        midpoint: curveAnchor(curve, 0.5),
-        end: curveAnchor(curve, 1),
-    };
-}
-function curveAnchor(curve, position) {
-    const point = curve.pointAt(position);
-    const tangent = curve.tangentAt(position);
-    try {
-        return {
-            kind: 'point',
-            transform: frameFromYAxis(point.toTuple(), tangent.toTuple()),
-        };
-    }
-    finally {
-        point.delete();
-        tangent.delete();
-    }
-}
-function buildLoftGeometry(sections, spine, ruled) {
-    const inputs = [];
-    let spineWire;
-    try {
-        for (const [index, section] of sections.entries()) {
-            inputs.push({
-                shape: shapeWithTransform(section.geometry.value.shape, section.transform),
-                topology: section.geometry.value.topology,
-                index: index + 1,
-            });
-        }
-        if (spine) {
-            const edge = shapeWithTransform(spine.geometry.value.shape, spine.transform);
-            try {
-                spineWire = assembleWire([edge]);
-            }
-            finally {
-                edge.delete();
-            }
-        }
-        return loftWithTopology(inputs, spineWire, ruled);
-    }
-    finally {
-        inputs.forEach(input => input.shape.delete());
-        spineWire?.delete();
-    }
-}
-function shapeBounds(shape) {
-    const boundingBox = new BoundingBox();
-    try {
-        // Use analytic geometry, independent of whether a viewport has meshed it.
-        getOC().BRepBndLib.AddOptimal(shape.wrapped, boundingBox.wrapped, false, false);
-        const [minimum, maximum] = boundingBox.bounds;
-        return [
-            [minimum[0], minimum[1], minimum[2]],
-            [maximum[0], maximum[1], maximum[2]],
-        ];
-    }
-    finally {
-        boundingBox.delete();
-    }
-}
-function boundsCenter(bounds) {
-    const [[minX, minY, minZ], [maxX, maxY, maxZ]] = bounds;
-    return [(minX + maxX) / 2, (minY + maxY) / 2, (minZ + maxZ) / 2];
-}
-function solidElements(bounds) {
-    return { axis: { kind: 'line', transform: translation(boundsCenter(bounds)) } };
-}
-function constraintReferences(constraint) {
-    return [
-        constraint.source.model,
-        constraint.target.model,
-        ...constraint.rotations.map(action => action.pivot.kind === 'around' ? action.pivot.axis.model : undefined),
-    ].filter((model) => !!model);
-}
-function computeTransformedBounds(geometry, query) {
-    const { transform, selection, scale } = query;
-    return withTopologyShape(geometry.shape, geometry.topology, selection, shape => {
-        const scaled = scale === 1 ? shape : shapeWithScale(shape, scale);
-        try {
-            const moved = shapeWithTransform(scaled, transform);
-            try {
-                return shapeBounds(moved);
-            }
-            finally {
-                moved.delete();
-            }
-        }
-        finally {
-            if (scaled !== shape)
-                scaled.delete();
-        }
-    });
-}
-function pointBounds(points) {
-    if (!points.length)
-        throw new Error('Empty geometry has no directional bounds.');
-    return [
-        [0, 1, 2].map(axis => Math.min(...points.map(point => point[axis]))),
-        [0, 1, 2].map(axis => Math.max(...points.map(point => point[axis]))),
-    ];
-}
-function combineBounds(bounds) {
-    return pointBounds(bounds.flat());
-}
-const boundDirections = {
-    up: [0, 1, 0],
-    down: [0, -1, 0],
-    left: [-1, 0, 0],
-    right: [1, 0, 0],
-    front: [0, 0, 1],
-    back: [0, 0, -1],
-};
-function directionalBound(reference, direction) {
-    const quaternion = frameFromYAxis(origin, boundDirections[direction]).quaternion;
-    const bounds = reference.model[referenceBounds](reference, invertTransform(rotation(quaternion)));
-    const center = [
-        (bounds[0][0] + bounds[1][0]) / 2,
-        bounds[1][1],
-        (bounds[0][2] + bounds[1][2]) / 2,
-    ];
-    return modelAnchor(reference.model, reference.whole ? direction : `${reference.name}.${direction}`, {
-        kind: 'face',
-        transform: composeTransforms(rotation(quaternion), translation(center)),
-        bound: {
-            size: [bounds[1][0] - bounds[0][0], bounds[1][2] - bounds[0][2]],
-            facing: 1,
-        },
-    });
-}
-function modelAnchor(model, name, element) {
-    const reference = { ...element, model, name };
-    return (element.topology
-        ? new ModelTopologyElement(reference)
-        : new ModelAnchor(reference));
-}
-function snapshotElements(elements, prefix = '') {
-    return Object.entries(elements).flatMap(([key, element]) => {
-        const name = `${prefix}${key}`;
-        const topology = element.topology;
-        return [
-            {
-                name,
-                kind: element.kind,
-                transform: toTransform(element.transform),
-                bound: element.bound,
-                facing: element.facing,
-                direction: element.direction,
-                topology: topology
-                    ? {
-                        geometryNodeId: topology.source.nodeId,
-                        transform: {
-                            ...topology.transform,
-                            scale: [topology.scale, topology.scale, topology.scale],
-                        },
-                        ...topology.selection,
-                    }
-                    : undefined,
-            },
-            ...snapshotElements(element.members ?? {}, `${name}.`),
-        ];
-    });
-}
-function scaleElements(elements, factor) {
-    return Object.fromEntries(Object.entries(elements).map(([name, element]) => [
-        name,
-        scaleElement(element, factor),
-    ]));
-}
-function transformElement(element, transform) {
-    return {
-        ...element,
-        transform: composeTransforms(transform, element.transform),
-        topology: element.topology
-            ? {
-                ...element.topology,
-                transform: composeTransforms(transform, element.topology.transform),
-            }
-            : undefined,
-        members: element.members
-            ? Object.fromEntries(Object.entries(element.members).map(([name, member]) => [
-                name,
-                transformElement(member, transform),
-            ]))
-            : undefined,
-    };
-}
-function scaleElement(element, factor) {
-    return {
-        ...element,
-        bound: element.bound
-            ? {
-                ...element.bound,
-                size: [
-                    element.bound.size[0] * factor,
-                    element.bound.size[1] * factor,
-                ],
-            }
-            : undefined,
-        topology: element.topology
-            ? {
-                ...element.topology,
-                scale: element.topology.scale * factor,
-                transform: scaleFrame(element.topology.transform, factor),
-            }
-            : undefined,
-        members: element.members
-            ? scaleElements(element.members, factor)
-            : undefined,
-        transform: {
-            ...element.transform,
-            position: [
-                element.transform.position[0] * factor,
-                element.transform.position[1] * factor,
-                element.transform.position[2] * factor,
-            ],
-        },
-    };
-}
-function scaleFrame(transform, factor) {
-    return {
-        ...transform,
-        position: transform.position.map(value => value * factor),
-    };
-}
-function topologyTransform(topology, frame) {
-    return composeTransforms(topology.transform, scaleFrame(frame, topology.scale));
-}
-function topologyCenter(geometry, selection) {
-    const { referenceBasis, shape, topology } = geometry.value;
-    if (referenceBasis)
-        return withTopologyShape(referenceBasis.shape, referenceBasis.topology, selection, selected => topologyTransform(referenceBasis, translation(boundsCenter(shapeBounds(selected)))));
-    return withTopologyShape(shape, topology, selection, selected => translation(boundsCenter(shapeBounds(selected))));
-}
-function transformedReferenceBasis(source, transform, scale) {
-    const basis = source.value.referenceBasis;
-    return {
-        shape: (basis?.shape ?? source.value.shape).clone(),
-        topology: basis?.topology ?? source.value.topology,
-        transform: composeTransforms(transform, scaleFrame(basis?.transform ?? identityRigidTransform, scale)),
-        scale: (basis?.scale ?? 1) * scale,
-    };
-}
-function topologyName(selection) {
-    return selection.kind === 'solid'
-        ? 'solid'
-        : formatTopologyId(selection.kind, selection.id);
-}
-function topologyReferences(model, prefix, context, kind, ids) {
-    const geometry = context.source[modelGeometry]().value;
-    const basis = geometry.referenceBasis;
-    const { shape, topology } = basis ?? geometry;
-    const frames = kind === 'vertex'
-        ? topologyVertexPoints(shape, topology.vertices, ids).map(point => translation(point.position))
-        : (kind === 'edge'
-            ? topologyEdgeDirections(shape, topology.edges, ids)
-            : topologySurfaceDirections(shape, topology.surfaces, ids)).map(({ position, direction }) => frameFromYAxis(position, direction));
-    return ids.map((id, index) => {
-        const selection = { kind, id };
-        return new ModelTopologyElement({
-            model,
-            name: `${prefix}${topologyName(selection)}`,
-            kind: topologyElementKinds[kind],
-            transform: topologyTransform(context, basis ? topologyTransform(basis, frames[index]) : frames[index]),
-            topology: { ...context, selection },
-        });
-    });
-}
-function unionSectionShape(left, right) {
-    const section = new (getOC().BRepAlgoAPI_Section)(left.wrapped, right.wrapped, false);
-    try {
-        section.Build();
-        const sectionShape = castOwnedShape(section.Shape());
-        const edges = shapeSubshapes(sectionShape, 'edge');
-        if (edges.length === 0) {
-            return sectionShape;
-        }
-        let wire;
-        try {
-            wire = assembleWire(edges);
-            const face = makeFace(wire);
-            sectionShape.delete();
-            return face;
-        }
-        catch {
-            return sectionShape;
-        }
-        finally {
-            edges.forEach(edge => edge.delete());
-            wire?.delete();
-        }
-    }
-    finally {
-        section.delete();
-    }
-}
-function boundReference(target) {
-    const reference = target instanceof ModelAnchor ? target[anchorReferenceValue] : undefined;
-    if (!reference?.bound)
-        throw new Error('on() requires a directional bound: up, down, left, right, front, or back.');
-    return reference;
-}
-function anchorReference(anchor) {
-    if (anchor instanceof ModelObject) {
-        return anchor.relationAnchorReference();
-    }
-    return anchor[anchorReferenceValue];
-}
-function anchorSnapshot(modelOrReference, stored) {
-    const model = stored ? modelOrReference : undefined;
-    const reference = stored ?? modelOrReference;
-    return {
-        nodeId: (model ?? modelOrReference.model).nodeId,
-        name: reference.name,
-        kind: reference.kind,
-    };
-}
-function uniqueModels(models) {
-    return [...new Set(models)];
-}
-function toTransform(transform) {
-    return { ...transform, scale: unitScale };
-}
-function shapeWithTransform(source, transform) {
-    const oc = getOC();
-    let shape = source.clone();
-    const { axis, angleDegrees } = quaternionAxisAngle(transform.quaternion);
-    try {
-        if (Math.abs(angleDegrees) > 1e-9) {
-            const rotated = transformShape(shape, value => {
-                const point = new oc.gp_Pnt(0, 0, 0);
-                const direction = new oc.gp_Dir(...axis);
-                const rotationAxis = new oc.gp_Ax1(point, direction);
-                try {
-                    value.SetRotation(rotationAxis, angleDegrees * (Math.PI / 180));
-                }
-                finally {
-                    rotationAxis.delete();
-                    direction.delete();
-                    point.delete();
-                }
-            });
-            shape.delete();
-            shape = rotated;
-        }
-        return transformShape(shape, value => {
-            const vector = new oc.gp_Vec(...transform.position);
-            try {
-                value.SetTranslation(vector);
-            }
-            finally {
-                vector.delete();
-            }
-        });
-    }
-    finally {
-        shape.delete();
-    }
-}
-function shapeWithScale(source, scale) {
-    return transformShape(source, value => {
-        const point = new (getOC().gp_Pnt)(0, 0, 0);
-        try {
-            value.SetScale(point, scale);
-        }
-        finally {
-            point.delete();
-        }
-    });
-}
-function requireModelObject(value, message) {
-    if (!isModelObject(value)) {
-        throw new Error(message);
-    }
-    return value;
-}
-function requireModelKind(value, kind, message) {
-    const object = requireModelObject(value, message);
-    if (object.kind !== kind) {
-        throw new Error(message);
-    }
-    return object;
-}
-function booleanOperands(operation, operands) {
-    if (operands.length < 2) {
-        throw new Error(`${operation} requires at least two model operands.`);
-    }
-    const runtimeOperands = operands.map(operand => requireModelKind(operand, 'solid', `Every ${operation} operand must be a solid model.`));
-    return { first: runtimeOperands[0], others: runtimeOperands.slice(1) };
-}
-function assertPositive(label, value) {
-    if (!Number.isFinite(value) || value <= 0) {
-        throw new Error(`${label} must be a positive finite number.`);
-    }
-}
-function assertFiniteVector(label, value) {
-    if (value.some(component => !Number.isFinite(component))) {
-        throw new Error(`${label} must be a finite number.`);
-    }
-}
-function assertCurvePoints(label, points, minimum) {
-    if (points.length < minimum) {
-        throw new Error(`${label} requires at least ${minimum} points.`);
-    }
-    points.forEach((point, index) => assertFiniteVector(`${label} point ${index + 1}`, point));
-    const [first, ...rest] = points;
-    if (rest.every(point => point.every((component, index) => component === first[index]))) {
-        throw new Error(`${label} requires at least two distinct points.`);
-    }
-}
-function toPoint(vector) {
-    return [vector[0], vector[1], vector[2]];
-}
-function appendUniqueParameters(destination, parameters) {
-    for (const parameter of parameters) {
-        if (!hasParameter(destination, parameter)) {
-            destination.push(parameter);
-        }
-    }
-}
-function uniqueParameters(parameters) {
-    const unique = [];
-    appendUniqueParameters(unique, parameters);
-    return unique;
-}
-function hasParameter(parameters, parameter) {
-    return parameters.some(candidate => candidate.operation === parameter.operation &&
-        candidate.argument === parameter.argument &&
-        candidate.operationRef.file === parameter.operationRef.file &&
-        candidate.operationRef.start === parameter.operationRef.start &&
-        candidate.operationRef.end === parameter.operationRef.end &&
-        candidate.expressionRef.file === parameter.expressionRef.file &&
-        candidate.expressionRef.start === parameter.expressionRef.start &&
-        candidate.expressionRef.end === parameter.expressionRef.end &&
-        candidate.target.id === parameter.target.id);
-}
-//# sourceMappingURL=runtime.js.map