brepjs 18.17.0 → 18.19.0

package/dist/{cameraFns-leKP1O1t.cjs → cameraFns-CR2inEBU.cjs}

@@ -1,6 +1,6 @@
-const require_shapeTypes = require("./shapeTypes-xj3nxBTM.cjs");
-const require_errors = require("./errors-Dv6pfNct.cjs");
-const require_topologyQueryFns = require("./topologyQueryFns-D0v-c2Xk.cjs");
+const require_shapeTypes = require("./shapeTypes-BpKhed-9.cjs");
+const require_errors = require("./errors-BiY8-q1s.cjs");
+const require_topologyQueryFns = require("./topologyQueryFns-CHsPXNbI.cjs");
 const require_vecOps = require("./vecOps-D7xplSx8.cjs");
 //#region src/projection/projectionPlanes.ts
 /** Lookup table mapping each {@link ProjectionPlane} to its camera configuration. */

package/dist/{cameraFns-Bix9SLAm.js → cameraFns-Dg1lQP0S.js}

@@ -1,6 +1,6 @@
-import { X as getKernel, t as castShape } from "./shapeTypes-B_s2jyQ2.js";
-import { A as ok, b as err, d as validationError } from "./errors-0fYW_YnO.js";
-import { o as getEdges } from "./topologyQueryFns-BcYn7Adz.js";
+import { Z as getKernel, t as castShape } from "./shapeTypes-DGtDTS9s.js";
+import { A as ok, b as err, d as validationError } from "./errors-8GZS3vy9.js";
+import { o as getEdges } from "./topologyQueryFns-CcWaCxeb.js";
 import { c as vecLength, d as vecNormalize, g as vecSub, r as vecCross } from "./vecOps-DVROrqTV.js";
 //#region src/projection/projectionPlanes.ts
 /** Lookup table mapping each {@link ProjectionPlane} to its camera configuration. */

package/dist/core/errors.d.ts

@@ -58,6 +58,7 @@ export declare const BrepErrorCode: {
     readonly CHAMFER_NOT_3D: "CHAMFER_NOT_3D";
     readonly CHAMFER_ANGLE_NOT_3D: "CHAMFER_ANGLE_NOT_3D";
     readonly CHAMFER_ANGLE_FAILED: "CHAMFER_ANGLE_FAILED";
+    readonly CSG_NOT_3D: "CSG_NOT_3D";
     readonly SHELL_NOT_3D: "SHELL_NOT_3D";
     readonly OFFSET_NOT_3D: "OFFSET_NOT_3D";
     readonly NULL_SHAPE: "NULL_SHAPE";

package/dist/core.cjs

@@ -1,10 +1,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_shapeTypes = require("./shapeTypes-xj3nxBTM.cjs");
-const require_errors = require("./errors-Dv6pfNct.cjs");
+const require_shapeTypes = require("./shapeTypes-BpKhed-9.cjs");
+const require_errors = require("./errors-BiY8-q1s.cjs");
 const require_constants = require("./constants-DTorLmes.cjs");
 const require_types = require("./types-CDkxah-M.cjs");
 const require_vecOps = require("./vecOps-D7xplSx8.cjs");
-const require_planeOps = require("./planeOps-CH4ruLuj.cjs");
+const require_planeOps = require("./planeOps-2EyPq0tU.cjs");
 exports.BrepBugError = require_errors.BrepBugError;
 exports.DEG2RAD = require_constants.DEG2RAD;
 exports.DisposalScope = require_shapeTypes.DisposalScope;

package/dist/core.js

@@ -1,7 +1,7 @@
-import { B as createKernelHandle, C as isOrientedFace, D as manifoldShell, E as isValidSolid, H as isLive, I as is2D, J as withScopeResultAsync, K as withScope, L as is3D, M as getShapeKind, O as orientedFace, R as DisposalScope, S as isManifoldShell, _ as isSolid, b as closedWire, d as isCompound, f as isEdge, g as isShell, h as isShape3D, j as validSolid, m as isShape1D, p as isFace, q as withScopeResult, t as castShape, v as isVertex, x as isClosedWire, y as isWire, z as createHandle } from "./shapeTypes-B_s2jyQ2.js";
-import { A as ok, B as unwrapOr, E as map, I as tryCatch, L as tryCatchAsync, O as mapErr, R as unwrap, T as isOk, V as unwrapOrElse, a as moduleInitError, b as err, c as sketcherStateError, d as validationError, g as OK, h as bug, i as kernelError, k as match, l as typeCastError, m as BrepBugError, n as computationError, o as queryError, r as ioError, u as unsupportedError, v as andThen, w as isErr, x as flatMap, y as collect, z as unwrapErr } from "./errors-0fYW_YnO.js";
+import { B as createKernelHandle, C as isOrientedFace, D as manifoldShell, E as isValidSolid, H as isLive, I as is2D, J as withScopeResultAsync, K as withScope, L as is3D, M as getShapeKind, O as orientedFace, R as DisposalScope, S as isManifoldShell, _ as isSolid, b as closedWire, d as isCompound, f as isEdge, g as isShell, h as isShape3D, j as validSolid, m as isShape1D, p as isFace, q as withScopeResult, t as castShape, v as isVertex, x as isClosedWire, y as isWire, z as createHandle } from "./shapeTypes-DGtDTS9s.js";
+import { A as ok, B as unwrapOr, E as map, I as tryCatch, L as tryCatchAsync, O as mapErr, R as unwrap, T as isOk, V as unwrapOrElse, a as moduleInitError, b as err, c as sketcherStateError, d as validationError, g as OK, h as bug, i as kernelError, k as match, l as typeCastError, m as BrepBugError, n as computationError, o as queryError, r as ioError, u as unsupportedError, v as andThen, w as isErr, x as flatMap, y as collect, z as unwrapErr } from "./errors-8GZS3vy9.js";
 import { n as HASH_CODE_MAX, r as RAD2DEG, t as DEG2RAD } from "./constants-Ci5CA3aZ.js";
 import { n as toVec2, r as toVec3, t as resolveDirection } from "./types-BIdk_GJY.js";
 import { a as vecDot, c as vecLength, d as vecNormalize, f as vecProjectToPlane, g as vecSub, h as vecScale, i as vecDistance, l as vecLengthSq, m as vecRotate, n as vecAngle, o as vecEquals, p as vecRepr, r as vecCross, s as vecIsZero, t as vecAdd, u as vecNegate } from "./vecOps-DVROrqTV.js";
-import { i as pivotPlane, n as createPlane, o as resolvePlane, s as translatePlane, t as createNamedPlane } from "./planeOps-4i2qEraD.js";
+import { i as pivotPlane, n as createPlane, o as resolvePlane, s as translatePlane, t as createNamedPlane } from "./planeOps-Bea3T3mc.js";
 export { BrepBugError, DEG2RAD, DisposalScope, HASH_CODE_MAX, OK, RAD2DEG, andThen, bug, castShape, closedWire, collect, computationError, createHandle, createKernelHandle, createNamedPlane, createPlane, err, flatMap, getShapeKind, ioError, is2D, is3D, isClosedWire, isCompound, isEdge, isErr, isFace, isLive, isManifoldShell, isOk, isOrientedFace, isShape1D, isShape3D, isShell, isSolid, isValidSolid, isVertex, isWire, kernelError, manifoldShell, map, mapErr, match, moduleInitError, ok, orientedFace, pivotPlane, queryError, resolveDirection, resolvePlane, sketcherStateError, toVec2, toVec3, translatePlane, tryCatch, tryCatchAsync, typeCastError, unsupportedError, unwrap, unwrapErr, unwrapOr, unwrapOrElse, validSolid, validationError, vecAdd, vecAngle, vecCross, vecDistance, vecDot, vecEquals, vecIsZero, vecLength, vecLengthSq, vecNegate, vecNormalize, vecProjectToPlane, vecRepr, vecRotate, vecScale, vecSub, withScope, withScopeResult, withScopeResultAsync };

package/dist/{cornerFinder-Cm58LsyX.cjs → cornerFinder-CXN1IxPg.cjs}

@@ -1,6 +1,6 @@
 const require_constants = require("./constants-DTorLmes.cjs");
 const require_arrayAccess = require("./arrayAccess-7pTWqkJu.cjs");
-const require_helpers = require("./helpers-CrH0p3GU.cjs");
+const require_helpers = require("./helpers-BU3ANziG.cjs");
 //#region src/query/cornerFinder.ts
 var PI_2 = 2 * Math.PI;
 function positiveHalfAngle(angle) {

package/dist/{cornerFinder-GBVBku2c.js → cornerFinder-tfWhcA2M.js}

@@ -1,6 +1,6 @@
 import { t as DEG2RAD } from "./constants-Ci5CA3aZ.js";
 import { n as getAtOrThrow } from "./arrayAccess-C5IWcxs9.js";
-import { _ as samePoint, p as distance2d, u as angle2d } from "./helpers-C7wU_L9l.js";
+import { _ as samePoint, p as distance2d, u as angle2d } from "./helpers-D1J5VHbk.js";
 //#region src/query/cornerFinder.ts
 var PI_2 = 2 * Math.PI;
 function positiveHalfAngle(angle) {

package/dist/csg/builders.d.ts

@@ -0,0 +1,36 @@
+import { ScalarInput, Vec3Input } from './expressions.js';
+import { BoxNode, SphereNode, CylinderNode, ConeNode, TorusNode, PolygonNode, CircleNode, LineNode, VertexLitNode, EmptyNode, FuseNode, CutNode, IntersectNode, FuseAllNode, CutAllNode, TranslateNode, RotateNode, ScaleNode, MirrorNode, CompoundNode, IRNode, SolidNode, FaceNode, EdgeNode, VertexNode } from './types.js';
+export declare function box(x: ScalarInput, y: ScalarInput, z: ScalarInput): BoxNode;
+export declare function sphere(radius: ScalarInput): SphereNode;
+export declare function cylinder(radius: ScalarInput, height: ScalarInput): CylinderNode;
+export declare function cone(radius1: ScalarInput, radius2: ScalarInput, height: ScalarInput): ConeNode;
+export declare function torus(majorRadius: ScalarInput, minorRadius: ScalarInput): TorusNode;
+export declare function polygon(points: ReadonlyArray<Vec3Input>): PolygonNode;
+export declare function circle(radius: ScalarInput): CircleNode;
+export declare function line(from: Vec3Input, to: Vec3Input): LineNode;
+export declare function vertex(point: Vec3Input): VertexLitNode;
+export declare function emptySolid(): EmptyNode;
+export declare function emptyFace(): EmptyNode;
+export declare function emptyWire(): EmptyNode;
+export declare function fuse(a: SolidNode, b: SolidNode, tolerance?: number): FuseNode;
+export declare function cut(a: SolidNode, b: SolidNode, tolerance?: number): CutNode;
+export declare function intersect(a: SolidNode, b: SolidNode, tolerance?: number): IntersectNode;
+export declare function fuseAll(shapes: ReadonlyArray<SolidNode>, tolerance?: number): FuseAllNode;
+export declare function cutAll(base: SolidNode, tools: ReadonlyArray<SolidNode>, tolerance?: number): CutAllNode;
+export declare function translate(target: IRNode, vector: Vec3Input): TranslateNode;
+export interface RotateOptions {
+    readonly axis?: Vec3Input | undefined;
+    readonly at?: Vec3Input | undefined;
+}
+export declare function rotate(target: IRNode, angle: ScalarInput, options?: RotateOptions): RotateNode;
+export interface ScaleOptions {
+    readonly center?: Vec3Input | undefined;
+}
+export declare function scale(target: IRNode, factor: ScalarInput, options?: ScaleOptions): ScaleNode;
+export interface MirrorOptions {
+    readonly normal?: Vec3Input | undefined;
+    readonly at?: Vec3Input | undefined;
+}
+export declare function mirror(target: IRNode, options?: MirrorOptions): MirrorNode;
+export declare function compound(children: ReadonlyArray<IRNode>): CompoundNode;
+export type { FaceNode, EdgeNode, VertexNode, SolidNode };

package/dist/csg/edit.d.ts

@@ -0,0 +1,5 @@
+import { IRNode } from './types.js';
+export type NodePredicate = (node: IRNode) => boolean;
+export declare function replaceNode(root: IRNode, pred: NodePredicate, replacement: IRNode): IRNode;
+export declare function forEachNode(root: IRNode, fn: (node: IRNode) => void): void;
+export declare function nodeCount(root: IRNode): number;

package/dist/csg/evaluate.d.ts

@@ -0,0 +1,52 @@
+import { Result } from '../core/result.js';
+import { AnyShape, Dimension } from '../core/shapeTypes.js';
+import { Env } from './expressions.js';
+import { IRNode } from './types.js';
+export interface EvaluatorOptions {
+    /** Kernel id to materialize against. Defaults to the currently-active kernel. */
+    readonly kernel?: string | undefined;
+    /** Default boolean tolerance applied when a node doesn't override it. */
+    readonly tolerance?: number | undefined;
+    /** Optional callback fired after each node is materialized (cache hits not reported). */
+    readonly onStep?: ((info: StepInfo) => void) | undefined;
+}
+export interface StepInfo {
+    readonly node: IRNode;
+    readonly cacheKey: string;
+    readonly cacheHit: boolean;
+}
+export interface CacheStats {
+    readonly hits: number;
+    readonly misses: number;
+    readonly entries: number;
+}
+export declare class Evaluator implements Disposable {
+    private readonly scope;
+    private readonly cache;
+    private readonly registered;
+    private readonly kernelId;
+    private readonly defaultTolerance;
+    private readonly onStep?;
+    private hits;
+    private misses;
+    constructor(options?: EvaluatorOptions);
+    /**
+     * Materialize a CSG IR tree against the given parameter environment.
+     * The returned shape is borrowed — valid for as long as this Evaluator is
+     * not disposed. Callers must NOT call `.delete()` / `[Symbol.dispose]()`
+     * on the returned shape; that would invalidate the cache entry for every
+     * future call returning the same handle.
+     */
+    evaluate(node: IRNode, env?: Env): Result<AnyShape<Dimension>>;
+    private evaluateInner;
+    cacheStats(): CacheStats;
+    resetStats(): void;
+    [Symbol.dispose](): void;
+}
+/**
+ * Run a callback with a fresh Evaluator that is disposed when the callback
+ * returns. Sync-only: an async callback would resolve after disposal,
+ * leaving borrowed shapes pointing at freed WASM memory. Mirrors the
+ * Promise-guard pattern in `withKernel`.
+ */
+export declare function withEvaluator<T extends Exclude<unknown, Promise<unknown>>>(options: EvaluatorOptions, fn: (evaluator: Evaluator) => T): T;

package/dist/csg/evaluators/booleans.d.ts

@@ -0,0 +1,11 @@
+import { Result } from '../../core/result.js';
+import { AnyShape, Dimension } from '../../core/shapeTypes.js';
+import { FuseNode, CutNode, IntersectNode, FuseAllNode, CutAllNode } from '../types.js';
+import { EvalContext } from './context.js';
+type S = Result<AnyShape<Dimension>>;
+export declare function evalFuse(node: FuseNode, ctx: EvalContext): S;
+export declare function evalCut(node: CutNode, ctx: EvalContext): S;
+export declare function evalIntersect(node: IntersectNode, ctx: EvalContext): S;
+export declare function evalFuseAll(node: FuseAllNode, ctx: EvalContext): S;
+export declare function evalCutAll(node: CutAllNode, ctx: EvalContext): S;
+export {};

package/dist/csg/evaluators/compound.d.ts

@@ -0,0 +1,8 @@
+import { Result } from '../../core/result.js';
+import { AnyShape, Dimension } from '../../core/shapeTypes.js';
+import { CompoundNode } from '../types.js';
+import { EvalContext } from './context.js';
+type S = Result<AnyShape<Dimension>>;
+export declare function evalCompound(node: CompoundNode, ctx: EvalContext): S;
+export declare function evalEmpty(): S;
+export {};

package/dist/csg/evaluators/context.d.ts

@@ -0,0 +1,9 @@
+import { AnyShape, Dimension } from '../../core/shapeTypes.js';
+import { Result } from '../../core/result.js';
+import { Env } from '../expressions.js';
+import { IRNode } from '../types.js';
+export interface EvalContext {
+    readonly env: Env;
+    readonly tolerance: number | undefined;
+    readonly evalNode: (node: IRNode) => Result<AnyShape<Dimension>>;
+}

package/dist/csg/evaluators/primitives.d.ts

@@ -0,0 +1,15 @@
+import { Result } from '../../core/result.js';
+import { AnyShape, Dimension } from '../../core/shapeTypes.js';
+import { BoxNode, SphereNode, CylinderNode, ConeNode, TorusNode, PolygonNode, CircleNode, LineNode, VertexLitNode } from '../types.js';
+import { EvalContext } from './context.js';
+type S = Result<AnyShape<Dimension>>;
+export declare function evalBox(node: BoxNode, ctx: EvalContext): S;
+export declare function evalSphere(node: SphereNode, ctx: EvalContext): S;
+export declare function evalCylinder(node: CylinderNode, ctx: EvalContext): S;
+export declare function evalCone(node: ConeNode, ctx: EvalContext): S;
+export declare function evalTorus(node: TorusNode, ctx: EvalContext): S;
+export declare function evalPolygon(node: PolygonNode, ctx: EvalContext): S;
+export declare function evalCircle(node: CircleNode, ctx: EvalContext): S;
+export declare function evalLine(node: LineNode, ctx: EvalContext): S;
+export declare function evalVertex(node: VertexLitNode, ctx: EvalContext): S;
+export {};

package/dist/csg/evaluators/transforms.d.ts

@@ -0,0 +1,10 @@
+import { Result } from '../../core/result.js';
+import { AnyShape, Dimension } from '../../core/shapeTypes.js';
+import { TranslateNode, RotateNode, ScaleNode, MirrorNode } from '../types.js';
+import { EvalContext } from './context.js';
+type S = Result<AnyShape<Dimension>>;
+export declare function evalTranslate(node: TranslateNode, ctx: EvalContext): S;
+export declare function evalRotate(node: RotateNode, ctx: EvalContext): S;
+export declare function evalScale(node: ScaleNode, ctx: EvalContext): S;
+export declare function evalMirror(node: MirrorNode, ctx: EvalContext): S;
+export {};

package/dist/csg/expressions.d.ts

@@ -0,0 +1,72 @@
+import { Vec2, Vec3 } from '../core/types.js';
+import { Result } from '../core/result.js';
+export interface ExprBase {
+    readonly structuralHash: bigint;
+    readonly freeParams: ReadonlySet<string>;
+}
+export interface NumLitExpr extends ExprBase {
+    readonly kind: 'NumLit';
+    readonly value: number;
+}
+export interface Vec3LitExpr extends ExprBase {
+    readonly kind: 'Vec3Lit';
+    readonly value: Vec3;
+}
+export interface Vec2LitExpr extends ExprBase {
+    readonly kind: 'Vec2Lit';
+    readonly value: Vec2;
+}
+export interface ParamExpr extends ExprBase {
+    readonly kind: 'Param';
+    readonly name: string;
+}
+export type BinaryOp = '+' | '-' | '*' | '/';
+export interface BinOpExpr extends ExprBase {
+    readonly kind: 'BinOp';
+    readonly op: BinaryOp;
+    readonly a: Expr;
+    readonly b: Expr;
+}
+export type UnaryOp = 'neg' | 'sin' | 'cos' | 'sqrt' | 'abs';
+export interface UnaryOpExpr extends ExprBase {
+    readonly kind: 'UnaryOp';
+    readonly op: UnaryOp;
+    readonly arg: Expr;
+}
+export interface ComponentExpr extends ExprBase {
+    readonly kind: 'Component';
+    readonly vec: Expr;
+    readonly index: 0 | 1 | 2;
+}
+export interface BuildVecExpr extends ExprBase {
+    readonly kind: 'BuildVec';
+    readonly dim: 2 | 3;
+    readonly components: readonly Expr[];
+}
+export type Expr = NumLitExpr | Vec3LitExpr | Vec2LitExpr | ParamExpr | BinOpExpr | UnaryOpExpr | ComponentExpr | BuildVecExpr;
+/** Value an expression can evaluate to. */
+export type ExprValue = number | Vec2 | Vec3;
+/** Parameter binding environment. */
+export type Env = Readonly<Record<string, ExprValue>>;
+/** Input shape for builder params — a literal or an expression. */
+export type ScalarInput = number | Expr;
+/** Either a literal Vec3, a mixed `[scalar-or-expr, ...]` tuple, or a bare Expr. */
+export type Vec3Input = Vec3 | readonly [ScalarInput, ScalarInput, ScalarInput] | Expr;
+export type Vec2Input = Vec2 | readonly [ScalarInput, ScalarInput] | Expr;
+export declare function numLit(value: number): NumLitExpr;
+export declare function vec3Lit(value: Vec3): Vec3LitExpr;
+export declare function vec2Lit(value: Vec2): Vec2LitExpr;
+export declare function param(name: string): ParamExpr;
+export declare function binOp(op: BinaryOp, a: Expr, b: Expr): BinOpExpr;
+export declare function unaryOp(op: UnaryOp, arg: Expr): UnaryOpExpr;
+export declare function component(vec: Expr, index: 0 | 1 | 2): ComponentExpr;
+export declare function buildVec(dim: 2 | 3, components: readonly Expr[]): BuildVecExpr;
+export declare const add: (a: Expr, b: Expr) => BinOpExpr;
+export declare const mul: (a: Expr, b: Expr) => BinOpExpr;
+export declare function asScalarExpr(input: ScalarInput): Expr;
+export declare function asVec3Expr(input: Vec3Input): Expr;
+export declare function asVec2Expr(input: Vec2Input): Expr;
+export declare function evalExpr(expr: Expr, env: Env): Result<ExprValue>;
+export declare function evalScalar(expr: Expr, env: Env, where: string): Result<number>;
+export declare function evalVec3(expr: Expr, env: Env, where: string): Result<Vec3>;
+export declare function projectEnv(env: Env, deps: ReadonlySet<string>): Env;

package/dist/csg/hash.d.ts

@@ -0,0 +1,9 @@
+export declare function fnvInit(): bigint;
+export declare function fnvMixByte(h: bigint, byte: number): bigint;
+export declare function fnvMixBytes(h: bigint, bytes: ArrayLike<number>): bigint;
+export declare function fnvMixString(h: bigint, s: string): bigint;
+export declare function fnvMixNumber(h: bigint, n: number): bigint;
+export declare function fnvMixHash(h: bigint, child: bigint): bigint;
+export declare function fnvMixInt32(h: bigint, n: number): bigint;
+export declare function fnvMixBool(h: bigint, b: boolean): bigint;
+export declare function toHex(h: bigint): string;

package/dist/csg/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * CSG IR — Constructive Solid Geometry as an Intermediate Representation.
+ *
+ * Build a content-addressed DAG of primitives, booleans, and transforms;
+ * parameterize via named expression bindings; evaluate against the active
+ * kernel with subtree-level cache reuse for incremental parametric edits.
+ */
+export { box, sphere, cylinder, cone, torus, polygon, circle, line, vertex, emptySolid, emptyFace, emptyWire, fuse, cut, intersect, fuseAll, cutAll, translate, rotate, scale, mirror, compound, type RotateOptions, type ScaleOptions, type MirrorOptions, } from './builders.js';
+export { numLit, vec3Lit, vec2Lit, param, binOp, unaryOp, component, buildVec, add, mul, asScalarExpr, asVec3Expr, asVec2Expr, type Expr, type ExprValue, type Env, type ScalarInput, type Vec3Input, type Vec2Input, type BinaryOp, type UnaryOp, } from './expressions.js';
+export type { IRNode, NodeKind, OutputKind, PrimitiveNode, BooleanNode, TransformIRNode, SolidNode, FaceNode, EdgeNode, VertexNode, AnyNode, } from './types.js';
+export { outputKindOf } from './types.js';
+export { Evaluator, withEvaluator, type EvaluatorOptions, type StepInfo, type CacheStats, } from './evaluate.js';
+export { toJSON, fromJSON, CSG_VERSION, type CsgEnvelope } from './serialize.js';
+export { optimize, foldExpr } from './optimize.js';
+export { replaceNode, forEachNode, nodeCount, type NodePredicate } from './edit.js';

package/dist/csg/optimize.d.ts

@@ -0,0 +1,4 @@
+import { Expr } from './expressions.js';
+import { IRNode } from './types.js';
+export declare function optimize(node: IRNode): IRNode;
+export declare function foldExpr(e: Expr): Expr;

package/dist/csg/serialize.d.ts

@@ -0,0 +1,9 @@
+import { Result } from '../core/result.js';
+import { IRNode } from './types.js';
+export declare const CSG_VERSION = 1;
+export interface CsgEnvelope {
+    readonly csgVersion: number;
+    readonly root: unknown;
+}
+export declare function toJSON(node: IRNode): CsgEnvelope;
+export declare function fromJSON(envelope: unknown): Result<IRNode>;

package/dist/csg/types.d.ts

@@ -0,0 +1,128 @@
+import { Expr } from './expressions.js';
+export type OutputKind = 'Solid' | 'Face' | 'Wire' | 'Edge' | 'Vertex' | 'Compound';
+/** Output kinds that have a corresponding empty-shape builder + serializer. */
+export type EmptyOutputKind = 'Solid' | 'Face' | 'Wire';
+export interface IRNodeBase {
+    readonly structuralHash: bigint;
+    readonly freeParams: ReadonlySet<string>;
+}
+export interface BoxNode extends IRNodeBase {
+    readonly kind: 'Box';
+    readonly x: Expr;
+    readonly y: Expr;
+    readonly z: Expr;
+}
+export interface SphereNode extends IRNodeBase {
+    readonly kind: 'Sphere';
+    readonly radius: Expr;
+}
+export interface CylinderNode extends IRNodeBase {
+    readonly kind: 'Cylinder';
+    readonly radius: Expr;
+    readonly height: Expr;
+}
+export interface ConeNode extends IRNodeBase {
+    readonly kind: 'Cone';
+    readonly radius1: Expr;
+    readonly radius2: Expr;
+    readonly height: Expr;
+}
+export interface TorusNode extends IRNodeBase {
+    readonly kind: 'Torus';
+    readonly majorRadius: Expr;
+    readonly minorRadius: Expr;
+}
+export interface PolygonNode extends IRNodeBase {
+    readonly kind: 'Polygon';
+    readonly points: readonly Expr[];
+}
+export interface CircleNode extends IRNodeBase {
+    readonly kind: 'Circle';
+    readonly radius: Expr;
+}
+export interface LineNode extends IRNodeBase {
+    readonly kind: 'Line';
+    readonly from: Expr;
+    readonly to: Expr;
+}
+export interface VertexLitNode extends IRNodeBase {
+    readonly kind: 'Vertex';
+    readonly point: Expr;
+}
+/** A typed empty shape — the identity element for booleans of its output kind. */
+export interface EmptyNode extends IRNodeBase {
+    readonly kind: 'Empty';
+    readonly output: EmptyOutputKind;
+}
+export interface FuseNode extends IRNodeBase {
+    readonly kind: 'Fuse';
+    readonly a: IRNode;
+    readonly b: IRNode;
+    readonly tolerance?: number | undefined;
+}
+export interface CutNode extends IRNodeBase {
+    readonly kind: 'Cut';
+    readonly a: IRNode;
+    readonly b: IRNode;
+    readonly tolerance?: number | undefined;
+}
+export interface IntersectNode extends IRNodeBase {
+    readonly kind: 'Intersect';
+    readonly a: IRNode;
+    readonly b: IRNode;
+    readonly tolerance?: number | undefined;
+}
+export interface FuseAllNode extends IRNodeBase {
+    readonly kind: 'FuseAll';
+    readonly shapes: readonly IRNode[];
+    readonly tolerance?: number | undefined;
+}
+export interface CutAllNode extends IRNodeBase {
+    readonly kind: 'CutAll';
+    readonly base: IRNode;
+    readonly tools: readonly IRNode[];
+    readonly tolerance?: number | undefined;
+}
+export interface TranslateNode extends IRNodeBase {
+    readonly kind: 'Translate';
+    readonly target: IRNode;
+    readonly vector: Expr;
+}
+export interface RotateNode extends IRNodeBase {
+    readonly kind: 'Rotate';
+    readonly target: IRNode;
+    readonly angle: Expr;
+    readonly axis?: Expr | undefined;
+    readonly at?: Expr | undefined;
+}
+export interface ScaleNode extends IRNodeBase {
+    readonly kind: 'Scale';
+    readonly target: IRNode;
+    readonly factor: Expr;
+    readonly center?: Expr | undefined;
+}
+export interface MirrorNode extends IRNodeBase {
+    readonly kind: 'Mirror';
+    readonly target: IRNode;
+    readonly normal?: Expr | undefined;
+    readonly at?: Expr | undefined;
+}
+export interface CompoundNode extends IRNodeBase {
+    readonly kind: 'Compound';
+    readonly children: readonly IRNode[];
+}
+export type PrimitiveNode = BoxNode | SphereNode | CylinderNode | ConeNode | TorusNode | PolygonNode | CircleNode | LineNode | VertexLitNode | EmptyNode;
+export type BooleanNode = FuseNode | CutNode | IntersectNode | FuseAllNode | CutAllNode;
+export type TransformIRNode = TranslateNode | RotateNode | ScaleNode | MirrorNode;
+export type IRNode = PrimitiveNode | BooleanNode | TransformIRNode | CompoundNode;
+export type NodeKind = IRNode['kind'];
+export type AnyNode = IRNode;
+/** Nodes that produce a 3D solid. */
+export type SolidNode = AnyNode;
+/** Nodes that produce a 2D or 3D face. */
+export type FaceNode = AnyNode;
+/** Nodes that produce an edge. */
+export type EdgeNode = AnyNode;
+/** Nodes that produce a vertex. */
+export type VertexNode = AnyNode;
+export declare function outputKindOf(node: IRNode): OutputKind;

package/dist/{curveFns-DVHUVmuO.js → curveFns-BEF8t7XY.js}

@@ -1,5 +1,5 @@
-import { X as getKernel, f as isEdge, t as castShape, y as isWire } from "./shapeTypes-B_s2jyQ2.js";
-import { A as ok, b as err, l as typeCastError } from "./errors-0fYW_YnO.js";
+import { Z as getKernel, f as isEdge, t as castShape, y as isWire } from "./shapeTypes-DGtDTS9s.js";
+import { A as ok, b as err, l as typeCastError } from "./errors-8GZS3vy9.js";
 //#region src/topology/curveFns.ts
 /**
 * Curve and 1D shape functions — functional replacements for _1DShape/Curve methods.

package/dist/{curveFns-Ds0e7i2y.cjs → curveFns-CcheHkr4.cjs}

@@ -1,5 +1,5 @@
-const require_shapeTypes = require("./shapeTypes-xj3nxBTM.cjs");
-const require_errors = require("./errors-Dv6pfNct.cjs");
+const require_shapeTypes = require("./shapeTypes-BpKhed-9.cjs");
+const require_errors = require("./errors-BiY8-q1s.cjs");
 //#region src/topology/curveFns.ts
 /**
 * Curve and 1D shape functions — functional replacements for _1DShape/Curve methods.

package/dist/{drawFns-CaWzI_lX.js → drawFns-CEjshioX.js}

@@ -1,22 +1,22 @@
-import { R as DisposalScope, X as getKernel, Y as _usingCtx, a as createEdge, o as createFace, u as createWire } from "./shapeTypes-B_s2jyQ2.js";
+import { R as DisposalScope, Y as _usingCtx, Z as getKernel, a as createEdge, o as createFace, u as createWire } from "./shapeTypes-DGtDTS9s.js";
 import { n as wasmIndex } from "./vec3-BRj3eI54.js";
-import { R as unwrap, h as bug, s as safeIndex } from "./errors-0fYW_YnO.js";
-import { o as getEdges } from "./topologyQueryFns-BcYn7Adz.js";
+import { R as unwrap, h as bug, s as safeIndex } from "./errors-8GZS3vy9.js";
+import { o as getEdges } from "./topologyQueryFns-CcWaCxeb.js";
 import { t as DEG2RAD } from "./constants-Ci5CA3aZ.js";
 import { r as toVec3 } from "./types-BIdk_GJY.js";
 import { d as vecNormalize, g as vecSub, h as vecScale, m as vecRotate, r as vecCross } from "./vecOps-DVROrqTV.js";
-import { a as planeToWorld, o as resolvePlane } from "./planeOps-4i2qEraD.js";
-import { _ as downcast, c as normalAt, l as outerWire, n as faceCenter, p as uvBounds, u as pointOnSurface } from "./faceFns-m0GePUMn.js";
-import { c as curveStartPoint, m as offsetWire2D, r as curveIsClosed } from "./curveFns-DVHUVmuO.js";
+import { a as planeToWorld, o as resolvePlane } from "./planeOps-Bea3T3mc.js";
+import { _ as downcast, c as normalAt, l as outerWire, n as faceCenter, p as uvBounds, u as pointOnSurface } from "./faceFns-BNhFoEII.js";
+import { c as curveStartPoint, m as offsetWire2D, r as curveIsClosed } from "./curveFns-BEF8t7XY.js";
 import { n as getAtOrThrow, r as lastOrThrow, t as firstOrThrow } from "./arrayAccess-C5IWcxs9.js";
-import { c as makeBSplineApproximation, d as makeCircle, f as makeEllipse, m as makeHelix, r as makeFace, s as assembleWire } from "./surfaceBuilders-DRxCelXR.js";
-import { a as Blueprints, c as make2dOffset, i as CompoundBlueprint, l as intersectCurves, n as BaseSketcher2d, o as chamferCurves, s as filletCurves, u as Flatbush } from "./blueprintSketcher-DlJ7yDBD.js";
-import { _ as samePoint$1, b as subtract2d, c as PRECISION_OFFSET, l as add2d, y as squareDistance2d } from "./helpers-C7wU_L9l.js";
-import { _ as Curve2D, a as edgeToCurve, c as make2dCircle, d as make2dInerpolatedBSplineCurve, f as make2dSegmentCurve, g as approximateAsSvgCompatibleCurve, i as curvesAsEdgesOnPlane, l as make2dEllipse, o as make2dArcFromCenter, t as Blueprint, v as deserializeCurve2D, y as BoundingBox2d } from "./blueprint-C-ngUkOG.js";
-import { t as cornerFinder } from "./cornerFinder-GBVBku2c.js";
-import { c as roundedRectangleBlueprint, n as fuse2D, r as intersect2D, s as polysidesBlueprint, t as cut2D } from "./boolean2D-C3x4nSLt.js";
-import { _ as wrapSketchDataArray, a as Sketch, g as wrapSketchData, i as Sketches, t as textBlueprints } from "./textBlueprints-D5zPssgR.js";
-import { i as projectEdges, t as cameraFromPlane } from "./cameraFns-Bix9SLAm.js";
+import { c as makeBSplineApproximation, d as makeCircle, f as makeEllipse, m as makeHelix, r as makeFace, s as assembleWire } from "./surfaceBuilders-zJyikeav.js";
+import { a as Blueprints, c as make2dOffset, i as CompoundBlueprint, l as intersectCurves, n as BaseSketcher2d, o as chamferCurves, s as filletCurves, u as Flatbush } from "./blueprintSketcher-DeEogKbs.js";
+import { _ as samePoint$1, b as subtract2d, c as PRECISION_OFFSET, l as add2d, y as squareDistance2d } from "./helpers-D1J5VHbk.js";
+import { _ as Curve2D, a as edgeToCurve, c as make2dCircle, d as make2dInerpolatedBSplineCurve, f as make2dSegmentCurve, g as approximateAsSvgCompatibleCurve, i as curvesAsEdgesOnPlane, l as make2dEllipse, o as make2dArcFromCenter, t as Blueprint, v as deserializeCurve2D, y as BoundingBox2d } from "./blueprint-Cy5veXS3.js";
+import { t as cornerFinder } from "./cornerFinder-tfWhcA2M.js";
+import { c as roundedRectangleBlueprint, n as fuse2D, r as intersect2D, s as polysidesBlueprint, t as cut2D } from "./boolean2D-lE2uy4Mm.js";
+import { _ as wrapSketchDataArray, a as Sketch, g as wrapSketchData, i as Sketches, t as textBlueprints } from "./textBlueprints-Bv6zhEyn.js";
+import { i as projectEdges, t as cameraFromPlane } from "./cameraFns-Dg1lQP0S.js";
 //#region src/2d/lib/stitching.ts
 /**
 * Group a flat list of curves into connected chains by matching endpoints.

package/dist/{drawFns-BvqZW_fK.cjs → drawFns-CuzUHFyD.cjs}

@@ -1,22 +1,22 @@
-const require_textBlueprints = require("./textBlueprints-Dy4xulfR.cjs");
-const require_shapeTypes = require("./shapeTypes-xj3nxBTM.cjs");
+const require_textBlueprints = require("./textBlueprints-CHh9SChA.cjs");
+const require_shapeTypes = require("./shapeTypes-BpKhed-9.cjs");
 const require_vec3 = require("./vec3-S4Oh59IX.cjs");
-const require_errors = require("./errors-Dv6pfNct.cjs");
-const require_topologyQueryFns = require("./topologyQueryFns-D0v-c2Xk.cjs");
+const require_errors = require("./errors-BiY8-q1s.cjs");
+const require_topologyQueryFns = require("./topologyQueryFns-CHsPXNbI.cjs");
 const require_constants = require("./constants-DTorLmes.cjs");
 const require_types = require("./types-CDkxah-M.cjs");
 const require_vecOps = require("./vecOps-D7xplSx8.cjs");
-const require_planeOps = require("./planeOps-CH4ruLuj.cjs");
-const require_faceFns = require("./faceFns-CbpUuSSF.cjs");
-const require_curveFns = require("./curveFns-Ds0e7i2y.cjs");
+const require_planeOps = require("./planeOps-2EyPq0tU.cjs");
+const require_faceFns = require("./faceFns-BbESdudy.cjs");
+const require_curveFns = require("./curveFns-CcheHkr4.cjs");
 const require_arrayAccess = require("./arrayAccess-7pTWqkJu.cjs");
-const require_surfaceBuilders = require("./surfaceBuilders-BkgewbNs.cjs");
-const require_blueprintSketcher = require("./blueprintSketcher-D2awQyoi.cjs");
-const require_helpers = require("./helpers-CrH0p3GU.cjs");
-const require_blueprint = require("./blueprint-Dn16jzZs.cjs");
-const require_cornerFinder = require("./cornerFinder-Cm58LsyX.cjs");
-const require_boolean2D = require("./boolean2D-BlazC0Yu.cjs");
-const require_cameraFns = require("./cameraFns-leKP1O1t.cjs");
+const require_surfaceBuilders = require("./surfaceBuilders-frj7YRrD.cjs");
+const require_blueprintSketcher = require("./blueprintSketcher-Cr9A-R8I.cjs");
+const require_helpers = require("./helpers-BU3ANziG.cjs");
+const require_blueprint = require("./blueprint-Bl0YQjkk.cjs");
+const require_cornerFinder = require("./cornerFinder-CXN1IxPg.cjs");
+const require_boolean2D = require("./boolean2D-BZ1UjpjX.cjs");
+const require_cameraFns = require("./cameraFns-CR2inEBU.cjs");
 //#region src/2d/lib/stitching.ts
 /**
 * Group a flat list of curves into connected chains by matching endpoints.

package/dist/{errors-0fYW_YnO.js → errors-8GZS3vy9.js}

@@ -339,6 +339,7 @@ var BrepErrorCode = {
 	CHAMFER_NOT_3D: "CHAMFER_NOT_3D",
 	CHAMFER_ANGLE_NOT_3D: "CHAMFER_ANGLE_NOT_3D",
 	CHAMFER_ANGLE_FAILED: "CHAMFER_ANGLE_FAILED",
+	CSG_NOT_3D: "CSG_NOT_3D",
 	SHELL_NOT_3D: "SHELL_NOT_3D",
 	OFFSET_NOT_3D: "OFFSET_NOT_3D",
 	NULL_SHAPE: "NULL_SHAPE",

package/dist/{errors-Dv6pfNct.cjs → errors-BiY8-q1s.cjs}

@@ -339,6 +339,7 @@ var BrepErrorCode = {
 	CHAMFER_NOT_3D: "CHAMFER_NOT_3D",
 	CHAMFER_ANGLE_NOT_3D: "CHAMFER_ANGLE_NOT_3D",
 	CHAMFER_ANGLE_FAILED: "CHAMFER_ANGLE_FAILED",
+	CSG_NOT_3D: "CSG_NOT_3D",
 	SHELL_NOT_3D: "SHELL_NOT_3D",
 	OFFSET_NOT_3D: "OFFSET_NOT_3D",
 	NULL_SHAPE: "NULL_SHAPE",

package/dist/{extrudeFns-BZAIPeYY.cjs → extrudeFns-BwU4ng1V.cjs}

@@ -1,5 +1,5 @@
-const require_shapeTypes = require("./shapeTypes-xj3nxBTM.cjs");
-const require_errors = require("./errors-Dv6pfNct.cjs");
+const require_shapeTypes = require("./shapeTypes-BpKhed-9.cjs");
+const require_errors = require("./errors-BiY8-q1s.cjs");
 const require_vecOps = require("./vecOps-D7xplSx8.cjs");
 //#region src/operations/extrudeUtils.ts
 /**

package/dist/{extrudeFns-vl1_n-yk.js → extrudeFns-gcWJSK9T.js}

@@ -1,5 +1,5 @@
-import { X as getKernel, c as createSolid, h as isShape3D, t as castShape, y as isWire } from "./shapeTypes-B_s2jyQ2.js";
-import { A as ok, b as err, d as validationError, i as kernelError, l as typeCastError, t as BrepErrorCode, w as isErr } from "./errors-0fYW_YnO.js";
+import { Z as getKernel, c as createSolid, h as isShape3D, t as castShape, y as isWire } from "./shapeTypes-DGtDTS9s.js";
+import { A as ok, b as err, d as validationError, i as kernelError, l as typeCastError, t as BrepErrorCode, w as isErr } from "./errors-8GZS3vy9.js";
 import { c as vecLength, d as vecNormalize, t as vecAdd } from "./vecOps-DVROrqTV.js";
 //#region src/operations/extrudeUtils.ts
 /**