three-cad-viewer 5.0.6 → 5.0.7

package/dist/rendering/id-picking.d.ts

@@ -25,7 +25,10 @@ export declare const BACKGROUND_ID = 0;
  * `Uint32BufferAttribute` under this name; the pick pass reads it as an **integer**
  * attribute (`gpuType = THREE.IntType`, GLSL3 `in uint`) so ids stay exact past
  * 2^24. The geometry side must set `gpuType = THREE.IntType` on the attribute for
- * the pick shader to read it.
+ * the pick shader to read it. Between the stages the id travels as two float
+ * varyings (16-bit halves), deliberately NOT as a `flat uint` — see the note in
+ * highlight.ts: a `flat` varying costs ~25x the scene's buffer bytes in graphics
+ * memory under WebKit's ANGLE-on-Metal backend.
  */
 export declare const COMPONENT_ID_ATTRIBUTE = "componentId";
 /**

package/dist/three-cad-viewer.esm.js

@@ -83999,7 +83999,10 @@ const BACKGROUND_ID = 0;
  * `Uint32BufferAttribute` under this name; the pick pass reads it as an **integer**
  * attribute (`gpuType = THREE.IntType`, GLSL3 `in uint`) so ids stay exact past
  * 2^24. The geometry side must set `gpuType = THREE.IntType` on the attribute for
- * the pick shader to read it.
+ * the pick shader to read it. Between the stages the id travels as two float
+ * varyings (16-bit halves), deliberately NOT as a `flat uint` — see the note in
+ * highlight.ts: a `flat` varying costs ~25x the scene's buffer bytes in graphics
+ * memory under WebKit's ANGLE-on-Metal backend.
  */
 const COMPONENT_ID_ATTRIBUTE = "componentId";
 /**
@@ -84297,8 +84300,9 @@ const VERTEX_DEPTH_BIAS_FACTOR = 2e-4;
  */
 const PICK_POINT_SIZE = 3;
 /**
- * Shared GLSL3 MRT fragment shader for all pick materials (face/vertex/edge): packs
- * the flat `vId` into attachment 0 (byte order MUST match `packId()`: low byte in R)
+ * Shared GLSL3 MRT fragment shader for all pick materials (face/vertex/edge):
+ * reassembles the id from its two interpolated halves and packs it into attachment 0
+ * (byte order MUST match `packId()`: low byte in R)
  * and writes the interpolated world position into attachment 1 (RGBA32F; `w=1` marks
  * "has position"). The fragment clip chunk only `discard`s (non-ALPHA_TO_COVERAGE),
  * so no `diffuseColor` symbol is required.
@@ -84306,13 +84310,15 @@ const PICK_POINT_SIZE = 3;
 const PICK_FRAGMENT_SHADER = /* glsl */ `
   #include <clipping_planes_pars_fragment>
 
-  flat in uint vId;
+  in float vIdLo;
+  in float vIdHi;
   in vec3 vWorldPos;
   layout(location = 0) out vec4 fragId;
   layout(location = 1) out vec4 fragPos;
 
   void main() {
     #include <clipping_planes_fragment>
+    uint vId = ( uint( vIdHi + 0.5 ) << 16 ) | uint( vIdLo + 0.5 );
     fragId = vec4(
       float( vId & 0xFFu ) / 255.0,
       float( ( vId >> 8 ) & 0xFFu ) / 255.0,
@@ -84330,19 +84336,24 @@ const PICK_FRAGMENT_SHADER = /* glsl */ `
 function createFacePickMaterial(options = {}) {
     // GLSL3 (WebGL2). For a (non-Raw) ShaderMaterial three.js auto-injects
     // `in vec3 position;`, `uniform mat4 modelMatrix/modelViewMatrix/projectionMatrix`,
-    // so we declare ONLY the custom integer attribute + flat varying. Integer
-    // varyings MUST be `flat`. Clip chunks use legacy `varying`/`attribute` keywords
+    // so we declare ONLY the custom integer attribute + the two id-half varyings
+    // (float, interpolated — an integer varying would have to be `flat`, which is
+    // the ANGLE-on-Metal memory trap described in highlight.ts; all vertices of a
+    // primitive carry the same id, so interpolation + rounding is exact). Clip
+    // chunks use legacy `varying`/`attribute` keywords
     // which three remaps via `#define` under GLSL3; the vertex chunk reads a local
     // `vec4 mvPosition`, which we compute before the include.
     const vertexShader = /* glsl */ `
     #include <clipping_planes_pars_vertex>
 
     in uint componentId;
-    flat out uint vId;
+    out float vIdLo;
+    out float vIdHi;
     out vec3 vWorldPos;
 
     void main() {
-      vId = componentId;
+      vIdLo = float( componentId & 0xFFFFu );
+      vIdHi = float( componentId >> 16 );
       vec4 worldPos = modelMatrix * vec4( position, 1.0 );
       vWorldPos = worldPos.xyz;
       vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );
@@ -84381,13 +84392,15 @@ function createVertexPickMaterial(options = {}) {
     #include <clipping_planes_pars_vertex>
 
     in uint componentId;
-    flat out uint vId;
+    out float vIdLo;
+    out float vIdHi;
     out vec3 vWorldPos;
     uniform float uPickSize;
     uniform float uDepthBias;
 
     void main() {
-      vId = componentId;
+      vIdLo = float( componentId & 0xFFFFu );
+      vIdHi = float( componentId >> 16 );
       vec4 worldPos = modelMatrix * vec4( position, 1.0 );
       vWorldPos = worldPos.xyz;
       vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );
@@ -84447,7 +84460,8 @@ function createEdgePickMaterial(options = {}) {
     in vec3 instanceEnd;
     in uint componentId;
 
-    flat out uint vId;
+    out float vIdLo;
+    out float vIdHi;
     out vec3 vWorldPos;
 
     void trimSegment( const in vec4 start, inout vec4 end ) {
@@ -84459,7 +84473,8 @@ function createEdgePickMaterial(options = {}) {
     }
 
     void main() {
-      vId = componentId;
+      vIdLo = float( componentId & 0xFFFFu );
+      vIdHi = float( componentId >> 16 );
 
       // World-space segment endpoints → approximate hit point along the edge.
       vWorldPos = ( position.y < 0.5 )
@@ -84997,20 +85012,41 @@ const U_HIGHLIGHT_HOVER_COLOR = "uHighlightHoverColor";
 //
 // three upgrades stock materials to GLSL ES 3.00 on WebGL2 via `#define attribute
 // in` / `#define varying out|in` macros (WebGLProgram.js), so writing `attribute` /
-// `flat varying` here is converted automatically; `usampler2D` / `texelFetch` /
+// `varying` here is converted automatically; `usampler2D` / `texelFetch` /
 // integer attributes are then available.
+//
+// The component id crosses to the fragment stage as TWO ordinary (interpolated)
+// float varyings holding its 16-bit halves — NOT as a `flat uint`. A `flat`
+// varying is what an integer varying would require, and it is exactly what must
+// be avoided here: under WebKit's ANGLE-on-Metal backend, every draw whose
+// program has a `flat` varying makes ANGLE allocate a converted copy of the
+// draw's index data (>= 64 KB each, pooled, never returned to the GL on
+// deleteBuffer). With this varying on every visible material that was ~25x the
+// scene's vertex/index bytes in graphics memory (26 MB of buffers -> 812 MB;
+// 100 MB -> 2.3 GB) and it is charged to the page's WebContent process in the
+// system WebKit, which killed build123d Studio at 16 GB after a few large
+// shows. Without `flat` the same scene takes 63 MB / 160 MB. Measured 2026-09-17
+// (working-docs/leak-harness.html + probe2.html, Playwright WebKit and Safari).
+//
+// Interpolating floats is exact for the id's purpose: every vertex of a face,
+// every vertex of an instanced segment and a point carry the SAME id, so the
+// interpolated value equals it up to rounding, and `uint(x + 0.5)` recovers it.
+// Two 16-bit halves (both < 65536, exactly representable in float32) keep the
+// full 32-bit id range that `applyComponentIds` promises.
 // ---------------------------------------------------------------------------
 /**
  * Shared state-fetch GLSL, injected into BOTH stages: the vertex stage needs it for
  * widening / point size, the fragment for color. Declares the sampler + texWidth +
- * the flat varying and a helper returning the component's {@link HighlightFlag} bits
- * (0 for background / nothing).
+ * the two id-half varyings and a helper returning the component's
+ * {@link HighlightFlag} bits (0 for background / nothing).
  */
 const HL_STATE_GLSL = `
-flat varying uint vHighlightId;
+varying float vHighlightIdLo;
+varying float vHighlightIdHi;
 uniform highp usampler2D ${U_HIGHLIGHT_STATE};
 uniform int ${U_HIGHLIGHT_TEX_WIDTH};
 uint highlightState() {
+  uint vHighlightId = (uint(vHighlightIdHi + 0.5) << 16) | uint(vHighlightIdLo + 0.5);
   if (vHighlightId == 0u) return 0u;
   ivec2 hlUv = ivec2(
     int(vHighlightId) % ${U_HIGHLIGHT_TEX_WIDTH},
@@ -85025,8 +85061,8 @@ uint highlightState() {
 const HL_VERTEX_HEADER = `
 attribute uint ${COMPONENT_ID_ATTRIBUTE};
 ${HL_STATE_GLSL}`;
-/** Vertex main: forward the id. Injected right after `void main() {`. */
-const HL_VERTEX_ASSIGN = `vHighlightId = ${COMPONENT_ID_ATTRIBUTE};`;
+/** Vertex main: forward the id as two 16-bit halves. Injected right after `void main() {`. */
+const HL_VERTEX_ASSIGN = `vHighlightIdLo = float(${COMPONENT_ID_ATTRIBUTE} & 0xFFFFu); vHighlightIdHi = float(${COMPONENT_ID_ATTRIBUTE} >> 16);`;
 /** Fragment header: the shared state fetch + the two highlight colors. */
 const HL_FRAGMENT_HEADER = `
 ${HL_STATE_GLSL}
@@ -85276,7 +85312,7 @@ class HighlightController {
                 this.uniforms.uHighlightSelectedColor;
             shader.uniforms[U_HIGHLIGHT_HOVER_COLOR] =
                 this.uniforms.uHighlightHoverColor;
-            // Common: forward the component id as a flat varying.
+            // Common: forward the component id (as two interpolated float halves).
             shader.vertexShader =
                 HL_VERTEX_HEADER +
                     "\n" +
@@ -88808,7 +88844,14 @@ class Grid extends Group {
             group.name = `GridHelper-${i}`;
             group.add(new GridHelper(this.size, 2 * this.ticks, this.colors[this.theme][i === 0 ? 1 : i === 1 ? 0 : 2], this.colors[this.theme][i === 0 ? 0 : i === 1 ? 2 : 1], this.theme == "dark" ? 0x7777777 : 0xbbbbbb));
             let label;
-            for (let x = -this.size / 2; x <= this.size / 2; x += this.delta / 2) {
+            // A grid of no size has no labels, and asking for them hangs the tab:
+            // `niceBounds` answers [0, 0, 0] for a bounding box whose largest extent
+            // is zero - which is what an empty model gives it - so `delta` is zero
+            // and the loop below steps by zero, never advancing and never throwing.
+            // Guarded here rather than in `niceBounds`, whose answer is right: there
+            // is nothing to place ticks on.
+            const step = this.delta / 2;
+            for (let x = -this.size / 2; step > 0 && x <= this.size / 2; x += step) {
                 if (Math.abs(x) < 1e-6) {
                     continue;
                 } // skip center label
@@ -97350,7 +97393,7 @@ class Tools {
     }
 }
 
-const version = "5.0.6";
+const version = "5.0.7";
 
 /**
  * `PickedComponent` over a GPU id-pick result. Drives the shader
@@ -110820,6 +110863,11 @@ class Viewer {
             deepDispose(this._rendered.camera);
             deepDispose(this._rendered.controls);
             deepDispose(this._rendered.treeview);
+            // The orientation marker owns its own THREE.Scene (cones, labels, sphere,
+            // axes), not part of the main scene above, so it needs its own dispose —
+            // without it every clear()/render() cycle left 8 geometries and 3 programs
+            // behind on the GL (measured 2026-09-17, working-docs/leak-harness.html).
+            this._rendered.orientationMarker.dispose();
             // clear tree view
             this.display.clearCadTree();
             // clear info