brep-io-kernel 1.0.0

package/src/features/hole/screwClearance.js

@@ -0,0 +1,86 @@
+import { ThreadStandard } from '../../BREP/threadGeometry.js';
+
+const MM_PER_INCH = 25.4;
+
+const normalizeKey = (s) => String(s || '').replace(/\s+/g, '').toUpperCase();
+
+// ISO 273 style clearance holes (fine=close, normal, coarse=loose)
+const METRIC_CLEARANCE = {
+  'M2': { CLOSE: 2.2, NORMAL: 2.4, LOOSE: 2.6 },
+  'M2.5': { CLOSE: 2.8, NORMAL: 3.0, LOOSE: 3.2 },
+  'M3': { CLOSE: 3.2, NORMAL: 3.4, LOOSE: 3.6 },
+  'M4': { CLOSE: 4.3, NORMAL: 4.5, LOOSE: 4.8 },
+  'M5': { CLOSE: 5.3, NORMAL: 5.5, LOOSE: 5.8 },
+  'M6': { CLOSE: 6.4, NORMAL: 6.6, LOOSE: 7.0 },
+  'M8': { CLOSE: 8.4, NORMAL: 9.0, LOOSE: 10.0 },
+  'M10': { CLOSE: 10.5, NORMAL: 11.0, LOOSE: 12.0 },
+  'M12': { CLOSE: 13.0, NORMAL: 13.5, LOOSE: 14.0 },
+  'M16': { CLOSE: 17.0, NORMAL: 18.0, LOOSE: 19.0 },
+  'M20': { CLOSE: 21.0, NORMAL: 22.0, LOOSE: 24.0 },
+  'M24': { CLOSE: 25.0, NORMAL: 26.0, LOOSE: 28.0 },
+  'M30': { CLOSE: 32.0, NORMAL: 33.0, LOOSE: 35.0 },
+};
+
+// Typical UNC/UNF clearance holes (in inches); converted to mm on read.
+const UNIFIED_CLEARANCE = {
+  '#2-56': { CLOSE: 0.089, NORMAL: 0.096, LOOSE: 0.106 },
+  '#4-40': { CLOSE: 0.116, NORMAL: 0.128, LOOSE: 0.144 },
+  '#6-32': { CLOSE: 0.140, NORMAL: 0.149, LOOSE: 0.169 },
+  '#8-32': { CLOSE: 0.169, NORMAL: 0.182, LOOSE: 0.201 },
+  '#8-36': { CLOSE: 0.169, NORMAL: 0.182, LOOSE: 0.201 },
+  '#10-24': { CLOSE: 0.196, NORMAL: 0.201, LOOSE: 0.221 },
+  '#10-32': { CLOSE: 0.196, NORMAL: 0.201, LOOSE: 0.221 },
+  '1/4-20': { CLOSE: 0.257, NORMAL: 0.266, LOOSE: 0.281 },
+  '1/4-28': { CLOSE: 0.257, NORMAL: 0.266, LOOSE: 0.281 },
+  '5/16-18': { CLOSE: 0.320, NORMAL: 0.332, LOOSE: 0.352 },
+  '5/16-24': { CLOSE: 0.320, NORMAL: 0.332, LOOSE: 0.352 },
+  '3/8-16': { CLOSE: 0.385, NORMAL: 0.397, LOOSE: 0.421 },
+  '3/8-24': { CLOSE: 0.385, NORMAL: 0.397, LOOSE: 0.421 },
+  '7/16-14': { CLOSE: 0.438, NORMAL: 0.453, LOOSE: 0.484 },
+  '7/16-20': { CLOSE: 0.438, NORMAL: 0.453, LOOSE: 0.484 },
+  '1/2-13': { CLOSE: 0.515, NORMAL: 0.531, LOOSE: 0.562 },
+  '1/2-20': { CLOSE: 0.515, NORMAL: 0.531, LOOSE: 0.562 },
+  '5/8-11': { CLOSE: 0.642, NORMAL: 0.656, LOOSE: 0.688 },
+  '5/8-18': { CLOSE: 0.642, NORMAL: 0.656, LOOSE: 0.688 },
+  '3/4-10': { CLOSE: 0.769, NORMAL: 0.781, LOOSE: 0.812 },
+  '3/4-16': { CLOSE: 0.769, NORMAL: 0.781, LOOSE: 0.812 },
+  '7/8-9': { CLOSE: 0.885, NORMAL: 0.906, LOOSE: 0.938 },
+  '1-8': { CLOSE: 1.027, NORMAL: 1.063, LOOSE: 1.094 },
+  '1-12': { CLOSE: 1.027, NORMAL: 1.063, LOOSE: 1.094 },
+};
+
+function lookupUnified(designation, fit) {
+  const key = normalizeKey(designation);
+  for (const raw in UNIFIED_CLEARANCE) {
+    if (!Object.prototype.hasOwnProperty.call(UNIFIED_CLEARANCE, raw)) continue;
+    const candidate = normalizeKey(raw);
+    if (candidate === key) {
+      const diam = UNIFIED_CLEARANCE[raw]?.[fit];
+      return typeof diam === 'number' ? diam * MM_PER_INCH : null;
+    }
+  }
+  return null;
+}
+
+function lookupMetric(designation, fit) {
+  const key = normalizeKey(designation).replace(/X.+$/, ''); // strip pitch, keep base size
+  if (METRIC_CLEARANCE[key] && typeof METRIC_CLEARANCE[key][fit] === 'number') {
+    return METRIC_CLEARANCE[key][fit];
+  }
+  return null;
+}
+
+export function getClearanceDiameter({ standard, designation, fit }) {
+  const fitKey = String(fit || 'NONE').toUpperCase();
+  if (fitKey === 'NONE') return null;
+  if (!designation) return null;
+  const std = String(standard || '').toUpperCase();
+  if (std === ThreadStandard.UNIFIED) {
+    return lookupUnified(designation, fitKey);
+  }
+  if (std === ThreadStandard.ISO_METRIC || std === ThreadStandard.TRAPEZOIDAL_METRIC) {
+    return lookupMetric(designation, fitKey);
+  }
+  // fallback: try metric-style lookup anyway
+  return lookupMetric(designation, fitKey) || lookupUnified(designation, fitKey);
+}

package/src/features/hole/threadDesignationCatalog.js

@@ -0,0 +1,149 @@
+import { ThreadStandard } from '../../BREP/threadGeometry.js';
+
+const makeOptions = (list) => list
+  .map((entry) => {
+    if (typeof entry === 'string') return { value: entry, label: entry };
+    if (Array.isArray(entry) && entry[0]) {
+      return { value: String(entry[0]), label: String(entry[1] || entry[0]) };
+    }
+    return null;
+  })
+  .filter(Boolean);
+
+const ISO_METRIC = makeOptions([
+  ['M2x0.4', 'M2 x 0.4'],
+  ['M2.5x0.45', 'M2.5 x 0.45'],
+  ['M3x0.5', 'M3 x 0.5'],
+  ['M4x0.7', 'M4 x 0.7'],
+  ['M5x0.8', 'M5 x 0.8'],
+  ['M6x1', 'M6 x 1 (coarse)'],
+  ['M6x0.75', 'M6 x 0.75 (fine)'],
+  ['M8x1.25', 'M8 x 1.25 (coarse)'],
+  ['M8x1', 'M8 x 1 (fine)'],
+  ['M10x1.5', 'M10 x 1.5 (coarse)'],
+  ['M10x1.25', 'M10 x 1.25 (fine)'],
+  ['M12x1.75', 'M12 x 1.75 (coarse)'],
+  ['M12x1.25', 'M12 x 1.25 (fine)'],
+  ['M16x2', 'M16 x 2'],
+  ['M16x1.5', 'M16 x 1.5'],
+  ['M20x2.5', 'M20 x 2.5'],
+  ['M20x1.5', 'M20 x 1.5'],
+  ['M24x3', 'M24 x 3'],
+  ['M24x2', 'M24 x 2'],
+  ['M30x3.5', 'M30 x 3.5'],
+]);
+
+const UNIFIED = makeOptions([
+  ['#2-56UNF', '#2-56 UNF'],
+  ['#4-40UNC', '#4-40 UNC'],
+  ['#6-32UNC', '#6-32 UNC'],
+  ['#8-32UNC', '#8-32 UNC'],
+  ['#8-36UNF', '#8-36 UNF'],
+  ['#10-24UNC', '#10-24 UNC'],
+  ['#10-32UNF', '#10-32 UNF'],
+  ['1/4-20UNC', '1/4-20 UNC'],
+  ['1/4-28UNF', '1/4-28 UNF'],
+  ['5/16-18UNC', '5/16-18 UNC'],
+  ['5/16-24UNF', '5/16-24 UNF'],
+  ['3/8-16UNC', '3/8-16 UNC'],
+  ['3/8-24UNF', '3/8-24 UNF'],
+  ['7/16-14UNC', '7/16-14 UNC'],
+  ['7/16-20UNF', '7/16-20 UNF'],
+  ['1/2-13UNC', '1/2-13 UNC'],
+  ['1/2-20UNF', '1/2-20 UNF'],
+  ['5/8-11UNC', '5/8-11 UNC'],
+  ['5/8-18UNF', '5/8-18 UNF'],
+  ['3/4-10UNC', '3/4-10 UNC'],
+  ['3/4-16UNF', '3/4-16 UNF'],
+  ['7/8-9UNC', '7/8-9 UNC'],
+  ['1-8UNC', '1-8 UNC'],
+  ['1-12UNF', '1-12 UNF'],
+]);
+
+const TRAPEZOIDAL_METRIC = makeOptions([
+  ['Tr8x1.5', 'Tr8 x 1.5'],
+  ['Tr10x2', 'Tr10 x 2'],
+  ['Tr12x3', 'Tr12 x 3'],
+  ['Tr16x4', 'Tr16 x 4'],
+  ['Tr20x4', 'Tr20 x 4'],
+  ['Tr20x5', 'Tr20 x 5'],
+  ['Tr24x5', 'Tr24 x 5'],
+  ['Tr30x6', 'Tr30 x 6'],
+  ['Tr36x6', 'Tr36 x 6'],
+]);
+
+const ACME = makeOptions([
+  ['1/4-16', '1/4-16 Acme'],
+  ['3/8-12', '3/8-12 Acme'],
+  ['1/2-10', '1/2-10 Acme'],
+  ['5/8-8', '5/8-8 Acme'],
+  ['3/4-6', '3/4-6 Acme'],
+  ['1-5', '1-5 Acme'],
+  ['1.25-5', '1.25-5 Acme'],
+  ['1.5-4', '1.5-4 Acme'],
+  ['2-4', '2-4 Acme'],
+]);
+
+const STUB_ACME = makeOptions([
+  ['3/8-16', '3/8-16 Stub Acme'],
+  ['1/2-16', '1/2-16 Stub Acme'],
+  ['5/8-12', '5/8-12 Stub Acme'],
+  ['3/4-12', '3/4-12 Stub Acme'],
+  ['1-10', '1-10 Stub Acme'],
+  ['1.25-10', '1.25-10 Stub Acme'],
+  ['1.5-8', '1.5-8 Stub Acme'],
+  ['2-6', '2-6 Stub Acme'],
+]);
+
+const WHITWORTH = makeOptions([
+  ['1/8-40', '1/8-40 BSW'],
+  ['3/16-32', '3/16-32 BSW'],
+  ['1/4-20', '1/4-20 BSW'],
+  ['5/16-18', '5/16-18 BSW'],
+  ['3/8-16', '3/8-16 BSW'],
+  ['7/16-14', '7/16-14 BSW'],
+  ['1/2-12', '1/2-12 BSW'],
+  ['5/8-11', '5/8-11 BSW'],
+  ['3/4-10', '3/4-10 BSW'],
+  ['1-8', '1-8 BSW'],
+  ['1/4-26', '1/4-26 BSF'],
+  ['5/16-22', '5/16-22 BSF'],
+  ['3/8-20', '3/8-20 BSF'],
+  ['7/16-18', '7/16-18 BSF'],
+  ['1/2-16', '1/2-16 BSF'],
+]);
+
+const NPT = makeOptions([
+  ['1/16-27NPT', '1/16-27 NPT'],
+  ['1/8-27NPT', '1/8-27 NPT'],
+  ['1/4-18NPT', '1/4-18 NPT'],
+  ['3/8-18NPT', '3/8-18 NPT'],
+  ['1/2-14NPT', '1/2-14 NPT'],
+  ['3/4-14NPT', '3/4-14 NPT'],
+  ['1-11.5NPT', '1-11.5 NPT'],
+  ['1.25-11.5NPT', '1-1/4-11.5 NPT'],
+  ['1.5-11.5NPT', '1-1/2-11.5 NPT'],
+  ['2-11.5NPT', '2-11.5 NPT'],
+]);
+
+export const THREAD_DESIGNATION_PRESETS = {
+  [ThreadStandard.ISO_METRIC]: ISO_METRIC,
+  [ThreadStandard.UNIFIED]: UNIFIED,
+  [ThreadStandard.TRAPEZOIDAL_METRIC]: TRAPEZOIDAL_METRIC,
+  [ThreadStandard.ACME]: ACME,
+  [ThreadStandard.STUB_ACME]: STUB_ACME,
+  [ThreadStandard.WHITWORTH]: WHITWORTH,
+  [ThreadStandard.NPT]: NPT,
+};
+
+export function normalizeThreadStandard(standard) {
+  if (standard == null && standard !== 0) return 'NONE';
+  return String(standard).toUpperCase();
+}
+
+export function getThreadDesignationOptions(standard) {
+  const key = normalizeThreadStandard(standard);
+  const list = THREAD_DESIGNATION_PRESETS[key] || [];
+  // Return a shallow copy so callers cannot mutate the shared presets.
+  return list.map((opt) => ({ ...opt }));
+}

package/src/features/imageHeightSolid/ImageHeightmapSolidFeature.js

@@ -0,0 +1,463 @@
+import { BREP } from "../../BREP/BREP.js";
+const THREE = BREP.THREE;
+import { ImageEditorUI } from '../imageToFace/imageEditor.js';
+
+const inputParamsSchema = {
+  id: {
+    type: "string",
+    default_value: null,
+    hint: "unique identifier for the heightmap solid feature",
+  },
+  fileToImport: {
+    type: "file",
+    default_value: "",
+    accept: ".png,image/png",
+    hint: "Grayscale or RGB PNG heightmap (click to choose a file)",
+  },
+  editImage: {
+    type: "button",
+    label: "Edit Image",
+    default_value: null,
+    hint: "Launch the paint like image editor",
+    actionFunction: (ctx) => {
+      let { fileToImport } = ctx.feature.inputParams;
+      if (!fileToImport) {
+        try {
+          const c = document.createElement('canvas');
+          c.width = 300; c.height = 300;
+          const ctx2d = c.getContext('2d');
+          ctx2d.fillStyle = '#ffffff';
+          ctx2d.fillRect(0, 0, c.width, c.height);
+          fileToImport = c.toDataURL('image/png');
+        } catch (_) { fileToImport = null; }
+      }
+      const imageEditor = new ImageEditorUI(fileToImport, {
+        onSave: (editedImage) => {
+          try { ctx.feature.inputParams.fileToImport = editedImage; } catch (_) { }
+          try { if (ctx.params) ctx.params.fileToImport = editedImage; } catch (_) { }
+          try {
+            if (ctx.partHistory) {
+              ctx.partHistory.currentHistoryStepId = ctx.feature.inputParams.featureID;
+              if (typeof ctx.partHistory.runHistory === 'function') ctx.partHistory.runHistory();
+            }
+          } catch (_) { }
+        },
+        onCancel: () => { /* no-op */ }
+      });
+      imageEditor.open();
+    }
+  },
+  heightScale: {
+    type: "number",
+    default_value: 1,
+    hint: "World units of elevation per full-intensity pixel (0-255)",
+  },
+  baseHeight: {
+    type: "number",
+    default_value: 0,
+    hint: "Base plane height used as the minimum elevation",
+  },
+  invertHeights: {
+    type: "boolean",
+    default_value: false,
+    hint: "Invert grayscale so dark pixels become tall regions",
+  },
+  pixelScale: {
+    type: "number",
+    default_value: 1,
+    hint: "World units per pixel in X/Y directions",
+  },
+  center: {
+    type: "boolean",
+    default_value: true,
+    hint: "Center the heightmap around the origin before placement",
+  },
+  sampleStride: {
+    type: "number",
+    default_value: 1,
+    hint: "Sample every Nth pixel (higher stride reduces triangles)",
+  },
+  placementPlane: {
+    type: "reference_selection",
+    selectionFilter: ["PLANE", "FACE"],
+    multiple: false,
+    default_value: null,
+    hint: "Select a plane or face where the heightmap will be placed",
+  },
+  simplifyTolerance: {
+    type: "number",
+    default_value: 0,
+    hint: "Simplify tolerance (>0 enables Manifold simplify)",
+  },
+  boolean: {
+    type: "boolean_operation",
+    default_value: { targets: [], operation: 'NONE' },
+    hint: "Optional boolean operation with selected solids"
+  }
+};
+
+export class ImageHeightmapSolidFeature {
+  static shortName = "HEIGHTMAP";
+  static longName = "Image Heightmap Solid";
+  static inputParamsSchema = inputParamsSchema;
+
+  constructor() {
+    this.inputParams = {};
+    this.persistentData = {};
+  }
+
+  async run(partHistory) {
+    const {
+      fileToImport,
+      heightScale,
+      baseHeight,
+      invertHeights,
+      pixelScale,
+      center,
+      sampleStride,
+      simplifyTolerance,
+    } = this.inputParams;
+
+    const imageData = await decodeToImageData(fileToImport);
+    if (!imageData) {
+      console.warn('[HEIGHTMAP] No image data decoded');
+      return { added: [], removed: [] };
+    }
+
+    const width = imageData.width | 0;
+    const height = imageData.height | 0;
+    if (!(width >= 2 && height >= 2)) {
+      console.warn('[HEIGHTMAP] Heightmap requires an image at least 2x2 pixels');
+      return { added: [], removed: [] };
+    }
+
+    const src = imageData.data;
+    const scaleXY = Number.isFinite(Number(pixelScale)) && Number(pixelScale) !== 0 ? Number(pixelScale) : 1;
+    const scaleZ = Number.isFinite(Number(heightScale)) ? Number(heightScale) : 1;
+    const base = Number.isFinite(Number(baseHeight)) ? Number(baseHeight) : 0;
+    const invert = !!invertHeights;
+    const centerXY = center !== false;
+    const strideRaw = Number(sampleStride);
+    const stride = Number.isFinite(strideRaw) && strideRaw >= 1 ? Math.floor(strideRaw) : 1;
+
+    const offsetX = centerXY ? (width - 1) * 0.5 : 0;
+    const offsetY = centerXY ? (height - 1) * 0.5 : 0;
+
+    const sampleXs = buildSampleIndices(width, stride);
+    const sampleYs = buildSampleIndices(height, stride);
+    const gridWidth = sampleXs.length;
+    const gridHeight = sampleYs.length;
+    if (!(gridWidth >= 2 && gridHeight >= 2)) {
+      console.warn('[HEIGHTMAP] Sampling produced insufficient grid resolution');
+      return { added: [], removed: [] };
+    }
+    const idx = (x, y) => y * gridWidth + x;
+    const topVerts = new Array(gridWidth * gridHeight);
+    const bottomVerts = new Array(gridWidth * gridHeight);
+
+    let minX = Infinity, minY = Infinity, minZ = Infinity;
+    let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
+    const updateBounds = (p) => {
+      if (!p) return;
+      if (p[0] < minX) minX = p[0];
+      if (p[1] < minY) minY = p[1];
+      if (p[2] < minZ) minZ = p[2];
+      if (p[0] > maxX) maxX = p[0];
+      if (p[1] > maxY) maxY = p[1];
+      if (p[2] > maxZ) maxZ = p[2];
+    };
+
+    for (let gy = 0; gy < gridHeight; gy++) {
+      const sy = sampleYs[gy];
+      for (let gx = 0; gx < gridWidth; gx++) {
+        const sx = sampleXs[gx];
+        const i = idx(gx, gy);
+        const si = (sy * width + sx) * 4;
+        const r = src[si] | 0;
+        const g = src[si + 1] | 0;
+        const b = src[si + 2] | 0;
+        const a = src[si + 3] | 0;
+        const gray = (r * 0.2126 + g * 0.7152 + b * 0.0722) / 255;
+        const alphaMask = (a >= 16) ? 1 : 0;
+        let value = invert ? (1 - gray) : gray;
+        if (alphaMask === 0) value = 0;
+        value = Math.max(0, Math.min(1, value));
+        const h = base + value * scaleZ;
+        const px = (sx - offsetX) * scaleXY;
+        const py = ((centerXY ? (offsetY - sy) : -sy)) * scaleXY;
+        const top = [px, py, h];
+        const bottom = [px, py, base];
+        topVerts[i] = top;
+        bottomVerts[i] = bottom;
+        updateBounds(top);
+        updateBounds(bottom);
+      }
+    }
+
+    if (!Number.isFinite(minX) || !Number.isFinite(maxX) || !Number.isFinite(minZ) || !Number.isFinite(maxZ)) {
+      console.warn('[HEIGHTMAP] Failed to compute geometry bounds');
+      return { added: [], removed: [] };
+    }
+
+    if (!((maxZ - minZ) > 1e-9)) {
+      console.warn('[HEIGHTMAP] Heightmap has zero thickness; increase heightScale or height variation');
+      return { added: [], removed: [] };
+    }
+
+    const centerVec = [
+      (minX + maxX) * 0.5,
+      (minY + maxY) * 0.5,
+      (minZ + maxZ) * 0.5,
+    ];
+
+    const solid = new BREP.Solid();
+    const featureName = this.inputParams.featureID || 'HEIGHTMAP_SOLID';
+    solid.name = featureName;
+
+    const addTriangleFacingOutward = (faceName, p0, p1, p2) => {
+      if (!p0 || !p1 || !p2) return;
+      const ax = p1[0] - p0[0];
+      const ay = p1[1] - p0[1];
+      const az = p1[2] - p0[2];
+      const bx = p2[0] - p0[0];
+      const by = p2[1] - p0[1];
+      const bz = p2[2] - p0[2];
+      const nx = ay * bz - az * by;
+      const ny = az * bx - ax * bz;
+      const nz = ax * by - ay * bx;
+      const lenSq = nx * nx + ny * ny + nz * nz;
+      if (!(lenSq > 1e-24)) return;
+      const cx = (p0[0] + p1[0] + p2[0]) / 3;
+      const cy = (p0[1] + p1[1] + p2[1]) / 3;
+      const cz = (p0[2] + p1[2] + p2[2]) / 3;
+      const vx = centerVec[0] - cx;
+      const vy = centerVec[1] - cy;
+      const vz = centerVec[2] - cz;
+      const dot = nx * vx + ny * vy + nz * vz;
+      if (dot > 0) {
+        solid.addTriangle(faceName, p0, p2, p1);
+      } else {
+        solid.addTriangle(faceName, p0, p1, p2);
+      }
+    };
+
+    const faceBase = featureName ? `${featureName}` : 'HEIGHTMAP';
+    const topFace = `${faceBase}:TOP`;
+    const bottomFace = `${faceBase}:BOTTOM`;
+    const sidePosY = `${faceBase}:SIDE_POS_Y`;
+    const sideNegY = `${faceBase}:SIDE_NEG_Y`;
+    const sideNegX = `${faceBase}:SIDE_NEG_X`;
+    const sidePosX = `${faceBase}:SIDE_POS_X`;
+
+    for (let y = 0; y < gridHeight - 1; y++) {
+      for (let x = 0; x < gridWidth - 1; x++) {
+        const i00 = idx(x, y);
+        const i10 = idx(x + 1, y);
+        const i01 = idx(x, y + 1);
+        const i11 = idx(x + 1, y + 1);
+        const v00 = topVerts[i00];
+        const v10 = topVerts[i10];
+        const v01 = topVerts[i01];
+        const v11 = topVerts[i11];
+        addTriangleFacingOutward(topFace, v00, v11, v10);
+        addTriangleFacingOutward(topFace, v00, v01, v11);
+
+        const b00 = bottomVerts[i00];
+        const b10 = bottomVerts[i10];
+        const b01 = bottomVerts[i01];
+        const b11 = bottomVerts[i11];
+        addTriangleFacingOutward(bottomFace, b00, b10, b11);
+        addTriangleFacingOutward(bottomFace, b00, b11, b01);
+      }
+    }
+
+    const addSideQuad = (faceName, topA, topB, bottomB, bottomA) => {
+      addTriangleFacingOutward(faceName, topA, topB, bottomB);
+      addTriangleFacingOutward(faceName, topA, bottomB, bottomA);
+    };
+
+    for (let x = 0; x < gridWidth - 1; x++) {
+      const iA = idx(x, 0);
+      const iB = idx(x + 1, 0);
+      addSideQuad(sidePosY, topVerts[iA], topVerts[iB], bottomVerts[iB], bottomVerts[iA]);
+    }
+
+    for (let x = 0; x < gridWidth - 1; x++) {
+      const row = gridHeight - 1;
+      const iA = idx(x, row);
+      const iB = idx(x + 1, row);
+      addSideQuad(sideNegY, topVerts[iA], topVerts[iB], bottomVerts[iB], bottomVerts[iA]);
+    }
+
+    for (let y = 0; y < gridHeight - 1; y++) {
+      const iA = idx(0, y);
+      const iB = idx(0, y + 1);
+      addSideQuad(sideNegX, topVerts[iA], topVerts[iB], bottomVerts[iB], bottomVerts[iA]);
+    }
+
+    for (let y = 0; y < gridHeight - 1; y++) {
+      const col = gridWidth - 1;
+      const iA = idx(col, y);
+      const iB = idx(col, y + 1);
+      addSideQuad(sidePosX, topVerts[iA], topVerts[iB], bottomVerts[iB], bottomVerts[iA]);
+    }
+
+    const basis = getPlacementBasis(this.inputParams?.placementPlane, partHistory);
+    const origin = new THREE.Vector3().fromArray(basis.origin);
+    const xAxis = new THREE.Vector3().fromArray(basis.x);
+    const yAxis = new THREE.Vector3().fromArray(basis.y);
+    const zAxis = new THREE.Vector3().fromArray(basis.z);
+    const placement = new THREE.Matrix4().makeBasis(xAxis, yAxis, zAxis).setPosition(origin);
+    solid.bakeTransform(placement);
+
+    solid.userData = solid.userData || {};
+    solid.userData.heightmap = {
+      width,
+      height,
+      pixelScale: scaleXY,
+      heightScale: scaleZ,
+      baseHeight: base,
+      invert: invert,
+      sampleStride: stride,
+      gridWidth,
+      gridHeight,
+    };
+    let finalSolid = solid;
+    const tol = Number(simplifyTolerance);
+    if (Number.isFinite(tol) && tol > 0) {
+      try {
+        const simplified = solid.simplify(tol);
+        if (simplified && simplified instanceof BREP.Solid) finalSolid = simplified;
+      } catch (e) {
+        console.warn('[HEIGHTMAP] Simplify failed, using original solid:', e);
+      }
+    }
+    if (finalSolid !== solid) {
+      finalSolid.name = featureName;
+      finalSolid.userData = { ...solid.userData };
+    }
+    finalSolid.visualize();
+
+    const effects = await BREP.applyBooleanOperation(partHistory || {}, finalSolid, this.inputParams.boolean, this.inputParams.featureID);
+    return effects;
+  }
+}
+
+async function decodeToImageData(raw) {
+  try {
+    if (!raw) return null;
+    if (raw instanceof ImageData) return raw;
+    if (raw instanceof ArrayBuffer) {
+      try {
+        const blob = new Blob([raw], { type: 'image/png' });
+        const img = await createImageBitmap(blob);
+        const c = document.createElement('canvas');
+        c.width = img.width; c.height = img.height;
+        const ctx = c.getContext('2d');
+        ctx.drawImage(img, 0, 0);
+        const id = ctx.getImageData(0, 0, img.width, img.height);
+        try { img.close && img.close(); } catch { }
+        return id;
+      } catch { }
+      return null;
+    }
+    if (typeof raw === 'string') {
+      if (raw.startsWith('data:')) {
+        const img = await createImageBitmap(await (await fetch(raw)).blob());
+        const c = document.createElement('canvas');
+        c.width = img.width; c.height = img.height;
+        const ctx = c.getContext('2d');
+        ctx.drawImage(img, 0, 0);
+        const id = ctx.getImageData(0, 0, img.width, img.height);
+        try { img.close && img.close(); } catch { }
+        return id;
+      }
+      try {
+        const b64 = raw;
+        const binaryStr = (typeof atob === 'function') ? atob(b64) : (typeof Buffer !== 'undefined' ? Buffer.from(b64, 'base64').toString('binary') : '');
+        const len = binaryStr.length | 0;
+        const bytes = new Uint8Array(len);
+        for (let i = 0; i < len; i++) bytes[i] = binaryStr.charCodeAt(i) & 0xff;
+        const blob = new Blob([bytes], { type: 'image/png' });
+        const img = await createImageBitmap(blob);
+        const c = document.createElement('canvas');
+        c.width = img.width; c.height = img.height;
+        const ctx = c.getContext('2d');
+        ctx.drawImage(img, 0, 0);
+        const id = ctx.getImageData(0, 0, img.width, img.height);
+        try { img.close && img.close(); } catch { }
+        return id;
+      } catch { }
+      return null;
+    }
+  } catch (e) {
+    console.warn('[HEIGHTMAP] Failed to decode input as image data', e);
+  }
+  return null;
+}
+
+function buildSampleIndices(count, stride) {
+  const out = [];
+  if (count <= 0) return out;
+  for (let i = 0; i < count; i += stride) out.push(i);
+  const last = count - 1;
+  if (out[out.length - 1] !== last) out.push(last);
+  return out;
+}
+
+function getPlacementBasis(ref, partHistory) {
+  const x = new THREE.Vector3(1, 0, 0);
+  const y = new THREE.Vector3(0, 1, 0);
+  const z = new THREE.Vector3(0, 0, 1);
+  const origin = new THREE.Vector3(0, 0, 0);
+
+  let refObj = null;
+  try {
+    if (Array.isArray(ref)) refObj = ref[0] || null;
+    else if (ref && typeof ref === 'object') refObj = ref;
+    else if (ref) refObj = partHistory?.scene?.getObjectByName(ref);
+  } catch { }
+
+  if (refObj) {
+    try { refObj.updateWorldMatrix(true, true); } catch { }
+    try {
+      const g = refObj.geometry;
+      if (g) {
+        const bs = g.boundingSphere || (g.computeBoundingSphere(), g.boundingSphere);
+        if (bs) origin.copy(refObj.localToWorld(bs.center.clone()));
+        else origin.copy(refObj.getWorldPosition(new THREE.Vector3()));
+      } else origin.copy(refObj.getWorldPosition(new THREE.Vector3()));
+    } catch { origin.copy(refObj.getWorldPosition(new THREE.Vector3())); }
+
+    let n = null;
+    try {
+      if (refObj.type === 'FACE' && typeof refObj.getAverageNormal === 'function') {
+        n = refObj.getAverageNormal().clone();
+      } else {
+        n = new THREE.Vector3(0, 0, 1).applyQuaternion(refObj.getWorldQuaternion(new THREE.Quaternion()));
+      }
+    } catch { n = null; }
+    if (!n || n.lengthSq() < 1e-16) n = new THREE.Vector3(0, 0, 1);
+    n.normalize();
+
+    const worldX = new THREE.Vector3(1, 0, 0).applyQuaternion(refObj.getWorldQuaternion(new THREE.Quaternion()));
+    const worldY = new THREE.Vector3().crossVectors(n, worldX);
+    if (worldY.lengthSq() < 1e-20) {
+      worldX.set(1, 0, 0);
+      worldY.set(0, 1, 0);
+    } else {
+      worldY.normalize();
+      worldX.crossVectors(worldY, n).normalize();
+    }
+    x.copy(worldX);
+    y.copy(worldY);
+    z.copy(n);
+  }
+
+  return {
+    origin: [origin.x, origin.y, origin.z],
+    x: [x.x, x.y, x.z],
+    y: [y.x, y.y, y.z],
+    z: [z.x, z.y, z.z],
+  };
+}