@idetik/core 0.4.0 → 0.4.2

package/dist/index.d.ts

@@ -139,11 +139,51 @@ type ChunkLoader = {
     loadChunkData(chunk: Chunk, signal: AbortSignal): Promise<void>;
 };
 
+declare const ALL_CATEGORIES: readonly ["fallbackVisible", "prefetchTime", "visibleCurrent", "fallbackBackground", "prefetchSpace"];
+type PriorityCategory = (typeof ALL_CATEGORIES)[number];
+type ImageSourcePolicyConfig = {
+    profile?: string;
+    prefetch: {
+        x: number;
+        y: number;
+        z?: number;
+        t?: number;
+    };
+    priorityOrder: PriorityCategory[];
+    lod?: {
+        min?: number;
+        max?: number;
+        bias?: number;
+    };
+};
+type ImageSourcePolicy = Readonly<{
+    profile: string;
+    prefetch: {
+        x: number;
+        y: number;
+        z: number;
+        t: number;
+    };
+    priorityOrder: readonly PriorityCategory[];
+    priorityMap: Readonly<Record<PriorityCategory, number>>;
+    lod: {
+        min: number;
+        max: number;
+        bias: number;
+    };
+}>;
+declare function createImageSourcePolicy(config: ImageSourcePolicyConfig): ImageSourcePolicy;
+declare function createExplorationPolicy(overrides?: Partial<ImageSourcePolicyConfig>): ImageSourcePolicy;
+declare function createPlaybackPolicy(overrides?: Partial<ImageSourcePolicyConfig>): ImageSourcePolicy;
+declare function createNoPrefetchPolicy(overrides?: Partial<ImageSourcePolicyConfig>): ImageSourcePolicy;
+
 declare class ChunkStore {
     private readonly chunks_;
     private readonly loader_;
     private readonly lowestResLOD_;
     private readonly dimensions_;
+    private readonly views_;
+    private hasHadViews_;
     constructor(loader: ChunkLoader);
     getChunksAtTime(timeIndex: number): Chunk[];
     getTimeIndex(sliceCoords: SliceCoordinates): number;
@@ -151,6 +191,12 @@ declare class ChunkStore {
     get dimensions(): SourceDimensionMap;
     getLowestResLOD(): number;
     loadChunkData(chunk: Chunk, signal: AbortSignal): Promise<void>;
+    createView(policy: ImageSourcePolicy): ChunkStoreView;
+    removeView(view: ChunkStoreView): void;
+    get views(): ReadonlyArray<ChunkStoreView>;
+    canDispose(): boolean;
+    updateAndCollectChunkChanges(): Set<Chunk>;
+    private aggregateChunkViewStates;
     private validateXYScaleRatios;
     private getAndValidateTimeDimension;
     private getAndValidateChannelDimension;
@@ -472,44 +518,6 @@ declare class Viewport {
 }
 declare function parseViewportConfigs(viewportConfigs: ViewportConfig[], canvas: HTMLCanvasElement, context: IdetikContext): Viewport[];
 
-declare const ALL_CATEGORIES: readonly ["fallbackVisible", "prefetchTime", "visibleCurrent", "fallbackBackground", "prefetchSpace"];
-type PriorityCategory = (typeof ALL_CATEGORIES)[number];
-type ImageSourcePolicyConfig = {
-    profile?: string;
-    prefetch: {
-        x: number;
-        y: number;
-        z?: number;
-        t?: number;
-    };
-    priorityOrder: PriorityCategory[];
-    lod?: {
-        min?: number;
-        max?: number;
-        bias?: number;
-    };
-};
-type ImageSourcePolicy = Readonly<{
-    profile: string;
-    prefetch: {
-        x: number;
-        y: number;
-        z: number;
-        t: number;
-    };
-    priorityOrder: readonly PriorityCategory[];
-    priorityMap: Readonly<Record<PriorityCategory, number>>;
-    lod: {
-        min: number;
-        max: number;
-        bias: number;
-    };
-}>;
-declare function createImageSourcePolicy(config: ImageSourcePolicyConfig): ImageSourcePolicy;
-declare function createExplorationPolicy(overrides?: Partial<ImageSourcePolicyConfig>): ImageSourcePolicy;
-declare function createPlaybackPolicy(overrides?: Partial<ImageSourcePolicyConfig>): ImageSourcePolicy;
-declare function createNoPrefetchPolicy(overrides?: Partial<ImageSourcePolicyConfig>): ImageSourcePolicy;
-
 declare class ChunkStoreView {
     private readonly store_;
     private policy_;
@@ -521,13 +529,16 @@ declare class ChunkStoreView {
     private sourceMaxSquareDistance2D_;
     private readonly chunkViewStates_;
     constructor(store: ChunkStore, policy: ImageSourcePolicy);
-    get store(): ChunkStore;
     get chunkViewStates(): ReadonlyMap<Chunk, ChunkViewState>;
+    getChunksAtTime(timeIndex: number): Chunk[];
+    getTimeIndex(sliceCoords: SliceCoordinates): number;
+    get lodCount(): number;
     getChunksToRender(sliceCoords: SliceCoordinates): Chunk[];
     updateChunkStates(sliceCoords: SliceCoordinates, viewport: Viewport): void;
     allVisibleLowestLODLoaded(sliceCoords: SliceCoordinates): boolean;
     get currentLOD(): number;
     maybeForgetChunk(chunk: Chunk): void;
+    dispose(): void;
     setImageSourcePolicy(newPolicy: ImageSourcePolicy, key: symbol): void;
     private setLOD;
     private updateChunkViewStates;
@@ -546,15 +557,10 @@ declare class ChunkStoreView {
 declare class ChunkManager {
     private readonly stores_;
     private readonly pendingStores_;
-    private readonly views_;
     private readonly queue_;
     addView(source: ChunkSource, policy: ImageSourcePolicy): Promise<ChunkStoreView>;
-    removeView(view: ChunkStoreView): void;
-    private addSource;
-    private getSourceForStore;
+    private getOrCreateStore;
     update(): void;
-    private updateAndCollectChunkChanges;
-    private aggregateChunkViewStates;
 }
 
 type Overlay = {
@@ -640,7 +646,6 @@ declare class Idetik {
     start(): this;
     private animate;
     stop(): void;
-    private updateSize;
 }
 
 declare abstract class Renderer {
@@ -810,7 +815,7 @@ declare class ChunkedImageLayer extends Layer implements ChannelsEnabled {
     private readonly wireframeColors_;
     constructor({ source, sliceCoords, policy, channelProps, onPickValue, ...layerOptions }: ChunkedImageLayerProps);
     onAttached(context: IdetikContext): Promise<void>;
-    onDetached(context: IdetikContext): void;
+    onDetached(_context: IdetikContext): void;
     update(context?: RenderContext): void;
     private updateChunks;
     get lastPresentationTimeCoord(): number | undefined;

package/dist/index.js

@@ -2009,136 +2009,11 @@ function xQ(g, A) {
 function jI(g, A, I = 1e-6) {
   return Math.abs(g - A) <= I;
 }
-class bQ {
-  chunks_;
-  loader_;
-  lowestResLOD_;
-  dimensions_;
-  constructor(A) {
-    this.loader_ = A, this.dimensions_ = this.loader_.getSourceDimensionMap(), this.lowestResLOD_ = this.dimensions_.numLods - 1, this.validateXYScaleRatios();
-    const { size: I } = this.getAndValidateTimeDimension(), { size: B } = this.getAndValidateChannelDimension();
-    this.chunks_ = Array.from({ length: I }, () => []);
-    for (let Q = 0; Q < I; ++Q) {
-      const C = this.chunks_[Q];
-      for (let E = 0; E < this.dimensions_.numLods; ++E) {
-        const i = this.dimensions_.x.lods[E], o = this.dimensions_.y.lods[E], a = this.dimensions_.z?.lods[E], D = i.chunkSize, h = o.chunkSize, y = a?.chunkSize ?? 1, t = Math.ceil(i.size / D), F = Math.ceil(o.size / h), r = Math.ceil((a?.size ?? 1) / y);
-        for (let S = 0; S < B; ++S)
-          for (let e = 0; e < t; ++e) {
-            const c = i.translation + e * i.chunkSize * i.scale;
-            for (let N = 0; N < F; ++N) {
-              const M = o.translation + N * o.chunkSize * o.scale;
-              for (let Y = 0; Y < r; ++Y) {
-                const J = a !== void 0 ? a.translation + Y * y * a.scale : 0;
-                C.push({
-                  state: "unloaded",
-                  lod: E,
-                  visible: !1,
-                  prefetch: !1,
-                  priority: null,
-                  orderKey: null,
-                  shape: {
-                    x: Math.min(D, i.size - e * D),
-                    y: Math.min(h, o.size - N * h),
-                    z: Math.min(y, (a?.size ?? 1) - Y * y),
-                    c: 1
-                  },
-                  rowAlignmentBytes: 1,
-                  chunkIndex: { x: e, y: N, z: Y, c: S, t: Q },
-                  scale: {
-                    x: i.scale,
-                    y: o.scale,
-                    z: a?.scale ?? 1
-                  },
-                  offset: {
-                    x: c,
-                    y: M,
-                    z: J
-                  }
-                });
-              }
-            }
-          }
-      }
-    }
-  }
-  getChunksAtTime(A) {
-    return this.chunks_[A];
-  }
-  getTimeIndex(A) {
-    return A.t === void 0 || this.dimensions_.t === void 0 ? 0 : xQ(this.dimensions_.t.lods[0], A.t);
-  }
-  get lodCount() {
-    return this.lowestResLOD_ + 1;
-  }
-  get dimensions() {
-    return this.dimensions_;
-  }
-  getLowestResLOD() {
-    return this.lowestResLOD_;
-  }
-  loadChunkData(A, I) {
-    return this.loader_.loadChunkData(A, I);
-  }
-  validateXYScaleRatios() {
-    const A = this.dimensions_.x, I = this.dimensions_.y;
-    for (let B = 1; B < this.dimensions_.numLods; B++) {
-      const Q = A.lods[B].scale / A.lods[B - 1].scale, C = I.lods[B].scale / I.lods[B - 1].scale;
-      if (!jI(Q, 2, 0.02) || !jI(C, 2, 0.02))
-        throw new Error(
-          `Invalid downsampling factor between levels ${B - 1} → ${B}: expected (2× in X and Y), but got (${Q.toFixed(2)}×, ${C.toFixed(2)}×) from scale [${A.lods[B - 1].scale}, ${I.lods[B - 1].scale}] → [${A.lods[B].scale}, ${I.lods[B].scale}]`
-        );
-    }
-  }
-  getAndValidateTimeDimension() {
-    for (let A = 0; A < this.dimensions_.numLods; ++A) {
-      const I = this.dimensions_.t?.lods[A];
-      if (!I) continue;
-      if (I.chunkSize !== 1)
-        throw new Error(
-          `ChunkStore only supports a chunk size of 1 in t. Found ${I.chunkSize} at LOD ${A}`
-        );
-      const B = this.dimensions_.t?.lods[A - 1];
-      if (B && I.size !== B.size)
-        throw new Error(
-          `ChunkStore does not support downsampling in t. Found ${B.size} at LOD ${A - 1} → ${I.size} at LOD ${A}`
-        );
-    }
-    return {
-      size: this.dimensions_.t?.lods[0].size ?? 1
-    };
-  }
-  getAndValidateChannelDimension() {
-    for (let A = 0; A < this.dimensions_.numLods; ++A) {
-      const I = this.dimensions_.c?.lods[A];
-      if (!I) continue;
-      if (I.chunkSize !== 1)
-        throw new Error(
-          `ChunkStore only supports a chunk size of 1 in c. Found ${I.chunkSize} at LOD ${A}`
-        );
-      if (I.scale !== 1)
-        throw new Error(
-          `ChunkStore does not support scale in c. Found ${I.scale} at LOD ${A}`
-        );
-      if (I.translation !== 0)
-        throw new Error(
-          `ChunkStore does not support translation in c. Found ${I.translation} at LOD ${A}`
-        );
-      const B = this.dimensions_.c?.lods[A - 1];
-      if (B && I.size !== B.size)
-        throw new Error(
-          `ChunkStore does not support downsampling in c. Found ${B.size} at LOD ${A - 1} → ${I.size} at LOD ${A}`
-        );
-    }
-    return {
-      size: this.dimensions_.c?.lods[0].size ?? 1
-    };
-  }
-}
 function OA(g, A, I) {
   return Math.max(A, Math.min(I, g));
 }
 const FB = Symbol("INTERNAL_POLICY_KEY");
-class ZQ {
+class bQ {
   store_;
   policy_;
   policyChanged_ = !1;
@@ -2159,12 +2034,19 @@ class ZQ {
       u(Q.size * Q.scale, C.size * C.scale)
     );
   }
-  get store() {
-    return this.store_;
-  }
   get chunkViewStates() {
     return this.chunkViewStates_;
   }
+  // forwarding methods for chunk stats overlay while keeping store_ private
+  getChunksAtTime(A) {
+    return this.store_.getChunksAtTime(A);
+  }
+  getTimeIndex(A) {
+    return this.store_.getTimeIndex(A);
+  }
+  get lodCount() {
+    return this.store_.lodCount;
+  }
   getChunksToRender(A) {
     const I = this.store_.getTimeIndex(A), B = this.store_.getChunksAtTime(I), Q = B.filter(
       (i) => i.lod === this.currentLOD_ && this.chunkViewStates_.get(i)?.visible === !0 && i.state === "loaded"
@@ -2195,6 +2077,9 @@ class ZQ {
     const I = this.chunkViewStates_.get(A);
     I && (I.visible || I.prefetch || I.priority !== null) || this.chunkViewStates_.delete(A);
   }
+  dispose() {
+    this.store_.removeView(this);
+  }
   setImageSourcePolicy(A, I) {
     if (I !== FB)
       throw new Error("Unauthorized policy mutation");
@@ -2229,7 +2114,7 @@ class ZQ {
       q(I.min[0], I.min[1], E),
       q(I.max[0], I.max[1], i)
     );
-    this.chunkViewStates_.forEach(PQ), this.updateChunksAtTimeIndex(
+    this.chunkViewStates_.forEach(ZQ), this.updateChunksAtTimeIndex(
       B,
       A,
       o,
@@ -2346,80 +2231,118 @@ class ZQ {
     return Q * Q + C * C;
   }
 }
-function PQ(g) {
+function ZQ(g) {
   g.visible = !1, g.prefetch = !1, g.priority = null, g.orderKey = null;
 }
-class OQ {
-  stores_ = /* @__PURE__ */ new Map();
-  pendingStores_ = /* @__PURE__ */ new Map();
-  views_ = /* @__PURE__ */ new Map();
-  queue_ = new WQ();
-  async addView(A, I) {
-    const B = await this.addSource(A), Q = new ZQ(B, I);
-    return this.views_.set(B, (this.views_.get(B) ?? []).concat(Q)), Q;
+class PQ {
+  chunks_;
+  loader_;
+  lowestResLOD_;
+  dimensions_;
+  views_ = [];
+  hasHadViews_ = !1;
+  constructor(A) {
+    this.loader_ = A, this.dimensions_ = this.loader_.getSourceDimensionMap(), this.lowestResLOD_ = this.dimensions_.numLods - 1, this.validateXYScaleRatios();
+    const { size: I } = this.getAndValidateTimeDimension(), { size: B } = this.getAndValidateChannelDimension();
+    this.chunks_ = Array.from({ length: I }, () => []);
+    for (let Q = 0; Q < I; ++Q) {
+      const C = this.chunks_[Q];
+      for (let E = 0; E < this.dimensions_.numLods; ++E) {
+        const i = this.dimensions_.x.lods[E], o = this.dimensions_.y.lods[E], a = this.dimensions_.z?.lods[E], D = i.chunkSize, h = o.chunkSize, y = a?.chunkSize ?? 1, t = Math.ceil(i.size / D), F = Math.ceil(o.size / h), r = Math.ceil((a?.size ?? 1) / y);
+        for (let S = 0; S < B; ++S)
+          for (let e = 0; e < t; ++e) {
+            const c = i.translation + e * i.chunkSize * i.scale;
+            for (let N = 0; N < F; ++N) {
+              const M = o.translation + N * o.chunkSize * o.scale;
+              for (let Y = 0; Y < r; ++Y) {
+                const J = a !== void 0 ? a.translation + Y * y * a.scale : 0;
+                C.push({
+                  state: "unloaded",
+                  lod: E,
+                  visible: !1,
+                  prefetch: !1,
+                  priority: null,
+                  orderKey: null,
+                  shape: {
+                    x: Math.min(D, i.size - e * D),
+                    y: Math.min(h, o.size - N * h),
+                    z: Math.min(y, (a?.size ?? 1) - Y * y),
+                    c: 1
+                  },
+                  rowAlignmentBytes: 1,
+                  chunkIndex: { x: e, y: N, z: Y, c: S, t: Q },
+                  scale: {
+                    x: i.scale,
+                    y: o.scale,
+                    z: a?.scale ?? 1
+                  },
+                  offset: {
+                    x: c,
+                    y: M,
+                    z: J
+                  }
+                });
+              }
+            }
+          }
+      }
+    }
+  }
+  getChunksAtTime(A) {
+    return this.chunks_[A];
+  }
+  getTimeIndex(A) {
+    return A.t === void 0 || this.dimensions_.t === void 0 ? 0 : xQ(this.dimensions_.t.lods[0], A.t);
+  }
+  get lodCount() {
+    return this.lowestResLOD_ + 1;
+  }
+  get dimensions() {
+    return this.dimensions_;
+  }
+  getLowestResLOD() {
+    return this.lowestResLOD_;
+  }
+  loadChunkData(A, I) {
+    return this.loader_.loadChunkData(A, I);
+  }
+  createView(A) {
+    const I = new bQ(this, A);
+    return this.views_.push(I), this.hasHadViews_ = !0, I;
   }
   removeView(A) {
-    const I = A.store, B = this.getSourceForStore(I), Q = this.views_.get(I);
-    if (!Q)
-      throw new Error("Cannot remove view: store not managed by ChunkManager");
-    const C = Q.indexOf(A);
-    if (C === -1)
+    const I = this.views_.indexOf(A);
+    if (I === -1)
       throw new Error(
-        `Cannot remove view: view not found in store's view list (source: ${B})`
+        "Cannot remove view: view not found in store's view list"
       );
-    const E = Array.from(A.chunkViewStates.keys());
-    Q.splice(C, 1);
-    for (const i of E)
-      this.aggregateChunkViewStates(i, I);
-    Q.length === 0 && (this.stores_.delete(B), this.views_.delete(I));
-  }
-  async addSource(A) {
-    const I = this.stores_.get(A) ?? this.pendingStores_.get(A);
-    if (I)
-      return I;
-    const Q = (async () => {
-      const C = await A.open(), E = new bQ(C);
-      return this.stores_.set(A, E), this.pendingStores_.delete(A), E;
-    })();
-    return this.pendingStores_.set(A, Q), Q;
+    const B = Array.from(A.chunkViewStates.keys());
+    this.views_.splice(I, 1);
+    for (const Q of B)
+      this.aggregateChunkViewStates(Q);
   }
-  getSourceForStore(A) {
-    for (const [I, B] of this.stores_)
-      if (B === A)
-        return I;
-    throw new Error("Source not found for the given store.");
+  get views() {
+    return this.views_;
   }
-  update() {
-    for (const [A, I] of this.stores_) {
-      const B = this.updateAndCollectChunkChanges(I);
-      for (const Q of B)
-        Q.priority === null ? this.queue_.cancel(Q) : Q.state === "queued" && this.queue_.enqueue(
-          Q,
-          (C) => I.loadChunkData(Q, C)
-        );
-    }
-    this.queue_.flush();
+  canDispose() {
+    return this.hasHadViews_ && this.views_.length === 0;
   }
-  updateAndCollectChunkChanges(A) {
-    const I = this.views_.get(A);
-    if (!I) return /* @__PURE__ */ new Set();
-    const B = /* @__PURE__ */ new Set();
-    for (const Q of I)
-      for (const [C, E] of Q.chunkViewStates)
-        B.add(C);
-    for (const Q of B)
-      this.aggregateChunkViewStates(Q, A);
-    return B;
+  updateAndCollectChunkChanges() {
+    const A = /* @__PURE__ */ new Set();
+    for (const I of this.views_)
+      for (const [B, Q] of I.chunkViewStates)
+        A.add(B);
+    for (const I of A)
+      this.aggregateChunkViewStates(I);
+    return A;
   }
-  aggregateChunkViewStates(A, I) {
-    const B = this.views_.get(I);
-    if (!B) return;
-    let Q = !1, C = !1, E = null, i = null;
-    for (const h of B) {
-      const y = h.chunkViewStates.get(A);
-      y && (y.visible && (Q = !0), y.prefetch && (C = !0), y.priority !== null && (E === null || y.priority < E) && (E = y.priority, i = y.orderKey), !y.visible && !y.prefetch && y.priority === null && h.maybeForgetChunk(A));
+  aggregateChunkViewStates(A) {
+    let I = !1, B = !1, Q = null, C = null;
+    for (const a of this.views_) {
+      const D = a.chunkViewStates.get(A);
+      D && (D.visible && (I = !0), D.prefetch && (B = !0), D.priority !== null && (Q === null || D.priority < Q) && (Q = D.priority, C = D.orderKey), !D.visible && !D.prefetch && D.priority === null && a.maybeForgetChunk(A));
     }
-    if (A.visible = Q, A.prefetch = C, A.priority = E, A.orderKey = i, A.priority !== null && A.state === "unloaded") {
+    if (A.visible = I, A.prefetch = B, A.priority = Q, A.orderKey = C, A.priority !== null && A.state === "unloaded") {
       A.state = "queued";
       return;
     }
@@ -2428,10 +2351,100 @@ class OQ {
       return;
     }
     A.state === "loaded" && !A.visible && !A.prefetch && (A.data = void 0, A.state = "unloaded", A.priority = null, A.orderKey = null, A.prefetch = !1, U.debug(
-      "ChunkManager",
+      "ChunkStore",
       `Disposing chunk ${JSON.stringify(A.chunkIndex)} in LOD ${A.lod}`
     ));
   }
+  validateXYScaleRatios() {
+    const A = this.dimensions_.x, I = this.dimensions_.y;
+    for (let B = 1; B < this.dimensions_.numLods; B++) {
+      const Q = A.lods[B].scale / A.lods[B - 1].scale, C = I.lods[B].scale / I.lods[B - 1].scale;
+      if (!jI(Q, 2, 0.02) || !jI(C, 2, 0.02))
+        throw new Error(
+          `Invalid downsampling factor between levels ${B - 1} → ${B}: expected (2× in X and Y), but got (${Q.toFixed(2)}×, ${C.toFixed(2)}×) from scale [${A.lods[B - 1].scale}, ${I.lods[B - 1].scale}] → [${A.lods[B].scale}, ${I.lods[B].scale}]`
+        );
+    }
+  }
+  getAndValidateTimeDimension() {
+    for (let A = 0; A < this.dimensions_.numLods; ++A) {
+      const I = this.dimensions_.t?.lods[A];
+      if (!I) continue;
+      if (I.chunkSize !== 1)
+        throw new Error(
+          `ChunkStore only supports a chunk size of 1 in t. Found ${I.chunkSize} at LOD ${A}`
+        );
+      const B = this.dimensions_.t?.lods[A - 1];
+      if (B && I.size !== B.size)
+        throw new Error(
+          `ChunkStore does not support downsampling in t. Found ${B.size} at LOD ${A - 1} → ${I.size} at LOD ${A}`
+        );
+    }
+    return {
+      size: this.dimensions_.t?.lods[0].size ?? 1
+    };
+  }
+  getAndValidateChannelDimension() {
+    for (let A = 0; A < this.dimensions_.numLods; ++A) {
+      const I = this.dimensions_.c?.lods[A];
+      if (!I) continue;
+      if (I.chunkSize !== 1)
+        throw new Error(
+          `ChunkStore only supports a chunk size of 1 in c. Found ${I.chunkSize} at LOD ${A}`
+        );
+      if (I.scale !== 1)
+        throw new Error(
+          `ChunkStore does not support scale in c. Found ${I.scale} at LOD ${A}`
+        );
+      if (I.translation !== 0)
+        throw new Error(
+          `ChunkStore does not support translation in c. Found ${I.translation} at LOD ${A}`
+        );
+      const B = this.dimensions_.c?.lods[A - 1];
+      if (B && I.size !== B.size)
+        throw new Error(
+          `ChunkStore does not support downsampling in c. Found ${B.size} at LOD ${A - 1} → ${I.size} at LOD ${A}`
+        );
+    }
+    return {
+      size: this.dimensions_.c?.lods[0].size ?? 1
+    };
+  }
+}
+class OQ {
+  stores_ = /* @__PURE__ */ new Map();
+  pendingStores_ = /* @__PURE__ */ new Map();
+  queue_ = new WQ();
+  async addView(A, I) {
+    return (await this.getOrCreateStore(A)).createView(I);
+  }
+  async getOrCreateStore(A) {
+    const I = this.stores_.get(A);
+    if (I)
+      return I;
+    const B = this.pendingStores_.get(A);
+    if (B)
+      return B;
+    const C = (async () => {
+      const i = await A.open();
+      return new PQ(i);
+    })();
+    this.pendingStores_.set(A, C);
+    const E = await C;
+    return this.stores_.set(A, E), this.pendingStores_.delete(A), E;
+  }
+  update() {
+    for (const [A, I] of this.stores_) {
+      const B = I.updateAndCollectChunkChanges();
+      for (const Q of B)
+        Q.priority === null ? this.queue_.cancel(Q) : Q.state === "queued" && this.queue_.enqueue(
+          Q,
+          (C) => I.loadChunkData(Q, C)
+        );
+    }
+    this.queue_.flush();
+    for (const [A, I] of this.stores_)
+      I.canDispose() && this.stores_.delete(A);
+  }
 }
 var ZA = function(g = 1) {
   var A = 0, I = document.createElement("div");
@@ -2711,9 +2724,9 @@ class IC {
   resizeObserver_;
   mediaQuery_;
   onMediaQueryChange_;
-  changed_ = !1;
-  constructor(A = []) {
-    this.elements_ = A;
+  onChange_;
+  constructor(A = [], I) {
+    this.elements_ = A, this.onChange_ = I;
   }
   connect() {
     if (this.resizeObserver_) {
@@ -2724,21 +2737,17 @@ class IC {
       return;
     }
     this.resizeObserver_ = new ResizeObserver(() => {
-      this.changed_ = !0;
+      this.onChange_();
     });
     for (const A of this.elements_)
       this.resizeObserver_.observe(A);
     this.startDevicePixelRatioObserver();
   }
-  getAndResetChanged() {
-    const A = this.changed_;
-    return this.changed_ = !1, A;
-  }
   startDevicePixelRatioObserver() {
     this.mediaQuery_ = matchMedia(
       `(resolution: ${window.devicePixelRatio}dppx)`
     ), this.onMediaQueryChange_ = () => {
-      this.changed_ = !0, this.startDevicePixelRatioObserver();
+      this.onChange_(), this.startDevicePixelRatioObserver();
     }, this.mediaQuery_.addEventListener("change", this.onMediaQueryChange_, {
       once: !0
     });
@@ -2825,7 +2834,11 @@ class Do {
     const I = [this.canvas];
     for (const B of this.viewports_)
       B.element !== this.canvas && I.push(B.element);
-    this.sizeObserver_ = new IC(I);
+    this.sizeObserver_ = new IC(I, () => {
+      this.renderer_.updateSize();
+      for (const B of this.viewports_)
+        B.updateSize(), this.renderer_.render(B);
+    });
   }
   get renderedObjects() {
     return this.renderer_.renderedObjects;
@@ -2855,7 +2868,7 @@ class Do {
     return this;
   }
   animate(A) {
-    this.stats_ && this.stats_.begin(), this.sizeObserver_.getAndResetChanged() && this.updateSize();
+    this.stats_ && this.stats_.begin();
     for (const I of this.viewports_)
       this.renderer_.render(I);
     this.chunkManager_.update();
@@ -2875,11 +2888,6 @@ class Do {
       cancelAnimationFrame(this.lastAnimationId_), this.lastAnimationId_ = void 0;
     }
   }
-  updateSize() {
-    this.renderer_.updateSize();
-    for (const A of this.viewports_)
-      A.updateSize();
-  }
 }
 class gC extends pA {
   constructor(A) {
@@ -3932,7 +3940,7 @@ class NB extends GA {
     );
   }
   onDetached(A) {
-    this.releaseAndRemoveChunks(this.visibleChunks_.keys()), this.clearObjects(), this.chunkStoreView_ && (A.chunkManager.removeView(this.chunkStoreView_), this.chunkStoreView_ = void 0);
+    this.releaseAndRemoveChunks(this.visibleChunks_.keys()), this.clearObjects(), this.chunkStoreView_ && (this.chunkStoreView_.dispose(), this.chunkStoreView_ = void 0);
   }
   update(A) {
     !A || !this.chunkStoreView_ || (this.chunkStoreView_.updateChunkStates(this.sliceCoords_, A.viewport), this.updateChunks(), this.resliceIfZChanged());