dopaminejs 2.0.2 → 2.2.0

package/dist/dopamine.js

@@ -1,4 +1,4 @@
-class M {
+class D {
   constructor() {
     this.listeners = /* @__PURE__ */ new Map();
   }
@@ -8,28 +8,28 @@ class M {
    * @param {Function} callback - Callback function
    * @returns {Function} Unsubscribe function
    */
-  on(t, e) {
-    return this.listeners.has(t) || this.listeners.set(t, /* @__PURE__ */ new Set()), this.listeners.get(t).add(e), () => this.off(t, e);
+  on(e, t) {
+    return this.listeners.has(e) || this.listeners.set(e, /* @__PURE__ */ new Set()), this.listeners.get(e).add(t), () => this.off(e, t);
   }
   /**
    * Unsubscribe from an event
    * @param {string} event - Event name
    * @param {Function} callback - Callback function
    */
-  off(t, e) {
-    this.listeners.has(t) && this.listeners.get(t).delete(e);
+  off(e, t) {
+    this.listeners.has(e) && this.listeners.get(e).delete(t);
   }
   /**
    * Emit an event
    * @param {string} event - Event name
    * @param {*} data - Event data
    */
-  emit(t, e) {
-    this.listeners.has(t) && this.listeners.get(t).forEach((s) => {
+  emit(e, t) {
+    this.listeners.has(e) && this.listeners.get(e).forEach((s) => {
       try {
-        s(e);
+        s(t);
       } catch (i) {
-        console.error(`Error in listener for event '${t}':`, i);
+        console.error(`Error in listener for event '${e}':`, i);
       }
     });
   }
@@ -40,16 +40,49 @@ class M {
     this.listeners.clear();
   }
 }
-class E extends M {
-  constructor(t, e = {}) {
-    super(), this.dataService = t, this.player = null, this.achievements = { ...this._initAchievements(), ...e.achievements || {} };
+class O extends D {
+  /**
+   * @param {Object} dataService - Persistence, see DataService
+   * @param {Object} [config]
+   * @param {Object} [config.achievements] - Extra achievement definitions
+   * @param {Object} [config.events] - Kernel EventBus to mirror events onto
+   * @param {Object} [config.kernel] - Kernel; its `events` bus is used if present
+   */
+  constructor(e, t = {}) {
+    var s;
+    super(), this.dataService = e, this.player = null, this.achievements = { ...this._initAchievements(), ...t.achievements || {} }, this.events = t.events || ((s = t.kernel) == null ? void 0 : s.events) || null, this._batchDepth = 0, this._pendingSave = !1;
+  }
+  /**
+   * Emit locally, and mirror onto the kernel bus when one is attached.
+   * @private
+   */
+  _publish(e, t) {
+    this.emit(e, t), this.events && this.events.emit(e, t);
+  }
+  /**
+   * Run `fn` with saves collapsed into a single write at the end.
+   *
+   * Nested batches are counted, so an inner operation that batches on its
+   * own still results in exactly one write for the outermost call.
+   *
+   * @param {Function} fn
+   * @private
+   */
+  async _batch(e) {
+    this._batchDepth++;
+    try {
+      return await e();
+    } finally {
+      this._batchDepth--, this._batchDepth === 0 && this._pendingSave && (this._pendingSave = !1, await this._write());
+    }
   }
   /**
    * Initialize the reward system for current player
    * @returns {Promise<Object>} Player data
    */
   async init() {
-    return this.player = await this.dataService.load("player", this._getDefaultPlayer()), this._updateDailyStreak(), await this.save(), this.player;
+    const e = await this.dataService.load("player", null);
+    return this.player = this._migrate(e), this._updateDailyStreak(), await this.save(), this.player;
   }
   /**
    * Get default player data structure
@@ -74,11 +107,45 @@ class E extends M {
       }
     };
   }
+  /**
+   * Merge a persisted player record onto the current default shape.
+   *
+   * Saves written by older versions are missing whatever fields were added
+   * since. Without this the first property access on a new field throws
+   * before the game has drawn a frame.
+   *
+   * @param {Object|null} saved - Previously persisted player, if any
+   * @returns {Object} Player object guaranteed to have every field
+   * @private
+   */
+  _migrate(e) {
+    const t = this._getDefaultPlayer();
+    return !e || typeof e != "object" ? t : {
+      ...t,
+      ...e,
+      streak: { ...t.streak, ...e.streak || {} },
+      achievements: e.achievements || {},
+      stats: e.stats || {}
+    };
+  }
   /**
    * Save player data
    */
   async save() {
-    this.player && (this.player.lastPlayedAt = Date.now(), await this.dataService.save("player", this.player));
+    if (this.player) {
+      if (this._batchDepth > 0) {
+        this._pendingSave = !0;
+        return;
+      }
+      await this._write();
+    }
+  }
+  /**
+   * The actual persistence call. Bypasses batching.
+   * @private
+   */
+  async _write() {
+    this.player.lastPlayedAt = Date.now(), await this.dataService.save("player", this.player);
   }
   /**
    * Add XP and handle level ups
@@ -86,28 +153,30 @@ class E extends M {
    * @param {string} reason - Why XP was awarded (for notifications)
    * @returns {Object} { leveledUp: boolean, newLevel: number, xpGained: number }
    */
-  async addXP(t, e = "") {
+  async addXP(e, t = "") {
+    if (!Number.isFinite(e))
+      throw new TypeError(`[DopamineJS] addXP expects a finite number, received ${e}`);
     const s = this.player.level;
-    this.player.xp += t;
+    this.player.xp += e;
     const i = this._calculateLevel(this.player.xp), r = i > s;
-    return r && (this.player.level = i), await this.save(), this.emit("xp_gained", { amount: t, reason: e, leveledUp: r, newLevel: i }), r && this.emit("level_up", { oldLevel: s, newLevel: i }), { leveledUp: r, newLevel: i, xpGained: t };
+    return r && (this.player.level = i), await this.save(), this._publish("xp_gained", { amount: e, reason: t, leveledUp: r, newLevel: i }), r && this._publish("level_up", { oldLevel: s, newLevel: i }), { leveledUp: r, newLevel: i, xpGained: e };
   }
   /**
    * Calculate level from XP (exponential curve)
    */
-  _calculateLevel(t) {
-    const e = Math.floor((1 + Math.sqrt(1 + 8 * t / 50)) / 2);
-    return Math.max(1, e);
+  _calculateLevel(e) {
+    const t = Math.floor((1 + Math.sqrt(1 + 4 * e / 50)) / 2);
+    return Math.max(1, t);
   }
   /**
    * Get XP needed for next level
    */
   getXPForNextLevel() {
-    const t = this.player.level + 1, e = 50 * t * (t - 1), s = 50 * this.player.level * (this.player.level - 1);
+    const e = this.player.level + 1, t = 50 * e * (e - 1), s = 50 * this.player.level * (this.player.level - 1), i = t - s, r = i > 0 ? Math.max(0, Math.min(1, (this.player.xp - s) / i)) : 0;
     return {
-      total: e,
-      needed: e - this.player.xp,
-      progress: (this.player.xp - s) / (e - s)
+      total: t,
+      needed: Math.max(0, t - this.player.xp),
+      progress: r
     };
   }
   /**
@@ -115,87 +184,120 @@ class E extends M {
    * @param {string} gameName - Unique ID for the game
    * @param {Object} result - Game-specific result data
    */
-  async recordGame(t, e) {
-    this.player.stats[t] || (this.player.stats[t] = { totalPlays: 0, highScore: 0 });
-    const s = this.player.stats[t];
-    s.totalPlays++, this.player.totalGamesPlayed++, e.score !== void 0 && e.score > s.highScore && (s.highScore = e.score, this.emit("new_high_score", { gameName: t, score: e.score })), Object.keys(e).forEach((r) => {
-      r !== "score" && (s[r] = (s[r] || 0) + (typeof e[r] == "number" ? e[r] : 0));
+  async recordGame(e, t) {
+    return this._batch(() => this._recordGame(e, t));
+  }
+  /**
+   * @private
+   */
+  async _recordGame(e, t) {
+    this.player.stats[e] || (this.player.stats[e] = { totalPlays: 0, highScore: 0 });
+    const s = this.player.stats[e];
+    s.totalPlays++, this.player.totalGamesPlayed++, t.score !== void 0 && t.score > s.highScore && (s.highScore = t.score, this._publish("new_high_score", { gameName: e, score: t.score })), Object.keys(t).forEach((r) => {
+      r !== "score" && (s[r] = (s[r] || 0) + (typeof t[r] == "number" ? t[r] : 0));
     });
     let i = 10;
-    e.score && (i += Math.floor(e.score / 5)), i = Math.floor(i * this.getStreakMultiplier()), await this.addXP(i, `Played ${t}`), await this.checkAchievements(t, e), await this.save();
+    t.score && (i += Math.floor(t.score / 5)), i = Math.floor(i * this.getStreakMultiplier()), await this.addXP(i, `Played ${e}`), await this.checkAchievements(e, t), await this.save();
   }
   /**
    * Check and unlock achievements
    */
-  async checkAchievements(t, e) {
+  async checkAchievements(e, t) {
     const s = [];
-    for (const [i, r] of Object.entries(this.achievements))
-      this.player.achievements[i] || r.check(this.player, t, e) && (await this.unlockAchievement(i), s.push(r));
+    for (const [i, r] of Object.entries(this.achievements)) {
+      if (this.player.achievements[i]) continue;
+      let n = !1;
+      try {
+        n = r.check(this.player, e, t);
+      } catch (o) {
+        console.error(`[DopamineJS] Achievement "${i}" check threw:`, o);
+        continue;
+      }
+      n && (await this.unlockAchievement(i), s.push(r));
+    }
     return s;
   }
   /**
    * Unlock an achievement
    */
-  async unlockAchievement(t) {
-    const e = this.achievements[t];
-    return e ? (this.player.achievements[t] = {
+  async unlockAchievement(e) {
+    const t = this.achievements[e];
+    return t ? (this.player.achievements[e] = {
       unlockedAt: Date.now(),
       seen: !1
-    }, await this.addXP(e.xp, `Achievement: ${e.name}`), this.emit("achievement_unlocked", e), await this.save(), !0) : !1;
+    }, await this.addXP(
+      Number.isFinite(t.xp) ? t.xp : 0,
+      `Achievement: ${t.name}`
+    ), this._publish("achievement_unlocked", t), await this.save(), !0) : !1;
   }
   /**
    * Get all unlocked achievements
    */
   getUnlockedAchievements() {
-    return Object.entries(this.player.achievements).map(([t, e]) => ({
-      ...this.achievements[t],
-      id: t,
-      ...e
+    return Object.entries(this.player.achievements).map(([e, t]) => ({
+      ...this.achievements[e],
+      id: e,
+      ...t
     }));
   }
   /**
    * Get achievements user hasn't seen the notification for yet
    */
   getUnseenAchievements() {
-    return this.getUnlockedAchievements().filter((t) => !t.seen);
+    return this.getUnlockedAchievements().filter((e) => !e.seen);
   }
   /**
    * Mark achievements as seen
    */
-  async markAchievementsSeen(t) {
-    for (const e of t)
-      this.player.achievements[e] && (this.player.achievements[e].seen = !0);
+  async markAchievementsSeen(e) {
+    for (const t of e)
+      this.player.achievements[t] && (this.player.achievements[t].seen = !0);
     await this.save();
   }
   /**
    * Update daily streak
    */
   _updateDailyStreak() {
-    const t = this._getTodayDateString(), e = this.player.streak.lastPlayDate;
-    if (e === t)
+    const e = this._getTodayDateString(), t = this.player.streak.lastPlayDate;
+    if (t === e)
       return;
     const s = this._getYesterdayDateString();
-    e === s ? (this.player.streak.current++, this.player.streak.current > this.player.streak.longest && (this.player.streak.longest = this.player.streak.current)) : this.player.streak.current = 1, this.player.streak.lastPlayDate = t;
+    t === s ? (this.player.streak.current++, this.player.streak.current > this.player.streak.longest && (this.player.streak.longest = this.player.streak.current)) : this.player.streak.current = 1, this.player.streak.lastPlayDate = e;
   }
   /**
    * Get streak multiplier for XP
    */
   getStreakMultiplier() {
-    const t = this.player.streak.current;
-    return t >= 7 ? 2 : t >= 5 ? 1.5 : t >= 3 ? 1.25 : 1;
+    const e = this.player.streak.current;
+    return e >= 7 ? 2 : e >= 5 ? 1.5 : e >= 3 ? 1.25 : 1;
+  }
+  /**
+   * Format a Date as a YYYY-MM-DD string in the player's local timezone.
+   *
+   * Deliberately not toISOString(), which formats in UTC. For anyone east or
+   * west of Greenwich that shifts the calendar day for part of every day and
+   * makes streaks reset or double-count.
+   *
+   * @param {Date} date
+   * @returns {string}
+   * @private
+   */
+  _toLocalDateString(e) {
+    const t = e.getFullYear(), s = String(e.getMonth() + 1).padStart(2, "0"), i = String(e.getDate()).padStart(2, "0");
+    return `${t}-${s}-${i}`;
   }
   /**
-   * Get today's date as YYYY-MM-DD string
+   * Get today's local date as YYYY-MM-DD string
    */
   _getTodayDateString() {
-    return (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    return this._toLocalDateString(/* @__PURE__ */ new Date());
   }
   /**
-   * Get yesterday's date as YYYY-MM-DD string
+   * Get yesterday's local date as YYYY-MM-DD string
    */
   _getYesterdayDateString() {
-    const t = /* @__PURE__ */ new Date();
-    return t.setDate(t.getDate() - 1), t.toISOString().split("T")[0];
+    const e = /* @__PURE__ */ new Date();
+    return e.setDate(e.getDate() - 1), this._toLocalDateString(e);
   }
   /**
    * Initialize achievement definitions
@@ -209,52 +311,77 @@ class E extends M {
         description: "Play your first game",
         icon: "🎮",
         xp: 50,
-        check: (t) => t.totalGamesPlayed >= 1
+        check: (e) => e.totalGamesPlayed >= 1
       },
       level_5: {
         name: "Rising Star",
         description: "Reach level 5",
         icon: "⭐",
         xp: 100,
-        check: (t) => t.level >= 5
+        check: (e) => e.level >= 5
       },
       level_10: {
         name: "Expert Player",
         description: "Reach level 10",
         icon: "🏆",
         xp: 250,
-        check: (t) => t.level >= 10
+        check: (e) => e.level >= 10
       },
       streak_3: {
         name: "Dedicated",
         description: "Play 3 days in a row",
         icon: "🔥",
         xp: 100,
-        check: (t) => t.streak.current >= 3
+        check: (e) => e.streak.current >= 3
       },
       streak_7: {
         name: "Unstoppable",
         description: "Play 7 days in a row",
         icon: "💥",
         xp: 300,
-        check: (t) => t.streak.current >= 7
+        check: (e) => e.streak.current >= 7
       }
     };
   }
 }
-class P {
-  constructor(t = {}) {
-    this.storage = t.storage || window.localStorage, this.prefix = t.prefix || "dopamine_";
+function S() {
+  const a = /* @__PURE__ */ new Map();
+  return {
+    getItem: (e) => a.has(e) ? a.get(e) : null,
+    setItem: (e, t) => {
+      a.set(e, String(t));
+    },
+    removeItem: (e) => {
+      a.delete(e);
+    },
+    clear: () => {
+      a.clear();
+    }
+  };
+}
+function b() {
+  try {
+    if (typeof localStorage > "u")
+      return S();
+    const a = "__dopamine_probe__";
+    return localStorage.setItem(a, "1"), localStorage.removeItem(a), localStorage;
+  } catch {
+    return S();
+  }
+}
+class A {
+  constructor(e = {}) {
+    this.storage = e.storage || b(), this.prefix = e.prefix || "dopamine_";
   }
   /**
    * Save data to local storage
    * @param {string} key 
    * @param {any} data 
    */
-  async save(t, e) {
+  async save(e, t) {
     try {
-      const s = JSON.stringify(e);
-      return this.storage.setItem(this.prefix + t, s), !0;
+      const s = JSON.stringify(t);
+      return this.storage.setItem(this.prefix + e, s), !0;
     } catch (s) {
       return console.error("Error saving data:", s), !1;
     }
@@ -264,240 +391,305 @@ class P {
    * @param {string} key 
    * @param {any} defaultValue 
    */
-  async load(t, e = null) {
+  async load(e, t = null) {
     try {
-      const s = this.storage.getItem(this.prefix + t);
-      return s ? JSON.parse(s) : e;
+      const s = this.storage.getItem(this.prefix + e);
+      return s ? JSON.parse(s) : t;
     } catch (s) {
-      return console.error("Error loading data:", s), e;
+      return console.error("Error loading data:", s), t;
     }
   }
   /**
    * Clear specific data
    * @param {string} key 
    */
-  async clear(t) {
-    this.storage.removeItem(this.prefix + t);
+  async clear(e) {
+    this.storage.removeItem(this.prefix + e);
   }
 }
-class C {
-  constructor(t) {
-    this.particleSystem = t, this.container = null, this.xpBar = null, this.levelDisplay = null, this.streakDisplay = null, this.init();
+const k = "game-ui-overlay";
+class T {
+  constructor(e) {
+    this.particleSystem = e, this.container = null, this.xpBar = null, this.levelDisplay = null, this.streakDisplay = null, this._timers = /* @__PURE__ */ new Set(), this._detached = [], this.init();
   }
   /**
    * Initialize UI overlay
    */
   init() {
-    this.container = document.createElement("div"), this.container.id = "game-ui-overlay", this.container.innerHTML = `
+    this.container = document.createElement("div"), this.container.className = "game-ui-overlay", document.getElementById(k) || (this.container.id = k), this.container.innerHTML = `
             <div class="game-ui-top-bar">
-                <div class="level-badge" id="level-badge">
+                <div class="level-badge">
                     <span class="level-label">LVL</span>
-                    <span class="level-number" id="level-number">1</span>
+                    <span class="level-number">1</span>
                 </div>
-                
+
                 <div class="xp-container">
                     <div class="xp-bar-bg">
-                        <div class="xp-bar-fill" id="xp-bar-fill" style="width: 0%"></div>
+                        <div class="xp-bar-fill" style="width: 0%"></div>
                     </div>
-                    <div class="xp-text" id="xp-text">0 /100 XP</div>
+                    <div class="xp-text">0 / 100 XP</div>
                 </div>
-                
-                <div class="streak-badge" id="streak-badge">
+
+                <div class="streak-badge">
                     <span class="streak-icon">🔥</span>
-                    <span class="streak-number" id="streak-number">1</span>
+                    <span class="streak-number">1</span>
                 </div>
             </div>
-        `, document.body.appendChild(this.container), this.xpBar = document.getElementById("xp-bar-fill"), this.xpText = document.getElementById("xp-text"), this.levelDisplay = document.getElementById("level-number"), this.streakDisplay = document.getElementById("streak-number");
+        `, document.body.appendChild(this.container), this.levelBadge = this.container.querySelector(".level-badge"), this.streakBadge = this.container.querySelector(".streak-badge"), this.xpBar = this.container.querySelector(".xp-bar-fill"), this.xpText = this.container.querySelector(".xp-text"), this.levelDisplay = this.container.querySelector(".level-number"), this.streakDisplay = this.container.querySelector(".streak-number");
+  }
+  /**
+   * setTimeout that destroy() can cancel.
+   * @private
+   */
+  _defer(e, t) {
+    const s = setTimeout(() => {
+      this._timers.delete(s), e();
+    }, t);
+    return this._timers.add(s), s;
+  }
+  /**
+   * Append a transient element and remember it for cleanup.
+   * @private
+   */
+  _mount(e) {
+    return document.body.appendChild(e), this._detached.push(e), e;
+  }
+  /**
+   * Replay a CSS animation by clearing it for one tick.
+   * @private
+   */
+  _replayAnimation(e, t) {
+    e && (e.style.animation = "none", this._defer(() => {
+      e.style.animation = t;
+    }, 10));
   }
   /**
    * Update XP bar
+   * @param {number} current - XP held right now
+   * @param {number} needed - XP still required for the next level
+   * @param {number} total - XP total that marks the next level
    */
-  updateXP(t, e, s) {
-    const i = t / s * 100;
-    this.xpBar.style.width = `${Math.min(100, i)}%`, this.xpText.textContent = `${t} / ${s} XP`, this.xpBar.style.animation = "none", setTimeout(() => {
-      this.xpBar.style.animation = "xp-pulse 0.3s ease-out";
-    }, 10);
+  updateXP(e, t, s) {
+    const i = s > 0 ? e / s * 100 : 0;
+    this.xpBar.style.width = `${Math.max(0, Math.min(100, i))}%`, this.xpText.textContent = `${e} / ${s} XP`, this._replayAnimation(this.xpBar, "xp-pulse 0.3s ease-out");
   }
   /**
    * Update level display
    */
-  updateLevel(t) {
-    this.levelDisplay.textContent = t;
-    const e = document.getElementById("level-badge");
-    e.style.animation = "none", setTimeout(() => {
-      e.style.animation = "level-pulse 0.5s ease-out";
-    }, 10);
+  updateLevel(e) {
+    this.levelDisplay.textContent = e, this._replayAnimation(this.levelBadge, "level-pulse 0.5s ease-out");
   }
   /**
    * Update streak display
    */
-  updateStreak(t) {
-    this.streakDisplay.textContent = t;
-    const e = document.getElementById("streak-badge");
-    t >= 7 ? e.style.background = "linear-gradient(135deg, #ff6b00 0%, #ff4400 100%)" : t >= 3 && (e.style.background = "linear-gradient(135deg, #ff8800 0%, #ff6b00 100%)");
+  updateStreak(e) {
+    this.streakDisplay.textContent = e, e >= 7 ? this.streakBadge.style.background = "linear-gradient(135deg, #ff6b00 0%, #ff4400 100%)" : e >= 3 && (this.streakBadge.style.background = "linear-gradient(135deg, #ff8800 0%, #ff6b00 100%)");
   }
   /**
    * Show achievement unlocked popup
-   */
-  showAchievement(t) {
-    const e = document.createElement("div");
-    e.className = "achievement-popup", e.innerHTML = `
+   *
+   * `icon` is rendered as HTML by design (documented in ARCHITECTURE.md, so
+   * games can pass an <img> or inline SVG). Every other field is game state
+   * and could carry a player-supplied or server-supplied string, so it goes
+   * in as text.
+   */
+  showAchievement(e) {
+    const t = document.createElement("div");
+    t.className = "achievement-popup", t.innerHTML = `
             <div class="achievement-shine"></div>
             <div class="achievement-content">
-                <div class="achievement-icon">${t.icon}</div>
+                <div class="achievement-icon"></div>
                 <div class="achievement-info">
                     <div class="achievement-title">Achievement Unlocked!</div>
-                    <div class="achievement-name">${t.name}</div>
-                    <div class="achievement-desc">${t.description}</div>
-                    <div class="achievement-xp">+${t.xp} XP</div>
+                    <div class="achievement-name"></div>
+                    <div class="achievement-desc"></div>
+                    <div class="achievement-xp"></div>
                 </div>
             </div>
-        `, document.body.appendChild(e), setTimeout(() => {
-      const s = e.getBoundingClientRect();
+        `, t.querySelector(".achievement-icon").innerHTML = e.icon ?? "", t.querySelector(".achievement-name").textContent = e.name ?? "", t.querySelector(".achievement-desc").textContent = e.description ?? "", t.querySelector(".achievement-xp").textContent = `+${e.xp ?? 0} XP`, this._mount(t), this._defer(() => {
+      const s = t.getBoundingClientRect();
       this.particleSystem.confetti(s.left + s.width / 2, s.top + s.height / 2, 40);
-    }, 300), setTimeout(() => {
-      e.style.animation = "slideOut 0.3s ease-in forwards", setTimeout(() => e.remove(), 300);
+    }, 300), this._defer(() => {
+      t.style.animation = "slideOut 0.3s ease-in forwards", this._defer(() => this._remove(t), 300);
     }, 4e3);
   }
   /**
    * Show level up screen
    */
-  showLevelUp(t, e) {
+  showLevelUp(e, t) {
     const s = document.createElement("div");
     s.className = "level-up-overlay", s.innerHTML = `
             <div class="level-up-content">
                 <div class="level-up-title">LEVEL UP!</div>
-                <div class="level-up-number">${e}</div>
+                <div class="level-up-number"></div>
                 <div class="level-up-subtitle">Amazing progress!</div>
             </div>
-        `, document.body.appendChild(s), setTimeout(() => {
+        `, s.querySelector(".level-up-number").textContent = t, this._mount(s), this._defer(() => {
       for (let i = 0; i < 5; i++)
-        setTimeout(() => {
+        this._defer(() => {
           const r = Math.random() * window.innerWidth, n = Math.random() * window.innerHeight * 0.6;
           this.particleSystem.confetti(r, n, 30);
         }, i * 200);
-    }, 300), setTimeout(() => {
-      s.style.opacity = "0", setTimeout(() => s.remove(), 500);
+    }, 300), this._defer(() => {
+      s.style.opacity = "0", this._defer(() => this._remove(s), 500);
     }, 2500);
   }
   /**
    * Show floating text (e.g., "+50 XP", "COMBO!")
    */
-  showFloatingText(t, e, s, i = "#ffd700", r = "24px") {
+  showFloatingText(e, t, s, i = "#ffd700", r = "24px") {
     const n = document.createElement("div");
-    n.className = "floating-text", n.textContent = t, n.style.left = e + "px", n.style.top = s + "px", n.style.color = i, n.style.fontSize = r, document.body.appendChild(n), setTimeout(() => n.remove(), 2e3);
+    n.className = "floating-text", n.textContent = e, n.style.left = t + "px", n.style.top = s + "px", n.style.color = i, n.style.fontSize = r, this._mount(n), this._defer(() => this._remove(n), 2e3);
   }
   /**
    * Show combo multiplier
    */
-  showCombo(t, e, s) {
-    this.showFloatingText(`${t}× COMBO!`, e, s, "#ff6b6b", "32px"), this.particleSystem.fire(e, s, 20);
+  showCombo(e, t, s) {
+    this.showFloatingText(`${e}× COMBO!`, t, s, "#ff6b6b", "32px"), this.particleSystem.fire(t, s, 20);
   }
   /**
-   * Show "near miss"indicator
+   * Show "near miss" indicator
    */
-  showNearMiss(t, e) {
-    this.showFloatingText("CLOSE CALL!", t, e, "#45b7d1", "20px"), this.particleSystem.sparkle(t, e, 15, "#45b7d1");
+  showNearMiss(e, t) {
+    this.showFloatingText("CLOSE CALL!", e, t, "#45b7d1", "20px"), this.particleSystem.sparkle(e, t, 15, "#45b7d1");
   }
   /**
    * Show lucky moment (random multiplier)
    */
-  showLuckyMoment(t, e, s) {
-    this.showFloatingText(`LUCKY ${t}×!`, e, s, "#ffd700", "36px"), this.particleSystem.starBurst(e, s, 12), this.particleSystem.confetti(e, s, 25);
+  showLuckyMoment(e, t, s) {
+    this.showFloatingText(`LUCKY ${e}×!`, t, s, "#ffd700", "36px"), this.particleSystem.starBurst(t, s, 12), this.particleSystem.confetti(t, s, 25);
   }
   /**
    * Show generic notification
    */
-  showNotification(t, e = "normal") {
+  showNotification(e, t = "normal") {
     const s = window.innerWidth / 2, i = window.innerHeight / 3;
-    e === "legendary" ? this.showLuckyMoment(t, s, i) : e === "rare" ? this.showCombo(t, s, i) : this.showFloatingText(t, s, i, "#fff", "24px");
+    t === "legendary" ? this.showLuckyMoment(e, s, i) : t === "rare" ? this.showCombo(e, s, i) : this.showFloatingText(e, s, i, "#fff", "24px");
   }
   /**
    * Show Game Over Summary
+   *
+   * @param {Object} data
+   * @param {number|string} data.score - Final score
+   * @param {Object} [data.metrics] - Label/value pairs listed under the score
+   * @param {Function} [data.onReplay] - Replay button handler (default: reload)
+   * @param {Function} [data.onExit] - Exit button handler (button hidden if omitted)
+   */
+  showSummary(e) {
+    const t = document.createElement("div");
+    t.className = "message-box", t.style.display = "flex", t.style.position = "absolute", t.style.top = "50%", t.style.left = "50%", t.style.transform = "translate(-50%, -50%)", t.style.zIndex = "1000";
+    const s = document.createElement("h1");
+    s.textContent = "Game Over";
+    const i = document.createElement("div");
+    i.className = "summary-score", i.style.cssText = "font-size: 3rem; font-weight: bold; color: #e06020; margin: 10px 0;", i.textContent = e.score;
+    const r = document.createElement("div");
+    r.className = "summary-metrics", r.style.cssText = "width: 100%; margin-bottom: 20px;";
+    for (const [o, c] of Object.entries(e.metrics || {})) {
+      const h = document.createElement("div");
+      h.style.cssText = "display:flex;justify-content:space-between;width:100%";
+      const l = document.createElement("span");
+      l.textContent = `${o}:`;
+      const u = document.createElement("strong");
+      u.textContent = c, h.append(l, u), r.appendChild(h);
+    }
+    t.append(s, i, r);
+    const n = document.createElement("button");
+    if (n.className = "btn", n.textContent = "Play Again", n.addEventListener("click", e.onReplay || (() => window.location.reload())), t.appendChild(n), e.onExit) {
+      const o = document.createElement("button");
+      o.className = "btn", o.textContent = "Exit", o.style.cssText = "margin-top: 10px; background: #543847;", o.addEventListener("click", e.onExit), t.appendChild(o);
+    }
+    return this._mount(t), t;
+  }
+  /**
+   * @private
    */
-  showSummary(t) {
-    const e = document.createElement("div");
-    e.className = "message-box", e.style.display = "flex", e.style.position = "absolute", e.style.top = "50%", e.style.left = "50%", e.style.transform = "translate(-50%, -50%)", e.style.zIndex = "1000";
-    let s = "";
-    t.metrics && (s = Object.entries(t.metrics).map(([i, r]) => `<div style="display:flex;justify-content:space-between;width:100%"><span>${i}:</span> <strong>${r}</strong></div>`).join("")), e.innerHTML = `
-            <h1>Game Over</h1>
-            <div style="font-size: 3rem; font-weight: bold; color: #e06020; margin: 10px 0;">${t.score}</div>
-            <div style="width: 100%; margin-bottom: 20px;">
-                ${s}
-            </div>
-            <button class="btn" onclick="location.reload()">Play Again</button>
-            <button class="btn" onclick="window.location.href='index.html'" style="margin-top: 10px; background: #543847;">Exit</button>
-        `, document.body.appendChild(e);
+  _remove(e) {
+    e.remove();
+    const t = this._detached.indexOf(e);
+    t > -1 && this._detached.splice(t, 1);
+  }
+  /**
+   * Tear down the overlay, any transient popups, and all pending timers.
+   */
+  destroy() {
+    var e;
+    for (const t of this._timers)
+      clearTimeout(t);
+    this._timers.clear();
+    for (const t of this._detached)
+      t.remove();
+    this._detached = [], (e = this.container) == null || e.remove(), this.container = null, this.xpBar = null, this.xpText = null, this.levelBadge = null, this.streakBadge = null, this.levelDisplay = null, this.streakDisplay = null;
   }
 }
-class T {
-  constructor(t = {}) {
-    this.container = t.container ? typeof t.container == "string" ? document.querySelector(t.container) : t.container : document.body, this.canvasId = t.canvasId || "dopamine-particle-canvas", this.canvas = document.getElementById(this.canvasId), this.canvas || (this.canvas = document.createElement("canvas"), this.canvas.id = this.canvasId, this.canvas.style.pointerEvents = "none", this.canvas.style.zIndex = t.zIndex || "9999", this.container === document.body ? (this.canvas.style.position = "fixed", this.canvas.style.top = "0", this.canvas.style.left = "0") : (this.canvas.style.position = "absolute", this.canvas.style.top = "0", this.canvas.style.left = "0", window.getComputedStyle(this.container).position === "static" && (this.container.style.position = "relative")), this.container.appendChild(this.canvas)), this.ctx = this.canvas.getContext("2d"), this.particles = [], this.pool = [], this.sprites = /* @__PURE__ */ new Map(), this.customEffects = /* @__PURE__ */ new Map(), this.isAnimating = !1, this._resize(), window.ResizeObserver && this.container !== document.body ? new ResizeObserver(() => this._resize()).observe(this.container) : window.addEventListener("resize", () => this._resize());
+class I {
+  constructor(e = {}) {
+    this.container = e.container ? typeof e.container == "string" ? document.querySelector(e.container) : e.container : document.body, this.canvasId = e.canvasId || "dopamine-particle-canvas", this.canvas = document.createElement("canvas"), this.canvas.classList.add("dopamine-particle-canvas"), document.getElementById(this.canvasId) || (this.canvas.id = this.canvasId), this.canvas.style.pointerEvents = "none", this.canvas.style.zIndex = e.zIndex || "9999", this.container === document.body ? (this.canvas.style.position = "fixed", this.canvas.style.top = "0", this.canvas.style.left = "0") : (this.canvas.style.position = "absolute", this.canvas.style.top = "0", this.canvas.style.left = "0", window.getComputedStyle(this.container).position === "static" && (this.container.style.position = "relative")), this.container.appendChild(this.canvas), this.ctx = this.canvas.getContext("2d"), this.particles = [], this.pool = [], this.sprites = /* @__PURE__ */ new Map(), this.customEffects = /* @__PURE__ */ new Map(), this.isAnimating = !1, this._onResize = () => this._resize(), this._resizeObserver = null, this._frameHandle = null, this._resize(), window.ResizeObserver && this.container !== document.body ? (this._resizeObserver = new ResizeObserver(this._onResize), this._resizeObserver.observe(this.container)) : window.addEventListener("resize", this._onResize);
   }
   _resize() {
-    this.container === document.body ? (this.canvas.width = window.innerWidth, this.canvas.height = window.innerHeight) : (this.canvas.width = this.container.clientWidth, this.canvas.height = this.container.clientHeight);
+    const e = this.container === document.body ? window.innerWidth : this.container.clientWidth, t = this.container === document.body ? window.innerHeight : this.container.clientHeight, s = window.devicePixelRatio || 1;
+    this.width = e, this.height = t, this.canvas.width = Math.round(e * s), this.canvas.height = Math.round(t * s), this.canvas.style.width = `${e}px`, this.canvas.style.height = `${t}px`, this.ctx.setTransform(s, 0, 0, s, 0, 0);
   }
   /**
    * Register a custom sprite image
    * @param {string} key 
    * @param {string} url 
    */
-  registerSprite(t, e) {
+  registerSprite(e, t) {
     const s = new Image();
-    s.src = e, this.sprites.set(t, s);
+    s.src = t, this.sprites.set(e, s);
   }
   /**
    * Register a custom effect
    * @param {string} name 
    * @param {Function} callback - (x, y, ...args) => void
    */
-  registerEffect(t, e) {
-    this.customEffects.set(t, e);
+  registerEffect(e, t) {
+    this.customEffects.set(e, t);
   }
   /**
    * Play a registered effect
    */
-  play(t, e, s, ...i) {
-    const r = this.customEffects.get(t);
-    r ? r(e, s, ...i) : console.warn(`[DopamineJS] Effect '${t}' not found.`);
+  play(e, t, s, ...i) {
+    const r = this.customEffects.get(e);
+    r ? r(t, s, ...i) : console.warn(`[DopamineJS] Effect '${e}' not found.`);
   }
   /**
    * Emit particles with custom config
    * @param {Object} config 
    */
-  emit(t) {
+  emit(e) {
     const {
-      x: e,
+      x: t,
       y: s,
       count: i = 10,
       speed: r = 5,
       gravity: n = 0.1,
       decay: o = 0.02,
-      life: h = 1,
-      color: c = "#ffd700",
-      sprite: d = null,
+      life: c = 1,
+      color: h = "#ffd700",
+      sprite: l = null,
       spread: u = Math.PI * 2,
       angle: m = 0,
       size: f = 5
-    } = t;
+    } = e;
     for (let v = 0; v < i; v++) {
-      const l = this._getParticle(), w = m + (Math.random() - 0.5) * u, x = Math.random() * r;
-      l.x = e, l.y = s, l.vx = Math.cos(w) * x, l.vy = Math.sin(w) * x, l.life = h, l.decay = o * (0.8 + Math.random() * 0.4), l.gravity = n, l.color = Array.isArray(c) ? c[Math.floor(Math.random() * c.length)] : c, l.size = f * (0.8 + Math.random() * 0.4), l.sprite = d, l.rotation = Math.random() * Math.PI * 2, l.rotationSpeed = (Math.random() - 0.5) * 0.2, this.particles.push(l);
+      const d = this._getParticle(), x = m + (Math.random() - 0.5) * u, w = Math.random() * r;
+      d.x = t, d.y = s, d.vx = Math.cos(x) * w, d.vy = Math.sin(x) * w, d.life = c, d.decay = o * (0.8 + Math.random() * 0.4), d.gravity = n, d.color = Array.isArray(h) ? h[Math.floor(Math.random() * h.length)] : h, d.size = f * (0.8 + Math.random() * 0.4), d.sprite = l, d.rotation = Math.random() * Math.PI * 2, d.rotationSpeed = (Math.random() - 0.5) * 0.2, this.particles.push(d);
     }
     this._startAnimation();
   }
   _getParticle() {
     return this.pool.length > 0 ? this.pool.pop() : {};
   }
-  _recycleParticle(t) {
-    this.pool.push(t);
+  _recycleParticle(e) {
+    this.pool.push(e);
   }
   // --- Built-in Effects ---
-  confetti(t, e, s = 50) {
+  confetti(e, t, s = 50) {
     const i = ["#ff6b6b", "#4ecdc4", "#45b7d1", "#f7dc6f", "#c06c84", "#6c5ce7"];
     this.emit({
-      x: t,
-      y: e,
+      x: e,
+      y: t,
       count: s,
       color: i,
       speed: 10,
@@ -507,10 +699,10 @@ class T {
       spread: Math.PI * 2
     });
   }
-  coinShower(t, e, s = 10) {
+  coinShower(e, t, s = 10) {
     this.emit({
-      x: t,
-      y: e,
+      x: e,
+      y: t,
       count: s,
       color: "#ffd700",
       speed: 4,
@@ -522,10 +714,10 @@ class T {
       spread: Math.PI / 2
     });
   }
-  sparkle(t, e, s = 20, i = "#ffd700") {
+  sparkle(e, t, s = 20, i = "#ffd700") {
     this.emit({
-      x: t,
-      y: e,
+      x: e,
+      y: t,
       count: s,
       color: i,
       speed: 3,
@@ -535,11 +727,11 @@ class T {
       size: 3
     });
   }
-  fire(t, e, s = 15) {
+  fire(e, t, s = 15) {
     const i = ["#ff6b00", "#ff8800", "#ffaa00", "#ff4400"];
     this.emit({
-      x: t,
-      y: e,
+      x: e,
+      y: t,
       count: s,
       color: i,
       speed: 3,
@@ -550,10 +742,10 @@ class T {
       spread: Math.PI / 4
     });
   }
-  starBurst(t, e, s = 8) {
+  starBurst(e, t, s = 8) {
     for (let i = 0; i < s; i++) {
       const r = this._getParticle(), n = Math.PI * 2 / s * i, o = 4;
-      r.x = t, r.y = e, r.vx = Math.cos(n) * o, r.vy = Math.sin(n) * o, r.life = 1, r.decay = 0.03, r.gravity = 0, r.color = "#ffffff", r.size = 15, r.sprite = null, r.type = "star", r.rotation = n, r.rotationSpeed = 0, this.particles.push(r);
+      r.x = e, r.y = t, r.vx = Math.cos(n) * o, r.vy = Math.sin(n) * o, r.life = 1, r.decay = 0.03, r.gravity = 0, r.color = "#ffffff", r.size = 15, r.sprite = null, r.type = "star", r.rotation = n, r.rotationSpeed = 0, this.particles.push(r);
     }
     this._startAnimation();
   }
@@ -561,98 +753,129 @@ class T {
     this.isAnimating || (this.isAnimating = !0, this._animate());
   }
   _animate() {
-    this.ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
-    for (let t = this.particles.length - 1; t >= 0; t--) {
-      const e = this.particles[t];
-      if (e.vy += e.gravity, e.x += e.vx, e.y += e.vy, e.life -= e.decay, e.rotationSpeed && (e.rotation += e.rotationSpeed), e.life <= 0) {
-        this._recycleParticle(e), this.particles.splice(t, 1);
+    this._frameHandle = null, this.ctx.clearRect(0, 0, this.width, this.height);
+    for (let e = this.particles.length - 1; e >= 0; e--) {
+      const t = this.particles[e];
+      if (t.vy += t.gravity, t.x += t.vx, t.y += t.vy, t.life -= t.decay, t.rotationSpeed && (t.rotation += t.rotationSpeed), t.life <= 0) {
+        this._recycleParticle(t), this.particles.splice(e, 1);
         continue;
       }
-      if (this.ctx.save(), this.ctx.globalAlpha = e.life, this.ctx.translate(e.x, e.y), this.ctx.rotate(e.rotation), e.sprite && this.sprites.has(e.sprite)) {
-        const s = this.sprites.get(e.sprite);
-        s.complete && this.ctx.drawImage(s, -e.size / 2, -e.size / 2, e.size, e.size);
-      } else e.type === "star" ? (this.ctx.fillStyle = e.color, this._drawStarPath(0, 0, 5, e.size, e.size / 2), this.ctx.fill()) : (this.ctx.fillStyle = e.color, this.ctx.beginPath(), this.ctx.arc(0, 0, e.size, 0, Math.PI * 2), this.ctx.fill());
+      if (this.ctx.save(), this.ctx.globalAlpha = t.life, this.ctx.translate(t.x, t.y), this.ctx.rotate(t.rotation), t.sprite && this.sprites.has(t.sprite)) {
+        const s = this.sprites.get(t.sprite);
+        s.complete && this.ctx.drawImage(s, -t.size / 2, -t.size / 2, t.size, t.size);
+      } else t.type === "star" ? (this.ctx.fillStyle = t.color, this._drawStarPath(0, 0, 5, t.size, t.size / 2), this.ctx.fill()) : (this.ctx.fillStyle = t.color, this.ctx.beginPath(), this.ctx.arc(0, 0, t.size, 0, Math.PI * 2), this.ctx.fill());
       this.ctx.restore();
     }
-    this.particles.length > 0 ? requestAnimationFrame(() => this._animate()) : this.isAnimating = !1;
+    this.particles.length > 0 ? this._frameHandle = requestAnimationFrame(() => this._animate()) : this.isAnimating = !1;
   }
-  _drawStarPath(t, e, s, i, r) {
-    let n = Math.PI / 2 * 3, o = t, h = e;
-    const c = Math.PI / s;
-    this.ctx.beginPath(), this.ctx.moveTo(t, e - i);
-    for (let d = 0; d < s; d++)
-      o = t + Math.cos(n) * i, h = e + Math.sin(n) * i, this.ctx.lineTo(o, h), n += c, o = t + Math.cos(n) * r, h = e + Math.sin(n) * r, this.ctx.lineTo(o, h), n += c;
-    this.ctx.lineTo(t, e - i), this.ctx.closePath();
+  _drawStarPath(e, t, s, i, r) {
+    let n = Math.PI / 2 * 3, o = e, c = t;
+    const h = Math.PI / s;
+    this.ctx.beginPath(), this.ctx.moveTo(e, t - i);
+    for (let l = 0; l < s; l++)
+      o = e + Math.cos(n) * i, c = t + Math.sin(n) * i, this.ctx.lineTo(o, c), n += h, o = e + Math.cos(n) * r, c = t + Math.sin(n) * r, this.ctx.lineTo(o, c), n += h;
+    this.ctx.lineTo(e, t - i), this.ctx.closePath();
   }
   clear() {
-    this.particles.forEach((t) => this._recycleParticle(t)), this.particles = [], this.ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
+    this.particles.forEach((e) => this._recycleParticle(e)), this.particles = [], this.ctx.clearRect(0, 0, this.width, this.height);
+  }
+  /**
+   * Stop animating, detach resize handling, and remove the canvas.
+   *
+   * Without this the resize listener and canvas outlive the instance, which
+   * matters in any single-page app that mounts and unmounts a game view.
+   */
+  destroy() {
+    this.clear(), this.isAnimating = !1, this._frameHandle !== null && (cancelAnimationFrame(this._frameHandle), this._frameHandle = null), this._resizeObserver && (this._resizeObserver.disconnect(), this._resizeObserver = null), window.removeEventListener("resize", this._onResize), this.canvas.remove(), this.sprites.clear(), this.customEffects.clear(), this.pool = [];
   }
 }
-class I {
-  constructor(t = {}) {
-    this.audioContext = null, this.storageKey = t.storageKey || "dopamineSoundsMuted", this.muted = localStorage.getItem(this.storageKey) === "true", this.assets = /* @__PURE__ */ new Map(), this.customSounds = t.customSounds || {}, Object.keys(this.customSounds).length > 0 && this.preloadSounds(this.customSounds);
+class L {
+  constructor(e = {}) {
+    this.audioContext = null, this.storageKey = e.storageKey || "dopamineSoundsMuted", this.storage = e.storage || b(), this.muted = this.storage.getItem(this.storageKey) === "true", this.assets = /* @__PURE__ */ new Map(), this.customSounds = e.customSounds || {}, this.masterGain = null, this._volume = e.volume ?? 1, Object.keys(this.customSounds).length > 0 && this.preloadSounds(this.customSounds);
   }
   /**
    * Initialize Audio Context (must be called after user interaction)
    */
   initAudio() {
     if (!this.audioContext) {
-      const t = window.AudioContext || window.webkitAudioContext;
-      this.audioContext = new t();
+      const e = typeof window < "u" ? window.AudioContext || window.webkitAudioContext : void 0;
+      if (!e) return !1;
+      this.audioContext = new e(), this.masterGain = this.audioContext.createGain(), this.masterGain.gain.value = this._volume, this.masterGain.connect(this.audioContext.destination);
     }
-    this.audioContext.state === "suspended" && this.audioContext.resume();
+    return this.audioContext.state === "suspended" && this.audioContext.resume(), !0;
+  }
+  /**
+   * Set master output volume.
+   * @param {number} value - 0..1
+   */
+  setVolume(e) {
+    return this._volume = Math.max(0, Math.min(1, e)), this.masterGain && (this.masterGain.gain.value = this._volume), this._volume;
+  }
+  /**
+   * Current master output volume.
+   * @returns {number}
+   */
+  getVolume() {
+    return this._volume;
+  }
+  /**
+   * Node every sound routes through, so volume and mute apply uniformly.
+   * @private
+   */
+  _output() {
+    return this.masterGain || this.audioContext.destination;
   }
   /**
    * Toggle mute state
    * @returns {boolean} New mute state
    */
   toggleMute() {
-    return this.muted = !this.muted, localStorage.setItem(this.storageKey, this.muted), this.muted;
+    return this.muted = !this.muted, this.storage.setItem(this.storageKey, this.muted), this.muted;
   }
   /**
    * Register a custom sound URL
    * @param {string} key - Unique identifier (e.g., 'jump', 'win')
    * @param {string} url - Path to audio file
    */
-  registerSound(t, e) {
-    this.customSounds[t] = e, this.audioContext && this.loadSound(t, e);
+  registerSound(e, t) {
+    this.customSounds[e] = t, this.audioContext && this.loadSound(e, t);
   }
   /**
    * Preload multiple sounds
    * @param {Object} soundMap - { key: url }
    */
-  async preloadSounds(t) {
-    const e = Object.entries(t).map(([s, i]) => this.loadSound(s, i));
-    await Promise.allSettled(e);
+  async preloadSounds(e) {
+    const t = Object.entries(e).map(([s, i]) => this.loadSound(s, i));
+    await Promise.allSettled(t);
   }
   /**
    * Load and decode a sound file
    */
-  async loadSound(t, e) {
+  async loadSound(e, t) {
     try {
       if (!this.audioContext)
         return;
-      const i = await (await fetch(e)).arrayBuffer(), r = await this.audioContext.decodeAudioData(i);
-      this.assets.set(t, r);
+      const i = await (await fetch(t)).arrayBuffer(), r = await this.audioContext.decodeAudioData(i);
+      this.assets.set(e, r);
     } catch (s) {
-      console.warn(`[DopamineJS] Failed to load sound '${t}':`, s);
+      console.warn(`[DopamineJS] Failed to load sound '${e}':`, s);
     }
   }
   /**
    * Play a sound by key (custom) or fallback to synth
    * @param {string} key - 'jump', 'score', 'success', etc.
    */
-  async play(t) {
-    if (this.muted) return;
-    if (this.initAudio(), this.assets.has(t)) {
-      this._playBuffer(this.assets.get(t));
+  async play(e) {
+    if (this.muted || !this.initAudio()) return;
+    if (this.assets.has(e)) {
+      this._playBuffer(this.assets.get(e));
       return;
     }
-    if (this.customSounds[t] && !this.assets.has(t) && (await this.loadSound(t, this.customSounds[t]), this.assets.has(t))) {
-      this._playBuffer(this.assets.get(t));
+    if (this.customSounds[e] && !this.assets.has(e) && (await this.loadSound(e, this.customSounds[e]), this.assets.has(e))) {
+      this._playBuffer(this.assets.get(e));
       return;
     }
-    const e = {
+    const t = {
       jump: () => this.playJump(!0),
       score: () => this.playScore(!0),
       success: () => this.playSuccess(!0),
@@ -660,50 +883,51 @@ class I {
       error: () => this.playError(!0),
       gameover: () => this.playGameOver(!0)
     };
-    e[t] && e[t]();
+    t[e] && t[e]();
   }
-  _playBuffer(t) {
-    const e = this.audioContext.createBufferSource();
-    e.buffer = t, e.connect(this.audioContext.destination), e.start(0);
+  _playBuffer(e) {
+    const t = this.audioContext.createBufferSource();
+    t.buffer = e, t.connect(this._output()), t.start(0);
   }
   /**
    * Play a synthesized tone
    */
-  playTone(t, e, s = "sine", i = 0.3) {
-    if (this.muted) return;
-    this.initAudio();
+  playTone(e, t, s = "sine", i = 0.3) {
+    if (this.muted || !this.initAudio()) return;
     const r = this.audioContext.createOscillator(), n = this.audioContext.createGain();
-    r.connect(n), n.connect(this.audioContext.destination), r.frequency.value = t, r.type = s, n.gain.setValueAtTime(i, this.audioContext.currentTime), n.gain.exponentialRampToValueAtTime(0.01, this.audioContext.currentTime + e), r.start(this.audioContext.currentTime), r.stop(this.audioContext.currentTime + e);
+    r.connect(n), n.connect(this._output()), r.frequency.value = e, r.type = s;
+    const o = Math.max(1e-4, i);
+    n.gain.setValueAtTime(o, this.audioContext.currentTime), n.gain.exponentialRampToValueAtTime(0.01, this.audioContext.currentTime + t), r.start(this.audioContext.currentTime), r.stop(this.audioContext.currentTime + t);
   }
   // --- Presets (Synth) ---
-  playJump(t = !1) {
-    if (!t && this.assets.has("jump")) return this.play("jump");
+  playJump(e = !1) {
+    if (!e && this.assets.has("jump")) return this.play("jump");
     this.playTone(400, 0.1, "square", 0.2);
   }
-  playScore(t = !1) {
-    if (!t && this.assets.has("score")) return this.play("score");
+  playScore(e = !1) {
+    if (!e && this.assets.has("score")) return this.play("score");
     this.playTone(800, 0.15, "sine", 0.25), setTimeout(() => this.playTone(1e3, 0.15, "sine", 0.25), 50);
   }
-  playGameOver(t = !1) {
-    if (!t && this.assets.has("gameover")) return this.play("gameover");
+  playGameOver(e = !1) {
+    if (!e && this.assets.has("gameover")) return this.play("gameover");
     this.playTone(300, 0.2, "sawtooth", 0.3), setTimeout(() => this.playTone(200, 0.2, "sawtooth", 0.3), 100), setTimeout(() => this.playTone(150, 0.3, "sawtooth", 0.3), 200);
   }
-  playClick(t = !1) {
-    if (!t && this.assets.has("click")) return this.play("click");
+  playClick(e = !1) {
+    if (!e && this.assets.has("click")) return this.play("click");
     this.playTone(600, 0.05, "sine", 0.1);
   }
-  playSuccess(t = !1) {
-    if (!t && this.assets.has("success")) return this.play("success");
+  playSuccess(e = !1) {
+    if (!e && this.assets.has("success")) return this.play("success");
     this.playTone(600, 0.1, "sine", 0.2), setTimeout(() => this.playTone(800, 0.2, "sine", 0.2), 100);
   }
-  playError(t = !1) {
-    if (!t && this.assets.has("error")) return this.play("error");
+  playError(e = !1) {
+    if (!e && this.assets.has("error")) return this.play("error");
     this.playTone(200, 0.2, "sawtooth", 0.3);
   }
 }
-class B {
-  constructor(t = {}) {
-    this.config = t, this.dataService = new P(t.data || {}), this.rewardSystem = new E(this.dataService, t.rewards || {}), this.soundManager = new I(t.sound || {}), this.particleSystem = new T(t.particles || {}), this.gameUI = new C(this.particleSystem), this._bindEvents();
+class H {
+  constructor(e = {}) {
+    this.config = e, this.dataService = new A(e.data || {}), this.rewardSystem = new O(this.dataService, e.rewards || {}), this.soundManager = new L(e.sound || {}), this.particleSystem = new I(e.particles || {}), this.gameUI = new T(this.particleSystem), this._bindEvents();
   }
   async init() {
     return await this.rewardSystem.init(), {
@@ -714,15 +938,15 @@ class B {
     };
   }
   _bindEvents() {
-    this.rewardSystem.on("xp_gained", (t) => {
-      const { total: e, needed: s } = this.rewardSystem.getXPForNextLevel();
-      this.gameUI.updateXP(this.rewardSystem.player.xp, s, e), t.xpGained > 0;
-    }), this.rewardSystem.on("level_up", (t) => {
-      this.gameUI.updateLevel(t.newLevel), this.gameUI.showLevelUp(t.oldLevel, t.newLevel);
-    }), this.rewardSystem.on("achievement_unlocked", (t) => {
-      this.gameUI.showAchievement(t);
-    }), this.rewardSystem.on("new_high_score", (t) => {
-      this.gameUI.showNotification(`New High Score: ${t.score}!`, "legendary"), this.soundManager.playSuccess();
+    this.rewardSystem.on("xp_gained", (e) => {
+      const { total: t, needed: s } = this.rewardSystem.getXPForNextLevel();
+      this.gameUI.updateXP(this.rewardSystem.player.xp, s, t), e.xpGained > 0;
+    }), this.rewardSystem.on("level_up", (e) => {
+      this.gameUI.updateLevel(e.newLevel), this.gameUI.showLevelUp(e.oldLevel, e.newLevel);
+    }), this.rewardSystem.on("achievement_unlocked", (e) => {
+      this.gameUI.showAchievement(e);
+    }), this.rewardSystem.on("new_high_score", (e) => {
+      this.gameUI.showNotification(`New High Score: ${e.score}!`, "legendary"), this.soundManager.playSuccess();
     });
   }
 }
@@ -737,8 +961,8 @@ class p {
    * @param {number} priority - Higher priority = called first (default: 0)
    * @returns {EventBus} - For chaining
    */
-  on(t, e, s = 0) {
-    return this._listeners.has(t) || this._listeners.set(t, /* @__PURE__ */ new Set()), this._listeners.get(t).add({ callback: e, priority: s }), this._sortedCache.delete(t), this;
+  on(e, t, s = 0) {
+    return this._listeners.has(e) || this._listeners.set(e, /* @__PURE__ */ new Set()), this._listeners.get(e).add({ callback: t, priority: s }), this._sortedCache.delete(e), this;
   }
   /**
    * Register a one-time event listener
@@ -746,8 +970,8 @@ class p {
    * @param {Function} callback - Callback function
    * @returns {EventBus} - For chaining
    */
-  once(t, e) {
-    return this._onceListeners.has(t) || this._onceListeners.set(t, /* @__PURE__ */ new Set()), this._onceListeners.get(t).add(e), this;
+  once(e, t) {
+    return this._onceListeners.has(e) || this._onceListeners.set(e, /* @__PURE__ */ new Set()), this._onceListeners.get(e).add(t), this;
   }
   /**
    * Remove an event listener
@@ -755,62 +979,74 @@ class p {
    * @param {Function} callback - Callback function to remove
    * @returns {EventBus} - For chaining
    */
-  off(t, e) {
-    const s = this._listeners.get(t);
-    if (s) {
-      for (const r of s)
-        if (r.callback === e) {
-          s.delete(r), this._sortedCache.delete(t);
-          break;
-        }
-    }
-    const i = this._onceListeners.get(t);
-    return i && i.delete(e), this;
+  off(e, t) {
+    const s = this._listeners.get(e);
+    if (s)
+      for (const r of [...s])
+        r.callback === t && (s.delete(r), this._sortedCache.delete(e));
+    const i = this._onceListeners.get(e);
+    return i && i.delete(t), this;
   }
   /**
    * Emit an event to all registered listeners
    * @param {string} event - Event name
    * @param {*} data - Event data
    */
-  emit(t, e) {
-    const s = this._getSortedListeners(t);
+  emit(e, t) {
+    const s = this._getSortedListeners(e);
     for (let r = 0; r < s.length; r++)
-      s[r].callback(e);
-    const i = this._onceListeners.get(t);
+      this._invoke(s[r].callback, t, e);
+    const i = this._onceListeners.get(e);
     if (i && i.size > 0) {
-      for (const r of i)
-        r(e);
+      const r = [...i];
       i.clear();
+      for (const n of r)
+        this._invoke(n, t, e);
+    }
+  }
+  /**
+   * Call one listener without letting it abort the dispatch.
+   *
+   * A throwing listener used to take out every lower-priority listener for
+   * that event, which on 'tick' means the game silently stops updating.
+   *
+   * @private
+   */
+  _invoke(e, t, s) {
+    try {
+      e(t);
+    } catch (i) {
+      console.error(`[DopamineJS] Listener for "${s}" threw:`, i);
     }
   }
   /**
    * Get sorted listeners for an event (with caching)
    * @private
    */
-  _getSortedListeners(t) {
-    if (this._sortedCache.has(t))
-      return this._sortedCache.get(t);
-    const e = this._listeners.get(t);
-    if (!e || e.size === 0)
+  _getSortedListeners(e) {
+    if (this._sortedCache.has(e))
+      return this._sortedCache.get(e);
+    const t = this._listeners.get(e);
+    if (!t || t.size === 0)
       return [];
-    const s = Array.from(e).sort((i, r) => r.priority - i.priority);
-    return this._sortedCache.set(t, s), s;
+    const s = Array.from(t).sort((i, r) => r.priority - i.priority);
+    return this._sortedCache.set(e, s), s;
   }
   /**
    * Remove all listeners for an event, or all events if no event specified
    * @param {string} [event] - Event name (optional)
    */
-  clear(t) {
-    t ? (this._listeners.delete(t), this._onceListeners.delete(t), this._sortedCache.delete(t)) : (this._listeners.clear(), this._onceListeners.clear(), this._sortedCache.clear());
+  clear(e) {
+    e ? (this._listeners.delete(e), this._onceListeners.delete(e), this._sortedCache.delete(e)) : (this._listeners.clear(), this._onceListeners.clear(), this._sortedCache.clear());
   }
   /**
    * Check if an event has listeners
    * @param {string} event - Event name
    * @returns {boolean}
    */
-  hasListeners(t) {
-    const e = this._listeners.get(t), s = this._onceListeners.get(t);
-    return e && e.size > 0 || s && s.size > 0;
+  hasListeners(e) {
+    const t = this._listeners.get(e), s = this._onceListeners.get(e);
+    return !!(t != null && t.size) || !!(s != null && s.size);
   }
 }
 p.Events = {
@@ -833,9 +1069,9 @@ p.Events = {
   PLUGIN_LOADED: "plugin_loaded",
   PLUGIN_UNLOADED: "plugin_unloaded"
 };
-class O {
-  constructor(t) {
-    this.kernel = t, this._systems = /* @__PURE__ */ new Map(), this._updateOrder = [], this._fixedUpdateOrder = [], this._needsRecompute = !1;
+class U {
+  constructor(e) {
+    this.kernel = e, this._systems = /* @__PURE__ */ new Map(), this._updateOrder = [], this._fixedUpdateOrder = [], this._needsRecompute = !1;
   }
   /**
    * Register a system
@@ -846,62 +1082,62 @@ class O {
    * @param {string[]} options.dependencies - System names this depends on
    * @returns {SystemRegistry} - For chaining
    */
-  register(t, e, { priority: s = 0, dependencies: i = [] } = {}) {
-    this._systems.has(t) && (console.warn(`[SystemRegistry] System "${t}" already registered. Replacing.`), this.unregister(t));
+  register(e, t, { priority: s = 0, dependencies: i = [] } = {}) {
+    this._systems.has(e) && (console.warn(`[SystemRegistry] System "${e}" already registered. Replacing.`), this.unregister(e));
     for (const r of i)
-      this._systems.has(r) || console.warn(`[SystemRegistry] Dependency "${r}" not found for system "${t}"`);
-    return this._systems.set(t, {
-      system: e,
+      this._systems.has(r) || console.warn(`[SystemRegistry] Dependency "${r}" not found for system "${e}"`);
+    return this._systems.set(e, {
+      system: t,
       priority: s,
       dependencies: i
-    }), e.init && e.init(this.kernel), this._needsRecompute = !0, this.kernel.events.emit("system_registered", { name: t, system: e }), this;
+    }), t.init && t.init(this.kernel), this._needsRecompute = !0, this.kernel.events.emit("system_registered", { name: e, system: t }), this;
   }
   /**
    * Get a system by name
    * @param {string} name - System name
    * @returns {Object|undefined} - System instance
    */
-  get(t) {
-    const e = this._systems.get(t);
-    return e ? e.system : void 0;
+  get(e) {
+    const t = this._systems.get(e);
+    return t ? t.system : void 0;
   }
   /**
    * Check if a system is registered
    * @param {string} name - System name
    * @returns {boolean}
    */
-  has(t) {
-    return this._systems.has(t);
+  has(e) {
+    return this._systems.has(e);
   }
   /**
    * Unregister a system
    * @param {string} name - System name
    * @returns {boolean} - True if system was found and removed
    */
-  unregister(t) {
-    const e = this._systems.get(t);
-    return e ? (e.system.destroy && e.system.destroy(), this._systems.delete(t), this._needsRecompute = !0, this.kernel.events.emit("system_unregistered", { name: t }), !0) : !1;
+  unregister(e) {
+    const t = this._systems.get(e);
+    return t ? (t.system.destroy && t.system.destroy(), this._systems.delete(e), this._needsRecompute = !0, this.kernel.events.emit("system_unregistered", { name: e }), !0) : !1;
   }
   /**
    * Update all systems (called each frame)
    * @param {number} dt - Delta time in seconds
    */
-  update(t) {
+  update(e) {
     this._needsRecompute && this._recomputeUpdateOrder();
-    for (let e = 0; e < this._updateOrder.length; e++) {
-      const s = this._updateOrder[e];
-      s.update && s.update(t);
+    for (let t = 0; t < this._updateOrder.length; t++) {
+      const s = this._updateOrder[t];
+      s.update && s.update(e);
     }
   }
   /**
    * Fixed update for physics (called at fixed timestep)
    * @param {number} dt - Fixed delta time
    */
-  fixedUpdate(t) {
+  fixedUpdate(e) {
     this._needsRecompute && this._recomputeUpdateOrder();
-    for (let e = 0; e < this._fixedUpdateOrder.length; e++) {
-      const s = this._fixedUpdateOrder[e];
-      s.fixedUpdate && s.fixedUpdate(t);
+    for (let t = 0; t < this._fixedUpdateOrder.length; t++) {
+      const s = this._fixedUpdateOrder[t];
+      s.fixedUpdate && s.fixedUpdate(e);
     }
   }
   /**
@@ -910,29 +1146,29 @@ class O {
    * @private
    */
   _recomputeUpdateOrder() {
-    const t = Array.from(this._systems.entries()), e = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map();
-    for (const [n, o] of t)
-      e.set(n, o.dependencies), s.set(n, 0);
+    const e = Array.from(this._systems.entries()), t = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map();
     for (const [n, o] of e)
-      for (const h of o)
-        s.has(h) && s.set(n, s.get(n) + 1);
+      t.set(n, o.dependencies), s.set(n, 0);
+    for (const [n, o] of t)
+      for (const c of o)
+        s.has(c) && s.set(n, s.get(n) + 1);
     const i = [], r = [];
     for (const [n, o] of s)
       o === 0 && i.push(n);
     for (; i.length > 0; ) {
-      i.sort((o, h) => {
-        const c = this._systems.get(o).priority;
-        return this._systems.get(h).priority - c;
+      i.sort((o, c) => {
+        const h = this._systems.get(o).priority;
+        return this._systems.get(c).priority - h;
       });
       const n = i.shift();
       r.push(n);
-      for (const [o, h] of e)
-        if (h.includes(n)) {
-          const c = s.get(o) - 1;
-          s.set(o, c), c === 0 && i.push(o);
+      for (const [o, c] of t)
+        if (c.includes(n)) {
+          const h = s.get(o) - 1;
+          s.set(o, h), h === 0 && i.push(o);
         }
     }
-    r.length !== t.length && (console.error("[SystemRegistry] Circular dependency detected in systems!"), r.length = 0, r.push(...t.map(([n]) => n).sort((n, o) => this._systems.get(o).priority - this._systems.get(n).priority))), this._updateOrder = r.map((n) => this._systems.get(n).system).filter((n) => n.update), this._fixedUpdateOrder = r.map((n) => this._systems.get(n).system).filter((n) => n.fixedUpdate), this._needsRecompute = !1;
+    r.length !== e.length && (console.error("[SystemRegistry] Circular dependency detected in systems!"), r.length = 0, r.push(...e.map(([n]) => n).sort((n, o) => this._systems.get(o).priority - this._systems.get(n).priority))), this._updateOrder = r.map((n) => this._systems.get(n).system).filter((n) => n.update), this._fixedUpdateOrder = r.map((n) => this._systems.get(n).system).filter((n) => n.fixedUpdate), this._needsRecompute = !1;
   }
   /**
    * Get all registered system names
@@ -945,13 +1181,13 @@ class O {
    * Clear all systems
    */
   clear() {
-    for (const t of this._systems.keys())
-      this.unregister(t);
+    for (const e of this._systems.keys())
+      this.unregister(e);
   }
 }
-class A {
-  constructor(t) {
-    this.kernel = t, this._plugins = /* @__PURE__ */ new Map(), this._loadOrder = [];
+class R {
+  constructor(e) {
+    this.kernel = e, this._plugins = /* @__PURE__ */ new Map(), this._loadOrder = [];
   }
   /**
    * Register and initialize a plugin
@@ -967,21 +1203,21 @@ class A {
    * @param {Object} plugin - Plugin instance
    * @returns {PluginRegistry} - For chaining
    */
-  use(t) {
-    if (!t.name)
+  use(e) {
+    if (!e.name)
       throw new Error("[PluginRegistry] Plugin must have a name");
-    if (this._plugins.has(t.name))
-      return console.warn(`[PluginRegistry] Plugin "${t.name}" already registered. Skipping.`), this;
-    if (!t.init || typeof t.init != "function")
-      throw new Error(`[PluginRegistry] Plugin "${t.name}" must have an init() method`);
-    this._plugins.set(t.name, t), this._loadOrder.push(t.name);
+    if (this._plugins.has(e.name))
+      return console.warn(`[PluginRegistry] Plugin "${e.name}" already registered. Skipping.`), this;
+    if (!e.init || typeof e.init != "function")
+      throw new Error(`[PluginRegistry] Plugin "${e.name}" must have an init() method`);
+    this._plugins.set(e.name, e), this._loadOrder.push(e.name);
     try {
-      t.init(this.kernel), this.kernel.events.emit("plugin_loaded", {
-        name: t.name,
-        version: t.version
+      e.init(this.kernel), this.kernel.events.emit("plugin_loaded", {
+        name: e.name,
+        version: e.version
       });
-    } catch (e) {
-      throw console.error(`[PluginRegistry] Failed to initialize plugin "${t.name}":`, e), this._plugins.delete(t.name), this._loadOrder.pop(), e;
+    } catch (t) {
+      throw console.error(`[PluginRegistry] Failed to initialize plugin "${e.name}":`, t), this._plugins.delete(e.name), this._loadOrder.pop(), t;
     }
     return this;
   }
@@ -992,21 +1228,21 @@ class A {
    * @param {Object} plugin - Plugin instance with async init
    * @returns {Promise<PluginRegistry>} - For chaining
    */
-  async useAsync(t) {
-    if (!t.name)
+  async useAsync(e) {
+    if (!e.name)
       throw new Error("[PluginRegistry] Plugin must have a name");
-    if (this._plugins.has(t.name))
-      return console.warn(`[PluginRegistry] Plugin "${t.name}" already registered. Skipping.`), this;
-    if (!t.init || typeof t.init != "function")
-      throw new Error(`[PluginRegistry] Plugin "${t.name}" must have an init() method`);
-    this._plugins.set(t.name, t), this._loadOrder.push(t.name);
+    if (this._plugins.has(e.name))
+      return console.warn(`[PluginRegistry] Plugin "${e.name}" already registered. Skipping.`), this;
+    if (!e.init || typeof e.init != "function")
+      throw new Error(`[PluginRegistry] Plugin "${e.name}" must have an init() method`);
+    this._plugins.set(e.name, e), this._loadOrder.push(e.name);
     try {
-      await t.init(this.kernel), this.kernel.events.emit("plugin_loaded", {
-        name: t.name,
-        version: t.version
+      await e.init(this.kernel), this.kernel.events.emit("plugin_loaded", {
+        name: e.name,
+        version: e.version
       });
-    } catch (e) {
-      throw console.error(`[PluginRegistry] Failed to initialize plugin "${t.name}":`, e), this._plugins.delete(t.name), this._loadOrder.pop(), e;
+    } catch (t) {
+      throw console.error(`[PluginRegistry] Failed to initialize plugin "${e.name}":`, t), this._plugins.delete(e.name), this._loadOrder.pop(), t;
     }
     return this;
   }
@@ -1015,35 +1251,35 @@ class A {
    * @param {string} name - Plugin name
    * @returns {boolean} - True if plugin was found and removed
    */
-  remove(t) {
-    const e = this._plugins.get(t);
-    if (!e)
+  remove(e) {
+    const t = this._plugins.get(e);
+    if (!t)
       return !1;
-    if (e.destroy)
+    if (t.destroy)
       try {
-        e.destroy();
+        t.destroy();
       } catch (i) {
-        console.error(`[PluginRegistry] Error destroying plugin "${t}":`, i);
+        console.error(`[PluginRegistry] Error destroying plugin "${e}":`, i);
       }
-    this._plugins.delete(t);
-    const s = this._loadOrder.indexOf(t);
-    return s > -1 && this._loadOrder.splice(s, 1), this.kernel.events.emit("plugin_unloaded", { name: t }), !0;
+    this._plugins.delete(e);
+    const s = this._loadOrder.indexOf(e);
+    return s > -1 && this._loadOrder.splice(s, 1), this.kernel.events.emit("plugin_unloaded", { name: e }), !0;
   }
   /**
    * Get a plugin by name
    * @param {string} name - Plugin name
    * @returns {Object|undefined} - Plugin instance
    */
-  get(t) {
-    return this._plugins.get(t);
+  get(e) {
+    return this._plugins.get(e);
   }
   /**
    * Check if a plugin is registered
    * @param {string} name - Plugin name
    * @returns {boolean}
    */
-  has(t) {
-    return this._plugins.has(t);
+  has(e) {
+    return this._plugins.has(e);
   }
   /**
    * Get all registered plugin names
@@ -1063,13 +1299,13 @@ class A {
    * Clear all plugins (in reverse load order)
    */
   clear() {
-    for (let t = this._loadOrder.length - 1; t >= 0; t--)
-      this.remove(this._loadOrder[t]);
+    for (let e = this._loadOrder.length - 1; e >= 0; e--)
+      this.remove(this._loadOrder[e]);
   }
 }
-class D {
-  constructor(t = {}) {
-    this.width = t.width || 800, this.height = t.height || 600, this.backgroundColor = t.backgroundColor || "#000000", t.canvas ? (this.canvas = t.canvas, this.canvas.width = this.width, this.canvas.height = this.height) : (this.canvas = document.createElement("canvas"), this.canvas.width = this.width, this.canvas.height = this.height, (t.parent ? typeof t.parent == "string" ? document.querySelector(t.parent) : t.parent : document.body).appendChild(this.canvas)), this.ctx = this.canvas.getContext("2d");
+class z {
+  constructor(e = {}) {
+    this.width = e.width || 800, this.height = e.height || 600, this.backgroundColor = e.backgroundColor || "#000000", e.canvas ? (this.canvas = e.canvas, this.canvas.width = this.width, this.canvas.height = this.height) : (this.canvas = document.createElement("canvas"), this.canvas.width = this.width, this.canvas.height = this.height, (e.parent ? typeof e.parent == "string" ? document.querySelector(e.parent) : e.parent : document.body).appendChild(this.canvas)), this.ctx = this.canvas.getContext("2d");
   }
   /**
    * Clear the canvas.
@@ -1077,50 +1313,63 @@ class D {
   clear() {
     this.ctx.fillStyle = this.backgroundColor, this.ctx.fillRect(0, 0, this.width, this.height);
   }
-  resize(t, e) {
-    this.width = t, this.height = e, this.canvas.width = t, this.canvas.height = e;
+  resize(e, t) {
+    this.width = e, this.height = t, this.canvas.width = e, this.canvas.height = t;
   }
 }
-class L {
+class G {
   constructor() {
-    this.running = !1, this.lastTime = 0, this.callbacks = /* @__PURE__ */ new Set(), this._tick = this._tick.bind(this);
+    this.running = !1, this.lastTime = 0, this.callbacks = /* @__PURE__ */ new Set(), this._frameHandle = null, this._tick = this._tick.bind(this);
   }
   /**
    * Add a callback to the loop.
    * @param {Function} callback - Function to call each frame (receives dt).
    */
-  add(t) {
-    this.callbacks.add(t);
+  add(e) {
+    this.callbacks.add(e);
   }
   /**
    * Remove a callback from the loop.
    * @param {Function} callback 
    */
-  remove(t) {
-    this.callbacks.delete(t);
+  remove(e) {
+    this.callbacks.delete(e);
   }
   /**
    * Start the loop.
    */
   start() {
-    this.running || (this.running = !0, this.lastTime = performance.now(), requestAnimationFrame(this._tick));
+    this.running || (this.running = !0, this.lastTime = performance.now(), this._frameHandle !== null && cancelAnimationFrame(this._frameHandle), this._frameHandle = requestAnimationFrame(this._tick));
   }
   /**
    * Stop the loop.
    */
   stop() {
-    this.running = !1;
-  }
-  _tick(t) {
-    if (!this.running) return;
-    const e = (t - this.lastTime) / 1e3;
-    this.lastTime = t;
-    const s = Math.min(e, 0.1);
-    for (const i of this.callbacks)
+    this.running = !1, this._frameHandle !== null && (cancelAnimationFrame(this._frameHandle), this._frameHandle = null);
+  }
+  _tick(e) {
+    if (this._frameHandle = null, !this.running) return;
+    const t = (e - this.lastTime) / 1e3;
+    this.lastTime = e;
+    const s = Math.min(t, 0.1);
+    for (const i of [...this.callbacks])
       i(s);
-    requestAnimationFrame(this._tick);
+    this.running && (this._frameHandle = requestAnimationFrame(this._tick));
   }
 }
+function g(a, e) {
+  let t = !1;
+  return new Proxy(a, {
+    get(s, i, r) {
+      t || (t = !0, console.warn(e));
+      const n = Reflect.get(s, i, r);
+      return typeof n == "function" ? n.bind(s) : n;
+    },
+    set(s, i, r) {
+      return t || (t = !0, console.warn(e)), Reflect.set(s, i, r);
+    }
+  });
+}
 class y {
   constructor() {
     this.gameObject = null, this.kernel = null;
@@ -1129,33 +1378,33 @@ class y {
    * Access systems through kernel (no more globals!)
    */
   get physics() {
-    var t;
-    return (t = this.kernel) == null ? void 0 : t.systems.get("physics");
+    var e;
+    return (e = this.kernel) == null ? void 0 : e.systems.get("physics");
   }
   get input() {
-    var t;
-    return (t = this.kernel) == null ? void 0 : t.systems.get("input");
+    var e;
+    return (e = this.kernel) == null ? void 0 : e.systems.get("input");
   }
   get loader() {
-    var t;
-    return (t = this.kernel) == null ? void 0 : t.systems.get("loader");
+    var e;
+    return (e = this.kernel) == null ? void 0 : e.systems.get("loader");
   }
   get events() {
-    var t;
-    return (t = this.kernel) == null ? void 0 : t.events;
+    var e;
+    return (e = this.kernel) == null ? void 0 : e.events;
   }
   onAttach() {
   }
   onDetach() {
   }
-  update(t) {
+  update(e) {
   }
-  render(t) {
+  render(e) {
   }
 }
-class G extends y {
-  constructor(t = "box", e = 50, s = 50, i = 25) {
-    super(), this.type = t, this.width = e, this.height = s, this.radius = i, this.tag = null;
+class $ extends y {
+  constructor(e = "box", t = 50, s = 50, i = 25) {
+    super(), this.type = e, this.width = t, this.height = s, this.radius = i, this.tag = null;
   }
   onAttach() {
     super.onAttach(), this.physics && this.physics.add(this);
@@ -1164,36 +1413,36 @@ class G extends y {
     super.onDetach(), this.physics && this.physics.remove(this);
   }
   getBounds() {
-    const t = this.gameObject;
+    const e = this.gameObject;
     if (this.type === "box")
       return {
-        left: t.x - this.width / 2,
-        right: t.x + this.width / 2,
-        top: t.y - this.height / 2,
-        bottom: t.y + this.height / 2
+        left: e.x - this.width / 2,
+        right: e.x + this.width / 2,
+        top: e.y - this.height / 2,
+        bottom: e.y + this.height / 2
       };
     if (this.type === "circle")
       return {
-        x: t.x,
-        y: t.y,
+        x: e.x,
+        y: e.y,
         radius: this.radius
       };
   }
 }
-class _ {
+class M {
   constructor() {
     this.colliders = [], this.kernel = null;
   }
   /**
    * ISystem interface - called when registered
    */
-  init(t) {
-    this.kernel = t;
+  init(e) {
+    this.kernel = e;
   }
   /**
    * ISystem interface - called at fixed timestep
    */
-  fixedUpdate(t) {
+  fixedUpdate(e) {
     this.step();
   }
   /**
@@ -1202,27 +1451,27 @@ class _ {
   destroy() {
     this.colliders = [];
   }
-  add(t) {
-    this.colliders.push(t);
+  add(e) {
+    this.colliders.push(e);
   }
-  remove(t) {
-    const e = this.colliders.indexOf(t);
-    e > -1 && this.colliders.splice(e, 1);
+  remove(e) {
+    const t = this.colliders.indexOf(e);
+    t > -1 && this.colliders.splice(t, 1);
   }
   /**
    * Main Physics Step.
    * Checks all pairs and triggers callbacks.
    */
   step() {
-    for (let t = 0; t < this.colliders.length; t++)
-      for (let e = t + 1; e < this.colliders.length; e++) {
-        const s = this.colliders[t], i = this.colliders[e];
+    for (let e = 0; e < this.colliders.length; e++)
+      for (let t = e + 1; t < this.colliders.length; t++) {
+        const s = this.colliders[e], i = this.colliders[t];
         this._intersects(s, s.getBounds(), i, i.getBounds()) && (this._notifyCollision(s.gameObject, i.gameObject), this._notifyCollision(i.gameObject, s.gameObject));
       }
   }
-  _notifyCollision(t, e) {
-    !t || !t.components || t.components.forEach((s) => {
-      s.onCollisionEnter && s.onCollisionEnter(e);
+  _notifyCollision(e, t) {
+    !e || !e.components || e.components.forEach((s) => {
+      s.onCollisionEnter && s.onCollisionEnter(t);
     });
   }
   /**
@@ -1230,51 +1479,53 @@ class _ {
    * @param {Collider} source 
    * @param {string} targetTag 
    */
-  checkOverlap(t, e) {
-    const s = [], i = t.getBounds();
+  checkOverlap(e, t) {
+    const s = [], i = e.getBounds();
     for (const r of this.colliders) {
-      if (r === t || e && r.tag !== e) continue;
+      if (r === e || t && r.tag !== t) continue;
       const n = r.getBounds();
-      this._intersects(t, i, r, n) && s.push(r);
+      this._intersects(e, i, r, n) && s.push(r);
     }
     return s;
   }
-  _intersects(t, e, s, i) {
-    if (t.type === "box" && s.type === "box")
-      return e.left < i.right && e.right > i.left && e.top < i.bottom && e.bottom > i.top;
-    if (t.type === "circle" && s.type === "circle") {
-      const r = e.x - i.x, n = e.y - i.y;
-      return Math.sqrt(r * r + n * n) < e.radius + i.radius;
+  _intersects(e, t, s, i) {
+    if (e.type === "box" && s.type === "box")
+      return t.left < i.right && t.right > i.left && t.top < i.bottom && t.bottom > i.top;
+    if (e.type === "circle" && s.type === "circle") {
+      const r = t.x - i.x, n = t.y - i.y;
+      return Math.sqrt(r * r + n * n) < t.radius + i.radius;
     }
     return !1;
   }
   // IPhysicsSystem interface methods (for plugin compatibility)
-  addBody(t) {
-    this.add(t);
+  addBody(e) {
+    this.add(e);
   }
-  removeBody(t) {
-    this.remove(t);
+  removeBody(e) {
+    this.remove(e);
   }
-  checkCollision(t, e) {
-    return this._intersects(t, t.getBounds(), e, e.getBounds());
+  checkCollision(e, t) {
+    return this._intersects(e, e.getBounds(), t, t.getBounds());
   }
-  raycast(t, e, s) {
+  raycast(e, t, s) {
     return null;
   }
-  setGravity(t, e) {
+  setGravity(e, t) {
   }
 }
-const $ = new _();
-console.warn("[DopamineJS] GlobalPhysics is deprecated. Use kernel.physics instead.");
-class k {
+const q = g(
+  new M(),
+  "[DopamineJS] GlobalPhysics is deprecated. Use kernel.physics instead."
+);
+class E {
   constructor() {
     this.keys = /* @__PURE__ */ new Map(), this.mouse = { x: 0, y: 0, buttons: /* @__PURE__ */ new Map() }, this.kernel = null, this._onKeyDown = this._onKeyDown.bind(this), this._onKeyUp = this._onKeyUp.bind(this), this._onMouseMove = this._onMouseMove.bind(this), this._onMouseDown = this._onMouseDown.bind(this), this._onMouseUp = this._onMouseUp.bind(this);
   }
   /**
    * ISystem interface - called when registered
    */
-  init(t) {
-    this.kernel = t, window.addEventListener("keydown", this._onKeyDown), window.addEventListener("keyup", this._onKeyUp), window.addEventListener("mousemove", this._onMouseMove), window.addEventListener("mousedown", this._onMouseDown), window.addEventListener("mouseup", this._onMouseUp);
+  init(e) {
+    this.kernel = e, window.addEventListener("keydown", this._onKeyDown), window.addEventListener("keyup", this._onKeyUp), window.addEventListener("mousemove", this._onMouseMove), window.addEventListener("mousedown", this._onMouseDown), window.addEventListener("mouseup", this._onMouseUp);
   }
   /**
    * ISystem interface - cleanup
@@ -1282,39 +1533,41 @@ class k {
   destroy() {
     window.removeEventListener("keydown", this._onKeyDown), window.removeEventListener("keyup", this._onKeyUp), window.removeEventListener("mousemove", this._onMouseMove), window.removeEventListener("mousedown", this._onMouseDown), window.removeEventListener("mouseup", this._onMouseUp);
   }
-  _onKeyDown(t) {
-    this.keys.set(t.key, !0);
+  _onKeyDown(e) {
+    this.keys.set(e.key, !0);
   }
-  _onKeyUp(t) {
-    this.keys.set(t.key, !1);
+  _onKeyUp(e) {
+    this.keys.set(e.key, !1);
   }
-  _onMouseMove(t) {
-    this.mouse.x = t.clientX, this.mouse.y = t.clientY;
+  _onMouseMove(e) {
+    this.mouse.x = e.clientX, this.mouse.y = e.clientY;
   }
-  _onMouseDown(t) {
-    this.mouse.buttons.set(t.button, !0);
+  _onMouseDown(e) {
+    this.mouse.buttons.set(e.button, !0);
   }
-  _onMouseUp(t) {
-    this.mouse.buttons.set(t.button, !1);
+  _onMouseUp(e) {
+    this.mouse.buttons.set(e.button, !1);
   }
-  isKeyDown(t) {
-    return this.keys.get(t) || !1;
+  isKeyDown(e) {
+    return this.keys.get(e) || !1;
   }
-  isMouseButtonDown(t = 0) {
-    return this.mouse.buttons.get(t) || !1;
+  isMouseButtonDown(e = 0) {
+    return this.mouse.buttons.get(e) || !1;
   }
 }
-const F = new k();
-console.warn("[DopamineJS] GlobalInput is deprecated. Use kernel.input instead.");
-class S {
+const K = g(
+  new E(),
+  "[DopamineJS] GlobalInput is deprecated. Use kernel.input instead."
+);
+class P {
   constructor() {
     this.assets = /* @__PURE__ */ new Map(), this.kernel = null;
   }
   /**
    * ISystem interface - called when registered
    */
-  init(t) {
-    this.kernel = t;
+  init(e) {
+    this.kernel = e;
   }
   /**
    * ISystem interface - cleanup
@@ -1322,47 +1575,49 @@ class S {
   destroy() {
     this.assets.clear();
   }
-  async loadImage(t, e) {
+  async loadImage(e, t) {
     return new Promise((s, i) => {
       const r = new Image();
       r.onload = () => {
-        this.assets.set(t, r), s(r);
-      }, r.onerror = i, r.src = e;
+        this.assets.set(e, r), s(r);
+      }, r.onerror = i, r.src = t;
     });
   }
-  get(t) {
-    return this.assets.get(t);
+  get(e) {
+    return this.assets.get(e);
   }
 }
-const N = new S();
-console.warn("[DopamineJS] GlobalLoader is deprecated. Use kernel.loader instead.");
-class U {
-  constructor(t = {}) {
-    this.config = t, this.events = new p(), this.systems = new O(this), this.plugins = new A(this), this._registerCoreSystems(t), this.fixedTimestep = t.fixedTimestep || 1 / 60, this._accumulator = 0, this._maxAccumulator = this.fixedTimestep * 5;
+const X = g(
+  new P(),
+  "[DopamineJS] GlobalLoader is deprecated. Use kernel.loader instead."
+);
+class B {
+  constructor(e = {}) {
+    this.config = e, this._boundUpdate = this._update.bind(this), this.events = new p(), this.systems = new U(this), this.plugins = new R(this), this._registerCoreSystems(e), this.fixedTimestep = e.fixedTimestep || 1 / 60, this._accumulator = 0, this._maxAccumulator = this.fixedTimestep * 5;
   }
   /**
    * Register core engine systems
    * These can be replaced by plugins
    * @private
    */
-  _registerCoreSystems(t) {
-    this.systems.register("ticker", new L(), {
+  _registerCoreSystems(e) {
+    this.systems.register("ticker", new G(), {
       priority: 100
     });
-    const e = {
-      width: t.width,
-      height: t.height,
-      backgroundColor: t.backgroundColor,
-      canvas: t.canvas,
-      ...t.renderer
+    const t = {
+      width: e.width,
+      height: e.height,
+      backgroundColor: e.backgroundColor,
+      canvas: e.canvas,
+      ...e.renderer
     };
-    this.systems.register("renderer", new D(e), {
+    this.systems.register("renderer", new z(t), {
       priority: 90
-    }), this.systems.register("input", new k(), {
+    }), this.systems.register("input", new E(), {
       priority: 80
-    }), this.systems.register("loader", new S(), {
+    }), this.systems.register("loader", new P(), {
       priority: 70
-    }), this.systems.register("physics", new _(), {
+    }), this.systems.register("physics", new M(), {
       priority: 60
     });
   }
@@ -1370,24 +1625,24 @@ class U {
    * Start the kernel (begins game loop)
    */
   start() {
-    const t = this.systems.get("ticker");
-    t && (t.add(this._update.bind(this)), t.start()), this.events.emit("kernel_started");
+    const e = this.systems.get("ticker");
+    e && (e.add(this._boundUpdate), e.start()), this.events.emit("kernel_started");
   }
   /**
    * Stop the kernel
    */
   stop() {
-    const t = this.systems.get("ticker");
-    t && t.stop(), this.events.emit("kernel_stopped");
+    const e = this.systems.get("ticker");
+    e && e.stop(), this.events.emit("kernel_stopped");
   }
   /**
    * Main update loop
    * @private
    */
-  _update(t) {
-    for (this.events.emit(p.Events.TICK, { dt: t }), this._accumulator += t, this._accumulator > this._maxAccumulator && (this._accumulator = this._maxAccumulator); this._accumulator >= this.fixedTimestep; )
+  _update(e) {
+    for (this.events.emit(p.Events.TICK, { dt: e }), this._accumulator += e, this._accumulator > this._maxAccumulator && (this._accumulator = this._maxAccumulator); this._accumulator >= this.fixedTimestep; )
       this.events.emit(p.Events.FIXED_UPDATE, { dt: this.fixedTimestep }), this.systems.fixedUpdate(this.fixedTimestep), this._accumulator -= this.fixedTimestep;
-    this.systems.update(t), this.events.emit(p.Events.RENDER, { dt: t });
+    this.systems.update(e), this.events.emit(p.Events.RENDER, { dt: e });
   }
   /**
    * Shorthand accessors for common systems (backward compatibility)
@@ -1411,10 +1666,12 @@ class U {
    * Destroy the kernel and cleanup all systems
    */
   destroy() {
-    this.stop(), this.plugins.clear(), this.systems.clear(), this.events.clear();
+    this.stop();
+    const e = this.systems.get("ticker");
+    e && e.remove(this._boundUpdate), this.plugins.clear(), this.systems.clear(), this.events.clear();
   }
 }
-const g = {
+const _ = {
   /**
    * Called when system is registered to the kernel
    * @param {DopamineKernel} kernel - The kernel instance
@@ -1439,22 +1696,22 @@ const g = {
   destroy() {
   }
 };
-class K {
+class J {
   constructor() {
     this.kernel = null;
   }
-  init(t) {
-    this.kernel = t;
+  init(e) {
+    this.kernel = e;
   }
-  update(t) {
+  update(e) {
   }
-  fixedUpdate(t) {
+  fixedUpdate(e) {
   }
   destroy() {
   }
 }
-const X = {
-  ...g,
+const W = {
+  ..._,
   /**
    * Add a physics body to the simulation
    * @param {Object} body - Physics body (implementation-specific)
@@ -1473,7 +1730,7 @@ const X = {
    * @param {Object} b - Second body
    * @returns {boolean} - True if colliding
    */
-  checkCollision(a, t) {
+  checkCollision(a, e) {
   },
   /**
    * Perform a raycast
@@ -1482,14 +1739,14 @@ const X = {
    * @param {number} distance - Maximum ray distance
    * @returns {Object|null} - Hit result or null
    */
-  raycast(a, t, e) {
+  raycast(a, e, t) {
   },
   /**
    * Set gravity for the physics world
    * @param {number} x - Gravity X component
    * @param {number} y - Gravity Y component
    */
-  setGravity(a, t) {
+  setGravity(a, e) {
   },
   /**
    * Step the physics simulation
@@ -1497,14 +1754,14 @@ const X = {
    */
   step(a) {
   }
-}, H = {
-  ...g,
+}, Y = {
+  ..._,
   /**
    * Register a sound with a key
    * @param {string} key - Sound identifier
    * @param {string} url - Path to audio file
    */
-  registerSound(a, t) {
+  registerSound(a, e) {
   },
   /**
    * Preload multiple sounds
@@ -1518,7 +1775,7 @@ const X = {
    * @param {string} key - Sound identifier
    * @param {Object} options - Playback options (volume, loop, etc.)
    */
-  play(a, t) {
+  play(a, e) {
   },
   /**
    * Play a synthesized tone
@@ -1527,7 +1784,7 @@ const X = {
    * @param {string} type - Waveform type ('sine', 'square', etc.)
    * @param {number} volume - Volume (0-1)
    */
-  playTone(a, t, e, s) {
+  playTone(a, e, t, s) {
   },
   /**
    * Stop a playing sound
@@ -1547,21 +1804,21 @@ const X = {
    */
   setVolume(a) {
   }
-}, q = {
-  ...g,
+}, V = {
+  ..._,
   /**
    * Register a sprite for particles
    * @param {string} key - Sprite identifier
    * @param {string} url - Path to image
    */
-  registerSprite(a, t) {
+  registerSprite(a, e) {
   },
   /**
    * Register a custom effect
    * @param {string} name - Effect name
    * @param {Function} callback - Effect function (x, y, ...args) => void
    */
-  registerEffect(a, t) {
+  registerEffect(a, e) {
   },
   /**
    * Play a registered effect
@@ -1570,7 +1827,7 @@ const X = {
    * @param {number} y - Y position
    * @param {...any} args - Additional arguments
    */
-  play(a, t, e, ...s) {
+  play(a, e, t, ...s) {
   },
   /**
    * Emit particles with custom configuration
@@ -1584,18 +1841,18 @@ const X = {
   clear() {
   },
   // Built-in effects (optional, but recommended)
-  confetti(a, t, e) {
+  confetti(a, e, t) {
   },
-  coinShower(a, t, e) {
+  coinShower(a, e, t) {
   },
-  sparkle(a, t, e, s) {
+  sparkle(a, e, t, s) {
   },
-  fire(a, t, e) {
+  fire(a, e, t) {
   },
-  starBurst(a, t, e) {
+  starBurst(a, e, t) {
   }
 };
-class W {
+class Q {
   constructor() {
     this.gameObjects = [], this.kernel = null;
   }
@@ -1613,49 +1870,49 @@ class W {
    * Add a GameObject to the scene.
    * @param {GameObject} gameObject 
    */
-  add(t) {
-    return this.kernel && (t.kernel = this.kernel), this.gameObjects.push(t), t;
+  add(e) {
+    return this.kernel && (e.kernel = this.kernel), this.gameObjects.push(e), e;
   }
   /**
    * Remove a GameObject from the scene.
    * @param {GameObject} gameObject 
    */
-  remove(t) {
-    const e = this.gameObjects.indexOf(t);
-    e > -1 && this.gameObjects.splice(e, 1);
+  remove(e) {
+    const t = this.gameObjects.indexOf(e);
+    t > -1 && this.gameObjects.splice(t, 1);
   }
   /**
    * Update loop for the scene.
    * @param {number} dt 
    */
-  update(t) {
-    for (const e of this.gameObjects)
-      e.update(t);
+  update(e) {
+    for (const t of this.gameObjects)
+      t.update(e);
   }
   /**
    * Render loop for the scene.
    * @param {CanvasRenderingContext2D} ctx 
    */
-  render(t) {
-    for (const e of this.gameObjects)
-      e.render(t);
+  render(e) {
+    for (const t of this.gameObjects)
+      t.render(e);
   }
 }
-class R {
-  constructor(t) {
-    this.game = t, this.currentScene = null;
+class j {
+  constructor(e) {
+    this.game = e, this.currentScene = null;
   }
   /**
    * Switch to a new scene.
    * @param {Scene} scene 
    */
-  run(t) {
-    this.currentScene && this.currentScene.onExit(), this.currentScene = t, this.currentScene.game = this.game, this.game.scene = t, t.onEnter();
+  run(e) {
+    this.currentScene && this.currentScene.onExit(), this.currentScene = e, this.currentScene.game = this.game, this.game.scene = e, e.onEnter();
   }
 }
-class J {
-  constructor(t = {}) {
-    this.config = t, this.kernel = new U(t), this.director = new R(this), this.kernel.systems.register("director", this.director), this.kernel.events.on(p.Events.TICK, this._update.bind(this), 10), this.kernel.events.on(p.Events.RENDER, this._render.bind(this), 10);
+class Z {
+  constructor(e = {}) {
+    this.config = e, this.kernel = new B(e), this.director = new j(this), this.kernel.systems.register("director", this.director), this.kernel.events.on(p.Events.TICK, this._update.bind(this), 10), this.kernel.events.on(p.Events.RENDER, this._render.bind(this), 10);
   }
   /**
    * Backward compatibility accessors
@@ -1688,13 +1945,13 @@ class J {
    * Switch to a new scene.
    * @param {Scene} newScene 
    */
-  setScene(t) {
-    t.kernel = this.kernel, this.director.run(t);
+  setScene(e) {
+    e.kernel = this.kernel, this.director.run(e);
   }
-  _update({ dt: t }) {
-    this.director.currentScene && this.director.currentScene.update(t);
+  _update({ dt: e }) {
+    this.director.currentScene && this.director.currentScene.update(e);
   }
-  _render({ dt: t }) {
+  _render({ dt: e }) {
     this.renderer.clear(), this.director.currentScene && this.director.currentScene.render(this.renderer.ctx);
   }
   /**
@@ -1704,188 +1961,188 @@ class J {
     this.kernel.destroy();
   }
 }
-class Y {
-  constructor(t = 0, e = 0) {
-    this.x = t, this.y = e, this.rotation = 0, this.scale = { x: 1, y: 1 }, this.components = [], this.children = [], this.parent = null, this._kernel = null;
+class ee {
+  constructor(e = 0, t = 0) {
+    this.x = e, this.y = t, this.rotation = 0, this.scale = { x: 1, y: 1 }, this.components = [], this.children = [], this.parent = null, this._kernel = null;
   }
   get kernel() {
     return this._kernel;
   }
-  set kernel(t) {
-    this._kernel = t;
-    for (const e of this.components)
-      e.kernel = t;
-    for (const e of this.children)
-      e.kernel = t;
+  set kernel(e) {
+    this._kernel = e;
+    for (const t of this.components)
+      t.kernel = e;
+    for (const t of this.children)
+      t.kernel = e;
   }
   /**
    * Add a child object.
    * @param {GameObject} child 
    */
-  addChild(t) {
-    return t.parent = this, t.kernel = this.kernel, this.children.push(t), t;
+  addChild(e) {
+    return e.parent = this, e.kernel = this.kernel, this.children.push(e), e;
   }
   /**
    * Add a component.
    * @param {Component} component 
    */
-  addComponent(t) {
-    return t.gameObject = this, t.kernel = this.kernel, this.components.push(t), t.onAttach(), t;
+  addComponent(e) {
+    return e.gameObject = this, e.kernel = this.kernel, this.components.push(e), e.onAttach(), e;
   }
   /**
    * Get a component by class type.
    * @param {class} type 
    */
-  getComponent(t) {
-    return this.components.find((e) => e instanceof t);
+  getComponent(e) {
+    return this.components.find((t) => t instanceof e);
   }
-  update(t) {
-    for (const e of this.components)
-      e.update && e.update(t);
-    for (const e of this.children)
-      e.update(t);
+  update(e) {
+    for (const t of this.components)
+      t.update && t.update(e);
+    for (const t of this.children)
+      t.update(e);
   }
-  render(t) {
-    t.save(), t.translate(this.x, this.y), t.rotate(this.rotation), t.scale(this.scale.x, this.scale.y);
-    for (const e of this.components)
-      e.render && e.render(t);
-    for (const e of this.children)
-      e.render(t);
-    t.restore();
+  render(e) {
+    e.save(), e.translate(this.x, this.y), e.rotate(this.rotation), e.scale(this.scale.x, this.scale.y);
+    for (const t of this.components)
+      t.render && t.render(e);
+    for (const t of this.children)
+      t.render(e);
+    e.restore();
   }
 }
-class b {
-  constructor(t = 0, e = 0) {
-    this.x = t, this.y = e;
+class C {
+  constructor(e = 0, t = 0) {
+    this.x = e, this.y = t;
   }
-  add(t) {
-    return this.x += t.x, this.y += t.y, this;
+  add(e) {
+    return this.x += e.x, this.y += e.y, this;
   }
-  sub(t) {
-    return this.x -= t.x, this.y -= t.y, this;
+  sub(e) {
+    return this.x -= e.x, this.y -= e.y, this;
   }
-  scale(t) {
-    return this.x *= t, this.y *= t, this;
+  scale(e) {
+    return this.x *= e, this.y *= e, this;
   }
-  distance(t) {
-    const e = this.x - t.x, s = this.y - t.y;
-    return Math.sqrt(e * e + s * s);
+  distance(e) {
+    const t = this.x - e.x, s = this.y - e.y;
+    return Math.sqrt(t * t + s * s);
   }
   normalize() {
-    const t = Math.sqrt(this.x * this.x + this.y * this.y);
-    return t > 0 && (this.x /= t, this.y /= t), this;
+    const e = Math.sqrt(this.x * this.x + this.y * this.y);
+    return e > 0 && (this.x /= e, this.y /= e), this;
   }
   clone() {
-    return new b(this.x, this.y);
+    return new C(this.x, this.y);
   }
-  static distance(t, e) {
-    return Math.sqrt(Math.pow(e.x - t.x, 2) + Math.pow(e.y - t.y, 2));
+  static distance(e, t) {
+    return Math.sqrt(Math.pow(t.x - e.x, 2) + Math.pow(t.y - e.y, 2));
   }
 }
-class j extends y {
-  constructor(t) {
-    super(), this.image = t, this.anchor = { x: 0.5, y: 0.5 }, this.width = t ? t.width : 0, this.height = t ? t.height : 0, this.frame = { x: 0, y: 0, w: this.width, h: this.height };
+class F extends y {
+  constructor(e) {
+    super(), this.image = e, this.anchor = { x: 0.5, y: 0.5 }, this.width = e ? e.width : 0, this.height = e ? e.height : 0, this.frame = { x: 0, y: 0, w: this.width, h: this.height };
   }
-  setFrame(t, e, s, i) {
-    this.frame = { x: t, y: e, w: s, h: i }, this.width = s, this.height = i;
+  setFrame(e, t, s, i) {
+    this.frame = { x: e, y: t, w: s, h: i }, this.width = s, this.height = i;
   }
-  setTexture(t) {
-    this.image = t, t && this.setFrame(0, 0, t.width, t.height);
+  setTexture(e) {
+    this.image = e, e && this.setFrame(0, 0, e.width, e.height);
   }
-  render(t) {
+  render(e) {
     if (!this.image) return;
-    const e = this.frame.w, s = this.frame.h, i = -e * this.anchor.x, r = -s * this.anchor.y;
-    t.drawImage(
+    const t = this.frame.w, s = this.frame.h, i = -t * this.anchor.x, r = -s * this.anchor.y;
+    e.drawImage(
       this.image,
       this.frame.x,
       this.frame.y,
-      e,
+      t,
       s,
       // Source
       i,
       r,
-      e,
+      t,
       s
       // Destination
     );
   }
 }
-class V extends y {
+class te extends y {
   constructor() {
     super(), this.animations = {}, this.currentAnim = null, this.timer = 0, this.currentFrameIndex = 0, this.sprite = null;
   }
   onAttach() {
-    this.sprite = this.gameObject.getComponent(j), this.sprite || console.warn("Animator attached to GameObject without a Sprite component.");
+    this.sprite = this.gameObject.getComponent(F), this.sprite || console.warn("Animator attached to GameObject without a Sprite component.");
   }
-  addAnimation(t, e, s = 10, i = !0) {
-    this.animations[t] = { frames: e, fps: s, loop: i };
+  addAnimation(e, t, s = 10, i = !0) {
+    this.animations[e] = { frames: t, fps: s, loop: i };
   }
-  play(t) {
-    this.currentAnim && this.currentAnim.name === t || this.animations[t] && (this.currentAnim = { name: t, ...this.animations[t] }, this.currentFrameIndex = 0, this.timer = 0, this._updateFrame());
+  play(e) {
+    this.currentAnim && this.currentAnim.name === e || this.animations[e] && (this.currentAnim = { name: e, ...this.animations[e] }, this.currentFrameIndex = 0, this.timer = 0, this._updateFrame());
   }
-  update(t) {
+  update(e) {
     if (!this.currentAnim || !this.sprite) return;
-    this.timer += t;
-    const e = 1 / this.currentAnim.fps;
-    this.timer >= e && (this.timer -= e, this.currentFrameIndex++, this.currentFrameIndex >= this.currentAnim.frames.length && (this.currentAnim.loop ? this.currentFrameIndex = 0 : this.currentFrameIndex = this.currentAnim.frames.length - 1), this._updateFrame());
+    this.timer += e;
+    const t = 1 / this.currentAnim.fps;
+    this.timer >= t && (this.timer -= t, this.currentFrameIndex++, this.currentFrameIndex >= this.currentAnim.frames.length && (this.currentAnim.loop ? this.currentFrameIndex = 0 : this.currentFrameIndex = this.currentAnim.frames.length - 1), this._updateFrame());
   }
   _updateFrame() {
-    const t = this.currentAnim.frames[this.currentFrameIndex];
-    this.sprite.setFrame(t.x, t.y, t.w, t.h);
+    const e = this.currentAnim.frames[this.currentFrameIndex];
+    this.sprite.setFrame(e.x, e.y, e.w, e.h);
   }
 }
-class Q {
-  static createGround(t, e, s = "#333") {
+class se {
+  static createGround(e, t, s = "#333") {
     const i = document.createElement("canvas");
-    i.width = t, i.height = e;
+    i.width = e, i.height = t;
     const r = i.getContext("2d");
-    r.fillStyle = s, r.fillRect(0, 0, t, e);
+    r.fillStyle = s, r.fillRect(0, 0, e, t);
     for (let n = 0; n < 1e3; n++) {
       r.fillStyle = Math.random() > 0.5 ? "#444" : "#222";
       const o = Math.random() * 4 + 2;
-      r.fillRect(Math.random() * t, Math.random() * e, o, o);
+      r.fillRect(Math.random() * e, Math.random() * t, o, o);
     }
     r.strokeStyle = "rgba(255,255,255,0.05)", r.lineWidth = 2, r.beginPath();
-    for (let n = 0; n <= t; n += 64)
-      r.moveTo(n, 0), r.lineTo(n, e);
     for (let n = 0; n <= e; n += 64)
-      r.moveTo(0, n), r.lineTo(t, n);
+      r.moveTo(n, 0), r.lineTo(n, t);
+    for (let n = 0; n <= t; n += 64)
+      r.moveTo(0, n), r.lineTo(e, n);
     return r.stroke(), i;
   }
-  static createCharacterSheet(t, e) {
+  static createCharacterSheet(e, t) {
     const r = document.createElement("canvas");
     r.width = 64 * 4, r.height = 64;
     const n = r.getContext("2d");
     for (let o = 0; o < 4; o++) {
-      const h = o * 64, c = 0, d = h + 64 / 2, u = c + 64 / 2, m = o % 2 === 0 ? 0 : -2, f = o === 1 ? 5 : o === 3 ? -5 : 0;
-      n.fillStyle = t, n.beginPath(), n.arc(d, u + m, 20, 0, Math.PI * 2), n.fill(), n.fillStyle = e, n.beginPath(), n.arc(d - 15, u + m + f, 8, 0, Math.PI * 2), n.arc(d + 15, u + m - f, 8, 0, Math.PI * 2), n.fill(), n.fillStyle = z(t), n.beginPath(), n.arc(d, u + m, 15, 0, Math.PI * 2), n.fill(), e === "#333" && (n.fillStyle = "#000", n.fillRect(d + 10, u + m - 5, 25, 6));
+      const c = o * 64, h = 0, l = c + 64 / 2, u = h + 64 / 2, m = o % 2 === 0 ? 0 : -2, f = o === 1 ? 5 : o === 3 ? -5 : 0;
+      n.fillStyle = e, n.beginPath(), n.arc(l, u + m, 20, 0, Math.PI * 2), n.fill(), n.fillStyle = t, n.beginPath(), n.arc(l - 15, u + m + f, 8, 0, Math.PI * 2), n.arc(l + 15, u + m - f, 8, 0, Math.PI * 2), n.fill(), n.fillStyle = N(e), n.beginPath(), n.arc(l, u + m, 15, 0, Math.PI * 2), n.fill(), t === "#333" && (n.fillStyle = "#000", n.fillRect(l + 10, u + m - 5, 25, 6));
     }
     return r;
   }
 }
-function z(a, t) {
+function N(a, e) {
   return a;
 }
-class Z extends y {
-  constructor(t) {
-    super(), this.system = t;
+class ie extends y {
+  constructor(e) {
+    super(), this.system = e;
   }
   /**
    * Trigger an effect at the GameObject's current position.
    * @param {string} effectName - 'confetti', 'fire', 'sparkle', etc.
    * @param {object} options - override options
    */
-  play(t, e = {}) {
+  play(e, t = {}) {
     const s = this.gameObject.x, i = this.gameObject.y;
-    switch (t) {
+    switch (e) {
       case "confetti":
-        this.system.confetti(s, i, e.count);
+        this.system.confetti(s, i, t.count);
         break;
       case "fire":
-        this.system.fire(s, i, e.count);
+        this.system.fire(s, i, t.count);
         break;
       case "sparkle":
-        this.system.sparkle(s, i, e.count, e.color);
+        this.system.sparkle(s, i, t.count, t.color);
         break;
       case "blood":
         this.system.emit({
@@ -1902,62 +2159,65 @@ class Z extends y {
         this.system.emit({
           x: s,
           y: i,
-          ...e
+          ...t
         });
     }
   }
 }
-class tt extends y {
+class re extends y {
   constructor() {
     super(), this.intensity = 0, this.duration = 0, this.timer = 0, this.originalPos = { x: 0, y: 0 }, this.isShaking = !1;
   }
-  shake(t = 5, e = 0.2) {
-    this.intensity = t, this.duration = e, this.timer = 0, this.isShaking = !0, this.timer === 0 && (this.originalPos.x = this.gameObject.x, this.originalPos.y = this.gameObject.y);
+  shake(e = 5, t = 0.2) {
+    this.intensity = e, this.duration = t, this.timer = 0, this.isShaking = !0, this.timer === 0 && (this.originalPos.x = this.gameObject.x, this.originalPos.y = this.gameObject.y);
   }
-  update(t) {
+  update(e) {
     if (!this.isShaking) return;
-    if (this.timer += t, this.timer >= this.duration) {
+    if (this.timer += e, this.timer >= this.duration) {
       this.isShaking = !1, this.gameObject.x = this.originalPos.x, this.gameObject.y = this.originalPos.y;
       return;
     }
-    const e = (Math.random() - 0.5) * 2 * this.intensity, s = (Math.random() - 0.5) * 2 * this.intensity;
-    this.gameObject.x = this.originalPos.x + e, this.gameObject.y = this.originalPos.y + s;
+    const t = (Math.random() - 0.5) * 2 * this.intensity, s = (Math.random() - 0.5) * 2 * this.intensity;
+    this.gameObject.x = this.originalPos.x + t, this.gameObject.y = this.originalPos.y + s;
   }
 }
 export {
-  V as Animator,
-  G as Collider,
+  te as Animator,
+  $ as Collider,
   y as Component,
-  P as DataService,
-  R as Director,
-  U as DopamineKernel,
+  A as DataService,
+  j as Director,
+  B as DopamineKernel,
   p as EventBus,
-  J as Game,
-  Y as GameObject,
-  C as GameUI,
-  F as GlobalInput,
-  N as GlobalLoader,
-  $ as GlobalPhysics,
-  H as IAudioSystem,
-  q as IParticleSystem,
-  X as IPhysicsSystem,
-  g as ISystem,
-  k as Input,
-  S as Loader,
-  Z as ParticleEmitter,
-  T as ParticleSystem,
-  _ as Physics,
-  A as PluginRegistry,
-  D as Renderer,
-  E as RewardSystem,
-  W as Scene,
-  tt as ScreenShake,
-  I as SoundManager,
-  j as Sprite,
-  K as System,
-  O as SystemRegistry,
-  Q as TextureGenerator,
-  L as Ticker,
-  b as Vector2,
-  B as default
+  D as EventEmitter,
+  Z as Game,
+  ee as GameObject,
+  T as GameUI,
+  K as GlobalInput,
+  X as GlobalLoader,
+  q as GlobalPhysics,
+  Y as IAudioSystem,
+  V as IParticleSystem,
+  W as IPhysicsSystem,
+  _ as ISystem,
+  E as Input,
+  P as Loader,
+  ie as ParticleEmitter,
+  I as ParticleSystem,
+  M as Physics,
+  R as PluginRegistry,
+  z as Renderer,
+  O as RewardSystem,
+  Q as Scene,
+  re as ScreenShake,
+  L as SoundManager,
+  F as Sprite,
+  J as System,
+  U as SystemRegistry,
+  se as TextureGenerator,
+  G as Ticker,
+  C as Vector2,
+  S as createMemoryStorage,
+  H as default,
+  b as resolveStorage
 };