ice3 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ICE3 contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,58 @@
-# Temporary Holding Version
+# ICE3
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+> Document ID: ICE3-ENG-RM-002
+>
+> Status: Active
+>
+> Owner: ICE3 Engine maintainers
+
+ICE3 是面向工业场景的浏览器 3D Runtime。公开代码通过单向 facade 暴露 Scene、
+Geometry、Camera、Asset 和 Tileset API。
+
+## 安装
+
+```bash
+npm install ice3
+```
+
+## 最小使用
+
+```ts
+import {
+  ICE3,
+  ICEBasicMaterial,
+  ICEBoxGeometry,
+  ICEMesh,
+  ICEPerspectiveCamera,
+  ICEScene,
+} from 'ice3';
+
+const host = document.querySelector<HTMLElement>('#stage');
+if (!host) throw new Error('stage element is required');
+
+const engine = new ICE3().init(host);
+const scene = new ICEScene({ id: 'main' });
+const camera = new ICEPerspectiveCamera({
+  id: 'camera',
+  position: [3, 2, 4],
+  target: [0, 0, 0],
+});
+
+scene.addChild(new ICEMesh({
+  id: 'sample',
+  geometry: new ICEBoxGeometry({ width: 1, height: 1, depth: 1 }),
+  material: new ICEBasicMaterial({ color: '#2f81f7' }),
+}));
+
+engine.setScene(scene).setCamera(camera).start();
+```
+
+完整文档和相关工具见
+[Engine 文档](https://github.com/ice-3d/ice3-engine/blob/main/README.md)。
+
+工业模型接入 Runtime 前，使用配套的
+[ICE3 Toolchain](https://github.com/ice-3d/ice3-toolchain/blob/main/README.md)
+进行离线格式转换、验证、切分、LOD 和 Tileset 发布。功能与格式支持见
+[Toolchain 功能指南](https://github.com/ice-3d/ice3-toolchain/blob/main/docs/guides/capabilities.md)。
+
+本项目采用 MIT License。

package/dist/_types/assets/ICEGLBReader.d.ts

@@ -0,0 +1,4 @@
+import type { ICEPreparedAssetSnapshot } from './ICEPreparedGLB.js';
+export declare function readPreparedGLB(bytes: ArrayBuffer): ICEPreparedAssetSnapshot;
+export declare function verifyPreparedGLBIntegrity(bytes: ArrayBuffer): Promise<boolean>;
+//# sourceMappingURL=ICEGLBReader.d.ts.map

package/dist/_types/assets/ICEPreparedGLB.d.ts

@@ -0,0 +1,87 @@
+import type { ICEGeometryBounds, ICEMatrix4Tuple } from '../core/index.js';
+export interface ICEPreparedNode {
+    readonly id: string;
+    readonly selectionId: string;
+    readonly name: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly parent: number | null;
+    readonly matrix: ICEMatrix4Tuple;
+    readonly visible: boolean;
+}
+export interface ICEPreparedGeometry {
+    readonly id: string;
+    readonly positions: Float32Array;
+    readonly indices: Uint16Array | Uint32Array;
+    readonly edgeIndices?: Uint16Array | Uint32Array;
+    readonly colors?: Float32Array;
+    readonly semanticIndices?: Uint32Array;
+    readonly bounds: ICEGeometryBounds;
+}
+export interface ICEPreparedMaterial {
+    readonly id: string;
+    readonly baseColor: string;
+    readonly edgeColor?: string;
+}
+export interface ICEPreparedMesh {
+    readonly id: string;
+    readonly node: number;
+    readonly geometry: number;
+    readonly material: number;
+}
+export interface ICEPreparedBatch {
+    readonly id: string;
+    readonly mesh: number;
+    readonly primitive: number;
+    readonly material: number;
+    readonly mode: 4 | 1;
+    readonly triangleCount: number;
+    readonly bounds: ICEGeometryBounds;
+}
+export interface ICEPreparedBatching {
+    readonly version: '1.0';
+    readonly semanticIds: readonly string[];
+    readonly semanticNodeIds: readonly string[];
+    readonly semanticSelectionIds: readonly string[];
+    readonly batches: readonly ICEPreparedBatch[];
+}
+export interface ICEPreparedStats {
+    readonly nodeCount: number;
+    readonly maxNodeDepth: number;
+    readonly meshCount: number;
+    readonly primitiveCount: number;
+    readonly triangleCount: number;
+    readonly edgeSegmentCount: number;
+    readonly materialCount: number;
+    readonly selectionGroupCount: number;
+}
+export interface ICEPreparedContract {
+    readonly status: 'active' | 'legacy';
+    readonly version?: string;
+    readonly preparation?: Readonly<{
+        runtimeConversionRequired: false;
+        sourceFormat: 'gltf-2.0';
+        unitsNormalized: true;
+        matrixTransformsBaked: true;
+        requiredCompressionDecoded: true;
+        edgesPrepared: boolean;
+        selectionGroupsPrepared: true;
+    }>;
+    readonly budget?: Readonly<{
+        profile: string;
+        status: 'pass' | 'warning' | 'error';
+        warningCount: number;
+        errorCount: number;
+    }>;
+}
+export interface ICEPreparedAssetSnapshot {
+    readonly assetId: string;
+    readonly bounds: ICEGeometryBounds;
+    readonly stats: ICEPreparedStats;
+    readonly contract: ICEPreparedContract;
+    readonly nodes: readonly ICEPreparedNode[];
+    readonly geometries: readonly ICEPreparedGeometry[];
+    readonly materials: readonly ICEPreparedMaterial[];
+    readonly meshes: readonly ICEPreparedMesh[];
+    readonly batching?: ICEPreparedBatching;
+}
+//# sourceMappingURL=ICEPreparedGLB.d.ts.map

package/dist/_types/assets/ICEProfileValidator.d.ts

@@ -0,0 +1,11 @@
+type JSONRecord = Record<string, unknown>;
+export interface ICEProfileValidation {
+    readonly json: JSONRecord;
+    readonly binary: Uint8Array;
+    readonly profile: JSONRecord;
+}
+export declare function validatePreparedProfile(json: JSONRecord, binary: Uint8Array): ICEProfileValidation;
+export declare function records(value: unknown): JSONRecord[];
+export declare function record(value: unknown): JSONRecord | undefined;
+export {};
+//# sourceMappingURL=ICEProfileValidator.d.ts.map

package/dist/_types/assets/ICETileset.d.ts

@@ -0,0 +1,17 @@
+import type { ICEGeometryBounds } from '../core/index.js';
+export interface ICETilesetTile {
+    readonly id: string;
+    readonly bounds: ICEGeometryBounds;
+    readonly contentUris: readonly string[];
+    readonly contentUri?: string;
+    readonly children: readonly ICETilesetTile[];
+    readonly geometricError: number;
+    readonly transform?: readonly number[];
+}
+export interface ICETilesetSnapshot {
+    readonly assetId: string;
+    readonly root: ICETilesetTile;
+    readonly bounds: ICEGeometryBounds;
+    readonly tiles: readonly ICETilesetTile[];
+}
+//# sourceMappingURL=ICETileset.d.ts.map

package/dist/_types/assets/ICETilesetReader.d.ts

@@ -0,0 +1,3 @@
+import type { ICETilesetSnapshot } from './ICETileset.js';
+export declare function readTileset(text: string, baseUrl: string): ICETilesetSnapshot;
+//# sourceMappingURL=ICETilesetReader.d.ts.map

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

@@ -0,0 +1,5 @@
+export { readPreparedGLB, verifyPreparedGLBIntegrity, } from './ICEGLBReader.js';
+export type { ICEPreparedAssetSnapshot, ICEPreparedBatch, ICEPreparedBatching, ICEPreparedContract, ICEPreparedGeometry, ICEPreparedMaterial, ICEPreparedMesh, ICEPreparedNode, ICEPreparedStats, } from './ICEPreparedGLB.js';
+export { readTileset } from './ICETilesetReader.js';
+export type { ICETilesetSnapshot, ICETilesetTile, } from './ICETileset.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/_types/core/camera/ICEPerspectiveCamera.d.ts

@@ -0,0 +1,25 @@
+import { ICEMatrix4 } from '../math/ICEMatrix4.js';
+import { ICEVector3, type ICEVector3Tuple } from '../math/ICEVector3.js';
+export interface ICEPerspectiveCameraOptions {
+    readonly id: string;
+    readonly fov: number;
+    readonly near: number;
+    readonly far: number;
+    readonly position: ICEVector3Tuple;
+    readonly target?: ICEVector3Tuple;
+}
+export declare class ICEPerspectiveCamera {
+    readonly id: string;
+    readonly fov: number;
+    readonly near: number;
+    readonly far: number;
+    private eye;
+    private lookTarget;
+    constructor(options: ICEPerspectiveCameraOptions);
+    setPosition(position: ICEVector3Tuple): this;
+    setTarget(target: ICEVector3Tuple): this;
+    getPosition(): ICEVector3;
+    getTarget(): ICEVector3;
+    getViewProjectionMatrix(aspect: number): ICEMatrix4;
+}
+//# sourceMappingURL=ICEPerspectiveCamera.d.ts.map

package/dist/_types/core/culling/ICEFrustum.d.ts

@@ -0,0 +1,9 @@
+import type { ICEGeometryBounds } from '../geometry/ICEGeometry.js';
+import type { ICEMatrix4 } from '../math/ICEMatrix4.js';
+export declare class ICEFrustum {
+    private readonly planes;
+    private constructor();
+    static fromViewProjection(matrix: ICEMatrix4): ICEFrustum;
+    intersectsBounds(bounds: ICEGeometryBounds, margin?: number): boolean;
+}
+//# sourceMappingURL=ICEFrustum.d.ts.map

package/dist/_types/core/diagnostics/ICEDiagnostic.d.ts

@@ -0,0 +1,9 @@
+export type ICEDiagnosticSeverity = 'error' | 'warning' | 'info';
+export interface ICEDiagnostic {
+    readonly severity: ICEDiagnosticSeverity;
+    readonly code: string;
+    readonly message: string;
+    readonly path?: string;
+    readonly details?: Readonly<Record<string, unknown>>;
+}
+//# sourceMappingURL=ICEDiagnostic.d.ts.map

package/dist/_types/core/diagnostics/ICEEngineError.d.ts

@@ -0,0 +1,8 @@
+import type { ICEDiagnostic } from './ICEDiagnostic.js';
+export declare class ICEEngineError extends Error {
+    readonly code: string;
+    readonly details?: Readonly<Record<string, unknown>> | undefined;
+    readonly diagnostic?: Readonly<ICEDiagnostic> | undefined;
+    constructor(code: string, message: string, details?: Readonly<Record<string, unknown>> | undefined, diagnostic?: Readonly<ICEDiagnostic> | undefined);
+}
+//# sourceMappingURL=ICEEngineError.d.ts.map

package/dist/_types/core/event/ICEEvent.d.ts

@@ -0,0 +1,7 @@
+export declare class ICEEvent<T = unknown> {
+    readonly type: string;
+    readonly target: unknown;
+    readonly param?: T | undefined;
+    constructor(type: string, target: unknown, param?: T | undefined);
+}
+//# sourceMappingURL=ICEEvent.d.ts.map

package/dist/_types/core/event/ICEEventDispatcher.d.ts

@@ -0,0 +1,11 @@
+import { ICEEvent } from './ICEEvent.js';
+export declare class ICEEventDispatcher {
+    private readonly listeners;
+    on<T>(type: string, listener: (event: ICEEvent<T>) => void): this;
+    once<T>(type: string, listener: (event: ICEEvent<T>) => void): this;
+    off<T>(type: string, listener?: (event: ICEEvent<T>) => void): this;
+    removeAllListeners(): this;
+    trigger<T>(type: string, param?: T): this;
+    private add;
+}
+//# sourceMappingURL=ICEEventDispatcher.d.ts.map

package/dist/_types/core/geometry/ICEBoxGeometry.d.ts

@@ -0,0 +1,19 @@
+export interface ICEBoxGeometryOptions {
+    readonly width: number;
+    readonly height: number;
+    readonly depth: number;
+}
+export declare class ICEBoxGeometry implements ICEGeometry {
+    readonly typeId = "ice3:BoxGeometry";
+    readonly width: number;
+    readonly height: number;
+    readonly depth: number;
+    readonly positions: Float32Array;
+    readonly indices: Uint16Array;
+    readonly edgeIndices: Uint16Array;
+    constructor(options: ICEBoxGeometryOptions);
+    getBounds(): ICEGeometryBounds;
+    toJSON(): Record<string, unknown>;
+}
+import type { ICEGeometry, ICEGeometryBounds } from './ICEGeometry.js';
+//# sourceMappingURL=ICEBoxGeometry.d.ts.map

package/dist/_types/core/geometry/ICEGeometry.d.ts

@@ -0,0 +1,15 @@
+export interface ICEGeometryBounds {
+    readonly min: readonly [number, number, number];
+    readonly max: readonly [number, number, number];
+}
+export interface ICEGeometry {
+    readonly typeId: string;
+    readonly positions: Float32Array;
+    readonly indices: Uint16Array | Uint32Array;
+    readonly edgeIndices?: Uint16Array | Uint32Array;
+    readonly colors?: Float32Array;
+    readonly semanticIndices?: Uint32Array;
+    getBounds(): ICEGeometryBounds;
+    toJSON(): Record<string, unknown>;
+}
+//# sourceMappingURL=ICEGeometry.d.ts.map

package/dist/_types/core/geometry/ICEIndexedGeometry.d.ts

@@ -0,0 +1,22 @@
+import type { ICEGeometry, ICEGeometryBounds } from './ICEGeometry.js';
+export interface ICEIndexedGeometryOptions {
+    readonly id: string;
+    readonly positions: Float32Array;
+    readonly indices: Uint16Array | Uint32Array;
+    readonly edgeIndices?: Uint16Array | Uint32Array;
+    readonly colors?: Float32Array;
+    readonly semanticIndices?: Uint32Array;
+}
+export declare class ICEIndexedGeometry implements ICEGeometry {
+    readonly typeId = "ice3:IndexedGeometry";
+    readonly id: string;
+    readonly positions: Float32Array;
+    readonly indices: Uint16Array | Uint32Array;
+    readonly edgeIndices?: Uint16Array | Uint32Array;
+    readonly colors?: Float32Array;
+    readonly semanticIndices?: Uint32Array;
+    constructor(options: ICEIndexedGeometryOptions);
+    getBounds(): ICEGeometryBounds;
+    toJSON(): Record<string, unknown>;
+}
+//# sourceMappingURL=ICEIndexedGeometry.d.ts.map

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

@@ -0,0 +1,27 @@
+export { ICEVector3 } from './math/ICEVector3.js';
+export type { ICEVector3Tuple } from './math/ICEVector3.js';
+export { ICEMatrix4 } from './math/ICEMatrix4.js';
+export { ICEEvent } from './event/ICEEvent.js';
+export { ICEEventDispatcher } from './event/ICEEventDispatcher.js';
+export { ICEBoxGeometry } from './geometry/ICEBoxGeometry.js';
+export type { ICEBoxGeometryOptions } from './geometry/ICEBoxGeometry.js';
+export { ICEIndexedGeometry } from './geometry/ICEIndexedGeometry.js';
+export type { ICEIndexedGeometryOptions } from './geometry/ICEIndexedGeometry.js';
+export type { ICEGeometry, ICEGeometryBounds } from './geometry/ICEGeometry.js';
+export { ICEBasicMaterial } from './material/ICEBasicMaterial.js';
+export type { ICEBasicMaterialOptions } from './material/ICEBasicMaterial.js';
+export { ICEPerspectiveCamera } from './camera/ICEPerspectiveCamera.js';
+export type { ICEPerspectiveCameraOptions } from './camera/ICEPerspectiveCamera.js';
+export { ICEFrustum } from './culling/ICEFrustum.js';
+export { ICENode } from './scene/ICENode.js';
+export type { ICEMatrix4Tuple, ICENodeOptions, ICESerializedNode, } from './scene/ICENode.js';
+export { ICEScene } from './scene/ICEScene.js';
+export { ICEMesh } from './scene/ICEMesh.js';
+export type { ICEMeshOptions } from './scene/ICEMesh.js';
+export { ICETypeRegistry } from './types/ICETypeRegistry.js';
+export type { ICENodeType } from './types/ICETypeRegistry.js';
+export { deserializeScene, serializeScene, } from './serialization/serializeScene.js';
+export type { ICEDeserializedScene, ICESerializedScene, } from './serialization/serializeScene.js';
+export { ICEEngineError } from './diagnostics/ICEEngineError.js';
+export type { ICEDiagnostic, ICEDiagnosticSeverity } from './diagnostics/ICEDiagnostic.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/_types/core/material/ICEBasicMaterial.d.ts

@@ -0,0 +1,12 @@
+export interface ICEBasicMaterialOptions {
+    readonly color: string;
+    readonly edgeColor?: string;
+}
+export declare class ICEBasicMaterial {
+    readonly typeId = "ice3:BasicMaterial";
+    readonly color: string;
+    readonly edgeColor: string | undefined;
+    constructor(options: ICEBasicMaterialOptions);
+    toJSON(): Record<string, unknown>;
+}
+//# sourceMappingURL=ICEBasicMaterial.d.ts.map

package/dist/_types/core/math/ICEMatrix4.d.ts

@@ -0,0 +1,11 @@
+import { ICEVector3 } from './ICEVector3.js';
+export declare class ICEMatrix4 {
+    readonly elements: Float32Array<ArrayBuffer>;
+    constructor();
+    identity(): this;
+    multiply(other: ICEMatrix4): this;
+    perspective(fovDegrees: number, aspect: number, near: number, far: number): this;
+    lookAt(eye: ICEVector3, target: ICEVector3, up: ICEVector3): this;
+    transformPoint(point: ICEVector3): [number, number, number, number];
+}
+//# sourceMappingURL=ICEMatrix4.d.ts.map

package/dist/_types/core/math/ICEVector3.d.ts

@@ -0,0 +1,10 @@
+export type ICEVector3Tuple = readonly [number, number, number];
+export declare class ICEVector3 {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+    constructor(x?: number, y?: number, z?: number);
+    clone(): ICEVector3;
+    toArray(): [number, number, number];
+}
+//# sourceMappingURL=ICEVector3.d.ts.map

package/dist/_types/core/scene/ICEMesh.d.ts

@@ -0,0 +1,18 @@
+import type { ICEGeometry } from '../geometry/ICEGeometry.js';
+import type { ICEBasicMaterial } from '../material/ICEBasicMaterial.js';
+import { ICENode, type ICENodeOptions, type ICESerializedNode } from './ICENode.js';
+export interface ICEMeshOptions extends ICENodeOptions {
+    readonly geometry: ICEGeometry;
+    readonly material: ICEBasicMaterial;
+}
+export declare class ICEMesh extends ICENode {
+    static readonly typeId = "ice3:Mesh";
+    readonly geometry: ICEGeometry;
+    readonly material: ICEBasicMaterial;
+    readonly selectionId: string;
+    constructor(options: ICEMeshOptions);
+    get typeId(): string;
+    toJSON(): ICESerializedNode;
+    static fromJSON(value: ICESerializedNode): ICEMesh;
+}
+//# sourceMappingURL=ICEMesh.d.ts.map

package/dist/_types/core/scene/ICENode.d.ts

@@ -0,0 +1,77 @@
+import { ICEEventDispatcher } from '../event/ICEEventDispatcher.js';
+import { ICEMatrix4 } from '../math/ICEMatrix4.js';
+import { ICEVector3, type ICEVector3Tuple } from '../math/ICEVector3.js';
+export interface ICENodeOptions {
+    readonly id: string;
+    readonly displayName?: string;
+    readonly selectionId?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly position?: ICEVector3Tuple;
+    readonly rotation?: ICEVector3Tuple;
+    readonly scale?: ICEVector3Tuple;
+    readonly matrix?: ICEMatrix4Tuple;
+}
+export type ICEMatrix4Tuple = readonly [
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number
+];
+export interface ICESerializedNode {
+    readonly id: string;
+    readonly displayName?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly typeId: string;
+    readonly visible: boolean;
+    readonly position: ICEVector3Tuple;
+    readonly rotation: ICEVector3Tuple;
+    readonly scale: ICEVector3Tuple;
+    readonly matrix?: ICEMatrix4Tuple;
+    readonly children: readonly ICESerializedNode[];
+    readonly [key: string]: unknown;
+}
+export declare class ICENode extends ICEEventDispatcher {
+    readonly id: string;
+    readonly displayName: string;
+    readonly selectionId?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly position: ICEVector3;
+    readonly rotation: ICEVector3;
+    readonly scale: ICEVector3;
+    visible: boolean;
+    private _parent;
+    private readonly _children;
+    private readonly worldMatrix;
+    private localMatrixOverride;
+    constructor(options: ICENodeOptions);
+    get typeId(): string;
+    get parent(): ICENode | null;
+    get children(): readonly ICENode[];
+    addChild(node: ICENode): this;
+    removeChild(node: ICENode, options?: {
+        readonly dispose?: boolean;
+    }): this;
+    findByID(id: string): ICENode | undefined;
+    updateWorldMatrix(parentMatrix?: ICEMatrix4): ICEMatrix4;
+    getWorldPosition(): ICEVector3;
+    setLocalMatrix(matrix: ICEMatrix4Tuple): this;
+    clearLocalMatrix(): this;
+    toJSON(): ICESerializedNode;
+    dispose(): void;
+    private getRoot;
+    private isAncestorOf;
+    private localMatrix;
+}
+//# sourceMappingURL=ICENode.d.ts.map

package/dist/_types/core/scene/ICEScene.d.ts

@@ -0,0 +1,6 @@
+import { ICENode, type ICENodeOptions } from './ICENode.js';
+export declare class ICEScene extends ICENode {
+    constructor(options: ICENodeOptions);
+    get typeId(): string;
+}
+//# sourceMappingURL=ICEScene.d.ts.map

package/dist/_types/core/serialization/serializeScene.d.ts

@@ -0,0 +1,18 @@
+import type { ICEDiagnostic } from '../diagnostics/ICEDiagnostic.js';
+import type { ICETypeRegistry } from '../types/ICETypeRegistry.js';
+import { type ICESerializedNode } from '../scene/ICENode.js';
+import { ICEScene } from '../scene/ICEScene.js';
+export interface ICESerializedScene {
+    readonly schemaVersion: 1;
+    readonly typeId: 'ice3:Scene';
+    readonly scene: ICESerializedNode;
+}
+export interface ICEDeserializedScene {
+    readonly scene: ICEScene;
+    readonly report: Readonly<{
+        errors: readonly ICEDiagnostic[];
+    }>;
+}
+export declare function serializeScene(scene: ICEScene): ICESerializedScene;
+export declare function deserializeScene(value: ICESerializedScene, registry: ICETypeRegistry): ICEDeserializedScene;
+//# sourceMappingURL=serializeScene.d.ts.map

package/dist/_types/core/types/ICETypeRegistry.d.ts

@@ -0,0 +1,12 @@
+import type { ICENode, ICESerializedNode } from '../scene/ICENode.js';
+export interface ICENodeType {
+    readonly typeId: string;
+    fromJSON(value: ICESerializedNode): ICENode;
+}
+export declare class ICETypeRegistry {
+    private readonly types;
+    private readonly typeIds;
+    register(typeId: string, type: ICENodeType): this;
+    get(typeId: string): ICENodeType | undefined;
+}
+//# sourceMappingURL=ICETypeRegistry.d.ts.map

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

@@ -0,0 +1,27 @@
+import type { ICERendererBackend, ICERendererCapabilities, ICEFrame, ICERendererStats, ICEViewport } from './types.js';
+export declare class FakeRendererBackend implements ICERendererBackend {
+    readonly capabilities: Readonly<ICERendererCapabilities>;
+    readonly stats: Readonly<ICERendererStats>;
+    readonly frames: ICEFrame[];
+    lastViewport: ICEViewport;
+    lastBackgroundColor: string;
+    pickResult: string | undefined;
+    pickError: Error | undefined;
+    private disposed;
+    private disposals;
+    constructor(options?: {
+        readonly picking?: boolean;
+        readonly stats?: ICERendererStats;
+    });
+    initialize(): void;
+    resize(viewport: ICEViewport): void;
+    setBackgroundColor(color: string): void;
+    prepareBatchGeometry(): void;
+    releaseBatchGeometry(): void;
+    render(frame: ICEFrame): void;
+    pick(): string | undefined;
+    dispose(): void;
+    get disposeCount(): number;
+    private assertActive;
+}
+//# sourceMappingURL=FakeRendererBackend.d.ts.map

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

@@ -0,0 +1,31 @@
+import type { ICEGeometryBounds } from '../core/index.js';
+export interface ICEBatchUploadBuffer {
+    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;
+    readonly byteLength: number;
+}
+export interface ICEBatchUploadOptions {
+    readonly generation: number;
+    readonly bytesPerFrame: number;
+    readonly onUploaded: (generation: number) => void;
+    readonly onFailed: (generation: number, error: unknown) => void;
+    readonly upload?: (buffer: ICEBatchUploadBuffer) => unknown;
+    readonly release?: (resource: unknown) => void;
+    readonly onActivate?: (generation: number, resources: readonly unknown[]) => void;
+    readonly schedule?: (callback: FrameRequestCallback) => number;
+    readonly cancelSchedule?: (id: number) => void;
+    readonly isCurrent?: () => boolean;
+}
+export interface ICEBatchGenerationHandle {
+    cancel(): void;
+}
+export declare function queueBatchGeneration(buffers: readonly ICEBatchUploadBuffer[], options: ICEBatchUploadOptions): ICEBatchGenerationHandle;
+//# sourceMappingURL=ICEWebGL2BatchGenerationUploader.d.ts.map

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

@@ -0,0 +1,10 @@
+import { ICEMesh, type ICEScene } from '../core/index.js';
+export interface ICEGeometryRenderable {
+    readonly id: string;
+    readonly mesh: ICEMesh;
+    readonly worldMatrix: Float32Array;
+}
+export declare function collectRenderables(scene: ICEScene, output?: ICEGeometryRenderable[]): readonly ICEGeometryRenderable[];
+export declare const selectionIdentity: (mesh: ICEMesh) => string;
+export { collectRenderBatches, semanticSelectionId, type ICERenderBatchDraw, type ICERenderBatchNode, } from './WebGL2RenderBatch.js';
+//# sourceMappingURL=WebGL2GeometryBatch.d.ts.map