@series-inc/rundot-3d-engine 0.3.0

package/dist/systems/index.d.ts

@@ -0,0 +1,3356 @@
+import { b as PrefabComponentConstructor, c as PrefabJSON, P as PrefabNode, d as PrefabCollectionJSON, G as GameObject, C as Component, a as ComponentJSON, R as RigidBodyComponentThree, A as AnimationCullingManager } from '../ComponentRegistry-V_7WauAE.js';
+export { f as ColliderShape, i as ComponentRegistry, j as PrefabComponentFactory, l as PrefabComponentJSON, k as PrefabMountJSON, m as PrefabNodeJSON, h as RigidBodyOptions, e as RigidBodyType, T as TransformComponentJSON, g as createCollisionGroup, n as isTransformComponent } from '../ComponentRegistry-V_7WauAE.js';
+import * as THREE from 'three';
+import { Vector3 } from 'three';
+import { World, RigidBodyDesc, ColliderDesc, RigidBody, Collider } from '@dimforge/rapier3d';
+import { StowKitPack } from '@stowkit/three-loader';
+
+declare function PrefabComponent(typeName: string): <T extends PrefabComponentConstructor>(target: T) => T;
+
+declare class Prefab {
+    static createFromJSON(json: PrefabJSON): Prefab;
+    private readonly _name;
+    private readonly _root;
+    private readonly _mounts;
+    constructor(name: string, root: PrefabNode, mounts: {
+        alias: string;
+        path: string;
+    }[]);
+    get name(): string;
+    get root(): PrefabNode;
+    get mounts(): ReadonlyArray<{
+        alias: string;
+        path: string;
+    }>;
+    getNodeByPath(path: string): PrefabNode | undefined;
+}
+
+declare class PrefabCollection {
+    static createFromJSON(json: PrefabCollectionJSON): PrefabCollection;
+    private readonly _prefabsByName;
+    constructor(prefabs: Iterable<Prefab>);
+    get prefabs(): IterableIterator<Prefab>;
+    getPrefabByName(name: string): Prefab | undefined;
+    getAllComponentTypes(): Set<string>;
+    /**
+     * Get all unique mounts from all prefabs in the collection.
+     * Mounts define StowKit pack aliases and CDN paths.
+     * @returns Array of mount points with alias and path
+     */
+    getMounts(): Array<{
+        alias: string;
+        path: string;
+    }>;
+    private traverseNodes;
+}
+
+/**
+ * Options for prefab instantiation
+ */
+interface PrefabInstantiateOptions {
+    /** Whether meshes should cast shadows (default: true) */
+    castShadow?: boolean;
+    /** Whether meshes should receive shadows (default: true) */
+    receiveShadow?: boolean;
+}
+declare class PrefabInstance {
+    /**
+     * Current instantiation options - used by components during creation
+     * Components like MeshRenderer can read this to apply shadow settings
+     */
+    static currentOptions: PrefabInstantiateOptions | null;
+    static instantiate(prefabNode: PrefabNode, parent?: GameObject | null, options?: PrefabInstantiateOptions): PrefabInstance;
+    /**
+     * Apply shadow options to all meshes in the prefab tree.
+     * Call this after meshes have loaded if shadows aren't being applied correctly.
+     */
+    setShadows(castShadow: boolean, receiveShadow?: boolean): void;
+    private applyShadowOptions;
+    private static createComponent;
+    private readonly _prefabNode;
+    private readonly _gameObject;
+    private readonly _components;
+    private readonly _childrenByName;
+    private readonly _descendantsByPath;
+    constructor(prefabNode: PrefabNode, gameObject: GameObject, components: Component[], children: PrefabInstance[]);
+    get name(): string;
+    get gameObject(): GameObject;
+    get prefabNode(): PrefabNode;
+    get components(): ReadonlyArray<Component>;
+    get children(): ReadonlyArray<PrefabInstance>;
+    get descendants(): MapIterator<[string, PrefabInstance]>;
+    getComponent<T extends Component>(componentType: new (...args: unknown[]) => T): T | undefined;
+    getChildByName(name: string): PrefabInstance | undefined;
+    getDescendantByPath(path: string): PrefabInstance | undefined;
+    getDescendantByPathOrThrow(path: string): PrefabInstance;
+    dispose(): void;
+}
+
+declare class PrefabLoader {
+    static loadCollection(json: PrefabCollectionJSON): PrefabCollection;
+    static instantiate(prefabNode: PrefabNode, parent?: GameObject | null, options?: PrefabInstantiateOptions): PrefabInstance;
+    static instantiatePrefab(prefab: Prefab, parent?: GameObject | null, options?: PrefabInstantiateOptions): PrefabInstance;
+    static validateCollection(collection: PrefabCollection): string[];
+    static getRegisteredComponentTypes(): string[];
+}
+
+/**
+ * Three.js physics system using Rapier
+ * Much simpler than Babylon.js Havok integration
+ */
+declare class PhysicsSystem {
+    private static world;
+    private static isInitialized;
+    private static rigidBodies;
+    private static colliders;
+    private static fixedTimeStep;
+    private static maxSubSteps;
+    private static accumulator;
+    private static alpha;
+    /**
+     * Configure physics stepping parameters at runtime
+     */
+    static configure(params?: {
+        fixedTimeStep?: number;
+        maxSubSteps?: number;
+    }): void;
+    /**
+     * Get interpolation alpha for rendering (accumulator / fixedTimeStep)
+     */
+    static getInterpolationAlpha(): number;
+    private static eventQueue;
+    private static colliderHandleToComponent;
+    private static colliderHandleToId;
+    private static colliderIdToGameObject;
+    private static debugEnabled;
+    private static debugScene;
+    private static debugMeshes;
+    private static debugMaterial;
+    /**
+     * Initialize Rapier physics world
+     */
+    static initialize(): Promise<void>;
+    /**
+     * Get the physics world
+     */
+    static getWorld(): World | null;
+    /**
+     * Check if physics is initialized
+     */
+    static isReady(): boolean;
+    /**
+     * Step the physics simulation
+     */
+    static step(deltaTime: number): void;
+    /**
+     * Create a rigid body
+     */
+    static createRigidBody(id: string, rigidBodyDesc: RigidBodyDesc, colliderDesc?: ColliderDesc): {
+        rigidBody: RigidBody;
+        collider?: Collider;
+    } | null;
+    /**
+     * Register a GameObject with its collider ID (called by RigidBodyComponentThree for all colliders)
+     */
+    static registerGameObject(colliderId: string, gameObject: any): void;
+    /**
+     * Unregister a GameObject from collider mapping
+     */
+    static unregisterGameObject(colliderId: string): void;
+    /**
+     * Register a component for trigger events
+     */
+    static registerTriggerComponent(colliderId: string, component: any): void;
+    /**
+     * Unregister a component from trigger events
+     */
+    static unregisterTriggerComponent(colliderId: string): void;
+    /**
+     * Process collision events from the event queue
+     */
+    private static processCollisionEvents;
+    /**
+     * Remove a rigid body
+     */
+    static removeRigidBody(id: string): void;
+    /**
+     * Get rigid body by ID
+     */
+    static getRigidBody(id: string): RigidBody | null;
+    /**
+     * Get collider by ID
+     */
+    static getCollider(id: string): Collider | null;
+    /**
+     * Sync Three.js object position with physics body
+     */
+    static syncObjectToPhysics(object: THREE.Object3D, rigidBody: RigidBody): void;
+    /**
+     * Sync physics body position to Three.js object
+     */
+    static syncPhysicsToObject(rigidBody: RigidBody, object: THREE.Object3D): void;
+    /**
+     * Create a ground plane
+     */
+    static createGround(size?: number): {
+        rigidBody: RigidBody;
+        collider: Collider;
+    } | null;
+    /**
+     * Create a box collider
+     */
+    static createBox(id: string, position: THREE.Vector3, size: THREE.Vector3, isDynamic?: boolean): {
+        rigidBody: RigidBody;
+        collider: Collider;
+    } | null;
+    /**
+     * Create a sphere collider
+     */
+    static createSphere(id: string, position: THREE.Vector3, radius: number, isDynamic?: boolean): {
+        rigidBody: RigidBody;
+        collider: Collider;
+    } | null;
+    /**
+     * Initialize debug visualization
+     */
+    static initializeDebug(scene: THREE.Scene): void;
+    /**
+     * Toggle physics debug visualization
+     */
+    static setDebugEnabled(enabled: boolean): void;
+    /**
+     * Get debug enabled state
+     */
+    static isDebugEnabled(): boolean;
+    /**
+     * Create debug mesh for a collider
+     */
+    private static createDebugMesh;
+    /**
+     * Add debug mesh for a physics body
+     */
+    private static addDebugMesh;
+    /**
+     * Remove debug mesh for a physics body
+     */
+    private static removeDebugMesh;
+    /**
+     * Show all debug meshes
+     */
+    private static showAllDebugMeshes;
+    /**
+     * Hide all debug meshes
+     */
+    private static hideAllDebugMeshes;
+    /**
+     * Update debug mesh positions to match physics bodies
+     */
+    static updateDebugMeshes(): void;
+    /**
+     * Dispose of physics system
+     */
+    static dispose(): void;
+}
+
+interface BoxComponentJSON extends ComponentJSON {
+    type: "box";
+    isCollider?: boolean;
+    size: number[];
+    offset: number[];
+}
+declare class BoxColliderComponent extends Component {
+    static fromPrefabJSON(json: BoxComponentJSON, _node: PrefabNode): BoxColliderComponent | null;
+    private rigidBody;
+    private readonly size;
+    private readonly offset;
+    constructor(size: THREE.Vector3, offset: THREE.Vector3);
+    protected onCreate(): void;
+    getRigidBody(): RigidBodyComponentThree | null;
+}
+
+interface MeshColliderJSON extends ComponentJSON {
+    type: "mesh_collider";
+    colliderType: "bounding_box";
+}
+declare class MeshColliderComponent extends Component {
+    static fromPrefabJSON(json: MeshColliderJSON, node: PrefabNode): MeshColliderComponent | null;
+    private rigidBody;
+    private readonly meshName;
+    constructor(meshName: string);
+    protected onCreate(): void;
+    getRigidBody(): RigidBodyComponentThree | null;
+}
+
+/**
+ * Debug utility for analyzing rendering performance and GPU instancing
+ * Contains all debugging functionality separate from core rendering classes
+ */
+declare class RenderingDebugger {
+    /**
+     * Get comprehensive rendering statistics from AssetManager
+     */
+    static getRenderingStats(): any;
+    /**
+     * Print comprehensive rendering report
+     */
+    static printRenderingReport(): void;
+    /**
+     * Analyze what's causing high draw calls
+     */
+    static analyzeDrawCalls(): void;
+    /**
+     * Test frustum culling with current camera
+     */
+    static testFrustumCulling(): void;
+    /**
+     * Debug frustum culling for a specific asset type
+     * @param assetPath Asset to debug (e.g., 'tree.obj')
+     */
+    static debugFrustumCullingForAsset(assetPath: string): void;
+    /**
+     * Inspect scene objects to detect duplicate rendering
+     */
+    static inspectScene(): void;
+    /**
+     * Make all debug functions globally available
+     */
+    static makeGloballyAvailable(): void;
+}
+
+/**
+ * Debug option interface for tracking state
+ */
+interface DebugOption {
+    label: string;
+    checked: boolean;
+    onChange: (checked: boolean) => void;
+    element?: HTMLElement;
+}
+/**
+ * Base Debug panel for Three.js applications
+ * Can be extended by specific game implementations to add custom debug options
+ */
+declare class DebugPanelThree {
+    static alwaysHide: boolean;
+    protected container: HTMLElement;
+    protected contentContainer: HTMLElement;
+    protected options: DebugOption[];
+    protected isVisible: boolean;
+    protected contentsExpanded: boolean;
+    protected performanceStats: {
+        fps: number;
+        frameTime: number;
+    };
+    protected performanceElement?: HTMLElement;
+    protected playerPositionElement?: HTMLElement;
+    protected renderer?: any;
+    protected playerGameObject?: any;
+    constructor();
+    /**
+     * Set the Three.js renderer for draw call tracking
+     * Should be called by the game implementation
+     */
+    setRenderer(renderer: any): void;
+    /**
+     * Set the player GameObject for position tracking
+     * Should be called by the game implementation
+     */
+    setPlayerGameObject(playerGameObject: any): void;
+    /**
+     * Create the main debug panel HTML structure
+     */
+    protected createPanel(): void;
+    /**
+     * Add core debug options that all implementations should have
+     * Can be overridden by implementations to add custom options
+     */
+    protected addCoreOptions(): void;
+    /**
+     * Add common debug options that most Three.js games will need
+     * These have working implementations using dynamic imports
+     */
+    protected addCommonDebugOptions(): void;
+    /**
+     * Run scene analysis to find instancing opportunities
+     */
+    protected runSceneAnalysis(): void;
+    /**
+     * Run render cost analysis to identify bottlenecks
+     */
+    protected runRenderCostAnalysis(): void;
+    /**
+     * Get the scene from VenusGame
+     */
+    protected findScene(): THREE.Scene | null;
+    /**
+     * Bake duplicate meshes into InstancedMeshes for better performance.
+     * Finds meshes with the same geometry and replaces them with a single InstancedMesh.
+     */
+    protected bakeInstancing(): void;
+    /**
+     * Add a debug option to the panel
+     */
+    addOption(label: string, defaultValue: boolean, onChange: (checked: boolean) => void): void;
+    /**
+     * Add a numeric slider to the panel
+     */
+    addSlider(label: string, defaultValue: number, min: number, max: number, onChange: (value: number) => void): void;
+    /**
+     * Create performance stats display
+     */
+    protected createPerformanceDisplay(): void;
+    /**
+     * Create player position display
+     */
+    protected createPlayerPositionDisplay(): void;
+    /**
+     * Set up performance monitoring
+     */
+    protected setupPerformanceMonitoring(): void;
+    /**
+     * Update all performance metrics in the display
+     */
+    protected updatePerformanceDisplay(): void;
+    /**
+     * Update player position display
+     */
+    protected updatePlayerPositionDisplay(): void;
+    /**
+     * Set up keyboard toggle for debug panel
+     */
+    protected setupKeyboardToggle(): void;
+    /**
+     * Show the debug panel
+     */
+    show(): void;
+    /**
+     * Hide the debug panel
+     */
+    hide(): void;
+    /**
+     * Toggle the debug panel visibility
+     */
+    toggle(): void;
+    /**
+     * Get current visibility state
+     */
+    getVisibility(): boolean;
+    /**
+     * Dispose of the debug panel
+     */
+    dispose(): void;
+}
+
+/**
+ * Simple centralized input management system
+ * Just tracks key state - gameplay logic stays in components
+ */
+declare enum InputAction {
+    MOVE_FORWARD = "move_forward",
+    MOVE_BACKWARD = "move_backward",
+    MOVE_LEFT = "move_left",
+    MOVE_RIGHT = "move_right",
+    RUN = "run"
+}
+/**
+ * Default key bindings - can be customized later
+ */
+declare const DEFAULT_KEY_BINDINGS: Record<InputAction, string>;
+/**
+ * Centralized Input Manager - Singleton
+ * Simple API for checking if keys/actions are currently pressed
+ */
+declare class InputManager {
+    private static instance;
+    private activeKeys;
+    private keyBindings;
+    private isEnabled;
+    private boundKeyDown;
+    private boundKeyUp;
+    private boundWindowBlur;
+    private constructor();
+    /**
+     * Get singleton instance
+     */
+    static getInstance(): InputManager;
+    /**
+     * Initialize the input system (call this in VenusGame)
+     */
+    static initialize(): void;
+    /**
+     * Setup DOM event listeners
+     */
+    private setupEventListeners;
+    /**
+     * Handle key down events
+     */
+    private onKeyDown;
+    /**
+     * Handle key up events
+     */
+    private onKeyUp;
+    /**
+     * Handle window blur to prevent stuck keys
+     */
+    private onWindowBlur;
+    /**
+     * Check if a specific action is currently pressed
+     */
+    isActionPressed(action: InputAction): boolean;
+    /**
+     * Check if a specific key code is currently pressed
+     */
+    isKeyPressed(keyCode: string): boolean;
+    /**
+     * Enable/disable input processing
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * Update key binding for an action
+     */
+    setKeyBinding(action: InputAction, keyCode: string): void;
+    /**
+     * Check if a key code is used by the game (for preventDefault)
+     */
+    private isGameKey;
+    /**
+     * Get all currently active keys (for debugging)
+     */
+    getActiveKeys(): string[];
+    /**
+     * Cleanup - remove event listeners
+     */
+    dispose(): void;
+}
+declare const Input: {
+    isPressed: (action: InputAction) => boolean;
+    isKeyPressed: (keyCode: string) => boolean;
+    setEnabled: (enabled: boolean) => void;
+};
+
+/**
+ * Simple Three.js directional light component
+ * No complex shadow management - just Three.js native properties
+ */
+declare class DirectionalLightComponent extends Component {
+    private light;
+    constructor(options?: {
+        color?: THREE.ColorRepresentation;
+        intensity?: number;
+        castShadow?: boolean;
+        shadowMapSize?: number;
+        shadowCamera?: {
+            left?: number;
+            right?: number;
+            top?: number;
+            bottom?: number;
+            near?: number;
+            far?: number;
+        };
+    });
+    protected onCreate(): void;
+    protected onCleanup(): void;
+    /**
+     * Get the Three.js light for direct access
+     */
+    getLight(): THREE.DirectionalLight;
+    /**
+     * Set light position
+     */
+    setPosition(x: number, y: number, z: number): void;
+    /**
+     * Set light target position
+     */
+    setTarget(x: number, y: number, z: number): void;
+    /**
+     * Set light intensity
+     */
+    setIntensity(intensity: number): void;
+    /**
+     * Set light color
+     */
+    setColor(color: THREE.ColorRepresentation): void;
+    /**
+     * Enable/disable shadow casting
+     */
+    setCastShadow(enabled: boolean): void;
+}
+
+/**
+ * Enhanced Three.js ambient light component that mimics Babylon.js HemisphericLight
+ * Provides directional ambient lighting with ground color support
+ */
+declare class AmbientLightComponent extends Component {
+    private ambientLight;
+    private hemisphereLight;
+    private useHemispheric;
+    constructor(options?: {
+        color?: THREE.ColorRepresentation;
+        intensity?: number;
+        groundColor?: THREE.ColorRepresentation;
+        direction?: THREE.Vector3;
+    });
+    protected onCreate(): void;
+    protected onCleanup(): void;
+    /**
+     * Get the Three.js light for direct access
+     */
+    getLight(): THREE.Light;
+    /**
+     * Set light intensity
+     */
+    setIntensity(intensity: number): void;
+    /**
+     * Set sky color (main color)
+     */
+    setColor(color: THREE.ColorRepresentation): void;
+    /**
+     * Set ground color (only works with hemispheric lighting)
+     */
+    setGroundColor(color: THREE.ColorRepresentation): void;
+}
+
+/**
+ * Simple Three.js material utilities
+ * Provides common material patterns without complex abstractions
+ */
+declare class MaterialUtils {
+    static readonly DEFAULT_TOON_GRADIENT_PATH = "assets/cozy_game_general/threeTone.jpg";
+    private static textureLoader;
+    private static cachedGradientMap;
+    /**
+     * Create a standard PBR material with common settings
+     */
+    static createStandardMaterial(options?: {
+        color?: THREE.ColorRepresentation;
+        map?: THREE.Texture;
+        mapPath?: string;
+        roughness?: number;
+        metalness?: number;
+        normalMap?: THREE.Texture;
+        normalMapPath?: string;
+        transparent?: boolean;
+        opacity?: number;
+    }): THREE.MeshStandardMaterial;
+    /**
+     * Create a basic material with a color
+     */
+    static createBasicMaterial(color: THREE.ColorRepresentation): THREE.MeshBasicMaterial;
+    /**
+     * Create a Lambert material (good for low-poly/stylized looks)
+     */
+    static createLambertMaterial(options?: {
+        color?: THREE.ColorRepresentation;
+        map?: THREE.Texture;
+    }): THREE.MeshLambertMaterial;
+    /**
+     * Create a material with texture
+     */
+    static createTexturedMaterial(textureUrl: string, options?: {
+        color?: THREE.ColorRepresentation;
+        roughness?: number;
+        metalness?: number;
+    }): THREE.MeshStandardMaterial;
+    /**
+     * Create a simple shared material for prototyping
+     */
+    static createSharedMaterial(color?: THREE.ColorRepresentation): THREE.MeshStandardMaterial;
+    /**
+     * Get or load the toon gradient map (ramp) texture.
+     * The texture is cached after first load. Uses nearest filtering and disables mipmaps
+     * to preserve crisp banding of the ramp.
+     */
+    static getToonGradientMap(gradientPath?: string): THREE.Texture;
+    /**
+     * Create a MeshToonMaterial with optional albedo map and the shared gradient ramp.
+     */
+    static createToonMaterial(options?: {
+        color?: THREE.ColorRepresentation;
+        map?: THREE.Texture;
+        mapPath?: string;
+        transparent?: boolean;
+        opacity?: number;
+        gradientPath?: string;
+        emissive?: THREE.ColorRepresentation;
+    }): THREE.MeshToonMaterial;
+    /**
+     * Convert an arbitrary THREE.Material into a MeshToonMaterial while
+     * preserving common properties like color, map and transparency.
+     */
+    static convertToToon(material: THREE.Material, gradientPath?: string): THREE.MeshToonMaterial;
+}
+
+/**
+ * Math utilities for game development
+ */
+declare class MathUtil {
+    /**
+     * Linear interpolation - exponential approach, never quite reaches target
+     * @param current Current value
+     * @param target Target value
+     * @param factor Interpolation factor (0-1)
+     * @returns Interpolated value
+     */
+    static lerp(current: number, target: number, factor: number): number;
+    /**
+     * Move towards - linear approach with max speed, reaches target exactly
+     * @param current Current value
+     * @param target Target value
+     * @param maxDelta Maximum change per call
+     * @returns New value moved towards target
+     */
+    static moveTowards(current: number, target: number, maxDelta: number): number;
+    /**
+     * Clamp a value between min and max
+     * @param value Value to clamp
+     * @param min Minimum value
+     * @param max Maximum value
+     * @returns Clamped value
+     */
+    static clamp(value: number, min: number, max: number): number;
+    /**
+     * Check if two values are approximately equal
+     * @param a First value
+     * @param b Second value
+     * @param epsilon Tolerance (default: 0.001)
+     * @returns True if values are approximately equal
+     */
+    static approximately(a: number, b: number, epsilon?: number): boolean;
+}
+
+/**
+ * Easing functions for smooth animations
+ */
+declare class Easing {
+    static linear(t: number): number;
+    static easeInQuad(t: number): number;
+    static easeOutQuad(t: number): number;
+    static easeInOutQuad(t: number): number;
+    static easeInCubic(t: number): number;
+    static easeOutCubic(t: number): number;
+    static easeInOutCubic(t: number): number;
+    static spring(t: number, damping?: number, stiffness?: number): number;
+    static easeOutElastic(t: number): number;
+    static easeInBack(t: number, s?: number): number;
+    static easeOutBack(t: number, s?: number): number;
+    static anticipateOvershoot(t: number, s?: number): number;
+}
+/**
+ * Individual tween instance
+ */
+declare class Tween {
+    private target;
+    private property;
+    private startValue;
+    private endValue;
+    private duration;
+    private elapsed;
+    private easingFunction;
+    private onComplete?;
+    private onUpdate?;
+    private active;
+    constructor(target: any, property: string, endValue: number, duration: number, easingFunction?: (t: number) => number);
+    /**
+     * Set completion callback
+     */
+    onCompleted(callback: () => void): Tween;
+    /**
+     * Set update callback
+     */
+    onUpdated(callback: (value: number) => void): Tween;
+    /**
+     * Update the tween (optimized for performance)
+     */
+    update(deltaTime: number): boolean;
+    /**
+     * Stop the tween
+     */
+    stop(): void;
+    /**
+     * Check if tween is active
+     */
+    isActive(): boolean;
+}
+/**
+ * Global tween manager with performance optimizations
+ */
+declare class TweenSystem {
+    private static tweens;
+    private static pendingTweens;
+    static debugLogging: boolean;
+    private static lastActiveFrame;
+    private static frameCount;
+    /**
+     * Create and register a new tween
+     */
+    static tween(target: any, property: string, endValue: number, duration: number, easingFunction?: (t: number) => number): Tween;
+    /**
+     * Update all active tweens (optimized to skip when empty)
+     */
+    static update(deltaTime: number): void;
+    /**
+     * Stop all tweens
+     */
+    static stopAll(): void;
+    /**
+     * Get number of active tweens
+     */
+    static getActiveCount(): number;
+    /**
+     * Check if the tween system is currently active
+     */
+    static isActive(): boolean;
+    /**
+     * Get performance stats for debugging
+     */
+    static getStats(): {
+        active: number;
+        pending: number;
+        lastActiveFrame: number;
+        currentFrame: number;
+    };
+}
+
+/**
+ * Second-order dynamics system for smooth, physics-based animation
+ * Based on the critically damped harmonic oscillator
+ * Perfect for springy, responsive animations that react to input changes
+ */
+declare class SecondOrderDynamics {
+    private k1;
+    private k2;
+    private k3;
+    private xp;
+    private y;
+    private yd;
+    /**
+     * Create a second-order dynamics system
+     * @param f - Frequency (speed of response) - higher = faster response
+     * @param z - Damping coefficient - 0 = no damping (oscillates forever), 1 = critically damped, >1 = overdamped
+     * @param r - Initial response factor - affects initial "kick" of the animation
+     * @param initialValue - Starting position
+     */
+    constructor(f: number, z: number, r: number, initialValue?: THREE.Vector3);
+    /**
+     * Update the system with a new target position
+     * @param x - Target position
+     * @param deltaTime - Time step
+     * @returns Current smoothed position
+     */
+    update(x: THREE.Vector3, deltaTime: number): THREE.Vector3;
+    /**
+     * Get current position without updating
+     */
+    getCurrentPosition(): THREE.Vector3;
+    /**
+     * Get current velocity
+     */
+    getCurrentVelocity(): THREE.Vector3;
+    /**
+     * Reset the system to a new position
+     */
+    reset(position: THREE.Vector3): void;
+}
+/**
+ * Simplified 1D version for scalar values
+ */
+declare class SecondOrderDynamics1D {
+    private k1;
+    private k2;
+    private k3;
+    private xp;
+    private y;
+    private yd;
+    constructor(f: number, z: number, r: number, initialValue?: number);
+    update(x: number, deltaTime: number): number;
+    getCurrentValue(): number;
+    getCurrentVelocity(): number;
+    reset(value: number): void;
+}
+
+interface Footprint {
+    type: "polygon" | "circle";
+    vertices?: Vector3[];
+    x?: number;
+    z?: number;
+    radius?: number;
+}
+interface AABB {
+    minX: number;
+    minZ: number;
+    maxX: number;
+    maxZ: number;
+}
+/**
+ * A fast 2D navigation grid using reference counting for obstacle management
+ * OPTIMIZED for high-performance incremental add/remove operations
+ */
+declare class NavigationGrid {
+    private grid;
+    private worldWidth;
+    private worldDepth;
+    private gridSize;
+    private cols;
+    private rows;
+    private halfWorldWidth;
+    private halfWorldDepth;
+    private halfGridSize;
+    private gridSizeInv;
+    private static DEBUG_MODE;
+    constructor(worldWidth: number, worldDepth: number, gridSize: number);
+    /**
+     * OPTIMIZED: Converts world X, Z coordinates to grid column, row
+     * Uses pre-calculated values for maximum performance
+     */
+    worldToGrid(x: number, z: number): {
+        col: number;
+        row: number;
+    };
+    /**
+     * Converts grid column, row to world X, Z center coordinates
+     * Uses centered coordinate system where (0,0) world = center of grid
+     */
+    gridToWorld(col: number, row: number): {
+        x: number;
+        z: number;
+    };
+    /**
+     * Point-in-Polygon test using ray casting algorithm for 2D XZ plane
+     */
+    private isPointInPolygon;
+    /**
+     * Point-in-Circle test for 2D XZ plane
+     */
+    private isPointInCircle;
+    /**
+     * Check if a polygon intersects with a grid cell (not just contains the center)
+     * This is crucial for thin obstacles like walls that might span multiple cells
+     * but not contain the cell centers
+     */
+    private doesPolygonIntersectCell;
+    /**
+     * Check if two line segments intersect
+     */
+    private doLineSegmentsIntersect;
+    /**
+     * Calculate the direction/orientation of three points
+     */
+    private direction;
+    /**
+     * Check if point p lies on line segment ab
+     */
+    private onSegment;
+    /**
+     * OPTIMIZED: Fast polygon-cell intersection using simplified approach
+     * Much faster than full line-segment intersection for reference counting
+     */
+    private fastPolygonIntersectCell;
+    /**
+     * OPTIMIZED: Calculate AABB with minimal overhead
+     */
+    private calculateAABB;
+    /**
+     * OPTIMIZED: Add obstacle with maximum performance - INCREMENTAL reference counting only
+     * Only touches cells affected by THIS obstacle - no global rebaking
+     */
+    addObstacle(footprint: Footprint): void;
+    /**
+     * OPTIMIZED: Remove obstacle with maximum performance - INCREMENTAL reference counting only
+     * Only touches cells affected by THIS obstacle - no global rebaking
+     */
+    removeObstacle(footprint: Footprint): void;
+    /**
+     * Check if a grid cell is walkable (reference count is zero)
+     */
+    isWalkable(col: number, row: number): boolean;
+    /**
+     * Get grid dimensions
+     */
+    getDimensions(): {
+        cols: number;
+        rows: number;
+        worldWidth: number;
+        worldDepth: number;
+        gridSize: number;
+    };
+    /**
+     * Debug helper to print the grid state
+     */
+    printGrid(): void;
+    /**
+     * Get the raw grid data (for debugging or visualization)
+     */
+    getGridData(): number[][];
+    /**
+     * Enable/disable debug logging for performance tuning
+     * Set to false for production performance
+     */
+    static setDebugMode(enabled: boolean): void;
+    /**
+     * Get current debug mode status
+     */
+    static isDebugMode(): boolean;
+}
+
+interface Waypoint {
+    x: number;
+    z: number;
+}
+interface PathfindingResult {
+    success: boolean;
+    waypoints: Waypoint[];
+    distance: number;
+}
+/**
+ * Three.js version of DynamicNavSystem
+ * Uses Three.js Vector2/Vector3 instead of Babylon.js types
+ * Clean static API with no scene dependency needed
+ */
+declare class DynamicNavSystem {
+    private static navigationGrid;
+    private static scene;
+    private static isInitialized;
+    private static obstacleRegistry;
+    /**
+     * Initialize the navigation system (must be called before use)
+     * Scene parameter is optional - only needed for debug visualization
+     */
+    static initialize(scene?: THREE.Scene, worldWidth?: number, worldDepth?: number, gridSize?: number): void;
+    /**
+     * Check if the system is initialized
+     */
+    static getIsInitialized(): boolean;
+    /**
+     * Dispose of the navigation system
+     */
+    static dispose(): void;
+    /**
+     * Add an obstacle to the navigation grid
+     */
+    static addObstacle(footprint: Footprint): void;
+    /**
+     * Remove an obstacle from the navigation grid
+     */
+    static removeObstacle(footprint: Footprint): void;
+    /**
+     * Check if a position is walkable
+     */
+    static isWalkable(x: number, z: number): boolean;
+    /**
+     * Convert world coordinates to grid coordinates
+     */
+    static worldToGrid(x: number, z: number): {
+        col: number;
+        row: number;
+    } | null;
+    /**
+     * Convert grid coordinates to world coordinates
+     */
+    static gridToWorld(col: number, row: number): {
+        x: number;
+        z: number;
+    } | null;
+    /**
+     * Debug method to print current navigation state
+     */
+    static debugNavigation(): void;
+    /**
+     * Add a box obstacle to the navigation grid
+     * @param x World X position (center)
+     * @param z World Z position (center)
+     * @param width Width of the obstacle
+     * @param depth Depth of the obstacle
+     */
+    static addBoxObstacle(x: number, z: number, width: number, depth: number): void;
+    /**
+     * Remove a box obstacle from the navigation grid
+     * @param x World X position (center)
+     * @param z World Z position (center)
+     * @param width Width of the obstacle
+     * @param depth Depth of the obstacle
+     */
+    static removeBoxObstacle(x: number, z: number, width: number, depth: number): void;
+    static addBoxObstacleFromRigidBody(gameObject: GameObject): void;
+    /**
+     * Add a box obstacle from a GameObject and its bounds size
+     * @param gameObject The GameObject to get world position from
+     * @param boundsSize The size from renderer bounds (uses X and Z for navigation)
+     */
+    static addBoxObstacleFromBounds(gameObject: GameObject, boundsSize: THREE.Vector3): void;
+    /**
+     * Add a rotated box obstacle from bounds and track it by GameObject ID
+     * @param gameObject The GameObject to get world transform from
+     * @param boundsSize The size from bounds (uses X and Z for navigation)
+     * @returns The ID used to track this obstacle (GameObject UUID)
+     */
+    static addRotatedBoxObstacle(gameObject: GameObject, boundsSize: THREE.Vector3): string;
+    /**
+     * Remove an obstacle by GameObject ID
+     * @param id The ID returned from addRotatedBoxObstacle (GameObject UUID)
+     * @returns true if obstacle was found and removed
+     */
+    static removeObstacleById(id: string): boolean;
+    /**
+     * Remove an obstacle by GameObject
+     * @param gameObject The GameObject whose obstacle should be removed
+     * @returns true if obstacle was found and removed
+     */
+    static removeObstacleByGameObject(gameObject: GameObject): boolean;
+    /**
+     * Find a path from start position to end position using A* pathfinding
+     * @param startPos Start position as THREE.Vector2 (x, z)
+     * @param endPos End position as THREE.Vector2 (x, z)
+     */
+    static findPath(startPos: THREE.Vector2, endPos: THREE.Vector2): PathfindingResult;
+    /**
+     * Find a path from start position to end position using A* pathfinding
+     * @param startPos Start position as THREE.Vector3 (uses x, z components)
+     * @param endPos End position as THREE.Vector3 (uses x, z components)
+     */
+    static findPath(startPos: THREE.Vector3, endPos: THREE.Vector3): PathfindingResult;
+    /**
+     * Find the closest walkable cell to a given position
+     */
+    private static findClosestWalkableCell;
+    /**
+     * A* pathfinding algorithm implementation
+     * Returns array of grid nodes representing the path
+     */
+    private static findPathAStar;
+    /**
+     * Reconstruct path from the end node back to start
+     */
+    private static reconstructPath;
+    /**
+     * Calculate distance between two grid positions (Manhattan distance with diagonal support)
+     */
+    private static getDistance;
+    /**
+     * Simplify path by removing unnecessary waypoints using line-of-sight optimization
+     */
+    private static simplifyPath;
+    /**
+     * Check if there's a clear line of sight between two waypoints
+     */
+    private static hasLineOfSight;
+    /**
+     * Calculate total distance of a path (like Babylon.js version)
+     */
+    private static calculatePathDistance;
+    /**
+     * Check if a path exists between two positions (faster than full pathfinding)
+     */
+    static canReach(startX: number, startZ: number, endX: number, endZ: number): boolean;
+}
+
+/**
+ * Three.js version of NavAgent
+ * Transform-based navigation agent for AI entities
+ * Moves the gameObject position directly without physics for smooth movement
+ * Uses waypoint-based pathfinding for all movement
+ * Perfect for entities that don't need collision detection (like customers)
+ *
+ * Handles pathfinding and visualization automatically!
+ */
+declare class NavAgent extends Component {
+    moveSpeed: number;
+    acceleration: number;
+    deceleration: number;
+    arrivalDistance: number;
+    angularAcceleration: number;
+    private waypoints;
+    private currentWaypointIndex;
+    private currentVelocity;
+    private maxSpeed;
+    private currentTarget;
+    private isMoving;
+    private pathVisualizationId;
+    private isVisualizationEnabled;
+    constructor();
+    /**
+     * Move to a target position using pathfinding
+     * Handles pathfinding and visualization automatically
+     * Returns true if pathfinding succeeded, false otherwise
+     */
+    moveTo(targetPosition: THREE.Vector3 | THREE.Vector2): boolean;
+    /**
+     * Check if the agent has reached its target (matches Babylon.js NavAgent exactly)
+     */
+    hasReachedTarget(): boolean;
+    /**
+     * Check if the agent is currently in motion
+     * Returns true if the agent has a target or is still moving (velocity > threshold)
+     */
+    isInMotion(): boolean;
+    /**
+     * Get the current movement speed as a normalized value (0-1)
+     * 0 = stopped, 1 = moving at max speed
+     * Useful for animation blending
+     */
+    getMovementSpeedNormalized(): number;
+    /**
+     * Get the current movement speed (units per second)
+     */
+    getMovementSpeed(): number;
+    /**
+     * Enable or disable path visualization
+     */
+    setVisualizationEnabled(enabled: boolean): void;
+    /**
+     * Get current movement speed
+     */
+    getCurrentSpeed(): number;
+    /**
+     * Get current waypoints
+     */
+    getWaypoints(): THREE.Vector3[];
+    /**
+     * Stop current movement (matches Babylon.js NavAgent)
+     */
+    stop(): void;
+    /**
+     * Set path from pathfinding result (used internally by moveTo)
+     */
+    private setPath;
+    /**
+     * Set waypoints to follow (used internally)
+     */
+    private setWaypoints;
+    /**
+     * Clear the current target (stops movement) - matches Babylon.js NavAgent exactly
+     */
+    private clearTarget;
+    /**
+     * Clear path visualization
+     */
+    private clearVisualization;
+    /**
+     * Update movement along waypoints (called automatically by component system)
+     */
+    update(deltaTime: number): void;
+    /**
+     * Handle stopping when path is complete
+     * Returns true if path is complete
+     */
+    private handlePathComplete;
+    /**
+     * Check if current waypoint is reached and advance if so
+     */
+    private checkWaypointReached;
+    /**
+     * Move toward a specific position with smooth acceleration/deceleration
+     */
+    private moveTowardPosition;
+    /**
+     * Apply the current velocity to the gameObject position
+     */
+    private applyMovement;
+    /**
+     * Rotate towards movement direction
+     */
+    private rotateTowardsDirection;
+}
+
+/**
+ * Three.js visualization system for pathfinding results
+ * Shows waypoints as spheres and paths as lines for debugging
+ */
+declare class PathVisualizationThree {
+    private static scene;
+    private static isInitialized;
+    private static visualizationEnabled;
+    private static pathMaterial;
+    private static waypointMaterial;
+    private static startMaterial;
+    private static endMaterial;
+    private static pathVisualizations;
+    private static currentPath;
+    /**
+     * Initialize the path visualization system
+     */
+    static initialize(scene: THREE.Scene): void;
+    /**
+     * Create materials for different visual elements
+     */
+    private static createMaterials;
+    /**
+     * Enable or disable path visualization globally
+     */
+    static setVisualizationEnabled(enabled: boolean): void;
+    /**
+     * Check if path visualization is globally enabled
+     */
+    static isVisualizationEnabled(): boolean;
+    /**
+     * Add a path visualization with optional ID for later removal
+     */
+    static addPath(pathId: string, result: PathfindingResult, startX?: number, startZ?: number, endX?: number, endZ?: number): boolean;
+    /**
+     * Add a path visualization (simplified API - infers start/end from waypoints)
+     */
+    static addPathSimple(pathId: string, result: PathfindingResult): boolean;
+    /**
+     * Remove a specific path visualization by ID
+     */
+    static removePath(pathId: string): boolean;
+    /**
+     * Visualize a pathfinding result (legacy method - uses default ID)
+     */
+    static visualizePath(result: PathfindingResult, startX?: number, startZ?: number, endX?: number, endZ?: number): void;
+    /**
+     * Create visual marker for start position
+     */
+    private static createStartMarker;
+    /**
+     * Create visual marker for end position
+     */
+    private static createEndMarker;
+    /**
+     * Create spheres to mark waypoints along the path
+     */
+    private static createWaypointSpheres;
+    /**
+     * Create lines connecting waypoints to show the path
+     */
+    private static createPathLines;
+    /**
+     * Clear all path visualizations
+     */
+    static clearVisualization(): void;
+    /**
+     * Get list of active path IDs
+     */
+    static getActivePathIds(): string[];
+    /**
+     * Check if any path is currently being visualized
+     */
+    static hasActiveVisualization(): boolean;
+    /**
+     * Get current path result (legacy support)
+     */
+    static getCurrentPath(): PathfindingResult | null;
+    /**
+     * Console helper function for manual testing
+     */
+    static testPath(startX: number, startZ: number, endX: number, endZ: number): void;
+    /**
+     * Dispose of the path visualization system
+     */
+    static dispose(): void;
+}
+declare global {
+    interface Window {
+        testPathThree: (startX: number, startZ: number, endX: number, endZ: number) => void;
+        clearPathThree: () => void;
+        addPathThree: (pathId: string, startX: number, startZ: number, endX: number, endZ: number) => void;
+        removePathThree: (pathId: string) => void;
+        listPathsThree: () => void;
+    }
+}
+
+/**
+ * HTML/CSS-based UI system for Three.js
+ * Provides overlay elements for HUD, interaction prompts, menus, and dialogs
+ * Uses modern CSS and HTML instead of canvas-based UI
+ *
+ * The system uses two separate containers:
+ * - Main container: For HUD, menus, etc. Respects safe area insets
+ * - World container: For world-space UI (indicators above 3D objects). Not affected by safe areas
+ */
+declare class UISystem {
+    private static container;
+    private static worldContainer;
+    private static isInitialized;
+    private static activeElements;
+    private static lastMoneyAmount;
+    private static referenceWidth;
+    private static referenceHeight;
+    private static matchWidthOrHeight;
+    private static minScale;
+    private static maxScale;
+    private static currentScale;
+    /**
+     * Reset the UISystem state - useful for page refreshes or reinitialization
+     */
+    static reset(): void;
+    static setInsets(insets: {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+    }): void;
+    /**
+     * Initialize the UI system
+     */
+    static initialize(): void;
+    /**
+     * Add global CSS styles for UI elements
+     */
+    private static addGlobalStyles;
+    /**
+     * Create a HUD element (money display, health bar, etc.)
+     */
+    static createHUD(id: string, content: string, position: {
+        x: number;
+        y: number;
+    }, options?: {
+        className?: string;
+        style?: string;
+    }): UIElement;
+    /**
+     * Create an interaction prompt (Press E to interact, etc.)
+     */
+    static createInteractionPrompt(id: string, text: string, position: {
+        x: number;
+        y: number;
+    }): UIElement;
+    /**
+     * Create a progress bar (cooking progress, etc.)
+     */
+    static createProgressBar(id: string, position: {
+        x: number;
+        y: number;
+    }, size: {
+        width: number;
+        height: number;
+    }, progress?: number): UIProgressBar;
+    /**
+     * Create a button
+     */
+    static createButton(id: string, text: string, position: {
+        x: number;
+        y: number;
+    }, onClick: () => void): UIElement;
+    /**
+     * Create a modal dialog
+     */
+    static createModal(id: string, content: string, options?: {
+        title?: string;
+        buttons?: Array<{
+            text: string;
+            onClick: () => void;
+        }>;
+        width?: number;
+        height?: number;
+        fullScreenOverlay?: boolean;
+    }): UIElement;
+    /**
+     * Update money display (special HUD element)
+     */
+    static updateMoneyDisplay(amount: number): void;
+    /**
+     * Create a world-space UI element that follows a 3D position
+     */
+    static createWorldSpaceUI(id: string, content: string, worldPosition: THREE.Vector3, camera: THREE.Camera, options?: {
+        offset?: {
+            x: number;
+            y: number;
+        };
+        className?: string;
+    }): UIWorldElement;
+    /**
+     * Update all world-space UI elements
+     */
+    static updateWorldSpaceElements(camera: THREE.Camera): void;
+    /**
+     * Unity-style Canvas Scaler with "Match Width Or Height" support
+     *
+     * How it works:
+     * - Reference resolution (e.g., 800x600) - screen size where UI is 100% scale
+     * - matchWidthOrHeight: 0 = match width, 1 = match height, 0.5 = blend both
+     * - UI components use CSS: transform: scale(var(--ui-scale, 1))
+     *
+     * The blend formula (same as Unity):
+     * scale = widthScale^(1-match) * heightScale^match
+     *
+     * This means on portrait mobile (narrow width, tall height):
+     * - Width-only (match=0): very small UI
+     * - Height-only (match=1): large UI
+     * - Blend (match=0.5): balanced UI that looks good
+     */
+    static updateResponsiveScale(): void;
+    /**
+     * Create a HUD element with responsive anchor-based positioning
+     */
+    static createResponsiveHUD(id: string, content: string, anchor: {
+        x: number;
+        y: number;
+    }, // 0-1 values (0 = left/top, 1 = right/bottom)
+    offset?: {
+        x: number;
+        y: number;
+    }, // Pixel offset from anchor
+    options?: {
+        className?: string;
+        style?: string;
+    }): UIElement;
+    /**
+     * Get an element by ID
+     */
+    static getElement(id: string): UIElement | undefined;
+    /**
+     * Remove an element
+     */
+    static removeElement(id: string): void;
+    /**
+     * Clear all UI elements
+     */
+    static clear(): void;
+    /**
+     * Show/hide the entire UI system
+     */
+    static setVisible(visible: boolean): void;
+    /**
+     * Generic element creation helper
+     */
+    private static createElement;
+    /**
+     * Configure the reference resolution for UI scaling (like Unity's Canvas Scaler)
+     * @param referenceWidth - The width at which UI is designed (default: 1920 Full HD)
+     * @param referenceHeight - The height at which UI is designed (default: 1080 Full HD)
+     * @param matchWidthOrHeight - 0 = match width, 1 = match height, 0.5 = blend both (recommended)
+     * @param minScale - Minimum scale factor (prevents UI from getting too small)
+     * @param maxScale - Maximum scale factor (prevents UI from getting too large)
+     */
+    static configureScaling(referenceWidth?: number, referenceHeight?: number, matchWidthOrHeight?: number, minScale?: number, maxScale?: number): void;
+    /**
+     * Get the current calculated UI scale factor
+     */
+    static getUIScale(): number;
+    /**
+     * Get the reference width used for scaling calculations
+     */
+    static getReferenceWidth(): number;
+    /**
+     * Dispose of the UI system
+     */
+    static dispose(): void;
+}
+interface UIElement {
+    id: string;
+    type: string;
+    element: HTMLElement;
+    show: () => void;
+    hide: () => void;
+    remove: () => void;
+}
+interface UIProgressBar extends UIElement {
+    fillElement: HTMLElement;
+    setProgress: (value: number) => void;
+}
+interface UIWorldElement extends UIElement {
+    worldPosition: THREE.Vector3;
+    update: (camera: THREE.Camera) => void;
+}
+
+/**
+ * Three.js UI utilities for creating consistent world-space UI components
+ * Simplified to provide consistent text sizing based on world units
+ */
+declare class UIUtils {
+    /**
+     * Create world-space UI plane with consistent text sizing
+     * Text sizes in pixels directly translate to world units via pixelsPerUnit
+     *
+     * @param worldWidth Width of the plane in world units
+     * @param worldHeight Height of the plane in world units
+     * @param options Configuration options
+     * @returns Object containing the plane mesh, canvas, context, and texture
+     */
+    static createWorldUI(worldWidth: number, worldHeight: number, options?: {
+        /** Resolution (pixels per world unit) - use same value across all UI for consistent text size */
+        pixelsPerUnit?: number;
+        /** Height above ground (default: 0.05) */
+        heightOffset?: number;
+        /** Rotate 180 degrees for correct text orientation (default: true) */
+        flipOrientation?: boolean;
+    }): {
+        plane: THREE.Mesh;
+        canvas: HTMLCanvasElement;
+        ctx: CanvasRenderingContext2D;
+        texture: THREE.CanvasTexture;
+        worldSize: {
+            width: number;
+            height: number;
+        };
+        pixelsPerUnit: number;
+    };
+    /**
+     * Helper function to draw rounded rectangles on canvas
+     */
+    static drawRoundedRect(ctx: CanvasRenderingContext2D, x: number, y: number, width: number, height: number, radius: number): void;
+    static readonly COLORS: {
+        SUCCESS: string;
+        PRIMARY: string;
+        WARNING: string;
+        DANGER: string;
+        WHITE: string;
+        BLACK: string;
+        GRAY: string;
+        BACKGROUND: string;
+        BORDER: string;
+    };
+    static readonly FONT_FAMILY = "'Palanquin Dark', sans-serif";
+    /**
+     * Initialize CSS variables for UI styling
+     * Call this once at app startup (UISystem.initialize() calls this automatically)
+     */
+    static initializeCSSVariables(): void;
+}
+
+declare class UILoadingScreen {
+    private static loadingScreenElement;
+    /**
+     * Show the loading screen with a spinner
+     * @param message Optional loading message to display
+     * @param backgroundColor Optional background color (default: #1a1a1a)
+     */
+    static showLoadingScreen(message?: string, backgroundColor?: string): void;
+    /**
+     * Hide and remove the loading screen
+     * @param fadeOut Optional fade out animation (default: true)
+     */
+    static hideLoadingScreen(fadeOut?: boolean): void;
+    /**
+     * Remove the loading screen from DOM
+     */
+    private static removeLoadingScreen;
+    /**
+     * Add spinner animation to the document
+     */
+    private static addSpinnerAnimation;
+}
+
+/**
+ * A reusable particle emitter component that can be attached to any GameObject.
+ * The particle system becomes a child of the GameObject and follows it automatically.
+ */
+declare class Particle extends Component {
+    private emitter;
+    private config;
+    private assets;
+    private static readonly _tempOrigin;
+    /**
+     * Creates a new particle emitter component
+     * @param config - The emitter configuration
+     * @param assets - The assets (textures) for the particles
+     */
+    constructor(config: EmitterConfig, assets: EmitterAssets);
+    protected onCreate(): void;
+    /**
+     * Trigger a burst of particles at the current GameObject position
+     * @param count - Number of particles to emit
+     */
+    trigger(count?: number): void;
+    /**
+     * Update the particle system
+     * @param deltaTime - Time since last frame in seconds
+     */
+    update(deltaTime: number): void;
+    /**
+     * Get the underlying particle system
+     */
+    getEmitter(): ParticleSystem | null;
+    /**
+     * Clean up the particle system
+     */
+    protected onCleanup(): void;
+}
+
+/**
+ * Animation Curve System for Particle Effects
+ *
+ * Provides cubic Hermite interpolation similar to Unity's AnimationCurve.
+ * Used for "X over Lifetime" properties like size, speed, opacity, rotation.
+ */
+/**
+ * A single keyframe on an animation curve.
+ */
+interface CurveKeyframe {
+    /** Time position on the curve (0-1 normalized) */
+    time: number;
+    /** Output value at this keyframe */
+    value: number;
+    /** Left tangent slope (controls curve shape approaching this point) */
+    inTangent: number;
+    /** Right tangent slope (controls curve shape leaving this point) */
+    outTangent: number;
+}
+/**
+ * An animation curve defined by keyframes with tangent handles.
+ */
+interface AnimationCurve {
+    /** Sorted array of keyframes (by time) */
+    keys: CurveKeyframe[];
+}
+/**
+ * CurveableValue - a property that can be either a constant or a curve.
+ * Used in EmitterConfig for properties that support "over lifetime" curves.
+ */
+type CurveableValue = number | {
+    curve: AnimationCurve;
+};
+/**
+ * Evaluates an animation curve at a given time using cubic Hermite interpolation.
+ *
+ * @param curve - The animation curve to evaluate
+ * @param t - Time value (typically 0-1 for particle lifetime)
+ * @returns The interpolated value at time t
+ */
+declare function evaluateCurve(curve: AnimationCurve, t: number): number;
+/**
+ * Evaluates a CurveableValue (constant or curve) at a given time.
+ *
+ * @param value - Either a constant number or an object with a curve
+ * @param t - Time value (0-1 for particle lifetime)
+ * @param defaultValue - Value to return if value is undefined
+ * @returns The evaluated value
+ */
+declare function evaluateCurveableValue(value: CurveableValue | undefined, t: number, defaultValue?: number): number;
+/**
+ * Creates a keyframe with auto-calculated tangents for smooth interpolation.
+ */
+declare function createKeyframe(time: number, value: number, inTangent?: number, outTangent?: number): CurveKeyframe;
+/**
+ * Creates a simple curve from an array of [time, value] pairs.
+ * Tangents are automatically calculated for smooth interpolation.
+ */
+declare function createCurveFromPoints(points: Array<[number, number]>): AnimationCurve;
+/**
+ * Preset curve factories for common curve shapes.
+ */
+declare const CurvePresets: {
+    /**
+     * Linear curve from 0 to 1
+     */
+    linear(): AnimationCurve;
+    /**
+     * Linear curve from 1 to 0 (inverse)
+     */
+    linearInverse(): AnimationCurve;
+    /**
+     * Constant value curve
+     */
+    constant(value?: number): AnimationCurve;
+    /**
+     * Ease-in curve (slow start, fast end)
+     */
+    easeIn(): AnimationCurve;
+    /**
+     * Ease-out curve (fast start, slow end)
+     */
+    easeOut(): AnimationCurve;
+    /**
+     * Ease-in-out curve (smooth S-curve)
+     */
+    easeInOut(): AnimationCurve;
+    /**
+     * Bell curve (starts at 0, peaks at 1 in middle, returns to 0)
+     */
+    bell(): AnimationCurve;
+    /**
+     * Fade-in curve (0 to 1 with smooth ramp)
+     */
+    fadeIn(): AnimationCurve;
+    /**
+     * Fade-out curve (1 to 0 with smooth ramp)
+     */
+    fadeOut(): AnimationCurve;
+    /**
+     * Bounce curve (oscillating decay)
+     */
+    bounce(): AnimationCurve;
+};
+/**
+ * Clones an animation curve (deep copy).
+ */
+declare function cloneCurve(curve: AnimationCurve): AnimationCurve;
+/**
+ * Adds a keyframe to a curve at the specified time.
+ * The curve is re-sorted after insertion.
+ */
+declare function addKeyframe(curve: AnimationCurve, keyframe: CurveKeyframe): AnimationCurve;
+/**
+ * Removes a keyframe at the specified index.
+ */
+declare function removeKeyframe(curve: AnimationCurve, index: number): AnimationCurve;
+/**
+ * Updates a keyframe at the specified index.
+ */
+declare function updateKeyframe(curve: AnimationCurve, index: number, updates: Partial<CurveKeyframe>): AnimationCurve;
+
+interface CurvePropertyValue {
+    mode: "constant" | "curve";
+    constant?: number;
+    curve?: {
+        keys: {
+            time: number;
+            value: number;
+            inTangent: number;
+            outTangent: number;
+        }[];
+    };
+}
+interface ParticleSystemJSON extends ComponentJSON {
+    type: "particle_system";
+    main: {
+        duration: number;
+        looping: boolean;
+        startLifetimeMin: number;
+        startLifetimeMax: number;
+        startSpeedMin: number;
+        startSpeedMax: number;
+        startSizeMin: number;
+        startSizeMax: number;
+        gravityModifier: number;
+        maxParticles: number;
+        startColor: number[];
+        useRandomStartColors?: boolean;
+        randomStartColors?: number[][];
+        colorOverLifetime: boolean;
+        endColor: number[];
+        useMidColor?: boolean;
+        midColor?: number[];
+        opacityOverLifetime?: CurvePropertyValue;
+    };
+    emission: {
+        enabled: boolean;
+        mode: "constant" | "burst";
+        rateOverTime: number;
+        burstCount?: number;
+        burstCycles?: number;
+        burstInterval?: number;
+    };
+    shape: {
+        enabled: boolean;
+        shape: "cone" | "sphere" | "box" | "point";
+        radius: number;
+        coneAngleMin?: number;
+        coneAngleMax?: number;
+        coneDirection?: number[];
+        boxSize?: number[];
+        sphereRadius?: number;
+    };
+    velocity: {
+        enabled: boolean;
+        gravity: number[];
+        damping?: number;
+        speedOverLifetime?: CurvePropertyValue;
+        orbitalX?: number;
+        orbitalY?: number;
+        orbitalZ?: number;
+    };
+    size: {
+        value?: {
+            enabled?: boolean;
+            endSizeMin?: number;
+            endSizeMax?: number;
+        };
+        enabled?: boolean;
+        endSizeMin: number;
+        endSizeMax: number;
+        sizeOverLifetime?: CurvePropertyValue;
+    };
+    rotation: {
+        enabled: boolean;
+        startAngleMin: number;
+        startAngleMax: number;
+        angularVelocityMin: number;
+        angularVelocityMax: number;
+        rotationOverLifetime?: CurvePropertyValue;
+    };
+    noise?: {
+        enabled: boolean;
+        positionAmount?: number;
+        rotationAmount?: number;
+        sizeAmount?: number;
+        frequency?: number;
+        scrollSpeed?: number;
+        octaves?: number;
+    };
+    textureSheet: {
+        enabled: boolean;
+        timeMode?: "fps" | "startLifetime";
+        rows: number;
+        columns: number;
+        fps: number;
+        loop: boolean;
+        randomStartFrame?: boolean;
+    };
+    collision: {
+        enabled: boolean;
+        planeY?: number;
+        restitution?: number;
+        friction?: number;
+        killAfterBounces?: number;
+    };
+    renderer: {
+        texture: {
+            pack: string;
+            assetId: string;
+        };
+        renderMode?: "billboard" | "quad";
+        blending: "additive" | "normal";
+        premultipliedAlpha: boolean;
+        maskFromLuminance: boolean;
+        velocityScale: number;
+        stretchWithVelocity: boolean;
+        alignToVelocity: boolean;
+        flipX?: number;
+        flipY?: number;
+    };
+}
+/**
+ * Prefab component for particle systems.
+ * Directly creates particle emitter like the editor does.
+ */
+declare class ParticleSystemPrefabComponent extends Component {
+    private emitter;
+    private json;
+    private static readonly _tempOrigin;
+    /**
+     * Create a ParticleSystemPrefabComponent from prefab JSON
+     */
+    static fromPrefabJSON(json: ParticleSystemJSON, _node: PrefabNode): ParticleSystemPrefabComponent | null;
+    constructor(json: ParticleSystemJSON);
+    protected onCreate(): void;
+    /**
+     * Load texture on-demand and update the emitter's material
+     * This matches how the editor loads textures asynchronously
+     */
+    private loadTextureAsync;
+    /**
+     * Build EmitterConfig from prefab JSON - matches editor's buildEmitterConfigFromComponentData
+     */
+    private buildEmitterConfig;
+    /**
+     * Build EmitterAssets from prefab JSON
+     * Starts with procedural texture - actual texture is loaded asynchronously in loadTextureAsync()
+     */
+    private buildEmitterAssets;
+    /**
+     * Trigger a burst of particles
+     */
+    trigger(count?: number): void;
+    /**
+     * Play the particle system
+     */
+    play(): void;
+    /**
+     * Stop the particle system
+     */
+    stop(): void;
+    /**
+     * Update the particle system
+     */
+    update(deltaTime: number): void;
+    /**
+     * Get the underlying particle system
+     */
+    getEmitter(): ParticleSystem | null;
+    protected onCleanup(): void;
+}
+
+type ParticleSystem = {
+    object: THREE.InstancedMesh;
+    update: (dt: number, camera: THREE.Camera, emitterWorldMatrix?: THREE.Matrix4) => void;
+    burst: (origin: THREE.Vector3, count?: number) => void;
+    setSpawnRate: (rate: number) => void;
+    setOrigin: (origin: THREE.Vector3) => void;
+    config: EmitterConfig;
+    setTexture?: (texture: THREE.Texture) => void;
+    play: () => void;
+    stop: () => void;
+    restart: () => void;
+    isPlaying: () => boolean;
+    getElapsed: () => number;
+    playInternal?: () => void;
+    stopInternal?: () => void;
+    restartInternal?: () => void;
+};
+type NumRange = number | readonly [number, number];
+type Vec4Range = THREE.Vector4 | {
+    min: THREE.Vector4;
+    max: THREE.Vector4;
+};
+declare function range(min: number, max: number): readonly [number, number];
+declare const EmitterShape: {
+    readonly CONE: "cone";
+    readonly SPHERE: "sphere";
+    readonly BOX: "box";
+    readonly POINT: "point";
+};
+type EmitterShapeKey = (typeof EmitterShape)[keyof typeof EmitterShape];
+type BurstConfig = {
+    time: number;
+    count: number;
+    cycles?: number;
+    interval?: number;
+};
+type EmissionConfig = {
+    mode: "constant" | "burst";
+    rateOverTime?: number;
+    bursts?: BurstConfig[];
+};
+type NoiseConfig = {
+    enabled?: boolean;
+    positionAmount?: number;
+    rotationAmount?: number;
+    sizeAmount?: number;
+    frequency?: number;
+    scrollSpeed?: number;
+    octaves?: number;
+    strengthX?: number;
+    strengthY?: number;
+};
+type FlipConfig = {
+    x?: number;
+    y?: number;
+};
+type RenderMode = "billboard" | "quad";
+type EmitterConfig = {
+    maxParticles?: number;
+    duration?: number;
+    looping?: boolean;
+    playOnAwake?: boolean;
+    emission?: EmissionConfig;
+    shape?: EmitterShapeKey;
+    coneAngle?: NumRange;
+    coneDirection?: THREE.Vector3;
+    radius?: number;
+    boxSize?: THREE.Vector3;
+    sphereRadius?: number;
+    lifetime?: NumRange;
+    size?: {
+        start: NumRange;
+        end: NumRange;
+    };
+    speed?: NumRange;
+    gravity?: THREE.Vector3;
+    damping?: number;
+    orbital?: {
+        x?: number;
+        y?: number;
+        z?: number;
+    };
+    alignment?: {
+        velocityScale?: number;
+        enableVelocityStretch?: boolean;
+        enableVelocityAlignment?: boolean;
+    };
+    rotation?: {
+        angle?: NumRange;
+        velocity?: NumRange;
+    };
+    sizeOverLifetime?: CurveableValue;
+    speedOverLifetime?: CurveableValue;
+    opacityOverLifetime?: CurveableValue;
+    rotationOverLifetime?: CurveableValue;
+    noise?: NoiseConfig;
+    color?: {
+        start: Vec4Range;
+        startList?: THREE.Vector4[];
+        useStartAsEnd?: boolean;
+        mid?: Vec4Range;
+        end: Vec4Range;
+    };
+    blending?: THREE.Blending;
+    premultipliedAlpha?: boolean;
+    maskFromLuminance?: boolean;
+    flip?: FlipConfig;
+    renderMode?: RenderMode;
+    collision?: {
+        enabled?: boolean;
+        planeY?: number;
+        restitution?: number;
+        friction?: number;
+        killAfterBounces?: number;
+    };
+    spriteSheet?: {
+        rows: number;
+        columns: number;
+        frameCount?: number;
+        timeMode?: "fps" | "startLifetime";
+        fps?: number;
+        loop?: boolean;
+        randomStartFrame?: boolean;
+    };
+    debug?: boolean;
+    debugVelocities?: boolean;
+};
+type EmitterAssets = {
+    texture?: THREE.Texture;
+    textureUrl?: string;
+    material?: THREE.MeshBasicMaterial;
+};
+declare function createParticleEmitter(cfg?: EmitterConfig, assets?: EmitterAssets): ParticleSystem;
+
+declare enum ParameterType {
+    BOOL = "bool",
+    FLOAT = "float",
+    INT = "int",
+    TRIGGER = "trigger"
+}
+declare enum ComparisonOperator {
+    EQUALS = "==",
+    NOT_EQUALS = "!=",
+    GREATER = ">",
+    LESS = "<",
+    GREATER_EQUALS = ">=",
+    LESS_EQUALS = "<="
+}
+declare enum BlendType {
+    LINEAR = "linear",
+    EASE_IN_OUT = "ease_in_out"
+}
+declare enum AnimationEvent {
+    STATE_CHANGED = "state_changed",
+    TRANSITION_START = "transition_start",
+    TRANSITION_END = "transition_end"
+}
+interface Parameter {
+    type: ParameterType;
+    value: any;
+}
+interface TransitionCondition {
+    parameter: string;
+    operator: ComparisonOperator;
+    value: any;
+}
+interface TransitionConfig$1 {
+    from: string;
+    to: string;
+    conditions: TransitionCondition[];
+    duration?: number;
+    priority?: number;
+    blend_type?: BlendType;
+}
+interface ClipInfo {
+    id: string;
+    is_playing: boolean;
+    weight: number;
+    loop: boolean;
+}
+interface BlendTreeConfig {
+    parameter: string;
+    children: {
+        state_id: string;
+        threshold: number;
+    }[];
+}
+interface ActiveTransition {
+    from_state: string;
+    to_state: string;
+    progress: number;
+}
+type EventCallback = () => void;
+/**
+ * Lightweight animation state machine for visualization
+ * No actual animation playback - SharedAnimationManager handles that
+ */
+declare class Animatrix {
+    private states;
+    private transitions;
+    private parameters;
+    private treeStates;
+    private blendTreeConfigs;
+    private currentState;
+    private activeTransition;
+    private listeners;
+    constructor();
+    add_parameter(name: string, type: ParameterType, defaultValue: any): void;
+    add_clip(name: string, clipInfo: {
+        duration: number;
+    }): void;
+    add_blend_tree_1d(id: string, parameter: string, children: {
+        state_id: string;
+        threshold: number;
+    }[]): void;
+    add_transition(config: TransitionConfig$1): void;
+    set_state(name: string): void;
+    set_bool(name: string, value: boolean): void;
+    set_float(name: string, value: number): void;
+    set_int(name: string, value: number): void;
+    get_float(name: string): number;
+    get_bool(name: string): boolean;
+    get_int(name: string): number;
+    update(_deltaTime: number): void;
+    stop_all(): void;
+    get_current_state(): string | null;
+    get_clips(): Map<string, ClipInfo>;
+    get_transitions(): TransitionConfig$1[];
+    get_active_transition(): ActiveTransition | null;
+    get_blend_tree_ids(): Set<string>;
+    is_blend_tree_state(id: string): boolean;
+    get_blend_tree_config(id: string): BlendTreeConfig | null;
+    get_clip_progress(_stateId: string): number;
+    get_parameters_map(): Map<string, Parameter>;
+    add_listener(event: AnimationEvent, callback: EventCallback): void;
+    remove_listener(event: AnimationEvent, callback: EventCallback): void;
+    private emit_event;
+}
+
+declare class AnimatrixVisualizer {
+    private animator;
+    private animators;
+    private current_animator_name;
+    private canvas;
+    private ctx;
+    private node_positions;
+    private is_visible;
+    private container;
+    private auto_layout_complete;
+    private animation_frame_id;
+    private event_listeners;
+    private readonly NODE_RADIUS;
+    private readonly NODE_COLOR_IDLE;
+    private readonly NODE_COLOR_ACTIVE;
+    private readonly NODE_COLOR_TRANSITIONING;
+    private readonly NODE_COLOR_BLENDTREE;
+    private readonly CONNECTION_COLOR;
+    private readonly CONNECTION_COLOR_ACTIVE;
+    private readonly TEXT_COLOR;
+    private readonly BG_COLOR;
+    private viewScale;
+    private panX;
+    private panY;
+    private isPanningView;
+    private panStart;
+    private isDraggingWindow;
+    private dragWindowOffset;
+    private isResizingWindow;
+    private resizeStart;
+    private isMinimized;
+    private nodeDrawerOpen;
+    private hoveredChevron;
+    private pendingLabels;
+    private drillDownState;
+    private drillDownTreeConfig;
+    private lastClickTime;
+    private lastClickNode;
+    private getLOD;
+    constructor(animator?: Animatrix, name?: string);
+    add_animator(name: string, animator: Animatrix): void;
+    remove_animator(name: string): void;
+    set_animator(name: string | null): void;
+    private setup_animator_listeners;
+    private cleanup_animator_listeners;
+    private update_animator_select;
+    private update_title;
+    private start_animation_loop;
+    private auto_layout_nodes;
+    private detectCycles;
+    private radialLayout;
+    private sortNodesByConnectivity;
+    private forceDirectedRefinement;
+    private buildGraph;
+    private assignLayers;
+    private minimizeCrossings;
+    private orderLayerByBarycenter;
+    private assignCoordinates;
+    private priorityLayoutAdjustment;
+    private dragging_node;
+    private drag_offset;
+    private handle_mouse_down;
+    private handle_mouse_move;
+    private handle_mouse_up;
+    private handle_wheel;
+    private start_window_drag;
+    private on_window_drag;
+    private stop_window_drag;
+    private start_window_resize;
+    private on_window_resize;
+    private stop_window_resize;
+    private toggle_minimize;
+    private update_canvas_size;
+    private render;
+    private enterDrillDown;
+    private exitDrillDown;
+    private render_drill_down_view;
+    private draw_connections;
+    private getRectEdgePoint;
+    private draw_nodes;
+    private get_node_dimensions;
+    private queue_label;
+    private draw_labels_screen_space;
+    private draw_chevron;
+    private draw_rounded_rect;
+    private draw_playback_indicator;
+    private update_parameters_panel;
+    toggle_visibility(): void;
+    show(): void;
+    hide(): void;
+    destroy(): void;
+}
+
+declare class AnimationLibrary {
+    private static clips;
+    private static loader;
+    private static debug;
+    private static readonly ACCESSORY_PREFIXES;
+    static setDebug(enabled: boolean): void;
+    static loadAnimation(id: string, path: string): Promise<THREE.AnimationClip>;
+    static loadAnimations(paths: {
+        [id: string]: string;
+    }): Promise<void>;
+    static registerClip(id: string, clip: THREE.AnimationClip): void;
+    static getClip(id: string): THREE.AnimationClip | undefined;
+    static cloneClip(id: string): THREE.AnimationClip | undefined;
+    static getAllClips(): Map<string, THREE.AnimationClip>;
+    static hasClip(id: string): boolean;
+}
+
+/**
+ * Simplified component wrapper for Animatrix animation visualization
+ * Note: For actual animation playback, use AnimationGraphComponent which uses SharedAnimationManager
+ */
+declare class AnimationControllerComponent extends Component {
+    private static instances;
+    private static sharedVisualizer;
+    private static debugViewEnabled;
+    private animator;
+    private debug;
+    constructor(debug?: boolean);
+    static setDebugViewEnabled(enabled: boolean): void;
+    static isDebugViewEnabled(): boolean;
+    getAnimator(): Animatrix | null;
+    addParameter(name: string, type: ParameterType, initialValue?: any): void;
+    setBool(name: string, value: boolean): void;
+    setFloat(name: string, value: number): void;
+    setInt(name: string, value: number): void;
+    setState(stateId: string): boolean;
+    getCurrentState(): string | null;
+    stopAll(): void;
+    protected onCreate(): void;
+    protected onCleanup(): void;
+    update(deltaTime: number): void;
+}
+
+/**
+ * Component for managing animation library functionality
+ * Provides centralized animation loading and caching as a component
+ */
+declare class AnimationLibraryComponent extends Component {
+    private loadedAnimations;
+    private debug;
+    constructor(debug?: boolean);
+    /**
+     * Load a single animation and add it to the library
+     */
+    loadAnimation(id: string, path: string): Promise<THREE.AnimationClip>;
+    /**
+     * Load multiple animations in parallel
+     */
+    loadAnimations(paths: {
+        [id: string]: string;
+    }): Promise<void>;
+    /**
+     * Get an animation clip from the library
+     */
+    getClip(id: string): THREE.AnimationClip | undefined;
+    /**
+     * Get a cloned copy of an animation clip
+     */
+    cloneClip(id: string): THREE.AnimationClip | undefined;
+    /**
+     * Check if an animation is loaded in the library
+     */
+    hasClip(id: string): boolean;
+    /**
+     * Get all loaded animations
+     */
+    getAllClips(): Map<string, THREE.AnimationClip>;
+    /**
+     * Get list of animations loaded by this component instance
+     */
+    getLoadedAnimationIds(): string[];
+    /**
+     * Set debug mode for the animation library
+     */
+    setDebug(enabled: boolean): void;
+    protected onCreate(): void;
+    protected onCleanup(): void;
+    onEnabled(): void;
+    onDisabled(): void;
+    /**
+     * Preload a standard set of character animations
+     * Useful for common character animation setups
+     */
+    preloadCharacterAnimations(basePath?: string): Promise<void>;
+    /**
+     * Check if all required animations are loaded
+     */
+    hasAllAnimations(requiredIds: string[]): boolean;
+    /**
+     * Get missing animations from a required list
+     */
+    getMissingAnimations(requiredIds: string[]): string[];
+}
+
+/**
+ * Component for visualizing animation state machines
+ * Provides debug visualization functionality as a component
+ */
+declare class AnimationVisualizerComponent extends Component {
+    private visualizer;
+    private animationController;
+    private name;
+    constructor(name?: string);
+    /**
+     * Set the animation controller to visualize
+     */
+    setAnimationController(controller: AnimationControllerComponent): void;
+    /**
+     * Get the underlying visualizer instance
+     */
+    getVisualizer(): AnimatrixVisualizer | null;
+    /**
+     * Show the visualizer UI
+     */
+    show(): void;
+    /**
+     * Hide the visualizer UI
+     */
+    hide(): void;
+    /**
+     * Toggle visualizer visibility
+     */
+    toggleVisibility(): void;
+    /**
+     * Check if visualizer is currently visible
+     */
+    isVisible(): boolean;
+    /**
+     * Destroy the visualizer UI
+     */
+    destroyVisualizer(): void;
+    protected onCreate(): void;
+    protected onCleanup(): void;
+    onEnabled(): void;
+    onDisabled(): void;
+    /**
+     * Auto-setup: find an AnimationControllerComponent on the same GameObject and connect to it
+     */
+    autoConnectToController(): boolean;
+    /**
+     * Connect to a specific animation controller component from another GameObject
+     */
+    connectToController(controller: AnimationControllerComponent): void;
+}
+
+interface ParameterConfig {
+    type: "bool" | "float" | "int";
+    default: any;
+}
+interface AnimationTreeChild {
+    animation: string;
+    threshold: number;
+}
+interface AnimationTree {
+    parameter: string;
+    children: AnimationTreeChild[];
+}
+interface StateConfig {
+    animation?: string;
+    tree?: AnimationTree;
+    randomizeStartTime?: boolean;
+}
+interface TransitionConfig {
+    from: string;
+    to: string;
+    when?: Record<string, any>;
+    /** Exit time as a normalized value (0-1). If true, defaults to 1.0 (end of animation) */
+    exitTime?: number | boolean;
+}
+interface AnimationGraphConfig {
+    parameters?: Record<string, ParameterConfig>;
+    states: Record<string, StateConfig>;
+    transitions?: TransitionConfig[];
+    initialState: string;
+    debug?: boolean;
+}
+interface StoredTreeConfig {
+    stateName: string;
+    tree: AnimationTree | null;
+    simpleAnimation: string | null;
+}
+declare class AnimationGraphComponent extends Component {
+    private static instances;
+    private static instancesByName;
+    private static sharedVisualizer;
+    private static debugViewEnabled;
+    private static treeConfigs;
+    private config;
+    private readonly model;
+    private controller;
+    private sharedManager;
+    private animator;
+    private animatorName;
+    private parameters;
+    private currentState;
+    private currentAnimation;
+    private stateElapsedTime;
+    private currentStateDuration;
+    private transitionsByState;
+    private stateDurations;
+    private useFrustumCulling;
+    private boundingRadius;
+    private cullingManager;
+    constructor(model: THREE.Object3D, config: AnimationGraphConfig);
+    static setDebugViewEnabled(enabled: boolean): void;
+    static isDebugViewEnabled(): boolean;
+    static getTreeConfig(animatorName: string, stateName: string): StoredTreeConfig | null;
+    static getStateConfigs(animatorName: string): Map<string, StoredTreeConfig> | null;
+    static getParameterValue(animatorName: string, paramName: string): any;
+    static getCurrentAnimation(animatorName: string): string | null;
+    getAnimator(): Animatrix | null;
+    protected onCreate(): void;
+    private setupAnimationGraph;
+    /**
+     * Pre-index transitions by source state for O(1) lookup during update
+     */
+    private preIndexTransitions;
+    /**
+     * Cache state durations to avoid repeated AnimationLibrary lookups
+     */
+    private cacheStateDurations;
+    private storeTreeConfigs;
+    private registerAnimationClips;
+    private setupAnimatrix;
+    update(deltaTime: number): void;
+    private updateAnimation;
+    setParameter(name: string, value: any): void;
+    getParameter(name: string): any;
+    setState(stateName: string): void;
+    getCurrentState(): string | null;
+    /**
+     * Pause/unpause animation updates.
+     * Use for off-screen or distant characters to save CPU.
+     * @param paused If true, animation mixer won't update (bones freeze)
+     */
+    setPaused(paused: boolean): void;
+    /**
+     * Check if animation is paused
+     */
+    isPaused(): boolean;
+    /**
+     * Enable/disable frustum culling for this animator.
+     * When enabled, animation updates are skipped if the model is outside the camera frustum.
+     * @param enabled Whether to use frustum culling (default: true)
+     */
+    setFrustumCulling(enabled: boolean): void;
+    /**
+     * Set the bounding radius used for frustum culling.
+     * @param radius The sphere radius around the character (default: 2)
+     */
+    setBoundingRadius(radius: number): void;
+    /**
+     * Get the AnimationCullingManager instance for global culling settings.
+     * Use this to add cameras, configure distance culling, etc.
+     */
+    static getCullingManager(): AnimationCullingManager;
+    private getStateDuration;
+    private getStateRandomizeTime;
+    addEventListener(_event: string, _callback: (data?: any) => void): void;
+    protected onCleanup(): void;
+}
+
+/**
+ * Shared animation clip registry
+ * Stores clips once, characters create their own mixers
+ *
+ * Note: We tried using AnimationObjectGroup for true sharing, but it had
+ * issues with certain animations not applying to some character models.
+ * Per-character mixers are slightly less efficient but much more reliable.
+ */
+declare class SharedAnimationManager {
+    private static instance;
+    private clips;
+    private constructor();
+    static getInstance(): SharedAnimationManager;
+    /**
+     * Register an animation clip once
+     */
+    registerClip(name: string, clip: THREE.AnimationClip): void;
+    getClip(name: string): THREE.AnimationClip | undefined;
+    getRegisteredClipNames(): string[];
+    /**
+     * No-op for backward compatibility
+     * Per-character mixers update themselves
+     */
+    update(_deltaTime: number): void;
+}
+/**
+ * Per-character animation controller with its own mixer
+ * Uses shared clips from SharedAnimationManager for memory efficiency
+ */
+declare class CharacterAnimationController {
+    private manager;
+    private mixer;
+    private actions;
+    private currentAnimation;
+    private crossfadeDuration;
+    private isPaused;
+    constructor(model: THREE.Object3D, manager: SharedAnimationManager);
+    /**
+     * Pause animation updates (for off-screen or distant characters)
+     */
+    setPaused(paused: boolean): void;
+    /**
+     * Check if animation is paused
+     */
+    getIsPaused(): boolean;
+    /**
+     * Set the crossfade duration for animation transitions
+     */
+    setCrossfadeDuration(duration: number): void;
+    /**
+     * Play a single animation with crossfade transition
+     */
+    playAnimation(name: string, startTime?: number): void;
+    /**
+     * Update the mixer - MUST be called every frame
+     * Returns early if paused (for performance optimization of off-screen characters)
+     */
+    update(deltaTime: number): void;
+    /**
+     * Stop all animations
+     */
+    stopAll(): void;
+    /**
+     * Cleanup
+     */
+    dispose(): void;
+}
+
+/**
+ * Console filter stub - kept for backwards compatibility
+ * Filtering is no longer needed as animations are pre-cleaned
+ */
+declare class AnimationConsoleFilter {
+    private static isFilterActive;
+    /**
+     * Enable filtering of PropertyBinding warnings for missing animation targets
+     * NOTE: This is no longer needed as we're pre-cleaning animations
+     */
+    static enable(): void;
+    /**
+     * Disable the console filter
+     */
+    static disable(): void;
+    /**
+     * Check if the filter is currently active
+     */
+    static isActive(): boolean;
+}
+
+/**
+ * Simple performance utilities for the animation system
+ * Focuses on reducing skin influences and cleaning up animation tracks
+ */
+declare class AnimationPerformance {
+    /**
+     * Reduce the number of bone influences per vertex for better mobile performance
+     * @param skinnedMesh The skinned mesh to optimize
+     * @param maxInfluences Maximum number of bone influences per vertex (default 2)
+     */
+    static reduceSkinInfluences(skinnedMesh: THREE.SkinnedMesh, maxInfluences?: number): void;
+    /**
+     * Clean up animation clip by removing tracks for non-bone objects
+     * This prevents PropertyBinding warnings and improves performance
+     * Removes tracks for accessories, hair, hats, etc that are mesh names not bones
+     *
+     * IMPORTANT: Returns a NEW clip, does not modify the original
+     */
+    static cleanAnimationClip(clip: THREE.AnimationClip, model: THREE.Object3D, silent?: boolean): THREE.AnimationClip;
+    /**
+     * Process all skinned meshes in a model to reduce influences
+     */
+    static optimizeModelForMobile(model: THREE.Object3D, maxInfluences?: number): void;
+    /**
+     * Clean all animation clips in a mixer to remove missing bone tracks
+     */
+    static cleanMixerAnimations(mixer: THREE.AnimationMixer, model: THREE.Object3D): void;
+    /**
+     * Check if running on a mobile device
+     */
+    static isMobile(): boolean;
+    /**
+     * Get recommended settings based on platform
+     */
+    static getRecommendedSettings(): {
+        maxSkinInfluences: number;
+        enableDebugLogs: boolean;
+    };
+}
+
+/**
+ * Configuration for spline debug visualization
+ */
+interface SplineDebugConfig {
+    showWaypoints?: boolean;
+    showCurve?: boolean;
+    showDirection?: boolean;
+    waypointSize?: number;
+    waypointColor?: THREE.Color;
+    curveColor?: THREE.Color;
+}
+/**
+ * Global manager for spline debug visualization
+ * Allows centralized control of debug rendering for all splines
+ */
+declare class SplineDebugManager {
+    private static instance;
+    private registrations;
+    private debugEnabled;
+    private defaultConfig;
+    private constructor();
+    /**
+     * Get the singleton instance
+     */
+    static getInstance(): SplineDebugManager;
+    /**
+     * Register a spline for debug visualization
+     */
+    registerSpline(spline: SplineThree, config?: SplineDebugConfig): void;
+    /**
+     * Unregister a spline from debug visualization
+     */
+    unregisterSpline(spline: SplineThree): void;
+    /**
+     * Enable debug visualization for all registered splines
+     */
+    setDebugEnabled(enabled: boolean): void;
+    /**
+     * Check if debug is currently enabled
+     */
+    isDebugEnabled(): boolean;
+    /**
+     * Get the number of registered splines
+     */
+    getRegisteredCount(): number;
+    /**
+     * Create debug visualization for a specific spline
+     */
+    private createDebugVisualization;
+    /**
+     * Destroy debug visualization for a specific spline
+     */
+    private destroyDebugVisualization;
+    /**
+     * Update configuration for the default debug visualization
+     */
+    setDefaultConfig(config: SplineDebugConfig): void;
+    /**
+     * Clear all registrations (useful for cleanup/testing)
+     */
+    clear(): void;
+}
+
+interface SplinePointThree {
+    position: THREE.Vector3;
+    index: number;
+}
+interface SplineSegmentThree {
+    startPoint: SplinePointThree;
+    endPoint: SplinePointThree;
+    length: number;
+}
+declare enum SplineTypeThree {
+    LINEAR = "linear",
+    CATMULL_ROM = "catmull_rom",
+    BEZIER = "bezier"
+}
+interface SplineConfigThree {
+    type: SplineTypeThree;
+    resolution: number;
+    tension?: number;
+    closed?: boolean;
+}
+/**
+ * A flexible spline system for Three.js that can create smooth curves through waypoints
+ */
+declare class SplineThree {
+    private waypoints;
+    private config;
+    private interpolatedPoints;
+    private segments;
+    private totalLength;
+    private cumulativeDistances;
+    private debugEnabled;
+    private debugConfig;
+    constructor(config?: SplineConfigThree);
+    /**
+     * Set the waypoints for the spline
+     */
+    setWaypoints(waypoints: THREE.Vector3[]): void;
+    /**
+     * Get a point along the spline at parameter t (0-1)
+     */
+    getPointAt(t: number): THREE.Vector3;
+    /**
+     * Get the direction (tangent) at parameter t (0-1)
+     */
+    getDirectionAt(t: number): THREE.Vector3;
+    /**
+     * Convert a distance along the spline to a t parameter (0-1)
+     * Uses the cumulative distance lookup table for accurate distance-based parameterization
+     */
+    private getTFromDistance;
+    /**
+     * Get a point at a specific distance from the start
+     * This now uses proper distance-based parameterization
+     */
+    getPointAtDistance(distance: number): THREE.Vector3;
+    /**
+     * Get the direction (tangent) at a specific distance from the start
+     * This now uses proper distance-based parameterization
+     */
+    getDirectionAtDistance(distance: number): THREE.Vector3;
+    /**
+     * Find the closest point on the spline to a given position
+     */
+    getClosestPoint(position: THREE.Vector3): {
+        point: THREE.Vector3;
+        t: number;
+        distance: number;
+    };
+    /**
+     * Get the total length of the spline
+     */
+    getTotalLength(): number;
+    /**
+     * Get all interpolated points
+     */
+    getInterpolatedPoints(): THREE.Vector3[];
+    /**
+     * Get the original waypoints (not interpolated points)
+     */
+    getWaypoints(): THREE.Vector3[];
+    /**
+     * Get the segments of the spline
+     */
+    getSegments(): SplineSegmentThree[];
+    /**
+     * Position a GameObject at parameter t along the spline with proper rotation
+     */
+    setGameObjectAt(gameObject: any, t: number): void;
+    /**
+     * Generate the spline interpolation
+     */
+    private generateSpline;
+    /**
+     * Generate linear interpolation between waypoints
+     */
+    private generateLinearSpline;
+    /**
+     * Generate Catmull-Rom spline interpolation
+     */
+    private generateCatmullRomSpline;
+    /**
+     * Catmull-Rom interpolation function
+     */
+    private catmullRomInterpolate;
+    /**
+     * Generate Bezier spline (simplified - using quadratic Bezier)
+     */
+    private generateBezierSpline;
+    /**
+     * Quadratic Bezier interpolation
+     */
+    private quadraticBezier;
+    /**
+     * Calculate segments between interpolated points
+     */
+    private calculateSegments;
+    /**
+     * Calculate total length of the spline and build cumulative distance lookup table
+     */
+    private calculateTotalLength;
+    /**
+     * Enable debug visualization for this spline
+     */
+    enableDebug(config?: SplineDebugConfig): void;
+    /**
+     * Disable debug visualization for this spline
+     */
+    disableDebug(): void;
+    /**
+     * Check if debug is enabled for this spline
+     */
+    isDebugEnabled(): boolean;
+    /**
+     * Get the debug configuration for this spline
+     */
+    getDebugConfig(): SplineDebugConfig | undefined;
+    /**
+     * Dispose of the spline and unregister from debug manager
+     */
+    dispose(): void;
+}
+
+interface SplineDebugOptionsThree {
+    showWaypoints?: boolean;
+    showCurve?: boolean;
+    showDirection?: boolean;
+    waypointSize?: number;
+    waypointColor?: THREE.Color;
+    curveColor?: THREE.Color;
+    directionColor?: THREE.Color;
+    directionLength?: number;
+    directionSpacing?: number;
+}
+/**
+ * Three.js component for debugging and visualizing splines
+ */
+declare class SplineDebugRendererThree extends Component {
+    private spline;
+    private options;
+    private waypointMeshes;
+    private curveLine;
+    private directionArrows;
+    private parentGroup;
+    constructor(spline: SplineThree, options?: SplineDebugOptionsThree);
+    protected onCreate(): void;
+    protected onCleanup(): void;
+    update(deltaTime: number): void;
+    /**
+     * Update the visualization (call this if the spline changes)
+     */
+    refresh(): void;
+    /**
+     * Show or hide waypoints
+     */
+    setShowWaypoints(show: boolean): void;
+    /**
+     * Show or hide the curve
+     */
+    setShowCurve(show: boolean): void;
+    /**
+     * Show or hide direction arrows
+     */
+    setShowDirection(show: boolean): void;
+    /**
+     * Create all debug visualization elements
+     */
+    private createDebugVisualization;
+    /**
+     * Create waypoint spheres
+     */
+    private createWaypoints;
+    /**
+     * Create the curve line
+     */
+    private createCurve;
+    /**
+     * Create direction arrows along the spline
+     */
+    private createDirectionArrows;
+    /**
+     * Create a single direction arrow
+     */
+    private createArrow;
+    /**
+     * Clear all visualization elements
+     */
+    private clearVisualization;
+}
+
+declare const AudioSystem: AudioSystemInstance;
+declare const Main2DAudioBank: AudioBank2D;
+declare const Main3DAudioBank: AudioBank3D;
+type AudioSystemInstance = {
+    mainListener: THREE.AudioListener | null;
+    initialize(): void;
+};
+type AudioBank2D = {
+    [key: string]: THREE.Audio;
+};
+type AudioBank3D = {
+    [key: string]: THREE.PositionalAudio;
+};
+type AudioClip2DConfig = {
+    path: string;
+    volume?: number;
+};
+type AudioClip3DConfig = {
+    path: string;
+    volume?: number;
+};
+declare function PopulateAudioBank2D(systemInstance: AudioSystemInstance, audioBank: AudioBank2D, clips: AudioClip2DConfig[]): Promise<void>;
+declare function PopulateAudioBank3D(systemInstance: AudioSystemInstance, audioBank: AudioBank3D, clips: AudioClip3DConfig[]): Promise<void>;
+declare function PlayAudioOneShot2D(audioBank: AudioBank2D, audioClip: string): void;
+/**
+ * Play a random 2D audio clip from the provided list.
+ * Only clips that exist and are loaded in the provided bank will be considered.
+ * Returns the clip name that was played.
+ */
+declare function PlayAudioRandom2D(audioBank: AudioBank2D, clipNames: string[]): string;
+declare function PlayAudioOneShot3D(audioBank: AudioBank3D, audioClip: string, parentObject: THREE.Object3D): void;
+/** Set global master volume using Three.js AudioListener */
+declare function SetMasterVolume(volume: number): void;
+/** Get the last set (intended) master volume [0..1]. */
+declare function GetMasterVolume(): number;
+/** Toggle global mute using Three.js AudioListener */
+declare function SetAudioMuted(muted: boolean): void;
+/** Check if audio is currently muted globally. */
+declare function IsAudioMuted(): boolean;
+
+/**
+ * A simple 2D audio component that can be attached to any GameObject.
+ * Provides easy access to play 2D audio clips from a configured bank.
+ */
+declare class Audio2D extends Component {
+    private audioBank;
+    private availableClips;
+    /**
+     * Creates a new Audio2D component
+     * @param availableClips - Array of clip names this component can play (optional - if not provided, can play any clip in the bank)
+     */
+    constructor(availableClips?: string[]);
+    /**
+     * Play a 2D audio clip
+     * @param clipName - Name/path of the audio clip to play
+     */
+    play(clipName: string): void;
+    /**
+     * Check if a clip is available and loaded
+     * @param clipName - Name/path of the audio clip to check
+     */
+    isClipReady(clipName: string): boolean;
+    /**
+     * Get list of available clips (if configured)
+     */
+    getAvailableClips(): string[];
+    /**
+     * Add a clip to the available clips list
+     * @param clipName - Name/path of the audio clip to add
+     */
+    addAvailableClip(clipName: string): void;
+    /**
+     * Remove a clip from the available clips list
+     * @param clipName - Name/path of the audio clip to remove
+     */
+    removeAvailableClip(clipName: string): void;
+    protected onCreate(): void;
+    protected onCleanup(): void;
+}
+/**
+ * A 2D audio component that plays a random clip from a provided list.
+ * Uses the main 2D audio bank.
+ */
+declare class RandomAudio2D extends Component {
+    private audioBank;
+    private clipNames;
+    private avoidImmediateRepeat;
+    private lastPlayed;
+    /**
+     * @param clipNames - List of clip paths to randomly play (must be in Main2DAudioBank)
+     * @param avoidImmediateRepeat - If true, avoids choosing the same clip twice in a row when possible
+     */
+    constructor(clipNames: string[], avoidImmediateRepeat?: boolean);
+    /**
+     * Play a random clip from the list. Returns the chosen clip name.
+     */
+    play(): string;
+    /** Replace the internal clip list. */
+    setClips(clipNames: string[]): void;
+    /** Get the internal clip list. */
+    getClips(): string[];
+    /** Add a single clip to the list. */
+    addClip(clipName: string): void;
+    /** Remove a single clip from the list. */
+    removeClip(clipName: string): void;
+    /** Check if all clips are present (and at least one is loaded) in the bank. */
+    isReady(): boolean;
+    protected onCreate(): void;
+    protected onCleanup(): void;
+}
+
+declare const MusicBank: MusicBankType;
+type MusicBankType = {
+    [key: string]: THREE.Audio;
+};
+interface MusicSystemState {
+    currentTrack: string | null;
+    isPlaying: boolean;
+    isPaused: boolean;
+    volume: number;
+    loop: boolean;
+    playlist: string[];
+    playlistIndex: number;
+    playlistActive: boolean;
+}
+declare const MusicSystem: MusicSystemState;
+/**
+ * Populate the music bank with audio files
+ * @param systemInstance - The audio system instance
+ * @param musicBank - The music bank to populate
+ * @param musicList - Array of music file paths
+ */
+declare function PopulateMusicBank(systemInstance: AudioSystemInstance, musicBank: MusicBankType, musicList: string[]): Promise<void>;
+/**
+ * Play a music track
+ * @param musicBank - The music bank
+ * @param trackName - Name/path of the music track
+ * @param loop - Whether to loop the track (default: true)
+ */
+declare function PlayMusic(musicBank: MusicBankType, trackName: string, loop?: boolean): void;
+/**
+ * Pause the currently playing music
+ * @param musicBank - The music bank
+ */
+declare function PauseMusic(musicBank: MusicBankType): void;
+/**
+ * Resume the currently paused music
+ * @param musicBank - The music bank
+ */
+declare function ResumeMusic(musicBank: MusicBankType): void;
+/**
+ * Stop the currently playing music
+ * @param musicBank - The music bank
+ */
+declare function StopMusic(musicBank: MusicBankType): void;
+/**
+ * Set the volume for music playback
+ * @param volume - Volume level (0.0 to 1.0)
+ * @param musicBank - The music bank
+ */
+declare function SetMusicVolume(volume: number, musicBank: MusicBankType): void;
+/**
+ * Toggle music playback (play/pause)
+ * @param musicBank - The music bank
+ */
+declare function ToggleMusic(musicBank: MusicBankType): void;
+/**
+ * Check if a music track is ready to play
+ * @param musicBank - The music bank
+ * @param trackName - Name/path of the music track
+ */
+declare function IsMusicReady(musicBank: MusicBankType, trackName: string): boolean;
+/**
+ * Get the current music system state
+ */
+declare function GetMusicSystemState(): MusicSystemState;
+/**
+ * Crossfade to a new music track
+ * @param musicBank - The music bank
+ * @param newTrackName - Name/path of the new music track
+ * @param fadeDuration - Duration of the crossfade in milliseconds (default: 2000ms)
+ * @param loop - Whether to loop the new track (default: true)
+ */
+declare function CrossfadeToMusic(musicBank: MusicBankType, newTrackName: string, fadeDuration?: number, loop?: boolean): void;
+/**
+ * Start music with automatic handling of browser autoplay policies
+ * This utility function tries to play music immediately, and if blocked by autoplay policy,
+ * it sets up event listeners to start music on first user interaction.
+ *
+ * @param musicBank - The music bank
+ * @param trackName - Name/path of the music track to play
+ * @param loop - Whether to loop the track (default: true)
+ */
+declare function StartMusicWithAutoplayHandling(musicBank: MusicBankType, trackName: string, loop?: boolean): void;
+/**
+ * Start playing a playlist of tracks in rotation
+ * @param musicBank - The music bank
+ * @param trackNames - Array of track names to play in rotation
+ * @param startIndex - Index to start from (default: 0)
+ */
+declare function StartPlaylist(musicBank: MusicBankType, trackNames: string[], startIndex?: number): void;
+/**
+ * Stop the playlist and reset state
+ * @param musicBank - The music bank
+ */
+declare function StopPlaylist(musicBank: MusicBankType): void;
+/**
+ * Start playlist with automatic handling of browser autoplay policies
+ * @param musicBank - The music bank
+ * @param trackNames - Array of track names to play in rotation
+ */
+declare function StartPlaylistWithAutoplayHandling(musicBank: MusicBankType, trackNames: string[]): void;
+
+/**
+ * Configuration for loading from build.json.
+ */
+interface StowKitLoadConfig {
+    /**
+     * Material converter function - called when cloning meshes.
+     * Game provides this to apply custom materials (e.g., toon shaders).
+     * If not provided, materials are used as-is.
+     */
+    materialConverter?: (material: THREE.Material) => THREE.Material;
+    /**
+     * Function to fetch blob data from CDN.
+     * Required for loading packs from mount paths.
+     */
+    fetchBlob: (path: string) => Promise<Blob>;
+    /**
+     * Decoder paths for StowKit loaders.
+     */
+    decoderPaths?: {
+        basis?: string;
+        draco?: string;
+        wasm?: string;
+    };
+}
+/**
+ * StowKitSystem - Simple asset loading from build.json.
+ *
+ * Usage:
+ * ```typescript
+ * // Load everything from build.json - that's it!
+ * const prefabs = await StowKitSystem.getInstance().loadFromBuildJson(buildJson, {
+ *   materialConverter: (mat) => MaterialUtils.convertToToon(mat),
+ *   fetchBlob: (path) => RundotGameAPI.cdn.fetchBlob(path)
+ * })
+ *
+ * // Register instancing batches (optional, for frequently spawned items)
+ * await StowKitSystem.getInstance().registerMeshForInstancing("burger", "restaurant_display_Burger", 100)
+ *
+ * // Use prefabs - meshes load automatically
+ * const burgerStation = PrefabLoader.instantiate(prefabs.getPrefabByName("burger_station"))
+ * ```
+ */
+declare class StowKitSystem {
+    private static _instance;
+    private materialConverter?;
+    private decoderPaths;
+    private fetchBlob?;
+    private packs;
+    private meshes;
+    private textures;
+    private animations;
+    private audioFiles;
+    private _prefabCollection;
+    private loadMeshPromises;
+    private loadTexturePromises;
+    private loadAudioPromises;
+    private loadAnimationPromises;
+    private constructor();
+    static getInstance(): StowKitSystem;
+    /**
+     * Get the material converter function (if configured).
+     */
+    getMaterialConverter(): ((material: THREE.Material) => THREE.Material) | undefined;
+    /**
+     * Load everything from build.json.
+     * This is the main entry point - loads prefab collection and all packs from mounts.
+     *
+     * @param buildJson The build.json content (import directly or fetch)
+     * @param config Configuration including material converter and CDN fetch function
+     * @returns The loaded PrefabCollection
+     */
+    loadFromBuildJson(buildJson: unknown, config: StowKitLoadConfig): Promise<PrefabCollection>;
+    /**
+     * Load an additional pack by path.
+     * Use this for packs not referenced in prefab mounts (e.g., character packs).
+     *
+     * @param alias Unique alias for this pack
+     * @param path CDN path to the .stow file
+     */
+    loadPack(alias: string, path: string): Promise<void>;
+    /**
+     * Get the prefab collection.
+     */
+    getPrefabCollection(): PrefabCollection;
+    /**
+     * Get a prefab node by path from the "restaurant" prefab.
+     * Convenience method for game code.
+     */
+    getPrefab(path: string): PrefabNode;
+    /**
+     * Get a loaded pack by alias.
+     */
+    getPack(alias: string): StowKitPack | null;
+    /**
+     * Check if a pack is loaded.
+     */
+    isPackLoaded(alias: string): boolean;
+    /**
+     * Get a mesh by name. Loads on-demand if not cached.
+     * For synchronous access, use getMeshSync() after ensuring it's loaded.
+     */
+    getMesh(name: string): Promise<THREE.Group>;
+    /**
+     * Get a mesh synchronously. Returns null if not loaded yet.
+     */
+    getMeshSync(name: string): THREE.Group | null;
+    /**
+     * Check if a mesh is loaded.
+     */
+    isMeshLoaded(name: string): boolean;
+    private loadMeshFromPacks;
+    /**
+     * Load a skinned mesh (for characters).
+     */
+    getSkinnedMesh(name: string, scale?: number): Promise<THREE.Group>;
+    private loadSkinnedMeshFromPacks;
+    /**
+     * Clone a mesh with material conversion and shadow settings.
+     */
+    cloneMesh(meshName: string, castShadow?: boolean, receiveShadow?: boolean): Promise<THREE.Group>;
+    /**
+     * Clone an already-loaded mesh synchronously.
+     */
+    cloneMeshSync(original: THREE.Group, castShadow?: boolean, receiveShadow?: boolean): THREE.Group;
+    /**
+     * Get a texture by name. Loads on-demand if not cached.
+     */
+    getTexture(name: string): Promise<THREE.Texture>;
+    /**
+     * Get a texture synchronously. Returns null if not loaded yet.
+     */
+    getTextureSync(name: string): THREE.Texture | null;
+    private loadTextureFromPacks;
+    /**
+     * Get an animation by name. Loads on-demand if not cached.
+     * @param name Animation name
+     * @param meshName Mesh to load animation with (required for first load)
+     */
+    getAnimation(name: string, meshName?: string): Promise<THREE.AnimationClip>;
+    /**
+     * Get an animation synchronously. Returns null if not loaded yet.
+     */
+    getAnimationSync(name: string): THREE.AnimationClip | null;
+    /**
+     * Get all loaded animations.
+     */
+    getAllAnimations(): Map<string, THREE.AnimationClip>;
+    private loadAnimationFromPacks;
+    /**
+     * Get audio by name. Loads on-demand if not cached.
+     */
+    getAudio(name: string): Promise<THREE.Audio>;
+    /**
+     * Get audio synchronously. Returns null if not loaded yet.
+     */
+    getAudioSync(name: string): THREE.Audio | null;
+    /**
+     * Get all loaded audio.
+     */
+    getAllAudio(): Map<string, THREE.Audio>;
+    private loadAudioFromPacks;
+    /**
+     * Register a mesh for GPU instancing.
+     * Batch auto-grows as needed, so initialCapacity is optional.
+     */
+    registerMeshForInstancing(batchKey: string, meshName: string, castShadow?: boolean, receiveShadow?: boolean, initialCapacity?: number): Promise<boolean>;
+    /**
+     * Register a batch for GPU instancing from a prefab.
+     * Extracts the mesh name from the prefab's stow_mesh component.
+     * Batch auto-grows as needed, so initialCapacity is optional.
+     */
+    registerBatchFromPrefab(prefabName: string, castShadow?: boolean, receiveShadow?: boolean, initialCapacity?: number): Promise<boolean>;
+    private extractGeometry;
+    private createMaterial;
+    /**
+     * Get bounds of a mesh group.
+     */
+    getBounds(meshGroup: THREE.Group): THREE.Vector3;
+    /**
+     * Dispose of all loaded assets and reset the system.
+     */
+    dispose(): void;
+}
+
+export { type AABB, type ActiveTransition, AmbientLightComponent, AnimationConsoleFilter, AnimationControllerComponent, AnimationCullingManager, type AnimationCurve, AnimationEvent, AnimationGraphComponent, AnimationLibrary, AnimationLibraryComponent, AnimationPerformance, AnimationVisualizerComponent, Animatrix, AnimatrixVisualizer, Audio2D, type AudioBank2D, type AudioBank3D, type AudioClip2DConfig, type AudioClip3DConfig, AudioSystem, type AudioSystemInstance, type BlendTreeConfig, BlendType, BoxColliderComponent, type BurstConfig, CharacterAnimationController, type ClipInfo, ComparisonOperator, ComponentJSON, CrossfadeToMusic, type CurveKeyframe, CurvePresets, type CurveableValue, DEFAULT_KEY_BINDINGS, DebugPanelThree, DirectionalLightComponent, DynamicNavSystem, Easing, type EmissionConfig, type EmitterAssets, type EmitterConfig, EmitterShape, type EmitterShapeKey, type FlipConfig, type Footprint, GetMasterVolume, GetMusicSystemState, Input, InputAction, InputManager, IsAudioMuted, IsMusicReady, Main2DAudioBank, Main3DAudioBank, MaterialUtils, MathUtil, MeshColliderComponent, MusicBank, type MusicBankType, MusicSystem, type MusicSystemState, NavAgent, NavigationGrid, type NoiseConfig, type NumRange, type Parameter, ParameterType, Particle, type ParticleSystem, ParticleSystemPrefabComponent, PathVisualizationThree, type PathfindingResult, PauseMusic, PhysicsSystem, PlayAudioOneShot2D, PlayAudioOneShot3D, PlayAudioRandom2D, PlayMusic, PopulateAudioBank2D, PopulateAudioBank3D, PopulateMusicBank, Prefab, PrefabCollection, PrefabCollectionJSON, PrefabComponent, PrefabComponentConstructor, PrefabInstance, type PrefabInstantiateOptions, PrefabJSON, PrefabLoader, PrefabNode, RandomAudio2D, type RenderMode, RenderingDebugger, ResumeMusic, RigidBodyComponentThree, SecondOrderDynamics, SecondOrderDynamics1D, SetAudioMuted, SetMasterVolume, SetMusicVolume, SharedAnimationManager, type SplineConfigThree, type SplineDebugConfig, SplineDebugManager, type SplineDebugOptionsThree, SplineDebugRendererThree, type SplinePointThree, type SplineSegmentThree, SplineThree, SplineTypeThree, StartMusicWithAutoplayHandling, StartPlaylist, StartPlaylistWithAutoplayHandling, StopMusic, StopPlaylist, type StowKitLoadConfig, StowKitSystem, ToggleMusic, type TransitionCondition, type TransitionConfig$1 as TransitionConfig, Tween, TweenSystem, type UIElement, UILoadingScreen, type UIProgressBar, UISystem, UIUtils, type UIWorldElement, type Waypoint, addKeyframe, cloneCurve, createCurveFromPoints, createKeyframe, createParticleEmitter, evaluateCurve, evaluateCurveableValue, range, removeKeyframe, updateKeyframe };