@supersuit/suggest-a-change 0.1.2 → 0.1.3

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.1.3 (2026-10-13)
+
+- **The phone's saved answers belong to whoever asked.** A list or report that the app answers after the signed-in account has changed is neither saved under the earlier account's key nor drawn: the account is asked again after the answer, as the outbox does before a write.
+- **A refusal is not "could not reach the app".** `mine()` and `one(id)` signal a refusal by throwing an error with `refused: true` or a `status` of 401, 403 or 404 (`one` may also answer an object with a string `refused`). On a refusal the saved copy is deleted and the screen says the suggestion could not be opened (or the list could not be loaded); any other failure keeps the saved copy under the "Could not reach the app" line, as in 0.1.2. Documented on `StoreAdapter`.
+- **The detail view follows its `id`.** Changing the id prop resets what is shown, so one report is never drawn under another's address.
+- **The saved views are kept tidy.** After a successful list, saved reports the app no longer lists are deleted, and signing out clears the account's saved views from the phone.
+- "Updating" shows only until the first answer after the screen opens, not on every periodic reload.
+
 ## 0.1.2 (2026-10-13)
 
 - **My suggestions and the detail view draw at once.** Each keeps its last successful answer (`mine()` and each `one(id)`) in the module's own IndexedDB store, keyed by app and account like a draft, and draws it as soon as the phone has read it, with a quiet "Updating" line until the app answers. The app's answer replaces it (a report that vanished on the app disappears). If the app cannot be reached, the saved rows stay and the screen says so: "Could not reach the app. Showing what this phone last saw." A first open with nothing saved shows the loading state, as before. Reports waiting in the outbox show as they did. Another account never reads this account's saved answer. New strings `updating` and `offlineShowingSaved` (replaceable through `words.text`).

package/README.md

@@ -47,7 +47,7 @@ const adapters: Adapters = {
 // then:                        {open && <SuggestSheet adapters={adapters} where={{ screen: "Photos", route: location.pathname }} onClose={() => setOpen(false)} />}
 ```
 
-`SuggestEntry` also takes `className` and `role` (for example `role="menuitem"` when a host shows it as a menu row); no role is set by default. My suggestions and the detail view keep their last answer from the app on the phone (module-owned IndexedDB, keyed by app and account like a draft), draw it at once with a quiet "Updating" line, and replace it when the app answers; if the app cannot be reached they keep the saved rows and say so. A first open with nothing saved shows "Loading".
+`SuggestEntry` also takes `className` and `role` (for example `role="menuitem"` when a host shows it as a menu row); no role is set by default. My suggestions and the detail view keep their last answer from the app on the phone (module-owned IndexedDB, keyed by app and account like a draft), draw it at once with a quiet "Updating" line, and replace it when the app answers; if the app cannot be reached they keep the saved rows and say so. An adapter tells a refusal from an unreachable app: `mine()` and `one()` throw an error with `refused: true` or a `status` of 401, 403 or 404 for a refusal (the saved copy is then deleted), and anything else thrown is unreachable. Saved reports the list no longer holds are pruned, and signing out clears them. A first open with nothing saved shows "Loading".
 
 The entry also keeps the phone's outbox moving while it is mounted (a report sent with the Mac away goes when it is back, with the sheet closed); a host with no always-mounted entry renders `<KeepSending adapters={adapters} />` once, high in the app. The entry carries `data-suggest-entry` (the attribute the screen check looks for; see "The check" below). Signed out, it opens nothing and says why. The receipt says "Got it" only after the adapter has answered `done` for the report and every attachment; until then it says the report is on the phone. Every text field the module renders sits in a `[data-voice-field]` container with a `[data-voice-control]`; a host's `Field` slot must keep that shape (it receives `FieldProps`, which is the Helm's voice field props). A voice note alone is a whole report: the recording is kept and uploaded as a part, and the receiving Mac writes the transcript.
 

package/dist/client/detail.js

@@ -11,7 +11,7 @@ import { recoverTakes } from './recorder.js';
 import { queueFollowUp } from './reports.js';
 import { useRuntime, useTick } from './runtime.js';
 import { Toasts } from './toast.js';
-import { oneCacheKey, readCache, writeCache } from './view-cache.js';
+import { dropCache, isRefusal, oneCacheKey, readCache, useClearOnSignOut, writeCache } from './view-cache.js';
 import { effectiveCeilings, lengthWords, sizeWords, statusMeaning, statusWords, stringsFor } from './words.js';
 export function statusOf(r) {
     if (typeof r.status === 'string')
@@ -96,7 +96,8 @@ export function SuggestionDetail({ adapters, id }) {
     // 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++; shown.current = false; setUpdating(false); setOffline(false); setReport(undefined); setPending([]); setReady(false); setMore(''); setHeard([]); followId.current = null; n.current = 0; restored.current = makeDeferred(); }, [rt]);
+    useClearOnSignOut(rt, who, adapters.words.app);
+    useEffect(() => { loads.current++; shown.current = false; setUpdating(false); setOffline(false); setReport(undefined); setPending([]); setReady(false); setMore(''); setHeard([]); followId.current = null; n.current = 0; restored.current = makeDeferred(); }, [rt, id]);
     const load = useCallback(async () => {
         if (!rt)
             return;
@@ -127,14 +128,30 @@ export function SuggestionDetail({ adapters, id }) {
                 }
             }
             let r;
+            let refused = false;
             try {
-                r = (await adapters.store.one(id));
+                const a = (await adapters.store.one(id));
+                if (a && typeof a === 'object' && typeof a.refused === 'string')
+                    refused = true;
+                else
+                    r = a;
             }
-            catch {
+            catch (e) {
                 r = undefined;
+                refused = isRefusal(e);
+            }
+            // The answer belongs to whoever asked: if the signed-in account is no longer that one, nothing is kept or drawn.
+            let now = null;
+            try {
+                now = await adapters.identity();
+            }
+            catch {
+                now = null;
             }
             if (!fresh())
                 return;
+            if (!now || now.account !== rt.who.account)
+                return;
             setUpdating(false);
             if (r) {
                 shown.current = true;
@@ -142,6 +159,12 @@ export function SuggestionDetail({ adapters, id }) {
                 setReport(r);
                 void writeCache(rt.store, ckey, r);
             }
+            else if (refused) {
+                shown.current = false;
+                setOffline(false);
+                void dropCache(rt.store, ckey);
+                setReport(null);
+            }
             else if (shown.current)
                 setOffline(true);
             else

package/dist/client/mine.js

@@ -7,7 +7,7 @@ import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-run
 import { useCallback, useEffect, useRef, useState } from 'react';
 import { SuggestionDetail } from './detail.js';
 import { useRuntime, useTick } from './runtime.js';
-import { mineCacheKey, readCache, writeCache } from './view-cache.js';
+import { dropCache, isRefusal, mineCacheKey, pruneOnes, readCache, useClearOnSignOut, writeCache } from './view-cache.js';
 import { Toasts } from './toast.js';
 import { statusMeaning, statusWords, stringsFor } from './words.js';
 export function MySuggestions({ adapters, onOpen }) {
@@ -23,7 +23,10 @@ export function MySuggestions({ adapters, onOpen }) {
     const loads = useRef(0);
     // What the app last said (or the phone kept of it) for this account; null until either is known.
     const known = useRef(null);
-    useEffect(() => { loads.current++; known.current = null; setRows(null); setOpen(null); setBad(''); setUpdating(false); }, [rt]);
+    // The first answer after mount ends "Updating"; later periodic reloads refresh quietly.
+    const answered = useRef(false);
+    useClearOnSignOut(rt, who, adapters.words.app);
+    useEffect(() => { loads.current++; known.current = null; answered.current = false; setRows(null); setOpen(null); setBad(''); setUpdating(false); }, [rt]);
     const load = useCallback(async () => {
         if (!rt)
             return;
@@ -49,25 +52,47 @@ export function MySuggestions({ adapters, onOpen }) {
             if (mine_ !== loads.current)
                 return;
             paint(known.current, local);
-            setUpdating(true);
+            if (!answered.current)
+                setUpdating(true);
         }
         let theirs = null;
+        let refused = false;
         try {
             theirs = await adapters.store.mine();
         }
-        catch {
+        catch (e) {
             theirs = null;
+            refused = isRefusal(e);
+        }
+        // The answer belongs to whoever asked. If the signed-in account is no longer that one, nothing is kept or drawn.
+        let now = null;
+        try {
+            now = await adapters.identity();
+        }
+        catch {
+            now = null;
         }
         const local = await rt.waiting();
         if (mine_ !== loads.current)
             return;
+        if (!now || now.account !== rt.who.account)
+            return;
+        answered.current = true;
         setUpdating(false);
         if (theirs) {
             known.current = theirs;
             void writeCache(rt.store, key, theirs);
+            void pruneOnes(rt.store, { app: adapters.words.app, account: rt.who.account }, theirs.map((t) => t.id));
             setBad('');
             paint(theirs, local);
         }
+        else if (refused) {
+            // The app said no: what the phone held is no longer this person's to see.
+            known.current = null;
+            void dropCache(rt.store, key);
+            setBad(S.couldNotLoadMine);
+            paint([], local);
+        }
         else if (known.current !== null) {
             setBad(S.offlineShowingSaved);
             paint(known.current, local);

package/dist/client/reports.d.ts

@@ -22,7 +22,9 @@ export interface StoreAdapter {
     uploadPart(reportId: string, file: string, part: number, bytes: Blob): Promise<'done' | {
         refused: string;
     }>;
+    /** An unreachable app THROWS (a network error). A refusal (the list is no longer this person's) throws an error with `refused: true` or a `status` of 401, 403 or 404: the phone then drops what it kept. */
     mine(): Promise<Summary[]>;
+    /** Same contract as `mine`: a report that is gone or not this person's is a refusal (`refused: true`, or status 401/403/404, or an answer object with a string `refused`), never a plain failure, so the phone stops showing its saved copy. */
     one(id: string): Promise<Report>;
     /** Adds to a report. Also at-least-once: it must dedupe by (id, `more.followId`). */
     append(id: string, more: Record<string, unknown>): Promise<'done' | {

package/dist/client/view-cache.d.ts

@@ -1,11 +1,26 @@
 import type { Store } from './idb.ts';
-export declare const mineCacheKey: (id: {
+type Id = {
     app: string;
     account: string;
-}) => string;
-export declare const oneCacheKey: (id: {
-    app: string;
-    account: string;
-}, reportId: string) => string;
+};
+export declare const mineCacheKey: (id: Id) => string;
+export declare const oneCacheKey: (id: Id, reportId: string) => string;
 export declare function readCache<T>(store: Store, key: string): Promise<T | undefined>;
 export declare function writeCache(store: Store, key: string, value: unknown): Promise<void>;
+export declare function dropCache(store: Store, key: string): Promise<void>;
+/** After a successful list: cached reports the app no longer lists (deleted, or no longer this person's) are dropped. */
+export declare function pruneOnes(store: Store, id: Id, keep: string[]): Promise<void>;
+/** Everything cached for one account: the list and every report. */
+export declare function clearViewCache(store: Store, id: Id): Promise<void>;
+/** True when the app REFUSED (the report is gone, or this person may not see it), as against being unreachable.
+ *  The adapter contract: `mine()` and `one()` throw an error carrying `refused: true`, or a `status` of 401, 403 or 404;
+ *  `one()` may instead answer an object with a string `refused`. Anything else thrown is a failure to reach the app. */
+export declare function isRefusal(e: unknown): boolean;
+/** When the person signs out (identity becomes null), the account that was signed in loses its cached views on this phone. */
+export declare function useClearOnSignOut(rt: {
+    store: Store;
+    who: {
+        account: string;
+    };
+} | null, who: unknown, app: string): void;
+export {};

package/dist/client/view-cache.js

@@ -1,6 +1,8 @@
+'use client';
 // THE LAST ANSWER, KEPT ON THE PHONE. My suggestions and the detail view draw from this at once and then
 // refresh from the app, so opening them never waits on the app being reachable. The key names the app and
 // the account exactly as a draft's does, so one person's cache is never read for another.
+import { useEffect, useRef } from 'react';
 import { draftKey } from './drafts.js';
 const base = (id) => `${draftKey(id)}#view`;
 export const mineCacheKey = (id) => `${base(id)}:mine`;
@@ -19,3 +21,52 @@ export async function writeCache(store, key, value) {
     }
     catch { /* a full or blocked database only costs the next open its head start */ }
 }
+export async function dropCache(store, key) {
+    try {
+        await store.del('kv', key);
+    }
+    catch { /* nothing to drop */ }
+}
+/** After a successful list: cached reports the app no longer lists (deleted, or no longer this person's) are dropped. */
+export async function pruneOnes(store, id, keep) {
+    try {
+        const prefix = `${base(id)}:one:`;
+        const live = new Set(keep);
+        for (const row of await store.all('kv', prefix))
+            if (!live.has(row.key.slice(prefix.length)))
+                await store.del('kv', row.key);
+    }
+    catch { /* the next list prunes again */ }
+}
+/** Everything cached for one account: the list and every report. */
+export async function clearViewCache(store, id) {
+    try {
+        for (const row of await store.all('kv', base(id)))
+            await store.del('kv', row.key);
+    }
+    catch { /* best effort */ }
+}
+/** True when the app REFUSED (the report is gone, or this person may not see it), as against being unreachable.
+ *  The adapter contract: `mine()` and `one()` throw an error carrying `refused: true`, or a `status` of 401, 403 or 404;
+ *  `one()` may instead answer an object with a string `refused`. Anything else thrown is a failure to reach the app. */
+export function isRefusal(e) {
+    if (!e || typeof e !== 'object')
+        return false;
+    const x = e;
+    return x.refused === true || (typeof x.refused === 'string' && x.refused !== '') || x.status === 401 || x.status === 403 || x.status === 404;
+}
+/** When the person signs out (identity becomes null), the account that was signed in loses its cached views on this phone. */
+export function useClearOnSignOut(rt, who, app) {
+    const last = useRef(null);
+    useEffect(() => {
+        if (rt) {
+            last.current = { store: rt.store, id: { app, account: rt.who.account } };
+            return;
+        }
+        if (who === null && last.current) {
+            const l = last.current;
+            last.current = null;
+            void clearViewCache(l.store, l.id);
+        }
+    }, [rt, who, app]);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supersuit/suggest-a-change",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "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/detail.tsx

@@ -11,7 +11,7 @@ import { recoverTakes } from './recorder.ts'
 import { queueFollowUp, type Report } from './reports.ts'
 import { useRuntime, useTick, type FollowUp } from './runtime.ts'
 import { Toasts } from './toast.tsx'
-import { oneCacheKey, readCache, writeCache } from './view-cache.ts'
+import { dropCache, isRefusal, oneCacheKey, readCache, useClearOnSignOut, writeCache } from './view-cache.ts'
 import { effectiveCeilings, lengthWords, sizeWords, statusMeaning, statusWords, stringsFor } from './words.ts'
 
 export function statusOf(r: Record<string, unknown>): string {
@@ -103,7 +103,8 @@ export function SuggestionDetail({ adapters, id }: { adapters: Adapters; id: str
   const restored = useRef(makeDeferred())
 
   // A different account (or none) shows nothing of the last one.
-  useEffect(() => { loads.current++; shown.current = false; setUpdating(false); setOffline(false); setReport(undefined); setPending([]); setReady(false); setMore(''); setHeard([]); followId.current = null; n.current = 0; restored.current = makeDeferred() }, [rt])
+  useClearOnSignOut(rt, who, adapters.words.app)
+  useEffect(() => { loads.current++; shown.current = false; setUpdating(false); setOffline(false); setReport(undefined); setPending([]); setReady(false); setMore(''); setHeard([]); followId.current = null; n.current = 0; restored.current = makeDeferred() }, [rt, id])
 
   const load = useCallback(async () => {
     if (!rt) return
@@ -124,10 +125,20 @@ export function SuggestionDetail({ adapters, id }: { adapters: Adapters; id: str
         if (saved && typeof saved === 'object') { shown.current = true; setReport(saved); setUpdating(true) }
       }
       let r: (Report & Record<string, unknown>) | undefined
-      try { r = (await adapters.store.one(id)) as Report & Record<string, unknown> } catch { r = undefined }
+      let refused = false
+      try {
+        const a = (await adapters.store.one(id)) as unknown
+        if (a && typeof a === 'object' && typeof (a as { refused?: unknown }).refused === 'string') refused = true
+        else r = a as Report & Record<string, unknown>
+      } catch (e) { r = undefined; refused = isRefusal(e) }
+      // The answer belongs to whoever asked: if the signed-in account is no longer that one, nothing is kept or drawn.
+      let now: { account: string } | null = null
+      try { now = await adapters.identity() } catch { now = null }
       if (!fresh()) return
+      if (!now || now.account !== rt.who.account) return
       setUpdating(false)
       if (r) { shown.current = true; setOffline(false); setReport(r); void writeCache(rt.store, ckey, r) }
+      else if (refused) { shown.current = false; setOffline(false); void dropCache(rt.store, ckey); setReport(null) }
       else if (shown.current) setOffline(true)
       else setReport(null)
     } catch { if (fresh()) setReport(null) }

package/src/client/mine.tsx

@@ -8,7 +8,7 @@ import type { Adapters } from './adapters.ts'
 import { SuggestionDetail } from './detail.tsx'
 import type { Summary } from './reports.ts'
 import { useRuntime, useTick } from './runtime.ts'
-import { mineCacheKey, readCache, writeCache } from './view-cache.ts'
+import { dropCache, isRefusal, mineCacheKey, pruneOnes, readCache, useClearOnSignOut, writeCache } from './view-cache.ts'
 import { Toasts } from './toast.tsx'
 import { statusMeaning, statusWords, stringsFor } from './words.ts'
 
@@ -28,7 +28,10 @@ export function MySuggestions({ adapters, onOpen }: { adapters: Adapters; onOpen
   const loads = useRef(0)
   // What the app last said (or the phone kept of it) for this account; null until either is known.
   const known = useRef<Summary[] | null>(null)
-  useEffect(() => { loads.current++; known.current = null; setRows(null); setOpen(null); setBad(''); setUpdating(false) }, [rt])
+  // The first answer after mount ends "Updating"; later periodic reloads refresh quietly.
+  const answered = useRef(false)
+  useClearOnSignOut(rt, who, adapters.words.app)
+  useEffect(() => { loads.current++; known.current = null; answered.current = false; setRows(null); setOpen(null); setBad(''); setUpdating(false) }, [rt])
 
   const load = useCallback(async () => {
     if (!rt) return
@@ -51,18 +54,31 @@ export function MySuggestions({ adapters, onOpen }: { adapters: Adapters; onOpen
       const local = await rt.waiting()
       if (mine_ !== loads.current) return
       paint(known.current, local)
-      setUpdating(true)
+      if (!answered.current) setUpdating(true)
     }
     let theirs: Summary[] | null = null
-    try { theirs = await adapters.store.mine() } catch { theirs = null }
+    let refused = false
+    try { theirs = await adapters.store.mine() } catch (e) { theirs = null; refused = isRefusal(e) }
+    // The answer belongs to whoever asked. If the signed-in account is no longer that one, nothing is kept or drawn.
+    let now: { account: string } | null = null
+    try { now = await adapters.identity() } catch { now = null }
     const local = await rt.waiting()
     if (mine_ !== loads.current) return
+    if (!now || now.account !== rt.who.account) return
+    answered.current = true
     setUpdating(false)
     if (theirs) {
       known.current = theirs
       void writeCache(rt.store, key, theirs)
+      void pruneOnes(rt.store, { app: adapters.words.app, account: rt.who.account }, theirs.map((t) => t.id))
       setBad('')
       paint(theirs, local)
+    } else if (refused) {
+      // The app said no: what the phone held is no longer this person's to see.
+      known.current = null
+      void dropCache(rt.store, key)
+      setBad(S.couldNotLoadMine)
+      paint([], local)
     } else if (known.current !== null) {
       setBad(S.offlineShowingSaved)
       paint(known.current, local)

package/src/client/reports.ts

@@ -21,7 +21,9 @@ export interface Summary { id: string; status: string; kind?: string; at?: numbe
 export interface StoreAdapter {
   submit(report: Report): Promise<'done' | { refused: string }>
   uploadPart(reportId: string, file: string, part: number, bytes: Blob): Promise<'done' | { refused: string }>
+  /** An unreachable app THROWS (a network error). A refusal (the list is no longer this person's) throws an error with `refused: true` or a `status` of 401, 403 or 404: the phone then drops what it kept. */
   mine(): Promise<Summary[]>
+  /** Same contract as `mine`: a report that is gone or not this person's is a refusal (`refused: true`, or status 401/403/404, or an answer object with a string `refused`), never a plain failure, so the phone stops showing its saved copy. */
   one(id: string): Promise<Report>
   /** Adds to a report. Also at-least-once: it must dedupe by (id, `more.followId`). */
   append(id: string, more: Record<string, unknown>): Promise<'done' | { refused: string }>

package/src/client/view-cache.ts

@@ -1,12 +1,15 @@
+'use client'
 // THE LAST ANSWER, KEPT ON THE PHONE. My suggestions and the detail view draw from this at once and then
 // refresh from the app, so opening them never waits on the app being reachable. The key names the app and
 // the account exactly as a draft's does, so one person's cache is never read for another.
+import { useEffect, useRef } from 'react'
 import { draftKey } from './drafts.ts'
 import type { Store } from './idb.ts'
 
-const base = (id: { app: string; account: string }) => `${draftKey(id)}#view`
-export const mineCacheKey = (id: { app: string; account: string }) => `${base(id)}:mine`
-export const oneCacheKey = (id: { app: string; account: string }, reportId: string) => `${base(id)}:one:${reportId}`
+type Id = { app: string; account: string }
+const base = (id: Id) => `${draftKey(id)}#view`
+export const mineCacheKey = (id: Id) => `${base(id)}:mine`
+export const oneCacheKey = (id: Id, reportId: string) => `${base(id)}:one:${reportId}`
 
 export async function readCache<T>(store: Store, key: string): Promise<T | undefined> {
   try { return await store.get<T>('kv', key) } catch { return undefined }
@@ -14,3 +17,38 @@ export async function readCache<T>(store: Store, key: string): Promise<T | undef
 export async function writeCache(store: Store, key: string, value: unknown): Promise<void> {
   try { await store.put('kv', key, value) } catch { /* a full or blocked database only costs the next open its head start */ }
 }
+export async function dropCache(store: Store, key: string): Promise<void> {
+  try { await store.del('kv', key) } catch { /* nothing to drop */ }
+}
+
+/** After a successful list: cached reports the app no longer lists (deleted, or no longer this person's) are dropped. */
+export async function pruneOnes(store: Store, id: Id, keep: string[]): Promise<void> {
+  try {
+    const prefix = `${base(id)}:one:`
+    const live = new Set(keep)
+    for (const row of await store.all('kv', prefix)) if (!live.has(row.key.slice(prefix.length))) await store.del('kv', row.key)
+  } catch { /* the next list prunes again */ }
+}
+
+/** Everything cached for one account: the list and every report. */
+export async function clearViewCache(store: Store, id: Id): Promise<void> {
+  try { for (const row of await store.all('kv', base(id))) await store.del('kv', row.key) } catch { /* best effort */ }
+}
+
+/** True when the app REFUSED (the report is gone, or this person may not see it), as against being unreachable.
+ *  The adapter contract: `mine()` and `one()` throw an error carrying `refused: true`, or a `status` of 401, 403 or 404;
+ *  `one()` may instead answer an object with a string `refused`. Anything else thrown is a failure to reach the app. */
+export function isRefusal(e: unknown): boolean {
+  if (!e || typeof e !== 'object') return false
+  const x = e as { refused?: unknown; status?: unknown }
+  return x.refused === true || (typeof x.refused === 'string' && x.refused !== '') || x.status === 401 || x.status === 403 || x.status === 404
+}
+
+/** When the person signs out (identity becomes null), the account that was signed in loses its cached views on this phone. */
+export function useClearOnSignOut(rt: { store: Store; who: { account: string } } | null, who: unknown, app: string): void {
+  const last = useRef<{ store: Store; id: Id } | null>(null)
+  useEffect(() => {
+    if (rt) { last.current = { store: rt.store, id: { app, account: rt.who.account } }; return }
+    if (who === null && last.current) { const l = last.current; last.current = null; void clearViewCache(l.store, l.id) }
+  }, [rt, who, app])
+}