brepjs 12.8.2 → 12.9.1

package/dist/{operations-BfbkK6DU.js → operations-DisJ5F8s.js}

@@ -1,10 +1,10 @@
-import { B as getKernel, d as createKernelHandle, c as castShape, p as isShape3D, u as isWire, F as createSolid } from "./shapeTypes-CpSaBLDv.js";
-import { g as vecLength, v as vecAdd, j as vecNormalize, f as vecIsZero } from "./vecOps-ZDdZWbwT.js";
-import { e as err, z as validationError, v as unwrap, r as typeCastError, o as ok, A as BrepErrorCode, k as kernelError, i as ioError, d as computationError } from "./result-BaSD1fqR.js";
-import { a as buildLawFromProfile } from "./loft-Bhw-FMoL.js";
-import { j as fuseAll } from "./booleanFns-BCTjYZAg.js";
-import { t as toBREP } from "./shapeFns-FDuKkrDR.js";
-import { j as fromBREP } from "./faceFns-B8GnxjdY.js";
+import { e as err, v as validationError, u as unwrap, t as typeCastError, o as ok, k as kernelError, B as BrepErrorCode, i as ioError, d as computationError } from "./result-DtuwWSUD.js";
+import { v as vecLength, a as vecAdd, i as vecIsZero, c as vecNormalize } from "./vecOps-LTN--A58.js";
+import { g as fuseAll } from "./booleanFns-Br2KdGJq.js";
+import { g as getKernel, w as createKernelHandle, c as castShape, j as isShape3D, b as isWire } from "./shapeTypes-CAEAyk8j.js";
+import { t as toBREP } from "./shapeFns-BJbua5kT.js";
+import { j as fromBREP } from "./faceFns-DGMp47Os.js";
+import { a as buildLawFromProfile } from "./loft-D0aCZRaB.js";
 function uuidv() {
   return (String([1e7]) + String(-1e3) + String(-4e3) + String(-8e3) + String(-1e11)).replace(
     /[018]/g,
@@ -41,42 +41,6 @@ function makeHelixWire(pitch, height, radius, center, dir, _lefthand = false) {
   const kernel = getKernel();
   return castShape(kernel.makeHelixWire(pitch, height, radius, [...center], [...dir]));
 }
-function extrude(face, extrusionVec) {
-  if (getKernel().isNull(face.wrapped)) {
-    return err(validationError(BrepErrorCode.NULL_SHAPE_INPUT, "extrude: face is a null shape"));
-  }
-  if (vecLength(extrusionVec) === 0) {
-    return err(validationError("EXTRUDE_ZERO_VECTOR", "extrude: extrusion vector has zero length"));
-  }
-  try {
-    const kernel = getKernel();
-    const len = vecLength(extrusionVec);
-    const dir = vecNormalize(extrusionVec);
-    const shape = kernel.extrude(face.wrapped, [...dir], len);
-    const downcastShape = kernel.downcast(shape, "solid");
-    const solid = createSolid(downcastShape);
-    return ok(solid);
-  } catch (e) {
-    return err(
-      kernelError("EXTRUDE_FAILED", "Extrusion operation failed", e, {
-        operation: "extrude",
-        vectorLength: vecLength(extrusionVec)
-      })
-    );
-  }
-}
-function revolve(face, center = [0, 0, 0], direction = [0, 0, 1], angle = 360) {
-  if (getKernel().isNull(face.wrapped)) {
-    return err(validationError(BrepErrorCode.NULL_SHAPE_INPUT, "revolve: face is a null shape"));
-  }
-  const kernel = getKernel();
-  const shape = kernel.revolveVec(face.wrapped, [...center], [...direction], angle);
-  const result = castShape(shape);
-  if (!isShape3D(result)) {
-    return err(typeCastError("REVOLUTION_NOT_3D", "Revolution did not produce a 3D shape"));
-  }
-  return ok(result);
-}
 function sweep(wire, spine, config = {}, shellMode = false) {
   if (config.mode === "simple" && !shellMode) {
     const kernel2 = getKernel();
@@ -173,6 +137,95 @@ function twistExtrude(wire, angleDegrees, center, normal, profileShape, shellMod
   const law = profileShape ? unwrap(buildLawFromProfile(extrusionLength, profileShape)) : null;
   return sweep(wire, spine, { auxiliarySpine, law }, shellMode);
 }
+function multiSectionSweep(sections, spine, options) {
+  if (sections.length < 2) {
+    return err(
+      validationError(
+        BrepErrorCode.MULTI_SWEEP_INSUFFICIENT_SECTIONS,
+        `Multi-section sweep requires at least 2 sections, got ${sections.length}`
+      )
+    );
+  }
+  const { solid = true, ruled = false, tolerance = 1e-6 } = options ?? {};
+  const explicitLocations = sections.map((s) => s.location);
+  for (let i = 0; i < explicitLocations.length; i++) {
+    const loc = explicitLocations[i];
+    if (loc !== void 0 && (loc < 0 || loc > 1)) {
+      return err(
+        validationError(
+          BrepErrorCode.MULTI_SWEEP_FAILED,
+          `Section ${i} location ${loc} is out of range [0, 1]`
+        )
+      );
+    }
+  }
+  const definedLocs = explicitLocations.filter((l) => l !== void 0);
+  for (let i = 1; i < definedLocs.length; i++) {
+    if ((definedLocs[i] ?? 0) <= (definedLocs[i - 1] ?? 0)) {
+      return err(
+        validationError(
+          BrepErrorCode.MULTI_SWEEP_FAILED,
+          "Section locations must be strictly increasing"
+        )
+      );
+    }
+  }
+  try {
+    const kernel = getKernel();
+    const [uFirst, uLast] = kernel.curveParameters(spine.wrapped);
+    const uRange = uLast - uFirst;
+    const params = sections.map((s, i) => {
+      if (s.location !== void 0) {
+        return uFirst + s.location * uRange;
+      }
+      return uFirst + i / (sections.length - 1) * uRange;
+    });
+    const positionedWires = [];
+    for (let i = 0; i < sections.length; i++) {
+      const param = params[i];
+      const section = sections[i];
+      if (param === void 0 || section === void 0) continue;
+      const positioned = kernel.positionOnCurve(section.wire.wrapped, spine.wrapped, param);
+      positionedWires.push(kernel.downcast(positioned, "wire"));
+    }
+    const loftResult = kernel.loftAdvanced(positionedWires, { solid, ruled, tolerance });
+    const result = castShape(loftResult);
+    if (!isShape3D(result)) {
+      return err(
+        typeCastError("MULTI_SWEEP_NOT_3D", "Multi-section sweep did not produce a 3D shape")
+      );
+    }
+    return ok(result);
+  } catch (e) {
+    const raw = e instanceof Error ? e.message : String(e);
+    return err(
+      kernelError(BrepErrorCode.MULTI_SWEEP_FAILED, `Multi-section sweep failed: ${raw}`, e)
+    );
+  }
+}
+function guidedSweep(profile, spine, guides, options = {}) {
+  const { transition = "transformed", solid = true, tolerance } = options;
+  try {
+    const kernel = getKernel();
+    const shellMode = !solid;
+    const auxiliary = guides.length > 0 ? guides[0]?.wrapped : void 0;
+    const sweepResult = kernel.sweepPipeShell(profile.wrapped, spine.wrapped, {
+      transitionMode: transition,
+      ...auxiliary ? { auxiliary } : {},
+      shellMode,
+      ...tolerance !== void 0 ? { tolerance, boundTolerance: tolerance } : {}
+    });
+    const ocShape = typeof sweepResult === "object" && "shape" in sweepResult ? sweepResult.shape : sweepResult;
+    const result = castShape(ocShape);
+    if (!isShape3D(result)) {
+      return err(typeCastError("GUIDED_SWEEP_NOT_3D", "Guided sweep did not produce a 3D shape"));
+    }
+    return ok(result);
+  } catch (e) {
+    const raw = e instanceof Error ? e.message : String(e);
+    return err(kernelError(BrepErrorCode.GUIDED_SWEEP_FAILED, `Guided sweep failed: ${raw}`, e));
+  }
+}
 function exportAssemblySTEP(shapes = [], { unit, modelUnit } = {}) {
   const parseHex = (hex) => {
     let h = hex;
@@ -541,22 +594,22 @@ export {
   addStep as b,
   circularPattern as c,
   collectShapes as d,
-  extrude as e,
-  complexExtrude as f,
-  countNodes as g,
-  createAssembly as h,
-  createAssemblyNode as i,
-  createHistory as j,
-  createRegistry as k,
+  complexExtrude as e,
+  countNodes as f,
+  createAssembly as g,
+  createAssemblyNode as h,
+  createHistory as i,
+  createRegistry as j,
+  deserializeHistory as k,
   linearPattern as l,
-  deserializeHistory as m,
-  exportAssemblySTEP as n,
-  findNode as o,
-  findStep as p,
-  getShape as q,
-  revolve as r,
+  exportAssemblySTEP as m,
+  findNode as n,
+  findStep as o,
+  getShape as p,
+  guidedSweep as q,
+  modifyStep as r,
   sweep as s,
-  modifyStep as t,
+  multiSectionSweep as t,
   registerOperation as u,
   registerShape as v,
   walkAssembly as w,

package/dist/{operations-CYpmLSC4.cjs → operations-DwZ-RBO1.cjs}

@@ -1,11 +1,11 @@
 "use strict";
-const shapeTypes = require("./shapeTypes-7xEam9Ri.cjs");
+const result = require("./result-DJAAj1yb.cjs");
 const vecOps = require("./vecOps-CjRL1jau.cjs");
-const result = require("./result-fAX0OZzI.cjs");
-const loft = require("./loft-hp3pc1M7.cjs");
-const booleanFns = require("./booleanFns-gmsX3Cv2.cjs");
-const shapeFns = require("./shapeFns-C2SnNvdH.cjs");
-const faceFns = require("./faceFns-DB1Fc5gy.cjs");
+const booleanFns = require("./booleanFns-BBd2oTvv.cjs");
+const shapeTypes = require("./shapeTypes-owrg2MNK.cjs");
+const shapeFns = require("./shapeFns-w9tWELHX.cjs");
+const faceFns = require("./faceFns-BAKkZG6D.cjs");
+const loft = require("./loft-BNvBZzqe.cjs");
 function uuidv() {
   return (String([1e7]) + String(-1e3) + String(-4e3) + String(-8e3) + String(-1e11)).replace(
     /[018]/g,
@@ -42,42 +42,6 @@ function makeHelixWire(pitch, height, radius, center, dir, _lefthand = false) {
   const kernel = shapeTypes.getKernel();
   return shapeTypes.castShape(kernel.makeHelixWire(pitch, height, radius, [...center], [...dir]));
 }
-function extrude(face, extrusionVec) {
-  if (shapeTypes.getKernel().isNull(face.wrapped)) {
-    return result.err(result.validationError(result.BrepErrorCode.NULL_SHAPE_INPUT, "extrude: face is a null shape"));
-  }
-  if (vecOps.vecLength(extrusionVec) === 0) {
-    return result.err(result.validationError("EXTRUDE_ZERO_VECTOR", "extrude: extrusion vector has zero length"));
-  }
-  try {
-    const kernel = shapeTypes.getKernel();
-    const len = vecOps.vecLength(extrusionVec);
-    const dir = vecOps.vecNormalize(extrusionVec);
-    const shape = kernel.extrude(face.wrapped, [...dir], len);
-    const downcastShape = kernel.downcast(shape, "solid");
-    const solid = shapeTypes.createSolid(downcastShape);
-    return result.ok(solid);
-  } catch (e) {
-    return result.err(
-      result.kernelError("EXTRUDE_FAILED", "Extrusion operation failed", e, {
-        operation: "extrude",
-        vectorLength: vecOps.vecLength(extrusionVec)
-      })
-    );
-  }
-}
-function revolve(face, center = [0, 0, 0], direction = [0, 0, 1], angle = 360) {
-  if (shapeTypes.getKernel().isNull(face.wrapped)) {
-    return result.err(result.validationError(result.BrepErrorCode.NULL_SHAPE_INPUT, "revolve: face is a null shape"));
-  }
-  const kernel = shapeTypes.getKernel();
-  const shape = kernel.revolveVec(face.wrapped, [...center], [...direction], angle);
-  const result$1 = shapeTypes.castShape(shape);
-  if (!shapeTypes.isShape3D(result$1)) {
-    return result.err(result.typeCastError("REVOLUTION_NOT_3D", "Revolution did not produce a 3D shape"));
-  }
-  return result.ok(result$1);
-}
 function sweep(wire, spine, config = {}, shellMode = false) {
   if (config.mode === "simple" && !shellMode) {
     const kernel2 = shapeTypes.getKernel();
@@ -174,6 +138,95 @@ function twistExtrude(wire, angleDegrees, center, normal, profileShape, shellMod
   const law = profileShape ? result.unwrap(loft.buildLawFromProfile(extrusionLength, profileShape)) : null;
   return sweep(wire, spine, { auxiliarySpine, law }, shellMode);
 }
+function multiSectionSweep(sections, spine, options) {
+  if (sections.length < 2) {
+    return result.err(
+      result.validationError(
+        result.BrepErrorCode.MULTI_SWEEP_INSUFFICIENT_SECTIONS,
+        `Multi-section sweep requires at least 2 sections, got ${sections.length}`
+      )
+    );
+  }
+  const { solid = true, ruled = false, tolerance = 1e-6 } = options ?? {};
+  const explicitLocations = sections.map((s) => s.location);
+  for (let i = 0; i < explicitLocations.length; i++) {
+    const loc = explicitLocations[i];
+    if (loc !== void 0 && (loc < 0 || loc > 1)) {
+      return result.err(
+        result.validationError(
+          result.BrepErrorCode.MULTI_SWEEP_FAILED,
+          `Section ${i} location ${loc} is out of range [0, 1]`
+        )
+      );
+    }
+  }
+  const definedLocs = explicitLocations.filter((l) => l !== void 0);
+  for (let i = 1; i < definedLocs.length; i++) {
+    if ((definedLocs[i] ?? 0) <= (definedLocs[i - 1] ?? 0)) {
+      return result.err(
+        result.validationError(
+          result.BrepErrorCode.MULTI_SWEEP_FAILED,
+          "Section locations must be strictly increasing"
+        )
+      );
+    }
+  }
+  try {
+    const kernel = shapeTypes.getKernel();
+    const [uFirst, uLast] = kernel.curveParameters(spine.wrapped);
+    const uRange = uLast - uFirst;
+    const params = sections.map((s, i) => {
+      if (s.location !== void 0) {
+        return uFirst + s.location * uRange;
+      }
+      return uFirst + i / (sections.length - 1) * uRange;
+    });
+    const positionedWires = [];
+    for (let i = 0; i < sections.length; i++) {
+      const param = params[i];
+      const section = sections[i];
+      if (param === void 0 || section === void 0) continue;
+      const positioned = kernel.positionOnCurve(section.wire.wrapped, spine.wrapped, param);
+      positionedWires.push(kernel.downcast(positioned, "wire"));
+    }
+    const loftResult = kernel.loftAdvanced(positionedWires, { solid, ruled, tolerance });
+    const result$1 = shapeTypes.castShape(loftResult);
+    if (!shapeTypes.isShape3D(result$1)) {
+      return result.err(
+        result.typeCastError("MULTI_SWEEP_NOT_3D", "Multi-section sweep did not produce a 3D shape")
+      );
+    }
+    return result.ok(result$1);
+  } catch (e) {
+    const raw = e instanceof Error ? e.message : String(e);
+    return result.err(
+      result.kernelError(result.BrepErrorCode.MULTI_SWEEP_FAILED, `Multi-section sweep failed: ${raw}`, e)
+    );
+  }
+}
+function guidedSweep(profile, spine, guides, options = {}) {
+  const { transition = "transformed", solid = true, tolerance } = options;
+  try {
+    const kernel = shapeTypes.getKernel();
+    const shellMode = !solid;
+    const auxiliary = guides.length > 0 ? guides[0]?.wrapped : void 0;
+    const sweepResult = kernel.sweepPipeShell(profile.wrapped, spine.wrapped, {
+      transitionMode: transition,
+      ...auxiliary ? { auxiliary } : {},
+      shellMode,
+      ...tolerance !== void 0 ? { tolerance, boundTolerance: tolerance } : {}
+    });
+    const ocShape = typeof sweepResult === "object" && "shape" in sweepResult ? sweepResult.shape : sweepResult;
+    const result$1 = shapeTypes.castShape(ocShape);
+    if (!shapeTypes.isShape3D(result$1)) {
+      return result.err(result.typeCastError("GUIDED_SWEEP_NOT_3D", "Guided sweep did not produce a 3D shape"));
+    }
+    return result.ok(result$1);
+  } catch (e) {
+    const raw = e instanceof Error ? e.message : String(e);
+    return result.err(result.kernelError(result.BrepErrorCode.GUIDED_SWEEP_FAILED, `Guided sweep failed: ${raw}`, e));
+  }
+}
 function exportAssemblySTEP(shapes = [], { unit, modelUnit } = {}) {
   const parseHex = (hex) => {
     let h = hex;
@@ -541,19 +594,19 @@ exports.createHistory = createHistory;
 exports.createRegistry = createRegistry;
 exports.deserializeHistory = deserializeHistory;
 exports.exportAssemblySTEP = exportAssemblySTEP;
-exports.extrude = extrude;
 exports.findNode = findNode;
 exports.findStep = findStep;
 exports.getShape = getShape;
 exports.gridPattern = gridPattern;
+exports.guidedSweep = guidedSweep;
 exports.linearPattern = linearPattern;
 exports.modifyStep = modifyStep;
+exports.multiSectionSweep = multiSectionSweep;
 exports.registerOperation = registerOperation;
 exports.registerShape = registerShape;
 exports.removeChild = removeChild;
 exports.replayFrom = replayFrom;
 exports.replayHistory = replayHistory;
-exports.revolve = revolve;
 exports.serializeHistory = serializeHistory;
 exports.stepCount = stepCount;
 exports.stepsFrom = stepsFrom;

package/dist/operations.cjs

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const operations = require("./operations-CYpmLSC4.cjs");
-const loft = require("./loft-hp3pc1M7.cjs");
+const operations = require("./operations-DwZ-RBO1.cjs");
+const loft = require("./loft-BNvBZzqe.cjs");
 exports.addChild = operations.addChild;
 exports.addStep = operations.addStep;
 exports.circularPattern = operations.circularPattern;

package/dist/operations.js

@@ -1,32 +1,32 @@
-import { a, b, c, d, f, g, h, i, j, k, n, o, p, q, H, l, t, u, v, x, y, z, B, C, D, s, E, F, G, w } from "./operations-BfbkK6DU.js";
-import { b as b2, g as g2, l as l2, r } from "./loft-Bhw-FMoL.js";
+import { a, b, c, d, e, f, g, h, i, j, m, n, o, p, H, l, r, u, v, x, y, z, B, C, D, s, E, F, G, w } from "./operations-DisJ5F8s.js";
+import { b as b2, g as g2, l as l2, r as r2 } from "./loft-D0aCZRaB.js";
 export {
   a as addChild,
   b as addStep,
   b2 as basicFaceExtrusion,
   c as circularPattern,
   d as collectShapes,
-  f as complexExtrude,
-  g as countNodes,
-  h as createAssembly,
-  i as createAssemblyNode,
-  j as createHistory,
-  k as createRegistry,
-  n as exportAssemblySTEP,
-  o as findNode,
-  p as findStep,
+  e as complexExtrude,
+  f as countNodes,
+  g as createAssembly,
+  h as createAssemblyNode,
+  i as createHistory,
+  j as createRegistry,
+  m as exportAssemblySTEP,
+  n as findNode,
+  o as findStep,
   g2 as genericSweep,
-  q as getHistoryShape,
+  p as getHistoryShape,
   H as gridPattern,
   l as linearPattern,
   l2 as loft,
-  t as modifyStep,
+  r as modifyStep,
   u as registerOperation,
   v as registerShape,
   x as removeChild,
   y as replayFrom,
   z as replayHistory,
-  r as revolution,
+  r2 as revolution,
   B as stepCount,
   C as stepsFrom,
   D as supportExtrude,

package/dist/originTrackingFns-NJ1dWoiF.js

@@ -0,0 +1,137 @@
+import { g as getKernel } from "./shapeTypes-CAEAyk8j.js";
+import { H as HASH_CODE_MAX } from "./vecOps-LTN--A58.js";
+import { g as getCacheEntry, a as getOrCreateCache, b as getFaces } from "./topologyQueryFns-De439iBP.js";
+function setShapeOrigin(shape, origin) {
+  const cache = getOrCreateCache(shape);
+  const map = /* @__PURE__ */ new Map();
+  for (const f of getFaces(shape)) {
+    map.set(getKernel().hashCode(f.wrapped, HASH_CODE_MAX), origin);
+  }
+  cache.faceOrigins = map;
+}
+function getFaceOrigins(shape) {
+  return getCacheEntry(shape)?.faceOrigins;
+}
+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, 0);
+        }
+      }
+    }
+  }
+  if (resultMap.size > 0) {
+    const cache = getOrCreateCache(result);
+    cache.faceOrigins = resultMap;
+  }
+}
+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);
+  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);
+    }
+  }
+  if (resultMap.size === 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,
+            0.5 * (bounds.uMin + bounds.uMax),
+            0.5 * (bounds.vMin + bounds.vMax)
+          );
+          const centroid = kernel.surfaceCenterOfMass(f.wrapped);
+          inputSigs.push({ origin, normal, centroid });
+        } catch {
+        }
+      }
+    }
+    if (inputSigs.length > 0) {
+      for (const f of resultFaces) {
+        const hash = kernel.hashCode(f.wrapped, HASH_CODE_MAX);
+        try {
+          const outBounds = kernel.uvBounds(f.wrapped);
+          const outNormal = kernel.surfaceNormal(
+            f.wrapped,
+            0.5 * (outBounds.uMin + outBounds.uMax),
+            0.5 * (outBounds.vMin + outBounds.vMax)
+          );
+          const outCentroid = kernel.surfaceCenterOfMass(f.wrapped);
+          let bestScore = -Infinity;
+          let bestOrigin;
+          for (const inp of inputSigs) {
+            const dot = outNormal[0] * inp.normal[0] + outNormal[1] * inp.normal[1] + outNormal[2] * inp.normal[2];
+            if (dot < 0.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 > 100) continue;
+            const score = dot - distSq / 100;
+            if (score > bestScore) {
+              bestScore = score;
+              bestOrigin = inp.origin;
+            }
+          }
+          if (bestOrigin !== void 0) {
+            resultMap.set(hash, bestOrigin);
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  if (resultMap.size > 0) {
+    const cache = getOrCreateCache(result);
+    cache.faceOrigins = resultMap;
+  }
+}
+export {
+  propagateOriginsFromEvolution as a,
+  getFaceOrigins as g,
+  propagateOriginsByHash as p,
+  setShapeOrigin as s
+};