1681-engine 0.5.8 → 0.5.10

package/dist/assets/AssetLoader.js

@@ -1,40 +1,62 @@
-import { parseTiled as h } from "../tilemap/tiled.js";
-function n(r, t) {
+import { sound as f } from "../audio/SoundEngine.js";
+import { ldtkExternalLevels as w, parseLdtk as m } from "../tilemap/ldtkParse.js";
+import { parseTiled as p } from "../tilemap/tiled.js";
+import { collectAtlasPages as g, duplicateFrames as x, parseAtlas as v } from "./textureAtlas.js";
+function l(r) {
+  return r instanceof Error ? r.message : String(r);
+}
+function h(r, t) {
   if (/^[a-z][a-z0-9+.-]*:/i.test(r) || r.startsWith("/")) return r;
-  const a = (t.slice(0, t.lastIndexOf("/") + 1) + r).split("/"), s = [];
-  for (const o of a)
-    o === ".." && s.length && s[s.length - 1] !== ".." && s[s.length - 1] !== "" ? s.pop() : o !== "." && s.push(o);
-  return s.join("/");
+  const s = (t.slice(0, t.lastIndexOf("/") + 1) + r).split("/"), a = [];
+  for (const o of s)
+    o === ".." && a.length && a[a.length - 1] !== ".." && a[a.length - 1] !== "" ? a.pop() : o !== "." && a.push(o);
+  return a.join("/");
+}
+function A(r, t, e) {
+  const s = r;
+  return [...s.levels ?? [], ...(s.worlds ?? []).flatMap((o) => o.levels ?? [])].some((o) => o.externalRelPath === t && o.identifier !== void 0 && e.has(o.identifier));
 }
-async function c(r) {
+async function $(r) {
   const t = await createImageBitmap(r), e = document.createElement("canvas");
   e.width = t.width, e.height = t.height;
-  const a = e.getContext("2d");
-  if (!a) throw new Error("AssetLoader: no 2D context (out of canvas memory?)");
-  return a.drawImage(t, 0, 0), t.close(), e;
+  const s = e.getContext("2d");
+  if (!s) throw new Error("AssetLoader: no 2D context (out of canvas memory?)");
+  return s.drawImage(t, 0, 0), t.close(), e;
 }
-class u {
+async function b(r, t, e) {
+  if (typeof FontFace > "u" || typeof document > "u" || !document.fonts)
+    throw new Error(`AssetLoader: this browser cannot load the font "${r}" (no FontFace)`);
+  const s = new FontFace(r, t, e);
+  await s.load(), document.fonts.add(s);
+}
+class B {
   constructor(t, e = {}) {
-    this.textures = t, this.options = e, this.fetcher = e.fetch ?? ((a) => fetch(a)), this.toCanvas = e.toCanvas ?? c;
+    this.textures = t, this.options = e, this.fetcher = e.fetch ?? ((s) => fetch(s)), this.toCanvas = e.toCanvas ?? $;
   }
   textures;
   options;
   queue = [];
   data = /* @__PURE__ */ new Map();
   maps = /* @__PURE__ */ new Map();
+  ldtks = /* @__PURE__ */ new Map();
+  atlases = /* @__PURE__ */ new Map();
+  /** Decoded audio by key; a key with bytes only waits for a context (`decodeAudio`). */
+  audioBuffers = /* @__PURE__ */ new Map();
+  audioBytes = /* @__PURE__ */ new Map();
+  decoding = /* @__PURE__ */ new Map();
   fetcher;
   toCanvas;
   total = 0;
   done = 0;
   image(t, e) {
     return this.add(t, async () => {
-      this.textures.addCanvas(t, await this.toCanvas(await this.blob(e)));
+      this.textures.addCanvas(t, await this.canvas(e));
     });
   }
   /** An image cut into equal frames named 0, 1, 2…, left to right, then row by row. */
-  spritesheet(t, e, a) {
+  spritesheet(t, e, s) {
     return this.add(t, async () => {
-      this.textures.addSpriteSheet(t, await this.toCanvas(await this.blob(e)), a);
+      this.textures.addSpriteSheet(t, await this.canvas(e), s);
     });
   }
   json(t, e) {
@@ -48,21 +70,120 @@ class u {
     });
   }
   /** A Tiled JSON map, then every tileset image it names (resolved beside the map file). */
-  tilemap(t, e, a = {}) {
+  tilemap(t, e, s = {}) {
+    return this.add(t, async () => {
+      const a = p(await (await this.request(e)).json());
+      this.maps.set(t, a);
+      const o = s.textureKey ?? ((i) => i.name);
+      for (const i of a.tilesets) this.image(o(i), h(i.image, e));
+    });
+  }
+  /**
+   * An LDtk project: the `.ldtk` file, the `.ldtkl` file of each level it saves apart (resolved beside the project),
+   * then every tileset image (resolved beside the project, as LDtk writes `relPath`). Counts as one asset, plus one
+   * per tileset image. Read it back with `ldtkProject(key)`; each level's `map` goes to `TilemapView` as it is.
+   */
+  ldtk(t, e, s = {}) {
+    return this.add(t, async () => {
+      const a = await (await this.request(e)).json(), o = s.levels ? new Set(s.levels) : null, i = w(a).filter((d) => !o || A(a, d, o)), c = await Promise.all(i.map(async (d) => [d, await (await this.request(h(d, e))).json()])), n = m(a, { levels: Object.fromEntries(c) });
+      this.ldtks.set(t, n);
+      const u = s.textureKey ?? ((d) => d.name);
+      for (const d of n.tilesets) this.image(u(d), h(d.image, e));
+    });
+  }
+  /** A loaded LDtk project. */
+  ldtkProject(t) {
+    const e = this.ldtks.get(t);
+    if (!e) throw new Error(`AssetLoader: no LDtk project loaded as "${t}"`);
+    return e;
+  }
+  /**
+   * A TexturePacker (or Pixi) JSON atlas, hash or array format: its page image, and for a multipack atlas every page
+   * named in `meta.related_multi_packs` (each resolved beside the file naming it). The first page is the texture
+   * `key`, further pages `key~1`, `key~2`…, and every frame of every page is found as `textures.get(key, frameName)`.
+   * Counts as one asset in the progress.
+   */
+  atlas(t, e) {
+    return this.add(t, async () => {
+      const s = this.textures.addAtlas?.bind(this.textures);
+      if (!s) throw new Error(`AssetLoader: the texture sink cannot take atlases (no addAtlas) for "${t}"`);
+      const a = await g(
+        e,
+        async (n) => v(await (await this.request(n)).json(), n),
+        h
+      ), o = await Promise.all(a.map((n) => this.canvas(h(n.page.image, n.url)))), i = x(a.map((n) => n.page));
+      i.length && console.warn(`[assets] atlas "${t}" names ${i.length} frame(s) on more than one page: ${i.slice(0, 5).join(", ")}`), s(t, a.map((n, u) => ({ canvas: o[u], frames: n.page.frames })));
+      const c = {};
+      for (const n of a) Object.assign(c, n.page.animations);
+      this.atlases.set(t, { frames: [...new Set(a.flatMap((n) => n.page.frames.map((u) => u.name)))], animations: c, pages: a.length });
+    });
+  }
+  /**
+   * A web font (woff2, woff, ttf) under `family`, added to `document.fonts` once loaded so canvas text and the DOM can
+   * use it at once — load fonts before the first `Text` is drawn, or it measures with the fallback.
+   */
+  font(t, e, s) {
+    const a = this.options.addFont ?? b;
     return this.add(t, async () => {
-      const s = h(await (await this.request(e)).json());
-      this.maps.set(t, s);
-      const o = a.textureKey ?? ((i) => i.name);
-      for (const i of s.tilesets) this.image(o(i), n(i.image, e));
+      const o = await this.bytes(e);
+      try {
+        await a(t, o, s);
+      } catch (i) {
+        throw new Error(`AssetLoader: could not load font "${t}" from ${this.full(e)}: ${l(i)}`);
+      }
     });
   }
+  /**
+   * A sound file decoded into an `AudioBuffer` through the engine's audio context (`getAudio`). Before any context
+   * exists (browsers open one only after a gesture) the bytes are kept and decoded by `decodeAudio`, so a loading
+   * screen never has to wait for the player to click.
+   */
+  audio(t, e) {
+    return this.add(t, async () => {
+      const s = await this.bytes(e);
+      this.audioBuffers.delete(t), this.decoding.delete(t);
+      const a = (this.options.audioContext ?? (() => f.audioContext))();
+      a ? this.audioBuffers.set(t, await this.decode(a, s, e)) : this.audioBytes.set(t, s);
+    });
+  }
+  /** A loaded sound, decoded; null while it waits for an audio context (`decodeAudio`). */
+  getAudio(t) {
+    const e = this.audioBuffers.get(t);
+    if (e) return e;
+    if (this.audioBytes.has(t)) return null;
+    throw new Error(`AssetLoader: no audio loaded as "${t}"`);
+  }
+  /** A loaded sound, decoding its kept bytes through `ctx` (default: the loader's context) the first time. */
+  decodeAudio(t, e) {
+    const s = this.audioBuffers.get(t);
+    if (s) return Promise.resolve(s);
+    const a = this.decoding.get(t);
+    if (a) return a;
+    const o = this.audioBytes.get(t);
+    if (!o) return Promise.reject(new Error(`AssetLoader: no audio loaded as "${t}"`));
+    const i = e ?? (this.options.audioContext ?? (() => f.audioContext))();
+    if (!i) return Promise.reject(new Error(`AssetLoader: no audio context to decode "${t}" yet`));
+    const c = this.decode(i, o, t).then(
+      (n) => (this.audioBuffers.set(t, n), this.audioBytes.delete(t), this.decoding.delete(t), n),
+      (n) => {
+        throw this.decoding.delete(t), n;
+      }
+    );
+    return this.decoding.set(t, c), c;
+  }
+  /** What a loaded atlas holds: its frame names and animations. */
+  getAtlas(t) {
+    const e = this.atlases.get(t);
+    if (!e) throw new Error(`AssetLoader: no atlas loaded as "${t}"`);
+    return e;
+  }
   /** Runs everything queued; `onProgress` after each asset. Safe to call again after queueing more. */
   async load(t) {
-    const e = Math.max(1, this.options.concurrency ?? 6), a = async () => {
-      for (let s = this.queue.shift(); s; s = this.queue.shift())
-        await s.run(), this.done++, t?.({ done: this.done, total: this.total, key: s.key });
+    const e = Math.max(1, this.options.concurrency ?? 6), s = async () => {
+      for (let a = this.queue.shift(); a; a = this.queue.shift())
+        await a.run(), this.done++, t?.({ done: this.done, total: this.total, key: a.key });
     };
-    for (; this.queue.length; ) await Promise.all(Array.from({ length: e }, a));
+    for (; this.queue.length; ) await Promise.all(Array.from({ length: e }, s));
   }
   /** A loaded JSON value. */
   getJson(t) {
@@ -82,23 +203,45 @@ class u {
   add(t, e) {
     return this.queue.push({ key: t, run: e }), this.total++, this;
   }
+  full(t) {
+    return h(t, this.options.baseUrl ?? "");
+  }
   async request(t) {
-    const e = n(t, this.options.baseUrl ?? "");
-    let a;
+    const e = this.full(t);
+    let s;
     try {
-      a = await this.fetcher(e);
-    } catch (s) {
-      throw new Error(`AssetLoader: could not fetch ${e}: ${s instanceof Error ? s.message : String(s)}`);
+      s = await this.fetcher(e);
+    } catch (a) {
+      throw new Error(`AssetLoader: could not fetch ${e}: ${l(a)}`);
     }
-    if (!a.ok) throw new Error(`AssetLoader: ${e} answered ${a.status}`);
-    return a;
+    if (!s.ok) throw new Error(`AssetLoader: ${e} answered ${s.status}`);
+    return s;
   }
   async blob(t) {
     return (await this.request(t)).blob();
   }
+  /** An image file decoded into a canvas; a file that is not an image fails naming its URL. */
+  async canvas(t) {
+    const e = await this.blob(t);
+    try {
+      return await this.toCanvas(e);
+    } catch (s) {
+      throw new Error(`AssetLoader: could not decode image ${this.full(t)}: ${l(s)}`);
+    }
+  }
+  async bytes(t) {
+    const e = await this.request(t);
+    return typeof e.arrayBuffer == "function" ? e.arrayBuffer() : (await e.blob()).arrayBuffer();
+  }
+  async decode(t, e, s) {
+    try {
+      return await t.decodeAudioData(e.slice(0));
+    } catch (a) {
+      throw new Error(`AssetLoader: could not decode audio ${s}: ${l(a)}`);
+    }
+  }
 }
 export {
-  u as AssetLoader,
-  n as resolveUrl
+  B as AssetLoader,
+  h as resolveUrl
 };
-//# sourceMappingURL=AssetLoader.js.map

package/dist/assets/Prepainter.js

@@ -0,0 +1,61 @@
+function d({ w: o, h: t, pixels: e }) {
+  if (typeof document > "u") return null;
+  const s = document.createElement("canvas");
+  s.width = o, s.height = t;
+  const n = s.getContext("2d");
+  return n ? (n.putImageData(new ImageData(new Uint8ClampedArray(e), o, t), 0, 0), s) : null;
+}
+class h {
+  constructor(t) {
+    this.options = t, this.key = t.key ?? ((e) => e);
+  }
+  options;
+  pending = /* @__PURE__ */ new Set();
+  /** Ids whose painting is held as a texture: the current one and its neighbours. */
+  held = /* @__PURE__ */ new Set();
+  key;
+  destroyed = !1;
+  /**
+   * Stands on `current`: its texture (painted by the caller on arrival, or ahead) and its neighbours' are kept, every
+   * other one this prepainter held is freed, and the neighbours not yet painted are started.
+   */
+  enter(t, e) {
+    const s = this.options.id, n = s(t), r = /* @__PURE__ */ new Set([n, ...e.map(s)]);
+    for (const i of this.held)
+      r.has(i) || (this.options.textures.remove(this.key(i)), this.held.delete(i));
+    this.held.add(n);
+    for (const i of e) this.prepare(i);
+  }
+  /** Whether `id` is being painted right now (so a caller may wait for it a moment rather than paint it again). */
+  painting(t) {
+    return this.pending.has(t);
+  }
+  /** Ids held as textures now. */
+  get holding() {
+    return this.held;
+  }
+  /** Starts painting `item` unless it is painted or under way. */
+  prepare(t) {
+    const e = this.options.id(t), s = this.options.textures.exists(this.key(e));
+    s && this.held.add(e);
+    const n = this.options.painter;
+    s || this.pending.has(e) || !n || this.destroyed || (this.pending.add(e), n.paint(t, e).then(
+      (r) => this.receive(e, r),
+      () => this.pending.delete(e)
+    ));
+  }
+  /** Stops painting; textures already made are left to the registry. */
+  destroy() {
+    this.destroyed = !0, this.options.painter?.dispose?.(), this.pending.clear();
+  }
+  receive(t, e) {
+    if (this.pending.delete(t), this.destroyed) return;
+    const s = this.key(t);
+    if (this.options.textures.exists(s)) return;
+    const n = (this.options.canvas ?? d)(e);
+    n && (this.options.textures.addCanvas(s, n), this.held.add(t), this.options.onPainted?.(t));
+  }
+}
+export {
+  h as Prepainter
+};

package/dist/assets/loadAseprite.js

@@ -47,4 +47,3 @@ export {
   p as addAsepriteTextures,
   A as loadAseprite
 };
-//# sourceMappingURL=loadAseprite.js.map

package/dist/assets/takeCleanerWorker-DTcI_Jqr.js

@@ -28,4 +28,3 @@ self.onmessage = (l) => {
   const { id: h, channels: a, sampleRate: f } = l.data, e = m(a, f);
   self.postMessage({ id: h, data: e }, e ? { transfer: [e.buffer] } : void 0);
 };
-//# sourceMappingURL=takeCleanerWorker-DTcI_Jqr.js.map

package/dist/assets/textureAtlas.js

@@ -0,0 +1,58 @@
+function m(n) {
+  const e = n;
+  return typeof e == "object" && e !== null && [e.x, e.y, e.w, e.h].every((t) => typeof t == "number" && Number.isFinite(t));
+}
+function u(n, e, t) {
+  if (!m(e.frame)) throw new Error(`${t}: frame "${n}" has no frame rect`);
+  const o = e.frame, i = e.rotated === !0, a = {
+    name: n,
+    x: Math.floor(o.x),
+    y: Math.floor(o.y),
+    w: Math.floor(i ? o.h : o.w),
+    h: Math.floor(i ? o.w : o.h),
+    rotated: i,
+    sourceW: Math.floor(e.trimmed && e.sourceSize ? e.sourceSize.w : o.w),
+    sourceH: Math.floor(e.trimmed && e.sourceSize ? e.sourceSize.h : o.h)
+  };
+  if (e.trimmed !== !1 && m(e.spriteSourceSize) && e.sourceSize) {
+    const f = e.spriteSourceSize;
+    f.x === 0 && f.y === 0 && o.w === e.sourceSize.w && o.h === e.sourceSize.h || (a.trim = { x: Math.floor(f.x), y: Math.floor(f.y), w: Math.floor(o.w), h: Math.floor(o.h) }, a.sourceW = Math.floor(e.sourceSize.w), a.sourceH = Math.floor(e.sourceSize.h));
+  }
+  const r = e.anchor ?? e.pivot;
+  return r && typeof r.x == "number" && typeof r.y == "number" && (a.anchor = { x: r.x, y: r.y }), a;
+}
+function h(n, e = "atlas") {
+  const t = n;
+  if (typeof t != "object" || t === null || typeof t.frames != "object" || t.frames === null)
+    throw new Error(`${e}: not a TexturePacker JSON atlas (no "frames")`);
+  const o = t.meta?.image;
+  if (typeof o != "string" || o === "") throw new Error(`${e}: no "meta.image"`);
+  const i = Array.isArray(t.frames) ? t.frames.map((s, c) => u(typeof s?.filename == "string" ? s.filename : String(c), s ?? {}, e)) : Object.entries(t.frames).map(([s, c]) => u(s, c ?? {}, e)), a = Array.isArray(t.meta?.related_multi_packs) ? t.meta.related_multi_packs.filter((s) => typeof s == "string" && s !== "") : [], r = {};
+  if (typeof t.animations == "object" && t.animations !== null)
+    for (const [s, c] of Object.entries(t.animations))
+      Array.isArray(c) && (r[s] = c.filter((l) => typeof l == "string"));
+  const f = Number(t.meta?.scale);
+  return { image: o, frames: i, animations: r, related: a, scale: Number.isFinite(f) && f > 0 ? f : 1 };
+}
+async function y(n, e, t) {
+  const o = /* @__PURE__ */ new Set([n]), i = [], a = [n];
+  for (let r = a.shift(); r !== void 0; r = a.shift()) {
+    const f = await e(r);
+    i.push({ url: r, page: f });
+    for (const s of f.related) {
+      const c = t(s, r);
+      o.has(c) || (o.add(c), a.push(c));
+    }
+  }
+  return i;
+}
+function p(n) {
+  const e = /* @__PURE__ */ new Set(), t = /* @__PURE__ */ new Set();
+  for (const o of n) for (const i of o.frames) (e.has(i.name) ? t : e).add(i.name);
+  return [...t];
+}
+export {
+  y as collectAtlasPages,
+  p as duplicateFrames,
+  h as parseAtlas
+};

package/dist/assets/workerPainter.js

@@ -0,0 +1,39 @@
+function w(i) {
+  let n;
+  const o = /* @__PURE__ */ new Map(), c = (r) => {
+    n?.terminate(), n = null;
+    for (const t of o.values()) for (const e of t) e.reject(new Error(r));
+    o.clear();
+  }, f = () => {
+    if (n !== void 0) return n;
+    try {
+      const r = i.create();
+      r.onmessage = (t) => {
+        const e = t.data, s = o.get(e.id);
+        if (s) {
+          o.delete(e.id);
+          for (const a of s)
+            "error" in e ? a.reject(new Error(e.error)) : a.resolve(e);
+        }
+      }, r.onerror = () => c("the painter worker failed"), n = r;
+    } catch {
+      n = null;
+    }
+    return n;
+  };
+  return {
+    paint(r, t) {
+      const e = f();
+      return e ? new Promise((s, a) => {
+        const l = o.get(t);
+        l ? l.push({ resolve: s, reject: a }) : (o.set(t, [{ resolve: s, reject: a }]), e.postMessage(i.message ? i.message(r, t) : { id: t, item: r }));
+      }) : Promise.reject(new Error("no painter worker"));
+    },
+    dispose() {
+      c("disposed");
+    }
+  };
+}
+export {
+  w as workerPainter
+};

package/dist/audio/Footsteps.js

@@ -23,4 +23,3 @@ class u {
 export {
   u as Footsteps
 };
-//# sourceMappingURL=Footsteps.js.map

package/dist/audio/MusicPlayer.js

@@ -75,4 +75,3 @@ export {
   a as MusicPlayer,
   w as music
 };
-//# sourceMappingURL=MusicPlayer.js.map

package/dist/audio/SoundEngine.js

@@ -2,8 +2,8 @@ import { engineSettings as m } from "../settings.js";
 import { SampleBank as E, hasTakes as y } from "./sampleBank.js";
 import { SOUNDS as u } from "./soundTable.js";
 import { renderRecipe as R, SYNTH_RATE as k } from "./synth.js";
-const p = 480, _ = 10, q = 6, B = 60, F = 0.45, O = 0.05, w = 80, g = [18e3, 1800], T = { freq: 3500, gainDb: -7 }, V = 11e3;
-class C {
+const p = 480, _ = 10, q = 6, B = 60, F = 0.45, C = 0.05, w = 80, g = [18e3, 1800], T = { freq: 3500, gainDb: -7 }, O = 11e3;
+class V {
   ctx = null;
   master = null;
   buffers = /* @__PURE__ */ new Map();
@@ -32,6 +32,13 @@ class C {
       this.ctx && this.master && this.master.gain.setTargetAtTime(this.level(s.sfxVolume), this.ctx.currentTime, 0.02);
     });
   }
+  /**
+   * The effects' audio context once something opened it (the first gesture does), else null: never created here, so
+   * asking does not open a context the browser would hold suspended. `AssetLoader.audio` decodes through it.
+   */
+  get audioContext() {
+    return this.ctx;
+  }
   play(t, n = {}) {
     if (!t || !u.recipes[t] && !y(t) || m.getState().sfxVolume <= 0) return;
     const e = this.ctx;
@@ -53,7 +60,7 @@ class C {
     v && (i *= u.recipes[t]?.fileGain ?? 1), this.lastAt.set(t, x);
     const c = e.createBufferSource();
     c.buffer = l;
-    const S = u.recipes[t]?.jitter ?? O;
+    const S = u.recipes[t]?.jitter ?? C;
     c.playbackRate.value = 1 + (Math.random() * 2 - 1) * S;
     const a = e.createGain();
     a.gain.value = Math.min(1, i);
@@ -79,7 +86,7 @@ class C {
     const t = this.ctx.createBiquadFilter();
     t.type = "highshelf", t.frequency.value = T.freq, t.gain.value = T.gainDb;
     const n = this.ctx.createBiquadFilter();
-    n.type = "lowpass", n.frequency.value = V, this.master.connect(t).connect(n).connect(this.ctx.destination);
+    n.type = "lowpass", n.frequency.value = O, this.master.connect(t).connect(n).connect(this.ctx.destination);
     const e = this.ctx, i = () => {
       const s = e.state === "running";
       this.onRunning(s), s && this.prerender(e);
@@ -111,9 +118,8 @@ class C {
     return this.buffers.set(n, s), s;
   }
 }
-const H = new C();
+const H = new V();
 export {
-  C as SoundEngine,
+  V as SoundEngine,
   H as sound
 };
-//# sourceMappingURL=SoundEngine.js.map

package/dist/audio/cleanTake.js

@@ -27,4 +27,3 @@ function L(c, h) {
 export {
   L as cleanSamples
 };
-//# sourceMappingURL=cleanTake.js.map

package/dist/audio/music/ElementVoice.js

@@ -32,4 +32,3 @@ class m {
 export {
   m as ElementVoice
 };
-//# sourceMappingURL=ElementVoice.js.map

package/dist/audio/music/GraphVoice.js

@@ -36,4 +36,3 @@ class h {
 export {
   h as GraphVoice
 };
-//# sourceMappingURL=GraphVoice.js.map

package/dist/audio/music/MusicChannel.js

@@ -55,4 +55,3 @@ class h {
 export {
   h as MusicChannel
 };
-//# sourceMappingURL=MusicChannel.js.map

package/dist/audio/music/musicVoice.js

@@ -10,4 +10,3 @@ export {
   o as clamp01,
   n as elementVolumeLocked
 };
-//# sourceMappingURL=musicVoice.js.map

package/dist/audio/sampleBank.js

@@ -79,4 +79,3 @@ export {
   y as hasTakes,
   k as registerTakes
 };
-//# sourceMappingURL=sampleBank.js.map

package/dist/audio/soundTable.js

@@ -6,4 +6,3 @@ export {
   s as SOUNDS,
   r as registerSounds
 };
-//# sourceMappingURL=soundTable.js.map

package/dist/audio/synth.js

@@ -33,4 +33,3 @@ export {
   Y as SYNTH_RATE,
   _ as renderRecipe
 };
-//# sourceMappingURL=synth.js.map

package/dist/cjs/electron/electronLike.d.ts

@@ -0,0 +1,55 @@
+/** `electron.safeStorage`. */
+export interface SafeStorageLike {
+    isEncryptionAvailable(): boolean;
+    /** Linux only: `basic_text` means a hard-coded key, which is no encryption at all. */
+    getSelectedStorageBackend?(): string;
+    encryptString(plainText: string): Uint8Array;
+    decryptString(encrypted: Buffer): string;
+}
+/** `electron.ipcMain`. */
+export interface IpcMainLike {
+    handle(channel: string, listener: (event: any, ...args: any[]) => unknown): void;
+    removeHandler?(channel: string): void;
+}
+/** `electron.shell`. */
+export interface ShellLike {
+    openExternal(url: string): Promise<void>;
+}
+/** What `before-input-event` hands a listener (`Electron.Input`). */
+export interface InputLike {
+    type: string;
+    key: string;
+    control: boolean;
+    meta: boolean;
+    shift: boolean;
+    alt: boolean;
+}
+/** An event a listener may cancel. */
+export interface PreventableLike {
+    preventDefault(): void;
+}
+/** `electron.Session`, for the permission handlers. */
+export interface SessionLike {
+    setPermissionRequestHandler(handler: ((webContents: any, permission: any, callback: (granted: boolean) => void, details: any) => void) | null): void;
+    setPermissionCheckHandler(handler: ((webContents: any, permission: any, requestingOrigin: string, details: any) => boolean) | null): void;
+}
+/** `electron.WebContents`. */
+export interface WebContentsLike {
+    setWindowOpenHandler(handler: (details: {
+        url: string;
+    }) => any): void;
+    on(event: any, listener: (...args: any[]) => void): unknown;
+    toggleDevTools(): void;
+    session?: SessionLike;
+}
+/** `electron.BrowserWindow`, as far as a lockdown needs it. */
+export interface WindowLike {
+    webContents: WebContentsLike;
+}
+/** `electron.app`, as far as the debugger refusal needs it. */
+export interface AppLike {
+    isPackaged: boolean;
+    commandLine: {
+        hasSwitch(name: string): boolean;
+    };
+}

package/dist/cjs/electron/electronLike.js

@@ -0,0 +1,7 @@
+"use strict";
+/*
+ * The few parts of Electron's main-process API this module touches, written as structural types so the engine never
+ * imports or depends on `electron`: a game passes its own `app`, `safeStorage`, `ipcMain`, `shell` and windows, and
+ * a test passes fakes. Each is a subset of Electron's own type, so Electron's objects fit them as they are.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/electron/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `1681-engine/electron`: the main-process side of a desktop build on Electron — file-by-file web patching from a
+ * release store, the shell's identity, an OS-encrypted session store and a window lockdown. Electron is an optional
+ * peer: nothing here imports it, the game hands in its own `app`, `safeStorage`, `ipcMain`, `shell` and windows. Runs
+ * in the main process only (it uses Node's `fs` and `crypto`); the pure rules it shares with browsers and phones are
+ * `1681-engine/updates`. Importable from ESM (`import`) and from a CommonJS main process (`require`).
+ */
+export type { SafeStorageLike, IpcMainLike, ShellLike, InputLike, PreventableLike, SessionLike, WebContentsLike, WindowLike, AppLike } from './electronLike';
+export { shellId, type ShellIdOptions } from './shellId';
+export { WebPatcher, type WebPatcherOptions } from './webPatcher';
+export type { WebPointer, PointerName } from './webPointers';
+export { SessionStore, registerSessionStore, type SessionStoreOptions } from './sessionStore';
+export { isAllowedExternal, isAllowedNavigation, isDevToolsKey, debuggerRequested, DEBUG_SWITCHES, type ExternalPolicy } from './lockdownRules';
+export { lockDownWindow, denyPermissions, refuseDebugLaunch, type LockdownOptions } from './lockdown';

package/dist/cjs/electron/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.refuseDebugLaunch = exports.denyPermissions = exports.lockDownWindow = exports.DEBUG_SWITCHES = exports.debuggerRequested = exports.isDevToolsKey = exports.isAllowedNavigation = exports.isAllowedExternal = exports.registerSessionStore = exports.SessionStore = exports.WebPatcher = exports.shellId = void 0;
+var shellId_1 = require("./shellId");
+Object.defineProperty(exports, "shellId", { enumerable: true, get: function () { return shellId_1.shellId; } });
+var webPatcher_1 = require("./webPatcher");
+Object.defineProperty(exports, "WebPatcher", { enumerable: true, get: function () { return webPatcher_1.WebPatcher; } });
+var sessionStore_1 = require("./sessionStore");
+Object.defineProperty(exports, "SessionStore", { enumerable: true, get: function () { return sessionStore_1.SessionStore; } });
+Object.defineProperty(exports, "registerSessionStore", { enumerable: true, get: function () { return sessionStore_1.registerSessionStore; } });
+var lockdownRules_1 = require("./lockdownRules");
+Object.defineProperty(exports, "isAllowedExternal", { enumerable: true, get: function () { return lockdownRules_1.isAllowedExternal; } });
+Object.defineProperty(exports, "isAllowedNavigation", { enumerable: true, get: function () { return lockdownRules_1.isAllowedNavigation; } });
+Object.defineProperty(exports, "isDevToolsKey", { enumerable: true, get: function () { return lockdownRules_1.isDevToolsKey; } });
+Object.defineProperty(exports, "debuggerRequested", { enumerable: true, get: function () { return lockdownRules_1.debuggerRequested; } });
+Object.defineProperty(exports, "DEBUG_SWITCHES", { enumerable: true, get: function () { return lockdownRules_1.DEBUG_SWITCHES; } });
+var lockdown_1 = require("./lockdown");
+Object.defineProperty(exports, "lockDownWindow", { enumerable: true, get: function () { return lockdown_1.lockDownWindow; } });
+Object.defineProperty(exports, "denyPermissions", { enumerable: true, get: function () { return lockdown_1.denyPermissions; } });
+Object.defineProperty(exports, "refuseDebugLaunch", { enumerable: true, get: function () { return lockdown_1.refuseDebugLaunch; } });