melonjs 19.4.0 → 19.5.0

package/build/index.js

@@ -1,5 +1,5 @@
 /*!
- * melonJS Game Engine - 19.4.0
+ * melonJS Game Engine - 19.5.0
  * http://www.melonjs.org
  * melonjs is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license
@@ -799,11 +799,11 @@ var require_internal_state = __commonJS({
     };
     var getterFor = function(TYPE) {
       return function(it) {
-        var state2;
-        if (!isObject(it) || (state2 = get2(it)).type !== TYPE) {
+        var state3;
+        if (!isObject(it) || (state3 = get2(it)).type !== TYPE) {
           throw new TypeError2("Incompatible receiver, " + TYPE + " required");
         }
-        return state2;
+        return state3;
       };
     };
     if (NATIVE_WEAK_MAP || shared.state) {
@@ -894,9 +894,9 @@ var require_make_built_in = __commonJS({
         } else if (value.prototype) value.prototype = void 0;
       } catch (error) {
       }
-      var state2 = enforceInternalState(value);
-      if (!hasOwn(state2, "source")) {
-        state2.source = join(TEMPLATE, typeof name == "string" ? name : "");
+      var state3 = enforceInternalState(value);
+      if (!hasOwn(state3, "source")) {
+        state3.source = join(TEMPLATE, typeof name == "string" ? name : "");
       }
       return value;
     };
@@ -1819,7 +1819,7 @@ var require_howler = __commonJS({
         }
       };
       var Howler3 = new HowlerGlobal2();
-      var Howl3 = function(o) {
+      var Howl4 = function(o) {
         var self2 = this;
         if (!o.src || o.src.length === 0) {
           console.error("An array of source files must be passed with any new Howl.");
@@ -1827,7 +1827,7 @@ var require_howler = __commonJS({
         }
         self2.init(o);
       };
-      Howl3.prototype = {
+      Howl4.prototype = {
         /**
          * Initialize a new Howl group object.
          * @param  {Object} o Passed in properties for this group.
@@ -3245,23 +3245,23 @@ var require_howler = __commonJS({
         define([], function() {
           return {
             Howler: Howler3,
-            Howl: Howl3
+            Howl: Howl4
           };
         });
       }
       if (typeof exports !== "undefined") {
         exports.Howler = Howler3;
-        exports.Howl = Howl3;
+        exports.Howl = Howl4;
       }
       if (typeof global !== "undefined") {
         global.HowlerGlobal = HowlerGlobal2;
         global.Howler = Howler3;
-        global.Howl = Howl3;
+        global.Howl = Howl4;
         global.Sound = Sound2;
       } else if (typeof window !== "undefined") {
         window.HowlerGlobal = HowlerGlobal2;
         window.Howler = Howler3;
-        window.Howl = Howl3;
+        window.Howl = Howl4;
         window.Sound = Sound2;
       }
     })();
@@ -4853,6 +4853,30 @@ var Bounds = class _Bounds {
       }
     }
   }
+  /**
+   * Expand this bounds to include every shape in `shapes`. Each shape
+   * contributes its own `.getBounds()` (so `Rect`, `Polygon`, `Ellipse`,
+   * `Bounds`, and anything else implementing the same getter all work);
+   * shapes without `.getBounds()` are silently ignored. Use `clear=true`
+   * to compute a fresh union (matches the `add` / `addBounds` shape).
+   *
+   * Useful for sizing a renderable from its `bodyDef.shapes` before
+   * the underlying physics body has been constructed — used by the
+   * TMX shape factory and {@link Trigger}.
+   * @param shapes - one shape or an iterable of shapes
+   * @param [clear] - reset the bounds before unioning
+   */
+  addShapes(shapes, clear = false) {
+    if (clear) {
+      this.clear();
+    }
+    const iterable = typeof shapes[Symbol.iterator] === "function" ? shapes : [shapes];
+    for (const s of iterable) {
+      if (typeof s?.getBounds === "function") {
+        this.addBounds(s.getBounds());
+      }
+    }
+  }
   /**
    * Adds the given point to the bounds definition.
    * @param point - The point to add to the bounds.
@@ -4977,18 +5001,6 @@ var Bounds = class _Bounds {
     bounds.addBounds(this);
     return bounds;
   }
-  /**
-   * Returns a polygon whose edges are the same as this bounds.
-   * @returns A new Polygon that represents this bounds.
-   */
-  toPolygon() {
-    return polygonPool.get(this.x, this.y, [
-      new Vector2d(0, 0),
-      new Vector2d(this.width, 0),
-      new Vector2d(this.width, this.height),
-      new Vector2d(0, this.height)
-    ]);
-  }
 };
 var boundsPool = createPool((vertices) => {
   const instance = new Bounds(vertices);
@@ -10032,7 +10044,9 @@ __export(audio_exports, {
   disable: () => disable,
   enable: () => enable,
   fade: () => fade,
+  getAudioContext: () => getAudioContext,
   getCurrentTrack: () => getCurrentTrack,
+  getMasterGain: () => getMasterGain,
   getVolume: () => getVolume,
   hasAudio: () => hasAudio,
   hasFormat: () => hasFormat,
@@ -10041,6 +10055,7 @@ __export(audio_exports, {
   mute: () => mute,
   muteAll: () => muteAll,
   muted: () => muted,
+  noise: () => noise,
   orientation: () => orientation,
   panner: () => panner,
   pause: () => pause,
@@ -10057,51 +10072,83 @@ __export(audio_exports, {
   stop: () => stop,
   stopOnAudioError: () => stopOnAudioError,
   stopTrack: () => stopTrack,
+  tone: () => tone,
   unload: () => unload,
   unloadAll: () => unloadAll,
   unmute: () => unmute,
   unmuteAll: () => unmuteAll
 });
+
+// src/audio/backend.ts
 var import_howler = __toESM(require_howler(), 1);
-var audioTracks = {};
-var current_track_id = null;
-var retry_counter = 0;
-var audioExts = [];
-var soundLoadError = function(sound_name, onerror_cb) {
-  if (retry_counter++ > 3) {
+var stopOnAudioError = true;
+var state = {
+  tracks: {},
+  currentTrackId: null,
+  retryCounter: 0,
+  audioExts: []
+};
+function getSoundOrThrow(sound_name) {
+  const sound2 = state.tracks[sound_name];
+  if (!sound2) {
+    throw new Error(`audio clip ${sound_name} does not exist`);
+  }
+  return sound2;
+}
+var soundLoadError = function(sound_name, onerror_cb, stopOnError = true) {
+  if (state.retryCounter++ >= 3) {
     const errmsg = `melonJS: failed loading ${sound_name}`;
-    if (!stopOnAudioError) {
-      disable();
+    if (!stopOnError) {
+      import_howler.Howler.mute(true);
       onerror_cb?.();
-      console.log(`${errmsg}, disabling audio`);
+      console.warn(`${errmsg}, disabling audio`);
     } else {
       onerror_cb?.();
       throw new Error(errmsg);
     }
   } else {
-    audioTracks[sound_name].load();
+    state.tracks[sound_name]?.load();
   }
 };
-var stopOnAudioError = true;
-function init(format = "mp3") {
-  audioExts = format.split(",");
-  return !import_howler.Howler.noAudio;
+function getAudioContext() {
+  if (import_howler.Howler.noAudio) return null;
+  if (import_howler.Howler.usingWebAudio && !import_howler.Howler.ctx) {
+    import_howler.Howler.volume(import_howler.Howler.volume());
+  }
+  return import_howler.Howler.ctx ?? null;
 }
-function hasFormat(codec) {
-  return hasAudio() && import_howler.Howler.codecs(codec);
+function getMasterGain() {
+  if (!getAudioContext()) return null;
+  return import_howler.Howler.masterGain ?? null;
 }
-function hasAudio() {
-  return !import_howler.Howler.noAudio;
+function getGlobalVolume() {
+  return import_howler.Howler.volume();
 }
-function enable() {
-  unmuteAll();
+function setGlobalVolume(v) {
+  import_howler.Howler.volume(v);
 }
-function disable() {
-  muteAll();
+function setGlobalMuted(muted2) {
+  import_howler.Howler.mute(muted2);
+}
+function isGlobalMuted() {
+  return import_howler.Howler._muted;
+}
+function stopAllPlayback() {
+  import_howler.Howler.stop();
+}
+function hasCodec(codec) {
+  if (!isAudioAvailable()) return false;
+  return import_howler.Howler.codecs(codec) === true;
 }
+function isAudioAvailable() {
+  return !import_howler.Howler.noAudio;
+}
+
+// src/audio/playback.ts
+var import_howler2 = __toESM(require_howler(), 1);
 function load(sound2, onloadcb, onerrorcb, settings = {}) {
   const urls = [];
-  if (audioExts.length === 0) {
+  if (state.audioExts.length === 0) {
     throw new Error(
       "target audio extension(s) should be set through me.audio.init() before calling the preloader."
     );
@@ -10109,25 +10156,25 @@ function load(sound2, onloadcb, onerrorcb, settings = {}) {
   if (isDataUrl(sound2.src)) {
     urls.push(sound2.src);
   } else {
-    for (let i = 0; i < audioExts.length; i++) {
+    for (let i = 0; i < state.audioExts.length; i++) {
       urls.push(
-        `${sound2.src + sound2.name}.${audioExts[i]}${settings.nocache ?? ""}`
+        `${sound2.src + sound2.name}.${state.audioExts[i]}${settings.nocache ?? ""}`
       );
     }
   }
-  audioTracks[sound2.name] = new import_howler.Howl({
+  state.tracks[sound2.name] = new import_howler2.Howl({
     src: urls,
-    volume: import_howler.Howler.volume(),
+    volume: getGlobalVolume(),
     autoplay: sound2.autoplay === true,
-    loop: sound2.loop = true,
+    loop: sound2.loop === true,
     html5: sound2.stream === true || sound2.html5 === true,
     // @ts-expect-error xhrWithCredentials is a valid Howl option but not in the type definitions
     xhrWithCredentials: settings.withCredentials,
     onloaderror() {
-      soundLoadError.call(this, sound2.name, onerrorcb);
+      soundLoadError.call(this, sound2.name, onerrorcb, stopOnAudioError);
     },
     onload() {
-      retry_counter = 0;
+      state.retryCounter = 0;
       if (typeof onloadcb === "function") {
         onloadcb();
       }
@@ -10136,176 +10183,310 @@ function load(sound2, onloadcb, onerrorcb, settings = {}) {
   return 1;
 }
 function play(sound_name, loop = false, onend, volume) {
-  const sound2 = audioTracks[sound_name];
-  if (sound2 && typeof sound2 !== "undefined") {
-    const id = sound2.play();
-    if (typeof loop === "boolean") {
-      sound2.loop(loop, id);
-    }
-    sound2.volume(
-      typeof volume === "number" ? clamp(volume, 0, 1) : import_howler.Howler.volume(),
-      id
-    );
-    if (typeof onend === "function") {
-      if (loop) {
-        sound2.on("end", onend, id);
-      } else {
-        sound2.once("end", onend, id);
-      }
+  const sound2 = getSoundOrThrow(sound_name);
+  const id = sound2.play();
+  sound2.loop(loop, id);
+  sound2.volume(
+    typeof volume === "number" ? clamp(volume, 0, 1) : getGlobalVolume(),
+    id
+  );
+  if (typeof onend === "function") {
+    if (loop) {
+      sound2.on("end", onend, id);
+    } else {
+      sound2.once("end", onend, id);
     }
-    return id;
-  } else {
-    throw new Error(`audio clip ${sound_name} does not exist`);
   }
+  return id;
 }
 function fade(sound_name, from, to, duration, id) {
-  const sound2 = audioTracks[sound_name];
-  if (sound2 && typeof sound2 !== "undefined") {
-    sound2.fade(from, to, duration, id);
-  } else {
-    throw new Error(`audio clip ${sound_name} does not exist`);
-  }
+  getSoundOrThrow(sound_name).fade(from, to, duration, id);
 }
 function seek(sound_name, ...args) {
-  const sound2 = audioTracks[sound_name];
-  if (sound2 && typeof sound2 !== "undefined") {
-    return sound2.seek(...args);
-  } else {
-    throw new Error(`audio clip ${sound_name} does not exist`);
-  }
+  return getSoundOrThrow(sound_name).seek(...args);
 }
 function rate(sound_name, ...args) {
-  const sound2 = audioTracks[sound_name];
-  if (sound2 && typeof sound2 !== "undefined") {
-    return sound2.rate(...args);
-  } else {
-    throw new Error(`audio clip ${sound_name} does not exist`);
-  }
+  return getSoundOrThrow(sound_name).rate(...args);
 }
 function stereo(sound_name, pan, id) {
-  const sound2 = audioTracks[sound_name];
-  if (sound2 && typeof sound2 !== "undefined") {
-    return pan !== void 0 ? sound2.stereo(pan, id) : sound2.stereo();
-  } else {
-    throw new Error(`audio clip ${sound_name} does not exist`);
+  const sound2 = getSoundOrThrow(sound_name);
+  if (pan === void 0) {
+    return sound2.stereo();
   }
+  sound2.stereo(pan, id);
 }
 function position(sound_name, x, y, z, id) {
-  const sound2 = audioTracks[sound_name];
-  if (sound2 && typeof sound2 !== "undefined") {
-    return sound2.pos(x, y, z, id);
-  } else {
-    throw new Error(`audio clip ${sound_name} does not exist`);
+  const sound2 = getSoundOrThrow(sound_name);
+  if (x === void 0) {
+    return sound2.pos();
   }
+  sound2.pos(x, y, z, id);
 }
 function orientation(sound_name, x, y, z, id) {
-  const sound2 = audioTracks[sound_name];
-  if (sound2 && typeof sound2 !== "undefined") {
-    return sound2.orientation(x, y, z, id);
-  } else {
-    throw new Error(`audio clip ${sound_name} does not exist`);
+  const sound2 = getSoundOrThrow(sound_name);
+  if (x === void 0) {
+    return sound2.orientation();
   }
+  sound2.orientation(x, y, z, id);
 }
 function panner(sound_name, attributes, id) {
-  const sound2 = audioTracks[sound_name];
-  if (sound2 && typeof sound2 !== "undefined") {
-    return sound2.pannerAttr(
-      attributes,
-      id
-    );
-  } else {
-    throw new Error(`audio clip ${sound_name} does not exist`);
+  const sound2 = getSoundOrThrow(sound_name);
+  if (attributes !== void 0) {
+    const attrs = attributes;
+    if (id !== void 0) sound2.pannerAttr(attrs, id);
+    else sound2.pannerAttr(attrs);
   }
+  return id !== void 0 ? sound2.pannerAttr(id) : sound2.pannerAttr();
 }
 function stop(sound_name, id) {
-  if (typeof sound_name !== "undefined") {
-    const sound2 = audioTracks[sound_name];
-    if (sound2 && typeof sound2 !== "undefined") {
-      sound2.stop(id);
-      sound2.off("end", void 0, id);
-    } else {
-      throw new Error(`audio clip ${sound_name} does not exist`);
-    }
-  } else {
-    import_howler.Howler.stop();
+  if (sound_name === void 0) {
+    stopAllPlayback();
+    return;
   }
+  const sound2 = getSoundOrThrow(sound_name);
+  sound2.stop(id);
+  sound2.off("end", void 0, id);
 }
 function pause(sound_name, id) {
-  const sound2 = audioTracks[sound_name];
-  if (sound2 && typeof sound2 !== "undefined") {
-    sound2.pause(id);
-  } else {
-    throw new Error(`audio clip ${sound_name} does not exist`);
-  }
+  getSoundOrThrow(sound_name).pause(id);
 }
 function resume(sound_name, id) {
-  const sound2 = audioTracks[sound_name];
-  if (sound2 && typeof sound2 !== "undefined") {
-    sound2.play(id);
+  getSoundOrThrow(sound_name).play(id);
+}
+
+// src/audio/procedural.ts
+function _resumeIfSuspended(ctx) {
+  if (ctx.state === "suspended") {
+    ctx.resume().catch(() => {
+    });
+  }
+}
+function _buildGainEnvelope(ctx, t0, t1, attack, duration, gain) {
+  const atk = Math.min(duration / 2, Math.max(1e-3, attack));
+  const env = ctx.createGain();
+  env.gain.setValueAtTime(0, t0);
+  env.gain.linearRampToValueAtTime(gain, t0 + atk);
+  if (gain > 1e-4) {
+    env.gain.exponentialRampToValueAtTime(1e-4, t1);
   } else {
-    throw new Error(`audio clip ${sound_name} does not exist`);
+    env.gain.linearRampToValueAtTime(0, t1);
   }
+  return env;
+}
+function _connectToOutput(ctx, source, pan, t0) {
+  const out = getMasterGain() ?? ctx.destination;
+  if (pan === 0) {
+    source.connect(out);
+    return null;
+  }
+  const panner2 = ctx.createStereoPanner();
+  panner2.pan.setValueAtTime(Math.max(-1, Math.min(1, pan)), t0);
+  source.connect(panner2).connect(out);
+  return panner2;
+}
+function tone(opts) {
+  const ctx = getAudioContext();
+  if (!ctx) return;
+  const {
+    freq,
+    duration,
+    wave = "sine",
+    gain = 0.1,
+    attack = 5e-3,
+    pan = 0,
+    pitchSlide = 1
+  } = opts;
+  const freqs = Array.isArray(freq) ? freq : [freq];
+  if (freqs.length === 0) return;
+  _resumeIfSuspended(ctx);
+  const dur = Math.max(1e-3, duration);
+  const t0 = ctx.currentTime;
+  const t1 = t0 + dur;
+  const env = _buildGainEnvelope(ctx, t0, t1, attack, dur, gain);
+  const panner2 = _connectToOutput(ctx, env, pan, t0);
+  let remaining = freqs.length;
+  for (const f of freqs) {
+    const osc = ctx.createOscillator();
+    osc.type = wave;
+    osc.frequency.setValueAtTime(f, t0);
+    if (pitchSlide !== 1 && f > 0) {
+      osc.frequency.exponentialRampToValueAtTime(
+        Math.max(0.01, f * pitchSlide),
+        t1
+      );
+    }
+    osc.connect(env);
+    osc.start(t0);
+    osc.stop(t1 + 0.02);
+    osc.onended = () => {
+      osc.disconnect();
+      if (--remaining === 0) {
+        env.disconnect();
+        panner2?.disconnect();
+      }
+    };
+  }
+}
+function fillNoiseBuffer(data2, type) {
+  const n = data2.length;
+  if (type === "white") {
+    for (let i = 0; i < n; i++) {
+      data2[i] = Math.random() * 2 - 1;
+    }
+    return;
+  }
+  if (type === "pink") {
+    let b0 = 0;
+    let b1 = 0;
+    let b2 = 0;
+    let b3 = 0;
+    let b4 = 0;
+    let b5 = 0;
+    let b6 = 0;
+    for (let i = 0; i < n; i++) {
+      const w = Math.random() * 2 - 1;
+      b0 = 0.99886 * b0 + w * 0.0555179;
+      b1 = 0.99332 * b1 + w * 0.0750759;
+      b2 = 0.969 * b2 + w * 0.153852;
+      b3 = 0.8665 * b3 + w * 0.3104856;
+      b4 = 0.55 * b4 + w * 0.5329522;
+      b5 = -0.7616 * b5 - w * 0.016898;
+      data2[i] = (b0 + b1 + b2 + b3 + b4 + b5 + b6 + w * 0.5362) * 0.11;
+      b6 = w * 0.115926;
+    }
+    return;
+  }
+  let last = 0;
+  for (let i = 0; i < n; i++) {
+    const w = Math.random() * 2 - 1;
+    last = (last + 0.02 * w) / 1.02;
+    data2[i] = last * 3.5;
+  }
+}
+function noise(opts) {
+  const ctx = getAudioContext();
+  if (!ctx) return;
+  const {
+    duration,
+    type = "white",
+    gain = 0.1,
+    attack = 5e-3,
+    pan = 0,
+    filter,
+    filterSweep = 1
+  } = opts;
+  _resumeIfSuspended(ctx);
+  const dur = Math.max(1e-3, duration);
+  const t0 = ctx.currentTime;
+  const t1 = t0 + dur;
+  const env = _buildGainEnvelope(ctx, t0, t1, attack, dur, gain);
+  const sampleCount = Math.max(1, Math.ceil(dur * ctx.sampleRate));
+  const buffer = ctx.createBuffer(1, sampleCount, ctx.sampleRate);
+  fillNoiseBuffer(buffer.getChannelData(0), type);
+  const src = ctx.createBufferSource();
+  src.buffer = buffer;
+  src.connect(env);
+  let tail = env;
+  if (filter !== void 0) {
+    const biquad = ctx.createBiquadFilter();
+    biquad.type = filter.type;
+    biquad.frequency.setValueAtTime(filter.frequency, t0);
+    if (filter.Q !== void 0) {
+      biquad.Q.setValueAtTime(filter.Q, t0);
+    }
+    if (filterSweep !== 1 && filter.frequency > 0) {
+      biquad.frequency.exponentialRampToValueAtTime(
+        Math.max(0.01, filter.frequency * filterSweep),
+        t1
+      );
+    }
+    tail.connect(biquad);
+    tail = biquad;
+  }
+  const panner2 = _connectToOutput(ctx, tail, pan, t0);
+  src.start(t0);
+  src.stop(t1 + 0.02);
+  src.onended = () => {
+    src.disconnect();
+    env.disconnect();
+    if (tail !== env) tail.disconnect();
+    panner2?.disconnect();
+  };
+}
+
+// src/audio/audio.ts
+function init(format = "mp3") {
+  state.audioExts = format.split(",");
+  return isAudioAvailable();
+}
+function hasFormat(codec) {
+  return hasCodec(codec);
+}
+function hasAudio() {
+  return isAudioAvailable();
+}
+function enable() {
+  unmuteAll();
+}
+function disable() {
+  muteAll();
 }
 function playTrack(sound_name, volume) {
-  current_track_id = sound_name;
-  return play(current_track_id, true, null, volume);
+  state.currentTrackId = sound_name;
+  return play(state.currentTrackId, true, null, volume);
 }
 function stopTrack() {
-  if (current_track_id !== null) {
-    audioTracks[current_track_id].stop();
-    current_track_id = null;
+  if (state.currentTrackId !== null) {
+    state.tracks[state.currentTrackId]?.stop();
+    state.currentTrackId = null;
   }
 }
 function pauseTrack() {
-  if (current_track_id !== null) {
-    audioTracks[current_track_id].pause();
+  if (state.currentTrackId !== null) {
+    state.tracks[state.currentTrackId]?.pause();
   }
 }
 function resumeTrack() {
-  if (current_track_id !== null) {
-    audioTracks[current_track_id].play();
+  if (state.currentTrackId !== null) {
+    state.tracks[state.currentTrackId]?.play();
   }
 }
 function getCurrentTrack() {
-  return current_track_id;
+  return state.currentTrackId;
 }
 function setVolume(volume) {
-  import_howler.Howler.volume(volume);
+  setGlobalVolume(volume);
 }
 function getVolume() {
-  return import_howler.Howler.volume();
+  return getGlobalVolume();
 }
 function mute(sound_name, id, shouldMute = true) {
-  const sound2 = audioTracks[sound_name];
-  if (sound2 && typeof sound2 !== "undefined") {
-    sound2.mute(shouldMute, id);
-  } else {
-    throw new Error(`audio clip ${sound_name} does not exist`);
-  }
+  getSoundOrThrow(sound_name).mute(shouldMute, id);
 }
 function unmute(sound_name, id) {
   mute(sound_name, id, false);
 }
 function muteAll() {
-  import_howler.Howler.mute(true);
+  setGlobalMuted(true);
 }
 function unmuteAll() {
-  import_howler.Howler.mute(false);
+  setGlobalMuted(false);
 }
 function muted() {
-  return import_howler.Howler._muted;
+  return isGlobalMuted();
 }
 function unload(sound_name) {
-  if (!(sound_name in audioTracks)) {
+  const sound2 = state.tracks[sound_name];
+  if (!sound2) {
     return false;
   }
-  audioTracks[sound_name].unload();
-  delete audioTracks[sound_name];
+  sound2.unload();
+  delete state.tracks[sound_name];
   return true;
 }
 function unloadAll() {
-  for (const sound_name in audioTracks) {
-    if (Object.prototype.hasOwnProperty.call(audioTracks, sound_name)) {
+  for (const sound_name in state.tracks) {
+    if (Object.prototype.hasOwnProperty.call(state.tracks, sound_name)) {
       unload(sound_name);
     }
   }
@@ -10341,7 +10522,6 @@ var CameraEffect = class {
    */
   update(_dt) {
   }
-  // eslint-disable-line @typescript-eslint/no-unused-vars
   /**
    * Called after the scene renders to draw visual overlays (e.g. color fills for fading).
    * @param _renderer - the renderer to draw with
@@ -10350,7 +10530,6 @@ var CameraEffect = class {
    */
   draw(_renderer2, _width, _height) {
   }
-  // eslint-disable-line @typescript-eslint/no-unused-vars
   /**
    * Called when the effect is removed from the camera. Override to clean up resources.
    */
@@ -11277,7 +11456,7 @@ var collision = {
   }
 };
 
-// src/physics/body.js
+// src/physics/builtin/body.js
 var Body = class {
   /**
    * @param {Renderable|Container|Entity|Sprite|NineSliceSprite} ancestor - the parent object this body is attached to
@@ -11308,11 +11487,16 @@ var Body = class {
     this.friction.set(0, 0);
     this.bounce = 0;
     this.mass = 1;
+    this.angle = 0;
+    this.angularVelocity = 0;
+    this.angularDrag = 0;
+    this.pseudoInertia = 1;
     if (typeof this.maxVel === "undefined") {
       this.maxVel = vector2dPool.get();
     }
     this.maxVel.set(490, 490);
     this.isStatic = false;
+    this.isSensor = false;
     this.gravityScale = 1;
     this.ignoreGravity = false;
     this.falling = false;
@@ -11340,6 +11524,229 @@ var Body = class {
   setStatic(isStatic = true) {
     this.isStatic = isStatic === true;
   }
+  /**
+   * set this body's linear velocity. Portable across physics adapters —
+   * under the builtin adapter this mutates `body.vel`; under Matter it
+   * delegates to `Matter.Body.setVelocity`.
+   * @param {number} x - velocity along the X axis
+   * @param {number} y - velocity along the Y axis
+   */
+  setVelocity(x, y) {
+    this.vel.set(x, y);
+  }
+  /**
+   * read this body's linear velocity into an optional output vector.
+   * @param {Vector2d} [out] - vector to write into; a new Vector2d is
+   * allocated when omitted
+   * @returns {Vector2d}
+   */
+  getVelocity(out) {
+    return (out ?? vector2dPool.get()).copy(this.vel);
+  }
+  /**
+   * accumulate a force on this body for the current step. Repeated calls
+   * within a single update add together; the engine clears the
+   * accumulator at the end of each integration step. Force magnitude
+   * conventions differ between adapters — consult the active adapter's
+   * docs for tuning ranges (builtin: px/frame²; Matter: Newtonian
+   * `force/mass·dt²`, typically ~100× smaller than builtin).
+   * @param {number} x - force along the X axis
+   * @param {number} y - force along the Y axis
+   * @param {number} [pointX] - world X of the application point; when
+   *   present (along with `pointY`) and different from the body centroid,
+   *   the resulting lever arm generates a torque
+   *   `τ = (r.x · F.y) − (r.y · F.x)` that bumps {@link Body#angularVelocity}
+   *   by `τ / pseudoInertia`. Omit both `pointX` and `pointY` for the
+   *   linear-only behaviour that's compatible with code written before
+   *   the angular API was added.
+   * @param {number} [pointY] - world Y of the application point
+   * @example
+   * // pure linear thrust (2-arg form, unchanged behaviour):
+   * ship.body.applyForce(0, -0.05);
+   *
+   * // off-centre push on a crate: the contact point at the top of the
+   * // crate is above its centroid, so the same horizontal force now
+   * // both translates AND tips the crate forward.
+   * const topX = crate.pos.x + crate.width / 2;
+   * const topY = crate.pos.y;
+   * crate.body.applyForce(1.5, 0, topX, topY);
+   *
+   * // wind pushing on the top of a flag-pole: pole tilts, base stays put
+   * // (only meaningful here if the base is anchored / static).
+   * pole.body.applyForce(0.3, 0, pole.pos.x + pole.width / 2, pole.pos.y);
+   */
+  applyForce(x, y, pointX, pointY) {
+    this.force.x += x;
+    this.force.y += y;
+    if (typeof pointX === "number" && typeof pointY === "number") {
+      const bounds = this.bounds;
+      const rx = pointX - bounds.centerX;
+      const ry = pointY - bounds.centerY;
+      const torque = rx * y - ry * x;
+      if (this.pseudoInertia > 0) {
+        this.angularVelocity += torque / this.pseudoInertia;
+      }
+    }
+  }
+  /**
+   * Apply an instantaneous angular impulse: `Δω = τ / pseudoInertia`.
+   * The angular analog of {@link Body#applyImpulse} — bypasses the
+   * lever-arm computation in {@link Body#applyForce} for the
+   * "just spin this up directly" case (a power-up's intrinsic spin,
+   * an explicit thruster, a knockback spin effect on hit).
+   * @param {number} torque - angular impulse magnitude. Positive values
+   *   produce clockwise rotation on screen (matching the Y-down canvas
+   *   convention); negative values rotate counter-clockwise.
+   * @example
+   * // give a pickup a one-shot spin-up when collected:
+   * pickup.body.applyTorque(80);
+   *
+   * // explosion knockback that both pushes and spins:
+   * crate.body.applyImpulse(impulseX, impulseY);
+   * crate.body.applyTorque((Math.random() - 0.5) * 100);
+   */
+  applyTorque(torque) {
+    if (this.pseudoInertia > 0) {
+      this.angularVelocity += torque / this.pseudoInertia;
+    }
+  }
+  /**
+   * Set angular velocity directly. Bypasses inertia — the value is the
+   * actual rad/frame that integration will apply next step. Use this
+   * for "set and hold" rotation (a coin that always spins at the same
+   * rate); use {@link Body#applyTorque} for impulse-style spin-up.
+   * @param {number} omega - target angular velocity (rad / frame)
+   * @example
+   * // make a fan blade spin at a fixed rate:
+   * fan.body.setAngularVelocity(0.1);  // ~6°/frame
+   */
+  setAngularVelocity(omega) {
+    this.angularVelocity = omega;
+  }
+  /**
+   * Read current angular velocity (rad / frame).
+   * @returns {number}
+   * @example
+   * // freeze rotation if the body is spinning too fast:
+   * if (Math.abs(body.getAngularVelocity()) > 2) {
+   *     body.setAngularVelocity(0);
+   * }
+   */
+  getAngularVelocity() {
+    return this.angularVelocity;
+  }
+  /**
+   * Set absolute rotation angle (radians). Updates the body's `angle`
+   * field and re-syncs the renderable's `currentTransform` immediately
+   * so the visual rotation reflects the new value without waiting for
+   * the next integration step.
+   * @param {number} rad - target angle in radians
+   * @example
+   * // turret aims at the player every frame:
+   * const dx = player.centerX - turret.centerX;
+   * const dy = player.centerY - turret.centerY;
+   * turret.body.setAngle(Math.atan2(dy, dx));
+   */
+  setAngle(rad) {
+    this.angle = rad;
+    this._syncAngleTransform();
+  }
+  /**
+   * Read absolute rotation angle (radians).
+   * @returns {number}
+   */
+  getAngle() {
+    return this.angle;
+  }
+  /**
+   * Sync `this.angle` to the renderable's `currentTransform`. Pivot is
+   * the body's bounds center (matches the matter adapter's rotation
+   * pivot — see `MatterAdapter.syncFromPhysics`). Internal helper used
+   * by both the per-step integrator and {@link Body#setAngle}.
+   * @ignore
+   */
+  _syncAngleTransform() {
+    const t = this.ancestor?.currentTransform;
+    if (!t) {
+      return;
+    }
+    const bounds = this.bounds;
+    const cx = bounds.centerX - this.ancestor.pos.x;
+    const cy = bounds.centerY - this.ancestor.pos.y;
+    t.identity();
+    if (this.angle !== 0) {
+      if (cx !== 0 || cy !== 0) {
+        t.translate(cx, cy);
+        t.rotate(this.angle);
+        t.translate(-cx, -cy);
+      } else {
+        t.rotate(this.angle);
+      }
+    }
+  }
+  /**
+   * apply an instantaneous impulse to this body — a single-step velocity
+   * change scaled by inverse mass (`dv = J / m`). Useful for one-shot
+   * events like a cue strike, projectile launch, or knockback, where
+   * mass should influence the resulting velocity change. Repeated calls
+   * within a single update accumulate. Static bodies (mass 0) ignore
+   * the call. Identical signature on the Matter adapter, where the
+   * adapter integrates the impulse the same way (matter has no native
+   * `applyImpulse`).
+   * @param {number} x - impulse along the X axis
+   * @param {number} y - impulse along the Y axis
+   */
+  applyImpulse(x, y) {
+    const invMass = this.mass > 0 ? 1 / this.mass : 0;
+    this.vel.x += x * invMass;
+    this.vel.y += y * invMass;
+  }
+  /**
+   * set this body's mass. Useful for variable-mass entities (projectiles
+   * loaded with ammo, weight pickups, characters carrying objects).
+   * Mass affects `applyImpulse` (via `dv = J / m`) and the proportional
+   * push-out response in dynamic-dynamic collisions. A mass of 0 makes
+   * the body inert to forces and impulses (without going static).
+   * @param {number} m - new mass, non-negative
+   */
+  setMass(m) {
+    this.mass = m;
+  }
+  /**
+   * set this body's restitution / bounce factor. `0` = no bounce (energy
+   * absorbed on contact); `1` = perfect elastic rebound; values in
+   * between dampen the rebound. Applied by `Body.respondToCollision` —
+   * see `BuiltinAdapter` docs for the cancellation math.
+   *
+   * Matches the `bodyDef.restitution` field name used at registration
+   * time; the body-side property has historically been called `bounce`,
+   * which is the canonical legacy name and is preserved.
+   * @param {number} r - restitution factor, typically in [0, 1]
+   */
+  setBounce(r) {
+    this.bounce = r;
+  }
+  /**
+   * set this body's per-body gravity multiplier. `1` = world gravity
+   * (default), `0` = ignore world gravity (e.g. flying enemy, underwater
+   * float), `2` = 2× gravity (heavy-feel objects). Multiplied with the
+   * world's `gravity.y` each frame inside `applyGravity`.
+   * @param {number} scale - gravity scale factor
+   */
+  setGravityScale(scale2) {
+    this.gravityScale = scale2;
+  }
+  /**
+   * toggle this body between solid and sensor. Sensor bodies still emit
+   * collision events (`onCollisionStart`, `onCollisionActive`,
+   * `onCollisionEnd`) but the solver does not physically resolve the
+   * contact — same semantics as Matter's `isSensor`. Useful for one-way
+   * platforms, trigger zones, and ground-snap assists.
+   * @param {boolean} [isSensor=true]
+   */
+  setSensor(isSensor = true) {
+    this.isSensor = isSensor === true;
+  }
   /**
    * add a collision shape to this body <br>
    * (note: me.Rect objects will be converted to me.Polygon before being added)
@@ -11352,11 +11759,21 @@ var Body = class {
    * this.body.addShape(me.loader.getJSON("shapesdef").banana);
    */
   addShape(shape) {
-    if (shape instanceof Rect || shape instanceof Bounds) {
+    if (shape instanceof Rect) {
       const poly = shape.toPolygon();
       this.shapes.push(poly);
       this.bounds.add(poly.points);
       this.bounds.translate(poly.pos);
+    } else if (shape instanceof Bounds) {
+      const poly = polygonPool.get(shape.x, shape.y, [
+        new Vector2d(0, 0),
+        new Vector2d(shape.width, 0),
+        new Vector2d(shape.width, shape.height),
+        new Vector2d(0, shape.height)
+      ]);
+      this.shapes.push(poly);
+      this.bounds.add(poly.points);
+      this.bounds.translate(poly.pos);
     } else if (shape instanceof Ellipse) {
       if (!this.shapes.includes(shape)) {
         this.shapes.push(shape);
@@ -11377,11 +11794,26 @@ var Body = class {
     } else {
       this.fromJSON(shape);
     }
+    this._recomputePseudoInertia();
     if (typeof this.onBodyUpdate === "function") {
       this.onBodyUpdate(this);
     }
     return this.shapes.length;
   }
+  /**
+   * Recompute the default `pseudoInertia` from the current bounds.
+   * Uses the moment-of-inertia formula for a unit-mass rectangle —
+   * `(width² + height²) / 12` — which gives a value that scales
+   * sensibly with body size: a small body resists rotation less, a
+   * large body more. Clamped to a minimum of 1 to keep divisions
+   * well-defined even on degenerate 0-size bodies.
+   * @ignore
+   */
+  _recomputePseudoInertia() {
+    const w = this.bounds.width;
+    const h = this.bounds.height;
+    this.pseudoInertia = Math.max(1, (w * w + h * h) / 12);
+  }
   /**
    * set the body vertices to the given one
    * @param {Vector2d[]} vertices - an array of me.Vector2d points defining a convex hull
@@ -11545,7 +11977,7 @@ var Body = class {
         this.vel.y -= projVel * ratio * overlapN.y;
       }
     }
-    if (overlap.y !== 0 && !this.ignoreGravity) {
+    if (overlap.y !== 0 && !this.ignoreGravity && this.gravityScale !== 0) {
       const dir = this.falling === true ? 1 : this.jumping === true ? -1 : 0;
       this.falling = overlap.y >= dir;
       this.jumping = overlap.y <= -dir;
@@ -11691,6 +12123,13 @@ var Body = class {
     this.falling = this.vel.y * Math.sign(this.force.y) > 0;
     this.jumping = this.falling ? false : this.jumping;
     this.ancestor.pos.add(this.vel);
+    if (this.angularVelocity !== 0 || this.angle !== 0) {
+      if (this.angularDrag > 0 && this.angularVelocity !== 0) {
+        this.angularVelocity *= 1 - this.angularDrag;
+      }
+      this.angle += this.angularVelocity * deltaTime;
+      this._syncAngleTransform();
+    }
     return this.vel.x !== 0 || this.vel.y !== 0;
   }
   /**
@@ -11749,6 +12188,7 @@ var Renderable = class _Renderable extends Rect {
     }
     this.currentTransform.identity();
     this.body = void 0;
+    this.bodyDef = void 0;
     this.GUID = void 0;
     this.onVisibilityChange = void 0;
     this.alwaysUpdate = false;
@@ -12244,28 +12684,74 @@ var Renderable = class _Renderable extends Rect {
     this.isDirty = false;
   }
   /**
-   * onCollision callback, triggered in case of collision,
-   * when this renderable body is colliding with another one
-   * @param {ResponseObject} response - the collision response object
+   * Legacy collision callback — fires every frame this renderable body is
+   * overlapping another body. Kept for backward compatibility with code
+   * written against pre-19.5 melonJS; semantics are unchanged from the
+   * 19.4 contract.
+   *
+   * **NOTE — `onCollision` is NOT equivalent to {@link Renderable.onCollisionActive}.**
+   * The two handlers exist side by side and have intentionally different
+   * contracts:
+   *
+   * | | `onCollision` (legacy) | `onCollisionActive` (modern) |
+   * |---|---|---|
+   * | Cadence for dynamic-dynamic pairs | 2× per frame per side | 1× per frame per side |
+   * | `response.a` semantics | Fixed per pair (first body in detector call) | Always the receiver (`response.a === this`) |
+   * | `response.b` semantics | Fixed per pair | Always the partner (`response.b === other`) |
+   * | `response.normal` / `response.depth` | ✗ | ✓ — `normal.y < -0.7` = "push me up" |
+   * | `return false` to skip push-out | ✓ (honored by SAT) | ✗ — use `bodyDef.isSensor` or `setSensor` instead |
+   *
+   * If you're writing new code, prefer `onCollisionActive`. Keep
+   * `onCollision` only when its every-frame, return-false, fixed-`a`/`b`
+   * semantics are what you want.
+   *
+   * @param {import("../physics/adapter.ts").CollisionResponse} response - the collision response object
    * @param {Renderable} other - the other renderable touching this one (a reference to response.a or response.b)
-   * @returns {boolean} true if the object should respond to the collision (its position and velocity will be corrected)
+   * @returns {boolean} true if the object should respond to the collision (its position and velocity will be corrected); the return value is only honored by the builtin SAT adapter.
    * @example
-   * // collision handler
+   * // legacy collision handler — note the receiver-side check on response.a
    * onCollision(response) {
    *     if (response.b.body.collisionType === me.collision.types.ENEMY_OBJECT) {
-   *         // makes the other object solid, by substracting the overlap vector to the current position
    *         this.pos.sub(response.overlapV);
    *         this.hurt();
-   *         // not solid
-   *         return false;
+   *         return false;   // skip the SAT push-out
    *     }
-   *     // Make the object solid
    *     return true;
-   * },
+   * }
    */
-  onCollision() {
-    return false;
+  onCollision(_response, _other) {
   }
+  /*
+   * Modern collision lifecycle hooks (`onCollisionStart`,
+   * `onCollisionActive`, `onCollisionEnd`) are intentionally NOT
+   * defined on the base class. Subclasses override the ones they
+   * care about; the adapter's dispatch logic checks
+   * `typeof renderable.onCollisionX === "function"` to know whether
+   * to fire them. Defining base stubs would make every renderable
+   * "look like" it implements every hook, which would in turn make
+   * the `onCollisionActive supersedes onCollision` rule fire even
+   * for legacy-only code.
+   *
+   * Documented surface (subclasses implement these as needed):
+   *
+   *   onCollisionStart(response, other)
+   *     One-shot on first contact. Use for stomp bounces, pickups,
+   *     trigger entry. Receiver-symmetric (`response.a === this`,
+   *     `response.b === other`). Same contract on every adapter.
+   *
+   *   onCollisionActive(response, other)
+   *     Every step while two bodies remain in contact. The modern
+   *     equivalent of `onCollision`, with different semantics:
+   *       - 1× per frame per side (vs `onCollision`'s 2× for dyn-dyn)
+   *       - `response.a === this`, `response.b === other`
+   *       - `response.normal` is the MTV of the receiver
+   *       - `return false` is NOT honored (use `bodyDef.isSensor`)
+   *     When defined, `onCollision` is suppressed on the same
+   *     renderable. Stomp idiom: `response.normal.y < -0.7`.
+   *
+   *   onCollisionEnd(response, other)
+   *     One-shot when two bodies separate.
+   */
   /**
    * Destroy function<br>
    * @ignore
@@ -12309,9 +12795,31 @@ var Renderable = class _Renderable extends Rect {
   }
   /**
    * OnDestroy Notification function<br>
-   * Called by engine before deleting the object
+   * Called by engine before deleting the object. `Stage.destroy(app)`
+   * forwards the active Application, so subclasses that wire teardown
+   * against the app object can override as `onDestroyEvent(app)`.
+   * @param {...*} _args - forwarded by `destroy(...args)`; Stage passes the Application instance
    */
-  onDestroyEvent() {
+  onDestroyEvent(..._args) {
+  }
+  /**
+   * Lifecycle hook fired by {@link Container} when this renderable is
+   * added to a container that is part of the active scene graph.
+   * Override to wire up input handlers, register external listeners,
+   * or grab adapter references — `this.parentApp` is guaranteed to be
+   * available here. Pair with {@link Renderable#onDeactivateEvent}.
+   * @param {...*} _args - forwarded by `Container.addChild`
+   */
+  onActivateEvent(..._args) {
+  }
+  /**
+   * Lifecycle hook fired by {@link Container} when this renderable is
+   * removed from its container or its container is itself removed.
+   * Override to release input handlers, unsubscribe from events, or
+   * drop adapter references. Pair with {@link Renderable#onActivateEvent}.
+   * @param {...*} _args - forwarded by `Container.removeChildNow`
+   */
+  onDeactivateEvent(..._args) {
   }
 };
 
@@ -12420,6 +12928,421 @@ function fetchData(url, responseType, settings = {}) {
   });
 }
 
+// src/loader/parsers/aseprite.js
+var ASE_MAGIC_FILE = 42464;
+var ASE_MAGIC_FRAME = 61946;
+var CHUNK_OLD_PALETTE_04 = 4;
+var CHUNK_OLD_PALETTE_11 = 17;
+var CHUNK_LAYER = 8196;
+var CHUNK_CEL = 8197;
+var CHUNK_PALETTE = 8217;
+var CHUNK_TAGS = 8216;
+var CHUNK_TILESET = 8227;
+var CEL_RAW_IMAGE = 0;
+var CEL_LINKED = 1;
+var CEL_COMPRESSED_IMAGE = 2;
+var CEL_COMPRESSED_TILEMAP = 3;
+var ERR_TILEMAP_MODE = "aseprite: this file uses Aseprite's tilemap mode (tileset chunk or tilemap-cel), which is not supported. Export the sprite to a regular PNG (File \u2192 Export Sprite Sheet) or flatten the tilemap layer to pixel layers.";
+var DEPTH_RGBA = 32;
+var DEPTH_GRAYSCALE = 16;
+var DEPTH_INDEXED = 8;
+var LAYER_FLAG_VISIBLE = 1;
+var TAG_DIRECTIONS = ["forward", "reverse", "pingpong", "pingpong_reverse"];
+var Reader = class {
+  constructor(buffer, offset = 0) {
+    this.view = new DataView(buffer);
+    this.bytes = new Uint8Array(buffer);
+    this.offset = offset;
+  }
+  u8() {
+    return this.view.getUint8(this.offset++);
+  }
+  u16() {
+    const v = this.view.getUint16(this.offset, true);
+    this.offset += 2;
+    return v;
+  }
+  i16() {
+    const v = this.view.getInt16(this.offset, true);
+    this.offset += 2;
+    return v;
+  }
+  u32() {
+    const v = this.view.getUint32(this.offset, true);
+    this.offset += 4;
+    return v;
+  }
+  i32() {
+    const v = this.view.getInt32(this.offset, true);
+    this.offset += 4;
+    return v;
+  }
+  str() {
+    const len = this.u16();
+    const slice = this.bytes.subarray(this.offset, this.offset + len);
+    this.offset += len;
+    return new TextDecoder("utf-8").decode(slice);
+  }
+  skip(n) {
+    this.offset += n;
+  }
+  slice(n) {
+    const out = this.bytes.subarray(this.offset, this.offset + n);
+    this.offset += n;
+    return out;
+  }
+};
+async function inflate(bytes) {
+  const stream = new Response(bytes).body.pipeThrough(
+    new DecompressionStream("deflate")
+  );
+  return new Uint8Array(await new Response(stream).arrayBuffer());
+}
+function decodeCelPixels(raw, w, h, depth, palette, transparentIndex) {
+  const out = new Uint8ClampedArray(w * h * 4);
+  switch (depth) {
+    case DEPTH_RGBA:
+      out.set(raw);
+      break;
+    case DEPTH_GRAYSCALE:
+      for (let i = 0, j = 0; i < w * h; i++, j += 4) {
+        const v = raw[i * 2];
+        const a = raw[i * 2 + 1];
+        out[j] = v;
+        out[j + 1] = v;
+        out[j + 2] = v;
+        out[j + 3] = a;
+      }
+      break;
+    case DEPTH_INDEXED:
+      for (let i = 0, j = 0; i < w * h; i++, j += 4) {
+        const idx = raw[i];
+        if (idx === transparentIndex) {
+          out[j] = 0;
+          out[j + 1] = 0;
+          out[j + 2] = 0;
+          out[j + 3] = 0;
+        } else {
+          const p = palette[idx];
+          if (p) {
+            out[j] = p[0];
+            out[j + 1] = p[1];
+            out[j + 2] = p[2];
+            out[j + 3] = p[3];
+          }
+        }
+      }
+      break;
+    default:
+      throw new Error("aseprite: unsupported color depth " + depth);
+  }
+  return out;
+}
+async function parseAsepriteFile(buffer) {
+  const r = new Reader(buffer);
+  r.u32();
+  const magic = r.u16();
+  if (magic !== ASE_MAGIC_FILE) {
+    throw new Error(
+      "aseprite: invalid file magic 0x" + magic.toString(16) + " (expected 0xA5E0)"
+    );
+  }
+  const frameCount = r.u16();
+  const width = r.u16();
+  const height = r.u16();
+  const depth = r.u16();
+  r.u32();
+  r.u16();
+  r.u32();
+  r.u32();
+  const transparentIndex = r.u8();
+  r.skip(3);
+  r.u16();
+  r.offset = 128;
+  const palette = [];
+  const layers = [];
+  const tags = [];
+  const frames = [];
+  const ancestorVisible = [];
+  for (let f = 0; f < frameCount; f++) {
+    const frameStart = r.offset;
+    const frameSize = r.u32();
+    const fmagic = r.u16();
+    if (fmagic !== ASE_MAGIC_FRAME) {
+      throw new Error(
+        "aseprite: invalid frame magic at frame " + f + " (got 0x" + fmagic.toString(16) + ")"
+      );
+    }
+    let chunkCount = r.u16();
+    const duration = r.u16();
+    r.skip(2);
+    const newChunks = r.u32();
+    if (chunkCount === 65535) {
+      chunkCount = newChunks;
+    }
+    const cels = [];
+    for (let c = 0; c < chunkCount; c++) {
+      const chunkStart = r.offset;
+      const chunkSize = r.u32();
+      const chunkType = r.u16();
+      const chunkEnd = chunkStart + chunkSize;
+      switch (chunkType) {
+        case CHUNK_LAYER: {
+          const flags = r.u16();
+          r.u16();
+          const childLevel = r.u16();
+          r.u16();
+          r.u16();
+          r.u16();
+          r.u8();
+          r.skip(3);
+          const name = r.str();
+          const selfVisible = (flags & LAYER_FLAG_VISIBLE) !== 0;
+          const parentVisible = childLevel === 0 ? true : ancestorVisible[childLevel - 1] !== false;
+          const visible = selfVisible && parentVisible;
+          ancestorVisible[childLevel] = visible;
+          ancestorVisible.length = childLevel + 1;
+          layers.push({ flags, name, visible });
+          break;
+        }
+        case CHUNK_CEL: {
+          const layer = r.u16();
+          const x = r.i16();
+          const y = r.i16();
+          const opacity = r.u8();
+          const celType = r.u16();
+          r.skip(7);
+          if (celType === CEL_RAW_IMAGE) {
+            const cw = r.u16();
+            const ch = r.u16();
+            const pixelBytes = cw * ch * (depth / 8);
+            const raw = r.slice(pixelBytes);
+            cels.push({ layer, x, y, opacity, w: cw, h: ch, raw });
+          } else if (celType === CEL_LINKED) {
+            const linkFrame = r.u16();
+            cels.push({ layer, x, y, opacity, linkFrame });
+          } else if (celType === CEL_COMPRESSED_IMAGE) {
+            const cw = r.u16();
+            const ch = r.u16();
+            const compressed = r.slice(chunkEnd - r.offset);
+            const inflated = await inflate(compressed);
+            cels.push({
+              layer,
+              x,
+              y,
+              opacity,
+              w: cw,
+              h: ch,
+              raw: inflated
+            });
+          } else if (celType === CEL_COMPRESSED_TILEMAP) {
+            throw new Error(ERR_TILEMAP_MODE);
+          }
+          break;
+        }
+        case CHUNK_PALETTE: {
+          const size = r.u32();
+          const first = r.u32();
+          const last = r.u32();
+          r.skip(8);
+          for (let i = first; i <= last; i++) {
+            const flags = r.u16();
+            const cr = r.u8();
+            const cg = r.u8();
+            const cb = r.u8();
+            const ca = r.u8();
+            if (flags & 1) {
+              r.str();
+            }
+            palette[i] = [cr, cg, cb, ca];
+          }
+          void size;
+          break;
+        }
+        case CHUNK_OLD_PALETTE_04:
+        case CHUNK_OLD_PALETTE_11: {
+          const isLegacy6Bit = chunkType === CHUNK_OLD_PALETTE_11;
+          if (palette.length === 0) {
+            const packets = r.u16();
+            let idx = 0;
+            for (let p = 0; p < packets; p++) {
+              idx += r.u8();
+              let entries = r.u8();
+              if (entries === 0) {
+                entries = 256;
+              }
+              for (let e = 0; e < entries; e++) {
+                let cr = r.u8();
+                let cg = r.u8();
+                let cb = r.u8();
+                if (isLegacy6Bit) {
+                  cr = cr << 2 | cr >> 4;
+                  cg = cg << 2 | cg >> 4;
+                  cb = cb << 2 | cb >> 4;
+                }
+                palette[idx++] = [cr, cg, cb, 255];
+              }
+            }
+          }
+          break;
+        }
+        case CHUNK_TAGS: {
+          const count = r.u16();
+          r.skip(8);
+          for (let t = 0; t < count; t++) {
+            const from = r.u16();
+            const to = r.u16();
+            const dir = r.u8();
+            const repeat = r.u16();
+            r.skip(6);
+            r.skip(3);
+            r.skip(1);
+            const name = r.str();
+            tags.push({
+              name,
+              from,
+              to,
+              direction: TAG_DIRECTIONS[dir] || "forward",
+              repeat
+            });
+          }
+          break;
+        }
+        case CHUNK_TILESET:
+          throw new Error(ERR_TILEMAP_MODE);
+        default:
+          break;
+      }
+      r.offset = chunkEnd;
+    }
+    frames.push({ duration, cels });
+    r.offset = frameStart + frameSize;
+  }
+  return {
+    width,
+    height,
+    depth,
+    transparentIndex,
+    palette,
+    layers,
+    tags,
+    frames
+  };
+}
+function composite(parsed) {
+  const { width, height, depth, frames, layers, palette, transparentIndex } = parsed;
+  const stripWidth = width * frames.length;
+  const stripHeight = height;
+  const canvas = typeof OffscreenCanvas !== "undefined" ? new OffscreenCanvas(stripWidth, stripHeight) : Object.assign(document.createElement("canvas"), {
+    width: stripWidth,
+    height: stripHeight
+  });
+  const ctx = canvas.getContext("2d");
+  ctx.imageSmoothingEnabled = false;
+  for (let f = 0; f < frames.length; f++) {
+    const frame = frames[f];
+    const fx = f * width;
+    const ordered = frame.cels.slice().sort((a, b) => {
+      return a.layer - b.layer;
+    });
+    for (const cel of ordered) {
+      const layer = layers[cel.layer];
+      if (layer && layer.visible === false) {
+        continue;
+      }
+      let source = cel;
+      if (cel.linkFrame !== void 0) {
+        source = frames[cel.linkFrame]?.cels.find((c) => {
+          return c.layer === cel.layer;
+        });
+        if (!source || !source.raw) {
+          continue;
+        }
+      }
+      const rgba = decodeCelPixels(
+        source.raw,
+        source.w,
+        source.h,
+        depth,
+        palette,
+        transparentIndex
+      );
+      const img = new ImageData(rgba, source.w, source.h);
+      const tmp = typeof OffscreenCanvas !== "undefined" ? new OffscreenCanvas(source.w, source.h) : Object.assign(document.createElement("canvas"), {
+        width: source.w,
+        height: source.h
+      });
+      tmp.getContext("2d").putImageData(img, 0, 0);
+      if (cel.opacity !== 255) {
+        ctx.globalAlpha = cel.opacity / 255;
+      }
+      ctx.drawImage(tmp, fx + cel.x, cel.y);
+      if (cel.opacity !== 255) {
+        ctx.globalAlpha = 1;
+      }
+    }
+  }
+  return canvas;
+}
+function buildAtlasJSON(parsed, imageName) {
+  const { width, height, frames, tags } = parsed;
+  const out = {};
+  for (let i = 0; i < frames.length; i++) {
+    out[String(i)] = {
+      frame: { x: i * width, y: 0, w: width, h: height },
+      rotated: false,
+      trimmed: false,
+      spriteSourceSize: { x: 0, y: 0, w: width, h: height },
+      sourceSize: { w: width, h: height },
+      duration: frames[i].duration
+    };
+  }
+  return {
+    frames: out,
+    meta: {
+      app: "http://www.aseprite.org/",
+      version: "binary",
+      image: imageName,
+      format: "RGBA8888",
+      size: { w: width * frames.length, h: height },
+      scale: "1",
+      frameTags: tags
+    }
+  };
+}
+async function canvasToBitmap(canvas) {
+  if (typeof canvas.transferToImageBitmap === "function" && typeof createImageBitmap === "function") {
+    return canvas.transferToImageBitmap();
+  }
+  if (typeof createImageBitmap === "function") {
+    return await createImageBitmap(canvas);
+  }
+  return canvas;
+}
+async function parseAseprite(buffer, imageName = "default") {
+  const parsed = await parseAsepriteFile(buffer);
+  const canvas = composite(parsed);
+  const bitmap = await canvasToBitmap(canvas);
+  const json = buildAtlasJSON(parsed, imageName);
+  return { bitmap, json };
+}
+function preloadAseprite(data2, onload2, onerror, settings) {
+  fetchData(data2.src, "arrayBuffer", settings).then(async (buffer) => {
+    const { bitmap, json } = await parseAseprite(buffer, data2.name);
+    imgList[data2.name] = bitmap;
+    jsonList[data2.name] = json;
+    if (typeof onload2 === "function") {
+      onload2();
+    }
+  }).catch((error) => {
+    console.error(`Failed to parse aseprite asset "${data2.name}":`, error);
+    if (typeof onerror === "function") {
+      onerror(error);
+    }
+  });
+  return 1;
+}
+
 // src/loader/parsers/binary.js
 function preloadBinary(data2, onload2, onerror, settings) {
   fetchData(data2.src, "arrayBuffer", settings).then((response) => {
@@ -13512,6 +14435,13 @@ var isStringArray = (value) => {
 function deferredRemove(child, keepalive) {
   this.removeChildNow(child, keepalive);
 }
+function registerChildBody(child, worldContainer) {
+  if (child.bodyDef) {
+    worldContainer.adapter.addBody(child, child.bodyDef);
+  } else if (child.body instanceof Body) {
+    worldContainer.addBody(child.body);
+  }
+}
 var globalFloatingCounter = 0;
 var Container = class _Container extends Renderable {
   /**
@@ -13536,7 +14466,6 @@ var Container = class _Container extends Renderable {
     };
     this.enableChildBoundsUpdate = false;
     this.backgroundColor = colorPool.get(0, 0, 0, 0);
-    this.drawCount = 0;
     this.autoTransform = true;
     this.isKinematic = false;
     this.anchorPoint.set(0, 0);
@@ -13601,7 +14530,7 @@ var Container = class _Container extends Renderable {
       throw new Error(`${String(child)} is not an instance of Renderable`);
     }
     if (child.ancestor instanceof _Container) {
-      child.ancestor.removeChildNow(child);
+      child.ancestor.removeChildNow(child, true);
     } else {
       child.GUID = createGUID(child.id);
     }
@@ -13619,25 +14548,21 @@ var Container = class _Container extends Renderable {
     if (this.autoSort === true) {
       this.sort();
     }
-    if (typeof child.onActivateEvent === "function" && this.isAttachedToRoot()) {
-      child.onActivateEvent();
-    }
-    if (this.enableChildBoundsUpdate === true) {
-      this.updateBounds();
-    }
     if (this.isAttachedToRoot()) {
       const worldContainer = this.getRootAncestor();
-      if (child.body instanceof Body) {
-        worldContainer.addBody(child.body);
-      }
+      registerChildBody(child, worldContainer);
       if (child instanceof _Container) {
         child.forEach((cchild) => {
-          if (cchild.body instanceof Body) {
-            worldContainer.addBody(cchild.body);
-          }
+          registerChildBody(cchild, worldContainer);
         });
       }
     }
+    if (typeof child.onActivateEvent === "function" && this.isAttachedToRoot()) {
+      child.onActivateEvent();
+    }
+    if (this.enableChildBoundsUpdate === true) {
+      this.updateBounds();
+    }
     this.isDirty = true;
     this.onChildChange.call(this, this.getChildren().length - 1);
     return child;
@@ -13655,7 +14580,7 @@ var Container = class _Container extends Renderable {
     }
     if (index >= 0 && index <= this.getChildren().length) {
       if (child.ancestor instanceof _Container) {
-        child.ancestor.removeChildNow(child);
+        child.ancestor.removeChildNow(child, true);
       } else {
         child.GUID = createGUID();
       }
@@ -13665,25 +14590,21 @@ var Container = class _Container extends Renderable {
         child.floating = false;
       }
       child.updateBounds();
-      if (typeof child.onActivateEvent === "function" && this.isAttachedToRoot()) {
-        child.onActivateEvent();
-      }
-      if (this.enableChildBoundsUpdate === true) {
-        this.updateBounds();
-      }
       if (this.isAttachedToRoot()) {
         const worldContainer = this.getRootAncestor();
-        if (child.body instanceof Body) {
-          worldContainer.addBody(child.body);
-        }
+        registerChildBody(child, worldContainer);
         if (child instanceof _Container) {
           child.forEach((cchild) => {
-            if (cchild.body instanceof Body) {
-              worldContainer.addBody(cchild.body);
-            }
+            registerChildBody(cchild, worldContainer);
           });
         }
       }
+      if (typeof child.onActivateEvent === "function" && this.isAttachedToRoot()) {
+        child.onActivateEvent();
+      }
+      if (this.enableChildBoundsUpdate === true) {
+        this.updateBounds();
+      }
       this.isDirty = true;
       this.onChildChange.call(this, index);
       return child;
@@ -13928,8 +14849,11 @@ var Container = class _Container extends Renderable {
   }
   /**
    * @ignore
+   * @param {...*} _args - reserved; widens the signature so subclass
+   *   overrides like `onActivateEvent(app)` remain structurally
+   *   assignable to the base Container/Renderable type.
    */
-  onActivateEvent() {
+  onActivateEvent(..._args) {
     this.forEach((child) => {
       if (typeof child.onActivateEvent === "function") {
         child.onActivateEvent();
@@ -13961,10 +14885,23 @@ var Container = class _Container extends Renderable {
       if (typeof child.onDeactivateEvent === "function") {
         child.onDeactivateEvent();
       }
-      if (child.body instanceof Body) {
-        const root = this.getRootAncestor();
-        if (root) {
-          root.removeBody(child.body);
+      const root = this.getRootAncestor();
+      if (root?.broadphase) {
+        if (typeof child.addChild === "function") {
+          root.broadphase.removeContainer(child);
+        }
+        root.broadphase.remove(child);
+      }
+      if (child.body) {
+        const world = root;
+        if (world?.adapter?.removeBody) {
+          world.adapter.removeBody(child);
+        } else if (child.body instanceof Body) {
+          root?.removeBody?.(child.body);
+        } else {
+          console.warn(
+            "melonJS: removeChildNow could not clean up an adapter-specific body \u2014 the container is not attached to a world with an adapter. The body remains in the physics engine."
+          );
         }
       }
       if (!keepalive) {
@@ -14074,8 +15011,11 @@ var Container = class _Container extends Renderable {
   }
   /**
    * @ignore
+   * @param {...*} _args - reserved; widens the signature so subclass
+   *   overrides like `onDeactivateEvent(app)` remain structurally
+   *   assignable to the base Container/Renderable type.
    */
-  onDeactivateEvent() {
+  onDeactivateEvent(..._args) {
     this.forEach((child) => {
       if (typeof child.onDeactivateEvent === "function") {
         child.onDeactivateEvent();
@@ -14160,7 +15100,6 @@ var Container = class _Container extends Renderable {
    */
   draw(renderer2, viewport) {
     const bounds = this.getBounds();
-    this.drawCount = 0;
     renderer2.translate(this.pos.x, this.pos.y);
     if (this.root === false && this.clipping === true && bounds.isFinite() === true && Number.isFinite(this.width) === true && Number.isFinite(this.height) === true) {
       renderer2.clipRect(0, 0, this.width, this.height);
@@ -14192,7 +15131,6 @@ var Container = class _Container extends Renderable {
           }
           renderer2.restore();
         }
-        this.drawCount++;
       }
     }
   }
@@ -14504,16 +15442,14 @@ var CanvasRenderTarget = class extends RenderTarget {
    * @ignore
    */
   destroy(renderer2) {
-    if (renderer2 && typeof renderer2.gl !== "undefined" && typeof this.glTextureUnit !== "undefined") {
+    if (renderer2 && typeof renderer2.gl !== "undefined" && this.canvas && renderer2.cache.has(this.canvas)) {
       renderer2.setBatcher("quad");
-      renderer2.currentBatcher.deleteTexture2D(
-        renderer2.currentBatcher.getTexture2D(this.glTextureUnit)
-      );
-      this.glTextureUnit = void 0;
+      renderer2.currentBatcher.deleteTexture2D(renderer2.cache.get(this.canvas));
     }
     if (renderer2) {
       renderer2.cache.delete(this.canvas);
     }
+    this.glTextureUnit = void 0;
     this.context = void 0;
     this.canvas = void 0;
   }
@@ -15512,6 +16448,7 @@ var Renderer = class {
     this.currentColor = this.renderState.currentColor;
     this.currentTint = this.renderState.currentTint;
     this.currentScissor = this.renderState.currentScissor;
+    this.lineWidth = 1;
     this.maskLevel = 0;
     this.projectionMatrix = new Matrix3d();
     this.uvOffset = 0;
@@ -16059,6 +16996,128 @@ var Renderer = class {
     context.drawImage(src, 0, 0);
     return canvasTexture.canvas;
   }
+  /**
+   * Push the current transform / alpha / clip state onto an internal
+   * stack. Pair with {@link Renderer#restore}. Implemented by subclasses.
+   */
+  save() {
+  }
+  /**
+   * Pop the topmost saved state from the stack, restoring transform,
+   * alpha and clip. Pair with {@link Renderer#save}. Implemented by
+   * subclasses.
+   */
+  restore() {
+  }
+  /**
+   * Translate the current transform by `(x, y)`. Implemented by subclasses.
+   * @param {number} x - horizontal translation in pixels
+   * @param {number} y - vertical translation in pixels
+   */
+  // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
+  translate(x, y) {
+  }
+  /**
+   * Rotate the current transform by `angle` (radians). Implemented by subclasses.
+   * @param {number} angle - rotation angle in radians
+   */
+  // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
+  rotate(angle) {
+  }
+  /**
+   * Scale the current transform by `(x, y)`. Implemented by subclasses.
+   * @param {number} x - horizontal scale factor
+   * @param {number} y - vertical scale factor
+   */
+  // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
+  scale(x, y) {
+  }
+  /**
+   * Set the renderer global alpha (0..1) for subsequent draw calls.
+   * Implemented by subclasses.
+   * @param {number} alpha - opacity value in the [0..1] range
+   */
+  // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
+  setGlobalAlpha(alpha2) {
+  }
+  /**
+   * Fill an axis-aligned rectangle with the current color.
+   * Implemented by subclasses.
+   * @param {number} x - left edge in viewport pixels
+   * @param {number} y - top edge in viewport pixels
+   * @param {number} width - rectangle width
+   * @param {number} height - rectangle height
+   */
+  // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
+  fillRect(x, y, width, height) {
+  }
+  /**
+   * Stroke (outline) an axis-aligned rectangle with the current color
+   * at the current {@link Renderer#lineWidth}. Implemented by subclasses.
+   * @param {number} x - left edge in viewport pixels
+   * @param {number} y - top edge in viewport pixels
+   * @param {number} width - rectangle width
+   * @param {number} height - rectangle height
+   * @param {boolean} [fill=false] - also fill the rectangle
+   */
+  // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
+  strokeRect(x, y, width, height, fill) {
+  }
+  /**
+   * Fill an axis-aligned ellipse with the current color.
+   * Implemented by subclasses.
+   * @param {number} x - ellipse center X in viewport pixels
+   * @param {number} y - ellipse center Y in viewport pixels
+   * @param {number} w - horizontal radius
+   * @param {number} h - vertical radius
+   */
+  // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
+  fillEllipse(x, y, w, h) {
+  }
+  /**
+   * Stroke (outline) an axis-aligned ellipse with the current color
+   * at the current {@link Renderer#lineWidth}. Implemented by subclasses.
+   * @param {number} x - ellipse center X in viewport pixels
+   * @param {number} y - ellipse center Y in viewport pixels
+   * @param {number} w - horizontal radius
+   * @param {number} h - vertical radius
+   * @param {boolean} [fill=false] - also fill the ellipse
+   */
+  // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
+  strokeEllipse(x, y, w, h, fill) {
+  }
+  /**
+   * Draw a straight line between two points with the current color
+   * at the current {@link Renderer#lineWidth}. Implemented by subclasses.
+   * @param {number} startX - start X in viewport pixels
+   * @param {number} startY - start Y in viewport pixels
+   * @param {number} endX - end X in viewport pixels
+   * @param {number} endY - end Y in viewport pixels
+   */
+  // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
+  strokeLine(startX, startY, endX, endY) {
+  }
+  /**
+   * Draw an image or sub-image into the framebuffer.
+   * Implemented by subclasses (`CanvasRenderer` / `WebGLRenderer`).
+   *
+   * The 9-argument signature shown here is the canonical form used
+   * throughout the engine; the concrete renderers also accept the
+   * shorter `drawImage(image, dx, dy)` and `drawImage(image, dx, dy,
+   * dWidth, dHeight)` variants from the HTML Canvas2D spec.
+   * @param {HTMLImageElement|SVGImageElement|HTMLVideoElement|HTMLCanvasElement|ImageBitmap|OffscreenCanvas|VideoFrame} image - the source image
+   * @param {number} sx - source rectangle left
+   * @param {number} sy - source rectangle top
+   * @param {number} sw - source rectangle width
+   * @param {number} sh - source rectangle height
+   * @param {number} dx - destination left
+   * @param {number} dy - destination top
+   * @param {number} dw - destination width
+   * @param {number} dh - destination height
+   */
+  // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
+  drawImage(image, sx, sy, sw, sh, dx, dy, dw, dh) {
+  }
   /**
    * A mask limits rendering elements to the shape and position of the given mask object.
    * So, if the renderable is larger than the mask, only the intersecting part of the renderable will be visible.
@@ -16161,7 +17220,7 @@ var ArrayMultimap = class {
 };
 
 // src/video/texture/parser/aseprite.js
-function parseAseprite(data2, textureAtlas) {
+function parseAseprite2(data2, textureAtlas) {
   const atlas = {};
   const frames = data2.frames;
   for (const name in frames) {
@@ -16419,7 +17478,7 @@ var TextureAtlas = class {
               } else {
                 this.atlases.set(
                   atlas.meta.image || "default",
-                  parseAseprite(atlas, this)
+                  parseAseprite2(atlas, this)
                 );
               }
               break;
@@ -20553,6 +21612,65 @@ var TMXTileset = class {
     }
     if (!this.isCollection) {
       this._initAtlas(tileset);
+      this._applyAsepriteFrameTags(tileset);
+    }
+  }
+  /**
+   * If `tileset.image` was loaded via the .aseprite binary parser, walk
+   * its `meta.frameTags` and synthesize per-tile animations. Each tag
+   * `{ from, to }` becomes an animation on tile `from` that cycles through
+   * tiles `[from..to]` using each frame's `duration`.
+   *
+   * Throws on tag configurations that don't map to Tiled's animation model:
+   * non-forward direction (Tiled animations are forward-only) and non-zero
+   * repeat counts (Tiled animations loop forever).
+   * @ignore
+   */
+  _applyAsepriteFrameTags(tileset) {
+    const atlas = getJSON(getBasename("" + tileset.image));
+    if (!atlas || !atlas.meta || typeof atlas.meta.app !== "string") {
+      return;
+    }
+    if (!atlas.meta.app.includes("aseprite")) {
+      return;
+    }
+    const tags = atlas.meta.frameTags;
+    if (!Array.isArray(tags) || tags.length === 0) {
+      return;
+    }
+    const frames = atlas.meta.frames || atlas.frames || {};
+    for (const tag of tags) {
+      if (tag.direction !== "forward") {
+        throw new Error(
+          `melonJS: aseprite tag "${tag.name}" on tileset '${this.name}' uses direction "${tag.direction}" \u2014 Tiled tile animations only support forward playback. Re-export the tag as "forward" in Aseprite.`
+        );
+      }
+      if (typeof tag.repeat === "number" && tag.repeat !== 0) {
+        throw new Error(
+          `melonJS: aseprite tag "${tag.name}" on tileset '${this.name}' has a finite repeat count (${tag.repeat}) \u2014 Tiled tile animations only support infinite looping. Set the tag's repeat to "\u221E" in Aseprite.`
+        );
+      }
+      const anim = [];
+      for (let f = tag.from; f <= tag.to; f++) {
+        const frame = frames[String(f)] || frames[f];
+        anim.push({
+          tileid: f,
+          duration: frame && typeof frame.duration === "number" ? frame.duration : 100
+        });
+      }
+      if (anim.length === 0) {
+        continue;
+      }
+      if (this.animations.has(tag.from)) {
+        continue;
+      }
+      this.isAnimated = true;
+      this.animations.set(tag.from, {
+        dt: 0,
+        idx: 0,
+        frames: anim,
+        cur: anim[0]
+      });
     }
   }
   /**
@@ -21236,9 +22354,14 @@ var TMXTileMap = class {
           settings.tint = parseTintColor(settings.tintcolor);
         }
         const obj = createTMXObject(settings, this);
-        if (isCollisionGroup && !settings.name && obj.body) {
-          obj.body.collisionType = collision.types.WORLD_SHAPE;
-          obj.body.isStatic = true;
+        if (isCollisionGroup && !settings.name) {
+          if (obj.bodyDef) {
+            obj.bodyDef.collisionType = collision.types.WORLD_SHAPE;
+            obj.bodyDef.type = "static";
+          } else if (obj.body) {
+            obj.body.collisionType = collision.types.WORLD_SHAPE;
+            obj.body.isStatic = true;
+          }
         }
         if (obj.isRenderable === true && !(settings instanceof TMXLayer)) {
           if (!settings.visible) {
@@ -21657,6 +22780,7 @@ function setBaseURL(type, url = "./") {
     baseURL["tmx"] = url;
     baseURL["tsx"] = url;
     baseURL["fontface"] = url;
+    baseURL["aseprite"] = url;
   }
 }
 var onload;
@@ -21679,6 +22803,7 @@ function initParsers() {
   setParser("video", preloadVideo);
   setParser("obj", preloadOBJ);
   setParser("mtl", preloadMTL);
+  setParser("aseprite", preloadAseprite);
   parserInitialized = true;
 }
 function completeLoading(onloadcb) {
@@ -21852,6 +22977,16 @@ function unload2(asset) {
       }
       delete mtlList[asset.name];
       return true;
+    case "aseprite": {
+      const hadImage = asset.name in imgList;
+      const hadJson = asset.name in jsonList;
+      if (!hadImage && !hadJson) {
+        return false;
+      }
+      delete imgList[asset.name];
+      delete jsonList[asset.name];
+      return true;
+    }
     default:
       throw new Error(
         "unload : unknown or invalid resource type : " + asset.type
@@ -23799,7 +24934,6 @@ var Camera2d = class extends Renderable {
     }
   }
   /** @ignore */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   updateTarget(_dt) {
     if (this.target) {
       targetV.setV(this.pos);
@@ -24528,7 +25662,7 @@ function _endFreeze() {
   const wasOwnedPause = _freezeStartedPause;
   _freezeStartedPause = false;
   if (wasOwnedPause) {
-    state.resume(_freezeMusic);
+    state2.resume(_freezeMusic);
   }
   _resolveFreezeWaiters();
 }
@@ -24573,19 +25707,19 @@ function _switchState(stateId) {
 }
 var _app;
 once(BOOT, () => {
-  state.set(state.LOADING, new loadingscreen_default());
-  state.set(state.DEFAULT, new Stage());
+  state2.set(state2.LOADING, new loadingscreen_default());
+  state2.set(state2.DEFAULT, new Stage());
   on(GAME_INIT, (app) => {
     _app = app;
   });
   once(VIDEO_INIT, () => {
-    state.change(state.DEFAULT, true);
+    state2.change(state2.DEFAULT, true);
   });
   on(BLUR, () => {
     _cancelFreeze();
   });
 });
-var state = {
+var state2 = {
   /**
    * default state ID for Loading Stage
    */
@@ -24875,7 +26009,7 @@ var state = {
         const onComplete = () => {
           defer(
             _switchState,
-            state,
+            state2,
             stateId
           );
         };
@@ -24961,7 +26095,7 @@ var state = {
     return _state === stateId;
   }
 };
-var state_default = state;
+var state_default = state2;
 
 // src/system/timer.ts
 var Timer = class {
@@ -25109,10 +26243,17 @@ var Timer = class {
     return this.delta;
   }
   /**
-   * compute the actual frame time and fps rate
+   * update
    * @ignore
    */
-  countFPS() {
+  update(time) {
+    this.last = this.now;
+    this.now = time;
+    this.delta = this.now - this.last;
+    if (this.delta < 0) {
+      this.delta = 0;
+    }
+    this.tick = this.delta > this.minstep && this.interpolation ? this.delta / this.step : 1;
     this.framecount++;
     this.framedelta += this.delta;
     if (this.framecount % 10 === 0) {
@@ -25124,19 +26265,6 @@ var Timer = class {
       this.framedelta = 0;
       this.framecount = 0;
     }
-  }
-  /**
-   * update
-   * @ignore
-   */
-  update(time) {
-    this.last = this.now;
-    this.now = time;
-    this.delta = this.now - this.last;
-    if (this.delta < 0) {
-      this.delta = 0;
-    }
-    this.tick = this.delta > this.minstep && this.interpolation ? this.delta / this.step : 1;
     this.updateTimers();
   }
   /**
@@ -26075,14 +27203,24 @@ function createShapeObject(settings) {
     settings.height
   );
   const shape = getDefaultShape(settings);
+  if (!shape || Array.isArray(shape) && shape.length === 0) {
+    throw new Error(
+      `melonJS: TMX object (id=${settings.id}, name=${settings.name ?? ""}, type=${settings.type ?? ""}) has no usable collision shape. Check the object's geometry in Tiled.`
+    );
+  }
   obj.anchorPoint.set(0, 0);
   obj.name = settings.name;
   obj.type = settings.type;
   obj.class = settings.class || settings.type;
   obj.id = settings.id;
-  obj.body = new Body(obj, shape);
-  obj.body.setStatic(true);
-  obj.resize(obj.body.getBounds().width, obj.body.getBounds().height);
+  obj.bodyDef = {
+    type: "static",
+    shapes: Array.isArray(shape) ? shape : [shape]
+  };
+  const bounds = boundsPool.get();
+  bounds.addShapes(obj.bodyDef.shapes, true);
+  obj.resize(bounds.width, bounds.height);
+  boundsPool.release(bounds);
   obj.pos.z = settings.z;
   return obj;
 }
@@ -26909,8 +28047,10 @@ function createTextObject(settings) {
 function createTileObject(settings) {
   const shape = getDefaultShape(settings);
   const obj = settings.tile.getRenderable(settings);
-  obj.body = new Body(obj, shape);
-  obj.body.setStatic(true);
+  obj.bodyDef = {
+    type: "static",
+    shapes: Array.isArray(shape) ? shape : [shape]
+  };
   obj.pos.setMuted(settings.x, settings.y, settings.z);
   return obj;
 }
@@ -27217,10 +28357,14 @@ var Collectable = class extends Sprite {
         vector2dPool.get(this.width, this.height)
       ]);
     }
-    this.body = new Body(this, shape);
-    this.body.collisionType = collision.types.COLLECTABLE_OBJECT;
-    this.body.setCollisionMask(collision.types.PLAYER_OBJECT);
-    this.body.setStatic(true);
+    this.bodyDef = {
+      type: "static",
+      shapes: Array.isArray(shape) ? shape : [shape],
+      collisionType: collision.types.COLLECTABLE_OBJECT,
+      // by default only collides with PLAYER_OBJECT
+      collisionMask: collision.types.PLAYER_OBJECT,
+      isSensor: true
+    };
     if (settings.anchorPoint) {
       this.anchorPoint.set(settings.anchorPoint.x, settings.anchorPoint.y);
     } else {
@@ -28182,11 +29326,17 @@ var Trigger = class extends Renderable {
         vector2dPool.get(this.width, this.height)
       ]);
     }
-    this.body = new Body(this, shape);
-    this.body.collisionType = collision.types.ACTION_OBJECT;
-    this.body.setCollisionMask(collision.types.PLAYER_OBJECT);
-    this.body.setStatic(true);
-    this.resize(this.body.getBounds().width, this.body.getBounds().height);
+    this.bodyDef = {
+      type: "static",
+      shapes: Array.isArray(shape) ? shape : [shape],
+      collisionType: collision.types.ACTION_OBJECT,
+      collisionMask: collision.types.PLAYER_OBJECT,
+      isSensor: true
+    };
+    const bounds = boundsPool.get();
+    bounds.addShapes(this.bodyDef.shapes, true);
+    this.resize(bounds.width, bounds.height);
+    boundsPool.release(bounds);
   }
   /**
    * @ignore
@@ -28277,21 +29427,20 @@ var Trigger = class extends Renderable {
     }
   }
   /**
-   * onCollision callback, triggered in case of collision with this trigger
-   * @param {ResponseObject} response - the collision response object
-   * @param {Renderable} other - the other renderable touching this one (a reference to response.a or response.b)
-   * @returns {boolean} true if the object should respond to the collision (its position and velocity will be corrected)
+   * Fire the trigger when an entity first enters the trigger zone.
+   * Using `onCollisionStart` rather than `onCollision` so the event
+   * runs exactly once per entry — under the legacy alias this would
+   * fire every frame the entity was inside the trigger.
    */
-  onCollision() {
+  onCollisionStart() {
     if (this.name === "Trigger") {
       this.triggerEvent();
     }
-    return false;
   }
 };
 
 // src/version.ts
-var version = "19.4.0";
+var version = "19.5.0";
 
 // src/system/bootstrap.ts
 var initialized = false;
@@ -29527,7 +30676,167 @@ var ResponseObject = class {
 };
 var response_default = ResponseObject;
 
-// src/physics/sat.js
+// src/physics/builtin/raycast.ts
+function _cross(ax, ay, bx, by) {
+  return ax * by - ay * bx;
+}
+function _computeShapeAbsPos(renderable, shape, outPos) {
+  const ancestor = renderable.ancestor;
+  const ancestorAbs = ancestor && typeof ancestor.getAbsolutePosition === "function" ? ancestor.getAbsolutePosition() : null;
+  const ax = ancestorAbs ? ancestorAbs.x : 0;
+  const ay = ancestorAbs ? ancestorAbs.y : 0;
+  outPos.x = renderable.pos.x + ax + shape.pos.x;
+  outPos.y = renderable.pos.y + ay + shape.pos.y;
+}
+var _shapeAbs = new Vector2d(0, 0);
+function _raycastPolygon(fromX, fromY, dx, dy, shape, shapeAbsX, shapeAbsY) {
+  const points = shape.points;
+  const normals = shape.normals;
+  const len = points.length;
+  let bestT = Infinity;
+  let bestNormalIdx = -1;
+  for (let i = 0; i < len; i++) {
+    const p0 = points[i];
+    const p1 = points[(i + 1) % len];
+    const ax = shapeAbsX + p0.x;
+    const ay = shapeAbsY + p0.y;
+    const ex = p1.x - p0.x;
+    const ey = p1.y - p0.y;
+    const denom = _cross(dx, dy, ex, ey);
+    if (Math.abs(denom) < 1e-9) {
+      continue;
+    }
+    const fx = ax - fromX;
+    const fy = ay - fromY;
+    const t = _cross(fx, fy, ex, ey) / denom;
+    const s = _cross(fx, fy, dx, dy) / denom;
+    if (t >= 0 && t <= 1 && s >= 0 && s <= 1 && t < bestT) {
+      bestT = t;
+      bestNormalIdx = i;
+    }
+  }
+  if (bestNormalIdx === -1) {
+    return null;
+  }
+  const normal = normals[bestNormalIdx];
+  return { t: bestT, normalX: normal.x, normalY: normal.y };
+}
+function _raycastEllipse(fromX, fromY, dx, dy, shape, shapeAbsX, shapeAbsY) {
+  const cx = shapeAbsX;
+  const cy = shapeAbsY;
+  const rx = shape.radiusV.x;
+  const ry = shape.radiusV.y;
+  if (rx <= 0 || ry <= 0) {
+    return null;
+  }
+  const ox = (fromX - cx) / rx;
+  const oy = (fromY - cy) / ry;
+  const ddx = dx / rx;
+  const ddy = dy / ry;
+  const A = ddx * ddx + ddy * ddy;
+  const B = 2 * (ddx * ox + ddy * oy);
+  const C = ox * ox + oy * oy - 1;
+  const disc = B * B - 4 * A * C;
+  if (disc < 0 || A < 1e-12) {
+    return null;
+  }
+  const sqrtDisc = Math.sqrt(disc);
+  const t0 = (-B - sqrtDisc) / (2 * A);
+  const t1 = (-B + sqrtDisc) / (2 * A);
+  let t;
+  if (t0 >= 0 && t0 <= 1) {
+    t = t0;
+  } else if (t1 >= 0 && t1 <= 1) {
+    t = t1;
+  } else {
+    return null;
+  }
+  const hitX = fromX + dx * t;
+  const hitY = fromY + dy * t;
+  let nx = (hitX - cx) / (rx * rx);
+  let ny = (hitY - cy) / (ry * ry);
+  const nLen = Math.hypot(nx, ny);
+  if (nLen > 0) {
+    nx /= nLen;
+    ny /= nLen;
+  }
+  return { t, normalX: nx, normalY: ny };
+}
+function raycastQuery(world, fromX, fromY, toX, toY) {
+  const dx = toX - fromX;
+  const dy = toY - fromY;
+  const segLen = Math.hypot(dx, dy);
+  if (segLen < 1e-9) {
+    return [];
+  }
+  const line = linePool.get(fromX, fromY, [
+    new Vector2d(0, 0),
+    new Vector2d(dx, dy)
+  ]);
+  const candidates = [];
+  world.broadphase.retrieve(line, void 0, candidates);
+  const hits = [];
+  for (let i = candidates.length - 1; i >= 0; i--) {
+    const objB = candidates[i];
+    if (!objB.body) {
+      continue;
+    }
+    if (!line.getBounds().overlaps(objB.getBounds())) {
+      continue;
+    }
+    const bodyB = objB.body;
+    const shapeCount = bodyB.shapes.length;
+    if (shapeCount === 0) {
+      continue;
+    }
+    let bestT = Infinity;
+    let bestNormalX = 0;
+    let bestNormalY = 0;
+    for (let j = 0; j < shapeCount; j++) {
+      const shapeB = bodyB.getShape(j);
+      _computeShapeAbsPos(objB, shapeB, _shapeAbs);
+      const hit = shapeB.type === "Ellipse" ? _raycastEllipse(
+        fromX,
+        fromY,
+        dx,
+        dy,
+        shapeB,
+        _shapeAbs.x,
+        _shapeAbs.y
+      ) : _raycastPolygon(
+        fromX,
+        fromY,
+        dx,
+        dy,
+        shapeB,
+        _shapeAbs.x,
+        _shapeAbs.y
+      );
+      if (hit !== null && hit.t < bestT) {
+        bestT = hit.t;
+        bestNormalX = hit.normalX;
+        bestNormalY = hit.normalY;
+      }
+    }
+    if (bestT === Infinity) {
+      continue;
+    }
+    const flipSign = bestNormalX * dx + bestNormalY * dy > 0 ? -1 : 1;
+    hits.push({
+      renderable: objB,
+      point: new Vector2d(fromX + dx * bestT, fromY + dy * bestT),
+      normal: new Vector2d(bestNormalX * flipSign, bestNormalY * flipSign),
+      fraction: bestT
+    });
+  }
+  linePool.release(line);
+  hits.sort((a, b) => {
+    return a.fraction - b.fraction;
+  });
+  return hits;
+}
+
+// src/physics/builtin/sat.js
 var LEFT_VORNOI_REGION = -1;
 var MIDDLE_VORNOI_REGION = 0;
 var RIGHT_VORNOI_REGION = 1;
@@ -29805,7 +31114,7 @@ function testEllipsePolygon(a, ellipseA, b, polyB, response) {
   return result;
 }
 
-// src/physics/detector.js
+// src/physics/builtin/detector.js
 var SAT_LOOKUP = {
   PolygonPolygon: testPolygonPolygon,
   PolygonEllipse: testPolygonEllipse,
@@ -29824,15 +31133,6 @@ var SAT_LOOKUP = {
   RectangleRoundRect: testPolygonPolygon,
   RoundRectRectangle: testPolygonPolygon
 };
-var dummyObj = {
-  pos: new Vector2d(0, 0),
-  ancestor: {
-    _absPos: new Vector2d(0, 0),
-    getAbsolutePosition: function() {
-      return this._absPos;
-    }
-  }
-};
 var boundsA = new Bounds();
 var boundsB = new Bounds();
 var Detector = class {
@@ -29842,6 +31142,116 @@ var Detector = class {
   constructor(world) {
     this.world = world;
     this.response = new response_default();
+    this._activePairs = /* @__PURE__ */ new Map();
+    this._frameSeen = /* @__PURE__ */ new Map();
+    this._symViews = [
+      {
+        a: null,
+        b: null,
+        overlap: 0,
+        overlapN: { x: 0, y: 0 },
+        overlapV: { x: 0, y: 0 },
+        normal: { x: 0, y: 0 },
+        depth: 0
+      },
+      {
+        a: null,
+        b: null,
+        overlap: 0,
+        overlapN: { x: 0, y: 0 },
+        overlapV: { x: 0, y: 0 },
+        normal: { x: 0, y: 0 },
+        depth: 0
+      }
+    ];
+  }
+  /**
+   * Populate one of the pooled symmetric views from a SAT response.
+   * `flip=false` builds the view for `response.a`'s side (legacy
+   * fields kept as-is, `normal = -overlapN` = MTV of original a).
+   * `flip=true` builds it for `response.b`'s side: `a` / `b` swap,
+   * `overlapN` / `overlapV` negated, `normal = +overlapN` (the MTV
+   * of original b).
+   * @ignore
+   */
+  _fillSymView(slot, satResponse, flip) {
+    const view = this._symViews[slot];
+    const oN = satResponse.overlapN;
+    const oV = satResponse.overlapV;
+    if (flip) {
+      view.a = satResponse.b;
+      view.b = satResponse.a;
+      view.overlapN.x = -oN.x;
+      view.overlapN.y = -oN.y;
+      view.overlapV.x = -oV.x;
+      view.overlapV.y = -oV.y;
+      view.normal.x = oN.x;
+      view.normal.y = oN.y;
+    } else {
+      view.a = satResponse.a;
+      view.b = satResponse.b;
+      view.overlapN.x = oN.x;
+      view.overlapN.y = oN.y;
+      view.overlapV.x = oV.x;
+      view.overlapV.y = oV.y;
+      view.normal.x = -oN.x;
+      view.normal.y = -oN.y;
+    }
+    view.overlap = satResponse.overlap;
+    view.depth = satResponse.overlap;
+    return view;
+  }
+  /**
+   * Called by the adapter at the start of a physics step. Resets the
+   * "seen this frame" set so the end-of-step diff can fire
+   * `onCollisionEnd` for pairs that no longer overlap.
+   * @ignore
+   */
+  beginFrame() {
+    this._frameSeen.clear();
+  }
+  /**
+   * Called by the adapter at the end of a physics step. Diffs the
+   * "seen this frame" set against the previous-frame active pairs:
+   *   - pairs in active but not seen → fire onCollisionEnd
+   *   - swap active ← seen for the next step's diff
+   * @ignore
+   */
+  endFrame() {
+    for (const [key, pair] of this._activePairs) {
+      if (this._frameSeen.has(key)) {
+        continue;
+      }
+      const [a, b] = pair;
+      const aAttached = a.ancestor != null;
+      const bAttached = b.ancestor != null;
+      if (!aAttached && !bAttached) {
+        continue;
+      }
+      if (aAttached && typeof a.onCollisionEnd === "function") {
+        a.onCollisionEnd(void 0, b);
+      }
+      if (bAttached && typeof b.onCollisionEnd === "function") {
+        b.onCollisionEnd(void 0, a);
+      }
+    }
+    const prev = this._activePairs;
+    this._activePairs = this._frameSeen;
+    this._frameSeen = prev;
+  }
+  /**
+   * Build a stable order-independent key for a pair of renderables,
+   * using their GUID. Returns undefined if either lacks a GUID (defensive
+   * — detached or pool-recycled objects mid-step).
+   * @ignore
+   */
+  _pairKey(a, b) {
+    const ga = a.GUID;
+    const gb = b.GUID;
+    if (ga === void 0 || gb === void 0) {
+      return void 0;
+    }
+    return ga < gb ? `${ga}|${gb}` : `${gb}|${ga}`;
   }
   /**
    * determine if two objects should collide (based on both respective objects body collision mask and type).<br>
@@ -29902,10 +31312,37 @@ var Detector = class {
         if (boundsA.overlaps(boundsB)) {
           if (this.collides(objA.body, objB.body)) {
             collisionCounter++;
-            if (objA.onCollision && objA.onCollision(this.response, objB) !== false && objA.body.isStatic === false) {
+            const pairKey = this._pairKey(objA, objB);
+            const firstVisitThisFrame = pairKey !== void 0 && !this._frameSeen.has(pairKey);
+            if (firstVisitThisFrame) {
+              this._frameSeen.set(pairKey, [objA, objB]);
+              const isEntry = !this._activePairs.has(pairKey);
+              const viewA = this._fillSymView(0, this.response, false);
+              const viewB = this._fillSymView(1, this.response, true);
+              if (isEntry) {
+                if (typeof objA.onCollisionStart === "function") {
+                  objA.onCollisionStart(viewA, objB);
+                }
+                if (typeof objB.onCollisionStart === "function") {
+                  objB.onCollisionStart(viewB, objA);
+                }
+              }
+              if (typeof objA.onCollisionActive === "function") {
+                objA.onCollisionActive(viewA, objB);
+              }
+              if (typeof objB.onCollisionActive === "function") {
+                objB.onCollisionActive(viewB, objA);
+              }
+            }
+            const eitherSensor = objA.body.isSensor === true || objB.body.isSensor === true;
+            const aHasModern = typeof objA.onCollisionActive === "function";
+            const bHasModern = typeof objB.onCollisionActive === "function";
+            const aOptsOut = !aHasModern && typeof objA.onCollision === "function" && objA.onCollision(this.response, objB) === false;
+            if (!aOptsOut && objA.body.isStatic === false && !eitherSensor) {
               objA.body.respondToCollision.call(objA.body, this.response);
             }
-            if (objB.onCollision && objB.onCollision(this.response, objA) !== false && objB.body.isStatic === false) {
+            const bOptsOut = !bHasModern && typeof objB.onCollision === "function" && objB.onCollision(this.response, objA) === false;
+            if (!bOptsOut && objB.body.isStatic === false && !eitherSensor) {
               objB.body.respondToCollision.call(objB.body, this.response);
             }
             if (objA.body.shapes.length > 1 || objB.body.shapes.length > 1) {
@@ -29976,41 +31413,275 @@ var Detector = class {
    *    }
    */
   rayCast(line, result = []) {
-    let collisionCounter = 0;
-    const candidates = this.world.broadphase.retrieve(line);
-    for (let i = candidates.length, objB; i--, objB = candidates[i]; ) {
-      if (objB.body && line.getBounds().overlaps(objB.getBounds())) {
-        const bLen = objB.body.shapes.length;
-        if (objB.body.shapes.length === 0) {
-          continue;
-        }
-        const shapeA = line;
-        let indexB = 0;
-        do {
-          const shapeB = objB.body.getShape(indexB);
-          if (SAT_LOOKUP[shapeA.type + shapeB.type].call(
-            this,
-            dummyObj,
-            // a reference to the object A
-            shapeA,
-            objB,
-            // a reference to the object B
-            shapeB
-          )) {
-            result[collisionCounter] = objB;
-            collisionCounter++;
+    const fromX = line.pos.x + line.points[0].x;
+    const fromY = line.pos.y + line.points[0].y;
+    const toX = line.pos.x + line.points[1].x;
+    const toY = line.pos.y + line.points[1].y;
+    const hits = raycastQuery(this.world, fromX, fromY, toX, toY);
+    for (let i = 0; i < hits.length; i++) {
+      result[i] = hits[i].renderable;
+    }
+    result.length = hits.length;
+    return result;
+  }
+};
+var detector_default = Detector;
+
+// src/physics/builtin/builtin-adapter.ts
+var BuiltinAdapter = class {
+  /**
+   * Short adapter identifier exposed as `world.physic`. Lets user code
+   * branch on the active physics implementation without importing the
+   * concrete adapter class.
+   */
+  physicLabel = "builtin";
+  /**
+   * Advertised capabilities; user code may branch on these.
+   */
+  capabilities = {
+    constraints: false,
+    continuousCollisionDetection: false,
+    sleepingBodies: false,
+    raycasts: true,
+    velocityLimit: true,
+    isGrounded: true
+  };
+  /**
+   * World gravity. Mutate to change at runtime.
+   * @default <0, 0.98>
+   */
+  gravity;
+  /**
+   * Active physics bodies in this simulation.
+   */
+  bodies = /* @__PURE__ */ new Set();
+  /**
+   * Collision detector instance, created in {@link init}.
+   */
+  detector;
+  /**
+   * Back-reference to the owning world, set in {@link init}.
+   */
+  world;
+  constructor(options = {}) {
+    this.gravity = options.gravity ?? new Vector2d(0, 0.98);
+  }
+  init(world) {
+    this.world = world;
+    this.detector = new detector_default(world);
+  }
+  destroy() {
+    this.bodies.clear();
+  }
+  step(dt) {
+    const isPaused = state_default.isPaused();
+    this.detector.beginFrame();
+    for (const body of this.bodies) {
+      const ancestor = body.ancestor;
+      if (!body.isStatic && ancestor) {
+        if (!(isPaused && !ancestor.updateWhenPaused) && (ancestor.inViewport || ancestor.alwaysUpdate)) {
+          this.applyGravity(body);
+          if (body.update(dt)) {
+            ancestor.isDirty = true;
           }
-          indexB++;
-        } while (indexB < bLen);
+          this.detector.collisions(ancestor);
+        }
+      }
+      body.force.set(0, 0);
+    }
+    this.detector.endFrame();
+  }
+  syncFromPhysics() {
+  }
+  addBody(renderable, def) {
+    let body = renderable.body;
+    const isAlreadyAdapterManaged = body instanceof Body && this.bodies.has(body);
+    if (isAlreadyAdapterManaged) {
+      throw new Error(
+        "BuiltinAdapter.addBody: renderable is already adapter-managed. Use adapter.updateShape() / property mutation / adapter.removeBody() first if you need to change the body."
+      );
+    }
+    if (!(body instanceof Body)) {
+      body = new Body(renderable, def.shapes);
+      renderable.body = body;
+    } else if (def.shapes.length > 0) {
+      body.shapes.length = 0;
+      body.getBounds().clear();
+      for (const s of def.shapes) {
+        body.addShape(s);
       }
     }
-    result.length = collisionCounter;
+    body.setStatic(def.type === "static");
+    if (typeof def.collisionType === "number") {
+      body.collisionType = def.collisionType;
+    }
+    if (typeof def.collisionMask === "number") {
+      body.collisionMask = def.collisionMask;
+    }
+    if (def.frictionAir !== void 0) {
+      if (typeof def.frictionAir === "number") {
+        body.setFriction(def.frictionAir, def.frictionAir);
+      } else {
+        body.setFriction(def.frictionAir.x, def.frictionAir.y);
+      }
+    }
+    if (typeof def.restitution === "number") {
+      body.bounce = def.restitution;
+    }
+    if (typeof def.density === "number") {
+      body.mass = def.density;
+    }
+    if (typeof def.gravityScale === "number") {
+      body.gravityScale = def.gravityScale;
+    }
+    if (def.maxVelocity !== void 0) {
+      body.setMaxVelocity(def.maxVelocity.x, def.maxVelocity.y);
+    }
+    if (def.isSensor === true) {
+      body.isSensor = true;
+    }
+    this.bodies.add(body);
+    return body;
+  }
+  removeBody(renderable) {
+    const body = renderable.body;
+    if (body instanceof Body) {
+      this.bodies.delete(body);
+    }
+  }
+  updateShape(renderable, shapes) {
+    const body = renderable.body;
+    if (!(body instanceof Body)) {
+      return;
+    }
+    body.shapes.length = 0;
+    body.getBounds().clear();
+    for (const s of shapes) {
+      body.addShape(s);
+    }
+  }
+  getVelocity(renderable, out) {
+    const body = renderable.body;
+    const target = out ?? new Vector2d();
+    if (!body || !this.bodies.has(body)) {
+      return target.set(0, 0);
+    }
+    return target.set(body.vel.x, body.vel.y);
+  }
+  setVelocity(renderable, v) {
+    renderable.body.vel.setV(v);
+  }
+  applyForce(renderable, force, point) {
+    const body = renderable.body;
+    if (point) {
+      body.applyForce(force.x, force.y, point.x, point.y);
+    } else {
+      body.applyForce(force.x, force.y);
+    }
+  }
+  applyImpulse(renderable, impulse) {
+    const body = renderable.body;
+    const invMass = body.mass > 0 ? 1 / body.mass : 0;
+    body.vel.x += impulse.x * invMass;
+    body.vel.y += impulse.y * invMass;
+  }
+  setPosition(renderable, p) {
+    renderable.pos.x = p.x;
+    renderable.pos.y = p.y;
+  }
+  setAngle(renderable, angle) {
+    renderable.body.setAngle(angle);
+  }
+  getAngle(renderable) {
+    return renderable.body.angle;
+  }
+  setAngularVelocity(renderable, omega) {
+    renderable.body.setAngularVelocity(omega);
+  }
+  getAngularVelocity(renderable) {
+    return renderable.body.angularVelocity;
+  }
+  applyTorque(renderable, torque) {
+    renderable.body.applyTorque(torque);
+  }
+  setStatic(renderable, isStatic) {
+    renderable.body.setStatic(isStatic);
+  }
+  setGravityScale(renderable, scale2) {
+    renderable.body.gravityScale = scale2;
+  }
+  setFrictionAir(renderable, friction) {
+    const body = renderable.body;
+    if (typeof friction === "number") {
+      body.setFriction(friction, friction);
+    } else {
+      body.setFriction(friction.x, friction.y);
+    }
+  }
+  setMaxVelocity(renderable, limit) {
+    renderable.body.setMaxVelocity(limit.x, limit.y);
+  }
+  getMaxVelocity(renderable) {
+    const v = renderable.body.maxVel;
+    return { x: v.x, y: v.y };
+  }
+  setCollisionType(renderable, type) {
+    renderable.body.collisionType = type;
+  }
+  setCollisionMask(renderable, mask) {
+    renderable.body.setCollisionMask(mask);
+  }
+  setSensor(renderable, isSensor) {
+    renderable.body.isSensor = isSensor;
+  }
+  getBodyAABB(renderable, out) {
+    const body = renderable.body;
+    if (!body || !this.bodies.has(body)) {
+      return void 0;
+    }
+    const b = body.bounds;
+    out.setMinMax(b.min.x, b.min.y, b.max.x, b.max.y);
+    return out;
+  }
+  getBodyShapes(renderable) {
+    const body = renderable.body;
+    if (!body || !this.bodies.has(body)) {
+      return [];
+    }
+    return body.shapes;
+  }
+  isGrounded(renderable) {
+    const body = renderable.body;
+    return !body.falling && !body.jumping;
+  }
+  raycast(from, to) {
+    const hits = raycastQuery(this.world, from.x, from.y, to.x, to.y);
+    return hits[0] ?? null;
+  }
+  queryAABB(rect) {
+    const queryBounds = rect.getBounds();
+    const result = [];
+    this.world.broadphase.retrieve(rect, void 0, result);
+    let writeIdx = 0;
+    for (let i = 0, len = result.length; i < len; i++) {
+      const r = result[i];
+      const b = r.getBounds();
+      if (b.overlaps(queryBounds)) {
+        result[writeIdx++] = r;
+      }
+    }
+    result.length = writeIdx;
     return result;
   }
+  applyGravity(body) {
+    if (body.gravityScale !== 0 && !body.ignoreGravity) {
+      body.force.x += body.mass * this.gravity.x * body.gravityScale;
+      body.force.y += body.mass * this.gravity.y * body.gravityScale;
+    }
+  }
 };
-var detector_default = Detector;
 
-// src/physics/quadtree.js
+// src/physics/builtin/quadtree.js
 var QT_ARRAY = [];
 function QT_ARRAY_POP(world, bounds, max_objects = 4, max_levels = 4, level2 = 0) {
   if (QT_ARRAY.length > 0) {
@@ -30045,6 +31716,8 @@ var QuadTree = class {
     this.level = level2;
     this.objects = [];
     this.nodes = [];
+    this._subtreeCount = 0;
+    this._retrieveScratch = level2 === 0 ? [] : null;
   }
   /*
    * Split the node into 4 subnodes
@@ -30176,6 +31849,7 @@ var QuadTree = class {
    * @param {object} item - object to be added
    */
   insert(item) {
+    this._subtreeCount++;
     if (this.nodes.length > 0) {
       const index = this.getIndex(item);
       if (index !== -1) {
@@ -30201,15 +31875,61 @@ var QuadTree = class {
     }
   }
   /**
-   * Return all objects that could collide with the given object
+   * Recursively remove the given container and its descendants from
+   * the quadtree. Mirrors `insertContainer` so the broadphase can be
+   * kept in sync when a subtree is detached via
+   * `Container.removeChildNow` between two `world.update()` rebuilds
+   * (pointer events fire async in that window and would otherwise
+   * hit destroyed renderables).
+   * @param {Container} container - group of objects to be removed
+   */
+  removeContainer(container) {
+    const children = container.getChildren?.();
+    if (!children) {
+      return;
+    }
+    const childrenLength = children.length;
+    for (let i = childrenLength, child; i--, child = children[i]; ) {
+      if (child.isKinematic !== true) {
+        if (typeof child.addChild === "function") {
+          if (child.name !== "rootContainer") {
+            this.remove(child);
+          }
+          this.removeContainer(child);
+        } else if (typeof child.getBounds === "function") {
+          this.remove(child);
+        }
+      }
+    }
+  }
+  /**
+   * Return all objects that could collide with the given object.
+   *
+   * **Re-entrancy contract:** when called with no explicit `result`
+   * argument, this method reuses a single root-level scratch array to
+   * avoid per-frame allocations. The returned reference is therefore
+   * **not safe to retain** past the next `retrieve()` call, AND it is
+   * **not safe to issue another scratch-mode `retrieve()` while iterating
+   * the previous result** — the second call clears the scratch and
+   * refills it, corrupting the outer iteration. In-engine callers
+   * (`pointerevent.ts`, `detector.js`) iterate synchronously and never
+   * recurse into `retrieve()`, so they're fine. User-facing portable
+   * APIs (`adapter.queryAABB`, `adapter.raycast`) pass their own array
+   * via the `result` parameter, which bypasses the scratch entirely
+   * and is safe to call from inside collision handlers.
+   *
    * @param {object} item - object to be checked against
    * @param {object} [fn] - a sorting function for the returned array
+   * @param {object[]} [result] - optional caller-supplied result array.
+   *   Pass an explicit (typically empty) array to sidestep the shared
+   *   scratch — required for re-entrancy safety.
    * @returns {object[]} array with all detected objects
    */
   retrieve(item, fn, result) {
     const isRoot = typeof result === "undefined";
     if (isRoot) {
-      result = [];
+      result = this._retrieveScratch;
+      result.length = 0;
     }
     const objects = this.objects;
     for (let i = 0, len = objects.length; i < len; i++) {
@@ -30245,9 +31965,6 @@ var QuadTree = class {
       const index = this.getIndex(item);
       if (index !== -1) {
         found = this.nodes[index].remove(item);
-        if (found && this.nodes[index].isPrunable()) {
-          this.nodes[index].clear();
-        }
       }
     }
     if (found === false) {
@@ -30257,6 +31974,24 @@ var QuadTree = class {
         found = true;
       }
     }
+    if (found === false && this.nodes.length > 0) {
+      for (let i = 0; i < this.nodes.length; i++) {
+        if (this.nodes[i].remove(item)) {
+          found = true;
+          break;
+        }
+      }
+    }
+    if (found) {
+      this._subtreeCount--;
+      if (this.nodes.length > 0 && this.objects.length === 0 && this._subtreeCount === 0) {
+        for (let i = 0; i < this.nodes.length; i++) {
+          this.nodes[i].clear();
+          QT_ARRAY_PUSH(this.nodes[i]);
+        }
+        this.nodes.length = 0;
+      }
+    }
     return found;
   }
   /**
@@ -30264,20 +31999,14 @@ var QuadTree = class {
    * @returns {boolean} true if the node is prunable
    */
   isPrunable() {
-    return !(this.hasChildren() || this.objects.length > 0);
+    return this._subtreeCount === 0;
   }
   /**
    * return true if the node has any children
    * @returns {boolean} true if the node has any children
    */
   hasChildren() {
-    for (let i = 0; i < this.nodes.length; i = i + 1) {
-      const subnode = this.nodes[i];
-      if (subnode.nodes.length > 0 || subnode.objects.length > 0) {
-        return true;
-      }
-    }
-    return false;
+    return this._subtreeCount > this.objects.length;
   }
   /**
    * clear the quadtree
@@ -30290,6 +32019,7 @@ var QuadTree = class {
       QT_ARRAY_PUSH(this.nodes[i]);
     }
     this.nodes.length = 0;
+    this._subtreeCount = 0;
     if (typeof bounds !== "undefined") {
       this.bounds.setMinMax(
         bounds.min.x,
@@ -30302,36 +32032,76 @@ var QuadTree = class {
 };
 
 // src/physics/world.js
+var EMPTY_BODIES = Object.freeze(/* @__PURE__ */ new Set());
 var World = class extends Container {
   /**
    * @param {number} [x=0] - position of the container (accessible via the inherited pos.x property)
    * @param {number} [y=0] - position of the container (accessible via the inherited pos.y property)
    * @param {number} [width=Infinity] - width of the world container
    * @param {number} [height=Infinity] - height of the world container
+   * @param {PhysicsAdapter} [adapter] - physics adapter to use; defaults to a new {@link BuiltinAdapter} instance
    */
-  constructor(x = 0, y = 0, width = Infinity, height = Infinity) {
+  constructor(x = 0, y = 0, width = Infinity, height = Infinity, adapter = void 0) {
     super(x, y, width, height, true);
     this.name = "rootContainer";
     this.anchorPoint.set(0, 0);
     this.app = void 0;
     this.physic = "builtin";
     this.fps = 60;
-    this.gravity = new Vector2d(0, 0.98);
     this.preRender = false;
     this.gpuTilemap = true;
-    this.bodies = /* @__PURE__ */ new Set();
+    this.adapter = adapter ?? new BuiltinAdapter();
+    this.adapter.init?.(this);
     this.broadphase = new QuadTree(
       this,
       this.getBounds().clone(),
       collision.maxChildren,
       collision.maxDepth
     );
-    this.detector = new detector_default(this);
     on(GAME_RESET, this.reset, this);
     on(LEVEL_LOADED, () => {
       this.broadphase.clear(this.getBounds());
     });
   }
+  /**
+   * Active physics bodies in this simulation. Backed by the active
+   * adapter; mutating this set directly is no longer the recommended
+   * pattern — use `world.adapter.addBody(...)` / `removeBody(...)`.
+   *
+   * Adapters that don't expose a native `bodies` Set (e.g. third-party
+   * integrations that own their own body storage) cause this getter
+   * to return a frozen empty Set, so any `world.bodies.add(...)`
+   * attempt throws `TypeError` instead of silently mutating a
+   * throwaway.
+   * @returns {Set<Body>}
+   */
+  get bodies() {
+    return (
+      /** @type {{ bodies?: Set<Body> }} */
+      this.adapter.bodies ?? EMPTY_BODIES
+    );
+  }
+  /**
+   * world gravity. Mutate to change at runtime.
+   * @returns {Vector2d}
+   */
+  get gravity() {
+    return this.adapter.gravity;
+  }
+  set gravity(v) {
+    this.adapter.gravity = v;
+  }
+  /**
+   * the collision detector instance used by this world instance.
+   * Available only when the active adapter is {@link BuiltinAdapter}.
+   * @returns {Detector | undefined}
+   */
+  get detector() {
+    return (
+      /** @type {{ detector?: Detector }} */
+      this.adapter.detector
+    );
+  }
   /**
    * reset the game world
    */
@@ -30339,28 +32109,40 @@ var World = class extends Container {
     this.broadphase.clear();
     this.anchorPoint.set(0, 0);
     super.reset();
-    const persistentBodies = [];
-    this.bodies.forEach((value) => {
-      if (value.ancestor && value.ancestor.isPersistent) {
-        persistentBodies.push(value);
-      }
-    });
-    this.bodies.clear();
-    if (persistentBodies.length > 0) {
-      persistentBodies.forEach((body) => {
-        this.addBody(body);
+    const bodies = (
+      /** @type {{ bodies?: Set<Body> }} */
+      this.adapter.bodies
+    );
+    if (bodies !== void 0) {
+      const persistentBodies = [];
+      bodies.forEach((value) => {
+        if (value.ancestor && value.ancestor.isPersistent) {
+          persistentBodies.push(value);
+        }
       });
+      bodies.clear();
+      if (persistentBodies.length > 0) {
+        persistentBodies.forEach((body) => {
+          this.addBody(body);
+        });
+      }
     }
   }
   /**
-   * Add a physic body to the game world
+   * Add a physic body to the game world. Legacy API for code that
+   * constructed `new Body(...)` directly and now wants to register it
+   * with the active physics adapter.
    * @see Container.addChild
    * @param {Body} body
    * @returns {World} this game world
    */
   addBody(body) {
     if (this.physic === "builtin") {
-      this.bodies.add(body);
+      const bodies = (
+        /** @type {{ bodies?: Set<Body> }} */
+        this.adapter.bodies
+      );
+      bodies?.add(body);
     }
     return this;
   }
@@ -30372,21 +32154,22 @@ var World = class extends Container {
    */
   removeBody(body) {
     if (this.physic === "builtin") {
-      this.bodies.delete(body);
+      const bodies = (
+        /** @type {{ bodies?: Set<Body> }} */
+        this.adapter.bodies
+      );
+      bodies?.delete(body);
     }
     return this;
   }
   /**
-   * Apply gravity to the given body
+   * Apply gravity to the given body. Backward-compat shim; the actual
+   * simulation runs through the active adapter.
    * @private
    * @param {Body} body
    */
   bodyApplyGravity(body) {
-    if (!body.ignoreGravity && body.gravityScale !== 0) {
-      const gravity = this.gravity;
-      body.force.x += body.mass * gravity.x * body.gravityScale;
-      body.force.y += body.mass * gravity.y * body.gravityScale;
-    }
+    this.adapter.applyGravity?.(body);
   }
   /**
    * update the game world
@@ -30402,28 +32185,13 @@ var World = class extends Container {
     return super.update(dt);
   }
   /**
-   * update the builtin physic simulation by one step (called by the game world update method)
+   * update the physics simulation by one step (called by the game world update method)
    * @param {number} dt - the time passed since the last frame update
    */
   step(dt) {
-    if (this.physic === "builtin") {
-      const isPaused = state_default.isPaused();
-      for (const body of this.bodies) {
-        if (!body.isStatic) {
-          const ancestor = body.ancestor;
-          if (!ancestor) {
-            continue;
-          }
-          if (!(isPaused && !ancestor.updateWhenPaused) && (ancestor.inViewport || ancestor.alwaysUpdate)) {
-            this.bodyApplyGravity(body);
-            if (body.update(dt) === true) {
-              ancestor.isDirty = true;
-            }
-            this.detector.collisions(ancestor);
-            body.force.set(0, 0);
-          }
-        }
-      }
+    if (this.physic !== "none") {
+      this.adapter.step(dt);
+      this.adapter.syncFromPhysics();
     }
     emit(WORLD_STEP, dt);
   }
@@ -31576,16 +33344,14 @@ var MaterialBatcher = class extends Batcher {
         );
       }
     } else if (typeof globalThis.OffscreenCanvas !== "undefined" && pixels instanceof globalThis.OffscreenCanvas) {
-      const imageBitmap = pixels.transferToImageBitmap();
       gl.texImage2D(
         gl.TEXTURE_2D,
         0,
         gl.RGBA,
         gl.RGBA,
         gl.UNSIGNED_BYTE,
-        imageBitmap
+        pixels
       );
-      imageBitmap.close();
     } else {
       gl.texImage2D(
         gl.TEXTURE_2D,
@@ -34913,6 +36679,16 @@ function onresize(game2) {
 }
 
 // src/application/application.ts
+function resolvePhysicSetting(physic) {
+  if (physic === "none") {
+    return { adapter: void 0, physicLabel: "none" };
+  }
+  if (physic === void 0 || physic === "builtin") {
+    return { adapter: void 0, physicLabel: "builtin" };
+  }
+  const adapter = typeof physic === "object" && "adapter" in physic ? physic.adapter : physic;
+  return { adapter, physicLabel: adapter?.physicLabel ?? "builtin" };
+}
 var Application = class {
   /**
    * the parent HTML element holding the main canvas of this application
@@ -35135,10 +36911,30 @@ var Application = class {
     if (this.settings.consoleHeader) {
       consoleHeader(this);
     }
-    this.world = new World(0, 0, this.settings.width, this.settings.height);
+    const { adapter, physicLabel } = resolvePhysicSetting(this.settings.physic);
+    this.world = new World(
+      0,
+      0,
+      this.settings.width,
+      this.settings.height,
+      adapter
+    );
     this.world.app = this;
-    this.world.physic = this.settings.physic;
+    this.world.physic = physicLabel;
     this.world.gpuTilemap = this.settings.gpuTilemap;
+    if (this.settings.consoleHeader) {
+      if (this.world.physic === "none") {
+        console.log("physics: disabled");
+      } else if (this.world.adapter) {
+        const a = this.world.adapter;
+        const label = a.name ?? a.constructor.name;
+        const version2 = a.version ? ` ${a.version}` : "";
+        const url = a.url ? ` | ${a.url}` : "";
+        console.log(`physics: ${label}${version2}${url}`);
+      } else {
+        console.log("physics: enabled (no adapter)");
+      }
+    }
     if (this.settings.gpuTilemap && // duck-type rather than `instanceof WebGLRenderer` to avoid a
     // runtime import; only the WebGL renderer carries `WebGLVersion`
     this.renderer.WebGLVersion !== 2) {
@@ -36586,7 +38382,6 @@ var UIBaseElement = class extends Container {
    * @param _event - the event object
    * @returns return false if we need to stop propagating the event
    */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   onClick(_event) {
     return true;
   }
@@ -36620,14 +38415,12 @@ var UIBaseElement = class extends Container {
    * function called when the pointer is moved over the object
    * @param _event - the event object
    */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   onMove(_event) {
   }
   /**
    * function called when the pointer is over the object
    * @param _event - the event object
    */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   onOver(_event) {
   }
   /**
@@ -36649,7 +38442,6 @@ var UIBaseElement = class extends Container {
    * function called when the pointer is leaving the object area
    * @param _event - the event object
    */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   onOut(_event) {
   }
   /**
@@ -36670,7 +38462,6 @@ var UIBaseElement = class extends Container {
    * @param _event - the event object
    * @returns return false if we need to stop propagating the event
    */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   onRelease(_event) {
     return true;
   }
@@ -36835,7 +38626,6 @@ var UISpriteElement = class extends Sprite {
    * @param _event - the event object
    * @returns return false if we need to stop propagating the event
    */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   onClick(_event) {
     return false;
   }
@@ -36852,7 +38642,6 @@ var UISpriteElement = class extends Sprite {
    * function called when the pointer is over the object
    * @param _event - the event object
    */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   onOver(_event) {
   }
   /**
@@ -36869,7 +38658,6 @@ var UISpriteElement = class extends Sprite {
    * function called when the pointer is leaving the object area
    * @param _event - the event object
    */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   onOut(_event) {
   }
   /**
@@ -36890,7 +38678,6 @@ var UISpriteElement = class extends Sprite {
    * @param _event - the event object
    * @returns return false if we need to stop propagating the event
    */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   onRelease(_event) {
     return false;
   }
@@ -37714,6 +39501,111 @@ var SepiaEffect = class extends ColorMatrixEffect {
   }
 };
 
+// src/video/webgl/effects/shine.js
+var ShineEffect = class extends ShaderEffect {
+  /**
+   * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
+   * @param {object} [options] - effect options
+   * @param {number[]} [options.color=[1.0, 1.0, 1.0]] - shine color as [r, g, b] (0.0–1.0)
+   * @param {number} [options.speed=0.5] - sweeps per second
+   * @param {number} [options.width=0.15] - glint half-width as a fraction of one tile (0.0–1.0)
+   * @param {number} [options.intensity=0.5] - maximum highlight strength
+   * @param {number} [options.angle=0.5] - sweep direction in radians (0 = horizontal L→R, π/2 = vertical T→B)
+   * @param {number} [options.bands=1.0] - number of parallel glints (1 = single shine; ~14.5 mimics a coin's etched-rim look)
+   * @param {number} [options.pulseDepth=0.0] - subtle base-brightness pulse amplitude (0 disables the pulse)
+   * @param {number} [options.pulseSpeed=3.0] - pulse oscillation rate (radians/second)
+   */
+  constructor(renderer2, options = {}) {
+    super(
+      renderer2,
+      `
+			uniform vec3  uShineColor;
+			uniform float uShineWidth;
+			uniform float uShineSpeed;
+			uniform float uShineIntensity;
+			uniform float uShineAngle;
+			uniform float uShineBands;
+			uniform float uPulseDepth;
+			uniform float uPulseSpeed;
+			uniform float uTime;
+			vec4 apply(vec4 color, vec2 uv) {
+				if (color.a == 0.0) return color;
+				// Optional brightness pulse on the base color.
+				float pulse = (1.0 - uPulseDepth) + uPulseDepth * sin(uTime * uPulseSpeed);
+				// Project uv along the sweep axis (uShineAngle).
+				float pos = uv.x * cos(uShineAngle) + uv.y * sin(uShineAngle);
+				// Tile by uShineBands so we get N parallel glints in unison.
+				// localX and sweep both live in [0,1] tile-space; the
+				// wrap-around distance (min(d, 1-d)) lets the glint exit
+				// the right edge of a tile and immediately re-enter from
+				// the left edge of the next, so there is NO perceived
+				// pause between sweeps. Previous implementation padded
+				// the sweep range to [-W, 1+W] which created a visible
+				// off-screen gap of duration ~2W/(1+2W) per cycle.
+				float localX = fract(pos * uShineBands);
+				float sweep = fract(uTime * uShineSpeed);
+				float d = abs(localX - sweep);
+				float dist = min(d, 1.0 - d);
+				float glint = smoothstep(uShineWidth, 0.0, dist) * uShineIntensity;
+				// color.rgb is already premultiplied by alpha \u2014 multiply the
+				// added glint by color.a so it stays premultiplied too, but
+				// do NOT scale the whole result by color.a (that would dim
+				// antialiased edges twice).
+				vec3 result = color.rgb * pulse + uShineColor * glint * color.a;
+				return vec4(result, color.a);
+			}
+			`
+    );
+    this.setUniform(
+      "uShineColor",
+      new Float32Array(options.color ?? [1, 1, 1])
+    );
+    this.setUniform("uShineWidth", options.width ?? 0.15);
+    this.setUniform("uShineSpeed", options.speed ?? 0.5);
+    this.setUniform("uShineIntensity", options.intensity ?? 0.5);
+    this.setUniform("uShineAngle", options.angle ?? 0.5);
+    this.setUniform("uShineBands", options.bands ?? 1);
+    this.setUniform("uPulseDepth", options.pulseDepth ?? 0);
+    this.setUniform("uPulseSpeed", options.pulseSpeed ?? 3);
+    this.setUniform("uTime", 0);
+  }
+  /**
+   * set the current time (call each frame for animation)
+   * @param {number} time - time in seconds
+   */
+  setTime(time) {
+    this.setUniform("uTime", time);
+  }
+  /**
+   * set the shine color
+   * @param {number[]} color - shine color as [r, g, b] (0.0–1.0)
+   */
+  setColor(color) {
+    this.setUniform("uShineColor", new Float32Array(color));
+  }
+  /**
+   * set the sweep speed
+   * @param {number} value - sweeps per second
+   */
+  setSpeed(value) {
+    this.setUniform("uShineSpeed", value);
+  }
+  /**
+   * set the highlight intensity
+   * @param {number} value - maximum highlight strength
+   */
+  setIntensity(value) {
+    this.setUniform("uShineIntensity", value);
+  }
+  /**
+   * set the number of parallel glints
+   * @param {number} value - 1 for a single shine, >1 for tiled stripes
+   */
+  setBands(value) {
+    this.setUniform("uShineBands", value);
+  }
+};
+
 // src/video/webgl/effects/tintPulse.js
 var TintPulseEffect = class extends ShaderEffect {
   /**
@@ -38385,6 +40277,7 @@ export {
   BlurEffect,
   Body,
   Bounds,
+  BuiltinAdapter,
   CANVAS,
   Camera2d,
   CameraEffect,
@@ -38449,6 +40342,7 @@ export {
   SepiaEffect,
   ShaderEffect,
   ShakeEffect,
+  ShineEffect,
   Sprite,
   Stage,
   TMXHexagonalRenderer,