@woosh/meep-engine 3.21.0 → 3.23.0

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

@@ -12,6 +12,12 @@
  * 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.
  *
+ * **Each read carries its own abort signal.** A page the camera stopped wanting is one request out
+ * of hundreds in flight, and cancelling it has to be possible without cancelling the rest — so the
+ * signal is a parameter of {@link read} rather than something baked into the source when it was
+ * built. A source over memory has nothing to abort and says so by checking the signal and refusing
+ * to start; one over the network passes it to `fetch` and the connection really does close.
+ *
  * 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.
  *
@@ -42,6 +48,11 @@ export class VGeoByteSource {
      * 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.
      *
+     * `Blob.arrayBuffer` takes no signal, so a cancelled read here is abandoned rather than
+     * stopped — the local read completes and its bytes are dropped. That is the honest behaviour for
+     * a source with no cancellation of its own, and it is why {@link read} checks the signal on both
+     * sides of the call rather than only before it.
+     *
      * @param {Blob} blob
      * @param {string} [name]
      * @returns {VGeoByteSource}
@@ -49,11 +60,12 @@ export class 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 {function(number, number, AbortSignal=): Promise<Uint8Array>} read given a byte offset,
+     *     a byte count and optionally a signal that says the caller stopped wanting the range,
+     *     resolves with exactly that many bytes
      * @param {string} [name]
      */
-    constructor(byte_length: number, read: (arg0: number, arg1: number) => Promise<Uint8Array>, name?: string);
+    constructor(byte_length: number, read: (arg0: number, arg1: number, arg2: AbortSignal | undefined) => Promise<Uint8Array>, name?: string);
     /**
      * How many bytes this source holds — the whole file, however little of it has been read.
      * @type {number}
@@ -84,11 +96,12 @@ export class VGeoByteSource {
     /**
      * @param {number} byte_offset
      * @param {number} byte_length
+     * @param {AbortSignal} [signal] aborting it abandons this read and no other
      * @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
+     * @throws {Error} if the range is not inside the source, the caller aborted it, or the reader
+     *     answered with a different number of bytes than it was asked for
      */
-    read(byte_offset: number, byte_length: number): Promise<Uint8Array>;
+    read(byte_offset: number, byte_length: number, signal?: AbortSignal): Promise<Uint8Array>;
     #private;
 }
 //# sourceMappingURL=VGeoByteSource.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"VGeoByteSource.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/format/read/VGeoByteSource.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;IA8GI;;;;;;;;;;OAUG;IACH,iBAJW,UAAU,GAAC,WAAW,SACtB,MAAM,GACJ,cAAc,CAU1B;IAED;;;;;;;;;;;;;;;OAeG;IACH,uBAJW,IAAI,SACJ,MAAM,GACJ,cAAc,CAU1B;IA5HD;;;;;;OAMG;IACH,yBANW,MAAM,eACG,MAAM,QAAE,MAAM,QAAE,WAAW,iBAAI,QAAQ,UAAU,CAAC,SAG3D,MAAM,EAUhB;IA7CD;;;OAGG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,eAFU,MAAM,CAEE;IAElB;;;;OAIG;IACH,YAFU,MAAM,CAED;IA8Bf;;OAEG;IACH,mBAEC;IAED;;;;;OAKG;IACH,uBAGC;IAED;;;;;;;OAOG;IACH,kBAPW,MAAM,eACN,MAAM,WACN,WAAW,GACT,QAAQ,UAAU,CAAC,CAsC/B;;CAgDJ"}

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

@@ -14,6 +14,12 @@ import { assert } from "../../../../../../core/assert.js";
  * 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.
  *
+ * **Each read carries its own abort signal.** A page the camera stopped wanting is one request out
+ * of hundreds in flight, and cancelling it has to be possible without cancelling the rest — so the
+ * signal is a parameter of {@link read} rather than something baked into the source when it was
+ * built. A source over memory has nothing to abort and says so by checking the signal and refusing
+ * to start; one over the network passes it to `fetch` and the connection really does close.
+ *
  * 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.
  *
@@ -45,7 +51,7 @@ export class VGeoByteSource {
     bytes_read = 0;
 
     /**
-     * @type {function(number, number): Promise<Uint8Array>}
+     * @type {function(number, number, AbortSignal=): Promise<Uint8Array>}
      */
     #read;
 
@@ -57,8 +63,9 @@ export class 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 {function(number, number, AbortSignal=): Promise<Uint8Array>} read given a byte offset,
+     *     a byte count and optionally a signal that says the caller stopped wanting the range,
+     *     resolves with exactly that many bytes
      * @param {string} [name]
      */
     constructor(byte_length, read, name = 'a byte source') {
@@ -92,11 +99,12 @@ export class VGeoByteSource {
     /**
      * @param {number} byte_offset
      * @param {number} byte_length
+     * @param {AbortSignal} [signal] aborting it abandons this read and no other
      * @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
+     * @throws {Error} if the range is not inside the source, the caller aborted it, or the reader
+     *     answered with a different number of bytes than it was asked for
      */
-    async read(byte_offset, byte_length) {
+    async read(byte_offset, byte_length, signal = undefined) {
         if (
             !Number.isInteger(byte_offset) || byte_offset < 0
             || !Number.isInteger(byte_length) || byte_length < 0
@@ -108,7 +116,13 @@ export class VGeoByteSource {
             );
         }
 
-        const bytes = await this.#read(byte_offset, byte_length);
+        // Before the read rather than only after: a source over memory resolves in a microtask, and
+        // a caller that cancelled between queueing and here would otherwise still pay for it.
+        signal?.throwIfAborted();
+
+        const bytes = await this.#read(byte_offset, byte_length, signal);
+
+        signal?.throwIfAborted();
 
         if (bytes.byteLength !== byte_length) {
             // Checked rather than trusted: everything downstream indexes by the format's offsets,
@@ -154,6 +168,11 @@ export class VGeoByteSource {
      * 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.
      *
+     * `Blob.arrayBuffer` takes no signal, so a cancelled read here is abandoned rather than
+     * stopped — the local read completes and its bytes are dropped. That is the honest behaviour for
+     * a source with no cancellation of its own, and it is why {@link read} checks the signal on both
+     * sides of the call rather than only before it.
+     *
      * @param {Blob} blob
      * @param {string} [name]
      * @returns {VGeoByteSource}

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

@@ -16,11 +16,26 @@
  * more, {@link evict} drops one, and a {@link VGeoPage} owns its own bytes and tables so that
  * dropping it drops everything it cost.
  *
+ * **Selectability is the other half of it, and it is not the same question.** {@link is_selectable}
+ * answers §10's activation invariant — whether a group's *entire ancestor cone* is here, not merely
+ * its own bytes — held as one counter per resident group. A traversal that clamps on residency
+ * instead refines into a group through the parents that arrived while a coarse cluster still stands
+ * in for one that did not, and draws both over the same surface. That is what activation is for, and
+ * it is why installing a page does bookkeeping rather than only filling a map.
+ *
+ * **Mechanics, not policy — and the line is deliberate.** Which page to fetch next, which to drop,
+ * how many bytes one asset may hold, how many requests may be in flight across a thousand of them:
+ * none of that is decided here, because none of it can be decided by one reader looking at one file.
+ * `VGeoResidencyManager` is where it is decided and readers register with one; §10's eviction bullet
+ * is the reason for the split rather than an apology for it. What *is* here is everything that is
+ * about the bytes — the fetch, the retries, the quarantine a page that will not arrive ends up in,
+ * and the accounting a budget owner spends against.
+ *
  * **Validation is not on this path.** The mandatory reject rules of §4 and §10 are applied
  * unconditionally by {@link vgeo_read_header} and {@link vgeo_read_page} — a file whose magic,
  * versions, encoding or codec this build does not understand is refused rather than misread. The
- * whole-file audit is {@link validate}, it reads every byte of the file, and it is off by default;
- * see {@link VGeoReadOptions.validate}.
+ * whole-file audit is `vgeo_audit_container` in `tool/`, it reads every byte of the file, and
+ * nothing on the runtime path can reach it.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
@@ -65,6 +80,16 @@ export class VGeoContainerReader {
     get resident_page_count(): number;
     /**
      * Decoded bytes currently held. The number a residency budget is spent against.
+     *
+     * It is exactly the decoded page images — the same number the directory's `decoded_size` column
+     * and every child-table entry promise *before* a page is fetched, which is what lets a budget
+     * owner admit a page rather than discover its cost after paying for it. It is deliberately not
+     * what the pages cost in the heap: the reader's own per-page bookkeeping — the `VGeoPage`, its
+     * cluster and child tables, the two activation arrays, the map entries — measured 6.4–11.9 KB
+     * per page on top of the image. That is 1.2% of a 544 KB page at the sizes design §5 targets and
+     * 294% of a 2 KB one, so a budget sized against very small pages has to allow for it and one
+     * sized against the design's page size is inside its own rounding.
+     *
      * @returns {number}
      */
     get resident_bytes(): number;
@@ -72,17 +97,60 @@ export class VGeoContainerReader {
      * @returns {number}
      */
     get pending_page_count(): number;
+    /**
+     * How many not-yet-resident pages the reverse-reference index is holding counters for.
+     *
+     * Diagnostic, and the number a leak in that index would show up in: an entry exists only while
+     * some resident, selectable cluster refers into a page that is not here, so this tracks the
+     * residency frontier and must not track how many pages a session has visited. See
+     * {@link #pending_refs} for what that was measured at.
+     *
+     * @returns {number}
+     */
+    get pending_reference_page_count(): number;
+    /**
+     * How many bytes of speculative head prefix are still held — zero once {@link release_head} has
+     * run, which is the normal state after the first read that falls outside the prefix.
+     *
+     * @returns {number}
+     */
+    get head_bytes(): number;
+    /**
+     * How many pages have failed their retries and will not be asked for again.
+     * @returns {number}
+     */
+    get quarantined_page_count(): number;
     /**
      * The root page, which is pinned for the life of the reader — §10 makes it the one page that is
      * never evictable, because every traversal starts by walking its parentless groups.
+     *
+     * What the pin costs is worth writing down, because "pinned for life, times a thousand assets"
+     * is the shape of a problem and this one is not: build invariant §11.7 puts exactly one root
+     * cluster in the file, and the assembler gives the root page the complete topmost level — so the
+     * root page *is* that one cluster. Measured on two torus builds, of 7.7K and 42K source
+     * triangles and 8 and 12 levels: 1,732 B and 1,472 B decoded. A thousand of them is under 2 MB,
+     * and no builder-side cap on root size is needed to keep it that way.
+     *
      * @returns {VGeoPage}
      */
     get root(): VGeoPage;
     /**
-     * Every resident page, in page-index order.
+     * Every resident page, sorted by page index.
+     *
+     * A snapshot, and it costs one: an array of every resident page plus a sort of it — 0.29 ms per
+     * access measured at 20,000 resident pages. So this is for a tool, a panel or a test, and **not
+     * for anything that runs per frame**. {@link resident_pages} is the same set in arrival order
+     * and allocates nothing, which is what a per-frame sweep should read.
+     *
      * @returns {VGeoPage[]}
      */
     get pages(): VGeoPage[];
+    /**
+     * Every resident page, in arrival order, allocating nothing.
+     *
+     * @returns {IterableIterator<VGeoPage>}
+     */
+    resident_pages(): IterableIterator<VGeoPage>;
     /**
      * The page, if it is here.
      *
@@ -98,18 +166,117 @@ export class VGeoContainerReader {
      * @returns {boolean}
      */
     is_resident(page_index: number): boolean;
+    /**
+     * How many of a page's child pages are resident.
+     *
+     * §10's eviction rule is written in terms of this: within a residency tier, a page is evictable
+     * only while it has no resident child pages in that tier, checked against its own child table.
+     * `SAME_PAGE` references never pin and are in no child table by construction (§11.2), so the
+     * table is the whole answer. The *rule* is a policy and lives with the budget owner; this
+     * lookup is about one page's own bytes and lives here.
+     *
+     * @param {number} page_index
+     * @returns {number} zero for a page that is not resident, and for one no child of which is
+     */
+    resident_child_count(page_index: number): number;
+    /**
+     * Whether a group may be selected from — §10's activation invariant, and **not** the same
+     * question as {@link is_resident}.
+     *
+     * A group is selectable iff every one of its `parent_cluster_count` references is live: the
+     * referencing cluster's page is installed and that cluster's own group is selectable. Groups
+     * with no parents at all — exactly the root page's topmost level — are selectable the moment
+     * their page is.
+     *
+     * The distinction is load-bearing and it is invisible until an asset is big enough to put one
+     * group's parents in two pages. Refining into a group whose page merely *arrived* draws it
+     * underneath the coarse cluster still standing in for the parent that did not, and the two
+     * surfaces fight over the same pixels. Residency says the bytes are here; selectability says
+     * nothing above them is missing, which is what "no holes and no double-draw, in any arrival
+     * order" actually rests on.
+     *
+     * Synchronous and total, like {@link page}: the traversal asks it per cluster and acts on a
+     * `false` by clamping.
+     *
+     * @param {number} page_index
+     * @param {number} group index within that page
+     * @returns {boolean}
+     */
+    is_selectable(page_index: number, group: number): boolean;
+    /**
+     * Whether a page has failed its retries and been quarantined.
+     *
+     * @param {number} page_index
+     * @returns {boolean}
+     */
+    is_quarantined(page_index: number): boolean;
+    /**
+     * Why a page was quarantined, or `undefined` if it was not.
+     *
+     * §10 asks for the quarantine *and* for telemetry, because a page that stopped arriving is the
+     * difference between a coarse asset and a broken deployment, and on screen the two are the same
+     * picture.
+     *
+     * @param {number} page_index
+     * @returns {string|undefined}
+     */
+    quarantine_reason(page_index: number): string | undefined;
+    /**
+     * Every quarantined page and its reason.
+     * @returns {IterableIterator<[number, string]>}
+     */
+    quarantine(): IterableIterator<[number, string]>;
+    /**
+     * Let a quarantined page be asked for again.
+     *
+     * **When** is a policy and is not decided here. A frame checksum that failed at a
+     * content-addressed URL will fail again and lifting its quarantine buys nothing; a run of 503s
+     * from one edge node is a different thing, and a budget owner that has watched other pages of
+     * other assets arrive since has evidence this reader does not have. So the reader quarantines
+     * for its own lifetime and offers this, and `VGeoResidencyManager` is where the decision to use
+     * it lives.
+     *
+     * @param {number} [page_index] omit to lift every quarantine
+     * @returns {number} how many pages were released
+     */
+    clear_quarantine(page_index?: number): number;
     /**
      * Fetch and install one page, from the exact range something already resident named.
      *
      * Concurrent calls for the same page share one fetch; a page already resident is returned
-     * without one.
+     * without one; a page in quarantine is refused without one.
      *
      * @param {number} page_index
      * @param {number} frame_offset absolute
      * @param {number} fetch_size
      * @returns {Promise<VGeoPage>}
+     * @throws {Error} asynchronously — when the page is already quarantined, when it fails every
+     *     attempt and is quarantined by doing so, or when {@link cancel} abandoned it
      */
     install(page_index: number, frame_offset: number, fetch_size: number): Promise<VGeoPage>;
+    /**
+     * Abandon a fetch that is still in flight.
+     *
+     * **What a want that goes stale mid-flight should do, decided:** abort it while it can still be
+     * aborted, and install it once it cannot. The camera moved, nothing wants the page now, and the
+     * request is worth closing — but once the bytes have landed, refusing to install them is the one
+     * choice that pays for the fetch *and* throws the page away. So an abort that arrives too late
+     * does nothing, the page installs, and it enters residency untouched — which under LRU on
+     * last-touched (design §6) makes it the first candidate for eviction if the camera really is
+     * done with it, and free if it is not.
+     *
+     * The pending promise rejects, so a caller awaiting it sees the abort rather than a page. A
+     * cancelled page is **not** quarantined: nothing was wrong with it.
+     *
+     * @param {number} page_index
+     * @returns {boolean} whether there was a fetch to abandon
+     */
+    cancel(page_index: number): boolean;
+    /**
+     * Abandon every fetch in flight.
+     * @returns {number} how many were abandoned
+     */
+    cancel_all(): number;
     /**
      * Install the page a want names.
      *
@@ -124,18 +291,31 @@ export class VGeoContainerReader {
      * clamped cluster projected — so a caller that stops early has fetched the pages that would fix
      * the most visible coarseness, not an arbitrary prefix of the list.
      *
+     * **A page that will not arrive does not take the batch down.** One flaky edge node, or one
+     * corrupt frame out of a thousand assets' worth of pages, must cost exactly that page: it is
+     * retried, then quarantined, then skipped, and what comes back is what did install. *Which*
+     * pages failed is durable rather than a per-call return — see {@link quarantine} — because a
+     * failure that lived only in one call's result is one the next call would repeat.
+     *
+     * The concurrency bound here is this reader's own. A runtime holding many assets wants a bound
+     * across all of them and should install through `VGeoResidencyManager`, which admits every
+     * registered reader's fetches through one scheduler: eight readers calling this at the default
+     * were measured issuing 48 concurrent range requests.
+     *
      * @param {VGeoPageWant[]} wants
      * @param {number} [limit] most pages to install; the rest are left for the next traversal to
      *     want again, which it will, from a cut taken with everything this call did install
+     * @param {AbortSignal} [signal] stops the batch taking new wants, and abandons what is in flight
      * @returns {Promise<VGeoPage[]>} the pages installed, in completion order
      */
-    install_wants(wants: VGeoPageWant[], limit?: number): Promise<VGeoPage[]>;
+    install_wants(wants: VGeoPageWant[], limit?: number, signal?: AbortSignal): Promise<VGeoPage[]>;
     /**
      * Drop a page.
      *
      * The eviction *rule* — a page is evictable only while it has no resident child pages, and the
      * root is pinned (§10) — is a residency policy and belongs to whatever is managing the budget,
-     * not here. What this does is the dropping.
+     * not here. What this does is the dropping; {@link resident_child_count} is the lookup the rule
+     * is written in terms of.
      *
      * @param {number} page_index
      * @returns {boolean} whether a page was there to drop
@@ -160,10 +340,9 @@ export class VGeoContainerReader {
     /**
      * Install every page the directory lists.
      *
-     * The opposite of what this reader is for, and exactly what a tool wants when the question is
-     * about the file rather than about a view of it — the pages no cut reaches are the ones a bug
-     * hides in.
-     *
+     * @deprecated it reads the whole file, and a renderer holding a reader must not be able to reach
+     *     that from the reader. Call `vgeo_install_all_pages` in `tool/` instead, which is a tool
+     *     and says so. Kept as a shim because the playground and the specs are what it is for.
      * @param {function(number, number): void} [on_progress] called with pages installed and total
      * @returns {Promise<void>}
      */
@@ -172,13 +351,24 @@ export class VGeoContainerReader {
      * The whole-file audit — every build invariant of §11, every checksum, and the directory against
      * what a frame scan reconstructs.
      *
-     * **This reads the entire file**, which is the one thing the rest of this class exists to avoid,
-     * and it is why it is a separate call and off by default. It answers a question about whoever
-     * produced the file; nothing about reading one depends on it having been asked.
-     *
+     * @deprecated it reads the entire file into one `ArrayBuffer`, which is the one thing the rest
+     *     of this class exists to avoid and which a multi-GB asset does not survive. Call
+     *     `vgeo_audit_container` in `tool/` instead, which refuses a file too large to audit this
+     *     way rather than attempting it. Kept as a shim for the playground and the specs.
      * @returns {Promise<VGeoDefect[]>} empty is the only good answer
      */
     validate(): Promise<VGeoDefect[]>;
+    /**
+     * Drop the speculative head prefix.
+     *
+     * Nothing depends on it afterwards: the header and level table are parsed into {@link header}
+     * before anything else runs, the root page owns its own decoded bytes, and every later read
+     * names a range the source can serve. A page whose frame lay inside the prefix costs one request
+     * if it is wanted after this — the same request it would have cost had the prefix been smaller.
+     *
+     * @returns {number} bytes released
+     */
+    release_head(): number;
     #private;
 }
 import { VGeoReadOptions } from "./VGeoReadOptions.js";

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

@@ -1 +1 @@
-{"version":3,"file":"VGeoContainerReader.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/format/read/VGeoContainerReader.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAqHI;;;;;;;;OAQG;IACH,8CALW,eAAe,GACb,QAAQ,mBAAmB,CAAC,CAUxC;IA/ED;;;OAGG;IACH,8CAFW,eAAe,EAOzB;IA7DD;;OAEG;IACH,4BAAmB;IAEnB;;;;OAIG;IACH,WAFU,gBAAc,SAAS,CAEX;IAqDtB;;OAEG;IACH,6BAEC;IAED;;OAEG;IACH,+BAEC;IAED;;OAEG;IACH,kCAEC;IAED;;;OAGG;IACH,6BAEC;IAED;;OAEG;IACH,iCAEC;IAED;;;;OAIG;IACH,qBAEC;IAED;;;OAGG;IACH,wBAEC;IAyFD;;;;;;;;OAQG;IACH,iBAHW,MAAM,GACJ,WAAS,SAAS,CAI9B;IAED;;;OAGG;IACH,wBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;;;OAUG;IACH,oBALW,MAAM,gBACN,MAAM,cACN,MAAM,GACJ,iBAAiB,CAqB7B;IA+BD;;;;;OAKG;IACH,kCAFa,iBAAiB,CAI7B;IAED;;;;;;;;;;;OAWG;IACH,qBALW,cAAc,UACd,MAAM,GAEJ,QAAQ,UAAU,CAAC,CA8B/B;IAED;;;;;;;;;OASG;IACH,kBAHW,MAAM,GACJ,OAAO,CAcnB;IAED;;;;OAIG;IACH,aAFa,MAAM,CAYlB;IAED;;;;;;;;OAQG;IACH,kBAFa,sBAAsB,CAkBlC;IAED;;;;;;;;;OASG;IACH,uCAHoB,MAAM,QAAE,MAAM,KAAG,IAAI,GAC5B,QAAQ,IAAI,CAAC,CAgBzB;IAED;;;;;;;;;OASG;IACH,YAFa,QAAQ,YAAY,CAAC,CAUjC;;CA6EJ;gCArjB+B,sBAAsB"}
+{"version":3,"file":"VGeoContainerReader.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/format/read/VGeoContainerReader.js"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH;IAwPI;;;;;;;;OAQG;IACH,8CALW,eAAe,GACb,QAAQ,mBAAmB,CAAC,CAUxC;IAhJD;;;OAGG;IACH,8CAFW,eAAe,EAOzB;IA/HD;;OAEG;IACH,4BAAmB;IAEnB;;;;OAIG;IACH,WAFU,gBAAc,SAAS,CAEX;IAuHtB;;OAEG;IACH,6BAEC;IAED;;OAEG;IACH,+BAEC;IAED;;OAEG;IACH,kCAEC;IAED;;;;;;;;;;;;;OAaG;IACH,6BAEC;IAED;;OAEG;IACH,iCAEC;IAED;;;;;;;;;OASG;IACH,2CAEC;IAED;;;;;OAKG;IACH,yBAEC;IAED;;;OAGG;IACH,qCAEC;IAED;;;;;;;;;;;;OAYG;IACH,qBAEC;IAED;;;;;;;;;OASG;IACH,wBAEC;IAED;;;;OAIG;IACH,kBAFa,0BAA0B,CAItC;IA0FD;;;;;;;;OAQG;IACH,iBAHW,MAAM,GACJ,WAAS,SAAS,CAI9B;IAED;;;OAGG;IACH,wBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;;;;OAWG;IACH,iCAHW,MAAM,GACJ,MAAM,CAoBlB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,0BAJW,MAAM,SACN,MAAM,GACJ,OAAO,CAUnB;IAoOD;;;;;OAKG;IACH,2BAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;;OASG;IACH,8BAHW,MAAM,GACJ,MAAM,GAAC,SAAS,CAI5B;IAED;;;OAGG;IACH,cAFa,iBAAiB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAI9C;IAED;;;;;;;;;;;;OAYG;IACH,8BAHW,MAAM,GACJ,MAAM,CAYlB;IAED;;;;;;;;;;;;OAYG;IACH,oBAPW,MAAM,gBACN,MAAM,cACN,MAAM,GACJ,iBAAiB,CAoC7B;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,mBAHW,MAAM,GACJ,OAAO,CAYnB;IAED;;;OAGG;IACH,cAFa,MAAM,CAYlB;IA0ED;;;;;OAKG;IACH,kCAFa,iBAAiB,CAI7B;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,qBANW,cAAc,UACd,MAAM,WAEN,WAAW,GACT,QAAQ,UAAU,CAAC,CA+D/B;IAED;;;;;;;;;;OAUG;IACH,kBAHW,MAAM,GACJ,OAAO,CAoDnB;IAED;;;;OAIG;IACH,aAFa,MAAM,CAYlB;IAED;;;;;;;;OAQG;IACH,kBAFa,sBAAsB,CAkBlC;IAED;;;;;;;;OAQG;IACH,uCAHoB,MAAM,QAAE,MAAM,KAAG,IAAI,GAC5B,QAAQ,IAAI,CAAC,CAMzB;IAED;;;;;;;;;OASG;IACH,YAFa,QAAQ,YAAY,CAAC,CAYjC;IAiCD;;;;;;;;;OASG;IACH,gBAFa,MAAM,CAQlB;;CA8DJ;gCA9vC+B,sBAAsB"}