@skewedaspect/sage 0.9.6 → 0.10.0-beta.2

package/dist/behaviors/sound.d.ts

@@ -1,137 +1,22 @@
-import { TransformNode } from '@babylonjs/core';
-import { GameEntityBehavior } from "../classes/entity.d.ts";
-import { GameEngine } from "../classes/gameEngine.d.ts";
-import { GameEvent } from "../classes/eventBus.d.ts";
-/**
- * Configuration for a single sound.
- */
+import { Behavior } from '@skewedaspect/sage-core';
+import { NodeBehaviorHooks } from "../entities/nodeEntity.d.ts";
 export interface SoundConfig {
-    /** Path to the sound file */
     url: string;
-    /** Volume level (0-1), default 1 */
     volume?: number;
-    /** Whether to loop the sound, default false */
     loop?: boolean;
-    /** Whether to use spatial 3D audio, default false */
     spatial?: boolean;
-    /** Maximum distance for spatial audio, default 100 */
     maxDistance?: number;
-    /** Whether to autoplay when registered, default false */
-    autoplay?: boolean;
-    /** Audio channel name (e.g., 'sfx', 'music'). Used with AudioManager. */
     channel?: string;
 }
-/**
- * State interface for entities using SoundBehavior.
- * Entity state should include a `sounds` property with sound configurations.
- */
-export interface SoundEntityState {
-    /** Map of sound name to configuration */
-    sounds?: Record<string, SoundConfig>;
+export interface SoundState {
+    sounds: Record<string, SoundConfig>;
 }
-/**
- * Behavior for managing sounds on an entity.
- *
- * Sounds are configured in the entity's state under the `sounds` property.
- * The behavior creates sounds via AudioManager (BabylonJS AudioV2).
- *
- * Requires AudioManager to be configured on the GameEngine. If no AudioManager is found,
- * a warning is logged and no sounds are created.
- *
- * @example
- * ```typescript
- * // Entity definition
- * {
- *     type: 'player',
- *     behaviors: [SoundBehavior, ...],
- *     defaultState: {
- *         sounds: {
- *             jump: { url: 'sounds/jump.mp3', volume: 0.8, channel: 'sfx' },
- *             footstep: { url: 'sounds/footstep.mp3', loop: true, channel: 'sfx' }
- *         }
- *     }
- * }
- *
- * // In another behavior, get the sound behavior and control sounds
- * const soundBehavior = entity.getBehavior(SoundBehavior);
- * soundBehavior?.play('jump');
- * ```
- */
-export declare class SoundBehavior extends GameEntityBehavior<SoundEntityState> {
-    name: string;
-    eventSubscriptions: string[];
-    /** Map of sound name to StaticSound instance */
-    private _sounds;
-    /** Whether sounds have been initialized */
-    private _initialized;
-    /** AudioManager reference */
-    private _audioManager;
-    /** Node reference for spatial detach on cleanup */
-    private _node;
-    private _log;
-    onNodeAttached(node: TransformNode, gameEngine: GameEngine): void;
-    processEvent(_event: GameEvent, _state: SoundEntityState): boolean;
-    onReset(_state: SoundEntityState): void;
-    destroy(): Promise<void>;
-    private _createSound;
-    private _disposeSounds;
-    /**
-     * Play a sound by name.
-     *
-     * @param name - The name of the sound to play. If omitted and only one sound exists, plays that sound.
-     * @param time - Optional time offset in seconds to start playing from
-     */
-    play(name?: string, time?: number): void;
-    /**
-     * Stop a sound by name.
-     *
-     * @param name - The name of the sound to stop. If omitted, stops all sounds.
-     */
-    stop(name?: string): void;
-    /**
-     * Pause a sound by name.
-     *
-     * @param name - The name of the sound to pause. If omitted and only one sound exists, pauses that sound.
-     */
-    pause(name?: string): void;
-    /**
-     * Set the volume of a sound.
-     *
-     * @param volume - Volume level (0-1)
-     * @param name - The name of the sound. If omitted, sets volume for all sounds.
-     */
-    setVolume(volume: number, name?: string): void;
-    /**
-     * Check if a sound is currently playing.
-     *
-     * @param name - The name of the sound. If omitted and only one sound exists, checks that sound.
-     */
-    isPlaying(name?: string): boolean;
-    /**
-     * Get all registered sound names.
-     */
-    getSoundNames(): string[];
-    /**
-     * Check if a sound with the given name exists.
-     *
-     * @param name
-     */
-    hasSound(name: string): boolean;
-    /**
-     * Register a new sound at runtime. Replaces any existing sound with the same name.
-     *
-     * @param name
-     * @param config
-     */
-    registerSound(name: string, config: SoundConfig): void;
-    /**
-     * Unregister and dispose a sound.
-     *
-     * @param name
-     */
-    unregisterSound(name: string): void;
-    /**
-     * Get a sound by name. If name is omitted and only one sound exists, returns that sound.
-     */
-    private _getSound;
+export declare class SoundBehavior extends Behavior<SoundState> implements NodeBehaviorHooks {
+    #private;
+    static readonly ops: readonly ["play", "stop"];
+    readonly defaults: SoundState;
+    onMeshLoaded(): void;
+    onDestroy(): void;
+    play(name: string): void;
+    stop(name: string): void;
 }

package/dist/classes/debugConsole.d.ts

@@ -14,6 +14,7 @@ export declare class DebugConsole implements Disposable {
     $teardown(): Promise<void>;
     private _isDynamicGetter;
     private _getNamespace;
+    private _assertNamespaceFree;
     private _installNamespace;
     private _removeNamespace;
     private _defineGetter;

package/dist/classes/gameEngine.d.ts

@@ -1,28 +1,28 @@
-import { AbstractEngine, HavokPlugin } from '@babylonjs/core';
-import { GameCanvas } from "../interfaces/game.d.ts";
+import { AbstractEngine, HavokPlugin, Scene } from '@babylonjs/core';
+import { EntityMeshLoader, GameCanvas } from "../interfaces/game.d.ts";
 import { Disposable } from "../interfaces/lifecycle.d.ts";
+import { NodeSimulation } from "../entities/nodeSimulation.d.ts";
 import { SceneEngine } from "../engines/scene.d.ts";
 import { AudioEngine } from "../engines/audio.d.ts";
 import { AssetManager } from "../managers/asset.d.ts";
-import { BindingManager } from "../managers/binding.d.ts";
 import { ColliderDebugManager } from "../managers/colliderDebug.d.ts";
 import { DebugConsole } from "./debugConsole.d.ts";
 import { GameManager } from "../managers/game.d.ts";
-import { GameEntityManager } from "../managers/entity.d.ts";
+import { InputManager } from "../managers/input.d.ts";
 import { LevelManager } from "../managers/level.d.ts";
-import { SaveManager } from "../managers/save.d.ts";
-import { UserInputManager } from "../managers/input.d.ts";
+import { SimulationSaveManager } from "../managers/simulationSave.d.ts";
 import { AudioManager } from "../managers/audio.d.ts";
-import { GameEvent, GameEventBus, GameEventCallback, Unsubscribe } from "./eventBus.d.ts";
-import { ActionPayload, LibraryEventPayloadMap } from "../events/payloads.d.ts";
+import { GameEventBus, GameEventCallback, Unsubscribe } from "./eventBus.d.ts";
+import { LibraryEventPayloadMap } from "../events/payloads.d.ts";
 import { WildcardPattern } from "../events/types.d.ts";
 import { LoggingUtility } from "../utils/logger.d.ts";
-import { RaycastHelper } from "../utils/raycast.d.ts";
 import { GameTimer } from "../utils/timer.d.ts";
 /**
  * Type definition for game lifecycle hook functions
  */
 export type GameHook = (gameEngine: GameEngine) => Promise<void>;
+/** Builds a NodeSimulation bound to a scene and a mesh source -- a fresh one is built for every level that loads. */
+export type SimulationFactory = (scene: Scene, meshSource?: EntityMeshLoader) => NodeSimulation;
 /**
  * Interface representing the engines used in the game.
  * All engines must implement Disposable for proper cleanup.
@@ -37,12 +37,10 @@ interface Engines extends Record<string, Disposable | undefined> {
  */
 interface Managers extends Record<string, Disposable | undefined> {
     assetManager: AssetManager;
-    bindingManager: BindingManager;
     gameManager: GameManager;
-    entityManager: GameEntityManager;
-    inputManager: UserInputManager;
+    inputManager: InputManager;
     levelManager: LevelManager;
-    saveManager: SaveManager;
+    saveManager: SimulationSaveManager;
     audioManager?: AudioManager;
 }
 /**
@@ -65,12 +63,14 @@ export declare class GameEngine {
     engines: Engines;
     eventBus: GameEventBus;
     logger: LoggingUtility;
-    raycast: RaycastHelper;
+    simulation: NodeSimulation | null;
     timer: GameTimer;
     debug: DebugTools;
     largeWorldRendering: boolean;
     started: boolean;
+    private _stopped;
     private _log;
+    private _buildSimulation;
     private _beforeStartHook;
     private _onStartHook;
     private _onTeardownHook;
@@ -81,10 +81,18 @@ export declare class GameEngine {
      * @param physics
      * @param eventBus
      * @param logger
+     * @param timer
+     * @param buildSimulation - Builds a fresh simulation for a scene, once rebuildSimulation is called with one.
      * @param engines
      * @param managers
      */
-    constructor(canvas: GameCanvas, renderEngine: AbstractEngine, physics: HavokPlugin, eventBus: GameEventBus, logger: LoggingUtility, raycast: RaycastHelper, timer: GameTimer, engines: Engines, managers: Managers, largeWorldRendering?: boolean, debug?: DebugTools);
+    constructor(canvas: GameCanvas, renderEngine: AbstractEngine, physics: HavokPlugin, eventBus: GameEventBus, logger: LoggingUtility, timer: GameTimer, buildSimulation: SimulationFactory, engines: Engines, managers: Managers, largeWorldRendering?: boolean, debug?: DebugTools);
+    /**
+     * Builds a fresh NodeSimulation bound to the given scene and mesh source, and swaps it in. A level calls
+     * this once its own scene is ready, so every NodeEntity it spawns gets a node in that scene and loads its
+     * mesh through that source. Left unset, a spawned entity gets a node with no mesh.
+     */
+    rebuildSimulation(scene: Scene, meshSource?: EntityMeshLoader): NodeSimulation;
     /**
      * Register a function to be called before the game engine starts
      * @param hook
@@ -108,7 +116,7 @@ export declare class GameEngine {
      *
      * This is a convenience method that forwards to `eventBus.subscribe()`.
      *
-     * @param eventType - Exact event type string, wildcard pattern (e.g. 'input:*'), or RegExp
+     * @param eventType - Exact event type string, wildcard pattern (e.g. 'level:*'), or RegExp
      * @param callback
      * @returns A function that removes this subscription when called
      *
@@ -118,45 +126,22 @@ export declare class GameEngine {
      *     console.log('Level complete:', event.payload.levelName);
      * });
      *
-     * // Subscribe to all input events
-     * engine.subscribe('input:*', (event) => {
-     *     console.log('Input event:', event.type);
+     * // Subscribe to every level event
+     * engine.subscribe('level:*', (event) => {
+     *     console.log('Level event:', event.type);
      * });
      */
     subscribe<T extends keyof LibraryEventPayloadMap & string>(eventType: T | WildcardPattern | RegExp, callback: GameEventCallback<T, LibraryEventPayloadMap>): Unsubscribe;
-    /**
-     * Subscribe to an action event with full type safety.
-     *
-     * Action events are fired by the binding system when inputs trigger registered actions.
-     * All action events have the same payload structure (`ActionPayload`), containing:
-     * - `value`: The action value (number for analog, boolean for digital)
-     * - `deviceId`: The ID of the input device that triggered the action
-     * - `context`: The binding context that was active (optional)
-     *
-     * @param actionName - The action name (without the 'action:' prefix)
-     * @param callback
-     * @returns A function that removes this subscription when called
-     *
-     * @example
-     * // Subscribe to a specific action
-     * engine.subscribeAction('jump', (event) => {
-     *     console.log('Jump triggered with value:', event.payload.value);
-     *     console.log('From device:', event.payload.deviceId);
-     * });
-     *
-     * // Subscribe to movement action
-     * engine.subscribeAction('moveForward', (event) => {
-     *     const velocity = Number(event.payload.value);
-     *     player.move(velocity);
-     * });
-     */
-    subscribeAction(actionName: string, callback: (event: GameEvent<`action:${string}`, Record<`action:${string}`, ActionPayload>>) => void): Unsubscribe;
     /**
      * Start the engine: runs beforeStart hook, starts the game manager, then runs onStart hook.
      */
     start(): Promise<void>;
     /**
      * Stop the engine: runs the teardown hook, then tears down all managers and engines in order.
+     *
+     * Managers claim what they need when they are built, not when the engine starts -- the input manager's
+     * window listeners, the debug console's namespace -- so an engine that never started still has
+     * everything to release. Tearing down twice is the no-op.
      */
     stop(): Promise<void>;
 }

package/dist/classes/gameLevel.d.ts

@@ -1,6 +1,7 @@
 import { Quaternion, Scene, StaticSound, TransformNode, Vector3 } from '@babylonjs/core';
 import { LevelConfig, LevelContext } from "../interfaces/level.d.ts";
-import { GameEntity } from "./entity.d.ts";
+import { NodeEntity } from "../entities/nodeEntity.d.ts";
+import { NodeSimulation } from "../entities/nodeSimulation.d.ts";
 import { Level } from "./level.d.ts";
 /**
  * Metadata collected from a spawn point node.
@@ -33,7 +34,7 @@ export declare class GameLevel extends Level {
     /** Collected entity nodes from the scene */
     protected _entityNodes: EntityNodeData[];
     /** Entities spawned by this level */
-    protected _spawnedEntities: GameEntity[];
+    protected _spawnedEntities: NodeEntity[];
     /** Level-scoped sounds created from config */
     protected _levelSounds: Map<string, StaticSound>;
     /** Sounds that were playing before deactivation (for resume on activate) */
@@ -46,7 +47,12 @@ export declare class GameLevel extends Level {
      */
     constructor(config: LevelConfig, context: LevelContext);
     get config(): LevelConfig;
-    get spawnedEntities(): readonly GameEntity[];
+    get spawnedEntities(): readonly NodeEntity[];
+    /**
+     * The simulation this level built its scene against: the one its own spawns and despawns go through,
+     * whichever simulation the engine holds at the time. Throws before `buildScene` has bound one.
+     */
+    protected get simulation(): NodeSimulation;
     /**
      * Build the scene by loading assets, processing node metadata, and spawning entities.
      */
@@ -124,22 +130,25 @@ export declare class GameLevel extends Level {
      */
     private _processSpawnPoint;
     /**
-     * Apply debug collider visualization to an entity if configured.
-     * Level/spawn config takes priority over the entity definition's debugCollider.
-     */
-    private _applyDebugCollider;
-    /**
-     * Create an entity from a spawn definition, inheriting position/rotation/scaling from the spawn point.
+     * Spawn an entity through the simulation, inheriting position and rotation from the spawn point. The node
+     * and its mesh are the simulation's own business, built by NodeEntity's constructor from the class name and
+     * state -- the level does no mesh building of its own.
+     *
+     * A spawn point's scaling has nowhere to go: NodeEntityState declares position and rotation, not scaling,
+     * and inventing a state field for it is not this level's call to make. It is dropped.
      */
     private _spawnEntity;
     /**
-     * Create game entities for all nodes marked with the 'entity' metadata property.
+     * Match collected entity nodes against the level config's entity definitions and spawn entities adopting
+     * their marked node.
      */
     private _processEntityNodes;
     /**
-     * Create a game entity for an entity-tagged node, attaching the existing scene node to it.
+     * Spawn an entity adopting an entity marker's node. `nodeName` is the marked node's own name, written by
+     * the level rather than by configuration, since it is the binding key adoption resolves through
+     * (design/authoring.md#the-binding-key).
      */
-    private _processEntityNode;
+    private _spawnEntityNode;
     /**
      * Create level-scoped sounds from YAML config. Sounds are tracked for lifecycle management
      * (pause on deactivate, resume on activate, dispose on unload).

package/dist/classes/level.d.ts

@@ -1,28 +1,15 @@
-import { Color3, Quaternion, Scene, TransformNode, Vector3 } from '@babylonjs/core';
+import { Color3, Scene, TransformNode } from '@babylonjs/core';
 import { ClusteredLightContainer } from '@babylonjs/core/Lights/Clustered/clusteredLightContainer';
+import { NodeSimulation } from "../entities/nodeSimulation.d.ts";
 import { LoggerInterface } from "../interfaces/logger.d.ts";
-import { ColorConfig, LevelConfig, LevelContext, LevelInstance, PropertyHandler } from "../interfaces/level.d.ts";
-import { GameEntity } from "./entity.d.ts";
+import { ColorConfig, LevelConfig, LevelContext, LevelInstance, LevelLoadOptions, PropertyHandler } from "../interfaces/level.d.ts";
 import { GameEngine } from "./gameEngine.d.ts";
 import { OutlineManager } from "../managers/outline.d.ts";
-/**
- * Transform and visibility overrides applied to a mesh built by `Level.createEntityMesh()`.
- */
-export interface CreateEntityMeshOptions {
-    /** World position for the entity's root node. Left at the node default when omitted. */
-    position?: Vector3;
-    /** World rotation for the entity's root node. Left at the node default when omitted. */
-    rotation?: Quaternion;
-    /** Scaling for the entity's root node. Left at the node default when omitted. */
-    scaling?: Vector3;
-    /** When false, the node is disabled immediately on creation so nothing ever renders. Default true. */
-    enabled?: boolean;
-}
 /**
  * Abstract base class for game levels.
  *
  * Levels are responsible for creating and configuring their own scenes via the
- * `buildScene()` method. All runtime dependencies (eventBus, sceneEngine, entityManager)
+ * `buildScene()` method. All runtime dependencies (eventBus, sceneEngine, simulation)
  * are injected via the constructor and are immediately available.
  *
  * Users should not instantiate Level subclasses directly. Instead, use LevelManager
@@ -41,6 +28,13 @@ export declare abstract class Level implements LevelInstance {
     protected readonly _log: LoggerInterface;
     protected readonly _context: LevelContext;
     protected _scene: Scene | null;
+    protected _forRestore: boolean;
+    /**
+     * The simulation this level's scene was built against. A transition loads the next level before
+     * disposing this one, so by the time this level despawns what it spawned, the engine already holds the
+     * next level's simulation, minting the same IDs.
+     */
+    protected _simulation: NodeSimulation | null;
     clusteredLights: ClusteredLightContainer | null;
     outlines: OutlineManager | null;
     /**
@@ -60,6 +54,18 @@ export declare abstract class Level implements LevelInstance {
      * @param progress - Percentage (0-100)
      * @param message
      */
+    /**
+     * The simulation this level owns, or nothing for a level that never built one. The level manager binds
+     * the engine to the current level's simulation (design/simulation.md#which-simulation-the-engine-holds).
+     */
+    get $simulation(): NodeSimulation | null;
+    /**
+     * Take over a simulation built to replace this level's own, as a save load does once it has restored
+     * into a fresh one.
+     *
+     * @param simulation
+     */
+    $adoptSimulation(simulation: NodeSimulation): void;
     protected $emitProgress(progress: number, message: string): void;
     protected _toColor3(color: ColorConfig): Color3;
     /**
@@ -77,18 +83,7 @@ export declare abstract class Level implements LevelInstance {
      * Load and create the scene for this level.
      * Progress events will be emitted during loading.
      */
-    load(): Promise<Scene>;
-    /**
-     * Build or import a mesh from the entity definition and attach it to the entity.
-     * Supports primitive shapes (box/sphere/capsule/cylinder) and GLB/GLTF file paths.
-     *
-     * @param entity - The entity whose definition supplies the mesh spec
-     * @param options - Transform overrides and initial enabled state
-     *
-     * @returns The root node the mesh was built under, or null if the level has no scene, the definition has no
-     * mesh spec, or the GLB import produced no meshes.
-     */
-    createEntityMesh(entity: GameEntity, options?: CreateEntityMeshOptions): Promise<TransformNode | null>;
+    load(options?: LevelLoadOptions): Promise<Scene>;
     /**
      * Abstract method for building the scene content.
      * Concrete levels must implement this to create their specific content.

package/dist/entities/constants.d.ts

@@ -0,0 +1 @@
+export declare const poolSizeLimit = 8;

package/dist/entities/defineEntity.d.ts

@@ -0,0 +1,17 @@
+import { Action, BehaviorClass, StateFor, ValidTuple } from '@skewedaspect/sage-core';
+import { NodeEntity } from "./nodeEntity.d.ts";
+import { MeshConfig } from "./meshConfig.d.ts";
+export interface GameEntityDefinition<Behaviors extends readonly BehaviorClass[]> {
+    type: string;
+    tags?: string[];
+    defaultState?: Partial<StateFor<Behaviors>>;
+    behaviors: Behaviors;
+    mesh?: MeshConfig;
+    actions?: readonly Action[];
+}
+export type GameEntityDefinitionClass<Behaviors extends readonly BehaviorClass[]> = typeof NodeEntity & {
+    readonly behaviors: Behaviors;
+};
+export declare function defineEntity<Behaviors extends readonly BehaviorClass[]>(definition: GameEntityDefinition<Behaviors> & {
+    behaviors: ValidTuple<Behaviors>;
+}): GameEntityDefinitionClass<Behaviors>;

package/dist/entities/entityPicking.d.ts

@@ -0,0 +1,15 @@
+import { Vector3, AbstractMesh, PickingInfo } from '@babylonjs/core';
+import { GameEntity } from '@skewedaspect/sage-core';
+import { NodeEntity } from "./nodeEntity.d.ts";
+export interface EntityPickFilter {
+    tags?: readonly string[];
+}
+export interface EntityPickResult {
+    entity: NodeEntity;
+    mesh: AbstractMesh;
+    point: Vector3;
+    distance: number;
+    normal: Vector3;
+}
+export declare function findEntityForMesh(entities: readonly GameEntity[], mesh: AbstractMesh): NodeEntity | undefined;
+export declare function toEntityPickResult(entities: readonly GameEntity[], info: PickingInfo | null, filter?: EntityPickFilter): EntityPickResult | undefined;

package/dist/entities/meshConfig.d.ts

@@ -0,0 +1,14 @@
+import { ColorConfig } from "../interfaces/level.d.ts";
+export interface MeshMaterialConfig {
+    type?: 'standard' | 'pbr';
+    color?: ColorConfig;
+    emissive?: ColorConfig;
+    metallic?: number;
+    roughness?: number;
+}
+export interface MeshConfig {
+    source: string;
+    params?: Record<string, unknown>;
+    material?: MeshMaterialConfig;
+    visible?: boolean;
+}

package/dist/entities/nodeEntity.d.ts

@@ -0,0 +1,43 @@
+import { TransformNode, AbstractMesh } from '@babylonjs/core';
+import { GameEntity, Action, GameEntityState, GameSimulationContext } from '@skewedaspect/sage-core';
+import { AudioManager } from "../managers/audio.d.ts";
+import { ColliderDebugConfig } from "../managers/colliderDebug.d.ts";
+import { MeshConfig } from "./meshConfig.d.ts";
+export interface Vector3State {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface QuaternionState {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+export interface NodeEntityState extends GameEntityState {
+    parentID?: string;
+    nodeName?: string;
+    position: Vector3State;
+    rotation: QuaternionState;
+    debugCollider?: ColliderDebugConfig;
+}
+export interface NodeBehaviorHooks {
+    onMeshLoaded?(): void;
+    onDestroy?(): void;
+}
+export declare abstract class NodeEntity extends GameEntity {
+    #private;
+    static readonly poolable: boolean;
+    static readonly poolSize?: number;
+    static readonly meshConfig?: MeshConfig;
+    static readonly actions?: readonly Action[];
+    get node(): TransformNode;
+    get mesh(): AbstractMesh | undefined;
+    set mesh(mesh: AbstractMesh | undefined);
+    get audio(): AudioManager | undefined;
+    showCollider(config?: ColliderDebugConfig, color?: string): void;
+    hideCollider(name?: string): void;
+    protected constructor(id: string, context: GameSimulationContext, providedState: object, runCreateHooks: boolean, name?: string);
+    update(dt: number): void;
+    destroy(): void;
+}

package/dist/entities/nodePool.d.ts

@@ -0,0 +1,8 @@
+import { NodeSet } from "./nodeSimulationContext.d.ts";
+export declare class NodePool {
+    #private;
+    take(name: string): NodeSet | undefined;
+    give(name: string, set: NodeSet, limit?: number): void;
+    clear(name: string): void;
+    clearAll(): void;
+}

package/dist/entities/nodeSimulation.d.ts

@@ -0,0 +1,30 @@
+import { GameSimulationManager, GameSimulationOptions, StateBag } from '@skewedaspect/sage-core';
+import { AbstractMesh, Camera, Ray, Scene } from '@babylonjs/core';
+import { EntityPickFilter, EntityPickResult } from "./entityPicking.d.ts";
+import { NodeEntity } from "./nodeEntity.d.ts";
+import { NodePool } from "./nodePool.d.ts";
+import { MeshLoader, NodeSimulationContext } from "./nodeSimulationContext.d.ts";
+import { AudioManager } from "../managers/audio.d.ts";
+import { ColliderDebugManager } from "../managers/colliderDebug.d.ts";
+export interface NodeSimulationOptions extends GameSimulationOptions {
+    scene: Scene;
+    loadMesh: MeshLoader;
+    pool: NodePool;
+    audio?: AudioManager;
+    colliders: ColliderDebugManager;
+}
+export declare class NodeSimulation extends GameSimulationManager implements NodeSimulationContext {
+    #private;
+    readonly scene: Scene;
+    readonly pool: NodePool;
+    readonly loadMesh: MeshLoader;
+    readonly audio: AudioManager | undefined;
+    readonly colliders: ColliderDebugManager;
+    constructor(options: NodeSimulationOptions);
+    prewarm(name: string, count: number, state?: StateBag): Promise<void>;
+    pickEntityWithRay(ray: Ray, filter?: EntityPickFilter): EntityPickResult | undefined;
+    pickEntity(x: number, y: number, filter?: EntityPickFilter): EntityPickResult | undefined;
+    pickEntityForward(camera: Camera, range: number, filter?: EntityPickFilter): EntityPickResult | undefined;
+    getEntityForMesh(mesh: AbstractMesh): NodeEntity | undefined;
+    protected buildReplacementSimulation(options: GameSimulationOptions): NodeSimulation;
+}

package/dist/entities/nodeSimulationContext.d.ts

@@ -0,0 +1,17 @@
+import { AbstractMesh, Scene, TransformNode } from '@babylonjs/core';
+import { GameSimulationContext, StateBag } from '@skewedaspect/sage-core';
+import { AudioManager } from "../managers/audio.d.ts";
+import { ColliderDebugManager } from "../managers/colliderDebug.d.ts";
+import { NodePool } from "./nodePool.d.ts";
+export interface NodeSet {
+    node: TransformNode;
+    mesh: AbstractMesh | undefined;
+}
+export type MeshLoader = (name: string, state: Readonly<StateBag>) => Promise<AbstractMesh | undefined>;
+export interface NodeSimulationContext extends GameSimulationContext {
+    readonly scene: Scene;
+    readonly pool: NodePool;
+    readonly loadMesh: MeshLoader;
+    readonly audio?: AudioManager;
+    readonly colliders: ColliderDebugManager;
+}

package/dist/entities/standardMeshSource.d.ts

@@ -0,0 +1,8 @@
+import { AbstractMesh, AssetContainer, Mesh } from '@babylonjs/core';
+import { GameEntityType } from '@skewedaspect/sage-core';
+import { EntityMeshLoader } from "../interfaces/game.d.ts";
+export interface MeshAssetSource {
+    load(path: string): Promise<AssetContainer | AbstractMesh>;
+    clone(path: string): Mesh;
+}
+export declare function buildStandardMeshSource(entityClasses: Readonly<Record<string, GameEntityType>>, assets: MeshAssetSource): EntityMeshLoader;