@holoscript/engine 6.0.3 → 6.0.4

package/dist/index-CKwAJGck.d.ts

@@ -0,0 +1,455 @@
+import { W as World } from './World-CgKA4O2J.js';
+
+/**
+ * ProjectManager.ts
+ *
+ * Project-level management: project files, scene references,
+ * asset dependency tracking, and build configuration.
+ *
+ * @module scene
+ */
+interface SceneReference {
+    id: string;
+    name: string;
+    path: string;
+    isStartScene: boolean;
+    lastModified: number;
+}
+interface ProjectAssetRef {
+    id: string;
+    type: string;
+    path: string;
+    usedByScenes: string[];
+    sizeBytes: number;
+}
+interface BuildConfig {
+    target: 'development' | 'production' | 'debug';
+    optimizeAssets: boolean;
+    minifyScripts: boolean;
+    bundleAssets: boolean;
+    outputDir: string;
+}
+interface ProjectFile {
+    name: string;
+    version: string;
+    createdAt: number;
+    modifiedAt: number;
+    scenes: SceneReference[];
+    assets: ProjectAssetRef[];
+    buildConfig: BuildConfig;
+    settings: Record<string, unknown>;
+}
+declare class ProjectManager {
+    private project;
+    constructor(name: string, version?: string);
+    addScene(ref: Omit<SceneReference, 'lastModified'>): void;
+    removeScene(sceneId: string): boolean;
+    getScene(sceneId: string): SceneReference | undefined;
+    getScenes(): SceneReference[];
+    getStartScene(): SceneReference | undefined;
+    setStartScene(sceneId: string): boolean;
+    addAsset(ref: ProjectAssetRef): void;
+    removeAsset(assetId: string): boolean;
+    getAsset(assetId: string): ProjectAssetRef | undefined;
+    getAssets(): ProjectAssetRef[];
+    /**
+     * Find unused assets (not referenced by any scene).
+     */
+    findUnusedAssets(): ProjectAssetRef[];
+    /**
+     * Get total project size in bytes.
+     */
+    getTotalAssetSize(): number;
+    setBuildConfig(config: Partial<BuildConfig>): void;
+    getBuildConfig(): BuildConfig;
+    setSetting(key: string, value: unknown): void;
+    getSetting<T = unknown>(key: string): T | undefined;
+    serialize(): string;
+    static deserialize(json: string): ProjectManager;
+    getProjectFile(): ProjectFile;
+}
+
+/**
+ * Minimal HoloScript+ node shape used by extracted engine scene modules.
+ */
+interface HSPlusNode {
+    id?: string;
+    type?: string;
+    properties?: Record<string, unknown>;
+    traits?: Map<string, unknown>;
+    children?: HSPlusNode[];
+}
+
+/**
+ * SceneSerializer.ts
+ *
+ * Serializes HoloScript+ scene graphs to JSON-compatible format.
+ * Handles Map/Set conversion, circular reference protection,
+ * and trait config extraction.
+ */
+
+interface SerializedScene {
+    version: number;
+    timestamp: string;
+    name: string;
+    root: SerializedNode;
+    metadata?: Record<string, unknown>;
+}
+interface SerializedNode {
+    id: string;
+    type: string;
+    properties: Record<string, unknown>;
+    traits: Record<string, unknown>;
+    children: SerializedNode[];
+}
+declare class SceneSerializer {
+    private world?;
+    private visitedIds;
+    constructor(world?: World);
+    /**
+     * Serialize a scene.
+     * Overload 1: serialize(root: HSPlusNode, name?, metadata?) — from node tree
+     * Overload 2: serialize(name?, metadata?) — from World entities
+     */
+    serialize(rootOrName?: HSPlusNode | string, sceneNameOrMeta?: string | Record<string, unknown>, metadata?: Record<string, unknown>): SerializedScene;
+    /**
+     * Node-based serialization helper.
+     */
+    private serializeFromNode;
+    private serializeEntity;
+    /**
+     * Legacy/Utility: Serialize a HSPlusNode tree
+     */
+    serializeNode(node: HSPlusNode): SerializedNode;
+    /**
+     * Serialize a node tree to a JSON string.
+     */
+    toJSON(root: HSPlusNode, sceneName?: string): string;
+    private sanitizeProperties;
+    private sanitizeValue;
+}
+
+/**
+ * SceneDeserializer.ts
+ *
+ * Reconstructs live HoloScript+ node trees from serialized JSON.
+ * Rebuilds Map-based traits from Object representations.
+ */
+
+declare class SceneDeserializer {
+    /**
+     * Deserialize from a SerializedScene object.
+     */
+    deserialize(scene: SerializedScene): HSPlusNode;
+    /**
+     * Deserialize from a JSON string.
+     */
+    fromJSON(json: string): {
+        node: HSPlusNode;
+        name: string;
+        metadata?: Record<string, any>;
+    };
+    private rebuildNode;
+}
+
+/**
+ * StateSnapshot.ts
+ *
+ * Captures runtime state beyond the scene graph:
+ * animation progress, particle emitter state, scroll offsets, focus state.
+ */
+interface AnimationSnapshot {
+    activeClipIds: string[];
+    springValues: Record<string, number>;
+}
+interface ParticleSnapshot {
+    emitterId: string;
+    isEmitting: boolean;
+    activeCount: number;
+}
+interface UISnapshot {
+    focusedInputId: string | null;
+    cursorIndex: number;
+    scrollOffsets: Record<string, number>;
+}
+interface RuntimeStateSnapshot {
+    timestamp: string;
+    animation: AnimationSnapshot;
+    particles: ParticleSnapshot[];
+    ui: UISnapshot;
+    custom: Record<string, any>;
+}
+/**
+ * Capture current runtime state from various subsystems.
+ */
+declare class StateSnapshotCapture {
+    /**
+     * Create a snapshot of the current runtime state.
+     * Subsystem references are passed in to avoid coupling.
+     */
+    capture(options: {
+        animationEngine?: {
+            getActiveIds: () => string[];
+        };
+        particleSystems?: Array<{
+            id: string;
+            isEmitting: () => boolean;
+            getActiveCount: () => number;
+        }>;
+        keyboardSystem?: {
+            focusedInputId: string | null;
+            cursorIndex: number;
+        };
+        scrollOffsets?: Record<string, number>;
+        custom?: Record<string, any>;
+    }): RuntimeStateSnapshot;
+}
+
+/**
+ * SceneManager.ts
+ *
+ * High-level API for saving, loading, and listing HoloScript+ scenes.
+ * Combines SceneSerializer + SceneDeserializer + StateSnapshot.
+ */
+
+interface SavedScene {
+    scene: SerializedScene;
+    state?: RuntimeStateSnapshot;
+}
+interface SceneListEntry {
+    name: string;
+    timestamp: string;
+    nodeCount: number;
+}
+declare class SceneManager {
+    private serializer;
+    private deserializer;
+    private stateCapture;
+    private storage;
+    /**
+     * Save a scene to the internal store.
+     */
+    save(name: string, root: HSPlusNode, stateOptions?: Parameters<StateSnapshotCapture['capture']>[0], metadata?: Record<string, any>): SavedScene;
+    /**
+     * Load a scene by name.
+     */
+    load(name: string): {
+        node: HSPlusNode;
+        state?: RuntimeStateSnapshot;
+    } | null;
+    /**
+     * Check if a scene exists.
+     */
+    has(name: string): boolean;
+    /**
+     * Delete a saved scene.
+     */
+    delete(name: string): boolean;
+    /**
+     * List all saved scenes.
+     */
+    list(): SceneListEntry[];
+    /**
+     * Export a scene to JSON string.
+     */
+    exportJSON(name: string): string | null;
+    /**
+     * Import a scene from JSON string.
+     */
+    importJSON(json: string): string;
+    /**
+     * Get count of saved scenes.
+     */
+    get count(): number;
+    private countNodes;
+}
+
+/**
+ * SceneNode.ts
+ *
+ * Scene graph node: hierarchical transform, parent/child,
+ * local+world matrices, dirty flags, tag/layer assignment.
+ *
+ * @module scene
+ */
+interface Transform {
+    position: [number, number, number];
+    rotation: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    scale: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+type Matrix4 = Float64Array;
+declare class SceneNode {
+    readonly id: string;
+    name: string;
+    tags: Set<string>;
+    layer: number;
+    visible: boolean;
+    private local;
+    private worldMatrix;
+    private dirty;
+    private parent;
+    private children;
+    constructor(id: string, name?: string);
+    setPosition(x: number, y: number, z: number): void;
+    setRotation(x: number, y: number, z: number): void;
+    setScale(x: number, y: number, z: number): void;
+    getLocalTransform(): Transform;
+    getWorldPosition(): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    getWorldMatrix(): Matrix4;
+    addChild(child: SceneNode): void;
+    removeChild(child: SceneNode): void;
+    getParent(): SceneNode | null;
+    getChildren(): SceneNode[];
+    getChildCount(): number;
+    traverse(callback: (node: SceneNode, depth: number) => void, depth?: number): void;
+    private markDirty;
+    updateWorldMatrix(): void;
+    private computeLocalMatrix;
+    private setIdentity;
+    private multiply;
+    isDirty(): boolean;
+}
+
+/**
+ * SceneQuery.ts
+ *
+ * Scene queries: frustum culling, spatial range queries,
+ * tag/layer filtering, and visitor pattern.
+ *
+ * @module scene
+ */
+
+interface Frustum {
+    position: [number, number, number];
+    direction: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    fov: number;
+    near: number;
+    far: number;
+}
+type NodeVisitor = (node: SceneNode) => boolean;
+declare class SceneQuery {
+    static findByTag(root: SceneNode, tag: string): SceneNode[];
+    static findByLayer(root: SceneNode, layer: number): SceneNode[];
+    static findByName(root: SceneNode, name: string): SceneNode | null;
+    static findInRadius(root: SceneNode, center: {
+        x: number;
+        y: number;
+        z: number;
+    }, radius: number): SceneNode[];
+    static frustumCull(root: SceneNode, frustum: Frustum): SceneNode[];
+    static visit(root: SceneNode, visitor: NodeVisitor): void;
+    private static normalize;
+}
+
+/**
+ * VersionMigration.ts
+ *
+ * Schema versioning and backward-compatible migration.
+ * Automatically upgrades old scene data to the current version.
+ *
+ * @module scene
+ */
+interface MigrationStep {
+    fromVersion: number;
+    toVersion: number;
+    name: string;
+    migrate: (data: Record<string, unknown>) => Record<string, unknown>;
+}
+interface MigrationResult {
+    success: boolean;
+    fromVersion: number;
+    toVersion: number;
+    stepsApplied: string[];
+    warnings: string[];
+    data: Record<string, unknown>;
+}
+interface MigrationLog {
+    timestamp: number;
+    fromVersion: number;
+    toVersion: number;
+    stepsApplied: string[];
+    dataHash: string;
+}
+declare const CURRENT_SCHEMA_VERSION = 5;
+declare class VersionMigration {
+    private migrations;
+    private logs;
+    constructor();
+    register(step: MigrationStep): void;
+    getMigrations(): MigrationStep[];
+    getMigrationCount(): number;
+    /**
+     * Migrate data from its current version to the target version.
+     */
+    migrate(data: Record<string, unknown>, targetVersion?: number): MigrationResult;
+    /**
+     * Check if data needs migration.
+     */
+    needsMigration(data: Record<string, unknown>): boolean;
+    /**
+     * Get the version of the given data.
+     */
+    getDataVersion(data: Record<string, unknown>): number;
+    getLogs(): MigrationLog[];
+    clearLogs(): void;
+    private registerBuiltIns;
+    private simpleHash;
+}
+
+type index_AnimationSnapshot = AnimationSnapshot;
+type index_BuildConfig = BuildConfig;
+declare const index_CURRENT_SCHEMA_VERSION: typeof CURRENT_SCHEMA_VERSION;
+type index_Frustum = Frustum;
+type index_Matrix4 = Matrix4;
+type index_MigrationLog = MigrationLog;
+type index_MigrationResult = MigrationResult;
+type index_MigrationStep = MigrationStep;
+type index_NodeVisitor = NodeVisitor;
+type index_ParticleSnapshot = ParticleSnapshot;
+type index_ProjectAssetRef = ProjectAssetRef;
+type index_ProjectFile = ProjectFile;
+type index_ProjectManager = ProjectManager;
+declare const index_ProjectManager: typeof ProjectManager;
+type index_RuntimeStateSnapshot = RuntimeStateSnapshot;
+type index_SavedScene = SavedScene;
+type index_SceneDeserializer = SceneDeserializer;
+declare const index_SceneDeserializer: typeof SceneDeserializer;
+type index_SceneListEntry = SceneListEntry;
+type index_SceneManager = SceneManager;
+declare const index_SceneManager: typeof SceneManager;
+type index_SceneNode = SceneNode;
+declare const index_SceneNode: typeof SceneNode;
+type index_SceneQuery = SceneQuery;
+declare const index_SceneQuery: typeof SceneQuery;
+type index_SceneReference = SceneReference;
+type index_SceneSerializer = SceneSerializer;
+declare const index_SceneSerializer: typeof SceneSerializer;
+type index_SerializedNode = SerializedNode;
+type index_SerializedScene = SerializedScene;
+type index_StateSnapshotCapture = StateSnapshotCapture;
+declare const index_StateSnapshotCapture: typeof StateSnapshotCapture;
+type index_Transform = Transform;
+type index_UISnapshot = UISnapshot;
+type index_VersionMigration = VersionMigration;
+declare const index_VersionMigration: typeof VersionMigration;
+declare namespace index {
+  export { type index_AnimationSnapshot as AnimationSnapshot, type index_BuildConfig as BuildConfig, index_CURRENT_SCHEMA_VERSION as CURRENT_SCHEMA_VERSION, type index_Frustum as Frustum, type index_Matrix4 as Matrix4, type index_MigrationLog as MigrationLog, type index_MigrationResult as MigrationResult, type index_MigrationStep as MigrationStep, type index_NodeVisitor as NodeVisitor, type index_ParticleSnapshot as ParticleSnapshot, type index_ProjectAssetRef as ProjectAssetRef, type index_ProjectFile as ProjectFile, index_ProjectManager as ProjectManager, type index_RuntimeStateSnapshot as RuntimeStateSnapshot, type index_SavedScene as SavedScene, index_SceneDeserializer as SceneDeserializer, type index_SceneListEntry as SceneListEntry, index_SceneManager as SceneManager, index_SceneNode as SceneNode, index_SceneQuery as SceneQuery, type index_SceneReference as SceneReference, index_SceneSerializer as SceneSerializer, type index_SerializedNode as SerializedNode, type index_SerializedScene as SerializedScene, index_StateSnapshotCapture as StateSnapshotCapture, type index_Transform as Transform, type index_UISnapshot as UISnapshot, index_VersionMigration as VersionMigration };
+}
+
+export { type AnimationSnapshot as A, type BuildConfig as B, CURRENT_SCHEMA_VERSION as C, type Frustum as F, type Matrix4 as M, type NodeVisitor as N, type ParticleSnapshot as P, type RuntimeStateSnapshot as R, type SavedScene as S, type Transform as T, type UISnapshot as U, VersionMigration as V, type MigrationLog as a, type MigrationResult as b, type MigrationStep as c, type ProjectAssetRef as d, type ProjectFile as e, ProjectManager as f, SceneDeserializer as g, type SceneListEntry as h, index as i, SceneManager as j, SceneNode as k, SceneQuery as l, type SceneReference as m, SceneSerializer as n, type SerializedNode as o, type SerializedScene as p, StateSnapshotCapture as q };