1681-engine 0.5.9 → 0.6.0

package/dist/assets/AssetLoader.js

@@ -1,35 +1,44 @@
-import { sound as u } from "../audio/SoundEngine.js";
-import { parseTiled as f } from "../tilemap/tiled.js";
-import { collectAtlasPages as l, duplicateFrames as w, parseAtlas as p } from "./textureAtlas.js";
-function c(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 i of a)
-    i === ".." && s.length && s[s.length - 1] !== ".." && s[s.length - 1] !== "" ? s.pop() : i !== "." && s.push(i);
-  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 m(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;
 }
-async function g(r, t, e) {
+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 a = new FontFace(r, t, e);
-  await a.load(), document.fonts.add(a);
+  const s = new FontFace(r, t, e);
+  await s.load(), document.fonts.add(s);
 }
-class $ {
+class B {
   constructor(t, e = {}) {
-    this.textures = t, this.options = e, this.fetcher = e.fetch ?? ((a) => fetch(a)), this.toCanvas = e.toCanvas ?? m;
+    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();
@@ -41,13 +50,13 @@ class $ {
   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) {
@@ -61,14 +70,33 @@ class $ {
     });
   }
   /** 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 s = f(await (await this.request(e)).json());
-      this.maps.set(t, s);
-      const i = a.textureKey ?? ((n) => n.name);
-      for (const n of s.tilesets) this.image(i(n), c(n.image, e));
+      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
@@ -77,27 +105,32 @@ class $ {
    */
   atlas(t, e) {
     return this.add(t, async () => {
-      const a = this.textures.addAtlas?.bind(this.textures);
-      if (!a) throw new Error(`AssetLoader: the texture sink cannot take atlases (no addAtlas) for "${t}"`);
-      const s = await l(
+      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 (o) => p(await (await this.request(o)).json(), o),
-        c
-      ), i = await Promise.all(s.map((o) => this.blob(c(o.page.image, o.url)).then((h) => this.toCanvas(h)))), n = w(s.map((o) => o.page));
-      n.length && console.warn(`[assets] atlas "${t}" names ${n.length} frame(s) on more than one page: ${n.slice(0, 5).join(", ")}`), a(t, s.map((o, h) => ({ canvas: i[h], frames: o.page.frames })));
-      const d = {};
-      for (const o of s) Object.assign(d, o.page.animations);
-      this.atlases.set(t, { frames: [...new Set(s.flatMap((o) => o.page.frames.map((h) => h.name)))], animations: d, pages: s.length });
+        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, a) {
-    const s = this.options.addFont ?? g;
+  font(t, e, s) {
+    const a = this.options.addFont ?? b;
     return this.add(t, async () => {
-      await s(t, await this.bytes(e), a);
+      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)}`);
+      }
     });
   }
   /**
@@ -107,10 +140,10 @@ class $ {
    */
   audio(t, e) {
     return this.add(t, async () => {
-      const a = await this.bytes(e);
+      const s = await this.bytes(e);
       this.audioBuffers.delete(t), this.decoding.delete(t);
-      const s = (this.options.audioContext ?? (() => u.audioContext))();
-      s ? this.audioBuffers.set(t, await this.decode(s, a, e)) : this.audioBytes.set(t, a);
+      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`). */
@@ -122,21 +155,21 @@ class $ {
   }
   /** A loaded sound, decoding its kept bytes through `ctx` (default: the loader's context) the first time. */
   decodeAudio(t, e) {
-    const a = this.audioBuffers.get(t);
-    if (a) return Promise.resolve(a);
-    const s = this.decoding.get(t);
-    if (s) return s;
-    const i = this.audioBytes.get(t);
-    if (!i) return Promise.reject(new Error(`AssetLoader: no audio loaded as "${t}"`));
-    const n = e ?? (this.options.audioContext ?? (() => u.audioContext))();
-    if (!n) return Promise.reject(new Error(`AssetLoader: no audio context to decode "${t}" yet`));
-    const d = this.decode(n, i, t).then(
-      (o) => (this.audioBuffers.set(t, o), this.audioBytes.delete(t), this.decoding.delete(t), o),
-      (o) => {
-        throw this.decoding.delete(t), o;
+    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, d), d;
+    return this.decoding.set(t, c), c;
   }
   /** What a loaded atlas holds: its frame names and animations. */
   getAtlas(t) {
@@ -146,11 +179,11 @@ class $ {
   }
   /** 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) {
@@ -170,33 +203,45 @@ class $ {
   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 = c(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, a) {
+  async decode(t, e, s) {
     try {
       return await t.decodeAudioData(e.slice(0));
-    } catch (s) {
-      throw new Error(`AssetLoader: could not decode audio ${a}: ${s instanceof Error ? s.message : String(s)}`);
+    } catch (a) {
+      throw new Error(`AssetLoader: could not decode audio ${s}: ${l(a)}`);
     }
   }
 }
 export {
-  $ as AssetLoader,
-  c as resolveUrl
+  B as AssetLoader,
+  h as resolveUrl
 };

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/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/spatial.js

@@ -0,0 +1,118 @@
+const l = [18e3, 1800];
+function f(c, t, e = {}) {
+  const i = e.range ?? 480, s = t.x - c.x, n = Math.hypot(s, t.y - c.y), r = e.maxPan ?? 0.8, h = Math.max(-r, Math.min(r, s / (e.panWidth ?? i / 2))), o = e.muffle === void 0 ? l : e.muffle, a = Math.min(1, n / i), u = o ? o[0] * Math.pow(o[1] / o[0], a) : 2e4;
+  return n >= i ? { audible: !1, gain: 0, pan: h, cutoffHz: u } : { audible: !0, gain: Math.pow(1 - a, e.rolloff ?? 1.5), pan: h, cutoffHz: u };
+}
+const m = 0.05;
+class d {
+  constructor(t, e = t.destination) {
+    this.context = t, this.output = t.createGain(), this.output.connect(e);
+  }
+  context;
+  /** Every emitter's gain goes through this: the game's volume setting. */
+  output;
+  emitters = /* @__PURE__ */ new Set();
+  here = { x: 0, y: 0 };
+  /** The listener's place as of the last `update`. */
+  get listener() {
+    return this.here;
+  }
+  /** How many emitters are alive (playing or waiting out of range). */
+  get size() {
+    return this.emitters.size;
+  }
+  /** A sound at (x, y), looping by default. Starts at once when in range of the listener. */
+  emitter(t, e, i, s = {}) {
+    const n = new p(this, t, e, i, s);
+    return this.emitters.add(n), n.refresh(this.here, !1), n;
+  }
+  /** A one-shot at (x, y), dropped when it ends; skipped (and done at once) when out of range. */
+  play(t, e, i, s = {}) {
+    return this.emitter(t, e, i, { ...s, loop: !1 });
+  }
+  /** Moves the listener and re-mixes every emitter. Call once a frame. */
+  update(t = this.here) {
+    this.here = { x: t.x, y: t.y };
+    for (const e of this.emitters) e.refresh(this.here, !0);
+  }
+  /** Stops every emitter. */
+  stopAll(t = 0) {
+    for (const e of [...this.emitters]) e.stop(t);
+  }
+  destroy() {
+    this.stopAll(), this.output.disconnect();
+  }
+  /** @internal */
+  forget(t) {
+    this.emitters.delete(t);
+  }
+}
+class p {
+  constructor(t, e, i, s, n) {
+    this.owner = t, this.buffer = e, this.x = i, this.y = s, this.options = n;
+    const r = t.context;
+    this.volume = n.volume ?? 1, this.rate = n.playbackRate ?? 1, this.origin = r.currentTime, this.filter = r.createBiquadFilter(), this.filter.type = "lowpass", this.gain = r.createGain(), this.panner = r.createStereoPanner(), this.filter.connect(this.gain).connect(this.panner).connect(t.output);
+  }
+  owner;
+  buffer;
+  x;
+  y;
+  options;
+  volume;
+  done = !1;
+  source = null;
+  gain;
+  panner;
+  filter;
+  /** When the loop would have begun, had it never stopped: where a restart picks it up. */
+  origin;
+  rate;
+  get playing() {
+    return this.source !== null;
+  }
+  refresh(t, e) {
+    if (this.done) return;
+    const i = f(t, this, this.options), s = this.options.loop ?? !0;
+    if (!i.audible) {
+      if (!s) return this.stop();
+      this.halt();
+      return;
+    }
+    const n = this.owner.context, r = n.currentTime, h = (o, a) => e && this.source ? o.setTargetAtTime(a, r, m) : o.setValueAtTime(a, r);
+    h(this.gain.gain, i.gain * Math.max(0, Math.min(1, this.volume))), h(this.panner.pan, i.pan), h(this.filter.frequency, Math.min(i.cutoffHz, n.sampleRate / 2)), this.source || this.begin(s);
+  }
+  stop(t = 0) {
+    if (this.done) return;
+    this.done = !0, this.owner.forget(this);
+    const e = this.source, i = this.owner.context;
+    if (e && t > 0) {
+      const s = i.currentTime + t / 1e3;
+      this.gain.gain.setValueAtTime(this.gain.gain.value, i.currentTime), this.gain.gain.linearRampToValueAtTime(0, s), e.stop(s), e.onended = () => this.release();
+    } else
+      this.halt(), this.release();
+  }
+  begin(t) {
+    const e = this.owner.context, i = e.createBufferSource();
+    i.buffer = this.buffer, i.loop = t, i.playbackRate.value = this.rate, i.connect(this.filter);
+    const s = t ? (e.currentTime - this.origin) * this.rate % this.buffer.duration : 0;
+    i.start(e.currentTime, s), t || (i.onended = () => this.stop()), this.source = i;
+  }
+  halt() {
+    const t = this.source;
+    if (t) {
+      this.source = null, t.onended = null;
+      try {
+        t.stop();
+      } catch {
+      }
+      t.disconnect();
+    }
+  }
+  release() {
+    this.filter.disconnect(), this.gain.disconnect(), this.panner.disconnect();
+  }
+}
+export {
+  d as SpatialAudio,
+  f as spatialMix
+};

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; } });

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

@@ -0,0 +1,33 @@
+import type { AppLike, SessionLike, ShellLike, WindowLike } from './electronLike';
+import { type ExternalPolicy } from './lockdownRules';
+/** How {@link lockDownWindow} treats a window. */
+export interface LockdownOptions {
+    /** `electron.shell`, which opens an allowed link in the system browser. */
+    shell: ShellLike;
+    /** The links that may leave for the system browser. */
+    external: ExternalPolicy;
+    /** `app.isPackaged`: a packaged build refuses the DevTools keys. */
+    packaged: boolean;
+    /** A dev run's page origin, allowed for navigation; leave unset in a packaged build whatever the environment says. */
+    devServerUrl?: string;
+    /** In a dev run, this key toggles DevTools. Default `F12`; null for none. */
+    devToolsKey?: string | null;
+    /** Where refusals are reported. Default `console.log`. */
+    log?: (...args: unknown[]) => void;
+}
+/**
+ * Keeps a window on the game: a new window is never opened (an allowed link goes to the system browser instead, any
+ * other is refused), the window never navigates or redirects away from the game's own page, and a packaged build
+ * refuses the DevTools keys (set `webPreferences.devTools: !app.isPackaged` too: the keys are only the visible way in).
+ */
+export declare function lockDownWindow(win: WindowLike, o: LockdownOptions): void;
+/**
+ * Answers every permission request and check on `session` (camera, microphone, notifications, geolocation…) with no,
+ * but those in `allow`. Chromium's default in Electron is yes to almost everything, which a game never needs.
+ */
+export declare function denyPermissions(session: SessionLike, allow?: readonly string[]): void;
+/**
+ * A packaged app started with a debugger switch quits before it opens a window. Call it first thing in the main
+ * process; `exit` defaults to `process.exit` — not `app.exit`, so nothing after the call may run.
+ */
+export declare function refuseDebugLaunch(app: AppLike, argv?: readonly string[], exit?: (code: number) => void): boolean;