1681-engine 0.5.9 → 0.6.0

package/dist/net/Room.js

@@ -1,21 +1,38 @@
-import { createMover as l, stepMover as p } from "./movement.js";
-import { moverToWire as c } from "./protocol.js";
-class g {
+import { LagCompensator as f } from "./LagCompensator.js";
+import { createMover as m, stepMover as p } from "./movement.js";
+import { moverToWire as y } from "./protocol.js";
+import { SpatialHash as b } from "./SpatialHash.js";
+const g = 1 << 24;
+class M {
   constructor(e) {
     this.options = e, this.maxQueue = e.maxQueue ?? 30, this.maxSteps = e.maxStepsPerTick ?? 3, this.backlog = e.backlog ?? 4;
+    const i = e.interest;
+    if (i && !(i.radius > 0)) throw new Error(`Room: interest.radius must be above 0 (got ${i.radius})`);
+    this.hash = i ? new b(i.radius) : null, this.rewindMs = Math.max(0, e.rewindMs ?? 0), this.history = this.rewindMs > 0 ? new f(this.rewindMs + 200) : null;
   }
   options;
   players = /* @__PURE__ */ new Map();
+  /** The bodies the server moves (`addBody`). */
+  bodies = /* @__PURE__ */ new Map();
   tick = 0;
+  /** Past positions for judging shots against what a client saw, when the room was made with `rewindMs`. */
+  history;
+  /** How far back a client's claimed view time is honoured (`rewindMs`, 0 when off). */
+  rewindMs;
   known = /* @__PURE__ */ new Map();
+  hash;
+  nearby = [];
   maxQueue;
   maxSteps;
   backlog;
+  nextBodyId = g;
   join(e, i) {
     if (this.players.has(e)) throw new Error(`Room: player ${e} has already joined`);
-    const r = this.options.spawn(e, i), t = {
+    if (this.bodies.has(e)) throw new Error(`Room: id ${e} is a body's`);
+    const t = this.options.spawn(e, i), s = {
+      kind: "player",
       id: e,
-      mover: l(r.x, r.y),
+      mover: m(t.x, t.y),
       data: i,
       params: { ...this.options.params },
       ack: -1,
@@ -26,66 +43,128 @@ class g {
       flags: 0,
       strikes: 0
     };
-    return this.players.set(e, t), this.known.set(e, /* @__PURE__ */ new Set()), t;
+    return this.players.set(e, s), this.known.set(e, /* @__PURE__ */ new Set()), this.hash?.set(e, t.x, t.y), s;
   }
   leave(e) {
-    this.players.delete(e), this.known.delete(e);
+    this.players.delete(e), this.known.delete(e), this.hash?.delete(e), this.history?.forget(e);
+  }
+  /**
+   * Records where every body is now, at server time `time`, into `history`; `RoomHost` calls it as each round of
+   * snapshots goes out, so the history holds exactly the positions clients interpolate between.
+   */
+  record(e) {
+    if (!this.history) return;
+    const i = [...this.players.values()].map((t) => ({ id: t.id, x: t.mover.x, y: t.mover.y }));
+    for (const t of this.bodies.values()) i.push({ id: t.id, x: t.x, y: t.y });
+    this.history.record(e, i);
+  }
+  /**
+   * Adds a body the server moves, at (x, y), with the game's `data` (what players are told it looks like). Its id
+   * is `id`, or the next from `BODY_ID_BASE` up; an id a player or body has is refused.
+   */
+  addBody(e, i, t, s) {
+    let o = s;
+    if (o === void 0) {
+      for (; this.bodies.has(this.nextBodyId) || this.players.has(this.nextBodyId); ) this.nextBodyId++;
+      o = this.nextBodyId++;
+    } else if (this.bodies.has(o) || this.players.has(o)) throw new Error(`Room: id ${o} is taken`);
+    if (!Number.isInteger(o) || o < 0 || o > 2147483647) throw new Error(`Room: a body id must fit an i32 (got ${o})`);
+    const a = { kind: "body", id: o, x: i, y: t, aim: 0, anim: 0, hp: 0, flags: 0, data: e };
+    return this.bodies.set(o, a), this.hash?.set(o, i, t), a;
+  }
+  /** Takes a body out: players who saw it get it in `rm` with their next snapshot. */
+  removeBody(e) {
+    this.bodies.delete(e) && (this.hash?.delete(e), this.history?.forget(e));
   }
   /**
    * Input steps `seq`, `seq + 1`, … from a player. Steps already received are skipped (a resend), any step with
    * numbers no client sends refuses the whole message, and steps past a full queue are dropped. Returns false when
    * something was refused.
    */
-  input(e, i, r) {
-    const t = this.players.get(e);
-    if (!t) return !1;
-    if (!Number.isInteger(i) || i < 0 || !Array.isArray(r) || r.length > this.maxQueue)
-      return t.strikes++, !1;
-    for (const s of r)
-      if (!Array.isArray(s) || s.length !== 3 || !s.every((u) => Number.isFinite(u)) || Math.abs(s[0]) > 1 || Math.abs(s[1]) > 1 || !Number.isInteger(s[2]))
-        return t.strikes++, !1;
-    const n = t.ack + 1 + t.queue.length, o = i - n;
-    if (o > this.maxQueue)
-      return t.strikes++, !1;
-    for (let s = 0; s < o; s++) t.queue.push([0, 0, 0]);
-    let h = !0;
-    for (let s = 0; s < r.length; s++)
-      if (!(i + s < n)) {
-        if (t.queue.length >= this.maxQueue) {
-          h = !1, t.strikes++;
+  input(e, i, t) {
+    const s = this.players.get(e);
+    if (!s) return !1;
+    if (!Number.isInteger(i) || i < 0 || !Array.isArray(t) || t.length > this.maxQueue)
+      return s.strikes++, !1;
+    for (const r of t)
+      if (!Array.isArray(r) || r.length !== 3 || !r.every((h) => Number.isFinite(h)) || Math.abs(r[0]) > 1 || Math.abs(r[1]) > 1 || !Number.isInteger(r[2]))
+        return s.strikes++, !1;
+    const o = s.ack + 1 + s.queue.length, a = i - o;
+    if (a > this.maxQueue)
+      return s.strikes++, !1;
+    for (let r = 0; r < a; r++) s.queue.push([0, 0, 0]);
+    let u = !0;
+    for (let r = 0; r < t.length; r++)
+      if (!(i + r < o)) {
+        if (s.queue.length >= this.maxQueue) {
+          u = !1, s.strikes++;
           break;
         }
-        t.queue.push([r[s][0], r[s][1], r[s][2]]);
+        s.queue.push([t[r][0], t[r][1], t[r][2]]);
       }
-    return h;
+    return u;
   }
   /** One simulation step for everyone. */
   step() {
     this.tick++;
     for (const e of this.players.values()) {
-      const i = e.queue.length;
-      if (i === 0) continue;
-      const r = i > this.backlog ? Math.min(this.maxSteps, i - this.backlog + 1) : 1;
-      for (let t = 0; t < r; t++) {
-        const n = e.queue.shift();
-        p(e.mover, n, e.params, this.options.grid), e.ack++, this.options.onStep?.(e, n);
+      const i = e.queue.length, t = i > this.backlog ? Math.min(this.maxSteps, i - this.backlog + 1) : Math.min(1, i);
+      for (let s = 0; s < t; s++) {
+        const o = e.queue.shift();
+        p(e.mover, o, e.params, this.options.grid), e.ack++, this.options.onStep?.(e, o);
       }
+      this.hash?.set(e.id, e.mover.x, e.mover.y);
     }
+    if (this.hash) for (const e of this.bodies.values()) this.hash.set(e.id, e.x, e.y);
+  }
+  /**
+   * Moves a player by hand (a teleport, a respawn), and files it in the interest grid at once. Writing `mover.x/y`
+   * directly also works; the room then finds it at its new place from the next step.
+   */
+  place(e, i, t) {
+    const s = this.players.get(e), o = this.bodies.get(e);
+    if (s)
+      s.mover.x = i, s.mover.y = t;
+    else if (o)
+      o.x = i, o.y = t;
+    else return;
+    this.hash?.set(e, i, t);
   }
   /** The snapshot player `id` should get now. `time` is the server's wall clock (ms). */
   snapshotFor(e, i) {
-    const r = this.players.get(e), t = this.known.get(e);
-    if (!r || !t) return null;
-    const n = [], o = [], h = /* @__PURE__ */ new Set();
-    for (const a of this.players.values())
-      h.add(a.id), n.push([a.id, a.mover.x, a.mover.y, a.aim, a.anim, a.hp, a.flags]), t.has(a.id) || (t.add(a.id), o.push({ id: a.id, data: a.data }));
-    const s = [];
-    for (const a of t)
-      h.has(a) || (t.delete(a), s.push(a));
-    const u = { t: "snap", tick: this.tick, time: i, ack: r.ack, me: c(r.mover), up: n };
-    return o.length && (u.sp = o), s.length && (u.rm = s), u;
+    const t = this.players.get(e), s = this.known.get(e);
+    if (!t || !s) return null;
+    const o = [], a = [], u = /* @__PURE__ */ new Set();
+    for (const n of this.visibleTo(t, s)) {
+      u.add(n.id);
+      const c = d(n);
+      o.push([n.id, c.x, c.y, n.aim, n.anim, n.hp, n.flags]), s.has(n.id) || (s.add(n.id), a.push({ id: n.id, data: n.data }));
+    }
+    const r = [];
+    for (const n of s)
+      u.has(n) || (s.delete(n), r.push(n));
+    const h = { t: "snap", tick: this.tick, time: i, ack: t.ack, me: y(t.mover), up: o };
+    return a.length && (h.sp = a), r.length && (h.rm = r), h;
+  }
+  /** What `me` is sent: itself always; with interest, the rest in range (a known one until past the margin). */
+  visibleTo(e, i) {
+    const t = this.options.interest;
+    if (!t || !this.hash) return [...this.players.values(), ...this.bodies.values()];
+    const s = t.radius, o = s + (t.leaveMargin ?? s / 4), a = this.nearby;
+    a.length = 0, this.hash.near(e.mover.x, e.mover.y, o, a);
+    const u = [e];
+    for (const r of a) {
+      if (r === e.id) continue;
+      const h = this.players.get(r) ?? this.bodies.get(r);
+      if (!h) continue;
+      const n = d(h);
+      (n.x - e.mover.x) ** 2 + (n.y - e.mover.y) ** 2 > s * s && !i.has(r) || t.canSee && !t.canSee(e, h) || u.push(h);
+    }
+    return u.sort((r, h) => r.id - h.id);
   }
 }
+const d = (l) => l.kind === "player" ? l.mover : l;
 export {
-  g as Room
+  g as BODY_ID_BASE,
+  M as Room
 };

package/dist/net/RoomHost.js

@@ -1,5 +1,6 @@
-import { encodeSnapshotFrame as n } from "./snapshotCodec.js";
-class p {
+import { LagCompensator as n } from "./LagCompensator.js";
+import { encodeSnapshotFrame as r } from "./snapshotCodec.js";
+class c {
   constructor(t, s = {}) {
     this.room = t, this.options = s, this.stepMs = 1e3 / (s.stepRate ?? 60), this.snapEvery = Math.max(1, Math.round((s.stepRate ?? 60) / (s.snapRate ?? 20))), this.now = s.now ?? Date.now;
   }
@@ -64,7 +65,7 @@ class p {
   /** Sends one of the game's own messages to a player. */
   sendTo(t, s) {
     const e = this.sockets.get(t);
-    e && (s.t === "snap" && s.up?.length ? e.send(n(s)) : e.send(JSON.stringify(s)));
+    e && (s.t === "snap" && s.up?.length ? e.send(r(s)) : e.send(JSON.stringify(s)));
   }
   /** Starts stepping on a timer. Steps are counted by the clock, so a late timer runs the steps it owes. */
   start() {
@@ -81,11 +82,19 @@ class p {
   stepOnce() {
     if (this.room.step(), this.room.tick % this.snapEvery !== 0) return;
     const t = this.now();
+    this.room.record(t);
     for (const s of this.joined) {
       const e = this.room.snapshotFor(s, t);
       e && this.sendTo(s, e);
     }
   }
+  /**
+   * The server time a client's claimed view time (`InterpolationBuffer.viewTime`, sent with a shot) is judged at:
+   * kept within the room's `rewindMs` of now, so no claim reaches further back. `now` with no history kept.
+   */
+  rewindTime(t) {
+    return n.clampTime(t, this.now(), this.room.rewindMs);
+  }
   strike(t) {
     const s = this.room.players.get(t);
     s && (s.strikes++, this.checkStrikes(t));
@@ -96,5 +105,5 @@ class p {
   }
 }
 export {
-  p as RoomHost
+  c as RoomHost
 };

package/dist/net/SpatialHash.js

@@ -0,0 +1,66 @@
+const z = (a, t) => (a + 32768) * 65536 + (t + 32768);
+class M {
+  /** `cellSize`: world px per cell. About the radius queries ask for keeps a query to a 3×3 block. */
+  constructor(t) {
+    if (this.cellSize = t, !(t > 0)) throw new Error(`SpatialHash: cellSize must be above 0 (got ${t})`);
+  }
+  cellSize;
+  cells = /* @__PURE__ */ new Map();
+  entries = /* @__PURE__ */ new Map();
+  get size() {
+    return this.entries.size;
+  }
+  has(t) {
+    return this.entries.has(t);
+  }
+  /** Puts `id` at (x, y), or moves it there. */
+  set(t, s, e) {
+    const l = z(Math.floor(s / this.cellSize), Math.floor(e / this.cellSize)), i = this.entries.get(t);
+    if (i) {
+      if (i.x = s, i.y = e, i.cell === l) return;
+      this.unlink(t, i.cell), i.cell = l;
+    } else this.entries.set(t, { x: s, y: e, cell: l });
+    let n = this.cells.get(l);
+    n || this.cells.set(l, n = /* @__PURE__ */ new Set()), n.add(t);
+  }
+  delete(t) {
+    const s = this.entries.get(t);
+    s && (this.unlink(t, s.cell), this.entries.delete(t));
+  }
+  clear() {
+    this.cells.clear(), this.entries.clear();
+  }
+  /** The ids within `radius` of (x, y), edge included, pushed onto `out` in no set order. */
+  near(t, s, e, l = []) {
+    const i = e * e;
+    return this.visit(t - e, s - e, t + e, s + e, (n, c) => {
+      const r = c.x - t, o = c.y - s;
+      r * r + o * o <= i && l.push(n);
+    }), l;
+  }
+  /** The ids inside the box from (x0, y0) to (x1, y1), edges included. */
+  inRect(t, s, e, l, i = []) {
+    return this.visit(t, s, e, l, (n, c) => {
+      c.x >= t && c.x <= e && c.y >= s && c.y <= l && i.push(n);
+    }), i;
+  }
+  visit(t, s, e, l, i) {
+    const n = this.cellSize, c = Math.floor(t / n), r = Math.floor(s / n), o = Math.floor(e / n), S = Math.floor(l / n);
+    if ((o - c + 1) * (S - r + 1) > this.entries.size) {
+      for (const [h, f] of this.entries) i(h, f);
+      return;
+    }
+    for (let h = r; h <= S; h++)
+      for (let f = c; f <= o; f++) {
+        const g = this.cells.get(z(f, h));
+        if (g) for (const u of g) i(u, this.entries.get(u));
+      }
+  }
+  unlink(t, s) {
+    const e = this.cells.get(s);
+    e && (e.delete(t), e.size === 0 && this.cells.delete(s));
+  }
+}
+export {
+  M as SpatialHash
+};

package/dist/pixel/lifeArt.js

@@ -0,0 +1,83 @@
+const F = {
+  leaves: [
+    ["#7ab04e", "#3d7a36"],
+    ["#d8a040", "#9a5a24"]
+  ],
+  seed: ["#f6f2e4", "#c8c2b0"],
+  ember: ["#ffd070", "#ff8a30", "#a8481c"],
+  mote: ["rgba(206,226,240,0.85)", "rgba(150,180,206,0.7)"],
+  ash: [
+    ["#8a827c", "#5c5652"],
+    ["#6e6864", "#3e3a38"]
+  ],
+  butterflies: [
+    ["#f0d050", "#9a7420"],
+    ["#f4f0e8", "#a8a098"],
+    ["#e8883a", "#8a4418"],
+    ["#9ab8f0", "#465e9c"]
+  ],
+  butterflyBody: "#3a2a20",
+  bird: "#2c2830",
+  birdShadow: ["rgba(0,0,0,0.3)", "rgba(0,0,0,0.22)"],
+  firefly: ["#f0ff9a", "#a8c850"],
+  smoke: ["#b8b0b4", "#9a9296", "#7c7478"]
+}, v = 6;
+function L(o, e) {
+  const l = Number.parseInt(o.replace("#", ""), 16);
+  return `rgba(${l >> 16 & 255},${l >> 8 & 255},${l & 255},${e})`;
+}
+function M(o, e = F.smoke) {
+  const l = [[2, 2], [3, 3], [4, 3], [5, 4], [6, 5], [7, 5]], [s, n] = l[Math.max(0, Math.min(v - 1, o))], [b, _, p] = e, h = [], y = (s - 1) / 2, u = (n - 1) / 2, S = o < 3 ? 0.9 : o < 5 ? 0.78 : 0.62;
+  for (let a = 0; a < n; a++)
+    for (let r = 0; r < s; r++) {
+      const $ = (r - y) / (s / 2), m = (a - u) / (n / 2), g = (r * 7 + a * 13 + o * 5) % 5 / 10;
+      if ($ * $ + m * m > 0.85 + g || o >= v - 2 && (r + a + o) % 2) continue;
+      const w = $ + m, d = w < -0.35 ? b : w > 0.45 ? p : _;
+      h.push([r, a, d.startsWith("#") ? L(d, S) : d]);
+    }
+  return { w: s, h: n, px: h };
+}
+function f(o, e, l, s, n) {
+  if (o.exists(e)) return e;
+  const b = document.createElement("canvas");
+  b.width = l, b.height = s;
+  const _ = b.getContext("2d");
+  for (const [p, h, y] of n)
+    _.fillStyle = y, _.fillRect(p, h, 1, 1);
+  return o.addCanvas(e, b), e;
+}
+function R(o, e = {}, l = "life_") {
+  const s = { ...F, ...e }, n = (c) => l + c, b = s.leaves.map(([c, t], i) => [
+    f(o, n(`leaf_${i}_0`), 2, 1, [[0, 0, c], [1, 0, t]]),
+    f(o, n(`leaf_${i}_1`), 2, 2, [[0, 0, c], [1, 1, t]]),
+    f(o, n(`leaf_${i}_2`), 1, 2, [[0, 0, c], [0, 1, t]])
+  ]), _ = [
+    [f(o, n("seed_0"), 1, 1, [[0, 0, s.seed[0]]])],
+    [f(o, n("seed_1"), 2, 1, [[0, 0, s.seed[0]], [1, 0, s.seed[1]]])]
+  ], p = [s.ember.map((c, t) => f(o, n(`ember_${t}`), 1, 1, [[0, 0, c]]))], h = s.mote.map((c, t) => [f(o, n(`mote_${t}`), 1, 1, [[0, 0, c]])]), y = s.ash.map(
+    ([c, t], i) => (
+      // the first flake flat, the next tumbling on its corner
+      [f(o, n(`ash_${i}`), 2, i % 2 ? 2 : 1, i % 2 ? [[0, 0, c], [1, 1, t]] : [[0, 0, c], [1, 0, t]])]
+    )
+  ), u = s.butterflyBody, S = s.butterflies.map(([c, t], i) => [
+    f(o, n(`fly_${i}_o`), 3, 2, [[0, 0, c], [2, 0, c], [1, 0, u], [0, 1, t], [1, 1, u], [2, 1, t]]),
+    f(o, n(`fly_${i}_c`), 3, 2, [[1, 0, c], [1, 1, t]])
+  ]), a = s.bird, r = [
+    f(o, n("bird_0"), 5, 2, [[0, 0, a], [4, 0, a], [1, 1, a], [2, 1, a], [3, 1, a]]),
+    f(o, n("bird_1"), 5, 2, [[0, 1, a], [1, 0, a], [2, 0, a], [3, 0, a], [4, 1, a]])
+  ], [$, m] = s.birdShadow, g = f(o, n("bird_shadow"), 3, 1, [[0, 0, m], [1, 0, $], [2, 0, m]]), [w, d] = s.firefly, A = [
+    f(o, n("firefly_dim"), 3, 3, [[1, 1, d]]),
+    f(o, n("firefly_lit"), 3, 3, [[1, 1, w], [0, 1, d], [2, 1, d], [1, 0, d], [1, 2, d]])
+  ], C = [];
+  for (let c = 0; c < v; c++) {
+    const { w: t, h: i, px: E } = M(c, s.smoke);
+    C.push(f(o, n(`puff_${c}`), t, i, E));
+  }
+  return { leaves: b, seeds: _, embers: p, motes: h, ash: y, butterflies: S, bird: r, birdShadow: g, firefly: A, puffs: C };
+}
+export {
+  F as LIFE_COLORS,
+  v as PUFF_FRAMES,
+  R as paintLifeArt,
+  M as puffPixels
+};

package/dist/pixel.js

@@ -1,96 +1,101 @@
 import { PixelLayer as i, addPixelLayer as a } from "./pixel/PixelLayer.js";
-import { CLEAR as s, PixelGrid as x, PixelWindow as m, channels as l, hash2 as f, hex as h, makeSheet as n, mix as P, mulberry32 as d, rgba as R, shade as g, toCss as A, upscale as L, valueNoise as u, withAlpha as E } from "./pixel/pixel.js";
-import { P as T } from "./pixel/palette.js";
-import { art as M, groundShadow as O, litOutline as _, shadeBox as v } from "./pixel/propKit.js";
-import { MATERIALS as k, RAMP_FACTOR_SET as w, hueShade as y, outlineOf as C, ramp as W, rampTones as H, registerMaterial as N } from "./pixel/ramp.js";
-import { selectiveOutline as D } from "./pixel/selout.js";
+import { CLEAR as x, PixelGrid as s, PixelWindow as m, channels as l, hash2 as f, hex as h, makeSheet as n, mix as P, mulberry32 as R, rgba as L, shade as d, toCss as A, upscale as g, valueNoise as E, withAlpha as S } from "./pixel/pixel.js";
+import { P as M } from "./pixel/palette.js";
+import { art as T, groundShadow as _, litOutline as c, shadeBox as v } from "./pixel/propKit.js";
+import { MATERIALS as C, RAMP_FACTOR_SET as F, hueShade as k, outlineOf as w, ramp as y, rampTones as W, registerMaterial as H } from "./pixel/ramp.js";
+import { selectiveOutline as b } from "./pixel/selout.js";
 import { chevronPixels as G, discRuns as V, ellipsePixels as q, ringPixels as B } from "./pixel/aimPixels.js";
-import { PixelMarks as j } from "./pixel/PixelMarks.js";
+import { PixelMarks as X } from "./pixel/PixelMarks.js";
 import * as e from "./pixel/pixelPaint.js";
 import * as r from "./pixel/pixelTone.js";
-import { registerHandRamps as J } from "./pixel/pixelTone.js";
-import { paintLayer as Q } from "./pixel/paintLayer.js";
+import { registerHandRamps as z } from "./pixel/pixelTone.js";
+import { paintLayer as K } from "./pixel/paintLayer.js";
 import { Evaporation as Y } from "./pixel/Evaporation.js";
 import { NO_PIXELS as $, PackedPixels as ee, spritePixels as re } from "./pixel/spritePixels.js";
 import { CARRIED_LIGHT as oe, Darkness as ie, LAMP_DIM as ae, WARM_LIGHT as pe } from "./pixel/Darkness.js";
-import { carriedLight as xe, clearLights as me, flashLight as le, liveLights as fe } from "./pixel/lights.js";
+import { carriedLight as se, clearLights as me, flashLight as le, liveLights as fe } from "./pixel/lights.js";
 import { NightShade as ne } from "./pixel/NightShade.js";
-import { WEATHER_COLORS as de, mistPixels as Re, paintWeatherArt as ge } from "./pixel/weatherArt.js";
-import { buildRig as Le, complement as ue, gustAt as Ee, swayOffset as Se, tileHash as Te, trunkPivot as ce } from "./pixel/swayRig.js";
-import { SwayProp as Oe, opaqueRowWidths as _e } from "./pixel/SwayProp.js";
-import { heartbeat as Ie, vignetteMask as ke } from "./pixel/vignetteMask.js";
-import { DitherVignette as ye, ditherVignette as Ce } from "./pixel/DitherVignette.js";
-import { FRAME_CORNERS as He, FRAME_TWINS as Ne, frameSvg as be, nineSlice as De } from "./pixel/nineSlice.js";
+import { LIFE_COLORS as Re, PUFF_FRAMES as Le, paintLifeArt as de, puffPixels as Ae } from "./pixel/lifeArt.js";
+import { WEATHER_COLORS as Ee, mistPixels as Se, paintWeatherArt as ue } from "./pixel/weatherArt.js";
+import { buildRig as Oe, complement as Te, gustAt as _e, swayOffset as ce, tileHash as ve, trunkPivot as Ie } from "./pixel/swayRig.js";
+import { SwayProp as Fe, opaqueRowWidths as ke } from "./pixel/SwayProp.js";
+import { heartbeat as ye, vignetteMask as We } from "./pixel/vignetteMask.js";
+import { DitherVignette as Ne, ditherVignette as be } from "./pixel/DitherVignette.js";
+import { FRAME_CORNERS as Ge, FRAME_TWINS as Ve, frameSvg as qe, nineSlice as Be } from "./pixel/nineSlice.js";
 export {
   oe as CARRIED_LIGHT,
-  s as CLEAR,
+  x as CLEAR,
   ie as Darkness,
-  ye as DitherVignette,
+  Ne as DitherVignette,
   Y as Evaporation,
-  He as FRAME_CORNERS,
-  Ne as FRAME_TWINS,
+  Ge as FRAME_CORNERS,
+  Ve as FRAME_TWINS,
   ae as LAMP_DIM,
-  k as MATERIALS,
+  Re as LIFE_COLORS,
+  C as MATERIALS,
   $ as NO_PIXELS,
   ne as NightShade,
-  T as PALETTE,
+  M as PALETTE,
+  Le as PUFF_FRAMES,
   ee as PackedPixels,
-  x as PixelGrid,
+  s as PixelGrid,
   i as PixelLayer,
-  j as PixelMarks,
+  X as PixelMarks,
   m as PixelWindow,
-  w as RAMP_FACTOR_SET,
-  Oe as SwayProp,
+  F as RAMP_FACTOR_SET,
+  Fe as SwayProp,
   pe as WARM_LIGHT,
-  de as WEATHER_COLORS,
+  Ee as WEATHER_COLORS,
   a as addPixelLayer,
-  M as art,
-  Le as buildRig,
-  xe as carriedLight,
+  T as art,
+  Oe as buildRig,
+  se as carriedLight,
   l as channels,
   G as chevronPixels,
   me as clearLights,
-  ue as complement,
+  Te as complement,
   V as discRuns,
-  Ce as ditherVignette,
+  be as ditherVignette,
   q as ellipsePixels,
   le as flashLight,
-  be as frameSvg,
-  O as groundShadow,
-  Ee as gustAt,
+  qe as frameSvg,
+  _ as groundShadow,
+  _e as gustAt,
   f as hash2,
-  Ie as heartbeat,
+  ye as heartbeat,
   h as hex,
-  y as hueShade,
-  _ as litOutline,
+  k as hueShade,
+  c as litOutline,
   fe as liveLights,
   n as makeSheet,
-  Re as mistPixels,
+  Se as mistPixels,
   P as mix,
-  d as mulberry32,
-  De as nineSlice,
-  _e as opaqueRowWidths,
-  C as outlineOf,
-  Q as paintLayer,
-  ge as paintWeatherArt,
+  R as mulberry32,
+  Be as nineSlice,
+  ke as opaqueRowWidths,
+  w as outlineOf,
+  K as paintLayer,
+  de as paintLifeArt,
+  ue as paintWeatherArt,
   e as pixelPaint,
   r as pixelTone,
-  W as ramp,
-  H as rampTones,
-  J as registerHandRamps,
-  N as registerMaterial,
-  R as rgba,
+  Ae as puffPixels,
+  y as ramp,
+  W as rampTones,
+  z as registerHandRamps,
+  H as registerMaterial,
+  L as rgba,
   B as ringPixels,
-  D as selectiveOutline,
-  g as shade,
+  b as selectiveOutline,
+  d as shade,
   v as shadeBox,
   re as spritePixels,
-  Se as swayOffset,
-  Te as tileHash,
+  ce as swayOffset,
+  ve as tileHash,
   A as toCss,
-  ce as trunkPivot,
-  L as upscale,
-  u as valueNoise,
-  ke as vignetteMask,
-  E as withAlpha
+  Ie as trunkPivot,
+  g as upscale,
+  E as valueNoise,
+  We as vignetteMask,
+  S as withAlpha
 };

package/dist/react/ConfirmButton.js

@@ -0,0 +1,24 @@
+import { jsx as g } from "react/jsx-runtime";
+import { useState as A } from "react";
+import { useCx as C, useUi as L } from "./UiProvider.js";
+import { DEFAULT_LABELS as h } from "./labels.js";
+function U({ armKey: n = "armed", armed: s, setArmed: t, onConfirm: c, label: e, armedLabel: l, title: u, className: m = "small", disabled: a }) {
+  const f = C(), p = L(), [b, d] = A(null), r = t !== void 0, x = r ? s ?? null : b, i = r ? t : d, o = x === n;
+  return /* @__PURE__ */ g(
+    "button",
+    {
+      type: "button",
+      className: f("e1681-button", m, o ? "e1681-armed primary" : "ghost"),
+      disabled: a,
+      onClick: () => {
+        if (!o) return i(n);
+        c(), i(null);
+      },
+      title: u,
+      children: o ? l ?? p.labels.confirmAgain ?? h.confirmAgain : e
+    }
+  );
+}
+export {
+  U as ConfirmButton
+};

package/dist/react/baseCss.js

@@ -86,6 +86,7 @@ const o = `
 .e1681-button { padding: 2px 10px; cursor: pointer; min-height: 28px; }
 .e1681-button.small { padding: 0 6px; min-height: 22px; }
 .e1681-button.ghost { background-color: transparent; }
+.e1681-button.e1681-armed { color: var(--e1681-accent); }
 .e1681-button:hover:not(:disabled) { color: var(--e1681-accent); }
 /* pressed: the same face a pixel lower, never a transform */
 .e1681-button:active:not(:disabled) { padding-top: 3px; padding-bottom: 1px; }

package/dist/react/labels.js

@@ -1,4 +1,4 @@
-const n = {
+const c = {
   close: "Close {0}",
   closeHint: "Close (Esc)",
   backToList: "‹ List",
@@ -6,12 +6,13 @@ const n = {
   cancel: "Cancel",
   ok: "OK",
   quantity: "Quantity",
-  choose: "Choose"
+  choose: "Choose",
+  confirmAgain: "Sure?"
 };
-function l(e, ...t) {
-  return e.replace(/\{(\d+)\}/g, (o, c) => t[Number(c)] ?? o);
+function i(e, ...n) {
+  return e.replace(/\{(\d+)\}/g, (o, t) => n[Number(t)] ?? o);
 }
 export {
-  n as DEFAULT_LABELS,
-  l as fillLabel
+  c as DEFAULT_LABELS,
+  i as fillLabel
 };

package/dist/react/useJsonSelector.js

@@ -0,0 +1,13 @@
+import { useMemo as n } from "react";
+import { useStore as s } from "./useStore.js";
+function u(o, r) {
+  const e = o((t) => JSON.stringify(r(t)) ?? "null");
+  return n(() => JSON.parse(e), [e]);
+}
+function m(o, r) {
+  return u((e) => s(o, e), r);
+}
+export {
+  u as useJsonSelector,
+  m as useStoreJson
+};