u-space 0.0.29 → 0.0.30

package/dist/plugins/u-manager/loaders/SceneEditableBatchLayer.d.ts

@@ -0,0 +1,17 @@
+import { EditableGeometryBatchLayer, type EditableGeometryBatchBuildResult, type EditableGeometryBatchOptions, type EditableGeometryBatchStats, type Model, type UnsupportedEditableGeometryBatch } from 'u-space';
+import type { SceneInstanceObject } from './SceneInstancedLayer';
+export type SceneEditableBatchOptions = EditableGeometryBatchOptions;
+export type SceneEditableBatchStats = EditableGeometryBatchStats;
+export interface UnsupportedSceneBatch extends UnsupportedEditableGeometryBatch<SceneInstanceObject> {
+    url: string;
+}
+export interface SceneEditableBatchBuildResult extends EditableGeometryBatchBuildResult<SceneInstanceObject> {
+    unsupported: UnsupportedSceneBatch[];
+}
+export declare class SceneEditableBatchLayer extends EditableGeometryBatchLayer<SceneInstanceObject> {
+    isSceneEditableBatchLayer: boolean;
+    type: string;
+    constructor(options?: SceneEditableBatchOptions);
+    addTemplate(url: string, template: Model, instances: SceneInstanceObject[]): boolean;
+    build(): SceneEditableBatchBuildResult;
+}

package/dist/plugins/u-manager/loaders/SceneInstancedLayer.d.ts

@@ -1,11 +1,11 @@
 import type { Object3D } from 'three/webgpu';
-import { SemanticInstanceObject, SemanticModelInstancedLayer } from '../instances';
-export declare class SceneInstanceObject extends SemanticInstanceObject {
+import { InstanceObject, ModelInstancedLayer } from 'u-space';
+export declare class SceneInstanceObject extends InstanceObject {
     isSceneInstanceObject: boolean;
     type: string;
     constructor();
 }
-export declare class SceneInstancedLayer extends SemanticModelInstancedLayer<SceneInstanceObject> {
+export declare class SceneInstancedLayer extends ModelInstancedLayer<SceneInstanceObject> {
     isSceneInstancedLayer: boolean;
     type: string;
     constructor();

package/dist/plugins/u-manager/loaders/SceneLoader.d.ts

@@ -1,24 +1,32 @@
 import { Loader } from 'three/webgpu';
 import { Model, type Viewer, BaseGroup } from 'u-space';
 import { SceneInstancedLayer } from './SceneInstancedLayer';
+import { SceneEditableBatchLayer, type SceneEditableBatchOptions } from './SceneEditableBatchLayer';
 import type { ITreeData } from '../types';
 export declare class SceneGroup extends BaseGroup {
     isSceneGroup: boolean;
     type: string;
-    sceneLayer: SceneInstancedLayer | null;
+    sceneLayer: SceneInstancedLayer | SceneEditableBatchLayer | null;
     constructor();
-    setSceneLayer(layer: SceneInstancedLayer | null): this;
-    getDefaultSceneLayer(): SceneInstancedLayer | null;
+    setSceneLayer(layer: SceneInstancedLayer | SceneEditableBatchLayer | null): this;
+    getDefaultSceneLayer(): SceneInstancedLayer | SceneEditableBatchLayer | null;
 }
 export declare class SceneLoader extends Loader {
     #private;
     viewer: Viewer;
     key: string;
     cachedIds: Set<string>;
+    editableBatchOptions: SceneEditableBatchOptions | null;
     protected _resourceData: any;
     protected _treeData: ITreeData[];
     constructor(viewer: Viewer);
     setKey(key: string): this;
+    /**
+     * Merge mostly-static scene models into editable GPU batches. Logical scene
+     * objects remain addressable; transform or opacity edits materialize only the
+     * edited object back into an ordinary model.
+     */
+    setEditableBatching(options?: boolean | SceneEditableBatchOptions): this;
     protected loadModel(url: string): Promise<Model>;
     protected _preareTreeData(): Promise<void>;
     protected _prepareSemanticIds(): Promise<ReadonlySet<string>>;

package/dist/plugins/u-manager/semantics/objects/BuildingGroup.d.ts

@@ -1,10 +1,9 @@
-import { BaseGroup } from 'u-space';
+import { BaseGroup, type InstanceObject } from 'u-space';
 import type { ElevatorMesh } from './ElevatorMesh';
 import type { FloorMesh, FloorSemanticKind } from './FloorMesh';
 import type { VentMesh } from './VentMesh';
-import type { SemanticInstanceObject } from '../../instances';
 export type BuildingFloorReference = FloorMesh | number;
-export type BuildingFacilityReference = SemanticInstanceObject | string;
+export type BuildingFacilityReference = InstanceObject | string;
 export declare class BuildingGroup extends BaseGroup {
     #private;
     isBuildingGroup: boolean;
@@ -39,11 +38,11 @@ export declare class BuildingGroup extends BaseGroup {
     showAllFloors(): this;
     showAllFacilities(): this;
     hideAllFacilities(): this;
-    getFacilityById(id: string): SemanticInstanceObject | undefined;
+    getFacilityById(id: string): InstanceObject | undefined;
     syncFacilityIndexes(): this;
     get facilityIndexVersion(): number;
     getFacilityIndexIds(): MapIterator<string>;
-    getFacilityIndexObjects(): MapIterator<SemanticInstanceObject>;
+    getFacilityIndexObjects(): MapIterator<InstanceObject>;
     planishFloors(kind?: FloorSemanticKind): this;
     unplanishFloors(kind?: FloorSemanticKind): this;
 }

package/dist/plugins/u-manager/semantics/objects/FacilityInstancedLayer.d.ts

@@ -1,12 +1,12 @@
-import { SemanticInstanceObject, SemanticModelInstancedLayer, type SemanticInstanceCullingOptions } from '../../instances';
-export declare class FacilityInstanceObject extends SemanticInstanceObject {
+import { InstanceObject, ModelInstancedLayer, type InstanceCullingOptions } from 'u-space';
+export declare class FacilityInstanceObject extends InstanceObject {
     isFacilityInstanceObject: boolean;
     type: string;
     constructor();
 }
-export declare class FacilityInstancedLayer extends SemanticModelInstancedLayer<FacilityInstanceObject> {
+export declare class FacilityInstancedLayer extends ModelInstancedLayer<FacilityInstanceObject> {
     isFacilityInstancedLayer: boolean;
     type: string;
     constructor();
 }
-export type FacilityInstanceCullingOptions = SemanticInstanceCullingOptions;
+export type FacilityInstanceCullingOptions = InstanceCullingOptions;

package/dist/plugins/u-manager/semantics/objects/FloorMesh.d.ts

@@ -1,8 +1,7 @@
 import { Box3, BufferGeometry, Matrix4, MeshStandardNodeMaterial, Sphere, Vector3, Vector4, type ColorRepresentation, type Intersection, type Object3D, type Raycaster } from 'three/webgpu';
-import { BaseMesh, type InteractionEvent, type InteractionEventMap } from 'u-space';
+import { BaseMesh, InstanceObject, type InteractionEvent, type InteractionEventMap } from 'u-space';
 import type { SemanticColor, SemanticGeometryEntry, SemanticKind } from '../types';
-import { SemanticInstanceObject } from '../../instances';
-type FacilityReference = SemanticInstanceObject | string;
+type FacilityReference = InstanceObject | string;
 type FacilitySemanticKind = 'Facilities';
 type FloorMeshMaterial = MeshStandardNodeMaterial | MeshStandardNodeMaterial[];
 export type FloorSemanticKind = SemanticKind | FacilitySemanticKind;
@@ -20,7 +19,7 @@ export interface FloorFacilitySemanticEntity {
     id: string;
     name?: string;
     index: number;
-    object: SemanticInstanceObject;
+    object: InstanceObject;
     aliases: string[];
 }
 export type FloorSemanticEntity = FloorGeometrySemanticEntity | FloorFacilitySemanticEntity;
@@ -34,9 +33,8 @@ export interface FloorMeshIntersection extends Intersection<Object3D> {
     semanticKind: FloorSemanticKind;
     semanticName?: string;
     semanticIndex: number;
-    instanceId: number;
-    semanticObject?: SemanticInstanceObject;
-    facility?: SemanticInstanceObject;
+    semanticObject?: InstanceObject;
+    facility?: InstanceObject;
     facilityId?: string;
 }
 export type FloorMeshInteractionEvent = Omit<InteractionEvent, 'target' | 'currentTarget' | 'intersect'> & {
@@ -47,21 +45,21 @@ export type FloorMeshInteractionEvent = Omit<InteractionEvent, 'target' | 'curre
 export type FloorMeshEventMap = {
     [K in keyof InteractionEventMap]: FloorMeshEventPayload<InteractionEventMap[K]>;
 };
-export declare class FloorSemanticInstanceObject extends SemanticInstanceObject {
+export declare class FloorSemanticInstanceObject extends InstanceObject {
     #private;
     isFloorSemanticInstanceObject: boolean;
     type: string;
     readonly floorMesh: FloorMesh;
     readonly semanticIndex: number;
     constructor(floorMesh: FloorMesh, semanticIndex: number);
-    setSemanticVisible(visible: boolean): this;
-    setSemanticColor(color: ColorRepresentation): this;
-    resetSemanticColor(): this;
-    setSemanticOpacity(opacity: number): this;
-    getSemanticOpacity(): number;
-    setSemanticHighlight(color: ColorRepresentation, opacity: number, overwrite?: boolean): this;
-    clearSemanticHighlight(): this;
-    getSemanticBoundingBox(target?: Box3, world?: boolean): Box3;
+    setInstanceVisible(visible: boolean): this;
+    setInstanceColor(color: ColorRepresentation): this;
+    resetInstanceColor(): this;
+    setInstanceOpacity(opacity: number): this;
+    getInstanceOpacity(): number;
+    setInstanceHighlight(color: ColorRepresentation, opacity: number, overwrite?: boolean): this;
+    clearInstanceHighlight(): this;
+    getInstanceBoundingBox(target?: Box3, world?: boolean): Box3;
 }
 export declare class FloorMesh extends BaseMesh<BufferGeometry, FloorMeshMaterial, FloorMeshEventMap> {
     #private;
@@ -81,8 +79,8 @@ export declare class FloorMesh extends BaseMesh<BufferGeometry, FloorMeshMateria
     staircasesInstances: Map<string, number>;
     semanticInstances: Map<string, number>;
     semanticEntities: Map<string, FloorSemanticEntity>;
-    facilityObjectsById: Map<string, SemanticInstanceObject>;
-    facilityObjects: SemanticInstanceObject[];
+    facilityObjectsById: Map<string, InstanceObject>;
+    facilityObjects: InstanceObject[];
     facilityIndexVersion: number;
     constructor(entries: SemanticGeometryEntry[]);
     setSemanticIdentity(identity: {
@@ -104,10 +102,10 @@ export declare class FloorMesh extends BaseMesh<BufferGeometry, FloorMeshMateria
     getSemanticObjectAt(index: number): FloorSemanticInstanceObject;
     showAllFacilities(): this;
     hideAllFacilities(): this;
-    addFacility(object: SemanticInstanceObject, ids?: string | string[]): this;
-    getFacilityById(id: string): SemanticInstanceObject | undefined;
-    getFacilityAt(index: number): SemanticInstanceObject;
-    getFacilities(): SemanticInstanceObject[];
+    addFacility(object: InstanceObject, ids?: string | string[]): this;
+    getFacilityById(id: string): InstanceObject | undefined;
+    getFacilityAt(index: number): InstanceObject;
+    getFacilities(): InstanceObject[];
     removeFacility(facility: FacilityReference): this;
     setColorAt(index: number, color: SemanticColor): this;
     resetColorAt(index: number): this;

package/dist/plugins/u-manager/semantics/objects/SemanticGroup.d.ts

@@ -1,8 +1,7 @@
-import { BaseGroup } from 'u-space';
+import { BaseGroup, type InstanceObject } from 'u-space';
 import type { BuildingGroup } from './BuildingGroup';
 import type { FacilityInstancedLayer } from './FacilityInstancedLayer';
 import type { FloorMesh, FloorSemanticKind } from './FloorMesh';
-import type { SemanticInstanceObject } from '../../instances';
 export declare class SemanticGroup extends BaseGroup {
     #private;
     isSemanticGroup: boolean;
@@ -20,7 +19,7 @@ export declare class SemanticGroup extends BaseGroup {
     getDefaultFacilityLayer(): FacilityInstancedLayer | null;
     showAllFacilities(): this;
     hideAllFacilities(): this;
-    getFacilityById(id: string): SemanticInstanceObject | undefined;
+    getFacilityById(id: string): InstanceObject | undefined;
     showAllFloors(): this;
     planishFloors(kind?: FloorSemanticKind): this;
     unplanishFloors(kind?: FloorSemanticKind): this;

package/dist/protocol-C-OMPz15.js

@@ -0,0 +1,10 @@
+function a(s) {
+  return s instanceof Error ? {
+    message: s.message,
+    name: s.name,
+    stack: s.stack
+  } : { message: String(s) };
+}
+export {
+  a as s
+};

package/dist/protocol-IUAzx0lk.cjs

@@ -0,0 +1 @@
+"use strict";function e(s){return s instanceof Error?{message:s.message,name:s.name,stack:s.stack}:{message:String(s)}}exports.serializeError=e;

package/dist/src/batches/EditableGeometryBatchLayer.d.ts

@@ -0,0 +1,50 @@
+import { Object3D } from 'three/webgpu';
+import { BaseGroup, Model } from '../objects';
+import { InstanceObject } from '../instances/InstanceObject';
+import type { InteractionEventMap } from '../interactions/InteractionEvent';
+export interface EditableGeometryBatchOptions {
+    maxVerticesPerBatch?: number;
+    maxIndicesPerBatch?: number;
+    /** Bake the current pose of models with animation clips. Playing them later requires materialization. */
+    freezeAnimations?: boolean;
+}
+export interface EditableGeometryBatchStats {
+    instances: number;
+    sourceMeshes: number;
+    batches: number;
+    drawCallsSaved: number;
+    vertices: number;
+    indices: number;
+    unsupportedInstances: number;
+    unsupportedByReason: Record<string, number>;
+}
+export interface EditableGeometryBatchSource<TInstance extends InstanceObject = InstanceObject> {
+    key: string;
+    template: Model;
+    instances: TInstance[];
+}
+export interface UnsupportedEditableGeometryBatch<TInstance extends InstanceObject = InstanceObject> extends EditableGeometryBatchSource<TInstance> {
+    reasons: string[];
+}
+export interface EditableGeometryBatchBuildResult<TInstance extends InstanceObject = InstanceObject> {
+    stats: EditableGeometryBatchStats;
+    unsupported: UnsupportedEditableGeometryBatch<TInstance>[];
+}
+export type EditableGeometryBatchEventMap<TInstance extends InstanceObject = InstanceObject> = InteractionEventMap & {
+    materialize: {
+        instance: TInstance;
+        object: Object3D;
+    };
+};
+export declare class EditableGeometryBatchLayer<TInstance extends InstanceObject = InstanceObject> extends BaseGroup<EditableGeometryBatchEventMap<TInstance>> {
+    #private;
+    isEditableGeometryBatchLayer: boolean;
+    type: string;
+    readonly options: Required<EditableGeometryBatchOptions>;
+    readonly stats: EditableGeometryBatchStats;
+    constructor(options?: EditableGeometryBatchOptions);
+    addSource(source: EditableGeometryBatchSource<TInstance>): boolean;
+    build(): EditableGeometryBatchBuildResult<TInstance>;
+    materialize(instance: TInstance): Object3D<import("three").Object3DEventMap> | null;
+    dispose(): void;
+}

package/dist/src/batches/ModelInstancedLayer.d.ts

@@ -0,0 +1,42 @@
+import { Object3D } from 'three/webgpu';
+import { BaseGroup } from '../objects';
+import { InstanceObject } from '../instances/InstanceObject';
+export interface InstanceCullingOptions {
+    enabled?: boolean;
+    frustum?: boolean;
+    minScreenRadius?: number;
+}
+export interface ModelInstancedLayerOptions<T extends InstanceObject> {
+    name?: string;
+    instanceKind?: string;
+    getHitUserData?: (instance: T, renderIndex: number) => Record<string, unknown>;
+}
+export declare class ModelInstancedLayer<T extends InstanceObject = InstanceObject> extends BaseGroup {
+    #private;
+    isModelInstancedLayer: boolean;
+    type: string;
+    constructor(options?: ModelInstancedLayerOptions<T>);
+    get instanceKind(): string;
+    getInstances(): T[];
+    getInstanceById(id: string): T | undefined;
+    hasInstance(id: string): boolean;
+    getInstanceCulling(): {
+        enabled: boolean;
+        frustum: boolean;
+        minScreenRadius: number;
+    };
+    setInstanceCulling(options?: InstanceCullingOptions): this;
+    setInstanceVisible(visible: boolean): this;
+    setInstanceColor(color: Parameters<InstanceObject['setInstanceColor']>[0]): this;
+    resetInstanceColor(): this;
+    setInstanceOpacity(opacity: number): this;
+    setInstanceHighlight(color: Parameters<InstanceObject['setInstanceHighlight']>[0], opacity: number, overwrite?: boolean): this;
+    clearInstanceHighlight(): this;
+    reserveBatch(url: string, template: Object3D, capacity: number): boolean;
+    addInstance(url: string, template: Object3D, instance: T): boolean;
+    addInstances(url: string, template: Object3D, instances: T[]): boolean;
+    removeInstance(instanceOrId: T | string): boolean;
+    removeInstances(instancesOrIds: Iterable<T | string> | T | string): number;
+    removeBatch(url: string): boolean;
+    clearBatches(): this;
+}

package/dist/src/batches/index.d.ts

@@ -0,0 +1,2 @@
+export * from './EditableGeometryBatchLayer';
+export * from './ModelInstancedLayer';

package/dist/src/effects/TSLEffects.d.ts

@@ -1,4 +1,26 @@
-import { type ColorRepresentation } from 'three/webgpu';
+import { type ColorRepresentation, type Object3D } from 'three/webgpu';
+import type OutlineNode from 'three/addons/tsl/display/OutlineNode.js';
+import type { OutputNodeEffect } from '../viewers/RenderPipeline';
+export interface TSLOutlineOptions {
+    selectedObjects?: readonly Object3D[];
+    edgeStrength?: number;
+    edgeThickness?: number;
+    edgeGlow?: number;
+    visibleEdgeColor?: ColorRepresentation;
+    hiddenEdgeColor?: ColorRepresentation;
+    downSampleRatio?: number;
+    instanceBoundsProxy?: boolean;
+    instanceBoundsPadding?: number;
+    instanceBoundsMinSize?: number;
+}
+export type TSLOutlineUpdateOptions = Omit<TSLOutlineOptions, 'selectedObjects'>;
+export interface TSLOutlineEffect extends OutputNodeEffect {
+    readonly outlineNode: OutlineNode | null;
+    readonly selectedObjects: readonly Object3D[];
+    setSelectedObjects(objects: readonly Object3D[]): TSLOutlineEffect;
+    update(options: TSLOutlineUpdateOptions): TSLOutlineEffect;
+    dispose(): void;
+}
 export declare class TSLEffects {
     static flow(parameters?: {
         baseColor?: ColorRepresentation;
@@ -21,4 +43,5 @@ export declare class TSLEffects {
         intensity?: number;
         distortion?: number;
     }): import("three/webgpu").Node<"vec3">;
+    static outline(options?: TSLOutlineOptions): TSLOutlineEffect;
 }

package/dist/src/index.d.ts

@@ -6,6 +6,8 @@ export * from './objects';
 export * from './effects';
 export * from './animations';
 export * from './tools';
+export * from './instances';
+export * from './batches';
 export * from './interfaces';
 export * from './types';
 export declare const version: string;

package/dist/src/instances/InstanceObject.d.ts

@@ -0,0 +1,57 @@
+import { Box3, BufferGeometry, Color, Object3D, Sphere, type ColorRepresentation } from 'three/webgpu';
+import { BaseGroup } from '../objects';
+export interface InstanceStyle {
+    color: Color | null;
+    colorMode: number;
+    opacity: number;
+}
+export interface InstanceObjectOptions {
+    boundsName?: string;
+}
+export interface InstanceIdentity {
+    id?: string | null;
+    kind?: string | null;
+    name?: string | null;
+}
+export type InstanceMaterializer = () => Object3D | null;
+export declare const INSTANCE_COLOR_MODE_NONE = 0;
+export declare const INSTANCE_COLOR_MODE_OVERRIDE = 1;
+export declare const INSTANCE_COLOR_MODE_TINT = 2;
+export declare class InstanceObject extends BaseGroup {
+    #private;
+    isInstanceObject: boolean;
+    type: string;
+    instanceId: string;
+    instanceKind: string;
+    instanceName: string;
+    geometry: BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>;
+    boundingBox: Box3 | null;
+    boundingSphere: Sphere | null;
+    constructor(options?: InstanceObjectOptions);
+    setInstanceIdentity(identity: InstanceIdentity): this;
+    setInstanceBounds(bounds: Box3): this;
+    setInstanceRenderObject(object: Object3D | null): this;
+    getInstanceRenderObject(): Object3D<import("three").Object3DEventMap> | null;
+    setInstanceMaterializer(materializer: InstanceMaterializer | null): this;
+    hasInstanceMaterializer(materializer: InstanceMaterializer): boolean;
+    clearInstanceMaterializer(materializer?: InstanceMaterializer): this;
+    materialize(): Object3D<import("three").Object3DEventMap> | null;
+    computeBoundingBox(): void;
+    computeBoundingSphere(): void;
+    getInstanceBoundingBox(target?: Box3, world?: boolean): Box3;
+    setInstanceVisible(visible: boolean): this;
+    setInstanceColor(color: ColorRepresentation): this;
+    resetInstanceColor(): this;
+    setInstanceOpacity(opacity: number): this;
+    getInstanceColor(target?: Color): Color;
+    hasInstanceColor(): boolean;
+    getInstanceOpacity(): number;
+    setInstanceHighlight(color: ColorRepresentation, opacity: number, overwrite?: boolean): this;
+    clearInstanceHighlight(): this;
+    getInstanceColorMode(): number;
+    onInstanceRenderDirty(callback: () => void): () => boolean;
+    markInstanceRenderDirty(): this;
+    updateMatrixWorld(force?: boolean): void;
+    updateWorldMatrix(updateParents: boolean, updateChildren: boolean): void;
+}
+export declare function isInstanceObject(object: Object3D): object is InstanceObject;

package/dist/src/instances/index.d.ts

@@ -0,0 +1 @@
+export * from './InstanceObject';

package/dist/src/interactions/MeshBVHRaycast.d.ts

@@ -0,0 +1,9 @@
+import { type BufferGeometry, type Object3D } from 'three/webgpu';
+import { type GeometryBVH } from 'three-mesh-bvh';
+export declare function getGeometryBoundsTree(geometry: BufferGeometry): GeometryBVH | null;
+/**
+ * Installs lazy, per-mesh BVH raycasting without mutating Three.js prototypes.
+ * BVHs are shared by geometry and are built only after the ray hits a mesh's
+ * world-space bounding sphere.
+ */
+export declare function enableMeshBVHRaycast(root: Object3D): Object3D<import("three").Object3DEventMap>;

package/dist/src/interactions/index.d.ts

@@ -1,3 +1,4 @@
 export * from './InteractionEvent';
 export * from './InteractionManager';
+export { enableMeshBVHRaycast, getGeometryBoundsTree } from './MeshBVHRaycast';
 export * from './Selection';

package/dist/src/viewers/RenderPipeline.d.ts

@@ -12,6 +12,40 @@ export interface SSGIConfig {
     radius?: number;
     thickness?: number;
 }
+export interface SSRTemporalReprojectConfig {
+    maxFrames?: number;
+    clampIntensity?: number;
+    flickerSuppression?: number;
+    hitPointReprojection?: boolean;
+}
+export interface SSRDenoiseConfig {
+    lumaPhi?: number;
+    depthPhi?: number;
+    normalPhi?: number;
+    roughnessPhi?: number;
+    radius?: number;
+    alphaPhi?: number;
+    strength?: number;
+    adapt?: number;
+    smoothDisocclusions?: boolean;
+    flickerSuppression?: number;
+    adaptiveTrust?: number;
+}
+export interface SSRConfig {
+    resolutionScale?: number;
+    quality?: number;
+    mirrorBias?: number;
+    maxDistance?: number;
+    intensity?: number;
+    thickness?: number;
+    maxLuminance?: number;
+    stepExponent?: number;
+    binaryRefine?: boolean;
+    screenEdgeFade?: number;
+    screenEdgeFadeBlack?: boolean;
+    temporal?: SSRTemporalReprojectConfig;
+    denoise?: SSRDenoiseConfig;
+}
 export type ColorOutputNode = Node<'vec4'>;
 export type OutputNodeComposer = (scenePass: PassNode) => ColorOutputNode;
 export type OutputNodeEffect = ((scenePass: PassNode, inputNode: ColorOutputNode) => ColorOutputNode) & {
@@ -46,6 +80,9 @@ export declare class RenderPipeline extends RenderPipelineBase {
     enableSSGI(config?: SSGIConfig): void;
     disableSSGI(): void;
     updateSSGI(config: Partial<SSGIConfig>): void;
+    enableSSR(config?: SSRConfig): void;
+    disableSSR(): void;
+    updateSSR(config: SSRConfig): void;
     enableTRAA(): void;
     disableTRAA(): void;
     render(): void;

package/dist/src/viewers/ReversedDepthSSGICompat.d.ts

@@ -0,0 +1,10 @@
+import type { Node, PerspectiveCamera } from 'three/webgpu';
+import SSGINode from 'three/addons/tsl/display/SSGINode.js';
+type SetupBuilder = Parameters<SSGINode['setup']>[0] & {
+    getSharedContext: () => unknown;
+};
+export declare class ReversedDepthSSGINode extends SSGINode {
+    setup(builder: SetupBuilder): Node<unknown> | null | undefined;
+}
+export declare const reversedDepthSSGI: (beautyNode: Node<"vec4">, depthNode: Node, normalNode: Node, camera: PerspectiveCamera) => SSGINode;
+export {};

package/dist/src/viewers/ReversedDepthSSRCompat.d.ts

@@ -0,0 +1,20 @@
+import type { Camera, Node, TextureNode } from 'three/webgpu';
+import RecurrentDenoiseNode, { type RecurrentDenoiseNodeOptions } from 'three/addons/tsl/display/RecurrentDenoiseNode.js';
+import SSRNode, { type SSRNodeOptions } from 'three/addons/tsl/display/SSRNode.js';
+import TemporalReprojectNode, { type TemporalReprojectNodeOptions } from 'three/addons/tsl/display/TemporalReprojectNode.js';
+type SetupBuilder = Parameters<SSRNode['setup']>[0] & {
+    getSharedContext: () => unknown;
+};
+export declare class ReversedDepthSSRNode extends SSRNode {
+    setup(builder: SetupBuilder): Node<unknown> | null | undefined;
+}
+export declare class ReversedDepthTemporalReprojectNode extends TemporalReprojectNode {
+    setup(builder: SetupBuilder): Node<unknown> | null | undefined;
+}
+export declare class ReversedDepthRecurrentDenoiseNode extends RecurrentDenoiseNode {
+    setup(builder: SetupBuilder): Node<unknown> | null | undefined;
+}
+export declare const reversedDepthSSR: (colorNode: Node<"vec4">, depthNode: Node<"float"> | Node<"vec4">, normalNode: Node<"vec3">, options?: SSRNodeOptions) => SSRNode;
+export declare const reversedDepthTemporalReproject: (beautyNode: Node<"vec4">, depthNode: TextureNode, normalNode: TextureNode, velocityNode: TextureNode, camera: Camera, options?: TemporalReprojectNodeOptions) => TemporalReprojectNode;
+export declare const reversedDepthRecurrentDenoise: (inputTexture: Node<"vec4">, camera: Camera, options?: RecurrentDenoiseNodeOptions) => RecurrentDenoiseNode;
+export {};

package/dist/src/viewers/Viewer.d.ts

@@ -11,6 +11,7 @@ type ViewerRendererOptions = ConstructorParameters<typeof WebGPURenderer>['0'];
 export interface ViewerOptions {
     el: HTMLElement;
     rendererOptions?: ViewerRendererOptions;
+    pixelRatio?: number;
 }
 export interface ScreenshotOptions {
     width?: number;
@@ -64,11 +65,12 @@ declare class Viewer extends EventDispatcher<ViewerEventMap> {
     cssRenderer: CSSRenderer;
     frameCount: number;
     frameloop: 'always' | 'demand';
-    constructor({ el, rendererOptions }: ViewerOptions);
+    constructor({ el, rendererOptions, pixelRatio }: ViewerOptions);
     onWindowResize: () => void;
     init(): Promise<void>;
     setCamera(camera: PerspectiveCamera | OrthographicCamera): void;
     setCameraByType(type: 'perspective' | 'orthographic'): void;
+    invalidate(frame?: number): void;
     render(frame?: number): Promise<void>;
     private animate;
     private _initRenderer;

package/dist/src/viewers/renderInvalidation.d.ts

@@ -0,0 +1,2 @@
+declare function coalesceRenderFrames(pendingFrames: number, requestedFrames?: number): number;
+export { coalesceRenderFrames };

package/dist/src/worker/FrameTimingWindow.d.ts

@@ -0,0 +1,16 @@
+import type { WorkerFrameTimingStats } from './protocol';
+export interface FrameTimingWindowOptions {
+    windowMs?: number;
+    idleResetMs?: number;
+    missedFrameThresholdMs?: number;
+}
+export declare class FrameTimingWindow {
+    #private;
+    readonly windowMs: number;
+    readonly idleResetMs: number;
+    readonly missedFrameThresholdMs: number;
+    constructor(options?: FrameTimingWindowOptions);
+    add(duration: number, now?: number): WorkerFrameTimingStats;
+    snapshot(now?: number): WorkerFrameTimingStats;
+    reset(): void;
+}

package/dist/src/worker/OffscreenViewerHost.d.ts

@@ -0,0 +1,20 @@
+import type { SerializedDomEvent } from './protocol';
+export interface OffscreenViewerHostOptions {
+    el: HTMLElement;
+    worker: Worker;
+    canvas?: HTMLCanvasElement;
+    pixelRatio?: number;
+    terminateWorkerOnDispose?: boolean;
+}
+export declare function serializeDomEvent(event: Event): SerializedDomEvent;
+export declare class OffscreenViewerHost extends EventTarget {
+    #private;
+    readonly el: HTMLElement;
+    readonly worker: Worker;
+    readonly canvas: HTMLCanvasElement;
+    constructor(options: OffscreenViewerHostOptions);
+    static isSupported(): boolean;
+    init(): Promise<void>;
+    request<T = unknown>(command: string, payload?: unknown): Promise<T>;
+    dispose(): void;
+}

package/dist/src/worker/WorkerDomTarget.d.ts

@@ -0,0 +1,44 @@
+import type { SerializedDomEvent, WorkerCanvasSize } from './protocol';
+export type WorkerDomTarget = OffscreenCanvas & HTMLElement;
+declare class WorkerDomEvent {
+    readonly type: string;
+    readonly timeStamp: number;
+    readonly target: WorkerDomTarget;
+    readonly currentTarget: WorkerDomTarget;
+    readonly cancelable = true;
+    readonly bubbles = true;
+    defaultPrevented: boolean;
+    cancelBubble: boolean;
+    immediatePropagationStopped: boolean;
+    pointerId: number;
+    pointerType: string;
+    button: number;
+    buttons: number;
+    altKey: boolean;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    shiftKey: boolean;
+    movementX: number;
+    movementY: number;
+    clientX: number;
+    clientY: number;
+    offsetX: number;
+    offsetY: number;
+    pageX: number;
+    pageY: number;
+    screenX: number;
+    screenY: number;
+    deltaX: number;
+    deltaY: number;
+    deltaZ: number;
+    deltaMode: number;
+    constructor(data: SerializedDomEvent, target: WorkerDomTarget);
+    preventDefault(): void;
+    stopPropagation(): void;
+    stopImmediatePropagation(): void;
+    composedPath(): WorkerDomTarget[];
+}
+export declare function createWorkerDomTarget(canvas: OffscreenCanvas, initialSize: WorkerCanvasSize): WorkerDomTarget;
+export declare function resizeWorkerDomTarget(target: WorkerDomTarget, size: WorkerCanvasSize): void;
+export declare function dispatchWorkerDomEvent(target: WorkerDomTarget, data: SerializedDomEvent): WorkerDomEvent;
+export {};