brepjs 18.102.0 → 18.103.0

package/dist/brepjs.cjs

@@ -5471,6 +5471,19 @@ function compound$1(children) {
 		freeParams: depsOf(...children)
 	};
 }
+function instance$1(source, placements, fuse = false) {
+	const copied = placements.map((m) => m.map((row) => [...row]));
+	let h = fnvMixInt32(fnvMixBool(mix(startHash("Instance"), source), fuse), copied.length);
+	for (const m of copied) for (const v of m.flat()) h = fnvMixNumber(h, v);
+	return {
+		kind: "Instance",
+		source,
+		placements: copied,
+		fuse,
+		structuralHash: h,
+		freeParams: depsOf(source)
+	};
+}
 //#endregion
 //#region src/csg/types.ts
 function outputKindOf(node) {
@@ -5495,6 +5508,7 @@ function outputKindOf(node) {
 		case "Scale":
 		case "Mirror": return outputKindOf(node.target);
 		case "Compound": return "Compound";
+		case "Instance": return node.fuse ? "Solid" : "Compound";
 	}
 }
 //#endregion
@@ -5728,6 +5742,13 @@ function evalEmpty() {
 	return require_errors.err(require_errors.computationError(require_errors.BrepErrorCode.NULL_SHAPE_INPUT, "Empty: cannot materialize an Empty node directly — only valid as boolean/transform operand"));
 }
 //#endregion
+//#region src/csg/evaluators/instance.ts
+function evalInstance(node, ctx) {
+	const r = ctx.evalNode(node.source);
+	if (!r.ok) return r;
+	return materialize(instance(r.value, node.placements), { fuse: node.fuse });
+}
+//#endregion
 //#region src/csg/evaluate.ts
 function dispatch(node, ctx) {
 	switch (node.kind) {
@@ -5751,6 +5772,7 @@ function dispatch(node, ctx) {
 		case "Scale": return evalScale(node, ctx);
 		case "Mirror": return evalMirror(node, ctx);
 		case "Compound": return evalCompound(node, ctx);
+		case "Instance": return evalInstance(node, ctx);
 	}
 }
 function hashExprValue(h, v) {
@@ -6085,6 +6107,12 @@ function nodeToJson(n) {
 		kind: "Compound",
 		children: n.children.map(nodeToJson)
 	};
+	if (n.kind === "Instance") return {
+		kind: "Instance",
+		source: nodeToJson(n.source),
+		placements: n.placements,
+		fuse: n.fuse
+	};
 	return primitiveToJson(n) ?? booleanToJson(n) ?? transformToJson(n);
 }
 function bad(msg) {
@@ -6225,6 +6253,7 @@ function readNode(j) {
 		case "Scale":
 		case "Mirror": return readTransform(kind, j);
 		case "Compound": return readCompound(j);
+		case "Instance": return readInstance(j);
 		default: return bad(`unknown node kind: ${String(kind)}`);
 	}
 }
@@ -6383,6 +6412,16 @@ function readCompound(j) {
 	const children = readNodeArray(j["children"], "Compound.children");
 	return children.ok ? require_errors.ok(compound$1(children.value)) : children;
 }
+function isMatrix4x4(v) {
+	return Array.isArray(v) && v.length === 4 && v.every((row) => Array.isArray(row) && row.length === 4 && row.every(isNumber$1));
+}
+function readInstance(j) {
+	const source = readNode(j["source"]);
+	if (!source.ok) return source;
+	const placements = j["placements"];
+	if (!Array.isArray(placements) || !placements.every(isMatrix4x4)) return bad("Instance.placements must be an array of 4x4 number matrices");
+	return require_errors.ok(instance$1(source.value, placements, j["fuse"] === true));
+}
 //#endregion
 //#region src/csg/optimize.ts
 function optimize(node) {
@@ -6479,6 +6518,7 @@ function optimizeNode(n) {
 			at: n.at ? foldExpr(n.at) : void 0
 		});
 		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);
 	}
 }
 function optimizeFuse(a, b, tol) {
@@ -6568,6 +6608,7 @@ function rebuildChildren(n, pred, repl) {
 			at: n.at
 		});
 		case "Compound": return compound$1(n.children.map((c) => walk(c, pred, repl)));
+		case "Instance": return instance$1(walk(n.source, pred, repl), n.placements, n.fuse);
 	}
 }
 function forEachNode(root, fn) {
@@ -6596,6 +6637,7 @@ function childrenOf(n) {
 		case "Scale":
 		case "Mirror": return [n.target];
 		case "Compound": return n.children;
+		case "Instance": return [n.source];
 	}
 }
 function nodeCount(root) {
@@ -6632,6 +6674,7 @@ var csg_exports = /* @__PURE__ */ require_textBlueprints.__exportAll({
 	fromJSON: () => fromJSON,
 	fuse: () => fuse$1,
 	fuseAll: () => fuseAll$1,
+	instance: () => instance$1,
 	intersect: () => intersect$1,
 	line: () => line$1,
 	mirror: () => mirror$1,

package/dist/brepjs.js

@@ -5474,6 +5474,19 @@ function compound$1(children) {
 		freeParams: depsOf(...children)
 	};
 }
+function instance$1(source, placements, fuse = false) {
+	const copied = placements.map((m) => m.map((row) => [...row]));
+	let h = fnvMixInt32(fnvMixBool(mix(startHash("Instance"), source), fuse), copied.length);
+	for (const m of copied) for (const v of m.flat()) h = fnvMixNumber(h, v);
+	return {
+		kind: "Instance",
+		source,
+		placements: copied,
+		fuse,
+		structuralHash: h,
+		freeParams: depsOf(source)
+	};
+}
 //#endregion
 //#region src/csg/types.ts
 function outputKindOf(node) {
@@ -5498,6 +5511,7 @@ function outputKindOf(node) {
 		case "Scale":
 		case "Mirror": return outputKindOf(node.target);
 		case "Compound": return "Compound";
+		case "Instance": return node.fuse ? "Solid" : "Compound";
 	}
 }
 //#endregion
@@ -5731,6 +5745,13 @@ 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/evaluators/instance.ts
+function evalInstance(node, ctx) {
+	const r = ctx.evalNode(node.source);
+	if (!r.ok) return r;
+	return materialize(instance(r.value, node.placements), { fuse: node.fuse });
+}
+//#endregion
 //#region src/csg/evaluate.ts
 function dispatch(node, ctx) {
 	switch (node.kind) {
@@ -5754,6 +5775,7 @@ function dispatch(node, ctx) {
 		case "Scale": return evalScale(node, ctx);
 		case "Mirror": return evalMirror(node, ctx);
 		case "Compound": return evalCompound(node, ctx);
+		case "Instance": return evalInstance(node, ctx);
 	}
 }
 function hashExprValue(h, v) {
@@ -6088,6 +6110,12 @@ function nodeToJson(n) {
 		kind: "Compound",
 		children: n.children.map(nodeToJson)
 	};
+	if (n.kind === "Instance") return {
+		kind: "Instance",
+		source: nodeToJson(n.source),
+		placements: n.placements,
+		fuse: n.fuse
+	};
 	return primitiveToJson(n) ?? booleanToJson(n) ?? transformToJson(n);
 }
 function bad(msg) {
@@ -6228,6 +6256,7 @@ function readNode(j) {
 		case "Scale":
 		case "Mirror": return readTransform(kind, j);
 		case "Compound": return readCompound(j);
+		case "Instance": return readInstance(j);
 		default: return bad(`unknown node kind: ${String(kind)}`);
 	}
 }
@@ -6386,6 +6415,16 @@ function readCompound(j) {
 	const children = readNodeArray(j["children"], "Compound.children");
 	return children.ok ? ok(compound$1(children.value)) : children;
 }
+function isMatrix4x4(v) {
+	return Array.isArray(v) && v.length === 4 && v.every((row) => Array.isArray(row) && row.length === 4 && row.every(isNumber$1));
+}
+function readInstance(j) {
+	const source = readNode(j["source"]);
+	if (!source.ok) return source;
+	const placements = j["placements"];
+	if (!Array.isArray(placements) || !placements.every(isMatrix4x4)) return bad("Instance.placements must be an array of 4x4 number matrices");
+	return ok(instance$1(source.value, placements, j["fuse"] === true));
+}
 //#endregion
 //#region src/csg/optimize.ts
 function optimize(node) {
@@ -6482,6 +6521,7 @@ function optimizeNode(n) {
 			at: n.at ? foldExpr(n.at) : void 0
 		});
 		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);
 	}
 }
 function optimizeFuse(a, b, tol) {
@@ -6571,6 +6611,7 @@ function rebuildChildren(n, pred, repl) {
 			at: n.at
 		});
 		case "Compound": return compound$1(n.children.map((c) => walk(c, pred, repl)));
+		case "Instance": return instance$1(walk(n.source, pred, repl), n.placements, n.fuse);
 	}
 }
 function forEachNode(root, fn) {
@@ -6599,6 +6640,7 @@ function childrenOf(n) {
 		case "Scale":
 		case "Mirror": return [n.target];
 		case "Compound": return n.children;
+		case "Instance": return [n.source];
 	}
 }
 function nodeCount(root) {
@@ -6635,6 +6677,7 @@ var csg_exports = /* @__PURE__ */ __exportAll({
 	fromJSON: () => fromJSON,
 	fuse: () => fuse$1,
 	fuseAll: () => fuseAll$1,
+	instance: () => instance$1,
 	intersect: () => intersect$1,
 	line: () => line$1,
 	mirror: () => mirror$1,

package/dist/csg/builders.d.ts

@@ -1,5 +1,6 @@
 import { ScalarInput, Vec3Input } from './expressions.js';
-import { BoxNode, SphereNode, CylinderNode, ConeNode, TorusNode, PolygonNode, CircleNode, LineNode, VertexLitNode, EmptyNode, FuseNode, CutNode, IntersectNode, FuseAllNode, CutAllNode, TranslateNode, RotateNode, ScaleNode, MirrorNode, CompoundNode, IRNode, SolidNode, FaceNode, EdgeNode, VertexNode } from './types.js';
+import { Matrix4x4 } from '../core/types.js';
+import { BoxNode, SphereNode, CylinderNode, ConeNode, TorusNode, PolygonNode, CircleNode, LineNode, VertexLitNode, EmptyNode, FuseNode, CutNode, IntersectNode, FuseAllNode, CutAllNode, TranslateNode, RotateNode, ScaleNode, MirrorNode, CompoundNode, InstanceNode, IRNode, SolidNode, FaceNode, EdgeNode, VertexNode } from './types.js';
 export declare function box(x: ScalarInput, y: ScalarInput, z: ScalarInput): BoxNode;
 export declare function sphere(radius: ScalarInput): SphereNode;
 export declare function cylinder(radius: ScalarInput, height: ScalarInput): CylinderNode;
@@ -33,4 +34,5 @@ export interface MirrorOptions {
 }
 export declare function mirror(target: IRNode, options?: MirrorOptions): MirrorNode;
 export declare function compound(children: ReadonlyArray<IRNode>): CompoundNode;
+export declare function instance(source: IRNode, placements: ReadonlyArray<Matrix4x4>, fuse?: boolean): InstanceNode;
 export type { FaceNode, EdgeNode, VertexNode, SolidNode };

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

@@ -0,0 +1,5 @@
+import { Result } from '../../core/result.js';
+import { AnyShape, Dimension } from '../../core/shapeTypes.js';
+import { InstanceNode } from '../types.js';
+import { EvalContext } from './context.js';
+export declare function evalInstance(node: InstanceNode, ctx: EvalContext): Result<AnyShape<Dimension>>;

package/dist/csg/index.d.ts

@@ -5,9 +5,9 @@
  * parameterize via named expression bindings; evaluate against the active
  * kernel with subtree-level cache reuse for incremental parametric edits.
  */
-export { box, sphere, cylinder, cone, torus, polygon, circle, line, vertex, emptySolid, emptyFace, emptyWire, fuse, cut, intersect, fuseAll, cutAll, translate, rotate, scale, mirror, compound, type RotateOptions, type ScaleOptions, type MirrorOptions, } from './builders.js';
+export { box, sphere, cylinder, cone, torus, polygon, circle, line, vertex, emptySolid, emptyFace, emptyWire, fuse, cut, intersect, fuseAll, cutAll, translate, rotate, scale, mirror, compound, instance, type RotateOptions, type ScaleOptions, type MirrorOptions, } from './builders.js';
 export { numLit, vec3Lit, vec2Lit, param, binOp, unaryOp, component, buildVec, add, mul, asScalarExpr, asVec3Expr, asVec2Expr, type Expr, type ExprValue, type Env, type ScalarInput, type Vec3Input, type Vec2Input, type BinaryOp, type UnaryOp, } from './expressions.js';
-export type { IRNode, NodeKind, OutputKind, PrimitiveNode, BooleanNode, TransformIRNode, SolidNode, FaceNode, EdgeNode, VertexNode, AnyNode, } from './types.js';
+export type { IRNode, NodeKind, OutputKind, PrimitiveNode, BooleanNode, TransformIRNode, InstanceNode, SolidNode, FaceNode, EdgeNode, VertexNode, AnyNode, } from './types.js';
 export { outputKindOf } from './types.js';
 export { Evaluator, withEvaluator, type EvaluatorOptions, type StepInfo, type CacheStats, } from './evaluate.js';
 export { toJSON, fromJSON, CSG_VERSION, type CsgEnvelope } from './serialize.js';

package/dist/csg/types.d.ts

@@ -1,4 +1,5 @@
 import { Expr } from './expressions.js';
+import { Matrix4x4 } from '../core/types.js';
 export type OutputKind = 'Solid' | 'Face' | 'Wire' | 'Edge' | 'Vertex' | 'Compound';
 /** Output kinds that have a corresponding empty-shape builder + serializer. */
 export type EmptyOutputKind = 'Solid' | 'Face' | 'Wire';
@@ -111,10 +112,18 @@ export interface CompoundNode extends IRNodeBase {
     readonly kind: 'Compound';
     readonly children: readonly IRNode[];
 }
+export interface InstanceNode extends IRNodeBase {
+    readonly kind: 'Instance';
+    readonly source: IRNode;
+    /** Per-instance world transforms (row-major 4x4 literals). */
+    readonly placements: readonly Matrix4x4[];
+    /** Fuse the placed copies into one solid; otherwise a Compound. */
+    readonly fuse: boolean;
+}
 export type PrimitiveNode = BoxNode | SphereNode | CylinderNode | ConeNode | TorusNode | PolygonNode | CircleNode | LineNode | VertexLitNode | EmptyNode;
 export type BooleanNode = FuseNode | CutNode | IntersectNode | FuseAllNode | CutAllNode;
 export type TransformIRNode = TranslateNode | RotateNode | ScaleNode | MirrorNode;
-export type IRNode = PrimitiveNode | BooleanNode | TransformIRNode | CompoundNode;
+export type IRNode = PrimitiveNode | BooleanNode | TransformIRNode | CompoundNode | InstanceNode;
 export type NodeKind = IRNode['kind'];
 export type AnyNode = IRNode;
 /** Nodes that produce a 3D solid. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brepjs",
-  "version": "18.102.0",
+  "version": "18.103.0",
   "description": "Web CAD library with pluggable geometry kernel",
   "keywords": [
     "cad",