@splnlss/3d-story-viewer 0.8.4 → 0.8.5

package/build/{spark.module-OeW1hboi.js → spark.module-SbwV3up9.js}

@@ -1,5 +1,5 @@
 import { V as Vector3, a as Vector2, ak as Euler, M as Matrix4, Q as Quaternion, k as Color, bh as Vector4, bz as DataArrayTexture, bA as RGIntegerFormat, bB as UnsignedIntType, bC as RGBAIntegerFormat, bD as WebGLArrayRenderTarget, y as NearestFilter, aX as DataTexture, e as Raycaster, aQ as RGBAFormat, aR as UnsignedByteType, O as Object3D, b as Mesh, c as ShaderMaterial, W as DoubleSide, bE as GLSL3, bF as Timer, bb as WebGLRenderTarget, m as SRGBColorSpace, ap as Matrix3, af as ColorManagement, a3 as PerspectiveCamera, a4 as OrthographicCamera, bG as WebGLCubeRenderTarget, l as LinearSRGBColorSpace, x as LinearFilter, b7 as LinearMipMapLinearFilter, bH as CubeCamera, bI as Camera, bJ as PMREMGenerator, U as MeshStandardMaterial, L as Loader, F as FileLoader, ai as Box3, aV as UnsignedShortType, aW as FloatType, S as ShaderChunk, bK as InstancedBufferGeometry, s as BufferAttribute, bg as Matrix2, b0 as REVISION, bL as RawShaderMaterial } from "./index-a8PLKOvo.js";
-import { F as FullScreenQuad } from "./main-DZ2oJmQ9.js";
+import { F as FullScreenQuad } from "./main-DCLbtFn7.js";
 const LN_SCALE_MIN = -12;
 const LN_SCALE_MAX = 9;
 const SCALE_MIN = Math.exp(LN_SCALE_MIN);
@@ -11160,7 +11160,8 @@ class PagedSplats {
           requestHeader: this.requestHeader,
           withCredentials: this.withCredentials,
           offset: 0,
-          bytes: tryBytes
+          bytes: tryBytes,
+          signal: this.abortController.signal
         });
         const metaStart = decode_rad_header(bytes);
         if (metaStart) {
@@ -11179,7 +11180,7 @@ class PagedSplats {
   chunkUrl(chunk) {
     return this.rootUrl.replace(/-lod-0\./, `-lod-${chunk}.`);
   }
-  async fetchDecodeChunk(chunk) {
+  async fetchDecodeChunk(chunk, requestSignal = this.abortController.signal) {
     let decodeBytes = void 0;
     if (this.fileType === SplatFileType.RAD) {
       const { meta, chunksStart } = await this.getRadMeta();
@@ -11202,7 +11203,7 @@ class PagedSplats {
           url: chunkUrl,
           requestHeader: this.requestHeader,
           withCredentials: this.withCredentials,
-          signal: this.abortController.signal
+          signal: requestSignal
         });
       } else {
         offset += chunksStart;
@@ -11220,7 +11221,7 @@ class PagedSplats {
             withCredentials: this.withCredentials,
             offset,
             bytes,
-            signal: this.abortController.signal
+            signal: requestSignal
           });
         } else {
           throw new Error("No url or fileBytes provided");
@@ -11232,7 +11233,7 @@ class PagedSplats {
       const request = new Request(url, {
         headers: this.requestHeader ? new Headers(this.requestHeader) : void 0,
         credentials: this.withCredentials ? "include" : "same-origin",
-        signal: this.abortController.signal
+        signal: requestSignal
       });
       const response = await fetch(request);
       if (!response.ok || !response.body) {
@@ -11453,6 +11454,9 @@ const _SplatPager = class _SplatPager2 {
     this.fetchers = [];
     this.fetched = [];
     this.fetchPriority = [];
+    this.destinationRequests = /* @__PURE__ */ new Map();
+    this.livePriority = /* @__PURE__ */ new Map();
+    this.failedDestinationChunks = /* @__PURE__ */ new Map();
     this.packedTexture = new DynoUsampler2DArray({
       value: this.newUint32ArrayTexture(4)
     });
@@ -11786,7 +11790,48 @@ const _SplatPager = class _SplatPager2 {
     this.renderer.initTexture(texture2);
     return texture2;
   }
+  setDestinationEntries(entries) {
+    this.destinationRequests.clear();
+    for (const { splats, chunk } of entries) {
+      let chunks = this.destinationRequests.get(splats);
+      if (!chunks) this.destinationRequests.set(splats, chunks = /* @__PURE__ */ new Set());
+      chunks.add(chunk);
+    }
+  }
+  reclassifyLiveChunks(entries) {
+    var _a2;
+    this.livePriority.clear();
+    for (const { splats, chunk } of entries) {
+      let chunks = this.livePriority.get(splats);
+      if (!chunks) this.livePriority.set(splats, chunks = /* @__PURE__ */ new Set());
+      chunks.add(chunk);
+    }
+    for (const fetcher of this.fetchers) {
+      if ((_a2 = this.livePriority.get(fetcher.splats)) == null ? void 0 : _a2.has(fetcher.chunk)) fetcher.purpose = "live";
+    }
+  }
+  clearDestinationEntries(recompute = true) {
+    var _a2;
+    const old = this.destinationRequests;
+    const destinationOnly = (splats, chunk) => {
+      var _a3, _b2;
+      return ((_a3 = old.get(splats)) == null ? void 0 : _a3.has(chunk)) && !((_b2 = this.livePriority.get(splats)) == null ? void 0 : _b2.has(chunk));
+    };
+    this.fetchPriority = this.fetchPriority.filter(({ splats, chunk }) => !destinationOnly(splats, chunk));
+    this.fetched = this.fetched.filter(({ splats, chunk }) => !destinationOnly(splats, chunk));
+    for (const fetcher of [...this.fetchers]) {
+      if (fetcher.purpose !== "destination" || !destinationOnly(fetcher.splats, fetcher.chunk)) continue;
+      fetcher.cancelled = true;
+      (_a2 = fetcher.controller) == null ? void 0 : _a2.abort();
+      const index = this.fetchers.indexOf(fetcher);
+      if (index >= 0) this.fetchers.splice(index, 1);
+    }
+    this.destinationRequests = /* @__PURE__ */ new Map();
+    this.failedDestinationChunks.clear();
+    if (recompute && this.autoDrive) this.driveFetchers();
+  }
   driveFetchers() {
+    var _a2, _b2, _c;
     const needed = [];
     const overflow = [];
     let numPages = 0;
@@ -11810,12 +11855,19 @@ const _SplatPager = class _SplatPager2 {
         continue;
       }
       if (numPages < this.maxPages && this.fetchers.length < this.numFetchers) {
+        const purpose = ((_a2 = this.destinationRequests.get(splats)) == null ? void 0 : _a2.has(chunk)) && !((_b2 = this.livePriority.get(splats)) == null ? void 0 : _b2.has(chunk)) ? "destination" : "live";
+        if (purpose === "destination") {
+          if ((_c = this.failedDestinationChunks.get(splats)) == null ? void 0 : _c.has(chunk)) continue;
+          if (this.fetchers.some((entry) => entry.purpose === "destination") || this.pageFreelist.length <= this.fetchers.length) continue;
+        }
         numPages += 1;
-        const fetcher = { splats, chunk };
+        const controller = purpose === "destination" ? new AbortController() : null;
+        const requestSignal = controller ? AbortSignal.any([splats.abortController.signal, controller.signal]) : splats.abortController.signal;
+        const fetcher = { splats, chunk, purpose, controller, cancelled: false };
         this.fetchers.push(fetcher);
-        const promise = splats.fetchDecodeChunk(chunk).then(
+        const promise = splats.fetchDecodeChunk(chunk, requestSignal).then(
           async (data) => {
-            if (splats.abortController.signal.aborted) {
+            if (fetcher.cancelled || splats.abortController.signal.aborted) {
               return;
             }
             this.fetched.push({ splats, chunk, data });
@@ -11826,6 +11878,12 @@ const _SplatPager = class _SplatPager2 {
             }
           },
           async (error) => {
+            if (fetcher.cancelled || error.name === "AbortError") return;
+            if (purpose === "destination") {
+              let failed = this.failedDestinationChunks.get(splats);
+              if (!failed) this.failedDestinationChunks.set(splats, failed = /* @__PURE__ */ new Set());
+              failed.add(chunk);
+            }
             if (error.name !== "AbortError") {
               console.warn(error);
             }
@@ -11834,8 +11892,10 @@ const _SplatPager = class _SplatPager2 {
           }
         ).finally(() => {
           const fetchIndex = this.fetchers.indexOf(fetcher);
-          this.fetchers[fetchIndex] = this.fetchers[this.fetchers.length - 1];
-          this.fetchers.length--;
+          if (fetchIndex >= 0) {
+            this.fetchers[fetchIndex] = this.fetchers[this.fetchers.length - 1];
+            this.fetchers.length--;
+          }
           this.processFetched();
         });
         promise.then((data) => {
@@ -13489,6 +13549,9 @@ const _SparkRenderer = class _SparkRenderer2 extends Mesh {
     this.lodInitQueue = [];
     this.lodInstances = /* @__PURE__ */ new Map();
     this.lodUpdates = [];
+    this.destinationHint = null;
+    this.destinationArrivalHold = null;
+    this.pendingDestinationCancel = false;
     this.lastTraverseTime = 0;
     this.pagerId = 0;
     this.superXY = 1;
@@ -13701,6 +13764,146 @@ const _SparkRenderer = class _SparkRenderer2 extends Mesh {
       this.pager = void 0;
     }
   }
+  releasePagedSplats(splats) {
+    var _a2;
+    if (!splats) return Promise.resolve();
+    splats.abortController.abort();
+    if (this.viewerDisposed) return Promise.resolve();
+    if ((_a2 = this.destinationHint) == null ? void 0 : _a2.meshes.some((mesh) => mesh.paged === splats)) this.clearDestinationHint(false);
+    if (this.destinationArrivalHold) this.destinationArrivalHold = this.destinationArrivalHold.filter((entry) => entry.splats !== splats);
+    const pager = this.pager;
+    if (pager) {
+      pager.fetchPriority = pager.fetchPriority.filter((entry) => entry.splats !== splats);
+      pager.fetched = pager.fetched.filter((entry) => entry.splats !== splats);
+      pager.fetchers = pager.fetchers.filter((entry) => entry.splats !== splats);
+    }
+    this.lodMeshes = this.lodMeshes.filter(({ mesh }) => mesh.paged !== splats);
+    this.lodInitQueue = this.lodInitQueue.filter((entry) => entry !== splats);
+    this.lodDirty = true;
+    const release = async (worker) => {
+      if (this.viewerDisposed) return;
+      const record = this.lodIds.get(splats);
+      if (record) {
+        this.lodIds.delete(splats);
+        this.lodIdToSplats.delete(record.lodId);
+        this.lodUpdates = this.lodUpdates.filter((entry) => entry.lodId !== record.lodId);
+        for (const [mesh, instance] of this.lodInstances) {
+          if (instance.lodId === record.lodId) {
+            instance.texture.dispose();
+            this.lodInstances.delete(mesh);
+          }
+        }
+      }
+      if (pager) {
+        pager.fetchPriority = pager.fetchPriority.filter((entry) => entry.splats !== splats);
+        pager.fetched = pager.fetched.filter((entry) => entry.splats !== splats);
+        pager.fetchers = pager.fetchers.filter((entry) => entry.splats !== splats);
+        const pages = /* @__PURE__ */ new Set();
+        for (const entry of pager.splatsChunkToPage.get(splats) ?? []) {
+          if (entry) pages.add(entry.page);
+        }
+        pager.newUploads = pager.newUploads.filter((entry) => !pages.has(entry.page));
+        pager.readyUploads = pager.readyUploads.filter((entry) => !pages.has(entry.page));
+        pager.lodTreeUpdates = pager.lodTreeUpdates.filter((entry) => entry.splats !== splats);
+        pager.removeSplats(splats);
+        if (pager.autoDrive) pager.driveFetchers();
+      }
+      if (record && worker) await worker.call("disposeLodTree", { lodId: record.lodId });
+    };
+    const pending = this.lodWorker ? this.lodWorker.exclusive(release) : release(null);
+    return pending.catch((error) => {
+      if (!this.viewerDisposed) console.error(error);
+    });
+  }
+  setDestinationHint(hint) {
+    if (this.viewerDisposed) return;
+    this.clearDestinationHint(false);
+    this.destinationHint = { ...hint, entries: [] };
+    this.destinationArrivalHold = null;
+    this.lodDirty = true;
+  }
+  clearDestinationHint(arrival = false) {
+    const hint = this.destinationHint;
+    if (!hint) return;
+    this.destinationHint = null;
+    if (arrival) {
+      this.destinationArrivalHold = hint.entries.filter(({ splats, chunk }) => {
+        var _a2;
+        return (_a2 = this.pager) == null ? void 0 : _a2.getSplatsChunk(splats, chunk);
+      });
+    } else {
+      this.destinationArrivalHold = null;
+      this.pendingDestinationCancel = true;
+      if (this.pager) {
+        this.pager.fetchPriority = this.pager.fetchPriority.filter(
+          ({ splats, chunk }) => {
+            var _a2, _b2;
+            return !((_a2 = this.pager.destinationRequests.get(splats)) == null ? void 0 : _a2.has(chunk)) || ((_b2 = this.pager.livePriority.get(splats)) == null ? void 0 : _b2.has(chunk));
+          }
+        );
+        this.pager.fetched = this.pager.fetched.filter(
+          ({ splats, chunk }) => {
+            var _a2, _b2;
+            return !((_a2 = this.pager.destinationRequests.get(splats)) == null ? void 0 : _a2.has(chunk)) || ((_b2 = this.pager.livePriority.get(splats)) == null ? void 0 : _b2.has(chunk));
+          }
+        );
+      }
+    }
+    this.lodDirty = true;
+  }
+  async traverseDestinationHint(worker, pixelScaleLimit, renderOrigin) {
+    var _a2, _b2;
+    const hint = this.destinationHint;
+    if (!hint || !this.pager) return;
+    hint.entries = hint.entries.filter(
+      ({ splats, chunk }) => {
+        var _a3;
+        return hint.meshes.some((mesh) => mesh.paged === splats) && !((_a3 = this.pager.failedDestinationChunks.get(splats)) == null ? void 0 : _a3.has(chunk));
+      }
+    );
+    if (hint.entries.length >= hint.maxChunks) return;
+    const instances = {};
+    for (const mesh of hint.meshes) {
+      if (!mesh.paged || mesh.paged.abortController.signal.aborted || !mesh.visible || !mesh.parent) continue;
+      const record = this.lodIds.get(mesh.paged);
+      if ((record == null ? void 0 : record.rootPage) === void 0) continue;
+      mesh.updateMatrixWorld();
+      const destinationView = new Matrix4().compose(
+        hint.position.clone().sub(renderOrigin),
+        hint.quaternion,
+        new Vector3(1, 1, 1)
+      );
+      const objectToRender = mesh.matrixWorld.clone();
+      objectToRender.setPosition(mesh.getWorldPosition(new Vector3()).sub(renderOrigin));
+      instances[mesh.uuid] = {
+        instanceId: mesh.uuid,
+        lodId: record.lodId,
+        rootPage: record.rootPage,
+        viewToObjectCols: objectToRender.invert().multiply(destinationView).elements.slice(),
+        lodScale: mesh.lodScale,
+        behindFoveate: mesh.behindFoveate ?? this.behindFoveate,
+        coneFov0: mesh.coneFov0 ?? this.coneFov0,
+        coneFov: mesh.coneFov ?? this.coneFov,
+        coneFoveate: mesh.coneFoveate ?? this.coneFoveate
+      };
+    }
+    if (Object.keys(instances).length === 0) return;
+    const result = await worker.call("traverseLodTrees", {
+      maxSplats: hint.maxSplats,
+      pixelScaleLimit,
+      lastPixelLimit: this.lastPixelLimit,
+      instances,
+      traverseMode: this.lodTraverseMode
+    });
+    if (this.viewerDisposed || hint !== this.destinationHint) return;
+    for (const [lodId, chunk] of result.chunks) {
+      if (chunk === 0 || hint.entries.length >= hint.maxChunks) continue;
+      const splats = this.lodIdToSplats.get(lodId);
+      if (!splats || ((_a2 = this.pager.livePriority.get(splats)) == null ? void 0 : _a2.has(chunk)) || ((_b2 = this.pager.failedDestinationChunks.get(splats)) == null ? void 0 : _b2.has(chunk))) continue;
+      if (hint.entries.some((entry) => entry.splats === splats && entry.chunk === chunk)) continue;
+      hint.entries.push({ splats, chunk });
+    }
+  }
   setDirty() {
     var _a2;
     if (!this.dirty) {
@@ -14208,6 +14411,7 @@ const _SparkRenderer = class _SparkRenderer2 extends Mesh {
     }
   }
   async updateLodInstances(worker, deltaPred, lodMeshes, maxSplats, lodPos, viewPos, viewQuat, renderOrigin, pixelScaleLimit) {
+    var _a2, _b2;
     const uuidToMesh = /* @__PURE__ */ new Map();
     const cameraToWorld = this.lodCameraToWorld.compose(
       viewPos,
@@ -14216,12 +14420,12 @@ const _SparkRenderer = class _SparkRenderer2 extends Mesh {
     );
     const instances = lodMeshes.reduce(
       (instances2, mesh) => {
-        var _a2, _b2;
+        var _a22, _b22;
         uuidToMesh.set(mesh.uuid, mesh);
         const viewToObject = this.lodViewToObject.copy(mesh.matrixWorld).setPosition(
           this.lodMeshOrigin.setFromMatrixPosition(mesh.matrixWorld).sub(renderOrigin)
         ).invert().multiply(cameraToWorld);
-        const splats = ((_a2 = mesh.packedSplats) == null ? void 0 : _a2.lodSplats) ?? ((_b2 = mesh.extSplats) == null ? void 0 : _b2.lodSplats) ?? mesh.paged;
+        const splats = ((_a22 = mesh.packedSplats) == null ? void 0 : _a22.lodSplats) ?? ((_b22 = mesh.extSplats) == null ? void 0 : _b22.lodSplats) ?? mesh.paged;
         if (!splats) {
           return instances2;
         }
@@ -14295,10 +14499,28 @@ const _SparkRenderer = class _SparkRenderer2 extends Mesh {
           }
         }
       }
+      this.pager.reclassifyLiveChunks(this.pager.fetchPriority);
+      if (this.pendingDestinationCancel) {
+        this.pager.clearDestinationEntries(false);
+        this.pendingDestinationCancel = false;
+      }
+      let arrivalHandoff = false;
+      if (this.destinationHint) {
+        await this.traverseDestinationHint(worker, pixelScaleLimit, renderOrigin);
+        if (this.viewerDisposed) return;
+        this.pager.setDestinationEntries(((_a2 = this.destinationHint) == null ? void 0 : _a2.entries) ?? []);
+        for (const entry of ((_b2 = this.destinationHint) == null ? void 0 : _b2.entries) ?? []) this.pager.fetchPriority.push(entry);
+      } else if (this.destinationArrivalHold) {
+        this.pager.setDestinationEntries(this.destinationArrivalHold);
+        for (const entry of this.destinationArrivalHold) this.pager.fetchPriority.push(entry);
+        this.destinationArrivalHold = null;
+        arrivalHandoff = true;
+      }
       this.pager.autoDrive = this.enableLodFetching;
       if (this.enableLodFetching) {
         this.pager.driveFetchers();
       }
+      if (arrivalHandoff) this.pager.clearDestinationEntries(false);
     }
     if (this.lodRaycast && performance.now() - this.lastLodRaycastTime >= this.lodRaycastIntervalMs) {
       this.lastLodRaycastTime = performance.now();

package/build/types/src/main.d.ts

@@ -81,7 +81,7 @@ export type MeshLayerDefinition = {
         url: string;
     };
     /**
-     * Nonzero offsets require an explicit WGS84 offsetOrigin. Longitude/latitude are decimal degrees; altitude is ellipsoidal meters. The offset translates existing geometry in ECEF; it does not georeference a local model.
+     * A local-model transform is mutually exclusive with offset/offsetOrigin. Anchor longitude/latitude are WGS84 decimal degrees; altitude is ellipsoidal meters. Translation is ENU meters, XYZ rotation is degrees, scale is dimensionless. A missing rotation defaults to [90,0,0] for glTF Y-up. Legacy offsets translate existing ECEF geometry.
      */
     options?: {
         renderOrder?: number;
@@ -95,6 +95,16 @@ export type MeshLayerDefinition = {
             latitude: number;
             altitude: number;
         };
+        transform?: {
+            anchor: {
+                longitude: number;
+                latitude: number;
+                altitude: number;
+            };
+            translationENU?: Vector3Tuple;
+            rotationDegrees?: Vector3Tuple;
+            scale?: number;
+        };
     };
 };
 export type GeojsonLayerDefinition = {

package/build/types/src/viewer/ContentLayer/ContentLayerRegistry.d.ts

@@ -0,0 +1,31 @@
+/** Owns active named layers; definitions alone do not create loader resources. */
+export class ContentLayerRegistry {
+    /** @param {{ group?: import('three').Group, createLayer?: (definition: any) => any, onError?: (definition: any, error: Error) => void, onAllSplatsDisabled?: () => void }} [options] */
+    constructor({ group, createLayer, onError, onAllSplatsDisabled }?: {
+        group?: import("three").Group;
+        createLayer?: (definition: any) => any;
+        onError?: (definition: any, error: Error) => void;
+        onAllSplatsDisabled?: () => void;
+    });
+    group: import("three").Group<import("three").Object3DEventMap>;
+    createLayer: (definition: any) => any;
+    onError: (definition: any, error: Error) => void;
+    onAllSplatsDisabled: () => void;
+    definitions: any[];
+    enabledLabels: Set<any>;
+    active: Map<any, any>;
+    timeFrameStart: any;
+    timeFrameEnd: any;
+    disposed: boolean;
+    setDefinitions(definitions?: any[]): void;
+    setEnabledLabels(labels?: any[]): void;
+    setTimeFrame(start: any, end: any): void;
+    getActiveLayer(id: any): any;
+    createActiveLayer(definition: any): any;
+    orderActiveLayers(): void;
+    /** Replace one definition while preserving unrelated live layers. */
+    replaceDefinition(id: any, definition: any): boolean;
+    reconcile(): void;
+    clear(): void;
+    dispose(): void;
+}

package/build/types/src/viewer/ContentLayer/GeojsonLayer.d.ts

@@ -1,6 +1,7 @@
 export class GeojsonLayer extends ContentLayer {
     constructor(data: any, options?: {}, callbacks?: {});
     isGeojsonLayer: boolean;
+    disposed: boolean;
     setTimeFrame(start: any, end: any): void;
 }
 import { ContentLayer } from '.';

package/build/types/src/viewer/ContentLayer/MeshLayer.d.ts

@@ -1,6 +1,9 @@
 export class MeshLayer extends ContentLayer {
     constructor(url: any, options?: {}, callbacks?: {});
     isMeshLayer: boolean;
-    mesh: import("three").Group<import("three").Object3DEventMap>;
+    xrRenderLayer: number;
+    abortController: AbortController;
+    disposed: boolean;
+    mesh: any;
 }
 import { ContentLayer } from '.';

package/build/types/src/viewer/ContentLayer/TilesLayer.d.ts

@@ -1,6 +1,7 @@
 export class TilesLayer extends ContentLayer {
     constructor(url: any, options?: {}, callbacks?: {});
     isTilesLayer: boolean;
+    disposed: boolean;
     firstSet: any;
     camera: any;
     renderer: any;

package/build/types/src/viewer/ContentLayer/gaussianSplatUtils.d.ts

@@ -1,3 +1,9 @@
 export function validateGaussianSplatLayerDefinition(definition: any): any;
 export function makeGaussianSplatTransform(transform: any): Matrix4;
+export function normalizeLocalMeshTransform(transform: any): {
+    anchor: any;
+    translationENU: any[];
+    rotationDegrees: any[];
+    scale: any;
+};
 import { Matrix4 } from 'three';

package/build/types/src/viewer/DesktopLookControls.d.ts

@@ -0,0 +1,22 @@
+export class DesktopLookControls {
+    constructor(canvas: any, onLook: any);
+    canvas: any;
+    onLook: any;
+    root: any;
+    window: any;
+    pointer: {
+        id: any;
+        startX: any;
+        startY: any;
+        x: any;
+        y: any;
+        dragging: boolean;
+    };
+    down: (event: any) => void;
+    move: (event: any) => void;
+    end: (event: any) => void;
+    wheel: (event: any) => any;
+    contextMenu: (event: any) => any;
+    handleKeyDown(event: any): boolean;
+    dispose(): void;
+}

package/build/types/src/viewer/GlobeManager.d.ts

@@ -7,12 +7,15 @@ export class GlobeManager extends EventDispatcher {
     destinationTileCamera: PerspectiveCamera;
     destinationTileResolution: number;
     previousAutoDisableRendererCulling: boolean;
+    parseQueueTimer: number;
     dracoLoader: any;
     ownsDecoders: boolean;
     decoders: any;
     apiToken: any;
     googleMapsToken: any;
     initTiles(): void;
+    startParseQueuePump(): void;
+    stopParseQueuePump(): void;
     attachTileLoadListener(): void;
     /** The renderer shares one cache and request scheduler between both registered cameras. */
     setDestinationTilePrefetch(target: any): void;

package/build/types/src/viewer/SplatDestinationPrefetch.d.ts

@@ -0,0 +1,18 @@
+/** Owns one temporary destination viewpoint; layer definitions stay independent. */
+export class SplatDestinationPrefetch {
+    constructor({ getRenderer, getLayer }: {
+        getRenderer: any;
+        getLayer: any;
+    });
+    getRenderer: any;
+    getLayer: any;
+    target: any;
+    boundRenderer: any;
+    boundMeshes: any[];
+    timeoutId: number;
+    disposed: boolean;
+    set(target: any): void;
+    sync(): void;
+    clear(reason?: string): void;
+    dispose(): void;
+}

package/build/types/src/viewer/WebXRSession.d.ts

@@ -18,7 +18,6 @@ export class WebXRSession {
         pose: XRViewerPose;
     }) => void;
     onStateChange: (active: boolean) => void;
-    showAttribution: boolean;
     session: any;
     starting: any;
     bridge: {
@@ -29,7 +28,8 @@ export class WebXRSession {
             direction: import("three").Vector3Tuple;
         };
         setNavigationCue: (cue: any) => void;
-        setTerrainCredits: (credits: any) => void;
+        setTerrainCredits: () => void;
+        setDiagnosticsRows(rows: any): void;
         setPlayerPose(pose: any): void;
         setVisualBlend(blend: any): void;
         hasUi(): boolean;

package/build/types/src/viewer/XRDiagnosticsPanel.d.ts

@@ -0,0 +1,14 @@
+/** A small head-local canvas, drawn by the shared layer-31 pass for both eyes. */
+export class XRDiagnosticsPanel {
+    context: CanvasRenderingContext2D;
+    texture: CanvasTexture<HTMLCanvasElement>;
+    mesh: Mesh<PlaneGeometry, MeshBasicMaterial, import("three").Object3DEventMap>;
+    rows: any[];
+    setRows(rows: any): void;
+    update(headMatrix: any): void;
+    dispose(): void;
+}
+import { CanvasTexture } from 'three';
+import { PlaneGeometry } from 'three';
+import { MeshBasicMaterial } from 'three';
+import { Mesh } from 'three';

package/build/types/src/viewer/XRRenderBridge.d.ts

@@ -5,9 +5,7 @@
  * @param {XRRigidTransform} initialHeadPose
  * @param {{ showAttribution?: boolean }} [options]
  */
-export function createXRRenderBridge(viewer: import("./index.js").default, initialHeadPose: XRRigidTransform, { showAttribution }?: {
-    showAttribution?: boolean;
-}): {
+export function createXRRenderBridge(viewer: import("./index.js").default, initialHeadPose: XRRigidTransform, _options?: {}): {
     getHeadPose: () => import("./XRPlayerRig.js").XRHeadPose;
     getHeadForward: () => import("three").Vector3Tuple;
     getControllerWorldRay: (controller: any) => {
@@ -15,7 +13,8 @@ export function createXRRenderBridge(viewer: import("./index.js").default, initi
         direction: import("three").Vector3Tuple;
     };
     setNavigationCue: (cue: any) => void;
-    setTerrainCredits: (credits: any) => void;
+    setTerrainCredits: () => void;
+    setDiagnosticsRows(rows: any): void;
     setPlayerPose(pose: any): void;
     setVisualBlend(blend: any): void;
     hasUi(): boolean;