@skewedaspect/sage 0.3.0

package/dist/sage.es.js

@@ -0,0 +1,2208 @@
+var I = Object.defineProperty;
+var k = (a, e, t) => e in a ? I(a, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : a[e] = t;
+var n = (a, e, t) => k(a, typeof e != "symbol" ? e + "" : e, t);
+import { FreeCamera as V, Vector3 as b, HemisphericLight as G, MeshBuilder as D, PhysicsAggregate as E, PhysicsShapeType as C, Scene as L, NullEngine as B, WebGPUEngine as K, Engine as U, HavokPlugin as R } from "@babylonjs/core";
+import z from "@babylonjs/havok";
+const m = "0.3.0";
+class T {
+  /**
+   * Creates an instance of SkewedAspectGameEngine.
+   * @param canvas - The game canvas.
+   * @param renderEngine - The rendering engine.
+   * @param physics - The physics engine.
+   * @param eventBus - The event bus.
+   * @param logger - The logging utility.
+   * @param engines - The engines used in the game.
+   * @param managers - The managers used in the game.
+   */
+  constructor(e, t, s, i, o, r, c) {
+    n(this, "canvas");
+    n(this, "renderEngine");
+    n(this, "physics");
+    n(this, "managers");
+    n(this, "engines");
+    n(this, "eventBus");
+    n(this, "logger");
+    n(this, "_log");
+    this.canvas = e, this.renderEngine = t, this.physics = s, this.eventBus = i, this.logger = o, this.engines = r, this.managers = c, this._log = o.getLogger("GameEngine");
+  }
+  //------------------------------------------------------------------------------------------------------------------
+  // Public API
+  //------------------------------------------------------------------------------------------------------------------
+  /**
+   * Starts the game engine.
+   */
+  async start() {
+    this._log.info(`Starting SkewedAspect Game Engine (Version: ${m})...`), await this.managers.gameManager.start(this.canvas), this._log.info("Game engine started successfully");
+  }
+  /**
+   * Stops the game engine.
+   */
+  async stop() {
+    this._log.info(`Stopping SkewedAspect Game Engine (Version: ${m})...`), await this.managers.gameManager.stop(), this._log.info("Game engine stopped successfully");
+  }
+}
+class W {
+  constructor() {
+    n(this, "timers");
+    this.timers = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Get the CSS style for a specific log level
+   */
+  getStyleForLevel(e) {
+    const t = {
+      trace: "color: #999999",
+      // Dim gray
+      debug: "color: #00AAAA",
+      // Cyan
+      info: "color: #00AA00",
+      // Green
+      warn: "color: #AAAA00",
+      // Yellow
+      error: "color: #AA0000",
+      // Red
+      timer: "color: #AA00AA",
+      // Magenta
+      none: "color: inherit"
+      // Default
+    };
+    return t[e] || t.none;
+  }
+  /**
+   * Format a log message with category, timestamp and log level
+   */
+  formatMessage(e, t) {
+    const s = /* @__PURE__ */ new Date(), i = s.getHours() % 12 || 12, o = s.getMinutes().toString().padStart(2, "0"), r = s.getSeconds().toString().padStart(2, "0"), c = s.getHours() >= 12 ? "PM" : "AM", h = `[${i}:${o}:${r} ${c}]`, u = t.toUpperCase();
+    return [
+      `${h} %c${u}%c (${e}): `,
+      // Format string with placeholders
+      this.getStyleForLevel(t),
+      // Level style
+      "",
+      // Default style
+      ""
+      // Reset style
+    ];
+  }
+  trace(e, t, ...s) {
+    const [i, o, r, c] = this.formatMessage(e, "trace");
+    console.debug(i, o, r, c, t, ...s);
+  }
+  debug(e, t, ...s) {
+    const [i, o, r, c] = this.formatMessage(e, "debug");
+    console.debug(i, o, r, c, t, ...s);
+  }
+  info(e, t, ...s) {
+    const [i, o, r, c] = this.formatMessage(e, "info");
+    console.info(i, o, r, c, t, ...s);
+  }
+  warn(e, t, ...s) {
+    const [i, o, r, c] = this.formatMessage(e, "warn");
+    console.warn(i, o, r, c, t, ...s);
+  }
+  error(e, t, ...s) {
+    const [i, o, r, c] = this.formatMessage(e, "error");
+    console.error(i, o, r, c, t, ...s);
+  }
+  /**
+   * Start a timer with the specified label.
+   */
+  time(e, t) {
+    const s = `${e}:${t}`;
+    this.timers.set(s, performance.now());
+  }
+  /**
+   * End a timer and log the elapsed time.
+   */
+  timeEnd(e, t) {
+    const s = `${e}:${t}`, i = this.timers.get(s);
+    if (i !== void 0) {
+      const o = performance.now() - i;
+      this.timers.delete(s);
+      const [r, c, h, u] = this.formatMessage(e, "timer");
+      console.info(`${r} Timer '${t}' completed in ${o.toFixed(2)}ms`, c, h, u);
+    } else
+      console.warn(`[${e}]: Timer '${t}' does not exist`);
+  }
+}
+class P {
+  trace(e, t, ...s) {
+  }
+  debug(e, t, ...s) {
+  }
+  info(e, t, ...s) {
+  }
+  warn(e, t, ...s) {
+  }
+  error(e, t, ...s) {
+  }
+  time(e, t) {
+  }
+  timeEnd(e, t) {
+  }
+}
+class l {
+  constructor(e, t = "none", s = new P()) {
+    n(this, "category");
+    n(this, "backend");
+    n(this, "minLevel");
+    this.category = e, this.backend = s, this.minLevel = t;
+  }
+  /**
+   * Update the logger's backend and minimum level
+   */
+  updateSettings(e, t) {
+    this.backend = e, this.minLevel = t;
+  }
+  trace(e, ...t) {
+    this.shouldLog("trace") && this.backend.trace(this.category, e, ...t);
+  }
+  debug(e, ...t) {
+    this.shouldLog("debug") && this.backend.debug(this.category, e, ...t);
+  }
+  info(e, ...t) {
+    this.shouldLog("info") && this.backend.info(this.category, e, ...t);
+  }
+  warn(e, ...t) {
+    this.shouldLog("warn") && this.backend.warn(this.category, e, ...t);
+  }
+  error(e, ...t) {
+    this.shouldLog("error") && this.backend.error(this.category, e, ...t);
+  }
+  time(e) {
+    this.minLevel !== "none" && this.backend.time(this.category, e);
+  }
+  timeEnd(e) {
+    this.minLevel !== "none" && this.backend.timeEnd(this.category, e);
+  }
+  /**
+   * Determine if a message at the given level should be logged based on the current minimum level.
+   */
+  shouldLog(e) {
+    if (this.minLevel === "none")
+      return !1;
+    switch (this.minLevel) {
+      case "trace":
+        return !0;
+      case "debug":
+        return e !== "trace";
+      case "info":
+        return e === "info" || e === "warn" || e === "error";
+      case "warn":
+        return e === "warn" || e === "error";
+      case "error":
+        return e === "error";
+      default:
+        return !1;
+    }
+  }
+}
+class F {
+  /**
+   * Create a new LoggingUtility.
+   *
+   * @param level - The minimum logging level (defaults to INFO)
+   * @param backend - The logging backend to use (defaults to ConsoleBackend)
+   */
+  constructor(e = "debug", t = new W()) {
+    n(this, "backend");
+    n(this, "level");
+    n(this, "loggers");
+    this.backend = t, this.level = e, this.loggers = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Set the logging backend.
+   *
+   * @param backend - The logging backend to use
+   */
+  setBackend(e) {
+    this.backend = e, this.loggers.forEach((t) => {
+      t instanceof l && t.updateSettings(this.backend, this.level);
+    });
+  }
+  /**
+   * Set the minimum logging level.
+   *
+   * @param level - The minimum logging level to display
+   */
+  setLevel(e) {
+    this.level = e, this.loggers.forEach((t) => {
+      t instanceof l && t.updateSettings(this.backend, this.level);
+    });
+  }
+  /**
+   * Get the current minimum logging level.
+   */
+  getLevel() {
+    return this.level;
+  }
+  /**
+   * Get a logger for the specified category.
+   *
+   * @param category - The category for this logger (typically class/module name)
+   * @returns A Logger instance for the specified category
+   */
+  getLogger(e) {
+    this.loggers.has(e) || this.loggers.set(e, new l(e, this.level, this.backend));
+    const t = this.loggers.get(e);
+    if (t === void 0)
+      throw new Error(`Failed to create logger for category: ${e}`);
+    return t;
+  }
+}
+class O {
+  /**
+   * Creates a new GameEventBus instance
+   *
+   * @param logger - The logging utility to use
+   */
+  constructor(e) {
+    /**
+     * For exact event-type matches:
+     * - Key = event type string (e.g. "input:keydown")
+     * - Value = set of subscriptions for that exact type
+     */
+    n(this, "directMap", /* @__PURE__ */ new Map());
+    /**
+     * For pattern-based (wildcard or RegExp) subscriptions.
+     */
+    n(this, "patternSubs", /* @__PURE__ */ new Set());
+    /**
+     * Logger instance
+     */
+    n(this, "_log");
+    this._log = (e == null ? void 0 : e.getLogger("EventBus")) || new l("EventBus");
+  }
+  /**
+   * Subscribe with automatic detection:
+   *   - If `eventTypeOrPattern` is a `RegExp` or a string containing `*`, treat it as a pattern subscription.
+   *   - Otherwise, treat it as an exact subscription.
+   *
+   * @template P - The payload shape you want to expect in the callback.
+   * @param {string | RegExp} eventTypeOrPattern - The exact event type or a wildcard/RegExp pattern.
+   * @param {GameEventCallback<P>} callback - A callback expecting a `GameEvent<P>`.
+   * @returns {Unsubscribe} function that, when called, removes this subscription.
+   */
+  subscribe(e, t) {
+    return this._log.trace(`Subscribe request for: ${e.toString()}`), e instanceof RegExp || typeof e == "string" && e.includes("*") ? this.subscribePattern(e, t) : this.subscribeExact(e, t);
+  }
+  /**
+   * Subscribes to an exact event type (e.g. "input:keydown").
+   *
+   * @template P - The payload shape you want to expect in the callback.
+   * @param {string} eventType - The exact string to match.
+   * @param {GameEventCallback<P>} callback - A callback expecting a `GameEvent<P>`.
+   * @returns {Unsubscribe} function that unsubscribes this exact subscription.
+   */
+  subscribeExact(e, t) {
+    this._log.debug(`Adding exact subscription for: ${e}`);
+    let s = this.directMap.get(e);
+    s || (s = /* @__PURE__ */ new Set(), this.directMap.set(e, s));
+    const i = {
+      callback: (o) => t(o)
+      // runtime "type-lie" cast
+    };
+    return s.add(i), () => {
+      this._log.debug(`Removing exact subscription for: ${e}`), s.delete(i), s.size === 0 && this.directMap.delete(e);
+    };
+  }
+  /**
+   * Subscribes with either:
+   *  - a wildcard string (contains `*`) that gets converted to a RegExp
+   *  - a RegExp directly
+   *
+   * @template P - The payload shape you want to expect in the callback.
+   * @param {string | RegExp} patternOrRegExp - The pattern to match (`"input:*"` or `/^input:/`).
+   * @param {GameEventCallback<P>} callback - A callback expecting a `GameEvent<P>`.
+   * @returns {Unsubscribe} function that unsubscribes this pattern-based subscription.
+   */
+  subscribePattern(e, t) {
+    let s;
+    if (typeof e == "string") {
+      const o = e.replace(/[-/\\^$+?.()|[\]{}]/g, "\\$&").replace(/\*/g, ".*");
+      s = new RegExp(`^${o}$`), this._log.debug(`Adding pattern subscription for string: ${e}, regex: ${s.toString()}`);
+    } else
+      s = e, this._log.debug(`Adding pattern subscription for regex: ${s.toString()}`);
+    const i = {
+      pattern: s,
+      callback: (o) => t(o)
+    };
+    return this.patternSubs.add(i), () => {
+      this._log.debug(`Removing pattern subscription: ${s.toString()}`), this.patternSubs.delete(i);
+    };
+  }
+  /**
+   * Publishes an event, invoking all matching callbacks.
+   *
+   * Callbacks are called asynchronously (microtask) via `Promise.resolve()`.
+   *
+   * @param {GameEvent<any>} event - The event object to publish.
+   */
+  publish(e) {
+    this._log.trace(`Publishing event: ${e.type}`, e);
+    let t = 0;
+    const s = this.directMap.get(e.type);
+    if (s) {
+      t += s.size;
+      for (const i of s)
+        Promise.resolve().then(() => i.callback(e));
+    }
+    for (const i of this.patternSubs)
+      i.pattern && i.pattern.test(e.type) && (t++, Promise.resolve().then(() => i.callback(e)));
+    t === 0 ? this._log.debug(`No subscribers found for event: ${e.type}`) : this._log.trace(`Event ${e.type} dispatched to ${t} subscribers`);
+  }
+}
+class N {
+  constructor(e, t, s) {
+    n(this, "_engine");
+    n(this, "_physics");
+    n(this, "_log");
+    this._engine = e, this._physics = t, this._log = (s == null ? void 0 : s.getLogger("SceneEngine")) || new l("SceneEngine");
+  }
+  async _buildDemoScene(e, t) {
+    this._log.debug("Building demo scene..."), this._log.trace("Creating camera...");
+    const s = new V("camera1", new b(0, 5, -10), e);
+    s.setTarget(b.Zero()), s.attachControl(t, !0), this._log.trace("Creating light...");
+    const i = new G("light", new b(0, 1, 0), e);
+    i.intensity = 0.7, this._log.trace("Creating sphere...");
+    const o = D.CreateSphere("sphere", { diameter: 2, segments: 32 }, e);
+    o.position.y = 4, this._log.trace("Creating ground...");
+    const r = D.CreateGround("ground", { width: 10, height: 10 }, e);
+    this._log.trace("Adding physics to sphere..."), new E(o, C.SPHERE, { mass: 1, restitution: 0.75 }, e), this._log.trace("Adding physics to ground..."), new E(r, C.BOX, { mass: 0 }, e), this._log.debug("Demo scene built successfully");
+  }
+  // TODO: This needs more logic to handle different scenes
+  async loadScene(e) {
+    this._log.info("Loading scene..."), this._log.time("sceneLoad"), this._log.debug("Creating new scene...");
+    const t = new L(this._engine);
+    return this._log.debug("Enabling physics with gravity (0, -9.8, 0)..."), t.enablePhysics(new b(0, -9.8, 0), this._physics), await this._buildDemoScene(t, e), this._log.timeEnd("sceneLoad"), this._log.info("Scene loaded successfully"), t;
+  }
+}
+const J = [
+  "trigger",
+  "toggle",
+  "value"
+];
+class Y {
+  //------------------------------------------------------------------------------------------------------------------
+  /**
+   * Create a new trigger binding
+   *
+   * @param action - Action to trigger
+   * @param deviceID - Device ID this binding is for
+   * @param reader - Input reader to read values from
+   * @param options - Binding configuration options
+   */
+  constructor(e, t, s, i = {}) {
+    n(this, "type", "trigger");
+    n(this, "action");
+    n(this, "context");
+    n(this, "deviceID");
+    n(this, "reader");
+    // Trigger-specific options
+    n(this, "_edgeMode");
+    n(this, "_threshold");
+    // State tracking
+    n(this, "_lastDigitalState", !1);
+    this.action = e, this.deviceID = t, this.reader = s, this.context = i.context, this._edgeMode = i.edgeMode ?? "rising", this._threshold = i.threshold ?? 0.5;
+  }
+  //------------------------------------------------------------------------------------------------------------------
+  // Public Getters
+  //------------------------------------------------------------------------------------------------------------------
+  /**
+   * Get the current options for this trigger binding.
+   *
+   * @returns The current options for this trigger binding
+   */
+  get options() {
+    return {
+      edgeMode: this._edgeMode,
+      threshold: this._threshold
+    };
+  }
+  //------------------------------------------------------------------------------------------------------------------
+  // Public Methods
+  //------------------------------------------------------------------------------------------------------------------
+  /**
+   * Process input state and emit an action if triggered
+   *
+   * @param state - Current input state
+   * @param eventBus - Event bus to emit action events to
+   * @returns True if an action was triggered, false otherwise
+   */
+  process(e, t) {
+    const s = this.reader.getValue(e) ?? !1, i = typeof s == "boolean" ? s : s >= this._threshold;
+    let o = !1;
+    switch (this._edgeMode) {
+      case "rising":
+        o = i && !this._lastDigitalState;
+        break;
+      case "falling":
+        o = !i && this._lastDigitalState;
+        break;
+      case "both":
+        o = i !== this._lastDigitalState;
+        break;
+    }
+    if (this._lastDigitalState = i, o) {
+      let r;
+      if (this.action.type === "analog") {
+        let h = typeof s == "number" ? s : s ? 1 : 0;
+        if (this.action.minValue !== void 0 || this.action.maxValue !== void 0) {
+          const u = this.action.minValue ?? 0, g = this.action.maxValue ?? 1;
+          h = u + h * (g - u);
+        }
+        r = h;
+      } else
+        r = !0;
+      const c = {
+        type: `action:${this.action.name}`,
+        payload: {
+          value: r,
+          deviceId: this.deviceID,
+          context: this.context
+        }
+      };
+      t.publish(c);
+    }
+  }
+  /**
+   * Returns a JSON-serializable representation of this trigger binding
+   *
+   * @returns A simple object representation that can be converted to JSON
+   */
+  toJSON() {
+    return {
+      type: this.type,
+      action: this.action.name,
+      input: {
+        deviceID: this.deviceID,
+        ...this.reader.toJSON()
+      },
+      context: this.context,
+      options: this.options
+    };
+  }
+}
+class H {
+  //------------------------------------------------------------------------------------------------------------------
+  /**
+   * Create a new toggle binding
+   *
+   * @param action - Action to toggle
+   * @param deviceID - Device ID this binding is for
+   * @param reader - Input reader to read values from
+   * @param options - Binding configuration options
+   */
+  constructor(e, t, s, i = {}) {
+    n(this, "type", "toggle");
+    n(this, "action");
+    n(this, "context");
+    n(this, "deviceID");
+    n(this, "reader");
+    // Toggle-specific options
+    n(this, "_invert");
+    n(this, "_threshold");
+    n(this, "_initialState");
+    n(this, "_onValue");
+    n(this, "_offValue");
+    // State tracking
+    n(this, "_lastDigitalState", !1);
+    n(this, "_toggleState");
+    this.action = e, this.deviceID = t, this.reader = s, this.context = i.context, this._invert = i.invert ?? !1, this._threshold = i.threshold ?? 0.5, this._initialState = i.initialState ?? !1, this._toggleState = this._initialState, this._onValue = i.onValue ?? !0, this._offValue = i.offValue ?? !1;
+  }
+  //------------------------------------------------------------------------------------------------------------------
+  // Public Getters
+  //------------------------------------------------------------------------------------------------------------------
+  /**
+   * Get the current toggle state
+   *
+   * @returns Current toggle state (true = on, false = off)
+   */
+  get state() {
+    return this._toggleState;
+  }
+  /**
+   * Set the toggle state directly (useful for programmatic control)
+   *
+   * @param value - New toggle state
+   */
+  set state(e) {
+    this._toggleState = e;
+  }
+  /**
+   * Get the value emitted when toggle is in the "on" state
+   *
+   * @returns The value for the "on" state
+   */
+  get onValue() {
+    return this._onValue;
+  }
+  /**
+   * Get the value emitted when toggle is in the "off" state
+   *
+   * @returns The value for the "off" state
+   */
+  get offValue() {
+    return this._offValue;
+  }
+  /**
+   * Get the current value based on toggle state
+   *
+   * @returns The current value (boolean or number)
+   */
+  get value() {
+    return this.action.type === "analog" ? this._toggleState ? this.action.maxValue ?? 1 : this.action.minValue ?? 0 : this._toggleState ? this._onValue : this._offValue;
+  }
+  /**
+   * Get the current options for this toggle binding.
+   *
+   * @returns The current options for this toggle binding
+   */
+  get options() {
+    return {
+      invert: this._invert,
+      threshold: this._threshold,
+      initialState: this._initialState,
+      onValue: this._onValue,
+      offValue: this._offValue
+    };
+  }
+  //------------------------------------------------------------------------------------------------------------------
+  // Public Methods
+  //------------------------------------------------------------------------------------------------------------------
+  /**
+   * Process input state and emit a digital action if toggled
+   *
+   * @param state - Current input state
+   * @param eventBus - Event bus to emit action events to
+   */
+  process(e, t) {
+    const s = this.reader.getValue(e) ?? !1, i = typeof s == "boolean" ? s : s >= this._threshold, o = this._invert ? !i && this._lastDigitalState : i && !this._lastDigitalState;
+    this._lastDigitalState = i, o && (this._toggleState = !this._toggleState, t.publish({
+      type: `action:${this.action.name}`,
+      payload: {
+        value: this.value,
+        deviceId: this.deviceID,
+        context: this.context
+      }
+    }));
+  }
+  /**
+   * Reset toggle to its initial state
+   */
+  reset() {
+    this._toggleState = this._initialState;
+  }
+  /**
+   * Returns a JSON-serializable representation of this toggle binding
+   *
+   * @returns A simple object representation that can be converted to JSON
+   */
+  toJSON() {
+    return {
+      type: this.type,
+      action: this.action.name,
+      input: {
+        deviceID: this.deviceID,
+        ...this.reader.toJSON()
+      },
+      state: this._toggleState,
+      context: this.context,
+      options: this.options
+    };
+  }
+}
+class X {
+  //------------------------------------------------------------------------------------------------------------------
+  /**
+   * Create a new value binding
+   *
+   * @param action - Action to emit values for
+   * @param deviceID - Device ID this binding is for
+   * @param reader - Input reader to read values from
+   * @param options - Binding configuration options
+   */
+  constructor(e, t, s, i = {}) {
+    n(this, "type", "value");
+    n(this, "action");
+    n(this, "context");
+    n(this, "deviceID");
+    n(this, "reader");
+    // Value-specific options
+    n(this, "_scale");
+    n(this, "_offset");
+    n(this, "_invert");
+    n(this, "_emitOnChange");
+    n(this, "_deadzone");
+    n(this, "_onValue");
+    n(this, "_offValue");
+    n(this, "_min");
+    n(this, "_max");
+    // State tracking
+    n(this, "_lastValue");
+    this.action = e, this.deviceID = t, this.reader = s, this.context = i.context, this._scale = i.scale ?? 1, this._offset = i.offset ?? 0, this._invert = i.invert ?? !1, this._emitOnChange = i.emitOnChange ?? !0, this._deadzone = i.deadzone ?? 0, this._onValue = i.onValue ?? !0, this._offValue = i.offValue ?? !1;
+    const o = this.action.type === "analog" ? this.action.minValue ?? Number.NEGATIVE_INFINITY : Number.NEGATIVE_INFINITY;
+    this._min = i.min ?? o;
+    const r = this.action.type === "analog" ? this.action.maxValue ?? Number.POSITIVE_INFINITY : Number.POSITIVE_INFINITY;
+    this._max = i.max ?? r;
+  }
+  //------------------------------------------------------------------------------------------------------------------
+  /**
+   * Get the current options for this value binding.
+   *
+   * @returns The current options for this value binding
+   */
+  get options() {
+    return {
+      scale: this._scale,
+      offset: this._offset,
+      invert: this._invert,
+      emitOnChange: this._emitOnChange,
+      deadzone: this._deadzone,
+      onValue: this._onValue,
+      offValue: this._offValue,
+      min: this._min,
+      max: this._max
+    };
+  }
+  //------------------------------------------------------------------------------------------------------------------
+  // Public Methods
+  //------------------------------------------------------------------------------------------------------------------
+  /**
+   * Process input state and emit an action value
+   *
+   * @param state - Current input state
+   * @param eventBus - Event bus to emit action events to
+   * @returns True if a value was emitted, false otherwise
+   */
+  process(e, t) {
+    const s = this.reader.getValue(e);
+    if (s === void 0)
+      return;
+    const i = typeof s == "boolean" ? s ? 1 : 0 : s;
+    if (i === void 0)
+      return;
+    let o = this._deadzone > 0 && Math.abs(i) < this._deadzone ? 0 : i;
+    o = (this._invert ? -o : o) * this._scale + this._offset, o = Math.max(this._min, Math.min(this._max, o)), !(this._emitOnChange && this._lastValue === o) && (this._lastValue = o, t.publish({
+      type: `action:${this.action.name}`,
+      payload: {
+        value: o,
+        deviceId: this.deviceID,
+        context: this.context
+      }
+    }));
+  }
+  /**
+   * Returns a JSON-serializable representation of this value binding
+   *
+   * @returns A simple object representation that can be converted to JSON
+   */
+  toJSON() {
+    return {
+      type: this.type,
+      action: this.action.name,
+      input: {
+        deviceID: this.deviceID,
+        ...this.reader.toJSON()
+      },
+      context: this.context,
+      options: this.options
+    };
+  }
+}
+class w {
+  /**
+   * Creates a new KeyboardValueReader
+   *
+   * @param keyCode - The key code to monitor (e.g., "KeyA", "Space")
+   * @param options - Configuration options
+   */
+  constructor(e, t = {}) {
+    /**
+     * The type of keyboard input (always 'key')
+     */
+    n(this, "sourceType", "key");
+    /**
+     * The key code to monitor (e.g., "KeyA", "Space")
+     */
+    n(this, "sourceKey");
+    /**
+     * Whether to use delta state instead of current state
+     */
+    n(this, "useDelta");
+    this.sourceKey = e, this.useDelta = t.useDelta || !1;
+  }
+  /**
+   * Gets the value of the key state
+   *
+   * @param state - The input state
+   * @returns The key state value or undefined if the state type is not keyboard
+   */
+  getValue(e) {
+    if (e.type !== "keyboard")
+      return;
+    const t = e;
+    return this.useDelta ? t.delta[this.sourceKey] : t.keys[this.sourceKey];
+  }
+  /**
+   * Creates a KeyboardValueReader from a string representation
+   *
+   * @param sourceKey - The key code (e.g., "KeyA", "Space")
+   * @param options - Optional configuration
+   * @returns A new KeyboardValueReader instance
+   */
+  static fromString(e, t = {}) {
+    return new w(e, t);
+  }
+  /**
+   * Returns a JSON-serializable representation of this keyboard value reader
+   *
+   * @returns A simple object representation that can be converted to JSON
+   */
+  toJSON() {
+    return {
+      type: "keyboard",
+      sourceType: this.sourceType,
+      sourceKey: this.sourceKey,
+      options: {
+        useDelta: this.useDelta
+      }
+    };
+  }
+}
+class x {
+  /**
+   * Creates a new MouseValueReader
+   *
+   * @param sourceType - Type of mouse input to monitor (button, position, wheel)
+   * @param sourceKey - The specific key for this input type
+   */
+  constructor(e, t) {
+    /**
+     * The type of mouse input
+     */
+    n(this, "sourceType");
+    /**
+     * The specific key for this input
+     */
+    n(this, "sourceKey");
+    this.sourceType = e, this.sourceKey = t;
+  }
+  /**
+   * Gets the value of the mouse input source
+   *
+   * @param state - The current input state
+   * @returns The value of the input source
+   */
+  getValue(e) {
+    if (e.type === "mouse")
+      switch (this.sourceType) {
+        case "button": {
+          const t = e.buttons[this.sourceKey];
+          return t ? t.pressed : void 0;
+        }
+        case "position": {
+          const [t, s] = this.sourceKey.split(":");
+          return !t || !s || t !== "absolute" && t !== "relative" || s !== "x" && s !== "y" ? void 0 : e.position[t][s];
+        }
+        case "wheel": {
+          const t = this.sourceKey === "deltaX" || this.sourceKey === "deltaY" || this.sourceKey === "deltaZ";
+          return e.wheel && t ? e.wheel[this.sourceKey] : void 0;
+        }
+        default:
+          return;
+      }
+  }
+  /**
+   * Creates a MouseValueReader from a string representation
+   *
+   * @param sourceTypeString - String in format "sourceType:sourceKey" (e.g., "button:0", "position:absolute:x")
+   * @returns A new MouseValueReader instance
+   */
+  static fromString(e) {
+    const [t, ...s] = e.split(":"), i = s.join(":");
+    if (!t || !i)
+      throw new Error(`Invalid mouse source format: ${e}`);
+    return new x(t, i);
+  }
+  /**
+   * Returns a JSON-serializable representation of this mouse value reader
+   *
+   * @returns A simple object representation that can be converted to JSON
+   */
+  toJSON() {
+    return {
+      type: "mouse",
+      sourceType: this.sourceType,
+      sourceKey: this.sourceKey
+    };
+  }
+}
+class S {
+  /**
+   * Creates a new GamepadValueReader
+   *
+   * @param sourceType - Type of gamepad input to monitor (button or axis)
+   * @param sourceKey - The specific key for this input type
+   * @param options - Configuration options
+   */
+  constructor(e, t, s = {}) {
+    /**
+     * The type of gamepad input
+     */
+    n(this, "sourceType");
+    /**
+     * The specific key for this input
+     */
+    n(this, "sourceKey");
+    /**
+     * Whether to use analog value for buttons
+     */
+    n(this, "useAnalogValue");
+    /**
+     * Deadzone value for axes
+     */
+    n(this, "deadzone");
+    /**
+     * Whether to invert axis values
+     */
+    n(this, "invert");
+    this.sourceType = e, this.sourceKey = t, this.useAnalogValue = s.useAnalogValue || !1, this.deadzone = s.deadzone || 0.1, this.invert = s.invert || !1;
+  }
+  /**
+   * Gets the value of the input source based on the current state
+   *
+   * @param state - The current input state
+   * @returns The value of the input source
+   */
+  getValue(e) {
+    if (e.type === "gamepad")
+      switch (this.sourceType) {
+        case "button": {
+          const t = e.buttons[this.sourceKey];
+          return t ? this.useAnalogValue ? t.value : t.pressed : void 0;
+        }
+        case "axis": {
+          let t = e.axes[this.sourceKey];
+          return t === void 0 ? void 0 : (Math.abs(t) < this.deadzone && (t = 0), this.invert ? -t : t);
+        }
+        default:
+          return;
+      }
+  }
+  /**
+   * Creates a GamepadValueReader from a string representation
+   *
+   * @param sourceTypeString - String in format "sourceType:sourceKey" (e.g., "button:0", "axis:1")
+   * @param options - Optional configuration options
+   * @returns A new GamepadValueReader instance
+   */
+  static fromString(e, t = {}) {
+    const [s, i] = e.split(":");
+    if (!s || !i)
+      throw new Error(`Invalid gamepad source format: ${e}`);
+    return new S(s, i, t);
+  }
+  /**
+   * Returns a JSON-serializable representation of this gamepad value reader
+   *
+   * @returns A simple object representation that can be converted to JSON
+   */
+  toJSON() {
+    return {
+      type: "gamepad",
+      sourceType: this.sourceType,
+      sourceKey: this.sourceKey,
+      options: {
+        useAnalogValue: this.useAnalogValue,
+        deadzone: this.deadzone,
+        invert: this.invert
+      }
+    };
+  }
+}
+class j {
+  /**
+   * Creates an instance of BindingManager.
+   *
+   * @param eventBus - The game event bus to publish events to
+   * @param logger - The logging utility to use
+   */
+  constructor(e, t) {
+    /** Map of device IDs to their bindings */
+    n(this, "_bindings", /* @__PURE__ */ new Map());
+    /** Map of action names to their action definitions */
+    n(this, "_actions", /* @__PURE__ */ new Map());
+    /** Map of all registered contexts by name for O(1) lookup */
+    n(this, "_contexts", /* @__PURE__ */ new Map());
+    /**
+     * Set of all active contexts (both exclusive and non-exclusive)
+     */
+    n(this, "_activeContexts", /* @__PURE__ */ new Set());
+    /** Event bus for handling game events */
+    n(this, "_eventBus");
+    /** Logger instance */
+    n(this, "_log");
+    this._eventBus = e, this._eventBus.subscribe("input:changed", (s) => {
+      s.payload && this.$handleInput(s.payload.device, s.payload.state);
+    }), this._log = (t == null ? void 0 : t.getLogger("BindingManager")) || new l("BindingManager"), this._log.debug("BindingManager initialized");
+  }
+  //------------------------------------------------------------------------------------------------------------------
+  // Private Methods
+  //------------------------------------------------------------------------------------------------------------------
+  /**
+   * Checks if a binding's context is currently active
+   *
+   * @param binding - The binding to check
+   * @returns True if binding's context is active or has no context
+   */
+  _isBindingContextActive(e) {
+    return e.context ? this._activeContexts.has(e.context) : !0;
+  }
+  /**
+   * Get a context by name, creating it if it doesn't exist
+   *
+   * @param contextName - The name of the context to get or create
+   * @param exclusive - Whether the context is exclusive (only used if creating)
+   * @returns The context object
+   */
+  _getOrCreateContext(e, t = !0) {
+    let s = this._contexts.get(e);
+    return s || (s = {
+      name: e,
+      exclusive: t
+    }, this._contexts.set(e, s), this._log.debug(`Auto-created context "${e}" (exclusive: ${t})`)), s;
+  }
+  /**
+   * Deactivate all exclusive contexts except the specified one
+   *
+   * @param exceptContextName - Name of context to not deactivate
+   * @returns Array of deactivated context names
+   */
+  _deactivateExclusiveContexts(e) {
+    const t = [];
+    for (const s of this._activeContexts) {
+      if (s === e)
+        continue;
+      const i = this._contexts.get(s);
+      i != null && i.exclusive && (this._activeContexts.delete(s), t.push(s));
+    }
+    return t;
+  }
+  /**
+   * Create a binding from a binding definition
+   *
+   * @param definition - The binding definition to create a binding from
+   * @returns A new binding instance or null if the type is not supported
+   */
+  _createBindingFromDefinition(e) {
+    const t = this._actions.get(e.action);
+    if (!t)
+      return this._log.warn(`Cannot create binding: Action "${e.action}" not found.`), null;
+    const { deviceID: s, ...i } = e.input;
+    switch (e.type) {
+      case "trigger":
+        return new Y(t, s, this._createInputSourceFromDefinition(i), {
+          ...e.options || {},
+          context: e.context
+        });
+      case "toggle":
+        return new H(t, s, this._createInputSourceFromDefinition(i), {
+          ...e.options || {},
+          context: e.context
+        });
+      case "value":
+        return new X(t, s, this._createInputSourceFromDefinition(i), {
+          ...e.options || {},
+          context: e.context
+        });
+      default:
+        return this._log.error(`Binding type not implemented: ${e.type}`), null;
+    }
+  }
+  /**
+   * Create a device value reader from a definition object
+   *
+   * @param definition - The device value reader definition
+   * @returns A new device value reader instance
+   * @throws Error if the reader type is not supported
+   */
+  _createInputSourceFromDefinition(e) {
+    switch (e.type) {
+      case "keyboard":
+        return new w(e.sourceKey, e.options);
+      case "mouse": {
+        const t = e.sourceType;
+        if (!(t === "button" || t === "position" || t === "wheel"))
+          throw new Error(`Invalid mouse source type: ${t}`);
+        return new x(t, e.sourceKey);
+      }
+      case "gamepad": {
+        const t = e.sourceType;
+        if (!(t === "button" || t === "axis"))
+          throw new Error(`Invalid gamepad source type: ${t}`);
+        return new S(t, e.sourceKey, e.options);
+      }
+      default:
+        throw new Error(`Unsupported input source type: ${e.type}`);
+    }
+  }
+  //------------------------------------------------------------------------------------------------------------------
+  // Internal API
+  //------------------------------------------------------------------------------------------------------------------
+  /**
+   * Handle input from a device and process all relevant bindings
+   *
+   * @param device - The input device
+   * @param state - Current input state
+   */
+  $handleInput(e, t) {
+    const s = this._bindings.get(e.id);
+    if (!(!s || s.length === 0) && !(this._activeContexts.size === 0 && s.some((i) => i.context)))
+      for (const i of s)
+        this._isBindingContextActive(i) && i.process(t, this._eventBus);
+  }
+  //------------------------------------------------------------------------------------------------------------------
+  // Action Management API
+  //------------------------------------------------------------------------------------------------------------------
+  /**
+   * Registers an action
+   *
+   * @param action - The action to register
+   * @throws Error if action is already registered
+   */
+  registerAction(e) {
+    if (this._log.debug(`Registering action "${e.name}"`), this._actions.has(e.name)) {
+      const t = `Action "${e.name}" already registered.`;
+      throw this._log.error(t), new Error(t);
+    }
+    this._actions.set(e.name, e), this._log.debug(`Action "${e.name}" registered successfully`);
+  }
+  /**
+   * Gets an action by name
+   *
+   * @param actionName - The name of the action to get
+   * @returns The action or null if not found
+   */
+  getAction(e) {
+    this._log.trace(`Getting action "${e}"`);
+    const t = this._actions.get(e) ?? null;
+    return t || this._log.debug(`Action "${e}" not found`), t;
+  }
+  //------------------------------------------------------------------------------------------------------------------
+  // Context Management API
+  //------------------------------------------------------------------------------------------------------------------
+  /**
+   * Registers a context with specific options
+   *
+   * @param contextName - The name of the context to register
+   * @param exclusive - Whether the context is exclusive (default: true)
+   * @returns The registered context
+   */
+  registerContext(e, t = !0) {
+    const s = this._getOrCreateContext(e, t);
+    return s.exclusive !== t && (s.exclusive = t, this._log.info(`Updated context "${e}" exclusivity: ${t}`)), s;
+  }
+  /**
+   * Activates a context, enabling all bindings associated with it.
+   * If the context is exclusive, all other exclusive contexts will be deactivated.
+   *
+   * @param contextName - The name of the context to activate
+   */
+  activateContext(e) {
+    const s = this._getOrCreateContext(e).exclusive;
+    this._log.debug(`Activating context "${e}" (exclusive: ${s})`);
+    const i = this._activeContexts.has(e);
+    if (s) {
+      const o = this._deactivateExclusiveContexts(e);
+      o.length > 0 && this._log.info(`Deactivated exclusive contexts: ${o.join(", ")}`);
+    }
+    i || (this._activeContexts.add(e), this._log.info(`Context "${e}" activated${s ? " as exclusive" : ""}`));
+  }
+  /**
+   * Deactivates a context, disabling all bindings associated with it
+   *
+   * @param contextName - The name of the context to deactivate
+   */
+  deactivateContext(e) {
+    this._log.debug(`Deactivating context "${e}"`), this._activeContexts.has(e) ? (this._activeContexts.delete(e), this._log.info(`Context "${e}" deactivated`)) : this._log.debug(`Context "${e}" was not active`);
+  }
+  /**
+   * Returns a list of all active contexts
+   *
+   * @returns Array of active context names
+   */
+  getActiveContexts() {
+    return [...this._activeContexts];
+  }
+  /**
+   * Returns whether a context is active
+   *
+   * @param contextName - The context to check
+   * @returns True if the context is active
+   */
+  isContextActive(e) {
+    return this._activeContexts.has(e);
+  }
+  /**
+   * Gets a context by name
+   *
+   * @param contextName - The context name to get
+   * @returns The context or null if not found
+   */
+  getContext(e) {
+    return this._contexts.get(e) || null;
+  }
+  //------------------------------------------------------------------------------------------------------------------
+  // Binding Management API
+  //------------------------------------------------------------------------------------------------------------------
+  /**
+   * Register a binding for an input device
+   *
+   * @param binding - The binding to register
+   * @throws Error if binding type is invalid
+   */
+  $registerBinding(e) {
+    var t;
+    if (!J.includes(e.type))
+      throw new Error(`Invalid binding type: ${e.type}`);
+    e.context && !this._contexts.has(e.context) && this.registerContext(e.context), this._bindings.has(e.deviceID) || this._bindings.set(e.deviceID, []), (t = this._bindings.get(e.deviceID)) == null || t.push(e), this._log.debug(`Registered ${e.type} binding for "${e.action.name}" in context "${e.context || null}"`);
+  }
+  /**
+   * Register a binding using a binding definition object
+   *
+   * @param definition - The binding definition to register
+   */
+  registerBinding(e) {
+    const t = this._createBindingFromDefinition(e);
+    t ? this.$registerBinding(t) : this._log.error(`Failed to create binding for action "${e.action}" with type "${e.type}"`);
+  }
+  /**
+   * Unregister all bindings for an action within a context
+   *
+   * @param actionName - The name of the action
+   * @param context - The context to unregister from (defaults to null)
+   */
+  unregisterBindings(e, t = null) {
+    this._log.debug(`Unregistering all bindings for action "${e}" in context "${t}"`);
+    let s = 0;
+    for (const [i, o] of this._bindings.entries()) {
+      const r = o.filter((c) => {
+        const h = c.context || null, u = c.action.name !== e || h !== t;
+        return u || s++, u;
+      });
+      r.length !== o.length && this._bindings.set(i, r);
+    }
+    this._log.info(`Removed ${s} bindings for action "${e}" in context "${t}"`);
+  }
+  /**
+   * Gets all bindings for a specific action
+   *
+   * @param actionName - The name of the action
+   * @param context - The context to get bindings from (optional)
+   * @returns Array of bindings that match the criteria
+   */
+  getBindingsForAction(e, t) {
+    const s = [];
+    for (const i of this._bindings.values())
+      for (const o of i) {
+        const r = o.context || null;
+        o.action.name === e && (!t || r === t) && s.push(o);
+      }
+    return s;
+  }
+  //------------------------------------------------------------------------------------------------------------------
+  // Configuration Management API
+  //------------------------------------------------------------------------------------------------------------------
+  /**
+   * Exports the current configuration to a serializable object
+   *
+   * @returns A BindingConfiguration object representing the current state
+   */
+  exportConfiguration() {
+    this._log.debug("Exporting binding configuration");
+    const e = [...this._actions.values()].map((i) => i.type === "analog" ? {
+      name: i.name,
+      type: i.type,
+      minValue: i.minValue ?? 0,
+      maxValue: i.maxValue ?? 1
+    } : i), t = [];
+    for (const i of this._bindings.values())
+      for (const o of i)
+        t.push(o.toJSON());
+    const s = [...this._contexts.values()].map((i) => ({
+      name: i.name,
+      exclusive: i.exclusive,
+      active: this._activeContexts.has(i.name)
+    }));
+    return this._log.info(`Configuration exported: ${e.length} actions, ${t.length} bindings, ${s.length} contexts`), {
+      actions: e,
+      bindings: t,
+      contexts: s
+    };
+  }
+  /**
+   * Imports a configuration from an object
+   *
+   * @param config - The configuration to import
+   */
+  importConfiguration(e) {
+    this._log.debug("Importing binding configuration"), this._bindings.clear(), this._actions.clear(), this._contexts.clear(), this._activeContexts.clear();
+    for (const t of e.actions)
+      this.registerAction(t);
+    for (const t of e.contexts)
+      this.registerContext(t.name, t.exclusive), t.active && this.activateContext(t.name);
+    for (const t of e.bindings)
+      try {
+        this.registerBinding(t);
+      } catch (s) {
+        s instanceof Error && this._log.error(`Failed to import binding for action "${t.action}": ${s.message}`);
+      }
+    this._log.info(`Configuration imported: ${e.actions.length} actions, ${e.bindings.length} bindings, ${e.contexts.length} contexts`);
+  }
+}
+function A() {
+  return typeof window < "u" && typeof window.document < "u";
+}
+function $() {
+  return A() && !!window.navigator.gpu;
+}
+class Z {
+  //------------------------------------------------------------------------------------------------------------------
+  constructor(e, t, s, i, o) {
+    n(this, "_engine");
+    n(this, "_entityManager");
+    n(this, "_inputManager");
+    n(this, "_sceneEngine");
+    n(this, "_currentScene", null);
+    n(this, "_log");
+    n(this, "started", !1);
+    this._engine = e, this._sceneEngine = t, this._entityManager = s, this._inputManager = i, this._log = (o == null ? void 0 : o.getLogger("GameManager")) || new l("GameManager"), A() && window.addEventListener("resize", this._resizeHandler.bind(this));
+  }
+  _renderLoop() {
+    const e = this._engine.getDeltaTime();
+    this._entityManager.$frameUpdate(e), this._inputManager && this._inputManager.pollGamepads(), this._currentScene && this._currentScene.render();
+  }
+  _resizeHandler() {
+    this.started && this._engine.resize();
+  }
+  //------------------------------------------------------------------------------------------------------------------
+  // Public API
+  //------------------------------------------------------------------------------------------------------------------
+  async start(e) {
+    this._currentScene = await this._sceneEngine.loadScene(e), this._engine.runRenderLoop(this._renderLoop.bind(this)), this.started = !0, this._log.info("SkewedAspect Game Engine started successfully");
+  }
+  async stop() {
+    this.started = !1, this._engine.stopRenderLoop(), this._log.info("SkewedAspect Game Engine stopped successfully");
+  }
+}
+class ue {
+  constructor() {
+    n(this, "entity", null);
+  }
+  //------------------------------------------------------------------------------------------------------------------
+  // Internal API
+  //------------------------------------------------------------------------------------------------------------------
+  $emit(e) {
+    if (!this.entity)
+      throw new Error("Entity is not set for this behavior.");
+    e.senderID = this.entity.id, this.entity.eventBus.publish(e);
+  }
+  /**
+   * Sets the entity for this behavior.
+   * @param entity - The entity to set.
+   */
+  $setEntity(e) {
+    this.entity = e;
+  }
+}
+class q {
+  /**
+   * Creates an instance of GameEntityBase.
+   * @param type - The type of the entity.
+   * @param initialState - The initial state of the entity.
+   * @param behaviors - An array of behaviors to attach to the entity.
+   * @param eventBus
+   */
+  constructor(e, t, s, i) {
+    /** The unique identifier of the entity. */
+    n(this, "id");
+    /** The type of the entity. */
+    n(this, "type");
+    /** The state of the entity. */
+    n(this, "state");
+    /** A map of behaviors attached to the entity. */
+    n(this, "behaviors", /* @__PURE__ */ new Map());
+    /** The event bus for the entity. */
+    n(this, "eventBus");
+    /** The event subscriptions for the entity. */
+    n(this, "subscriptions", /* @__PURE__ */ new Map());
+    this.id = crypto.randomUUID(), this.type = e, this.state = s, this.eventBus = t;
+    for (const o of i)
+      this.attachBehavior(new o());
+  }
+  //------------------------------------------------------------------------------------------------------------------
+  // Internal Methods
+  //------------------------------------------------------------------------------------------------------------------
+  /**
+   * Processes a game event by passing it to the entity's behaviors.
+   * @param event - The game event to process.
+   * @returns A promise that resolves when the event has been processed.
+   */
+  async $processEvent(e) {
+    for (const t of this.behaviors.values())
+      if (await t.processEvent(e, this.state))
+        break;
+  }
+  /**
+   * Updates the entity by calling the update method of its behaviors.
+   * @param dt - The delta time since the last update.
+   */
+  $update(e) {
+    var t;
+    for (const s of this.behaviors.values())
+      (t = s.update) == null || t.call(s, e, this.state);
+  }
+  /**
+   * Destroys the entity by calling the destroy method of its behaviors.
+   * @returns A promise that resolves when the entity has been destroyed.
+   */
+  async $destroy() {
+    var e;
+    for (const t of this.behaviors.values())
+      (e = t.destroy) == null || e.call(t);
+    for (const t of this.subscriptions.values())
+      t.unsubscribe();
+    this.behaviors.clear(), this.subscriptions.clear();
+  }
+  //------------------------------------------------------------------------------------------------------------------
+  // Public Methods
+  //------------------------------------------------------------------------------------------------------------------
+  /**
+   * Attaches a behavior to the entity.
+   * @param behavior - The behavior to attach.
+   * @throws Will throw an error if the behavior is already attached.
+   */
+  attachBehavior(e) {
+    if (this.behaviors.has(e.name))
+      throw new Error(`Behavior ${e.name} is already attached to this entity.`);
+    for (const t of e.eventSubscriptions) {
+      const s = this.subscriptions.get(t);
+      if (s)
+        s.count++;
+      else {
+        const i = this.eventBus.subscribe(t, this.$processEvent.bind(this));
+        this.subscriptions.set(t, { count: 1, unsubscribe: i });
+      }
+    }
+    this.behaviors.set(e.name, e), e.$setEntity(this);
+  }
+  /**
+   * Detaches a behavior from the entity.
+   * @param behaviorName - The behavior to detach.
+   */
+  detachBehavior(e) {
+    const t = this.behaviors.get(e);
+    if (t) {
+      for (const s of t.eventSubscriptions) {
+        const i = this.subscriptions.get(s);
+        i && (i.count--, i.count <= 0 && (i.unsubscribe(), this.subscriptions.delete(s)));
+      }
+      this.behaviors.delete(t.name), t.$setEntity(null);
+    }
+  }
+}
+class Q {
+  /**
+   * Creates an instance of EntityManager.
+   * @param eventBus - The event bus for the entity manager.
+   * @param logger - The logging utility to use
+   * @param bindingManager - The binding manager for registering actions
+   */
+  constructor(e, t, s) {
+    /** The event bus for the entity manager. */
+    n(this, "eventBus");
+    /** A map of entities managed by the entity manager. */
+    n(this, "entities", /* @__PURE__ */ new Map());
+    /** A map of entity definitions registered with the entity manager. */
+    n(this, "entityDefinitions", /* @__PURE__ */ new Map());
+    /** Reference to the binding manager for registering actions */
+    n(this, "bindingManager");
+    /** Logger instance */
+    n(this, "_log");
+    this.eventBus = e, this.bindingManager = s, this._log = (t == null ? void 0 : t.getLogger("EntityManager")) || new l("EntityManager"), this._log.info("EntityManager initialized");
+  }
+  //------------------------------------------------------------------------------------------------------------------
+  // Private Methods
+  //------------------------------------------------------------------------------------------------------------------
+  /**
+   * Checks if two actions are compatible
+   * @param existingAction - The action already registered
+   * @param newAction - The action being registered
+   * @returns true if the actions are compatible, false if they have conflicting options
+   */
+  areActionsCompatible(e, t) {
+    return !(e.type !== t.type || e.type === "analog" && t.type === "analog" && (t.minValue !== void 0 && e.minValue !== t.minValue || t.maxValue !== void 0 && e.maxValue !== t.maxValue));
+  }
+  /**
+   * Registers actions defined in the entity definition with the binding manager
+   * @param entityDef - The entity definition containing actions to register
+   */
+  registerEntityActions(e) {
+    if (e.actions)
+      for (const t of e.actions)
+        try {
+          const s = this.bindingManager.getAction(t.name);
+          s ? this.areActionsCompatible(s, t) ? this._log.trace(`Action "${t.name}" already registered with compatible options, skipping registration`) : this._log.warn(`Action "${t.name}" already registered with different options. Entity "${e.type}" requires: ${JSON.stringify(t)}, but found: ${JSON.stringify(s)}`) : (this._log.debug(`Registering action "${t.name}" from entity type "${e.type}"`), this.bindingManager.registerAction(t));
+        } catch (s) {
+          this._log.debug(`Failed to register action "${t.name}": ${s instanceof Error ? s.message : String(s)}`);
+        }
+  }
+  $frameUpdate(e) {
+    this._log.trace(`Updating ${this.entities.size} entities with dt=${e}`);
+    for (const t of this.entities.values())
+      t.$update(e);
+  }
+  //------------------------------------------------------------------------------------------------------------------
+  // Public API
+  //------------------------------------------------------------------------------------------------------------------
+  /**
+   * Registers a new entity definition.
+   * @param entityDef - The definition of the entity.
+   */
+  registerEntityDefinition(e) {
+    this._log.debug(`Registering entity definition: ${e.type}`), this.registerEntityActions(e), this.entityDefinitions.set(e.type, e);
+  }
+  /**
+   * Creates a new entity of the given type.
+   * @param type - The type of the entity to create.
+   * @param initialState - The initial state of the entity.
+   * @returns The created entity.
+   */
+  createEntity(e, t = {}) {
+    var r;
+    this._log.debug(`Creating entity of type: ${e}`);
+    const s = this.entityDefinitions.get(e);
+    if (!s) {
+      const c = `Entity type ${e} is not registered.`;
+      throw this._log.error(c), new Error(c);
+    }
+    this._log.trace(`Using entity definition with ${((r = s.behaviors) == null ? void 0 : r.length) || 0} behaviors`);
+    const i = { ...s.defaultState, ...t }, o = new q(s.type, this.eventBus, i, s.behaviors);
+    return this.entities.set(o.id, o), this._log.debug(`Entity created with ID: ${o.id}`), o;
+  }
+  /**
+   * Destroys the entity with the given ID.
+   * @param entityID - The ID of the entity to destroy.
+   */
+  destroyEntity(e) {
+    this._log.debug(`Destroying entity: ${e}`);
+    const t = this.entities.get(e);
+    t ? (t.$destroy(), this.entities.delete(e), this._log.debug(`Entity ${e} destroyed`)) : this._log.warn(`Attempted to destroy non-existent entity: ${e}`);
+  }
+  /**
+   * Gets the entity with the given ID.
+   * @param entityID - The ID of the entity to get.
+   * @returns The entity with the given ID, or null if it does not exist.
+   */
+  getEntity(e) {
+    return this._log.trace(`Getting entity: ${e}`), this.entities.get(e) ?? null;
+  }
+  /**
+   * Adds an existing entity to the entity manager.
+   * @param entity - The entity to add.
+   */
+  addEntity(e) {
+    this._log.debug(`Adding existing entity: ${e.id} (type: ${e.type})`), this.entities.set(e.id, e);
+  }
+  /**
+   * Removes the entity with the given ID, without destroying it.
+   * @param entityID - The ID of the entity to remove.
+   */
+  removeEntity(e) {
+    this._log.debug(`Removing entity: ${e}`), this.entities.get(e) ? (this.entities.delete(e), this._log.debug(`Entity ${e} removed`)) : this._log.warn(`Attempted to remove non-existent entity: ${e}`);
+  }
+}
+class ee {
+  //------------------------------------------------------------------------------------------------------------------
+  /**
+   * Create a new KeyboardResourceAccess
+   */
+  constructor() {
+    n(this, "_keyboardDevice");
+    n(this, "_keysState", {});
+    // Callbacks
+    n(this, "_onDeviceConnected");
+    n(this, "_onInputChanged");
+    this._keyboardDevice = {
+      id: "keyboard-0",
+      name: "Keyboard",
+      type: "keyboard",
+      connected: !0
+    }, this._setupKeyboardEvents(), setTimeout(() => this._notifyDeviceConnected(), 0);
+  }
+  //------------------------------------------------------------------------------------------------------------------
+  // Public API
+  //------------------------------------------------------------------------------------------------------------------
+  /**
+   * Register a callback for device connected events
+   *
+   * @param callback - The callback to register
+   */
+  onDeviceConnected(e) {
+    this._onDeviceConnected = e;
+  }
+  /**
+   * Register a callback for input changed events
+   *
+   * @param callback - The callback to register
+   */
+  onInputChanged(e) {
+    this._onInputChanged = e;
+  }
+  /**
+   * Get the current keyboard state
+   */
+  getState() {
+    return {
+      type: "keyboard",
+      keys: { ...this._keysState },
+      delta: {}
+    };
+  }
+  /**
+   * Get the keyboard device
+   */
+  getDevice() {
+    return { ...this._keyboardDevice };
+  }
+  /**
+   * Destroy the keyboard resource access and clean up event listeners
+   */
+  destroy() {
+    window.removeEventListener("keydown", this._handleKeyDown), window.removeEventListener("keyup", this._handleKeyUp);
+  }
+  //------------------------------------------------------------------------------------------------------------------
+  // Private Methods
+  //------------------------------------------------------------------------------------------------------------------
+  /**
+   * Set up keyboard event listeners
+   */
+  _setupKeyboardEvents() {
+    this._handleKeyDown = this._handleKeyDown.bind(this), this._handleKeyUp = this._handleKeyUp.bind(this), window.addEventListener("keydown", this._handleKeyDown), window.addEventListener("keyup", this._handleKeyUp);
+  }
+  /**
+   * Handle keyboard key down events
+   */
+  _handleKeyDown(e) {
+    this._keysState[e.code] = !0;
+    const t = {};
+    t[e.code] = !0;
+    const s = {
+      type: "keyboard",
+      keys: { ...this._keysState },
+      delta: t,
+      event: e
+    };
+    this._notifyInputChanged(s);
+  }
+  /**
+   * Handle keyboard key up events
+   */
+  _handleKeyUp(e) {
+    this._keysState[e.code] = !1;
+    const t = {};
+    t[e.code] = !1;
+    const s = {
+      type: "keyboard",
+      keys: { ...this._keysState },
+      delta: t,
+      event: e
+    };
+    this._notifyInputChanged(s);
+  }
+  /**
+   * Notify subscribers of device connected event
+   */
+  _notifyDeviceConnected() {
+    this._onDeviceConnected && this._onDeviceConnected(this._keyboardDevice);
+  }
+  /**
+   * Notify subscribers of input changed event
+   */
+  _notifyInputChanged(e) {
+    this._onInputChanged && this._onInputChanged(this._keyboardDevice, e);
+  }
+}
+class te {
+  //------------------------------------------------------------------------------------------------------------------
+  /**
+   * Create a new MouseResourceAccess
+   *
+   * @param targetElement - The DOM element to attach mouse listeners to (defaults to document.body)
+   */
+  constructor(e = document.body) {
+    n(this, "_targetElement");
+    n(this, "_mouseDevice");
+    n(this, "_buttonState", {});
+    n(this, "_axesState", {});
+    n(this, "_position", {
+      absolute: { x: 0, y: 0 },
+      relative: { x: 0, y: 0 }
+    });
+    n(this, "_wheelState", {
+      deltaX: 0,
+      deltaY: 0,
+      deltaZ: 0,
+      deltaMode: 0
+    });
+    // Callbacks
+    n(this, "_onDeviceConnected");
+    n(this, "_onInputChanged");
+    this._targetElement = e, this._mouseDevice = {
+      id: "mouse-0",
+      name: "Mouse",
+      type: "mouse",
+      connected: !0
+    }, this._setupMouseEvents(), this._axesState["axis-x"] = 0, this._axesState["axis-y"] = 0, setTimeout(() => this._notifyDeviceConnected(), 0);
+  }
+  //------------------------------------------------------------------------------------------------------------------
+  // Public API
+  //------------------------------------------------------------------------------------------------------------------
+  /**
+   * Register a callback for device connected events
+   *
+   * @param callback - The callback to register
+   */
+  onDeviceConnected(e) {
+    this._onDeviceConnected = e;
+  }
+  /**
+   * Register a callback for input changed events
+   *
+   * @param callback - The callback to register
+   */
+  onInputChanged(e) {
+    this._onInputChanged = e;
+  }
+  /**
+   * Get the current mouse state
+   */
+  getState() {
+    return {
+      type: "mouse",
+      buttons: { ...this._buttonState },
+      axes: { ...this._axesState },
+      position: {
+        absolute: { ...this._position.absolute },
+        relative: { ...this._position.relative }
+      },
+      wheel: { ...this._wheelState }
+    };
+  }
+  /**
+   * Get the mouse device
+   */
+  getDevice() {
+    return { ...this._mouseDevice };
+  }
+  /**
+   * Destroy the mouse resource access and clean up event listeners
+   */
+  destroy() {
+    this._targetElement.removeEventListener("mousedown", this._handleMouseDown), this._targetElement.removeEventListener("mouseup", this._handleMouseUp), this._targetElement.removeEventListener("mousemove", this._handleMouseMove), this._targetElement.removeEventListener("wheel", this._handleMouseWheel);
+  }
+  //------------------------------------------------------------------------------------------------------------------
+  // Private Methods
+  //------------------------------------------------------------------------------------------------------------------
+  /**
+   * Set up mouse event listeners
+   */
+  _setupMouseEvents() {
+    this._handleMouseDown = this._handleMouseDown.bind(this), this._handleMouseUp = this._handleMouseUp.bind(this), this._handleMouseMove = this._handleMouseMove.bind(this), this._handleMouseWheel = this._handleMouseWheel.bind(this), this._targetElement.addEventListener("mousedown", this._handleMouseDown), this._targetElement.addEventListener("mouseup", this._handleMouseUp), this._targetElement.addEventListener("mousemove", this._handleMouseMove), this._targetElement.addEventListener("wheel", this._handleMouseWheel);
+  }
+  /**
+   * Handle mouse button down events
+   */
+  _handleMouseDown(e) {
+    const t = `button-${e.button}`, s = {
+      pressed: !0
+    };
+    this._buttonState[t] = s, this._notifyInputChanged({
+      type: "mouse",
+      event: e,
+      buttons: { ...this._buttonState },
+      axes: { ...this._axesState },
+      position: { ...this._position }
+    });
+  }
+  /**
+   * Handle mouse button up events
+   */
+  _handleMouseUp(e) {
+    const t = `button-${e.button}`, s = {
+      pressed: !1
+    };
+    this._buttonState[t] = s, this._notifyInputChanged({
+      type: "mouse",
+      event: e,
+      buttons: { ...this._buttonState },
+      axes: { ...this._axesState },
+      position: { ...this._position }
+    });
+  }
+  /**
+   * Handle mouse move events
+   */
+  _handleMouseMove(e) {
+    this._position = {
+      absolute: {
+        x: e.clientX,
+        y: e.clientY
+      },
+      relative: {
+        x: e.movementX,
+        y: e.movementY
+      }
+    }, this._axesState["axis-x"] = e.clientX, this._axesState["axis-y"] = e.clientY, this._notifyInputChanged({
+      type: "mouse",
+      event: e,
+      buttons: { ...this._buttonState },
+      axes: { ...this._axesState },
+      position: { ...this._position }
+    });
+  }
+  /**
+   * Handle mouse wheel events
+   */
+  _handleMouseWheel(e) {
+    this._wheelState = {
+      deltaX: e.deltaX,
+      deltaY: e.deltaY,
+      deltaZ: e.deltaZ,
+      deltaMode: e.deltaMode
+    }, this._notifyInputChanged({
+      type: "mouse",
+      event: e,
+      buttons: { ...this._buttonState },
+      axes: { ...this._axesState },
+      position: { ...this._position },
+      wheel: { ...this._wheelState }
+    });
+  }
+  /**
+   * Notify subscribers of device connected event
+   */
+  _notifyDeviceConnected() {
+    this._onDeviceConnected && this._onDeviceConnected(this._mouseDevice);
+  }
+  /**
+   * Notify subscribers of input changed event
+   */
+  _notifyInputChanged(e) {
+    this._onInputChanged && this._onInputChanged(this._mouseDevice, e);
+  }
+}
+class se {
+  //------------------------------------------------------------------------------------------------------------------
+  /**
+   * Create a new GamepadResourceAccess
+   */
+  constructor() {
+    n(this, "_gamepadDevices", {});
+    n(this, "_buttonStates", {});
+    n(this, "_axesStates", {});
+    // Callbacks
+    n(this, "_onDeviceConnected");
+    n(this, "_onDeviceDisconnected");
+    n(this, "_onInputChanged");
+    this._setupGamepadEvents();
+  }
+  //------------------------------------------------------------------------------------------------------------------
+  // Public API
+  //------------------------------------------------------------------------------------------------------------------
+  /**
+   * Register a callback for device connected events
+   *
+   * @param callback - The callback to register
+   */
+  onDeviceConnected(e) {
+    this._onDeviceConnected = e;
+  }
+  /**
+   * Register a callback for device disconnected events
+   *
+   * @param callback - The callback to register
+   */
+  onDeviceDisconnected(e) {
+    this._onDeviceDisconnected = e;
+  }
+  /**
+   * Register a callback for input changed events
+   *
+   * @param callback - The callback to register
+   */
+  onInputChanged(e) {
+    this._onInputChanged = e;
+  }
+  /**
+   * Get all connected gamepad devices
+   */
+  getDevices() {
+    return Object.values(this._gamepadDevices).map((e) => ({ ...e }));
+  }
+  /**
+   * Get all connected gamepad states
+   */
+  getStates() {
+    const e = {};
+    return Object.keys(this._buttonStates).forEach((t) => {
+      const s = Number(t), i = this._buttonStates[s] || {}, o = this._axesStates[s] || {};
+      e[s] = {
+        type: "gamepad",
+        buttons: { ...i },
+        axes: { ...o }
+      };
+    }), e;
+  }
+  /**
+   * Get a specific gamepad device by index
+   *
+   * @param index - The index of the gamepad to get
+   */
+  getDevice(e) {
+    const t = this._gamepadDevices[e];
+    return t ? { ...t } : null;
+  }
+  /**
+   * Get a specific gamepad state by index
+   *
+   * @param index - The index of the gamepad state to get
+   */
+  getState(e) {
+    const t = this._buttonStates[e], s = this._axesStates[e];
+    return !t && !s ? null : {
+      type: "gamepad",
+      buttons: t ? { ...t } : {},
+      axes: s ? { ...s } : {}
+    };
+  }
+  /**
+   * Poll for gamepad state updates - call this in your game loop
+   */
+  pollGamepads() {
+    if (!navigator.getGamepads)
+      return;
+    const e = navigator.getGamepads();
+    for (const t of e) {
+      if (!t)
+        continue;
+      const s = t.index;
+      if (!this._gamepadDevices[s]) {
+        this._handleGamepadConnected(t);
+        continue;
+      }
+      const i = this._gamepadDevices[s];
+      if (!i)
+        continue;
+      const o = this._buttonStates[s] || {}, r = this._axesStates[s] || {}, c = {};
+      let h = !1;
+      t.buttons.forEach((d, _) => {
+        const p = `button-${_}`, f = {
+          pressed: d.pressed,
+          touched: d.touched,
+          value: d.value
+        };
+        c[p] = f;
+        const y = o[p];
+        (!y || y.pressed !== f.pressed || y.touched !== f.touched || y.value !== f.value) && (h = !0);
+      });
+      const u = {};
+      let g = !1;
+      if (t.axes.forEach((d, _) => {
+        const p = `axis-${_}`;
+        u[p] = d, r[p] !== d && (g = !0);
+      }), this._buttonStates[s] = c, this._axesStates[s] = u, h || g) {
+        const d = {
+          type: "gamepad",
+          buttons: { ...c },
+          axes: { ...u }
+        };
+        this._notifyInputChanged(i, d);
+      }
+    }
+  }
+  /**
+   * Destroy the gamepad resource access and clean up event listeners
+   */
+  destroy() {
+    window.removeEventListener("gamepadconnected", this._handleGamepadConnected), window.removeEventListener("gamepaddisconnected", this._handleGamepadDisconnected);
+  }
+  //------------------------------------------------------------------------------------------------------------------
+  // Private Methods
+  //------------------------------------------------------------------------------------------------------------------
+  /**
+   * Set up gamepad event listeners
+   */
+  _setupGamepadEvents() {
+    if (this._handleGamepadConnected = this._handleGamepadConnected.bind(this), this._handleGamepadDisconnected = this._handleGamepadDisconnected.bind(this), window.addEventListener("gamepadconnected", this._handleGamepadConnected), window.addEventListener("gamepaddisconnected", this._handleGamepadDisconnected), navigator.getGamepads) {
+      const e = navigator.getGamepads();
+      for (const t of e)
+        t && this._handleGamepadConnected(t);
+    }
+  }
+  /**
+   * Handle gamepad connected event
+   */
+  _handleGamepadConnected(e) {
+    const t = e instanceof GamepadEvent ? e.gamepad : e, s = t.index, i = {
+      id: `gamepad-${s}`,
+      name: t.id,
+      type: "gamepad",
+      connected: !0,
+      index: s,
+      mapping: t.mapping,
+      axes: Array.from(t.axes),
+      buttons: Array.from(t.buttons)
+    };
+    this._gamepadDevices[s] = i;
+    const o = {};
+    Array.from(t.buttons).forEach((c, h) => {
+      o[`button-${h}`] = {
+        pressed: c.pressed,
+        touched: c.touched,
+        value: c.value
+      };
+    }), this._buttonStates[s] = o;
+    const r = {};
+    Array.from(t.axes).forEach((c, h) => {
+      r[`axis-${h}`] = c;
+    }), this._axesStates[s] = r, this._notifyDeviceConnected(i), this._notifyInputChanged(i, {
+      type: "gamepad",
+      buttons: { ...o },
+      axes: { ...r },
+      event: e instanceof GamepadEvent ? e : void 0
+    });
+  }
+  /**
+   * Handle gamepad disconnected event
+   */
+  _handleGamepadDisconnected(e) {
+    const s = e.gamepad.index, i = this._gamepadDevices[s];
+    i && (i.connected = !1, this._notifyDeviceDisconnected(i), this._gamepadDevices[s] = void 0, this._buttonStates[s] = void 0, this._axesStates[s] = void 0);
+  }
+  /**
+   * Notify subscribers of device connected event
+   */
+  _notifyDeviceConnected(e) {
+    this._onDeviceConnected && this._onDeviceConnected(e);
+  }
+  /**
+   * Notify subscribers of device disconnected event
+   */
+  _notifyDeviceDisconnected(e) {
+    this._onDeviceDisconnected && this._onDeviceDisconnected(e);
+  }
+  /**
+   * Notify subscribers of input changed event
+   */
+  _notifyInputChanged(e, t) {
+    this._onInputChanged && this._onInputChanged(e, t);
+  }
+}
+class ie {
+  //------------------------------------------------------------------------------------------------------------------
+  /**
+   * Create a new UserInputManager
+   *
+   * @param eventBus - The game event bus to publish events to
+   * @param canvas - The DOM element to attach input listeners to
+   * @param logger - The logging utility to use
+   */
+  constructor(e, t, s) {
+    n(this, "_eventBus");
+    n(this, "_keyboardRA");
+    n(this, "_mouseRA");
+    n(this, "_gamepadRA");
+    /** Logger instance */
+    n(this, "_log");
+    this._eventBus = e, this._log = (s == null ? void 0 : s.getLogger("UserInputManager")) || new l("UserInputManager"), this._log.info("Initializing UserInputManager"), this._log.debug("Initializing input resource access classes"), this._keyboardRA = new ee(), this._mouseRA = new te(t), this._gamepadRA = new se(), this._log.debug("Registering input event callbacks"), this._keyboardRA.onDeviceConnected(this._publishDeviceConnected.bind(this)), this._keyboardRA.onInputChanged(this._publishInputChanged.bind(this)), this._mouseRA.onDeviceConnected(this._publishDeviceConnected.bind(this)), this._mouseRA.onInputChanged(this._publishInputChanged.bind(this)), this._gamepadRA.onDeviceConnected(this._publishDeviceConnected.bind(this)), this._gamepadRA.onDeviceDisconnected(this._publishDeviceDisconnected.bind(this)), this._gamepadRA.onInputChanged(this._publishInputChanged.bind(this)), this._log.info("UserInputManager initialized successfully");
+  }
+  //------------------------------------------------------------------------------------------------------------------
+  // Private methods
+  //------------------------------------------------------------------------------------------------------------------
+  /**
+   * Publish device connected event to the event bus
+   */
+  _publishDeviceConnected(e) {
+    this._log.debug(`Device connected: ${e.id} (${e.name})`);
+    const t = {
+      type: "input:device:connected",
+      payload: { device: e }
+    };
+    this._eventBus.publish(t);
+  }
+  /**
+   * Publish device disconnected event to the event bus
+   */
+  _publishDeviceDisconnected(e) {
+    this._log.debug(`Device disconnected: ${e.id} (${e.name})`);
+    const t = {
+      type: "input:device:disconnected",
+      payload: { device: e }
+    };
+    this._eventBus.publish(t);
+  }
+  /**
+   * Publish input changed event to the event bus, used by all device types
+   */
+  _publishInputChanged(e, t) {
+    this._log.trace(`Input changed: ${e.id}`, t);
+    const s = {
+      type: "input:changed",
+      payload: {
+        deviceId: e.id,
+        device: e,
+        state: t
+      }
+    };
+    this._eventBus.publish(s);
+  }
+  //------------------------------------------------------------------------------------------------------------------
+  // Internal methods
+  //------------------------------------------------------------------------------------------------------------------
+  /**
+   * Destroy the input manager and clean up event listeners
+   */
+  $destroy() {
+    this._log.info("Destroying UserInputManager"), this._log.debug("Cleaning up input resource access instances"), this._keyboardRA.destroy(), this._mouseRA.destroy(), this._gamepadRA.destroy(), this._log.info("UserInputManager destroyed");
+  }
+  //------------------------------------------------------------------------------------------------------------------
+  // Public methods
+  //------------------------------------------------------------------------------------------------------------------
+  /**
+   * Get all input devices
+   *
+   * @return An array of input devices
+   */
+  listDevices() {
+    this._log.debug("Getting all connected input devices");
+    const e = [];
+    return e.push(this._keyboardRA.getDevice()), e.push(this._mouseRA.getDevice()), e.push(...this._gamepadRA.getDevices()), this._log.debug(`Found ${e.length} connected devices`), e;
+  }
+  /**
+   * Get a specific input device by ID
+   *
+   * @param deviceId - The ID of the device to get
+   *
+   * @return The input device, or null if not found
+   */
+  getDevice(e) {
+    if (this._log.debug(`Getting device: ${e}`), e.startsWith("keyboard-"))
+      return this._keyboardRA.getDevice();
+    if (e.startsWith("mouse-"))
+      return this._mouseRA.getDevice();
+    if (e.startsWith("gamepad-")) {
+      const t = parseInt(e.split("-")[1], 10);
+      return this._gamepadRA.getDevice(t);
+    } else {
+      const t = this.listDevices();
+      for (const s of t)
+        if (s.id === e)
+          return s;
+    }
+    return this._log.warn(`Device not found: ${e}`), null;
+  }
+  /**
+   * Poll for gamepad state updates - call this in your game loop
+   */
+  pollGamepads() {
+    this._gamepadRA.pollGamepads();
+  }
+}
+async function M(a, e) {
+  const t = new K(a, e);
+  return await t.initAsync(), t;
+}
+function v(a, e) {
+  return new U(a, e.antialias, e.options, e.adaptToDeviceRatio);
+}
+function ne(a) {
+  return new B(a);
+}
+async function oe(a, e) {
+  if (a === null)
+    return console.debug("Using Null Engine"), ne(e);
+  const t = e.forceEngine || "auto";
+  if (t === "webgpu")
+    if ($())
+      try {
+        return console.debug("Using forced WebGPU engine"), await M(a, e);
+      } catch (s) {
+        throw console.error("Forced WebGPU initialization failed:", s), new Error("Forced WebGPU failed to initialize. If WebGPU is required, check browser compatibility.");
+      }
+    else
+      throw new Error("WebGPU was forced but is not available in this browser.");
+  if (t === "webgl")
+    return console.debug("Using forced WebGL engine"), v(a, e);
+  if ($())
+    try {
+      return console.debug("Using WebGPU"), M(a, e).catch((s) => (console.warn("WebGPU initialization failed, falling back to WebGL:", s), v(a, e)));
+    } catch (s) {
+      console.warn("WebGPU initialization failed, falling back to WebGL:", s);
+    }
+  else
+    console.warn("WebGPU not supported, falling back to WebGL.");
+  return console.debug("Using WebGL"), v(a, e);
+}
+async function ae() {
+  const a = await z();
+  return new R(!0, a);
+}
+async function de(a, e = {}) {
+  const t = new F(e.logLevel || "debug"), s = t.getLogger("SAGE");
+  s.info(`Initializing SAGE Game Engine v${m}...`), s.debug("Creating rendering engine...");
+  const i = await oe(a, e.renderOptions || {});
+  s.debug("Creating physics engine...");
+  const o = await ae();
+  s.debug("Creating event bus...");
+  const r = new O(t);
+  s.debug("Creating scene engine...");
+  const c = new N(i, o, t);
+  s.debug("Creating managers...");
+  const h = new ie(r, a, t), u = new j(r, t), g = new Q(r, t, u), d = new Z(i, c, g, h, t);
+  if (s.info(`SAGE Game Engine v${m} initialized successfully.`), s.debug("Registering default input bindings..."), e.bindings)
+    for (const _ of e.bindings)
+      u.registerBinding(_);
+  return new T(
+    a,
+    i,
+    o,
+    r,
+    t,
+    // Engines
+    {
+      sceneEngine: c
+    },
+    // Managers
+    {
+      bindingManager: u,
+      entityManager: g,
+      gameManager: d,
+      inputManager: h
+    }
+  );
+}
+export {
+  W as ConsoleBackend,
+  q as GameEntity,
+  ue as GameEntityBehavior,
+  O as GameEventBus,
+  F as LoggingUtility,
+  P as NullBackend,
+  T as SkewedAspectGameEngine,
+  m as VERSION,
+  de as createGameEngine
+};
+//# sourceMappingURL=sage.es.js.map