@lewismoten/gamemaker-sandbox-engine 0.0.0-stage → 3.3.0

package/dist/audio/context.js

@@ -0,0 +1,75 @@
+let e, i = !1;
+const r = /* @__PURE__ */ new Set(), l = ["pointerup", "touchend", "click", "keydown", "mousedown"];
+function v() {
+  if (!(typeof window > "u"))
+    return window.AudioContext ?? window.webkitAudioContext;
+}
+function u() {
+  try {
+    const t = navigator.audioSession;
+    t && t.type !== "playback" && (t.type = "playback");
+  } catch {
+  }
+}
+function w() {
+  if (e) return e;
+  const t = v();
+  if (t) {
+    try {
+      u(), e = new t({ latencyHint: "interactive" });
+    } catch {
+      return;
+    }
+    return d(), e.addEventListener("statechange", () => {
+      e && e.state !== "running" && i && document.visibilityState === "visible" && e.resume().catch(() => {
+      });
+    }), navigator.userActivation?.isActive && s(), e;
+  }
+}
+function y() {
+  return i && !!e && e.state === "running";
+}
+function k(t) {
+  return r.add(t), () => r.delete(t);
+}
+function s() {
+  const t = w();
+  if (!t) return;
+  u();
+  const a = !i;
+  if (i = !0, t.state !== "running" && t.resume().catch(() => {
+  }), a)
+    try {
+      const n = t.createBufferSource();
+      n.buffer = t.createBuffer(1, 1, t.sampleRate), n.connect(t.destination), n.start(0);
+    } catch {
+    }
+  for (const n of [...r])
+    try {
+      n();
+    } catch (f) {
+      console.warn(f);
+    }
+}
+let c = !1;
+function p(t) {
+  t.type === "keydown" && (t.key === "Shift" || t.key === "Meta") || t.isTrusted && (y() || s());
+}
+function o() {
+  e && i && e.state !== "running" && document.visibilityState === "visible" && e.resume().catch(() => {
+  });
+}
+function d() {
+  if (!(c || typeof window > "u")) {
+    c = !0;
+    for (const t of l) window.addEventListener(t, p, { capture: !0, passive: !0 });
+    document.addEventListener("visibilitychange", o), window.addEventListener("pageshow", o), window.addEventListener("focus", o);
+  }
+}
+typeof window < "u" && d();
+export {
+  w as audioContext,
+  k as onSoundUnlocked,
+  y as soundUnlocked,
+  s as unlock
+};

package/dist/audio/engine.js

@@ -0,0 +1,173 @@
+import { loadSong as g } from "./cmfLoad.js";
+import { isVoc as p, decodeVoc as G } from "../formats/voc.js";
+import { TICK_RATE as v } from "./cmfPlayer.js";
+import { output as x } from "./output.js";
+import { onMix as S, channelGain as m } from "./mix.js";
+import { audioContext as k, unlock as E } from "./context.js";
+const M = "" + new URL("../assets/music.worklet-aD2x7RRM.js", import.meta.url).href, d = 300;
+let f;
+class V {
+  ctx;
+  master;
+  /** Music and effects each go through their own gain, set by the visitor's sound settings (mix.ts). */
+  musicGain;
+  sfxGain;
+  /** Music and effects of a game being played also pass the Games setting (setGame). */
+  gameGain;
+  game = !1;
+  level = 1;
+  unmix;
+  music;
+  musicReady;
+  speaker;
+  voc;
+  vocCache = /* @__PURE__ */ new WeakMap();
+  musicEnabled = !0;
+  soundEnabled = !0;
+  cardEnabled = !0;
+  requestedSong;
+  loadedSong;
+  get soundCardEnabled() {
+    return this.cardEnabled;
+  }
+  /** Optional live host control: card removal pauses FM and stops digital effects, leaving the PC speaker alone. */
+  setSoundCard(t) {
+    this.cardEnabled !== t && (this.cardEnabled = t, t ? this.musicEnabled && this.requestedSong && (this.requestedSong === this.loadedSong ? this.pauseMusic(!1) : this.playSong(this.requestedSong)) : (this.stopVoc(), this.pauseMusic(!0)));
+  }
+  /**
+   * Starts the sound. The first time, call it from a user gesture's handler (iOS: inside
+   * the touchend/click itself, before any await); the page's one AudioContext (context.ts)
+   * is resumed there.
+   */
+  async resume() {
+    if (!this.ctx) {
+      const t = k();
+      if (!t) return;
+      this.ctx = t, this.master = t.createGain(), this.master.gain.value = 0.8, this.master.connect(x(t)), this.musicGain = t.createGain(), this.sfxGain = t.createGain(), this.gameGain = t.createGain(), this.gameGain.connect(this.master), this.musicGain.connect(this.gameGain), this.sfxGain.connect(this.gameGain);
+      const s = () => {
+        this.musicGain && (this.musicGain.gain.value = m("music")), this.sfxGain && (this.sfxGain.gain.value = m("sfx")), this.gameGain && (this.gameGain.gain.value = this.gameLevel());
+      };
+      s(), this.unmix = S(s), f ??= t.audioWorklet.addModule(M);
+      const e = this.master, i = this.musicGain;
+      this.musicReady = f.then(() => {
+        this.master === e && (this.music = new AudioWorkletNode(t, "gm-music", { outputChannelCount: [1] }), this.music.connect(i));
+      }).catch((a) => console.warn("Music unavailable:", a));
+    }
+    this.ctx.state !== "running" && (navigator.userActivation?.isActive && E(), await Promise.race([this.ctx.resume().catch(() => {
+    }), new Promise((t) => setTimeout(t, d))]));
+  }
+  /** Marks this engine as a game's: its sound also follows the Games setting (live). */
+  setGame(t) {
+    this.game = t, this.gameGain && (this.gameGain.gain.value = this.gameLevel());
+  }
+  /** A fixed trim (0 to 1) under the visitor's settings, for sound meant to sit quietly in the background. */
+  setLevel(t) {
+    this.level = t, this.gameGain && (this.gameGain.gain.value = this.gameLevel());
+  }
+  gameLevel() {
+    return (this.game ? m("games") : 1) * this.level;
+  }
+  /** Where this engine's sound leaves it (for recording just this game's sound). */
+  get node() {
+    return this.master;
+  }
+  /**
+   * Stops everything and lets go of the page's context (it is shared, so it stays open);
+   * a later resume() starts afresh.
+   */
+  dispose() {
+    this.stopAll(), this.music?.port.postMessage({ type: "end" }), this.unmix?.(), this.music?.disconnect(), this.musicGain?.disconnect(), this.sfxGain?.disconnect(), this.gameGain?.disconnect(), this.master?.disconnect(), this.unmix = this.music = this.musicGain = this.sfxGain = this.gameGain = this.master = this.ctx = void 0, this.musicReady = void 0;
+  }
+  get context() {
+    return this.ctx;
+  }
+  post(t, s = []) {
+    this.music?.port.postMessage(t, s);
+  }
+  /** PlaySong: returns false (silently, as the original did) for invalid songs. */
+  async playSong(t) {
+    if (this.stopSong(), !this.musicEnabled || (this.requestedSong = t, !this.cardEnabled)) return !1;
+    const s = g(t);
+    if (!s) return !1;
+    const e = ++this.songs, i = () => {
+      e !== this.songs || !this.cardEnabled || (this.loadedSong = t, this.post({ type: "load", music: s.music.slice(), instruments: s.instruments.map((n) => n.slice()) }));
+    }, a = this.musicReady;
+    return a && !this.music && await Promise.race([a, new Promise((n) => setTimeout(n, d * 3))]), this.music ? i() : a?.then(i), !0;
+  }
+  /** Counts songs asked for, so one still waiting for the worklet doesn't start after a newer one (or a stop). */
+  songs = 0;
+  stopSong() {
+    this.songs++, this.requestedSong = this.loadedSong = void 0, this.post({ type: "stop" });
+  }
+  /** The song stands still for `ms` (its notes keep sounding), then goes on from where it was: a slow PC's disk read. */
+  holdMusic(t) {
+    t > 0 && this.post({ type: "hold", ms: t });
+  }
+  pauseMusic(t) {
+    this.post({ type: "pause", paused: t });
+  }
+  /** DoSound's PC speaker path: one frequency per 1/145.6 s tick; 0 = silence. */
+  playSpeaker(t) {
+    if (!this.ctx || !this.master || !this.soundEnabled) return;
+    this.stopSpeaker();
+    const s = this.ctx.createOscillator(), e = this.ctx.createGain();
+    s.type = "square", e.gain.value = 0, s.connect(e).connect(this.sfxGain ?? this.master);
+    const i = this.ctx.currentTime + 5e-3, a = 1 / v;
+    for (let c = 0; c < t.length; c++) {
+      const o = t[c], r = i + c * a;
+      o >= 20 ? (s.frequency.setValueAtTime(Math.min(o, 2e4), r), e.gain.setValueAtTime(0.12, r)) : e.gain.setValueAtTime(0, r);
+    }
+    const n = i + t.length * a;
+    e.gain.setValueAtTime(0, n), s.start(i), s.stop(n + 0.01), this.speaker = { osc: s, gain: e }, s.onended = () => {
+      this.speaker?.osc === s && (this.speaker = void 0);
+    };
+  }
+  stopSpeaker() {
+    if (this.speaker) {
+      try {
+        this.speaker.osc.stop();
+      } catch {
+      }
+      this.speaker = void 0;
+    }
+  }
+  /** PlaySbVocFile: a new digital sound cuts off the previous one. */
+  playVoc(t) {
+    if (!this.cardEnabled || !this.ctx || !this.master || !t || !this.soundEnabled || !p(t)) return !1;
+    this.stopVoc();
+    let s = this.vocCache.get(t);
+    if (!s) {
+      const i = G(t);
+      if (!i.samples.length) return !1;
+      s = y(this.ctx, i.samples, i.sampleRate), this.vocCache.set(t, s);
+    }
+    const e = this.ctx.createBufferSource();
+    return e.buffer = s, e.connect(this.sfxGain ?? this.master), e.start(), this.voc = e, !0;
+  }
+  stopVoc() {
+    try {
+      this.voc?.stop();
+    } catch {
+    }
+    this.voc = void 0;
+  }
+  stopAll() {
+    this.stopSong(), this.stopSpeaker(), this.stopVoc();
+  }
+}
+function y(h, t, s) {
+  try {
+    const e = h.createBuffer(1, t.length, s);
+    return e.copyToChannel(t, 0), e;
+  } catch {
+    const e = h.sampleRate, i = Math.max(1, Math.floor(t.length * e / s)), a = h.createBuffer(1, i, e), n = a.getChannelData(0), c = s / e;
+    for (let o = 0; o < i; o++) {
+      const r = o * c, u = Math.floor(r), l = r - u;
+      n[o] = (t[u] ?? 0) * (1 - l) + (t[u + 1] ?? t[u] ?? 0) * l;
+    }
+    return a;
+  }
+}
+export {
+  V as AudioEngine
+};

package/dist/audio/mix.js

@@ -0,0 +1,40 @@
+const s = "gm-sound-mix", l = ["music", "voice", "sfx", "games"], m = () => ({
+  music: { on: !0, volume: 100 },
+  voice: { on: !0, volume: 100 },
+  sfx: { on: !0, volume: 100 },
+  games: { on: !0, volume: 100 }
+});
+function r() {
+  const o = m();
+  try {
+    const u = JSON.parse(localStorage.getItem(s) ?? "null");
+    if (u && typeof u == "object")
+      for (const n of l) {
+        const e = u[n];
+        typeof e?.on == "boolean" && (o[n].on = e.on), typeof e?.volume == "number" && e.volume >= 0 && e.volume <= 100 && (o[n].volume = Math.round(e.volume));
+      }
+  } catch {
+  }
+  return o;
+}
+let t = r();
+const c = /* @__PURE__ */ new Set(), a = () => t, i = (o) => t[o].on ? t[o].volume / 100 : 0;
+function f(o, u) {
+  const n = { ...t[o], ...u };
+  n.volume = Math.max(0, Math.min(100, Math.round(n.volume))), t = { ...t, [o]: n };
+  try {
+    localStorage.setItem(s, JSON.stringify(t));
+  } catch {
+  }
+  for (const e of [...c]) e(t);
+}
+function v(o) {
+  return c.add(o), () => c.delete(o);
+}
+export {
+  l as CHANNELS,
+  i as channelGain,
+  a as getMix,
+  v as onMix,
+  f as setChannel
+};

package/dist/audio/opl.js

@@ -0,0 +1,245 @@
+const y = [0.5, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 12, 12, 15, 15], u = [0, 9, 12, 13.875, 15, 16.125, 16.875, 17.625, 18, 18.75, 19.125, 19.5, 19.875, 20.25, 20.625, 21], w = [0, 0.5, 0.25, 1], v = 49716, l = 96, D = [0, 1, 2, 3, 4, 5, 8, 9, 10, 11, 12, 13, 16, 17, 18, 19, 20, 21];
+class m {
+  am = !1;
+  vib = !1;
+  sustainHold = !1;
+  ksr = !1;
+  mult = 1;
+  ksl = 0;
+  tl = 0;
+  ar = 0;
+  dr = 0;
+  sl = 0;
+  rr = 0;
+  wave = 0;
+  // Runtime state. envDb is the envelope attenuation (0 = full, SILENT_DB = off);
+  // out/prevOut keep the last two modulator outputs for feedback.
+  phase = 0;
+  // cycles
+  stage = 0;
+  envDb = l;
+  out = 0;
+  prevOut = 0;
+  keyOn() {
+    this.stage = 1, this.phase = 0;
+  }
+  keyOff() {
+    this.stage !== 0 && (this.stage = 4);
+  }
+  /** Rate in "rate units" (0..63) including key scale rate offset. */
+  rate(s, t) {
+    return s === 0 ? 0 : Math.min(63, s * 4 + (this.ksr ? t : t >> 2));
+  }
+  stepEnvelope(s, t) {
+    switch (this.stage) {
+      case 1: {
+        const e = this.rate(this.ar, t);
+        if (e === 0) return;
+        if (e >= 60)
+          this.envDb = 0;
+        else {
+          const a = 2.826 / Math.pow(2, (e - 4) / 4);
+          this.envDb -= (this.envDb + 8) * (s / a) * 3.2;
+        }
+        this.envDb <= 0 && (this.envDb = 0, this.stage = 2);
+        return;
+      }
+      case 2: {
+        const e = this.sl === 15 ? 93 : this.sl * 3;
+        this.envDb += this.decayDbPerSecond(this.dr, t) * s, this.envDb >= e && (this.envDb = e, this.stage = 3);
+        return;
+      }
+      // EG-TYP set (sustainHold) holds the level until key off; otherwise the
+      // percussive envelope keeps falling at the release rate.
+      case 3:
+        this.sustainHold || (this.envDb += this.decayDbPerSecond(this.rr, t) * s);
+        break;
+      case 4:
+        this.envDb += this.decayDbPerSecond(this.rr, t) * s;
+        break;
+      default:
+        return;
+    }
+    this.envDb >= l && (this.envDb = l, this.stage = 0);
+  }
+  decayDbPerSecond(s, t) {
+    const e = this.rate(s, t);
+    return e === 0 ? 0 : l / (39.28 / Math.pow(2, (e - 4) / 4));
+  }
+  /** Waveform value at phase (cycles): 0 sine, 1 half sine, 2 absolute sine, 3 pulse (quarter) sine. */
+  wave01(s) {
+    const t = s - Math.floor(s), e = Math.sin(t * 2 * Math.PI);
+    switch (this.wave) {
+      case 1:
+        return t < 0.5 ? e : 0;
+      case 2:
+        return Math.abs(e);
+      case 3:
+        return t < 0.25 || t >= 0.5 && t < 0.75 ? Math.abs(e) : 0;
+      default:
+        return e;
+    }
+  }
+}
+class S {
+  fnum = 0;
+  block = 0;
+  key = !1;
+  feedback = 0;
+  additive = !1;
+  ops = [new m(), new m()];
+  /** Hz = F-number * clock / 2^(20 - block); block is the octave. */
+  get freq() {
+    return this.fnum * v / Math.pow(2, 20 - this.block);
+  }
+  /** Key scale rate offset: block * 2 + bit 9 (or 8) of the F-number. */
+  rof(s) {
+    return this.block * 2 + (this.fnum >> (s ? 8 : 9) & 1);
+  }
+  /** KSL attenuation: table value minus 6 dB per octave below block 7, scaled by the KSL setting. */
+  kslDb(s) {
+    return s.ksl ? Math.max(0, u[this.fnum >> 6] - 6 * (7 - this.block)) * w[s.ksl] : 0;
+  }
+}
+class M {
+  sampleRate;
+  channels = Array.from({ length: 9 }, () => new S());
+  regs = new Uint8Array(256);
+  waveSelect = !1;
+  noteSel = !1;
+  amDepth = !1;
+  vibDepth = !1;
+  rhythm = !1;
+  time = 0;
+  noise = 1;
+  constructor(s) {
+    this.sampleRate = s;
+  }
+  reset() {
+    for (let s = 0; s < 256; s++) this.write(s, 0);
+    for (const s of this.channels)
+      for (const t of s.ops)
+        t.stage = 0, t.envDb = l;
+  }
+  read(s) {
+    return this.regs[s & 255];
+  }
+  write(s, t) {
+    if (s &= 255, t &= 255, this.regs[s] = t, s === 1) {
+      this.waveSelect = (t & 32) !== 0;
+      return;
+    }
+    if (s === 8) {
+      this.noteSel = (t & 64) !== 0;
+      return;
+    }
+    if (s === 189) {
+      this.writeRhythm(t);
+      return;
+    }
+    const e = s & 224;
+    if (e >= 32 && e <= 128 || e === 224) {
+      const n = D.indexOf(s & 31);
+      if (n < 0) return;
+      const i = this.channels[Math.floor(n / 6) * 3 + n % 3].ops[Math.floor(n % 6 / 3)];
+      switch (e) {
+        case 32:
+          i.am = (t & 128) !== 0, i.vib = (t & 64) !== 0, i.sustainHold = (t & 32) !== 0, i.ksr = (t & 16) !== 0, i.mult = y[t & 15];
+          break;
+        case 64:
+          i.ksl = t >> 6, i.tl = t & 63;
+          break;
+        case 96:
+          i.ar = t >> 4, i.dr = t & 15;
+          break;
+        case 128:
+          i.sl = t >> 4, i.rr = t & 15;
+          break;
+        case 224:
+          i.wave = this.waveSelect ? t & 3 : 0;
+          break;
+      }
+      return;
+    }
+    const a = s & 15;
+    if (a > 8) return;
+    const h = this.channels[a];
+    if (e === 160 && s < 176)
+      h.fnum = h.fnum & 768 | t;
+    else if (s >= 176 && s <= 184) {
+      h.fnum = h.fnum & 255 | (t & 3) << 8, h.block = t >> 2 & 7;
+      const n = (t & 32) !== 0;
+      if (n && !h.key) for (const o of h.ops) o.keyOn();
+      if (!n && h.key) for (const o of h.ops) o.keyOff();
+      h.key = n;
+    } else s >= 192 && s <= 200 && (h.feedback = t >> 1 & 7, h.additive = (t & 1) !== 0);
+  }
+  rhythmKeys = 0;
+  /**
+   * Register 0xBD: bit 7 tremolo depth, bit 6 vibrato depth, bit 5 rhythm mode, bits 0-4 the
+   * drum keys. In rhythm mode channels 6-8 become the bass drum (both operators of channel 6),
+   * hi-hat and snare (channel 7) and tom-tom and cymbal (channel 8).
+   */
+  writeRhythm(s) {
+    this.amDepth = (s & 128) !== 0, this.vibDepth = (s & 64) !== 0, this.rhythm = (s & 32) !== 0;
+    const t = this.rhythm ? s & 31 : 0, e = t ^ this.rhythmKeys, [a, h, n] = [this.channels[6], this.channels[7], this.channels[8]], o = (i, r) => {
+      if (e & i)
+        for (const c of r) t & i ? c.keyOn() : c.keyOff();
+    };
+    o(16, a.ops), o(8, [h.ops[1]]), o(4, [n.ops[0]]), o(2, [n.ops[1]]), o(1, [h.ops[0]]), this.rhythmKeys = t;
+  }
+  /** Renders mono samples into out (added to existing content). */
+  render(s, t = 0.12) {
+    const e = 1 / this.sampleRate;
+    for (let a = 0; a < s.length; a++) {
+      this.time += e;
+      const h = (1 - Math.cos(this.time * 3.7 * 2 * Math.PI)) / 2 * (this.amDepth ? 4.8 : 1), n = Math.sin(this.time * 6.1 * 2 * Math.PI) * (this.vibDepth ? 14 : 7), o = Math.pow(2, n / 1200);
+      this.noise = this.noise >> 1 | ((this.noise >> 0 ^ this.noise >> 14) & 1) << 22;
+      const i = this.noise & 1 ? 1 : -1;
+      let r = 0;
+      const c = this.rhythm ? 6 : 9;
+      for (let f = 0; f < c; f++) r += this.channelSample(this.channels[f], e, h, o);
+      this.rhythm && (r += this.rhythmSample(e, h, o, i)), s[a] += r * t;
+    }
+  }
+  /** Linear amplitude from the summed attenuation: envelope + TL (0.75 dB steps) + KSL + tremolo. */
+  opLevel(s, t, e) {
+    const a = t.envDb + t.tl * 0.75 + s.kslDb(t) + (t.am ? e : 0);
+    return a >= l ? 0 : Math.pow(10, -a / 20);
+  }
+  advance(s, t, e, a) {
+    t.phase += s.freq * t.mult * (t.vib ? a : 1) * e, t.phase > 1e6 && (t.phase -= Math.floor(t.phase)), t.stepEnvelope(e, s.rof(this.noteSel));
+  }
+  channelSample(s, t, e, a) {
+    const [h, n] = s.ops;
+    if (h.stage === 0 && n.stage === 0) return 0;
+    this.advance(s, h, t, a), this.advance(s, n, t, a);
+    const o = s.feedback ? (h.out + h.prevOut) * Math.pow(2, s.feedback - 7) : 0, i = h.wave01(h.phase + o) * this.opLevel(s, h, e);
+    h.prevOut = h.out, h.out = i;
+    const r = this.opLevel(s, n, e);
+    return s.additive ? i + n.wave01(n.phase) * r : n.wave01(n.phase + i * 4) * r;
+  }
+  /**
+   * Approximates the five drums. The bass drum is a normal FM channel (at double level); the
+   * hi-hat, snare and cymbal mix operator tone with LFSR noise, and the tom-tom is a plain tone.
+   * The mixing weights are this port's approximation, not the chip's exact phase logic.
+   */
+  rhythmSample(s, t, e, a) {
+    const [h, n, o] = [this.channels[6], this.channels[7], this.channels[8]];
+    let i = this.channelSample(h, s, t, e) * 2;
+    const [r, c] = n.ops, [f, p] = o.ops;
+    for (const [d, k] of [
+      [n, r],
+      [n, c],
+      [o, f],
+      [o, p]
+    ])
+      this.advance(d, k, s, e);
+    return r.stage !== 0 && (i += a * 0.5 * this.opLevel(n, r, t) * (r.wave01(r.phase) > 0 ? 1 : 0.6) * 2), c.stage !== 0 && (i += (c.wave01(c.phase) * 0.6 + a * 0.4) * this.opLevel(n, c, t) * 2), f.stage !== 0 && (i += f.wave01(f.phase) * this.opLevel(o, f, t) * 2), p.stage !== 0 && (i += (p.wave01(p.phase) > 0 ? 0.5 : -0.5) * (a > 0 ? 1 : 0.7) * this.opLevel(o, p, t) * 2), i;
+  }
+}
+const O = [0, 1, 2, 8, 9, 10, 16, 17, 18];
+export {
+  O as MODULATOR_OFFSET,
+  M as Opl2
+};

package/dist/audio/output.js

@@ -0,0 +1,40 @@
+const a = "gm-volume", u = /* @__PURE__ */ new Map();
+function s() {
+  try {
+    const t = Number(localStorage.getItem(a));
+    return localStorage.getItem(a) !== null && t >= 0 && t <= 1 ? t : 1;
+  } catch {
+    return 1;
+  }
+}
+let o = s();
+const i = () => o;
+function g(t) {
+  o = Math.max(0, Math.min(1, t));
+  for (const [e, n] of u) n.gain.setTargetAtTime(o, e.currentTime, 0.02);
+  try {
+    localStorage.setItem(a, String(o));
+  } catch {
+  }
+}
+const c = /* @__PURE__ */ new Map();
+function m(t) {
+  let e = c.get(t);
+  if (!e) {
+    const n = t.createGain();
+    n.gain.value = o, n.connect(t.destination), u.set(t, n), e = t.createGain(), e.connect(n), c.set(t, e);
+    for (const l of r) l(t, e);
+  }
+  return e;
+}
+const r = /* @__PURE__ */ new Set();
+function f(t) {
+  for (const [e, n] of c) t(e, n);
+  return r.add(t), () => r.delete(t);
+}
+export {
+  i as getVolume,
+  m as output,
+  g as setVolume,
+  f as tapOutputs
+};

package/dist/core/gameFiles.js

@@ -0,0 +1,89 @@
+class h {
+  files = /* @__PURE__ */ new Map();
+  /** Notified after any change. */
+  onChange;
+  /** Set while files are still arriving: the game waits for one it needs (engine/machine.ts, need). */
+  stream;
+  /** Asked before set or delete changes a file; throws to refuse (a game opened to look inside, editor/core/readOnly.ts). */
+  guard;
+  constructor(t) {
+    if (t) for (const [s, e] of t) this.files.set(i(s), e);
+  }
+  get(t) {
+    return t ? this.files.get(i(t)) ?? this.files.get(o(t)) : void 0;
+  }
+  has(t) {
+    return !!t && (this.files.has(i(t)) || this.files.has(o(t)));
+  }
+  /** The stored name a reference opens (see cdName), or undefined when there is none. */
+  resolve(t) {
+    if (!t) return;
+    const s = i(t);
+    if (this.files.has(s)) return s;
+    const e = o(t);
+    return this.files.has(e) ? e : void 0;
+  }
+  set(t, s) {
+    const e = i(t);
+    this.guard?.(e), this.files.set(e, s), this.onChange?.(e);
+  }
+  /**
+   * A copy of these files to change freely. While files are still arriving here, the copy
+   * gets them too as it needs them (its own changes stay).
+   */
+  copy() {
+    const t = new h(this.entries());
+    if (!this.stream) return t;
+    const s = (e) => {
+      for (const a of e) {
+        const r = this.resolve(a);
+        r && !t.has(r) && t.put(r, this.get(r));
+      }
+    };
+    return t.stream = {
+      need: (e) => (s(e), this.stream?.need(e)?.then(() => s(e))),
+      want: (e) => this.stream?.want(e)
+    }, t;
+  }
+  /** Adds a file that arrived (not one the game wrote): onChange is not told, and a file already here stays. */
+  put(t, s) {
+    const e = i(t);
+    this.files.has(e) || this.files.set(e, s);
+  }
+  delete(t) {
+    const s = i(t);
+    this.guard?.(s), this.files.delete(s), this.onChange?.(s);
+  }
+  names() {
+    return [...this.files.keys()].sort();
+  }
+  entries() {
+    return this.names().map((t) => [t, this.files.get(t)]);
+  }
+  byExtension(t) {
+    const s = t.startsWith(".") ? t : `.${t}`;
+    return this.names().filter((e) => e.endsWith(s));
+  }
+  get size() {
+    return this.files.size;
+  }
+  /** The .gam file to play: the one named like the folder, else the first. */
+  mainGame(t) {
+    const s = this.byExtension("gam");
+    return t && s.includes(i(t)) ? i(t) : s[0];
+  }
+}
+function i(n) {
+  const t = (n.replace(/\\/g, "/").split("/").pop() ?? n).trim().toLowerCase(), s = t.indexOf("."), e = s < 0 ? "" : t.slice(s + 1, s + 4).trim();
+  return e ? `${t.slice(0, Math.min(s, 8))}.${e}` : t.slice(0, s < 0 ? 8 : Math.min(s, 8));
+}
+function o(n) {
+  return i(n).replace(/[^a-z0-9_.]/g, "_");
+}
+const c = /\.(exe|com|bat|drv|ico|bak|obj|map\.bak)$/i;
+export {
+  h as GameFiles,
+  c as IGNORED_FILE,
+  o as cdName,
+  i as normalize
+};