@al8b/runtime 0.1.0

package/dist/core/index.mjs

@@ -0,0 +1,1757 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/core/controller.ts
+import { AudioCore } from "@al8b/audio";
+import { PlayerService } from "@al8b/player";
+import { SceneManager } from "@al8b/scene";
+import { Screen } from "@al8b/screen";
+import { StatePlayer, TimeMachine } from "@al8b/time";
+import { L8BVM } from "@al8b/vm";
+
+// src/assets/constructors.ts
+import { Sound } from "@al8b/audio";
+import { TileMap } from "@al8b/map";
+import { Image } from "@al8b/image";
+import { Sprite } from "@al8b/sprites";
+
+// src/assets/loader.ts
+import { Sound as Sound2, Music } from "@al8b/audio";
+
+// src/constants.ts
+var DEFAULT_FPS = 60;
+var DEFAULT_UPDATE_RATE = 60;
+var FRAME_TIME_MS = 1e3 / DEFAULT_FPS;
+var PAUSE_THRESHOLD_MS = 160;
+var DEFAULT_BLOCK_SIZE = 16;
+var LOADING_BAR_THROTTLE_MS = 16;
+var ASSET_LOAD_TIMEOUT_MS = 3e4;
+
+// src/assets/loader.ts
+import { LoadMap } from "@al8b/map";
+import { LoadSprite } from "@al8b/sprites";
+function withTimeout(promise, ms) {
+  return Promise.race([
+    promise,
+    new Promise((_, reject) => setTimeout(() => reject(new Error(`Asset load timed out after ${ms}ms`)), ms))
+  ]);
+}
+__name(withTimeout, "withTimeout");
+var AssetLoader = class {
+  static {
+    __name(this, "AssetLoader");
+  }
+  url;
+  resources;
+  collections;
+  loadingBarTime = null;
+  audioCore;
+  listener;
+  constructor(url, resources, audioCore, listener) {
+    this.url = url;
+    this.resources = resources;
+    this.audioCore = audioCore;
+    this.listener = listener;
+    this.collections = {
+      sprites: {},
+      maps: {},
+      sounds: {},
+      music: {},
+      assets: {}
+    };
+  }
+  /**
+  * Load all assets
+  */
+  async loadAll() {
+    await Promise.all([
+      this.loadSprites(),
+      this.loadMaps(),
+      this.loadSounds(),
+      this.loadMusic(),
+      this.loadGenericAssets()
+    ]);
+    return this.collections;
+  }
+  /**
+  * Load a set of callback-based assets (sprites or maps) with timeout and placeholder fallback.
+  */
+  async loadCallbackAssets(resources, urlPrefix, collectionKey, load, createPlaceholder) {
+    if (!resources) return;
+    const promises = resources.map((res) => new Promise((resolve) => {
+      const name = res.file.split(".")[0].replace(/-/g, "/");
+      const url = `${this.url}${urlPrefix}/${res.file}?v=${res.version || 0}`;
+      try {
+        const inner = new Promise((onReady) => {
+          this.collections[collectionKey][name] = load(url, res, onReady);
+        });
+        withTimeout(inner, ASSET_LOAD_TIMEOUT_MS).then(resolve).catch((err) => {
+          this.listener?.log?.(`[AssetLoader] Failed to load ${collectionKey.slice(0, -1)} "${name}": ${String(err)}`);
+          this.collections[collectionKey][name] = createPlaceholder(name, res);
+          resolve();
+        });
+      } catch (err) {
+        this.listener?.log?.(`[AssetLoader] Failed to load ${collectionKey.slice(0, -1)} "${name}": ${String(err)}`);
+        this.collections[collectionKey][name] = createPlaceholder(name, res);
+        resolve();
+      }
+    }));
+    await Promise.all(promises);
+  }
+  /**
+  * Load sprites
+  */
+  async loadSprites() {
+    await this.loadCallbackAssets(this.resources.images, "sprites", "sprites", (url, img, onReady) => LoadSprite(url, img.properties, onReady), (name, img) => ({
+      name,
+      ready: false,
+      frames: [],
+      fps: img.properties?.fps || 5,
+      width: 0,
+      height: 0
+    }));
+  }
+  /**
+  * Load maps
+  */
+  async loadMaps() {
+    await this.loadCallbackAssets(this.resources.maps, "maps", "maps", (url, _mapRes, onReady) => LoadMap(url, this.collections.sprites, onReady), (name) => ({
+      name,
+      ready: false,
+      width: 0,
+      height: 0,
+      block_width: DEFAULT_BLOCK_SIZE,
+      block_height: DEFAULT_BLOCK_SIZE,
+      data: []
+    }));
+  }
+  /**
+  * Load sounds
+  */
+  async loadSounds() {
+    if (!this.resources.sounds) return;
+    const promises = this.resources.sounds.map((sound) => {
+      return new Promise((resolve) => {
+        const name = sound.file.split(".")[0];
+        const url = `${this.url}sounds/${sound.file}?v=${sound.version || 0}`;
+        try {
+          const soundInstance = new Sound2(this.audioCore, url);
+          this.collections.sounds[name] = soundInstance;
+          resolve();
+        } catch (err) {
+          this.listener?.log?.(`[AssetLoader] Failed to load sound "${name}": ${String(err)}`);
+          this.collections.sounds[name] = new Sound2(this.audioCore, url);
+          resolve();
+        }
+      });
+    });
+    await Promise.all(promises);
+  }
+  /**
+  * Load music
+  */
+  async loadMusic() {
+    if (!this.resources.music) return;
+    const promises = this.resources.music.map((mus) => {
+      return new Promise((resolve) => {
+        const name = mus.file.split(".")[0];
+        const url = `${this.url}music/${mus.file}?v=${mus.version || 0}`;
+        try {
+          const musicInstance = new Music(this.audioCore, url);
+          this.collections.music[name] = musicInstance;
+          resolve();
+        } catch (err) {
+          this.listener?.log?.(`[AssetLoader] Failed to load music "${name}": ${String(err)}`);
+          this.collections.music[name] = new Music(this.audioCore, url);
+          resolve();
+        }
+      });
+    });
+    await Promise.all(promises);
+  }
+  /**
+  * Load generic assets
+  */
+  async loadGenericAssets() {
+    if (!this.resources.assets) return;
+    for (const asset of this.resources.assets) {
+      const name = asset.file.split(".")[0].replace(/-/g, "/");
+      this.collections.assets[name] = {
+        name,
+        file: asset.file,
+        version: asset.version
+      };
+    }
+  }
+  /**
+  * Check if all assets are ready
+  */
+  isReady() {
+    return this.countReady() === this.countTotal();
+  }
+  /**
+  * Get loading progress (0-1)
+  */
+  getProgress() {
+    const total = this.countTotal();
+    if (total === 0) return 1;
+    return this.countReady() / total;
+  }
+  /**
+  * Count total assets
+  */
+  countTotal() {
+    let count = 0;
+    count += Object.keys(this.collections.sprites).length;
+    count += Object.keys(this.collections.maps).length;
+    count += Object.keys(this.collections.sounds).length;
+    count += Object.keys(this.collections.music).length;
+    return count;
+  }
+  /**
+  * Count ready assets
+  */
+  countReady() {
+    let ready = 0;
+    for (const sprite of Object.values(this.collections.sprites)) {
+      if (sprite.ready) ready++;
+    }
+    for (const map of Object.values(this.collections.maps)) {
+      if (map.ready) ready++;
+    }
+    for (const sound of Object.values(this.collections.sounds)) {
+      if (sound.ready) ready++;
+    }
+    for (const mus of Object.values(this.collections.music)) {
+      if (mus.ready) ready++;
+    }
+    return ready;
+  }
+  /**
+  * Show loading bar on screen
+  */
+  showLoadingBar(screenInterface) {
+    if (this.loadingBarTime && Date.now() < this.loadingBarTime + LOADING_BAR_THROTTLE_MS) {
+      return;
+    }
+    this.loadingBarTime = Date.now();
+    const progress = this.getProgress();
+    screenInterface.clear("#000");
+    screenInterface.drawRect(0, 0, 100, 10, "#DDD");
+    screenInterface.fillRect(-(1 - progress) * 48, 0, progress * 96, 6, "#DDD");
+  }
+  /**
+  * Get loaded collections
+  */
+  getCollections() {
+    return this.collections;
+  }
+};
+
+// src/hot-reload/updater.ts
+var SourceUpdater = class {
+  static {
+    __name(this, "SourceUpdater");
+  }
+  vm;
+  listener;
+  audio;
+  screen;
+  reportWarnings;
+  emitBridgeEvent;
+  updateMemory = {};
+  previousInit = null;
+  constructor(vm, listener, audio, screen, reportWarnings2, emitBridgeEvent) {
+    this.vm = vm;
+    this.listener = listener;
+    this.audio = audio;
+    this.screen = screen;
+    this.reportWarnings = reportWarnings2;
+    this.emitBridgeEvent = emitBridgeEvent;
+  }
+  /**
+  * Update source code (hot reload)
+  */
+  updateSource(file, src, reinit = false) {
+    if (!this.vm) return false;
+    if (src === this.updateMemory[file]) return false;
+    this.updateMemory[file] = src;
+    if (this.audio) {
+      this.audio.cancelBeeps();
+    }
+    if (this.screen) {
+      this.screen.clear();
+    }
+    try {
+      this.vm.run(src, 3e3, file);
+      if (this.emitBridgeEvent) {
+        this.emitBridgeEvent("compile_success", {
+          file
+        });
+      }
+      if (this.reportWarnings) {
+        this.reportWarnings();
+      }
+      if (this.vm.error_info) {
+        const err = Object.assign({}, this.vm.error_info);
+        err.type = "init";
+        err.file = file;
+        this.listener.reportError?.(err);
+        return false;
+      }
+      if (this.vm.runner?.getFunctionSource) {
+        const init = this.vm.runner.getFunctionSource("init");
+        if (init && init !== this.previousInit && reinit) {
+          this.previousInit = init;
+          this.vm.call("init");
+          if (this.vm.error_info) {
+            const err = Object.assign({}, this.vm.error_info);
+            err.type = "init";
+            this.listener.reportError?.(err);
+          }
+        }
+      }
+      return true;
+    } catch (err) {
+      err.file = file;
+      this.listener.reportError?.(err);
+      return false;
+    }
+  }
+};
+
+// src/input/manager.ts
+import { GamepadInput, KeyboardInput, MouseInput, TouchInput } from "@al8b/input";
+var InputManager = class {
+  static {
+    __name(this, "InputManager");
+  }
+  keyboard;
+  mouse;
+  touch;
+  gamepad;
+  constructor(canvas) {
+    this.keyboard = new KeyboardInput();
+    this.mouse = new MouseInput();
+    this.touch = new TouchInput(this.mouse);
+    this.gamepad = new GamepadInput();
+    if (canvas) {
+      this.attachCanvas(canvas);
+    }
+  }
+  /**
+  * Attach input systems to canvas
+  */
+  attachCanvas(canvas) {
+    this.mouse.setCanvas(canvas);
+    this.touch.setCanvas(canvas);
+  }
+  /**
+  * Update all input systems (call each frame)
+  */
+  update() {
+    this.keyboard.update();
+    this.mouse.update();
+    this.touch.update();
+    this.gamepad.update();
+  }
+  /**
+  * Get input states for game code
+  */
+  getStates() {
+    return {
+      keyboard: this.keyboard.state,
+      mouse: this.mouse.state,
+      touch: this.touch.state,
+      gamepad: this.gamepad.status
+    };
+  }
+};
+
+// src/loop/game-loop.ts
+var GameLoop = class {
+  static {
+    __name(this, "GameLoop");
+  }
+  callbacks;
+  state;
+  stopped = false;
+  animationFrameId = null;
+  constructor(callbacks) {
+    this.callbacks = callbacks;
+    this.state = {
+      currentFrame: 0,
+      floatingFrame: 0,
+      dt: FRAME_TIME_MS,
+      lastTime: performance.now(),
+      fps: DEFAULT_FPS,
+      updateRate: DEFAULT_UPDATE_RATE
+    };
+    this.loop = this.loop.bind(this);
+  }
+  /**
+  * Start the game loop
+  */
+  start() {
+    this.stopped = false;
+    this.state.lastTime = performance.now();
+    this.state.currentFrame = 0;
+    this.state.floatingFrame = 0;
+    this.loop();
+  }
+  /**
+  * Stop the game loop
+  */
+  stop() {
+    this.stopped = true;
+    if (this.animationFrameId !== null) {
+      cancelAnimationFrame(this.animationFrameId);
+      this.animationFrameId = null;
+    }
+  }
+  /**
+  * Resume the game loop
+  */
+  resume() {
+    if (!this.stopped) return;
+    this.stopped = false;
+    this.state.lastTime = performance.now();
+    this.loop();
+  }
+  /**
+  * Main game loop
+  */
+  loop() {
+    if (this.stopped) return;
+    this.animationFrameId = requestAnimationFrame(this.loop);
+    const time = performance.now();
+    if (Math.abs(time - this.state.lastTime) > PAUSE_THRESHOLD_MS) {
+      this.state.lastTime = time - LOADING_BAR_THROTTLE_MS;
+    }
+    const dt = time - this.state.lastTime;
+    this.state.dt = this.state.dt * 0.9 + dt * 0.1;
+    this.state.lastTime = time;
+    const fps = Math.round(1e3 / this.state.dt);
+    this.state.fps = fps;
+    if (this.callbacks.setFPS) {
+      this.callbacks.setFPS(fps);
+    }
+    let updateRate = this.state.updateRate;
+    if (this.callbacks.getUpdateRate) {
+      const rate = this.callbacks.getUpdateRate();
+      if (rate != null && rate > 0 && Number.isFinite(rate)) {
+        updateRate = rate;
+      }
+    }
+    this.state.floatingFrame += this.state.dt * updateRate / 1e3;
+    let ds = Math.min(10, Math.round(this.state.floatingFrame - this.state.currentFrame));
+    if ((ds === 0 || ds === 2) && updateRate === DEFAULT_UPDATE_RATE && Math.abs(fps - DEFAULT_FPS) < 2) {
+      ds = 1;
+      this.state.floatingFrame = this.state.currentFrame + 1;
+    }
+    for (let i = 1; i <= ds; i++) {
+      this.callbacks.onUpdate();
+      if (i < ds && this.callbacks.onTick) {
+        this.callbacks.onTick();
+      }
+    }
+    this.state.currentFrame += ds;
+    this.callbacks.onDraw();
+    if (this.callbacks.onTick) {
+      this.callbacks.onTick();
+    }
+    if (ds > 0 && this.callbacks.onWatchStep) {
+      this.callbacks.onWatchStep();
+    }
+  }
+  /**
+  * Get current state
+  */
+  getState() {
+    return this.state;
+  }
+  /**
+  * Set update rate
+  */
+  setUpdateRate(rate) {
+    if (rate > 0 && Number.isFinite(rate)) {
+      this.state.updateRate = rate;
+    }
+  }
+  /**
+  * Get FPS
+  */
+  getFPS() {
+    return this.state.fps;
+  }
+};
+
+// src/system/api.ts
+var System = class {
+  static {
+    __name(this, "System");
+  }
+  systemAPI;
+  constructor() {
+    this.systemAPI = {
+      // Time
+      get time() {
+        return Date.now();
+      },
+      // FPS
+      fps: DEFAULT_FPS,
+      // CPU load
+      cpu_load: 0,
+      // Update rate
+      update_rate: DEFAULT_UPDATE_RATE,
+      // Language
+      get language() {
+        return typeof navigator !== "undefined" ? navigator.language : "en";
+      },
+      // Input availability
+      inputs: {
+        get keyboard() {
+          return 1;
+        },
+        get mouse() {
+          return 1;
+        },
+        get touch() {
+          return typeof window !== "undefined" && "ontouchstart" in window ? 1 : 0;
+        },
+        get gamepad() {
+          return typeof navigator !== "undefined" && typeof navigator.getGamepads === "function" ? 1 : 0;
+        }
+      },
+      // Loading progress
+      loading: 0,
+      // Utility functions
+      prompt: /* @__PURE__ */ __name((text, callback) => {
+        if (typeof window !== "undefined") {
+          const result = window.prompt(text);
+          if (result !== null && callback) {
+            callback(result);
+          }
+        }
+      }, "prompt"),
+      say: /* @__PURE__ */ __name((text) => {
+        if (typeof window !== "undefined") {
+          window.alert(text);
+        }
+      }, "say"),
+      // File drop support
+      file: {
+        dropped: 0
+      },
+      // JavaScript interop (placeholder for future use)
+      javascript: {},
+      // Additional flags
+      disable_autofullscreen: 0,
+      preemptive: 1
+    };
+  }
+  /**
+  * Get system API for game code
+  */
+  getAPI() {
+    return this.systemAPI;
+  }
+  /**
+  * Update FPS
+  */
+  setFPS(fps) {
+    this.systemAPI.fps = fps;
+  }
+  /**
+  * Update CPU load
+  */
+  setCPULoad(load) {
+    this.systemAPI.cpu_load = load;
+  }
+  /**
+  * Update loading progress
+  */
+  setLoading(progress) {
+    this.systemAPI.loading = progress;
+  }
+};
+
+// src/core/debug-logger.ts
+var DebugLogger = class {
+  static {
+    __name(this, "DebugLogger");
+  }
+  lastInputDebug;
+  lastScreenDebug;
+  /**
+  * Log input state changes (deduplication via shallow compare)
+  */
+  debugInputs(input, debug) {
+    if (!debug?.input) return;
+    const snapshot = this.createInputSnapshot(input, debug.input);
+    if (!snapshot) return;
+    if (this.lastInputDebug && shallowEqual(snapshot, this.lastInputDebug)) return;
+    this.lastInputDebug = snapshot;
+    console.debug("[@al8b/runtime][input]", snapshot);
+  }
+  /**
+  * Log screen dimension changes
+  */
+  debugScreen(screen, debug) {
+    if (!debug?.screen) return;
+    const canvas = screen.getCanvas();
+    const current = {
+      width: screen.width,
+      height: screen.height,
+      canvasWidth: canvas.width,
+      canvasHeight: canvas.height
+    };
+    if (this.lastScreenDebug && current.width === this.lastScreenDebug.width && current.height === this.lastScreenDebug.height && current.canvasWidth === this.lastScreenDebug.canvasWidth && current.canvasHeight === this.lastScreenDebug.canvasHeight) {
+      return;
+    }
+    this.lastScreenDebug = current;
+    console.debug("[@al8b/runtime][screen]", {
+      screen: {
+        width: screen.width,
+        height: screen.height
+      },
+      canvas: {
+        width: canvas.width,
+        height: canvas.height,
+        clientWidth: canvas.clientWidth,
+        clientHeight: canvas.clientHeight,
+        style: {
+          width: canvas.style.width,
+          height: canvas.style.height
+        }
+      }
+    });
+  }
+  /**
+  * Create a snapshot of current input state based on enabled channels
+  */
+  createInputSnapshot(input, setting) {
+    const channels = getEnabledInputChannels(setting);
+    if (channels.length === 0) return null;
+    const states = input.getStates();
+    const snapshot = {};
+    if (channels.includes("touch")) {
+      snapshot.touch = {
+        touching: states.touch.touching,
+        press: states.touch.press,
+        release: states.touch.release,
+        x: Number(states.touch.x?.toFixed?.(2) ?? states.touch.x),
+        y: Number(states.touch.y?.toFixed?.(2) ?? states.touch.y),
+        count: states.touch.touches?.length ?? 0
+      };
+    }
+    if (channels.includes("mouse")) {
+      snapshot.mouse = {
+        pressed: states.mouse.pressed,
+        left: states.mouse.left,
+        x: Number(states.mouse.x?.toFixed?.(2) ?? states.mouse.x),
+        y: Number(states.mouse.y?.toFixed?.(2) ?? states.mouse.y),
+        wheel: states.mouse.wheel
+      };
+    }
+    if (channels.includes("keyboard")) {
+      snapshot.keyboard = {
+        UP: states.keyboard.UP,
+        DOWN: states.keyboard.DOWN,
+        LEFT: states.keyboard.LEFT,
+        RIGHT: states.keyboard.RIGHT,
+        press: states.keyboard.press,
+        release: states.keyboard.release
+      };
+    }
+    if (channels.includes("gamepad")) {
+      snapshot.gamepad = {
+        count: input.gamepad.count,
+        A: states.gamepad.A,
+        B: states.gamepad.B,
+        UP: states.gamepad.UP,
+        DOWN: states.gamepad.DOWN,
+        LEFT: states.gamepad.LEFT,
+        RIGHT: states.gamepad.RIGHT
+      };
+    }
+    return Object.keys(snapshot).length === 0 ? null : snapshot;
+  }
+};
+function getEnabledInputChannels(setting) {
+  if (typeof setting === "boolean") {
+    return setting ? [
+      "keyboard",
+      "mouse",
+      "touch",
+      "gamepad"
+    ] : [];
+  }
+  const channels = [];
+  if (setting.keyboard) channels.push("keyboard");
+  if (setting.mouse) channels.push("mouse");
+  if (setting.touch) channels.push("touch");
+  if (setting.gamepad) channels.push("gamepad");
+  return channels;
+}
+__name(getEnabledInputChannels, "getEnabledInputChannels");
+function shallowEqual(obj1, obj2) {
+  if (obj1 === obj2) return true;
+  if (!obj1 || !obj2 || typeof obj1 !== "object" || typeof obj2 !== "object") return false;
+  const keys1 = Object.keys(obj1);
+  const keys2 = Object.keys(obj2);
+  if (keys1.length !== keys2.length) return false;
+  for (const key of keys1) {
+    const val1 = obj1[key];
+    const val2 = obj2[key];
+    if (val1 === val2) continue;
+    if (val1 == null || val2 == null) {
+      if (val1 !== val2) return false;
+      continue;
+    }
+    if (typeof val1 === "object" && typeof val2 === "object") {
+      const keys1Nested = Object.keys(val1);
+      const keys2Nested = Object.keys(val2);
+      if (keys1Nested.length !== keys2Nested.length) return false;
+      for (const nestedKey of keys1Nested) {
+        if (val1[nestedKey] !== val2[nestedKey]) return false;
+      }
+    } else {
+      return false;
+    }
+  }
+  return true;
+}
+__name(shallowEqual, "shallowEqual");
+
+// src/core/error-handler.ts
+import { createDiagnostic, formatForBrowser } from "@al8b/diagnostics";
+function formatRuntimeError(error) {
+  if (error.code || error.context || error.suggestions) {
+    return error;
+  }
+  const code = error.code || "E2005";
+  const diagnostic = createDiagnostic(code, {
+    file: error.file,
+    line: error.line,
+    column: error.column,
+    context: error.context,
+    suggestions: error.suggestions,
+    related: error.related,
+    stackTrace: error.stackTrace,
+    data: {
+      error: error.error || error.message
+    }
+  });
+  const formattedMessage = formatForBrowser(diagnostic);
+  return {
+    ...error,
+    ...diagnostic,
+    formatted: formattedMessage
+  };
+}
+__name(formatRuntimeError, "formatRuntimeError");
+function reportError(listener, error) {
+  if (listener.reportError) {
+    const formatted = formatRuntimeError(error);
+    listener.reportError(formatted);
+  }
+}
+__name(reportError, "reportError");
+function reportWarnings(vm, listener) {
+  if (!vm) return;
+  const warnings = vm.context?.warnings;
+  if (!warnings) return;
+  if (warnings.invoking_non_function) {
+    for (const value of Object.values(warnings.invoking_non_function)) {
+      const warning = value;
+      if (!warning.reported) {
+        warning.reported = true;
+        reportError(listener, {
+          error: "",
+          type: "non_function",
+          expression: warning.expression,
+          line: warning.line,
+          column: warning.column,
+          file: warning.file
+        });
+      }
+    }
+  }
+  if (warnings.using_undefined_variable) {
+    for (const value of Object.values(warnings.using_undefined_variable)) {
+      const warning = value;
+      if (!warning.reported) {
+        warning.reported = true;
+        reportError(listener, {
+          error: "",
+          type: "undefined_variable",
+          expression: warning.expression,
+          line: warning.line,
+          column: warning.column,
+          file: warning.file
+        });
+      }
+    }
+  }
+}
+__name(reportWarnings, "reportWarnings");
+
+// src/core/assets-registry.ts
+var RuntimeAssetsRegistry = class {
+  static {
+    __name(this, "RuntimeAssetsRegistry");
+  }
+  collections = {
+    sprites: {},
+    maps: {},
+    sounds: {},
+    music: {},
+    assets: {}
+  };
+  replace(collections) {
+    this.collections = collections;
+  }
+  getCollections() {
+    return this.collections;
+  }
+  get sprites() {
+    return this.collections.sprites;
+  }
+  get maps() {
+    return this.collections.maps;
+  }
+  get sounds() {
+    return this.collections.sounds;
+  }
+  get music() {
+    return this.collections.music;
+  }
+  get assets() {
+    return this.collections.assets;
+  }
+};
+
+// src/core/api-factory.ts
+import { Palette } from "@al8b/palette";
+import { Random, Routine } from "@al8b/vm";
+
+// src/utils/object-pool.ts
+var ObjectPool = class {
+  static {
+    __name(this, "ObjectPool");
+  }
+  pool = [];
+  factory;
+  reset;
+  maxSize;
+  /**
+  * Create a new object pool
+  *
+  * @param factory - Function to create new objects
+  * @param reset - Function to reset object state for reuse
+  * @param maxSize - Maximum pool size (default: 100)
+  */
+  constructor(factory, reset, maxSize = 100) {
+    this.factory = factory;
+    this.reset = reset;
+    this.maxSize = maxSize;
+  }
+  /**
+  * Acquire an object from the pool
+  *
+  * Returns a new object if pool is empty, otherwise reuses a pooled object.
+  *
+  * @returns Object from pool or newly created
+  */
+  acquire() {
+    if (this.pool.length > 0) {
+      return this.pool.pop();
+    }
+    return this.factory();
+  }
+  /**
+  * Release an object back to the pool
+  *
+  * Resets the object and adds it back to the pool for reuse.
+  * If pool is at max size, the object is discarded.
+  *
+  * @param obj - Object to release
+  */
+  release(obj) {
+    if (this.pool.length >= this.maxSize) {
+      return;
+    }
+    this.reset(obj);
+    this.pool.push(obj);
+  }
+  /**
+  * Clear all objects from the pool
+  */
+  clear() {
+    this.pool = [];
+  }
+  /**
+  * Get current pool size
+  *
+  * @returns Number of objects in pool
+  */
+  size() {
+    return this.pool.length;
+  }
+  /**
+  * Get maximum pool size
+  *
+  * @returns Maximum pool size
+  */
+  getMaxSize() {
+    return this.maxSize;
+  }
+  /**
+  * Set maximum pool size
+  *
+  * @param maxSize - New maximum pool size
+  */
+  setMaxSize(maxSize) {
+    this.maxSize = maxSize;
+    if (this.pool.length > maxSize) {
+      this.pool = this.pool.slice(0, maxSize);
+    }
+  }
+};
+
+// src/core/api-factory.ts
+function createRuntimeMeta(context) {
+  return {
+    print: /* @__PURE__ */ __name((text) => {
+      const vm = context.getVM();
+      if ((typeof text === "object" || typeof text === "function") && vm) {
+        text = vm.toString(text);
+      }
+      if (context.listener.log) {
+        context.listener.log(String(text));
+      } else {
+        console.log(text);
+      }
+    }, "print")
+  };
+}
+__name(createRuntimeMeta, "createRuntimeMeta");
+function createRuntimeGlobalApi(context) {
+  const inputStates = context.input.getStates();
+  const session = {
+    user: /* @__PURE__ */ __name(() => cloneValue(context.getSessionSnapshot()?.user ?? null), "user"),
+    player: /* @__PURE__ */ __name(() => cloneValue(context.getSessionSnapshot()?.player ?? null), "player"),
+    game: /* @__PURE__ */ __name(() => cloneValue(context.getSessionSnapshot()?.game ?? null), "game"),
+    room: /* @__PURE__ */ __name(() => cloneValue(context.getSessionSnapshot()?.room ?? null), "room")
+  };
+  const host = {
+    emit: /* @__PURE__ */ __name((name, payload) => {
+      context.sendHostEvent({
+        type: name,
+        payload,
+        source: "host"
+      });
+    }, "emit"),
+    request: /* @__PURE__ */ __name((name, payload, callback) => context.sendHostRequest(name, payload, callback), "request")
+  };
+  const memory = {
+    export: /* @__PURE__ */ __name(() => context.exportSnapshot(), "export"),
+    import: /* @__PURE__ */ __name((snapshot) => context.importSnapshot(snapshot), "import"),
+    reset: /* @__PURE__ */ __name((options) => context.resetRuntime(options), "reset"),
+    save: /* @__PURE__ */ __name((meta, callback) => context.saveSnapshot(meta, callback), "save"),
+    load: /* @__PURE__ */ __name((meta, callback) => context.loadSnapshot(meta, callback), "load")
+  };
+  return {
+    screen: context.screen.getInterface(),
+    audio: context.audio.getInterface(),
+    keyboard: inputStates.keyboard,
+    mouse: inputStates.mouse,
+    touch: inputStates.touch,
+    gamepad: inputStates.gamepad,
+    sprites: context.assets.sprites,
+    maps: context.assets.maps,
+    sounds: context.assets.sounds,
+    music: context.assets.music,
+    assets: context.assets.assets,
+    player: context.playerService.getInterface(),
+    host,
+    session,
+    memory,
+    system: context.system.getAPI(),
+    scene: /* @__PURE__ */ __name((name, definition) => {
+      const convertedDefinition = convertSceneDefinition(asSceneDefinition(definition), context.getVM(), context.listener);
+      context.sceneManager.registerScene(name, convertedDefinition);
+    }, "scene"),
+    route: /* @__PURE__ */ __name((path, sceneName) => context.sceneManager.registerRoute(path, sceneName), "route"),
+    router: context.sceneManager.router.getInterface(),
+    Image,
+    Sprite,
+    TileMap,
+    Sound,
+    Palette,
+    Random,
+    ObjectPool
+  };
+}
+__name(createRuntimeGlobalApi, "createRuntimeGlobalApi");
+function convertSceneDefinition(definition, vm, listener) {
+  if (!vm?.runner?.main_thread?.processor) {
+    listener.log?.("[RuntimeController] VM not ready for scene conversion. Scene functions may not work correctly.");
+    return definition;
+  }
+  const processor = vm.runner.main_thread.processor;
+  const context = vm.context;
+  const converted = {};
+  for (const [key, value] of Object.entries(definition)) {
+    if (value instanceof Routine) {
+      converted[key] = processor.routineAsFunction(value, context);
+      continue;
+    }
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      converted[key] = convertSceneDefinition(value, vm, listener);
+      continue;
+    }
+    converted[key] = value;
+  }
+  return converted;
+}
+__name(convertSceneDefinition, "convertSceneDefinition");
+function asSceneDefinition(definition) {
+  if (!definition || typeof definition !== "object" || Array.isArray(definition)) {
+    throw new Error("Scene definition must be an object.");
+  }
+  return definition;
+}
+__name(asSceneDefinition, "asSceneDefinition");
+function cloneValue(value) {
+  if (value == null) {
+    return value;
+  }
+  return JSON.parse(JSON.stringify(value));
+}
+__name(cloneValue, "cloneValue");
+
+// src/core/controller.ts
+function createRuntime(options = {}) {
+  return new RuntimeControllerImpl(options);
+}
+__name(createRuntime, "createRuntime");
+var RuntimeControllerImpl = class {
+  static {
+    __name(this, "RuntimeControllerImpl");
+  }
+  options;
+  listener;
+  assetRegistry = new RuntimeAssetsRegistry();
+  assetLoader;
+  debugLogger = new DebugLogger();
+  DEBUG_UPDATE_FREQUENCY = 10;
+  snapshotRestorer = new StatePlayer();
+  bridgeUnsubscribe = null;
+  sourceUpdater = null;
+  gameLoop = null;
+  frameCount = 0;
+  lastUpdateRate = -1;
+  isStopped = false;
+  preserveStorageOnNextBoot;
+  sessionSnapshot;
+  screen;
+  audio;
+  input;
+  system;
+  playerService;
+  sceneManager;
+  vm = null;
+  timeMachine = null;
+  constructor(options = {}) {
+    this.options = options;
+    this.listener = options.listener || {};
+    this.preserveStorageOnNextBoot = options.preserveStorage || false;
+    this.sessionSnapshot = options.initialSession || null;
+    this.screen = new Screen({
+      runtime: this,
+      canvas: options.canvas,
+      width: options.width || 400,
+      height: options.height || 400
+    });
+    this.audio = new AudioCore(this);
+    this.input = new InputManager(this.screen.getCanvas());
+    this.system = new System();
+    this.playerService = new PlayerService({
+      pause: /* @__PURE__ */ __name(() => this.stop(), "pause"),
+      resume: /* @__PURE__ */ __name(() => this.resume(), "resume"),
+      postMessage: /* @__PURE__ */ __name((message) => this.emitPlayerMessage(message), "postMessage"),
+      getFps: /* @__PURE__ */ __name(() => this.system.getAPI().fps, "getFps"),
+      getUpdateRate: /* @__PURE__ */ __name(() => this.system.getAPI().update_rate, "getUpdateRate"),
+      setUpdateRate: /* @__PURE__ */ __name((rate) => {
+        this.system.getAPI().update_rate = rate;
+      }, "setUpdateRate")
+    });
+    this.sceneManager = new SceneManager();
+    this.assetLoader = new AssetLoader(options.url || "", options.resources || {}, this.audio, this.listener);
+    this.logStep("RuntimeController constructed", {
+      width: this.screen.width,
+      height: this.screen.height,
+      resources: {
+        images: options.resources?.images?.length ?? 0,
+        sounds: options.resources?.sounds?.length ?? 0,
+        music: options.resources?.music?.length ?? 0
+      }
+    });
+  }
+  get sprites() {
+    return this.assetRegistry.sprites;
+  }
+  get maps() {
+    return this.assetRegistry.maps;
+  }
+  get sounds() {
+    return this.assetRegistry.sounds;
+  }
+  get music() {
+    return this.assetRegistry.music;
+  }
+  get assets() {
+    return this.assetRegistry.assets;
+  }
+  get stopped() {
+    return this.isStopped;
+  }
+  getSession() {
+    return this.sessionSnapshot ? cloneSnapshot(this.sessionSnapshot) : null;
+  }
+  async start() {
+    this.logStep("startup: begin");
+    await this.hydrateSession();
+    this.ensureBridgeSubscription();
+    this.logStep("startup: loading assets");
+    await this.loadAssets();
+    this.logStep("startup: assets loaded", {
+      sprites: Object.keys(this.sprites).length,
+      maps: Object.keys(this.maps).length,
+      sounds: Object.keys(this.sounds).length,
+      music: Object.keys(this.music).length,
+      assets: Object.keys(this.assets).length
+    });
+    this.logStep("startup: waiting for asset readiness");
+    await this.waitForAssetsReady();
+    this.logStep("startup: assets ready");
+    this.logStep("startup: initializing VM");
+    this.initializeVM();
+    this.logStep("startup: VM ready", {
+      sourceFiles: Object.keys(this.options.sources || {}).length
+    });
+    this.logStep("startup: starting game loop");
+    this.startGameLoop();
+    this.isStopped = false;
+    this.logStep("startup: completed");
+  }
+  stop() {
+    this.logStep("lifecycle: stop requested");
+    this.isStopped = true;
+    this.gameLoop?.stop();
+    this.audio.stopAll();
+  }
+  resume() {
+    this.logStep("lifecycle: resume requested");
+    this.isStopped = false;
+    this.gameLoop?.resume();
+  }
+  async reset(options = {}) {
+    this.logStep("lifecycle: reset requested", options);
+    const preservedSnapshot = options.preserveSnapshot ? this.exportSnapshot() : null;
+    const preserveSession = options.preserveSession ?? true;
+    const preserveStorage = options.preserveStorage ?? this.options.preserveStorage ?? false;
+    this.stop();
+    this.teardownRuntimeState();
+    if (!preserveSession) {
+      this.sessionSnapshot = null;
+    }
+    this.preserveStorageOnNextBoot = preserveStorage;
+    await this.start();
+    if (preservedSnapshot) {
+      await this.importSnapshot(preservedSnapshot);
+    }
+  }
+  exportSnapshot() {
+    const global = this.vm?.context?.global;
+    const routerState = this.sceneManager.router.getState();
+    return {
+      version: 1,
+      global: global ? serializeGlobalSnapshot(global) : {},
+      session: this.getSession(),
+      router: {
+        path: routerState.path,
+        sceneName: this.sceneManager.getCurrentSceneName()
+      },
+      system: {
+        updateRate: this.system.getAPI().update_rate
+      }
+    };
+  }
+  async importSnapshot(snapshot) {
+    if (!this.vm?.context?.global) {
+      return;
+    }
+    this.snapshotRestorer.restoreState(this.vm.context.global, snapshot.global);
+    this.system.getAPI().update_rate = snapshot.system.updateRate;
+    this.updateGameLoopUpdateRate();
+    if (snapshot.session) {
+      this.sessionSnapshot = cloneSnapshot(snapshot.session);
+    }
+    if (snapshot.router.path) {
+      this.sceneManager.router.replace(snapshot.router.path);
+    } else if (snapshot.router.sceneName) {
+      this.sceneManager.setActiveScene(snapshot.router.sceneName);
+    }
+  }
+  updateSource(file, src, reinit = false) {
+    if (!this.sourceUpdater) return false;
+    return this.sourceUpdater.updateSource(file, src, reinit);
+  }
+  handleMessage(message) {
+    if (!message) {
+      return;
+    }
+    if (typeof message === "object" && "type" in message && typeof message.type === "string") {
+      this.sendHostEvent(message);
+      return;
+    }
+    if (message.name === "time_machine" && this.timeMachine) {
+      this.timeMachine.messageReceived(message);
+    }
+  }
+  sendHostEvent(event) {
+    this.handleHostEvent(event);
+  }
+  getCanvas() {
+    return this.screen.getCanvas();
+  }
+  async loadAssets() {
+    const collections = await this.assetLoader.loadAll();
+    this.assetRegistry.replace(collections);
+  }
+  async waitForAssetsReady() {
+    return new Promise((resolve) => {
+      const checkReady = /* @__PURE__ */ __name(() => {
+        if (this.assetLoader.isReady()) {
+          this.system.setLoading(100);
+          resolve();
+          return;
+        }
+        const progress = this.assetLoader.getProgress();
+        this.system.setLoading(Math.floor(progress * 100));
+        this.assetLoader.showLoadingBar(this.screen.getInterface());
+        requestAnimationFrame(checkReady);
+      }, "checkReady");
+      checkReady();
+    });
+  }
+  initializeVM() {
+    this.logStep("vm: building meta/global APIs");
+    const apiContext = {
+      listener: this.listener,
+      options: this.options,
+      screen: this.screen,
+      audio: this.audio,
+      input: this.input,
+      system: this.system,
+      playerService: this.playerService,
+      sceneManager: this.sceneManager,
+      assets: this.assetRegistry,
+      bridge: this.options.bridge,
+      getVM: /* @__PURE__ */ __name(() => this.vm, "getVM"),
+      getSessionSnapshot: /* @__PURE__ */ __name(() => this.getSession(), "getSessionSnapshot"),
+      sendHostEvent: /* @__PURE__ */ __name((event) => this.emitBridgeEvent(event.type, event.payload), "sendHostEvent"),
+      sendHostRequest: /* @__PURE__ */ __name((name, payload, callback) => this.sendBridgeRequest(name, payload, callback), "sendHostRequest"),
+      exportSnapshot: /* @__PURE__ */ __name(() => this.exportSnapshot(), "exportSnapshot"),
+      importSnapshot: /* @__PURE__ */ __name((snapshot) => this.importSnapshot(snapshot), "importSnapshot"),
+      resetRuntime: /* @__PURE__ */ __name((options) => this.reset(options), "resetRuntime"),
+      saveSnapshot: /* @__PURE__ */ __name((meta2, callback) => this.saveSnapshot(meta2, callback), "saveSnapshot"),
+      loadSnapshot: /* @__PURE__ */ __name((meta2, callback) => this.loadSnapshot(meta2, callback), "loadSnapshot")
+    };
+    const meta = createRuntimeMeta(apiContext);
+    const global = createRuntimeGlobalApi(apiContext);
+    this.vm = new L8BVM(meta, global, this.options.namespace || "/l8b", this.preserveStorageOnNextBoot);
+    this.sourceUpdater = new SourceUpdater(this.vm, this.listener, this.audio, this.screen, () => reportWarnings(this.vm, this.listener), (name, payload) => this.emitBridgeEvent(name, payload));
+    this.timeMachine = new TimeMachine(this);
+    this.timeMachine.onStatus((status) => {
+      this.emitBridgeEvent("time_machine_status", {
+        status
+      });
+    });
+    this.loadPrograms();
+    this.initializeScenesAndRouter();
+    this.emitBridgeEvent("runtime.started", {});
+  }
+  loadPrograms() {
+    if (!this.vm) {
+      return;
+    }
+    const compiledRoutines = this.options.compiledRoutines || {};
+    const sources = this.options.sources || {};
+    if (Object.keys(compiledRoutines).length > 0) {
+      this.logStep("vm: loading compiled routines", {
+        files: Object.keys(compiledRoutines)
+      });
+      for (const [file, routine] of Object.entries(compiledRoutines)) {
+        try {
+          this.vm.loadRoutine(routine, file);
+        } catch (err) {
+          reportError(this.listener, {
+            error: err.message || String(err),
+            type: "compile",
+            stack: err.stack,
+            file
+          });
+          this.logStep("vm: routine load error", {
+            file,
+            message: err?.message || String(err)
+          });
+        }
+      }
+    } else if (Object.keys(sources).length > 0) {
+      this.logStep("vm: executing sources", {
+        files: Object.keys(sources)
+      });
+      for (const [file, src] of Object.entries(sources)) {
+        this.sourceUpdater?.updateSource(file, src, false);
+      }
+    } else {
+      this.logStep("vm: no sources or compiled routines provided");
+    }
+    try {
+      this.vm.call("init");
+      this.vm.runner.tick();
+      this.logStep("vm: init() executed");
+    } catch (err) {
+      reportError(this.listener, {
+        error: err.message || String(err),
+        type: "init",
+        stack: err.stack
+      });
+      this.logStep("vm: init() error", {
+        message: err?.message || String(err)
+      });
+    }
+  }
+  initializeScenesAndRouter() {
+    const registeredScenes = this.sceneManager.registry.getNames();
+    this.logStep("router: initializing", {
+      registeredScenes: registeredScenes.length,
+      sceneNames: registeredScenes
+    });
+    this.sceneManager.router.init();
+    const activeScene = this.sceneManager.hasActiveScene() ? this.sceneManager.getCurrentSceneName?.() || "unknown" : null;
+    const routerState = this.sceneManager.router.getState();
+    this.logStep("router: initialized", {
+      activeScene: activeScene || "none",
+      path: routerState.path,
+      hasActiveScene: this.sceneManager.hasActiveScene()
+    });
+  }
+  startGameLoop() {
+    this.logStep("loop: creating game loop");
+    this.gameLoop = new GameLoop({
+      onUpdate: /* @__PURE__ */ __name(() => this.handleUpdate(), "onUpdate"),
+      onDraw: /* @__PURE__ */ __name(() => this.handleDraw(), "onDraw"),
+      onTick: /* @__PURE__ */ __name(() => this.handleTick(), "onTick"),
+      onWatchStep: /* @__PURE__ */ __name(() => this.handleWatchStep(), "onWatchStep"),
+      getUpdateRate: /* @__PURE__ */ __name(() => {
+        if (!this.vm) return void 0;
+        try {
+          return this.vm.context?.global?.system?.update_rate;
+        } catch {
+          return void 0;
+        }
+      }, "getUpdateRate"),
+      setFPS: /* @__PURE__ */ __name((fps) => {
+        if (!this.vm) return;
+        try {
+          if (this.vm.context?.global?.system) {
+            this.vm.context.global.system.fps = fps;
+          }
+        } catch {
+        }
+      }, "setFPS")
+    });
+    this.gameLoop.start();
+    this.logStep("loop: started");
+  }
+  updateGameLoopUpdateRate() {
+    if (!this.vm || !this.gameLoop) return;
+    try {
+      const updateRate = this.vm.context?.global?.system?.update_rate;
+      const rate = updateRate != null && updateRate > 0 && Number.isFinite(updateRate) ? updateRate : 60;
+      if (rate !== this.lastUpdateRate) {
+        this.lastUpdateRate = rate;
+        this.gameLoop.setUpdateRate(rate);
+      }
+    } catch {
+    }
+  }
+  handleUpdate() {
+    if (!this.vm) return;
+    this.frameCount++;
+    this.input.update();
+    if (this.frameCount % this.DEBUG_UPDATE_FREQUENCY === 0) {
+      this.debugLogger.debugInputs(this.input, this.options.debug);
+      this.debugLogger.debugScreen(this.screen, this.options.debug);
+    }
+    if (this.gameLoop) {
+      this.system.setFPS(this.gameLoop.getFPS());
+      this.updateGameLoopUpdateRate();
+    }
+    try {
+      if (this.sceneManager.hasActiveScene()) {
+        this.sceneManager.update();
+      } else {
+        this.vm.call("update");
+        this.vm.runner.tick();
+      }
+      if (this.vm.error_info) {
+        const err = Object.assign({}, this.vm.error_info);
+        err.type = "update";
+        reportError(this.listener, err);
+      }
+    } catch (err) {
+      reportError(this.listener, {
+        error: err.message || String(err),
+        type: "update",
+        stack: err.stack
+      });
+    }
+  }
+  handleDraw() {
+    if (!this.vm) return;
+    try {
+      this.screen.initDraw();
+      this.screen.updateInterface();
+      if (this.sceneManager.hasActiveScene()) {
+        this.sceneManager.draw();
+      } else {
+        this.vm.call("draw");
+        this.vm.runner.tick();
+      }
+      reportWarnings(this.vm, this.listener);
+      if (this.vm.error_info) {
+        const err = Object.assign({}, this.vm.error_info);
+        err.type = "draw";
+        reportError(this.listener, err);
+      }
+    } catch (err) {
+      reportError(this.listener, {
+        error: err.message || String(err),
+        type: "draw",
+        stack: err.stack
+      });
+    }
+    this.timeMachine?.step();
+  }
+  handleTick() {
+    if (this.vm?.runner) {
+      this.vm.runner.tick?.();
+    }
+  }
+  handleWatchStep() {
+    this.timeMachine?.loopStep();
+  }
+  ensureBridgeSubscription() {
+    if (this.bridgeUnsubscribe || !this.options.bridge?.subscribe) {
+      return;
+    }
+    const maybeUnsubscribe = this.options.bridge.subscribe((event) => this.handleHostEvent(event));
+    this.bridgeUnsubscribe = typeof maybeUnsubscribe === "function" ? maybeUnsubscribe : null;
+  }
+  handleHostEvent(event) {
+    switch (event.type) {
+      case "session.update":
+        this.mergeSession(event.payload);
+        break;
+      case "runtime.reset":
+        void this.reset(asRecord(event.payload));
+        break;
+      case "runtime.import_snapshot":
+        if (isRuntimeSnapshot(event.payload)) {
+          void this.importSnapshot(event.payload);
+        }
+        break;
+      case "runtime.export_snapshot":
+        this.emitBridgeEvent("runtime.snapshot", this.exportSnapshot());
+        break;
+      case "runtime.stop":
+      case "runtime.pause":
+        this.stop();
+        break;
+      case "runtime.resume":
+        this.resume();
+        break;
+      case "time_machine":
+        if (this.timeMachine && isRecord(event.payload)) {
+          const command = event.payload.command;
+          if (typeof command === "string") {
+            this.timeMachine.messageReceived({
+              name: "time_machine",
+              command,
+              position: typeof event.payload.position === "number" ? event.payload.position : void 0
+            });
+          }
+        }
+        break;
+    }
+  }
+  emitPlayerMessage(message) {
+    if (isRecord(message) && typeof message.type === "string") {
+      this.emitBridgeEvent(message.type, message);
+    } else {
+      this.emitBridgeEvent("player.message", message);
+    }
+  }
+  emitBridgeEvent(name, payload) {
+    this.options.bridge?.emit?.(name, payload);
+  }
+  sendBridgeRequest(name, payload, callback) {
+    const request = this.options.bridge?.request;
+    if (!request) {
+      callback?.({
+        ok: false,
+        error: `No runtime bridge request handler registered for "${name}"`
+      });
+      return null;
+    }
+    const requestId = createRequestId(name);
+    try {
+      const result = request(name, payload);
+      if (isPromiseLike(result)) {
+        void result.then((value) => callback?.(value)).catch((error) => callback?.({
+          ok: false,
+          error: error instanceof Error ? error.message : String(error)
+        }));
+      } else {
+        callback?.(result);
+      }
+      return requestId;
+    } catch (error) {
+      callback?.({
+        ok: false,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return requestId;
+    }
+  }
+  saveSnapshot(meta, callback) {
+    const snapshot = this.exportSnapshot();
+    const save = this.options.bridge?.saveSnapshot;
+    if (!save) {
+      const fallback = {
+        ok: false,
+        error: "No runtime bridge saveSnapshot handler registered",
+        snapshot
+      };
+      callback?.(fallback);
+      return fallback;
+    }
+    try {
+      const result = save(snapshot, meta);
+      if (isPromiseLike(result)) {
+        void result.then(() => callback?.({
+          ok: true,
+          snapshot
+        })).catch((error) => callback?.({
+          ok: false,
+          error: error instanceof Error ? error.message : String(error)
+        }));
+        return null;
+      }
+      callback?.({
+        ok: true,
+        snapshot
+      });
+      return {
+        ok: true,
+        snapshot
+      };
+    } catch (error) {
+      const failure = {
+        ok: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+      callback?.(failure);
+      return failure;
+    }
+  }
+  loadSnapshot(meta, callback) {
+    const load = this.options.bridge?.loadSnapshot;
+    if (!load) {
+      const fallback = {
+        ok: false,
+        error: "No runtime bridge loadSnapshot handler registered"
+      };
+      callback?.(fallback);
+      return fallback;
+    }
+    try {
+      const result = load(meta);
+      if (isPromiseLike(result)) {
+        void result.then(async (snapshot) => {
+          if (snapshot) {
+            await this.importSnapshot(snapshot);
+          }
+          callback?.({
+            ok: true,
+            snapshot
+          });
+        }).catch((error) => callback?.({
+          ok: false,
+          error: error instanceof Error ? error.message : String(error)
+        }));
+        return null;
+      }
+      if (result) {
+        void this.importSnapshot(result);
+      }
+      callback?.({
+        ok: true,
+        snapshot: result
+      });
+      return result;
+    } catch (error) {
+      const failure = {
+        ok: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+      callback?.(failure);
+      return failure;
+    }
+  }
+  async hydrateSession() {
+    if (this.sessionSnapshot) {
+      return;
+    }
+    const getSession = this.options.bridge?.getSession;
+    if (!getSession) {
+      this.sessionSnapshot = this.options.initialSession || null;
+      return;
+    }
+    try {
+      const session = getSession();
+      this.sessionSnapshot = isPromiseLike(session) ? await session : session;
+    } catch {
+      this.sessionSnapshot = this.options.initialSession || null;
+    }
+  }
+  mergeSession(payload) {
+    if (!isRecord(payload)) {
+      return;
+    }
+    const current = this.sessionSnapshot || {};
+    this.sessionSnapshot = {
+      ...current,
+      ...payload
+    };
+  }
+  teardownRuntimeState() {
+    this.gameLoop = null;
+    this.sourceUpdater = null;
+    this.vm = null;
+    this.timeMachine = null;
+    this.frameCount = 0;
+    this.lastUpdateRate = -1;
+    this.isStopped = false;
+    this.sceneManager.registry.clear();
+    this.sceneManager.routeManager.clear();
+  }
+  logStep(message, payload) {
+    if (!this.options.debug?.lifecycle) return;
+    const prefix = "[@al8b/runtime][lifecycle]";
+    if (payload !== void 0) {
+      console.info(`${prefix} ${message}`, payload);
+    } else {
+      console.info(`${prefix} ${message}`);
+    }
+    if (this.listener.log) {
+      try {
+        const serialized = payload === void 0 ? "" : ` ${JSON.stringify(payload)}`;
+        this.listener.log(`${prefix} ${message}${serialized}`);
+      } catch {
+        this.listener.log(`${prefix} ${message}`);
+      }
+    }
+  }
+};
+function serializeGlobalSnapshot(global) {
+  const globalRecord = global;
+  const excluded = [
+    globalRecord.random,
+    globalRecord.screen,
+    globalRecord.audio,
+    globalRecord.keyboard,
+    globalRecord.mouse,
+    globalRecord.touch,
+    globalRecord.gamepad,
+    globalRecord.system,
+    globalRecord.storage,
+    globalRecord.host,
+    globalRecord.session,
+    globalRecord.memory
+  ].filter((value) => value != null);
+  return deepCloneValue(globalRecord, excluded);
+}
+__name(serializeGlobalSnapshot, "serializeGlobalSnapshot");
+function deepCloneValue(value, excluded = []) {
+  if (value == null) {
+    return value;
+  }
+  if (excluded.includes(value)) {
+    return null;
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => deepCloneValue(entry, excluded));
+  }
+  if (typeof value === "object") {
+    const clone = {};
+    for (const [key, entry] of Object.entries(value)) {
+      clone[key] = deepCloneValue(entry, excluded);
+    }
+    return clone;
+  }
+  return null;
+}
+__name(deepCloneValue, "deepCloneValue");
+function cloneSnapshot(value) {
+  return deepCloneValue(value);
+}
+__name(cloneSnapshot, "cloneSnapshot");
+function createRequestId(name) {
+  return `${name}:${Date.now()}:${Math.random().toString(36).slice(2, 8)}`;
+}
+__name(createRequestId, "createRequestId");
+function isPromiseLike(value) {
+  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+}
+__name(isPromiseLike, "isPromiseLike");
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isRecord, "isRecord");
+function asRecord(value) {
+  return isRecord(value) ? value : void 0;
+}
+__name(asRecord, "asRecord");
+function isRuntimeSnapshot(value) {
+  if (!isRecord(value)) return false;
+  if (value.version !== 1) return false;
+  if (!isRecord(value.global)) return false;
+  if (!("router" in value)) return false;
+  if (!("session" in value)) return false;
+  return true;
+}
+__name(isRuntimeSnapshot, "isRuntimeSnapshot");
+export {
+  createRuntime
+};
+//# sourceMappingURL=index.mjs.map