@miris-inc/core 0.0.8-00bf05b → 0.0.8-038793b

package/dist/core.d.ts

@@ -1,16 +1,59 @@
+export declare const AssetFormat: {
+    readonly GaussianSplats: 1;
+    readonly GES: 2;
+};
+
 declare interface AttributeInfo extends EmbindObject {
-    readonly dataType: number;
-    readonly componentCount: number;
-    readonly dataPtr: number;
-    readonly dataByteLength: number;
+    // Logical elements from the drop metadata: splats for a per-splat attribute, records for a
+    // per-surfel one. Not necessarily dataSizeBytes / bytesPerElement.
+    readonly elementCount: number;
+    readonly dataSizeBytes: number;
     readonly clientSideId: bigint;
+    // An embind CompressionType value, compared by identity against MainModule.CompressionType
+    readonly compressionType: unknown;
+    readonly minValue: { x: number; y: number; z: number; w: number };
     readonly maxValue: { x: number; y: number; z: number };
 }
 
+export declare class AttributeNames {
+    static readonly SPARK_PACKED_SPLAT: string;
+    static readonly SPARK_EXTENDED_SPLAT_LOW: string;
+    static readonly SPARK_EXTENDED_SPLAT_HIGH: string;
+    static readonly SPARK_PACKED_SH1: string;
+    static readonly SPARK_PACKED_SH2: string;
+    static readonly SPARK_PACKED_SH3: string;
+    static readonly SPARK_EXTENDED_SH1: string;
+    static readonly SPARK_EXTENDED_SH2: string;
+    static readonly SPARK_EXTENDED_SH3_A: string;
+    static readonly SPARK_EXTENDED_SH3_B: string;
+    static readonly UNUSED: string;
+    static readonly SHARK_ELLIPSOIDS: string;
+    static readonly SHARK_ELLIPSOIDS_COMPRESSED: string;
+    static readonly SHARK_SPHERICAL_HARMONICS: string;
+    static readonly COLOR: string;
+    static readonly OCTANT_OFFSETS: string;
+    static readonly SURFEL_OCTANT_OFFSETS: string;
+    static readonly SURFEL_COUNT: string;
+    static readonly SURFEL_OWNER_GROUPS: string;
+    static readonly OCTANT_CELL: string;
+    static readonly REFLECTANCE_DATA_V1: string;
+    static readonly REFLECTANCE_DATA_V2: string;
+    static readonly GLASS_MESH_GEOMETRY: string;
+    static readonly GLASS_MESH_PANELS: string;
+    static readonly MOD_DEPTH: string;
+}
+
+declare type CachedAttribute = {
+    paddedData: Uint32Array<ArrayBuffer>;
+    originalSizeInUints: number;
+};
+
 export declare class Camera {
     #private;
     readonly id: number;
     update(): void;
+    get viewportHeight(): number;
+    set viewportHeight(viewportHeight: number);
     get aspect(): number;
     set aspect(aspect: number);
     get fov(): number;
@@ -24,7 +67,7 @@ export declare class Camera {
     readonly engine: Engine;
     readonly miris: Miris;
     readonly scene: Scene;
-    constructor({ aspect, fov, near, far, matrix, scene }: CameraInit);
+    constructor({ aspect, fov, near, far, matrix, scene, viewportHeight, }: CameraInit);
 }
 
 export declare type CameraInit = {
@@ -34,6 +77,7 @@ export declare type CameraInit = {
     far: number;
     matrix: Matrix4x4Tuple;
     scene: Scene;
+    viewportHeight?: number;
 };
 
 export declare class Change {
@@ -43,7 +87,7 @@ export declare class Change {
 }
 
 export declare type ChangeInit = {
-    type: "created" | "activated" | "modified" | "deactivated" | "deleted";
+    type: "created" | "activated" | "modified" | "deactivated" | "deleted" | "remasked";
     lod: Lod;
 };
 
@@ -60,6 +104,7 @@ declare class Client {
     getAssetsAsync(...args: ClientMethodParameters["getAssetsAsync"]): AssetInfo[];
     getAttribute(...args: ClientMethodParameters["getAttribute"]): AquaStatus;
     getDefaultCameraId(...args: ClientMethodParameters["getDefaultCameraId"]): number;
+    getViewingVolumeId(...args: ClientMethodParameters["getViewingVolumeId"]): number;
     getLocalBoundingBox(...args: ClientMethodParameters["getLocalBoundingBox"]): AquaStatus;
     getWorldBoundingBox(...args: ClientMethodParameters["getWorldBoundingBox"]): AquaStatus;
     getLodIndex(...args: ClientMethodParameters["getLodIndex"]): number;
@@ -68,6 +113,8 @@ declare class Client {
     getSceneMetadata(...args: ClientMethodParameters["getSceneMetadata"]): number;
     getSceneObjectParent(...args: ClientMethodParameters["getSceneObjectParent"]): number;
     getSceneObjectType(...args: ClientMethodParameters["getSceneObjectType"]): SceneObjectType;
+    getStreamStatus(...args: ClientMethodParameters["getStreamStatus"]): StreamStatus;
+    getDrawnOctantMask(...args: ClientMethodParameters["getDrawnOctantMask"]): number;
     getLocalTransform(...args: ClientMethodParameters["getLocalTransform"]): AquaStatus;
     getWorldTransform(...args: ClientMethodParameters["getWorldTransform"]): AquaStatus;
     hasAttribute(...args: ClientMethodParameters["hasAttribute"]): boolean;
@@ -83,6 +130,8 @@ declare class Client {
     hasFeature(...args: ClientMethodParameters["hasFeature"]): boolean;
     getFeatureVersion(...args: ClientMethodParameters["getFeatureVersion"]): number;
     getFeatureState(...args: ClientMethodParameters["getFeatureState"]): number;
+    getAssetFormatVersion(...args: ClientMethodParameters["getAssetFormatVersion"]): number;
+    getDrMapLadderRoughnessLevels(...args: ClientMethodParameters["getDrMapLadderRoughnessLevels"]): number[];
     getName(...args: ClientMethodParameters["getName"]): string;
     setVariantSelection(...args: ClientMethodParameters["setVariantSelection"]): AquaStatus;
     takeAttribute(...args: ClientMethodParameters["takeAttribute"]): AquaStatus;
@@ -90,7 +139,6 @@ declare class Client {
     takeRenderRequired(...args: ClientMethodParameters["takeRenderRequired"]): boolean;
     unlockScene(...args: ClientMethodParameters["unlockScene"]): boolean;
     updateSceneExecution(...args: ClientMethodParameters["updateSceneExecution"]): AquaStatus;
-    recordFrameTime(...args: ClientMethodParameters["recordFrameTime"]): AquaStatus;
 }
 
 declare type ClientInit = {
@@ -140,6 +188,8 @@ declare class Engine {
     };
     static Feature: {
         readonly DrMap: 0;
+        readonly ReflMesh: 1;
+        readonly GlassMesh: 2;
     };
     static FeatureState: {
         readonly NotLoaded: 0;
@@ -147,11 +197,23 @@ declare class Engine {
         readonly Loaded: 2;
         readonly Failed: 3;
     };
+    static StreamStatus: {
+        readonly Unknown: 0;
+        readonly Resolving: 1;
+        readonly Loading: 2;
+        readonly Ready: 3;
+        readonly Failed: 4;
+    };
     readonly ready: Promise<this>;
     readonly pending: boolean;
     get module(): MainModule;
     constructor(moduleOptions?: Record<string, unknown>);
     get AttributeInfo(): new () => AttributeInfo;
+    get CompressionType(): {
+        SHARK_ELLIPSOID_COMPRESSED: unknown;
+        SHARK_ELLIPSOID_COMPRESSED_ROOT_RELATIVE: unknown;
+        SHARK_ELLIPSOID_COMPRESSED_ROOT_RELATIVE_V2: unknown;
+    };
     get Handedness(): {
         Right: number;
         Left: number;
@@ -187,6 +249,8 @@ declare class Engine {
     deletedObjectIdsView(...args: [sceneChangeIds: SceneChangeIds]): Uint32Array;
     dataPtrView(...args: [attributeInfo: AttributeInfo]): Uint32Array;
     deactivatedObjectIdsView(...args: [sceneChangeIds: SceneChangeIds]): Uint32Array;
+    remaskedObjectIdsView(...args: [sceneChangeIds: SceneChangeIds]): Uint32Array;
+    getDrawnOctantMask(...args: [handle: AquaClientHandle, sceneObjectId: number]): number;
     destroyClient(...args: [handle: AquaClientHandle]): AquaStatus;
     free(...args: [size: number]): number;
     getAssetsAsync(...args: [handle: AquaClientHandle, tags: StringVector]): AssetInfo[];
@@ -196,7 +260,8 @@ declare class Engine {
     attributeName: string,
     attributeInfo: AttributeInfo
     ]): AquaStatus;
-    getDefaultCameraId(...args: [handle: AquaClientHandle]): number;
+    getDefaultCameraId(...args: [handle: AquaClientHandle, streamObjectId: number]): number;
+    getViewingVolumeId(...args: [handle: AquaClientHandle, streamObjectId: number]): number;
     getLocalBoundingBox(...args: [handle: AquaClientHandle, sceneObjectId: number, boxData: number]): AquaStatus;
     getWorldBoundingBox(...args: [handle: AquaClientHandle, sceneObjectId: number, boxData: number]): AquaStatus;
     getLodIndex(...args: [handle: AquaClientHandle, sceneObjectId: number]): number;
@@ -204,6 +269,7 @@ declare class Engine {
     getSceneChangesCounts(...args: [handle: AquaClientHandle, sceneChangeIds: SceneChangeIds]): void;
     getSceneMetadata(...args: [handle: AquaClientHandle, metadata: SceneMetadata]): number;
     getSceneObjectParent(...args: [handle: AquaClientHandle, sceneObjectId: number]): number;
+    getStreamStatus(...args: [handle: AquaClientHandle, streamObjectId: number]): StreamStatus;
     getSceneObjectType(...args: [handle: AquaClientHandle, sceneObjectId: number]): SceneObjectType;
     getLocalTransform(...args: [
     handle: AquaClientHandle,
@@ -245,19 +311,18 @@ declare class Engine {
     removeStream(...args: [handle: AquaClientHandle, streamObjectId: number]): boolean;
     setAssetViewerKey(...args: [handle: AquaClientHandle, key: string]): AquaStatus;
     setClientSpatialFormat(...args: [handle: AquaClientHandle, spatialFormat: SpatialFormat]): AquaStatus;
-    setRuntimeSettings(...args: [
-    handle: AquaClientHandle,
-    settings: RuntimeSettings
-    ]): AquaStatus;
+    setRuntimeSettings(...args: [handle: AquaClientHandle, settings: RuntimeSettings]): AquaStatus;
     setMainCameraTransform(...args: [handle: AquaClientHandle, cameraTransform: number]): AquaStatus;
     setMainCameraViewFrustum(...args: [
     handle: AquaClientHandle,
     aspectRatio: number,
     verticalFov: number,
     nearPlane: number,
-    farPlane: number
+    farPlane: number,
+    viewportHeightPixels: number
     ]): AquaStatus;
     setMaxCacheSize(...args: [maxSizeBytes: number]): void;
+    setPreferSharkEncodingProfiles(...args: [preferShark: boolean]): void;
     setSceneObjectTransform(...args: [
     handle: AquaClientHandle,
     sceneObjectId: number,
@@ -266,14 +331,10 @@ declare class Engine {
     hasFeature(...args: [handle: AquaClientHandle, sceneObjectId: number, feature: number]): boolean;
     getFeatureVersion(...args: [handle: AquaClientHandle, sceneObjectId: number, feature: number]): number;
     getFeatureState(...args: [handle: AquaClientHandle, sceneObjectId: number, feature: number]): number;
-    getName(...args: [
-    handle: AquaClientHandle,
-    sceneObjectId: number
-    ]): string;
-    setVariantSelection(...args: [
-    handle: AquaClientHandle,
-    sceneObjectId: number
-    ]): AquaStatus;
+    getDrMapLadderRoughnessLevels(...args: [handle: AquaClientHandle, sceneObjectId: number]): number[];
+    getAssetFormatVersion(...args: [handle: AquaClientHandle, sceneObjectId: number]): number;
+    getName(...args: [handle: AquaClientHandle, sceneObjectId: number]): string;
+    setVariantSelection(...args: [handle: AquaClientHandle, sceneObjectId: number]): AquaStatus;
     takeAttribute(...args: [
     handle: AquaClientHandle,
     sceneObjectId: number,
@@ -284,8 +345,15 @@ declare class Engine {
     getActiveClientSideIdsCheckSum(): number;
     unlockScene(...args: [handle: AquaClientHandle]): boolean;
     updateSceneExecution(...args: [handle: AquaClientHandle]): AquaStatus;
-    recordFrameTime(...args: [handle: AquaClientHandle, frameTimeMs: number]): AquaStatus;
     takeRenderRequired(...args: [handle: AquaClientHandle]): boolean;
+    /**
+     * Advances the runtime by one frame and recomputes the streaming budget. Call once per
+     * displayed frame per context, before the per-client updateSceneExecution() calls.
+     * `previousFrameTimeMs` is how long the previous frame took; pass 0 when there is no plausible
+     * measurement (first frame, or a resume from a stall) and the frame advances without recording
+     * one.
+     */
+    beginFrame(...args: [contextHandle: AquaContextHandle, previousFrameTimeMs: number]): AquaStatus;
     createDeserializeWorker(_url: string, _workerUrl: string, poolSize: number): boolean;
     cancelRequest(requestIdLow: number, requestIdHigh: number): boolean;
     submitToWorker(requestIdLow: number, requestIdHigh: number, descriptorBuffer: ArrayBuffer, contextPtr: number): boolean;
@@ -299,45 +367,62 @@ declare type EngineMethodParameters<E extends Engine = Engine> = {
     [Key in keyof E]: E[Key] extends (...args: any[]) => any ? Parameters<E[Key]> : never;
 };
 
+export declare const HaveData = 2;
+
+export declare const HaveMetadata = 1;
+
+export declare const HaveNothing = 0;
+
 export declare class Lod {
     #private;
     readonly id: LodInit["id"];
     readonly store: LodStore;
-    useExtSplats: boolean;
-    splatsExtendedData: Uint32Array<ArrayBuffer> | null;
-    sh1Data: Uint32Array<ArrayBuffer> | null;
-    sh1Max: number;
-    sh2Data: Uint32Array<ArrayBuffer> | null;
-    sh2Max: number;
-    sh3Data: Uint32Array<ArrayBuffer> | null;
-    sh3Max: number;
-    sh3ExtendedData: Uint32Array<ArrayBuffer> | null;
     get key(): unknown;
     set key(key: unknown);
     readonly modelRoot: ModelRoot;
-    set splats(splats: Uint32Array<ArrayBuffer> | null);
-    get splats(): Uint32Array<ArrayBuffer> | null;
     set bounds(bounds: Float32Array<ArrayBuffer> | null);
+    /**
+     * Retrieves the cached world bounds of this object
+     *
+     * @deprecated Retrieve the local bounds and transform as needed
+     */
     get bounds(): Float32Array<ArrayBuffer> | null;
-    /* Excluded from this release type: _boundsStreamSpace */
-    /* Excluded from this release type: _boundsStreamSpace */
+    /**
+     * Sets the local bounds of this lod
+     */
+    set localBounds(bounds: Float32Array<ArrayBuffer> | null);
+    /**
+     * Retrieves the local bounds of this lod
+     */
+    get localBounds(): Float32Array<ArrayBuffer> | null;
     set lodIndex(index: number);
     get lodIndex(): number | null;
-    set paddingCount(count: number);
-    get paddingCount(): number;
+    set paddingSplatsCount(count: number);
+    get paddingSplatsCount(): number;
     set transform(transform: Float32Array<ArrayBuffer> | null);
     get transform(): Float32Array<ArrayBuffer> | null;
-    setSh1(sh1Data: Uint32Array<ArrayBuffer>, sh1Max: number): void;
-    setSh2(sh2Data: Uint32Array<ArrayBuffer>, sh2Max: number): void;
-    setSh3(sh3Data: Uint32Array<ArrayBuffer>, sh3Max: number): void;
+    get _drawnOctantMask(): number;
+    set _drawnOctantMask(mask: number);
+    get _octantOffsets(): Uint32Array<ArrayBuffer> | null;
+    get _hasOctantOffsets(): boolean;
+    get _surfelOctantOffsets(): Uint32Array<ArrayBuffer> | null;
+    get _surfelCount(): number;
+    get _surfelOwnerGroups(): Uint32Array<ArrayBuffer> | null;
+    get _octantCell(): Uint32Array<ArrayBuffer> | null;
+    _readOctantOffsets(engine: Engine): void;
+    hasAttribute(attributeName: string): boolean;
+    getDataFromAttribute(engine: Engine, attributeName: string, attributeInfo: AttributeInfo): CachedAttribute | null;
+    _getRawByteAttribute(engine: Engine, attributeName: string): Uint8Array<ArrayBuffer> | null;
+    _getRawByteAttributeWithBounds(engine: Engine, attributeName: string): RawByteAttributeWithBounds | null;
     dispose(): void;
-    constructor({ id, modelRoot, lodStore }: LodInit);
+    constructor({ id, modelRoot, lodStore, client }: LodInit);
 }
 
 export declare type LodInit = {
     id: number;
     modelRoot: ModelRoot;
     lodStore: LodStore;
+    client: Client;
 };
 
 export declare class LodStore {
@@ -353,6 +438,11 @@ export declare class LodStore {
 
 declare interface MainModule {
     AttributeInfo: new () => AttributeInfo;
+    CompressionType: {
+        SHARK_ELLIPSOID_COMPRESSED: unknown;
+        SHARK_ELLIPSOID_COMPRESSED_ROOT_RELATIVE: unknown;
+        SHARK_ELLIPSOID_COMPRESSED_ROOT_RELATIVE_V2: unknown;
+    };
     Handedness: { Right: number; Left: number };
     HEAPF32: Float32Array<ArrayBuffer>;
     HEAPU8: Uint8Array<ArrayBuffer>;
@@ -378,7 +468,9 @@ declare interface MainModule {
     createdObjectIdsView(sceneChangeIds: SceneChangeIds): Uint32Array;
     dataPtrView(attributeInfo: AttributeInfo): Uint32Array;
     deactivatedObjectIdsView(sceneChangeIds: SceneChangeIds): Uint32Array;
+    remaskedObjectIdsView(sceneChangeIds: SceneChangeIds): Uint32Array;
     deletedObjectIdsView(sceneChangeIds: SceneChangeIds): Uint32Array;
+    GetDrawnOctantMask(handle: number, sceneObjectId: number): number;
     GetAssetsAsync(handle: number, tags: StringVector): unknown[];
     GetSceneChanges(handle: number, sceneChangeIds: SceneChangeIds): void;
     GetSceneChangesCounts(handle: number, sceneChangeIds: SceneChangeIds): void;
@@ -387,13 +479,17 @@ declare interface MainModule {
     HasFeature(handle: number, sceneObjectId: number, feature: number): boolean;
     GetFeatureVersion(handle: number, sceneObjectId: number, feature: number): number;
     GetFeatureState(handle: number, sceneObjectId: number, feature: number): number;
+    GetAssetFormatVersion(handle: number, sceneObjectId: number): number;
+    GetDrMapLadderRoughnessLevels(handle: number, sceneObjectId: number): number[];
     SetClientSpatialFormat(handle: number, spatialFormat: SpatialFormat): { value: number };
     SetRuntimeSettings(handle: number, settings: RuntimeSettings): { value: number };
     TakeEvictedClientSideAttributeIds(handle: number): EmbindVector<bigint>;
     GetActiveClientSideIdsCheckSum(): number;
     TakeRenderRequired(handle: number): boolean;
+    BeginFrame(contextHandle: number, previousFrameTimeMs: number): number;
     modifiedObjectIdsView(sceneChangeIds: SceneChangeIds): Uint32Array;
     setMaxCacheSize(maxSizeBytes: number): void;
+    SetPreferSharkEncodingProfiles(prefer: boolean): void;
 }
 
 /**
@@ -406,6 +502,7 @@ declare interface MainModule {
  */
 export declare class Miris {
     #private;
+    static tryUseShark: boolean;
     static _instance: Miris;
     static instance<T extends typeof Miris>(this: T): Promise<InstanceType<T>>;
     readonly engine: Engine;
@@ -415,14 +512,36 @@ export declare class Miris {
     get viewerKey(): string | null | undefined;
     set viewerKey(viewerKey: string | null | undefined);
     get scenes(): Set<Scene>;
+    get useSphericalHarmonics(): boolean;
+    set useSphericalHarmonics(value: boolean);
     constructor();
     dispose(): void;
     updateParentedTransform(_modelTransform: Float32Array<ArrayBuffer>, _parentTransform: Float32Array<ArrayBuffer>): Float32Array<ArrayBuffer> | undefined;
+    protected _xrModeActive: boolean;
+    protected _xrSession: XRSession | null;
+    protected _requestAnimationFrame: RequestAnimationFrameFn | null;
+    signalResumeFromIdle(): void;
+    get _splatCountBudget(): number;
+    /**
+     * Why 43? Because the AVP throttles down to 45Hz :(
+     */
+    static readonly _XR_TARGET_FRAME_RATE = 43;
+    /* Excluded from this release type: _XR_SPLAT_COUNT_BUDGET */
+    /* Excluded from this release type: _SHARK_SPLAT_CAPACITY_MOBILE */
+    static readonly _SHARK_SPLAT_CAPACITY_DESKTOP = 3000000;
+    /* Excluded from this release type: _SHARK_SPLAT_BUDGET_CAP_MOBILE */
+    static readonly _SHARK_SPLAT_BUDGET_CAP_DESKTOP = 2500000;
+    /* Excluded from this release type: _isMobileDevice */
+    /* Excluded from this release type: _sharkSplatCapacity */
+    /* Excluded from this release type: _limitSharkSplatCapacity */
+    /* Excluded from this release type: _sharkSplatBudgetCap */
+    /* Excluded from this release type: _setTargetFrameRate */
     /* Excluded from this release type: _setXRModeActive */
+    /* Excluded from this release type: _setSplatCountBudgetOverride */
     /* Excluded from this release type: _update */
     getLocalTransform(client: Client, sceneObjectId: number): Float32Array<ArrayBuffer> | undefined;
     getWorldTransform(client: Client, sceneObjectId: number): Float32Array<ArrayBuffer> | undefined;
-    update(): boolean;
+    /* Excluded from this release type: _updateForScene */
     applyChanges(_entries: Change[]): void;
     _computeAdditionalRenderNeeded(): boolean;
     onColorSpaceDetected(_isLinear: boolean): void;
@@ -451,11 +570,40 @@ export declare type ModelRootInit = {
     stream: Stream;
 };
 
+/**
+ * The byte-exact counterpart of getRawUint32Attribute above: same no-padding, no-takeAttribute
+ * contract, returning bytes rather than words.
+ *
+ * Use this rather than that one wherever the stride is not a whole number of words: the
+ * reflectance records' 18- and 26-byte strides are not, and an odd record count would lose that
+ * record's last field to dataPtrView's truncation.
+ */
+export declare type RawByteAttributeWithBounds = {
+    bytes: Uint8Array<ArrayBuffer>;
+    minValue: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    maxValue: {
+        x: number;
+        y: number;
+        z: number;
+    };
+};
+
+declare type ReadyState_2 = typeof HaveNothing | typeof HaveMetadata | typeof HaveData;
+export { ReadyState_2 as ReadyState }
+
+declare type RequestAnimationFrameFn = ((callback: FrameRequestCallback) => number) | ((callback: XRFrameRequestCallback) => void);
+
 declare interface RuntimeSettings extends EmbindObject {
     maxBandwidthBitsPerSecond: number;
     maxConcurrentRequests: number;
     targetFramesPerSecond: number;
     xrModeActive: boolean;
+    splatCountBudget: number;
+    splatCountBudgetCap: number;
 }
 
 export declare class Scene extends EventTarget {
@@ -467,6 +615,7 @@ export declare class Scene extends EventTarget {
     readonly id: number;
     get key(): unknown;
     set key(key: unknown);
+    /* Excluded from this release type: _assetFormat */
     get viewerKey(): string | null;
     set viewerKey(viewerKey: string | null);
     get streams(): Set<Stream>;
@@ -476,6 +625,18 @@ export declare class Scene extends EventTarget {
     readonly client: Client;
     readonly handle?: number;
     constructor({ miris, viewerKey }: SceneInit);
+    /**
+     * Drives a frame and answers whether *this* scene's canvas needs repainting. Call it once per
+     * displayed frame from the host's animation loop, and render when it returns true.
+     *
+     * Every scene on the page calls this from its own loop. The first call in a displayed frame
+     * drives one engine tick for all of them; the rest recognise the frame and reuse it.
+     *
+     * @param ts the host's frame timestamp. Optional - the document timeline supplies one, and it
+     *   reads the same for every scene in a displayed frame. Pass it when the host runs its own
+     *   clock, as an immersive XR session does, because XRFrame time is not the document timeline.
+     */
+    update(ts?: DOMHighResTimeStamp): boolean;
     dispose(): void;
     fetchAssets(tags?: string | Iterable<string>): Promise<{
         name: string;
@@ -483,13 +644,16 @@ export declare class Scene extends EventTarget {
         uuid: string;
         tags: string[];
     }[]>;
-    getDefaultCameraTransform(): Float32Array<ArrayBuffer> | null | undefined;
     add(stream: Stream): void;
     getStreamForId(streamObjectId: number): Stream | undefined;
     getStreamForDescendentId(descendentObjectId: number): Stream | null;
     getModelRootForDescendentId(descendentObjectId: number): ModelRoot | null;
+    _recordAssetFormat(modelRoot: ModelRoot, formatVersion: number): void;
+    /* Excluded from this release type: _getFeatureMesh */
     /* Excluded from this release type: _getDrMap */
+    /* Excluded from this release type: _onDrMapLadder */
     /* Excluded from this release type: _onFeatureData */
+    /* Excluded from this release type: _updateStreamStatuses */
     /* Excluded from this release type: _onSceneLoaded */
     delete(stream: Stream): void;
     close(): void;
@@ -501,6 +665,7 @@ declare interface SceneChangeIds extends EmbindObject {
     readonly modifiedObjectsCount: number;
     readonly deactivatedObjectsCount: number;
     readonly deletedObjectsCount: number;
+    readonly remaskedObjectsCount: number;
 }
 
 export declare type SceneInit = {
@@ -512,6 +677,13 @@ declare interface SceneMetadata extends EmbindObject {
     readonly inputColorSpace: string;
 }
 
+declare type SparkAttributeInfo = {
+    elementsPerSplat: number;
+    discard: boolean;
+};
+
+export declare const sparkAttributeList: Record<string, SparkAttributeInfo>;
+
 declare interface SpatialFormat extends EmbindObject {
     metersPerUnit: number;
     upAxis: number;
@@ -539,6 +711,8 @@ export declare class Stream extends EventTarget {
     set key(key: unknown);
     get matrix(): Matrix4x4Tuple;
     set matrix(matrix: Matrix4x4Tuple);
+    get opacity(): number;
+    set opacity(opacity: number);
     get boundingBox(): {
         min: {
             x: number;
@@ -569,6 +743,11 @@ export declare class Stream extends EventTarget {
     constructor(options: StreamInit);
     _initStream({ uuid }: StreamInit): void;
     /* Excluded from this release type: _onStreamLoaded */
+    getDefaultCameraTransform(): Float32Array<ArrayBuffer> | null | undefined;
+    /* Excluded from this release type: _getViewingVolumeObb */
+    /** How much of the stream has loaded, as of the last frame. */
+    get readyState(): ReadyState_2;
+    /* Excluded from this release type: _updateStatus */
     /* Excluded from this release type: _onRootLoaded */
     add(modelRoot: ModelRoot): void;
     end(): void;