samagotchi 0.111.1 → 0.113.0

data/lib/samagotchi/web/public/notifications.js

@@ -6,23 +6,33 @@
 // (notify.js, Several tabs).
 //
 // In the Home Screen app (push.js pushSupported) the bell means "push to
-// this device" instead (Web Push): chi web pushes approvals and questions to
-// it while the app is closed. chi web without push (no https public URL)
+// this device" instead (Web Push): chi web pushes what needs the user (an
+// approval, a question, a step-limit continue, a card, a failed turn) to it
+// while the app is closed. chi web without push (no https public URL)
 // leaves the bell as it is in a tab. With the bell on, the app also tidies
 // the device (syncDevice): it closes the pushed notifications whose
-// question isn't open any more and sets the app's badge, as chi web sends
-// no close push (WebKit's silent-push quota).
+// question or card isn't open any more and sets the app's badge, as chi
+// web sends no close push (WebKit's silent-push quota). There the bell
+// opens the notifications sheet (push_devices.js): this device's switch,
+// the other devices with their "long turns done" switch and Remove.
+//
+// Every page, in a tab or the app, also tells chi web whether the user is
+// at it (POST /api/push/presence, reportPresence): chi web pushes nothing
+// while one is in front, as the user is looking (the iPhone's service
+// worker can't see the app in front, so chi web decides).
 //
 // The browser parts come in as deps (globals by default) so the specs can
 // drive it without a DOM.
 
 import { sessionHash } from "./route.js";
 import {
-  NOTIFY_CHANNEL, attentionText, createNotifyGate, initialAttentionState, notifyState as bellState, trackAttention,
+  NOTIFY_CHANNEL, attentionText, createNotifyGate, initialAttentionState, notifyState as bellState, randomTabId,
+  trackAttention,
 } from "./notify.js";
 import {
-  isQuestionTag, openPushKeys, pushSupported, subscribe as pushSubscribe, unsubscribe as pushUnsubscribe,
+  isWaitingTag, openPushKeys, pushSupported, subscribe as pushSubscribe, unsubscribe as pushUnsubscribe,
 } from "./push.js";
+import { createPushDevices } from "./push_devices.js";
 
 export const NOTIFY_KEY = "chi_notify";
 // The device id chi web gave this app's subscription (POST subscribe's
@@ -32,6 +42,12 @@ export const PUSH_DEVICE_KEY = "chi_push_device";
 // A long-lived Home Screen app checks for a new sw.js at most this often
 // when it comes back in front (reg.update()).
 export const SW_UPDATE_MS = 60 * 60 * 1000;
+// Presence: a page in front reports this often (chi web counts a report
+// 45 s), and is in front only if touched this recently (a tab left focused
+// on a screen nobody watches stops quieting the phone).
+export const PRESENCE_PATH = "/api/push/presence";
+export const PRESENCE_EVERY_MS = 30 * 1000;
+export const TOUCH_FRESH_MS = 2 * 60 * 1000;
 
 const NOTIFY_TITLES = {
   on: "Notifications on: a session that needs you while this tab is in the background. Click to turn off",
@@ -40,8 +56,8 @@ const NOTIFY_TITLES = {
 };
 
 const PUSH_TITLES = {
-  on: "Notifications to this phone: on (approvals and questions, also while the app is closed). Tap to turn off",
-  off: "Notify this phone when a session needs approval or an answer, also while the app is closed",
+  on: "Notifications to this phone: on (a session that needs you or failed, also while the app is closed). Tap for the devices",
+  off: "Notify this phone when a session needs you or a turn fails, also while the app is closed. Tap to turn it on",
   denied: "Notifications are blocked for this app in the phone's settings",
 };
 
@@ -57,6 +73,21 @@ async function defaultApi(method, path, body) {
   return data;
 }
 
+// How a presence report goes: a beacon when the page is leaving (it
+// outlives the page; same origin, so the cookie goes), else the api's
+// fetch. Errors swallowed: a lost report only means a push or a quiet one.
+// @return (body, leaving) => void
+export function presenceSender({ nav, api, BlobApi = globalThis.Blob }) {
+  return (body, leaving) => {
+    if (leaving && typeof nav?.sendBeacon === "function" && typeof BlobApi === "function") {
+      try {
+        if (nav.sendBeacon(PRESENCE_PATH, new BlobApi([JSON.stringify(body)], { type: "application/json" }))) return;
+      } catch (_) {}
+    }
+    try { api("POST", PRESENCE_PATH, body)?.catch?.(() => {}); } catch (_) {}
+  };
+}
+
 function defaultChannel() {
   try {
     if (typeof globalThis.BroadcastChannel === "function") return new BroadcastChannel(NOTIFY_CHANNEL);
@@ -75,7 +106,13 @@ function defaultChannel() {
 // @param api (method, path, body) => Promise of chi web's JSON
 // @param scoped the page shows one project's sessions (?dir=): it never
 //   tidies the device, as it doesn't see the others'
-// @param now () => ms (the service worker update's spacing; specs)
+// @param now () => ms (the service worker update's spacing, presence's
+//   touch; specs)
+// @param sendPresence (body, leaving) => void (presenceSender's by default)
+// @param every (fn, ms) => void, a repeating timer (presence's tick)
+// @param pageId this page load's id in its presence reports
+// @param devices (hooks) => the notifications sheet ({toggle, refresh}),
+//   made once chi web says it pushes (push_devices.js by default)
 // @return {noticeSessions(type, data), noticeList(sessions), setBaseTitle(title), clearBadge()}
 export function createNotifications({
   button,
@@ -89,12 +126,18 @@ export function createNotifications({
   api = defaultApi,
   scoped = false,
   now = () => Date.now(),
+  sendPresence = presenceSender({ nav, api }),
+  every = (fn, ms) => setInterval(fn, ms),
+  pageId = randomTabId(),
+  devices = (hooks) => createPushDevices({ ...hooks, doc, win }),
 }) {
   let attention = initialAttentionState();
   // Web Push in the Home Screen app: null until chi web says it pushes
   // ({reg, key, on}), and for good in a tab or without push.
   let push = null;
   let pushBusy = false;
+  // The notifications sheet the bell opens in push mode.
+  let sheet = null;
   let syncing = null;
   let syncAgain = false;
   // When this page last had the browser check for a newer sw.js.
@@ -151,7 +194,7 @@ export function createNotifications({
   }
 
   async function toggleNotify() {
-    if (push) return togglePush();
+    if (push) return sheet?.toggle();
     const state = notifyState();
     if (state === "unsupported" || state === "denied") return;
     let wanted = state !== "on";
@@ -162,10 +205,11 @@ export function createNotifications({
     renderNotifyBtn();
   }
 
-  // This device's subscription on (permission from the tap: iOS asks only
-  // from one), a test push to show it works; or off.
+  // This device's subscription on (permission from the tap on the sheet's
+  // switch: iOS asks only from one), a test push to show it works; or off.
+  // @return the failure's message, or null
   async function togglePush() {
-    if (pushBusy || notifyState() === "denied") return;
+    if (pushBusy || notifyState() === "denied") return null;
     pushBusy = true;
     let failed = null;
     try {
@@ -193,8 +237,9 @@ export function createNotifications({
       pushBusy = false;
     }
     renderNotifyBtn();
-    // Said on the bell (its tooltip); the next tap tries again.
+    // Said on the bell (its tooltip) and in the sheet; the next tap tries again.
     if (failed) button.title = `Notifications to this phone failed: ${failed}`;
+    return failed && `Notifications to this phone failed: ${failed}`;
   }
 
   // The Home Screen app: its service worker, chi web's key, and whether
@@ -208,6 +253,10 @@ export function createNotifications({
       const info = await api("GET", `/api/push${query}`);
       if (!info?.enabled || !info.public_key) return;
       push = { reg, key: info.public_key, on: !!(sub && info.this) };
+      sheet = devices({
+        button, api, state: notifyState, toggleThis: togglePush,
+        endpoint: async () => (await push.reg.pushManager.getSubscription())?.endpoint || null,
+      });
       // register() has just checked for a newer sw.js.
       swCheckedAt = now();
       renderNotifyBtn();
@@ -234,7 +283,8 @@ export function createNotifications({
   }
 
   // The Home Screen app with the bell on: closes the pushed notifications
-  // whose question isn't open (chi's own, chi:test, stay) and sets the
+  // whose question or card isn't open (chi's own, chi:test, and a failed
+  // or done turn's stay) and sets the
   // app's badge. Never before the first snapshot (an empty byId would close
   // them all) nor on a project's page (its byId lacks the others). One at a
   // time; asked again meanwhile, it runs once more after.
@@ -250,7 +300,7 @@ export function createNotifications({
         const open = new Set(openPushKeys(attention.byId));
         try {
           const shown = await push.reg.getNotifications();
-          for (const n of shown || []) if (isQuestionTag(n.tag) && !open.has(n.tag)) n.close();
+          for (const n of shown || []) if (isWaitingTag(n.tag) && !open.has(n.tag)) n.close();
         } catch (_) {}
         if (push?.on) setDeviceBadge(open.size);
       } while (syncAgain);
@@ -321,6 +371,31 @@ export function createNotifications({
     syncDevice();
     updateWorker();
   }
+  // ── Presence ──────────────────────────────────────────────────────────
+  // Loading the page counts as a touch.
+  let touchedAt = now();
+  let reportedFront = null;
+  const atPage = () => tabInFront() && now() - touchedAt < TOUCH_FRESH_MS;
+  function reportPresence(front = atPage(), leaving = false) {
+    reportedFront = front;
+    sendPresence({ page: pageId, front }, leaving);
+  }
+  // The first touch that brings the page to the front (after being idle,
+  // or behind) says so at once; the tick has the rest.
+  function touched() {
+    touchedAt = now();
+    if (reportedFront !== true && atPage()) reportPresence(true);
+  }
+  // Every 30 s while in front, and once more when it no longer is (no
+  // touch for 2 min).
+  every(() => { if (reportedFront || atPage()) reportPresence(); }, PRESENCE_EVERY_MS);
+  doc.addEventListener("visibilitychange", () => (doc.visibilityState === "visible" ? reportPresence() : reportPresence(false, true)));
+  win.addEventListener("focus", () => reportPresence());
+  win.addEventListener("blur", () => reportPresence(false));
+  win.addEventListener("pagehide", () => reportPresence(false, true));
+  for (const type of ["pointerdown", "keydown", "touchstart"]) doc.addEventListener(type, touched, { capture: true, passive: true });
+  if (atPage()) reportPresence(true);
+
   doc.addEventListener("visibilitychange", backInFront);
   win.addEventListener("focus", backInFront);
   doc.addEventListener("pointerdown", clearBadge, true);

data/lib/samagotchi/web/public/notify.js

@@ -96,7 +96,7 @@ const cardKey = (sessionId, cardId) => `${sessionId}:card:${cardId}`;
 // @param prev the summary held before (null for a session not seen yet)
 // @param next the new summary (null when the session is gone)
 // @return [String] keys, maybe none
-function closedKeys(prev, next) {
+export function closedKeys(prev, next) {
   const keys = [];
   const q = prev?.pending_question;
   const nq = next?.pending_question;
@@ -152,7 +152,7 @@ export function trackAttention(state, type, data = {}) {
 // The notification's words: a short title (the session) and the reason.
 // No question or answer text (it would show on a lock screen).
 export function attentionText(session, attention) {
-  const name = String(session?.title || session?.first_preview || session?.last_prompt || "chi session").trim();
+  const name = String(session?.title || session?.auto_title || session?.first_preview || session?.last_prompt || "chi session").trim();
   const title = clip(name, 61);
   const seconds = Math.round(Number(session?.last_turn?.seconds) || 0);
   const body = {
@@ -262,7 +262,7 @@ export function createNotifyGate({ channel = null, holdMs = NOTIFY_HOLD_MS, onSe
   };
 }
 
-function randomTabId() {
+export function randomTabId() {
   try {
     if (typeof globalThis.crypto?.randomUUID === "function") return globalThis.crypto.randomUUID();
   } catch (_) {}

data/lib/samagotchi/web/public/participant.html

@@ -11,6 +11,8 @@
    (the Plan): beside the thread on a wide screen, a Plan | Thread toggle on a narrow one (the composer pinned in both).
    The owner's participant view is the same page with no composer. Colours are tokens.css's. */
 *{box-sizing:border-box;margin:0;padding:0}
+/* No iOS text autosizing (index.html's twin). */
+html{-webkit-text-size-adjust:100%;text-size-adjust:100%}
 html,body{height:100%;height:100dvh}
 .p-body{flex:1;min-height:0;display:flex}
 .p-col{flex:1;min-width:0;min-height:0;display:flex;flex-direction:column}
@@ -126,6 +128,8 @@ button.small{font-size:12px;padding:2px 8px}
   .p-bubble{padding:9px 12px}
   .p-hint,.p-note{display:none}
 }
+/* Under 16px iOS Safari zooms the page on focus (and a Home Screen app never zooms back). */
+@media (max-width:600px),(pointer:coarse){.p-compose textarea{font-size:16px}}
 </style>
 </head>
 <body>

data/lib/samagotchi/web/public/push.js

@@ -6,31 +6,30 @@
 // a browser tab keeps the in-tab notifications). See
 // docs/internals/web-push.md.
 
-import { questionReason } from "./notify.js";
-
-// The reasons chi web pushes (Web::Push::Attention::PUSHED).
-const PUSHED = new Set(["approval", "question"]);
-
-// The keys still open in a byId (notify.js trackAttention's: session id →
-// summary): a pending question with an id, not relayed, of a reason chi
-// web pushes. Attention.open_keys's rule, so the page, the worker's open
-// list and the badge agree.
-// @return [String] "<session id>:<question id>" keys
+// The waiting keys still open in a byId (notify.js trackAttention's:
+// session id → summary): a pending question with an id, not relayed (any
+// reason: a step-limit continue too), and a card with actions.
+// Attention.open_keys's rule, so the page, the worker's open list and the
+// badge agree.
+// @return [String] "<session id>:<question id>" and "<session id>:card:<card id>" keys
 export function openPushKeys(byId) {
   const keys = [];
   for (const summary of Object.values(byId || {})) {
     const q = summary?.pending_question;
-    if (!q || !q.id || q.relayed_to || !PUSHED.has(questionReason(q))) continue;
-    keys.push(`${summary.id}:${q.id}`);
+    if (q && q.id && !q.relayed_to) keys.push(`${summary.id}:${q.id}`);
+    const card = summary?.pending_card;
+    if (card && card.id) keys.push(`${summary.id}:card:${card.id}`);
   }
   return keys;
 }
 
-// A pushed question's tag ("<session id>:<question id>"), not one of chi's
-// own (chi:test, chi:other): only these are ever cleaned up. sw.js keeps
-// the same pattern (a classic script imports nothing).
-export const QUESTION_TAG = /^(?!chi:)[^:]+:[^:]+$/;
-export const isQuestionTag = (tag) => typeof tag === "string" && QUESTION_TAG.test(tag);
+// A pushed waiting key's tag: a question's "<session id>:<question id>" or
+// a card's "<session id>:card:<card id>", not one of chi's own (chi:test,
+// chi:other) nor a failed or done turn's "<session id>:<ended_at>" (its
+// time has colons): only these are ever cleaned up. sw.js keeps the same
+// pattern (a classic script imports nothing).
+export const WAITING_TAG = /^(?!chi:)[^:]+:(?:card:)?[^:]+$/;
+export const isWaitingTag = (tag) => typeof tag === "string" && WAITING_TAG.test(tag);
 
 // A standalone app with a service worker and PushManager, on a secure
 // context (chi web's https public URL; the LAN's plain http has none).

data/lib/samagotchi/web/public/push_devices.js

@@ -0,0 +1,187 @@
+// The Home Screen app's notifications sheet (Web Push; notifications.js
+// opens it from the bell when chi web pushes): this device's switch (the
+// bell's subscribe / unsubscribe), then every device chi web pushes to from
+// this origin (GET /api/push's devices): its label, "this device", the last
+// delivery and the last error, a "Long turns done" switch (PATCH
+// /api/push/subscriptions/ID {prefs: {done}}), Remove for another device
+// (DELETE /api/push/subscriptions/ID), and the stale ones (another origin's,
+// never sent to) as one line. A phone gets it as a bottom sheet, a wider
+// window as a popover at the bell (chip_popover.js), small enough to need
+// no scrolling for a few devices.
+//
+// This device's row has the switch and never Remove: turning it off is the
+// bell turned off (the page forgets its device id), so the page's state and
+// chi web's store stay one. A device iOS revoked silently still shows a
+// recent delivery (Apple keeps answering 201): the list can't tell; switch
+// it off and on there.
+//
+// Pure templates and models, plus createPushDevices (the injected api and
+// the popover shell), so the specs run them under node --test.
+
+import { html, nothing, render } from "./vendor/lit-html.js";
+import { createChipPopover } from "./chip_popover.js";
+import { relativeTime } from "./format.js";
+
+export const DEVICE_PATH = "/api/push/subscriptions";
+
+// The rows GET /api/push's +info+ gives, this device first.
+// @return [{id, label, this, last, error, done}]
+export function deviceRows(info, now) {
+  const devices = Array.isArray(info?.devices) ? info.devices : [];
+  const rows = devices.map((d) => ({
+    id: String(d.id || ""),
+    label: d.label || d.id || "device",
+    this: d.this === true,
+    last: d.last_ok_at ? `last delivery ${relativeTime(d.last_ok_at, now)}` : "no delivery yet",
+    error: d.last_error ? `last error ${d.last_error}` : "",
+    done: d.prefs?.done === true,
+  }));
+  return [...rows.filter((r) => r.this), ...rows.filter((r) => !r.this)];
+}
+
+// "2 more devices from an earlier address, never sent to" (another origin's:
+// a renamed machine or tailnet), "" for none.
+export function staleText(count) {
+  const n = Number(count) || 0;
+  if (n <= 0) return "";
+  return `${n === 1 ? "1 more device" : `${n} more devices`} from an earlier address, never sent to (chi web push rm)`;
+}
+
+// What the sheet draws: +state+ the bell's ("on" | "off" | "denied"),
+// +info+ GET /api/push's answer (null before the first), +busy+ a change
+// in flight, +error+ the last one's failure.
+export function sheetModel({ state, info, busy = false, error = "", now = Date.now() }) {
+  const rows = deviceRows(info, now);
+  const mine = rows.find((r) => r.this) || null;
+  const thisRow = mine || {
+    id: "", label: "This device", this: true, done: false, error: "",
+    last: state === "denied" ? "notifications are blocked for this app in the phone's settings" : "off: nothing is pushed here",
+  };
+  return {
+    on: state === "on" && !!mine,
+    denied: state === "denied",
+    busy,
+    error,
+    thisRow,
+    others: rows.filter((r) => !r.this),
+    stale: staleText(info?.stale),
+    loading: !info,
+  };
+}
+
+const doneSwitch = (row, busy) => html`<label class="pd-done"><span>Long turns done (10 s or more)</span
+  ><input type="checkbox" class="pd-switch" role="switch" data-pd="done" data-id=${row.id} .checked=${row.done}
+    ?disabled=${busy}></label>`;
+
+function rowTemplate(row, model) {
+  const mine = row.this;
+  const subscribed = !mine || model.on;
+  return html`<li class=${`pd-row${mine ? " this" : ""}`} data-id=${row.id || nothing}>
+    <div class="pd-who"><b>${row.label}</b>${mine ? html`<span class="pd-tag">this device</span>` : nothing}</div>
+    <div class="pd-act">${mine
+      ? html`<input type="checkbox" class="pd-switch" role="switch" data-pd="this" aria-label="Notifications to this device"
+          .checked=${model.on} ?disabled=${model.busy || model.denied}>`
+      : html`<button type="button" class="pd-remove" data-pd="remove" data-id=${row.id} ?disabled=${model.busy}>Remove</button>`}</div>
+    <div class="pd-meta">${row.last}${row.error ? html` · <span class="pd-error">${row.error}</span>` : nothing}</div>
+    ${subscribed ? doneSwitch(row, model.busy) : nothing}
+  </li>`;
+}
+
+// The sheet's content (a lit-html template).
+export function sheetTemplate(model) {
+  return html`<div class="ctx-pop-head"><strong>Notifications</strong><span class="ctx-pop-kind">devices</span
+    ><button type="button" class="ctx-pop-close" data-act="close" aria-label="Close">×</button></div
+    ><ul class="pd-list">${rowTemplate(model.thisRow, model)}${model.others.map((row) => rowTemplate(row, model))}</ul
+    >${model.loading ? html`<div class="pd-note">Loading the devices…</div>` : nothing
+    }${model.stale ? html`<div class="pd-note">${model.stale}</div>` : nothing
+    }${model.error ? html`<div class="pd-note pd-error" role="alert">${model.error}</div>` : nothing
+    }<div class="pd-note">Approvals, questions, step limits, cards and failed turns; quiet while a chi web page is in front.</div>`;
+}
+
+// The sheet at the bell. +state+() the bell's state; +endpoint+() this
+// device's push endpoint (a Promise; null without a subscription);
+// +toggleThis+() the bell's subscribe / unsubscribe (resolves to its
+// failure's message, or null); +api+ chi web's JSON (notifications.js's).
+// @return {toggle(), refresh(), isOpen(), pop}
+export function createPushDevices({ button, api, state, endpoint, toggleThis, now = () => Date.now(),
+                                    doc = globalThis.document, win = globalThis.window }) {
+  let info = null;
+  let busy = false;
+  let error = "";
+  // Each load's turn: an older answer that arrives late is dropped.
+  let loads = 0;
+
+  const draw = () => {
+    if (shell.isOpen()) render(sheetTemplate(sheetModel({ state: state(), info, busy, error, now: now() })), shell.pop);
+  };
+
+  const shell = createChipPopover({
+    id: "pushDevices", className: "ctx-popover push-devices", width: 340, el: doc.createElement("span"),
+    anchor: "#notifyBtn", openers: "#notifyBtn", summary: () => ({}), sheet: true, label: "Notifications", doc, win,
+    show: () => render(sheetTemplate(sheetModel({ state: state(), info, busy, error, now: now() })), shell.pop),
+    onClose: () => { error = ""; },
+  });
+
+  async function load() {
+    const turn = ++loads;
+    try {
+      const at = await endpoint();
+      const answer = await api("GET", `/api/push${at ? `?endpoint=${encodeURIComponent(at)}` : ""}`);
+      if (turn !== loads) return;
+      info = answer;
+    } catch (e) {
+      if (turn !== loads) return;
+      error = `Can't read the devices: ${e?.message || e}`;
+    }
+    draw();
+    shell.replace();
+  }
+
+  // One change at a time; the list is read again after it.
+  async function change(run) {
+    if (busy) return;
+    busy = true;
+    error = "";
+    draw();
+    try {
+      error = (await run()) || "";
+    } catch (e) {
+      error = e?.message || String(e);
+    } finally {
+      busy = false;
+    }
+    await load();
+  }
+
+  shell.pop.addEventListener("change", (e) => {
+    const input = e.target.closest?.("[data-pd]");
+    if (!input) return;
+    if (input.dataset.pd === "this") change(toggleThis);
+    else if (input.dataset.pd === "done") {
+      const id = input.dataset.id;
+      const done = input.checked;
+      change(() => api("PATCH", `${DEVICE_PATH}/${encodeURIComponent(id)}`, { prefs: { done } }).then(() => null));
+    }
+  });
+  shell.pop.addEventListener("click", (e) => {
+    const remove = e.target.closest?.('[data-pd="remove"]');
+    if (!remove) return;
+    const id = remove.dataset.id;
+    change(() => api("DELETE", `${DEVICE_PATH}/${encodeURIComponent(id)}`).then(() => null));
+  });
+
+  return {
+    pop: shell.pop,
+    isOpen: shell.isOpen,
+    // The bell's tap: open (drawn from what is known, then read again) or close.
+    toggle() {
+      if (shell.isOpen()) return shell.close();
+      shell.open(button);
+      return load();
+    },
+    // The bell's state changed elsewhere: redraw an open sheet.
+    refresh: draw,
+    // Read the devices again (specs await it).
+    load,
+  };
+}

data/lib/samagotchi/web/public/session_state.js

@@ -121,12 +121,13 @@ export function sessionStateFrom(data) {
   return state;
 }
 
-// The info bar's title: the session's own title (/title), else the first
-// user message when the payload has messages, else the card's preview, else
+// The info bar's title: the session's own title (/title), else its auto
+// title, else its recap's first sentence (as its card), else the first user message when the payload has messages, else the card's preview, else
 // the first prompt of its history.
 function sessionFirstPreview(data) {
   const s = data.session;
-  if (s.title) return firstPreview(s.title);
+  const named = s.title || s.auto_title || s.recap;
+  if (named) return firstPreview(named);
   let preview = s.first_preview || previewForCard(s);
   if (data.messages && data.messages.length) {
     const first = data.messages.find((m) => m.role === "user");

data/lib/samagotchi/web/public/sw.js

@@ -17,9 +17,10 @@
 
 const ICON = "/icons/chi-192.png";
 const FALLBACK = { title: "chi", body: "open chi", tag: "chi:other", url: "/" };
-// push.js QUESTION_TAG: a pushed question's "<session id>:<question id>",
-// never chi's own (chi:test, chi:other).
-const QUESTION_TAG = /^(?!chi:)[^:]+:[^:]+$/;
+// push.js WAITING_TAG: a pushed question's "<session id>:<question id>" or
+// card's "<session id>:card:<card id>", never chi's own (chi:test,
+// chi:other) nor a failed or done turn's (its time has colons).
+const WAITING_TAG = /^(?!chi:)[^:]+:(?:card:)?[^:]+$/;
 
 function payloadOf(event) {
   try {
@@ -53,7 +54,7 @@ async function show({ title, body, tag, url }) {
   }
 }
 
-// Closes the shown question notifications chi web no longer has open
+// Closes the shown waiting notifications chi web no longer has open
 // (never the new one nor chi's own). The unfiltered list only names the
 // tags: on the iPhone (iOS 26, 2026-10-24) close() on a notification from
 // it did nothing, while one looked up by its tag closes (the probe in
@@ -63,7 +64,7 @@ async function closeAnswered(open, keep) {
     const still = new Set(open.map(String));
     const tags = new Set();
     for (const n of await self.registration.getNotifications()) {
-      if (n.tag !== keep && QUESTION_TAG.test(n.tag || "") && !still.has(n.tag)) tags.add(n.tag);
+      if (n.tag !== keep && WAITING_TAG.test(n.tag || "") && !still.has(n.tag)) tags.add(n.tag);
     }
     for (const tag of tags) {
       for (const n of await self.registration.getNotifications({ tag })) n.close();