brepjs 20.1.4 → 20.2.0

package/dist/brepjs.cjs

@@ -1,41 +1,41 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_rolldown_runtime = require("./rolldown-runtime-C0BPl7ul.cjs");
-const require_shapeTypes = require("./shapeTypes-CACpB7r3.cjs");
+const require_shapeTypes = require("./shapeTypes-BWsKDxzf.cjs");
 const require_occtWasmAdapter = require("./occtWasmAdapter-wCKnmevS.cjs");
 const require_bug = require("./bug-O02CsAmt.cjs");
-const require_errors = require("./errors-DWezb9DI.cjs");
-const require_topologyQueryFns = require("./topologyQueryFns-Cp390rTF.cjs");
-const require_validityTypes = require("./validityTypes-DtfxKjGs.cjs");
+const require_errors = require("./errors-gG-7hA7k.cjs");
+const require_topologyQueryFns = require("./topologyQueryFns-CI4j3NTE.cjs");
+const require_validityTypes = require("./validityTypes-D9oxhu4U.cjs");
 const require_constants = require("./constants-BOVyEYGH.cjs");
 const require_types = require("./types-KjA8tY4Y.cjs");
 const require_vecOps = require("./vecOps-CCnJt-yH.cjs");
-const require_planeOps = require("./planeOps-CpupTCRM.cjs");
-const require_faceFns = require("./faceFns-CGXvMjno.cjs");
-const require_originTrackingFns = require("./originTrackingFns-CuCeiMNZ.cjs");
-const require_solidBuilders = require("./solidBuilders-BdKU5bQ9.cjs");
-const require_primitiveFns = require("./primitiveFns-DSUL72Md.cjs");
-const require_shapeFns = require("./shapeFns-BsuUPJR3.cjs");
-const require_curveFns = require("./curveFns-BXGE1xHa.cjs");
-const require_meshFns = require("./meshFns-vO9xsIlB.cjs");
+const require_planeOps = require("./planeOps-DqGSxcMr.cjs");
+const require_faceFns = require("./faceFns-DaXVpMr5.cjs");
+const require_originTrackingFns = require("./originTrackingFns-B3-1bBED.cjs");
+const require_solidBuilders = require("./solidBuilders-B8t5h68e.cjs");
+const require_primitiveFns = require("./primitiveFns-Ke-n8Bib.cjs");
+const require_shapeFns = require("./shapeFns-CmJNoPsh.cjs");
+const require_curveFns = require("./curveFns-DciWOppG.cjs");
+const require_meshFns = require("./meshFns-BT7W4b1c.cjs");
 const require_arrayAccess = require("./arrayAccess-e4H9cBfh.cjs");
-const require_surfaceBuilders = require("./surfaceBuilders-BaVNAtRf.cjs");
-const require_healingFns = require("./healingFns-D8_IZ8LC.cjs");
-const require_threadFns = require("./threadFns-P682L-Kg.cjs");
-const require_blueprintSketcher = require("./blueprintSketcher-DobJgYX3.cjs");
-const require_helpers = require("./helpers-BjKe6-M-.cjs");
-const require_blueprint = require("./blueprint-BsaJ4TJW.cjs");
-const require_drawFns = require("./drawFns-B9JThnjT.cjs");
-const require_measureFns = require("./measureFns-CyU-fOaZ.cjs");
-const require_cornerFinder = require("./cornerFinder-BdK6e9T-.cjs");
-const require_boolean2D = require("./boolean2D-CB3xwM21.cjs");
-const require_blueprintFns = require("./blueprintFns-CCVf2Yat.cjs");
-const require_importFns = require("./importFns-C0WKTbbQ.cjs");
-const require_loftFns = require("./loftFns-B3aEz87L.cjs");
-const require_textBlueprints = require("./textBlueprints-BHOADZSh.cjs");
-const require_refResolveFns = require("./refResolveFns-BleIGUVN.cjs");
-const require_adjacencyFns = require("./adjacencyFns-C_ZNyZRx.cjs");
-const require_cameraFns = require("./cameraFns-BSHErz3i.cjs");
-const require_textMetrics = require("./textMetrics-DHWYuTUK.cjs");
+const require_surfaceBuilders = require("./surfaceBuilders-Bn-c9xVR.cjs");
+const require_healingFns = require("./healingFns-C_f03IV6.cjs");
+const require_threadFns = require("./threadFns-DAKMitvE.cjs");
+const require_blueprintSketcher = require("./blueprintSketcher-DRXOTYuD.cjs");
+const require_helpers = require("./helpers-Dh4qTGcQ.cjs");
+const require_blueprint = require("./blueprint-CJuRunkd.cjs");
+const require_drawFns = require("./drawFns-DeUXFpjR.cjs");
+const require_measureFns = require("./measureFns-B8Yj_BMz.cjs");
+const require_cornerFinder = require("./cornerFinder-BVUuCBX-.cjs");
+const require_boolean2D = require("./boolean2D-DmPqFj_V.cjs");
+const require_blueprintFns = require("./blueprintFns-BRceCeZp.cjs");
+const require_importFns = require("./importFns-CKfKRdiq.cjs");
+const require_loftFns = require("./loftFns-CI8uJc1D.cjs");
+const require_textBlueprints = require("./textBlueprints-DQi920gG.cjs");
+const require_refResolveFns = require("./refResolveFns-BPqbBoxy.cjs");
+const require_adjacencyFns = require("./adjacencyFns-DZsPfYIq.cjs");
+const require_cameraFns = require("./cameraFns-B8Ai6b3Q.cjs");
+const require_textMetrics = require("./textMetrics-DhysRMr7.cjs");
 const require_workerPool = require("./workerPool-D30NsiIW.cjs");
 //#region src/kernel/types.ts
 /** Check if the kernel supports hidden-line-removal projection. */
@@ -1174,6 +1174,14 @@ function fnvMixInt32(h, n) {
 	}
 	return r;
 }
+function fnvMixText(h, s) {
+	let r = fnvMixInt32(h, s.length);
+	for (let i = 0; i < s.length; i++) {
+		const c = s.charCodeAt(i);
+		r = fnvMixByte(fnvMixByte(r, c), c >>> 8);
+	}
+	return r;
+}
 function fnvMixBool(h, b) {
 	return fnvMixByte(h, b ? 1 : 0);
 }
@@ -1522,6 +1530,130 @@ function foldSegment(s, foldExpr) {
 	}
 }
 //#endregion
+//#region src/csg/jsonData.ts
+/** Validate `value` as JSON-safe and return its canonical frozen copy, or a
+*  message naming the first offending path (rooted at `path`). */
+function canonicalJson(value, path) {
+	return copyJson(value, path, /* @__PURE__ */ new Set());
+}
+function copyJson(v, path, ancestors) {
+	if (v === null || typeof v === "boolean" || typeof v === "string") return require_errors.ok(v);
+	if (typeof v === "number") {
+		if (!Number.isFinite(v)) return require_errors.err(`${path}: ${String(v)} is not JSON-safe`);
+		return require_errors.ok(v === 0 ? 0 : v);
+	}
+	if (typeof v !== "object") return require_errors.err(`${path}: ${typeof v} is not JSON-safe`);
+	if (ancestors.has(v)) return require_errors.err(`${path}: circular reference is not JSON-safe`);
+	ancestors.add(v);
+	const out = Array.isArray(v) ? copyArray(v, path, ancestors) : copyObject(v, path, ancestors);
+	ancestors.delete(v);
+	return out;
+}
+function copyArray(v, path, ancestors) {
+	const out = [];
+	for (let i = 0; i < v.length; i++) {
+		const r = copyJson(v[i], `${path}[${i}]`, ancestors);
+		if (!r.ok) return r;
+		out.push(r.value);
+	}
+	return require_errors.ok(Object.freeze(out));
+}
+function copyObject(v, path, ancestors) {
+	const proto = Object.getPrototypeOf(v);
+	if (proto !== Object.prototype && proto !== null) {
+		const ctor = v.constructor;
+		const what = typeof ctor === "function" && ctor.name ? `${ctor.name} instance` : "object";
+		return require_errors.err(`${path}: ${what} is not JSON-safe (use a plain object)`);
+	}
+	const record = v;
+	const entries = [];
+	for (const key of Object.keys(record).sort()) {
+		const r = copyJson(record[key], `${path}.${key}`, ancestors);
+		if (!r.ok) return r;
+		entries.push([key, r.value]);
+	}
+	return require_errors.ok(Object.freeze(Object.fromEntries(entries)));
+}
+var TAG_NULL = 0;
+var TAG_FALSE = 1;
+var TAG_TRUE = 2;
+var TAG_NUMBER = 3;
+var TAG_STRING = 4;
+var TAG_ARRAY = 5;
+var TAG_OBJECT = 6;
+/** Type-tagged, length-prefixed Merkle mix of a JSON value; object keys are
+*  hashed in sorted order, so key order never changes the result. */
+function hashJson(h, v) {
+	if (v === null) return fnvMixByte(h, TAG_NULL);
+	if (typeof v === "boolean") return fnvMixByte(h, v ? TAG_TRUE : TAG_FALSE);
+	if (typeof v === "number") return fnvMixNumber(fnvMixByte(h, TAG_NUMBER), v);
+	if (typeof v === "string") return fnvMixText(fnvMixByte(h, TAG_STRING), v);
+	if (isJsonArray(v)) {
+		let r = fnvMixInt32(fnvMixByte(h, TAG_ARRAY), v.length);
+		for (const item of v) r = hashJson(r, item);
+		return r;
+	}
+	const keys = Object.keys(v).sort();
+	let r = fnvMixInt32(fnvMixByte(h, TAG_OBJECT), keys.length);
+	for (const key of keys) {
+		r = fnvMixText(r, key);
+		r = hashJson(r, v[key] ?? null);
+	}
+	return r;
+}
+function isJsonArray(v) {
+	return Array.isArray(v);
+}
+//#endregion
+//#region src/csg/types.ts
+var OUTPUT_KINDS = {
+	Solid: true,
+	Face: true,
+	Wire: true,
+	Edge: true,
+	Vertex: true,
+	Compound: true
+};
+function isOutputKind(v) {
+	return typeof v === "string" && Object.hasOwn(OUTPUT_KINDS, v);
+}
+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":
+		case "Color": return outputKindOf(node.target);
+		case "Extrude":
+		case "Revolve":
+		case "Loft":
+		case "Sweep":
+		case "Fillet":
+		case "Chamfer":
+		case "Shell": return "Solid";
+		case "Profile": return "Face";
+		case "Path": return "Wire";
+		case "Compound": return "Compound";
+		case "Instance": return node.fuse ? "Solid" : "Compound";
+		case "Extension": return node.output;
+	}
+}
+//#endregion
 //#region src/csg/builders.ts
 var EMPTY_DEPS = /* @__PURE__ */ new Set();
 function startHash(tag) {
@@ -2025,42 +2157,47 @@ function instance$1(source, placements, fuse = false) {
 		freeParams: depsOf(source)
 	};
 }
-//#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":
-		case "Color": return outputKindOf(node.target);
-		case "Extrude":
-		case "Revolve":
-		case "Loft":
-		case "Sweep":
-		case "Fillet":
-		case "Chamfer":
-		case "Shell": return "Solid";
-		case "Profile": return "Face";
-		case "Path": return "Wire";
-		case "Compound": return "Compound";
-		case "Instance": return node.fuse ? "Solid" : "Compound";
-	}
+function isExpr(v) {
+	return typeof v === "object" && v !== null && typeof v.structuralHash === "bigint";
+}
+function extensionParams(name, input) {
+	const entries = [];
+	for (const key of Object.keys(input).sort()) {
+		const v = input[key];
+		if (typeof v !== "number" && !isExpr(v)) throw new TypeError(`csg.extension(${name}): params.${key} must be a number or an Expr`);
+		entries.push([key, asScalarExpr(v)]);
+	}
+	return entries;
+}
+/** A caller-defined operation, materialized at evaluation by the
+*  `ExtensionEvaluator` registered under `name` in
+*  `EvaluatorOptions.extensions`. Unlike the other builders this one validates
+*  eagerly and throws a TypeError: a node whose data cannot be hashed
+*  canonically has no content address. */
+function extension(name, output, options) {
+	if (typeof name !== "string" || name.length === 0) throw new TypeError("csg.extension: name must be a non-empty string");
+	if (!isOutputKind(output)) throw new TypeError(`csg.extension(${name}): unknown output kind ${String(output)}`);
+	const data = canonicalJson(options?.data ?? null, "data");
+	if (!data.ok) throw new TypeError(`csg.extension(${name}): ${data.error}`);
+	const children = [...options?.children ?? []];
+	const params = extensionParams(name, options?.params ?? {});
+	let h = fnvMixText(startHash("Extension"), name);
+	h = fnvMixText(h, output);
+	h = fnvMixInt32(h, children.length);
+	for (const c of children) h = mix(h, c);
+	h = fnvMixInt32(h, params.length);
+	for (const [key, e] of params) h = mix(fnvMixText(h, key), e);
+	h = hashJson(h, data.value);
+	return {
+		kind: "Extension",
+		name,
+		output,
+		children,
+		params: Object.fromEntries(params),
+		data: data.value,
+		structuralHash: h,
+		freeParams: depsOf(...children, ...params.map(([, e]) => e))
+	};
 }
 //#endregion
 //#region src/csg/profiles.ts
@@ -3115,6 +3252,29 @@ function evalShell(node, ctx) {
 	return require_healingFns.shell(solid.value, faces, thickness.value);
 }
 //#endregion
+//#region src/csg/evaluators/extension.ts
+function evalExtension(node, ctx) {
+	const evaluator = ctx.extensions.get(node.name);
+	if (evaluator === void 0) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.CSG_EXTENSION_UNKNOWN, `Extension: no evaluator registered for '${node.name}'`, void 0, { name: node.name }, `Register one with new csg.Evaluator({ extensions: { '${node.name}': fn } })`));
+	const params = [];
+	for (const [key, expr] of Object.entries(node.params)) {
+		const v = evalScalar(expr, ctx.env, `Extension(${node.name}).params.${key}`);
+		if (!v.ok) return v;
+		params.push([key, v.value]);
+	}
+	const children = [];
+	for (const child of node.children) {
+		const r = ctx.evalNode(child);
+		if (!r.ok) return r;
+		children.push(r.value);
+	}
+	return evaluator({
+		params: Object.fromEntries(params),
+		data: node.data,
+		children
+	});
+}
+//#endregion
 //#region src/csg/evaluate.ts
 function dispatch(node, ctx) {
 	switch (node.kind) {
@@ -3139,6 +3299,7 @@ function dispatch(node, ctx) {
 		case "Mirror": return evalMirror(node, ctx);
 		case "Compound": return evalCompound(node, ctx);
 		case "Instance": return evalInstance(node, ctx);
+		case "Extension": return evalExtension(node, ctx);
 		case "Extrude":
 		case "Revolve":
 		case "Loft":
@@ -3366,6 +3527,7 @@ var Evaluator = class {
 	maxMeshCacheEntries;
 	meshCache = /* @__PURE__ */ new Map();
 	onStep;
+	extensions;
 	hits = 0;
 	misses = 0;
 	evictions = 0;
@@ -3379,6 +3541,9 @@ var Evaluator = class {
 		const meshMax = options.maxMeshCacheEntries;
 		if (meshMax !== void 0 && (!Number.isInteger(meshMax) || meshMax < 1)) throw new RangeError(`Evaluator: maxMeshCacheEntries must be a positive integer, got ${String(meshMax)}`);
 		this.maxMeshCacheEntries = meshMax;
+		const extensions = new Map(Object.entries(options.extensions ?? {}));
+		for (const [name, fn] of extensions) if (typeof fn !== "function") throw new TypeError(`Evaluator: extensions['${name}'] must be a function`);
+		this.extensions = extensions;
 	}
 	/**
 	* Materialize a CSG IR tree against the given parameter environment.
@@ -3507,7 +3672,8 @@ var Evaluator = class {
 		const result = dispatch(node, {
 			env,
 			tolerance: this.defaultTolerance,
-			evalNode: (child) => this.evaluateInner(child, env)
+			evalNode: (child) => this.evaluateInner(child, env),
+			extensions: this.extensions
 		});
 		if (!result.ok) return result;
 		const shape = result.value;
@@ -3635,6 +3801,11 @@ function rebuildChildren(n, pred, repl, memo) {
 		});
 		case "Compound": return compound$1(n.children.map((c) => walk(c, pred, repl, memo)));
 		case "Instance": return instance$1(walk(n.source, pred, repl, memo), n.placements, n.fuse);
+		case "Extension": return extension(n.name, n.output, {
+			children: n.children.map((c) => walk(c, pred, repl, memo)),
+			params: n.params,
+			data: n.data
+		});
 		case "Extrude":
 		case "Revolve":
 		case "Loft":
@@ -3699,7 +3870,8 @@ function childrenOf(n) {
 		case "Fillet":
 		case "Chamfer":
 		case "Shell": return [n.target];
-		case "Compound": return n.children;
+		case "Compound":
+		case "Extension": return n.children;
 		case "Instance": return [n.source];
 		case "Extrude":
 		case "Revolve": return [n.profile];
@@ -3723,11 +3895,11 @@ function toJSON(node) {
 	};
 	const root = emitNode(node, ctx);
 	return ctx.defs.length > 0 ? {
-		csgVersion: 8,
+		csgVersion: 9,
 		defs: ctx.defs,
 		root
 	} : {
-		csgVersion: 8,
+		csgVersion: 9,
 		root
 	};
 }
@@ -4000,7 +4172,18 @@ function featureToJson(n, ctx) {
 		default: return;
 	}
 }
+function extensionToJson(n, ctx) {
+	return {
+		kind: "Extension",
+		name: n.name,
+		output: n.output,
+		children: n.children.map((c) => emitNode(c, ctx)),
+		params: Object.fromEntries(Object.entries(n.params).map(([k, e]) => [k, exprToJson(e)])),
+		data: n.data
+	};
+}
 function nodeToJson(n, ctx) {
+	if (n.kind === "Extension") return extensionToJson(n, ctx);
 	if (n.kind === "Color") return {
 		kind: "Color",
 		target: emitNode(n.target, ctx),
@@ -4067,7 +4250,7 @@ function readVec2(v, where) {
 function fromJSON(envelope) {
 	if (!isObj(envelope)) return bad("input is not an object");
 	const v = envelope["csgVersion"];
-	if (typeof v !== "number" || !Number.isInteger(v) || v < MIN_CSG_VERSION || v > 8) return bad(`unsupported csgVersion ${String(v)} (expected ${MIN_CSG_VERSION}..8)`);
+	if (typeof v !== "number" || !Number.isInteger(v) || v < MIN_CSG_VERSION || v > 9) return bad(`unsupported csgVersion ${String(v)} (expected ${MIN_CSG_VERSION}..9)`);
 	const rawDefs = envelope["defs"];
 	const defs = [];
 	if (rawDefs !== void 0) {
@@ -4159,15 +4342,15 @@ function readOptTolerance(j) {
 	if (t === void 0 || t === null) return require_errors.ok(void 0);
 	return isNumber$1(t) ? require_errors.ok(t) : bad("tolerance: not a finite number");
 }
+function readRef(ref, defs) {
+	if (!isNumber$1(ref) || !Number.isInteger(ref) || ref < 0) return bad("$ref: expected a non-negative integer def index");
+	const node = defs[ref];
+	if (node === void 0) return bad(`$ref: ${ref} is out of range (forward refs are rejected)`);
+	return require_errors.ok(node);
+}
 function readNode(j, defs) {
 	if (!isObj(j)) return bad("node: not an object");
-	const ref = j["$ref"];
-	if (ref !== void 0) {
-		if (!isNumber$1(ref) || !Number.isInteger(ref) || ref < 0) return bad("$ref: expected a non-negative integer def index");
-		const node = defs[ref];
-		if (node === void 0) return bad(`$ref: ${ref} is out of range (forward refs are rejected)`);
-		return require_errors.ok(node);
-	}
+	if (j["$ref"] !== void 0) return readRef(j["$ref"], defs);
 	const kind = j["kind"];
 	switch (kind) {
 		case "Box":
@@ -4201,6 +4384,7 @@ function readNode(j, defs) {
 		case "Fillet": return readFillet(j, defs);
 		case "Chamfer": return readChamfer(j, defs);
 		case "Shell": return readShell(j, defs);
+		case "Extension": return readExtension(j, defs);
 		default: return bad(`unknown node kind: ${String(kind)}`);
 	}
 }
@@ -4612,6 +4796,34 @@ function readCompound(j, defs) {
 function isMatrix4x4(v) {
 	return Array.isArray(v) && v.length === 4 && v.every((row) => Array.isArray(row) && row.length === 4 && row.every(isNumber$1));
 }
+function readExtensionParams(j) {
+	if (j === void 0) return require_errors.ok({});
+	if (!isObj(j)) return bad("Extension.params: not an object");
+	const entries = [];
+	for (const [key, raw] of Object.entries(j)) {
+		const e = readExpr(raw);
+		if (!e.ok) return e;
+		entries.push([key, e.value]);
+	}
+	return require_errors.ok(Object.fromEntries(entries));
+}
+function readExtension(j, defs) {
+	const name = j["name"];
+	if (!isString(name) || name.length === 0) return bad("Extension.name: expected a non-empty string");
+	const output = j["output"];
+	if (!isOutputKind(output)) return bad(`Extension.output: ${String(output)}`);
+	const children = j["children"] === void 0 ? require_errors.ok([]) : readNodeArray(j["children"], "Extension.children", defs);
+	if (!children.ok) return children;
+	const params = readExtensionParams(j["params"]);
+	if (!params.ok) return params;
+	const data = canonicalJson(j["data"] ?? null, "Extension.data");
+	if (!data.ok) return bad(data.error);
+	return require_errors.ok(extension(name, output, {
+		children: children.value,
+		params: params.value,
+		data: data.value
+	}));
+}
 function readInstance(j, defs) {
 	const source = readNode(j["source"], defs);
 	if (!source.ok) return source;
@@ -4718,6 +4930,7 @@ function rewriteNode(n) {
 		case "Mirror": return optimizeTransform(n);
 		case "Compound": return compound$1(n.children.map(optimizeNode).filter((c) => c.kind !== "Empty"));
 		case "Instance": return instance$1(optimizeNode(n.source), n.placements, n.fuse);
+		case "Extension": return optimizeExtension(n);
 		case "Extrude":
 		case "Revolve":
 		case "Loft":
@@ -4747,6 +4960,13 @@ function optimizeFeature(n) {
 		case "Shell": return shell$1(optimizeNode(n.target), n.refs, foldExpr(n.thickness));
 	}
 }
+function optimizeExtension(n) {
+	return extension(n.name, n.output, {
+		children: n.children.map(optimizeNode),
+		params: Object.fromEntries(Object.entries(n.params).map(([k, e]) => [k, foldExpr(e)])),
+		data: n.data
+	});
+}
 function optimizeTransform(n) {
 	switch (n.kind) {
 		case "Rotate": return rotate$1(optimizeNode(n.target), foldExpr(n.angle), {
@@ -8770,7 +8990,7 @@ var patterns_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
 //#endregion
 //#region src/ns/csg.ts
 var csg_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
-	CSG_VERSION: () => 8,
+	CSG_VERSION: () => 9,
 	Evaluator: () => Evaluator,
 	add: () => add$1,
 	arbitraryClosedProfile: () => arbitraryClosedProfile,
@@ -8802,6 +9022,7 @@ var csg_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
 	emptyFace: () => emptyFace,
 	emptySolid: () => emptySolid,
 	emptyWire: () => emptyWire,
+	extension: () => extension,
 	extrude: () => extrude$1,
 	fillet: () => fillet$1,
 	foldExpr: () => foldExpr,