ice3 0.1.1 → 0.2.1

package/dist/_types/renderer/WebGPUInstanceCache.d.ts

@@ -0,0 +1,24 @@
+import type { ICEInstanceBatch } from './InstanceBatch.js';
+export interface WebGPUInstanceEntry {
+    readonly matrixBuffer: GPUBuffer;
+    readonly semanticBuffer: GPUBuffer;
+    instanceCount: number;
+    readonly bytes: number;
+    readonly generation: number;
+}
+export declare class WebGPUInstanceCache {
+    private readonly device;
+    private readonly entries;
+    private active;
+    private bufferGeneration;
+    constructor(device: GPUDevice);
+    retain(batch: ICEInstanceBatch): WebGPUInstanceEntry;
+    beginFrame(): void;
+    endFrame(): void;
+    clear(): void;
+    dispose(): void;
+    get totalBytes(): number;
+    get generation(): number;
+    private deleteEntry;
+}
+//# sourceMappingURL=WebGPUInstanceCache.d.ts.map

package/dist/_types/renderer/WebGPUInstanceStorage.d.ts

@@ -0,0 +1,39 @@
+import type { ICEGeometry } from '../core/index.js';
+import type { ICEInstanceBatch } from './InstanceBatch.js';
+export declare const INSTANCE_RECORD_BYTES = 96;
+export type ICEInstanceStoragePagePlan = Readonly<{
+    firstInstance: number;
+    instanceCount: number;
+}>;
+export type ICEInstanceStoragePage = ICEInstanceStoragePagePlan & {
+    readonly buffer: GPUBuffer;
+};
+export type ICEInstanceStorageEntry = Readonly<{
+    pages: readonly ICEInstanceStoragePage[];
+    generation: number;
+    bytes: number;
+}>;
+export type WebGPUInstanceStorageOptions = {
+    readonly maxBindingBytes: number;
+    readonly minOffsetAlignment: number;
+};
+export declare class WebGPUInstanceStorage {
+    private readonly device;
+    private readonly entries;
+    private active;
+    private resourceGeneration;
+    private uploadBytes;
+    private readonly maxBindingBytes;
+    private readonly minOffsetAlignment;
+    constructor(device: GPUDevice, options?: Partial<WebGPUInstanceStorageOptions>);
+    plan(instanceCount: number, recordBytes?: number): readonly ICEInstanceStoragePagePlan[];
+    retain(batch: ICEInstanceBatch, geometry: ICEGeometry): ICEInstanceStorageEntry;
+    beginFrame(): void;
+    endFrame(): void;
+    get generation(): number;
+    get totalBytes(): number;
+    get totalUploadBytes(): number;
+    dispose(): void;
+    private delete;
+}
+//# sourceMappingURL=WebGPUInstanceStorage.d.ts.map

package/dist/_types/renderer/WebGPUPicker.d.ts

@@ -0,0 +1,30 @@
+import { WebGPUGeometryCache } from './WebGPUGeometryCache.js';
+import type { ICEFrame, ICEScreenPoint } from './types.js';
+type ICEPickFrame = ICEFrame & {
+    readonly point: ICEScreenPoint;
+};
+export declare class WebGPUPicker {
+    private readonly device;
+    private readonly pipelinePromise;
+    private readonly instanceCache;
+    private readonly identityInstances;
+    private readonly zeroSemantics;
+    private readonly renderPlan;
+    private target;
+    private depth;
+    private uniformBuffer;
+    private width;
+    private height;
+    private disposed;
+    constructor(device: GPUDevice, format: GPUTextureFormat);
+    pick(frame: ICEPickFrame, geometryCache: WebGPUGeometryCache, pickIds: Readonly<Record<number, string>>): Promise<string | undefined>;
+    resize(width: number, height: number): void;
+    dispose(): void;
+    private ensureTarget;
+    private ensureUniformBuffer;
+    private uniformBufferCapacity;
+    private uniformBufferDraws;
+}
+export declare function collectWebGPUPickIds(frame: ICEFrame): Readonly<Record<number, string>>;
+export {};
+//# sourceMappingURL=WebGPUPicker.d.ts.map

package/dist/_types/renderer/WebGPUProbe.d.ts

@@ -0,0 +1,21 @@
+export type ICEWebGPUProbeFailureReason = 'document-unavailable' | 'api-unavailable' | 'adapter-unavailable' | 'adapter-timeout' | 'feature-missing' | 'limit-too-low' | 'device-failed' | 'context-failed' | 'pipeline-failed' | 'device-lost';
+export type ICEWebGPUProbeResult = {
+    readonly supported: true;
+    readonly adapter: GPUAdapter;
+    readonly device: GPUDevice;
+    readonly format: GPUTextureFormat;
+    readonly enabledFeatures: ReadonlySet<GPUFeatureName>;
+    readonly release: () => void;
+} | {
+    readonly supported: false;
+    readonly reason: ICEWebGPUProbeFailureReason;
+    readonly detail?: string;
+};
+export type ICEWebGPUProbeOptions = {
+    readonly gpu?: GPU;
+    readonly timeoutMs?: number;
+    readonly createCanvas?: () => OffscreenCanvas | HTMLCanvasElement;
+    readonly optionalFeatures?: readonly GPUFeatureName[];
+};
+export declare function probeWebGPU(options?: ICEWebGPUProbeOptions): Promise<ICEWebGPUProbeResult>;
+//# sourceMappingURL=WebGPUProbe.d.ts.map

package/dist/_types/renderer/WebGPURenderPipeline.d.ts

@@ -0,0 +1,22 @@
+export declare const WEBGPU_UNIFORM_STRIDE = 256;
+export declare const WEBGPU_UNIFORM_BYTES = 144;
+export declare class WebGPURenderPipeline {
+    readonly device: GPUDevice;
+    readonly format: GPUTextureFormat;
+    readonly bindGroupLayout: GPUBindGroupLayout;
+    readonly pipelineLayout: GPUPipelineLayout;
+    readonly triangle: GPURenderPipeline;
+    readonly line: GPURenderPipeline;
+    readonly selectionTriangle: GPURenderPipeline;
+    readonly selectionLine: GPURenderPipeline;
+    readonly selectionMask: boolean;
+    readonly storageInstances: boolean;
+    readonly indirectInstances: boolean;
+    private constructor();
+    static create(device: GPUDevice, format: GPUTextureFormat, options?: {
+        readonly selectionMask?: boolean;
+        readonly storageInstances?: boolean;
+        readonly indirectInstances?: boolean;
+    }): Promise<WebGPURenderPipeline>;
+}
+//# sourceMappingURL=WebGPURenderPipeline.d.ts.map

package/dist/_types/renderer/WebGPURenderPlan.d.ts

@@ -0,0 +1,23 @@
+import type { ICEScene } from '../core/index.js';
+import { type ICEGeometryRenderable } from './Renderables.js';
+import { type ICEInstanceBatch } from './InstanceBatch.js';
+import { type ICERenderBatchDraw } from './RenderBatch.js';
+export type WebGPURenderPlan = Readonly<{
+    scene: ICEScene;
+    revision: number;
+    renderables: readonly ICEGeometryRenderable[];
+    instances: readonly ICEInstanceBatch[];
+    batches: readonly ICERenderBatchDraw[];
+    instancedMeshIds: ReadonlySet<string>;
+}>;
+export declare class WebGPURenderPlanCache {
+    private scene;
+    private current;
+    private readonly renderablesScratch;
+    private readonly instancesScratch;
+    private readonly batchesScratch;
+    get(scene: ICEScene): WebGPURenderPlan;
+    invalidate(): void;
+    dispose(): void;
+}
+//# sourceMappingURL=WebGPURenderPlan.d.ts.map

package/dist/_types/renderer/WebGPURendererBackend.d.ts

@@ -0,0 +1,113 @@
+import { ICEEngineError, type ICEGeometry } from '../core/index.js';
+import type { ICERendererBackend, ICERendererCapabilities, ICEFrame, ICEViewport } from './types.js';
+import { type ICEFrameStageProfile } from './RendererProfiler.js';
+import { type ICEWebGPUOptimizationStats } from './WebGPUCapabilities.js';
+import type { ICEScreenPoint } from './types.js';
+export type WebGPUDeviceContext = Readonly<{
+    adapter: GPUAdapter;
+    device: GPUDevice;
+    format: GPUTextureFormat;
+    release?: () => void;
+}>;
+export type WebGPURendererBackendOptions = Readonly<{
+    readonly forceStoragePath?: boolean;
+    readonly forceGpuDriven?: boolean;
+}>;
+export declare class WebGPURendererBackend implements ICERendererBackend {
+    capabilities: Readonly<ICERendererCapabilities>;
+    private readonly adapter;
+    private device;
+    private readonly format;
+    private pipeline;
+    private storagePipeline;
+    private gpuDrivenPipeline;
+    private visibilityEncoder;
+    private storageCache;
+    private readonly acceleration;
+    private readonly forceStoragePath;
+    private readonly forceGpuDriven;
+    private readonly releaseProbe;
+    private onContextLost;
+    private onContextRestored;
+    private onError;
+    private disposing;
+    private canvas;
+    private context;
+    private geometryCache;
+    private instanceCache;
+    private picker;
+    private selectionMaskBuffer;
+    private timestampProfiler;
+    private timestampProfilingEnabled;
+    private bundleCache;
+    private bundleActive;
+    private frameBindGroup;
+    private frameBindGroupKey;
+    private readonly storageBindGroups;
+    private uniformBufferGeneration;
+    private readonly optimizationWarnings;
+    private identityInstances;
+    private zeroSemantics;
+    private uniformBuffer;
+    private depthTexture;
+    private uniformCapacity;
+    private viewport;
+    private dpr;
+    private backgroundRgba;
+    private frameStats;
+    private lastFrame;
+    private captureRequest;
+    private readonly renderPlan;
+    private readonly drawListScratch;
+    private readonly selected;
+    private readonly drawStorage;
+    private readonly lastVisibilityEntries;
+    private readonly mvpScratch;
+    private readonly worldScratch;
+    private readonly profiler;
+    private lastFrameProfile;
+    private optimizationFailureReason;
+    private storageFailureReason;
+    private visibilityFailureReason;
+    private constructor();
+    static create(context: WebGPUDeviceContext, options?: WebGPURendererBackendOptions): Promise<WebGPURendererBackend>;
+    initialize(options: {
+        readonly canvas: HTMLCanvasElement;
+        readonly onContextLost?: () => void;
+        readonly onContextRestored?: () => void;
+        readonly onError?: (error: ICEEngineError) => void;
+    }): void;
+    resize(viewport: ICEViewport, dpr: number): void;
+    setBackgroundColor(color: string): void;
+    prepareBatchGeometry(geometry: ICEGeometry): void;
+    prepareGeometry(geometry: ICEGeometry, update?: import('../core/index.js').ICEGeometryBufferUpdate): void;
+    releaseGeometry(geometry: ICEGeometry): void;
+    releaseBatchGeometry(geometry: ICEGeometry): void;
+    render(frame: ICEFrame): void;
+    enableProfiling(enabled: boolean): void;
+    get frameProfile(): ICEFrameStageProfile | null;
+    pick(frame: ICEFrame, point: ICEScreenPoint): Promise<string | undefined>;
+    dispose(): void;
+    capture(): Promise<Blob>;
+    finish(): Promise<void>;
+    drainGpuTimings(): Promise<readonly number[]>;
+    enableTimestampProfiling(enabled: boolean): void;
+    get timestampProfilingAvailable(): boolean;
+    get timestampProfilingUnavailableReason(): string | undefined;
+    get stats(): Readonly<typeof this.frameStats>;
+    readVisibilityStats(): Promise<Readonly<{
+        visibleInstances: number;
+        culledInstances: number;
+        dispatchCount: number;
+    }> | undefined>;
+    get storageActive(): boolean;
+    private get gpuDrivenActive();
+    get optimizationStats(): ICEWebGPUOptimizationStats;
+    private storageBindGroupFor;
+    private reportOptimizationFailure;
+    private requireGeometryCache;
+    private ensureUniformCapacity;
+    private watchDevice;
+    private recoverDevice;
+}
+//# sourceMappingURL=WebGPURendererBackend.d.ts.map

package/dist/_types/renderer/WebGPUResources.d.ts

@@ -0,0 +1,9 @@
+export declare const WEBGPU_BUFFER_USAGE: {
+    readonly vertex: number;
+    readonly index: number;
+};
+export declare function alignToFourBytes(value: number): number;
+export declare function createGPUDataBuffer(device: GPUDevice, data: ArrayBufferView, usage: GPUBufferUsageFlags, label: string): GPUBuffer;
+export declare function createEmptyGPUDataBuffer(device: GPUDevice, byteLength: number, usage: GPUBufferUsageFlags, label: string): GPUBuffer;
+export declare function writeGPUData(device: GPUDevice, buffer: GPUBuffer, data: ArrayBufferView): void;
+//# sourceMappingURL=WebGPUResources.d.ts.map

package/dist/_types/renderer/WebGPUSelectionMask.d.ts

@@ -0,0 +1,18 @@
+export type ICESelectionMaskLayout = Readonly<{
+    words: Uint32Array;
+    bases: readonly number[];
+}>;
+export declare function buildSelectionMask(ranges: readonly (readonly string[])[], selection: readonly string[]): ICESelectionMaskLayout;
+export declare class WebGPUSelectionMaskBuffer {
+    private readonly device;
+    private maskBuffer;
+    private previous;
+    private maskGeneration;
+    constructor(device: GPUDevice);
+    get buffer(): GPUBuffer | null;
+    get generation(): number;
+    get totalBytes(): number;
+    update(words: Uint32Array): void;
+    dispose(): void;
+}
+//# sourceMappingURL=WebGPUSelectionMask.d.ts.map

package/dist/_types/renderer/WebGPUTimestampProfiler.d.ts

@@ -0,0 +1,16 @@
+export declare class WebGPUTimestampProfiler {
+    private readonly device;
+    private readonly slots;
+    private readonly pending;
+    private reason;
+    private disposed;
+    constructor(device: GPUDevice, slotCount?: number);
+    get unavailableReason(): string | undefined;
+    querySetFor(frameId: number): GPUQuerySet;
+    resolveFrame(encoder: GPUCommandEncoder, frameId: number): void;
+    drain(): Promise<readonly number[]>;
+    dispose(): void;
+    private slotFor;
+    private slotIndex;
+}
+//# sourceMappingURL=WebGPUTimestampProfiler.d.ts.map

package/dist/_types/renderer/WebGPUVisibility.d.ts

@@ -0,0 +1,27 @@
+import type { ICEGeometryBounds } from '../core/index.js';
+import type { ICEInstanceStoragePage } from './WebGPUInstanceStorage.js';
+export declare function createIndirectArguments(indexCount: number, firstIndex: number, baseVertex: number): Uint32Array | undefined;
+export declare function isAabbVisible(matrix: ArrayLike<number>, bounds: ICEGeometryBounds, viewProjection: ArrayLike<number>): boolean;
+export type ICEVisibilityEntry = Readonly<{
+    readonly visibleBuffer: GPUBuffer;
+    readonly indirectBuffer: GPUBuffer;
+    readonly instanceCount: number;
+}>;
+export declare class WebGPUVisibilityEncoder {
+    private readonly device;
+    readonly bindGroupLayout: GPUBindGroupLayout;
+    readonly pipeline: GPUComputePipeline;
+    private readonly entries;
+    private constructor();
+    static create(device: GPUDevice): Promise<WebGPUVisibilityEncoder>;
+    retain(page: ICEInstanceStoragePage, indexCount: number): ICEVisibilityEntry;
+    encode(encoder: GPUCommandEncoder, entry: ICEVisibilityEntry, page: ICEInstanceStoragePage, uniformBuffer: GPUBuffer, uniformOffset: number): void;
+    readStats(entry: ICEVisibilityEntry, page: ICEInstanceStoragePage): Promise<Readonly<{
+        visibleInstances: number;
+        culledInstances: number;
+        dispatchCount: number;
+    }>>;
+    dispose(): void;
+    private destroy;
+}
+//# sourceMappingURL=WebGPUVisibility.d.ts.map

package/dist/_types/renderer/index.d.ts

@@ -1,12 +1,26 @@
 export { FakeRendererBackend } from './FakeRendererBackend.js';
 export { WebGL2RendererBackend, colorToRgba, } from './WebGL2RendererBackend.js';
-export { collectRenderables } from './WebGL2GeometryBatch.js';
-export type { ICEGeometryRenderable } from './WebGL2GeometryBatch.js';
-export { collectInstanceBatches } from './WebGL2InstanceBatch.js';
-export type { ICEInstanceBatch } from './WebGL2InstanceBatch.js';
+export { selectDefaultRendererBackend, selectRendererBackend, type ICERendererBackendSelection, type ICERendererFactories, } from './RendererSelection.js';
+export { WebGPURendererBackend, type WebGPUDeviceContext, } from './WebGPURendererBackend.js';
+export { probeWebGPU } from './WebGPUProbe.js';
+export type { ICEWebGPUProbeFailureReason, ICEWebGPUProbeOptions, ICEWebGPUProbeResult, } from './WebGPUProbe.js';
+export { WebGPUGeometryCache, type WebGPUGeometryCacheOptions, type WebGPUGeometryEntry, } from './WebGPUGeometryCache.js';
+export { WebGPUInstanceCache, type WebGPUInstanceEntry, } from './WebGPUInstanceCache.js';
+export { WebGPUDrawStorage, type ICEWebGPUDrawUniform, } from './WebGPUDrawStorage.js';
+export { WebGPURenderPlanCache, type WebGPURenderPlan, } from './WebGPURenderPlan.js';
+export { detectWebGPUAcceleration, WEBGPU_GPU_DRIVEN_DEFAULT, WEBGPU_INSTANCE_VISIBILITY_THRESHOLD, WEBGPU_STORAGE_DEFAULT, type ICEWebGPUAcceleration, type ICEWebGPUAccelerationTier, type ICEWebGPUOptimizationStats, } from './WebGPUCapabilities.js';
+export { INSTANCE_RECORD_BYTES, WebGPUInstanceStorage, type ICEInstanceStorageEntry, type ICEInstanceStoragePage, type ICEInstanceStoragePagePlan, type WebGPUInstanceStorageOptions, } from './WebGPUInstanceStorage.js';
+export { createIndirectArguments, isAabbVisible, WebGPUVisibilityEncoder, type ICEVisibilityEntry, } from './WebGPUVisibility.js';
+export { WebGPUBundleCache } from './WebGPUBundleCache.js';
+export { buildSelectionMask, WebGPUSelectionMaskBuffer, type ICESelectionMaskLayout, } from './WebGPUSelectionMask.js';
+export { collectWebGPUPickIds, WebGPUPicker, } from './WebGPUPicker.js';
+export { collectRenderables, selectionIdentity, type ICEGeometryRenderable, } from './Renderables.js';
+export { collectInstanceBatches, type ICEInstanceBatch, } from './InstanceBatch.js';
 export { queueBatchGeneration } from './ICEWebGL2BatchGenerationUploader.js';
+export type { ICEFrameStageProfile, } from './RendererProfiler.js';
+export { RendererProfiler, } from './RendererProfiler.js';
+export { WebGPUTimestampProfiler } from './WebGPUTimestampProfiler.js';
 export type { ICEBatchGenerationHandle, ICEBatchUploadBuffer, ICEBatchUploadOptions, } from './ICEWebGL2BatchGenerationUploader.js';
-export { collectRenderBatches } from './WebGL2RenderBatch.js';
-export type { ICERenderBatchDraw, ICERenderBatchNode, } from './WebGL2RenderBatch.js';
-export type { ICERendererBackend, ICERendererCapabilities, ICERendererStats, ICEFrame, ICEScreenPoint, ICEViewport, } from './types.js';
+export { collectRenderBatches, semanticSelectionId, type ICERenderBatchDraw, type ICERenderBatchNode, } from './RenderBatch.js';
+export type { ICERendererBackend, ICERendererCapabilities, ICERendererStats, ICEFrame, ICEScreenPoint, ICEViewport, ICE3RendererPreference, ICE3RendererSelection, ICEWebGPUOptimizationFailureReason, } from './types.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/_types/renderer/types.d.ts

@@ -1,10 +1,20 @@
-import type { ICEGeometry, ICEPerspectiveCamera, ICEScene } from '../core/index.js';
+import type { ICEGeometry, ICEGeometryBufferUpdate, ICEEngineError, ICEPerspectiveCamera, ICEScene } from '../core/index.js';
 export type ICEViewport = {
     readonly x: number;
     readonly y: number;
     readonly width: number;
     readonly height: number;
 };
+export type ICEWebGPUOptimizationFailureReason = 'limit-too-low' | 'pipeline-failed' | 'resource-failed' | 'runtime-failed' | 'threshold-not-met';
+export type ICE3RendererPreference = 'auto' | 'webgpu' | 'webgl2';
+export type ICE3RendererSelection = Readonly<{
+    requested: ICE3RendererPreference | 'custom';
+    selected: 'webgl2' | 'webgpu' | 'fake';
+    fallback: boolean;
+    experimental: boolean;
+    probeDurationMs?: number;
+    fallbackReason?: import('./WebGPUProbe.js').ICEWebGPUProbeFailureReason;
+}>;
 export type ICEScreenPoint = Readonly<{
     x: number;
     y: number;
@@ -18,7 +28,7 @@ export type ICEFrame = {
     readonly selection: readonly string[];
 };
 export interface ICERendererCapabilities {
-    readonly backend: 'webgl2' | 'fake';
+    readonly backend: 'webgl2' | 'webgpu' | 'fake';
     readonly maxTextureSize: number;
     readonly picking: boolean;
 }
@@ -38,13 +48,17 @@ export interface ICERendererBackend {
         readonly canvas: HTMLCanvasElement;
         readonly onContextLost?: () => void;
         readonly onContextRestored?: () => void;
+        readonly onError?: (error: ICEEngineError) => void;
     }): void;
     resize(viewport: ICEViewport, dpr: number): void;
     setBackgroundColor?(color: string): void;
     prepareBatchGeometry?(geometry: ICEGeometry): void;
     releaseBatchGeometry?(geometry: ICEGeometry): void;
-    pick?(frame: ICEFrame, point: ICEScreenPoint): string | undefined;
+    prepareGeometry?(geometry: ICEGeometry, update?: ICEGeometryBufferUpdate): void;
+    releaseGeometry?(geometry: ICEGeometry): void;
+    pick?(frame: ICEFrame, point: ICEScreenPoint): Promise<string | undefined>;
     render(frame: ICEFrame): void;
+    finish?(): Promise<void>;
     capture?(): Promise<Blob>;
     dispose(): void;
 }

package/dist/_types/runtime/ICE3.d.ts

@@ -1,5 +1,5 @@
 import { ICEEventDispatcher, ICEPerspectiveCamera, ICEScene, type ICEDiagnostic, type ICEGeometry, type ICENode } from '../core/index.js';
-import { type ICERendererBackend, type ICEScreenPoint, type ICEViewport } from '../renderer/index.js';
+import { type ICE3RendererPreference, type ICE3RendererSelection, type ICERendererBackend, type ICEScreenPoint, type ICEViewport } from '../renderer/index.js';
 import { ICE2DLayer } from './layer/ICE2DLayer.js';
 import { type ICEProjectedPoint } from './ICEProjection.js';
 import { type ICERenderScheduler } from './ICERenderScheduler.js';
@@ -7,6 +7,7 @@ import type { ICEVector3Tuple } from '../core/index.js';
 import { type ICERay, type ICESceneItem, type ICESceneQuery } from './query/ICESceneQuery.js';
 export type ICE3Options = {
     readonly backend?: ICERendererBackend;
+    readonly renderer?: ICE3RendererPreference;
     readonly scheduler?: ICERenderScheduler;
 };
 export type ICEEngineDiagnostics = {
@@ -14,10 +15,11 @@ export type ICEEngineDiagnostics = {
     readonly fps: number;
     readonly cpuFrameTimeMs: number;
     readonly backend: Readonly<{
-        backend: 'webgl2' | 'fake';
+        backend: 'webgl2' | 'webgpu' | 'fake';
         maxTextureSize: number;
         picking: boolean;
     }>;
+    readonly rendererSelection: Readonly<ICE3RendererSelection>;
     readonly nodeCount: number;
     readonly layerCount: number;
     readonly labelCount: number;
@@ -53,7 +55,9 @@ export type ICEEngineDiagnostics = {
     readonly lastDiagnostic?: Readonly<ICEDiagnostic>;
 };
 export declare class ICE3 extends ICEEventDispatcher {
-    private readonly backend;
+    private backend;
+    private readonly rendererPreference;
+    private rendererSelection;
     private readonly scheduler;
     private readonly interaction;
     private readonly layers;
@@ -82,15 +86,20 @@ export declare class ICE3 extends ICEEventDispatcher {
     private readonly pointerGestures;
     private lastDiagnostic;
     private instancingFallbackReported;
+    private pickGeneration;
     private readonly removeInputListeners;
     private readonly handleWindowResize;
     constructor(options?: ICE3Options);
     init(target: string | HTMLElement): this;
+    initAsync(target: string | HTMLElement): Promise<this>;
+    private initializeWithBackend;
     setScene(scene: ICEScene): this;
     setCamera(camera: ICEPerspectiveCamera): this;
     setBackgroundColor(color: string): this;
     prepareRenderBatchGeometry(geometry: ICEGeometry): this;
     releaseRenderBatchGeometry(geometry: ICEGeometry): this;
+    prepareGeometry(geometry: ICEGeometry, update?: import('../core/index.js').ICEGeometryBufferUpdate): this;
+    releaseGeometry(geometry: ICEGeometry): this;
     addLayer(layer: ICE2DLayer): this;
     removeLayer(layer: ICE2DLayer): this;
     start(): this;
@@ -102,10 +111,11 @@ export declare class ICE3 extends ICEEventDispatcher {
     findBySelectionId(selectionId: string): ICENode | undefined;
     raycast(ray: ICERay): ICESceneItem | undefined;
     setSelection(ids: readonly string[]): this;
-    pick(point: ICEScreenPoint): ICENode | undefined;
-    pickItem(point: ICEScreenPoint): {
+    pick(point: ICEScreenPoint): Promise<ICENode | undefined>;
+    pickItem(point: ICEScreenPoint): Promise<{
         readonly item?: ICESceneItem;
-    };
+    }>;
+    capture(): Promise<Blob>;
     getDiagnostics(): Readonly<ICEEngineDiagnostics>;
     destroy(): void;
     resize(): this;

package/dist/_types/runtime/asset/ICEAssetSceneBuilder.d.ts

@@ -1,9 +1,15 @@
-import type { ICEPreparedAssetSnapshot, ICEPreparedStats } from '../../assets/index.js';
-import { ICEScene, type ICEGeometryBounds } from '../../core/index.js';
+import type { ICEPreparedAssetSnapshot, ICEPreparedStats, ICEPreviewGeometryPacket } from '../../assets/index.js';
+import { ICEIndexedGeometry, ICEScene, type ICEGeometryBounds, type ICEGeometryBufferUpdate } from '../../core/index.js';
 export interface ICEBuiltAsset {
     readonly scene: ICEScene;
     readonly bounds: ICEGeometryBounds;
     readonly stats: ICEPreparedStats;
 }
+export interface ICEBuiltPreviewPacket {
+    readonly scene: ICEScene;
+    readonly geometries: ReadonlyMap<string, ICEIndexedGeometry>;
+    readonly geometryUpdates: ReadonlyMap<string, ICEGeometryBufferUpdate>;
+}
 export declare function buildAssetScene(snapshot: ICEPreparedAssetSnapshot): ICEBuiltAsset;
+export declare function buildPreviewPacketScene(packet: ICEPreviewGeometryPacket, previousGeometries?: ReadonlyMap<string, ICEIndexedGeometry>): ICEBuiltPreviewPacket;
 //# sourceMappingURL=ICEAssetSceneBuilder.d.ts.map

package/dist/_types/runtime/asset/ICEPreviewPacketLoader.d.ts

@@ -0,0 +1,25 @@
+import { type ICEPreviewGeometryPacket } from '../../assets/index.js';
+import type { ICEGeometryBufferUpdate, ICEIndexedGeometry, ICEScene } from '../../core/index.js';
+export type ICEPreviewPacketFallbackReason = 'packet-unavailable' | 'packet-invalid' | 'packet-revision-mismatch';
+export type ICEPreviewPacketLoadResult = {
+    readonly kind: 'packet';
+    readonly packet: ICEPreviewGeometryPacket;
+} | {
+    readonly kind: 'fallback';
+    readonly reason: ICEPreviewPacketFallbackReason;
+};
+export interface ICEPreviewPacketLoaderOptions {
+    readonly fetch?: typeof fetch;
+    readonly pinGeometry?: (geometry: ICEIndexedGeometry, update?: ICEGeometryBufferUpdate) => void;
+}
+export declare class ICEPreviewPacketLoader {
+    private readonly fetcher;
+    private readonly pinGeometry;
+    private geometries;
+    private publishedScene;
+    constructor(options?: ICEPreviewPacketLoaderOptions | typeof fetch);
+    get scene(): ICEScene | null;
+    get currentGeometries(): ReadonlyMap<string, ICEIndexedGeometry>;
+    load(url: string, current?: ICEPreviewGeometryPacket): Promise<ICEPreviewPacketLoadResult>;
+}
+//# sourceMappingURL=ICEPreviewPacketLoader.d.ts.map

package/dist/_types/runtime/asset/ICETilesetLoader.d.ts

@@ -154,7 +154,6 @@ export declare class ICETilesetHandle extends ICEEventDispatcher {
     private enterCameraMotion;
     private promoteReadyVisibleTargets;
     private lodReadyVisibleCoverage;
-    private reconcileSelectionVisibility;
     private rejectReadyIfVisibleSetFailed;
     private updateBudgetWarning;
     private residentBudgetReached;

package/dist/_types/runtime/index.d.ts

@@ -25,10 +25,11 @@ export { ICERenderBatch, type ICERenderBatchOptions, } from './asset/ICERenderBa
 export { ICEAssetLoader, type ICEAssetHandle, type ICEAssetLoaderOptions, type ICEAssetLoadOptions, } from './asset/ICEAssetLoader.js';
 export { ICETilesetHandle, ICETilesetLoader, type ICETilesetEvent, type ICETilesetLoaderOptions, type ICETilesetOpenOptions, type ICETilesetStats, type ICETilesetTileState, } from './asset/ICETilesetLoader.js';
 export { ICETilesetScheduler, type ICETilesetSchedulerOptions, type ICETilesetWorkSet, type ICETilesetWorkSetInput, } from './asset/ICETilesetScheduler.js';
+export { ICEPreviewPacketLoader, type ICEPreviewPacketFallbackReason, type ICEPreviewPacketLoadResult, type ICEPreviewPacketLoaderOptions, } from './asset/ICEPreviewPacketLoader.js';
 export { ICELodSelector, type ICELodSelection, type ICELodSelectionInput, } from './asset/ICELodSelector.js';
 export type { ICELodStats } from './asset/ICETilesetLoader.js';
 export { collectSceneItems, raycastSceneNode, type ICERay, type ICESceneItem, type ICESceneQuery, } from './query/ICESceneQuery.js';
-export type { ICEPreparedContract, ICEPreparedStats, } from '../assets/index.js';
+export type { ICEPreparedContract, ICEPreparedStats, ICEPreviewGeometryPacket, } from '../assets/index.js';
 export { ICEAdaptiveRenderBatchController, } from './batching/ICEAdaptiveRenderBatchController.js';
 export type { ICEAdaptiveBatchExecutionResult, ICEAdaptiveBatchRequest, ICEAdaptiveBatchRequestResult, ICERenderBatchingMode, ICERenderBatchingOptions, } from './batching/ICEAdaptiveRenderBatchController.js';
 export { ICERenderBatchPlanner } from './batching/ICERenderBatchPlanner.js';

package/dist/_types/runtime/input/ICEOrbitController.d.ts

@@ -7,6 +7,8 @@ export declare class ICEOrbitController {
     private yaw;
     private pitch;
     private distance;
+    private readonly minDistance;
+    private readonly maxDistance;
     private targetYaw;
     private targetPitch;
     private targetDistance;

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-export { ICEBasicMaterial, ICEBoxGeometry, ICEIndexedGeometry, ICEEngineError, ICEAssetLoader, ICETilesetHandle, ICETilesetLoader, ICELabel, ICEMesh, ICENode, ICEOrbitController, ICEPerspectiveCamera, ICEScene, ICEScreenLayer, ICETypeRegistry, ICEWorldLayer, ICE3, deserializeScene, serializeScene, } from './_types/runtime/index.js';
-export type { ICEDeserializedScene, ICEDiagnostic, ICEDiagnosticSeverity, ICEEngineDiagnostics, ICEInputEvent, ICEInputTarget, ICEKeyboardInputEvent, ICEProjectedPoint, ICEAssetHandle, ICEAssetLoaderOptions, ICEAssetLoadOptions, ICETilesetEvent, ICETilesetLoaderOptions, ICETilesetOpenOptions, ICETilesetStats, ICETilesetTileState, ICEPreparedContract, ICEPreparedStats, ICERenderBatchingOptions, ICESerializedScene, ICEGeometry, ICEGeometryBounds, ICEIndexedGeometryOptions, ICEMatrix4Tuple, ICEPickOutcome, } from './_types/runtime/index.js';
+export { ICEBasicMaterial, ICEBoxGeometry, ICEIndexedGeometry, ICEEngineError, ICEAssetLoader, ICETilesetHandle, ICETilesetLoader, ICELabel, ICEMesh, ICENode, ICEOrbitController, ICEPreviewPacketLoader, ICEPerspectiveCamera, ICEScene, ICEScreenLayer, ICETypeRegistry, ICEWorldLayer, ICE3, collectSceneItems, deserializeScene, serializeScene, } from './_types/runtime/index.js';
+export type { ICEDeserializedScene, ICEDiagnostic, ICEDiagnosticSeverity, ICEEngineDiagnostics, ICE3Options, ICE3RendererPreference, ICE3RendererSelection, ICEInputEvent, ICEInputTarget, ICEKeyboardInputEvent, ICEProjectedPoint, ICEAssetHandle, ICEAssetLoaderOptions, ICEAssetLoadOptions, ICETilesetEvent, ICETilesetLoaderOptions, ICETilesetOpenOptions, ICETilesetStats, ICETilesetTileState, ICEPreparedContract, ICEPreparedStats, ICERenderBatchingOptions, ICESerializedScene, ICEGeometry, ICEGeometryBounds, ICEIndexedGeometryOptions, ICEMatrix4Tuple, ICEPickOutcome, ICEPreviewPacketFallbackReason, ICEPreviewPacketLoadResult, ICEPreviewPacketLoaderOptions, ICEPreviewGeometryPacket, } from './_types/runtime/index.js';
 //# sourceMappingURL=index.d.ts.map