@code3d/core 0.0.1-alpha.0

package/bld/library/runtime.d.ts

@@ -0,0 +1,775 @@
+import type { Material } from './three.js';
+import { type ModelMaterialSnapshot } from './material.js';
+import { type TopologyInspection, type TopologyInspectionOptions } from './topology-inspection.js';
+import { type AnyShape } from 'replicad';
+import { type Quaternion, type RigidTransform, type Vec3 } from './spatial.js';
+import { type KernelOperationKey } from './kernel-cache.js';
+import type { SketchRegion } from './sketch-regions.js';
+import { type TopologyId } from './topology-id.js';
+import { type EdgeId, type ShapeTopology, type SurfaceId, type TopologyKind, type TopologySelection, type VertexId } from './topology.js';
+import { sketch } from './sketch.js';
+export type { Quaternion, Vec3 } from './spatial.js';
+export type { EdgeId, SurfaceId, TopologyKind, VertexId } from './topology.js';
+export type SourceRef = Readonly<{
+    file: string;
+    start: number;
+    end: number;
+}>;
+export type ParameterKind = 'length' | 'angle' | 'ratio' | 'count' | 'scalar';
+export type ParameterTarget = Readonly<{
+    id: string;
+    label: string;
+    kind: ParameterKind;
+    value: number;
+    sourceRef: SourceRef;
+}>;
+export type ParameterUsage = Readonly<{
+    operation: string;
+    argument: string;
+    value: number;
+    operationRef: SourceRef;
+    expressionRef: SourceRef;
+    target: ParameterTarget;
+    sensitivity: number;
+}>;
+export type Transform = Readonly<{
+    position: Vec3;
+    quaternion: Quaternion;
+    scale: Vec3;
+}>;
+export type ElementKind = 'point' | 'line' | 'face' | 'frame';
+export type ElementSnapshot = Readonly<{
+    name: string;
+    kind: ElementKind;
+    transform: Transform;
+    bound?: Readonly<{
+        size: readonly [number, number];
+        facing: 1 | -1;
+    }>;
+    facing?: 1 | -1;
+    direction?: 1 | -1;
+    arrow?: RigidTransform;
+    topology?: Readonly<{
+        geometryNodeId: string;
+        transform: Transform;
+    }> & TopologySelection;
+}>;
+export type ConstraintAnchorSnapshot = Readonly<{
+    nodeId: string;
+    name: string;
+    kind: ElementKind;
+}>;
+export type ConstraintSnapshot = Readonly<{
+    id: string;
+    source: ConstraintAnchorSnapshot;
+    target: ConstraintAnchorSnapshot;
+    sourceElement: ElementSnapshot;
+    targetElement: ElementSnapshot;
+    offsetDirection: 1 | -1;
+    offset: Vec3;
+    offsetFrame: Transform;
+    sourceRefs: readonly SourceRef[];
+    parameters: readonly ParameterUsage[];
+}> & (Readonly<{
+    kind: 'on';
+    /** Finite source extent in the contact frame, local to the source node. */
+    sourceBounds: Readonly<{
+        size: Vec3;
+        transform: Transform;
+    }>;
+}> | Readonly<{
+    kind: 'align';
+}>);
+export type ModelOperationKind = 'box' | 'cylinder' | 'tube' | 'coil' | 'sphere' | 'frustum' | 'regularPrism' | 'circle' | 'ellipse' | 'rectangle' | 'regularPolygon' | 'point' | 'line' | 'arc' | 'bezier' | 'spline' | 'loft' | 'sketchFace' | 'extrude' | 'primitive' | 'material' | 'scaled' | 'originOffset' | 'originVertex' | 'originPoint' | 'originCenter' | 'rotate' | 'fillet' | 'chamfer' | 'shell' | 'relate' | 'expose' | 'group' | 'union' | 'cut' | 'intersect';
+export type ModelOperationInputRole = 'source' | 'receiver' | 'operand' | 'tool' | 'child' | 'collection' | 'reference' | 'section' | 'spine';
+export type ModelGeometryKind = 'solid' | 'face' | 'edge' | 'vertex';
+export type ModelKind = ModelGeometryKind | 'group';
+export type ModelOperationRegionSnapshot = Readonly<{
+    kind: 'intersection' | 'section';
+    inputNodeId: string;
+    /** The model whose local coordinates contain this region mesh. */
+    frameNodeId: string;
+    mesh: RenderMesh;
+}>;
+export type ModelOperationSelectionSnapshot = Readonly<{
+    kind: TopologyKind;
+    inputNodeId: string;
+    ids: readonly TopologyId[];
+    /** Input geometry coordinates expressed in the operation output's frame. */
+    transform: Transform;
+}>;
+export type ModelOperationSnapshot = Readonly<{
+    id: string;
+    siteId?: string;
+    execution?: number;
+    kind: ModelOperationKind;
+    order?: number;
+    outputNodeId: string;
+    inputs: readonly Readonly<{
+        nodeId: string;
+        role: ModelOperationInputRole;
+        index: number;
+    }>[];
+    regions: readonly ModelOperationRegionSnapshot[];
+    selections: readonly ModelOperationSelectionSnapshot[];
+    sourceRef?: SourceRef;
+    spatial?: ModelSpatialOperation;
+    /** Authored dimensions in the operation output's local geometry frame. */
+    dimensions?: Readonly<Record<string, ModelParameterDimension>>;
+}>;
+export type ModelParameterDimension = Readonly<{
+    origin: Vec3;
+    vector: Vec3;
+}>;
+/** Local geometry coordinates; vector is the authored coordinates, offset, or angles. */
+export type ModelSpatialOperation = Readonly<{
+    origin: Vec3;
+    vector: Vec3;
+    /** Relation edits use self's frame at this authored operation. */
+    frame?: RigidTransform;
+    rotation?: Vec3;
+    axisOnly?: boolean;
+}>;
+export type ConstraintSpatialReference = Readonly<{
+    nodeId: string;
+    kind: 'pivot' | 'pivotVertex' | 'around' | 'rotate';
+    spatial: ModelSpatialOperation;
+}>;
+export type ConstraintPreview = Readonly<{
+    object: Pick<ModelSnapshotObject, 'nodeId' | 'compositionTransform' | 'constraints'>;
+    spatial?: ConstraintSpatialReference;
+}>;
+export type RenderMesh = Readonly<{
+    /** Tessellation vertices used by the triangle mesh. */
+    vertices: Float32Array;
+    normals: Float32Array;
+    /** Native face UVs normalized to each tessellated face's range. */
+    uvs?: Float32Array;
+    triangles: Uint32Array;
+    edges: Float32Array;
+    /** OpenCascade topology vertices, aligned with vertexIds. */
+    topologyVertices: Float32Array;
+    vertexIds: readonly VertexId[];
+    surfaceGroups: readonly Readonly<{
+        start: number;
+        count: number;
+        surfaceId: SurfaceId;
+    }>[];
+    edgeGroups: readonly Readonly<{
+        start: number;
+        count: number;
+        edgeId: EdgeId;
+    }>[];
+}>;
+export type ModelSnapshotObject = Readonly<{
+    nodeId: string;
+    kind: ModelKind;
+    name: string;
+    /** Effective material, including recursive overrides from enclosing groups. */
+    material?: ModelMaterialSnapshot;
+    children: readonly ModelSnapshotObject[];
+    /** Placement used when this snapshot participates in a composition. */
+    compositionTransform: Transform;
+    /** Placement in this snapshot tree; a root value uses model-local coordinates. */
+    transform: Transform;
+    constraints: readonly ConstraintSnapshot[];
+    elements: readonly ElementSnapshot[];
+    origin: Vec3;
+    sourceRefs: readonly SourceRef[];
+    parameters: readonly ParameterUsage[];
+    operation: ModelOperationSnapshot;
+    mesh?: RenderMesh;
+}>;
+type StoredElement = Readonly<{
+    kind: ElementKind;
+    transform: RigidTransform;
+    whole?: boolean;
+    bound?: Readonly<{
+        size: readonly [number, number];
+        facing: 1 | -1;
+    }>;
+    facing?: 1 | -1;
+    direction?: 1 | -1;
+    topology?: StoredTopology;
+    members?: StoredElements;
+}>;
+type StoredTopology = Readonly<{
+    source: ModelObject;
+    selection: TopologySelection;
+    transform: RigidTransform;
+    scale: number;
+}>;
+type StoredElements = Readonly<Record<string, StoredElement>>;
+type StoredAnchor = StoredElement & Readonly<{
+    name: string;
+}>;
+type AnchorReference = StoredAnchor & Readonly<{
+    model: ModelObject;
+}>;
+export type ModelElementReference = Readonly<{
+    model: ModelObject;
+    name: string;
+    kind: ElementKind;
+    transform: Transform;
+    bound?: ElementSnapshot['bound'];
+    facing?: 1 | -1;
+    direction?: 1 | -1;
+}>;
+export type ModelTopologyReference = Readonly<{
+    model: ModelObject;
+    geometry: ModelObject;
+    transform: Transform;
+}> & TopologySelection;
+export type ConstraintTraceReference = Readonly<{
+    constraintId: string;
+    source: ModelObject;
+    target: ModelObject;
+    self?: ModelObject;
+}>;
+export type ModelOperationInstrumentation = Readonly<{
+    siteId: string;
+    execution: number;
+    order: number;
+    sourceRef: SourceRef;
+    parameters: readonly ParameterUsage[];
+}>;
+export type ModelObjectRuntimeInfo = Readonly<{
+    nodeId: string;
+    name: string;
+    sourceRefs: readonly SourceRef[];
+}>;
+type StoredConstraint = Readonly<{
+    id: string;
+    kind: 'on' | 'align';
+    source: RelationReference;
+    target: RelationReference;
+    rotations: readonly ConstraintRotation[];
+    offset: Vec3 | undefined;
+}>;
+type RelationReference = StoredAnchor & Readonly<{
+    model?: ModelObject;
+}>;
+type PivotSelection = Readonly<{
+    kind: 'pivot';
+    point: Vec3;
+}> | Readonly<{
+    kind: 'pivotVertex';
+    id: VertexId;
+}> | Readonly<{
+    kind: 'around';
+    axis: RelationReference;
+}>;
+type ConstraintRotation = Readonly<{
+    pivot: PivotSelection;
+    angles: Vec3 | number;
+}>;
+type ConstraintSpatialSelection = Readonly<{
+    kind: ConstraintSpatialReference['kind'];
+    pivot: PivotSelection;
+}>;
+type RelateContext = Readonly<{
+    self: ModelObject;
+    original: ModelObject;
+}>;
+/**
+ * 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 declare function beginModelEvaluation(checkCancelled?: () => void): () => void;
+type LocalBounds = readonly [minimum: Vec3, maximum: Vec3];
+declare const anchorKind: unique symbol;
+declare const modelFamily: unique symbol;
+declare const modelNamedElements: unique symbol;
+export interface Anchor<Kind extends ElementKind = ElementKind> {
+    readonly [anchorKind]: Kind;
+    /** Translate this geometry's matching bound onto the directed target bound. */
+    on(target: Bound): Constraint;
+    /** Align the underlying geometry, retaining unconstrained position and orientation. */
+    align(this: Anchor<'point' | 'line' | 'face'>, target: Anchor<'point' | 'line' | 'face'>): Constraint;
+}
+export interface PointAnchor extends Anchor<'point'> {
+}
+export interface LineAnchor extends Anchor<'line'> {
+    /** Reverse direction without changing geometry or the reference coordinate axes. */
+    reverse(): this;
+}
+export interface FaceAnchor extends Anchor<'face'> {
+    /** Reverse facing without changing geometry, position, or the reference axes. */
+    flip(): this;
+}
+declare const boundKind: unique symbol;
+export interface Bound extends FaceAnchor {
+    readonly [boundKind]: true;
+}
+export interface DirectionalBounds {
+    readonly up: Bound;
+    readonly down: Bound;
+    readonly left: Bound;
+    readonly right: Bound;
+    readonly front: Bound;
+    readonly back: Bound;
+}
+export interface GeometryQueryCapabilities extends DirectionalBounds {
+    /** Local bounding-box center, carried through geometry transforms. */
+    readonly center: PointAnchor;
+}
+export interface Vertex extends PointAnchor, GeometryQueryCapabilities, VertexTopologyCapabilities {
+    readonly kind: 'vertex';
+    readonly id: VertexId;
+}
+export interface Edge extends LineAnchor, GeometryQueryCapabilities, EdgeTopologyCapabilities {
+    readonly kind: 'edge';
+    readonly id: EdgeId;
+    readonly start: PointAnchor;
+    readonly midpoint: PointAnchor;
+    readonly end: PointAnchor;
+}
+export interface Surface extends FaceAnchor, GeometryQueryCapabilities, SurfaceTopologyCapabilities {
+    readonly kind: 'surface';
+    readonly id: SurfaceId;
+}
+export interface Solid extends Anchor<'frame'>, GeometryQueryCapabilities, SurfaceTopologyCapabilities {
+    readonly kind: 'solid';
+}
+export type ElementSources = Readonly<Record<string, Anchor>>;
+export type NamedElements = Readonly<Record<string, Anchor>>;
+export type ExposedValue<Value> = Value extends {
+    readonly [modelFamily]: infer Family;
+    readonly [modelNamedElements]: infer Elements;
+} ? (Family extends 'solid' ? Solid : Family extends 'face' ? Surface : Family extends 'edge' ? Edge : Family extends 'vertex' ? Vertex : Family extends 'group' ? Anchor<'frame'> : Anchor) & Elements : Value extends Anchor ? Value : never;
+export type ExposedElements<Sources extends ElementSources> = Readonly<{
+    [Name in keyof Sources]: ExposedValue<Sources[Name]>;
+}>;
+export type MergedElements<Existing extends NamedElements, Added extends NamedElements> = Omit<Existing, keyof Added> & Added;
+export type ModelElementKind<Kind extends ModelKind> = Kind extends 'face' ? 'face' : Kind extends 'edge' ? 'line' : Kind extends 'vertex' ? 'point' : 'frame';
+export type ModelFamily = ModelKind | 'model';
+export type ModelFamilyElementKind<Family extends ModelFamily> = Family extends ModelKind ? ModelElementKind<Family> : ElementKind;
+export type ModelForFamily<Elements extends NamedElements, Family extends ModelFamily> = Family extends 'solid' ? SolidModel<Elements> : Family extends 'face' ? FaceModel<Elements> : Family extends 'edge' ? EdgeModel<Elements> : Family extends 'vertex' ? VertexModel<Elements> : Family extends 'group' ? GroupModel<Elements> : Model<Elements>;
+export interface ModelCapabilities<Elements extends NamedElements, Family extends ModelFamily> extends Anchor<ModelFamilyElementKind<Family>>, DirectionalBounds {
+    readonly [modelFamily]: Family extends ModelKind ? Family : ModelKind;
+    readonly [modelNamedElements]: Elements;
+    relate(build: (self: ModelForFamily<Elements, Family>) => Constraint | readonly Constraint[]): ModelForFamily<Elements, Family>;
+    expose<const Sources extends ElementSources>(sources: Sources): ModelForFamily<MergedElements<Elements, ExposedElements<Sources>>, Family>;
+    /**
+     * Shift the origin by this displacement: every local point becomes p - d.
+     * @code3d.param dx {kind: 'length', label: 'Origin ΔX'}
+     * @code3d.param dy {kind: 'length', label: 'Origin ΔY'}
+     * @code3d.param dz {kind: 'length', label: 'Origin ΔZ'}
+     */
+    originOffset(dx: number, dy: number, dz: number): ModelForFamily<Elements, Family>;
+    /** Re-express the model with this point reference at local zero. */
+    originPoint(point: PointAnchor): ModelForFamily<Elements, Family>;
+    /**
+     * Rotate about the current origin, in degrees, about fixed local X, Y, then Z axes.
+     * @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: number, y: number, z: number): ModelForFamily<Elements, Family>;
+    /**
+     * Return a value with its entire material replaced, including every group descendant.
+     * Capture a Three.js material at assignment, or use a CSS color for the default material.
+     */
+    material(material: Material | string): ModelForFamily<Elements, Family>;
+}
+export interface GeometryCapabilities<Elements extends NamedElements, Family extends ModelGeometryKind> extends GeometryQueryCapabilities {
+    /** Re-express the model with its geometric center at local zero. */
+    originCenter(): ModelForFamily<Elements, Family>;
+    /**
+     * Re-express the model with the selected vertex at local zero.
+     * @code3d.param id {kind: 'vertex', label: 'Origin vertex'}
+     */
+    originVertex(id: VertexId): ModelForFamily<Elements, Family>;
+    /** @code3d.param factor {kind: 'ratio', label: 'Scale'} */
+    scaled(factor: number): ModelForFamily<Elements, Family>;
+}
+export interface VertexTopologyCapabilities {
+    /** @code3d.param id {kind: 'vertex', label: 'Vertex'} */
+    vertex(id: VertexId): Vertex;
+    /** @code3d.param ids {kind: 'vertex', label: 'Vertices', actions: [{label: 'Use all', action: 'remove-argument'}]} */
+    vertices(ids?: readonly VertexId[]): readonly Vertex[];
+}
+export interface EdgeTopologyCapabilities extends VertexTopologyCapabilities {
+    /** @code3d.param id {kind: 'edge', label: 'Edge'} */
+    edge(id: EdgeId): Edge;
+    /** @code3d.param ids {kind: 'edge', label: 'Edges', actions: [{label: 'Use all', action: 'remove-argument'}]} */
+    edges(ids?: readonly EdgeId[]): readonly Edge[];
+}
+export interface SurfaceTopologyCapabilities extends EdgeTopologyCapabilities {
+    /** @code3d.param id {kind: 'surface', label: 'Surface'} */
+    surface(id: SurfaceId): Surface;
+    /** @code3d.param ids {kind: 'surface', label: 'Surfaces', actions: [{label: 'Use all', action: 'remove-argument'}]} */
+    surfaces(ids?: readonly SurfaceId[]): readonly Surface[];
+}
+export interface SolidModificationCapabilities<Elements extends NamedElements> {
+    /** Subtracts all tools in one boolean operation, equivalent to cut(stock, tools). */
+    cut(tools: readonly SolidModel<{}>[]): SolidModel;
+    /**
+     * @code3d.param radius {kind: 'length', label: 'Fillet radius', constraints: {exclusiveMin: 0}}
+     * @code3d.param edgeIds {kind: 'edge', actions: [{label: 'Use all', action: 'remove-argument'}]}
+     */
+    fillet(radius: number, edgeIds?: readonly EdgeId[]): SolidModel<Elements>;
+    /**
+     * @code3d.param distance {kind: 'length', label: 'Chamfer distance', constraints: {exclusiveMin: 0}}
+     * @code3d.param edgeIds {kind: 'edge', actions: [{label: 'Use all', action: 'remove-argument'}]}
+     */
+    chamfer(distance: number, edgeIds?: readonly EdgeId[]): SolidModel<Elements>;
+    /**
+     * Hollow a solid with uniform walls. Positive thickness offsets inward;
+     * negative thickness offsets outward. Selected surfaces become openings.
+     * Omit the selection, or use [], for a fully enclosed cavity.
+     * @code3d.param thickness {kind: 'length', label: 'Wall thickness'}
+     * @code3d.param removedSurfaceIds {kind: 'surface', label: 'Openings', actions: [{label: 'Close all openings', action: 'remove-argument'}]}
+     */
+    shell(thickness: number, removedSurfaceIds?: readonly SurfaceId[]): SolidModel<Elements>;
+}
+export type Model<Elements extends NamedElements = {}> = ModelCapabilities<Elements, 'model'> & Elements;
+export type GroupModel<Elements extends NamedElements = {}> = ModelCapabilities<Elements, 'group'> & Elements;
+export type VertexModel<Elements extends NamedElements = {}> = ModelCapabilities<Elements, 'vertex'> & GeometryCapabilities<Elements, 'vertex'> & VertexTopologyCapabilities & Elements;
+export type EdgeModel<Elements extends NamedElements = CurveElements> = ModelCapabilities<Elements, 'edge'> & GeometryCapabilities<Elements, 'edge'> & EdgeTopologyCapabilities & {
+    reverse(): Edge;
+} & Elements;
+export type FaceModel<Elements extends NamedElements = PlanarElements> = ModelCapabilities<Elements, 'face'> & GeometryCapabilities<Elements, 'face'> & SurfaceTopologyCapabilities & {
+    flip(): Surface;
+    /**
+     * Extrudes along the face's local plane normal. Signed distance; no recentering.
+     * @code3d.param distance {kind: 'length', label: 'Extrusion distance'}
+     */
+    extrude(distance: number): SolidModel;
+} & Elements;
+export type SolidModel<Elements extends NamedElements = CanonicalElements> = ModelCapabilities<Elements, 'solid'> & GeometryCapabilities<Elements, 'solid'> & SurfaceTopologyCapabilities & SolidModificationCapabilities<Elements> & Elements;
+type RuntimeModel<Elements extends NamedElements, Kind extends ModelKind> = ModelObject<Elements, Kind> & Elements;
+export type CanonicalElements = Readonly<{
+    center: PointAnchor;
+    axis: LineAnchor;
+}>;
+export type PlanarElements = Readonly<{
+    center: PointAnchor;
+    plane: FaceAnchor;
+}>;
+export type CurveElements = Readonly<{
+    start: PointAnchor;
+    midpoint: PointAnchor;
+    end: PointAnchor;
+}>;
+export declare function modelElementReference(value: unknown): ModelElementReference | undefined;
+export declare function modelTopologyReference(value: unknown): ModelTopologyReference | undefined;
+export declare function modelTopologyIds(value: unknown, kind: TopologyKind): readonly TopologyId[] | undefined;
+/** Traceable relation values, including unfinished pivot and axis selections. */
+export declare abstract class ConstraintExpression {
+    protected readonly kind: StoredConstraint['kind'];
+    protected readonly source: AnchorReference;
+    protected readonly target: AnchorReference;
+    protected readonly displacement: Vec3 | undefined;
+    protected readonly rotations: readonly ConstraintRotation[];
+    protected readonly context: RelateContext | undefined;
+    protected readonly constraintId: string;
+    private get sourceRefs();
+    private get parameters();
+    protected spatialOperation?: ConstraintSpatialSelection;
+    protected constructor(kind: StoredConstraint['kind'], source: AnchorReference, target: AnchorReference, displacement: Vec3 | undefined, rotations: readonly ConstraintRotation[], context: RelateContext | undefined, constraintId: string, previous?: ConstraintExpression);
+}
+export declare class Constraint extends ConstraintExpression {
+    private constructor();
+    /**
+     * 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: number, y: number, z: number): Constraint;
+    /**
+     * 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]: Vec3): ConstraintPivotChain;
+    /** @code3d.param id {kind: 'vertex', label: 'Pivot vertex'} */
+    pivotVertex(id: VertexId): ConstraintPivotChain;
+    /** Select a positioned axis in the composition. */
+    around(axis: LineAnchor): ConstraintAroundChain;
+    /**
+     * 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: number, y: number, z: number): Constraint;
+}
+export declare class ConstraintPivotChain extends ConstraintExpression {
+    private readonly constraint;
+    private readonly 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: number, y: number, z: number): Constraint;
+}
+export declare class ConstraintAroundChain extends ConstraintExpression {
+    private readonly constraint;
+    private readonly selection;
+    /** @code3d.param angle {kind: 'angle', label: 'Rotate'} */
+    rotate(angle: number): Constraint;
+}
+declare const referenceBounds: unique symbol;
+declare const referenceBoundsParts: unique symbol;
+declare const modelSnapshotQueries: unique symbol;
+export declare class ModelObject<Elements extends NamedElements = {}, Kind extends ModelKind = ModelKind> implements Anchor<ModelElementKind<Kind>> {
+    readonly [anchorKind]: ModelElementKind<Kind>;
+    readonly [modelFamily]: Kind;
+    readonly [modelNamedElements]: Elements;
+    private readonly geometry?;
+    private readonly assembly?;
+    private readonly meshTolerance;
+    private readonly geometryAnchor;
+    private readonly elements;
+    private constraints;
+    private readonly operation;
+    private constructor();
+    get up(): Bound;
+    get down(): Bound;
+    get left(): Bound;
+    get right(): Bound;
+    get front(): Bound;
+    get back(): Bound;
+    on(target: Bound): Constraint;
+    align(target: Anchor<'point' | 'line' | 'face'>): Constraint;
+    reverse(): Edge;
+    flip(): Surface;
+    relate(build: (self: RuntimeModel<Elements, Kind>) => Constraint | readonly Constraint[]): RuntimeModel<Elements, Kind>;
+    expose<const Sources extends ElementSources>(sources: Sources): RuntimeModel<MergedElements<Elements, ExposedElements<Sources>>, Kind>;
+    /** Resolve both own and occurrence references into this model's local frame. */
+    private localElements;
+    vertex(id: VertexId): Vertex;
+    vertices(ids?: readonly VertexId[]): readonly Vertex[];
+    edge(id: EdgeId): Edge;
+    edges(ids?: readonly EdgeId[]): readonly Edge[];
+    surface(id: SurfaceId): Surface;
+    surfaces(ids?: readonly SurfaceId[]): readonly Surface[];
+    private selectTopology;
+    material(material: Material | string): RuntimeModel<Elements, Kind>;
+    originOffset(dx: number, dy: number, dz: number): RuntimeModel<Elements, Kind>;
+    originPoint(point: PointAnchor): RuntimeModel<Elements, Kind>;
+    originVertex(id: VertexId): RuntimeModel<Elements, Kind>;
+    originCenter(): RuntimeModel<Elements, Kind>;
+    private withOrigin;
+    rotate(x: number, y: number, z: number): RuntimeModel<Elements, Kind>;
+    private transformed;
+    private mapConstraintGeometry;
+    scaled(factor: number): RuntimeModel<Elements, Kind>;
+    extrude(this: ModelObject<Elements, 'face'>, distance: number): SolidModel;
+    cut(this: ModelObject<Elements, 'solid'>, tools: readonly SolidModel<{}>[]): SolidModel;
+    fillet(this: ModelObject<Elements, 'solid'>, radius: number, edgeIds?: readonly EdgeId[]): SolidModel<Elements>;
+    chamfer(this: ModelObject<Elements, 'solid'>, distance: number, edgeIds?: readonly EdgeId[]): SolidModel<Elements>;
+    shell(this: ModelObject<Elements, 'solid'>, thickness: number, removedSurfaceIds?: readonly SurfaceId[]): SolidModel<Elements>;
+    private snapshotNode;
+    private evaluateBoolean;
+    private allParameters;
+    private solvePose;
+    private memberPoses;
+    /** Bounds of the selected finite geometry after a rigid transform. */
+    private [referenceBoundsParts];
+    /** Bounds of the selected finite geometry after a rigid transform. */
+    [referenceBounds](reference: StoredAnchor, transform: RigidTransform): LocalBounds;
+    /** Pure query collection: it never substitutes geometry or runs author code. */
+    [modelSnapshotQueries](): SnapshotQueryInput[];
+    private alignmentGeometry;
+    private relationElement;
+    private bodyRotations;
+    private constraintSpatial;
+    /** Fix the assembly frame once, using only its direct member origins. */
+    private static createAssembly;
+    private static createSolveContext;
+    private constraintSnapshot;
+    private requireGeometry;
+    private requireSolidGeometry;
+    private operationSnapshot;
+    private copyWithGeometry;
+    private copy;
+}
+/** @code3d.param radius {kind: 'length', default: 5, constraints: {exclusiveMin: 0}} */
+export declare function circle(radius: number): FaceModel;
+/**
+ * @code3d.param xRadius {kind: 'length', default: 5, label: 'X radius', constraints: {exclusiveMin: 0}}
+ * @code3d.param zRadius {kind: 'length', default: 3, label: 'Z radius', constraints: {exclusiveMin: 0}}
+ */
+export declare function ellipse(xRadius: number, zRadius: number): FaceModel;
+/**
+ * @code3d.param x {kind: 'length', default: 10, constraints: {exclusiveMin: 0}}
+ * @code3d.param z {kind: 'length', default: 10, constraints: {exclusiveMin: 0}}
+ */
+export declare function rectangle(x: number, z: number): FaceModel;
+/**
+ * @code3d.param radius {kind: 'length', default: 5, constraints: {exclusiveMin: 0}}
+ * @code3d.param sides {kind: 'count', default: 6, constraints: {min: 3}}
+ * @code3d.param rotation {kind: 'angle', default: 0}
+ */
+export declare function regularPolygon(radius: number, sides: number, rotation?: number): FaceModel;
+/**
+ * @code3d.param x {kind: 'length', label: 'X'}
+ * @code3d.param y {kind: 'length', label: 'Y'}
+ * @code3d.param z {kind: 'length', label: 'Z'}
+ */
+export declare function point([x, y, z]?: Vec3): VertexModel;
+/**
+ * @code3d.param x {kind: 'length', label: 'End X'}
+ * @code3d.param y {kind: 'length', label: 'End Y'}
+ * @code3d.param z {kind: 'length', label: 'End Z'}
+ */
+export declare function line([x, y, z]: Vec3): EdgeModel;
+/**
+ * @code3d.param startX {kind: 'length', label: 'Start X'}
+ * @code3d.param startY {kind: 'length', label: 'Start Y'}
+ * @code3d.param startZ {kind: 'length', label: 'Start Z'}
+ * @code3d.param endX {kind: 'length', label: 'End X'}
+ * @code3d.param endY {kind: 'length', label: 'End Y'}
+ * @code3d.param endZ {kind: 'length', label: 'End Z'}
+ */
+export declare function line([startX, startY, startZ]: Vec3, [endX, endY, endZ]: Vec3): EdgeModel;
+export declare function arc(start: Vec3, middle: Vec3, end: Vec3): EdgeModel;
+export declare function bezier(points: readonly Vec3[]): EdgeModel;
+export declare function spline(points: readonly Vec3[]): EdgeModel;
+export type LoftOptions = Readonly<{
+    spine?: EdgeModel<{}>;
+    ruled?: boolean;
+}>;
+export declare function loft(sections: readonly FaceModel<{}>[], { spine, ruled }?: LoftOptions): SolidModel;
+/**
+ * @code3d.param x {kind: 'length', default: 10, constraints: {exclusiveMin: 0}}
+ * @code3d.param y {kind: 'length', default: 10, constraints: {exclusiveMin: 0}}
+ * @code3d.param z {kind: 'length', default: 10, constraints: {exclusiveMin: 0}}
+ */
+export declare function box(x: number, y: number, z: number): SolidModel;
+/**
+ * @code3d.param radius {kind: 'length', default: 5, constraints: {exclusiveMin: 0}}
+ * @code3d.param y {kind: 'length', default: 10, constraints: {exclusiveMin: 0}}
+ */
+export declare function cylinder(radius: number, y: number): SolidModel;
+/**
+ * A concentric, constant-section tube, open at both ends and centered on Y.
+ * @code3d.param outerRadius {kind: 'length', default: 5, label: 'Outer radius', constraints: {exclusiveMin: 0}}
+ * @code3d.param innerRadius {kind: 'length', default: 3, label: 'Inner radius', constraints: {exclusiveMin: 0}}
+ * @code3d.param y {kind: 'length', default: 10, constraints: {exclusiveMin: 0}}
+ */
+export declare function tube(outerRadius: number, innerRadius: number, y: number): SolidModel;
+/**
+ * A right-handed, constant-pitch coil with a circular wire section and plain ends.
+ * coilRadius measures to the wire centerline; pitch is the Y advance per turn.
+ * The centerline spans -pitch * turns / 2 to +pitch * turns / 2 on the Y axis.
+ * Fractional turns are supported. No spring-specific end treatments are applied.
+ * @code3d.param coilRadius {kind: 'length', default: 5, label: 'Coil radius', constraints: {exclusiveMin: 0}}
+ * @code3d.param wireRadius {kind: 'length', default: 1, label: 'Wire radius', constraints: {exclusiveMin: 0}}
+ * @code3d.param pitch {kind: 'length', default: 3, constraints: {exclusiveMin: 0}}
+ * @code3d.param turns {kind: 'scalar', default: 3, constraints: {exclusiveMin: 0}}
+ */
+export declare function coil(coilRadius: number, wireRadius: number, pitch: number, turns: number): SolidModel;
+/** @code3d.param radius {kind: 'length', default: 5, constraints: {exclusiveMin: 0}} */
+export declare function sphere(radius: number): SolidModel;
+/**
+ * @code3d.param bottomRadius {kind: 'length', default: 5, label: 'Bottom radius', constraints: {exclusiveMin: 0}}
+ * @code3d.param topRadius {kind: 'length', default: 3, label: 'Top radius', constraints: {exclusiveMin: 0}}
+ * @code3d.param y {kind: 'length', default: 10, constraints: {exclusiveMin: 0}}
+ */
+export declare function frustum(bottomRadius: number, topRadius: number, y: number): SolidModel;
+/**
+ * @code3d.param radius {kind: 'length', default: 5, constraints: {exclusiveMin: 0}}
+ * @code3d.param y {kind: 'length', default: 10, constraints: {exclusiveMin: 0}}
+ * @code3d.param sides {kind: 'count', default: 6, constraints: {min: 3}}
+ * @code3d.param rotation {kind: 'angle', default: 0}
+ */
+export declare function regularPrism(radius: number, y: number, sides: number, rotation?: number): SolidModel;
+export declare function group(children: readonly Model[], name?: string): GroupModel;
+export declare function union(operands: readonly SolidModel<{}>[]): SolidModel;
+/**
+ * Extrudes a single face; use faces.map(face => extrude(face, distance)) for multiple regions.
+ * @code3d.param distance {kind: 'length', label: 'Extrusion distance'}
+ */
+export declare function extrude(face: FaceModel<{}>, distance: number): SolidModel;
+export declare function cut(stock: SolidModel<{}>, tools: readonly SolidModel<{}>[]): SolidModel;
+export declare function intersect(operands: readonly SolidModel<{}>[]): SolidModel;
+export declare function isModelObject(value: unknown): value is ModelObject;
+export declare function isConstraint(value: unknown): value is Constraint;
+export declare function isConstraintExpression(value: unknown): value is ConstraintExpression;
+export declare function constraintPreview(value: ConstraintExpression): ConstraintPreview | undefined;
+export declare function instrumentConstraint(constraint: ConstraintExpression, sourceRef: SourceRef, parameters: readonly ParameterUsage[]): void;
+export declare function instrumentModelOperation(object: ModelObject, instrumentation: ModelOperationInstrumentation): void;
+export declare function constraintTraceReference(constraint: ConstraintExpression): ConstraintTraceReference;
+export declare function modelObjectRuntimeInfo(object: ModelObject): ModelObjectRuntimeInfo;
+export declare function relatedModelObjects(object: ModelObject): readonly ModelObject[];
+export type SnapshotQuery = Readonly<{
+    key: KernelOperationKey;
+}> & (Readonly<{
+    kind: 'bounds';
+    transform: RigidTransform;
+    selection: TopologySelection;
+    scale: number;
+}> | Readonly<{
+    kind: 'mesh';
+    tolerance: number;
+    topology: boolean;
+}>);
+export type SnapshotQueryResult = LocalBounds | RenderMesh;
+type SnapshotQueryInput = {
+    inputId: string;
+    geometry: {
+        shape: AnyShape;
+        topology?: ShapeTopology;
+    };
+    query: SnapshotQuery;
+};
+/** Host-owned native input and result admission. Only encode() bytes cross runtimes. */
+export type SnapshotQueryBatch = Readonly<{
+    id: string;
+    queries: readonly SnapshotQuery[];
+    weight: number;
+    sourceRef?: SourceRef;
+    encode(): Uint8Array;
+    accept(query: SnapshotQuery, value: SnapshotQueryResult): void;
+}>;
+export declare function planModelSnapshotQueries(objects: readonly ModelObject[]): SnapshotQueryBatch[];
+/** Each batch owns its restored shape; completed results leave before cancellation checks. */
+export declare function executeSnapshotQueryBatch(id: string, bytes: Uint8Array, queries: readonly SnapshotQuery[], checkCancelled: () => void, onResult: (query: SnapshotQuery, value: SnapshotQueryResult) => void, onRestore?: (milliseconds: number) => void): void;
+export declare function createModelSnapshotter(): (object: ModelObject) => ModelSnapshotObject;
+export declare function disposeModelObjects(objects: Iterable<ModelObject>): void;
+/** Worker-owned native geometry, independent of the author's object lifetime. */
+export type ModelGeometrySnapshot = Readonly<{
+    /** Borrowed shapes; clone before passing them to consuming operations. */
+    shapes: ReadonlyMap<string, AnyShape>;
+    inspect(nodeId: string, options?: TopologyInspectionOptions): TopologyInspection;
+    dispose(): void;
+}>;
+export declare function retainModelGeometry(objects: Iterable<ModelObject>): ModelGeometrySnapshot;
+export declare const authoringApi: Readonly<{
+    sketch: typeof sketch;
+    circle: typeof circle;
+    ellipse: typeof ellipse;
+    extrude: typeof extrude;
+    rectangle: typeof rectangle;
+    regularPolygon: typeof regularPolygon;
+    point: typeof point;
+    line: typeof line;
+    arc: typeof arc;
+    bezier: typeof bezier;
+    spline: typeof spline;
+    loft: typeof loft;
+    box: typeof box;
+    cylinder: typeof cylinder;
+    tube: typeof tube;
+    coil: typeof coil;
+    sphere: typeof sphere;
+    frustum: typeof frustum;
+    regularPrism: typeof regularPrism;
+    group: typeof group;
+    union: typeof union;
+    cut: typeof cut;
+    intersect: typeof intersect;
+}>;
+/** Internal bridge from the kernel-independent sketch definition to model geometry. */
+export declare function sketchFaceModel(region: SketchRegion): FaceModel;
+//# sourceMappingURL=runtime.d.ts.map