@woosh/meep-engine 3.41.0 → 3.42.0

package/src/shade/renderer/geometry/virtual/format/vgeo_validate_container.js

@@ -381,6 +381,12 @@ function check_header(buffer, out) {
         usable = false;
     }
 
+    if (root_page_offset >= directory_offset) {
+        out.push(new VGeoDefect(VGEO_DEFECT.HEADER, `root_page_offset ${root_page_offset} is not before directory_offset ${directory_offset}`));
+
+        usable = false;
+    }
+
     // Byte 103 was reserved through `format_version` 5 and is `level_count`'s high byte from 6 on,
     // so there is nothing left to check between it and `source_vertex_count`; the read above landed
     // at 104 and the one below expects to start there.
@@ -425,6 +431,63 @@ function check_header(buffer, out) {
     return usable;
 }
 
+/**
+ * @param {BinaryBuffer} buffer with a checked, in-file level table
+ * @param {number} level_count
+ * @param {number} total_clusters
+ * @param {number} total_groups
+ * @param {VGeoDefect[]} out
+ */
+function check_levels(buffer, level_count, total_clusters, total_groups, out) {
+    let counted_clusters = 0;
+    let counted_groups = 0;
+
+    for (let level = 0; level < level_count; level++) {
+        const base = VGEO_HEADER_SIZE + level * VGEO_LEVEL_RECORD_SIZE;
+
+        buffer.position = base;
+
+        const min_error = buffer.readFloat32();
+        const max_error = buffer.readFloat32();
+
+        if (!Number.isFinite(min_error) || min_error < 0) {
+            out.push(new VGeoDefect(VGEO_DEFECT.HEADER, `level ${level}: min_error ${min_error} must be finite and non-negative`));
+        }
+
+        if (!Number.isFinite(max_error) || max_error < 0) {
+            out.push(new VGeoDefect(VGEO_DEFECT.HEADER, `level ${level}: max_error ${max_error} must be finite and non-negative`));
+        }
+
+        if (min_error > max_error) {
+            out.push(new VGeoDefect(VGEO_DEFECT.HEADER, `level ${level}: min_error ${min_error} exceeds max_error ${max_error}`));
+        }
+
+        buffer.position = base + 12;
+
+        const cluster_count = buffer.readUint32();
+        const group_count = buffer.readUint32();
+
+        if (cluster_count === 0) {
+            out.push(new VGeoDefect(VGEO_DEFECT.HEADER, `level ${level}: cluster_count is 0`));
+        }
+
+        if (group_count === 0) {
+            out.push(new VGeoDefect(VGEO_DEFECT.HEADER, `level ${level}: group_count is 0`));
+        }
+
+        counted_clusters += cluster_count;
+        counted_groups += group_count;
+    }
+
+    if (counted_clusters !== total_clusters) {
+        out.push(new VGeoDefect(VGEO_DEFECT.HEADER, `level table holds ${counted_clusters} clusters, header says ${total_clusters}`));
+    }
+
+    if (counted_groups !== total_groups) {
+        out.push(new VGeoDefect(VGEO_DEFECT.HEADER, `level table holds ${counted_groups} groups, header says ${total_groups}`));
+    }
+}
+
 /**
  * @param {BinaryBuffer} buffer whole file
  * @param {VGeoDefect[]} out
@@ -865,6 +928,7 @@ function check_page_nodes(pages, page_groups, page_clusters, out) {
          * @type {Int32Array}
          */
         const group_hits = new Int32Array(groups.length);
+        const node_hits = new Int32Array(nodes.length);
 
         let structural = true;
 
@@ -902,12 +966,31 @@ function check_page_nodes(pages, page_groups, page_clusters, out) {
 
                 structural = false;
             }
+
+            for (let i = 0; i < node.child_count; i++) {
+                node_hits[node.child_first + i]++;
+            }
         });
 
         if (!structural) {
             continue;
         }
 
+        // Strictly forward children with one parent per non-root node form one rooted tree.
+        for (let index = 0; index < nodes.length; index++) {
+            const expected = index === 0 ? 0 : 1;
+
+            if (node_hits[index] !== expected) {
+                out.push(new VGeoDefect(VGEO_DEFECT.PAGE_LAYOUT, `page ${page.page_index} node ${index}: has ${node_hits[index]} incoming node references, expected ${expected}`));
+
+                structural = false;
+            }
+        }
+
+        if (!structural) {
+            continue;
+        }
+
         const unreached = group_hits.reduce((count, hits) => count + (hits === 0 ? 1 : 0), 0);
         const repeated = group_hits.reduce((count, hits) => count + (hits > 1 ? 1 : 0), 0);
 
@@ -1847,6 +1930,8 @@ export async function vgeo_validate_container(buffer) {
     const total_clusters = Number(buffer.readUint64());
     const total_groups = Number(buffer.readUint64());
 
+    check_levels(buffer, level_count, total_clusters, total_groups, out);
+
     buffer.position = VGEO_HEADER_OFFSET.OBJECT_SPHERE;
 
     const object_sphere = read_sphere(buffer);

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

@@ -1 +1 @@
-{"version":3,"file":"GPUVirtualGeometryRuntime.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/GPUVirtualGeometryRuntime.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IAiHI;;;;;;;;;;;;;;;OAeG;IACH;QAd2C,IAAI,EAApC,sBAAsB;QACL,aAAa,GAA9B,MAAM;QACW,qBAAqB,GAAtC,MAAM;QAEW,mBAAmB,GAApC,MAAM;QAEW,cAAc,GAA/B,MAAM;QACW,cAAc,GAA/B,MAAM;QAEW,qBAAqB,GAAtC,MAAM;QACW,aAAa,GAA9B,MAAM;OAgFhB;IAzKD;;;;OAIG;IACH,KAFU,MAAM,CAER;IAER;;OAEG;IACH,cAFU,OAAO,CAEG;IAiKpB;;OAEG;IACH,yEAEC;IAED;;;;OAIG;IACH,4BAEC;IAED;;OAEG;IACH,6BAEC;IAED;;OAEG;IACH,kCAEC;IAED;;;;;OAKG;IACH,6BAEC;IAED;;;;OAIG;IACH,gCAEC;IAWD;;;;;;OAMG;IACH,iCAKC;IArBD;;;;OAIG;IACH,4BAEC;IAgBD;;;;OAIG;IACH,0BAEC;IAED;;;;OAIG;IACH,yDAEC;IAED;;;;;OAKG;IACH,2BAEC;IAED;;OAEG;IACH;;;;;;;;MAEC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH;QAHgC,IAAI,EAAzB,WAAW;QACT,IAAI,CAoChB;IAwBD;;;;;;;;;;OAUG;IACH,cAHW,WAAW,GACT,MAAM,CA0BlB;IAED;;;;;;OAMG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,eAFa,WAAW,EAAE,EAAE,CAI3B;IAED;;;;;;;;;OASG;IACH,mBAHW,UAAU,GACR,MAAM,CAkClB;IAED;;;;;;;;;;;;OAYG;IACH,wBAJW,UAAU,UACV,MAAM,GACJ,IAAI,CAOhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH;QAJ2B,iBAAiB,EAAjC,MAAM;QACU,gBAAgB,EAAhC,MAAM;QACJ,IAAI,CAahB;IAED;;OAEG;IACH,gCAEC;IAED;;OAEG;IACH,+BAEC;IAED;;;;;OAKG;IACH,aAFa,IAAI,CAKhB;IAED;;;;;;;;OAQG;IACH,WAFa,IAAI,CAOhB;;CACJ;qCArnBY,OAAO,6BAA6B,EAAE,sBAAsB;0BAC5D,OAAO,kBAAkB,EAAE,WAAW;yBACtC,OAAO,iEAAiE,EAAE,UAAU"}
+{"version":3,"file":"GPUVirtualGeometryRuntime.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/GPUVirtualGeometryRuntime.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IAmHI;;;;;;;;;;;;;;;OAeG;IACH;QAd2C,IAAI,EAApC,sBAAsB;QACL,aAAa,GAA9B,MAAM;QACW,qBAAqB,GAAtC,MAAM;QAEW,mBAAmB,GAApC,MAAM;QAEW,cAAc,GAA/B,MAAM;QACW,cAAc,GAA/B,MAAM;QAEW,qBAAqB,GAAtC,MAAM;QACW,aAAa,GAA9B,MAAM;OAgFhB;IA3KD;;;;OAIG;IACH,KAFU,MAAM,CAER;IAER;;OAEG;IACH,cAFU,OAAO,CAEG;IAmKpB;;OAEG;IACH,yEAEC;IAED;;;;OAIG;IACH,4BAEC;IAED;;OAEG;IACH,6BAEC;IAED;;OAEG;IACH,kCAEC;IAED;;;;;OAKG;IACH,6BAEC;IAED;;;;OAIG;IACH,gCAEC;IAWD;;;;;;OAMG;IACH,iCAKC;IArBD;;;;OAIG;IACH,4BAEC;IAgBD;;;;OAIG;IACH,0BAEC;IAED;;;;OAIG;IACH,yDAEC;IAED;;;;;OAKG;IACH,2BAEC;IAED;;OAEG;IACH;;;;;;;;MAEC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH;QAHgC,IAAI,EAAzB,WAAW;QACT,IAAI,CAqChB;IAwBD;;;;;;;;;;OAUG;IACH,cAHW,WAAW,GACT,MAAM,CA0BlB;IAED;;;;;;OAMG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,eAFa,WAAW,EAAE,EAAE,CAI3B;IAED;;;;;;;;;OASG;IACH,mBAHW,UAAU,GACR,MAAM,CAkClB;IAED;;;;;;;;;;;;OAYG;IACH,wBAJW,UAAU,UACV,MAAM,GACJ,IAAI,CAOhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH;QAJ2B,iBAAiB,EAAjC,MAAM;QACU,gBAAgB,EAAhC,MAAM;QACJ,IAAI,CAgBhB;IAED;;OAEG;IACH,gCAEC;IAED;;OAEG;IACH,+BAEC;IAED;;;;;OAKG;IACH,aAFa,IAAI,CAKhB;IAED;;;;;;;;OAQG;IACH,WAFa,IAAI,CAOhB;;CACJ;qCA3nBY,OAAO,6BAA6B,EAAE,sBAAsB;0BAC5D,OAAO,kBAAkB,EAAE,WAAW;yBACtC,OAAO,iEAAiE,EAAE,UAAU"}

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

@@ -150,6 +150,8 @@ export class GPUVirtualGeometryRuntime {
      */
     #instance_capacity = 0;
 
+    #collections_declared = false;
+
     /**
      * @type {number}
      */
@@ -414,6 +416,7 @@ export class GPUVirtualGeometryRuntime {
          that runs against it appends nothing rather than appending past the end of a collection
          whose real size it was never told.
          */
+        this.#collections_declared = false;
         this.#instance_capacity = 0;
         this.#meshlet_capacity = 0;
     }
@@ -583,13 +586,16 @@ export class GPUVirtualGeometryRuntime {
         assert.isNonNegativeInteger(instance_capacity, 'instance_capacity');
         assert.isNonNegativeInteger(meshlet_capacity, 'meshlet_capacity');
 
-        this.#instance_capacity = this.#instance_capacity === 0
-            ? instance_capacity
-            : Math.min(this.#instance_capacity, instance_capacity);
+        if (!this.#collections_declared) {
+            this.#instance_capacity = instance_capacity;
+            this.#meshlet_capacity = meshlet_capacity;
+            this.#collections_declared = true;
+
+            return;
+        }
 
-        this.#meshlet_capacity = this.#meshlet_capacity === 0
-            ? meshlet_capacity
-            : Math.min(this.#meshlet_capacity, meshlet_capacity);
+        this.#instance_capacity = Math.min(this.#instance_capacity, instance_capacity);
+        this.#meshlet_capacity = Math.min(this.#meshlet_capacity, meshlet_capacity);
     }
 
     /**

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

@@ -1 +1 @@
-{"version":3,"file":"VGeoPageFetcher.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/VGeoPageFetcher.js"],"names":[],"mappings":"AAIA;;;GAGG;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH;IAgFI;;;;;;OAMG;IACH;QAL4B,YAAY,GAA7B,MAAM;QACuB,WAAW,SAA5B,MAAM;OAS5B;IAED;;OAEG;IACH,2BAEC;IAED;;;OAGG;IACH,iCAEC;IAED;;;OAGG;IACH,qCAEC;IAED;;OAEG;IACH,4BAEC;IAED;;;OAGG;IACH,gCAEC;IAED;;;;;;;OAOG;IACH,cAPW,mBAAmB,cACnB,MAAM,gBACN,MAAM,cACN,MAAM,WACN,WAAW,GACT,QAAQ,QAAQ,CAAC,CAqB7B;IAED;;;;;;OAMG;IACH,eAHW,mBAAmB,GACjB,MAAM,CAkClB;IAED;;;;;OAKG;IACH,WAFa,IAAI,CAsBhB;;CAgOJ;kCAzdY,OAAO,uCAAuC,EAAE,mBAAmB;uBACnE,OAAO,4BAA4B,EAAE,QAAQ"}
+{"version":3,"file":"VGeoPageFetcher.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/VGeoPageFetcher.js"],"names":[],"mappings":"AAIA;;;GAGG;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH;IAgFI;;;;;;OAMG;IACH;QAL4B,YAAY,GAA7B,MAAM;QACuB,WAAW,SAA5B,MAAM;OAS5B;IAED;;OAEG;IACH,2BAEC;IAED;;;OAGG;IACH,iCAEC;IAED;;;OAGG;IACH,qCAEC;IAED;;OAEG;IACH,4BAEC;IAED;;;OAGG;IACH,gCAEC;IAED;;;;;;;OAOG;IACH,cAPW,mBAAmB,cACnB,MAAM,gBACN,MAAM,cACN,MAAM,WACN,WAAW,GACT,QAAQ,QAAQ,CAAC,CA4B7B;IAED;;;;;;OAMG;IACH,eAHW,mBAAmB,GACjB,MAAM,CAkClB;IAED;;;;;OAKG;IACH,WAFa,IAAI,CAsBhB;;CAgOJ;kCAheY,OAAO,uCAAuC,EAAE,mBAAmB;uBACnE,OAAO,4BAA4B,EAAE,QAAQ"}

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

@@ -174,6 +174,13 @@ export class VGeoPageFetcher {
             );
         }
 
+        if (signal?.aborted) {
+            return Promise.reject(new VGeoFetchError(
+                `page ${page_index}: the fetch was cancelled`, false,
+                String(signal.reason?.message ?? signal.reason)
+            ));
+        }
+
         if (this.#worker_count > 0 && !this.#no_workers && reader.source.descriptor !== undefined) {
             const worker = this.#worker_for();
 

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

@@ -1 +1 @@
-{"version":3,"file":"VGeoRuntimeTables.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/VGeoRuntimeTables.js"],"names":[],"mappings":"AAmBA;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH;IAmKI;;;;;;;;OAQG;IACH;QAP4B,aAAa,GAA9B,MAAM;QACW,SAAS,GAA1B,MAAM;QAEW,UAAU,GAA3B,MAAM;QACW,YAAY,GAA7B,MAAM;QACW,iBAAiB,GAAlC,MAAM;OA6BhB;IAED;;OAEG;IACH,gCAEC;IAED;;OAEG;IACH,+BAEC;IAED;;OAEG;IACH,kCAEC;IAED;;OAEG;IACH,gCAEC;IAED;;OAEG;IACH,yBAEC;IAED;;OAEG;IACH,4BAEC;IAED;;;OAGG;IACH,kCAEC;IAED;;OAEG;IACH,kCAEC;IAED;;;OAGG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,wBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;;;;;OAWG;IACH,8BALW,MAAM,qBACN,MAAM,GACJ,MAAM,CAiDlB;IAED;;;;;;OAMG;IACH,kCAJW,MAAM,GACJ,MAAM,EAAE,CAgDpB;IAED;;;;OAIG;IACH,6BAJW,MAAM,SACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,0BAJW,MAAM,cACN,MAAM,GACJ,MAAM,CAQlB;IAED;;;;OAIG;IACH,qBAJW,MAAM,SACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,oBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,qBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;OAGG;IACH,uBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;;;OAQG;IACH,sBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,sBARW,MAAM,QACN,QAAQ,gBACR,MAAM,GACJ,MAAM,CAkFlB;IAED;;;;;OAKG;IACH,qBAHW,QAAQ,GACN,MAAM,CAOlB;IAED;;;;;;;;;;;;;;OAcG;IACH,gBAHW,MAAM,GACJ,OAAO,CAuCnB;IAED;;;;;;OAMG;IACH,uBAHW,MAAM,GACJ,IAAI,MAAM,CAAC,CAIvB;IAED;;;;;;;;;;OAUG;IACH,4BAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,uBAFa,MAAM,EAAE,CAQpB;IAwWD;;;;;;;;;;;;OAYG;IACH,+BALW,MAAM,SACN,MAAM,cACN,OAAO,GACL,IAAI,CAUhB;IAED;;;;OAIG;IACH,8BAJW,MAAM,SACN,MAAM,GACJ,OAAO,CAQnB;IAED;;;;;OAKG;IACH,qBAHW,MAAM,GACJ,MAAM,EAAE,CAapB;IAED;;;;;OAKG;IACH,sBAHW,MAAM,GACJ,MAAM,EAAE,CAOpB;IAED;;;;;;OAMG;IACH,2BAJW,MAAM,gBACN,MAAM,GACJ,OAAO,CAYnB;;CA4DJ;uBAjtCY,OAAO,4BAA4B,EAAE,QAAQ"}
+{"version":3,"file":"VGeoRuntimeTables.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/VGeoRuntimeTables.js"],"names":[],"mappings":"AAmBA;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH;IAmKI;;;;;;;;OAQG;IACH;QAP4B,aAAa,GAA9B,MAAM;QACW,SAAS,GAA1B,MAAM;QAEW,UAAU,GAA3B,MAAM;QACW,YAAY,GAA7B,MAAM;QACW,iBAAiB,GAAlC,MAAM;OA6BhB;IAED;;OAEG;IACH,gCAEC;IAED;;OAEG;IACH,+BAEC;IAED;;OAEG;IACH,kCAEC;IAED;;OAEG;IACH,gCAEC;IAED;;OAEG;IACH,yBAEC;IAED;;OAEG;IACH,4BAEC;IAED;;;OAGG;IACH,kCAEC;IAED;;OAEG;IACH,kCAEC;IAED;;;OAGG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,wBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;;;;;OAWG;IACH,8BALW,MAAM,qBACN,MAAM,GACJ,MAAM,CAmDlB;IAED;;;;;;OAMG;IACH,kCAJW,MAAM,GACJ,MAAM,EAAE,CAgDpB;IAED;;;;OAIG;IACH,6BAJW,MAAM,SACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,0BAJW,MAAM,cACN,MAAM,GACJ,MAAM,CAQlB;IAED;;;;OAIG;IACH,qBAJW,MAAM,SACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,oBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,qBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;OAGG;IACH,uBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;;;OAQG;IACH,sBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,sBARW,MAAM,QACN,QAAQ,gBACR,MAAM,GACJ,MAAM,CAkFlB;IAED;;;;;OAKG;IACH,qBAHW,QAAQ,GACN,MAAM,CAOlB;IAED;;;;;;;;;;;;;;OAcG;IACH,gBAHW,MAAM,GACJ,OAAO,CAuCnB;IAED;;;;;;OAMG;IACH,uBAHW,MAAM,GACJ,IAAI,MAAM,CAAC,CAIvB;IAED;;;;;;;;;;OAUG;IACH,4BAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,uBAFa,MAAM,EAAE,CAQpB;IAwWD;;;;;;;;;;;;OAYG;IACH,+BALW,MAAM,SACN,MAAM,cACN,OAAO,GACL,IAAI,CAUhB;IAED;;;;OAIG;IACH,8BAJW,MAAM,SACN,MAAM,GACJ,OAAO,CAQnB;IAED;;;;;OAKG;IACH,qBAHW,MAAM,GACJ,MAAM,EAAE,CAapB;IAED;;;;;OAKG;IACH,sBAHW,MAAM,GACJ,MAAM,EAAE,CAOpB;IAED;;;;;;OAMG;IACH,2BAJW,MAAM,gBACN,MAAM,GACJ,OAAO,CAYnB;;CA4DJ;uBAntCY,OAAO,4BAA4B,EAAE,QAAQ"}

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

@@ -374,7 +374,7 @@ export class VGeoRuntimeTables {
         assert.isNonNegativeInteger(page_count, 'page_count');
         assert.greaterThan(page_count, 0, 'page_count');
 
-        const recycled = this.#free_geometry_rows.pop();
+        const recycled = this.#free_geometry_rows[this.#free_geometry_rows.length - 1];
 
         const row = recycled ?? this.#geometry_row_high_water;
 
@@ -396,6 +396,8 @@ export class VGeoRuntimeTables {
 
         if (recycled === undefined) {
             this.#geometry_row_high_water = row + 1;
+        } else {
+            this.#free_geometry_rows.pop();
         }
 
         this.#geometry_allocations.set(row, allocation);

package/src/shade/renderer/loader/gltf/tiny-gltf.d.ts

@@ -13,7 +13,7 @@ export class TinyGltf {
      * @readonly
      * @type {TextureFormat}
      */
-    static readonly "__#261@#UNCOMPRESSED_TARGET": TextureFormat;
+    static readonly "__#264@#UNCOMPRESSED_TARGET": TextureFormat;
     /**
      * @param {AssetManager} assetManager
      * @param {AssetRequestScope} [scope]

package/src/shade/renderer/scene/SCENE_DATABASE_SPEC.js

@@ -24,8 +24,9 @@ export const SCENE_DATABASE_SPEC = GPUDatabaseDefinition.from({
 
 SCENE_DATABASE_SPEC.add_link({ table: 'water_bodies', field: 'node', target_database: SCENE_DATABASE_SPEC,
     target_table: 'transforms', nullable: false, owning: false });
+// Every body has its surface row: any body can carry wave particles, and its bounds are read every frame.
 SCENE_DATABASE_SPEC.add_link({ table: 'water_bodies', field: 'wave', target_database: SCENE_DATABASE_SPEC,
-    target_table: 'water_waves', nullable: true, owning: true });
+    target_table: 'water_waves', nullable: false, owning: true });
 SCENE_DATABASE_SPEC.add_link({ table: 'water_waves', field: 'node', target_database: SCENE_DATABASE_SPEC,
     target_table: 'transforms', nullable: false, owning: false });
 

package/src/shade/renderer/shader/chunk/math/fft/chunk_fft128_inverse.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Unnormalized inverse discrete Fourier transform of 128 complex values, in place:
+ * `x[m] = Σₙ X[n] · e^{+2πi·n·m/128}`.
+ *
+ * Radix-2 decimation in time over a private array: a bit-reversal permutation, then seven butterfly
+ * stages of 64 butterflies each — 448 in all, a fixed budget. One invocation transforms one line, so a
+ * kernel built on it needs no workgroup memory and no barriers.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_fft128_inverse: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_fft128_inverse.d.ts.map

package/src/shade/renderer/shader/chunk/math/fft/chunk_fft128_inverse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_fft128_inverse.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/math/fft/chunk_fft128_inverse.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,mCAFU,SAAS,CA8BU;0BAzCH,gCAAgC"}

package/src/shade/renderer/shader/chunk/math/fft/chunk_fft128_inverse.js

@@ -0,0 +1,42 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { chunk_complex_multiply } from "../complex/chunk_complex_multiply.js";
+
+/**
+ * Unnormalized inverse discrete Fourier transform of 128 complex values, in place:
+ * `x[m] = Σₙ X[n] · e^{+2πi·n·m/128}`.
+ *
+ * Radix-2 decimation in time over a private array: a bit-reversal permutation, then seven butterfly
+ * stages of 64 butterflies each — 448 in all, a fixed budget. One invocation transforms one line, so a
+ * kernel built on it needs no workgroup memory and no barriers.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_fft128_inverse = CodeChunk.from(
+    //language=WGSL
+    `
+fn fft128_inverse(data: ptr<function, array<vec2<f32>, 128>>) {
+    for (var i = 0u; i < 128u; i++) {
+        let j = reverseBits(i) >> 25u;
+        if (j > i) {
+            let swap = (*data)[i];
+            (*data)[i] = (*data)[j];
+            (*data)[j] = swap;
+        }
+    }
+    for (var stage = 0u; stage < 7u; stage++) {
+        let span = 1u << stage;
+        // e^{+iπ·offset/span}: the inverse transform's twiddle for a butterfly over 2·span values
+        let turn = 3.14159265358979 / f32(span);
+        for (var k = 0u; k < 64u; k++) {
+            let offset = k & (span - 1u);
+            let i = ((k >> stage) << (stage + 1u)) + offset;
+            let j = i + span;
+            let angle = turn * f32(offset);
+            let t = complex_multiply(vec2<f32>(cos(angle), sin(angle)), (*data)[j]);
+            let u = (*data)[i];
+            (*data)[i] = u + t;
+            (*data)[j] = u - t;
+        }
+    }
+}
+`, [chunk_complex_multiply]);

package/src/shade/renderer/shader/chunk/math/fft/chunk_fft128x4_inverse_workgroup.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Four unnormalized inverse discrete Fourier transforms of 128 complex values, cooperatively by a workgroup of
+ * 256 invocations: `x[m] = Σₙ X[n] · e^{+2πi·n·m/128}` for each of the four lines of `fft128x4_lines`.
+ *
+ * The caller writes each line's input in bit-reversed order (`X[n]` at `reverseBits(n) >> 25`), calls
+ * `fft128x4_inverse(lane)` from every invocation in uniform control flow, and reads the output in natural order.
+ * Radix-2 decimation in time: seven stages, each invocation one butterfly of one line a stage, a barrier
+ * between stages. The values live in 4 KiB of workgroup memory instead of a private array per invocation, which
+ * a 128-point line spills to local memory.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_fft128x4_inverse_workgroup: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_fft128x4_inverse_workgroup.d.ts.map

package/src/shade/renderer/shader/chunk/math/fft/chunk_fft128x4_inverse_workgroup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_fft128x4_inverse_workgroup.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/math/fft/chunk_fft128x4_inverse_workgroup.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH,+CAFU,SAAS,CAyBU;0BAtCH,gCAAgC"}

package/src/shade/renderer/shader/chunk/math/fft/chunk_fft128x4_inverse_workgroup.js

@@ -0,0 +1,39 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { chunk_complex_multiply } from "../complex/chunk_complex_multiply.js";
+
+/**
+ * Four unnormalized inverse discrete Fourier transforms of 128 complex values, cooperatively by a workgroup of
+ * 256 invocations: `x[m] = Σₙ X[n] · e^{+2πi·n·m/128}` for each of the four lines of `fft128x4_lines`.
+ *
+ * The caller writes each line's input in bit-reversed order (`X[n]` at `reverseBits(n) >> 25`), calls
+ * `fft128x4_inverse(lane)` from every invocation in uniform control flow, and reads the output in natural order.
+ * Radix-2 decimation in time: seven stages, each invocation one butterfly of one line a stage, a barrier
+ * between stages. The values live in 4 KiB of workgroup memory instead of a private array per invocation, which
+ * a 128-point line spills to local memory.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_fft128x4_inverse_workgroup = CodeChunk.from(
+    //language=WGSL
+    `
+var<workgroup> fft128x4_lines: array<vec2<f32>, 512>;
+
+fn fft128x4_inverse(lane: u32) {
+    let line = (lane >> 6u) << 7u;
+    let k = lane & 63u;
+    for (var stage = 0u; stage < 7u; stage++) {
+        workgroupBarrier();
+        let span = 1u << stage;
+        let offset = k & (span - 1u);
+        let i = line + ((k >> stage) << (stage + 1u)) + offset;
+        let j = i + span;
+        // e^{+iπ·offset/span}: the inverse transform's twiddle for a butterfly over 2·span values
+        let angle = 3.14159265358979 / f32(span) * f32(offset);
+        let t = complex_multiply(vec2<f32>(cos(angle), sin(angle)), fft128x4_lines[j]);
+        let u = fft128x4_lines[i];
+        fft128x4_lines[i] = u + t;
+        fft128x4_lines[j] = u - t;
+    }
+    workgroupBarrier();
+}
+`, [chunk_complex_multiply]);

package/src/shade/renderer/shader/resource/ShaderResourceSetDescriptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShaderResourceSetDescriptor.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/resource/ShaderResourceSetDescriptor.js"],"names":[],"mappings":"AAuIA;IAoBI;;OAEG;IACH;cAFoB,MAAM;cAAQ,UAAU;MAI3C;IAED;;;;;OAKG;IACH,4BAMC;IAED;;;;;;;;;;;;OAYG;IACH,mBALW,MAAM,SACN,UAAU,GAAC,MAAM,GAEf,IAAI,CAoDhB;IAED;;;OAGG;IACH,8CAEC;IAGD;;;OAGG;IACH,6CAEC;IAaD;;;;OAIG;IACH;;;;;;;;;;;OAWG;IACH,sBAHW,MAAM,GACJ,OAAO,CAInB;IAED,+FAYC;IAED;;;;;;OAMG;IACH;QAJ4B,KAAK,GAAtB,MAAM;QACW,KAAK,GAAtB,MAAM;QACJ,6BAA6B,CAsBzC;IAED;;;;OAIG;IACH,gBAHW,6BAA6B,GAC3B,OAAO,CAQnB;IAED;;;OAGG;IACH,qBAFW,iBAAe,MAAM,QAW/B;IAED;;OAEG;IACH,oCAFa,wBAAwB,CAiBpC;IAED;;;OAGG;IACH,yBAFY,EAAE,EAAE,CAcf;IAED;;;;OAIG;IACH,8BAHW,iBAAe,MAAM,GACnB,wBAAwB,CAMpC;IAED;;;;;OAKG;IACH,qCAHW,sBAAsB,GACpB,oBAAoB,EAAE,CAgBlC;IAED;;;OAGG;IACH,qBAFY,SAAS,CAwGpB;IAED;;;;;;;;;;;;;;;OAeG;IACH,iCAHW,YAAY,GACV,OAAO,CAwFnB;;CACJ;;eA2BS,SAAS,2BAA2B,CAAC;;2BA1oBlC,OAAO,yCAAyC,EAAE,YAAY;qCAC9D,OAAO,2CAA2C,EAAE,sBAAsB;yBAC1E,OAAO,uBAAuB,EAAE,UAAU;8CALT,oCAAoC;yCAZzC,0DAA0D;0BAIzE,0BAA0B"}
+{"version":3,"file":"ShaderResourceSetDescriptor.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/resource/ShaderResourceSetDescriptor.js"],"names":[],"mappings":"AAyIA;IAoBI;;OAEG;IACH;cAFoB,MAAM;cAAQ,UAAU;MAI3C;IAED;;;;;OAKG;IACH,4BAMC;IAED;;;;;;;;;;;;OAYG;IACH,mBALW,MAAM,SACN,UAAU,GAAC,MAAM,GAEf,IAAI,CAoDhB;IAED;;;OAGG;IACH,8CAEC;IAGD;;;OAGG;IACH,6CAEC;IAaD;;;;OAIG;IACH;;;;;;;;;;;OAWG;IACH,sBAHW,MAAM,GACJ,OAAO,CAInB;IAED,+FAYC;IAED;;;;;;OAMG;IACH;QAJ4B,KAAK,GAAtB,MAAM;QACW,KAAK,GAAtB,MAAM;QACJ,6BAA6B,CAsBzC;IAED;;;;OAIG;IACH,gBAHW,6BAA6B,GAC3B,OAAO,CAQnB;IAED;;;OAGG;IACH,qBAFW,iBAAe,MAAM,QAW/B;IAED;;OAEG;IACH,oCAFa,wBAAwB,CAiBpC;IAED;;;OAGG;IACH,yBAFY,EAAE,EAAE,CAcf;IAED;;;;OAIG;IACH,8BAHW,iBAAe,MAAM,GACnB,wBAAwB,CAMpC;IAED;;;;;OAKG;IACH,qCAHW,sBAAsB,GACpB,oBAAoB,EAAE,CAgBlC;IAED;;;OAGG;IACH,qBAFY,SAAS,CAwGpB;IAED;;;;;;;;;;;;;;;OAeG;IACH,iCAHW,YAAY,GACV,OAAO,CAwFnB;;CACJ;;eA2BS,SAAS,2BAA2B,CAAC;;2BA5oBlC,OAAO,yCAAyC,EAAE,YAAY;qCAC9D,OAAO,2CAA2C,EAAE,sBAAsB;yBAC1E,OAAO,uBAAuB,EAAE,UAAU;8CALT,oCAAoC;yCAZzC,0DAA0D;0BAIzE,0BAA0B"}

package/src/shade/renderer/shader/resource/ShaderResourceSetDescriptor.js

@@ -83,6 +83,8 @@ function gen_type_storage_texture(member) {
 
     if (member.viewDimension === "2d") {
         proper_type = "texture_storage_2d"
+    } else if (member.viewDimension === "2d-array") {
+        proper_type = "texture_storage_2d_array";
     } else if (member.viewDimension === "3d") {
         proper_type = "texture_storage_3d";
     } else {

package/src/shade/renderer/water/GPUWaterRenderer.d.ts

@@ -23,6 +23,21 @@ export class GPUWaterRenderer {
      * @type {import("./medium/GPUWaterBodies.js").GPUWaterBodies|null}
      */
     bodies: import("./medium/GPUWaterBodies.js").GPUWaterBodies | null;
+    /**
+     * What the lattice's per-frame lists may hold (WATER_SURFACE_DISTANCE_LOD_PROPOSAL_2026_10_06.md §4.3). Grown from
+     * each view's totals, read back a frame or two later; a frame over a budget drops its tail until then.
+     */
+    lod_budgets: {
+        candidates: number;
+        interior: number;
+        boundary: number;
+        patches: number;
+    };
+    /**
+     * The lists' totals as the last read back frame needed them: candidates, interior cells, boundary cells, triangles
+     * drawn as themselves, patches.
+     */
+    lod_totals: Uint32Array;
     avboit_is_empty(view: any): boolean;
     /** Optional single-pixel readback on the next rendered water frame. No per-frame readback. */
     request_probe(uv: any): Promise<any>;

package/src/shade/renderer/water/GPUWaterRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUWaterRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/GPUWaterRenderer.js"],"names":[],"mappings":"AAmBA,sFAAsF;AACtF;IACI,WAAa;IACb,mBAAe;IACf,yBAAqB;IACrB,aAAS;IACT,WAAa;IACb;;;;;;;;;;;MAE6B;IAC7B;;;;OAIG;IACH,QAFU,OAAO,4BAA4B,EAAE,cAAc,GAAC,IAAI,CAEpD;IAQd,oCAIC;IAED,8FAA8F;IAC9F,qCAgBC;IAED,gBAKC;IAED;;;;;;;;;;;;;;;;MAyIC;IAQD;;;;;YAMC;IAED;;;;;;;;;;MAOC;IAED;;;;;;;;;;;;;;MAwBC;IAED,gGAAgG;IAChG,mEAYC;;CA4BJ"}
+{"version":3,"file":"GPUWaterRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/GPUWaterRenderer.js"],"names":[],"mappings":"AAqBA,sFAAsF;AACtF;IACI,WAAa;IACb,mBAAe;IACf,yBAAqB;IACrB,aAAS;IACT,WAAa;IACb;;;;;;;;;;;MAE6B;IAC7B;;;;OAIG;IACH,QAFU,OAAO,4BAA4B,EAAE,cAAc,GAAC,IAAI,CAEpD;IAOd;;;OAGG;IACH;;;;;MAA8F;IAC9F;;;OAGG;IACH,wBAAyD;IAMzD,oCAIC;IAED,8FAA8F;IAC9F,qCAgBC;IAED,gBASC;IAuDD;;;;;;;;;;;;;;;;MAgJC;IAQD;;;;;YAMC;IAED;;;;;;;;;;MAOC;IAED;;;;;;;;;;;;;;MAwBC;IAED,gGAAgG;IAChG,mEAYC;;CA4BJ"}

package/src/shade/renderer/water/GPUWaterRenderer.js

@@ -3,16 +3,18 @@ import { DEFAULT_DEPTH_TEXTURE_VIEW } from "../depth/DEFAULT_DEPTH_TEXTURE_VIEW.
 import { graph_compute_pass } from "../shader/graph/compute/graph_compute_pass.js";
 import { graph_image_pass } from "../shader/graph/graph_image_pass.js";
 import { ShadeIndirectLightingMode } from "../ShadeIndirectLightingMode.js";
-import { BufferResourceDescriptor } from "../../device/graph/BufferResourceDescriptor.js";
-import { build_indirect_draw_command } from "../gpu_primitive/indirect/build_indirect_draw_command.js";
 import { graph_water_tessellation } from "./surface/graph_water_tessellation.js";
-import { WATER_TESSELLATION_STRUCT, WATER_TILE_VERTEX_COUNT } from "./surface/chunk_water_tessellation.js";
+import { water_lod_view, WATER_LOD_VIEW_STRUCT } from "./surface/lod/WATER_LOD.js";
+import { WATER_LOD_LIMITS_STRUCT, WATER_LOD_PATCH_INDICES, WATER_LOD_STATISTICS_WORDS,
+    WaterLodCommand } from "./surface/lod/shader_water_lod.js";
+import { GEOMETRY_MESHLET_TRIANGLE_LIMIT } from "../geometry/meshlet/GEOMETRY_MESHLET_TRIANGLE_LIMIT.js";
 import { STATIC_GRAPHICS_ENGINE_ASSETS } from "../STATIC_GRAPHICS_ENGINE_ASSETS.js";
 import { SAMPLER_LINEAR_UPSCALE } from "../texture/SAMPLER_LINEAR_UPSCALE.js";
 import { SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR } from "../shadow/map/SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR.js";
 import { create_water_finalize_pipeline_brick4, create_water_finalize_pipeline_ibl, create_water_pipeline,
     WATER_FINALIZE_RESOURCES_BRICK4, WATER_FINALIZE_RESOURCES_IBL, WATER_RESOURCES,
-    WATER_TRACE_STRUCT, WATER_GRID_STRUCT } from "./shader_water.js";
+    WATER_TRACE_STRUCT } from "./shader_water.js";
+import { WATER_BAND_SAMPLER } from "./surface/GPUWaterSurface.js";
 import { shader_water_background_copy, shader_water_debug, shader_water_draw,
     shader_water_occupancy, shader_water_splat, shader_water_confidence_seed,
     shader_water_confidence_x, shader_water_confidence_y } from "./shader_water_avboit.js";
@@ -39,6 +41,20 @@ export class GPUWaterRenderer {
     #prepared = new WeakMap();
     #inspection = new WeakMap();
     #probe = null;
+    /**
+     * What the lattice's per-frame lists may hold (WATER_SURFACE_DISTANCE_LOD_PROPOSAL_2026_10_06.md §4.3). Grown from
+     * each view's totals, read back a frame or two later; a frame over a budget drops its tail until then.
+     */
+    lod_budgets = { candidates: 1 << 16, interior: 1 << 18, boundary: 1 << 16, patches: 1 << 12 };
+    /**
+     * The lists' totals as the last read back frame needed them: candidates, interior cells, boundary cells, triangles
+     * drawn as themselves, patches.
+     */
+    lod_totals = new Uint32Array(WATER_LOD_STATISTICS_WORDS);
+    /** Readback buffers for the lists' totals, idle ones first. */
+    #readbacks = [];
+    /** The patches' index buffer, one per device. */
+    #patch_indices = null;
 
     avboit_is_empty(view) {
         // the authored state: whether there is water at all, not whether its surface was produced yet
@@ -70,29 +86,100 @@ export class GPUWaterRenderer {
         this.#probe = null;
         this.#prepared = new WeakMap();
         this.#inspection = new WeakMap();
+        for (const readback of this.#readbacks) { readback.buffer.destroy(); }
+        this.#readbacks = [];
+        this.#patch_indices?.buffer.destroy();
+        this.#patch_indices = null;
+    }
+
+    /** The patches' indices on this device, made the first time a frame draws there. */
+    #patch_index_buffer(device) {
+        if (this.#patch_indices?.device !== device) {
+            this.#patch_indices?.buffer.destroy();
+            const buffer = device.createBuffer({ label: 'Water / lod patch indices', size: WATER_LOD_PATCH_INDICES.byteLength,
+                usage: GPUBufferUsage.INDEX, mappedAtCreation: true });
+            new Uint16Array(buffer.getMappedRange()).set(WATER_LOD_PATCH_INDICES);
+            buffer.unmap();
+            this.#patch_indices = { device, buffer };
+        }
+        return this.#patch_indices.buffer;
+    }
+
+    /** Keep a frame's totals and grow the budgets they outran, to the next power of two over a quarter more. */
+    #grow(totals) {
+        this.lod_totals.set(totals);
+        const budgets = this.lod_budgets;
+        // statistics words: candidates, interior, boundary, flat triangles (sized by the scene, not grown), patches
+        const keys = { candidates: 0, interior: 1, boundary: 2, patches: 4 };
+        for (const [key, i] of Object.entries(keys)) {
+            if (totals[i] > budgets[key]) { budgets[key] = 2 ** Math.ceil(Math.log2(totals[i] * 1.25)); }
+        }
+    }
+
+    /** After the lists are built, their totals to the CPU: at most three in flight, none if all are busy. */
+    #record_readback(graph, statistics) {
+        const data = {};
+        const pass = graph.add('Water / lod budgets', data, (d, resources, { encoder, graphics }) => {
+            // buffers of a device that has since been replaced go with it
+            this.#readbacks = this.#readbacks.filter(r => r.device === graphics.device || (r.buffer.destroy(), false));
+            let readback = this.#readbacks.find(r => !r.busy);
+            if (readback === undefined) {
+                if (this.#readbacks.length >= 3) { return; }
+                readback = { busy: false, device: graphics.device, buffer: graphics.device.createBuffer({ label: 'Water / lod budgets readback',
+                    size: WATER_LOD_STATISTICS_WORDS * 4, usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST }) };
+                this.#readbacks.push(readback);
+            }
+            readback.busy = true;
+            encoder.copyBufferToBuffer(resources.get(d.statistics), 0, readback.buffer, 0, WATER_LOD_STATISTICS_WORDS * 4);
+            encoder.done.then(async () => {
+                try {
+                    await readback.buffer.mapAsync(GPUMapMode.READ);
+                    this.#grow(new Uint32Array(readback.buffer.getMappedRange()));
+                    readback.buffer.unmap();
+                } catch (error) {
+                    // a device lost or a buffer destroyed with the system: nothing to grow for
+                } finally { readback.busy = false; }
+            });
+        });
+        data.statistics = pass.read(statistics);
+        pass.make_side_effect();
     }
 
     avboit_prepare({ graph, view_ctx, camera, color_texture, depth_texture, normal_texture,
         hzb_texture, environment_texture, light_cluster_parameters, light_cluster_lookup, light_cluster_data,
         shadowmap_atlas, indirect_lighting_mode = ShadeIndirectLightingMode.IBL }) {
         const scene = view_ctx.scene;
-        const meshlets = this.bodies.meshlets({ graph, view: view_ctx, camera, meshlet_capacity: this.meshlet_capacity });
         const settings = { ...this.settings };
         const probe = this.#probe;
         this.#probe = null;
         const resolution = Array.from(view_ctx.resolution);
-        const pixels = Math.max(1, settings.tessellation_pixels);
-        // Jitter moves raster samples, not the mesh sampling the simulation. A jittered
-        // reference would change displaced geometry and normals even while waves are paused.
-        const tessellation = { resolution, pixels,
-            view_projection_matrix: Float32Array.from(view_ctx.camera.camera.view_projection_matrix) };
-        const patches = graph_water_tessellation({ graph, scene, camera, meshlets,
-            meshlet_capacity: this.meshlet_capacity, tessellation });
+        const surface = this.waves;
+        // the lattice is chosen from the camera's position and its pixel angle, not its jittered projection's offset:
+        // raster jitter moves samples, not the mesh
+        const lod = water_lod_view(view_ctx.camera.camera.projection_matrix, resolution[1], Math.max(0.5, settings.tessellation_pixels));
+        const { meshlets, lod_bodies } = this.bodies.meshlets({ graph, view: view_ctx, camera, meshlet_capacity: this.meshlet_capacity,
+            visible_rows: surface.visible_rows, lod, steep: surface.steep });
+        const limits = { ...this.lod_budgets, triangles: Math.max(this.meshlet_capacity, 1) * GEOMETRY_MESHLET_TRIANGLE_LIMIT };
+        const patches = graph_water_tessellation({ graph, scene, camera, meshlets, lod_bodies, meshlet_capacity: this.meshlet_capacity,
+            lod, limits, steep: surface.steep });
+        this.#record_readback(graph, patches.statistics);
         const data = { resolution, frame_time: this.time };
-        const wave_state = this.waves.buffer, wave_resolution = this.waves.grid_resolution;
-        const geometry_bindings = () => ({ scene_database: scene.scene_database_buffer,
+        // the surface interface: the band tiles and the frame's particle hash; and the view's lattice
+        const geometry_bindings = (graphics, encoder, resources, d) => ({ scene_database: scene.scene_database_buffer,
             meshlet_metadata: scene.geometries.meshlets.buffer_metadata, meshlet_data: scene.geometries.meshlets.buffer_data,
-            wave_state });
+            water_band_displacement: surface.displacement, water_band_derivatives: surface.derivatives,
+            water_band_sampler: graphics.samplers.obtain(WATER_BAND_SAMPLER),
+            water_particle_offsets: surface.particle_offsets, water_particle_entries: surface.particle_entries,
+            lod: encoder.allocateTransientValueBuffer(WATER_LOD_VIEW_STRUCT, lod),
+            lod_limits: encoder.allocateTransientValueBuffer(WATER_LOD_LIMITS_STRUCT, limits),
+            water_lod_bodies: resources.get(d.lod_bodies), water_lod_candidates: resources.get(d.candidates),
+            water_lod_cells: resources.get(d.cells) });
+        // the interior, boundary and triangle lists' draws, and the patches'
+        const draw = (render, commands, device) => {
+            for (let list = 0; list < 3; list++) { render.drawIndirect(commands, WaterLodCommand.Draws + 16 * list); }
+            render.setIndexBuffer(this.#patch_index_buffer(device), 'uint16');
+            render.drawIndexedIndirect(commands, WaterLodCommand.PatchDraw);
+        };
         const pipeline = this.#pipeline;
         const pass = graph.add("Water / receivers", data, (data, resources, context) => {
             const { encoder, graphics } = context;
@@ -104,13 +191,7 @@ export class GPUWaterRenderer {
                 tHZB: resources.get(data.hzb).obtainView(),
                 tScene: resources.get(data.color).obtainView(),
             };
-            const command = resources.get(data.command);
-            build_indirect_draw_command(graphics.device, `${WATER_TILE_VERTEX_COUNT}, input, 0, 0`,
-                encoder, resources.get(data.patch_count), command);
-            const bindings = WATER_RESOURCES.generateBindings({ ...shared, ...geometry_bindings(),
-                wave_grid: encoder.allocateTransientValueBuffer(WATER_GRID_STRUCT, { resolution: wave_resolution }),
-                water_tiles: resources.get(data.tiles), water_tile_sums: resources.get(data.sums),
-                tessellation: encoder.allocateTransientValueBuffer(WATER_TESSELLATION_STRUCT, tessellation) }, encoder);
+            const bindings = WATER_RESOURCES.generateBindings({ ...shared, ...geometry_bindings(graphics, encoder, resources, data) }, encoder);
             const render = encoder.constructRenderPass({ label: "Water / receivers", pipeline, bindings: [],
                 colorAttachments: [data.receiver, data.trace_metadata].map(handle => ({
                     view: resources.get(handle).obtainView(), loadOp: "clear", storeOp: "store", clearValue: [0,0,0,0],
@@ -119,7 +200,7 @@ export class GPUWaterRenderer {
                     depthLoadOp: "clear", depthStoreOp: "store", depthClearValue: 0 },
             });
             graphics.setPipelineBindings(render, pipeline, bindings);
-            render.drawIndirect(command, 0);
+            draw(render, resources.get(data.commands), graphics.device);
             render.end();
         });
         for (const [name, handle] of Object.entries({ camera, color: color_texture, scene_depth: depth_texture,
@@ -128,8 +209,8 @@ export class GPUWaterRenderer {
             resolution, format, usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING
                 | (probe !== null && format !== "depth32float" ? GPUTextureUsage.COPY_SRC : 0),
         }));
-        data.tiles = pass.read(patches.tiles); data.sums = pass.read(patches.sums); data.patch_count = pass.read(patches.count);
-        data.command = pass.create('Water draw command', BufferResourceDescriptor.from(16, GPUBufferUsage.STORAGE | GPUBufferUsage.INDIRECT));
+        data.lod_bodies = pass.read(lod_bodies); data.candidates = pass.read(patches.candidates); data.cells = pass.read(patches.cells);
+        data.commands = pass.read(patches.commands);
         // Keep the accepted UV and both paths at f32 precision through final shading.
         data.receiver = target("receiver", "rgba32float");
         data.trace_metadata = target("trace metadata", "rgba32float");
@@ -164,9 +245,7 @@ export class GPUWaterRenderer {
                 tScene: resources.get(d.color).obtainView(),
                 receiver: resources.get(d.receiver).obtainView(), trace_metadata: resources.get(d.trace_metadata).obtainView(),
                 visibility_distance: resources.get(d.visibility_distance).obtainView(),
-                ...geometry_bindings(), water_tiles: resources.get(d.tiles), water_tile_sums: resources.get(d.sums),
-                tessellation: encoder.allocateTransientValueBuffer(WATER_TESSELLATION_STRUCT, tessellation),
-                wave_grid: encoder.allocateTransientValueBuffer(WATER_GRID_STRUCT, { resolution: wave_resolution }),
+                ...geometry_bindings(graphics, encoder, resources, d),
                 // the lights, as the transparent meshes bind them
                 light_data: view_ctx.scene.lights.buffer_data,
                 tEnvironment: resources.get(d.environment).obtainView(),
@@ -192,10 +271,11 @@ export class GPUWaterRenderer {
             graphics.setPipelineBindings(render, copy_pipeline, copy_bindings); render.draw(3);
             render.setPipeline(graphics.render_pipelines.obtain(finalize_pipeline)); render.record_pipeline(finalize_pipeline);
             graphics.setPipelineBindings(render, finalize_pipeline, bindings);
-            render.drawIndirect(resources.get(d.command), 0);
+            draw(render, resources.get(d.commands), graphics.device);
             render.end();
         });
-        for (const key of ['camera','scene_depth','normal','hzb','color','receiver','trace_metadata','visibility_distance','interface_depth','tiles','sums','command']) {
+        for (const key of ['camera','scene_depth','normal','hzb','color','receiver','trace_metadata','visibility_distance','interface_depth',
+            'lod_bodies','candidates','cells','commands']) {
             finalize_data[key] = finalize.read(data[key]);
         }
         for (const [key, handle] of Object.entries({ environment: environment_texture, light_cluster_parameters,