@oharness/server 0.10.0 → 0.11.0

package/dist/page/client/dialogs.js

@@ -807,5 +807,80 @@ function closePairing(id) {
   dialog.remove();
 }
 
+/**
+ * The app's own confirm and prompt, in place of the browser's. Those carry the
+ * page's address as a title ("127.0.0.1:4314 says"), take the OS's look, and
+ * block the whole page; these match every other dialog here and resolve a
+ * promise. Escape and Cancel are the same answer: false, or null for text.
+ */
+function askDialog(opts, withField) {
+  return new Promise((resolve) => {
+    const dialog = el("dialog", "ask-dialog");
+    if (opts.title) dialog.appendChild(el("div", "ask-dialog-title", opts.title));
+    if (opts.body) dialog.appendChild(el("div", "ask-dialog-body", opts.body));
+    let field = null;
+    if (withField) {
+      field = el("input", "ask-dialog-field");
+      field.type = "text";
+      field.value = opts.value || "";
+      if (opts.placeholder) field.placeholder = opts.placeholder;
+      field.setAttribute("aria-label", opts.title || opts.body || "");
+      dialog.appendChild(field);
+    }
+    const actions = el("div", "dlg-actions");
+    const cancel = el("button", "quiet", opts.cancel || t("dialog.cancel"));
+    const ok = el("button", opts.danger ? "approve danger" : "approve", opts.ok || t("dialog.ok"));
+    cancel.type = ok.type = "button";
+    actions.append(cancel, ok);
+    dialog.appendChild(actions);
+
+    let settled = false;
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      if (dialog.open) dialog.close();
+      dialog.remove();
+      resolve(value);
+    };
+    const accept = () => {
+      if (!field) return finish(true);
+      const text = field.value.trim();
+      if (text) finish(text);
+    };
+    cancel.onclick = () => finish(field ? null : false);
+    ok.onclick = accept;
+    if (field) {
+      const sync = () => { ok.disabled = !field.value.trim(); };
+      field.oninput = sync;
+      sync();
+      field.onkeydown = (e) => {
+        if (e.key !== "Enter" || e.isComposing) return;
+        e.preventDefault();
+        accept();
+      };
+    }
+    dialog.addEventListener("cancel", (e) => {
+      e.preventDefault();
+      finish(field ? null : false);
+    });
+    document.body.appendChild(dialog);
+    dialog.showModal();
+    if (field) {
+      field.focus();
+      field.select();
+    } else (opts.danger ? cancel : ok).focus();
+  });
+}
+
+/** Yes or no. Resolves true only for the confirming button. */
+function askConfirm(opts) {
+  return askDialog(typeof opts === "string" ? { body: opts } : opts, false);
+}
+
+/** One line of text, trimmed. Resolves null when cancelled. */
+function askText(opts) {
+  return askDialog(opts, true);
+}
+
 `;
 //# sourceMappingURL=dialogs.js.map

package/dist/page/client/dialogs.js.map

@@ -1 +1 @@
-{"version":3,"file":"dialogs.js","sourceRoot":"","sources":["../../../src/page/client/dialogs.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmyBhC,CAAC"}
+{"version":3,"file":"dialogs.js","sourceRoot":"","sources":["../../../src/page/client/dialogs.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA82BhC,CAAC"}

package/dist/page/client/events.js

@@ -74,6 +74,8 @@ events.onmessage = (message) => {
       // been written yet, so there is nothing at /attachment to ask for.
       const sent = sentPreviews.get(event.session) || [];
       sentPreviews.delete(event.session);
+      P.suggestion = null;
+      if (event.session === activeId) paintSuggestion();
       addUser(event.text || "", sent);
       startWorking(t("work.thinking"));
       const unshown = (event.attachments || []).filter(
@@ -144,7 +146,15 @@ events.onmessage = (message) => {
       renderQueued();
       break;
 
-    case "assistant_message": P.streaming = null; break;
+    case "assistant_message": {
+      P.streaming = null;
+      const meta = event.message && event.message.meta;
+      if (meta && typeof meta.agent === "string") {
+        const session = meta.acpSession || {};
+        agentReply(P.turn, { name: meta.agent, session: session.id, cwd: session.cwd });
+      }
+      break;
+    }
     // After the turn ended: under its last reply, not a new turn of its own.
     case "turn_shots": {
       const replies = P.node.querySelectorAll(":scope > .turn.assistant");
@@ -228,6 +238,11 @@ events.onmessage = (message) => {
     case "remote_pair_request": showPairing(event); break;
     case "remote_pair_closed": closePairing(event.id); break;
     case "question_request": questionCard(event); break;
+    // A theme proposed by set_theme, and what became of it; then the theme in
+    // use, from this window or another.
+    case "theme_preview": themePreviewCard(event.preview); break;
+    case "theme_preview_closed": closeThemePreview(event.id, event.outcome); break;
+    case "theme": setThemeState(event.state); break;
     case "question_result": settleQuestion(event); break;
     // Sent once per (re)connect, after the replay: a card this page still
     // shows as open but the server no longer holds closed while we were away.
@@ -329,13 +344,21 @@ events.onmessage = (message) => {
       void loadSessions();
       break;
     case "state": applyState(event.state); break;
+    case "suggestion":
+      P.suggestion = event.text;
+      if (event.session === activeId) paintSuggestion();
+      break;
+    case "suggestions":
+      if (!event.enabled) for (const entry of panes.values()) entry.suggestion = null;
+      paintSuggestion();
+      break;
     // What a conversation is doing on the computer, for the live view.
     case "computer": computerEvent(event.session, event.event); break;
     // The project's starters, written in the background after the fixed three.
     case "starters": startersArrived(event); break;
     case "connectors_changed":
       if (authorizing === event.connector) authorizing = null;
-      offer = { connectors: event.connectors, plugins: event.plugins || [], skills: event.skills || [] };
+      offer = { connectors: event.connectors, plugins: event.plugins || [], skills: event.skills || [], agents: event.agents || offer.agents || [] };
       // The failure already said what went wrong; this only announces the
       // half that is worth celebrating.
       if (event.authorized) addNotice(t("market.authorized", { name: event.connector }));

package/dist/page/client/events.js.map

@@ -1 +1 @@
-{"version":3,"file":"events.js","sourceRoot":"","sources":["../../../src/page/client/events.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+W/B,CAAC"}
+{"version":3,"file":"events.js","sourceRoot":"","sources":["../../../src/page/client/events.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsY/B,CAAC"}

package/dist/page/client/index.js

@@ -16,6 +16,8 @@ import { COMPUTER } from "./computer.js";
 import { FILES } from "./files.js";
 import { TERMINAL } from "./terminal.js";
 import { SHELL } from "./shell.js";
+import { RIPPLE } from "./ripple.js";
+import { THEME } from "./theme.js";
 /**
  * The client script, assembled.
  *
@@ -50,5 +52,7 @@ export const APP_SCRIPT = [
     BROWSER,
     COMPUTER,
     SHELL,
+    RIPPLE,
+    THEME,
 ].join("") + "\n";
 //# sourceMappingURL=index.js.map

package/dist/page/client/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/page/client/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,UAAU,GACrB;IACA,IAAI;IACJ,OAAO;IACP,UAAU;IACV,KAAK;IACL,MAAM;IACN,OAAO;IACP,QAAQ;IACR,KAAK;IACL,SAAS;IACT,OAAO;IACP,QAAQ;IACR,KAAK;IACL,MAAM;IACN,KAAK;IACL,QAAQ;IACR,OAAO;IACP,QAAQ;IACR,KAAK;CACJ,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/page/client/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,UAAU,GACrB;IACA,IAAI;IACJ,OAAO;IACP,UAAU;IACV,KAAK;IACL,MAAM;IACN,OAAO;IACP,QAAQ;IACR,KAAK;IACL,SAAS;IACT,OAAO;IACP,QAAQ;IACR,KAAK;IACL,MAAM;IACN,KAAK;IACL,QAAQ;IACR,OAAO;IACP,QAAQ;IACR,KAAK;IACL,MAAM;IACN,KAAK;CACJ,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC"}

package/dist/page/client/panels.js

@@ -384,7 +384,7 @@ async function showMemoryPage(id) {
     form.appendChild(mergeActions);
     form.onsubmit = async (event) => {
       event.preventDefault();
-      if (!confirm(t("memory.mergeConfirm"))) return;
+      if (!(await askConfirm({ body: t("memory.mergeConfirm"), ok: t("memory.mergeApply") }))) return;
       apply.disabled = true;
       await act({ action: "merge", note: { summary: summary.value.trim(), body: body.value.trim(), tags: tags.value.split(/[,，\s]+/).filter(Boolean), type: proposal.draft.type || "" } });
       apply.disabled = false;
@@ -563,9 +563,9 @@ async function showMemoryPage(id) {
         row.appendChild(line);
       }
       const remove = el("button", "ghost", t("memory.delete")); remove.type = "button";
-      remove.onclick = () => {
+      remove.onclick = async () => {
         const linked = links.in.length ? t("memory.confirmDeleteLinked", { count: links.in.length }) : "";
-        if (confirm(linked + t("memory.confirmDelete"))) void act({ action: "delete", scope: note.scope, id: note.id, expectedHash: note.hash });
+        if (await askConfirm({ body: linked + t("memory.confirmDelete"), ok: t("memory.delete"), danger: true })) void act({ action: "delete", scope: note.scope, id: note.id, expectedHash: note.hash });
       };
       row.appendChild(editor(note, remove));
       list.appendChild(row);
@@ -588,7 +588,7 @@ async function showMemoryPage(id) {
     text.appendChild(el("div", "muted small", [new Date(backup.backedUpAt).toLocaleString(LOCALE), backup.reason ? t("memory.backupReason." + backup.reason) : "", scopeLabel, backup.id].filter(Boolean).join(" · ")));
     row.appendChild(text);
     const restore = el("button", "ghost", t("memory.restore")); restore.type = "button";
-    restore.onclick = () => { if (confirm(t("memory.confirmRestore"))) void act({ action: "restore", file: backup.file }); };
+    restore.onclick = async () => { if (await askConfirm({ body: t("memory.confirmRestore"), ok: t("memory.restore") })) void act({ action: "restore", file: backup.file }); };
     row.appendChild(restore);
     backups.appendChild(row);
   }

package/dist/page/client/ripple.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The field behind a new session: a grid of dots a click sends a shockwave
+ * through.
+ *
+ * Only while the empty state is on screen. The canvas sits under everything
+ * in #main and takes no pointer, so it can never eat a click meant for the
+ * composer or a starter; it only hears them go by. Nothing animates at rest —
+ * a frame is drawn when a wave is travelling or the pointer moves, and the
+ * loop stops once the last wave has died out, so an idle new tab costs nothing.
+ *
+ * One part of the client script; see ./index.ts for how the parts join.
+ */
+export declare const RIPPLE: string;

package/dist/page/client/ripple.js

@@ -0,0 +1,247 @@
+/**
+ * The field behind a new session: a grid of dots a click sends a shockwave
+ * through.
+ *
+ * Only while the empty state is on screen. The canvas sits under everything
+ * in #main and takes no pointer, so it can never eat a click meant for the
+ * composer or a starter; it only hears them go by. Nothing animates at rest —
+ * a frame is drawn when a wave is travelling or the pointer moves, and the
+ * loop stops once the last wave has died out, so an idle new tab costs nothing.
+ *
+ * One part of the client script; see ./index.ts for how the parts join.
+ */
+export const RIPPLE = String.raw `
+// --- ripple field ------------------------------------------------------------
+
+(function rippleField() {
+  const host = document.getElementById("main");
+  if (!host || !emptyEl) return;
+  const still = window.matchMedia("(prefers-reduced-motion: reduce)");
+
+  const canvas = document.createElement("canvas");
+  canvas.id = "ripple";
+  canvas.setAttribute("aria-hidden", "true");
+  host.prepend(canvas);
+  const ctx = canvas.getContext("2d");
+
+  const GAP = 24;          // grid pitch, css px
+  const SPEED = 0.38;      // wavefront, px per ms
+  const LIFE = 3200;       // ms a wave travels before it is gone
+  const BAND = 90;         // width of the wavefront's swell
+  const LENS = 120;        // radius the pointer magnifies
+  const TINT = "fg";       // what a wave lights up in: "fg" plain, "brand" lime
+
+  let w = 0, h = 0, dpr = 1;
+  let waves = [];
+  let pointer = null;      // {x, y} inside the canvas, or null
+  let raf = 0;
+  let shown = false;
+  let ink = { fg: "#111", brand: "#5e8c00" };
+
+  function readInk() {
+    const css = getComputedStyle(document.documentElement);
+    ink = {
+      fg: css.getPropertyValue("--fg").trim() || ink.fg,
+      brand: css.getPropertyValue("--brand").trim() || ink.brand,
+    };
+  }
+
+  function fit() {
+    const box = host.getBoundingClientRect();
+    dpr = Math.min(window.devicePixelRatio || 1, 2);
+    w = Math.max(1, Math.round(box.width));
+    h = Math.max(1, Math.round(box.height));
+    canvas.width = w * dpr;
+    canvas.height = h * dpr;
+    ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+  }
+
+  /** Is the invitation actually in front of someone? */
+  const visible = () => emptyEl.isConnected && emptyEl.offsetParent !== null;
+
+  function kick() {
+    if (!raf) raf = requestAnimationFrame(frame);
+  }
+
+  function frame(now) {
+    raf = 0;
+    waves = waves.filter((wave) => now - wave.t < LIFE);
+    draw(now);
+    if (waves.length) kick();
+  }
+
+  function draw(at) {
+    ctx.clearRect(0, 0, w, h);
+    if (!shown) return;
+    // rAF's stamp is when the frame began, which can trail a wave pushed by a
+    // timer since; time is read here so no wave is ever younger than zero.
+    const now = Math.max(at, performance.now());
+
+    // The dot field: each dot pushed outward by every wave passing it, and lit
+    // by how hard it is being pushed.
+    const ox = (w % GAP) / 2 + GAP / 2;
+    const oy = (h % GAP) / 2 + GAP / 2;
+    ctx.fillStyle = ink.fg;
+    const lit = [];
+    for (let gy = oy; gy < h; gy += GAP) {
+      for (let gx = ox; gx < w; gx += GAP) {
+        let dx = 0, dy = 0, energy = 0;
+        for (const wave of waves) {
+          const age = now - wave.t;
+          const front = age * SPEED;
+          const vx = gx - wave.x, vy = gy - wave.y;
+          const dist = Math.hypot(vx, vy) || 1;
+          const off = dist - front;
+          if (off > BAND || off < -BAND * 3) continue;
+          const fade = 1 - age / LIFE;
+          // One long, low swell at the front — a breath through the grid, not a shake.
+          const env = Math.exp(-(off * off) / (BAND * BAND * 0.35)) * fade * fade;
+          const push = Math.sin(off / 26) * 4.5 * env * wave.power;
+          dx += (vx / dist) * push;
+          dy += (vy / dist) * push;
+          energy += env * wave.power;
+        }
+        let r = 1.05, alpha = 0.13;
+        if (pointer) {
+          const near = Math.hypot(gx - pointer.x, gy - pointer.y);
+          if (near < LENS) {
+            const k = 1 - near / LENS;
+            r += k * k * 1.3;
+            alpha += k * k * 0.22;
+          }
+        }
+        if (energy > 0.06) {
+          lit.push(gx + dx, gy + dy, Math.min(1, energy), r);
+          continue;
+        }
+        ctx.globalAlpha = alpha;
+        ctx.beginPath();
+        ctx.arc(gx + dx, gy + dy, r, 0, 6.2832);
+        ctx.fill();
+      }
+    }
+    // Dots on a wavefront take the brand's lime and swell with it.
+    ctx.fillStyle = ink[TINT];
+    for (let i = 0; i < lit.length; i += 4) {
+      const e = lit[i + 2];
+      ctx.globalAlpha = 0.18 + e * 0.5;
+      ctx.beginPath();
+      ctx.arc(lit[i], lit[i + 1], lit[i + 3] + e * 0.9, 0, 6.2832);
+      ctx.fill();
+    }
+
+    // The fronts themselves: a hairline lime ring with a faint dotted ghost of
+    // the ink riding just outside it, and a soft bloom where the click landed.
+    ctx.lineCap = "round";
+    for (const wave of waves) {
+      const age = now - wave.t;
+      const fade = 1 - age / LIFE;
+      const front = age * SPEED;
+      ctx.globalAlpha = 0.32 * fade * fade * fade * wave.power;
+      ctx.strokeStyle = ink[TINT];
+      ctx.lineWidth = 1;
+      ctx.beginPath();
+      ctx.arc(wave.x, wave.y, front, 0, 6.2832);
+      ctx.stroke();
+      ctx.globalAlpha = 0.08 * fade * fade * fade * wave.power;
+      ctx.strokeStyle = ink.fg;
+      ctx.lineWidth = 1;
+      ctx.setLineDash([2, 9]);
+      ctx.lineDashOffset = -age / 40;
+      ctx.beginPath();
+      ctx.arc(wave.x, wave.y, front * 1.03 + 4, 0, 6.2832);
+      ctx.stroke();
+      ctx.setLineDash([]);
+      if (age < 420) {
+        const k = 1 - age / 420;
+        const glow = ctx.createRadialGradient(wave.x, wave.y, 0, wave.x, wave.y, 46);
+        glow.addColorStop(0, ink[TINT]);
+        glow.addColorStop(1, "transparent");
+        ctx.globalAlpha = 0.22 * k * k * wave.power;
+        ctx.fillStyle = glow;
+        ctx.beginPath();
+        ctx.arc(wave.x, wave.y, 46, 0, 6.2832);
+        ctx.fill();
+      }
+    }
+    ctx.globalAlpha = 1;
+  }
+
+  function wave(x, y, power) {
+    if (still.matches) return;
+    waves.push({ x, y, t: performance.now(), power });
+    if (waves.length > 28) waves.shift();
+    kick();
+  }
+
+  function local(event) {
+    const box = canvas.getBoundingClientRect();
+    return { x: event.clientX - box.left, y: event.clientY - box.top };
+  }
+
+  // Held down and dragged, the pointer leaves a wake: a small wave every
+  // TRAIL px it travels, so a stroke draws a line of rings behind it.
+  const TRAIL = 40;
+  let drag = null;         // where the last wake wave went out, while held
+
+  host.addEventListener("pointerdown", (event) => {
+    if (!shown || event.button > 0) return;
+    const at = local(event);
+    drag = at;
+    // A stroke begun on bare background is drawing, not selecting: without
+    // this it would sweep the headline and starters into a text selection.
+    const bare = event.target === host || event.target.id === "log" || event.target === emptyEl;
+    if (bare) event.preventDefault();
+    wave(at.x, at.y, 1);
+  });
+  host.addEventListener("pointermove", (event) => {
+    if (!shown) return;
+    const at = local(event);
+    if (event.pointerType === "mouse") pointer = at;
+    if (drag && event.buttons & 1) {
+      const gone = Math.hypot(at.x - drag.x, at.y - drag.y);
+      if (gone >= TRAIL) {
+        drag = at;
+        wave(at.x, at.y, Math.min(0.45, 0.2 + gone / 240));
+      }
+    }
+    kick();
+  });
+  const release = () => { drag = null; };
+  window.addEventListener("pointerup", release);
+  window.addEventListener("pointercancel", release);
+  host.addEventListener("pointerleave", () => {
+    pointer = null;
+    if (shown) kick();
+  });
+
+  // The empty state comes and goes with tab switches and first messages, and
+  // nothing announces it, so look twice a second; on arrival, the brand mark
+  // sends out one wave of its own.
+  function check() {
+    const now = visible();
+    if (now === shown) return;
+    shown = now;
+    canvas.classList.toggle("on", shown);
+    if (!shown) { waves = []; pointer = null; kick(); return; }
+    readInk();
+    fit();
+    const mark = emptyEl.querySelector(".brand-mark");
+    if (mark) {
+      const at = mark.getBoundingClientRect();
+      const box = canvas.getBoundingClientRect();
+      wave(at.left + at.width / 2 - box.left, at.top + at.height / 2 - box.top, 0.7);
+    }
+    kick();
+  }
+  setInterval(check, 500);
+  check();
+
+  new ResizeObserver(() => { if (shown) { fit(); kick(); } }).observe(host);
+  // Theme flips (system or the in-app toggle) change the ink.
+  window.matchMedia("(prefers-color-scheme: dark)").addEventListener("change", () => { readInk(); kick(); });
+  new MutationObserver(() => { readInk(); kick(); })
+    .observe(document.documentElement, { attributes: true, attributeFilter: ["data-theme"] });
+})();
+`;
+//# sourceMappingURL=ripple.js.map

package/dist/page/client/ripple.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ripple.js","sourceRoot":"","sources":["../../../src/page/client/ripple.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyO/B,CAAC"}