@woosh/meep-engine 3.19.0 → 3.21.0

package/src/shade/renderer/extension/SceneColor.d.ts

@@ -17,7 +17,7 @@
  */
 export class SceneColor extends FrameRecord {
     static is_present_at(phase: any): boolean;
-    set color(arg: number);
+    set color(handle: number);
     /**
      * @returns {number}
      */

package/src/shade/renderer/extension/SceneColor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SceneColor.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/extension/SceneColor.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH;IAGI,0CAIC;IASD,uBAEC;IATD;;OAEG;IACH,oBAEC;;CAKJ;4BAtC2B,kBAAkB"}
+{"version":3,"file":"SceneColor.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/extension/SceneColor.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH;IAGI,0CAIC;IASD,0BAEC;IATD;;OAEG;IACH,oBAEC;;CAKJ;4BAtC2B,kBAAkB"}

package/src/shade/renderer/extension/ViewTextures.d.ts

@@ -12,26 +12,26 @@
  */
 export class ViewTextures extends FrameRecord {
     static is_present_at(phase: any): boolean;
-    set depth(arg: number);
+    set depth(handle: number);
     /**
      * @returns {number}
      */
     get depth(): number;
-    set depth_previous(arg: number);
+    set depth_previous(handle: number);
     /**
      * Last frame's depth, which reprojection-shaped effects need.
      *
      * @returns {number}
      */
     get depth_previous(): number;
-    set visibility_mesh(arg: number);
+    set visibility_mesh(handle: number);
     /**
      * Which mesh each pixel came from. What an outline or a selection highlight is derived from.
      *
      * @returns {number}
      */
     get visibility_mesh(): number;
-    set visibility_triangle(arg: number);
+    set visibility_triangle(handle: number);
     /**
      * Which triangle each pixel came from.
      *

package/src/shade/renderer/extension/ViewTextures.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ViewTextures.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/extension/ViewTextures.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH;IAMI,0CAKC;IASD,uBAEC;IATD;;OAEG;IACH,oBAEC;IAeD,gCAEC;IAXD;;;;OAIG;IACH,6BAEC;IAeD,iCAEC;IAXD;;;;OAIG;IACH,8BAEC;IAeD,qCAEC;IAXD;;;;OAIG;IACH,kCAEC;;CAKJ;4BA5E2B,kBAAkB"}
+{"version":3,"file":"ViewTextures.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/extension/ViewTextures.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH;IAMI,0CAKC;IASD,0BAEC;IATD;;OAEG;IACH,oBAEC;IAeD,mCAEC;IAXD;;;;OAIG;IACH,6BAEC;IAeD,oCAEC;IAXD;;;;OAIG;IACH,8BAEC;IAeD,wCAEC;IAXD;;;;OAIG;IACH,kCAEC;;CAKJ;4BA5E2B,kBAAkB"}

package/src/shade/renderer/geometry/Attribute.d.ts

@@ -34,7 +34,7 @@ export class Attribute {
      *
      * @param {boolean} v
      */
-    set needsUpdate(arg: boolean);
+    set needsUpdate(v: boolean);
     /**
      * @deprecated
      * @return {string}

package/src/shade/renderer/geometry/Attribute.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Attribute.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/geometry/Attribute.js"],"names":[],"mappings":"AASA;;;;GAIG;AACH;IA8GI;;;;;OAKG;IACH,mBAJW,MAAM,EAAE,GAAC,YAAY,GAAC,WAAW,GAAC,UAAU,GAAC,WAAW,aACxD,MAAM,SACN,MAAM,aAqBhB;IArID;;;OAGG;IACH,MAFU,aAAa,CAEI;IAG3B;;OAEG;IACH,MAFU,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,gBAAY,YAAY,GAAC,YAAY,CAEpE;IAEL;;;OAGG;IACH,OAFU,MAAM,CAEN;IASV;;;OAGG;IACH,sBAEC;IAED;;;OAGG;IACH,8BAMC;IAED;;;OAGG;IACH,mBAEC;IAED;;;OAGG;IACH,uBAEC;IAGD;;;;OAIG;IACH,cAHW,SAAS,GACP,OAAO,CAOnB;IAED,eAMC;IAED;;;OAGG;IACH,YAFW,SAAS,QAUnB;IAED;;;OAGG;IACH,SAFY,SAAS,CAQpB;IA6BD;;;OAGG;IACH,iCAQC;IAGL;;;OAGG;IACH,sBAFU,OAAO,CAEc;;CAN9B;8BA7J6B,oDAAoD"}
+{"version":3,"file":"Attribute.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/geometry/Attribute.js"],"names":[],"mappings":"AASA;;;;GAIG;AACH;IA8GI;;;;;OAKG;IACH,mBAJW,MAAM,EAAE,GAAC,YAAY,GAAC,WAAW,GAAC,UAAU,GAAC,WAAW,aACxD,MAAM,SACN,MAAM,aAqBhB;IArID;;;OAGG;IACH,MAFU,aAAa,CAEI;IAG3B;;OAEG;IACH,MAFU,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,gBAAY,YAAY,GAAC,YAAY,CAEpE;IAEL;;;OAGG;IACH,OAFU,MAAM,CAEN;IASV;;;OAGG;IACH,sBAEC;IAED;;;OAGG;IACH,4BAMC;IAED;;;OAGG;IACH,mBAEC;IAED;;;OAGG;IACH,uBAEC;IAGD;;;;OAIG;IACH,cAHW,SAAS,GACP,OAAO,CAOnB;IAED,eAMC;IAED;;;OAGG;IACH,YAFW,SAAS,QAUnB;IAED;;;OAGG;IACH,SAFY,SAAS,CAQpB;IA6BD;;;OAGG;IACH,iCAQC;IAGL;;;OAGG;IACH,sBAFU,OAAO,CAEc;;CAN9B;8BA7J6B,oDAAoD"}

package/src/shade/renderer/geometry/Geometry.d.ts

@@ -57,7 +57,7 @@ export class Geometry {
     /**
      * @param {boolean} v
      */
-    set needsUpdate(arg: boolean);
+    set needsUpdate(v: boolean);
     /**
      *
      * @param {number|GeometryFlags} flag

package/src/shade/renderer/geometry/Geometry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Geometry.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/geometry/Geometry.js"],"names":[],"mappings":"4BA2BU,MAAM;;;;AAQhB;;GAEG;AACH;IAQI;;;;OAIG;IACH,iBAEC;IAED;;;OAGG;IACH,MAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,YAFU,SAAS,EAAE,CAEL;IAEhB;;;OAGG;IACH,OAFU,SAAS,GAAC,IAAI,CAEX;IAEb;;;OAGG;IACH,cAFU,YAAY,CAEa;IACnC;;;OAGG;IACH,iBAFU,YAAY,CAEgB;IAEtC;;;OAGG;IACH,OAFU,MAAM,CAEM;IAOtB;;;;;;;;;;OAUG;IACH,sBAEC;IAED;;OAEG;IACH,8BAIC;IAGD;;;;OAIG;IACH,cAHW,MAAM,GAAC,aAAa,GAClB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,aAAa,GAClB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,aAAa,SACpB,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,aAAa,GAClB,OAAO,CAInB;IAED;;;;OAIG;IACH,cAHW,QAAQ,GACN,OAAO,CAYnB;IAED,eAQC;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACL,SAAS,GAAC,SAAS,CAkB9B;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,OAAO,CAMnB;IAED;;;OAGG;IACH,wBAFW,SAAS,QAQnB;IAED;;;OAGG;IACH,wBAFW,SAAS,QASnB;IAED;;;;OAIG;IACH,sBAHW,MAAM,GACL,SAAS,GAAC,SAAS,CAiB9B;IAED;;;OAGG;IACH,kBAFY,MAAM,CAWjB;IAED;;;OAGG;IACH,iBAFY,MAAM,CAYjB;IAED;;;;OAIG;IACH,qBAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,oBAIC;IAED;;OAEG;IACH,mBASC;IAED,qBAIC;IAED;;OAEG;IACH,qCAoBC;IAED,8BAaC;IAED,8BAKC;IAED,2BAeC;IAED,sBAOC;IAED,uBA4BC;IAoFD,uBAOC;IAED,wBAWC;IAED;;;OAGG;IACH,YAFW,QAAQ,QAmBlB;IAED;;;OAGG;IACH,SAFY,QAAQ,CAQnB;IAED,eAEC;IAED;;;OAGG;IACH,iCAYC;IAGL;;;OAGG;IACH,qBAFU,OAAO,CAEY;;CAN5B;0BAvkByB,gBAAgB"}
+{"version":3,"file":"Geometry.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/geometry/Geometry.js"],"names":[],"mappings":"4BA4BU,MAAM;;;;AAQhB;;GAEG;AACH;IAQI;;;;OAIG;IACH,iBAEC;IAED;;;OAGG;IACH,MAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,YAFU,SAAS,EAAE,CAEL;IAEhB;;;OAGG;IACH,OAFU,SAAS,GAAC,IAAI,CAEX;IAEb;;;OAGG;IACH,cAFU,YAAY,CAEa;IACnC;;;OAGG;IACH,iBAFU,YAAY,CAEgB;IAEtC;;;OAGG;IACH,OAFU,MAAM,CAEM;IAOtB;;;;;;;;;;OAUG;IACH,sBAEC;IAED;;OAEG;IACH,4BAIC;IAGD;;;;OAIG;IACH,cAHW,MAAM,GAAC,aAAa,GAClB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,aAAa,GAClB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,aAAa,SACpB,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,aAAa,GAClB,OAAO,CAInB;IAED;;;;OAIG;IACH,cAHW,QAAQ,GACN,OAAO,CAYnB;IAED,eAQC;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACL,SAAS,GAAC,SAAS,CAkB9B;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,OAAO,CAMnB;IAED;;;OAGG;IACH,wBAFW,SAAS,QAQnB;IAED;;;OAGG;IACH,wBAFW,SAAS,QASnB;IAED;;;;OAIG;IACH,sBAHW,MAAM,GACL,SAAS,GAAC,SAAS,CAiB9B;IAED;;;OAGG;IACH,kBAFY,MAAM,CAWjB;IAED;;;OAGG;IACH,iBAFY,MAAM,CAYjB;IAED;;;;OAIG;IACH,qBAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,oBAIC;IAED;;OAEG;IACH,mBASC;IAED,qBAIC;IAED;;OAEG;IACH,qCAoBC;IAED,8BAaC;IAED,8BAKC;IAED,2BAeC;IAED,sBAOC;IAED,uBA4BC;IAoFD,uBAOC;IAED,wBAWC;IAED;;;OAGG;IACH,YAFW,QAAQ,QAelB;IAED;;;OAGG;IACH,SAFY,QAAQ,CAQnB;IAED,eAEC;IAED;;;OAGG;IACH,iCAYC;IAGL;;;OAGG;IACH,qBAFU,OAAO,CAEY;;CAN5B;0BAnkByB,gBAAgB"}

package/src/shade/renderer/geometry/Geometry.js

@@ -14,8 +14,9 @@ import {
 import {
     geometry_compute_vertex_normals_unindexed
 } from "../../../engine/graphics/geometry/buffered/geometry_compute_vertex_normals_unindexed.js";
-import { optional_equality } from "../../descriptor/util/optional_equality.js";
-import { optional_hash } from "../../descriptor/util/optional_hash.js";
+import { optional_clone } from "../../../core/model/object/optional_clone.js";
+import { optional_equality } from "../../../core/model/object/optional_equality.js";
+import { optional_hash } from "../../../core/model/object/optional_hash.js";
 import { Attribute } from "./Attribute.js";
 import { build_tangent_from_normal } from "./normals/build_tangent_from_normal.js";
 import { geometry_build_tangents } from "./normals/geometry_build_tangents.js";
@@ -551,11 +552,7 @@ export class Geometry {
 
         this.name = other.name;
 
-        if (other.index !== null) {
-            this.index = other.index.clone();
-        } else {
-            this.index = null;
-        }
+        this.index = optional_clone(other.index);
 
         this.attributes = other.attributes.map(a => a.clone());
 

package/src/shade/renderer/geometry/bvh/bvh2_check_bounds.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bvh2_check_bounds.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/bvh/bvh2_check_bounds.js"],"names":[],"mappings":"AA6EA;;;;;;;;;;;;;;;;;GAiBG;AACH,8CALW,WAAW,GAAC,YAAY;IAEP,KAAK,GAAtB,MAAM;;cACO,MAAM,EAAE;cAAY,MAAM;YAAU,MAAM;WAAS,OAAO;EAwFjF;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,8CAPW,WAAW,GAAC,YAAY,0BACf,MAAM,QAAE,MAAM,KAAG,CAAC,MAAM,EAAE,GAAC,IAAI,CAAC;IAGxB,KAAK,GAAtB,MAAM;;cACO,MAAM,EAAE;YAAU,MAAM;WAAS,OAAO;EA6D/D"}
+{"version":3,"file":"bvh2_check_bounds.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/bvh/bvh2_check_bounds.js"],"names":[],"mappings":"AA6EA;;;;;;;;;;;;;;;;;GAiBG;AACH,8CALW,WAAW,GAAC,YAAY;IAEP,KAAK,GAAtB,MAAM;IACJ;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAC,CAwFlF;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,8CAPW,WAAW,GAAC,YAAY,0BACf,MAAM,QAAE,MAAM,KAAG,CAAC,MAAM,EAAE,GAAC,IAAI,CAAC;IAGxB,KAAK,GAAtB,MAAM;IACJ;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAC,CA6DhE"}

package/src/shade/renderer/geometry/bvh/bvh2_derive_topology.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bvh2_derive_topology.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/bvh/bvh2_derive_topology.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;GAiBG;AACH,4CALW,WAAW;aACC,WAAW;gBAAc,WAAW;EAuD1D"}
+{"version":3,"file":"bvh2_derive_topology.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/bvh/bvh2_derive_topology.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;GAiBG;AACH,4CALW,WAAW,GACT;IAAC,OAAO,EAAE,WAAW,CAAC;IAAC,UAAU,EAAE,WAAW,CAAA;CAAC,CAuD3D"}

package/src/shade/renderer/geometry/meshlet/MeshletBatch.d.ts

@@ -6,13 +6,13 @@ export class MeshletBatch {
      *
      * @param {ArrayBuffer} value
      */
-    set data_buffer(arg: ArrayBuffer);
+    set data_buffer(value: ArrayBuffer);
     get data_buffer(): ArrayBuffer;
     /**
      *
      * @param {ArrayBuffer} value
      */
-    set metadata_buffer(arg: ArrayBuffer);
+    set metadata_buffer(value: ArrayBuffer);
     /**
      *
      * @returns {ArrayBuffer}
@@ -22,7 +22,7 @@ export class MeshletBatch {
      *
      * @param {number} value
      */
-    set count(arg: number);
+    set count(value: number);
     /**
      * Number of meshlets in the batch
      * @return {number}

package/src/shade/renderer/geometry/meshlet/MeshletBatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MeshletBatch.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/meshlet/MeshletBatch.js"],"names":[],"mappings":"AA8DA;;GAEG;AACH;IAiBI;;;OAGG;IACH,kCAGC;IAXD,+BAEC;IA6BD;;;OAGG;IACH,sCAGC;IAfD;;;OAGG;IACH,mCAEC;IAqBD;;;OAGG;IACH,uBAEC;IAdD;;;OAGG;IACH,oBAEC;IAUD;;;OAGG;IACH,QAFa,MAAM,CASlB;IAED;;;OAGG;IACH,cAFW,YAAY,WAQtB;IAED;;;;OAIG;IACH,YAFa,MAAM,CAoFlB;IAED;;;OAGG;IACH,iBAEC;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACL,EAAE,CAeb;IAED;;;OAGG;IACH,yBAFW,MAAM;;;;MAgChB;IA4LD,qBA+BC;IAED;;;OAGG;IACH,gCAOC;IAIL;;;;OAIG;IACH,yBAFU,OAAO,CAEoB;;CAPpC"}
+{"version":3,"file":"MeshletBatch.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/meshlet/MeshletBatch.js"],"names":[],"mappings":"AA8DA;;GAEG;AACH;IAiBI;;;OAGG;IACH,oCAGC;IAXD,+BAEC;IA6BD;;;OAGG;IACH,wCAGC;IAfD;;;OAGG;IACH,mCAEC;IAqBD;;;OAGG;IACH,yBAEC;IAdD;;;OAGG;IACH,oBAEC;IAUD;;;OAGG;IACH,QAFa,MAAM,CASlB;IAED;;;OAGG;IACH,cAFW,YAAY,WAQtB;IAED;;;;OAIG;IACH,YAFa,MAAM,CAoFlB;IAED;;;OAGG;IACH,iBAEC;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACL,EAAE,CAeb;IAED;;;OAGG;IACH,yBAFW,MAAM;;;;MAgChB;IA4LD,qBA+BC;IAED;;;OAGG;IACH,gCAOC;IAIL;;;;OAIG;IACH,yBAFU,OAAO,CAEoB;;CAPpC"}

package/src/shade/renderer/geometry/virtual/build/gltf/gltf_collect_geometries.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gltf_collect_geometries.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/gltf/gltf_collect_geometries.js"],"names":[],"mappings":"AA0NA;;;;;;;;;;GAUG;AACH;gBAH0B,YAAY,EAAE;YAAU,iBAAiB;EAqElE;6BA7R4B,mBAAmB;kCADd,wBAAwB"}
+{"version":3,"file":"gltf_collect_geometries.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/gltf/gltf_collect_geometries.js"],"names":[],"mappings":"AA0NA;;;;;;;;;;GAUG;AACH,mGAHa;IAAC,UAAU,EAAE,YAAY,EAAE,CAAC;IAAC,MAAM,EAAE,iBAAiB,CAAA;CAAC,CAqEnE;6BA7R4B,mBAAmB;kCADd,wBAAwB"}

package/src/shade/renderer/geometry/virtual/format/attribute/VGEO_ATTRIBUTES.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VGEO_ATTRIBUTES.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/format/attribute/VGEO_ATTRIBUTES.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,8BAFU;IAAC,MAAK,kBAAkB,CAAC;IAAC,UAAU,EAAC,MAAM,CAAC;IAAC,QAAQ,EAAC,MAAM,EAAE,CAAC;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,gBAAgB,EAAC,MAAM,CAAC;IAAC,QAAQ,EAAC,MAAM,CAAA;CAAC,EAAE,CAiChI;mCAjDgC,gCAAgC"}
+{"version":3,"file":"VGEO_ATTRIBUTES.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/format/attribute/VGEO_ATTRIBUTES.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,8BAFU;IAAC,IAAI,EAAC,kBAAkB,CAAC;IAAC,UAAU,EAAC,MAAM,CAAC;IAAC,QAAQ,EAAC,MAAM,EAAE,CAAC;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,gBAAgB,EAAC,MAAM,CAAC;IAAC,QAAQ,EAAC,MAAM,CAAA;CAAC,EAAE,CAiChI;mCAjDgC,gCAAgC"}

package/src/shade/renderer/geometry/virtual/format/frame/vgeo_read_frame_extent.d.ts

@@ -0,0 +1,29 @@
+/**
+ * One frame's header, read where it sits.
+ *
+ * This is the whole of the format's self-delimiting rule (§5): 24 bytes say what codec the blob is
+ * under, how many child-table entries follow, and how long the blob is stored and decoded — from
+ * which the frame's extent, and therefore where the next one begins, follows. Nothing else in the
+ * file has to be consulted, which is what lets the same 24 bytes serve a sequential scan
+ * ({@link vgeo_scan_frames}) and a reader that fetched this frame's exact range and nothing else
+ * ({@link vgeo_read_page}).
+ *
+ * The `frame_offset` it comes back with is the `at` it was given, so a caller reading a range it
+ * fetched passes 0 and gets an extent whose offsets address that range — which is what the decoder
+ * wants — while a caller reading the whole file passes the absolute offset and gets absolute ones.
+ *
+ * The magic is deliberately not checked here. §5 forbids using a magic mismatch as the terminator of
+ * a prefix scan, and the scan is one of this function's two callers; the caller that fetched a
+ * specific range is the one for which a wrong magic means something, and it checks.
+ *
+ * @param {DataView} data over bytes that contain the frame header at `at`
+ * @param {number} at byte offset of the frame's first byte within `data`
+ * @param {number} page_index the frame's ordinal, which is also the page index
+ * @returns {VGeoFrameExtent}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function vgeo_read_frame_extent(data: DataView, at: number, page_index: number): VGeoFrameExtent;
+import { VGeoFrameExtent } from "./VGeoFrameExtent.js";
+//# sourceMappingURL=vgeo_read_frame_extent.d.ts.map

package/src/shade/renderer/geometry/virtual/format/frame/vgeo_read_frame_extent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vgeo_read_frame_extent.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/format/frame/vgeo_read_frame_extent.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,6CARW,QAAQ,MACR,MAAM,cACN,MAAM,GACJ,eAAe,CAwB3B;gCArD+B,sBAAsB"}

package/src/shade/renderer/geometry/virtual/format/frame/vgeo_read_frame_extent.js

@@ -0,0 +1,59 @@
+import { round_up } from "../../../../../../core/math/round_up.js";
+import { VGEO_CHILD_TABLE_ENTRY_SIZE } from "./VGEO_CHILD_TABLE_ENTRY_SIZE.js";
+import { VGEO_FRAME_ALIGNMENT } from "./VGEO_FRAME_ALIGNMENT.js";
+import { VGEO_FRAME_HEADER_SIZE } from "./VGEO_FRAME_HEADER_SIZE.js";
+import { VGEO_FRAME_OFFSET } from "./VGEO_FRAME_OFFSET.js";
+import { VGeoFrameExtent } from "./VGeoFrameExtent.js";
+
+/**
+ * Everything in the container is little-endian (`VGEO_FORMAT.md` §2).
+ * @type {boolean}
+ */
+const LE = true;
+
+/**
+ * One frame's header, read where it sits.
+ *
+ * This is the whole of the format's self-delimiting rule (§5): 24 bytes say what codec the blob is
+ * under, how many child-table entries follow, and how long the blob is stored and decoded — from
+ * which the frame's extent, and therefore where the next one begins, follows. Nothing else in the
+ * file has to be consulted, which is what lets the same 24 bytes serve a sequential scan
+ * ({@link vgeo_scan_frames}) and a reader that fetched this frame's exact range and nothing else
+ * ({@link vgeo_read_page}).
+ *
+ * The `frame_offset` it comes back with is the `at` it was given, so a caller reading a range it
+ * fetched passes 0 and gets an extent whose offsets address that range — which is what the decoder
+ * wants — while a caller reading the whole file passes the absolute offset and gets absolute ones.
+ *
+ * The magic is deliberately not checked here. §5 forbids using a magic mismatch as the terminator of
+ * a prefix scan, and the scan is one of this function's two callers; the caller that fetched a
+ * specific range is the one for which a wrong magic means something, and it checks.
+ *
+ * @param {DataView} data over bytes that contain the frame header at `at`
+ * @param {number} at byte offset of the frame's first byte within `data`
+ * @param {number} page_index the frame's ordinal, which is also the page index
+ * @returns {VGeoFrameExtent}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function vgeo_read_frame_extent(data, at, page_index) {
+    const result = new VGeoFrameExtent();
+
+    result.page_index = page_index;
+    result.frame_offset = at;
+
+    result.codec = data.getUint8(at + VGEO_FRAME_OFFSET.CODEC);
+    result.flags = data.getUint8(at + VGEO_FRAME_OFFSET.FLAGS);
+    result.child_page_count = data.getUint16(at + VGEO_FRAME_OFFSET.CHILD_PAGE_COUNT, LE);
+    result.stored_size = data.getUint32(at + VGEO_FRAME_OFFSET.STORED_SIZE, LE);
+    result.decoded_size = data.getUint32(at + VGEO_FRAME_OFFSET.DECODED_SIZE, LE);
+
+    result.extent = VGEO_FRAME_HEADER_SIZE
+        + VGEO_CHILD_TABLE_ENTRY_SIZE * result.child_page_count
+        + result.stored_size;
+
+    result.fetch_size = round_up(result.extent, VGEO_FRAME_ALIGNMENT);
+
+    return result;
+}

package/src/shade/renderer/geometry/virtual/format/frame/vgeo_scan_frames.d.ts

@@ -14,5 +14,4 @@
  * @copyright Company Named Limited (c) 2026
  */
 export function vgeo_scan_frames(buffer: BinaryBuffer): VGeoFrameExtent[];
-import { VGeoFrameExtent } from "./VGeoFrameExtent.js";
 //# sourceMappingURL=vgeo_scan_frames.d.ts.map

package/src/shade/renderer/geometry/virtual/format/frame/vgeo_scan_frames.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vgeo_scan_frames.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/format/frame/vgeo_scan_frames.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;GAcG;AACH,wDALa,eAAe,EAAE,CAsD7B;gCAlE+B,sBAAsB"}
+{"version":3,"file":"vgeo_scan_frames.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/format/frame/vgeo_scan_frames.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;GAcG;AACH,wDALa,iBAAiB,CAqC7B"}

package/src/shade/renderer/geometry/virtual/format/frame/vgeo_scan_frames.js

@@ -1,11 +1,7 @@
-import { round_up } from "../../../../../../core/math/round_up.js";
-import { VGEO_CHILD_TABLE_ENTRY_SIZE } from "./VGEO_CHILD_TABLE_ENTRY_SIZE.js";
-import { VGEO_FRAME_ALIGNMENT } from "./VGEO_FRAME_ALIGNMENT.js";
 import { VGEO_FRAME_HEADER_SIZE } from "./VGEO_FRAME_HEADER_SIZE.js";
-import { VGEO_FRAME_OFFSET } from "./VGEO_FRAME_OFFSET.js";
 import { VGEO_HEADER_OFFSET } from "../header/VGEO_HEADER_OFFSET.js";
 import { VGEO_HEADER_SIZE } from "../header/VGEO_HEADER_SIZE.js";
-import { VGeoFrameExtent } from "./VGeoFrameExtent.js";
+import { vgeo_read_frame_extent } from "./vgeo_read_frame_extent.js";
 
 /**
  * Walk a whole `.vgeo` file's frame region, in file order.
@@ -43,24 +39,7 @@ export function vgeo_scan_frames(buffer) {
     let offset = Math.max(VGEO_HEADER_SIZE, root_page_offset);
 
     while (offset + VGEO_FRAME_HEADER_SIZE <= end) {
-        const extent_record = new VGeoFrameExtent();
-
-        extent_record.page_index = result.length;
-        extent_record.frame_offset = offset;
-
-        buffer.position = offset + VGEO_FRAME_OFFSET.CODEC;
-
-        extent_record.codec = buffer.readUint8();
-        extent_record.flags = buffer.readUint8();
-        extent_record.child_page_count = buffer.readUint16();
-        extent_record.stored_size = buffer.readUint32();
-        extent_record.decoded_size = buffer.readUint32();
-
-        extent_record.extent = VGEO_FRAME_HEADER_SIZE
-            + VGEO_CHILD_TABLE_ENTRY_SIZE * extent_record.child_page_count
-            + extent_record.stored_size;
-
-        extent_record.fetch_size = round_up(extent_record.extent, VGEO_FRAME_ALIGNMENT);
+        const extent_record = vgeo_read_frame_extent(buffer.dataView, offset, result.length);
 
         result.push(extent_record);
 

package/src/shade/renderer/geometry/virtual/format/read/VGeoByteSource.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Somewhere a `.vgeo` can be read from, a range at a time.
+ *
+ * The whole point of the container's layout is that a reader never needs all of it: the header is
+ * 256 bytes, a frame's exact extent is written in the parent that points at it, and a page decodes
+ * from its own bytes with no other page involved. What a reader needs from the environment is
+ * therefore not "give me the file" but "give me these bytes of it", and that is the whole of this
+ * class. An `ArrayBuffer` in hand is one implementation, a `File` the user dropped is another
+ * ({@link from_blob} — the browser reads only the slice), an HTTP range request a third
+ * ({@link vgeo_fetch_byte_source}).
+ *
+ * Reads are asynchronous because the interesting sources are. A source over bytes already in memory
+ * resolves immediately and costs a microtask, which is the right price for not having two readers.
+ *
+ * Ranges are checked against the length the source declares, so a file that names bytes it does not
+ * have fails here, naming the range, rather than somewhere downstream holding a short array.
+ *
+ * {@link request_count} and {@link bytes_read} are kept because they are the measurement a streaming
+ * reader exists to move: what a view actually cost to put on screen, against the size of the file it
+ * came from.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class VGeoByteSource {
+    /**
+     * A source over bytes already in memory.
+     *
+     * Nothing is copied and nothing is deferred; it exists so that a caller holding a whole file —
+     * a build's own output, a fixture — reads it through the same interface as one that is
+     * streaming, and so that neither the reader nor anything under it has a resident case.
+     *
+     * @param {Uint8Array|ArrayBuffer} bytes
+     * @param {string} [name]
+     * @returns {VGeoByteSource}
+     */
+    static of(bytes: Uint8Array | ArrayBuffer, name?: string): VGeoByteSource;
+    /**
+     * A source over a `File` or a `Blob` — a file dropped onto a page.
+     *
+     * Genuinely partial: `Blob.slice` names a range and the browser reads that range, so dropping a
+     * gigabyte asset costs whatever the traversal asks for and not a gigabyte of heap. That is the
+     * one case where a debug tool and a runtime want exactly the same thing.
+     *
+     * @param {Blob} blob
+     * @param {string} [name]
+     * @returns {VGeoByteSource}
+     */
+    static from_blob(blob: Blob, name?: string): VGeoByteSource;
+    /**
+     * @param {number} byte_length
+     * @param {function(number, number): Promise<Uint8Array>} read given a byte offset and a byte
+     *     count, resolves with exactly that many bytes
+     * @param {string} [name]
+     */
+    constructor(byte_length: number, read: (arg0: number, arg1: number) => Promise<Uint8Array>, name?: string);
+    /**
+     * How many bytes this source holds — the whole file, however little of it has been read.
+     * @type {number}
+     */
+    byte_length: number;
+    /**
+     * Reads served so far.
+     * @type {number}
+     */
+    request_count: number;
+    /**
+     * Bytes served so far. Against {@link byte_length}, this is the fraction of the file a session
+     * actually touched.
+     * @type {number}
+     */
+    bytes_read: number;
+    /**
+     * @returns {string}
+     */
+    get name(): string;
+    /**
+     * Forget what has been read so far.
+     *
+     * For re-opening the same file under different read options, where the question is what *this*
+     * open cost and a running total across both would answer nobody's.
+     */
+    reset_counters(): void;
+    /**
+     * @param {number} byte_offset
+     * @param {number} byte_length
+     * @returns {Promise<Uint8Array>} exactly that range
+     * @throws {Error} if the range is not inside the source, or the reader answered with a different
+     *     number of bytes than it was asked for
+     */
+    read(byte_offset: number, byte_length: number): Promise<Uint8Array>;
+    #private;
+}
+//# sourceMappingURL=VGeoByteSource.d.ts.map

package/src/shade/renderer/geometry/virtual/format/read/VGeoByteSource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VGeoByteSource.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/format/read/VGeoByteSource.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IAsGI;;;;;;;;;;OAUG;IACH,iBAJW,UAAU,GAAC,WAAW,SACtB,MAAM,GACJ,cAAc,CAU1B;IAED;;;;;;;;;;OAUG;IACH,uBAJW,IAAI,SACJ,MAAM,GACJ,cAAc,CAU1B;IA/GD;;;;;OAKG;IACH,yBALW,MAAM,eACG,MAAM,QAAE,MAAM,KAAG,QAAQ,UAAU,CAAC,SAE7C,MAAM,EAUhB;IA5CD;;;OAGG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,eAFU,MAAM,CAEE;IAElB;;;;OAIG;IACH,YAFU,MAAM,CAED;IA6Bf;;OAEG;IACH,mBAEC;IAED;;;;;OAKG;IACH,uBAGC;IAED;;;;;;OAMG;IACH,kBANW,MAAM,eACN,MAAM,GACJ,QAAQ,UAAU,CAAC,CAgC/B;;CA2CJ"}

package/src/shade/renderer/geometry/virtual/format/read/VGeoByteSource.js

@@ -0,0 +1,170 @@
+import { assert } from "../../../../../../core/assert.js";
+
+/**
+ * Somewhere a `.vgeo` can be read from, a range at a time.
+ *
+ * The whole point of the container's layout is that a reader never needs all of it: the header is
+ * 256 bytes, a frame's exact extent is written in the parent that points at it, and a page decodes
+ * from its own bytes with no other page involved. What a reader needs from the environment is
+ * therefore not "give me the file" but "give me these bytes of it", and that is the whole of this
+ * class. An `ArrayBuffer` in hand is one implementation, a `File` the user dropped is another
+ * ({@link from_blob} — the browser reads only the slice), an HTTP range request a third
+ * ({@link vgeo_fetch_byte_source}).
+ *
+ * Reads are asynchronous because the interesting sources are. A source over bytes already in memory
+ * resolves immediately and costs a microtask, which is the right price for not having two readers.
+ *
+ * Ranges are checked against the length the source declares, so a file that names bytes it does not
+ * have fails here, naming the range, rather than somewhere downstream holding a short array.
+ *
+ * {@link request_count} and {@link bytes_read} are kept because they are the measurement a streaming
+ * reader exists to move: what a view actually cost to put on screen, against the size of the file it
+ * came from.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class VGeoByteSource {
+    /**
+     * How many bytes this source holds — the whole file, however little of it has been read.
+     * @type {number}
+     */
+    byte_length = 0;
+
+    /**
+     * Reads served so far.
+     * @type {number}
+     */
+    request_count = 0;
+
+    /**
+     * Bytes served so far. Against {@link byte_length}, this is the fraction of the file a session
+     * actually touched.
+     * @type {number}
+     */
+    bytes_read = 0;
+
+    /**
+     * @type {function(number, number): Promise<Uint8Array>}
+     */
+    #read;
+
+    /**
+     * For the message, so a failed read says which file it was.
+     * @type {string}
+     */
+    #name;
+
+    /**
+     * @param {number} byte_length
+     * @param {function(number, number): Promise<Uint8Array>} read given a byte offset and a byte
+     *     count, resolves with exactly that many bytes
+     * @param {string} [name]
+     */
+    constructor(byte_length, read, name = 'a byte source') {
+        assert.isNonNegativeInteger(byte_length, 'byte_length');
+        assert.isFunction(read, 'read');
+
+        this.byte_length = byte_length;
+
+        this.#read = read;
+        this.#name = name;
+    }
+
+    /**
+     * @returns {string}
+     */
+    get name() {
+        return this.#name;
+    }
+
+    /**
+     * Forget what has been read so far.
+     *
+     * For re-opening the same file under different read options, where the question is what *this*
+     * open cost and a running total across both would answer nobody's.
+     */
+    reset_counters() {
+        this.request_count = 0;
+        this.bytes_read = 0;
+    }
+
+    /**
+     * @param {number} byte_offset
+     * @param {number} byte_length
+     * @returns {Promise<Uint8Array>} exactly that range
+     * @throws {Error} if the range is not inside the source, or the reader answered with a different
+     *     number of bytes than it was asked for
+     */
+    async read(byte_offset, byte_length) {
+        if (
+            !Number.isInteger(byte_offset) || byte_offset < 0
+            || !Number.isInteger(byte_length) || byte_length < 0
+            || byte_offset + byte_length > this.byte_length
+        ) {
+            throw new Error(
+                `${this.#name} was asked for ${byte_length} bytes at ${byte_offset},`
+                + ` and holds ${this.byte_length}`
+            );
+        }
+
+        const bytes = await this.#read(byte_offset, byte_length);
+
+        if (bytes.byteLength !== byte_length) {
+            // Checked rather than trusted: everything downstream indexes by the format's offsets,
+            // and a short array would come back as a page whose tail reads as zeros — which decodes
+            // and very nearly validates.
+            throw new Error(
+                `${this.#name} answered ${bytes.byteLength} bytes for a read of ${byte_length}`
+                + ` at ${byte_offset}`
+            );
+        }
+
+        this.request_count++;
+        this.bytes_read += byte_length;
+
+        return bytes;
+    }
+
+    /**
+     * A source over bytes already in memory.
+     *
+     * Nothing is copied and nothing is deferred; it exists so that a caller holding a whole file —
+     * a build's own output, a fixture — reads it through the same interface as one that is
+     * streaming, and so that neither the reader nor anything under it has a resident case.
+     *
+     * @param {Uint8Array|ArrayBuffer} bytes
+     * @param {string} [name]
+     * @returns {VGeoByteSource}
+     */
+    static of(bytes, name = 'a buffer in memory') {
+        const array = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
+
+        return new VGeoByteSource(
+            array.byteLength,
+            async (offset, length) => array.subarray(offset, offset + length),
+            name
+        );
+    }
+
+    /**
+     * A source over a `File` or a `Blob` — a file dropped onto a page.
+     *
+     * Genuinely partial: `Blob.slice` names a range and the browser reads that range, so dropping a
+     * gigabyte asset costs whatever the traversal asks for and not a gigabyte of heap. That is the
+     * one case where a debug tool and a runtime want exactly the same thing.
+     *
+     * @param {Blob} blob
+     * @param {string} [name]
+     * @returns {VGeoByteSource}
+     */
+    static from_blob(blob, name = blob.name ?? 'a blob') {
+        return new VGeoByteSource(
+            blob.size,
+            async (offset, length) => new Uint8Array(
+                await blob.slice(offset, offset + length).arrayBuffer()
+            ),
+            name
+        );
+    }
+}