@woosh/meep-engine 3.29.0 → 3.30.0

package/src/shade/renderer/geometry/virtual/build/mesh/vgeo_compute_vertex_normals.js

@@ -6,7 +6,6 @@ import {
     bt_face_compute_newell_normal
 } from "../../../../../../core/geom/3d/topology/struct/binary/query/bt_face_compute_newell_normal.js";
 import { VGEO_ATTRIBUTE } from "../../format/attribute/VGEO_ATTRIBUTE.js";
-import { VGEO_CREASE_ANGLE } from "./VGEO_CREASE_ANGLE.js";
 
 /**
  * One corner's normal, on its way into the format's channel.
@@ -25,18 +24,28 @@ const scratch_normal = new Float32Array(3);
 const scratch_face = new Float32Array(3);
 
 /**
- * Area-weighted normals of a mesh, split at its creases, written into its normal channel.
+ * Area-weighted normals of a mesh, written into its normal channel, one per corner.
  *
  * The geometry a mesh actually has is the answer for that mesh: carrying a surviving vertex's
  * original normal through a dozen collapses shades a coarse level by whichever vertices happened to
  * win, which is visibly wrong.
  *
- * **Per corner group, not per vertex.** Averaging every face around a vertex is right for a surface
- * and wrong for a corner. Two faces sharing an edge belong to the same group when the surface turns
- * less than {@link VGEO_CREASE_ANGLE} across it; groups are the connected components that leaves,
- * and each gets its own area-weighted average. A vertex on a smooth surface has exactly one, and
- * this is then the pass it has always been. A box corner has three, and the eight vertices of a cube
- * stop carrying a normal that is ninety degrees wrong for every face using it.
+ * **It does not invent a crease.** An earlier version of this split a vertex wherever the surface
+ * turned more than a threshold, so that a synthesized cube got three normals at each corner instead
+ * of one that is ninety degrees wrong for every face using it. That is a real improvement to look
+ * at and it did not survive measurement: against a true LOD 0 reference in pixels it bought nothing
+ * on any object tested, and on high-frequency relief it *cost*, because the attribute quadric's
+ * least-squares fit lands near the neighbourhood's mean normal -- the right filtered answer for a
+ * Lambertian surface -- and bucketing each tile face on its own returns that one face's normal
+ * exactly instead. So the threshold is gone, and with it the one number in this work that was a
+ * judgement about content rather than a consequence of arithmetic.
+ *
+ * **Corners still group, by connectivity rather than by angle.** Two corners join when a manifold
+ * edge joins their faces, so a manifold vertex has exactly one group and this is the pass it has
+ * always been, arithmetic included. What the per-corner shape is *for* is the case this pass is not
+ * reached in at all: a source that authored its own shading frame, whose distinct corner values the
+ * weld would otherwise destroy. That is where wedges are worth their bytes, and it needs no
+ * threshold to decide anything.
  *
  * Area weighting falls out of the arithmetic rather than being applied: Newell's normal *is* the
  * face normal scaled by twice the area, so summing the raw face normals is the area-weighted sum.
@@ -62,12 +71,11 @@ const scratch_face = new Float32Array(3);
  *     slot for every live corner by construction
  * @param {Set<number>} pinned vertex ids to leave exactly as they are; empty for a mesh nothing has
  *     locked yet
- * @param {number} [crease_angle] degrees; see {@link VGEO_CREASE_ANGLE}
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
-export function vgeo_compute_vertex_normals(mesh, pinned, crease_angle = VGEO_CREASE_ANGLE) {
+export function vgeo_compute_vertex_normals(mesh, pinned) {
     const normals = mesh.layers[VGEO_ATTRIBUTE.NORMAL];
 
     assert.notNull(normals, 'mesh normal channel');
@@ -84,7 +92,8 @@ export function vgeo_compute_vertex_normals(mesh, pinned, crease_angle = VGEO_CR
     const face_normal = new Float64Array(face_pool.size * 3);
 
     /**
-     * Its length, so the angle test does not recompute one.
+     * Its length, which is twice the face's area, and so zero exactly where the face has none. Only
+     * the liveness test reads it now that nothing measures an angle.
      * @type {Float64Array}
      */
     const face_length = new Float64Array(face_pool.size);
@@ -122,8 +131,6 @@ export function vgeo_compute_vertex_normals(mesh, pinned, crease_angle = VGEO_CR
         group[loop] = loop;
     }
 
-    const smooth_cosine = Math.cos((crease_angle * Math.PI) / 180);
-
     const edge_pool = topology.edges;
 
     for (let edge = 0; edge < edge_pool.size; edge++) {
@@ -163,19 +170,6 @@ export function vgeo_compute_vertex_normals(mesh, pinned, crease_angle = VGEO_CR
             continue;
         }
 
-        const left_face = topology.loop_read_face(left);
-        const right_face = topology.loop_read_face(right);
-
-        const cosine = (
-            face_normal[left_face * 3] * face_normal[right_face * 3]
-            + face_normal[left_face * 3 + 1] * face_normal[right_face * 3 + 1]
-            + face_normal[left_face * 3 + 2] * face_normal[right_face * 3 + 2]
-        ) / (face_length[left_face] * face_length[right_face]);
-
-        if (cosine < smooth_cosine) {
-            continue;
-        }
-
         /*
          A loop's edge runs from its own vertex to the next loop's, so on an edge's loop those two
          are the edge's endpoints. Matching them up by vertex is what pairs the corner of one face

package/src/shade/renderer/geometry/virtual/build/mesh/vgeo_normalize_source.d.ts

@@ -42,12 +42,10 @@
  * @param {VirtualGeometryMesh} mesh mutated in place
  * @param {number} weld_ratio fraction of the bounding-box diagonal; see
  *     {@link VGeoBuildOptions#weld_ratio}
- * @param {number} [crease_angle] degrees; see {@link VGeoBuildOptions#crease_angle}. Only reaches a
- *     channel the source did not author.
  * @returns {number} the object-space distance the ratio came to for this mesh
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
-export function vgeo_normalize_source(mesh: VirtualGeometryMesh, weld_ratio: number, crease_angle?: number): number;
+export function vgeo_normalize_source(mesh: VirtualGeometryMesh, weld_ratio: number): number;
 //# sourceMappingURL=vgeo_normalize_source.d.ts.map

package/src/shade/renderer/geometry/virtual/build/mesh/vgeo_normalize_source.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vgeo_normalize_source.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/mesh/vgeo_normalize_source.js"],"names":[],"mappings":"AAiCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,6EATW,MAAM,iBAEN,MAAM,GAEJ,MAAM,CA+ClB"}
+{"version":3,"file":"vgeo_normalize_source.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/mesh/vgeo_normalize_source.js"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,6EAPW,MAAM,GAEJ,MAAM,CA+ClB"}

package/src/shade/renderer/geometry/virtual/build/mesh/vgeo_normalize_source.js

@@ -20,7 +20,6 @@ import {
 import { bt_mesh_validate } from "../../../../../../core/geom/3d/topology/struct/binary/query/bt_mesh_validate.js";
 import { VGEO_ATTRIBUTE } from "../../format/attribute/VGEO_ATTRIBUTE.js";
 import { vgeo_mesh_wedges } from "../../format/attribute/vgeo_mesh_wedges.js";
-import { VGEO_CREASE_ANGLE } from "./VGEO_CREASE_ANGLE.js";
 import { vgeo_compute_vertex_normals } from "./vgeo_compute_vertex_normals.js";
 import { vgeo_compute_vertex_tangents } from "./vgeo_compute_vertex_tangents.js";
 
@@ -75,14 +74,12 @@ const NOTHING_PINNED = new Set();
  * @param {VirtualGeometryMesh} mesh mutated in place
  * @param {number} weld_ratio fraction of the bounding-box diagonal; see
  *     {@link VGeoBuildOptions#weld_ratio}
- * @param {number} [crease_angle] degrees; see {@link VGeoBuildOptions#crease_angle}. Only reaches a
- *     channel the source did not author.
  * @returns {number} the object-space distance the ratio came to for this mesh
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
-export function vgeo_normalize_source(mesh, weld_ratio, crease_angle = VGEO_CREASE_ANGLE) {
+export function vgeo_normalize_source(mesh, weld_ratio) {
     const topology = mesh.topology;
 
     const weld_distance = bt_mesh_relative_merge_distance(topology, weld_ratio);
@@ -110,7 +107,7 @@ export function vgeo_normalize_source(mesh, weld_ratio, crease_angle = VGEO_CREA
     // Normals first: the tangent solve reads them, and a synthesized normal beside an authored
     // tangent is still the pair the frame is built from.
     if (mesh.synthesized[VGEO_ATTRIBUTE.NORMAL]) {
-        vgeo_compute_vertex_normals(mesh, NOTHING_PINNED, crease_angle);
+        vgeo_compute_vertex_normals(mesh, NOTHING_PINNED);
     }
 
     /*

package/src/shade/renderer/geometry/virtual/build/vgeo_build.js

@@ -137,7 +137,7 @@ export async function vgeo_build(geometry, options) {
 
     const mesh = VirtualGeometryMesh.from_geometry(geometry);
 
-    const weld_distance = vgeo_normalize_source(mesh, options.weld_ratio, options.crease_angle);
+    const weld_distance = vgeo_normalize_source(mesh, options.weld_ratio);
 
     const source_face_count = mesh.topology.faces.count();
     const source_vertex_count = mesh.topology.vertices.count();

package/src/shade/renderer/geometry/virtual/runtime/VGeoResidency.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VGeoResidency.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/VGeoResidency.js"],"names":[],"mappings":"AA2GA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH;IAiKI;;;;;;;OAOG;IACH;QAN2C,IAAI,EAApC,sBAAsB;QACS,OAAO,GAAtC,oBAAoB;QACM,IAAI,GAA9B,eAAe;QACW,OAAO,GAAjC,eAAe;OA8BzB;IAID;;OAEG;IACH,oCAEC;IAED;;OAEG;IACH,4BAEC;IAED;;OAEG;IACH,+BAEC;IAED;;OAEG;IACH,yEAEC;IAED;;;;OAIG;IACH,oBAEC;IAED;;;;OAIG;IACH,gCAGC;IAED,+BAEC;IAED,iCAEC;IAED,6BAEC;IAED,2BAEC;IAED,iCAEC;IAED,gCAEC;IAED;;;;OAIG;IACH,oCAEC;IAED;;;OAGG;IACH,kCAEC;IAED;;;OAGG;IACH,kCAEC;IAED;;;OAGG;IACH,iCAEC;IAED;;;OAGG;IACH,iCAEC;IAED;;;OAGG;IACH,gCAEC;IAED;;;;;OAKG;IACH,gCAEC;IAED;;;OAGG;IACH,iCAEC;IAED,gCAEC;IAED,+BAEC;IAED,8BAEC;IAED;;OAEG;IACH,qCAQC;IAID;;;;;;;;;;OAUG;IACH,iBAHW,mBAAmB,GACjB,MAAM,CA8ClB;IAED;;;;;;OAMG;IACH,mBAHW,mBAAmB,GACjB,OAAO,CAgBnB;IAED;;;OAGG;IACH,sBAHW,mBAAmB,GACjB,OAAO,CAInB;IAED;;;;;;OAMG;IACH,cAJW,mBAAmB,cACnB,MAAM,GACJ,QAAQ,GAAC,UAAU,GAAC,aAAa,GAAC,KAAK,GAAC,MAAM,GAAC,cAAc,CAqBzE;IAgCD;;;;OAIG;IACH,SAFa,IAAI,CAOhB;IAED;;;;OAIG;IACH,WAFa,IAAI,CAUhB;IAED;;;;OAIG;IACH,qBAFa,MAAM,CAkBlB;IAID;;;;;;;;;OASG;IACH,aANW,WAAW,UACX;QAAC,eAAe,EAAE,MAAM,CAAC;QAAC,gBAAgB,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAChF,UAAgB,EAAE,MAAM,CAAA;KAAC,iBACf,MAAM,GACJ,IAAI,CA6HhB;IA2FD;;;;;;OAMG;IACH,yBAHW,MAAM,GACJ,OAAO,CAgBnB;IAED;;;;;;OAMG;IACH,oBAHW,MAAM,GACJ,OAAO,CAoCnB;;CAqXJ;kCAr1CY,OAAO,uCAAuC,EAAE,mBAAmB;uBACnE,OAAO,4BAA4B,EAAE,QAAQ;qCAC7C,OAAO,6BAA6B,EAAE,sBAAsB;qCALpC,2BAA2B;gCALhC,gDAAgD;gCAIhD,sBAAsB"}
+{"version":3,"file":"VGeoResidency.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/VGeoResidency.js"],"names":[],"mappings":"AA2GA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH;IAiKI;;;;;;;OAOG;IACH;QAN2C,IAAI,EAApC,sBAAsB;QACS,OAAO,GAAtC,oBAAoB;QACM,IAAI,GAA9B,eAAe;QACW,OAAO,GAAjC,eAAe;OA8BzB;IAID;;OAEG;IACH,oCAEC;IAED;;OAEG;IACH,4BAEC;IAED;;OAEG;IACH,+BAEC;IAED;;OAEG;IACH,yEAEC;IAED;;;;OAIG;IACH,oBAEC;IAED;;;;OAIG;IACH,gCAGC;IAED,+BAEC;IAED,iCAEC;IAED,6BAEC;IAED,2BAEC;IAED,iCAEC;IAED,gCAEC;IAED;;;;OAIG;IACH,oCAEC;IAED;;;OAGG;IACH,kCAEC;IAED;;;OAGG;IACH,kCAEC;IAED;;;OAGG;IACH,iCAEC;IAED;;;OAGG;IACH,iCAEC;IAED;;;OAGG;IACH,gCAEC;IAED;;;;;OAKG;IACH,gCAEC;IAED;;;OAGG;IACH,iCAEC;IAED,gCAEC;IAED,+BAEC;IAED,8BAEC;IAED;;OAEG;IACH,qCAQC;IAID;;;;;;;;;;OAUG;IACH,iBAHW,mBAAmB,GACjB,MAAM,CA8ClB;IAED;;;;;;OAMG;IACH,mBAHW,mBAAmB,GACjB,OAAO,CAgBnB;IAED;;;OAGG;IACH,sBAHW,mBAAmB,GACjB,OAAO,CAInB;IAED;;;;;;OAMG;IACH,cAJW,mBAAmB,cACnB,MAAM,GACJ,QAAQ,GAAC,UAAU,GAAC,aAAa,GAAC,KAAK,GAAC,MAAM,GAAC,cAAc,CAqBzE;IA6CD;;;;OAIG;IACH,SAFa,IAAI,CAOhB;IAED;;;;OAIG;IACH,WAFa,IAAI,CAUhB;IAED;;;;OAIG;IACH,qBAFa,MAAM,CAkBlB;IAID;;;;;;;;;OASG;IACH,aANW,WAAW,UACX;QAAC,eAAe,EAAE,MAAM,CAAC;QAAC,gBAAgB,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAChF,UAAgB,EAAE,MAAM,CAAA;KAAC,iBACf,MAAM,GACJ,IAAI,CA6HhB;IA2FD;;;;;;OAMG;IACH,yBAHW,MAAM,GACJ,OAAO,CAgBnB;IAED;;;;;;OAMG;IACH,oBAHW,MAAM,GACJ,OAAO,CAoCnB;;CAqXJ;kCAl2CY,OAAO,uCAAuC,EAAE,mBAAmB;uBACnE,OAAO,4BAA4B,EAAE,QAAQ;qCAC7C,OAAO,6BAA6B,EAAE,sBAAsB;qCALpC,2BAA2B;gCALhC,gDAAgD;gCAIhD,sBAAsB"}

package/src/shade/renderer/geometry/virtual/runtime/VGeoResidency.js

@@ -645,7 +645,20 @@ export class VGeoResidency {
                 this.#vram_last_used[row] = 0;
             }
 
-            if (tag === TAG_VRAM || tag === TAG_RAM) {
+            /**
+             * TAG_PENDING too. `#fetch` reserves the slot and charges its bytes before the read goes
+             * out, and a fetching page is TAG_PENDING — so leaving it out here meant the slot and
+             * its reserved bytes were never given back: both settle handlers return on
+             * `#geometries.get(reader) !== geometry` before they would free it, and `unregister`
+             * drops the geometry synchronously right after cancelling, so that is the branch that
+             * always runs. A scene that swaps assets leaked a slot per fetch on the wire until
+             * `#make_ram_room` refused everything, while `ram_resident_bytes` and `ram_page_count`
+             * both went on reporting the tier as empty.
+             *
+             * `#free_ram_slot` is a no-op for NO_SLOT and for a slot already given back, so the
+             * quarantined half of TAG_PENDING costs nothing here.
+             */
+            if (tag === TAG_VRAM || tag === TAG_RAM || tag === TAG_PENDING) {
                 this.#free_ram_slot(geometry.slot[page_index]);
             }
 

package/src/shade/renderer/global_illumination/probe/octahedral/GPUProbeAtlas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUProbeAtlas.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe/octahedral/GPUProbeAtlas.js"],"names":[],"mappings":"AAuBA;;;GAGG;AAEH;;GAEG;AAIH;IAyEI;;;OAGG;IACH,+BAgBC;IAtFD;;;OAGG;IACH,0CAEC;IAGD;;;OAGG;IACH,2BAUC;IAQD;;;OAGG;IACH,uCAEC;IAED;;;OAGG;IACH,kBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,sCAGC;IAED;;;OAGG;IACH,QAFU,MAAM,MAAM,CAEM;IAgC5B;;;;OAIG;IACH,6BAFW,MAAM,QAiChB;IAED;;;;;;;;OAQG;IACH;QAHsC,WAAW,EAAtC,iBAAiB;QACU,cAAc,EAAzC,iBAAiB;aAY3B;IAED;;;;;;;OAOG;IACH;QAL+B,KAAK,EAAzB,UAAU;QACe,KAAK,EAA9B,eAAe;QACU,QAAQ,EAAjC,eAAe;QACE,gBAAgB,GAAjC,MAAM;eAuQhB;IAED,+BAGC;IAED,gBAGC;;CACJ;8BA9bY,OAAO,6BAA6B,EAAE,eAAe;8BACrD,OAAO,mCAAmC,EAAE,eAAe;yBAI3D,OAAO,iEAAiE,EAAE,UAAU;kCAnB/D,uCAAuC"}
+{"version":3,"file":"GPUProbeAtlas.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe/octahedral/GPUProbeAtlas.js"],"names":[],"mappings":"AAuBA;;;GAGG;AAEH;;GAEG;AAIH;IAyEI;;;OAGG;IACH,+BAgBC;IAtFD;;;OAGG;IACH,0CAEC;IAGD;;;OAGG;IACH,2BAUC;IAQD;;;OAGG;IACH,uCAEC;IAED;;;OAGG;IACH,kBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,sCAGC;IAED;;;OAGG;IACH,QAFU,MAAM,MAAM,CAEM;IAgC5B;;;;OAIG;IACH,6BAFW,MAAM,QAiChB;IAED;;;;;;;;OAQG;IACH;QAHsC,WAAW,EAAtC,iBAAiB;QACU,cAAc,EAAzC,iBAAiB;aAY3B;IAED;;;;;;;OAOG;IACH;QAL+B,KAAK,EAAzB,UAAU;QACe,KAAK,EAA9B,eAAe;QACU,QAAQ,EAAjC,eAAe;QACE,gBAAgB,GAAjC,MAAM;eAgRhB;IAED,+BAGC;IAED,gBAGC;;CACJ;8BAvcY,OAAO,6BAA6B,EAAE,eAAe;8BACrD,OAAO,mCAAmC,EAAE,eAAe;yBAI3D,OAAO,iEAAiE,EAAE,UAAU;kCAnB/D,uCAAuC"}

package/src/shade/renderer/global_illumination/probe/octahedral/GPUProbeAtlas.js

@@ -317,9 +317,18 @@ export class GPUProbeAtlas {
         */
         let t_radiance = graph_import_texture(graph, this.texture_radiance);
         let t_depth = graph_import_texture(graph, this.#texture_depth);
-        const b_probes = graph_import_buffer(graph, scene.light_probe_volume.buffer_probes)
+        const b_probes = graph_import_buffer(graph, scene.light_probe_volume.buffer_probes);
 
-        ({ radiance: t_radiance } = graph_lpv_shade({
+        /*
+         Plain assignment off the returned record, not a parenthesised destructuring assignment. The
+         line above used to end without a semicolon, and ASI does not insert one before an open
+         paren, so the two statements parsed as a single call expression: the handle
+         `graph_import_buffer` returns was invoked as a function and `graph_update` threw a TypeError
+         out of `Renderer.update_lpv` on its first frame, after `graph_lpv_shade` had already added
+         its pass and before the depth accumulation, border painting, SH convolution and SH store
+         were scheduled at all. This shape cannot recur.
+        */
+        t_radiance = graph_lpv_shade({
             graph,
             scene,
             atlas: this,
@@ -335,7 +344,7 @@ export class GPUProbeAtlas {
             g_buffer_pbr,
             g_buffer_position,
             g_buffer_indirect,
-        }));
+        }).radiance;
 
         // avoid upsetting WebGPU validator with empty buffers
         if (update_count > 0) {

package/src/shade/renderer/light/environment/rgbe/RGBE_ReadPixels_RLE.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RGBE_ReadPixels_RLE.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/light/environment/rgbe/RGBE_ReadPixels_RLE.js"],"names":[],"mappings":"AA2FA;;;GAGG;AACH,wCAFW,UAAU,kBAkGpB;AAED;;;;;;GAMG;AACH,4CALW,UAAU,KACV,MAAM,KACN,MAAM,GACJ,UAAU,CAmItB;+BAxU8B,qBAAqB"}
+{"version":3,"file":"RGBE_ReadPixels_RLE.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/light/environment/rgbe/RGBE_ReadPixels_RLE.js"],"names":[],"mappings":"AAiGA;;;GAGG;AACH,wCAFW,UAAU,kBAkGpB;AAED;;;;;;GAMG;AACH,4CALW,UAAU,KACV,MAAM,KACN,MAAM,GACJ,UAAU,CAmItB;+BA9U8B,qBAAqB"}

package/src/shade/renderer/light/environment/rgbe/RGBE_ReadPixels_RLE.js

@@ -64,7 +64,13 @@ function fgets(buffer, lineLimit = 1024, consume = true) {
         s += chunk;
         len += chunk.length;
         p += chunkSize;
-        chunk += String.fromCharCode.apply(null, new Uint16Array(buffer.subarray(p, p + chunkSize)));
+
+        //`=`, not `+=`. Appending left `chunk` holding every chunk read so far while `s` already
+        //held them, so the line came back with its first 128 characters repeated and `len` — which
+        //line 81 below adds to `buffer.pos` — overshot the real line end by 128 per extra read.
+        //Every later `fgets` then read from the wrong offset, and a header with a comment longer
+        //than one chunk, which Radiance writers emit as a matter of course, was rejected outright.
+        chunk = String.fromCharCode.apply(null, new Uint16Array(buffer.subarray(p, p + chunkSize)));
 
     }
 

package/src/shade/renderer/lightmap/GPULightMap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPULightMap.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/lightmap/GPULightMap.js"],"names":[],"mappings":"AAmBA;IAgCI;;;OAGG;IACH,+BA6CC;IA/ED;;;OAGG;IACH,WAFU,iBAAiB,GAAC,IAAI,CAEf;IACjB;;;OAGG;IACH,cAFU,iBAAiB,GAAC,IAAI,CAEZ;IACpB;;;OAGG;IACH,cAFU,iBAAiB,GAAC,IAAI,CAEZ;IAEpB;;;OAGG;IACH,aAFU,iBAAiB,GAAC,IAAI,CAEb;IAEnB;;;OAGG;IACH,yBAEC;IA2ED;;;;OAIG;IACH,wEAmCC;IA6BD;;OAEG;IACH,oBA0DC;IAED,iBA+DC;IAED;;;;OAIG;IACH,kEAQC;;CAEJ;kCA3UiC,iCAAiC"}
+{"version":3,"file":"GPULightMap.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/lightmap/GPULightMap.js"],"names":[],"mappings":"AAmBA;IAgCI;;;OAGG;IACH,+BA6CC;IA/ED;;;OAGG;IACH,WAFU,iBAAiB,GAAC,IAAI,CAEf;IACjB;;;OAGG;IACH,cAFU,iBAAiB,GAAC,IAAI,CAEZ;IACpB;;;OAGG;IACH,cAFU,iBAAiB,GAAC,IAAI,CAEZ;IAEpB;;;OAGG;IACH,aAFU,iBAAiB,GAAC,IAAI,CAEb;IAEnB;;;OAGG;IACH,yBAEC;IA2ED;;;;OAIG;IACH,wEAmCC;IA6BD;;OAEG;IACH,oBA0DC;IAED,iBA4EC;IAED;;;;OAIG;IACH,kEAQC;;CAEJ;kCAxViC,iCAAiC"}