brepjs 18.119.2 → 18.119.3

package/dist/shapeFns-BrHFNLMA.js

@@ -1,771 +0,0 @@
-import { it as getKernel, n as castResultShape } from "./shapeTypes-CnKFSfDT.js";
-import { O as ok, d as validationError, t as BrepErrorCode, v as err } from "./errors-B3CDG537.js";
-import { S as subShapeHashes, T as kernelCallRaw, c as getFaces, l as getOrCreateCache, r as getCacheEntry, w as kernelCall } from "./topologyQueryFns-DNqT88yx.js";
-import { n as HASH_CODE_MAX, t as DEG2RAD } from "./constants-ITRzCnCp.js";
-//#region src/topology/metadata/originTrackingFns.ts
-/**
-* Face origin tracking — tag faces with integer origins and propagate
-* them through kernel operations via ShapeEvolution records.
-*/
-/**
-* Tag all faces of a shape with an opaque integer origin.
-* Consumers assign meaning (e.g., source line number).
-*/
-function setShapeOrigin(shape, origin) {
-	const cache = getOrCreateCache(shape);
-	const map = /* @__PURE__ */ new Map();
-	for (const hash of subShapeHashes(shape, "face")) map.set(hash, origin);
-	cache.faceOrigins = map;
-}
-/**
-* Get the face origin map for a shape (faceHash → originTag).
-* Returns undefined if no origins have been set or propagated.
-*/
-function getFaceOrigins(shape) {
-	return getCacheEntry(shape)?.faceOrigins;
-}
-/**
-* Propagate face origins using a kernel-provided ShapeEvolution record.
-*/
-function propagateOriginsFromEvolution(evolution, inputs, result) {
-	const inputOrigins = /* @__PURE__ */ new Map();
-	for (const input of inputs) {
-		const origins = getFaceOrigins(input);
-		if (!origins) continue;
-		for (const [hash, origin] of origins) inputOrigins.set(hash, origin);
-	}
-	if (inputOrigins.size === 0) return;
-	const resultMap = /* @__PURE__ */ new Map();
-	for (const [hash, origin] of inputOrigins) {
-		if (evolution.deleted.has(hash)) continue;
-		const modifiedHashes = evolution.modified.get(hash);
-		if (modifiedHashes && modifiedHashes.length > 0) for (const modHash of modifiedHashes) resultMap.set(modHash, origin);
-		else resultMap.set(hash, origin);
-		const generatedHashes = evolution.generated.get(hash);
-		if (generatedHashes) {
-			for (const genHash of generatedHashes) if (!resultMap.has(genHash)) resultMap.set(genHash, origin);
-		}
-	}
-	if (resultMap.size > 0) {
-		const cache = getOrCreateCache(result);
-		cache.faceOrigins = resultMap;
-	}
-}
-/** Max 3D centroid separation (mm²) for a "near" match — the general case. */
-var MAX_MATCH_DIST_SQ = 100;
-/** Min |outNormal·inNormal| for two faces to count as sharing a plane's orientation. */
-var COPLANAR_NORMAL_MIN = .985;
-/**
-* Max squared perpendicular offset (mm²) from an input face's plane for the
-* output face to count as *coplanar* with it — i.e. a piece the boolean sliced
-* off that same planar surface. 0.1mm² tolerates kernel/mesh float noise while
-* still separating floors that sit even a fraction of a mm apart in depth.
-*/
-var COPLANAR_OFFSET_SQ = .1;
-/**
-* Find the best origin match for a result face by comparing normals and centroids
-* against input face signatures. Returns `undefined` if no good match exists.
-*
-* Two passes, near strictly preferred:
-*  1. Near match — same-facing normal (signed dot ≥ 0.707) and centroids within
-*     {@link MAX_MATCH_DIST_SQ}. The general case for regenerated seam faces
-*     (feature tops, flush walls). Unchanged legacy behavior. If any near match
-*     exists it wins outright — the coplanar pass never runs — so a distant
-*     coplanar candidate can't outscore a valid near one.
-*  2. Coplanar match (only when no near match, and only between PLANAR faces) —
-*     the output face lies on an input face's plane (parallel *or* antiparallel
-*     normal, tiny perpendicular offset) regardless of how far its centroid
-*     drifted in-plane. Two cases pass 1 misses:
-*       • A boolean that splits a large planar face — a wide cutout floor sliced
-*         by an overlapping deeper cutout — leaves pieces >10mm from the parent
-*         centroid (past pass 1's cutoff).
-*       • A cut flips the cavity face's normal versus the tool face it came from,
-*         so the floor is antiparallel to its origin's input face.
-*     Both left the surface tagless → body color in multi-color consumers
-*     (gridfinity GH #2443). The planar gate keeps a curved output face from
-*     inheriting an origin off an unrelated face that merely shares a sampled
-*     tangent plane; among coplanar candidates the nearest in-plane wins.
-*/
-function findBestOriginMatch(outNormal, outCentroid, outPlanar, inputSigs) {
-	let bestNearScore = -Infinity;
-	let bestNear;
-	for (const inp of inputSigs) {
-		const dot = outNormal[0] * inp.normal[0] + outNormal[1] * inp.normal[1] + outNormal[2] * inp.normal[2];
-		if (dot < .707) continue;
-		const dx = outCentroid[0] - inp.centroid[0];
-		const dy = outCentroid[1] - inp.centroid[1];
-		const dz = outCentroid[2] - inp.centroid[2];
-		const distSq = dx * dx + dy * dy + dz * dz;
-		if (distSq > MAX_MATCH_DIST_SQ) continue;
-		const score = dot - distSq / MAX_MATCH_DIST_SQ;
-		if (score > bestNearScore) {
-			bestNearScore = score;
-			bestNear = inp.origin;
-		}
-	}
-	if (bestNear !== void 0) return bestNear;
-	if (!outPlanar) return void 0;
-	let bestInPlaneSq = Infinity;
-	let bestCoplanar;
-	for (const inp of inputSigs) {
-		if (!inp.planar) continue;
-		const dot = outNormal[0] * inp.normal[0] + outNormal[1] * inp.normal[1] + outNormal[2] * inp.normal[2];
-		if (Math.abs(dot) < COPLANAR_NORMAL_MIN) continue;
-		const dx = outCentroid[0] - inp.centroid[0];
-		const dy = outCentroid[1] - inp.centroid[1];
-		const dz = outCentroid[2] - inp.centroid[2];
-		const perp = dx * inp.normal[0] + dy * inp.normal[1] + dz * inp.normal[2];
-		if (perp * perp > COPLANAR_OFFSET_SQ) continue;
-		const inPlaneSq = Math.max(0, dx * dx + dy * dy + dz * dz - perp * perp);
-		if (inPlaneSq < bestInPlaneSq) {
-			bestInPlaneSq = inPlaneSq;
-			bestCoplanar = inp.origin;
-		}
-	}
-	return bestCoplanar;
-}
-/**
-* Fallback origin propagation when no kernel op object is available
-* (native `fuseAll` / `cutAll`, which expose no ShapeEvolution record).
-*
-* Matches result faces to input faces by hash code first. Faces that pass
-* through the boolean unchanged keep their hash and recover their origin
-* directly. Faces the boolean *regenerates* (split, merged, or re-created at
-* the intersection) get a fresh hash that matches no input — these fall back
-* to geometric matching (normal + centroid) against the input face
-* signatures.
-*
-* The geometric pass runs for every unmatched face, not only when the hash
-* pass found nothing. A partial hash match is the common case for additive
-* features (pass-through side walls match by hash; the surfaces where the
-* tool meets the body — feature tops, flush walls — are regenerated and need
-* the geometric pass). Gating the fallback on "zero hash matches" left those
-* regenerated faces with no origin, so they fell back to 0 (body) at mesh
-* time — the multi-color export bug where a scoop/label/lip top printed in
-* the body color. Matching against the full signature set (body origin 0
-* included) keeps body faces body and feature faces feature.
-*/
-function propagateOriginsByHash(inputs, result) {
-	const lookup = /* @__PURE__ */ new Map();
-	for (const input of inputs) {
-		const origins = getFaceOrigins(input);
-		if (!origins) continue;
-		for (const [hash, origin] of origins) lookup.set(hash, origin);
-	}
-	if (lookup.size === 0) return;
-	const kernel = getKernel();
-	const resultMap = /* @__PURE__ */ new Map();
-	const resultFaces = getFaces(result);
-	const unmatched = [];
-	for (const f of resultFaces) {
-		const hash = kernel.hashCode(f.wrapped, HASH_CODE_MAX);
-		const origin = lookup.get(hash);
-		if (origin !== void 0) resultMap.set(hash, origin);
-		else unmatched.push(f);
-	}
-	if (unmatched.length > 0) {
-		const inputSigs = [];
-		for (const input of inputs) {
-			const origins = getFaceOrigins(input);
-			if (!origins) continue;
-			for (const f of getFaces(input)) {
-				const hash = kernel.hashCode(f.wrapped, HASH_CODE_MAX);
-				const origin = origins.get(hash);
-				if (origin === void 0) continue;
-				try {
-					const bounds = kernel.uvBounds(f.wrapped);
-					const normal = kernel.surfaceNormal(f.wrapped, .5 * (bounds.uMin + bounds.uMax), .5 * (bounds.vMin + bounds.vMax));
-					const centroid = kernel.surfaceCenterOfMass(f.wrapped);
-					const planar = kernel.surfaceType(f.wrapped) === "plane";
-					inputSigs.push({
-						origin,
-						normal,
-						centroid,
-						planar
-					});
-				} catch {}
-			}
-		}
-		if (inputSigs.length > 0) for (const f of unmatched) {
-			const hash = kernel.hashCode(f.wrapped, HASH_CODE_MAX);
-			try {
-				const outBounds = kernel.uvBounds(f.wrapped);
-				const bestOrigin = findBestOriginMatch(kernel.surfaceNormal(f.wrapped, .5 * (outBounds.uMin + outBounds.uMax), .5 * (outBounds.vMin + outBounds.vMax)), kernel.surfaceCenterOfMass(f.wrapped), kernel.surfaceType(f.wrapped) === "plane", inputSigs);
-				if (bestOrigin !== void 0) resultMap.set(hash, bestOrigin);
-			} catch {}
-		}
-	}
-	if (resultMap.size > 0) {
-		const cache = getOrCreateCache(result);
-		cache.faceOrigins = resultMap;
-	}
-}
-//#endregion
-//#region src/topology/metadata/faceTagFns.ts
-var shapeTagStore = /* @__PURE__ */ new WeakMap();
-var tagMetadataStore = /* @__PURE__ */ new WeakMap();
-/** O(1) check whether a shape has any face tags attached. */
-function hasFaceTags(shape) {
-	return shapeTagStore.has(shape.wrapped);
-}
-function getTagMap(shape) {
-	let map = shapeTagStore.get(shape.wrapped);
-	if (!map) {
-		map = /* @__PURE__ */ new Map();
-		shapeTagStore.set(shape.wrapped, map);
-	}
-	return map;
-}
-function getMetaMap(shape) {
-	let map = tagMetadataStore.get(shape.wrapped);
-	if (!map) {
-		map = /* @__PURE__ */ new Map();
-		tagMetadataStore.set(shape.wrapped, map);
-	}
-	return map;
-}
-/**
-* Tag selected faces with a string name.
-*
-* @param shape - The shape containing the faces.
-* @param selector - Array of faces, or a predicate function.
-* @param tag - The tag name to assign.
-* @returns The same shape (tags are stored externally).
-*/
-function tagFaces(shape, selector, tag) {
-	const faces = Array.isArray(selector) ? selector : getFaces(shape).filter(selector);
-	const tagMap = getTagMap(shape);
-	const existing = tagMap.get(tag) ?? /* @__PURE__ */ new Set();
-	for (const face of faces) existing.add(getKernel().hashCode(face.wrapped, HASH_CODE_MAX));
-	tagMap.set(tag, existing);
-	return shape;
-}
-/**
-* Find all faces on a shape that have the given tag.
-*
-* Checks both direct tags and propagated origins (for faces that
-* survived boolean/modifier operations).
-*/
-function findFacesByTag(shape, tag) {
-	const tagMap = shapeTagStore.get(shape.wrapped);
-	if (!tagMap) return [];
-	const hashes = tagMap.get(tag);
-	if (!hashes || hashes.size === 0) return [];
-	const result = [];
-	for (const face of getFaces(shape)) {
-		const hash = getKernel().hashCode(face.wrapped, HASH_CODE_MAX);
-		if (hashes.has(hash)) result.push(face);
-	}
-	return result;
-}
-/**
-* Get all tags and their associated faces on a shape.
-*/
-function getFaceTags(shape) {
-	const result = /* @__PURE__ */ new Map();
-	const tagMap = shapeTagStore.get(shape.wrapped);
-	if (!tagMap) return result;
-	const faces = getFaces(shape);
-	const faceByHash = /* @__PURE__ */ new Map();
-	for (const face of faces) faceByHash.set(getKernel().hashCode(face.wrapped, HASH_CODE_MAX), face);
-	for (const [tag, hashes] of tagMap) {
-		const taggedFaces = [];
-		for (const hash of hashes) {
-			const face = faceByHash.get(hash);
-			if (face) taggedFaces.push(face);
-		}
-		if (taggedFaces.length > 0) result.set(tag, taggedFaces);
-	}
-	return result;
-}
-/**
-* Store arbitrary metadata for a tag on a shape.
-*/
-function setTagMetadata(shape, tag, metadata) {
-	getMetaMap(shape).set(tag, metadata);
-	return shape;
-}
-/**
-* Retrieve metadata for a tag on a shape.
-*/
-function getTagMetadata(shape, tag) {
-	return tagMetadataStore.get(shape.wrapped)?.get(tag);
-}
-function addTagToResult(resultTagMap, tag, hash) {
-	const set = resultTagMap.get(tag) ?? /* @__PURE__ */ new Set();
-	set.add(hash);
-	resultTagMap.set(tag, set);
-}
-/**
-* Propagate face tags from input shapes to a result shape using a
-* kernel-provided ShapeEvolution record (no direct kernel op access needed).
-*/
-function propagateFaceTagsFromEvolution(evolution, inputs, result) {
-	const resultTagMap = getTagMap(result);
-	for (const input of inputs) {
-		const inputTagMap = shapeTagStore.get(input.wrapped);
-		if (!inputTagMap) continue;
-		const hashToTags = /* @__PURE__ */ new Map();
-		for (const [tag, hashes] of inputTagMap) for (const hash of hashes) {
-			const tags = hashToTags.get(hash) ?? [];
-			tags.push(tag);
-			hashToTags.set(hash, tags);
-		}
-		for (const [hash, tags] of hashToTags) {
-			if (evolution.deleted.has(hash)) continue;
-			const modifiedHashes = evolution.modified.get(hash);
-			const targetHashes = modifiedHashes && modifiedHashes.length > 0 ? modifiedHashes : [hash];
-			for (const targetHash of targetHashes) for (const tag of tags) addTagToResult(resultTagMap, tag, targetHash);
-		}
-		const inputMetaMap = tagMetadataStore.get(input.wrapped);
-		if (inputMetaMap) {
-			const resultMetaMap = getMetaMap(result);
-			for (const [tag, meta] of inputMetaMap) if (!resultMetaMap.has(tag)) resultMetaMap.set(tag, meta);
-		}
-	}
-}
-//#endregion
-//#region src/topology/metadata/colorFns.ts
-var shapeColorStore = /* @__PURE__ */ new WeakMap();
-var faceColorStore = /* @__PURE__ */ new WeakMap();
-/** O(1) check whether a shape has any color metadata (shape or face level). */
-function hasColorMetadata(shape) {
-	return shapeColorStore.has(shape.wrapped) || faceColorStore.has(shape.wrapped);
-}
-function getFaceColorMap(shape) {
-	let map = faceColorStore.get(shape.wrapped);
-	if (!map) {
-		map = /* @__PURE__ */ new Map();
-		faceColorStore.set(shape.wrapped, map);
-	}
-	return map;
-}
-function parseColor(input) {
-	if (typeof input === "string") {
-		let hex = input.startsWith("#") ? input.slice(1) : input;
-		if (hex.length === 3) hex = hex.charAt(0) + hex.charAt(0) + hex.charAt(1) + hex.charAt(1) + hex.charAt(2) + hex.charAt(2);
-		return [
-			parseInt(hex.slice(0, 2), 16) / 255,
-			parseInt(hex.slice(2, 4), 16) / 255,
-			parseInt(hex.slice(4, 6), 16) / 255,
-			1
-		];
-	}
-	if (input.length === 3) return [
-		input[0],
-		input[1],
-		input[2],
-		1
-	];
-	return [
-		input[0],
-		input[1],
-		input[2],
-		input[3]
-	];
-}
-/**
-* Set a whole-shape color (stored externally via WeakMap).
-* Returns the same shape reference.
-*/
-function colorShape(shape, color) {
-	shapeColorStore.set(shape.wrapped, parseColor(color));
-	return shape;
-}
-/**
-* Set per-face colors on a shape.
-* Returns the same shape reference.
-*/
-function colorFaces(shape, faces, color) {
-	const parsed = parseColor(color);
-	const map = getFaceColorMap(shape);
-	for (const face of faces) map.set(getKernel().hashCode(face.wrapped, HASH_CODE_MAX), parsed);
-	return shape;
-}
-/**
-* Get the whole-shape color, or undefined if none set.
-*/
-function getShapeColor(shape) {
-	return shapeColorStore.get(shape.wrapped);
-}
-/**
-* Get the color of a specific face, or undefined if none set.
-*/
-function getFaceColor(shape, face) {
-	const map = faceColorStore.get(shape.wrapped);
-	if (!map) return void 0;
-	return map.get(getKernel().hashCode(face.wrapped, HASH_CODE_MAX));
-}
-/**
-* Propagate colors from input shapes to a result shape using a
-* kernel-provided ShapeEvolution record (no direct kernel op access needed).
-*/
-function propagateColorsFromEvolution(evolution, inputs, result) {
-	for (const input of inputs) {
-		const c = shapeColorStore.get(input.wrapped);
-		if (c) {
-			shapeColorStore.set(result.wrapped, c);
-			break;
-		}
-	}
-	const resultFaceMap = getFaceColorMap(result);
-	for (const input of inputs) {
-		const inputFaceMap = faceColorStore.get(input.wrapped);
-		if (!inputFaceMap || inputFaceMap.size === 0) continue;
-		for (const [hash, color] of inputFaceMap) {
-			if (evolution.deleted.has(hash)) continue;
-			const modifiedHashes = evolution.modified.get(hash);
-			if (modifiedHashes && modifiedHashes.length > 0) for (const modHash of modifiedHashes) resultFaceMap.set(modHash, color);
-			else resultFaceMap.set(hash, color);
-		}
-	}
-}
-//#endregion
-//#region src/topology/metadata/metadataPropagation.ts
-/**
-* Collect ALL face hashes from input shapes for WithHistory kernel methods.
-*
-* Fast-path: returns empty array when no inputs have any metadata (origins,
-* tags, or colors), avoiding expensive WASM topology exploration.
-*/
-/**
-* O(1) check: does a shape carry any propagatable metadata (face origins,
-* tags, or colors)? Lets callers skip both expensive face iteration and
-* metadata-preserving slow paths when there's nothing to preserve.
-*/
-function hasAnyMetadata(shape) {
-	return getFaceOrigins(shape) !== void 0 || hasFaceTags(shape) || hasColorMetadata(shape);
-}
-function collectInputFaceHashes(inputs) {
-	if (!inputs.some(hasAnyMetadata)) return [];
-	const hashes = [];
-	for (const input of inputs) hashes.push(...subShapeHashes(input, "face"));
-	return hashes;
-}
-/**
-* Propagate all metadata (origins, tags, colors) from inputs to result
-* using a kernel-provided ShapeEvolution record.
-*
-* This is the standard pipeline for any operation that returns
-* `{ shape, evolution }` from a WithHistory kernel method.
-*/
-function propagateAllMetadata(evolution, inputs, result) {
-	propagateOriginsFromEvolution(evolution, inputs, result);
-	propagateFaceTagsFromEvolution(evolution, inputs, result);
-	propagateColorsFromEvolution(evolution, inputs, result);
-}
-/**
-* Fallback metadata propagation when no ShapeEvolution is available.
-*
-* Matches result faces to input faces by hash code (and geometric fallback).
-* Used by operations that don't support WithHistory (e.g., native fuseAll).
-*
-* **Limitation:** Only propagates face origins. Face tags and face colors
-* require a ShapeEvolution record to map input→output face hashes, so they
-* are lost through this path. Batch booleans (`fuseAll`, `cutAll`) therefore
-* have weaker metadata guarantees than pairwise booleans (`fuse`, `cut`).
-*/
-function propagateMetadataByHash(inputs, result) {
-	propagateOriginsByHash(inputs, result);
-}
-/**
-* Propagate all metadata through a *rigid relocation* (a `locate` re-tag).
-*
-* A relocated shape shares the source's TShape, so its faces correspond 1:1 to
-* the source faces in iteration order — but carry new, location-dependent
-* hashes, so the hash-keyed metadata must be re-keyed rather than left as-is.
-* This synthesizes a 1:1 `modified` evolution (source face hash → moved face
-* hash) and runs the standard propagation pipeline, so origins, tags, and
-* colors all survive a move at `locate` cost (O(faces)), not a full copy.
-*
-* Callers should gate on {@link hasAnyMetadata} first: with no metadata this
-* does pointless face iteration. The face counts always match for a rigid
-* relocation; the length guard is purely defensive.
-*/
-function propagateMetadataThroughRelocation(source, moved) {
-	const kernel = getKernel();
-	const srcFaces = [...kernel.iterShapes(source.wrapped, "face")];
-	const movedFaces = [...kernel.iterShapes(moved.wrapped, "face")];
-	if (srcFaces.length !== movedFaces.length) return;
-	const modified = /* @__PURE__ */ new Map();
-	for (let i = 0; i < srcFaces.length; i++) {
-		const sf = srcFaces[i];
-		const mf = movedFaces[i];
-		if (sf === void 0 || mf === void 0) continue;
-		modified.set(kernel.hashCode(sf, HASH_CODE_MAX), [kernel.hashCode(mf, HASH_CODE_MAX)]);
-	}
-	for (const f of srcFaces) kernel.dispose(f);
-	for (const f of movedFaces) kernel.dispose(f);
-	propagateAllMetadata({
-		modified,
-		generated: /* @__PURE__ */ new Map(),
-		deleted: /* @__PURE__ */ new Set()
-	}, [source], moved);
-}
-//#endregion
-//#region src/topology/transformFns.ts
-/**
-* Immutable shape transforms — translate, rotate, scale, mirror, applyMatrix.
-* All functions return new shapes without disposing inputs.
-*/
-/** Translate a shape by a vector. Returns a new shape. */
-function translate(shape, v) {
-	const inputFaceHashes = collectInputFaceHashes([shape]);
-	const { shape: resultShape, evolution } = getKernel().translateWithHistory(shape.wrapped, v[0], v[1], v[2], inputFaceHashes, HASH_CODE_MAX);
-	const result = castResultShape(resultShape);
-	propagateAllMetadata(evolution, [shape], result);
-	return result;
-}
-/** Rotate a shape around an axis. Angle is in degrees. Returns a new shape. */
-function rotate(shape, angle, position = [
-	0,
-	0,
-	0
-], direction = [
-	0,
-	0,
-	1
-]) {
-	const inputFaceHashes = collectInputFaceHashes([shape]);
-	const { shape: resultShape, evolution } = getKernel().rotateWithHistory(shape.wrapped, angle * DEG2RAD, inputFaceHashes, HASH_CODE_MAX, direction, position);
-	const result = castResultShape(resultShape);
-	propagateAllMetadata(evolution, [shape], result);
-	return result;
-}
-/** Mirror a shape through a plane defined by origin and normal. Returns a new shape. */
-function mirror(shape, planeNormal = [
-	0,
-	1,
-	0
-], planeOrigin = [
-	0,
-	0,
-	0
-]) {
-	const inputFaceHashes = collectInputFaceHashes([shape]);
-	const { shape: resultShape, evolution } = getKernel().mirrorWithHistory(shape.wrapped, planeOrigin, planeNormal, inputFaceHashes, HASH_CODE_MAX);
-	const result = castResultShape(resultShape);
-	propagateAllMetadata(evolution, [shape], result);
-	return result;
-}
-/** Scale a shape uniformly. Returns a new shape. */
-function scale(shape, factor, center = [
-	0,
-	0,
-	0
-]) {
-	const inputFaceHashes = collectInputFaceHashes([shape]);
-	const { shape: resultShape, evolution } = getKernel().scaleWithHistory(shape.wrapped, center, factor, inputFaceHashes, HASH_CODE_MAX);
-	const result = castResultShape(resultShape);
-	propagateAllMetadata(evolution, [shape], result);
-	return result;
-}
-/** Resize a shape to exact target dimensions with optional auto-proportional scaling. */
-function resize(shape, dimensions, options) {
-	const bbox = getKernel().boundingBox(shape.wrapped);
-	const size = [
-		bbox.max[0] - bbox.min[0],
-		bbox.max[1] - bbox.min[1],
-		bbox.max[2] - bbox.min[2]
-	];
-	const auto = options?.auto === true;
-	function factor(dim, sz, baseFactor) {
-		if (dim !== void 0 && sz > 1e-12) return dim / sz;
-		if (dim === void 0 && auto) return baseFactor;
-		return 1;
-	}
-	let autoFactor = 1;
-	if (auto) {
-		if (dimensions[0] !== void 0 && size[0] > 1e-12) autoFactor = dimensions[0] / size[0];
-		else if (dimensions[1] !== void 0 && size[1] > 1e-12) autoFactor = dimensions[1] / size[1];
-		else if (dimensions[2] !== void 0 && size[2] > 1e-12) autoFactor = dimensions[2] / size[2];
-	}
-	const factors = [
-		factor(dimensions[0], size[0], autoFactor),
-		factor(dimensions[1], size[1], autoFactor),
-		factor(dimensions[2], size[2], autoFactor)
-	];
-	if (!(Math.abs(factors[0] - factors[1]) < 1e-6 && Math.abs(factors[1] - factors[2]) < 1e-6)) return err(validationError(BrepErrorCode.VALIDATION_FAILED, "resize: non-uniform scaling is not supported (WASM build lacks BRepBuilderAPI_GTransform).", void 0, void 0, "Use auto: true to scale proportionally, or set all three dimensions to achieve uniform scaling."));
-	return ok(scale(shape, factors[0]));
-}
-/**
-* Parse a MatrixInput into a 3x3 linear part and translation vector.
-* Validates the bottom row of a Matrix4x4.
-*/
-function parseMatrixInput(input) {
-	if ("linear" in input) return ok({
-		linear: input.linear,
-		translation: input.translation
-	});
-	const [r0, r1, r2, r3] = input;
-	const TOL = 1e-10;
-	if (Math.abs(r3[0]) > TOL || Math.abs(r3[1]) > TOL || Math.abs(r3[2]) > TOL || Math.abs(r3[3] - 1) > TOL) return err(validationError(BrepErrorCode.VALIDATION_FAILED, `applyMatrix: invalid bottom row [${String(r3[0])}, ${String(r3[1])}, ${String(r3[2])}, ${String(r3[3])}]. Must be [0, 0, 0, 1] for an affine transform.`));
-	return ok({
-		linear: [
-			r0[0],
-			r0[1],
-			r0[2],
-			r1[0],
-			r1[1],
-			r1[2],
-			r2[0],
-			r2[1],
-			r2[2]
-		],
-		translation: [
-			r0[3],
-			r1[3],
-			r2[3]
-		]
-	});
-}
-/** Determinant of a 3x3 matrix given as 9 row-major values. */
-function det3x3(m) {
-	return m[0] * (m[4] * m[8] - m[5] * m[7]) - m[1] * (m[3] * m[8] - m[5] * m[6]) + m[2] * (m[3] * m[7] - m[4] * m[6]);
-}
-/**
-* Check if a 3x3 matrix is orthogonal (possibly with uniform scale).
-* M is orthogonal-with-scale if M^T * M = s^2 * I for some scalar s.
-*/
-function isOrthogonalMatrix(m) {
-	const TOL = 1e-8;
-	const d00 = m[0] * m[0] + m[3] * m[3] + m[6] * m[6];
-	const d11 = m[1] * m[1] + m[4] * m[4] + m[7] * m[7];
-	const d22 = m[2] * m[2] + m[5] * m[5] + m[8] * m[8];
-	const d01 = m[0] * m[1] + m[3] * m[4] + m[6] * m[7];
-	const d02 = m[0] * m[2] + m[3] * m[5] + m[6] * m[8];
-	const d12 = m[1] * m[2] + m[4] * m[5] + m[7] * m[8];
-	if (Math.abs(d01) > TOL) return false;
-	if (Math.abs(d02) > TOL) return false;
-	if (Math.abs(d12) > TOL) return false;
-	if (Math.abs(d00 - d11) > TOL) return false;
-	if (Math.abs(d00 - d22) > TOL) return false;
-	return true;
-}
-/**
-* Apply a 4x4 affine transformation matrix to a shape.
-* Equivalent to OpenSCAD's `multmatrix`.
-*
-* Uses the fast `kernel transform` path for orthogonal matrices (rotation, uniform scale, mirror)
-* and the general `gp_GTrsf` path for non-orthogonal transforms (shear, non-uniform scale).
-*/
-function applyMatrix(shape, matrix) {
-	const parsed = parseMatrixInput(matrix);
-	if (!parsed.ok) return parsed;
-	const { linear, translation } = parsed.value;
-	const d = det3x3(linear);
-	if (Math.abs(d) < 1e-12) return err(validationError(BrepErrorCode.VALIDATION_FAILED, "applyMatrix: singular matrix (determinant ≈ 0). Cannot apply a non-invertible transform."));
-	if (isOrthogonalMatrix(linear)) {
-		const inputFaceHashes = collectInputFaceHashes([shape]);
-		const { shape: resultShape, evolution } = getKernel().generalTransformWithHistory(shape.wrapped, linear, translation, true, inputFaceHashes, HASH_CODE_MAX);
-		const result = castResultShape(resultShape);
-		propagateAllMetadata(evolution, [shape], result);
-		return ok(result);
-	}
-	const result = castResultShape(getKernel().generalTransformNonOrthogonal(shape.wrapped, linear, translation));
-	propagateMetadataByHash([shape], result);
-	return ok(result);
-	/* v8 ignore stop */
-}
-/**
-* Compose multiple translate/rotate operations into a single kernel transform.
-* Operations are applied in order (first element applied first).
-* Call `.cleanup()` on the result when done to free the kernel object.
-*/
-function composeTransforms(ops) {
-	const kernelOps = ops.map((op) => {
-		if (op.type === "translate") return {
-			type: "translate",
-			x: op.v[0],
-			y: op.v[1],
-			z: op.v[2]
-		};
-		return {
-			type: "rotate",
-			angle: op.angle,
-			axis: op.axis,
-			center: op.center
-		};
-	});
-	const { handle, dispose } = getKernel().composeTransform(kernelOps);
-	return {
-		trsf: handle,
-		cleanup: dispose
-	};
-}
-/**
-* Placement-only rigid move (translate / rotate) via the kernel's cheap location
-* re-tag — an O(1) `TopLoc_Location` swap on occt-wasm ≥3.6.0, falling back to a
-* copying transform on kernels without it. Unlike `translate` / `rotate` (which
-* deep-copy through the history-tracking path), `locate` shares the source
-* geometry and only re-tags its placement, then re-keys face metadata
-* (tags/colors) onto the moved faces so it survives — the same metadata
-* guarantee `translate` gives, at location-swap cost. For per-position placement
-* of one cached cell (template instancing), this is the move without the copy.
-*
-* Accepts a single op or an ordered list (applied first-to-last, e.g. rotate
-* then translate). Non-rigid ops (`scale`) aren't a placement and don't belong
-* here — use `applyMatrix` for those.
-*/
-function locate(shape, placement) {
-	const { trsf, cleanup } = composeTransforms("type" in placement ? [placement] : placement);
-	let moved;
-	try {
-		moved = castResultShape(getKernel().locate(shape.wrapped, trsf));
-	} finally {
-		cleanup();
-	}
-	if (hasAnyMetadata(shape)) propagateMetadataThroughRelocation(shape, moved);
-	return moved;
-}
-/**
-* Clone a shape and apply a pre-composed transform in a single kernel operation.
-* Much faster than separate clone() + translate() + rotate() calls.
-*/
-function transformCopy(shape, composed) {
-	const inputFaceHashes = collectInputFaceHashes([shape]);
-	const { shape: resultShape, evolution } = getKernel().applyComposedTransformWithHistory(shape.wrapped, composed.trsf, inputFaceHashes, HASH_CODE_MAX);
-	const result = castResultShape(resultShape);
-	propagateAllMetadata(evolution, [shape], result);
-	return result;
-}
-//#endregion
-//#region src/topology/shapeFns.ts
-/**
-* Shape identity, introspection, and serialization functions.
-*
-* Re-exports from focused modules for backward compatibility:
-* - Transform functions from `./transformFns.js`
-* - Topology query functions from `./topologyQueryFns.js`
-* - Origin tracking functions from `./metadata/originTrackingFns.js`
-*/
-/** Clone a shape (an independently-disposable deep copy). */
-function clone(shape) {
-	return kernelCall(() => getKernel().copyShape(shape.wrapped), BrepErrorCode.CLONE_FAILED, "Failed to clone shape");
-}
-/** Serialize a shape to BREP string format. */
-function toBREP(shape) {
-	return kernelCallRaw(() => getKernel().toBREP(shape.wrapped), BrepErrorCode.TO_BREP_FAILED, "Failed to serialize shape to BREP");
-}
-/** Get the topology hash code of a shape. */
-function getHashCode(shape) {
-	return getKernel().hashCode(shape.wrapped, HASH_CODE_MAX);
-}
-/** Check if a shape is null. */
-function isEmpty(shape) {
-	return getKernel().isNull(shape.wrapped);
-}
-/** Check if two shapes are the same topological entity. */
-function isSameShape(a, b) {
-	return getKernel().isSame(a.wrapped, b.wrapped);
-}
-/** Check if two shapes are geometrically equal. */
-function isEqualShape(a, b) {
-	return getKernel().isEqual(a.wrapped, b.wrapped);
-}
-/** Simplify a shape by merging same-domain faces/edges. Returns a new shape. */
-function simplify(shape) {
-	return kernelCall(() => getKernel().simplify(shape.wrapped), BrepErrorCode.SIMPLIFY_FAILED, "Failed to simplify shape");
-}
-//#endregion
-export { tagFaces as A, colorShape as C, getFaceTags as D, findFacesByTag as E, setShapeOrigin as M, getTagMetadata as O, colorFaces as S, getShapeColor as T, collectInputFaceHashes as _, isSameShape as a, propagateMetadataByHash as b, applyMatrix as c, mirror as d, resize as f, translate as g, transformCopy as h, isEqualShape as i, getFaceOrigins as j, setTagMetadata as k, composeTransforms as l, scale as m, getHashCode as n, simplify as o, rotate as p, isEmpty as r, toBREP as s, clone as t, locate as u, hasAnyMetadata as v, getFaceColor as w, propagateMetadataThroughRelocation as x, propagateAllMetadata as y };