@supersuit/suggest-a-change 0.1.10 → 0.1.11

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## Unreleased
+
+## 0.1.11 (2026-10-18)
+
+- **A second tab no longer takes over the first tab's recording.** Two tabs share one IndexedDB, and a tab that opened while another was recording ran `recoverTakes` over the live take: it deleted its marker and chunks, so every second said after that had no marker and was lost if the recording tab then died (freedom-app-template#1). Each second of a take now refreshes `beatAt` on its marker, and `recoverTakes` leaves a take that beat within `LIVE_TAKE_MS` (5 s, exported) exactly as it is; it is made whole on an open after it goes quiet. `recoverTakes(store, claim, { now, liveMs })` takes the clock for tests. An app reopened within 5 s of a crash recovers that take on its next open instead of this one; nothing is lost.
+
 ## 0.1.10 (2026-10-17)
 
 - **What goes with it is one small line.** The sheet no longer draws a section with a legend, an explainer and four switches above Send. Every diagnostic (the app's version, the time, the screen size, the phone type) goes with every report, beside the screen's name and address, and one muted line says what goes and to whom. Whoever acts on a report needs all of them, so leaving one out only ever cost a round trip. The `Words` keys the switches used (`withLegend`, `alwaysSent`, `include`, `screenName`) stay, so an app that overrides them still typechecks.

package/dist/client/recorder.d.ts

@@ -1,5 +1,15 @@
 import type { Store } from './idb.ts';
 export declare function pickMime(): string;
+/**
+ * A take whose last second landed this recently is LIVE in some page, never abandoned. Two tabs
+ * share one IndexedDB, so a second tab opening while the first records would otherwise "recover"
+ * the first tab's take mid-recording: delete its marker and chunks, and leave every second said
+ * after that with no marker, lost if that tab then dies (freedom-app-template#1). Each second of a
+ * take refreshes `beatAt`, so a take nobody is recording goes quiet within a second and is made
+ * whole on the next open after this window. Chunks arrive every 1000 ms; the margin covers a busy
+ * main thread.
+ */
+export declare const LIVE_TAKE_MS = 5000;
 export interface Recorded {
     key: string;
     blob: Blob;
@@ -14,7 +24,11 @@ export declare function startTake(store: Store, key: string, questionId: string)
 }>;
 /** Takes the app was closed in the middle of, made whole again. */
 /** `claim` limits the recovery to takes the caller owns (by question id); the rest are left exactly as they are for their owner. */
-export declare function recoverTakes(store: Store, claim?: (questionId: string) => boolean): Promise<{
+/** A take still beating (another tab recording it, LIVE_TAKE_MS) is left exactly as it is; it is recovered on an open after it goes quiet. */
+export declare function recoverTakes(store: Store, claim?: (questionId: string) => boolean, { now, liveMs }?: {
+    now?: number;
+    liveMs?: number;
+}): Promise<{
     questionId: string;
     key: string;
     ms: number;

package/dist/client/recorder.js

@@ -6,6 +6,16 @@ export function pickMime() {
             return m;
     return '';
 }
+/**
+ * A take whose last second landed this recently is LIVE in some page, never abandoned. Two tabs
+ * share one IndexedDB, so a second tab opening while the first records would otherwise "recover"
+ * the first tab's take mid-recording: delete its marker and chunks, and leave every second said
+ * after that with no marker, lost if that tab then dies (freedom-app-template#1). Each second of a
+ * take refreshes `beatAt`, so a take nobody is recording goes quiet within a second and is made
+ * whole on the next open after this window. Chunks arrive every 1000 ms; the margin covers a busy
+ * main thread.
+ */
+export const LIVE_TAKE_MS = 5000;
 export async function startTake(store, key, questionId) {
     const stream = await navigator.mediaDevices.getUserMedia({ audio: { echoCancellation: true, noiseSuppression: true, autoGainControl: true } });
     const mime = pickMime();
@@ -14,13 +24,16 @@ export async function startTake(store, key, questionId) {
     const started = Date.now();
     const chunks = [];
     const writes = [];
-    await store.put('kv', `rec:${key}`, { questionId, mime: type, startedAt: started });
+    const meta = { questionId, mime: type, startedAt: started, beatAt: started };
+    await store.put('kv', `rec:${key}`, meta);
     rec.ondataavailable = (e) => {
         if (!e.data?.size)
             return;
         const seq = chunks.length;
         chunks.push(e.data);
         writes.push(store.put('blobs', `${key}#${String(seq).padStart(5, '0')}`, e.data).catch(() => { }));
+        // The heartbeat another tab's recovery reads (LIVE_TAKE_MS).
+        writes.push(store.put('kv', `rec:${key}`, { ...meta, beatAt: Date.now() }).catch(() => { }));
     };
     rec.start(1000);
     const meter = makeMeter(stream);
@@ -100,7 +113,8 @@ function makeMeter(stream) {
 }
 /** Takes the app was closed in the middle of, made whole again. */
 /** `claim` limits the recovery to takes the caller owns (by question id); the rest are left exactly as they are for their owner. */
-export async function recoverTakes(store, claim) {
+/** A take still beating (another tab recording it, LIVE_TAKE_MS) is left exactly as it is; it is recovered on an open after it goes quiet. */
+export async function recoverTakes(store, claim, { now = Date.now(), liveMs = LIVE_TAKE_MS } = {}) {
     const out = [];
     // By prefix: this runs before the first paint, and `kv` also holds every saved view.
     const metas = (await store.all('kv', 'rec:')).filter((r) => r.key.startsWith('rec:'));
@@ -110,6 +124,9 @@ export async function recoverTakes(store, claim) {
     for (const { key: metaKey, value: m } of metas) {
         if (claim && !claim(m.questionId))
             continue;
+        const beat = Number(m.beatAt ?? m.startedAt);
+        if (Number.isFinite(beat) && now - beat < liveMs)
+            continue;
         const key = metaKey.slice(4);
         const parts = blobs.filter((b) => b.key.startsWith(`${key}#`)).sort((a, b) => a.key.localeCompare(b.key));
         if (parts.length) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supersuit/suggest-a-change",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "description": "The report format and flow behind a Suggest a change button: what a report is, who acts at each step, the screens, and the check every app runs. The contract has zero dependencies.",
   "type": "module",
   "bin": {

package/src/client/recorder.ts

@@ -10,7 +10,18 @@ export function pickMime(): string {
   return ''
 }
 
-interface Meta { questionId: string; mime: string; startedAt: number }
+interface Meta { questionId: string; mime: string; startedAt: number; beatAt?: number }
+
+/**
+ * A take whose last second landed this recently is LIVE in some page, never abandoned. Two tabs
+ * share one IndexedDB, so a second tab opening while the first records would otherwise "recover"
+ * the first tab's take mid-recording: delete its marker and chunks, and leave every second said
+ * after that with no marker, lost if that tab then dies (freedom-app-template#1). Each second of a
+ * take refreshes `beatAt`, so a take nobody is recording goes quiet within a second and is made
+ * whole on the next open after this window. Chunks arrive every 1000 ms; the margin covers a busy
+ * main thread.
+ */
+export const LIVE_TAKE_MS = 5000
 export interface Recorded { key: string; blob: Blob; ms: number }
 
 export async function startTake(store: Store, key: string, questionId: string) {
@@ -21,12 +32,15 @@ export async function startTake(store: Store, key: string, questionId: string) {
   const started = Date.now()
   const chunks: Blob[] = []
   const writes: Promise<void>[] = []
-  await store.put('kv', `rec:${key}`, { questionId, mime: type, startedAt: started } satisfies Meta)
+  const meta: Meta = { questionId, mime: type, startedAt: started, beatAt: started }
+  await store.put('kv', `rec:${key}`, meta)
   rec.ondataavailable = (e) => {
     if (!e.data?.size) return
     const seq = chunks.length
     chunks.push(e.data)
     writes.push(store.put('blobs', `${key}#${String(seq).padStart(5, '0')}`, e.data).catch(() => {}))
+    // The heartbeat another tab's recovery reads (LIVE_TAKE_MS).
+    writes.push(store.put('kv', `rec:${key}`, { ...meta, beatAt: Date.now() }).catch(() => {}))
   }
   rec.start(1000)
   const meter = makeMeter(stream)
@@ -88,7 +102,9 @@ function makeMeter(stream: MediaStream): { level(): number; close(): void } | nu
 
 /** Takes the app was closed in the middle of, made whole again. */
 /** `claim` limits the recovery to takes the caller owns (by question id); the rest are left exactly as they are for their owner. */
-export async function recoverTakes(store: Store, claim?: (questionId: string) => boolean): Promise<{ questionId: string; key: string; ms: number }[]> {
+/** A take still beating (another tab recording it, LIVE_TAKE_MS) is left exactly as it is; it is recovered on an open after it goes quiet. */
+export async function recoverTakes(store: Store, claim?: (questionId: string) => boolean,
+  { now = Date.now(), liveMs = LIVE_TAKE_MS }: { now?: number; liveMs?: number } = {}): Promise<{ questionId: string; key: string; ms: number }[]> {
   const out: { questionId: string; key: string; ms: number }[] = []
   // By prefix: this runs before the first paint, and `kv` also holds every saved view.
   const metas = (await store.all<Meta>('kv', 'rec:')).filter((r) => r.key.startsWith('rec:'))
@@ -96,6 +112,8 @@ export async function recoverTakes(store: Store, claim?: (questionId: string) =>
   const blobs = await store.all<Blob>('blobs')
   for (const { key: metaKey, value: m } of metas) {
     if (claim && !claim(m.questionId)) continue
+    const beat = Number(m.beatAt ?? m.startedAt)
+    if (Number.isFinite(beat) && now - beat < liveMs) continue
     const key = metaKey.slice(4)
     const parts = blobs.filter((b) => b.key.startsWith(`${key}#`)).sort((a, b) => a.key.localeCompare(b.key))
     if (parts.length) {