@woosh/meep-engine 3.63.2 → 3.63.3

package/package.json

@@ -6,7 +6,7 @@
   "description": "Advanced 3D game engine",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "3.63.2",
+  "version": "3.63.3",
   "exports": {
     "./build/*": "./build/*",
     "./src/*": "./src/*",

package/src/shade/device/mock/SoftwareGPUCommandEncoder.d.ts

@@ -30,6 +30,23 @@ export class SoftwareGPUCommandEncoder extends SoftwareGPUObjectBase implements
      * @type {(SoftwareGPUComputePassEncoder|SoftwareGPURenderPassEncoder)[]}
      */
     passes: (SoftwareGPUComputePassEncoder | SoftwareGPURenderPassEncoder)[];
+    /**
+     * Everything encoded on this encoder, in the order it was encoded: each pass begun and each copy,
+     * clear and query resolve the encoder accepted. A device runs them in this order, so what one
+     * command finds in a buffer depends on where it sits among the rest — which {@link passes} alone
+     * cannot show for a pass and a copy or clear around it.
+     *
+     * Each entry names its method and carries that call's arguments, with any size the caller left
+     * out filled in:
+     * - `{ method: 'beginComputePass' | 'beginRenderPass', pass }`
+     * - `{ method: 'copyBufferToBuffer', source, source_offset, destination, destination_offset, size }`
+     * - `{ method: 'clearBuffer', buffer, offset, size }`
+     * - `{ method: 'copyTextureToTexture' | 'copyBufferToTexture' | 'copyTextureToBuffer', source, destination, size }`
+     * - `{ method: 'resolveQuerySet', query_set, first_query, query_count, destination, destination_offset }`
+     *
+     * @type {Object[]}
+     */
+    operations: any[];
     finish(): SoftwareGPUCommandBuffer;
     /**
      * Called by a pass this encoder opened, when that pass ends. Releases the lock.

package/src/shade/device/mock/SoftwareGPUCommandEncoder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SoftwareGPUCommandEncoder.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUCommandEncoder.js"],"names":[],"mappings":"AAgGA;;;;GAIG;AACH,gFAFgB,iBAAiB;IA+D7B;;;;OAIG;IACH,iFAIC;IAzDD;;;;OAIG;IACH,gBAFU,6BAA6B,EAAE,CAErB;IAEpB;;;;OAIG;IACH,eAFU,4BAA4B,EAAE,CAErB;IAEnB;;;;;;OAMG;IACH,QAFU,CAAC,6BAA6B,GAAC,4BAA4B,CAAC,EAAE,CAE5D;IA0EZ,mCAiBC;IAqBD;;;;;OAKG;IACH,wBAHW,6BAA6B,GAAC,4BAA4B,GACxD,IAAI,CAMhB;IAED;;;;;OAKG;IACH,gCAEC;IAED;;;;;;;;;OASG;IACH,sCAHW,MAAM,GACJ,IAAI,CAIhB;IAED;;;;;;;OAOG;IACH,+EAeC;IAED;;;;;;;;;;;;;OAaG;IACH,4BAHW,CAAC,sCAAoC,CAAC,EAAE,GACtC,IAAI,CAUhB;IAkBD;;;;;;;OAOG;IACH,4EAmCC;IAED;;;;;;;;OAQG;IACH,oHAFa,IAAI,CAuBhB;IAED;;;;;OAKG;IACH,kHAFa,IAAI,CAuBhB;IAED;;;;;OAKG;IACH,kHAFa,IAAI,CAuBhB;IAED;;;;;;;;;OASG;IACH,2DANW,MAAM,cACN,MAAM,qDAEN,MAAM,GACJ,IAAI,CAwBhB;IAwCD;;;;OAIG;IACH,sBAFW,MAAM,QAIhB;IAED,sBAEC;IAED;;OAEG;IACH,yBAFW,MAAM,QAIhB;IAyED;;;;;;;;OAQG;IACH,4DANW,MAAM,qDAEN,MAAM,QACN,MAAM,GACJ,IAAI,CAgChB;IAED;;;;;;;OAOG;IACH,gDAJW,MAAM,SACN,MAAM,GACJ,IAAI,CA6BhB;IAGL;;;OAGG;IACH,sCAFU,OAAO,CAE8C;;CAN9D;sCA/sBqC,4BAA4B;8CAFpB,oCAAoC;6CAGrC,mCAAmC;yCAJvC,+BAA+B"}
+{"version":3,"file":"SoftwareGPUCommandEncoder.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUCommandEncoder.js"],"names":[],"mappings":"AAgGA;;;;GAIG;AACH,gFAFgB,iBAAiB;IAiF7B;;;;OAIG;IACH,iFAIC;IA3ED;;;;OAIG;IACH,gBAFU,6BAA6B,EAAE,CAErB;IAEpB;;;;OAIG;IACH,eAFU,4BAA4B,EAAE,CAErB;IAEnB;;;;;;OAMG;IACH,QAFU,CAAC,6BAA6B,GAAC,4BAA4B,CAAC,EAAE,CAE5D;IAEZ;;;;;;;;;;;;;;;OAeG;IACH,YAFU,KAAQ,CAEF;IA0EhB,mCAiBC;IAqBD;;;;;OAKG;IACH,wBAHW,6BAA6B,GAAC,4BAA4B,GACxD,IAAI,CAMhB;IAED;;;;;OAKG;IACH,gCAEC;IAED;;;;;;;;;OASG;IACH,sCAHW,MAAM,GACJ,IAAI,CAIhB;IAED;;;;;;;OAOG;IACH,+EAgBC;IAED;;;;;;;;;;;;;OAaG;IACH,4BAHW,CAAC,sCAAoC,CAAC,EAAE,GACtC,IAAI,CAUhB;IAkBD;;;;;;;OAOG;IACH,4EAoCC;IAED;;;;;;;;OAQG;IACH,oHAFa,IAAI,CAyBhB;IAED;;;;;OAKG;IACH,kHAFa,IAAI,CAyBhB;IAED;;;;;OAKG;IACH,kHAFa,IAAI,CAyBhB;IAED;;;;;;;;;OASG;IACH,2DANW,MAAM,cACN,MAAM,qDAEN,MAAM,GACJ,IAAI,CAiChB;IAwCD;;;;OAIG;IACH,sBAFW,MAAM,QAIhB;IAED,sBAEC;IAED;;OAEG;IACH,yBAFW,MAAM,QAIhB;IAyED;;;;;;;;OAQG;IACH,4DANW,MAAM,qDAEN,MAAM,QACN,MAAM,GACJ,IAAI,CAyChB;IAED;;;;;;;OAOG;IACH,gDAJW,MAAM,SACN,MAAM,GACJ,IAAI,CA+BhB;IAGL;;;OAGG;IACH,sCAFU,OAAO,CAE8C;;CAN9D;sCA7vBqC,4BAA4B;8CAFpB,oCAAoC;6CAGrC,mCAAmC;yCAJvC,+BAA+B"}

package/src/shade/device/mock/SoftwareGPUCommandEncoder.js

@@ -135,6 +135,24 @@ export class SoftwareGPUCommandEncoder extends SoftwareGPUObjectBase {
      */
     passes = [];
 
+    /**
+     * Everything encoded on this encoder, in the order it was encoded: each pass begun and each copy,
+     * clear and query resolve the encoder accepted. A device runs them in this order, so what one
+     * command finds in a buffer depends on where it sits among the rest — which {@link passes} alone
+     * cannot show for a pass and a copy or clear around it.
+     *
+     * Each entry names its method and carries that call's arguments, with any size the caller left
+     * out filled in:
+     * - `{ method: 'beginComputePass' | 'beginRenderPass', pass }`
+     * - `{ method: 'copyBufferToBuffer', source, source_offset, destination, destination_offset, size }`
+     * - `{ method: 'clearBuffer', buffer, offset, size }`
+     * - `{ method: 'copyTextureToTexture' | 'copyBufferToTexture' | 'copyTextureToBuffer', source, destination, size }`
+     * - `{ method: 'resolveQuerySet', query_set, first_query, query_count, destination, destination_offset }`
+     *
+     * @type {Object[]}
+     */
+    operations = [];
+
     /**
      * The pass currently open on this encoder, `null` when none is.
      *
@@ -302,6 +320,7 @@ export class SoftwareGPUCommandEncoder extends SoftwareGPUObjectBase {
 
         this.compute_passes.push(pass);
         this.passes.push(pass);
+        this.operations.push({ method: 'beginComputePass', pass });
 
         return pass;
     }
@@ -387,6 +406,7 @@ export class SoftwareGPUCommandEncoder extends SoftwareGPUObjectBase {
 
         this.render_passes.push(pass);
         this.passes.push(pass);
+        this.operations.push({ method: 'beginRenderPass', pass });
 
         return pass;
     }
@@ -421,6 +441,8 @@ export class SoftwareGPUCommandEncoder extends SoftwareGPUObjectBase {
                 texture_copy_execute({ texture_source: source, texture_destination: destination, size: copySize });
             }
         });
+
+        this.operations.push({ method: 'copyTextureToTexture', source, destination, size: copySize });
     }
 
     /**
@@ -450,6 +472,8 @@ export class SoftwareGPUCommandEncoder extends SoftwareGPUObjectBase {
                 texture_copy_execute({ buffer_source: source, texture_destination: destination, size: copySize });
             }
         });
+
+        this.operations.push({ method: 'copyBufferToTexture', source, destination, size: copySize });
     }
 
     /**
@@ -479,6 +503,8 @@ export class SoftwareGPUCommandEncoder extends SoftwareGPUObjectBase {
                 texture_copy_execute({ texture_source: source, buffer_destination: destination, size: copySize });
             }
         });
+
+        this.operations.push({ method: 'copyTextureToBuffer', source, destination, size: copySize });
     }
 
     /**
@@ -513,6 +539,15 @@ export class SoftwareGPUCommandEncoder extends SoftwareGPUObjectBase {
                     .set(querySet.read(firstQuery, queryCount));
             }
         });
+
+        this.operations.push({
+            method: 'resolveQuerySet',
+            query_set: querySet,
+            first_query: firstQuery,
+            query_count: queryCount,
+            destination,
+            destination_offset: destinationOffset,
+        });
     }
 
     /**
@@ -683,6 +718,15 @@ export class SoftwareGPUCommandEncoder extends SoftwareGPUObjectBase {
                 array_buffer_copy(source.data, sourceOffset, destination.data, destinationOffset, _size);
             }
         });
+
+        this.operations.push({
+            method: 'copyBufferToBuffer',
+            source,
+            source_offset: sourceOffset,
+            destination,
+            destination_offset: destinationOffset,
+            size: _size,
+        });
     }
 
     /**
@@ -720,6 +764,8 @@ export class SoftwareGPUCommandEncoder extends SoftwareGPUObjectBase {
                 new Uint8Array(buffer.data, offset, clear_size).fill(0);
             }
         });
+
+        this.operations.push({ method: 'clearBuffer', buffer, offset, size: clear_size });
     }
 }
 

package/src/shade/renderer/buffer/table/GPUDatabase.d.ts

@@ -7,6 +7,18 @@
  * Note: GPU and CPU-side states are allowed to diverge but must eventually be synchronized.
  * This means that a modification on one side must propagate to the other.
  * see "Rendering 'Assassin's Creed Shadows'" GDC 2025 by Nicolas Lopez
+ *
+ * **What a row nobody occupies reads as on the GPU.** A shader may read a row by its index without
+ * asking the page's occupancy bitmap. To GPU work encoded after {@link update} on the same encoder:
+ * - a row of a page that has no slot reads as a record of zeros: the generated readers refuse it;
+ * - a row nothing has written, on a page that has a slot, reads as zeros too: a page's records are
+ *   cleared when it is given a slot, whichever page of whichever table held that slot before;
+ * - a row freed with {@link GPUTypedTable#remove} reads as the freed record: zeros, with
+ *   `GPU_DATABASE_NULL` in its link words and in the first word of its ranges.
+ *
+ * So a link word of an unoccupied row holds 0 or NULL depending on the row's history, and a reader
+ * that skips occupancy must not follow one. {@link GPUTypedTable#clear} sends nothing, so the rows it
+ * frees keep their last record on a page that stays allocated.
  */
 export class GPUDatabase {
     /**

package/src/shade/renderer/buffer/table/GPUDatabase.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUDatabase.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/table/GPUDatabase.js"],"names":[],"mappings":"AA4CA;;;;;;;;;GASG;AACH;IAEI;;;;OAIG;IACH,iCAFW,eAAe,QAKzB;IA8FD;;;;;;OAMG;IACH;QAL0C,UAAU,EAAzC,qBAAqB;QACF,MAAM;QACR,KAAK,GAAtB,MAAM;QACW,uBAAuB,GAAxC,MAAM;OAkJhB;IAlPD;;;OAGG;IACH,YAFU,qBAAqB,CAEpB;IAEX;;;;OAIG;IACH,QAFU,oBAAe,CAElB;IASP;;;OAGG;IACH,kBAAO;IAmDP;;OAEG;IACH,8BAEC;IAED;;;;OAIG;IACH,oBAEC;IA2JD;;;;;OAKG;IACH,UAHW,MAAM,GACJ,qBAAc,SAAS,CAUnC;IAGD;;;;;;;;;;;OAWG;IACH,oCAcC;IAED;;;;;OAKG;IACH,gCAEC;IAoPD;;;;;;;;;;;OAWG;IACH,kCAeC;IAED;;;OAGG;IACH,gBAFW,sBAAsB,QA6FhC;IAkPD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,2BAJW,MAAM,GACJ,QAAQ,KAAG,CAAC,CA6HxB;IAED;;;;;;;OAOG;IACH,+BAJW,MAAM,iBACN,MAAM,GACJ,YAAU,CAkCtB;IAED;;;OAGG;IACH,+BAQC;IAED;;OAEG;IACH,gBASC;;CACJ;8BAvpCY,OAAO,6CAA6C,EAAE,eAAe;qCACrE,OAAO,2CAA2C,EAAE,sBAAsB;oCAC1E,OAAO,4BAA4B,EAAE,qBAAqB;8BAPzC,oBAAoB;oCALd,0BAA0B"}
+{"version":3,"file":"GPUDatabase.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/table/GPUDatabase.js"],"names":[],"mappings":"AA4CA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAEI;;;;OAIG;IACH,iCAFW,eAAe,QAKzB;IA8GD;;;;;;OAMG;IACH;QAL0C,UAAU,EAAzC,qBAAqB;QACF,MAAM;QACR,KAAK,GAAtB,MAAM;QACW,uBAAuB,GAAxC,MAAM;OAkJhB;IAlQD;;;OAGG;IACH,YAFU,qBAAqB,CAEpB;IAEX;;;;OAIG;IACH,QAFU,oBAAe,CAElB;IASP;;;OAGG;IACH,kBAAO;IAmEP;;OAEG;IACH,8BAEC;IAED;;;;OAIG;IACH,oBAEC;IA2JD;;;;;OAKG;IACH,UAHW,MAAM,GACJ,qBAAc,SAAS,CAUnC;IAGD;;;;;;;;;;;OAWG;IACH,oCAcC;IAED;;;;;OAKG;IACH,gCAEC;IA4PD;;;;;;;;;;;OAWG;IACH,kCAeC;IAED;;;OAGG;IACH,gBAFW,sBAAsB,QAgGhC;IAgSD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,2BAJW,MAAM,GACJ,QAAQ,KAAG,CAAC,CA6HxB;IAED;;;;;;;OAOG;IACH,+BAJW,MAAM,iBACN,MAAM,GACJ,YAAU,CAkCtB;IAED;;;OAGG;IACH,+BAQC;IAED;;OAEG;IACH,gBASC;;CACJ;8BA5uCY,OAAO,6CAA6C,EAAE,eAAe;qCACrE,OAAO,2CAA2C,EAAE,sBAAsB;oCAC1E,OAAO,4BAA4B,EAAE,qBAAqB;8BAPzC,oBAAoB;oCALd,0BAA0B"}

package/src/shade/renderer/buffer/table/GPUDatabase.js

@@ -51,6 +51,18 @@ const UPLOAD_CHUNK_SIZE = 256 * KILOBYTE;
  * Note: GPU and CPU-side states are allowed to diverge but must eventually be synchronized.
  * This means that a modification on one side must propagate to the other.
  * see "Rendering 'Assassin's Creed Shadows'" GDC 2025 by Nicolas Lopez
+ *
+ * **What a row nobody occupies reads as on the GPU.** A shader may read a row by its index without
+ * asking the page's occupancy bitmap. To GPU work encoded after {@link update} on the same encoder:
+ * - a row of a page that has no slot reads as a record of zeros: the generated readers refuse it;
+ * - a row nothing has written, on a page that has a slot, reads as zeros too: a page's records are
+ *   cleared when it is given a slot, whichever page of whichever table held that slot before;
+ * - a row freed with {@link GPUTypedTable#remove} reads as the freed record: zeros, with
+ *   `GPU_DATABASE_NULL` in its link words and in the first word of its ranges.
+ *
+ * So a link word of an unoccupied row holds 0 or NULL depending on the row's history, and a reader
+ * that skips occupancy must not follow one. {@link GPUTypedTable#clear} sends nothing, so the rows it
+ * frees keep their last record on a page that stays allocated.
  */
 export class GPUDatabase {
 
@@ -130,6 +142,22 @@ export class GPUDatabase {
      */
     #page_buffer_pool;
 
+    /**
+     * The pages given a slot since {@link #clear_new_page_records} last ran, each after its table,
+     * flattened as `[table, page, table, page, …]` over the first {@link #pages_given_slots_length}
+     * entries. Entries past that are `null`. The array is never shortened, so it keeps its storage
+     * from one update to the next.
+     *
+     * @type {Array<GPUTypedTable|GPUPageMetadata|null>}
+     */
+    #pages_given_slots = [];
+
+    /**
+     * How many entries of {@link #pages_given_slots} are live: twice the number of pages.
+     * @type {number}
+     */
+    #pages_given_slots_length = 0;
+
     /**
      * Batched row readback, built on first use.
      *
@@ -557,6 +585,14 @@ export class GPUDatabase {
 
         page.slot_offset = slot_offset;
 
+        const given = this.#pages_given_slots;
+        const given_length = this.#pages_given_slots_length;
+
+        given[given_length] = table;
+        given[given_length + 1] = page;
+
+        this.#pages_given_slots_length = given_length + 2;
+
         const alloc_idx = table.descriptor.page_lookup_address + page_index;
 
         this.#allocation_table[alloc_idx] = slot_offset + this.#data_start_offset;
@@ -675,6 +711,9 @@ export class GPUDatabase {
             this.#deallocate_empty_pages(table);
         }
 
+        // after every page has its slot, and before the record uploads that land on top
+        this.#clear_new_page_records(encoder);
+
         // update allocation table — only the dirty range
         if (this.#alloc_table_dirty_min <= this.#alloc_table_dirty_max) {
             const min_byte = this.#alloc_table_dirty_min * Uint32Array.BYTES_PER_ELEMENT;
@@ -732,6 +771,52 @@ export class GPUDatabase {
         }
     }
 
+    /**
+     * Clear the records of every page given a slot since this last ran, so that a row nothing has
+     * written reads as a record of zeros and not as whatever the slot's previous page, of this table
+     * or any other, left there. See the class documentation for what an unoccupied row reads as.
+     *
+     * Called once every page has its slot: growing the buffer moves pages to new slots, so a clear
+     * encoded before the move would land in the buffer being replaced. The header is left alone
+     * because it goes up through the queue, and a queue write lands ahead of the whole submission —
+     * a clear over it would erase it. The record uploads, encoded after this, land on top.
+     *
+     * @param {ShadeGPUCommandContext} encoder
+     */
+    #clear_new_page_records(encoder) {
+        const pages = this.#pages_given_slots;
+        const length = this.#pages_given_slots_length;
+
+        if (length === 0) {
+            return;
+        }
+
+        const word_size = GPU_DATABASE_BUFFER_ELEMENT_TYPE.size;
+        const data_start = this.#data_start_offset;
+
+        for (let i = 0; i < length; i += 2) {
+            const descriptor = /** @type {GPUTypedTable} */ (pages[i]).descriptor;
+            const slot_offset = /** @type {GPUPageMetadata} */ (pages[i + 1]).slot_offset;
+
+            // let go of both, so a freed page is not kept alive by the list
+            pages[i] = null;
+            pages[i + 1] = null;
+
+            if (slot_offset === -1) {
+                // emptied in the same update, and its slot already given back
+                continue;
+            }
+
+            encoder.clearBuffer(
+                this.buffer,
+                (slot_offset + data_start + descriptor.page_header_words) * word_size,
+                descriptor.elements_per_page * descriptor.packed_element_size_bytes
+            );
+        }
+
+        this.#pages_given_slots_length = 0;
+    }
+
     /**
      * Dispatch a table's pending whole-record writes, chunked so no single transient buffer grows
      * past {@link UPLOAD_CHUNK_SIZE}. Rewinds the buffer.

package/src/shade/renderer/buffer/table/GPUDatabaseDefinition.d.ts

@@ -48,7 +48,8 @@ export class GPUDatabaseDefinition {
      * it into every link word the row has, whatever `nullable` says, because a freed row points
      * nowhere; a new page starts with it in every link word too. So a link no write has touched names
      * no row, on a row never written as on one freed, and a value that leaves a link out leaves it
-     * naming nothing.
+     * naming nothing. That holds on the GPU for every occupied row and every freed one; a row the GPU
+     * has never been sent reads 0 there instead (see {@link GPUDatabase}).
      *
      * `owning` means one thing: removing the row that holds the link removes the row it names, and
      * that row's owned rows in turn ({@link GPUTypedTable#remove}). Nothing else follows it.

package/src/shade/renderer/buffer/table/GPUDatabaseDefinition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUDatabaseDefinition.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/table/GPUDatabaseDefinition.js"],"names":[],"mappings":"AAwCA;;;;;;;;;;GAUG;AACH;IA0DI;;;;;OAKG;IACH,0CAHW,MAAM,GACJ,qBAAqB,CAIjC;IA9BD;;;OAGG;IACH,2CAFW,MAAM,EAkBhB;IAvDD;;OAEG;IACH,aAFU,uBAAuB,EAAE,CAElB;IAOjB;;;OAGG;IACH,iBAFU,MAAM,CAEA;IA8FhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8CG;IACH,eAVW;QACV,KAAW,EAAE,MAAM,CAAC;QACpB,KAAW,EAAE,MAAM,CAAC;QACpB,eAAqB,EAAE,qBAAqB,CAAC;QAC7C,YAAkB,EAAE,MAAM,CAAC;QAC3B,QAAc,EAAE,OAAO,CAAC;QACxB,MAAY,EAAE,OAAO,CAAC;KACnB,GACS,YAAY,CAgDxB;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,gBAVW;QACV,KAAW,EAAE,MAAM,CAAC;QACpB,WAAiB,EAAE,MAAM,CAAC;QAC1B,WAAiB,EAAE,MAAM,CAAC;QAC1B,eAAqB,EAAE,qBAAqB,CAAC;QAC7C,YAAkB,EAAE,MAAM,CAAC;QAC3B,MAAY,EAAE,OAAO,CAAC;KACnB,GACS,aAAa,CAmDzB;IAiCD;;;OAGG;IACH,4BAEC;IAED;;;OAGG;IACH,8BAEC;IAED;;;;;OAKG;IACH,iBAHW,uBAAuB,GACrB,aAAa,EAAE,CAM3B;IAED;;;;;OAKG;IACH,gBAHW,uBAAuB,GACrB,YAAY,EAAE,CAM1B;IAED;;;;OAIG;IACH,sBAEC;IAED;;;;;;;OAOG;IACH,aAiEC;IAED;;;;OAIG;IACH,UAHW,MAAM,GACJ,OAAO,CAMnB;IAED;;;OAGG;IACH,UAHW,MAAM,GACJ,uBAAuB,GAAC,SAAS,CAM7C;IAED;;OAEG;IACH,0BAEC;IAGL;;;OAGG;IACH,kCAFU,OAAO,CAEsC;;CANtD;wCA5fuC,8BAA8B;6BAFzC,mBAAmB;8BAClB,oBAAoB"}
+{"version":3,"file":"GPUDatabaseDefinition.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/table/GPUDatabaseDefinition.js"],"names":[],"mappings":"AAwCA;;;;;;;;;;GAUG;AACH;IA0DI;;;;;OAKG;IACH,0CAHW,MAAM,GACJ,qBAAqB,CAIjC;IA9BD;;;OAGG;IACH,2CAFW,MAAM,EAkBhB;IAvDD;;OAEG;IACH,aAFU,uBAAuB,EAAE,CAElB;IAOjB;;;OAGG;IACH,iBAFU,MAAM,CAEA;IA8FhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+CG;IACH,eAVW;QACV,KAAW,EAAE,MAAM,CAAC;QACpB,KAAW,EAAE,MAAM,CAAC;QACpB,eAAqB,EAAE,qBAAqB,CAAC;QAC7C,YAAkB,EAAE,MAAM,CAAC;QAC3B,QAAc,EAAE,OAAO,CAAC;QACxB,MAAY,EAAE,OAAO,CAAC;KACnB,GACS,YAAY,CAgDxB;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,gBAVW;QACV,KAAW,EAAE,MAAM,CAAC;QACpB,WAAiB,EAAE,MAAM,CAAC;QAC1B,WAAiB,EAAE,MAAM,CAAC;QAC1B,eAAqB,EAAE,qBAAqB,CAAC;QAC7C,YAAkB,EAAE,MAAM,CAAC;QAC3B,MAAY,EAAE,OAAO,CAAC;KACnB,GACS,aAAa,CAmDzB;IAiCD;;;OAGG;IACH,4BAEC;IAED;;;OAGG;IACH,8BAEC;IAED;;;;;OAKG;IACH,iBAHW,uBAAuB,GACrB,aAAa,EAAE,CAM3B;IAED;;;;;OAKG;IACH,gBAHW,uBAAuB,GACrB,YAAY,EAAE,CAM1B;IAED;;;;OAIG;IACH,sBAEC;IAED;;;;;;;OAOG;IACH,aAiEC;IAED;;;;OAIG;IACH,UAHW,MAAM,GACJ,OAAO,CAMnB;IAED;;;OAGG;IACH,UAHW,MAAM,GACJ,uBAAuB,GAAC,SAAS,CAM7C;IAED;;OAEG;IACH,0BAEC;IAGL;;;OAGG;IACH,kCAFU,OAAO,CAEsC;;CANtD;wCA7fuC,8BAA8B;6BAFzC,mBAAmB;8BAClB,oBAAoB"}

package/src/shade/renderer/buffer/table/GPUDatabaseDefinition.js

@@ -175,7 +175,8 @@ export class GPUDatabaseDefinition {
      * it into every link word the row has, whatever `nullable` says, because a freed row points
      * nowhere; a new page starts with it in every link word too. So a link no write has touched names
      * no row, on a row never written as on one freed, and a value that leaves a link out leaves it
-     * naming nothing.
+     * naming nothing. That holds on the GPU for every occupied row and every freed one; a row the GPU
+     * has never been sent reads 0 there instead (see {@link GPUDatabase}).
      *
      * `owning` means one thing: removing the row that holds the link removes the row it names, and
      * that row's owned rows in turn ({@link GPUTypedTable#remove}). Nothing else follows it.