@abide/abide 0.105.1 → 0.106.0

package/src/server/serveDev.ts

@@ -31,7 +31,7 @@ import { DEV_ADDRESS } from '#shared/ADDRESSES.ts'
 import type { Compilation } from './abideModules.ts'
 import { DEFAULT_PORT } from './DEFAULT_PORT.ts'
 import type { FromWorker, ToWorker } from './devWorker.ts'
-import { upgraded } from './muxUpgrade.ts'
+import { muxSocketOptions, sendOrClose, upgraded } from './muxUpgrade.ts'
 import { placeOf } from './placement.ts'
 import { plainAnswer } from './plainAnswer.ts'
 import { askOver } from './responseRelay.ts'
@@ -79,7 +79,7 @@ export async function serveDev(
     // 38.24, 38.35 — every request, asked of the worker there is and streamed back a chunk per read.
     // 16.22 — a call's idle timeout raised on the request bun handed this listener.
     const relay = askOver((request, seconds) =>
-        server.timeout(request, seconds),
+        served?.timeout(request, seconds),
     )
     // Every socket this listener holds: the reload client's, with no data, and the app mux's, carrying
     // the connection id the worker knows it by.
@@ -88,6 +88,7 @@ export async function serveDev(
     let nextConnection = 0
     let worker: DevWorker | undefined
     let ready = false
+    let served: Bun.Server<Carried> | undefined
 
     // ONE COMPILE AT A TIME, and the worker is started from the LAST one. A save landing while a
     // compile runs marks it stale rather than starting a second: two in flight each started a
@@ -201,9 +202,12 @@ export async function serveDev(
                 stdio: ['inherit', 'inherit', 'inherit'],
                 serialization: 'advanced',
                 ipc(message: FromWorker) {
-                    if (message.kind === 'ready') ready = true
-                    else if (message.kind === 'socket-send')
-                        muxed.get(message.connection)?.send(message.text)
+                    if (message.kind === 'ready') {
+                        ready = true
+                        muxOptions = message.muxOptions
+                        served?.reload(serving(undefined))
+                    } else if (message.kind === 'socket-send')
+                        sendOrClose(muxed.get(message.connection), message.text)
                     else relay.take(message)
                 },
                 // 38.41 — AN APP THAT EXITS ON ITS OWN is replaced, and says so: a listener still
@@ -290,86 +294,93 @@ export async function serveDev(
             void closeChecker().finally(() => process.kill(process.pid, signal))
         })
 
-    const listen = (port: number | undefined) =>
-        Bun.serve<Carried>({
-            ...(port === undefined ? {} : { port }),
-            // 16.54, as `App.listen` lifts it: the worker behind this is where the ceiling is read.
-            maxRequestBodySize: Number.MAX_SAFE_INTEGER,
-            async fetch(request, listening) {
-                const asked = new URL(request.url).pathname
-                // THE MUX STANDS UNDER THE MOUNT, which is the app's configuration and so the worker's to
-                // read: every upgrade but the reload client's is asked of it, and the worker says
-                // whether it is the mux's (`muxUpgrade`) — a status alone is not, since any rung at any
-                // address can answer one.
-                const mux =
-                    asked !== DEV_ADDRESS &&
-                    request.headers.get('upgrade') === 'websocket'
-                if (!mux && asked !== DEV_ADDRESS) return relay.ask(request)
-                // 37.3 — THE MUX'S UPGRADE IS ASKED OF THE APP FIRST, whose lane runs in the worker.
-                if (mux && ready) {
-                    const answered = await relay.ask(request)
-                    if (!relay.admitted(answered)) return answered
+    // 18.28 — THE MUX'S LIMITS ARE THE APP'S CONFIGURATION, and so the worker's to resolve: each
+    // worker reports them on `ready` and the listener is reloaded with them, or `abide dev` would
+    // hold a socket to a limit `onConfig` moved in production and not here. Bun applies a reload's
+    // `maxPayloadLength` to every connection opened after it.
+    let muxOptions = muxSocketOptions()
+    const serving = (port: number | undefined): Bun.Serve.Options<Carried> => ({
+        ...(port === undefined ? {} : { port }),
+        // 16.54, as `App.listen` lifts it: the worker behind this is where the ceiling is read.
+        maxRequestBodySize: Number.MAX_SAFE_INTEGER,
+        async fetch(request, listening) {
+            const asked = new URL(request.url).pathname
+            // THE MUX STANDS UNDER THE MOUNT, which is the app's configuration and so the worker's to
+            // read: every upgrade but the reload client's is asked of it, and the worker says
+            // whether it is the mux's (`muxUpgrade`) — a status alone is not, since any rung at any
+            // address can answer one.
+            const mux =
+                asked !== DEV_ADDRESS &&
+                request.headers.get('upgrade') === 'websocket'
+            if (!mux && asked !== DEV_ADDRESS) return relay.ask(request)
+            // 37.3 — THE MUX'S UPGRADE IS ASKED OF THE APP FIRST, whose lane runs in the worker.
+            if (mux && ready) {
+                const answered = await relay.ask(request)
+                if (!relay.admitted(answered)) return answered
+            }
+            // NOT WHILE THE APP IS COMPILING. The reload client and the browser's mux both read a
+            // refusal as "still rebuilding" and retry, which is what keeps a reload from racing
+            // the worker it is meant to show.
+            if (!ready) return plainAnswer('rebuilding', 503)
+            let data: Carried
+            if (mux) {
+                nextConnection += 1
+                data = {
+                    connection: nextConnection,
+                    url: request.url,
+                    headers: [...request.headers.entries()],
                 }
-                // NOT WHILE THE APP IS COMPILING. The reload client and the browser's mux both read a
-                // refusal as "still rebuilding" and retry, which is what keeps a reload from racing
-                // the worker it is meant to show.
-                if (!ready) return plainAnswer('rebuilding', 503)
-                let data: Carried
-                if (mux) {
-                    nextConnection += 1
-                    data = {
-                        connection: nextConnection,
-                        url: request.url,
-                        headers: [...request.headers.entries()],
-                    }
+            }
+            return upgraded(listening, request, data)
+        },
+        websocket: {
+            ...muxOptions,
+            open(socket) {
+                // A RELOAD LANDED between the upgrade and this open: the worker it was meant for is
+                // gone and the next one would never hear of it, so it is closed and retried instead.
+                if (!ready) {
+                    socket.terminate()
+                    return
                 }
-                return upgraded(listening, request, data)
+                sockets.add(socket)
+                const carried = socket.data
+                if (carried === undefined) return
+                muxed.set(carried.connection, socket)
+                worker?.postMessage({ kind: 'socket-open', ...carried })
             },
-            websocket: {
-                open(socket) {
-                    // A RELOAD LANDED between the upgrade and this open: the worker it was meant for is
-                    // gone and the next one would never hear of it, so it is closed and retried instead.
-                    if (!ready) {
-                        socket.terminate()
-                        return
-                    }
-                    sockets.add(socket)
-                    const carried = socket.data
-                    if (carried === undefined) return
-                    muxed.set(carried.connection, socket)
-                    worker?.postMessage({ kind: 'socket-open', ...carried })
-                },
-                close(socket) {
-                    sockets.delete(socket)
-                    const carried = socket.data
-                    if (carried === undefined) return
-                    // A socket a reload terminated is the old worker's, and the new one never knew it.
-                    if (muxed.delete(carried.connection))
-                        worker?.postMessage({
-                            kind: 'socket-close',
-                            connection: carried.connection,
-                        })
-                },
-                // The reload client says nothing; an app socket's frames go to the mux in the worker.
-                message(socket, text) {
-                    const carried = socket.data
-                    if (carried === undefined) return
+            close(socket) {
+                sockets.delete(socket)
+                const carried = socket.data
+                if (carried === undefined) return
+                // A socket a reload terminated is the old worker's, and the new one never knew it.
+                if (muxed.delete(carried.connection))
                     worker?.postMessage({
-                        kind: 'socket-message',
+                        kind: 'socket-close',
                         connection: carried.connection,
-                        text: String(text),
                     })
-                },
             },
-        })
+            // The reload client says nothing; an app socket's frames go to the mux in the worker.
+            message(socket, text) {
+                const carried = socket.data
+                if (carried === undefined) return
+                worker?.postMessage({
+                    kind: 'socket-message',
+                    connection: carried.connection,
+                    text: String(text),
+                })
+            },
+        },
+    })
+    const listen = (port: number | undefined) =>
+        Bun.serve<Carried>(serving(port))
 
     // 38.64 — A PORT SOMEONE NAMED IS THE PORT, and one taken is the failure. `Bun.serve` given
     // none reads `PORT` itself.
-    const server =
+    served =
         options.port !== undefined || process.env.PORT
             ? listen(options.port)
             : listenOnFirstFree(listen)
-    return server as unknown as Bun.Server<undefined>
+    return served as unknown as Bun.Server<undefined>
 }
 
 // 38.63 — NAMED BY NOBODY, the first free port from 3000. A port taken is the next one tried, and

package/src/server/surfaceOf.ts

@@ -15,6 +15,8 @@ export type Listed = {
     description: string | undefined
     /** Its args' JSON Schema, where it has one. 19.9, 20.11. */
     schema: unknown
+    /** What it answers, as JSON Schema, where its type says. 19.21. */
+    result: unknown
 }
 
 /**
@@ -47,6 +49,7 @@ export function surfaceOf(
         description:
             live === undefined ? mount.description : live.handler.description,
         schema: live === undefined ? mount.args : live.argsDocument,
+        result: mount.result,
     }
 }
 

package/src/server/testMount.ts

@@ -0,0 +1,53 @@
+// 38.119 — `mount` from `@abide/abide/test`: a component an app's test imported and bound, rendered
+// into the document's body as the server writes it and hydrated there by its browser module — the
+// same two halves a page load runs, in one process, so a test can click it and read the work.
+
+import { flushSync } from '#shared/reactive/Reactive.ts'
+import { MOUNTABLE } from './MOUNTABLE.ts'
+import { type Component, render } from './render.ts'
+
+type Mountable = {
+    accessors: Record<string, () => unknown>
+    client: () => Promise<{
+        default: (
+            region: unknown,
+            props: Record<string, () => unknown>,
+        ) => { stop(): void } | undefined
+    }>
+}
+
+/** A mounted component: `stop` ends every watch its hydration opened. */
+export type Mounted = { stop(): void; [Symbol.dispose](): void }
+
+/**
+ * Renders `component` into `document.body` and hydrates it there, with every effect its mount woke
+ * already run.
+ */
+export async function mount(component: Component): Promise<Mounted> {
+    const mountable = (component as Record<symbol, Mountable | undefined>)[
+        MOUNTABLE
+    ]
+    if (mountable === undefined)
+        throw new Error(
+            'abide: mount takes a component a test imported from a `.abide` and bound — `mount(Counter({ start: 2 }))`. RULEBOOK 38.119.',
+        )
+    if (typeof document === 'undefined')
+        throw new Error(
+            'abide: mount renders into a DOM, and this process has none. Preload `@abide/harness/preload` ahead of `@abide/abide/test` in bunfig.toml. RULEBOOK 38.119.',
+        )
+    const html = new TextDecoder().decode(await render(component))
+    // After the `<body …>` open tag, whatever attributes the component wrote onto it (35.15).
+    document.body.innerHTML = html.slice(
+        html.indexOf('>', html.indexOf('<body')) + 1,
+        html.indexOf('</body>'),
+    )
+    // LOADED HERE, not at the top: the preload this module is part of runs in processes with no DOM.
+    const [{ default: hydrate }, { pageRegion }] = await Promise.all([
+        mountable.client(),
+        import('#ui/regions.ts'),
+    ])
+    const scope = hydrate(pageRegion(document.body), mountable.accessors)
+    flushSync()
+    const stop = (): void => scope?.stop()
+    return { stop, [Symbol.dispose]: stop }
+}

package/src/shared/ADDRESSES.ts

@@ -35,7 +35,7 @@ export const OPENAPI_ADDRESS = `${ABIDE_ADDRESS}/openapi.json`
 export const MCP_ADDRESS = `${ABIDE_ADDRESS}/mcp`
 /** The health check. */
 export const HEALTH_ADDRESS = `${ABIDE_ADDRESS}/health`
-/** Where a visitor's Claude Code bridge pairs, and is relayed turns (45.13). */
+/** Where a visitor's Claude Code bridge pairs, and is relayed turns (44.13). */
 export const BRIDGE_ADDRESS = `${ABIDE_ADDRESS}/bridge`
 
 /**

package/src/shared/ERROR_META.ts

@@ -0,0 +1,3 @@
+// 35.18 — the meta an error page's document carries, so the browser does not hydrate the page its
+// address names over markup an error page painted.
+export const ERROR_META = 'abide-error'

package/src/shared/Schema.ts

@@ -161,7 +161,7 @@ function runSchemaTracked(schema: unknown, value: unknown): Checked {
         // rather than returning it. A real `Schema<boolean>` only ever sees booleans.
         if (typeof returned === 'boolean' && typeof value !== 'boolean')
             throw new Error(
-                'A predicate is not a Schema: it answered true/false where the value was expected. A Schema returns what it accepts (RULEBOOK 19.2) and throws what it refuses (19.4).',
+                'A predicate is not a Schema: it answered true/false where the value was expected. A Schema returns what it accepts (RULEBOOK 19.2) and throws what it refuses (RULEBOOK 19.4).',
             )
         return accepted(returned)
     }

package/src/shared/WORK.ts

@@ -1,14 +1,11 @@
 /**
  * The three work counters the measurement lane reads, and the record they are published on.
  *
- * A leaf — no imports of its own — because both seams increment it and `harness/measure` reads it
- * off `globalThis` rather than importing it: that lane may have no abide in its graph at all
- * (44.1), so the two halves cannot share a declaration and the key is spelled on both sides.
- *
- * WHY ALL THREE OR NONE. `armCase()` zeroes every field it reads, so a field abide declares and
- * never increments is created at 0 and read back at 0 — and every gate asserting it passes
- * against a counter that was never wired (44.21). Publishing two of three is worse than
- * publishing none, because the third looks measured.
+ * A leaf — no imports of its own — because both seams increment it and `@abide/harness/measure`
+ * reads it off `globalThis` rather than importing it: that lane may have nothing under test in its
+ * graph at all (43.1), so the two halves cannot share a declaration and the key is spelled on both
+ * sides. `@abide/harness/abide`'s `measure` reads it back by these field names, and throws naming
+ * one the record lacks (43.20).
  *
  * WHAT IT COSTS is one integer increment on the propagation walk and one per effect run, and it
  * is UNDER THE NOISE FLOOR rather than priced: two runs of `bun run bench:reactive` put the
@@ -31,7 +28,12 @@ export const WORK = {
     descents: 0,
 }
 
-// The name is spelled here and again in `harness/measure`'s own leaf. Two copies on purpose: the
-// lane checks the SHAPE at the read rather than sharing a type, so a rename breaks a test rather
-// than silently publishing to a key nothing looks at.
-;(globalThis as unknown as Record<string, unknown>).__ABIDE_WORK__ = WORK
+// The key is spelled here and again in the harness's own leaf. Two copies on purpose: the lane
+// checks the SHAPE at the read rather than sharing a type, so a rename breaks a test rather than
+// silently publishing to a key nothing looks at.
+type HarnessGlobal = {
+    __HARNESS_WORK__?: Record<string, Record<string, number>>
+}
+const published = (globalThis as HarnessGlobal).__HARNESS_WORK__ ?? {}
+published.abide = WORK
+;(globalThis as HarnessGlobal).__HARNESS_WORK__ = published

package/src/shared/applyPatch.ts

@@ -1,6 +1,6 @@
 // 18.11 — WHAT A PATCH WROTE, WRITTEN AGAIN HERE: a JSON Patch (RFC 6902) applied in order, each op's
 // `path` a JSON Pointer (RFC 6901). Called inside the value's own `s.patch`, so the rows it reaches are
-// the rows 32.33 remakes. A browser replays the server's writes.
+// the rows 32.33 updates. A browser replays the server's writes.
 //
 // A pointer walks own properties alone, and an array step is an index or, for `add`, `-`. Every op a
 // patch records passes, so the check costs a browser replaying its server nothing, and an op naming

package/src/shared/boundValue.ts

@@ -56,3 +56,84 @@ export function boundProp(hold: () => unknown): (held?: true) => unknown {
 export function groupHolds(group: unknown, value: unknown): boolean {
     return Array.isArray(group) ? group.includes(value) : group === value
 }
+
+/**
+ * Whether a `<select>`'s bound value selects an option: it is the option's value, or a list
+ * holding it.
+ *
+ * 32.61, 32.62 — compared as TEXT, unlike `groupHolds`: a select's value is written to the
+ * property as its text, so a number selects the option whose value spells it.
+ */
+export function selectHolds(value: unknown, option: string): boolean {
+    if (!Array.isArray(value))
+        return value !== undefined && value !== null && String(value) === option
+    for (const member of value) if (String(member) === option) return true
+    return false
+}
+
+// An `<option` open tag: the name, then attributes up to the `>` that ends it, a quoted value
+// carrying any `>` it holds.
+const OPTION_TAG = /<option(?=[\s>])((?:[^>"']|"[^"]*"|'[^']*')*)>/gi
+const VALUE_ATTRIBUTE = /\svalue\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'>]+))/i
+// What ends an option's text where it has no `value`: the next tag that is not a comment.
+const OPTION_TEXT_END = /<(?!!--)/
+const COMMENT = /<!--[\s\S]*?-->/g
+const REFERENCE = /&(?:#(\d+)|#x([\da-f]+)|(amp|lt|gt|quot|apos));/gi
+const NAMED: Record<string, string> = {
+    amp: '&',
+    lt: '<',
+    gt: '>',
+    quot: '"',
+    apos: "'",
+}
+
+/**
+ * A `<select>`'s rendered options with `selected` written on each its bound value selects.
+ *
+ * 32.61 — THE SERVER'S HALF OF THE PROPERTY: a select's value is no attribute of its own, so the
+ * painted page carries it on the options. Read off the markup rather than the template, because an
+ * option may come from a `{#for}`, an arm or a component, and every one of them has rendered by
+ * now. A single select marks the first match, which is the one assigning `value` selects.
+ */
+export function selectedMarkup(markup: string, value: unknown): string {
+    if (value === undefined || value === null) return markup
+    const multiple = Array.isArray(value)
+    let out = ''
+    let cut = 0
+    let marked = false
+    for (const match of markup.matchAll(OPTION_TAG)) {
+        if (marked && !multiple) break
+        const end = (match.index as number) + match[0].length
+        const named = VALUE_ATTRIBUTE.exec(match[1] as string)
+        let text: string
+        if (named !== null)
+            text = decoded(named[1] ?? named[2] ?? named[3] ?? '')
+        else {
+            // The option's text, as the browser reads `value` from it: comments out,
+            // whitespace collapsed.
+            const rest = markup.slice(end)
+            const stop = rest.search(OPTION_TEXT_END)
+            text = decoded(
+                (stop === -1 ? rest : rest.slice(0, stop)).replace(COMMENT, ''),
+            )
+                .replace(/\s+/g, ' ')
+                .trim()
+        }
+        if (!selectHolds(value, text)) continue
+        out += `${markup.slice(cut, end - 1)} selected>`
+        cut = end
+        marked = true
+    }
+    return cut === 0 ? markup : out + markup.slice(cut)
+}
+
+function decoded(text: string): string {
+    if (!text.includes('&')) return text
+    return text.replace(REFERENCE, (whole, decimal, hex, name) =>
+        decimal !== undefined
+            ? String.fromCodePoint(Number(decimal))
+            : hex !== undefined
+              ? String.fromCodePoint(Number.parseInt(hex, 16))
+              : (NAMED[(name as string).toLowerCase()] ?? whole),
+    )
+}

package/src/shared/index.ts

@@ -15,7 +15,12 @@ export type { Attributes } from './Attributes.ts'
 // 32.37 — what a value writes into an attribute, on both sides.
 export { attributeMarkup, attributeText } from './attributeText.ts'
 // EMITTED CODE'S: the value a `bind:` operand holds, as the server writes it into the tag (32.5).
-export { boundProp, boundValue, groupHolds } from './boundValue.ts'
+export {
+    boundProp,
+    boundValue,
+    groupHolds,
+    selectedMarkup,
+} from './boundValue.ts'
 export { type Cookies, cookies } from './cookies.ts'
 export { csp } from './csp.ts'
 export {
@@ -43,7 +48,6 @@ export {
     type MenuRole,
     menuItem,
 } from './menuItem.ts'
-export { onMenu } from './onMenu.ts'
 // `navigate` ALONE, of everything routing needs. This barrel is what an app resolves through the
 // bare `@abide/abide` specifier, and the matcher, the pattern grammar and `routeOf` are reached by path
 // from the two places that have them — the build and the client router. Putting them here would
@@ -51,6 +55,7 @@ export { onMenu } from './onMenu.ts'
 // modules into the static closure of the entry every page imports.
 export { navigate } from './navigate.ts'
 export { online } from './online.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).
 export {

package/src/shared/jsonSchema.ts

@@ -14,8 +14,17 @@ import { validateJson } from './validateJson.ts'
  * `validateJson`'s own, split at the dots `runSchema` joins it back at. And the document is
  * exposed where a Standard Schema exposes its JSON Schema, so 20.11's one probe publishes it with
  * no case of its own.
+ *
+ * 19.23 — WITH NO TYPE ARGUMENT IT IS `Untyped`, whose `validate` answers `any`: assignable to every
+ * slot, and a source the checker draws NO candidate from. A document says nothing the checker can
+ * read, so the value's type has to come from what the schema gates. Typed `StandardSchemaV1<never>`
+ * instead, `never` was a candidate nested inside the schema, and a candidate that is not top level
+ * stops a literal widening: `reactive(0, { schema })` was `Reactive<0>`. Typed
+ * `StandardSchemaV1<any>`, `any` was a candidate and every gated value became `any`.
  */
-export function jsonSchema<T>(document: JsonValue): StandardSchemaV1<T> {
+export function jsonSchema<T = Untyped>(
+    document: JsonValue,
+): [T] extends [Untyped] ? UntypedSchema : StandardSchemaV1<T> {
     return {
         '~standard': {
             version: 1,
@@ -46,5 +55,19 @@ export function jsonSchema<T>(document: JsonValue): StandardSchemaV1<T> {
                 output: () => document,
             },
         },
-    } as StandardSchemaV1<T>
+    } as [T] extends [Untyped] ? UntypedSchema : StandardSchemaV1<T>
+}
+
+declare const UNTYPED: unique symbol
+
+/** The type argument a bare `jsonSchema` takes: no output was named. */
+type Untyped = typeof UNTYPED
+
+/** A Standard Schema whose output is whatever the slot it gates says (19.23). */
+type UntypedSchema = {
+    readonly '~standard': {
+        readonly version: 1
+        readonly vendor: string
+        readonly validate: (value: unknown) => any
+    }
 }

package/src/shared/log.ts

@@ -144,6 +144,14 @@ function currentGate(): Gate {
     return gate
 }
 
+/**
+ * Whether `DEBUG` could enable any namespace at all: with no inclusion nothing passes, so a gated
+ * line returns before its namespace is built (28.12 still reads it on every line that can write).
+ */
+function anyEnabled(): boolean {
+    return currentGate().include.length !== 0
+}
+
 /** Whether `DEBUG` enables a namespace's gated lines (28.6). */
 function isEnabled(namespace: string): boolean {
     const { include, exclude } = currentGate()
@@ -247,10 +255,12 @@ function loggerOver(namespaceOf: () => string): Logger {
         write(namespaceOf(), 'info', args)
     }) as Logger
     logger.info = (...args) => {
+        if (!anyEnabled()) return
         const namespace = namespaceOf()
         if (isEnabled(namespace)) write(namespace, 'info', args)
     }
     logger.debug = (...args) => {
+        if (!anyEnabled()) return
         const namespace = namespaceOf()
         if (isEnabled(namespace)) write(namespace, 'debug', args)
     }
@@ -259,7 +269,7 @@ function loggerOver(namespaceOf: () => string): Logger {
     // 28.4 — another segment, below this one. 28.12 — asked per line too, so a logger named at module
     // load, before the app's name resolved, writes under the name once it has.
     logger.named = (name) => loggerOver(() => `${namespaceOf()}:${name}`)
-    logger.enabled = () => isEnabled(namespaceOf())
+    logger.enabled = () => anyEnabled() && isEnabled(namespaceOf())
     Object.defineProperty(logger, 'records', { get: recordsValue })
     return logger
 }

package/src/shared/reactive/Keyed.ts

@@ -107,7 +107,7 @@ type Follower = {
  * RECENCY IS THE ORDER OF A MAP. A production moves its key to the end by deleting and re-setting
  * it, so the oldest entry is always the first one and 11.48's "armed at the oldest" is one
  * iterator step rather than a scan — and the sweep stops at the first entry still inside its
- * life, the way `dropExpired` stops at the first live production.
+ * life.
  *
  * THE PRODUCTION IS HEARD BY A MIRROR ON EACH ENTRY, which is what the refusal that stood here
  * said could not be had without a hook on every cell in the design. A mirror is a reader, so only
@@ -117,6 +117,13 @@ type Follower = {
  * those apart: every one of them leaves nothing to serve, where a production always leaves
  * something.
  */
+function end(follower: Follower): void {
+    follower.reader.alive = false
+    dropReader(follower.cell, follower.reader)
+    detachProbes(follower.reader)
+    follower.evict()
+}
+
 class Lifetime {
     ms: number
     followed: Map<string, Follower>
@@ -178,13 +185,30 @@ class Lifetime {
             // 11.69 — PARKED, NOT EVICTED: a call reaching it joins the load, and the load's end
             // touches it back into the order.
             if (follower.cell.loading) continue
-            follower.reader.alive = false
-            dropReader(follower.cell, follower.reader)
-            detachProbes(follower.reader)
-            follower.evict()
+            end(follower)
         }
         this.arm()
     }
+
+    /**
+     * Evicts `key`'s entry where its life has run out and no load holds it, and says whether it did.
+     *
+     * THE REACH'S HALF of the sweep, as 6.5 is the read's half of 6.3: a timer that has not fired
+     * yet — a `ttl` of 0 is past as the entry produces — leaves an entry a reach would otherwise
+     * join. 16.7's mutation called twice in one turn is the case: the second call is a second write.
+     */
+    outlived(key: string): boolean {
+        const follower = this.followed.get(key)
+        if (
+            follower === undefined ||
+            follower.cell.loading ||
+            Date.now() - follower.at < this.ms
+        )
+            return false
+        this.followed.delete(key)
+        end(follower)
+        return true
+    }
 }
 
 /**
@@ -354,7 +378,7 @@ export function createKeyed<
     function reach(given: Args): Reactive<Stored, Accepted, Failures> {
         const args = normalized(self, given)
         const key = canonicalKey(args)
-        const standing = entries.get(key)
+        const standing = lifetime?.outlived(key) ? undefined : entries.get(key)
         // 1.8: reaching an instance that exists joins the standing work — 15.19, unless that work
         // failed transiently, which this reach runs again.
         if (standing !== undefined) {

package/src/shared/reactive/PATCHES.ts

@@ -2,7 +2,7 @@
  * Which objects an `s.patch` wrote to, and when.
  *
  * 32.33. `epoch` moves once per patch and `written` holds the epoch an object was last written at,
- * so a row made at epoch `e` is stale exactly where its item's entry is past `e`. A leaf, because
+ * so a row that took its item at epoch `e` is stale exactly where its item's entry is past `e`. A leaf, because
  * `reconcile` reads it from the `@abide/abide/runtime` barrel.
  */
 export const PATCHES: { epoch: number; written: WeakMap<object, number> } = {