brepjs 18.18.0 → 18.20.0

package/dist/brepjs.js

@@ -1,35 +1,35 @@
-import { $ as initFromOC, A as planarWire, B as createKernelHandle, C as isOrientedFace, D as manifoldShell, E as isValidSolid, F as as3D, H as isLive, I as is2D, J as withScopeResultAsync, K as withScope, L as is3D, M as getShapeKind, O as orientedFace, P as as2D, Q as init, R as DisposalScope, S as isManifoldShell, T as isPlanarWire, V as getDisposalStats, W as resetDisposalStats, X as getKernel, Y as _usingCtx, _ as isSolid, a as createEdge, at as BrepkitAdapter, b as closedWire, c as createSolid, d as isCompound, et as prewarm, f as isEdge, g as isShell, h as isShape3D, i as createCompound, it as supportsProjection, j as validSolid, k as planarFace, l as createVertex, m as isShape1D, n as castShape3D, nt as withKernel, o as createFace, ot as getPerformanceStats, p as isFace, q as withScopeResult, rt as supportsConstraintSketch, s as createShell, st as resetPerformanceStats, t as castShape, tt as registerKernel, u as createWire, v as isVertex, w as isPlanarFace, x as isClosedWire, y as isWire, z as createHandle } from "./shapeTypes-Dqjd8VMv.js";
+import { $ as init, A as planarWire, B as createKernelHandle, C as isOrientedFace, D as manifoldShell, E as isValidSolid, F as as3D, H as isLive, I as is2D, J as withScopeResultAsync, K as withScope, L as is3D, M as getShapeKind, O as orientedFace, P as as2D, R as DisposalScope, S as isManifoldShell, T as isPlanarWire, V as getDisposalStats, W as resetDisposalStats, X as getActiveKernelId, Y as _usingCtx, Z as getKernel, _ as isSolid, a as createEdge, at as supportsProjection, b as closedWire, c as createSolid, ct as resetPerformanceStats, d as isCompound, et as initFromOC, f as isEdge, g as isShell, h as isShape3D, i as createCompound, it as supportsConstraintSketch, j as validSolid, k as planarFace, l as createVertex, m as isShape1D, n as castShape3D, nt as registerKernel, o as createFace, ot as BrepkitAdapter, p as isFace, q as withScopeResult, rt as withKernel, s as createShell, st as getPerformanceStats, t as castShape, tt as prewarm, u as createWire, v as isVertex, w as isPlanarFace, x as isClosedWire, y as isWire, z as createHandle } from "./shapeTypes-DGtDTS9s.js";
 import { n as wasmIndex } from "./vec3-BRj3eI54.js";
 import { t as OcctWasmAdapter } from "./occtWasmAdapter--TZGP9DX.js";
-import { A as ok, B as unwrapOr, C as fromNullable, D as mapBoth, E as map, F as tapErr, H as zip, I as tryCatch, L as tryCatchAsync, M as orElse, N as pipeline, O as mapErr, P as tap, R as unwrap, S as flatten, T as isOk, V as unwrapOrElse, _ as all, a as moduleInitError, b as err, c as sketcherStateError, d as validationError, g as OK, h as bug, i as kernelError, j as or, k as match, l as typeCastError, m as BrepBugError, n as computationError, o as queryError, r as ioError, t as BrepErrorCode, u as unsupportedError, v as andThen, w as isErr, x as flatMap, y as collect, z as unwrapErr } from "./errors-0fYW_YnO.js";
-import { _ as kernelCall, a as getCachedSurfaceType, d as invalidateShapeCache, f as iterEdges, g as vertexPosition, h as iterWires, l as getVertices, m as iterVertices, n as getBounds, o as getEdges, p as iterFaces, s as getFaces, t as describe$1, u as getWires, v as kernelCallRaw, y as kernelCallScoped } from "./topologyQueryFns-DHbFP_6r.js";
+import { A as ok, B as unwrapOr, C as fromNullable, D as mapBoth, E as map, F as tapErr, H as zip, I as tryCatch, L as tryCatchAsync, M as orElse, N as pipeline, O as mapErr, P as tap, R as unwrap, S as flatten, T as isOk, V as unwrapOrElse, _ as all, a as moduleInitError, b as err, c as sketcherStateError, d as validationError, g as OK, h as bug, i as kernelError, j as or, k as match, l as typeCastError, m as BrepBugError, n as computationError, o as queryError, r as ioError, t as BrepErrorCode, u as unsupportedError, v as andThen, w as isErr, x as flatMap, y as collect, z as unwrapErr } from "./errors-8GZS3vy9.js";
+import { _ as kernelCall, a as getCachedSurfaceType, d as invalidateShapeCache, f as iterEdges, g as vertexPosition, h as iterWires, l as getVertices, m as iterVertices, n as getBounds, o as getEdges, p as iterFaces, s as getFaces, t as describe$1, u as getWires, v as kernelCallRaw, y as kernelCallScoped } from "./topologyQueryFns-CcWaCxeb.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, r as makePlane, s as translatePlane, t as createNamedPlane } from "./planeOps-4i2qEraD.js";
-import { _ as downcast, a as flipFaceOrientation, b as iterTopo, c as normalAt, d as projectPointOnFace, f as removeHolesFromFace, g as cast, h as asTopo, i as faceOrientation, l as outerWire, m as uvCoordinates, n as faceCenter, o as getSurfaceType, p as uvBounds, r as faceGeomType, s as innerWires, t as classifyPointOnFace, u as pointOnSurface, v as fromBREP, x as shapeType, y as isCompSolid } from "./faceFns-C9tfTZwq.js";
-import { C as findFacesByTag, D as tagFaces, E as setTagMetadata, O as getFaceOrigins, S as getShapeColor, T as getTagMetadata, a as isSameShape, b as colorShape, c as applyMatrix$1, d as resize, f as rotate$1, h as translate$1, i as isEqualShape, k as setShapeOrigin, l as composeTransforms, m as transformCopy$1, n as getHashCode, o as simplify$1, p as scale$1, r as isEmpty$2, s as toBREP$1, t as clone$1, u as mirror$1, w as getFaceTags, x as getFaceColor, y as colorFaces } from "./shapeFns-DaqT_8dv.js";
-import { a as curveLength, c as curveStartPoint, d as getCurveType, f as getOrientation, i as curveIsPeriodic, l as curveTangentAt, m as offsetWire2D, n as curveEndPoint, o as curvePeriod, p as interpolateCurve, r as curveIsClosed, s as curvePointAt, t as approximateCurve, u as flipOrientation } from "./curveFns-DkpbzRtv.js";
-import { a as meshEdges$1, c as createMeshCache, i as mesh$1, n as exportSTEP, o as meshMultiLOD, r as exportSTL, s as clearMeshCache, t as exportIGES } from "./meshFns-DWsgfwE8.js";
+import { i as pivotPlane, n as createPlane, o as resolvePlane, r as makePlane, s as translatePlane, t as createNamedPlane } from "./planeOps-Bea3T3mc.js";
+import { _ as downcast, a as flipFaceOrientation, b as iterTopo, c as normalAt, d as projectPointOnFace, f as removeHolesFromFace, g as cast, h as asTopo, i as faceOrientation, l as outerWire, m as uvCoordinates, n as faceCenter, o as getSurfaceType, p as uvBounds, r as faceGeomType, s as innerWires, t as classifyPointOnFace, u as pointOnSurface, v as fromBREP, x as shapeType, y as isCompSolid } from "./faceFns-BNhFoEII.js";
+import { C as findFacesByTag, D as tagFaces, E as setTagMetadata, O as getFaceOrigins, S as getShapeColor, T as getTagMetadata, a as isSameShape, b as colorShape, c as applyMatrix$1, d as resize, f as rotate$2, h as translate$2, i as isEqualShape, k as setShapeOrigin, l as composeTransforms, m as transformCopy$1, n as getHashCode, o as simplify$1, p as scale$2, r as isEmpty$2, s as toBREP$1, t as clone$1, u as mirror$2, w as getFaceTags, x as getFaceColor, y as colorFaces } from "./shapeFns-x8vqq2fR.js";
+import { a as curveLength, c as curveStartPoint, d as getCurveType, f as getOrientation, i as curveIsPeriodic, l as curveTangentAt, m as offsetWire2D, n as curveEndPoint, o as curvePeriod, p as interpolateCurve, r as curveIsClosed, s as curvePointAt, t as approximateCurve, u as flipOrientation } from "./curveFns-BEF8t7XY.js";
+import { a as meshEdges$1, c as createMeshCache, i as mesh$1, n as exportSTEP, o as meshMultiLOD, r as exportSTL, s as clearMeshCache, t as exportIGES } from "./meshFns-k0BdoBGR.js";
 import { n as getAtOrThrow, r as lastOrThrow, t as firstOrThrow } from "./arrayAccess-C5IWcxs9.js";
-import { _ as makeThreePointArc, d as makeCircle, h as makeLine, l as makeBSplineInterpolation, n as fill, r as makeFace, s as assembleWire } from "./surfaceBuilders-CuChXov6.js";
-import { a as fuseAll, c as sectionToFace$1, i as fuse$1, l as slice$1, n as cut$1, o as intersect$1, r as cutAll, s as section$1, t as booleanPipeline, u as split$1 } from "./booleanFns-D4r10eG8.js";
-import { $ as getNurbsSurfaceData, A as fixShape, B as offset$1, C as threePointArc, D as wireLoop, E as wire, F as isValid$1, G as chamferWithEvolution, H as thicken$1, I as solidFromShell, J as fuseWithEvolution, K as cutWithEvolution, L as chamfer$1, M as healFace, N as healSolid, O as autoHeal, P as healWire, Q as getNurbsCurveData, R as draft$1, S as tangentArc, T as vertex, U as variableFillet, V as shell$1, W as positionOnCurve, X as shellWithEvolution, Y as intersectWithEvolution, Z as checkBoolean, _ as polygon, a as circle, at as wiresOfFace, b as sphere, c as cylinder, ct as toGroupedBufferGeometryData, d as ellipsoid, et as adjacentFaces, f as face, g as offsetFace, h as line, i as bsplineApprox, it as verticesOfEdge, j as heal$1, k as fixSelfIntersection, l as ellipse, lt as toLODGeometryData, m as helix, n as bezier, nt as facesOfEdge, o as compound, ot as chamferDistAngle, p as filledFace, q as filletWithEvolution, r as box, rt as sharedEdges, s as cone, st as toBufferGeometryData, t as addHoles, tt as edgesOfFace, u as ellipseArc, ut as toLineGeometryData, v as sewShells, w as torus, x as subFace, y as solid, z as fillet$1 } from "./primitiveFns-BLIDnaB4.js";
-import { C as walkAssembly, D as exportAssemblySTEP, E as linearPattern, O as createAssembly, S as updateNode, _ as collectShapes, a as findStep, b as findNode, c as registerOperation, d as replayHistory, f as serializeHistory, g as addChild, h as undoLast, i as deserializeHistory, l as registerShape, m as stepsFrom, n as createHistory, o as getShape, p as stepCount, r as createRegistry, s as modifyStep, t as addStep, u as replayFrom, v as countNodes, w as circularPattern, x as removeChild, y as createAssemblyNode } from "./historyFns-B4M2dl-F.js";
-import { n as BaseSketcher2d, r as organiseBlueprints, t as BlueprintSketcher } from "./blueprintSketcher-mujcO3uV.js";
-import { a as createTypedFinder, i as wireFinder, n as edgeFinder, r as faceFinder, t as getSingleFace } from "./helpers-D3JzEtZl.js";
-import { A as sketchEllipse, D as makeBaseBox, E as deserializeDrawing, F as sketchRectangle, I as sketchRoundedRectangle, L as FaceSketcher, M as sketchHelix, N as sketchParametricFunction, O as polysideInnerRadius, P as sketchPolysides, R as Sketcher, S as drawText, _ as drawPolysides, a as drawingIntersect, b as drawSingleCircle, c as rotateDrawing, d as drawFaceOutline, f as drawProjection, g as drawPointsInterpolation, h as drawParametricFunction, i as drawingFuse, j as sketchFaceOffset, k as sketchCircle, l as scaleDrawing, m as drawEllipse, n as drawingCut, o as drawingToSketchOnPlane, p as drawCircle, r as drawingFillet, s as mirrorDrawing, t as drawingChamfer, u as translateDrawing, v as drawRectangle, w as draw, x as drawSingleEllipse, y as drawRoundedRectangle } from "./drawFns-1JQUg7iu.js";
-import { r as makeCylinder } from "./solidBuilders-CYtiaHtQ.js";
-import { a as measureDistance, c as measureLinearProps, d as measureVolumeProps, i as measureCurvatureAtMid, l as measureSurfaceProps, n as measureArea, o as measureDistanceProps, r as measureCurvatureAt, s as measureLength, t as createDistanceQuery, u as measureVolume } from "./measureFns-BTip3Aiz.js";
-import { t as cornerFinder } from "./cornerFinder-KEk4VpTe.js";
-import { a as fuseBlueprints, c as roundedRectangleBlueprint, i as cutBlueprints, n as fuse2D, o as intersectBlueprints, r as intersect2D, s as polysidesBlueprint, t as cut2D } from "./boolean2D-CdSpNYuw.js";
-import { S as reverseCurve, _ as curve2dIsOnCurve, a as isInside2D, b as curve2dSplitAt, c as scale2D, d as stretch2D, f as toSVGPathD, g as curve2dFirstPoint, h as curve2dDistanceFrom, i as getOrientation2D, l as sketchOnFace2D, m as curve2dBoundingBox, n as createCompoundBlueprint, o as mirror2D, p as translate2D, r as getBounds2D, s as rotate2D, t as createBlueprint, u as sketchOnPlane2D, v as curve2dLastPoint, x as curve2dTangentAt, y as curve2dParameter } from "./blueprintFns-BKCwR41V.js";
-import { a as importSVG, c as blueprintToDXF, d as exportGltf, f as exportOBJ, i as exportSTEPConfigured, l as exportDXF, n as importSTEP, o as importSVGPathD, r as importSTL, s as exportThreeMF, t as importIGES, u as exportGlb } from "./importFns-CJd7ltsW.js";
-import { a as guidedSweep, c as sweep, i as complexExtrude, l as twistExtrude, n as extrudeAll, o as multiSectionSweep, r as revolve$1, s as supportExtrude, t as extrude$1 } from "./extrudeFns-hUNicYgI.js";
-import { a as Sketch, b as loftAll, c as compoundSketchLoft, d as sketchFace, f as sketchLoft, h as sketchWires, i as Sketches, l as compoundSketchRevolve, m as sketchSweep, n as getFont, o as compoundSketchExtrude, p as sketchRevolve, r as loadFont, s as compoundSketchFace, t as textBlueprints, u as sketchExtrude, v as CompoundSketch, y as loft$1 } from "./textBlueprints-Cm_gPjjQ.js";
-import { a as makeProjectedEdges, i as projectEdges, n as cameraLookAt, r as createCamera, s as isProjectionPlane, t as cameraFromPlane } from "./cameraFns-DfqWQ17C.js";
-import { n as textMetrics, r as sketchText, t as fontMetrics } from "./textMetrics-Dbgikkim.js";
-import { a as updateRoles, i as resolveRef, n as captureHint, o as defaultScorer, r as createRef, t as assignRoles } from "./shapeRefFns-BEsxgYOo.js";
+import { _ as makeThreePointArc, d as makeCircle, h as makeLine, l as makeBSplineInterpolation, n as fill, r as makeFace, s as assembleWire } from "./surfaceBuilders-zJyikeav.js";
+import { a as fuseAll, c as sectionToFace$1, i as fuse$2, l as slice$1, n as cut$2, o as intersect$2, r as cutAll, s as section$1, t as booleanPipeline, u as split$1 } from "./booleanFns-CtvYfQZq.js";
+import { $ as fuseAllBisect, A as fixShape, B as offset$1, C as threePointArc, D as wireLoop, E as wire, F as isValid$1, G as chamferWithEvolution, H as thicken$1, I as solidFromShell, J as fuseWithEvolution, K as cutWithEvolution, L as chamfer$1, M as healFace, N as healSolid, O as autoHeal, P as healWire, Q as cutAllBisect, R as draft$1, S as tangentArc, T as vertex, U as variableFillet, V as shell$1, W as positionOnCurve, X as shellWithEvolution, Y as intersectWithEvolution, Z as checkBoolean, _ as polygon, a as circle, at as sharedEdges, b as sphere, c as cylinder, ct as chamferDistAngle, d as ellipsoid, dt as toLODGeometryData, et as getNurbsCurveData, f as face, ft as toLineGeometryData, g as offsetFace, h as line, i as bsplineApprox, it as facesOfEdge, j as heal$1, k as fixSelfIntersection, l as ellipse, lt as toBufferGeometryData, m as helix, n as bezier, nt as adjacentFaces, o as compound, ot as verticesOfEdge, p as filledFace, q as filletWithEvolution, r as box, rt as edgesOfFace, s as cone, st as wiresOfFace, t as addHoles, tt as getNurbsSurfaceData, u as ellipseArc, ut as toGroupedBufferGeometryData, v as sewShells, w as torus, x as subFace, y as solid, z as fillet$1 } from "./primitiveFns-BsO-feBX.js";
+import { C as walkAssembly, D as exportAssemblySTEP, E as linearPattern, O as createAssembly, S as updateNode, _ as collectShapes, a as findStep, b as findNode, c as registerOperation, d as replayHistory, f as serializeHistory, g as addChild, h as undoLast, i as deserializeHistory, l as registerShape, m as stepsFrom, n as createHistory, o as getShape, p as stepCount, r as createRegistry, s as modifyStep, t as addStep, u as replayFrom, v as countNodes, w as circularPattern, x as removeChild, y as createAssemblyNode } from "./historyFns-XZp1D_aA.js";
+import { n as BaseSketcher2d, r as organiseBlueprints, t as BlueprintSketcher } from "./blueprintSketcher-DeEogKbs.js";
+import { a as createTypedFinder, i as wireFinder, n as edgeFinder, r as faceFinder, t as getSingleFace } from "./helpers-D1J5VHbk.js";
+import { A as sketchEllipse, D as makeBaseBox, E as deserializeDrawing, F as sketchRectangle, I as sketchRoundedRectangle, L as FaceSketcher, M as sketchHelix, N as sketchParametricFunction, O as polysideInnerRadius, P as sketchPolysides, R as Sketcher, S as drawText, _ as drawPolysides, a as drawingIntersect, b as drawSingleCircle, c as rotateDrawing, d as drawFaceOutline, f as drawProjection, g as drawPointsInterpolation, h as drawParametricFunction, i as drawingFuse, j as sketchFaceOffset, k as sketchCircle, l as scaleDrawing, m as drawEllipse, n as drawingCut, o as drawingToSketchOnPlane, p as drawCircle, r as drawingFillet, s as mirrorDrawing, t as drawingChamfer, u as translateDrawing, v as drawRectangle, w as draw, x as drawSingleEllipse, y as drawRoundedRectangle } from "./drawFns-CEjshioX.js";
+import { r as makeCylinder } from "./solidBuilders-Cot05qzs.js";
+import { a as measureDistance, c as measureLinearProps, d as measureVolumeProps, i as measureCurvatureAtMid, l as measureSurfaceProps, n as measureArea, o as measureDistanceProps, r as measureCurvatureAt, s as measureLength, t as createDistanceQuery, u as measureVolume } from "./measureFns-C3y_WX_E.js";
+import { t as cornerFinder } from "./cornerFinder-tfWhcA2M.js";
+import { a as fuseBlueprints, c as roundedRectangleBlueprint, i as cutBlueprints, n as fuse2D, o as intersectBlueprints, r as intersect2D, s as polysidesBlueprint, t as cut2D } from "./boolean2D-lE2uy4Mm.js";
+import { S as reverseCurve, _ as curve2dIsOnCurve, a as isInside2D, b as curve2dSplitAt, c as scale2D, d as stretch2D, f as toSVGPathD, g as curve2dFirstPoint, h as curve2dDistanceFrom, i as getOrientation2D, l as sketchOnFace2D, m as curve2dBoundingBox, n as createCompoundBlueprint, o as mirror2D, p as translate2D, r as getBounds2D, s as rotate2D, t as createBlueprint, u as sketchOnPlane2D, v as curve2dLastPoint, x as curve2dTangentAt, y as curve2dParameter } from "./blueprintFns-CSB51aXT.js";
+import { a as importSVG, c as blueprintToDXF, d as exportGltf, f as exportOBJ, i as exportSTEPConfigured, l as exportDXF, n as importSTEP, o as importSVGPathD, r as importSTL, s as exportThreeMF, t as importIGES, u as exportGlb } from "./importFns-D1oB3yU8.js";
+import { a as guidedSweep, c as sweep, i as complexExtrude, l as twistExtrude, n as extrudeAll, o as multiSectionSweep, r as revolve$1, s as supportExtrude, t as extrude$1 } from "./extrudeFns-gcWJSK9T.js";
+import { a as Sketch, b as loftAll, c as compoundSketchLoft, d as sketchFace, f as sketchLoft, h as sketchWires, i as Sketches, l as compoundSketchRevolve, m as sketchSweep, n as getFont, o as compoundSketchExtrude, p as sketchRevolve, r as loadFont, s as compoundSketchFace, t as textBlueprints, u as sketchExtrude, v as CompoundSketch, y as loft$1 } from "./textBlueprints-Bv6zhEyn.js";
+import { a as makeProjectedEdges, i as projectEdges, n as cameraLookAt, r as createCamera, s as isProjectionPlane, t as cameraFromPlane } from "./cameraFns-Dg1lQP0S.js";
+import { n as textMetrics, r as sketchText, t as fontMetrics } from "./textMetrics-vUJTTEFi.js";
+import { a as updateRoles, i as resolveRef, n as captureHint, o as defaultScorer, r as createRef, t as assignRoles } from "./shapeRefFns-CE0yS0EB.js";
 import { a as createTaskQueue, c as isEmpty$1, d as isDisposeRequest, f as isErrorResponse, h as isSuccessResponse, i as createWorkerClient, l as pendingCount, m as isOperationRequest, n as createWorkerHandler, o as dequeueTask, p as isInitRequest, r as registerHandler, s as enqueueTask, t as createOperationRegistry, u as rejectAll } from "./workerHandler-DaulgMax.js";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
@@ -1993,17 +1993,17 @@ function resolve3D(s) {
 //#region src/topology/api.ts
 /** Translate a shape by a vector. Returns a new shape. */
 function translate(shape, v) {
-	return translate$1(resolve(shape), v);
+	return translate$2(resolve(shape), v);
 }
 /** Rotate a shape around an axis. Angle is in degrees. Returns a new shape. */
 function rotate(shape, angle, options) {
 	const pivotPoint = options?.at;
-	return rotate$1(resolve(shape), angle, pivotPoint, options?.axis);
+	return rotate$2(resolve(shape), angle, pivotPoint, options?.axis);
 }
 /** Mirror a shape through a plane. Returns a new shape. */
 function mirror(shape, options) {
 	const planeOrigin = options?.at;
-	return mirror$1(resolve(shape), options?.normal ?? [
+	return mirror$2(resolve(shape), options?.normal ?? [
 		1,
 		0,
 		0
@@ -2011,7 +2011,7 @@ function mirror(shape, options) {
 }
 /** Scale a shape uniformly. Returns a new shape. */
 function scale(shape, factor, options) {
-	return scale$1(resolve(shape), factor, options?.center);
+	return scale$2(resolve(shape), factor, options?.center);
 }
 /** Clone a shape (deep copy). */
 function clone(shape) {
@@ -2036,21 +2036,21 @@ function transformCopy(shape, composed) {
 }
 /** Fuse two 3D shapes (boolean union). */
 function fuse(a, b, options) {
-	return fuse$1(resolve(a), resolve(b), {
+	return fuse$2(resolve(a), resolve(b), {
 		...options,
 		unsafe: true
 	});
 }
 /** Cut a tool from a base shape (boolean subtraction). */
 function cut(base, tool, options) {
-	return cut$1(resolve(base), resolve(tool), {
+	return cut$2(resolve(base), resolve(tool), {
 		...options,
 		unsafe: true
 	});
 }
 /** Compute the intersection of two shapes (boolean common). */
 function intersect(a, b, options) {
-	return intersect$1(resolve(a), resolve(b), {
+	return intersect$2(resolve(a), resolve(b), {
 		...options,
 		unsafe: true
 	});
@@ -2353,7 +2353,7 @@ function drill(shape, options) {
 			pos[2] + dir[2] * tMin
 		], dir);
 	}
-	return cut$1(s, tool, { unsafe: true });
+	return cut$2(s, tool, { unsafe: true });
 }
 /**
 * Cut a pocket (2D profile extruded inward) into a shape.
@@ -2372,9 +2372,9 @@ function pocket(shape, options) {
 	const center = faceCenter(targetFace);
 	const faceResult = makeFace(toWire(profile));
 	if (isErr(faceResult)) return faceResult;
-	const toolResult = extrude$1(translate$1(faceResult.value, center), vecScale(vecNormalize(normal), -depth));
+	const toolResult = extrude$1(translate$2(faceResult.value, center), vecScale(vecNormalize(normal), -depth));
 	if (isErr(toolResult)) return toolResult;
-	return cut$1(s, toolResult.value, { unsafe: true });
+	return cut$2(s, toolResult.value, { unsafe: true });
 }
 /**
 * Add a boss (2D profile extruded outward) onto a shape.
@@ -2393,9 +2393,9 @@ function boss(shape, options) {
 	const center = faceCenter(targetFace);
 	const faceResult = makeFace(toWire(profile));
 	if (isErr(faceResult)) return faceResult;
-	const toolResult = extrude$1(translate$1(faceResult.value, center), vecScale(vecNormalize(normal), height));
+	const toolResult = extrude$1(translate$2(faceResult.value, center), vecScale(vecNormalize(normal), height));
 	if (isErr(toolResult)) return toolResult;
-	return fuse$1(s, toolResult.value, { unsafe: true });
+	return fuse$2(s, toolResult.value, { unsafe: true });
 }
 /**
 * Mirror a shape and fuse it with the original.
@@ -2411,7 +2411,7 @@ function mirrorJoin(shape, options) {
 	];
 	const planeOrigin = options?.at;
 	if (vecIsZero(normal)) return err(validationError("MIRROR_ZERO_NORMAL", "Mirror plane normal cannot be zero"));
-	return fuse$1(s, mirror$1(s, normal, planeOrigin), { unsafe: true });
+	return fuse$2(s, mirror$2(s, normal, planeOrigin), { unsafe: true });
 }
 /**
 * Create a rectangular (2D grid) pattern of a shape.
@@ -2436,7 +2436,7 @@ function rectangularPattern(shape, options) {
 			xNorm[1] * xSpacing * xi + yNorm[1] * ySpacing * yi,
 			xNorm[2] * xSpacing * xi + yNorm[2] * ySpacing * yi
 		];
-		copies.push(translate$1(s, offset));
+		copies.push(translate$2(s, offset));
 	}
 	return fuseAll(copies, { unsafe: true });
 }
@@ -2882,12 +2882,12 @@ function makeInternalGearProfileWire(params) {
 }
 function makeProfileWire(params, isInternal) {
 	try {
-		var _usingCtx$2 = _usingCtx();
+		var _usingCtx$3 = _usingCtx();
 		const { teeth, moduleSize, pressureAngle, shift, clearance, flankThinning, samples = adaptiveSampleCount(moduleSize) } = params;
 		if (teeth < 4) return err(validationError("GEAR_TEETH_TOO_FEW", `gear needs ≥ 4 teeth, got ${teeth}`));
 		if (moduleSize <= 0) return err(validationError("GEAR_MODULE_NONPOSITIVE", `module must be > 0, got ${moduleSize}`));
 		const tm = gearGeometry(teeth, moduleSize, pressureAngle, shift, clearance, flankThinning, isInternal);
-		const scope = _usingCtx$2.u(new DisposalScope());
+		const scope = _usingCtx$3.u(new DisposalScope());
 		const allEdges = [];
 		for (let i = 0; i < teeth; i++) {
 			const periodEdges = buildToothPeriodEdges(tm, i, teeth, samples, scope);
@@ -2898,9 +2898,9 @@ function makeProfileWire(params, isInternal) {
 		if (isErr(wireResult)) return wireResult;
 		return ok(wireResult.value);
 	} catch (_) {
-		_usingCtx$2.e = _;
+		_usingCtx$3.e = _;
 	} finally {
-		_usingCtx$2.d();
+		_usingCtx$3.d();
 	}
 }
 //#endregion
@@ -3081,8 +3081,8 @@ function resolvePlanetaryParams(params) {
 }
 function makeOuterCircleWire(radius) {
 	try {
-		var _usingCtx$1 = _usingCtx();
-		const wireResult = assembleWire([_usingCtx$1.u(new DisposalScope()).register(makeCircle(radius, [
+		var _usingCtx$2 = _usingCtx();
+		const wireResult = assembleWire([_usingCtx$2.u(new DisposalScope()).register(makeCircle(radius, [
 			0,
 			0,
 			0
@@ -3094,9 +3094,9 @@ function makeOuterCircleWire(radius) {
 		if (isErr(wireResult)) return wireResult;
 		return ok(wireResult.value);
 	} catch (_) {
-		_usingCtx$1.e = _;
+		_usingCtx$2.e = _;
 	} finally {
-		_usingCtx$1.d();
+		_usingCtx$2.d();
 	}
 }
 function finalizeExternalSolid(wire, thickness, bore, geom, diagnostics) {
@@ -3122,12 +3122,12 @@ function finalizeExternalSolid(wire, thickness, bore, geom, diagnostics) {
 		]);
 		if (isErr(boreRaw)) return boreRaw;
 		boreScope.register(boreRaw.value);
-		const boreSolid = boreScope.register(translate$1(boreRaw.value, [
+		const boreSolid = boreScope.register(translate$2(boreRaw.value, [
 			0,
 			0,
 			-.5
 		]));
-		const cutResult = cut$1(solidResult.value, boreSolid);
+		const cutResult = cut$2(solidResult.value, boreSolid);
 		if (isErr(cutResult)) return cutResult;
 		return ok(buildGearResult(cutResult.value, geom, diagnostics));
 	} catch (_) {
@@ -3167,14 +3167,14 @@ function placePlanets(planetProto, cfg) {
 	try {
 		for (let i = 0; i < cfg.numPlanets; i++) {
 			const orbital = i * 2 * Math.PI / cfg.numPlanets;
-			const rotated = rotate$1(planetProto, planetSelfRotationAngle(orbital, cfg.sunTeeth, cfg.planetTeeth) * 180 / Math.PI);
+			const rotated = rotate$2(planetProto, planetSelfRotationAngle(orbital, cfg.sunTeeth, cfg.planetTeeth) * 180 / Math.PI);
 			try {
 				const offset = [
 					cfg.centerDistance * Math.cos(orbital),
 					cfg.centerDistance * Math.sin(orbital),
 					0
 				];
-				planets.push(translate$1(rotated, offset));
+				planets.push(translate$2(rotated, offset));
 			} finally {
 				rotated.delete();
 			}
@@ -3188,7 +3188,7 @@ function placePlanets(planetProto, cfg) {
 function applyRingPhase(ring, zr) {
 	const phaseRad = evenToothPhaseOffset(zr);
 	if (phaseRad === 0) return ring;
-	const rotated = rotate$1(ring, phaseRad * 180 / Math.PI);
+	const rotated = rotate$2(ring, phaseRad * 180 / Math.PI);
 	ring.delete();
 	return rotated;
 }
@@ -3306,8 +3306,10 @@ var booleans_exports = /* @__PURE__ */ __exportAll({
 	convexHull: () => convexHull,
 	cut: () => cut,
 	cutAll: () => cutAll,
+	cutAllBisect: () => cutAllBisect,
 	fuse: () => fuse,
 	fuseAll: () => fuseAll,
+	fuseAllBisect: () => fuseAllBisect,
 	hull: () => hull,
 	intersect: () => intersect,
 	minkowski: () => minkowski,
@@ -3415,4 +3417,1685 @@ var patterns_exports = /* @__PURE__ */ __exportAll({
 	linearPattern: () => linearPattern
 });
 //#endregion
-export { BaseSketcher2d, BlueprintSketcher, BrepBugError, BrepErrorCode, BrepWrapperError, BrepkitAdapter, CompoundSketch, DEG2RAD, DisposalScope, FaceSketcher, HASH_CODE_MAX, OK, OcctWasmAdapter, RAD2DEG, Sketch, Sketcher, Sketches, addChild, addHoles, addMate, addStep, adjacentFaces, all, andThen, applyGlue, applyMatrix, approximateCurve, as2D, as3D, asTopo, assignRoles, autoHeal, bezier, blueprintToDXF, booleanPipeline, booleans_exports as booleans, boss, box, bsplineApprox, bug, cameraFromPlane, cameraLookAt, captureHint, cast, castShape, castShape3D, chamfer, chamferDistAngle as chamferDistAngleShape, chamferWithEvolution, checkAllInterferences, checkBoolean, checkInterference, circle, circularPattern, classifyPointOnFace, clearMeshCache, clone, closedWire, collect, collectShapes, colorFaces, colorShape, complexExtrude, composeTransforms, compound, compoundSketchExtrude, compoundSketchFace, compoundSketchLoft, compoundSketchRevolve, computationError, computeStraightSkeleton, cone, construction_exports as construction, convexHull, cornerFinder, countNodes, createAssembly, createAssemblyNode, createBlueprint, createCamera, createCompound, createCompoundBlueprint, createDistanceQuery, createEdge, createFace, createHandle, createHistory, createKernelHandle, createMeshCache, createNamedPlane, createOperationRegistry, createPlane, createRef, createRegistry, createShell, createSolid, createTaskQueue, createVertex, createWire, createWorkerClient, createWorkerHandler, curve2dBoundingBox, curve2dDistanceFrom, curve2dFirstPoint, curve2dIsOnCurve, curve2dLastPoint, curve2dParameter, curve2dSplitAt, curve2dTangentAt, curveEndPoint, curveIsClosed, curveIsPeriodic, curveLength, curvePeriod, curvePointAt, curveStartPoint, curveTangentAt, cut, cut2D, cutAll, cutBlueprints, cutWithEvolution, cylinder, defaultScorer, dequeueTask, describe, deserializeDrawing, deserializeHistory, fromBREP as deserializeShape, downcast, draft, draw, drawCircle, drawEllipse, drawFaceOutline, drawParametricFunction, drawPointsInterpolation, drawPolysides, drawProjection, drawRectangle, drawRoundedRectangle, drawSingleCircle, drawSingleEllipse, drawText, drawingChamfer, drawingCut, drawingFillet, drawingFuse, drawingIntersect, drawingToSketchOnPlane, drill, edgeFinder, edgesOfFace, ellipse, ellipseArc, ellipsoid, enqueueTask, err, exportAssemblySTEP, exportDXF, exportGlb, exportGltf, exportIGES, exportOBJ, exportSTEP, exportSTEPConfigured, exportSTL, exportThreeMF, extrude, extrudeAll, face, faceCenter, faceFinder, faceGeomType, faceOrientation, facesOfEdge, fill, filledFace, fillet, filletWithEvolution, findFacesByTag, findNode, findStep, fixSelfIntersection, fixShape, flatMap, flatten, flipFaceOrientation, flipOrientation, fontMetrics, fromBREP$1 as fromBREP, fromKernelDir, fromKernelPnt, fromKernelVec, fromNullable, fuse, fuse2D, fuseAll, fuseBlueprints, fuseWithEvolution, gearGeometry, getBounds, getBounds2D, getCurveType, getDisposalStats, getEdges, getFaceColor, getFaceOrigins, getFaceTags, getFaces, getFont, getHashCode, getShape as getHistoryShape, getKernel, getNurbsCurveData, getNurbsSurfaceData, getOrientation, getOrientation2D, getPerformanceStats, getShapeColor, getShapeKind, getSingleFace, getSurfaceType, getTagMetadata, getVertices, getWires, guidedSweep, heal, healFace, healSolid, healWire, helix, hull, importDXF, importGLB, importIGES, importOBJ, importSTEP, importSTL, importSVG, importSVGPathD, importThreeMF, init, initFromOC, innerWires, interpolateCurve, intersect, intersect2D, intersectBlueprints, intersectWithEvolution, invalidateShapeCache, ioNs_exports as io, ioError, is2D, is3D, isChamferRadius, isClosedWire, isCompSolid, isCompound, isDisposeRequest, isEdge, isEmpty, isEqualShape, isErr, isErrorResponse, isFace, isFilletRadius, isInitRequest, isInside2D, isLive, isManifoldShell, isNumber, isOk, isOperationRequest, isOrientedFace, isPlanarFace, isPlanarWire, isProjectionPlane, isEmpty$1 as isQueueEmpty, isSameShape, isShape1D, isShape3D, isShell, isSolid, isSuccessResponse, isValid, isValidSolid, isVertex, isWire, iterEdges, iterFaces, iterTopo, iterVertices, iterWires, kernelCall, kernelCallRaw, kernelCallScoped, kernelError, line, linearPattern, loadFont, loft, loftAll, makeBaseBox, makeExternalGear, makeInternalGear, makePlane, makePlanetaryGear, makeProjectedEdges, manifoldShell, map, mapBoth, mapErr, match, measureArea, measureCurvatureAt, measureCurvatureAtMid, measureDistance, measureDistanceProps, measureLength, measureLinearProps, measureSurfaceProps, measureVolume, measureVolumeProps, measurement_exports as measurement, mesh, meshEdges, meshMultiLOD, minkowski, mirror, mirror2D, mirrorDrawing, mirrorJoin, modifiers_exports as modifiers, modifyStep, moduleInitError, multiSectionSweep, normalAt, offset, offsetFace, offsetWire2D, ok, or, orElse, organiseBlueprints, orientedFace, outerWire, patterns_exports as patterns, pendingCount, pipeline, pivotPlane, planarFace, planarWire, planetPlacements, pocket, pointOnSurface, polygon, polyhedron, polysideInnerRadius, polysidesBlueprint, positionOnCurve, prewarm, primitives_exports as primitives, projectEdges, projectPointOnFace, query_exports as query, queryError, rectangularPattern, registerHandler, registerKernel, registerOperation, registerShape, rejectAll, removeChild, removeHolesFromFace, replayFrom, replayHistory, resetDisposalStats, resetPerformanceStats, resize, resolve, resolve3D, resolveDirection, resolvePlane, resolveRef, reverseCurve, revolve, roof, rotate, rotate2D, rotateDrawing, roundedRectangleBlueprint, scale, scale2D, scaleDrawing, section, sectionToFace, serializeHistory, setShapeOrigin, setTagMetadata, sewShells, shape, shapeType, sharedEdges, shell, shellWithEvolution, simplify, sketchCircle, sketchEllipse, sketchExtrude, sketchFace, sketchFaceOffset, sketchHelix, sketchLoft, sketchOnFace2D, sketchOnPlane2D, sketchParametricFunction, sketchPolysides, sketchRectangle, sketchRevolve, sketchRoundedRectangle, sketchSweep, sketchText, sketchWires, sketcherStateError, slice, solid, solidFromShell, solveAssembly, sphere, split, stepCount, stepsFrom, stretch2D, subFace, supportExtrude, supportsConstraintSketch, supportsProjection, surfaceFromGrid, surfaceFromImage, sweep, tagFaces, tangentArc, tap, tapErr, textBlueprints, textMetrics, thicken, threePointArc, toBREP, toBufferGeometryData, toGroupedBufferGeometryData, toKernelVec, toLODGeometryData, toLineGeometryData, toSVGPathD, toVec2, toVec3, torus, transformCopy, transforms_exports as transforms, translate, translate2D, translateDrawing, translatePlane, tryCatch, tryCatchAsync, twistExtrude, typeCastError, undoLast, unsupportedError, unwrap, unwrapErr, unwrapOr, unwrapOrElse, updateNode, updateRoles, uvBounds, uvCoordinates, validSolid, validatePlanetary, validationError, variableFillet, vecAdd, vecAngle, vecCross, vecDistance, vecDot, vecEquals, vecIsZero, vecLength, vecLengthSq, vecNegate, vecNormalize, vecProjectToPlane, vecRepr, vecRotate, vecScale, vecSub, vertex, vertexFinder, vertexPosition, verticesOfEdge, walkAssembly, wire, wireFinder, wireLoop, wiresOfFace, withKernel, withKernelDir, withKernelPnt, withKernelVec, withScope, withScopeResult, withScopeResultAsync, zip as zipResults };
+//#region src/csg/hash.ts
+var FNV_OFFSET = 14695981039346656037n;
+var FNV_PRIME = 1099511628211n;
+var MASK_64 = 18446744073709551615n;
+function fnvInit() {
+	return FNV_OFFSET;
+}
+function fnvMixByte(h, byte) {
+	return (h ^ BigInt(byte & 255)) * FNV_PRIME & MASK_64;
+}
+function fnvMixBytes(h, bytes) {
+	let r = h;
+	for (let i = 0; i < bytes.length; i++) r = fnvMixByte(r, bytes[i] ?? 0);
+	return r;
+}
+var ENCODER = new TextEncoder();
+function fnvMixString(h, s) {
+	return fnvMixBytes(h, ENCODER.encode(s));
+}
+var SCRATCH = /* @__PURE__ */ new ArrayBuffer(8);
+var SCRATCH_VIEW = new DataView(SCRATCH);
+var SCRATCH_BYTES = new Uint8Array(SCRATCH);
+function fnvMixNumber(h, n) {
+	SCRATCH_VIEW.setFloat64(0, Object.is(n, -0) ? 0 : n);
+	return fnvMixBytes(h, SCRATCH_BYTES);
+}
+function fnvMixHash(h, child) {
+	let r = h;
+	let v = child & MASK_64;
+	for (let i = 0; i < 8; i++) {
+		r = fnvMixByte(r, Number(v & 255n));
+		v >>= 8n;
+	}
+	return r;
+}
+function fnvMixInt32(h, n) {
+	let r = h;
+	let v = n | 0;
+	for (let i = 0; i < 4; i++) {
+		r = fnvMixByte(r, v & 255);
+		v >>>= 8;
+	}
+	return r;
+}
+function fnvMixBool(h, b) {
+	return fnvMixByte(h, b ? 1 : 0);
+}
+function toHex(h) {
+	return (h & MASK_64).toString(16).padStart(16, "0");
+}
+//#endregion
+//#region src/csg/expressions.ts
+var EMPTY_DEPS$1 = /* @__PURE__ */ new Set();
+function startHash$1(tag) {
+	return fnvMixString(fnvInit(), tag);
+}
+function numLit(value) {
+	return {
+		kind: "NumLit",
+		value,
+		structuralHash: fnvMixNumber(startHash$1("NumLit"), value),
+		freeParams: EMPTY_DEPS$1
+	};
+}
+function vec3Lit(value) {
+	let h = startHash$1("Vec3Lit");
+	for (const n of value) h = fnvMixNumber(h, n);
+	return {
+		kind: "Vec3Lit",
+		value,
+		structuralHash: h,
+		freeParams: EMPTY_DEPS$1
+	};
+}
+function vec2Lit(value) {
+	let h = startHash$1("Vec2Lit");
+	for (const n of value) h = fnvMixNumber(h, n);
+	return {
+		kind: "Vec2Lit",
+		value,
+		structuralHash: h,
+		freeParams: EMPTY_DEPS$1
+	};
+}
+function param(name) {
+	return {
+		kind: "Param",
+		name,
+		structuralHash: fnvMixString(startHash$1("Param"), name),
+		freeParams: new Set([name])
+	};
+}
+function binOp(op, a, b) {
+	let h = fnvMixString(startHash$1("BinOp"), op);
+	h = fnvMixHash(h, a.structuralHash);
+	h = fnvMixHash(h, b.structuralHash);
+	return {
+		kind: "BinOp",
+		op,
+		a,
+		b,
+		structuralHash: h,
+		freeParams: unionParams(a.freeParams, b.freeParams)
+	};
+}
+function unaryOp(op, arg) {
+	let h = fnvMixString(startHash$1("UnaryOp"), op);
+	h = fnvMixHash(h, arg.structuralHash);
+	return {
+		kind: "UnaryOp",
+		op,
+		arg,
+		structuralHash: h,
+		freeParams: arg.freeParams
+	};
+}
+function component(vec, index) {
+	let h = fnvMixInt32(startHash$1("Component"), index);
+	h = fnvMixHash(h, vec.structuralHash);
+	return {
+		kind: "Component",
+		vec,
+		index,
+		structuralHash: h,
+		freeParams: vec.freeParams
+	};
+}
+function buildVec(dim, components) {
+	let h = fnvMixInt32(startHash$1("BuildVec"), dim);
+	const deps = /* @__PURE__ */ new Set();
+	for (const c of components) {
+		h = fnvMixHash(h, c.structuralHash);
+		for (const p of c.freeParams) deps.add(p);
+	}
+	return {
+		kind: "BuildVec",
+		dim,
+		components,
+		structuralHash: h,
+		freeParams: deps
+	};
+}
+var add = (a, b) => binOp("+", a, b);
+var mul = (a, b) => binOp("*", a, b);
+function asScalarExpr(input) {
+	return typeof input === "number" ? numLit(input) : input;
+}
+function asVecExpr(input, dim) {
+	if (!Array.isArray(input)) return input;
+	const arr = input;
+	if (arr.every((v) => typeof v === "number")) return dim === 3 ? vec3Lit([
+		arr[0],
+		arr[1],
+		arr[2]
+	]) : vec2Lit([arr[0], arr[1]]);
+	return buildVec(dim, arr.map(asScalarExpr));
+}
+function asVec3Expr(input) {
+	return asVecExpr(input, 3);
+}
+function asVec2Expr(input) {
+	return asVecExpr(input, 2);
+}
+function unionParams(a, b) {
+	if (a.size === 0) return b;
+	if (b.size === 0) return a;
+	const out = new Set(a);
+	for (const x of b) out.add(x);
+	return out;
+}
+function isNumber$2(v) {
+	return typeof v === "number";
+}
+function expectNumber(v, where) {
+	if (isNumber$2(v)) return ok(v);
+	return err(validationError(BrepErrorCode.NULL_SHAPE_INPUT, `${where}: expected number, got ${Array.isArray(v) ? `vector(${v.length})` : typeof v}`));
+}
+function expectVecLen(v, len, where) {
+	if (Array.isArray(v) && v.length === len) return ok(v);
+	return err(validationError(BrepErrorCode.NULL_SHAPE_INPUT, `${where}: expected Vec${len}, got ${isNumber$2(v) ? "number" : `vector(${v.length})`}`));
+}
+function evalExpr(expr, env) {
+	switch (expr.kind) {
+		case "NumLit": return ok(expr.value);
+		case "Vec3Lit": return ok(expr.value);
+		case "Vec2Lit": return ok(expr.value);
+		case "Param": {
+			const v = env[expr.name];
+			if (v === void 0) return err(validationError(BrepErrorCode.NULL_SHAPE_INPUT, `unbound param: ${expr.name}`));
+			return ok(v);
+		}
+		case "BinOp": return evalBinOp(expr, env);
+		case "UnaryOp": return evalUnaryOp(expr, env);
+		case "Component": return evalComponent(expr, env);
+		case "BuildVec": return evalBuildVec(expr, env);
+	}
+}
+function evalBinOp(expr, env) {
+	const ar = evalExpr(expr.a, env);
+	if (!ar.ok) return ar;
+	const br = evalExpr(expr.b, env);
+	if (!br.ok) return br;
+	const an = expectNumber(ar.value, `BinOp(${expr.op}).a`);
+	if (!an.ok) return an;
+	const bn = expectNumber(br.value, `BinOp(${expr.op}).b`);
+	if (!bn.ok) return bn;
+	switch (expr.op) {
+		case "+": return ok(an.value + bn.value);
+		case "-": return ok(an.value - bn.value);
+		case "*": return ok(an.value * bn.value);
+		case "/":
+			if (bn.value === 0) return err(validationError(BrepErrorCode.NULL_SHAPE_INPUT, `BinOp(/): division by zero`));
+			return ok(an.value / bn.value);
+	}
+}
+function evalUnaryOp(expr, env) {
+	const ar = evalExpr(expr.arg, env);
+	if (!ar.ok) return ar;
+	const an = expectNumber(ar.value, `UnaryOp(${expr.op})`);
+	if (!an.ok) return an;
+	const n = an.value;
+	switch (expr.op) {
+		case "neg": return ok(-n);
+		case "sin": return ok(Math.sin(n));
+		case "cos": return ok(Math.cos(n));
+		case "sqrt": return ok(Math.sqrt(n));
+		case "abs": return ok(Math.abs(n));
+	}
+}
+function evalComponent(expr, env) {
+	const vr = evalExpr(expr.vec, env);
+	if (!vr.ok) return vr;
+	if (isNumber$2(vr.value)) return err(validationError(BrepErrorCode.NULL_SHAPE_INPUT, `Component: cannot index a scalar`));
+	const v = vr.value;
+	const c = v[expr.index];
+	if (c === void 0) return err(validationError(BrepErrorCode.NULL_SHAPE_INPUT, `Component: index ${expr.index} out of range for Vec${v.length}`));
+	return ok(c);
+}
+function evalBuildVec(expr, env) {
+	if (expr.components.length !== expr.dim) return err(validationError(BrepErrorCode.NULL_SHAPE_INPUT, `BuildVec(${expr.dim}): expected ${expr.dim} components, got ${expr.components.length}`));
+	const out = [];
+	for (const c of expr.components) {
+		const r = evalExpr(c, env);
+		if (!r.ok) return r;
+		const n = expectNumber(r.value, "BuildVec.component");
+		if (!n.ok) return n;
+		out.push(n.value);
+	}
+	return ok(expr.dim === 2 ? [out[0], out[1]] : [
+		out[0],
+		out[1],
+		out[2]
+	]);
+}
+function evalScalar(expr, env, where) {
+	const r = evalExpr(expr, env);
+	if (!r.ok) return r;
+	return expectNumber(r.value, where);
+}
+function evalVec3(expr, env, where) {
+	const r = evalExpr(expr, env);
+	if (!r.ok) return r;
+	const v = expectVecLen(r.value, 3, where);
+	if (!v.ok) return v;
+	const [a, b, c] = v.value;
+	return ok([
+		a,
+		b,
+		c
+	]);
+}
+function projectEnv(env, deps) {
+	if (deps.size === 0) return Object.freeze({});
+	const out = {};
+	for (const k of deps) {
+		const v = env[k];
+		if (v !== void 0) out[k] = v;
+	}
+	return Object.freeze(out);
+}
+//#endregion
+//#region src/csg/builders.ts
+var EMPTY_DEPS = /* @__PURE__ */ new Set();
+function startHash(tag) {
+	return fnvMixString(fnvInit(), tag);
+}
+function mix(h, x) {
+	return fnvMixHash(h, x.structuralHash);
+}
+function mixOptExpr(h, e) {
+	if (e === void 0) return fnvMixBool(h, false);
+	return mix(fnvMixBool(h, true), e);
+}
+function mixOptNumber(h, n) {
+	if (n === void 0) return fnvMixBool(h, false);
+	return fnvMixNumber(fnvMixBool(h, true), n);
+}
+function depsOf(...sources) {
+	const acc = /* @__PURE__ */ new Set();
+	for (const s of sources) {
+		if (!s) continue;
+		for (const p of s.freeParams) acc.add(p);
+	}
+	return acc.size === 0 ? EMPTY_DEPS : acc;
+}
+function box$1(x, y, z) {
+	const xe = asScalarExpr(x);
+	const ye = asScalarExpr(y);
+	const ze = asScalarExpr(z);
+	let h = startHash("Box");
+	h = mix(mix(mix(h, xe), ye), ze);
+	return {
+		kind: "Box",
+		x: xe,
+		y: ye,
+		z: ze,
+		structuralHash: h,
+		freeParams: depsOf(xe, ye, ze)
+	};
+}
+function sphere$1(radius) {
+	const re = asScalarExpr(radius);
+	return {
+		kind: "Sphere",
+		radius: re,
+		structuralHash: mix(startHash("Sphere"), re),
+		freeParams: re.freeParams
+	};
+}
+function cylinder$1(radius, height) {
+	const re = asScalarExpr(radius);
+	const he = asScalarExpr(height);
+	return {
+		kind: "Cylinder",
+		radius: re,
+		height: he,
+		structuralHash: mix(mix(startHash("Cylinder"), re), he),
+		freeParams: depsOf(re, he)
+	};
+}
+function cone$1(radius1, radius2, height) {
+	const r1 = asScalarExpr(radius1);
+	const r2 = asScalarExpr(radius2);
+	const he = asScalarExpr(height);
+	let h = startHash("Cone");
+	h = mix(mix(mix(h, r1), r2), he);
+	return {
+		kind: "Cone",
+		radius1: r1,
+		radius2: r2,
+		height: he,
+		structuralHash: h,
+		freeParams: depsOf(r1, r2, he)
+	};
+}
+function torus$1(majorRadius, minorRadius) {
+	const ma = asScalarExpr(majorRadius);
+	const mi = asScalarExpr(minorRadius);
+	return {
+		kind: "Torus",
+		majorRadius: ma,
+		minorRadius: mi,
+		structuralHash: mix(mix(startHash("Torus"), ma), mi),
+		freeParams: depsOf(ma, mi)
+	};
+}
+function polygon$1(points) {
+	const pts = points.map(asVec3Expr);
+	let h = fnvMixInt32(startHash("Polygon"), pts.length);
+	for (const p of pts) h = mix(h, p);
+	return {
+		kind: "Polygon",
+		points: pts,
+		structuralHash: h,
+		freeParams: depsOf(...pts)
+	};
+}
+function circle$1(radius) {
+	const re = asScalarExpr(radius);
+	return {
+		kind: "Circle",
+		radius: re,
+		structuralHash: mix(startHash("Circle"), re),
+		freeParams: re.freeParams
+	};
+}
+function line$1(from, to) {
+	const fe = asVec3Expr(from);
+	const te = asVec3Expr(to);
+	return {
+		kind: "Line",
+		from: fe,
+		to: te,
+		structuralHash: mix(mix(startHash("Line"), fe), te),
+		freeParams: depsOf(fe, te)
+	};
+}
+function vertex$1(point) {
+	const pe = asVec3Expr(point);
+	return {
+		kind: "Vertex",
+		point: pe,
+		structuralHash: mix(startHash("Vertex"), pe),
+		freeParams: pe.freeParams
+	};
+}
+function emptyOf(output) {
+	return {
+		kind: "Empty",
+		output,
+		structuralHash: fnvMixString(startHash("Empty"), output),
+		freeParams: EMPTY_DEPS
+	};
+}
+function emptySolid() {
+	return emptyOf("Solid");
+}
+function emptyFace() {
+	return emptyOf("Face");
+}
+function emptyWire() {
+	return emptyOf("Wire");
+}
+function binaryBoolHash(tag, a, b, tol) {
+	return mixOptNumber(mix(mix(startHash(tag), a), b), tol);
+}
+function fuse$1(a, b, tolerance) {
+	return {
+		kind: "Fuse",
+		a,
+		b,
+		tolerance,
+		structuralHash: binaryBoolHash("Fuse", a, b, tolerance),
+		freeParams: depsOf(a, b)
+	};
+}
+function cut$1(a, b, tolerance) {
+	return {
+		kind: "Cut",
+		a,
+		b,
+		tolerance,
+		structuralHash: binaryBoolHash("Cut", a, b, tolerance),
+		freeParams: depsOf(a, b)
+	};
+}
+function intersect$1(a, b, tolerance) {
+	return {
+		kind: "Intersect",
+		a,
+		b,
+		tolerance,
+		structuralHash: binaryBoolHash("Intersect", a, b, tolerance),
+		freeParams: depsOf(a, b)
+	};
+}
+function fuseAll$1(shapes, tolerance) {
+	let h = fnvMixInt32(startHash("FuseAll"), shapes.length);
+	for (const s of shapes) h = mix(h, s);
+	h = mixOptNumber(h, tolerance);
+	return {
+		kind: "FuseAll",
+		shapes,
+		tolerance,
+		structuralHash: h,
+		freeParams: depsOf(...shapes)
+	};
+}
+function cutAll$1(base, tools, tolerance) {
+	let h = mix(startHash("CutAll"), base);
+	h = fnvMixInt32(h, tools.length);
+	for (const t of tools) h = mix(h, t);
+	h = mixOptNumber(h, tolerance);
+	return {
+		kind: "CutAll",
+		base,
+		tools,
+		tolerance,
+		structuralHash: h,
+		freeParams: depsOf(base, ...tools)
+	};
+}
+function optVec3$1(v) {
+	return v !== void 0 ? asVec3Expr(v) : void 0;
+}
+function translate$1(target, vector) {
+	const ve = asVec3Expr(vector);
+	return {
+		kind: "Translate",
+		target,
+		vector: ve,
+		structuralHash: mix(mix(startHash("Translate"), target), ve),
+		freeParams: depsOf(target, ve)
+	};
+}
+function rotate$1(target, angle, options) {
+	const ae = asScalarExpr(angle);
+	const axisE = optVec3$1(options?.axis);
+	const atE = optVec3$1(options?.at);
+	let h = mix(mix(startHash("Rotate"), target), ae);
+	h = mixOptExpr(h, axisE);
+	h = mixOptExpr(h, atE);
+	return {
+		kind: "Rotate",
+		target,
+		angle: ae,
+		axis: axisE,
+		at: atE,
+		structuralHash: h,
+		freeParams: depsOf(target, ae, axisE, atE)
+	};
+}
+function scale$1(target, factor, options) {
+	const fe = asScalarExpr(factor);
+	const cE = optVec3$1(options?.center);
+	let h = mix(mix(startHash("Scale"), target), fe);
+	h = mixOptExpr(h, cE);
+	return {
+		kind: "Scale",
+		target,
+		factor: fe,
+		center: cE,
+		structuralHash: h,
+		freeParams: depsOf(target, fe, cE)
+	};
+}
+function mirror$1(target, options) {
+	const nE = optVec3$1(options?.normal);
+	const atE = optVec3$1(options?.at);
+	let h = mix(startHash("Mirror"), target);
+	h = mixOptExpr(h, nE);
+	h = mixOptExpr(h, atE);
+	return {
+		kind: "Mirror",
+		target,
+		normal: nE,
+		at: atE,
+		structuralHash: h,
+		freeParams: depsOf(target, nE, atE)
+	};
+}
+function compound$1(children) {
+	let h = fnvMixInt32(startHash("Compound"), children.length);
+	for (const c of children) h = mix(h, c);
+	return {
+		kind: "Compound",
+		children,
+		structuralHash: h,
+		freeParams: depsOf(...children)
+	};
+}
+//#endregion
+//#region src/csg/types.ts
+function outputKindOf(node) {
+	switch (node.kind) {
+		case "Box":
+		case "Sphere":
+		case "Cylinder":
+		case "Cone":
+		case "Torus": return "Solid";
+		case "Polygon": return "Face";
+		case "Circle":
+		case "Line": return "Edge";
+		case "Vertex": return "Vertex";
+		case "Empty": return node.output;
+		case "Fuse":
+		case "Cut":
+		case "Intersect": return outputKindOf(node.a);
+		case "FuseAll": return node.shapes[0] ? outputKindOf(node.shapes[0]) : "Solid";
+		case "CutAll": return outputKindOf(node.base);
+		case "Translate":
+		case "Rotate":
+		case "Scale":
+		case "Mirror": return outputKindOf(node.target);
+		case "Compound": return "Compound";
+	}
+}
+//#endregion
+//#region src/csg/evaluators/primitives.ts
+function evalBox(node, ctx) {
+	const x = evalScalar(node.x, ctx.env, "Box.x");
+	if (!x.ok) return x;
+	const y = evalScalar(node.y, ctx.env, "Box.y");
+	if (!y.ok) return y;
+	const z = evalScalar(node.z, ctx.env, "Box.z");
+	if (!z.ok) return z;
+	return ok(box(x.value, y.value, z.value));
+}
+function evalSphere(node, ctx) {
+	const r = evalScalar(node.radius, ctx.env, "Sphere.radius");
+	if (!r.ok) return r;
+	return ok(sphere(r.value));
+}
+function evalCylinder(node, ctx) {
+	const r = evalScalar(node.radius, ctx.env, "Cylinder.radius");
+	if (!r.ok) return r;
+	const h = evalScalar(node.height, ctx.env, "Cylinder.height");
+	if (!h.ok) return h;
+	return ok(cylinder(r.value, h.value));
+}
+function evalCone(node, ctx) {
+	const r1 = evalScalar(node.radius1, ctx.env, "Cone.radius1");
+	if (!r1.ok) return r1;
+	const r2 = evalScalar(node.radius2, ctx.env, "Cone.radius2");
+	if (!r2.ok) return r2;
+	const h = evalScalar(node.height, ctx.env, "Cone.height");
+	if (!h.ok) return h;
+	return ok(cone(r1.value, r2.value, h.value));
+}
+function evalTorus(node, ctx) {
+	const ma = evalScalar(node.majorRadius, ctx.env, "Torus.majorRadius");
+	if (!ma.ok) return ma;
+	const mi = evalScalar(node.minorRadius, ctx.env, "Torus.minorRadius");
+	if (!mi.ok) return mi;
+	return ok(torus(ma.value, mi.value));
+}
+function evalPolygon(node, ctx) {
+	const pts = [];
+	for (const p of node.points) {
+		const r = evalVec3(p, ctx.env, "Polygon.point");
+		if (!r.ok) return r;
+		pts.push(r.value);
+	}
+	return polygon(pts);
+}
+function evalCircle(node, ctx) {
+	const r = evalScalar(node.radius, ctx.env, "Circle.radius");
+	if (!r.ok) return r;
+	return ok(circle(r.value));
+}
+function evalLine(node, ctx) {
+	const f = evalVec3(node.from, ctx.env, "Line.from");
+	if (!f.ok) return f;
+	const t = evalVec3(node.to, ctx.env, "Line.to");
+	if (!t.ok) return t;
+	return ok(line(f.value, t.value));
+}
+function evalVertex(node, ctx) {
+	const p = evalVec3(node.point, ctx.env, "Vertex.point");
+	if (!p.ok) return p;
+	return ok(vertex(p.value));
+}
+//#endregion
+//#region src/csg/evaluators/booleans.ts
+/**
+* Evaluators for CSG boolean nodes.
+*
+* Identity short-circuits are correctness invariants, not optimisations:
+*   Fuse with an Empty operand: short-circuits to the other operand
+*   Cut with an Empty tool:     short-circuits to the base
+*   Intersect with any Empty:   errors (no empty-solid representation)
+*
+* The optimizer pass handles broader rewrites; these inline checks just
+* keep the evaluator from feeding null operands to the kernel.
+*/
+function emptyResult$1(kind) {
+	return err(computationError(BrepErrorCode.NULL_SHAPE_INPUT, `${kind}: empty result has no kernel representation`));
+}
+function resolveOperand(ctx, node, where) {
+	const r = ctx.evalNode(node);
+	if (!r.ok) return r;
+	if (!isShape3D(r.value)) return err(typeCastError(BrepErrorCode.CSG_NOT_3D, `${where}: operand did not produce a 3D shape`));
+	return ok(r.value);
+}
+function boolOptions(node, ctx) {
+	return {
+		unsafe: true,
+		fuzzyValue: node.tolerance ?? ctx.tolerance
+	};
+}
+function evalFuse(node, ctx) {
+	if (node.a.kind === "Empty") return ctx.evalNode(node.b);
+	if (node.b.kind === "Empty") return ctx.evalNode(node.a);
+	const a = resolveOperand(ctx, node.a, "Fuse.a");
+	if (!a.ok) return a;
+	const b = resolveOperand(ctx, node.b, "Fuse.b");
+	if (!b.ok) return b;
+	return fuse$2(a.value, b.value, boolOptions(node, ctx));
+}
+function evalCut(node, ctx) {
+	if (node.a.kind === "Empty") return emptyResult$1("Cut");
+	if (node.b.kind === "Empty") return ctx.evalNode(node.a);
+	const a = resolveOperand(ctx, node.a, "Cut.a");
+	if (!a.ok) return a;
+	const b = resolveOperand(ctx, node.b, "Cut.b");
+	if (!b.ok) return b;
+	return cut$2(a.value, b.value, boolOptions(node, ctx));
+}
+function evalIntersect(node, ctx) {
+	if (node.a.kind === "Empty" || node.b.kind === "Empty") return emptyResult$1("Intersect");
+	const a = resolveOperand(ctx, node.a, "Intersect.a");
+	if (!a.ok) return a;
+	const b = resolveOperand(ctx, node.b, "Intersect.b");
+	if (!b.ok) return b;
+	return intersect$2(a.value, b.value, boolOptions(node, ctx));
+}
+function resolveAll(ctx, nodes, where) {
+	const out = [];
+	for (const n of nodes) {
+		const r = resolveOperand(ctx, n, where);
+		if (!r.ok) return r;
+		out.push(r.value);
+	}
+	return ok(out);
+}
+function evalFuseAll(node, ctx) {
+	const non = node.shapes.filter((s) => s.kind !== "Empty");
+	if (non.length === 0) return emptyResult$1("FuseAll");
+	if (non.length === 1 && non[0]) return ctx.evalNode(non[0]);
+	const resolved = resolveAll(ctx, non, "FuseAll.operand");
+	if (!resolved.ok) return resolved;
+	return fuseAll(resolved.value, boolOptions(node, ctx));
+}
+function evalCutAll(node, ctx) {
+	if (node.base.kind === "Empty") return emptyResult$1("CutAll");
+	const tools = node.tools.filter((s) => s.kind !== "Empty");
+	if (tools.length === 0) return ctx.evalNode(node.base);
+	const base = resolveOperand(ctx, node.base, "CutAll.base");
+	if (!base.ok) return base;
+	const resolved = resolveAll(ctx, tools, "CutAll.tool");
+	if (!resolved.ok) return resolved;
+	return cutAll(base.value, resolved.value, boolOptions(node, ctx));
+}
+//#endregion
+//#region src/csg/evaluators/transforms.ts
+function emptyResult(kind) {
+	return err(computationError(BrepErrorCode.NULL_SHAPE_INPUT, `${kind}: cannot transform an Empty node`));
+}
+function optVec3(expr, env, where, fallback) {
+	return expr ? evalVec3(expr, env, where) : ok(fallback);
+}
+function evalTranslate(node, ctx) {
+	if (node.target.kind === "Empty") return emptyResult("Translate");
+	const v = evalVec3(node.vector, ctx.env, "Translate.vector");
+	if (!v.ok) return v;
+	const r = ctx.evalNode(node.target);
+	if (!r.ok) return r;
+	return ok(translate$2(r.value, v.value));
+}
+function evalRotate(node, ctx) {
+	if (node.target.kind === "Empty") return emptyResult("Rotate");
+	const a = evalScalar(node.angle, ctx.env, "Rotate.angle");
+	if (!a.ok) return a;
+	const axis = optVec3(node.axis, ctx.env, "Rotate.axis", [
+		0,
+		0,
+		1
+	]);
+	if (!axis.ok) return axis;
+	const at = optVec3(node.at, ctx.env, "Rotate.at", [
+		0,
+		0,
+		0
+	]);
+	if (!at.ok) return at;
+	const r = ctx.evalNode(node.target);
+	if (!r.ok) return r;
+	return ok(rotate$2(r.value, a.value, at.value, axis.value));
+}
+function evalScale(node, ctx) {
+	if (node.target.kind === "Empty") return emptyResult("Scale");
+	const f = evalScalar(node.factor, ctx.env, "Scale.factor");
+	if (!f.ok) return f;
+	const center = optVec3(node.center, ctx.env, "Scale.center", [
+		0,
+		0,
+		0
+	]);
+	if (!center.ok) return center;
+	const r = ctx.evalNode(node.target);
+	if (!r.ok) return r;
+	return ok(scale$2(r.value, f.value, center.value));
+}
+function evalMirror(node, ctx) {
+	if (node.target.kind === "Empty") return emptyResult("Mirror");
+	const normal = optVec3(node.normal, ctx.env, "Mirror.normal", [
+		1,
+		0,
+		0
+	]);
+	if (!normal.ok) return normal;
+	const at = optVec3(node.at, ctx.env, "Mirror.at", [
+		0,
+		0,
+		0
+	]);
+	if (!at.ok) return at;
+	const r = ctx.evalNode(node.target);
+	if (!r.ok) return r;
+	return ok(mirror$2(r.value, normal.value, at.value));
+}
+//#endregion
+//#region src/csg/evaluators/compound.ts
+function evalCompound(node, ctx) {
+	const non = node.children.filter((c) => c.kind !== "Empty");
+	if (non.length === 0) return err(computationError(BrepErrorCode.NULL_SHAPE_INPUT, "Compound: cannot materialize a compound with zero non-empty children"));
+	const shapes = [];
+	for (const c of non) {
+		const r = ctx.evalNode(c);
+		if (!r.ok) return r;
+		shapes.push(r.value);
+	}
+	return ok(compound(shapes));
+}
+function evalEmpty() {
+	return err(computationError(BrepErrorCode.NULL_SHAPE_INPUT, "Empty: cannot materialize an Empty node directly — only valid as boolean/transform operand"));
+}
+//#endregion
+//#region src/csg/evaluate.ts
+function dispatch(node, ctx) {
+	switch (node.kind) {
+		case "Box": return evalBox(node, ctx);
+		case "Sphere": return evalSphere(node, ctx);
+		case "Cylinder": return evalCylinder(node, ctx);
+		case "Cone": return evalCone(node, ctx);
+		case "Torus": return evalTorus(node, ctx);
+		case "Polygon": return evalPolygon(node, ctx);
+		case "Circle": return evalCircle(node, ctx);
+		case "Line": return evalLine(node, ctx);
+		case "Vertex": return evalVertex(node, ctx);
+		case "Empty": return evalEmpty();
+		case "Fuse": return evalFuse(node, ctx);
+		case "Cut": return evalCut(node, ctx);
+		case "Intersect": return evalIntersect(node, ctx);
+		case "FuseAll": return evalFuseAll(node, ctx);
+		case "CutAll": return evalCutAll(node, ctx);
+		case "Translate": return evalTranslate(node, ctx);
+		case "Rotate": return evalRotate(node, ctx);
+		case "Scale": return evalScale(node, ctx);
+		case "Mirror": return evalMirror(node, ctx);
+		case "Compound": return evalCompound(node, ctx);
+	}
+}
+function hashExprValue(h, v) {
+	if (typeof v === "number") return fnvMixNumber(fnvMixBool(h, false), v);
+	let r = fnvMixBool(h, true);
+	r = fnvMixInt32(r, v.length);
+	for (const n of v) r = fnvMixNumber(r, n);
+	return r;
+}
+function projectedEnvHash(env, deps) {
+	if (deps.size === 0) return fnvInit();
+	const projected = projectEnv(env, deps);
+	const keys = Object.keys(projected).sort();
+	let h = fnvInit();
+	for (const k of keys) {
+		h = fnvMixString(h, k);
+		const v = projected[k];
+		if (v !== void 0) h = hashExprValue(h, v);
+	}
+	return h;
+}
+function cacheKey(node, env, kernelId, tolerance) {
+	const projHash = projectedEnvHash(env, node.freeParams);
+	const tolHash = tolerance === void 0 ? "d" : fnvMixNumber(fnvInit(), tolerance).toString(16);
+	return `${toHex(node.structuralHash)}:${kernelId}:${toHex(projHash)}:${tolHash}`;
+}
+var Evaluator = class {
+	scope = new DisposalScope();
+	cache = /* @__PURE__ */ new Map();
+	registered = /* @__PURE__ */ new WeakSet();
+	kernelId;
+	defaultTolerance;
+	onStep;
+	hits = 0;
+	misses = 0;
+	constructor(options = {}) {
+		this.kernelId = options.kernel ?? getActiveKernelId() ?? "unregistered";
+		this.defaultTolerance = options.tolerance;
+		if (options.onStep) this.onStep = options.onStep;
+	}
+	/**
+	* 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, env = {}) {
+		return withKernel(this.kernelId, () => this.evaluateInner(node, env));
+	}
+	evaluateInner(node, env) {
+		const key = cacheKey(node, env, this.kernelId, this.defaultTolerance);
+		const cached = this.cache.get(key);
+		if (cached !== void 0) {
+			this.hits++;
+			this.onStep?.({
+				node,
+				cacheKey: key,
+				cacheHit: true
+			});
+			return ok(cached);
+		}
+		this.misses++;
+		const result = dispatch(node, {
+			env,
+			tolerance: this.defaultTolerance,
+			evalNode: (child) => this.evaluateInner(child, env)
+		});
+		if (!result.ok) return result;
+		if (!this.registered.has(result.value)) {
+			this.scope.register(result.value);
+			this.registered.add(result.value);
+		}
+		this.cache.set(key, result.value);
+		this.onStep?.({
+			node,
+			cacheKey: key,
+			cacheHit: false
+		});
+		return result;
+	}
+	cacheStats() {
+		return {
+			hits: this.hits,
+			misses: this.misses,
+			entries: this.cache.size
+		};
+	}
+	resetStats() {
+		this.hits = 0;
+		this.misses = 0;
+	}
+	[Symbol.dispose]() {
+		this.scope[Symbol.dispose]();
+		this.cache.clear();
+	}
+};
+/**
+* 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`.
+*/
+function withEvaluator(options, fn) {
+	try {
+		var _usingCtx$1 = _usingCtx();
+		const result = fn(_usingCtx$1.u(new Evaluator(options)));
+		if (result instanceof Promise) throw new Error("withEvaluator() callback returned a Promise. Async code must construct an Evaluator directly and dispose it manually — borrowed shapes would otherwise be freed before the Promise resolves.");
+		return result;
+	} catch (_) {
+		_usingCtx$1.e = _;
+	} finally {
+		_usingCtx$1.d();
+	}
+}
+function toJSON(node) {
+	return {
+		csgVersion: 1,
+		root: nodeToJson(node)
+	};
+}
+function exprToJson(e) {
+	switch (e.kind) {
+		case "NumLit": return {
+			kind: "NumLit",
+			value: e.value
+		};
+		case "Vec3Lit": return {
+			kind: "Vec3Lit",
+			value: [
+				e.value[0],
+				e.value[1],
+				e.value[2]
+			]
+		};
+		case "Vec2Lit": return {
+			kind: "Vec2Lit",
+			value: [e.value[0], e.value[1]]
+		};
+		case "Param": return {
+			kind: "Param",
+			name: e.name
+		};
+		case "BinOp": return {
+			kind: "BinOp",
+			op: e.op,
+			a: exprToJson(e.a),
+			b: exprToJson(e.b)
+		};
+		case "UnaryOp": return {
+			kind: "UnaryOp",
+			op: e.op,
+			arg: exprToJson(e.arg)
+		};
+		case "Component": return {
+			kind: "Component",
+			vec: exprToJson(e.vec),
+			index: e.index
+		};
+		case "BuildVec": return {
+			kind: "BuildVec",
+			dim: e.dim,
+			components: e.components.map(exprToJson)
+		};
+	}
+}
+function primitiveToJson(n) {
+	switch (n.kind) {
+		case "Box": return {
+			kind: "Box",
+			x: exprToJson(n.x),
+			y: exprToJson(n.y),
+			z: exprToJson(n.z)
+		};
+		case "Sphere": return {
+			kind: "Sphere",
+			radius: exprToJson(n.radius)
+		};
+		case "Cylinder": return {
+			kind: "Cylinder",
+			radius: exprToJson(n.radius),
+			height: exprToJson(n.height)
+		};
+		case "Cone": return {
+			kind: "Cone",
+			radius1: exprToJson(n.radius1),
+			radius2: exprToJson(n.radius2),
+			height: exprToJson(n.height)
+		};
+		case "Torus": return {
+			kind: "Torus",
+			majorRadius: exprToJson(n.majorRadius),
+			minorRadius: exprToJson(n.minorRadius)
+		};
+		case "Polygon": return {
+			kind: "Polygon",
+			points: n.points.map(exprToJson)
+		};
+		case "Circle": return {
+			kind: "Circle",
+			radius: exprToJson(n.radius)
+		};
+		case "Line": return {
+			kind: "Line",
+			from: exprToJson(n.from),
+			to: exprToJson(n.to)
+		};
+		case "Vertex": return {
+			kind: "Vertex",
+			point: exprToJson(n.point)
+		};
+		case "Empty": return {
+			kind: "Empty",
+			output: n.output
+		};
+		default: return;
+	}
+}
+function booleanToJson(n) {
+	switch (n.kind) {
+		case "Fuse":
+		case "Cut":
+		case "Intersect": return {
+			kind: n.kind,
+			a: nodeToJson(n.a),
+			b: nodeToJson(n.b),
+			tolerance: n.tolerance
+		};
+		case "FuseAll": return {
+			kind: "FuseAll",
+			shapes: n.shapes.map(nodeToJson),
+			tolerance: n.tolerance
+		};
+		case "CutAll": return {
+			kind: "CutAll",
+			base: nodeToJson(n.base),
+			tools: n.tools.map(nodeToJson),
+			tolerance: n.tolerance
+		};
+		default: return;
+	}
+}
+function optExprToJson(e) {
+	return e ? exprToJson(e) : void 0;
+}
+function transformToJson(n) {
+	switch (n.kind) {
+		case "Translate": return {
+			kind: "Translate",
+			target: nodeToJson(n.target),
+			vector: exprToJson(n.vector)
+		};
+		case "Rotate": return {
+			kind: "Rotate",
+			target: nodeToJson(n.target),
+			angle: exprToJson(n.angle),
+			axis: optExprToJson(n.axis),
+			at: optExprToJson(n.at)
+		};
+		case "Scale": return {
+			kind: "Scale",
+			target: nodeToJson(n.target),
+			factor: exprToJson(n.factor),
+			center: optExprToJson(n.center)
+		};
+		case "Mirror": return {
+			kind: "Mirror",
+			target: nodeToJson(n.target),
+			normal: optExprToJson(n.normal),
+			at: optExprToJson(n.at)
+		};
+		default: return;
+	}
+}
+function nodeToJson(n) {
+	if (n.kind === "Compound") return {
+		kind: "Compound",
+		children: n.children.map(nodeToJson)
+	};
+	return primitiveToJson(n) ?? booleanToJson(n) ?? transformToJson(n);
+}
+function bad(msg) {
+	return err(validationError(BrepErrorCode.NULL_SHAPE_INPUT, `csg.fromJSON: ${msg}`));
+}
+function isObj(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function isNumber$1(v) {
+	return typeof v === "number" && Number.isFinite(v);
+}
+function isString(v) {
+	return typeof v === "string";
+}
+function readVec3(v, where) {
+	if (!Array.isArray(v) || v.length !== 3) return bad(`${where}: expected Vec3 array`);
+	const [a, b, c] = v;
+	if (!isNumber$1(a) || !isNumber$1(b) || !isNumber$1(c)) return bad(`${where}: Vec3 contains non-number`);
+	return ok([
+		a,
+		b,
+		c
+	]);
+}
+function readVec2(v, where) {
+	if (!Array.isArray(v) || v.length !== 2) return bad(`${where}: expected Vec2 array`);
+	const [a, b] = v;
+	if (!isNumber$1(a) || !isNumber$1(b)) return bad(`${where}: Vec2 contains non-number`);
+	return ok([a, b]);
+}
+function fromJSON(envelope) {
+	if (!isObj(envelope)) return bad("input is not an object");
+	const v = envelope["csgVersion"];
+	if (v !== 1) return bad(`unsupported csgVersion ${String(v)} (expected 1)`);
+	const root = envelope["root"];
+	return readNode(root);
+}
+function readExpr(j) {
+	if (!isObj(j)) return bad("expression: not an object");
+	const kind = j["kind"];
+	switch (kind) {
+		case "NumLit": return isNumber$1(j["value"]) ? ok(numLit(j["value"])) : bad("NumLit.value");
+		case "Vec3Lit": {
+			const v = readVec3(j["value"], "Vec3Lit.value");
+			return v.ok ? ok(vec3Lit(v.value)) : v;
+		}
+		case "Vec2Lit": {
+			const v = readVec2(j["value"], "Vec2Lit.value");
+			return v.ok ? ok(vec2Lit(v.value)) : v;
+		}
+		case "Param": return isString(j["name"]) ? ok(param(j["name"])) : bad("Param.name");
+		case "BinOp": return readBinOp(j);
+		case "UnaryOp": return readUnaryOp(j);
+		case "Component": return readComponent(j);
+		case "BuildVec": return readBuildVec(j);
+		default: return bad(`unknown expression kind: ${String(kind)}`);
+	}
+}
+function readBinOp(j) {
+	const op = j["op"];
+	if (op !== "+" && op !== "-" && op !== "*" && op !== "/") return bad(`BinOp.op: ${String(op)}`);
+	const a = readExpr(j["a"]);
+	if (!a.ok) return a;
+	const b = readExpr(j["b"]);
+	if (!b.ok) return b;
+	return ok(binOp(op, a.value, b.value));
+}
+function readUnaryOp(j) {
+	const op = j["op"];
+	if (!isString(op) || ![
+		"neg",
+		"sin",
+		"cos",
+		"sqrt",
+		"abs"
+	].includes(op)) return bad(`UnaryOp.op: ${String(op)}`);
+	const arg = readExpr(j["arg"]);
+	if (!arg.ok) return arg;
+	return ok(unaryOp(op, arg.value));
+}
+function readComponent(j) {
+	const index = j["index"];
+	if (index !== 0 && index !== 1 && index !== 2) return bad(`Component.index: ${String(index)}`);
+	const vec = readExpr(j["vec"]);
+	if (!vec.ok) return vec;
+	return ok(component(vec.value, index));
+}
+function readBuildVec(j) {
+	const dim = j["dim"];
+	if (dim !== 2 && dim !== 3) return bad(`BuildVec.dim: ${String(dim)}`);
+	const comps = j["components"];
+	if (!Array.isArray(comps)) return bad("BuildVec.components: not array");
+	if (comps.length !== dim) return bad(`BuildVec.components: expected ${dim} components, got ${comps.length}`);
+	const out = [];
+	for (const c of comps) {
+		const r = readExpr(c);
+		if (!r.ok) return r;
+		out.push(r.value);
+	}
+	return ok(buildVec(dim, out));
+}
+function readNodeArray(j, where) {
+	if (!Array.isArray(j)) return bad(`${where}: not array`);
+	const out = [];
+	for (const c of j) {
+		const r = readNode(c);
+		if (!r.ok) return r;
+		out.push(r.value);
+	}
+	return ok(out);
+}
+function readOptTolerance(j) {
+	const t = j["tolerance"];
+	if (t === void 0 || t === null) return ok(void 0);
+	return isNumber$1(t) ? ok(t) : bad("tolerance: not a finite number");
+}
+function readNode(j) {
+	if (!isObj(j)) return bad("node: not an object");
+	const kind = j["kind"];
+	switch (kind) {
+		case "Box":
+		case "Sphere":
+		case "Cylinder":
+		case "Cone":
+		case "Torus":
+		case "Polygon":
+		case "Circle":
+		case "Line":
+		case "Vertex":
+		case "Empty": return readPrimitive(kind, j);
+		case "Fuse":
+		case "Cut":
+		case "Intersect": return readBinaryBool(kind, j);
+		case "FuseAll":
+		case "CutAll": return readNaryBool(kind, j);
+		case "Translate":
+		case "Rotate":
+		case "Scale":
+		case "Mirror": return readTransform(kind, j);
+		case "Compound": return readCompound(j);
+		default: return bad(`unknown node kind: ${String(kind)}`);
+	}
+}
+function readSingleExpr(j, key, build) {
+	const r = readExpr(j[key]);
+	return r.ok ? ok(build(r.value)) : r;
+}
+function readPrimitive(kind, j) {
+	switch (kind) {
+		case "Box": return readBox(j);
+		case "Sphere": return readSingleExpr(j, "radius", sphere$1);
+		case "Cylinder": return readCylinder(j);
+		case "Cone": return readCone(j);
+		case "Torus": return readTorus(j);
+		case "Polygon": return readPolygon(j);
+		case "Circle": return readSingleExpr(j, "radius", circle$1);
+		case "Line": return readLine(j);
+		case "Vertex": return readSingleExpr(j, "point", vertex$1);
+		case "Empty": return readEmpty(j);
+	}
+	return bad(`unhandled primitive: ${kind}`);
+}
+function readBox(j) {
+	const x = readExpr(j["x"]);
+	if (!x.ok) return x;
+	const y = readExpr(j["y"]);
+	if (!y.ok) return y;
+	const z = readExpr(j["z"]);
+	if (!z.ok) return z;
+	return ok(box$1(x.value, y.value, z.value));
+}
+function readCylinder(j) {
+	const r = readExpr(j["radius"]);
+	if (!r.ok) return r;
+	const h = readExpr(j["height"]);
+	if (!h.ok) return h;
+	return ok(cylinder$1(r.value, h.value));
+}
+function readCone(j) {
+	const r1 = readExpr(j["radius1"]);
+	if (!r1.ok) return r1;
+	const r2 = readExpr(j["radius2"]);
+	if (!r2.ok) return r2;
+	const h = readExpr(j["height"]);
+	if (!h.ok) return h;
+	return ok(cone$1(r1.value, r2.value, h.value));
+}
+function readTorus(j) {
+	const ma = readExpr(j["majorRadius"]);
+	if (!ma.ok) return ma;
+	const mi = readExpr(j["minorRadius"]);
+	if (!mi.ok) return mi;
+	return ok(torus$1(ma.value, mi.value));
+}
+function readPolygon(j) {
+	const pts = j["points"];
+	if (!Array.isArray(pts)) return bad("Polygon.points: not array");
+	const out = [];
+	for (const p of pts) {
+		const r = readExpr(p);
+		if (!r.ok) return r;
+		out.push(r.value);
+	}
+	return ok(polygon$1(out));
+}
+function readLine(j) {
+	const f = readExpr(j["from"]);
+	if (!f.ok) return f;
+	const t = readExpr(j["to"]);
+	if (!t.ok) return t;
+	return ok(line$1(f.value, t.value));
+}
+function readEmpty(j) {
+	const out = j["output"];
+	switch (out) {
+		case "Solid": return ok(emptySolid());
+		case "Face": return ok(emptyFace());
+		case "Wire": return ok(emptyWire());
+		default: return bad(`Empty.output: ${String(out)}`);
+	}
+}
+function readBinaryBool(kind, j) {
+	const a = readNode(j["a"]);
+	if (!a.ok) return a;
+	const b = readNode(j["b"]);
+	if (!b.ok) return b;
+	const t = readOptTolerance(j);
+	if (!t.ok) return t;
+	switch (kind) {
+		case "Fuse": return ok(fuse$1(a.value, b.value, t.value));
+		case "Cut": return ok(cut$1(a.value, b.value, t.value));
+		case "Intersect": return ok(intersect$1(a.value, b.value, t.value));
+	}
+}
+function readNaryBool(kind, j) {
+	const t = readOptTolerance(j);
+	if (!t.ok) return t;
+	if (kind === "FuseAll") {
+		const shapes = readNodeArray(j["shapes"], "FuseAll.shapes");
+		return shapes.ok ? ok(fuseAll$1(shapes.value, t.value)) : shapes;
+	}
+	const base = readNode(j["base"]);
+	if (!base.ok) return base;
+	const tools = readNodeArray(j["tools"], "CutAll.tools");
+	return tools.ok ? ok(cutAll$1(base.value, tools.value, t.value)) : tools;
+}
+function readTransform(kind, j) {
+	const tgt = readNode(j["target"]);
+	if (!tgt.ok) return tgt;
+	switch (kind) {
+		case "Translate": return readTranslate(j, tgt.value);
+		case "Rotate": return readRotate(j, tgt.value);
+		case "Scale": return readScale(j, tgt.value);
+		case "Mirror": return readMirror(j, tgt.value);
+	}
+}
+function readTranslate(j, target) {
+	const v = readExpr(j["vector"]);
+	return v.ok ? ok(translate$1(target, v.value)) : v;
+}
+function readOptExpr(j, key) {
+	if (j[key] === void 0) return ok(void 0);
+	const r = readExpr(j[key]);
+	return r.ok ? ok(r.value) : r;
+}
+function readRotate(j, target) {
+	const ang = readExpr(j["angle"]);
+	if (!ang.ok) return ang;
+	const axis = readOptExpr(j, "axis");
+	if (!axis.ok) return axis;
+	const at = readOptExpr(j, "at");
+	if (!at.ok) return at;
+	return ok(rotate$1(target, ang.value, {
+		axis: axis.value,
+		at: at.value
+	}));
+}
+function readScale(j, target) {
+	const f = readExpr(j["factor"]);
+	if (!f.ok) return f;
+	const center = readOptExpr(j, "center");
+	if (!center.ok) return center;
+	return ok(scale$1(target, f.value, { center: center.value }));
+}
+function readMirror(j, target) {
+	const normal = readOptExpr(j, "normal");
+	if (!normal.ok) return normal;
+	const at = readOptExpr(j, "at");
+	if (!at.ok) return at;
+	return ok(mirror$1(target, {
+		normal: normal.value,
+		at: at.value
+	}));
+}
+function readCompound(j) {
+	const children = readNodeArray(j["children"], "Compound.children");
+	return children.ok ? ok(compound$1(children.value)) : children;
+}
+//#endregion
+//#region src/csg/optimize.ts
+function optimize(node) {
+	return optimizeNode(node);
+}
+function foldExpr(e) {
+	switch (e.kind) {
+		case "NumLit":
+		case "Vec3Lit":
+		case "Vec2Lit":
+		case "Param": return e;
+		case "BinOp": {
+			const a = foldExpr(e.a);
+			const b = foldExpr(e.b);
+			if (a.kind === "NumLit" && b.kind === "NumLit") switch (e.op) {
+				case "+": return numLit(a.value + b.value);
+				case "-": return numLit(a.value - b.value);
+				case "*": return numLit(a.value * b.value);
+				case "/": return numLit(a.value / b.value);
+			}
+			if (a !== e.a || b !== e.b) return binOp(e.op, a, b);
+			return e;
+		}
+		case "UnaryOp": {
+			const arg = foldExpr(e.arg);
+			if (arg.kind === "NumLit") {
+				const n = arg.value;
+				switch (e.op) {
+					case "neg": return numLit(-n);
+					case "sin": return numLit(Math.sin(n));
+					case "cos": return numLit(Math.cos(n));
+					case "sqrt": return numLit(Math.sqrt(n));
+					case "abs": return numLit(Math.abs(n));
+				}
+			}
+			if (arg !== e.arg) return unaryOp(e.op, arg);
+			return e;
+		}
+		case "Component": {
+			const v = foldExpr(e.vec);
+			if (v.kind === "Vec3Lit") return numLit(v.value[e.index]);
+			if (v.kind === "Vec2Lit" && (e.index === 0 || e.index === 1)) return numLit(v.value[e.index]);
+			if (v !== e.vec) return component(v, e.index);
+			return e;
+		}
+		case "BuildVec": {
+			const folded = e.components.map(foldExpr);
+			const collapsed = foldBuildVec(e.dim, folded);
+			if (collapsed) return collapsed;
+			if (folded.some((c, i) => c !== e.components[i])) return buildVec(e.dim, folded);
+			return e;
+		}
+	}
+}
+function foldBuildVec(dim, comps) {
+	if (comps.length !== dim) return void 0;
+	const nums = [];
+	for (const c of comps) {
+		if (c.kind !== "NumLit") return void 0;
+		nums.push(c.value);
+	}
+	if (dim === 2) return vec2Lit([nums[0], nums[1]]);
+	return vec3Lit([
+		nums[0],
+		nums[1],
+		nums[2]
+	]);
+}
+function optimizeNode(n) {
+	switch (n.kind) {
+		case "Box": return box$1(foldExpr(n.x), foldExpr(n.y), foldExpr(n.z));
+		case "Sphere": return sphere$1(foldExpr(n.radius));
+		case "Cylinder": return cylinder$1(foldExpr(n.radius), foldExpr(n.height));
+		case "Cone": return cone$1(foldExpr(n.radius1), foldExpr(n.radius2), foldExpr(n.height));
+		case "Torus": return torus$1(foldExpr(n.majorRadius), foldExpr(n.minorRadius));
+		case "Polygon": return polygon$1(n.points.map(foldExpr));
+		case "Circle": return circle$1(foldExpr(n.radius));
+		case "Line": return line$1(foldExpr(n.from), foldExpr(n.to));
+		case "Vertex": return vertex$1(foldExpr(n.point));
+		case "Empty": return n;
+		case "Fuse": return optimizeFuse(n.a, n.b, n.tolerance);
+		case "Cut": return optimizeCut(n.a, n.b, n.tolerance);
+		case "Intersect": return optimizeIntersect(n.a, n.b, n.tolerance);
+		case "FuseAll": return optimizeFuseAll(n.shapes, n.tolerance);
+		case "CutAll": return optimizeCutAll(n.base, n.tools, n.tolerance);
+		case "Translate": return optimizeTranslate(n.target, n.vector);
+		case "Rotate": return rotate$1(optimizeNode(n.target), foldExpr(n.angle), {
+			axis: n.axis ? foldExpr(n.axis) : void 0,
+			at: n.at ? foldExpr(n.at) : void 0
+		});
+		case "Scale": return scale$1(optimizeNode(n.target), foldExpr(n.factor), { center: n.center ? foldExpr(n.center) : void 0 });
+		case "Mirror": return mirror$1(optimizeNode(n.target), {
+			normal: n.normal ? foldExpr(n.normal) : void 0,
+			at: n.at ? foldExpr(n.at) : void 0
+		});
+		case "Compound": return compound$1(n.children.map(optimizeNode).filter((c) => c.kind !== "Empty"));
+	}
+}
+function optimizeFuse(a, b, tol) {
+	const oa = optimizeNode(a);
+	const ob = optimizeNode(b);
+	if (oa.kind === "Empty") return ob;
+	if (ob.kind === "Empty") return oa;
+	return fuse$1(oa, ob, tol);
+}
+function optimizeCut(a, b, tol) {
+	const oa = optimizeNode(a);
+	const ob = optimizeNode(b);
+	if (ob.kind === "Empty") return oa;
+	if (oa.kind === "Empty") return oa;
+	return cut$1(oa, ob, tol);
+}
+function optimizeIntersect(a, b, tol) {
+	const oa = optimizeNode(a);
+	const ob = optimizeNode(b);
+	if (oa.kind === "Empty") return oa;
+	if (ob.kind === "Empty") return ob;
+	return intersect$1(oa, ob, tol);
+}
+function optimizeFuseAll(shapes, tol) {
+	const opt = shapes.map(optimizeNode).filter((s) => s.kind !== "Empty");
+	if (opt.length === 0) return emptySolid();
+	if (opt.length === 1) return opt[0];
+	return fuseAll$1(opt, tol);
+}
+function optimizeCutAll(base, tools, tol) {
+	const ob = optimizeNode(base);
+	if (ob.kind === "Empty") return ob;
+	const ot = tools.map(optimizeNode).filter((s) => s.kind !== "Empty");
+	if (ot.length === 0) return ob;
+	return cutAll$1(ob, ot, tol);
+}
+function optimizeTranslate(target, vector) {
+	const ot = optimizeNode(target);
+	const ov = foldExpr(vector);
+	if (ov.kind !== "Vec3Lit") return translate$1(ot, ov);
+	const [x, y, z] = ov.value;
+	if (x === 0 && y === 0 && z === 0) return ot;
+	if (ot.kind === "Translate") {
+		const inner = foldExpr(ot.vector);
+		if (inner.kind === "Vec3Lit") return translate$1(ot.target, [
+			inner.value[0] + x,
+			inner.value[1] + y,
+			inner.value[2] + z
+		]);
+	}
+	return translate$1(ot, ov);
+}
+//#endregion
+//#region src/csg/edit.ts
+function replaceNode(root, pred, replacement) {
+	return walk(root, pred, replacement);
+}
+function walk(node, pred, repl) {
+	if (pred(node)) return repl;
+	return rebuildChildren(node, pred, repl);
+}
+function rebuildChildren(n, pred, repl) {
+	switch (n.kind) {
+		case "Box":
+		case "Sphere":
+		case "Cylinder":
+		case "Cone":
+		case "Torus":
+		case "Polygon":
+		case "Circle":
+		case "Line":
+		case "Vertex":
+		case "Empty": return n;
+		case "Fuse": return fuse$1(walk(n.a, pred, repl), walk(n.b, pred, repl), n.tolerance);
+		case "Cut": return cut$1(walk(n.a, pred, repl), walk(n.b, pred, repl), n.tolerance);
+		case "Intersect": return intersect$1(walk(n.a, pred, repl), walk(n.b, pred, repl), n.tolerance);
+		case "FuseAll": return fuseAll$1(n.shapes.map((c) => walk(c, pred, repl)), n.tolerance);
+		case "CutAll": return cutAll$1(walk(n.base, pred, repl), n.tools.map((c) => walk(c, pred, repl)), n.tolerance);
+		case "Translate": return translate$1(walk(n.target, pred, repl), n.vector);
+		case "Rotate": return rotate$1(walk(n.target, pred, repl), n.angle, {
+			axis: n.axis,
+			at: n.at
+		});
+		case "Scale": return scale$1(walk(n.target, pred, repl), n.factor, { center: n.center });
+		case "Mirror": return mirror$1(walk(n.target, pred, repl), {
+			normal: n.normal,
+			at: n.at
+		});
+		case "Compound": return compound$1(n.children.map((c) => walk(c, pred, repl)));
+	}
+}
+function forEachNode(root, fn) {
+	fn(root);
+	for (const child of childrenOf(root)) forEachNode(child, fn);
+}
+function childrenOf(n) {
+	switch (n.kind) {
+		case "Box":
+		case "Sphere":
+		case "Cylinder":
+		case "Cone":
+		case "Torus":
+		case "Polygon":
+		case "Circle":
+		case "Line":
+		case "Vertex":
+		case "Empty": return [];
+		case "Fuse":
+		case "Cut":
+		case "Intersect": return [n.a, n.b];
+		case "FuseAll": return n.shapes;
+		case "CutAll": return [n.base, ...n.tools];
+		case "Translate":
+		case "Rotate":
+		case "Scale":
+		case "Mirror": return [n.target];
+		case "Compound": return n.children;
+	}
+}
+function nodeCount(root) {
+	let n = 0;
+	forEachNode(root, () => {
+		n++;
+	});
+	return n;
+}
+//#endregion
+//#region src/ns/csg.ts
+var csg_exports = /* @__PURE__ */ __exportAll({
+	CSG_VERSION: () => 1,
+	Evaluator: () => Evaluator,
+	add: () => add,
+	asScalarExpr: () => asScalarExpr,
+	asVec2Expr: () => asVec2Expr,
+	asVec3Expr: () => asVec3Expr,
+	binOp: () => binOp,
+	box: () => box$1,
+	buildVec: () => buildVec,
+	circle: () => circle$1,
+	component: () => component,
+	compound: () => compound$1,
+	cone: () => cone$1,
+	cut: () => cut$1,
+	cutAll: () => cutAll$1,
+	cylinder: () => cylinder$1,
+	emptyFace: () => emptyFace,
+	emptySolid: () => emptySolid,
+	emptyWire: () => emptyWire,
+	foldExpr: () => foldExpr,
+	forEachNode: () => forEachNode,
+	fromJSON: () => fromJSON,
+	fuse: () => fuse$1,
+	fuseAll: () => fuseAll$1,
+	intersect: () => intersect$1,
+	line: () => line$1,
+	mirror: () => mirror$1,
+	mul: () => mul,
+	nodeCount: () => nodeCount,
+	numLit: () => numLit,
+	optimize: () => optimize,
+	outputKindOf: () => outputKindOf,
+	param: () => param,
+	polygon: () => polygon$1,
+	replaceNode: () => replaceNode,
+	rotate: () => rotate$1,
+	scale: () => scale$1,
+	sphere: () => sphere$1,
+	toJSON: () => toJSON,
+	torus: () => torus$1,
+	translate: () => translate$1,
+	unaryOp: () => unaryOp,
+	vec2Lit: () => vec2Lit,
+	vec3Lit: () => vec3Lit,
+	vertex: () => vertex$1,
+	withEvaluator: () => withEvaluator
+});
+//#endregion
+export { BaseSketcher2d, BlueprintSketcher, BrepBugError, BrepErrorCode, BrepWrapperError, BrepkitAdapter, CompoundSketch, DEG2RAD, DisposalScope, FaceSketcher, HASH_CODE_MAX, OK, OcctWasmAdapter, RAD2DEG, Sketch, Sketcher, Sketches, addChild, addHoles, addMate, addStep, adjacentFaces, all, andThen, applyGlue, applyMatrix, approximateCurve, as2D, as3D, asTopo, assignRoles, autoHeal, bezier, blueprintToDXF, booleanPipeline, booleans_exports as booleans, boss, box, bsplineApprox, bug, cameraFromPlane, cameraLookAt, captureHint, cast, castShape, castShape3D, chamfer, chamferDistAngle as chamferDistAngleShape, chamferWithEvolution, checkAllInterferences, checkBoolean, checkInterference, circle, circularPattern, classifyPointOnFace, clearMeshCache, clone, closedWire, collect, collectShapes, colorFaces, colorShape, complexExtrude, composeTransforms, compound, compoundSketchExtrude, compoundSketchFace, compoundSketchLoft, compoundSketchRevolve, computationError, computeStraightSkeleton, cone, construction_exports as construction, convexHull, cornerFinder, countNodes, createAssembly, createAssemblyNode, createBlueprint, createCamera, createCompound, createCompoundBlueprint, createDistanceQuery, createEdge, createFace, createHandle, createHistory, createKernelHandle, createMeshCache, createNamedPlane, createOperationRegistry, createPlane, createRef, createRegistry, createShell, createSolid, createTaskQueue, createVertex, createWire, createWorkerClient, createWorkerHandler, csg_exports as csg, curve2dBoundingBox, curve2dDistanceFrom, curve2dFirstPoint, curve2dIsOnCurve, curve2dLastPoint, curve2dParameter, curve2dSplitAt, curve2dTangentAt, curveEndPoint, curveIsClosed, curveIsPeriodic, curveLength, curvePeriod, curvePointAt, curveStartPoint, curveTangentAt, cut, cut2D, cutAll, cutAllBisect, cutBlueprints, cutWithEvolution, cylinder, defaultScorer, dequeueTask, describe, deserializeDrawing, deserializeHistory, fromBREP as deserializeShape, downcast, draft, draw, drawCircle, drawEllipse, drawFaceOutline, drawParametricFunction, drawPointsInterpolation, drawPolysides, drawProjection, drawRectangle, drawRoundedRectangle, drawSingleCircle, drawSingleEllipse, drawText, drawingChamfer, drawingCut, drawingFillet, drawingFuse, drawingIntersect, drawingToSketchOnPlane, drill, edgeFinder, edgesOfFace, ellipse, ellipseArc, ellipsoid, enqueueTask, err, exportAssemblySTEP, exportDXF, exportGlb, exportGltf, exportIGES, exportOBJ, exportSTEP, exportSTEPConfigured, exportSTL, exportThreeMF, extrude, extrudeAll, face, faceCenter, faceFinder, faceGeomType, faceOrientation, facesOfEdge, fill, filledFace, fillet, filletWithEvolution, findFacesByTag, findNode, findStep, fixSelfIntersection, fixShape, flatMap, flatten, flipFaceOrientation, flipOrientation, fontMetrics, fromBREP$1 as fromBREP, fromKernelDir, fromKernelPnt, fromKernelVec, fromNullable, fuse, fuse2D, fuseAll, fuseAllBisect, fuseBlueprints, fuseWithEvolution, gearGeometry, getBounds, getBounds2D, getCurveType, getDisposalStats, getEdges, getFaceColor, getFaceOrigins, getFaceTags, getFaces, getFont, getHashCode, getShape as getHistoryShape, getKernel, getNurbsCurveData, getNurbsSurfaceData, getOrientation, getOrientation2D, getPerformanceStats, getShapeColor, getShapeKind, getSingleFace, getSurfaceType, getTagMetadata, getVertices, getWires, guidedSweep, heal, healFace, healSolid, healWire, helix, hull, importDXF, importGLB, importIGES, importOBJ, importSTEP, importSTL, importSVG, importSVGPathD, importThreeMF, init, initFromOC, innerWires, interpolateCurve, intersect, intersect2D, intersectBlueprints, intersectWithEvolution, invalidateShapeCache, ioNs_exports as io, ioError, is2D, is3D, isChamferRadius, isClosedWire, isCompSolid, isCompound, isDisposeRequest, isEdge, isEmpty, isEqualShape, isErr, isErrorResponse, isFace, isFilletRadius, isInitRequest, isInside2D, isLive, isManifoldShell, isNumber, isOk, isOperationRequest, isOrientedFace, isPlanarFace, isPlanarWire, isProjectionPlane, isEmpty$1 as isQueueEmpty, isSameShape, isShape1D, isShape3D, isShell, isSolid, isSuccessResponse, isValid, isValidSolid, isVertex, isWire, iterEdges, iterFaces, iterTopo, iterVertices, iterWires, kernelCall, kernelCallRaw, kernelCallScoped, kernelError, line, linearPattern, loadFont, loft, loftAll, makeBaseBox, makeExternalGear, makeInternalGear, makePlane, makePlanetaryGear, makeProjectedEdges, manifoldShell, map, mapBoth, mapErr, match, measureArea, measureCurvatureAt, measureCurvatureAtMid, measureDistance, measureDistanceProps, measureLength, measureLinearProps, measureSurfaceProps, measureVolume, measureVolumeProps, measurement_exports as measurement, mesh, meshEdges, meshMultiLOD, minkowski, mirror, mirror2D, mirrorDrawing, mirrorJoin, modifiers_exports as modifiers, modifyStep, moduleInitError, multiSectionSweep, normalAt, offset, offsetFace, offsetWire2D, ok, or, orElse, organiseBlueprints, orientedFace, outerWire, patterns_exports as patterns, pendingCount, pipeline, pivotPlane, planarFace, planarWire, planetPlacements, pocket, pointOnSurface, polygon, polyhedron, polysideInnerRadius, polysidesBlueprint, positionOnCurve, prewarm, primitives_exports as primitives, projectEdges, projectPointOnFace, query_exports as query, queryError, rectangularPattern, registerHandler, registerKernel, registerOperation, registerShape, rejectAll, removeChild, removeHolesFromFace, replayFrom, replayHistory, resetDisposalStats, resetPerformanceStats, resize, resolve, resolve3D, resolveDirection, resolvePlane, resolveRef, reverseCurve, revolve, roof, rotate, rotate2D, rotateDrawing, roundedRectangleBlueprint, scale, scale2D, scaleDrawing, section, sectionToFace, serializeHistory, setShapeOrigin, setTagMetadata, sewShells, shape, shapeType, sharedEdges, shell, shellWithEvolution, simplify, sketchCircle, sketchEllipse, sketchExtrude, sketchFace, sketchFaceOffset, sketchHelix, sketchLoft, sketchOnFace2D, sketchOnPlane2D, sketchParametricFunction, sketchPolysides, sketchRectangle, sketchRevolve, sketchRoundedRectangle, sketchSweep, sketchText, sketchWires, sketcherStateError, slice, solid, solidFromShell, solveAssembly, sphere, split, stepCount, stepsFrom, stretch2D, subFace, supportExtrude, supportsConstraintSketch, supportsProjection, surfaceFromGrid, surfaceFromImage, sweep, tagFaces, tangentArc, tap, tapErr, textBlueprints, textMetrics, thicken, threePointArc, toBREP, toBufferGeometryData, toGroupedBufferGeometryData, toKernelVec, toLODGeometryData, toLineGeometryData, toSVGPathD, toVec2, toVec3, torus, transformCopy, transforms_exports as transforms, translate, translate2D, translateDrawing, translatePlane, tryCatch, tryCatchAsync, twistExtrude, typeCastError, undoLast, unsupportedError, unwrap, unwrapErr, unwrapOr, unwrapOrElse, updateNode, updateRoles, uvBounds, uvCoordinates, validSolid, validatePlanetary, validationError, variableFillet, vecAdd, vecAngle, vecCross, vecDistance, vecDot, vecEquals, vecIsZero, vecLength, vecLengthSq, vecNegate, vecNormalize, vecProjectToPlane, vecRepr, vecRotate, vecScale, vecSub, vertex, vertexFinder, vertexPosition, verticesOfEdge, walkAssembly, wire, wireFinder, wireLoop, wiresOfFace, withKernel, withKernelDir, withKernelPnt, withKernelVec, withScope, withScopeResult, withScopeResultAsync, zip as zipResults };