@miris-inc/core 0.0.8-1d9d690 → 0.0.8-1db29d5

package/dist/core.d.ts

@@ -9,7 +9,9 @@ declare interface AttributeInfo extends EmbindObject {
     readonly elementCount: number;
     readonly dataSizeBytes: number;
     readonly clientSideId: bigint;
-    readonly minValue: { x: number; y: number; z: number };
+    // 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 };
 }
 
@@ -32,7 +34,12 @@ export declare class AttributeNames {
     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;
 }
 
@@ -63,6 +70,18 @@ export declare class Camera {
     constructor({ aspect, fov, near, far, matrix, scene, viewportHeight, }: CameraInit);
 }
 
+declare interface Camera_2 {
+    dir: vec4;
+    U: vec4;
+    V: vec4;
+    eye: vec4;
+    l: number;
+    fov: number;
+    zNear: number;
+    zFar: number;
+    delete(): void;
+}
+
 export declare type CameraInit = {
     aspect: number;
     fov: number;
@@ -106,7 +125,9 @@ 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;
+    getOctantLocalBoundingBoxes(...args: ClientMethodParameters["getOctantLocalBoundingBoxes"]): number[];
     getLocalTransform(...args: ClientMethodParameters["getLocalTransform"]): AquaStatus;
     getWorldTransform(...args: ClientMethodParameters["getWorldTransform"]): AquaStatus;
     hasAttribute(...args: ClientMethodParameters["hasAttribute"]): boolean;
@@ -116,6 +137,8 @@ declare class Client {
     setAssetViewerKey(...args: ClientMethodParameters["setAssetViewerKey"]): AquaStatus;
     setClientSpatialFormat(...args: ClientMethodParameters["setClientSpatialFormat"]): AquaStatus;
     setRuntimeSettings(...args: ClientMethodParameters["setRuntimeSettings"]): AquaStatus;
+    setStreamFetchMode(...args: ClientMethodParameters["setStreamFetchMode"]): boolean;
+    getStreamFetchMode(...args: ClientMethodParameters["getStreamFetchMode"]): number;
     setMainCameraTransform(...args: ClientMethodParameters["setMainCameraTransform"]): AquaStatus;
     setMainCameraViewFrustum(...args: ClientMethodParameters["setMainCameraViewFrustum"]): AquaStatus;
     setSceneObjectTransform(...args: ClientMethodParameters["setSceneObjectTransform"]): AquaStatus;
@@ -133,6 +156,14 @@ declare class Client {
     updateSceneExecution(...args: ClientMethodParameters["updateSceneExecution"]): AquaStatus;
 }
 
+declare type ClientAttributeInfo = {
+    elementsPerSplat: number;
+    discard: boolean;
+    bytes?: true;
+};
+
+export declare const clientAttributeList: Record<string, ClientAttributeInfo>;
+
 declare type ClientInit = {
     engine: Engine;
     context?: AquaContextHandle;
@@ -182,6 +213,7 @@ declare class Engine {
         readonly DrMap: 0;
         readonly ReflMesh: 1;
         readonly GlassMesh: 2;
+        readonly RenderAsPointCloud: 3;
     };
     static FeatureState: {
         readonly NotLoaded: 0;
@@ -189,11 +221,28 @@ 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;
+    };
+    static StreamFetchMode: {
+        readonly Regular: 0;
+        readonly Prefetch: 1;
+        readonly Parked: 2;
+    };
     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;
@@ -214,6 +263,7 @@ declare class Engine {
         Y: number;
         Z: number;
     };
+    get UsePadding(): boolean;
     activatedObjectIdsView(...args: [sceneChangeIds: SceneChangeIds]): Uint32Array;
     addStreamById(...args: [
     handle: AquaClientHandle,
@@ -231,6 +281,7 @@ declare class Engine {
     deactivatedObjectIdsView(...args: [sceneChangeIds: SceneChangeIds]): Uint32Array;
     remaskedObjectIdsView(...args: [sceneChangeIds: SceneChangeIds]): Uint32Array;
     getDrawnOctantMask(...args: [handle: AquaClientHandle, sceneObjectId: number]): number;
+    getOctantLocalBoundingBoxes(...args: [handle: AquaClientHandle, sceneObjectId: number]): number[];
     destroyClient(...args: [handle: AquaClientHandle]): AquaStatus;
     free(...args: [size: number]): number;
     getAssetsAsync(...args: [handle: AquaClientHandle, tags: StringVector]): AssetInfo[];
@@ -249,6 +300,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,
@@ -300,8 +352,11 @@ declare class Engine {
     farPlane: number,
     viewportHeightPixels: number
     ]): AquaStatus;
+    setStreamFetchMode(...args: [handle: AquaClientHandle, streamObjectId: number, mode: number]): boolean;
+    getStreamFetchMode(...args: [handle: AquaClientHandle, streamObjectId: number]): number;
     setMaxCacheSize(...args: [maxSizeBytes: number]): void;
     setPreferSharkEncodingProfiles(...args: [preferShark: boolean]): void;
+    setPadSplatAttributes(usePadding: boolean): void;
     setSceneObjectTransform(...args: [
     handle: AquaClientHandle,
     sceneObjectId: number,
@@ -330,9 +385,16 @@ declare class Engine {
      * 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.
+     * `primsResident` is what the renderer held at the end of the previous frame, fading
+     * prims included, and `primCapacity` what it can hold; activations that would not fit are
+     * deferred, where primCapacity 0 means deferral is disabled.
      */
-    beginFrame(...args: [contextHandle: AquaContextHandle, previousFrameTimeMs: number]): AquaStatus;
+    beginFrame(...args: [
+    contextHandle: AquaContextHandle,
+    previousFrameTimeMs: number,
+    primsResident: number,
+    primCapacity: 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;
@@ -346,6 +408,52 @@ declare type EngineMethodParameters<E extends Engine = Engine> = {
     [Key in keyof E]: E[Key] extends (...args: any[]) => any ? Parameters<E[Key]> : never;
 };
 
+declare interface GlassMeshRegistry {
+    // Decodes one octree node's glass payload and registers it, replacing any previous entry for
+    // that object. False for a malformed or empty payload, leaving the registry unchanged.
+    //
+    // The two slot arguments are different numbers here, unlike on the native path, and swapping
+    // them renders glass that does not follow its asset: modelRootSlot scopes the panel dedupe to
+    // one asset instance, while chunkModelRootIndex is stamped into every vertex and read back as
+    // chunkModelRoots[pos.w], so that one takes the chunk's fade slot.
+    //
+    // geometryPtr/panelPtr address THIS module's heap - _malloc here and copy the bytes in, since
+    // the attributes live in the engine module's. The AABB is the geometry attribute's own range.
+    registerObject(
+    objectId: number,
+    lodIndex: number,
+    modelRootSlot: number,
+    chunkModelRootIndex: number,
+    geometryPtr: number,
+    geometryByteCount: number,
+    panelPtr: number,
+    panelByteCount: number,
+    aabbMinX: number,
+    aabbMinY: number,
+    aabbMinZ: number,
+    aabbMaxX: number,
+    aabbMaxY: number,
+    aabbMaxZ: number,
+    ): boolean;
+    // Returns true if the object had glass, which is what says the buffers need rebuilding.
+    removeObject(objectId: number): boolean;
+    clear(): void;
+    isDirty(): boolean;
+    // Rebuilds the flattened buffers, keeping each panel from its deepest resident LOD. Stays dirty
+    // so uploadIfDirty still fires. Walks every registered object, so not per frame.
+    flattenIfDirty(): void;
+    uploadIfDirty(renderState: RenderState): void;
+    vertexCount(): number;
+    panelCount(): number;
+    delete(): void;
+}
+
+export declare const HaveData = 2;
+
+export declare const HaveMetadata = 1;
+
+export declare const HaveNothing = 0;
+
 export declare class Lod {
     #private;
     readonly id: LodInit["id"];
@@ -376,14 +484,19 @@ export declare class Lod {
     get transform(): Float32Array<ArrayBuffer> | null;
     get _drawnOctantMask(): number;
     set _drawnOctantMask(mask: number);
+    get _octantLocalBounds(): Float32Array<ArrayBuffer> | null;
+    set _octantLocalBounds(bounds: Float32Array<ArrayBuffer> | null);
     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, client }: LodInit);
 }
@@ -406,8 +519,13 @@ export declare class LodStore {
     deleteId(id: number): void;
 }
 
-declare interface MainModule {
+declare interface MainModule extends SharkModule {
     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>;
@@ -436,6 +554,7 @@ declare interface MainModule {
     remaskedObjectIdsView(sceneChangeIds: SceneChangeIds): Uint32Array;
     deletedObjectIdsView(sceneChangeIds: SceneChangeIds): Uint32Array;
     GetDrawnOctantMask(handle: number, sceneObjectId: number): number;
+    GetOctantLocalBoundingBoxes(handle: number, sceneObjectId: number): number[];
     GetAssetsAsync(handle: number, tags: StringVector): unknown[];
     GetSceneChanges(handle: number, sceneChangeIds: SceneChangeIds): void;
     GetSceneChangesCounts(handle: number, sceneChangeIds: SceneChangeIds): void;
@@ -448,10 +567,17 @@ declare interface MainModule {
     GetDrMapLadderRoughnessLevels(handle: number, sceneObjectId: number): number[];
     SetClientSpatialFormat(handle: number, spatialFormat: SpatialFormat): { value: number };
     SetRuntimeSettings(handle: number, settings: RuntimeSettings): { value: number };
+    SetStreamFetchMode(handle: number, streamObjectId: number, mode: number): boolean;
+    GetStreamFetchMode(handle: number, streamObjectId: number): number;
     TakeEvictedClientSideAttributeIds(handle: number): EmbindVector<bigint>;
     GetActiveClientSideIdsCheckSum(): number;
     TakeRenderRequired(handle: number): boolean;
-    BeginFrame(contextHandle: number, previousFrameTimeMs: number): number;
+    BeginFrame(
+    contextHandle: number,
+    previousFrameTimeMs: number,
+    primsResident: number,
+    primCapacity: number,
+    ): number;
     modifiedObjectIdsView(sceneChangeIds: SceneChangeIds): Uint32Array;
     setMaxCacheSize(maxSizeBytes: number): void;
     SetPreferSharkEncodingProfiles(prefer: boolean): void;
@@ -493,15 +619,20 @@ export declare class Miris {
     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;
+    static readonly _SHARK_SPLAT_CAPACITY_DESKTOP: number;
     /* Excluded from this release type: _SHARK_SPLAT_BUDGET_CAP_MOBILE */
-    static readonly _SHARK_SPLAT_BUDGET_CAP_DESKTOP = 2500000;
+    static readonly _SHARK_SPLAT_BUDGET_CAP_DESKTOP = 2400000;
     /* Excluded from this release type: _isMobileDevice */
     /* Excluded from this release type: _sharkSplatCapacity */
+    /* Excluded from this release type: _minimumSplatCount */
+    /* Excluded from this release type: _splatCountStorageKey */
+    /* Excluded from this release type: _reloadWithLowerSplatCapacity */
+    /* 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: _reportRendererPrims */
     /* Excluded from this release type: _update */
     getLocalTransform(client: Client, sceneObjectId: number): Float32Array<ArrayBuffer> | undefined;
     getWorldTransform(client: Client, sceneObjectId: number): Float32Array<ArrayBuffer> | undefined;
@@ -534,6 +665,94 @@ 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 interface RendererWGPU {
+    getProgramCount(): number;
+    getTextureCount(): number;
+    getEstimatedTextureSize(): number;
+    getTotalBufferSize(): number;
+    getGpuBufferSize(): number;
+    getUploadBufferSize(): number;
+    info: SharkInfo;
+    delete(): void;
+}
+
+declare interface RenderState {
+    delete(): void;
+    initRenderState(
+    renderer: RendererWGPU,
+    width: number,
+    height: number,
+    vertices: number,
+    splats: number,
+    cubes: number,
+    sortThreads: number,
+    sortGroupSize: number,
+    sortKeySize: number,
+    ): void;
+    initGraphicsState(
+    width: number,
+    height: number,
+    renderTextureFormat: TextureFormatValue,
+    depthTextureFormat: TextureFormatValue,
+    ): void;
+    updateRenderDetails(
+    width: number,
+    height: number,
+    splatTriangles: number,
+    ): void;
+    // Decodes Radiance .hdr bytes into roughness-ladder level `level` (0 is the sharp mirror).
+    // hdrPtr must address THIS module's heap - _malloc here and copy the bytes in.
+    // Returns false for bytes that are not a usable Radiance image, or a level out of range.
+    uploadEnvironmentLadderLevelFromHdr(
+    level: number,
+    sigmaDeg: number,
+    hdrPtr: number,
+    hdrSizeBytes: number,
+    ): boolean;
+    // Republish the ladder's shape. Call after any level lands, or it is sampled at whatever shape
+    // the last uploadSplatSetData declared. Pass SplatSet.hasReflectionParams().
+    uploadReflectionLadderParams(reflectionsEnabled: boolean): void;
+    // Debug controls. Drop the reflection term, or replace the surfel colour with one of the layers
+    // it is shaded from, numbered as RenderViewModes.h's AOV_* defines. setRenderView below sets
+    // the AOV together with the rest of a named view.
+    setReflectionsEnabled(enabled: boolean): void;
+    // Render textured gaussians on pixels no surfel covers, resolved as fvdb's open gate does.
+    // Off by default: those pixels show the clear colour.
+    setSurfelLessTextureSplatsEnabled(enabled: boolean): void;
+    setDebugAovMode(mode: number): void;
+    // GPU pass timing. Turning it on makes every pass write timestamps; a no-op on a device without
+    // timestamp-query. resolveTimeStamps goes after a frame's render; passTimingsMs starts a readback
+    // of them unless one is in flight and maps pass name to milliseconds from the last that landed.
+    setPassTimingEnabled(enabled: boolean): void;
+    resolveTimeStamps(): void;
+    passTimingsMs(): Record<string, number>;
+}
+
 declare type RequestAnimationFrameFn = ((callback: FrameRequestCallback) => number) | ((callback: XRFrameRequestCallback) => void);
 
 declare interface RuntimeSettings extends EmbindObject {
@@ -592,6 +811,8 @@ export declare class Scene extends EventTarget {
     /* Excluded from this release type: _getDrMap */
     /* Excluded from this release type: _onDrMapLadder */
     /* Excluded from this release type: _onFeatureData */
+    /* Excluded from this release type: _applyStreamFetchModes */
+    /* Excluded from this release type: _updateStreamStatuses */
     /* Excluded from this release type: _onSceneLoaded */
     delete(stream: Stream): void;
     close(): void;
@@ -615,12 +836,117 @@ declare interface SceneMetadata extends EmbindObject {
     readonly inputColorSpace: string;
 }
 
-declare type SparkAttributeInfo = {
-    elementsPerSplat: number;
-    discard: boolean;
-};
+declare interface SharkInfo {
+    renderCalls: number;
+    render: SharkRenderInfo;
+    reset(): void;
+}
 
-export declare const sparkAttributeList: Record<string, SparkAttributeInfo>;
+declare interface SharkModule {
+    Camera: new () => Camera_2;
+    RenderState: new () => RenderState;
+    SplatSet: new () => SplatSet;
+    GlassMeshRegistry: new () => GlassMeshRegistry;
+    vec4: new (x: number, y: number, z: number, w: number) => vec4;
+
+    SortType: {
+        RADIX_SORT: SortTypeValue;
+        OCTREE_SORT: SortTypeValue;
+        KDTREE_SORT: SortTypeValue;
+        STD_SORT: SortTypeValue;
+    };
+
+    TextureFormat: {
+        RGBA32_Float: TextureFormatValue;
+        RGBA16_Float: TextureFormatValue;
+        RG16_Float: TextureFormatValue;
+        RGBA32_UInt: TextureFormatValue;
+        RGBA32_SInt: TextureFormatValue;
+        RGBA16_UInt: TextureFormatValue;
+        RGBA16_SInt: TextureFormatValue;
+        RGBA8_UInt: TextureFormatValue;
+        RGBA8_SInt: TextureFormatValue;
+        RGBA8_UNorm: TextureFormatValue;
+        RGBA8_SNorm: TextureFormatValue;
+        RGBA16_UNorm: TextureFormatValue;
+        RGBA16_SNorm: TextureFormatValue;
+        BGRA8_UNorm: TextureFormatValue;
+        BC6HRGB_UFloat: TextureFormatValue;
+        BC6HRGB_Float: TextureFormatValue;
+        BC7RGBA_UNorm: TextureFormatValue;
+        BC7RGBA_UNormSrgb: TextureFormatValue;
+        BC3RGBA_UNorm: TextureFormatValue;
+        BC3RGBA_UNormSrgb: TextureFormatValue;
+        Depth16Unorm: TextureFormatValue;
+        Depth24Plus: TextureFormatValue;
+        Depth32Float: TextureFormatValue;
+    };
+
+    WebGPU: WebGPUInterface;
+
+    // HEAPU8 is replaced whenever the heap grows, so read it fresh rather than caching it.
+    _malloc(byteCount: number): number;
+    _free(ptr: number): void;
+    readonly HEAPU8: Uint8Array;
+
+    uploadSplatSetData(
+    set: SplatSet,
+    renderState: RenderState,
+    start: number,
+    ): void;
+    uploadChunkFades(set: SplatSet, renderState: RenderState): void;
+    // One mat4 per model root, so cheap enough to call every frame while an asset is moving
+    uploadModelRootTransforms(set: SplatSet, renderState: RenderState): void;
+    processSplatSet(
+    camera: Camera_2,
+    set: SplatSet,
+    renderState: RenderState,
+    width: number,
+    height: number,
+    triangles: number,
+    projectOnGPU: boolean,
+    cullEllipsoid: boolean,
+    useAffineApprox: boolean,
+    depthSortOnGPU: boolean,
+    useInvZ: boolean,
+    rasterizeWithCompute: boolean,
+    useSOGS: boolean,
+    sortType: SortTypeValue,
+    skipSort: boolean,
+    ): number;
+    createRendererWGPUWithoutSurface(
+    colorTargetFormat: TextureFormatValue,
+    ): RendererWGPU;
+    /// Gives back the reference WebGPU.importJsTexture returned for a texture.
+    releaseImportedTexture(texture: number): void;
+    renderSplatSetToSceneTextures(
+    splatSet: SplatSet,
+    renderState: RenderState,
+    colorTarget: number,
+    depthTarget: number,
+    renderGES: boolean,
+    ): void;
+    // Render view registry, indexed as RenderViews.h orders it. setRenderView ignores an index
+    // Shark cannot produce.
+    setRenderView(viewIndex: number): void;
+    renderView(): number;
+    renderViewCount(): number;
+    renderViewName(viewIndex: number): string;
+    renderViewSupported(viewIndex: number): boolean;
+    // The next supported view, forwards for direction 1 and backwards for -1.
+    stepRenderView(from: number, direction: number): number;
+}
+
+declare interface SharkRenderInfo {
+    triangles: number;
+}
+
+declare interface SortTypeValue {
+    value: number;
+}
+
+/** @deprecated Use clientAttributeList. */
+export declare const sparkAttributeList: Record<string, ClientAttributeInfo>;
 
 declare interface SpatialFormat extends EmbindObject {
     metersPerUnit: number;
@@ -629,6 +955,86 @@ declare interface SpatialFormat extends EmbindObject {
     handedness: number;
 }
 
+declare interface SplatSet {
+    splatCount: number;
+    // Number of splats actually drawn: ordering[0, activeSplats) holds the unmasked splat indices.
+    // Set alongside orderingView() to restrict the draw to unmasked octant ranges.
+    activeSplats: number;
+    // Selects which ellipsoid layout to allocate and what ellipsoidsView() exposes:
+    // packed (16 bytes/splat) or uncompressed (48). Must be set before the first resize.
+    usePackedEllipsoids: boolean;
+    // direct-write upload: resize -> write into the views -> finalize.
+    // views are valid only until the next resize.
+    resize(splatCount: number): void;
+    ellipsoidsView(): Uint32Array;
+    colorsView(): Uint32Array;
+    sh1View(): Uint32Array;
+    sh2View(): Uint32Array;
+    sh3aView(): Uint32Array;
+    sh3bView(): Uint32Array;
+    // mod_depth is a half-float per primitive slot (dense, padded for non-surfels), so this is a
+    // Uint16Array unlike every other view here -- do not address it with the uint32 splat strides
+    // used for ellipsoids/colors/sh*.
+    modDepthView(): Uint16Array;
+    // Per-chunk fade (opacity multiplier), one float per chunk, defaults to 1.0.
+    // Also sizes the chunk slot to model root slot map below, since both are indexed by chunk slot
+    resizeChunkFades(chunkCount: number): void;
+    chunkFadesView(): Float32Array;
+    // Per-splat chunk index, defaults to slot 0. Write before finalize()
+    chunkIndicesView(): Int32Array;
+    // Model transforms, resolved per splat as
+    //   modelRootTransforms[chunkModelRoots[chunkIndices[splat]]]
+    // Slot 0 of both tables is reserved as identity, so real slots start at 1 and a set that
+    // never writes them renders untransformed.
+    resizeModelRootSlots(modelRootCount: number): void;
+    // 16 floats per model root, COLUMN-major - i.e. write THREE's Matrix4.toArray() straight in
+    modelRootTransformsView(): Float32Array;
+    // The inverses, same slots and layout. The true-perspective projection (Project.glsl) transforms
+    // a quadratic form and needs them; writing a transform without its inverse leaves that path
+    // projecting the splat as if untransformed. Use Matrix4.invert() on a copy
+    modelRootInverseTransformsView(): Float32Array;
+    // Sized by resizeChunkFades. Defaults to slot 0 (identity) for every chunk
+    chunkModelRootsView(): Int32Array;
+    // resizeModelRootSlots resets every slot to the absolute decode. False for a slot outside the table
+    setModelRootRootRelativeDecode(
+    slot: number,
+    originX: number,
+    originY: number,
+    originZ: number,
+    step: number,
+    lnScaleOffset: number,
+    ): boolean;
+    // int32 render-order buffer (sized 2*splatCount after finalize). Valid only until the next resize.
+    orderingView(): Int32Array;
+    finalize(): void;
+    // like finalize() but keeps splats in their delivered (octant-sorted) order — no kd-tree reorder —
+    // so sparse-octant range masking can index child-octant ranges directly. RADIX_SORT only.
+    finalizeBounds(): void;
+    // Whether the asset carries per-surfel reflectance records, which is what decides whether
+    // reflections are shaded at all. Pass to RenderState.uploadReflectionLadderParams.
+    hasReflectionParams(): boolean;
+    // Widens packed reflectance records - recordVersion 2 for 18-byte reflectanceDataV2, 1 for
+    // 26-byte reflectanceDataV1 - into the per-splat GPU records at bufferOffset. wirePtr must
+    // address THIS module's heap - _malloc here and copy the bytes in, since the attribute lives in
+    // the engine module's. Records cover a node's surfel range, which starts at its first splat.
+    // Returns the records written; 0 if the data was rejected.
+    decodeReflectionParams(
+    recordVersion: number,
+    wirePtr: number,
+    wireSizeBytes: number,
+    elementCount: number,
+    bufferOffset: number,
+    nodeSplatCount: number,
+    logId: number,
+    ): number;
+    // Zeroes records in [startSplat, endSplat). Needed wherever splats are re-packed at fresh
+    // offsets, or a reused slot shades its splat from the previous occupant's material.
+    clearReflectionParams(startSplat: number, endSplat: number): void;
+    // Splats in [0, count) holding a non-zero record. Diagnostic.
+    populatedReflectionParamCount(count: number): number;
+    delete(): void;
+}
+
 export declare class Stream extends EventTarget {
     #private;
     static readonly _idMap: Map<number, Stream>;
@@ -651,6 +1057,9 @@ export declare class Stream extends EventTarget {
     set matrix(matrix: Matrix4x4Tuple);
     get opacity(): number;
     set opacity(opacity: number);
+    get fetchMode(): StreamFetchMode;
+    set fetchMode(fetchMode: StreamFetchMode);
+    /* Excluded from this release type: _applyFetchMode */
     get boundingBox(): {
         min: {
             x: number;
@@ -683,11 +1092,23 @@ export declare class Stream extends EventTarget {
     /* 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;
 }
 
+/**
+ * What the engine will do with stream data: "regular" fetches and draws what the
+ * camera needs. "prefetch" keeps fetching for the camera into the cache but does not change what is drawn.
+ * "parked" fetches nothing and draws nothing, giving its share of the splat budget and
+ * renderer to the other streams; what it already loaded stays cached on the cpu side for when it is unparked.
+ * You may want to park streams while making them invisible.
+ */
+export declare type StreamFetchMode = "regular" | "prefetch" | "parked";
+
 export declare type StreamInit = {
     uuid: string;
     scene: Scene;
@@ -697,6 +1118,10 @@ export declare type StreamInit = {
 
 declare type StringVector = EmbindVector<string>;
 
+declare interface TextureFormatValue {
+    value: number;
+}
+
 /** Recursive variant tree node from WASM. */
 export declare type VariantNode = {
     id: number;
@@ -707,4 +1132,18 @@ export declare type VariantNode = {
     nestedSets?: VariantNode[];
 };
 
+declare interface vec4 {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+    delete(): void;
+}
+
+declare interface WebGPUInterface {
+    importJsAdapter(adapter: GPUAdapter, parentPtr?: number): number;
+    importJsDevice(device: GPUDevice, parentPtr?: number): number;
+    importJsTexture(obj: GPUTexture, parentPtr?: number): number;
+}
+
 export { }