@abide/abide 0.114.0 → 0.115.0

package/src/server/answerWorker.ts

@@ -6,6 +6,9 @@
 // as bytecode (38.93), where a function has no source to read back.
 
 import { CLIENT_ADDRESS } from '#shared/ADDRESSES.ts'
+import { KEEP_HEADER } from '#shared/KEEP_HEADER.ts'
+import { KEEP_OPENED } from '#shared/KEEP_OPENED.ts'
+import { KEPT_HEADER } from '#shared/KEPT_HEADER.ts'
 import { MOUNT, mounted } from '#shared/mount.ts'
 import { NAVIGATION_HEADER } from '#shared/NAVIGATION_HEADER.ts'
 import {
@@ -35,7 +38,7 @@ async function dropOurs(keeping) {
 }
 `
 
-// 45.3 through 45.8, and 45.13.
+// 45.3 through 45.8, 45.13, and 45.17 through 45.21.
 const SAVING = `
 self.addEventListener('install', (event) => {
     event.waitUntil(
@@ -53,10 +56,11 @@ self.addEventListener('activate', (event) => {
             const cache = await caches.open(BUNDLE)
             for (const request of await cache.keys())
                 if (!FILES.has(request.url)) await cache.delete(request)
-            await self.registration.navigationPreload?.enable()
+            // A preload would ask the network for every navigation, a kept copy answered or not.
+            await self.registration.navigationPreload?.disable()
             await self.clients.claim()
             for (const client of await self.clients.matchAll({ type: 'window' }))
-                await fetch(client.url).then(
+                await fetch(pageRequest(client.url, undefined, '1')).then(
                     (response) =>
                         kept(response)
                             ? keep(new Request(client.url), response)
@@ -94,32 +98,123 @@ self.addEventListener('fetch', (event) => {
     event.respondWith(answer(event, false))
 })
 
+// 45.17 through 45.20 — THE COPY KEPT, BY ITS OWN cache-control: fresh is answered and the network
+// not asked, stale within stale-while-revalidate is answered while the network is asked for the next
+// one — save by a request asking force-cache, a call whose wire asks again itself once it reads the
+// copy (RULEBOOK 16.80, 16.85), so asking here too would ask twice — and stale within stale-if-error
+// stands in where the network gives nothing. A request asking past every cache (a refresh, a load
+// after invalidate) is the network's alone; a navigation never is, since a reload offline would
+// otherwise be the page saying nothing was saved.
 async function answer(event, page) {
-    let response
+    const request = event.request
+    const bypass =
+        !page &&
+        (request.cache === 'no-cache' ||
+            request.cache === 'reload' ||
+            request.cache === 'no-store')
+    const saved = bypass
+        ? undefined
+        : await caches.match(request, { cacheName: SAVED, ignoreVary: true })
+    const life = saved === undefined ? undefined : lifeOf(saved)
+    if (life !== undefined) {
+        if (life.age < life.fresh) return marked(saved)
+        if (life.age < life.fresh + life.revalidate) {
+            if (request.cache !== 'force-cache')
+                event.waitUntil(
+                    fromNetwork(event, page, false).then(
+                        (response) => response.body?.cancel(),
+                        () => {},
+                    ),
+                )
+            return marked(saved)
+        }
+    }
     try {
-        response =
-            (page ? await event.preloadResponse : undefined) ??
-            (await fetch(event.request))
+        return await fromNetwork(event, page, page)
     } catch {
-        const saved = await caches.match(event.request, {
-            cacheName: SAVED,
-            ignoreVary: true,
-        })
-        return saved ?? (page ? offline() : Response.error())
+        if (life !== undefined && life.age < life.fresh + life.error)
+            return marked(saved)
+        return page ? offline() : Response.error()
     }
+}
+
+// 45.22 — A COPY KEPT SAYS SO, and when the server answered it, so a page tells it from the network's.
+function marked(saved) {
+    const headers = new Headers(saved.headers)
+    headers.set(KEPT, saved.headers.get('date') ?? '')
+    return new Response(saved.body, {
+        status: saved.status,
+        statusText: saved.statusText,
+        headers,
+    })
+}
+
+// A page as the worker asks for it, whether a navigation or the worker keeping an open window's:
+// past the browser's cache, as a page kept, and with its redirects left to the page — one followed
+// would be saved under the address it was asked at, holding where it led (RULEBOOK 45.4, 45.21,
+// 45.23).
+function pageRequest(url, headers, keep) {
+    const asking = new Headers(headers)
+    asking.set(KEEP, keep)
+    return new Request(url, { headers: asking, redirect: 'manual', cache: 'no-cache' })
+}
+
+// 45.21 — PAST THE BROWSER'S OWN CACHE, which holds the same answers under the same headers and would
+// hand a revalidation the copy it is replacing. A navigation's request takes no init of its own, so it
+// is asked again by address, its redirects left to the page as a navigation's are — and 45.23, as a
+// page kept, which a script's fetch is not otherwise told from (RULEBOOK 41.29, 41.30), and as the
+// page the navigation opens where opened says it is, which then hydrates from what it seeded.
+async function fromNetwork(event, page, opened) {
+    const request = event.request
+    const asked = page
+        ? pageRequest(request.url, request.headers, opened ? OPENED : '1')
+        : new Request(request, { cache: 'no-cache' })
+    const response = await fetch(asked)
     // A copy nothing reads is a tee holding every chunk, so one is cloned only to be saved.
     const copy = kept(response) ? response.clone() : undefined
     const rotated = response.headers.has(PRINCIPAL)
     event.waitUntil(
         (rotated ? caches.delete(SAVED) : Promise.resolve()).then(() =>
-            copy === undefined ? undefined : keep(event.request, copy),
+            copy === undefined ? undefined : keep(request, copy),
         ),
     )
     return response
 }
 
+// How old a kept copy is and how long each of its windows runs, in seconds; a copy with no date is
+// as old as it can be.
+function lifeOf(response) {
+    const directives = directivesOf(response)
+    const date = Date.parse(response.headers.get('date') ?? '')
+    // no-cache is never fresh; it and must-revalidate are never served stale.
+    const unfresh = directives.has('no-cache')
+    const unstale = unfresh || directives.has('must-revalidate')
+    const seconds = (name, closed) => {
+        const value = Number(directives.get(name))
+        return closed || !Number.isFinite(value) ? 0 : value
+    }
+    return {
+        age: Number.isNaN(date) ? Infinity : (Date.now() - date) / 1000,
+        fresh: seconds('max-age', unfresh),
+        revalidate: seconds('stale-while-revalidate', unstale),
+        error: seconds('stale-if-error', unstale),
+    }
+}
+
+// An answer's cache-control, by directive.
+function directivesOf(response) {
+    const directives = new Map()
+    for (const part of (response.headers.get('cache-control') ?? '').split(',')) {
+        const [name, value] = part.trim().toLowerCase().split('=')
+        directives.set(name, value)
+    }
+    return directives
+}
+
+// 45.3, 45.4 — a 200 whose cache-control lets a private cache store it, and no stream.
 function kept(response) {
     if (response.status !== 200) return false
+    if (directivesOf(response).has('no-store')) return false
     const type = response.headers.get('content-type') ?? ''
     return !STREAMED.some((streamed) => type.startsWith(streamed))
 }
@@ -178,6 +273,9 @@ export function answerWorker(manifest: Manifest | undefined): Response {
         for (const name of bundleFiles(manifest))
             paths.push(mounted(`${CLIENT_ADDRESS}/${name}`))
         script = `${CACHES}const PRINCIPAL = ${JSON.stringify(PRINCIPAL_HEADER)}
+const KEPT = ${JSON.stringify(KEPT_HEADER)}
+const KEEP = ${JSON.stringify(KEEP_HEADER)}
+const OPENED = ${JSON.stringify(KEEP_OPENED)}
 const NAVIGATION = ${JSON.stringify(NAVIGATION_HEADER)}
 // 45.4 — the types a stream 16.32 frames, which has no end to save.
 const STREAMED = ${JSON.stringify(STREAMED_TYPES)}

package/src/server/createApp.ts

@@ -12,6 +12,7 @@ import { LONGEST_DELAY } from '#shared/LONGEST_DELAY.ts'
 import { namedLogger } from '#shared/log.ts'
 import { compose } from '#shared/Middleware.ts'
 import { MOUNT, unmounted } from '#shared/mount.ts'
+import { PRINCIPAL_HEADER } from '#shared/PRINCIPAL_HEADER.ts'
 import { RPC_SERVER } from '#shared/RPC_SERVER.ts'
 import { servedTable } from './abideModules.ts'
 import { type AppSources, answerRequest } from './answerRequest.ts'
@@ -329,7 +330,7 @@ export async function bootEntered(
                         reportUnexpected(thrown)
                         answered = plainAnswer('internal server error', 500)
                     }
-                    const stamped = beating(stamp(answered))
+                    const stamped = beating(stamp(answered, booted.offline))
                     // 28.7 — a closed namespace does not pay for the line it would have written.
                     if (REQUEST_LOG.enabled())
                         REQUEST_LOG.debug(
@@ -494,8 +495,11 @@ export async function bootEntered(
  *
  * 22.9 — AND WHAT WAS WRITTEN THROUGH `response`, laid over every answer here and nowhere else: a
  * lane builds its answer at the written status and leaves the headers to this.
+ *
+ * 21.24 — and where the worker keeps answers (`offline`), a sign-in or a sign-out has the browser's
+ * own cache drop what it kept for the caller before, as the worker drops its copies (45.7).
  */
-function stamp(answered: Response): Response {
+function stamp(answered: Response, offline: boolean): Response {
     let stamped = answered
     try {
         stamped.headers.set('x-content-type-options', 'nosniff')
@@ -507,6 +511,8 @@ function stamp(answered: Response): Response {
     const timing = serverTiming()
     if (timing !== undefined) stamped.headers.set('server-timing', timing)
     const written = applyWritten(stamped.headers)
+    if (offline && stamped.headers.has(PRINCIPAL_HEADER))
+        stamped.headers.set('clear-site-data', '"cache"')
     const status = written !== 200 ? written : stamped.status
     // 17.8 — a failure nobody named a reason for is given its registered one.
     const statusText =

package/src/server/installSourceMaps.ts

@@ -62,7 +62,7 @@ function placeFrames(error: Error, frames: CallSite[]): string {
     return out
 }
 
-// A call site's column counts from 0 where the stack bun writes counts from 1.
+// A call site's line and column count from 1; a map's from 0.
 function placed(frame: CallSite): string {
     // A handler file's frames name the file the author wrote, not the face it is served as.
     const file = (frame.getFileName() ?? '<anonymous>').replace(
@@ -70,15 +70,19 @@ function placed(frame: CallSite): string {
         '',
     )
     const line = frame.getLineNumber() ?? 0
-    const column = frame.getColumnNumber() ?? 0
+    const column = frame.getColumnNumber() ?? 1
     const registered = registeredFor(file)
     if (registered !== undefined && line > 0) {
         registered.lines ??= decodeMappings(registered.mappings)
-        const place = placeAt(registered.lines, line - 1, column)
+        const place = placeAt(
+            registered.lines,
+            line - 1,
+            Math.max(column - 1, 0),
+        )
         if (place !== undefined)
             return `${registered.source}:${place[0] + 1}:${place[1] + 1}`
     }
-    return `${file}:${line}:${column + 1}`
+    return `${file}:${line}:${column}`
 }
 
 function registeredFor(path: string): Registered | undefined {

package/src/server/render.ts

@@ -379,8 +379,9 @@ function earlyCallScript(calls: PageCall[]): string {
 // THE RUNNER RECORDS, IT NEVER CLASSIFIES: the `Response`, and a painted call's body read to its end
 // — the one decision is `painted`, which the server made. `answerOf` reads the record as it reads an
 // answer it fetched, so no second reading of a content type lives in a string no typecheck reaches.
-// The shape is `EarlyCall`'s.
-export const EARLY_CALL_RUNNER = `(function(s,c){for(var i=0;i<c.length;i++)(function(k,u,n,h){var e=s[k]={painted:h,response:void 0,bytes:void 0};e.promise=fetch(u,n).then(function(r){return h?r.arrayBuffer().then(function(b){e.bytes=b;e.response=r}):e.response=r}).catch(function(){})})(c[i][0],c[i][1],c[i][2],c[i][3])})(self.${EARLY_CALLS}||(self.${EARLY_CALLS}={}),JSON.parse(document.currentScript.previousElementSibling.textContent))`
+// The shape is `EarlyCall`'s. 16.80 — a page the worker answers has it answer the page's calls too,
+// which the browser alone can tell: the server cannot see whether a worker will replay this page.
+export const EARLY_CALL_RUNNER = `(function(s,c,w){for(var i=0;i<c.length;i++)(function(k,u,n,h){if(w)n.cache='force-cache';var e=s[k]={painted:h,response:void 0,bytes:void 0};e.promise=fetch(u,n).then(function(r){return h?r.arrayBuffer().then(function(b){e.bytes=b;e.response=r}):e.response=r}).catch(function(){})})(c[i][0],c[i][1],c[i][2],c[i][3])})(self.${EARLY_CALLS}||(self.${EARLY_CALLS}={}),JSON.parse(document.currentScript.previousElementSibling.textContent),(self.navigator.serviceWorker||{}).controller)`
 
 /** The early-call runner's hash, as `script-src` names it. 29.9. */
 export const EARLY_CALL_HASH = `'sha256-${new Bun.CryptoHasher('sha256').update(EARLY_CALL_RUNNER).digest('base64')}'`

package/src/server/seedBuffer.ts

@@ -83,6 +83,32 @@ type Entry = {
 // which is how a refresh of it is told from a call the render never made (41.12).
 const BUFFER = new Map<string, Map<object, Map<string, Entry[]>>>()
 
+/** A render's one report of each call (1.8): the call's key where it is new, `undefined` where not. */
+function reportsOnce(): (rpc: object, args: unknown) => string | undefined {
+    const reported = new Map<object, Set<string>>()
+    return (rpc, args) => {
+        const key = seedKey(args)
+        if (key === undefined) return undefined
+        let keys = reported.get(rpc)
+        if (keys === undefined) {
+            keys = new Set()
+            reported.set(rpc, keys)
+        }
+        if (keys.has(key)) return undefined
+        keys.add(key)
+        return key
+    }
+}
+
+/**
+ * 41.30 — the seed sink of a page the worker keeps: each call reported once, for the early-call
+ * script, and none of them left in the seed buffer (41.29) — the page is opened later, if at all.
+ */
+export function callsOnly(): PageRender['seed'] {
+    const firstReport = reportsOnce()
+    return (rpc, args) => firstReport(rpc, args) !== undefined
+}
+
 /**
  * The sink a page's render scope reports each call into, for one caller.
  *
@@ -91,17 +117,10 @@ const BUFFER = new Map<string, Map<object, Map<string, Entry[]>>>()
  * browser's `Rpc` joins a standing call (1.8).
  */
 export function seedFor(caller: string): PageRender['seed'] {
-    const reported = new Map<object, Set<string>>()
+    const firstReport = reportsOnce()
     return (rpc, args, reached) => {
-        const key = seedKey(args)
+        const key = firstReport(rpc, args)
         if (key === undefined) return false
-        let keys = reported.get(rpc)
-        if (keys === undefined) {
-            keys = new Set()
-            reported.set(rpc, keys)
-        }
-        if (keys.has(key)) return false
-        keys.add(key)
         const entry: Entry = {
             rpc,
             key,

package/src/shared/KEEP_HEADER.ts

@@ -0,0 +1,7 @@
+/**
+ * The header the offline worker asks for a page it keeps under, so the page carries the early calls
+ * a later open of it starts (41.30, 45.23).
+ *
+ * A leaf, because the server writes it into the worker's script and reads it off the request.
+ */
+export const KEEP_HEADER = 'abide-keep'

package/src/shared/KEEP_OPENED.ts

@@ -0,0 +1,7 @@
+/**
+ * The value of the offline worker's `abide-keep` header on the page a navigation opens, which then
+ * hydrates and so is seeded as one (41.29, 45.23) — a page saved behind the one opened is not.
+ *
+ * A leaf, because the server writes it into the worker's script and reads it off the request.
+ */
+export const KEEP_OPENED = 'open'

package/src/shared/KEPT_HEADER.ts

@@ -0,0 +1,6 @@
+/**
+ * The header the offline worker lays on an answer it gave from a copy it kept, naming when (45.22).
+ *
+ * A leaf, because the server writes it into the worker's script and the wire reads it (16.85).
+ */
+export const KEPT_HEADER = 'abide-kept'

package/src/shared/LOAD_OFFLINE.ts

@@ -0,0 +1,15 @@
+/**
+ * The `offline` of the call that is starting a load, while it starts.
+ *
+ * 16.81 — SET AROUND THE REACH as `LOAD_SIGNAL` is, and read by the browser's wire as its body
+ * starts: what stands in for an answer the call could not get. A leaf, because `callLoad` sets it
+ * and the wire reads it.
+ */
+export const LOAD_OFFLINE: {
+    current: ((args: unknown) => unknown) | undefined
+    /**
+     * Where the body that queues the call asks for the value the call reached, which `callLoad`
+     * fills once the reach returns: what the delivered answer lands in (46.7).
+     */
+    standing: { value: unknown } | undefined
+} = { current: undefined, standing: undefined }

package/src/shared/OUTBOX_SENDING.ts

@@ -0,0 +1,9 @@
+/**
+ * Whether the outbox has a call in flight, as a bare `busy` asks it (46.11).
+ *
+ * A leaf, because `outbox` fills it and the core's `busy` reads it from below `outbox`. Unfilled — an
+ * app holding no handler — no call is ever in flight.
+ */
+export const OUTBOX_SENDING: { any: (() => boolean) | undefined } = {
+    any: undefined,
+}

package/src/shared/answerOf.ts

@@ -11,6 +11,7 @@ import {
     framedChunks,
     framingOf,
 } from './framing.ts'
+import { KEPT_HEADER } from './KEPT_HEADER.ts'
 import { principalRotated } from './principalRotated.ts'
 import { refuse } from './refuse.ts'
 import type { RpcRequest } from './rpcRequest.ts'
@@ -35,6 +36,8 @@ export type Answer = {
     version: number | undefined
     /** The `max-age` its `cache-control` named, in ms (18.14, 21.8). */
     life: number | undefined
+    /** 16.85 — whether the worker answered from a copy it kept rather than the network (45.22). */
+    kept: boolean
     text: string | undefined
     /**
      * A binary answer's body read to the end (16.34), set in place of `text` — a body read as text
@@ -92,7 +95,7 @@ async function fetched(
         if (signal?.aborted === true) throw error
         // 16.79 — NO ANSWER AT ALL, as a status the app can narrow on rather than the browser's
         // own `TypeError`, whose message differs in each.
-        return unanswered()
+        return noAnswer()
     }
     // THE HANDLER SIGNED THIS CALLER IN OR OUT, and the cookie is already the browser's.
     principalRotated(response)
@@ -100,7 +103,7 @@ async function fetched(
 }
 
 /** The answer a call that reached no server stands in for: an empty 503, which `answered` refuses. */
-function unanswered(): Answer {
+export function noAnswer(): Answer {
     return {
         status: 503,
         statusText: '',
@@ -109,12 +112,20 @@ function unanswered(): Answer {
         followable: false,
         version: undefined,
         life: undefined,
+        kept: false,
         text: '',
         bytes: undefined,
         body: undefined,
     }
 }
 
+/** 46.4 — no answer at all (16.79), or a gateway's: try again later. */
+export function unanswered(answer: Answer): boolean {
+    return (
+        answer.status === 502 || answer.status === 503 || answer.status === 504
+    )
+}
+
 /**
  * `response`, classified: a body `read` to its end already (an early call the server painted)
  * decoded as what it carried, and one unread read as bytes where it is a binary (16.34), as text
@@ -139,6 +150,7 @@ function answerFrom(
         followable: ok && !binary,
         version: versionInEtag(headers.get(VERSION_HEADER)),
         life: seconds === null ? undefined : Number(seconds[1]) * 1000,
+        kept: headers.has(KEPT_HEADER),
         text: undefined,
         bytes: undefined,
         body: undefined,

package/src/shared/index.ts

@@ -55,6 +55,7 @@ export {
 // modules into the static closure of the entry every page imports.
 export { navigate } from './navigate.ts'
 export { online } from './online.ts'
+export { outbox, type QueuedCall } from './outbox.ts'
 export { onMenu } from './onMenu.ts'
 export { type Principal, principal } from './principal.ts'
 // EMITTED CODE'S: a prop the child writes (33.6, 33.7).
@@ -93,6 +94,7 @@ export {
     type Shared,
     type Store,
     structural,
+    synced,
     type Transformer,
     watch,
 } from './reactive/index.ts'

package/src/shared/outbox.ts

@@ -0,0 +1,116 @@
+// 46 — THE CALLS A BROWSER HAS NOT DELIVERED YET, asked of a selection as a probe is: `outbox()` for
+// every one, `outbox(logCall)` and `logCall.outbox(pattern)` for one handler's. What it answers is a
+// plain list, so a page counts, filters and walks it as it would any other, and each call carries
+// what can be done with it.
+//
+// THE FACE, NOT THE QUEUE: the queue is the browser's (`#ui/outboxQueue.ts`), which the wire loads and
+// which shows its line here through `showLine` and `showSending`. On a server nothing shows one, and
+// `outbox` answers no calls (46.15).
+
+import type { Failed } from './Failed.ts'
+import type { JsonValue } from './JsonValue.ts'
+import { ambient, type Reactive, type Selection } from './reactive/index.ts'
+import { matchesPattern } from './reactive/matchesPattern.ts'
+import { OUTBOX_SENDING } from './OUTBOX_SENDING.ts'
+import type { Method } from './rpc.ts'
+
+/** One call `outbox` holds: what it sends, when it was queued, how often it was sent, and its value. */
+export type QueuedCall<Value = unknown> = {
+    /** The call's `idempotency-key`, the same on every send (46.10). */
+    id: string
+    method: Method
+    url: string
+    args: Record<string, JsonValue> | undefined
+    queuedAt: number
+    attempts: number
+    /**
+     * 46.18 — the value the call settled: its stand-in until the server answers, and its refusal as
+     * `error()` where the server refused it.
+     */
+    value: Reactive<Value, Value, Failed<string, unknown>>
+    /** 46.12 — sends it again, at once. */
+    retry(): void
+    /** 46.13 — drops it, sent or not. */
+    discard(): void
+}
+
+/** A call as the queue shows it: the handler it is for, which a selection is matched against. */
+export type ShownCall = QueuedCall & { address: string }
+
+/** What a handler's calls settle to, read off its own `outbox` member; `unknown` for any other. */
+type ValueOf<Chosen> = Chosen extends {
+    outbox(pattern?: never): QueuedCall<infer Value>[]
+}
+    ? Value
+    : unknown
+
+/** A handler as a selection names it: its method and the address it is mounted at. */
+type Handler = { method: Method; address: string | undefined }
+
+/** A call as a selection is matched against it: its handler, and the args a pattern narrows. */
+type Matched = Pick<ShownCall, 'method' | 'address' | 'args'>
+
+const LINE = ambient<ShownCall[]>([])
+/** The call in flight, or `undefined` where none is. */
+const SENDING = ambient<Matched | undefined>(undefined)
+
+// 46.11 — a bare `busy` hears a call in flight, which no value holds.
+OUTBOX_SENDING.any = () => SENDING() !== undefined
+
+/** 46.1 — shows the queue's line, oldest first. */
+export function showLine(calls: ShownCall[]): void {
+    LINE.set(calls)
+}
+
+/** 46.11 — shows the call being sent, or that none is. */
+export function showSending(call: Matched | undefined): void {
+    SENDING.set(call)
+}
+
+/**
+ * The calls waiting to be delivered and the ones refused, oldest first: every one, or the ones a
+ * handler names, narrowed by `pattern` as its own members narrow (46.1, 46.16).
+ */
+export function outbox<Chosen extends Selection>(
+    selection?: Chosen,
+    pattern?: Record<string, unknown>,
+): QueuedCall<ValueOf<Chosen>>[] {
+    const line = LINE() as QueuedCall<ValueOf<Chosen>>[]
+    if (selection === undefined) return line
+    const handler = handlerOf(selection)
+    const named: QueuedCall<ValueOf<Chosen>>[] = []
+    if (handler === undefined) return named
+    for (const call of line)
+        if (forHandler(call as ShownCall, handler, pattern)) named.push(call)
+    return named
+}
+
+/** 46.11 — whether a call `outbox` holds for `handler`, matching `pattern`, is in flight. */
+export function sendingFor(
+    handler: Handler,
+    pattern: Record<string, unknown> | undefined,
+): boolean {
+    const call = SENDING()
+    return call !== undefined && forHandler(call, handler, pattern)
+}
+
+function forHandler(
+    call: Matched,
+    handler: Handler,
+    pattern: Record<string, unknown> | undefined,
+): boolean {
+    return (
+        call.method === handler.method &&
+        call.address === handler.address &&
+        matchesPattern(call.args, pattern)
+    )
+}
+
+/** The handler a selection names, or `undefined` where it names none — a value, a key, or tags. */
+function handlerOf(selection: object): Handler | undefined {
+    const handler = selection as Partial<Handler>
+    return typeof handler.method === 'string' &&
+        typeof handler.address === 'string'
+        ? (handler as Handler)
+        : undefined
+}

package/src/shared/reactive/Keyed.ts

@@ -66,6 +66,7 @@ export type Keyed<
 ) => Reactive<Stored, Accepted, Failures, Produced>) & {
     busy(pattern?: Partial<Args>): boolean
     ready(pattern?: Partial<Args>): boolean
+    synced(pattern?: Partial<Args>): boolean
     refresh(pattern?: Partial<Args>): void
     invalidate(pattern?: Partial<Args>): void
     /** The entries reached so far. Not app surface — the statics and the tests read it. */
@@ -462,6 +463,14 @@ export function createKeyed<
                     return false
             return true
         },
+        // 13.18 — ALL, as `ready` asks: one entry written here is one the server has not seen.
+        synced: (pattern?: Partial<Args>): boolean => {
+            askMembership()
+            for (const entry of entries.values())
+                if (matchesPattern(argsOf(entry), pattern) && !entry.synced())
+                    return false
+            return true
+        },
         refresh: (pattern?: Partial<Args>): void => {
             for (const entry of entries.values())
                 if (matchesPattern(argsOf(entry), pattern)) entry.refresh()