forgecad 0.10.2 → 0.10.3

package/dist/assets/cli/{render-B_0lQwKU.js → render-BsngirjC.js}

@@ -1,8 +1,8 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { D as DoubleSide, a as Scene, bx as BoxGeometry, c2 as MeshStandardMaterial, a5 as BackSide, b8 as PointLight, M as Mesh, ab as MeshBasicMaterial, cJ as localAabbPlaneRelation, i as Vector2, cK as ShapeUtils, cL as analyzePhysicalConnectivity, h as Vector3, a0 as Matrix4, cM as Frustum, J as Box3, a1 as MathUtils, cN as meshContactDataFor, cO as AabbSpatialIndex, cP as detectPhysicalContact, cQ as resolveThicknessInspectionOptions, R as Raycaster, cR as thicknessColor, cS as thicknessClass, b0 as BufferAttribute, cT as roughnessClassForAngle, cU as resolveRoughnessInspectionOptions, cV as roughnessColorForAngle, cW as roughnessScoreForAngle, cI as initBackendForEvaluation, f as Color, bb as COMPARISON_COLORS, az as resolveForgeRenderStyle, bG as getRenderStylePreset, ay as setParamOverrides, bm as runScript, cs as scanProxyGridForBounds, cX as Group, bf as shapeToGeometry, bn as MeshPhysicalMaterial, bE as AdditiveBlending, bJ as scanMaterialShellColor, cY as createScanProxyGeometry, aP as LineBasicMaterial, bI as NormalBlending, bo as LineSegments, P as PerspectiveCamera, cp as DEFAULT_VIEW_CONFIG, bt as worldAuthorPlaneToLocal, cZ as resolveSectionHatchMetrics, cA as buildGeometryComparisonPointCloud, cy as triangleSoupFromMeshes, O as OrthographicCamera, l as ShaderMaterial, bP as ZEBRA_STRIPE_FRAGMENT_SHADER, bQ as ZEBRA_STRIPE_VERTEX_SHADER, bK as ZEBRA_STRIPE_SOFTNESS, bL as ZEBRA_STRIPE_SCALE, bM as ZEBRA_LIGHT_COLOR, bN as ZEBRA_DARK_COLOR, bO as ZEBRA_ACCENT_COLOR, bF as geometryWithVisibleVertexColors, c_ as intersectWithPlane, c$ as setActiveBackend, W as WebGLRenderer, A as ACESFilmicToneMapping, d as SRGBColorSpace, d0 as parseCameraCliSpec, d1 as PMREMGenerator, b1 as CanvasTexture, b2 as Object3D, b3 as FogExp2, b4 as Fog, b5 as AmbientLight, b9 as DirectionalLight, b6 as HemisphereLight, aJ as findJointAnimationClip, q as Plane, bT as SURFACE_FIELD_FRAGMENT_SHADER, bU as SURFACE_FIELD_VERTEX_SHADER, bS as scanMaterialLayerStyles, bR as SCAN_PROXY_LAYER_STYLES, aK as resolveJointAnimation, aL as resolveJointViewValues, aO as BufferGeometry, bZ as ROUGHNESS_COLORS, d2 as PointsMaterial, d3 as Points, ba as heatPointsForSide, d4 as analyzeCollisionIntersections, d5 as serializeCollisionFinding, d6 as summarizeThicknessSamples, bY as THICKNESS_GRADIENT_COLORS, d7 as THICKNESS_COLORS, b7 as SpotLight, c6 as CylinderGeometry, d8 as TorusGeometry, bW as CatmullRomCurve3, bX as TubeGeometry, cE as resolveScalarSceneSampleBudget, bg as buildComparisonHeatPatchGeometry, bh as EdgesGeometry, d9 as SphereGeometry, da as ConeGeometry, bc as comparisonHeatDepthTest, bd as comparisonHeatEdgeOpacity, be as comparisonHeatPatchOpacity, cG as comparisonCandidateContextOpacity, db as DEFAULT_COMPARISON_CANDIDATE_OPACITY } from "../backendInit-ymjonyQp.js";
-import { m as mergeViewportRenderSceneStates, v as validateJointOverrides, b as buildBaseJointValues, p as parseRenderSceneCliSpec, g as getSceneObjectTreePath } from "../jointPose-4r8ed8_5.js";
+import { D as DoubleSide, a as Scene, bw as BoxGeometry, c1 as MeshStandardMaterial, a5 as BackSide, b2 as PointLight, M as Mesh, af as MeshBasicMaterial, cF as localAabbPlaneRelation, i as Vector2, cG as ShapeUtils, cH as analyzePhysicalConnectivity, h as Vector3, a0 as Matrix4, cI as Frustum, J as Box3, a1 as MathUtils, cJ as meshContactDataFor, cK as AabbSpatialIndex, cL as detectPhysicalContact, cM as resolveThicknessInspectionOptions, R as Raycaster, cN as thicknessColor, cO as thicknessClass, a6 as BufferAttribute, cE as initBackendForEvaluation, f as Color, b5 as COMPARISON_COLORS, aE as resolveForgeRenderStyle, bG as getRenderStylePreset, aD as setParamOverrides, bk as runScript, cp as scanProxyGridForBounds, cP as Group, b9 as shapeToGeometry, bl as MeshPhysicalMaterial, bD as AdditiveBlending, bJ as scanMaterialShellColor, cQ as createScanProxyGeometry, aU as LineBasicMaterial, bI as NormalBlending, bm as LineSegments, P as PerspectiveCamera, cm as DEFAULT_VIEW_CONFIG, bs as worldAuthorPlaneToLocal, cR as resolveSectionHatchMetrics, cv as buildGeometryComparisonPointCloud, ct as triangleSoupFromMeshes, O as OrthographicCamera, l as ShaderMaterial, bP as ZEBRA_STRIPE_FRAGMENT_SHADER, bQ as ZEBRA_STRIPE_VERTEX_SHADER, bK as ZEBRA_STRIPE_SOFTNESS, bL as ZEBRA_STRIPE_SCALE, bM as ZEBRA_LIGHT_COLOR, bN as ZEBRA_DARK_COLOR, bO as ZEBRA_ACCENT_COLOR, bE as geometryWithVisibleVertexColors, cS as intersectWithPlane, cT as setActiveBackend, W as WebGLRenderer, A as ACESFilmicToneMapping, d as SRGBColorSpace, cU as parseCameraCliSpec, cV as PMREMGenerator, aX as CanvasTexture, aY as Object3D, aZ as FogExp2, a_ as Fog, a$ as AmbientLight, b3 as DirectionalLight, b0 as HemisphereLight, aO as findJointAnimationClip, q as Plane, bT as SURFACE_FIELD_FRAGMENT_SHADER, bU as SURFACE_FIELD_VERTEX_SHADER, bS as scanMaterialLayerStyles, bR as SCAN_PROXY_LAYER_STYLES, aP as resolveJointAnimation, aQ as resolveJointViewValues, aT as BufferGeometry, cW as DEFAULT_ROUGHNESS_COLOR_SCALE, cX as PointsMaterial, cY as Points, b4 as heatPointsForSide, cZ as analyzeCollisionIntersections, c_ as serializeCollisionFinding, c$ as summarizeThicknessSamples, d0 as THICKNESS_GRADIENT_COLORS, d1 as THICKNESS_COLORS, d2 as DEFAULT_THICKNESS_COLOR_SCALE, b1 as SpotLight, c5 as CylinderGeometry, d3 as TorusGeometry, bW as CatmullRomCurve3, bX as TubeGeometry, cz as resolveScalarSceneSampleBudget, d4 as sampleColorScale, ba as buildComparisonHeatPatchGeometry, bb as EdgesGeometry, d5 as SphereGeometry, d6 as ConeGeometry, b6 as comparisonHeatDepthTest, b7 as comparisonHeatEdgeOpacity, b8 as comparisonHeatPatchOpacity, cC as comparisonCandidateContextOpacity, d7 as DEFAULT_COMPARISON_CANDIDATE_OPACITY } from "../backendInit-DbTkQN9J.js";
+import { m as mergeViewportRenderSceneStates, v as validateJointOverrides, b as buildBaseJointValues, p as parseRenderSceneCliSpec, g as getSceneObjectTreePath } from "../jointPose-AMvCywzS.js";
 const CAD_MATERIAL_PROPS = {
   color: 6003669,
   metalness: 0.05,
@@ -1464,6 +1464,79 @@ function analyzeThicknessGeometry(sourceGeometry, rawOptions = {}, context = {})
     warnings
   };
 }
+const DEFAULT_ROUGHNESS_INSPECTION_OPTIONS = {
+  smoothAngleDeg: 5,
+  sharpAngleDeg: 30,
+  harshAngleDeg: 90,
+  maxSamplesPerObject: 5e3
+};
+const ROUGHNESS_COLORS = {
+  smooth: [62, 72, 84],
+  moderate: [255, 214, 0],
+  sharp: [255, 124, 34],
+  harsh: [255, 42, 96]
+};
+function resolveRoughnessInspectionOptions(raw = {}) {
+  const options = {
+    smoothAngleDeg: raw.smoothAngleDeg ?? DEFAULT_ROUGHNESS_INSPECTION_OPTIONS.smoothAngleDeg,
+    sharpAngleDeg: raw.sharpAngleDeg ?? DEFAULT_ROUGHNESS_INSPECTION_OPTIONS.sharpAngleDeg,
+    harshAngleDeg: raw.harshAngleDeg ?? DEFAULT_ROUGHNESS_INSPECTION_OPTIONS.harshAngleDeg,
+    maxSamplesPerObject: raw.maxSamplesPerObject ?? DEFAULT_ROUGHNESS_INSPECTION_OPTIONS.maxSamplesPerObject
+  };
+  if (!Number.isFinite(options.smoothAngleDeg) || options.smoothAngleDeg < 0) {
+    throw new Error(`smoothAngleDeg must be a finite non-negative angle (got ${options.smoothAngleDeg}).`);
+  }
+  if (!Number.isFinite(options.sharpAngleDeg) || options.sharpAngleDeg <= options.smoothAngleDeg) {
+    throw new Error(`sharpAngleDeg must be greater than smoothAngleDeg (got ${options.sharpAngleDeg}).`);
+  }
+  if (!Number.isFinite(options.harshAngleDeg) || options.harshAngleDeg <= options.sharpAngleDeg || options.harshAngleDeg > 180) {
+    throw new Error(`harshAngleDeg must be greater than sharpAngleDeg and <= 180 (got ${options.harshAngleDeg}).`);
+  }
+  if (!Number.isFinite(options.maxSamplesPerObject) || options.maxSamplesPerObject <= 0) {
+    throw new Error(`maxSamplesPerObject must be a positive finite number (got ${options.maxSamplesPerObject}).`);
+  }
+  return {
+    ...options,
+    maxSamplesPerObject: Math.max(1, Math.floor(options.maxSamplesPerObject))
+  };
+}
+function roughnessClassForAngle(angleDeg, options) {
+  if (angleDeg >= options.harshAngleDeg) return "harsh";
+  if (angleDeg >= options.sharpAngleDeg) return "sharp";
+  if (angleDeg >= options.smoothAngleDeg) return "moderate";
+  return "smooth";
+}
+function roughnessScoreForAngle(angleDeg, options) {
+  if (angleDeg < options.sharpAngleDeg) return 0;
+  if (angleDeg < options.harshAngleDeg) {
+    return MathUtils.lerp(0.48, 0.82, (angleDeg - options.sharpAngleDeg) / (options.harshAngleDeg - options.sharpAngleDeg));
+  }
+  return 1;
+}
+function roughnessColorForAngle(angleDeg, options) {
+  const cls = roughnessClassForAngle(angleDeg, options);
+  if (cls === "smooth" || cls === "harsh") return ROUGHNESS_COLORS[cls];
+  if (cls === "moderate") {
+    return lerpRgb(
+      ROUGHNESS_COLORS.moderate,
+      ROUGHNESS_COLORS.sharp,
+      (angleDeg - options.smoothAngleDeg) / (options.sharpAngleDeg - options.smoothAngleDeg)
+    );
+  }
+  return lerpRgb(
+    ROUGHNESS_COLORS.sharp,
+    ROUGHNESS_COLORS.harsh,
+    (angleDeg - options.sharpAngleDeg) / (options.harshAngleDeg - options.sharpAngleDeg)
+  );
+}
+function lerpRgb(a, b, t) {
+  const clamped = MathUtils.clamp(t, 0, 1);
+  return [
+    Math.round(MathUtils.lerp(a[0], b[0], clamped)),
+    Math.round(MathUtils.lerp(a[1], b[1], clamped)),
+    Math.round(MathUtils.lerp(a[2], b[2], clamped))
+  ];
+}
 function emptyRoughnessSummary() {
   return {
     triangleCount: 0,
@@ -3602,7 +3675,7 @@ function bboxFromGeometry(geometry) {
     max: bbox ? [bbox.max.x, bbox.max.y, bbox.max.z] : [0, 0, 0]
   };
 }
-function pointBuffersFromSamples(samples, offset = 0.025) {
+function pointBuffersFromSamples(samples, colorScale, offset = 0.025) {
   const positions = new Float32Array(samples.length * 3);
   const colors = new Float32Array(samples.length * 3);
   samples.forEach((sample, index) => {
@@ -3610,9 +3683,16 @@ function pointBuffersFromSamples(samples, offset = 0.025) {
     positions[base] = sample.position[0] + sample.normal[0] * offset;
     positions[base + 1] = sample.position[1] + sample.normal[1] * offset;
     positions[base + 2] = sample.position[2] + sample.normal[2] * offset;
-    colors[base] = sample.color[0] / 255;
-    colors[base + 1] = sample.color[1] / 255;
-    colors[base + 2] = sample.color[2] / 255;
+    if (colorScale && sample.value != null && Number.isFinite(sample.value)) {
+      const [r, g, b] = sampleColorScale(colorScale, sample.value);
+      colors[base] = r / 255;
+      colors[base + 1] = g / 255;
+      colors[base + 2] = b / 255;
+    } else {
+      colors[base] = sample.color[0] / 255;
+      colors[base + 1] = sample.color[1] / 255;
+      colors[base + 2] = sample.color[2] / 255;
+    }
   });
   return { positions, colors };
 }
@@ -3680,6 +3760,11 @@ function getSessionThicknessInspection(session, rawOptions) {
   const byId = new Map(session.objects.map((obj) => [obj.id, obj]));
   const warnings = [];
   maybePushSceneSampleBudgetWarning(warnings, "Thickness", sampleBudget);
+  const thicknessColorScale = {
+    colormap: DEFAULT_THICKNESS_COLOR_SCALE.colormap,
+    domainMin: options.colorMinThickness,
+    domainMax: options.colorMaxThickness
+  };
   const objects = [];
   const cloudObjects = [];
   const points = [];
@@ -3727,7 +3812,7 @@ function getSessionThicknessInspection(session, rawOptions) {
         ...sample
       });
     });
-    overlays.push({ renderable, ...pointBuffersFromSamples(analysis.pointSamples) });
+    overlays.push({ renderable, ...pointBuffersFromSamples(analysis.pointSamples, thicknessColorScale) });
     analysis.geometry.dispose();
   });
   const state = {
@@ -3750,7 +3835,10 @@ function getSessionThicknessInspection(session, rawOptions) {
       objects,
       warnings,
       style: {
+        // gradientColors is the legacy 'thickness-classic' rainbow, kept for
+        // back-compat. colorScale is the truth the viewport/CLI now render with.
         gradientColors: THICKNESS_GRADIENT_COLORS.map((color) => [...color]),
+        colorScale: thicknessColorScale,
         colorMinThickness: options.colorMinThickness,
         colorMaxThickness: options.colorMaxThickness,
         unknownColor: THICKNESS_COLORS.unknown
@@ -3783,8 +3871,22 @@ function getSessionRoughnessInspection(session, rawOptions) {
   const cloudObjects = [];
   const points = [];
   const overlays = [];
-  session.renderables.forEach((renderable, index) => {
+  let roughnessMin = Infinity;
+  let roughnessMax = -Infinity;
+  const analysesByIndex = [];
+  session.renderables.forEach((renderable) => {
     const analysis = analyzeRoughnessGeometry(renderable.solid.geometry, options);
+    analysesByIndex.push(analysis);
+    for (const sample of analysis.pointSamples) {
+      if (sample.value != null && Number.isFinite(sample.value)) {
+        if (sample.value < roughnessMin) roughnessMin = sample.value;
+        if (sample.value > roughnessMax) roughnessMax = sample.value;
+      }
+    }
+  });
+  const roughnessColorScale = Number.isFinite(roughnessMin) && roughnessMax > roughnessMin ? { colormap: DEFAULT_ROUGHNESS_COLOR_SCALE.colormap, domainMin: roughnessMin, domainMax: roughnessMax } : DEFAULT_ROUGHNESS_COLOR_SCALE;
+  session.renderables.forEach((renderable, index) => {
+    const analysis = analysesByIndex[index];
     const bbox = bboxFromGeometry(analysis.geometry);
     const sourceObject = byId.get(renderable.id);
     if (analysis.warnings.length > 0) {
@@ -3819,7 +3921,7 @@ function getSessionRoughnessInspection(session, rawOptions) {
         ...sample
       });
     });
-    overlays.push({ renderable, ...pointBuffersFromSamples(analysis.pointSamples) });
+    overlays.push({ renderable, ...pointBuffersFromSamples(analysis.pointSamples, roughnessColorScale) });
     analysis.geometry.dispose();
   });
   const state = {
@@ -3842,6 +3944,9 @@ function getSessionRoughnessInspection(session, rawOptions) {
       objects,
       warnings,
       style: {
+        // Legacy class colors kept for back-compat; colorScale is the truth the
+        // viewport/CLI now render with (continuous viridis over the data domain).
+        colorScale: roughnessColorScale,
         smoothColor: ROUGHNESS_COLORS.smooth,
         moderateColor: ROUGHNESS_COLORS.moderate,
         sharpColor: ROUGHNESS_COLORS.sharp,

package/dist/assets/{constructionHistoryWorker-CZ42Dksy.js → constructionHistoryWorker-PCwXrTDB.js}

@@ -11427,6 +11427,65 @@ function basisFuns(span, u2, degree, knots) {
   }
   return N;
 }
+function basisFunsDeriv(span, u2, degree, knots, nDeriv) {
+  const ndu = Array.from({ length: degree + 1 }, () => new Array(degree + 1).fill(0));
+  const a2 = Array.from({ length: 2 }, () => new Array(degree + 1).fill(0));
+  const left = new Array(degree + 1);
+  const right = new Array(degree + 1);
+  ndu[0][0] = 1;
+  for (let j = 1; j <= degree; j++) {
+    left[j] = u2 - knots[span + 1 - j];
+    right[j] = knots[span + j] - u2;
+    let saved = 0;
+    for (let r2 = 0; r2 < j; r2++) {
+      ndu[j][r2] = right[r2 + 1] + left[j - r2];
+      const temp = ndu[j][r2] === 0 ? 0 : ndu[r2][j - 1] / ndu[j][r2];
+      ndu[r2][j] = saved + right[r2 + 1] * temp;
+      saved = left[j - r2] * temp;
+    }
+    ndu[j][j] = saved;
+  }
+  const ders = Array.from({ length: nDeriv + 1 }, () => new Array(degree + 1).fill(0));
+  for (let j = 0; j <= degree; j++) {
+    ders[0][j] = ndu[j][degree];
+  }
+  for (let r2 = 0; r2 <= degree; r2++) {
+    let s1 = 0;
+    let s2 = 1;
+    a2[0][0] = 1;
+    for (let k2 = 1; k2 <= nDeriv; k2++) {
+      let d2 = 0;
+      const rk = r2 - k2;
+      const pk = degree - k2;
+      if (r2 >= k2) {
+        a2[s2][0] = ndu[pk + 1][rk] === 0 ? 0 : a2[s1][0] / ndu[pk + 1][rk];
+        d2 = a2[s2][0] * ndu[rk][pk];
+      }
+      const j1 = rk >= -1 ? 1 : -rk;
+      const j2 = r2 - 1 <= pk ? k2 - 1 : degree - r2;
+      for (let j = j1; j <= j2; j++) {
+        a2[s2][j] = ndu[pk + 1][rk + j] === 0 ? 0 : (a2[s1][j] - a2[s1][j - 1]) / ndu[pk + 1][rk + j];
+        d2 += a2[s2][j] * ndu[rk + j][pk];
+      }
+      if (r2 <= pk) {
+        a2[s2][k2] = ndu[pk + 1][r2] === 0 ? 0 : -a2[s1][k2 - 1] / ndu[pk + 1][r2];
+        d2 += a2[s2][k2] * ndu[r2][pk];
+      }
+      ders[k2][r2] = d2;
+      const tmp = s1;
+      s1 = s2;
+      s2 = tmp;
+    }
+  }
+  let r = degree;
+  for (let k2 = 1; k2 <= nDeriv; k2++) {
+    for (let j = 0; j <= degree; j++) {
+      ders[k2][j] *= r;
+    }
+    r *= degree - k2;
+  }
+  return ders;
+}
 function deBoor3D(controlPoints, weights, knots, degree, u2) {
   const n = controlPoints.length;
   const span = findSpan(n, degree, u2, knots);
@@ -16863,7 +16922,7 @@ async function initTruckGeometryWasm() {
   if (_initPromise$1) return _initPromise$1;
   _initPromise$1 = (async () => {
     try {
-      const geometryModule = await import("./forgecad_geometry-BlMtqluF.js");
+      const geometryModule = await import("./forgecad_geometry-CZ_IfuvA.js");
       const isNode = isNodeRuntime();
       if (isNode) {
         const { readFileSync, existsSync } = await import("./__vite-browser-external-Dhvy_jtL.js");
@@ -17328,23 +17387,62 @@ class NurbsSurface {
     return [wx / wSum, wy / wSum, wz / wSum];
   }
   /**
-   * Evaluate the surface normal at (u, v) via cross product of partial derivatives.
+   * Evaluate the surface unit normal at (u, v) from analytic first derivatives.
+   *
+   * Uses Algorithm A2.3 basis-function derivatives with the rational quotient
+   * rule, so the normal is exact (no finite-difference epsilon, no error near
+   * the boundary). Constant chain-rule factors from the parameter remap scale Su
+   * and Sv positively and cancel under normalization, so they are omitted.
    */
   normalAt(u2, v) {
-    const eps = 1e-5;
-    const u0 = Math.max(0, u2 - eps), u1 = Math.min(1, u2 + eps);
-    const v0 = Math.max(0, v - eps), v1 = Math.min(1, v + eps);
-    const pu = this.pointAt(u1, v), pmu = this.pointAt(u0, v);
-    const pv = this.pointAt(u2, v1), pmv = this.pointAt(u2, v0);
-    const du = [pu[0] - pmu[0], pu[1] - pmu[1], pu[2] - pmu[2]];
-    const dv = [pv[0] - pmv[0], pv[1] - pmv[1], pv[2] - pmv[2]];
-    const nx = du[1] * dv[2] - du[2] * dv[1];
-    const ny = du[2] * dv[0] - du[0] * dv[2];
-    const nz = du[0] * dv[1] - du[1] * dv[0];
+    const { Su, Sv } = this.derivativesAt(u2, v);
+    const nx = Su[1] * Sv[2] - Su[2] * Sv[1];
+    const ny = Su[2] * Sv[0] - Su[0] * Sv[2];
+    const nz = Su[0] * Sv[1] - Su[1] * Sv[0];
     const len = Math.sqrt(nx * nx + ny * ny + nz * nz);
     if (len < 1e-12) return [0, 0, 1];
     return [nx / len, ny / len, nz / len];
   }
+  /** Analytic first partial derivatives S_u, S_v (rational quotient rule). */
+  derivativesAt(u2, v) {
+    const uu = this.remapU(Math.max(0, Math.min(1, u2)));
+    const vv = this.remapV(Math.max(0, Math.min(1, v)));
+    const spanU = findSpan(this.nU, this.degreeU, uu, this.knotsU);
+    const spanV = findSpan(this.nV, this.degreeV, vv, this.knotsV);
+    const dU = basisFunsDeriv(spanU, uu, this.degreeU, this.knotsU, 1);
+    const dV = basisFunsDeriv(spanV, vv, this.degreeV, this.knotsV, 1);
+    const A = [0, 0, 0];
+    const Au = [0, 0, 0];
+    const Av = [0, 0, 0];
+    let w2 = 0;
+    let wu = 0;
+    let wv = 0;
+    for (let i = 0; i <= this.degreeU; i++) {
+      const rowIdx = spanU - this.degreeU + i;
+      for (let j = 0; j <= this.degreeV; j++) {
+        const colIdx = spanV - this.degreeV + j;
+        const weight = this.weightsGrid[rowIdx][colIdx];
+        const pt = this.controlGrid[rowIdx][colIdx];
+        const n00 = dU[0][i] * dV[0][j] * weight;
+        const n10 = dU[1][i] * dV[0][j] * weight;
+        const n01 = dU[0][i] * dV[1][j] * weight;
+        w2 += n00;
+        wu += n10;
+        wv += n01;
+        for (let c2 = 0; c2 < 3; c2++) {
+          A[c2] += n00 * pt[c2];
+          Au[c2] += n10 * pt[c2];
+          Av[c2] += n01 * pt[c2];
+        }
+      }
+    }
+    if (w2 === 0) return { S: [0, 0, 0], Su: [0, 0, 0], Sv: [0, 0, 0] };
+    const invW = 1 / w2;
+    const S = [A[0] * invW, A[1] * invW, A[2] * invW];
+    const Su = [(Au[0] - wu * S[0]) * invW, (Au[1] - wu * S[1]) * invW, (Au[2] - wu * S[2]) * invW];
+    const Sv = [(Av[0] - wv * S[0]) * invW, (Av[1] - wv * S[1]) * invW, (Av[2] - wv * S[2]) * invW];
+    return { S, Su, Sv };
+  }
   /**
    * Tessellate the surface into a triangle mesh.
    * Returns positions, normals, and triangle indices.
@@ -19656,6 +19754,20 @@ function fromSlicesSingleSliceHalfExtentForManifold(plan) {
   }
   return Math.max(1, radius + maxOffsetMagnitude + plan.boundsPadding + plan.edgeLength * 3);
 }
+const BOOLEAN_OPERAND_NORMAL_SHARP_ANGLE_DEG = 60;
+function promoteBooleanOperandNormals(shapes) {
+  let maxExtra = 0;
+  for (const shape of shapes) maxExtra = Math.max(maxExtra, shape.numProp());
+  if (maxExtra < 3) return { operands: shapes, created: [] };
+  const created = [];
+  const operands = shapes.map((shape) => {
+    if (shape.numProp() >= 3) return shape;
+    const promoted = shape.calculateNormals(0, BOOLEAN_OPERAND_NORMAL_SHARP_ANGLE_DEG);
+    created.push(promoted);
+    return promoted;
+  });
+  return { operands, created };
+}
 function lowerShapeBooleanCompilePlan(plan, wasm) {
   const shapes = plan.shapes.map((shape) => lowerShapeCompilePlanToManifold(shape, wasm));
   if (shapes.length === 0) {
@@ -19664,16 +19776,18 @@ function lowerShapeBooleanCompilePlan(plan, wasm) {
   if (shapes.length === 1) {
     return shapes[0];
   }
+  const { operands, created } = promoteBooleanOperandNormals(shapes);
   try {
     switch (plan.op) {
       case "union":
-        return wasm.Manifold.union(shapes);
+        return wasm.Manifold.union(operands);
       case "difference":
-        return wasm.Manifold.difference(shapes);
+        return wasm.Manifold.difference(operands);
       case "intersection":
-        return wasm.Manifold.intersection(shapes);
+        return wasm.Manifold.intersection(operands);
     }
   } finally {
+    disposeWasmObjects(created);
     disposeWasmObjects(shapes);
   }
 }
@@ -21023,12 +21137,16 @@ function lowerNurbsSurfaceToManifold(plan, wasm) {
   const { positions, normals, indices } = surface.tessellate(res, res);
   const thickness = plan.thickness;
   const numVerts = positions.length;
-  const allPositions = [];
-  for (const [x2, y2, z2] of positions) allPositions.push(x2, y2, z2);
+  const vertProps = [];
   for (let i = 0; i < numVerts; i++) {
     const [x2, y2, z2] = positions[i];
     const [nx, ny, nz] = normals[i];
-    allPositions.push(x2 - nx * thickness, y2 - ny * thickness, z2 - nz * thickness);
+    vertProps.push(x2, y2, z2, nx, ny, nz);
+  }
+  for (let i = 0; i < numVerts; i++) {
+    const [x2, y2, z2] = positions[i];
+    const [nx, ny, nz] = normals[i];
+    vertProps.push(x2 - nx * thickness, y2 - ny * thickness, z2 - nz * thickness, -nx, -ny, -nz);
   }
   const allIndices = [];
   for (const idx of indices) allIndices.push(idx);
@@ -21053,11 +21171,12 @@ function lowerNurbsSurfaceToManifold(plan, wasm) {
     allIndices.push(c2, c2 + numVerts, d2, d2, c2 + numVerts, d2 + numVerts);
   }
   const mesh = new wasm.Mesh({
-    numProp: 3,
-    vertProperties: new Float32Array(allPositions),
+    numProp: 6,
+    vertProperties: new Float32Array(vertProps),
     triVerts: new Uint32Array(allIndices)
   });
   try {
+    mesh.merge();
     return new wasm.Manifold(mesh);
   } finally {
     disposeWasmObject(mesh);
@@ -37485,6 +37604,7 @@ const _TruckShapeBackend = class _TruckShapeBackend {
     const payload = JSON.parse(getTruckGeometryWasm().geometry_mesh(this.getLiveHandle("getMesh()")));
     const numTri = payload.triangles.length / 3;
     const numVert = payload.positions.length / 3;
+    const cornerNormals = payload.normals && payload.normals.length === numTri * 9 ? new Float32Array(payload.normals) : void 0;
     this.resource.mesh = {
       numProp: 3,
       numTri,
@@ -37498,7 +37618,8 @@ const _TruckShapeBackend = class _TruckShapeBackend {
       runTransform: new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0]),
       faceID: new Int32Array(payload.face_ids),
       faceIdNames: payload.face_id_names ?? [],
-      halfedgeTangent: new Float32Array(0)
+      halfedgeTangent: new Float32Array(0),
+      cornerNormals
     };
     return this.resource.mesh;
   }
@@ -38719,6 +38840,16 @@ function boundsInteriorOverlap(a2, b) {
   const tolerance = 1e-8;
   return Math.min(a2.max[0], b.max[0]) - Math.max(a2.min[0], b.min[0]) > tolerance && Math.min(a2.max[1], b.max[1]) - Math.max(a2.min[1], b.min[1]) > tolerance && Math.min(a2.max[2], b.max[2]) - Math.max(a2.min[2], b.min[2]) > tolerance;
 }
+function boundsFaceOrInteriorOverlap(a2, b) {
+  const tolerance = 1e-8;
+  const overlaps = [
+    Math.min(a2.max[0], b.max[0]) - Math.max(a2.min[0], b.min[0]),
+    Math.min(a2.max[1], b.max[1]) - Math.max(a2.min[1], b.min[1]),
+    Math.min(a2.max[2], b.max[2]) - Math.max(a2.min[2], b.min[2])
+  ];
+  if (overlaps.some((overlap) => overlap < -tolerance)) return false;
+  return overlaps.filter((overlap) => overlap <= tolerance).length <= 1;
+}
 function boundsFromPoints(points) {
   const first = points[0];
   if (!first) return null;
@@ -38801,16 +38932,16 @@ function shapePlanBounds(plan) {
       return null;
   }
 }
-function hasPairwiseInteriorBoundsOverlap(shapes) {
+function hasPairwiseFaceOrInteriorBoundsOverlap(shapes) {
   const bounds = shapes.map((shape) => shape.boundingBox());
   for (let i = 0; i < bounds.length; i++) {
     for (let j = i + 1; j < bounds.length; j++) {
-      if (boundsInteriorOverlap(bounds[i], bounds[j])) return true;
+      if (boundsFaceOrInteriorOverlap(bounds[i], bounds[j])) return true;
     }
   }
   return false;
 }
-function interiorOverlapComponents(shapes) {
+function faceOrInteriorOverlapComponents(shapes) {
   const bounds = shapes.map((shape) => shape.boundingBox());
   const visited = /* @__PURE__ */ new Set();
   const components = [];
@@ -38824,7 +38955,7 @@ function interiorOverlapComponents(shapes) {
       component.push(current);
       for (let next = 0; next < shapes.length; next++) {
         if (visited.has(next)) continue;
-        if (boundsInteriorOverlap(bounds[current], bounds[next])) {
+        if (boundsFaceOrInteriorOverlap(bounds[current], bounds[next])) {
           visited.add(next);
           queue.push(next);
         }
@@ -38869,10 +39000,10 @@ function lowerGenericBooleanPlan(plan) {
   let returned = null;
   try {
     if (plan.op === "union") {
-      if (!hasPairwiseInteriorBoundsOverlap(shapes)) {
+      if (!hasPairwiseFaceOrInteriorBoundsOverlap(shapes)) {
         return null;
       }
-      const components = interiorOverlapComponents(shapes);
+      const components = faceOrInteriorOverlapComponents(shapes);
       if (components.length > 1) {
         returned = lowerClusteredUnion(shapes, components);
         return returned;
@@ -39402,9 +39533,13 @@ function shapeHasClosedNativeTopology(shape) {
 function normalizeTruckShapeForBooleanInput(shape) {
   if (shapeHasClosedNativeTopology(shape)) return shape;
   if (!meshHasRawBoundaryEdges(shape.getMesh())) return shape;
-  const normalized = normalizeFacetedTruckShape(shape);
-  disposeShapeBackend(shape);
-  return normalized;
+  try {
+    const normalized = normalizeFacetedTruckShape(shape);
+    disposeShapeBackend(shape);
+    return normalized;
+  } catch {
+    return shape;
+  }
 }
 function lowerSdfPlan(plan) {
   if (getUnsupportedSdfProgramReason(plan.tree) === void 0) {
@@ -41288,7 +41423,7 @@ function circleProfilePlan(radius, segments) {
 }
 function annulusProfilePlan(outerRadius, innerRadius, segments) {
   const outer = Math.abs(outerRadius);
-  const inner = Math.abs(innerRadius);
+  const inner = Math.max(0, innerRadius);
   if (outer <= EXACT_PROFILE_EPS) return emptyProfilePlan();
   if (inner <= EXACT_PROFILE_EPS) return circleProfilePlan(outer, segments);
   return {
@@ -49960,7 +50095,7 @@ class Shape {
    *
    * Use `.color()` to set the base diffuse color; `.material()` controls how that color behaves
    * under light (metalness, roughness, clearcoat) and can add emissive glow independent of
-   * lighting. Emissive glow pairs naturally with the `postProcessing.bloom` effect in `scene()`.
+   * lighting.
    *
    * **Example**
    *
@@ -51493,7 +51628,8 @@ class FrozenShape extends Shape {
 const EDGE_THRESHOLD_DOT = Math.cos(Math.PI / 180);
 const SMOOTH_THRESHOLD_DOT = Math.cos(30 * Math.PI / 180);
 function computeGeometryArrays(mesh, options = {}) {
-  const { numProp, numTri: triCount, triVerts, vertProperties, vertNormals } = mesh;
+  const { numProp, numTri: triCount, triVerts, vertProperties, vertNormals, cornerNormals } = mesh;
+  const useCornerNormals = !!cornerNormals && cornerNormals.length === triCount * 9;
   const positions = new Float32Array(triCount * 9);
   const normals = new Float32Array(triCount * 9);
   const faceNx = new Float32Array(triCount);
@@ -51525,7 +51661,9 @@ function computeGeometryArrays(mesh, options = {}) {
     positions[o + 6] = cx;
     positions[o + 7] = cy;
     positions[o + 8] = cz;
-    if (vertNormals) {
+    if (useCornerNormals) {
+      for (let k2 = 0; k2 < 9; k2++) normals[o + k2] = cornerNormals[o + k2];
+    } else if (vertNormals) {
       normals[o] = vertNormals[i0 * 3];
       normals[o + 1] = vertNormals[i0 * 3 + 1];
       normals[o + 2] = vertNormals[i0 * 3 + 2];
@@ -51568,7 +51706,7 @@ function computeGeometryArrays(mesh, options = {}) {
     faceNy[t] = fny;
     faceNz[t] = fnz;
   }
-  if (!vertNormals && numProp < 6 && triCount > 0) {
+  if (!useCornerNormals && !vertNormals && numProp < 6 && triCount > 0) {
     computeAutoSmoothNormals(
       triVerts,
       vertProperties,
@@ -51755,7 +51893,8 @@ function shapeToGeometryFallback(shape) {
     vertProperties: mesh.vertProperties,
     mergeFromVert: mesh.mergeFromVert,
     mergeToVert: mesh.mergeToVert,
-    vertNormals
+    vertNormals,
+    cornerNormals: mesh.cornerNormals && mesh.cornerNormals.length === mesh.numTri * 9 ? mesh.cornerNormals : void 0
   });
   const solid = new BufferGeometry();
   solid.setAttribute("position", new BufferAttribute(positions, 3));