@woosh/meep-engine 3.29.0 → 3.31.0

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

@@ -5,7 +5,9 @@
  *
  * To create a live database from a definition, pass it to {@link GPUDatabase} constructor.
  *
- * Immutable.
+ * The tables are immutable from construction. Links and ranges between them are declared
+ * afterwards, one {@link add_link} per link word and one {@link add_range} per range, until the first
+ * {@link GPUDatabase} built from the definition {@link seal}s it.
  */
 export class GPUDatabaseDefinition {
     /**
@@ -29,6 +31,133 @@ export class GPUDatabaseDefinition {
      * @type {number}
      */
     page_size_bytes: number;
+    /**
+     * Declare that one `u32` word of a table's records names a row of a table — of this definition
+     * or of another.
+     *
+     * Every field is required and there are no defaults, so every declaration reads the same whether
+     * it stays within this database or leaves it; a link within this one passes this definition as
+     * `target_database`.
+     *
+     * One call per word. An array of structs is declared one element at a time
+     * (`'joints[0].node'`, `'joints[1].node'`, …), which keeps every declaration pointing at exactly
+     * one place in the record.
+     *
+     * "No row" is not the declaration's to choose: it is always {@link GPU_DATABASE_NULL}, and
+     * `nullable` says only whether an occupied row may hold it here. A table that frees a row writes
+     * 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.
+     *
+     * `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.
+     * - Writing the word with a new value frees nothing: the row it named is left belonging to no
+     *   one, which the link check reports as an orphan.
+     * - Removing an owned row directly leaves its owner naming a free row. The next add may hand that
+     *   row to someone else, and removing the owner then takes the stranger's row with it — links
+     *   carry no generation, and the check cannot see a row that was freed and handed out again.
+     * An owned row goes when its owner goes; to let go of one early, point the owner away from it
+     * first.
+     *
+     * Refused, as a programmer error:
+     * - a field missing, of the wrong type, or not one of the six
+     * - a `table` this definition does not have, or a `target_table` that `target_database` does not
+     * - a `field` path that does not end on exactly one `u32` word
+     * - an owning link into another definition
+     * - a word declared twice
+     * - any call once a database has been built from this definition
+     *
+     * @param {{
+     *     table: string,
+     *     field: string,
+     *     target_database: GPUDatabaseDefinition,
+     *     target_table: string,
+     *     nullable: boolean,
+     *     owning: boolean,
+     * }} spec
+     * @returns {GPUTableLink}
+     */
+    add_link(spec: {
+        table: string;
+        field: string;
+        target_database: GPUDatabaseDefinition;
+        target_table: string;
+        nullable: boolean;
+        owning: boolean;
+    }): GPUTableLink;
+    /**
+     * Declare that two `u32` words of a table's records name a contiguous run of rows of a table —
+     * the first row, and how many. Anvil's `Range<T>`, the fixed-size kind.
+     *
+     * An empty range is `(GPU_DATABASE_NULL, 0)`, and a range may always be empty; a freed row's
+     * range is left that way. Rows for a run come from {@link GPUTypedTable#add_run}, which answers
+     * an empty run with NULL. Like a link, every field is required, a range within this database
+     * passes this definition as `target_database`, and an owning range stays within its database:
+     * removing a row that owns a range removes the run — and, as for an owning link, nothing else
+     * does. Writing new range words frees the old run for nobody, and removing rows of an owned run
+     * directly leaves the owner naming them (see {@link add_link}).
+     *
+     * Refused, as a programmer error: what {@link add_link} refuses, and `first_field` and
+     * `count_field` naming the same word, or a word some link or range already declared.
+     *
+     * @param {{
+     *     table: string,
+     *     first_field: string,
+     *     count_field: string,
+     *     target_database: GPUDatabaseDefinition,
+     *     target_table: string,
+     *     owning: boolean,
+     * }} spec
+     * @returns {GPUTableRange}
+     */
+    add_range(spec: {
+        table: string;
+        first_field: string;
+        count_field: string;
+        target_database: GPUDatabaseDefinition;
+        target_table: string;
+        owning: boolean;
+    }): GPUTableRange;
+    /**
+     * Every declared link, in declaration order. Do not modify.
+     * @returns {GPUTableLink[]}
+     */
+    get links(): GPUTableLink[];
+    /**
+     * Every declared range, in declaration order. Do not modify.
+     * @returns {GPUTableRange[]}
+     */
+    get ranges(): GPUTableRange[];
+    /**
+     * The ranges held by one table's records, in declaration order.
+     *
+     * @param {GPUTypedTableDescriptor} table
+     * @returns {GPUTableRange[]}
+     */
+    ranges_of(table: GPUTypedTableDescriptor): GPUTableRange[];
+    /**
+     * The links held by one table's records, in declaration order.
+     *
+     * @param {GPUTypedTableDescriptor} table
+     * @returns {GPUTableLink[]}
+     */
+    links_of(table: GPUTypedTableDescriptor): GPUTableLink[];
+    /**
+     * Whether a database has been built from this definition, after which it takes no more links or
+     * ranges.
+     * @returns {boolean}
+     */
+    get sealed(): boolean;
+    /**
+     * Stop taking links and ranges. Called by {@link GPUDatabase} as it is built, so that every
+     * database made from a definition sees the same ones; calling it again does nothing.
+     *
+     * Refuses owning links and ranges between different tables that come back round to where they
+     * started — a row that owned its owner would be freed by its own removal. A table owning rows of
+     * itself, as a chain's `next` does, is fine: removal stops at a row that is already free.
+     */
+    seal(): void;
     /**
      *
      * @param {string} name
@@ -52,4 +181,6 @@ export class GPUDatabaseDefinition {
     #private;
 }
 import { GPUTypedTableDescriptor } from "./GPUTypedTableDescriptor.js";
+import { GPUTableLink } from "./GPUTableLink.js";
+import { GPUTableRange } from "./GPUTableRange.js";
 //# sourceMappingURL=GPUDatabaseDefinition.d.ts.map

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":"AAIA;;;;;;;;GAQG;AACH;IAuCI;;;;;OAKG;IACH,0CAHW,MAAM,GACJ,qBAAqB,CAIjC;IA9BD;;;OAGG;IACH,2CAFW,MAAM,EAkBhB;IApCD;;OAEG;IACH,aAFU,uBAAuB,EAAE,CAElB;IAOjB;;;OAGG;IACH,iBAFU,MAAM,CAEA;IA2EhB;;;;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;wCAhIuC,8BAA8B"}
+{"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"}

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

@@ -1,7 +1,43 @@
 import { assert } from "../../../../core/assert.js";
 import { GPU_DATABASE_PAGE_SIZE } from "./GPU_DATABASE_PAGE_SIZE.js";
+import { gpu_table_field_word } from "./gpu_table_field_word.js";
+import { GPUTableLink } from "./GPUTableLink.js";
+import { GPUTableRange } from "./GPUTableRange.js";
 import { GPUTypedTableDescriptor } from "./GPUTypedTableDescriptor.js";
 
+/**
+ * The fields {@link GPUDatabaseDefinition#add_link} takes — every one of them, and nothing else.
+ * @type {string[]}
+ */
+const LINK_FIELDS = ['table', 'field', 'target_database', 'target_table', 'nullable', 'owning'];
+
+/**
+ * The fields {@link GPUDatabaseDefinition#add_range} takes — every one of them, and nothing else.
+ * @type {string[]}
+ */
+const RANGE_FIELDS = ['table', 'first_field', 'count_field', 'target_database', 'target_table', 'owning'];
+
+/**
+ * Refuse a declaration carrying a field it does not take, and one missing a field it does.
+ *
+ * @param {object} spec
+ * @param {string[]} fields
+ * @param {string} kind
+ */
+function assert_declaration_fields(spec, fields, kind) {
+    assert.isObject(spec, 'spec');
+
+    const keys = Object.keys(spec);
+
+    for (let i = 0; i < keys.length; i++) {
+        assert.arrayHas(fields, keys[i], `'${keys[i]}' is not a ${kind} field; a ${kind} takes exactly ${fields.join(', ')}`);
+    }
+
+    for (let i = 0; i < fields.length; i++) {
+        assert.ok(Object.hasOwn(spec, fields[i]), `a ${kind} needs '${fields[i]}'; it takes exactly ${fields.join(', ')}`);
+    }
+}
+
 /**
  * Schema-only database definition, separate from any GPU device.
  * Use this for offline shader codegen, serialization, and schema validation
@@ -9,7 +45,9 @@ import { GPUTypedTableDescriptor } from "./GPUTypedTableDescriptor.js";
  *
  * To create a live database from a definition, pass it to {@link GPUDatabase} constructor.
  *
- * Immutable.
+ * The tables are immutable from construction. Links and ranges between them are declared
+ * afterwards, one {@link add_link} per link word and one {@link add_range} per range, until the first
+ * {@link GPUDatabase} built from the definition {@link seal}s it.
  */
 export class GPUDatabaseDefinition {
     /**
@@ -28,6 +66,25 @@ export class GPUDatabaseDefinition {
      */
     page_size_bytes;
 
+    /**
+     * Every link declared through {@link add_link}, in declaration order. Private because the
+     * definition itself is frozen and this is the one thing that still grows until {@link seal}.
+     * @type {GPUTableLink[]}
+     */
+    #links = [];
+
+    /**
+     * Every range declared through {@link add_range}, in declaration order. Private for the reason
+     * {@link #links} is.
+     * @type {GPUTableRange[]}
+     */
+    #ranges = [];
+
+    /**
+     * @type {boolean}
+     */
+    #sealed = false;
+
     /**
      * @param {Object<WebGPUType>} schema
      * @param {number} [page_size_bytes]
@@ -101,6 +158,332 @@ export class GPUDatabaseDefinition {
         this.#lookup.set(name, descriptor);
     }
 
+    /**
+     * Declare that one `u32` word of a table's records names a row of a table — of this definition
+     * or of another.
+     *
+     * Every field is required and there are no defaults, so every declaration reads the same whether
+     * it stays within this database or leaves it; a link within this one passes this definition as
+     * `target_database`.
+     *
+     * One call per word. An array of structs is declared one element at a time
+     * (`'joints[0].node'`, `'joints[1].node'`, …), which keeps every declaration pointing at exactly
+     * one place in the record.
+     *
+     * "No row" is not the declaration's to choose: it is always {@link GPU_DATABASE_NULL}, and
+     * `nullable` says only whether an occupied row may hold it here. A table that frees a row writes
+     * 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.
+     *
+     * `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.
+     * - Writing the word with a new value frees nothing: the row it named is left belonging to no
+     *   one, which the link check reports as an orphan.
+     * - Removing an owned row directly leaves its owner naming a free row. The next add may hand that
+     *   row to someone else, and removing the owner then takes the stranger's row with it — links
+     *   carry no generation, and the check cannot see a row that was freed and handed out again.
+     * An owned row goes when its owner goes; to let go of one early, point the owner away from it
+     * first.
+     *
+     * Refused, as a programmer error:
+     * - a field missing, of the wrong type, or not one of the six
+     * - a `table` this definition does not have, or a `target_table` that `target_database` does not
+     * - a `field` path that does not end on exactly one `u32` word
+     * - an owning link into another definition
+     * - a word declared twice
+     * - any call once a database has been built from this definition
+     *
+     * @param {{
+     *     table: string,
+     *     field: string,
+     *     target_database: GPUDatabaseDefinition,
+     *     target_table: string,
+     *     nullable: boolean,
+     *     owning: boolean,
+     * }} spec
+     * @returns {GPUTableLink}
+     */
+    add_link(spec) {
+        assert_declaration_fields(spec, LINK_FIELDS, 'link');
+        assert.notOk(this.#sealed, `a database has been built from this definition; declare every link before that`);
+
+        assert.isString(spec.table, 'spec.table');
+        assert.isString(spec.field, 'spec.field');
+        assert.defined(spec.target_database, 'spec.target_database');
+        assert.equal(spec.target_database.isGPUDatabaseDefinition, true, 'spec.target_database is not a GPUDatabaseDefinition');
+        assert.isString(spec.target_table, 'spec.target_table');
+        assert.isBoolean(spec.nullable, 'spec.nullable');
+        assert.isBoolean(spec.owning, 'spec.owning');
+
+        const table = this.get(spec.table);
+
+        assert.defined(table, `table '${spec.table}'`);
+
+        const target_table = spec.target_database.get(spec.target_table);
+
+        assert.defined(target_table, `target table '${spec.target_table}'`);
+
+        if (spec.owning) {
+            assert.equal(spec.target_database, this, `${spec.table}.${spec.field}: an owning link cannot leave its database — the rows it would free belong to whoever keeps the other one`);
+        }
+
+        const word = gpu_table_field_word(table.type, spec.field);
+
+        this.#assert_word_undeclared(table, word, spec.field);
+
+        const links = this.#links;
+
+        const link = new GPUTableLink();
+
+        link.database = this;
+        link.table = table;
+        link.field = spec.field;
+        link.word = word;
+        link.target_database = spec.target_database;
+        link.target_table = target_table;
+        link.nullable = spec.nullable;
+        link.owning = spec.owning;
+
+        Object.freeze(link);
+
+        links.push(link);
+
+        return link;
+    }
+
+    /**
+     * Declare that two `u32` words of a table's records name a contiguous run of rows of a table —
+     * the first row, and how many. Anvil's `Range<T>`, the fixed-size kind.
+     *
+     * An empty range is `(GPU_DATABASE_NULL, 0)`, and a range may always be empty; a freed row's
+     * range is left that way. Rows for a run come from {@link GPUTypedTable#add_run}, which answers
+     * an empty run with NULL. Like a link, every field is required, a range within this database
+     * passes this definition as `target_database`, and an owning range stays within its database:
+     * removing a row that owns a range removes the run — and, as for an owning link, nothing else
+     * does. Writing new range words frees the old run for nobody, and removing rows of an owned run
+     * directly leaves the owner naming them (see {@link add_link}).
+     *
+     * Refused, as a programmer error: what {@link add_link} refuses, and `first_field` and
+     * `count_field` naming the same word, or a word some link or range already declared.
+     *
+     * @param {{
+     *     table: string,
+     *     first_field: string,
+     *     count_field: string,
+     *     target_database: GPUDatabaseDefinition,
+     *     target_table: string,
+     *     owning: boolean,
+     * }} spec
+     * @returns {GPUTableRange}
+     */
+    add_range(spec) {
+        assert_declaration_fields(spec, RANGE_FIELDS, 'range');
+        assert.notOk(this.#sealed, `a database has been built from this definition; declare every range before that`);
+
+        assert.isString(spec.table, 'spec.table');
+        assert.isString(spec.first_field, 'spec.first_field');
+        assert.isString(spec.count_field, 'spec.count_field');
+        assert.defined(spec.target_database, 'spec.target_database');
+        assert.equal(spec.target_database.isGPUDatabaseDefinition, true, 'spec.target_database is not a GPUDatabaseDefinition');
+        assert.isString(spec.target_table, 'spec.target_table');
+        assert.isBoolean(spec.owning, 'spec.owning');
+
+        const table = this.get(spec.table);
+
+        assert.defined(table, `table '${spec.table}'`);
+
+        const target_table = spec.target_database.get(spec.target_table);
+
+        assert.defined(target_table, `target table '${spec.target_table}'`);
+
+        if (spec.owning) {
+            assert.equal(spec.target_database, this, `${spec.table}.${spec.first_field}: an owning range cannot leave its database — the rows it would free belong to whoever keeps the other one`);
+        }
+
+        const first_word = gpu_table_field_word(table.type, spec.first_field);
+        const count_word = gpu_table_field_word(table.type, spec.count_field);
+
+        assert.notEqual(first_word, count_word, `${spec.table}: '${spec.first_field}' and '${spec.count_field}' are the same word`);
+
+        this.#assert_word_undeclared(table, first_word, spec.first_field);
+        this.#assert_word_undeclared(table, count_word, spec.count_field);
+
+        const range = new GPUTableRange();
+
+        range.database = this;
+        range.table = table;
+        range.first_field = spec.first_field;
+        range.count_field = spec.count_field;
+        range.first_word = first_word;
+        range.count_word = count_word;
+        range.target_database = spec.target_database;
+        range.target_table = target_table;
+        range.owning = spec.owning;
+
+        Object.freeze(range);
+
+        this.#ranges.push(range);
+
+        return range;
+    }
+
+    /**
+     * Refuse a word some link or range of `table` has already declared.
+     *
+     * @param {GPUTypedTableDescriptor} table
+     * @param {number} word
+     * @param {string} field
+     */
+    #assert_word_undeclared(table, word, field) {
+        const links = this.#links;
+
+        for (let i = 0; i < links.length; i++) {
+            const existing = links[i];
+
+            assert.notOk(
+                existing.table === table && existing.word === word,
+                `${table.name}.${field} is word ${word}, which the link '${existing.field}' already declared`
+            );
+        }
+
+        const ranges = this.#ranges;
+
+        for (let i = 0; i < ranges.length; i++) {
+            const existing = ranges[i];
+
+            assert.notOk(
+                existing.table === table && (existing.first_word === word || existing.count_word === word),
+                `${table.name}.${field} is word ${word}, which the range (${existing.first_field}, ${existing.count_field}) already declared`
+            );
+        }
+    }
+
+    /**
+     * Every declared link, in declaration order. Do not modify.
+     * @returns {GPUTableLink[]}
+     */
+    get links() {
+        return this.#links;
+    }
+
+    /**
+     * Every declared range, in declaration order. Do not modify.
+     * @returns {GPUTableRange[]}
+     */
+    get ranges() {
+        return this.#ranges;
+    }
+
+    /**
+     * The ranges held by one table's records, in declaration order.
+     *
+     * @param {GPUTypedTableDescriptor} table
+     * @returns {GPUTableRange[]}
+     */
+    ranges_of(table) {
+        assert.equal(this.descriptors[table.index], table, `table '${table.name}' does not belong to this definition`);
+
+        return this.#ranges.filter(range => range.table === table);
+    }
+
+    /**
+     * The links held by one table's records, in declaration order.
+     *
+     * @param {GPUTypedTableDescriptor} table
+     * @returns {GPUTableLink[]}
+     */
+    links_of(table) {
+        assert.equal(this.descriptors[table.index], table, `table '${table.name}' does not belong to this definition`);
+
+        return this.#links.filter(link => link.table === table);
+    }
+
+    /**
+     * Whether a database has been built from this definition, after which it takes no more links or
+     * ranges.
+     * @returns {boolean}
+     */
+    get sealed() {
+        return this.#sealed;
+    }
+
+    /**
+     * Stop taking links and ranges. Called by {@link GPUDatabase} as it is built, so that every
+     * database made from a definition sees the same ones; calling it again does nothing.
+     *
+     * Refuses owning links and ranges between different tables that come back round to where they
+     * started — a row that owned its owner would be freed by its own removal. A table owning rows of
+     * itself, as a chain's `next` does, is fine: removal stops at a row that is already free.
+     */
+    seal() {
+        if (this.#sealed) {
+            return;
+        }
+
+        const table_count = this.descriptors.length;
+
+        // owning edges between different tables, by table index
+        const edges = new Array(table_count);
+
+        for (let i = 0; i < table_count; i++) {
+            edges[i] = [];
+        }
+
+        const links = this.#links;
+
+        for (let i = 0; i < links.length; i++) {
+            const link = links[i];
+
+            if (link.owning && link.target_table !== link.table) {
+                edges[link.table.index].push(link.target_table.index);
+            }
+        }
+
+        const ranges = this.#ranges;
+
+        for (let i = 0; i < ranges.length; i++) {
+            const range = ranges[i];
+
+            if (range.owning && range.target_table !== range.table) {
+                edges[range.table.index].push(range.target_table.index);
+            }
+        }
+
+        // 0 unvisited, 1 on the current path, 2 done
+        const state = new Uint8Array(table_count);
+
+        const visit = (index) => {
+            state[index] = 1;
+
+            const next = edges[index];
+
+            for (let i = 0; i < next.length; i++) {
+                const target = next[i];
+
+                assert.notEqual(state[target], 1, `owning links or ranges between '${this.descriptors[index].name}' and '${this.descriptors[target].name}' come back round`);
+
+                if (state[target] === 0) {
+                    visit(target);
+                }
+            }
+
+            state[index] = 2;
+        };
+
+        for (let i = 0; i < table_count; i++) {
+            if (state[i] === 0) {
+                visit(i);
+            }
+        }
+
+        Object.freeze(links);
+        Object.freeze(ranges);
+
+        this.#sealed = true;
+    }
+
     /**
      *
      * @param {string} name

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

@@ -1 +1 @@
-{"version":3,"file":"GPUDatabaseReadback.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/table/GPUDatabaseReadback.js"],"names":[],"mappings":"AA6LA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH;IA+II;;;;;;;OAOG;IACH;QAN2D,QAAQ,EAAxD,OAAO,kBAAkB,EAAE,WAAW;QACnB,MAAM;QACR,gBAAgB,GAAjC,MAAM;QACW,aAAa,GAA9B,MAAM;QACW,KAAK,GAAtB,MAAM;OAuBhB;IAED;;;OAGG;IACH,+BAEC;IAED;;;OAGG;IACH,4BAEC;IAED;;;;;;;;OAQG;IACH,yBAEC;IAED;;;;;OAKG;IACH,8BAEC;IAED;;;OAGG;IACH,4BAEC;IAED;;;OAGG;IACH,8BAEC;IAED;;;;;OAKG;IACH,6BAEC;IAED;;;OAGG;IACH,iCAEC;IAED;;;OAGG;IACH,8BAEC;IAED;;;;;;;;OAQG;IACH,4BAEC;IAED;;;;;;;OAOG;IACH,4BAEC;IAED;;;;;;;;;;OAUG;IACH,YAHW,MAAM,GACJ,MAAM,CAclB;IAED;;;;;;;;;;;;;;;OAeG;IACH,eAVW,MAAM,OACN,MAAM,eACN,MAAM,aACN,MAAM,UACN,UAAU,uBAGV,MAAM,GACJ,MAAM,CAgDlB;IAED;;;;;;;;;;;OAWG;IACH,SAFa,MAAM,CAwDlB;IAED;;;;;OAKG;IACH,gBAHW,OAAO,2CAA2C,EAAE,sBAAsB,GACxE,OAAO,CAyDnB;IAijBD,gBAyBC;;CACJ"}
+{"version":3,"file":"GPUDatabaseReadback.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/table/GPUDatabaseReadback.js"],"names":[],"mappings":"AA6LA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH;IA+II;;;;;;;OAOG;IACH;QAN2D,QAAQ,EAAxD,OAAO,kBAAkB,EAAE,WAAW;QACnB,MAAM;QACR,gBAAgB,GAAjC,MAAM;QACW,aAAa,GAA9B,MAAM;QACW,KAAK,GAAtB,MAAM;OAuBhB;IAED;;;OAGG;IACH,+BAEC;IAED;;;OAGG;IACH,4BAEC;IAED;;;;;;;;OAQG;IACH,yBAEC;IAED;;;;;OAKG;IACH,8BAEC;IAED;;;OAGG;IACH,4BAEC;IAED;;;OAGG;IACH,8BAEC;IAED;;;;;OAKG;IACH,6BAEC;IAED;;;OAGG;IACH,iCAEC;IAED;;;OAGG;IACH,8BAEC;IAED;;;;;;;;OAQG;IACH,4BAEC;IAED;;;;;;;OAOG;IACH,4BAEC;IAED;;;;;;;;;;OAUG;IACH,YAHW,MAAM,GACJ,MAAM,CAclB;IAED;;;;;;;;;;;;;;;OAeG;IACH,eAVW,MAAM,OACN,MAAM,eACN,MAAM,aACN,MAAM,UACN,UAAU,uBAGV,MAAM,GACJ,MAAM,CAgDlB;IAED;;;;;;;;;;;OAWG;IACH,SAFa,MAAM,CAiElB;IAED;;;;;OAKG;IACH,gBAHW,OAAO,2CAA2C,EAAE,sBAAsB,GACxE,OAAO,CAyDnB;IAijBD,gBAyBC;;CACJ"}