1681-engine 0.5.10 → 0.6.1

package/dist/core/Stage.js

@@ -1,24 +1,34 @@
-import { Container as r } from "pixi.js";
-import { Camera as n } from "./Camera.js";
-import { Clock as a } from "./Clock.js";
+import { Container as s } from "pixi.js";
+import { Camera as a } from "./Camera.js";
+import { Clock as n } from "./Clock.js";
 import { ObjectFactory as o } from "./ObjectFactory.js";
+import { PixelGrid as d } from "./PixelGrid.js";
 import { Pointer as c } from "./Pointer.js";
-import { Tweener as d } from "./Tweener.js";
+import { Tweener as m } from "./Tweener.js";
 class h {
-  constructor(e, t) {
-    this.app = e, this.textures = t, e.stage.addChild(this.world, this.screen), this.cameras = { main: new n(this.world, this.screen) }, this.input = { activePointer: new c(e.canvas) }, this.time.onError = (i) => this.caught("timers", i), this.syncSize();
+  constructor(t, e) {
+    this.app = t, this.textures = e, t.stage.addChild(this.world, this.screen), this.cameras = { main: new a(this.world, this.screen) }, this.input = { activePointer: new c(t.canvas) }, this.grid = new d(t, this.world), this.time.onError = (i) => this.caught("timers", i), this.syncSize();
   }
   app;
   textures;
   /** Told of every fault a guarded step caught (error telemetry, if the game sets one). */
   static onCaught = null;
-  world = new r({ sortableChildren: !0 });
-  screen = new r();
+  world = new s({ sortableChildren: !0 });
+  screen = new s();
   add = new o(this);
-  tweens = new d();
-  time = new a();
+  tweens = new m();
+  time = new n();
   cameras;
   input;
+  /**
+   * Pixel-perfect: the world drawn one texel to a world pixel and scaled up by the camera's zoom (`PixelGrid`), so turned,
+   * scaled and between-pixels art lands on one grid; text made by `add.text`/`add.label` stays at screen resolution.
+   * Off (the default), the world is drawn straight at the zoom. Takes effect on the next frame; may be switched any time.
+   */
+  pixelPerfect = !1;
+  grid;
+  /** Whether the grid drew last frame, so the frame it is switched off still takes it down. */
+  gridLive = !1;
   resizeListeners = [];
   lastWidth = 0;
   lastHeight = 0;
@@ -32,10 +42,10 @@ class h {
     return this.app.ticker.FPS;
   }
   /** Calls `fn` whenever the window changes size; the returned function stops it (a per-map listener must). */
-  onResize(e) {
-    return this.resizeListeners.push(e), () => {
-      const t = this.resizeListeners.indexOf(e);
-      t >= 0 && this.resizeListeners.splice(t, 1);
+  onResize(t) {
+    return this.resizeListeners.push(t), () => {
+      const e = this.resizeListeners.indexOf(t);
+      e >= 0 && this.resizeListeners.splice(e, 1);
     };
   }
   /**
@@ -43,9 +53,16 @@ class h {
    * ticker listener that throws never asks for the next animation frame, so one bad frame used to stop the world for
    * good — the canvas frozen and no input reaching the server (seen on Android).
    */
-  frame(e) {
-    const t = performance.now();
-    this.guard("resize", () => this.syncSize()), this.guard("update", () => this.update(t, e)), this.guard("tweens", () => this.tweens.update(e)), this.guard("timers", () => this.time.update(t)), this.guard("camera", () => this.cameras.main.apply(t));
+  frame(t) {
+    const e = performance.now();
+    this.guard("resize", () => this.syncSize()), this.guard("update", () => this.update(e, t)), this.guard("tweens", () => this.tweens.update(t)), this.guard("timers", () => this.time.update(e)), this.guard("camera", () => this.cameras.main.apply(e)), (this.pixelPerfect || this.gridLive) && (this.gridLive = this.pixelPerfect, this.guard("pixel grid", () => this.grid.render(this.cameras.main, this.pixelPerfect)));
+  }
+  /**
+   * Keeps a piece of text made outside `add.text`/`add.label` (put on the world any way) at screen resolution while the
+   * world is pixel-perfect. Those two do it themselves.
+   */
+  keepSharp(t) {
+    this.grid.text.track(t);
   }
   reported = /* @__PURE__ */ new Set();
   /**
@@ -53,30 +70,30 @@ class h {
    * of their own `update` too: a fault before the camera follows the player used to leave the view standing on one
    * spot while the world went on.
    */
-  guard(e, t) {
-    this.guarded(e, t, void 0);
+  guard(t, e) {
+    this.guarded(t, e, void 0);
   }
   /** `guard` for a step that answers something: `fallback` when it threw. */
-  guarded(e, t, i) {
+  guarded(t, e, i) {
     try {
-      return t();
-    } catch (s) {
-      return this.caught(e, s), i;
+      return e();
+    } catch (r) {
+      return this.caught(t, r), i;
     }
   }
   /** What a guarded step threw: logged once per distinct error, or a fault repeating every frame floods the log at 60 a second. */
-  caught(e, t) {
-    const i = `${e}|${t instanceof Error ? t.message : String(t)}`;
-    this.reported.has(i) || (this.reported.add(i), console.error(`[frame] ${e} failed`, t), h.onCaught?.(`[frame] ${e}`, t));
+  caught(t, e) {
+    const i = `${t}|${e instanceof Error ? e.message : String(e)}`;
+    this.reported.has(i) || (this.reported.add(i), console.error(`[frame] ${t} failed`, e), h.onCaught?.(`[frame] ${t}`, e));
   }
   destroy() {
-    this.tweens.clear(), this.time.clear(), this.input.activePointer.destroy(), this.world.destroy({ children: !0, context: !0 }), this.screen.destroy({ children: !0, context: !0 });
+    this.tweens.clear(), this.time.clear(), this.input.activePointer.destroy(), this.grid.destroy(this.cameras.main), this.world.destroy({ children: !0, context: !0 }), this.screen.destroy({ children: !0, context: !0 });
   }
   syncSize() {
-    const { width: e, height: t } = this.app.screen, i = this.cameras.main;
-    if (i.width = e, i.height = t, !(e === this.lastWidth && t === this.lastHeight)) {
-      this.lastWidth = e, this.lastHeight = t;
-      for (const s of [...this.resizeListeners]) s();
+    const { width: t, height: e } = this.app.screen, i = this.cameras.main;
+    if (i.width = t, i.height = e, !(t === this.lastWidth && e === this.lastHeight)) {
+      this.lastWidth = t, this.lastHeight = e;
+      for (const r of [...this.resizeListeners]) r();
     }
   }
 }

package/dist/core/gridPlacement.js

@@ -0,0 +1,14 @@
+function o(a, c, e, h, n, f) {
+  const t = e || 1, M = Math.floor(-a / t), d = Math.floor(-c / t);
+  return {
+    tx: M,
+    ty: d,
+    width: Math.ceil(n / t) + 2,
+    height: Math.ceil(f / t) + 2,
+    x: Math.round((a + M * t) * h) / h,
+    y: Math.round((c + d * t) * h) / h
+  };
+}
+export {
+  o as gridPlacement
+};

package/dist/dialogue/DialogueRunner.js

@@ -0,0 +1,173 @@
+import { expr as u } from "./expr.js";
+const f = 1e3;
+class d {
+  constructor(t, s = {}) {
+    this.script = t, this.options = s, this.vars = s.vars ?? {};
+    const i = s.functions ?? {};
+    this.scope = {
+      get: (e) => l(this.vars, e),
+      call: (e, n) => {
+        if (e === "visited") return this.visits.get(String(n[0])) ?? 0;
+        if (e === "chose") return this.chosen.has(`${n[0]}#${n[1]}`);
+        const o = i[e];
+        if (!o) throw new Error(`dialogue: no function '${e}'`);
+        return o(...n);
+      }
+    };
+  }
+  script;
+  options;
+  vars;
+  node = null;
+  line = 0;
+  step = { type: "end" };
+  visits = /* @__PURE__ */ new Map();
+  chosen = /* @__PURE__ */ new Set();
+  scope;
+  /** The step showing now. */
+  get current() {
+    return this.step;
+  }
+  /** The node the dialogue is in, or null once it has ended. */
+  get at() {
+    return this.node;
+  }
+  /** How many times a node was entered. */
+  visited(t) {
+    return this.visits.get(t) ?? 0;
+  }
+  /** Begins at `node` (default the script's `start`, else its first node). */
+  start(t = this.script.start ?? Object.keys(this.script.nodes)[0]) {
+    return t === void 0 ? this.finish() : this.go(t);
+  }
+  /** The line showing was read: on to the next line, the choices, or wherever the node leads. */
+  next() {
+    return this.step.type !== "line" ? this.step : (this.line++, this.show(0));
+  }
+  /** Picks a choice by its `index` (as shown). A locked or unknown index changes nothing. */
+  choose(t) {
+    if (this.step.type !== "choices" || this.node === null) return this.step;
+    if (!this.step.choices.find((n) => n.index === t)?.enabled) return this.step;
+    const i = this.node, e = this.nodeOf(i).choices[t];
+    return this.chosen.add(`${i}#${t}`), this.assign(e.set), this.run(e.do), e.goto === void 0 ? this.finish() : this.go(e.goto);
+  }
+  /** Jumps to a node from outside (the game's own event broke in). */
+  jump(t) {
+    return this.go(t);
+  }
+  /** Ends the dialogue now. */
+  stop() {
+    return this.finish();
+  }
+  /** The value of an expression over this dialogue's variables, for a game that shares the language. */
+  evaluate(t) {
+    return u(t)(this.scope);
+  }
+  save() {
+    return {
+      node: this.node,
+      line: this.line,
+      vars: structuredClone(this.vars),
+      visits: Object.fromEntries(this.visits),
+      chosen: [...this.chosen]
+    };
+  }
+  /** Puts a saved dialogue back where it was, without running the node's `set` and `do` again. */
+  restore(t) {
+    for (const s of Object.keys(this.vars)) delete this.vars[s];
+    Object.assign(this.vars, structuredClone(t.vars)), this.visits.clear();
+    for (const [s, i] of Object.entries(t.visits)) this.visits.set(s, i);
+    this.chosen.clear();
+    for (const s of t.chosen) this.chosen.add(s);
+    return t.node === null || !this.script.nodes[t.node] ? this.finish() : (this.node = t.node, this.line = t.line, this.show(0));
+  }
+  go(t) {
+    return this.enter(t, 0);
+  }
+  enter(t, s) {
+    if (s > f) throw new Error(`dialogue: '${t}' loops without showing anything`);
+    const i = this.nodeOf(t);
+    return this.node = t, this.line = 0, this.visits.set(t, (this.visits.get(t) ?? 0) + 1), this.assign(i.set), this.run(i.do), this.node !== t ? this.step : this.show(s);
+  }
+  /** The step from the current line on: the next line that holds, else the choices, else the way on. */
+  show(t) {
+    const s = this.node, i = this.nodeOf(s), e = i.lines ?? [];
+    for (; this.line < e.length; this.line++) {
+      const r = e[this.line], h = typeof r == "string" ? { text: r } : r;
+      if (!(h.if !== void 0 && !this.test(h.if)))
+        return this.step = { type: "line", node: s, speaker: h.speaker, text: this.text(h.text, h.key), tags: h.tags ?? [] };
+    }
+    const n = this.offered(s, i);
+    if (n.length > 0) return this.step = { type: "choices", node: s, choices: n };
+    const o = this.wayOn(i);
+    return o === null ? this.finish() : this.enter(o, t + 1);
+  }
+  offered(t, s) {
+    const i = [];
+    return (s.choices ?? []).forEach((e, n) => {
+      if (e.once && this.chosen.has(`${t}#${n}`)) return;
+      const o = e.if === void 0 || this.test(e.if);
+      !o && !e.showLocked || i.push({ index: n, text: this.text(e.text, e.key), enabled: o });
+    }), i.some((e) => e.enabled) ? i : [];
+  }
+  wayOn(t) {
+    if (t.next === void 0) return null;
+    if (typeof t.next == "string") return t.next;
+    for (const s of t.next) if (s.if === void 0 || this.test(s.if)) return s.goto;
+    return null;
+  }
+  finish() {
+    return this.node = null, this.step = { type: "end" };
+  }
+  nodeOf(t) {
+    const s = this.script.nodes[t];
+    if (!s) throw new Error(`dialogue: no node '${t}'`);
+    return s;
+  }
+  test(t) {
+    return !!u(t)(this.scope);
+  }
+  assign(t) {
+    if (!t) return;
+    const s = Object.entries(t).map(([i, e]) => [i, u(e)(this.scope)]);
+    for (const [i, e] of s) p(this.vars, i, e);
+  }
+  run(t) {
+    for (const s of t ?? []) {
+      const i = typeof s == "string" ? s : s.name;
+      this.options.onCommand?.(i, typeof s == "string" ? [] : s.args ?? [], this);
+    }
+  }
+  /** `text` translated, with each `{expression}` replaced by its value; `{{` and `}}` are braces. */
+  text(t, s) {
+    return (this.options.translate ? this.options.translate(t, s) : t).replace(/\{\{|\}\}|\{([^{}]+)\}/g, (e, n) => {
+      if (e === "{{") return "{";
+      if (e === "}}") return "}";
+      const o = u(n.trim())(this.scope);
+      return o == null ? "" : String(o);
+    });
+  }
+}
+function l(c, t) {
+  let s = c;
+  for (const i of t.split(".")) {
+    if (s === null || typeof s != "object" || !Object.prototype.hasOwnProperty.call(s, i)) return;
+    s = s[i];
+  }
+  return s;
+}
+function p(c, t, s) {
+  const i = t.split(".");
+  let e = c;
+  for (const o of i.slice(0, -1)) {
+    if (o === "__proto__" || o === "constructor" || o === "prototype") throw new Error(`dialogue: cannot set '${t}'`);
+    const r = e[o];
+    e = r !== null && typeof r == "object" ? r : e[o] = {};
+  }
+  const n = i[i.length - 1];
+  if (n === "__proto__" || n === "constructor" || n === "prototype") throw new Error(`dialogue: cannot set '${t}'`);
+  e[n] = s;
+}
+export {
+  d as DialogueRunner
+};

package/dist/dialogue/expr.js

@@ -0,0 +1,137 @@
+const A = ["&&", "||", "==", "!=", "<=", ">=", "<", ">", "!", "+", "-", "*", "/", "%", "(", ")", ","];
+function N(r) {
+  const i = [];
+  let o = 0;
+  for (; o < r.length; ) {
+    const l = r[o];
+    if (/\s/.test(l)) {
+      o++;
+      continue;
+    }
+    if (/[0-9.]/.test(l)) {
+      const c = /^(?:\d+\.?\d*|\.\d+)/.exec(r.slice(o));
+      if (!c) throw new Error(`bad number at ${o}`);
+      i.push({ k: "num", v: Number(c[0]) }), o += c[0].length;
+      continue;
+    }
+    if (l === '"' || l === "'") {
+      let c = o + 1, p = "";
+      for (; c < r.length && r[c] !== l; )
+        r[c] === "\\" && c + 1 < r.length && c++, p += r[c], c++;
+      if (c >= r.length) throw new Error(`unclosed string at ${o}`);
+      i.push({ k: "str", v: p }), o = c + 1;
+      continue;
+    }
+    if (/[A-Za-z_$]/.test(l)) {
+      const c = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*/.exec(r.slice(o));
+      i.push({ k: "id", v: c[0] }), o += c[0].length;
+      continue;
+    }
+    const f = A.find((c) => r.startsWith(c, o));
+    if (!f) throw new Error(`unexpected '${l}' at ${o}`);
+    i.push({ k: "op", v: f }), o += f.length;
+  }
+  return i;
+}
+const m = (r) => !!r, k = (r, i) => r === i || r == null && i == null, s = (r) => typeof r == "number" ? r : typeof r == "boolean" ? Number(r) : r == null ? 0 : Number(r);
+function Z(r) {
+  let i;
+  try {
+    i = N(r);
+  } catch (n) {
+    throw new Error(`expression '${r}': ${n.message}`);
+  }
+  let o = 0;
+  const l = () => i[o], f = (n) => l()?.k === "op" && l().v === n, c = (n) => {
+    const e = l();
+    return e?.k === "op" && n.includes(e.v);
+  }, p = (n) => {
+    throw new Error(`expression '${r}': ${n}`);
+  }, y = (n) => f(n) ? o++ : p(`expected '${n}'`), h = (n, e, u) => () => {
+    let t = n();
+    for (; c(e); ) {
+      const a = i[o++].v;
+      t = u(a, t, n());
+    }
+    return t;
+  }, x = () => {
+    const n = i[o++];
+    if (!n) return p("ended early");
+    if (n.k === "num" || n.k === "str") {
+      const e = n.v;
+      return () => e;
+    }
+    if (n.k === "id") {
+      const e = n.v;
+      if (e === "true") return () => !0;
+      if (e === "false") return () => !1;
+      if (e === "null") return () => null;
+      if (f("(")) {
+        o++;
+        const u = [];
+        for (; !f(")") && (u.push($()), !!f(",")); )
+          o++;
+        return y(")"), (t) => t.call(e, u.map((a) => a(t)));
+      }
+      return (u) => {
+        const t = u.get(e);
+        return typeof t == "number" || typeof t == "string" || typeof t == "boolean" || t == null ? t : String(t);
+      };
+    }
+    if (n.v === "(") {
+      const e = $();
+      return y(")"), e;
+    }
+    return p(`unexpected '${n.v}'`);
+  }, w = () => {
+    if (f("!")) {
+      o++;
+      const n = w();
+      return (e) => !m(n(e));
+    }
+    if (f("-")) {
+      o++;
+      const n = w();
+      return (e) => -s(n(e));
+    }
+    return x();
+  }, v = h(
+    w,
+    ["*", "/", "%"],
+    (n, e, u) => n === "*" ? (t) => s(e(t)) * s(u(t)) : n === "/" ? (t) => s(e(t)) / s(u(t)) : (t) => s(e(t)) % s(u(t))
+  ), E = h(
+    v,
+    ["+", "-"],
+    (n, e, u) => n === "+" ? (t) => {
+      const a = e(t), d = u(t);
+      return typeof a == "string" || typeof d == "string" ? `${a ?? ""}${d ?? ""}` : s(a) + s(d);
+    } : (t) => s(e(t)) - s(u(t))
+  ), _ = h(E, ["<", ">", "<=", ">=", "==", "!="], (n, e, u) => {
+    switch (n) {
+      case "==":
+        return (t) => k(e(t), u(t));
+      case "!=":
+        return (t) => !k(e(t), u(t));
+      case "<":
+        return (t) => s(e(t)) < s(u(t));
+      case ">":
+        return (t) => s(e(t)) > s(u(t));
+      case "<=":
+        return (t) => s(e(t)) <= s(u(t));
+      default:
+        return (t) => s(e(t)) >= s(u(t));
+    }
+  }), z = h(_, ["&&"], (n, e, u) => (t) => m(e(t)) && m(u(t))), $ = h(z, ["||"], (n, e, u) => (t) => m(e(t)) || m(u(t)));
+  i.length === 0 && p("empty");
+  const b = $();
+  return o < i.length && p(`unexpected '${i[o].v}'`), b;
+}
+const g = /* @__PURE__ */ new Map();
+function O(r) {
+  let i = g.get(r);
+  return i || (i = Z(r), g.size > 2e3 && g.clear(), g.set(r, i)), i;
+}
+export {
+  Z as compileExpr,
+  O as expr
+};

package/dist/dialogue/validateDialogue.js

@@ -0,0 +1,52 @@
+import { compileExpr as A } from "./expr.js";
+function S(r, d = {}) {
+  const $ = [], s = (e, n) => $.push({ path: e, message: n, level: "error" }), g = Object.keys(r.nodes ?? {});
+  if (g.length === 0)
+    return s("nodes", "the script has no nodes"), $;
+  const m = r.start ?? g[0];
+  r.nodes[m] || s("start", `no node '${m}'`);
+  const p = d.functions ? /* @__PURE__ */ new Set(["visited", "chose", ...d.functions]) : null, a = (e, n) => {
+    if (typeof n != "string") return s(e, "must be an expression in a string");
+    try {
+      A(n);
+    } catch (o) {
+      return s(e, o.message);
+    }
+    if (p)
+      for (const o of n.matchAll(/([A-Za-z_$][\w$]*)\s*\(/g)) p.has(o[1]) || s(e, `no function '${o[1]}'`);
+  }, h = (e, n) => {
+    if (typeof n != "string") return s(e, "must be text");
+    for (const o of n.replace(/\{\{|\}\}/g, "").matchAll(/\{([^{}]*)\}/g)) a(e, o[1].trim());
+  }, u = (e, n) => {
+    (typeof n != "string" || !r.nodes[n]) && s(e, `no node '${String(n)}'`);
+  }, y = (e, n) => {
+    for (const [o, i] of Object.entries(n ?? {})) a(`${e}.${o}`, i);
+  }, v = (e, n) => {
+    (n ?? []).forEach((o, i) => {
+      const t = typeof o == "string" ? o : o?.name;
+      typeof t != "string" ? s(`${e}[${i}]`, "a command needs a name") : d.commands && !d.commands.includes(t) && s(`${e}[${i}]`, `no command '${t}'`);
+    });
+  }, w = /* @__PURE__ */ new Map();
+  for (const e of g) {
+    const n = r.nodes[e], o = `nodes.${e}`, i = [];
+    y(`${o}.set`, n.set), v(`${o}.do`, n.do), (n.lines ?? []).forEach((t, f) => {
+      if (typeof t == "string") return h(`${o}.lines[${f}]`, t);
+      h(`${o}.lines[${f}].text`, t.text), t.if !== void 0 && a(`${o}.lines[${f}].if`, t.if);
+    }), (n.choices ?? []).forEach((t, f) => {
+      const c = `${o}.choices[${f}]`;
+      h(`${c}.text`, t.text), t.if !== void 0 && a(`${c}.if`, t.if), y(`${c}.set`, t.set), v(`${c}.do`, t.do), t.goto !== void 0 && (u(`${c}.goto`, t.goto), i.push(t.goto));
+    }), typeof n.next == "string" ? (u(`${o}.next`, n.next), i.push(n.next)) : Array.isArray(n.next) && n.next.forEach((t, f) => {
+      t.if !== void 0 && a(`${o}.next[${f}].if`, t.if), u(`${o}.next[${f}].goto`, t.goto), i.push(t.goto);
+    }), w.set(e, i);
+  }
+  const l = /* @__PURE__ */ new Set(), x = r.nodes[m] ? [m] : [];
+  for (; x.length; ) {
+    const e = x.pop();
+    l.has(e) || !r.nodes[e] || (l.add(e), x.push(...w.get(e) ?? []));
+  }
+  for (const e of g) l.has(e) || $.push({ path: `nodes.${e}`, message: "nothing leads here from the start", level: "warning" });
+  return $;
+}
+export {
+  S as validateDialogue
+};

package/dist/ecs/prefab.js

@@ -0,0 +1,94 @@
+function P(r, t) {
+  return [r, t];
+}
+function y(r, t, e = {}) {
+  const o = e.extends ?? null, n = new Map(o?.parts ?? []);
+  for (const [s, i] of t)
+    i === null ? n.delete(s) : n.set(s, l(n.get(s), i));
+  return { name: r, parts: n, base: o };
+}
+function w(r, t, e = {}) {
+  const o = e.with?.length ? y(t.name, e.with, { extends: t }).parts : t.parts, n = r.create(), s = { entity: n, args: e.args };
+  for (const [i, f] of o)
+    e.without?.includes(i) || r.add(n, i, g(f, s));
+  return n;
+}
+function x(r, t) {
+  for (let e = r; e; e = e.base) if (e === t) return !0;
+  return !1;
+}
+function g(r, t) {
+  return typeof r == "function" ? r(t) : r !== null && typeof r == "object" ? structuredClone(r) : r;
+}
+const h = (r) => r !== null && typeof r == "object" && !Array.isArray(r) && Object.getPrototypeOf(r) === Object.prototype;
+function l(r, t) {
+  if (!h(r) || !h(t)) return t;
+  const e = { ...r };
+  for (const [o, n] of Object.entries(t)) e[o] = l(r[o], n);
+  return e;
+}
+class O {
+  types = /* @__PURE__ */ new Map();
+  factories = /* @__PURE__ */ new Map();
+  prefabs = /* @__PURE__ */ new Map();
+  /** Lets data name a component type. */
+  component(t, e) {
+    return this.types.set(t, e), this;
+  }
+  /** A value made in code for a prefab loaded from data (and its variants): the data cannot hold a function. */
+  factory(t, e, o) {
+    let n = this.factories.get(t);
+    return n || this.factories.set(t, n = /* @__PURE__ */ new Map()), n.set(e, o), this;
+  }
+  /** Adds a prefab made in code. */
+  add(t) {
+    return this.prefabs.set(t.name, t), this;
+  }
+  /**
+   * Builds the prefabs of `data`, bases before their variants (in any order in the data), and adds them. Throws,
+   * naming the prefab, on an unknown component or base, or a prefab that extends itself.
+   */
+  load(t) {
+    const e = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Set(), n = (s) => {
+      const i = e.get(s);
+      if (i) return i;
+      const f = t[s];
+      if (!f) return this.get(s);
+      if (o.has(s)) throw new Error(`PrefabLibrary: '${s}' extends itself`);
+      o.add(s);
+      const d = f.extends === void 0 ? void 0 : n(f.extends), u = Object.entries(f.components ?? {}).map(([c, a]) => {
+        const b = this.types.get(c);
+        if (!b) throw new Error(`PrefabLibrary: '${s}' names an unknown component '${c}'`);
+        return [b, a];
+      });
+      for (const [c, a] of this.factories.get(s) ?? []) u.push([c, a]);
+      const p = y(s, u, { extends: d });
+      return o.delete(s), e.set(s, p), p;
+    };
+    for (const s of Object.keys(t)) n(s);
+    for (const [s, i] of e) this.prefabs.set(s, i);
+    return this;
+  }
+  get(t) {
+    const e = this.prefabs.get(t);
+    if (!e) throw new Error(`PrefabLibrary: no prefab '${t}'`);
+    return e;
+  }
+  has(t) {
+    return this.prefabs.has(t);
+  }
+  names() {
+    return [...this.prefabs.keys()];
+  }
+  /** `spawnPrefab` by name. */
+  spawn(t, e, o = {}) {
+    return w(t, this.get(e), o);
+  }
+}
+export {
+  O as PrefabLibrary,
+  y as definePrefab,
+  x as isPrefabOf,
+  P as prefabPart,
+  w as spawnPrefab
+};

package/dist/electron/webPatcher.js

@@ -1,11 +1,11 @@
 import { existsSync as b } from "node:fs";
 import { rm as d, mkdir as M, readFile as V, rename as T, readdir as x } from "node:fs/promises";
 import { join as s } from "node:path";
-import { isNewer as y, validManifest as $, fileUrl as U } from "../updates/manifest.js";
-import { planWeb as D } from "../updates/webPlan.js";
-import { fetchWithTimeout as u, hashWeb as E, putFile as g, sha256 as P } from "./webFiles.js";
+import { isNewer as y, validManifest as $, fileUrl as P } from "../updates/manifest.js";
+import { planWeb as U } from "../updates/webPlan.js";
+import { fetchWithTimeout as u, hashWeb as D, putFile as g, sha256 as E } from "./webFiles.js";
 import { WebPointers as W } from "./webPointers.js";
-class C {
+class z {
   constructor(e) {
     this.options = e, this.o = {
       root: e.root,
@@ -30,6 +30,7 @@ class C {
   loaded = null;
   /** The tidy a start began: a build waits for it, or it could delete the `.part` folder being filled. */
   tidying = Promise.resolve();
+  tidyChain = Promise.resolve();
   /** This shell's identity. */
   get shell() {
     const e = this.options.shell;
@@ -95,7 +96,7 @@ class C {
     if (b(s(l, this.o.entry)) && this.pointers.read("active")?.version !== o.version)
       return this.pointers.write("pending", p), t(100), o.version;
     await this.tidying;
-    const f = this.loaded?.dir ?? this.o.builtinDir, h = D(o, await E(f)), n = s(this.o.root, `${o.version}.part`);
+    const f = this.loaded?.dir ?? this.o.builtinDir, h = U(o, await D(f)), n = s(this.o.root, `${o.version}.part`);
     await d(n, { recursive: !0, force: !0 }), await M(n, { recursive: !0 });
     for (const r of h.copy) await g(n, r.path, await V(s(f, ...r.from.split("/"))));
     let v = 0;
@@ -105,9 +106,9 @@ class C {
       for (let r = m.shift(); r; r = m.shift()) {
         let a = w.get(r.sha256);
         if (!a) {
-          const c = await u(this.o.fetch, U(this.o.channelUrl, r.sha256), this.o.fetchTimeoutMs);
+          const c = await u(this.o.fetch, P(this.o.channelUrl, r.sha256), this.o.fetchTimeoutMs);
           if (!c.ok) throw new Error(`${r.path}: ${c.status}`);
-          if (a = new Uint8Array(await c.arrayBuffer()), P(a) !== r.sha256) throw new Error(`${r.path}: checksum`);
+          if (a = new Uint8Array(await c.arrayBuffer()), E(a) !== r.sha256) throw new Error(`${r.path}: checksum`);
           w.set(r.sha256, a), v += r.size, t(Math.min(99, Math.round(v / Math.max(1, h.bytes) * 100)));
         }
         await g(n, r.path, a);
@@ -132,8 +133,13 @@ class C {
   usable(e) {
     return !!e && e.shell === this.shell && y(e.version, this.o.appVersion) && b(s(this.o.root, e.version, this.o.entry));
   }
-  /** Removes every patched web but the active, pending and previous one, and any half-made folder. */
-  async tidy() {
+  /** Removes every patched web but the active, pending and previous one, and any half-made folder. A call made while
+   * one is running waits for it and then runs once more, so two never delete the same folder at once. */
+  tidy() {
+    const e = this.tidyChain.then(() => this.tidyOnce());
+    return this.tidyChain = e, e;
+  }
+  async tidyOnce() {
     try {
       const e = ["active", "pending", "previous"], t = new Set([...e.map((i) => this.pointers.read(i)?.version), this.loaded?.version].filter((i) => !!i));
       for (const i of await x(this.o.root))
@@ -143,5 +149,5 @@ class C {
   }
 }
 export {
-  C as WebPatcher
+  z as WebPatcher
 };