@supersuit/suggest-a-change 0.0.0-stage → 0.1.0

package/dist/client/detail.js

@@ -0,0 +1,215 @@
+'use client';
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// ONE SUGGESTION: the words, the attachments, the step strip from the flow, and a way to add to it until
+// it has an end status. A report's words are data: they are rendered as text, never as markup. A report
+// that is still only on this phone is shown from the phone's own copy, with the app's refusal if it gave one.
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { END, STATUSES } from '../contract.mjs';
+import { DefaultField } from './default-field.js';
+import { draftKey } from './drafts.js';
+import { recoverTakes } from './recorder.js';
+import { queueFollowUp } from './reports.js';
+import { useRuntime, useTick } from './runtime.js';
+import { Toasts } from './toast.js';
+import { effectiveCeilings, lengthWords, sizeWords, statusMeaning, statusWords, stringsFor } from './words.js';
+export function statusOf(r) {
+    if (typeof r.status === 'string')
+        return r.status;
+    const t = r.timeline;
+    if (Array.isArray(t) && t.length) {
+        const last = t[t.length - 1];
+        if (typeof last?.status === 'string')
+            return last.status;
+    }
+    return 'received';
+}
+/** The step shown under "Being made". The timeline entry is the truth (that is where the receiving side puts it); a top-level `step` is read only when there is no timeline. */
+export function stepOf(r) {
+    const t = r.timeline;
+    if (Array.isArray(t) && t.length) {
+        const s = t[t.length - 1]?.step;
+        return typeof s === 'string' && s ? s : undefined;
+    }
+    return typeof r.step === 'string' ? r.step : undefined;
+}
+const timelineOf = (r) => Array.isArray(r?.timeline) ? r.timeline.map((t) => String(t?.status)) : undefined;
+/** The strip is made from the contract's own statuses, one step per distinct word ("planned" reads as "With Freeda"),
+ *  and a step is marked from the report's timeline: reached, skipped (the report went past it), or still ahead. */
+export function StatusStrip({ status, owner, step, timeline, label }) {
+    const nodes = useMemo(() => {
+        const out = [];
+        for (const id of STATUSES.filter((s) => !END.includes(s))) {
+            const words = statusWords(id, owner);
+            const had = out.find((n) => n.words === words);
+            if (had)
+                had.ids.push(id);
+            else
+                out.push({ words, ids: [id] });
+        }
+        return out;
+    }, [owner]);
+    const ended = END.includes(status);
+    const here = nodes.findIndex((n) => n.ids.includes(status));
+    const at = ended ? nodes.length : Math.max(0, here);
+    const items = [...nodes, { words: statusWords(ended ? status : 'live', owner), ids: [ended ? status : 'end'] }];
+    const reached = new Set(timeline ?? []);
+    return (_jsx("ol", { className: "sac-strip", "aria-label": label ?? stringsFor({ app: 'x', owner }).stepLabel, "data-status": status, children: items.map((it, i) => {
+            const state = i === at ? 'now'
+                : it.ids.some((id) => reached.has(id)) ? 'past'
+                    : i > at ? 'next'
+                        : timeline ? 'skipped'
+                            // No timeline to read: an open report has passed what is before it; an ended one may have skipped any step.
+                            : ended ? 'unknown' : 'past';
+            return (_jsxs("li", { className: "sac-step", "data-state": state, "aria-current": i === at ? 'step' : undefined, children: [_jsx("span", { children: it.words }), i === at && it.ids.includes('being-made') && step ? _jsx("span", { className: "sac-step-detail", children: step }) : null] }, it.words + i));
+        }) }));
+}
+function makeDeferred() { let done = () => { }; const ready = new Promise((r) => { done = r; }); return { ready, done: () => done() }; }
+const newFollowId = () => `f-${Math.random().toString(36).slice(2, 8)}`;
+export function SuggestionDetail({ adapters, id }) {
+    const S = stringsFor(adapters.words);
+    const Field = adapters.Field ?? DefaultField;
+    const { rt, who } = useRuntime(adapters);
+    const tick = useTick(rt);
+    const ceilings = useMemo(() => effectiveCeilings(adapters.limits), [adapters.limits]);
+    const [report, setReport] = useState(undefined);
+    const [refusal, setRefusal] = useState();
+    const [pending, setPending] = useState([]);
+    const [more, setMore] = useState('');
+    const [heard, setHeard] = useState([]);
+    const [note, setNote] = useState('');
+    const [bad, setBad] = useState('');
+    const [ready, setReady] = useState(false);
+    // The follow-up being written: its id is made when the person starts it, so queuing it twice is one follow-up.
+    const followId = useRef(null);
+    const n = useRef(0);
+    const key = who ? draftKey({ app: adapters.words.app, account: who.account }) : null;
+    const fuKey = key ? `${key}#fu:${id}` : null;
+    const labels = { holdToTalk: S.holdToTalk, stopTalking: S.stopTalking, micDenied: S.micDenied, voiceUnavailable: S.voiceUnavailable, voiceTotalLimit: S.voiceTotalLimit };
+    // Each load takes a number; only the newest may paint, so a load still running for the account that
+    // was just replaced never draws its rows under the new one.
+    const loads = useRef(0);
+    // Anything that writes the follow-up waits until its draft has been read, so the counter is right.
+    const restored = useRef(makeDeferred());
+    // A different account (or none) shows nothing of the last one.
+    useEffect(() => { loads.current++; setReport(undefined); setPending([]); setReady(false); setMore(''); setHeard([]); followId.current = null; n.current = 0; restored.current = makeDeferred(); }, [rt]);
+    const load = useCallback(async () => {
+        if (!rt)
+            return;
+        const mine_ = ++loads.current;
+        const fresh = () => mine_ === loads.current;
+        try {
+            const waiting = await rt.followUps(id);
+            const mine = await rt.local(id);
+            if (!fresh())
+                return;
+            setPending(waiting);
+            if (mine) {
+                setReport({ ...mine.report, status: 'on-phone' });
+                setRefusal(mine.error);
+                return;
+            }
+            setRefusal(undefined);
+            const r = (await adapters.store.one(id));
+            if (fresh())
+                setReport(r);
+        }
+        catch {
+            if (fresh())
+                setReport(null);
+        }
+    }, [adapters, id, rt]);
+    useEffect(() => { void load(); }, [load, tick]);
+    // The follow-up in progress is kept on the phone as it is written, and a take cut off by a closed app rejoins it.
+    useEffect(() => {
+        if (!rt || !fuKey || !key)
+            return;
+        let live = true;
+        void (async () => {
+            const d = await rt.store.get('kv', fuKey);
+            let list = d?.heard ?? [];
+            // The counter starts from the notes already kept, before a rescued take takes the next number.
+            followId.current = d?.followId ?? followId.current;
+            n.current = list.reduce((m, h) => Math.max(m, Number(h.key.slice(h.key.lastIndexOf(':') + 1)) || 0), 0);
+            const rescued = await recoverTakes(rt.store, (q) => q === `${key}|field:append-${id}`);
+            for (const t of rescued) {
+                const blob = await rt.store.get('blobs', t.key);
+                if (!blob)
+                    continue;
+                followId.current ??= d?.followId ?? newFollowId();
+                const k = `fu:${id}:${followId.current}:${++n.current}`;
+                await rt.store.put('blobs', k, blob);
+                await rt.store.del('blobs', t.key);
+                list = [...list, { key: k, file: `added-${followId.current}-${n.current}.${(blob.type ?? '').split('/')[1]?.split(';')[0] || 'bin'}`, ms: t.ms }];
+            }
+            if (!live)
+                return;
+            // What was typed while this was loading wins over the saved words.
+            if (d)
+                setMore((cur) => (cur.trim() ? cur : d.words));
+            setHeard((cur) => [...list, ...cur]);
+            setReady(true);
+            restored.current.done();
+        })();
+        return () => { live = false; };
+    }, [rt, fuKey, key, id]);
+    useEffect(() => {
+        if (!rt || !fuKey || !ready)
+            return;
+        if (!more.trim() && !heard.length)
+            void rt.store.del('kv', fuKey);
+        else
+            void rt.store.put('kv', fuKey, { followId: (followId.current ??= newFollowId()), words: more, heard });
+    }, [rt, fuKey, ready, more, heard]);
+    if (who === null)
+        return _jsx("p", { role: "alert", children: S.signedOutMine });
+    if (report === undefined)
+        return _jsx("p", { children: S.loading });
+    if (report === null)
+        return _jsx("p", { role: "alert", children: S.couldNotOpen });
+    const status = statusOf(report);
+    const owner = adapters.words.owner;
+    const open = !END.includes(status) && status !== 'on-phone';
+    const answers = (report.answers ?? {});
+    const voice = Array.isArray(report.voice) ? report.voice : [];
+    const media = Array.isArray(report.media) ? report.media : [];
+    // Words and voice notes follow the report through the outbox, so they survive a bad connection like the report did.
+    async function add() {
+        const words = more.trim();
+        if (!rt || !key || !fuKey || (!words && !heard.length))
+            return;
+        setBad('');
+        setNote('');
+        try {
+            const fid = (followId.current ??= newFollowId());
+            await queueFollowUp({ outbox: rt.outbox, reportId: id, followId: fid, words, voice: heard.map((h) => ({ file: h.file, ms: h.ms, blob: h.key })), draft: key, ...(adapters.phone?.now ? { now: adapters.phone.now } : {}) });
+            await rt.store.del('kv', fuKey);
+            followId.current = null;
+            n.current = 0;
+            setMore('');
+            setHeard([]);
+            setNote(S.appended);
+            void rt.drain();
+            void load();
+        }
+        catch {
+            setBad(S.addFailed);
+        }
+    }
+    // A note recorded here is kept on the phone (the recorder's own blob goes) and sent when Add is tapped.
+    async function keepHeard(original, blob, ms) {
+        if (!rt)
+            return { refused: S.loading };
+        if (ms > ceilings.voiceMs)
+            return { refused: S.voiceTooLong };
+        await restored.current.ready;
+        const fid = (followId.current ??= newFollowId());
+        const k = `fu:${id}:${fid}:${++n.current}`;
+        await rt.store.put('blobs', k, blob);
+        if (original && original !== k)
+            await rt.store.del('blobs', original);
+        const file = `added-${fid}-${n.current}.${(blob.type ?? '').split('/')[1]?.split(';')[0] || 'bin'}`;
+        setHeard((cur) => [...cur, { key: k, file, ms }]);
+        return { audio: k, text: '' };
+    }
+    return (_jsxs("article", { className: "sac-detail", "data-report": id, children: [_jsx("h3", { className: "sac-status", "data-status": status, children: statusWords(status, owner) }), _jsxs("p", { className: "sac-muted", children: [statusMeaning(status, owner), status === 'live' && typeof report.liveAt === 'string' ? ` (${new Date(report.liveAt).toLocaleDateString()})` : ''] }), refusal ? (_jsxs(_Fragment, { children: [_jsx("p", { role: "alert", className: "sac-error", children: refusal }), rt ? _jsx("button", { type: "button", className: "sac-button", onClick: () => void rt.retry(id), children: S.retry }) : null] })) : null, _jsx(StatusStrip, { status: status, owner: owner, label: S.stepLabel, step: stepOf(report), timeline: timelineOf(report) }), typeof report.words === 'string' && report.words ? _jsx("p", { className: "sac-words", children: report.words }) : null, Object.entries(answers).filter(([, v]) => v).map(([k, v]) => _jsx("p", { className: "sac-words", "data-answer": k, children: v }, k)), voice.length ? _jsx("ul", { className: "sac-list", "aria-label": S.voiceNotesLabel, children: voice.map((v, i) => _jsx("li", { className: "sac-item", children: S.voiceNote(i + 1, lengthWords(v.ms)) }, v.file)) }) : null, media.length ? _jsx("ul", { className: "sac-list", "aria-label": S.attachmentsLabel, children: media.map((m) => _jsxs("li", { className: "sac-item", children: [m.file, ", ", sizeWords(m.bytes)] }, m.file)) }) : null, Array.isArray(report.added) ? report.added.map((a, i) => _jsx("p", { className: "sac-words", children: a.words }, i)) : null, pending.length ? (_jsx("ul", { className: "sac-list", "aria-label": S.waitingToSend, "data-followups": "", children: pending.map((f) => (_jsxs("li", { className: "sac-item", "data-followup": f.followId, children: [_jsx("span", { className: "sac-words", children: f.words || S.attachmentsLabel }), f.error ? _jsx("span", { role: "alert", className: "sac-error", children: f.error }) : _jsx("span", { className: "sac-muted", children: S.waitingToSend }), f.error && rt ? _jsx("button", { type: "button", className: "sac-button", onClick: () => void rt.retry(id), children: S.retry }) : null, f.error && rt ? _jsx("button", { type: "button", className: "sac-button", onClick: () => void rt.discardFollowUp(id, f.followId), children: S.discard }) : null] }, f.followId))) })) : null, open ? (_jsxs("form", { className: "sac-form", onSubmit: (e) => { e.preventDefault(); void add(); }, children: [rt ? (_jsx(Field, { rt: { store: rt.store }, id: `append-${id}`, label: S.appendLabel, value: more, onChange: setMore, multiline: true, persist: false, startTake: adapters.startTake, maxMs: ceilings.voiceMs, scope: key ?? undefined, labels: labels, ...(adapters.appendVoice === false ? {} : { upload: (k, b, ms) => keepHeard(k, b, ms) }) })) : null, heard.length ? _jsx("ul", { className: "sac-list", "aria-label": S.voiceNotesLabel, children: heard.map((h, i) => _jsx("li", { className: "sac-item", children: S.voiceNote(i + 1, lengthWords(h.ms)) }, h.key)) }) : null, bad ? _jsx("p", { role: "alert", className: "sac-error", children: bad }) : null, note ? _jsx("p", { role: "status", children: note }) : null, _jsx("button", { type: "submit", className: "sac-button", disabled: !more.trim() && !heard.length, children: S.appendSend })] })) : null, _jsx(Toasts, {})] }));
+}

package/dist/client/dialog.d.ts

@@ -0,0 +1,2 @@
+import { type RefObject } from 'react';
+export declare function useDialog(ref: RefObject<HTMLElement | null>, onClose?: () => void): void;

package/dist/client/dialog.js

@@ -0,0 +1,53 @@
+'use client';
+// A labelled dialog's behaviour: focus goes in when it opens, Tab stays inside it (listened for on the
+// document, so it holds even after the focused button has gone), Escape closes it, and focus goes back
+// to what had it when it closes.
+import { useEffect } from 'react';
+const FOCUSABLE = 'a[href], button:not([disabled]), input:not([disabled]), textarea:not([disabled]), select:not([disabled]), [tabindex]:not([tabindex="-1"])';
+export function useDialog(ref, onClose) {
+    useEffect(() => {
+        const box = ref.current;
+        if (!box)
+            return;
+        const before = document.activeElement;
+        const items = () => [...box.querySelectorAll(FOCUSABLE)].filter((el) => !el.hasAttribute('hidden'));
+        (items()[0] ?? box).focus();
+        function onKey(e) {
+            if (!box.isConnected)
+                return;
+            if (e.key === 'Escape' && onClose) {
+                e.stopPropagation();
+                onClose();
+                return;
+            }
+            if (e.key !== 'Tab')
+                return;
+            const list = items();
+            if (!list.length) {
+                e.preventDefault();
+                box.focus();
+                return;
+            }
+            const first = list[0];
+            const last = list[list.length - 1];
+            const active = document.activeElement;
+            if (!box.contains(active)) {
+                e.preventDefault();
+                (e.shiftKey ? last : first).focus();
+            }
+            else if (e.shiftKey && active === first) {
+                e.preventDefault();
+                last.focus();
+            }
+            else if (!e.shiftKey && active === last) {
+                e.preventDefault();
+                first.focus();
+            }
+        }
+        document.addEventListener('keydown', onKey);
+        return () => { document.removeEventListener('keydown', onKey); if (before && document.contains(before))
+            before.focus(); };
+        // The dialog opens once per mount; onClose is read through the closure it was given.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+}

package/dist/client/drafts.d.ts

@@ -0,0 +1,28 @@
+import type { Store } from './idb.ts';
+export interface Draft {
+    /** Made when the draft starts; it is the dedupe key everywhere the report travels. */
+    reportId: string;
+    kind?: string;
+    words: string;
+    /** Keys of attachments held in the `blobs` store (voice takes, images, one video). */
+    attachments: string[];
+    updatedAt: number;
+    /** Set when the draft's report has been put in the outbox. The next save then starts a new draft. */
+    queued?: boolean;
+}
+/** `app` may not contain ':' (the account may), so two different pairs can never make the same key. */
+export declare function draftKey({ app, account }: {
+    app: string;
+    account: string;
+}): string;
+/** A draft with `queued: true` is read-only for a UI: the next saveDraft replaces it with a fresh one. */
+export declare function loadDraft(store: Store, key: string): Promise<Draft | undefined>;
+/** Saves what the person has so far. The first save of a draft makes its report id; later saves keep it,
+ *  until the report is queued: a save after that starts a new draft with a new id, so words typed while
+ *  the old report is still sending are never part of it and never lost when it lands. */
+export declare function saveDraft(store: Store, key: string, fields?: Partial<Pick<Draft, 'kind' | 'words' | 'attachments'>>, { now, makeId }?: {
+    now?: () => number;
+    makeId?: () => string;
+}): Promise<Draft>;
+/** Clears the draft. With `reportId`, only if the draft still belongs to that report. */
+export declare function clearDraft(store: Store, key: string, reportId?: string): Promise<void>;

package/dist/client/drafts.js

@@ -0,0 +1,39 @@
+// A DRAFT BELONGS TO ONE APP AND ONE ACCOUNT. Two people can use one phone (a shared tablet, a signed-out
+// and signed-in again), and a draft is the most private thing the button holds: half a thought, maybe a
+// complaint about the person who is about to pick the phone up. So the key names both, and switching
+// people can never show the other's draft. The report id is made the moment the draft starts and stays
+// with it, so a send that is repeated (a double tap, a retry after a lost reply) is the same report.
+import { newReportId } from '../contract.mjs';
+/** `app` may not contain ':' (the account may), so two different pairs can never make the same key. */
+export function draftKey({ app, account }) {
+    if (app.includes(':'))
+        throw new Error(`an app name cannot contain ":" (got ${JSON.stringify(app)})`);
+    return `sac:${app}:${account}`;
+}
+/** A draft with `queued: true` is read-only for a UI: the next saveDraft replaces it with a fresh one. */
+export async function loadDraft(store, key) {
+    return store.get('kv', key);
+}
+/** Saves what the person has so far. The first save of a draft makes its report id; later saves keep it,
+ *  until the report is queued: a save after that starts a new draft with a new id, so words typed while
+ *  the old report is still sending are never part of it and never lost when it lands. */
+export async function saveDraft(store, key, fields = {}, { now = () => Date.now(), makeId = () => newReportId() } = {}) {
+    const queuedBefore = await loadDraft(store, key);
+    const had = queuedBefore?.queued ? undefined : queuedBefore;
+    const draft = {
+        reportId: had?.reportId ?? makeId(),
+        words: '',
+        attachments: [],
+        ...had,
+        ...fields,
+        updatedAt: now(),
+    };
+    await store.put('kv', key, draft);
+    return draft;
+}
+/** Clears the draft. With `reportId`, only if the draft still belongs to that report. */
+export async function clearDraft(store, key, reportId) {
+    if (reportId !== undefined && (await loadDraft(store, key))?.reportId !== reportId)
+        return;
+    await store.del('kv', key);
+}

package/dist/client/entry.d.ts

@@ -0,0 +1,12 @@
+import type { Adapters } from './adapters.ts';
+export declare function SuggestEntry({ adapters, onOpen, className }: {
+    adapters: Adapters;
+    onOpen(): void;
+    className?: string;
+}): import("react").JSX.Element;
+/** For an error screen: opens the sheet as "something is broken", with the screen and what went wrong filled in. */
+export declare function ReportProblem({ adapters, screen, error }: {
+    adapters: Adapters;
+    screen: string;
+    error?: unknown;
+}): import("react").JSX.Element;

package/dist/client/entry.js

@@ -0,0 +1,55 @@
+'use client';
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// THE ENTRY: one control, `data-suggest-entry`, which is the contract the screen checker looks for.
+// Signed out, it opens nothing and says why. Signed in, it hands over to the host (`onOpen`), which
+// shows the sheet. `<ReportProblem>` is the same control for an error screen, already filled in.
+import { useEffect, useState } from 'react';
+import { SuggestSheet } from './sheet.js';
+import { stringsFor } from './words.js';
+export function SuggestEntry({ adapters, onOpen, className }) {
+    const S = stringsFor(adapters.words);
+    const [why, setWhy] = useState('');
+    const [busy, setBusy] = useState(false);
+    useEffect(() => { setWhy(''); }, [adapters]);
+    async function press() {
+        setBusy(true);
+        let who = null;
+        try {
+            who = await adapters.identity();
+        }
+        catch {
+            who = null;
+        }
+        setBusy(false);
+        if (!who) {
+            setWhy(S.signedOut);
+            return;
+        }
+        setWhy('');
+        onOpen();
+    }
+    return (_jsxs("span", { className: "sac-entry-wrap", children: [_jsx("button", { type: "button", "data-suggest-entry": "", className: `sac-entry${className ? ` ${className}` : ''}`, "aria-busy": busy || undefined, onClick: () => void press(), children: S.entry }), why ? _jsx("span", { role: "status", className: "sac-entry-why", children: why }) : null] }));
+}
+/** For an error screen: opens the sheet as "something is broken", with the screen and what went wrong filled in. */
+export function ReportProblem({ adapters, screen, error }) {
+    const S = stringsFor(adapters.words);
+    const [open, setOpen] = useState(false);
+    const [why, setWhy] = useState('');
+    const happened = error instanceof Error ? error.message : error == null ? '' : String(error);
+    async function press() {
+        let who = null;
+        try {
+            who = await adapters.identity();
+        }
+        catch {
+            who = null;
+        }
+        if (!who) {
+            setWhy(S.signedOut);
+            return;
+        }
+        setWhy('');
+        setOpen(true);
+    }
+    return (_jsxs(_Fragment, { children: [_jsx("button", { type: "button", className: "sac-button sac-report-problem", onClick: () => void press(), children: S.reportProblem }), why ? _jsx("span", { role: "status", className: "sac-entry-why", children: why }) : null, open ? (_jsx(SuggestSheet, { adapters: adapters, where: { screen, route: typeof location === 'undefined' ? '' : location.pathname }, initial: { kind: 'broken', happened }, onClose: () => setOpen(false) })) : null] }));
+}

package/dist/client/idb.d.ts

@@ -0,0 +1,12 @@
+export type StoreName = 'kv' | 'outbox' | 'blobs';
+export interface Store {
+    get<T = unknown>(store: StoreName, key: string): Promise<T | undefined>;
+    put(store: StoreName, key: string, value: unknown): Promise<void>;
+    del(store: StoreName, key: string): Promise<void>;
+    /** Every record, or only those whose key starts with `prefix` (read without touching the rest). */
+    all<T = unknown>(store: StoreName, prefix?: string): Promise<{
+        key: string;
+        value: T;
+    }[]>;
+}
+export declare function openStore(name?: string): Promise<Store>;

package/dist/client/idb.js

@@ -0,0 +1,22 @@
+const STORES = ['kv', 'outbox', 'blobs'];
+const req = (r) => new Promise((res, rej) => { r.onsuccess = () => res(r.result); r.onerror = () => rej(r.error); });
+export async function openStore(name = 'suggest-a-change') {
+    const open = indexedDB.open(name, 1);
+    open.onupgradeneeded = () => { for (const s of STORES)
+        if (!open.result.objectStoreNames.contains(s))
+            open.result.createObjectStore(s); };
+    const db = await req(open);
+    const tx = (s, mode) => db.transaction(s, mode).objectStore(s);
+    const done = (t) => new Promise((res, rej) => { t.transaction.oncomplete = () => res(); t.transaction.onerror = () => rej(t.transaction.error); t.transaction.onabort = () => rej(t.transaction.error); });
+    return {
+        get: (s, k) => req(tx(s, 'readonly').get(k)),
+        async put(s, k, v) { const t = tx(s, 'readwrite'); t.put(v, k); await done(t); },
+        async del(s, k) { const t = tx(s, 'readwrite'); t.delete(k); await done(t); },
+        async all(s, prefix) {
+            const t = tx(s, 'readonly');
+            const range = prefix ? IDBKeyRange.bound(prefix, `${prefix}￿`) : undefined;
+            const [keys, values] = await Promise.all([req(t.getAllKeys(range)), req(t.getAll(range))]);
+            return keys.map((k, i) => ({ key: String(k), value: values[i] }));
+        },
+    };
+}

package/dist/client/index.d.ts

@@ -0,0 +1,16 @@
+export * from './idb.ts';
+export * from './op-id.ts';
+export * from './outbox.ts';
+export * from './recorder.ts';
+export * from './drafts.ts';
+export * from './reports.ts';
+export * from './words.ts';
+export * from './adapters.ts';
+export * from './toast.tsx';
+export * from './default-field.tsx';
+export * from './receipt.tsx';
+export * from './entry.tsx';
+export * from './sheet.tsx';
+export * from './mine.tsx';
+export * from './detail.tsx';
+export { refreshIdentity } from './runtime.ts';

package/dist/client/index.js

@@ -0,0 +1,16 @@
+export * from './idb.js';
+export * from './op-id.js';
+export * from './outbox.js';
+export * from './recorder.js';
+export * from './drafts.js';
+export * from './reports.js';
+export * from './words.js';
+export * from './adapters.js';
+export * from './toast.js';
+export * from './default-field.js';
+export * from './receipt.js';
+export * from './entry.js';
+export * from './sheet.js';
+export * from './mine.js';
+export * from './detail.js';
+export { refreshIdentity } from './runtime.js';

package/dist/client/mine.d.ts

@@ -0,0 +1,5 @@
+import type { Adapters } from './adapters.ts';
+export declare function MySuggestions({ adapters, onOpen }: {
+    adapters: Adapters;
+    onOpen?(id: string): void;
+}): import("react").JSX.Element;

package/dist/client/mine.js

@@ -0,0 +1,55 @@
+'use client';
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// MY SUGGESTIONS: everything this person has sent, newest first, each with its status in plain words.
+// A report still on the phone is listed too (as "On this phone"), with the app's refusal and a Try again
+// when it gave one. Only this signed-in account's reports are shown; another person's waiting reports
+// on the same phone are not.
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { SuggestionDetail } from './detail.js';
+import { useRuntime, useTick } from './runtime.js';
+import { Toasts } from './toast.js';
+import { statusMeaning, statusWords, stringsFor } from './words.js';
+export function MySuggestions({ adapters, onOpen }) {
+    const S = stringsFor(adapters.words);
+    const owner = adapters.words.owner;
+    const { rt, who } = useRuntime(adapters);
+    const tick = useTick(rt);
+    const [rows, setRows] = useState(null);
+    const [open, setOpen] = useState(null);
+    const [bad, setBad] = useState('');
+    // Another account (or none) shows nothing of the last one's rows.
+    const loads = useRef(0);
+    useEffect(() => { loads.current++; setRows(null); setOpen(null); }, [rt]);
+    const load = useCallback(async () => {
+        if (!rt)
+            return;
+        // Only the newest load may paint: one still running for the account just replaced must not draw its rows.
+        const mine_ = ++loads.current;
+        let theirs = [];
+        let failed = false;
+        try {
+            theirs = await adapters.store.mine();
+        }
+        catch {
+            failed = true;
+        }
+        const local = await rt.waiting();
+        if (mine_ !== loads.current)
+            return;
+        setBad(failed ? S.couldNotLoadMine : '');
+        const waiting = new Map(local.map((l) => [l.id, l]));
+        // A report the app already lists keeps its own status; one still on the phone is listed as on the phone.
+        const phone = local.filter((l) => !l.onlyFollowUp && !theirs.some((t) => t.id === l.id)).map((l) => ({ id: l.id, status: 'on-phone', at: l.at, ...(l.words ? { words: l.words } : {}), ...(l.error ? { error: l.error } : {}) }));
+        setRows([...theirs.map((t) => ({ ...t, ...(waiting.get(t.id)?.error ? { error: waiting.get(t.id).error } : {}) })), ...phone].sort((a, b) => (b.at ?? 0) - (a.at ?? 0)));
+    }, [adapters, rt, S.couldNotLoadMine]);
+    useEffect(() => { void load(); }, [load, tick]);
+    if (who === null)
+        return _jsx("p", { role: "alert", children: S.signedOutMine });
+    if (open && !onOpen) {
+        return (_jsxs("section", { className: "sac-mine", children: [_jsx("button", { type: "button", className: "sac-button", onClick: () => setOpen(null), children: S.back }), _jsx(SuggestionDetail, { adapters: adapters, id: open })] }));
+    }
+    return (_jsxs("section", { className: "sac-mine", "aria-labelledby": "sac-mine-title", children: [_jsx("h2", { id: "sac-mine-title", className: "sac-title", children: S.mineTitle }), bad ? _jsx("p", { role: "alert", className: "sac-error", children: bad }) : null, rows === null ? _jsx("p", { children: S.loading }) : rows.length === 0 ? _jsx("p", { children: S.mineEmpty }) : (_jsx("ul", { className: "sac-list", children: rows.map((r) => {
+                    const preview = typeof r.words === 'string' ? r.words : typeof r.title === 'string' ? r.title : '';
+                    return (_jsxs("li", { className: "sac-row", "data-status": r.status, children: [_jsxs("button", { type: "button", className: "sac-row-button", onClick: () => (onOpen ? onOpen(r.id) : setOpen(r.id)), children: [preview ? _jsx("span", { className: "sac-row-words", children: preview }) : null, _jsx("span", { className: "sac-row-status", children: statusWords(r.status, owner) }), _jsx("span", { className: "sac-muted", children: statusMeaning(r.status, owner) })] }), r.error ? (_jsxs(_Fragment, { children: [_jsx("p", { role: "alert", className: "sac-error", children: r.error }), rt ? _jsx("button", { type: "button", className: "sac-button", onClick: () => void rt.retry(r.id), children: S.retry }) : null] })) : null] }, r.id));
+                }) })), _jsx(Toasts, {})] }));
+}

package/dist/client/op-id.d.ts

@@ -0,0 +1,5 @@
+export declare const stableHash: (s: string) => string;
+export declare function opId(...parts: string[]): string;
+/** One take's own id inside a write: the write's id plus the take's key, so two takes into one note
+ *  are two receipts, and a replay of one take (its reply was lost) is still answered once. */
+export declare const takeOpId: (writeId: string, takeKey: string) => string;

package/dist/client/op-id.js

@@ -0,0 +1,27 @@
+// AN OP ID THE MAC ALWAYS TAKES. The receiving side answers a write or a take exactly once by its op id,
+// and refuses any id outside ^[\w-]{2,80}$ . An id built from data (a project
+// slug with a dot in it, a long judgment id) can fall outside that, and then every retry is refused
+// and the write never lands. opId builds the id from its parts deterministically, so the same write
+// made twice (a remount, a replay) still gets the same id: the plain joined parts when they already
+// fit, else a sanitized, truncated form with a stable hash of the original on the end.
+const OP = /^[\w-]{2,80}$/;
+/** FNV-1a, 32 bits, from a seed: two of these make a stable 64-bit fingerprint with no dependencies. */
+function fnv(s, seed) {
+    let h = seed >>> 0;
+    for (let i = 0; i < s.length; i++) {
+        h ^= s.charCodeAt(i);
+        h = Math.imul(h, 0x01000193) >>> 0;
+    }
+    return h >>> 0;
+}
+export const stableHash = (s) => fnv(s, 0x811c9dc5).toString(36) + fnv(s, 0x9747b28c).toString(36);
+export function opId(...parts) {
+    const plain = parts.join('-');
+    if (OP.test(plain))
+        return plain;
+    const clean = plain.replace(/[^\w-]+/g, '_').slice(0, 60);
+    return `${clean}-${stableHash(plain)}`;
+}
+/** One take's own id inside a write: the write's id plus the take's key, so two takes into one note
+ *  are two receipts, and a replay of one take (its reply was lost) is still answered once. */
+export const takeOpId = (writeId, takeKey) => opId(writeId, takeKey);

package/dist/client/outbox.d.ts

@@ -0,0 +1,35 @@
+import type { Store } from './idb.ts';
+export interface Op {
+    id: string;
+    /** A name the host app chooses for its own writes. The module adds 'report' and 'reportPart' (see reports.ts). */
+    kind: string;
+    body: Record<string, unknown>;
+    /** A recorded take in the `blobs` store, deleted with the op once it lands. */
+    blob?: string;
+    /** The id of the write this one belongs to (a part's report or follow-up). While that write is refused, this one is held, not sent. */
+    parent?: string;
+    at: number;
+    error?: string;
+}
+export type Sent = 'done' | {
+    refused: string;
+};
+export interface OutboxState {
+    waiting: number;
+    refused: number;
+    landed?: string;
+}
+export declare function makeOutbox({ store, send, reach }: {
+    store: Store;
+    send(op: Op): Promise<Sent>;
+    reach: {
+        check(force?: boolean): Promise<boolean>;
+        mark(up: boolean): void;
+    };
+}): {
+    pending: () => Promise<Op[]>;
+    enqueue(op: Op): Promise<void>;
+    drain(): Promise<void>;
+    subscribe(fn: (s: OutboxState) => void): () => void;
+    refresh: () => Promise<void>;
+};