ice3 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,173 @@
+import { ICEEventDispatcher, ICEScene, type ICEGeometryBounds, type ICEPerspectiveCamera } from '../../core/index.js';
+import { type ICETilesetSnapshot } from '../../assets/index.js';
+import type { ICE3 } from '../ICE3.js';
+import { ICETilesetScheduler } from './ICETilesetScheduler.js';
+import { type ICERenderBatchingOptions } from '../batching/ICEAdaptiveRenderBatchController.js';
+export type ICETilesetTileState = 'pending' | 'loading' | 'loaded' | 'failed' | 'evicted';
+export interface ICETilesetStats {
+    readonly total: number;
+    readonly pending: number;
+    readonly loading: number;
+    readonly loaded: number;
+    readonly failed: number;
+    readonly evicted: number;
+    readonly visible: number;
+    readonly resident: number;
+    readonly residentBytes: number;
+    readonly residentContents: number;
+    readonly loadingContents: number;
+    readonly lod: ICELodStats;
+}
+export interface ICELodStats {
+    readonly target: number;
+    readonly resident: number;
+    readonly coarseResident: number;
+    readonly fineResident: number;
+    readonly transitioning: number;
+    readonly fallback: number;
+    readonly maxScreenSpaceErrorPixels: number;
+}
+export interface ICETilesetEvent {
+    readonly stats: ICETilesetStats;
+    readonly tileId?: string;
+}
+export interface ICETilesetLoaderOptions {
+    readonly fetch?: typeof globalThis.fetch;
+    readonly camera: ICEPerspectiveCamera;
+    readonly maxConcurrentTiles?: number;
+    readonly maxResidentTiles?: number;
+    readonly maxResidentBytes?: number;
+    readonly prefetchMarginRatio?: number;
+    readonly unloadMarginRatio?: number;
+    readonly maxCommitsPerFrame?: number;
+    readonly maxScreenSpaceErrorPixels?: number;
+    readonly lodSettleDelayMs?: number;
+    readonly renderBatching?: ICERenderBatchingOptions;
+}
+export interface ICETilesetOpenOptions {
+    readonly signal?: AbortSignal;
+}
+export declare class ICETilesetLoader {
+    private readonly engine;
+    private readonly fetcher;
+    private readonly camera;
+    private readonly maxConcurrentTiles;
+    private readonly maxCommitsPerFrame;
+    private readonly scheduler;
+    private readonly maxScreenSpaceErrorPixels;
+    private readonly lodSettleDelayMs;
+    private readonly renderBatching;
+    constructor(engine: ICE3, options: ICETilesetLoaderOptions);
+    open(url: string, options?: ICETilesetOpenOptions): Promise<ICETilesetHandle>;
+}
+export declare class ICETilesetHandle extends ICEEventDispatcher {
+    private readonly engine;
+    private readonly snapshot;
+    private readonly camera;
+    private readonly scheduler;
+    private readonly maxConcurrentTiles;
+    private readonly maxCommitsPerFrame;
+    private readonly maxScreenSpaceErrorPixels;
+    readonly scene: ICEScene;
+    readonly bounds: ICEGeometryBounds;
+    private readonly states;
+    private readonly tilesById;
+    private readonly resident;
+    private readonly candidates;
+    private readonly activeIds;
+    private readonly prefetchIds;
+    private readonly failedLodFallbacks;
+    private readonly lodAncestorCache;
+    private readonly idleWaiters;
+    private readonly assetLoader;
+    private readonly lodSelector;
+    private readonly abortController;
+    private readonly readyPromise;
+    private readonly lodSettleDelayMs;
+    private requestQueue;
+    private commitQueue;
+    private workSet;
+    private residentBytes;
+    private activeRequests;
+    private resolveReady;
+    private rejectReady;
+    private readySettled;
+    private started;
+    private disposed;
+    private removeCallerAbort;
+    private workSetUpdateScheduled;
+    private workSetDirty;
+    private workSetForce;
+    private lastSignature;
+    private commitScheduled;
+    private budgetWarningActive;
+    private idleEmitted;
+    private lodSelection;
+    private lastLodTarget;
+    private lastLodFallbacks;
+    private cameraMoving;
+    private lodSettleTimer;
+    private motionFallbackId;
+    private readonly adaptiveController;
+    private readonly batchWorkerPool;
+    private readonly adaptivePlanner;
+    private readonly adaptiveUploadBytesPerFrame;
+    private readonly adaptiveMaxExtraGpuBytes;
+    private readonly adaptiveIdleTaskBudgetMs;
+    private adaptiveAbortController;
+    private adaptiveUploadHandle;
+    private adaptiveState;
+    private adaptivePlanningSignature;
+    private readonly renderBatchingMode;
+    private visibleCoverageIds;
+    constructor(engine: ICE3, snapshot: ICETilesetSnapshot, camera: ICEPerspectiveCamera, scheduler: ICETilesetScheduler, fetch: typeof globalThis.fetch, maxConcurrentTiles: number, maxCommitsPerFrame: number, maxScreenSpaceErrorPixels: number, lodSettleDelayMs: number, renderBatching: ICERenderBatchingOptions | undefined, callerSignal?: AbortSignal);
+    get stats(): ICETilesetStats;
+    get adaptiveStats(): Readonly<{
+        mode: ICERenderBatchingOptions['mode'];
+        activeGeneration: number;
+        candidateGeneration?: number;
+        adaptiveBatchCount: number;
+    }>;
+    private lodAncestors;
+    private lodAncestorIds;
+    private lodCoverageId;
+    private lodCoverageIds;
+    private lodNextTiles;
+    private lodUnsettledIds;
+    private recordLodFailure;
+    tileState(tileId: string): ICETilesetTileState | undefined;
+    whenReady(): Promise<void>;
+    whenIdle(): Promise<void>;
+    dispose(): void;
+    start(): void;
+    private readonly handleAfterRender;
+    private requestWorkSetUpdate;
+    private updateWorkSet;
+    private pumpRequests;
+    private loadTile;
+    private scheduleCommit;
+    private commitBatch;
+    private discardCandidate;
+    private discardCandidateRecord;
+    private unloadTile;
+    private hasPendingVisibleTargets;
+    private enterCameraMotion;
+    private promoteReadyVisibleTargets;
+    private lodReadyVisibleCoverage;
+    private reconcileSelectionVisibility;
+    private rejectReadyIfVisibleSetFailed;
+    private updateBudgetWarning;
+    private residentBudgetReached;
+    private residentBudgetExceeded;
+    private canCommitWithinBudget;
+    private enforceResidentBudget;
+    private maybeStartAdaptiveBatch;
+    private executeAdaptiveBatch;
+    private activateAdaptiveScene;
+    private restoreAdaptiveScene;
+    private cancelAdaptiveCandidate;
+    private settleIdleWaiters;
+    private abort;
+    private emit;
+}
+//# sourceMappingURL=ICETilesetLoader.d.ts.map

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

@@ -0,0 +1,34 @@
+import { type ICEGeometryBounds, type ICEPerspectiveCamera } from '../../core/index.js';
+import type { ICETilesetTile } from '../../assets/index.js';
+import type { ICEViewport } from '../../renderer/index.js';
+export interface ICETilesetSchedulerOptions {
+    readonly maxResidentTiles: number;
+    readonly maxResidentBytes: number;
+    readonly prefetchMarginRatio: number;
+    readonly unloadMarginRatio: number;
+}
+export interface ICETilesetWorkSetInput {
+    readonly assetBounds: ICEGeometryBounds;
+    readonly tiles: readonly ICETilesetTile[];
+    readonly camera: ICEPerspectiveCamera;
+    readonly viewport: ICEViewport;
+    readonly residentBytes: ReadonlyMap<string, number>;
+}
+export interface ICETilesetWorkSet {
+    readonly visible: readonly ICETilesetTile[];
+    readonly prefetch: readonly ICETilesetTile[];
+    readonly retainIds: ReadonlySet<string>;
+    readonly ordered: readonly ICETilesetTile[];
+    readonly budgetExceeded: boolean;
+}
+export declare class ICETilesetScheduler {
+    private readonly maxResidentTiles;
+    private readonly maxResidentBytes;
+    private readonly prefetchMarginRatio;
+    private readonly unloadMarginRatio;
+    constructor(options: ICETilesetSchedulerOptions);
+    get residentTileLimit(): number;
+    get residentByteLimit(): number;
+    update(input: ICETilesetWorkSetInput): ICETilesetWorkSet;
+}
+//# sourceMappingURL=ICETilesetScheduler.d.ts.map

package/dist/_types/runtime/batching/ICEAdaptiveRenderBatchController.d.ts

@@ -0,0 +1,59 @@
+import type { ICERenderBatchPlan } from './ICERenderBatchPlan.js';
+export type ICERenderBatchingMode = 'asset' | 'adaptive' | 'off';
+export interface ICERenderBatchingOptions {
+    readonly mode: ICERenderBatchingMode;
+    readonly maxWorkers?: number;
+    readonly idleTaskBudgetMs?: number;
+    readonly uploadBytesPerFrame?: number;
+    readonly maxExtraGpuBytes?: number;
+}
+export interface ICEAdaptiveBatchRequest {
+    readonly cameraMoving: boolean;
+    readonly generation: number;
+    readonly plan: ICERenderBatchPlan;
+}
+export type ICEAdaptiveBatchExecutionResult = {
+    readonly kind: 'completed';
+    readonly estimatedBytes: number;
+} | {
+    readonly kind: 'failed';
+    readonly reason: 'worker' | 'upload';
+    readonly error: unknown;
+};
+export type ICEAdaptiveBatchRequestResult = {
+    readonly kind: 'disabled';
+} | {
+    readonly kind: 'deferred';
+} | {
+    readonly kind: 'started';
+    readonly generation: number;
+} | {
+    readonly kind: 'rejected';
+    readonly reason: 'plan' | 'memory' | 'superseded' | 'busy';
+};
+export interface ICEAdaptiveRenderBatchControllerOptions {
+    readonly mode: ICERenderBatchingMode;
+    readonly activeGeneration: number;
+    readonly maxExtraGpuBytes?: number;
+    readonly execute: (request: ICEAdaptiveBatchRequest) => Promise<ICEAdaptiveBatchExecutionResult>;
+    readonly onDiagnostic?: (code: string, generation: number, message: string) => void;
+}
+export declare class ICEAdaptiveRenderBatchController {
+    private generation;
+    private candidateGeneration;
+    private readonly mode;
+    private readonly maxExtraGpuBytes;
+    private readonly execute;
+    private readonly onDiagnostic;
+    private readonly emitted;
+    constructor(options: ICEAdaptiveRenderBatchControllerOptions);
+    get activeGeneration(): number;
+    get candidate(): number | undefined;
+    request(request: ICEAdaptiveBatchRequest): ICEAdaptiveBatchRequestResult;
+    cancel(generation: number): void;
+    cameraMotion(): void;
+    dispose(): void;
+    private finish;
+    private diagnostic;
+}
+//# sourceMappingURL=ICEAdaptiveRenderBatchController.d.ts.map

package/dist/_types/runtime/batching/ICEBatchWorkerPool.d.ts

@@ -0,0 +1,27 @@
+import type { ICEBatchWorkerRequest, ICEBatchWorkerResponse } from './ICEBatchWorkerProtocol.js';
+export interface ICEBatchWorkerLike {
+    postMessage(message: unknown, transfer?: readonly Transferable[]): void;
+    addEventListener(type: string, listener: (event: MessageEvent | ErrorEvent) => void): void;
+    removeEventListener(type: string, listener: (event: MessageEvent | ErrorEvent) => void): void;
+    terminate(): void;
+}
+export interface ICEBatchWorkerPoolOptions {
+    readonly maxWorkers?: number;
+    readonly workerFactory?: () => ICEBatchWorkerLike;
+}
+export declare class ICEBatchWorkerPool {
+    private readonly maxWorkers;
+    private readonly workerFactory;
+    private readonly queue;
+    private readonly active;
+    private disposed;
+    private nextJobId;
+    constructor(options?: ICEBatchWorkerPoolOptions);
+    run(request: ICEBatchWorkerRequest, signal: AbortSignal): Promise<ICEBatchWorkerResponse>;
+    dispose(): void;
+    private pump;
+    private start;
+    private settle;
+    private cancel;
+}
+//# sourceMappingURL=ICEBatchWorkerPool.d.ts.map

package/dist/_types/runtime/batching/ICEBatchWorkerProtocol.d.ts

@@ -0,0 +1,40 @@
+import type { ICEGeometryBounds } from '../../core/index.js';
+export interface ICEBatchWorkerSource {
+    readonly id: string;
+    readonly materialKey: string;
+    readonly positions: ArrayBuffer;
+    readonly indices: ArrayBuffer;
+    readonly semanticIndices: ArrayBuffer;
+    readonly semanticIds: readonly string[];
+    readonly semanticNodeIds: readonly string[];
+    readonly semanticSelectionIds: readonly string[];
+}
+export interface ICEBatchWorkerOutput {
+    readonly id: string;
+    readonly materialKey: string;
+    readonly positions: ArrayBuffer;
+    readonly indices: ArrayBuffer;
+    readonly semanticIndices: ArrayBuffer;
+    readonly semanticIds: readonly string[];
+    readonly semanticNodeIds: readonly string[];
+    readonly semanticSelectionIds: readonly string[];
+    readonly bounds: ICEGeometryBounds;
+    readonly triangleCount: number;
+}
+export interface ICEBatchWorkerRequest {
+    readonly type: 'build';
+    readonly generation: number;
+    readonly maxTrianglesPerBatch: number;
+    readonly maxBytesPerBatch: number;
+    readonly sources: readonly ICEBatchWorkerSource[];
+}
+export type ICEBatchWorkerResponse = {
+    readonly type: 'built';
+    readonly generation: number;
+    readonly batches: readonly ICEBatchWorkerOutput[];
+} | {
+    readonly type: 'failed';
+    readonly generation: number;
+    readonly message: string;
+};
+//# sourceMappingURL=ICEBatchWorkerProtocol.d.ts.map

package/dist/_types/runtime/batching/ICERenderBatchPlan.d.ts

@@ -0,0 +1,24 @@
+import type { ICEGeometryBounds } from '../../core/index.js';
+export interface ICERenderBatchCandidate {
+    readonly id: string;
+    readonly materialKey: string;
+    readonly triangleCount: number;
+    readonly byteLength: number;
+    readonly bounds: ICEGeometryBounds;
+}
+export interface ICERenderBatchPlanInput {
+    readonly generation: number;
+    readonly visibleBatchIds: readonly string[];
+    readonly batches: readonly ICERenderBatchCandidate[];
+    readonly maxExtraGpuBytes: number;
+}
+export interface ICERenderBatchPlan {
+    readonly generation: number;
+    readonly sourceBatchIds: readonly string[];
+    readonly estimatedDrawCallsSaved: number;
+    readonly estimatedBytes: number;
+    readonly estimatedGainMs: number;
+    readonly estimatedCostMs: number;
+    readonly accepted: boolean;
+}
+//# sourceMappingURL=ICERenderBatchPlan.d.ts.map

package/dist/_types/runtime/batching/ICERenderBatchPlanner.d.ts

@@ -0,0 +1,5 @@
+import type { ICERenderBatchPlan, ICERenderBatchPlanInput } from './ICERenderBatchPlan.js';
+export declare class ICERenderBatchPlanner {
+    plan(input: ICERenderBatchPlanInput): ICERenderBatchPlan;
+}
+//# sourceMappingURL=ICERenderBatchPlanner.d.ts.map

package/dist/_types/runtime/batching/createBatchWorker.d.ts

@@ -0,0 +1,3 @@
+import type { ICEBatchWorkerLike } from './ICEBatchWorkerPool.js';
+export declare function createBatchWorker(): ICEBatchWorkerLike;
+//# sourceMappingURL=createBatchWorker.d.ts.map

package/dist/_types/runtime/batching/mergeBatchBuffers.d.ts

@@ -0,0 +1,20 @@
+import type { ICEGeometryBounds } from '../../core/index.js';
+import type { ICEBatchWorkerSource } from './ICEBatchWorkerProtocol.js';
+export interface ICEMergedBatchBuffer {
+    readonly id: string;
+    readonly materialKey: string;
+    readonly positions: Float32Array;
+    readonly indices: Uint32Array;
+    readonly semanticIndices: Uint32Array;
+    readonly semanticIds: readonly string[];
+    readonly semanticNodeIds: readonly string[];
+    readonly semanticSelectionIds: readonly string[];
+    readonly bounds: ICEGeometryBounds;
+    readonly triangleCount: number;
+}
+export interface ICEMergeBatchBuffersOptions {
+    readonly maxTrianglesPerBatch?: number;
+    readonly maxBytesPerBatch?: number;
+}
+export declare function mergeBatchBuffers(inputs: readonly ICEBatchWorkerSource[], options?: ICEMergeBatchBuffersOptions): readonly ICEMergedBatchBuffer[];
+//# sourceMappingURL=mergeBatchBuffers.d.ts.map

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

@@ -0,0 +1,36 @@
+export * from '../core/index.js';
+export * from '../renderer/index.js';
+export { ICE2DLayer } from './layer/ICE2DLayer.js';
+export type { ICE2DLayerOptions } from './layer/ICE2DLayer.js';
+export { ICE2DLayerRouter } from './layer/ICE2DLayerRouter.js';
+export type { ICELayerHit } from './layer/ICE2DLayerRouter.js';
+export { ICEWorldLayer } from './layer/ICEWorldLayer.js';
+export { ICEScreenLayer } from './layer/ICEScreenLayer.js';
+export { ICELabel } from './layer/ICELabel.js';
+export type { ICELabelOptions, ICELabelRect } from './layer/ICELabel.js';
+export { ICE3 } from './ICE3.js';
+export type { ICE3Options, ICEEngineDiagnostics, } from './ICE3.js';
+export { projectWorldPoint } from './ICEProjection.js';
+export type { ICEProjectedPoint } from './ICEProjection.js';
+export { ICEInteractionState } from './ICEInteractionState.js';
+export { BrowserRenderScheduler } from './ICERenderScheduler.js';
+export type { ICERenderScheduler } from './ICERenderScheduler.js';
+export { ICEInputRouter } from './input/ICEInputRouter.js';
+export type { ICEInputEvent, ICEInputTarget, ICEKeyboardInputEvent, } from './input/ICEInputRouter.js';
+export { ICEOrbitController } from './input/ICEOrbitController.js';
+export { SELECTION_CLICK_THRESHOLD_PX, isSelectionClick, selectionForOutcome, } from './input/ICESelectionGesture.js';
+export type { ICEPickOutcome } from './input/ICESelectionGesture.js';
+export * from './asset/ICEAssetSceneBuilder.js';
+export { ICERenderBatch, type ICERenderBatchOptions, } from './asset/ICERenderBatch.js';
+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 { 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 { ICEAdaptiveRenderBatchController, } from './batching/ICEAdaptiveRenderBatchController.js';
+export type { ICEAdaptiveBatchExecutionResult, ICEAdaptiveBatchRequest, ICEAdaptiveBatchRequestResult, ICERenderBatchingMode, ICERenderBatchingOptions, } from './batching/ICEAdaptiveRenderBatchController.js';
+export { ICERenderBatchPlanner } from './batching/ICERenderBatchPlanner.js';
+export type { ICERenderBatchCandidate, ICERenderBatchPlan, ICERenderBatchPlanInput, } from './batching/ICERenderBatchPlan.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,62 @@
+export type ICEInputTarget = {
+    readonly kind: 'layer';
+    readonly layerId: string;
+    readonly labelId: string;
+} | {
+    readonly kind: 'scene';
+    readonly nodeId?: string;
+};
+export type ICEInputEvent = {
+    readonly type: 'pointerdown' | 'pointermove' | 'pointerup' | 'pointercancel' | 'wheel';
+    readonly point: Readonly<{
+        x: number;
+        y: number;
+    }>;
+    readonly pointerId?: number;
+    readonly deltaY?: number;
+    readonly deltaMode?: number;
+};
+export type ICEKeyboardInputEvent = {
+    readonly type: 'keydown' | 'keyup';
+    readonly code: string;
+    readonly key: string;
+    readonly repeat: boolean;
+};
+export interface ICEInputRouterOptions {
+    readonly hitTestLayer: (point: {
+        x: number;
+        y: number;
+    }) => ICEInputTarget | undefined;
+    readonly pickScene: (point: {
+        x: number;
+        y: number;
+    }) => ICEInputTarget | undefined;
+    readonly dispatch?: (target: ICEInputTarget, event: ICEInputEvent) => void;
+}
+export declare class ICEInputRouter {
+    private readonly options;
+    private readonly captured;
+    constructor(options: ICEInputRouterOptions);
+    route(point: {
+        x: number;
+        y: number;
+    }): ICEInputTarget | undefined;
+    pointerDown(point: {
+        x: number;
+        y: number;
+    }, pointerId: number): ICEInputTarget | undefined;
+    pointerMove(point: {
+        x: number;
+        y: number;
+    }, pointerId: number): ICEInputTarget | undefined;
+    pointerUp(point: {
+        x: number;
+        y: number;
+    }, pointerId: number): ICEInputTarget | undefined;
+    pointerCancel(pointerId: number): void;
+    wheel(deltaY: number, point: {
+        x: number;
+        y: number;
+    }, deltaMode?: number): ICEInputTarget | undefined;
+}
+//# sourceMappingURL=ICEInputRouter.d.ts.map

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

@@ -0,0 +1,51 @@
+import { ICEPerspectiveCamera } from '../../core/index.js';
+import type { ICE3 } from '../ICE3.js';
+export declare class ICEOrbitController {
+    private readonly engine;
+    private readonly camera;
+    private target;
+    private yaw;
+    private pitch;
+    private distance;
+    private targetYaw;
+    private targetPitch;
+    private targetDistance;
+    private lastMotionAt;
+    private draggingPointer;
+    private lastPoint;
+    private readonly activePointers;
+    private pinchDistance;
+    private readonly pressedKeys;
+    private started;
+    private disposed;
+    private readonly onPointerDown;
+    private readonly onPointerMove;
+    private readonly onPointerUp;
+    private readonly onWheel;
+    private readonly onKeyDown;
+    private readonly onKeyUp;
+    private readonly onKeyCancel;
+    private readonly onBeforeRender;
+    constructor(engine: ICE3, camera: ICEPerspectiveCamera);
+    focus(target: {
+        readonly bounds: {
+            readonly min: readonly [number, number, number];
+            readonly max: readonly [number, number, number];
+        };
+    }, options?: {
+        readonly padding?: number;
+        readonly animate?: boolean;
+    }): this;
+    rotateBy(deltaX: number, deltaY: number): this;
+    zoomBy(delta: number): this;
+    start(): this;
+    stop(): this;
+    dispose(): void;
+    private applyPosition;
+    private applyKeyboardMovement;
+    private prepareMotion;
+    private motionSettled;
+    private assertActive;
+    private distanceBetweenPointers;
+}
+//# sourceMappingURL=ICEOrbitController.d.ts.map

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

@@ -0,0 +1,7 @@
+import { ICEPerspectiveCamera, ICEScene, type ICENode } from '../../core/index.js';
+import type { ICEViewport } from '../../renderer/index.js';
+export declare function pickSceneNode(scene: ICEScene, camera: ICEPerspectiveCamera, viewport: ICEViewport, point: {
+    readonly x: number;
+    readonly y: number;
+}): ICENode | undefined;
+//# sourceMappingURL=ICEScenePicker.d.ts.map

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

@@ -0,0 +1,18 @@
+export declare const SELECTION_CLICK_THRESHOLD_PX = 4;
+export declare function isSelectionClick(start: Readonly<{
+    x: number;
+    y: number;
+}>, end: Readonly<{
+    x: number;
+    y: number;
+}>): boolean;
+export type ICEPickOutcome = {
+    readonly kind: 'hit';
+    readonly id: string;
+} | {
+    readonly kind: 'empty';
+} | {
+    readonly kind: 'error';
+};
+export declare function selectionForOutcome(outcome: ICEPickOutcome): readonly string[] | undefined;
+//# sourceMappingURL=ICESelectionGesture.d.ts.map

package/dist/_types/runtime/layer/ICE2DCanvasPainter.d.ts

@@ -0,0 +1,6 @@
+import type { ICEViewport } from '../../renderer/index.js';
+import type { ICE2DLayer } from './ICE2DLayer.js';
+export declare class ICE2DCanvasPainter {
+    paint(canvas: HTMLCanvasElement, layers: readonly ICE2DLayer[], viewport: ICEViewport, dpr: number): void;
+}
+//# sourceMappingURL=ICE2DCanvasPainter.d.ts.map

package/dist/_types/runtime/layer/ICE2DLayer.d.ts

@@ -0,0 +1,29 @@
+import { ICEEventDispatcher } from '../../core/index.js';
+import type { ICEViewport } from '../../renderer/index.js';
+import { ICELabel } from './ICELabel.js';
+export interface ICE2DLayerOptions {
+    readonly id: string;
+    readonly order?: number;
+    readonly visible?: boolean;
+    readonly interactive?: boolean;
+    readonly passThrough?: boolean;
+}
+export declare class ICE2DLayer extends ICEEventDispatcher {
+    readonly id: string;
+    readonly order: number;
+    visible: boolean;
+    interactive: boolean;
+    passThrough: boolean;
+    protected readonly labels: ICELabel[];
+    constructor(options: ICE2DLayerOptions);
+    addChild(child: ICELabel): this;
+    removeChild(child: ICELabel): this;
+    hitTest(point: {
+        readonly x: number;
+        readonly y: number;
+    }): ICELabel | undefined;
+    getLabels(): readonly ICELabel[];
+    paint(context: CanvasRenderingContext2D, _viewport: ICEViewport): void;
+    dispose(): void;
+}
+//# sourceMappingURL=ICE2DLayer.d.ts.map

package/dist/_types/runtime/layer/ICE2DLayerRouter.d.ts

@@ -0,0 +1,20 @@
+import type { ICE2DLayer } from './ICE2DLayer.js';
+import type { ICELabel } from './ICELabel.js';
+export type ICELayerHit = {
+    readonly layer: ICE2DLayer;
+    readonly label: ICELabel;
+};
+export declare class ICE2DLayerRouter {
+    private readonly getLayers;
+    constructor(getLayers: () => readonly ICE2DLayer[]);
+    hitTest(point: {
+        readonly x: number;
+        readonly y: number;
+    }): ICELayerHit | undefined;
+    shouldPassThrough(point: {
+        readonly x: number;
+        readonly y: number;
+    }): boolean;
+    private topDown;
+}
+//# sourceMappingURL=ICE2DLayerRouter.d.ts.map

package/dist/_types/runtime/layer/ICELabel.d.ts

@@ -0,0 +1,42 @@
+import { ICEEventDispatcher } from '../../core/index.js';
+export interface ICELabelOptions {
+    readonly id: string;
+    readonly text: string;
+    readonly anchorId?: string;
+    readonly screenPosition?: readonly [number, number];
+    readonly color?: string;
+    readonly background?: string;
+    readonly padding?: number;
+    readonly interactive?: boolean;
+}
+export interface ICELabelRect {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+export declare class ICELabel extends ICEEventDispatcher {
+    readonly id: string;
+    readonly anchorId: string | undefined;
+    readonly color: string;
+    readonly background: string;
+    readonly padding: number;
+    readonly interactive: boolean;
+    visible: boolean;
+    private currentText;
+    private currentScreenPosition;
+    private rect;
+    constructor(options: ICELabelOptions);
+    get text(): string;
+    get screenPosition(): readonly [number, number] | undefined;
+    setText(text: string): this;
+    setScreenPosition(position: readonly [number, number]): this;
+    setWorldAnchor(position: readonly [number, number], visible?: boolean): this;
+    measure(context: CanvasRenderingContext2D): ICELabelRect;
+    getRect(): ICELabelRect;
+    containsPoint(point: {
+        readonly x: number;
+        readonly y: number;
+    }): boolean;
+}
+//# sourceMappingURL=ICELabel.d.ts.map