@abide/abide 0.100.0 → 0.101.0

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @abide/abide
 
+## 0.101.0
+
+### Minor Changes
+
+- 128f192: Breaking: an rpc export named as its file answers at the file's path ([`9758128`](https://github.com/briancray/abide/commit/97581285b14d6d01688c963a4332729f6af30d3a))
+
+### Patch Changes
+
+- 128f192: the executable carries the app as bytecode ([`4a72909`](https://github.com/briancray/abide/commit/4a729091955a28df259005b79109ee2e00593046))
+- 128f192: followers are filed by entry key, and an SSE event is read off its frame ([`7a137e7`](https://github.com/briancray/abide/commit/7a137e7224daf334c90539c75bb4f7ff25701dc8))
+- 128f192: a request's signal aborts when its caller hangs up or its worker is replaced ([`7a57131`](https://github.com/briancray/abide/commit/7a571311b08e2c4d3b14c244395bc7cc29fad4d7))
+- 128f192: a page loads only the framework modules it uses
+- 128f192: disposed readers are counted rather than found, and the probe edge is cursored ([`ef1bafe`](https://github.com/briancray/abide/commit/ef1bafec810f06bea37a88c51713ac2b92e212e7))
+- 128f192: answers of 64 KB or more are compressed off the event loop ([`f484e0d`](https://github.com/briancray/abide/commit/f484e0d140321d9cf2a171cb52dec0b0a3b2c227))
+
 ## 0.100.0
 
 ### Minor Changes

package/bin/abide.ts

@@ -322,6 +322,11 @@ async function compileExecutable(
         // whoever operates it — a minified line prints as the whole page module it sits in. The
         // map is embedded in the executable, which reads it from there.
         sourcemap: 'inline',
+        // 38.94 — parsed at build time rather than on every boot. ESM because the entry awaits at
+        // its top level, and bun's bytecode default is CommonJS, which refuses that. Nothing in the
+        // executable or the build's outputs says bytecode is inside, so no test can see this.
+        bytecode: true,
+        format: 'esm',
         compile: {
             ...(platform === undefined
                 ? {}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@abide/abide",
-    "version": "0.100.0",
+    "version": "0.101.0",
     "type": "module",
     "description": "Isomorphic type-safe framework for reactive async interfaces for humans and machines",
     "license": "MIT",
@@ -53,6 +53,11 @@
         "#compiler": "./src/compiler/index.ts",
         "#compiler/*": "./src/compiler/*"
     },
+    "sideEffects": [
+        "./src/server/**",
+        "./src/shared/WORK.ts",
+        "./src/shared/reactive/Reactive.ts"
+    ],
     "dependencies": {
         "typescript": "^7.0.2"
     },

package/src/compiler/handlersUnder.ts

@@ -1,6 +1,6 @@
 // 16.2 AND 19.1 — EVERY HANDLER AN APP DECLARES, AND WHERE IT IS ANSWERED. A handler is an export of
 // a module under `server/rpc`, and its address is the module's path below that directory and then
-// the export's name — `default` answering at the path alone.
+// the export's name — `default`, or an export named as its file, answering at the path alone.
 //
 // READ, NOT RUN. The build finds handlers by what their modules SAY rather than by importing them,
 // so a build never runs server code: an app's module may open a database at import, and nothing
@@ -82,7 +82,10 @@ export async function handlersUnder(
                 throw new Error(
                     `abide: ${source} exports \`${exported}\`, which is not declared as a handler. A module under ${HANDLER_DIRECTORY} exports handlers alone, each declared by abide's \`GET(…)\` (or POST, PUT, PATCH, DELETE); anything else belongs beside it. RULEBOOK 19.15.`,
                 )
-            const address = `${RPC_ADDRESS}/${path}${exported === 'default' ? '' : `/${exported}`}`
+            const atPath =
+                exported === 'default' ||
+                exported === path.slice(path.lastIndexOf('/') + 1)
+            const address = `${RPC_ADDRESS}/${path}${atPath ? '' : `/${exported}`}`
             const owner = owners.get(address)
             if (owner !== undefined)
                 throw new Error(

package/src/server/answerRpc.ts

@@ -243,24 +243,36 @@ export async function answerRpc(
     const caller = head ? undefined : callerOf()
     const seeded =
         caller === undefined ? undefined : takeSeed(caller, handler, args)
+    // The entry key of a `global` value, taken once for every read of it below.
+    const global = GLOBAL_GETS.get(handler)
+    const key = global?.key(args)
     // 21.15 — A `global` PRODUCTION ALREADY HELD, and not loading, answers without a run: a run
     // this call started moves the generation, and one it joined was loading when it came.
     const held =
-        seeded === undefined ? GLOBAL_GETS.get(handler)?.(args) : undefined
+        seeded === undefined && key !== undefined ? global?.at(key) : undefined
     const heldAt = held === undefined ? undefined : heldGenerationOf(held)
     const timing = currentRequestScope()?.timing
     if (timing !== undefined) timing.answering = handler
     const started = performance.now()
     const outcome =
         seeded === undefined ? await outcomeOf(handler(args)) : await seeded
+    // The entry as the run left it, which the answer reads too.
+    const entry = key === undefined ? undefined : global?.at(key)
     const cached =
         heldAt !== undefined &&
-        GLOBAL_GETS.get(handler)?.(args) === held &&
+        entry === held &&
         heldGenerationOf(held) === heldAt
     // 16.38 — A MUTATION A DOCUMENT MADE — a form posted with no script — is answered as a navigation.
     if (!inUrl && prefers(request, 'text/html', 'application/json'))
         return navigated(outcome, request, pathname, pages)
-    const answer = await answerOutcome(outcome, request, found, args)
+    const answer = await answerOutcome(
+        outcome,
+        request,
+        found,
+        args,
+        key,
+        entry,
+    )
     // A `Response` the handler built is its own — but the origin answer below is laid over it, so it
     // varies on `Origin` too (21.7), which `handlerHeaders` never reached.
     if (outcome.settled && outcome.value instanceof Response) {
@@ -308,23 +320,24 @@ async function answerOutcome(
     request: Request,
     found: Mounted,
     args: unknown,
+    key: string | undefined,
+    entry: unknown,
 ): Promise<Response> {
     const handler = found.handler
     if (!outcome.settled) return answered(failureOf(outcome.error))
+    const value = outcome.value
     // The `global` value the answer came from, or `undefined` for one built per request. 18.22 — or
     // for one whose production has moved past what is answered: a seeded answer is what the render
     // reached (41.13). 18.23 — or for a binary.
-    const global = GLOBAL_GETS.get(handler)?.(args)
-    const value = outcome.value
     const serving =
-        global !== undefined &&
+        entry !== undefined &&
         !(
             value instanceof Blob ||
             value instanceof ArrayBuffer ||
             ArrayBuffer.isView(value)
         ) &&
-        (streams(value) || (global as { peek(): unknown }).peek() === value)
-            ? global
+        (streams(value) || (entry as { peek(): unknown }).peek() === value)
+            ? entry
             : undefined
     // 21.3 — what the handler wrote through `response` is laid over it at the exit (21.10).
     const headers = handlerHeaders()
@@ -337,7 +350,7 @@ async function answerOutcome(
     const etag = serving !== undefined ? `"${versionOf(serving)}"` : undefined
     if (etag !== undefined) {
         headers.set(VERSION_HEADER, etag)
-        RPC_SERVER.served?.(handler, serving)
+        RPC_SERVER.served?.(handler, serving, key as string)
     }
     // 21.8, 21.9, 21.11 — WHAT IS LEFT OF THE LIFE OF THE PRODUCTION ANSWERED, in place of `no-store`
     // and nothing else. A `ttl` of Infinity is bounded by `invalidate` alone (11.35), which no cache

package/src/server/answerSocket.ts

@@ -54,19 +54,30 @@ type Follower = {
     peer: Peer
     id: number
     args: unknown
+    // The entry key its args are filed under (`GLOBAL_GETS`), taken once as it subscribes.
+    key: string
     // The `global` entry its productions are pushed from, which is what a refresh would otherwise
     // re-fetch — or `undefined`, and it is sent triggers instead.
     serving: unknown
     stopFeed: (() => void) | undefined
     // 18.6 — the version it was last sent, or named on subscribing.
     sent: number | undefined
-    // 13.15 — the literal `tags` the build copied onto the browser's copy, for a sweep to match.
-    tags: string[] | undefined
     // 18.8 — whether the handler's rungs let it through when it opened: a guarded `GET` feeds only
     // a follower they admitted, and sends the rest its triggers alone.
     admitted: boolean
 }
-const FOLLOWERS = new Map<object, Set<Follower>>()
+type Followed = {
+    // 13.15 — the literal `tags` the build copied onto the browser's copy, for a sweep to match:
+    // the handler's, so one for all of its followers.
+    tags: string[] | undefined
+    // What a trigger walks, matching each follower's args against its pattern.
+    all: Set<Follower>
+    // BY ENTRY KEY, so an entry answered walks the followers of its own args alone (18.8). Filed
+    // apart from `all` rather than instead of it: a walk of every follower through a set per key
+    // measured twice a flat set's.
+    byKey: Map<string, Set<Follower>>
+}
+const FOLLOWERS = new Map<object, Followed>()
 
 // 13.12 — narrowed by the pattern the trigger was handed, as the handler's own entries are.
 export function broadcast(
@@ -74,9 +85,9 @@ export function broadcast(
     member: 'invalidate' | 'refresh',
     pattern: unknown,
 ): void {
-    const followers = FOLLOWERS.get(rpc)
-    if (followers === undefined) return
-    for (const follower of followers) {
+    const followed = FOLLOWERS.get(rpc)
+    if (followed === undefined) return
+    for (const follower of followed.all) {
         if (!matchesPattern(follower.args, pattern)) continue
         // A fed copy is refreshed by the production the reload mints (7.18), and invalidated through
         // the cell it is fed from (`FOLLOWED`), whichever trigger reached it — where the entry it is
@@ -93,13 +104,14 @@ export function swept(
     member: 'invalidate' | 'refresh',
     tags: string[] | null,
 ): void {
-    for (const [rpc, followers] of FOLLOWERS)
-        for (const follower of followers) {
-            if (tags !== null && !sharesTag(follower.tags, tags)) continue
+    for (const [rpc, followed] of FOLLOWERS) {
+        if (tags !== null && !sharesTag(followed.tags, tags)) continue
+        for (const follower of followed.all) {
             if (attach(rpc as Mounted['handler'], follower) !== undefined)
                 continue
             send(follower.peer, { op: member, id: follower.id })
         }
+    }
 }
 
 function sharesTag(held: string[] | undefined, swept: string[]): boolean {
@@ -110,10 +122,14 @@ function sharesTag(held: string[] | undefined, swept: string[]): boolean {
 
 // 18.8 — AN ENTRY ANSWERED THAT NOBODY IS FED FROM: one made after a follower subscribed for its
 // args, or rebuilt after the one it was fed from was evicted. An entry already fed is the common
-// answer, and asks nothing more.
-export function feedFromServed(rpc: object, serving: unknown): void {
+// answer, and asks nothing more; one that is not reaches the followers filed under its key.
+export function feedFromServed(
+    rpc: object,
+    serving: unknown,
+    key: string,
+): void {
     if (FEEDS.has(serving as object)) return
-    const followers = FOLLOWERS.get(rpc)
+    const followers = FOLLOWERS.get(rpc)?.byKey.get(key)
     if (followers === undefined) return
     for (const follower of followers)
         attach(rpc as Mounted['handler'], follower)
@@ -128,7 +144,7 @@ function attach(rpc: Mounted['handler'], follower: Follower): unknown {
     const serving =
         rpc.guarded && !follower.admitted
             ? undefined
-            : GLOBAL_GETS.get(rpc)?.(follower.args)
+            : GLOBAL_GETS.get(rpc)?.at(follower.key)
     if (serving === follower.serving) return serving
     follower.stopFeed?.()
     // A version is one entry's count, so what it was sent of another says nothing about this one.
@@ -331,26 +347,42 @@ function followWith(
     admitted: boolean,
 ): () => void {
     const rpc = mounted.handler
+    const key = GLOBAL_GETS.get(rpc)?.key(args) ?? ''
     const follower: Follower = {
         peer,
         id,
         args,
+        key,
         serving: undefined,
         stopFeed: undefined,
         sent: held,
-        tags: mounted.copy?.tags,
         admitted,
     }
     attach(rpc, follower)
-    let followers = FOLLOWERS.get(rpc)
+    let followed = FOLLOWERS.get(rpc)
+    if (followed === undefined) {
+        followed = {
+            tags: mounted.copy?.tags,
+            all: new Set(),
+            byKey: new Map(),
+        }
+        FOLLOWERS.set(rpc, followed)
+    }
+    const byKey = followed.byKey
+    let followers = byKey.get(key)
     if (followers === undefined) {
         followers = new Set()
-        FOLLOWERS.set(rpc, followers)
+        byKey.set(key, followers)
     }
     followers.add(follower)
+    const all = followed.all
+    all.add(follower)
     return () => {
         follower.stopFeed?.()
-        followers.delete(follower)
+        all.delete(follower)
+        // A key nobody follows leaves, or the index grows with every key ever followed.
+        if (followers.delete(follower) && followers.size === 0)
+            byKey.delete(key)
     }
 }
 
@@ -410,19 +442,35 @@ export function followAsEvents(
     })
 }
 
-/** One mux frame as the SSE event it is: `event`, `id` where it names a version, and `data`. */
+/**
+ * One mux frame as the SSE event it is: `event`, `id` where it names a version, and `data`.
+ *
+ * 18.6 — READ OFF THE FRAME'S HEAD, never parsed: the body was serialized once for every follower
+ * (`sendAll`), and a parse and a stringify per event stream would pay it again per follower. Every
+ * frame this module writes is `{"op":…,"id":…`, numbers named `base` or `version`, and at most one
+ * body last — so the body is the rest of the text, as it was written.
+ */
 function eventOf(text: string): string {
-    const frame = JSON.parse(text) as ServerFrame
-    const data =
-        frame.op === 'value'
-            ? JSON.stringify(frame.value ?? null)
-            : frame.op === 'patch'
-              ? JSON.stringify(frame.ops ?? [])
-              : frame.op === 'error'
-                ? JSON.stringify(frame.error ?? null)
-                : ''
-    const id = frame.version === undefined ? '' : `id: ${frame.version}\n`
-    return `event: ${frame.op}\n${id}data: ${data}\n\n`
+    const opEnd = text.indexOf('"', 7)
+    const op = text.slice(7, opEnd)
+    let id = ''
+    let data =
+        op === 'value' || op === 'error' ? 'null' : op === 'patch' ? '[]' : ''
+    // Past `,"id":` — a number, so the next comma is the next member's.
+    let at = text.indexOf(',', opEnd + 6)
+    while (at !== -1) {
+        const nameEnd = text.indexOf('"', at + 2)
+        const name = text.slice(at + 2, nameEnd)
+        const from = nameEnd + 2
+        if (name !== 'base' && name !== 'version') {
+            data = text.slice(from, -1)
+            break
+        }
+        at = text.indexOf(',', from)
+        if (name === 'version')
+            id = `id: ${text.slice(from, at === -1 ? -1 : at)}\n`
+    }
+    return `event: ${op}\n${id}data: ${data}\n\n`
 }
 
 // 18.6 — ONE WATCH PER VALUE SERVED, however many follow it, and each frame's body serialized once

package/src/server/compressAnswer.ts

@@ -7,7 +7,9 @@
 // `accept-encoding` in `vary` through `DOCUMENT_HEADERS`, which its `HEAD` and error answers carry as
 // well; a JSON answer names it here. Both say their length: `abide dev` relays a body chunk by chunk
 // from its worker (38.36), and a relayed body with no declared length goes out chunked.
-import { brotliCompressSync, constants } from 'node:zlib' // bun has gzip and zstd of its own, and no brotli
+// BUN'S GZIP parts from zlib's past ~130 KB, which only the off-loop lane reaches — so that lane takes
+// zlib's, the loop keeps bun's, and the two make the same bytes.
+import { brotliCompress, brotliCompressSync, constants, gzip } from 'node:zlib' // bun has no brotli, and no compression off the loop
 import {
     ENCODINGS,
     type Encoding,
@@ -17,13 +19,18 @@ import {
 // QUALITY 5, NOT 11. This runs per request, and the top brotli level is priced for a build that
 // runs once: on an 18 KB docs page 11 took 15,800 µs against 5's 150, for 15% fewer bytes. 5 is
 // already under gzip's size at twice gzip's 70 µs.
-const QUALITY = 5
+const BROTLI_OPTIONS = { params: { [constants.BROTLI_PARAM_QUALITY]: 5 } }
 
 // 38.69 — the bytes under which a JSON answer goes out as it is. Under it an answer saves tens of
 // bytes that leave in the same packet anyway, for 3–8 µs of a ~57 µs request; at 8 KB the same CPU
 // saves seven kilobytes.
 const COMPRESSION_FLOOR = 1024
 
+// 38.96 — the bytes from which an answer is compressed off the event loop. Brotli 5 holds the loop
+// ~360 µs at 64 KB and ~7 ms at 700 KB — every other request and socket waits that long — where
+// the thread pool's hop adds ~20 µs to the answer it carries: 6% at 64 KB, 27% at 16 KB.
+const OFF_LOOP_FLOOR = 64 * 1024
+
 const ENCODER = new TextEncoder()
 
 function compressed(
@@ -31,24 +38,48 @@ function compressed(
     encoding: Encoding,
 ): Uint8Array<ArrayBuffer> {
     return encoding === 'br'
-        ? (brotliCompressSync(bytes, {
-              params: { [constants.BROTLI_PARAM_QUALITY]: QUALITY },
-          }) as Uint8Array<ArrayBuffer>)
+        ? (brotliCompressSync(bytes, BROTLI_OPTIONS) as Uint8Array<ArrayBuffer>)
         : Bun.gzipSync(bytes)
 }
 
+function compressedOffLoop(
+    bytes: Uint8Array<ArrayBuffer>,
+    encoding: Encoding,
+): Promise<Uint8Array<ArrayBuffer>> {
+    return new Promise((resolve, reject) => {
+        const settle = (error: Error | null, result: Uint8Array): void => {
+            if (error === null) resolve(result as Uint8Array<ArrayBuffer>)
+            else reject(error)
+        }
+        if (encoding === 'br') brotliCompress(bytes, BROTLI_OPTIONS, settle)
+        else gzip(bytes, settle)
+    })
+}
+
+function answered(
+    body: Uint8Array<ArrayBuffer>,
+    encoding: Encoding | undefined,
+    headers: Headers,
+    status: number,
+): Response {
+    if (encoding !== undefined) headers.set('content-encoding', encoding)
+    headers.set('content-length', String(body.byteLength))
+    return new Response(body, { status, headers })
+}
+
 /**
  * `answer` as the `Response` to `request`, in the encoding the request takes where it takes one.
  *
  * THE LANE IS THE BODY'S TYPE: a built document arrives as its bytes, and a JSON value as its text,
- * encoded once here and floored by its length.
+ * encoded once here and floored by its length. A `Promise` only where the compression runs off the
+ * loop, so an answer under that floor costs no await.
  */
 export function compressAnswer(
     answer: Uint8Array<ArrayBuffer> | string,
     request: Request,
     headers: Headers,
     status: number,
-): Response {
+): Response | Promise<Response> {
     const json = typeof answer === 'string'
     const bytes = json ? ENCODER.encode(answer) : answer
     const encoding =
@@ -59,8 +90,11 @@ export function compressAnswer(
                   ENCODINGS,
               )
     if (json) headers.append('vary', 'accept-encoding')
-    const body = encoding === undefined ? bytes : compressed(bytes, encoding)
-    if (encoding !== undefined) headers.set('content-encoding', encoding)
-    headers.set('content-length', String(body.byteLength))
-    return new Response(body, { status, headers })
+    if (encoding === undefined)
+        return answered(bytes, encoding, headers, status)
+    if (bytes.byteLength >= OFF_LOOP_FLOOR)
+        return compressedOffLoop(bytes, encoding).then((body) =>
+            answered(body, encoding, headers, status),
+        )
+    return answered(compressed(bytes, encoding), encoding, headers, status)
 }

package/src/server/devWorker.ts

@@ -125,8 +125,27 @@ export type Ask = {
 function toListener(message: FromWorker): void {
     process.send?.(message)
 }
-// The listener gone — its process killed rather than ended — takes this one with it.
-process.on('disconnect', () => process.exit(0))
+// 38.97 — EACH REQUEST'S SIGNAL, by request id, until its answer ends: the listener holds the
+// connection, so a hang-up reaches this worker as a `cancel` rather than through bun.
+const HANG_UPS = new Map<number, AbortController>()
+
+/** Files away the hang-up of the request `id`, whose answer has ended, and hands it back. */
+function answered(id: number): AbortController | undefined {
+    const hangUp = HANG_UPS.get(id)
+    HANG_UPS.delete(id)
+    return hangUp
+}
+
+// EVERY REQUEST IN FLIGHT HANGS UP WITH THIS WORKER, as each would with `abide start`'s process: a
+// handler that spawned under `request().signal` takes its child down, where an exit alone left it
+// running under launchd. The listener ends this worker on every reload, and its own end — killed
+// rather than ended — is a disconnect.
+function hangUpAndExit(): void {
+    for (const hangUp of HANG_UPS.values()) hangUp.abort()
+    process.exit(0)
+}
+process.on('disconnect', hangUpAndExit)
+process.on('SIGTERM', hangUpAndExit)
 
 // THE COMPILE, AS SOMETHING TO WAIT ON. A request that arrives while the worker is still
 // compiling has to wait for the app rather than be told there is none: the listener forwards
@@ -159,6 +178,7 @@ async function receive(message: ToWorker): Promise<void> {
     if (message.kind === 'cancel') {
         const reading = bodies.get(message.id)
         bodies.delete(message.id)
+        answered(message.id)?.abort()
         return reading?.reader.cancel()
     }
     await opening
@@ -217,10 +237,13 @@ const BODILESS = new Set([101, 204, 205, 304])
  * they gave up.
  */
 async function answerAsk(ask: Ask): Promise<void> {
+    const hangUp = new AbortController()
+    HANG_UPS.set(ask.id, hangUp)
     const request = new Request(ask.url, {
         method: ask.method,
         headers: ask.headers,
         body: ask.body,
+        signal: hangUp.signal,
     })
     ASKS.set(request, ask.id)
     let response: Response
@@ -251,7 +274,10 @@ async function answerAsk(ask: Ask): Promise<void> {
             carried !== undefined && admitsMux(request, response, carried),
         whole,
     })
-    if (body === null || whole !== undefined) return
+    if (body === null || whole !== undefined) {
+        answered(ask.id)
+        return
+    }
     bodies.set(ask.id, {
         reader: body.getReader(),
         html: (response.headers.get('content-type') ?? '').startsWith(
@@ -274,6 +300,7 @@ async function pull(id: number): Promise<void> {
         const { done, value } = await reading.reader.read()
         if (done) {
             bodies.delete(id)
+            answered(id)
             toListener({ kind: 'end', id })
             return
         }
@@ -284,6 +311,7 @@ async function pull(id: number): Promise<void> {
         toListener({ kind: 'chunk', id, bytes })
     } catch (thrown) {
         bodies.delete(id)
+        answered(id)
         const why = describe(thrown)
         if (reading.html) {
             const shown = new TextEncoder().encode(failureMarkup(why))

package/src/server/serveDev.ts

@@ -200,8 +200,11 @@ export async function serveDev(
                 if (!child.killed && child.exitCode === null)
                     child.send(message)
             },
+            // 38.97 — SIGTERM, which the worker answers by hanging up what it is answering; a worker
+            // wedged in a loop never reads it, so a second later it is killed outright.
             terminate() {
                 child.kill()
+                setTimeout(() => child.kill('SIGKILL'), 1000).unref()
             },
         }
         worker = started
@@ -391,11 +394,14 @@ export async function serveDev(
         })
     }
 
-    // THE CHECKER GOES WITH THE COMMAND. It is a process of its own, and an app with no tsconfig
-    // holds a temporary project on disk for as long as it is open. The signal is raised again once
-    // it is closed, so the command still ends the way that signal ends a process.
+    // THE CHECKER AND THE WORKER GO WITH THE COMMAND. Each is a process of its own, and an app with
+    // no tsconfig holds a temporary project on disk for as long as the checker is open. The worker
+    // is told directly rather than left to its `disconnect`, which a worker busy inside a build
+    // reads only when the build lets go — orphaned until then. The signal is raised again once the
+    // checker is closed, so the command still ends the way that signal ends a process.
     for (const signal of ['SIGINT', 'SIGTERM'] as const)
         process.once(signal, () => {
+            worker?.terminate()
             void closeChecker().finally(() => process.kill(process.pid, signal))
         })
 

package/src/shared/GLOBAL_GETS.ts

@@ -1,7 +1,13 @@
 /**
  * Every `GET` declared over a `global` value, to the value it is serving for some args.
  *
- * 21.8, 18.5 — `undefined` where no entry holds the args. The answer reads its `max-age` off it
- * (`deadlineOf`) and its version (`versionOf`), and the mux feeds a follower from it.
+ * 21.8, 18.5 — `at(key(args))` is `undefined` where no entry holds the args. The answer reads its
+ * `max-age` off it (`deadlineOf`) and its version (`versionOf`), and the mux feeds a follower from
+ * it. THE KEY IS ITS OWN STEP so each side takes it once: an answer once a request, a follower once
+ * as it subscribes — and the mux files its followers by it, so an entry answered reaches the
+ * followers of its own args and walks no other (18.8). An unkeyed value has one entry, under `''`.
  */
-export const GLOBAL_GETS = new WeakMap<object, (args: unknown) => unknown>()
+export const GLOBAL_GETS = new WeakMap<
+    object,
+    { key(args: unknown): string; at(key: string): unknown }
+>()

package/src/shared/RPC_SERVER.ts

@@ -39,12 +39,12 @@ export const RPC_SERVER: {
         | ((member: 'invalidate' | 'refresh', tags: string[] | null) => void)
         | null
     /**
-     * The `global` entry an answer came from.
+     * The `global` entry an answer came from, and the key it is filed under (`GLOBAL_GETS`).
      *
      * 18.8 — so a follower subscribed before it existed, or fed from one since evicted, is fed
      * from this one.
      */
-    served: ((rpc: object, serving: unknown) => void) | null
+    served: ((rpc: object, serving: unknown, key: string) => void) | null
     /**
      * How long a handler's own body took inside its rungs.
      *

package/src/shared/reactive/Cursor.ts

@@ -8,13 +8,13 @@
 // cursor reads is a handful of fields, and naming them keeps the cell's internals out of a
 // second file.
 
+import { PATCHES } from './PATCHES.ts'
 import {
     dropReader,
     newSubscriber,
     type Subscriber,
     type Tracked,
 } from './tracking.ts'
-import { PATCHES } from './PATCHES.ts'
 
 /**
  * What a cursor reads, and all of a cell the server is handed (`servedCellOf`).
@@ -22,15 +22,10 @@ import { PATCHES } from './PATCHES.ts'
  * `ring[index]` carries ordinal `ringBase + index + 1`, so a cursor holding an ordinal finds its
  * place in a stream's chunk buffer without the buffer having to hold one.
  */
-export type Retained = {
+export type Retained = Tracked & {
     /** The window a `throttle` or a `debounce` holds open, `holding` while a production waits on it. */
     cap: { holding: boolean } | null
     ordinal: number
-    /**
-     * Unused by a cursor and declared so a `Cell` still satisfies `Tracked`, which a cursor's
-     * subscriber is registered through.
-     */
-    probeReaders: Subscriber[]
     ring: unknown[]
     ringBase: number
     servable: boolean
@@ -41,7 +36,6 @@ export type Retained = {
      */
     stream: object | null
     value: unknown
-    readers: Subscriber[]
 }
 
 // The cursors standing over each source, for a patch to keep the place of the ones behind (5.7).
@@ -118,7 +112,7 @@ export class Cursor implements AsyncIterator<unknown> {
         // reader in the graph carries for the sake of the few that are cursors.
         // Registered outside the tracking protocol, so the source it waits on is declared
         // rather than discovered — see the same shape in `Reactive`'s `settled`.
-        this.reader = newSubscriber([source as unknown as Tracked], null)
+        this.reader = newSubscriber([source], null)
         // One production per waiting turn, in the order they were asked for: a burst that
         // lands three productions on a consumer holding two turns answers both.
         this.reader.notify = (): void => {

package/src/shared/reactive/Keyed.ts

@@ -40,6 +40,7 @@ import {
     detachProbes,
     dropReader,
     newSubscriber,
+    newTracked,
     type Subscriber,
     TRACKING,
     type Tracked,
@@ -332,7 +333,7 @@ export function createKeyed<
     // entry's probe carries it: a guard asked before a key was reached subscribed to the entries
     // there were, so the key that starts loading next — search-as-you-type — never woke it. One
     // signal per `Keyed`, moved where an entry is reached and where one is released.
-    const membership: Tracked = { readers: [], probeReaders: [] }
+    const membership = newTracked()
 
     function askMembership(): void {
         const reader = TRACKING.reader

package/src/shared/reactive/Reactive.ts

@@ -19,10 +19,10 @@ import { type Found, runSchema, type Schema } from '../Schema.ts'
 import { UNEXPECTED } from '../UNEXPECTED.ts'
 import { WORK } from '../WORK.ts'
 import { CELL } from './CELL.ts'
+import { Cursor, hasCursorBehind, keepPlaces, type Retained } from './Cursor.ts'
 import { ENTRY_LIVES } from './ENTRY_LIVES.ts'
 import { armTimer, type Expiry, expiryFor } from './Expiry.ts'
 import { FOLLOWED } from './FOLLOWED.ts'
-import { Cursor, hasCursorBehind, keepPlaces, type Retained } from './Cursor.ts'
 import { isReactive } from './isReactive.ts'
 import { isThenable } from './isThenable.ts'
 import { MUTATION } from './MUTATION.ts'
@@ -38,16 +38,19 @@ import {
     CLEAN,
     DIRTY,
     detach,
-    detachProbes,
     dropProbeReader,
     newSubscriber,
+    newTracked,
     RELEASING,
+    revive,
     type Subscriber,
     TRACKING,
     type Tracked,
+    tombstone,
     track,
     trackProbe,
     truncate,
+    truncateProbes,
     untracked,
 } from './tracking.ts'
 import { owned, owning, watchOver } from './watch.ts'
@@ -556,8 +559,12 @@ export function isStreamBody(body: (args: never) => unknown): boolean {
  * under JSC; adding a DEAD boolean back put all three within 0.6%, which is the proof it
  * was layout and not work — that same dead boolean then cost the probe walk 6-7%.
  *
- * So the boundary is worth KNOWING and not worth engineering around. Adding a field
- * costs nothing; getting under costs a structural change that the next field added here
+ * Above the budget is not free under JSC, though: three fields more (the dead-reader
+ * counts and `probeCursor`) moved `construct a value` and the derived case +6-8% there,
+ * and three UNUSED fields on the old record moved them the same — layout, not work.
+ *
+ * So the boundary is worth KNOWING and not worth engineering around. A field costs a few
+ * ns of construction; getting under costs a structural change that the next field added here
  * silently undoes, and it re-rolls in a different direction for every row. If
  * construction ever needs that 11%, shed fields — do not build machinery to shed them.
  * And when a V8-only move of this size shows up on a graph row, the first thing to check
@@ -568,20 +575,24 @@ class Cell {
      * Who reads this value, on the value edge.
      *
      * ARRAYS, not sets. The mark walk walks this per write and a set's iterator
-     * allocates; removal is O(n) against a reader count that is small by construction.
+     * allocates. A disposed reader is left in place and counted rather than found — see
+     * `dropFrom` in `tracking.ts` — so a walk over this skips `!alive`.
      */
     declare readers: Subscriber[]
+    declare deadReaders: number
     /**
      * Who asked about this value's PROBES — a different edge from `readers`, and see
      * `markProbes` for what that buys.
      */
     declare probeReaders: Subscriber[]
+    declare deadProbeReaders: number
     declare sources: Cell[]
     /**
      * The values whose PROBES this body asked about — a `Cell` is a `Subscriber`, so it
      * carries the reader half of the probe edge as well as the source half.
      */
     declare probeSources: Cell[]
+    declare probeCursor: number
     declare cursor: number
     /** See `Subscriber.seen`. */
     declare seen: Set<Cell> | null
@@ -801,9 +812,12 @@ class Cell {
     ) {
         // Every field, in one order, `undefined` included.
         this.readers = []
+        this.deadReaders = 0
         this.probeReaders = []
+        this.deadProbeReaders = 0
         this.sources = []
         this.probeSources = []
+        this.probeCursor = 0
         this.cursor = 0
         this.seen = null
         this.seenThrough = 0
@@ -1294,6 +1308,7 @@ function markProbes(cell: Cell, pass: number): void {
     const readers = cell.readers
     for (let index = 0; index < readers.length; index += 1) {
         const reader = readers[index] as Subscriber
+        if (!reader.alive) continue
         if (!reader.isEffect) markProbes(reader as unknown as Cell, pass)
         else if (reader.adopter !== null)
             markProbes(reader.adopter as unknown as Cell, pass)
@@ -2188,6 +2203,8 @@ function run(cell: Cell): void {
     // where the cascade would try: `a` reads `b` and `b` reads `a`. Without this the
     // recursion is unbounded and the failure is a stack overflow rather than a value.
     if (cell.running) return
+    // A released orphan read again (12.14) — see `tombstone`.
+    if (!cell.alive) revive(cell as unknown as Subscriber)
     cell.generation += 1
     cell.state = CLEAN
     cell.running = true
@@ -2199,9 +2216,7 @@ function run(cell: Cell): void {
     // THE RUN'S CURSOR, spelled out rather than behind a call frame on a path walked once
     // per node per write. Zero is also "has diverged nowhere yet": see `tracking.ts`.
     reader.cursor = 0
-    // The probe edge is rebuilt rather than cursored: a guard that stops being taken has
-    // to stop waking, and a body reads few probes where it reads many values.
-    if (reader.probeSources.length !== 0) detachProbes(reader)
+    reader.probeCursor = 0
     let produced: unknown
     try {
         // 11.32 — UNDER THE VALUE'S OWN SCOPE, not the ambient one. A drain runs every body a
@@ -2211,6 +2226,8 @@ function run(cell: Cell): void {
     } catch (thrown) {
         TRACKING.reader = previous
         if (reader.cursor < reader.sources.length) truncate(reader)
+        if (reader.probeCursor < reader.probeSources.length)
+            truncateProbes(reader)
         cell.running = false
         if (thrown instanceof NotLanded) {
             cell.loading = true
@@ -2235,6 +2252,8 @@ function run(cell: Cell): void {
     // that is the only thing the truncation has to do — so the test is here and the call
     // is the rare arm.
     if (reader.cursor < reader.sources.length) truncate(reader)
+    // And a guard this run did not take stops waking it.
+    if (reader.probeCursor < reader.probeSources.length) truncateProbes(reader)
     cell.running = false
     // A VALUE THAT WAS ADOPTING AND IS NOT ANY MORE. Behind the `adoption` load so every
     // other recompute pays one field test rather than the brand read below it.
@@ -3290,6 +3309,7 @@ function owedBelow(cell: Cell): void {
     const readers = cell.readers
     for (let index = 0; index < readers.length; index += 1) {
         const reader = readers[index] as Subscriber
+        if (!reader.alive) continue
         const below = (reader.isEffect
             ? reader.adopter
             : reader) as unknown as Cell | null
@@ -3713,14 +3733,13 @@ let compactProducersAt = 1024
  * subscribes to this, never to each entry — the probe edge `trackProbe` makes, from a node that
  * is nothing but that edge.
  */
-type Signal = { readers: Subscriber[]; probeReaders: Subscriber[] }
-const SIGNALS = new Map<string, Signal>()
-const SIGNALS_BY_TAG = new Map<string, Signal[]>()
+const SIGNALS = new Map<string, Tracked>()
+const SIGNALS_BY_TAG = new Map<string, Tracked[]>()
 /**
  * The bare selection's one signal. Not a key in `SIGNALS`: `{ tags: [] }` canonicalises to the
  * empty set and matches nothing, where the bare selection matches every filed load in reach.
  */
-const EVERY_PRODUCER: Signal = { readers: [], probeReaders: [] }
+const EVERY_PRODUCER = newTracked()
 
 function refOf(cell: Cell): WeakRef<Cell> {
     let ref = cell.ref
@@ -3839,13 +3858,13 @@ function trackSignal(tags: string[] | null): void {
     const reader = TRACKING.reader
     if (reader === null) return
     if (tags === null) {
-        trackProbe(EVERY_PRODUCER as unknown as Tracked, reader)
+        trackProbe(EVERY_PRODUCER, reader)
         return
     }
     const key = JSON.stringify([...new Set(tags)].sort())
     let signal = SIGNALS.get(key)
     if (signal === undefined) {
-        signal = { readers: [], probeReaders: [] }
+        signal = newTracked()
         SIGNALS.set(key, signal)
         for (const tag of tags) {
             const signals = SIGNALS_BY_TAG.get(tag)
@@ -3853,7 +3872,7 @@ function trackSignal(tags: string[] | null): void {
             else signals.push(signal)
         }
     }
-    trackProbe(signal as unknown as Tracked, reader)
+    trackProbe(signal, reader)
 }
 
 function markSignals(tags: string[]): void {
@@ -3936,6 +3955,7 @@ export function refreshOver(tags: string[] | null): void {
 function readByAny(readers: Subscriber[]): boolean {
     for (let index = 0; index < readers.length; index += 1) {
         const reader = readers[index] as Subscriber
+        if (!reader.alive) continue
         if (!reader.isMirror || reader.adopter !== null) return true
     }
     return false
@@ -4368,12 +4388,13 @@ function releaseOrphan(cell: Cell): void {
     const stream = cell.stream
     if (stream !== null && stream.source === null) stopStream(stream)
     dropAdoption(cell)
-    detach(cell as unknown as Subscriber)
     cell.aborted = false
     if (cell.body !== null && stream === null) {
+        // OWED A RUN, so a read that reaches it again runs it — and `run` revives it first.
+        tombstone(cell as unknown as Subscriber)
         cell.state = DIRTY
         cell.direct = false
-    }
+    } else detach(cell as unknown as Subscriber)
 }
 
 RELEASING.unread = (source: Tracked): void => releaseOrphan(source as Cell)

package/src/shared/reactive/tracking.ts

@@ -87,6 +87,11 @@ export type Subscriber = {
      * the identity gate that exists to stop exactly that cannot see a production nobody minted.
      */
     probeSources: Tracked[]
+    /**
+     * How far into `probeSources` this run has re-asked — `cursor` for the probe edge, and see
+     * `trackProbe` for why it is not the same protocol.
+     */
+    probeCursor: number
     /**
      * How far into `sources` this run has matched.
      *
@@ -111,8 +116,22 @@ export type Subscriber = {
 
 export type Tracked = {
     readers: Subscriber[]
+    /** How many of `readers` are disposed and not yet swept out — see `dropFrom`. */
+    deadReaders: number
     /** Who asked about this value's probes. Apart from `readers` — see `probeSources`. */
     probeReaders: Subscriber[]
+    /** `deadReaders` for `probeReaders`. */
+    deadProbeReaders: number
+}
+
+/** A node that is nothing but its edges — a probe signal with no value behind it. */
+export function newTracked(): Tracked {
+    return {
+        readers: [],
+        deadReaders: 0,
+        probeReaders: [],
+        deadProbeReaders: 0,
+    }
 }
 
 /** The reader whose run is on the stack, or `null` where reads subscribe to nothing. */
@@ -144,6 +163,7 @@ export function newSubscriber(
     return {
         sources,
         probeSources: [],
+        probeCursor: 0,
         cursor: 0,
         seen: null,
         seenThrough: 0,
@@ -167,8 +187,9 @@ export function newSubscriber(
  * of the loop beside this one is what CLAUDE.md's sibling-seam rule refuses.
  */
 export function dropReader(source: Tracked, reader: Subscriber): void {
-    removeFrom(source.readers, reader)
-    if (source.readers.length === 0) unread(source)
+    const readers = source.readers
+    source.deadReaders = dropFrom(readers, reader, source.deadReaders)
+    if (readers.length === 0) unread(source)
 }
 
 /**
@@ -218,40 +239,102 @@ export function untracked<First, Second, Result>(
  * rather than on a value.
  */
 export function dropProbeReader(source: Tracked, reader: Subscriber): void {
-    removeFrom(source.probeReaders, reader)
-    if (source.probeReaders.length === 0) unread(source)
+    const readers = source.probeReaders
+    source.deadProbeReaders = dropFrom(readers, reader, source.deadProbeReaders)
+    if (readers.length === 0) unread(source)
 }
 
-function removeFrom(readers: Subscriber[], reader: Subscriber): void {
+/**
+ * Takes `reader` off `readers`, of which `dead` are disposed, and returns how many are now.
+ *
+ * A DISPOSED READER IS LEFT WHERE IT IS AND COUNTED, rather than found. Finding it is a scan of
+ * every reader of the value, and a teardown drops them all — n rows reading one page value, torn
+ * down, paid n²/2 compares, and a keyed replace is the worst order there is: the new rows are
+ * pushed behind the old ones the scan walks past. 10,000 rows went 16-39 ms to 0.2-0.4. Every
+ * walk over a reader list skips `!alive`, so a dead slot costs a walk one test until the
+ * sweep below takes it out.
+ *
+ * SWEPT ONCE HALF THE LIST IS DEAD, which keeps a walk to at most twice the live readers and the
+ * sweep amortised O(1) a drop — and keeps the invariant every `length` test leans on: a list with
+ * entries has a LIVE one, since a list that is all dead is at least half dead. HALF, NOT MORE THAN
+ * HALF: a keyed replace ends on exactly half, n old rows dead behind n new ones, and a sweep that
+ * waited for one more drop kept the old rows — and through each one's `notify`, its scope and its
+ * nodes — reachable until some unrelated reader left. An over-count — a
+ * reader dropped twice — only sweeps early, and the sweep recounts from zero.
+ *
+ * A LIVE reader still scans: that is a run's own truncation or an orphan's release, a reader
+ * that may subscribe again, so it cannot be left to read as dead.
+ */
+function dropFrom(
+    readers: Subscriber[],
+    reader: Subscriber,
+    dead: number,
+): number {
+    if (!reader.alive) dead += 1
+    else purge(readers, reader)
+    if (dead * 2 < readers.length) return dead
+    let kept = 0
     for (let index = 0; index < readers.length; index += 1) {
-        if (readers[index] !== reader) continue
-        readers[index] = readers[readers.length - 1] as Subscriber
-        readers.pop()
-        return
+        const survivor = readers[index] as Subscriber
+        if (survivor.alive) {
+            readers[kept] = survivor
+            kept += 1
+        }
     }
+    readers.length = kept
+    return 0
 }
 
 /**
  * Subscribes `reader` to `source`'s probes, once per run.
  *
- * A PROBE EDGE IS REBUILT PER RUN rather than cursored. A body reads few probes where it reads
- * many values, and a guard that stops being taken must stop waking — so the list is dropped at
- * the start of a run and re-made by the reads that happen.
+ * A PROBE EDGE IS CURSORED, and kept in the order this run asked. `probeSources[0..probeCursor)`
+ * is what this run has asked so far; a source asked again is moved to the cursor rather than
+ * dropped and re-pushed, so a run that asks what its last one did touches no source's list at
+ * all. It used to be dropped at the start of every run and re-made — which put a scan of the
+ * SOURCE'S probe readers behind every rerun, and n guards over one shared `ready()` woken by one
+ * flip paid n²: 10,000 went 39 ms to 0.4. A guard that stops being taken still stops waking:
+ * what the run did not re-ask is past the cursor at its end, and `truncateProbes` drops it.
+ *
+ * NOT `track`'s protocol, because the list is a SET in no particular order where `sources` is
+ * positional: a re-ask out of order is a swap, never a divergence, and a body asks one to three.
  */
 export function trackProbe(source: Tracked, reader: Subscriber): void {
     const asked = reader.probeSources
-    for (let index = 0; index < asked.length; index += 1)
+    const at = reader.probeCursor
+    if (asked[at] === source) {
+        reader.probeCursor = at + 1
+        return
+    }
+    for (let index = 0; index < at; index += 1)
         if (asked[index] === source) return
-    asked.push(source)
-    source.probeReaders.push(reader)
+    let found = asked.length
+    for (let index = at + 1; index < asked.length; index += 1)
+        if (asked[index] === source) {
+            found = index
+            break
+        }
+    if (found === asked.length) {
+        asked.push(source)
+        source.probeReaders.push(reader)
+    }
+    asked[found] = asked[at] as Tracked
+    asked[at] = source
+    reader.probeCursor = at + 1
 }
 
-/** Drops every probe subscription `reader` holds. */
-export function detachProbes(reader: Subscriber): void {
+/** Drops the probe subscriptions `reader`'s run did not re-ask — the tail past its cursor. */
+export function truncateProbes(reader: Subscriber): void {
     const asked = reader.probeSources
-    for (let index = 0; index < asked.length; index += 1)
+    for (let index = reader.probeCursor; index < asked.length; index += 1)
         dropProbeReader(asked[index] as Tracked, reader)
-    asked.length = 0
+    asked.length = reader.probeCursor
+}
+
+/** Drops every probe subscription `reader` holds. */
+export function detachProbes(reader: Subscriber): void {
+    reader.probeCursor = 0
+    truncateProbes(reader)
 }
 
 // How far `kept * dropped` must outgrow `kept + dropped` before `truncate` builds a `Set` over the
@@ -278,8 +361,9 @@ const SET_OVER_SCAN = 20
  * `SET_OVER_SCAN`): at 1000/999 the scan is one probe per dropped slot and building the Set
  * doubled the flip, so the two are priced against each other instead.
  *
- * A duplicate inside the DROPPED tail needs no test — `removeFrom` takes one occurrence and the
- * second call finds none.
+ * A duplicate inside the DROPPED tail needs no test — `dropFrom` takes one occurrence and the
+ * second call finds none, or for a disposed reader counts one dead too many, which only sweeps
+ * early.
  *
  * Exported because a tracked run's end is exactly this and nothing more: the TEST that there is a
  * tail is the caller's — two field loads, on the rare arm.
@@ -416,3 +500,53 @@ export function detach(reader: Subscriber): void {
     truncate(reader)
     if (reader.probeSources.length !== 0) detachProbes(reader)
 }
+
+/**
+ * Lets go of every subscription `reader` holds as a DISPOSAL — counted dead where it stands
+ * (`dropFrom`) rather than scanned for — while keeping its lists, so `revive` can find what it left.
+ *
+ * FOR A RELEASED ORPHAN (12.14): n rows each deriving off one page value, torn down, scanned the
+ * page value's readers once a row. The orphan may be read again, which is what `revive` is for —
+ * paid by the read that comes back, which is rare, rather than by the release, which is per row.
+ */
+export function tombstone(reader: Subscriber): void {
+    reader.alive = false
+    const sources = reader.sources
+    for (let index = 0; index < sources.length; index += 1)
+        dropReader(sources[index] as Tracked, reader)
+    reader.cursor = 0
+    const asked = reader.probeSources
+    for (let index = 0; index < asked.length; index += 1)
+        dropProbeReader(asked[index] as Tracked, reader)
+    reader.probeCursor = 0
+}
+
+/**
+ * Takes a `tombstone`d reader's dead entries out of whatever list has not swept them yet, and
+ * makes it live with nothing subscribed — the state a fresh reader starts its run in.
+ */
+export function revive(reader: Subscriber): void {
+    reader.alive = true
+    const sources = reader.sources
+    for (let index = 0; index < sources.length; index += 1) {
+        const source = sources[index] as Tracked
+        if (purge(source.readers, reader)) source.deadReaders -= 1
+    }
+    sources.length = 0
+    const asked = reader.probeSources
+    for (let index = 0; index < asked.length; index += 1) {
+        const source = asked[index] as Tracked
+        if (purge(source.probeReaders, reader)) source.deadProbeReaders -= 1
+    }
+    asked.length = 0
+}
+
+function purge(readers: Subscriber[], reader: Subscriber): boolean {
+    for (let index = 0; index < readers.length; index += 1) {
+        if (readers[index] !== reader) continue
+        readers[index] = readers[readers.length - 1] as Subscriber
+        readers.pop()
+        return true
+    }
+    return false
+}

package/src/shared/reactive/watch.ts

@@ -20,12 +20,12 @@ import type { Reactive } from './Reactive.ts'
 import { currentScope, runInScope } from './scoping.ts'
 import {
     detach,
-    detachProbes,
     newSubscriber,
     type Subscriber,
     TRACKING,
     type Tracked,
     truncate,
+    truncateProbes,
     untracked,
 } from './tracking.ts'
 
@@ -248,7 +248,7 @@ export function watchOver(
  * binding's `Scope` and a `{#try}`'s retry hold their own, and call this direct.
  *
  * A SECOND BODY BESIDE `watchOver` ON PURPOSE, and it reads as the duplication it is: the two
- * differ by the cursor reset, the probe rebuild and the tail trim, and the rest is the same lines.
+ * differ by the cursor resets and the tail trims, and the rest is the same lines.
  * ONE BODY WITH A `tracked` FLAG WAS BUILT AND MEASURED, under V8 against this pair, interleaved
  * four runs a side: `write a value that changed` — one bound watch — went 15.6 ns to 21.4 in every
  * run, and `mount 50 readers` +12% (+7% under JSC). Three flag tests cannot cost 6 ns. The likely
@@ -276,7 +276,7 @@ export function watchTracked(effect: Effect): Disposer {
         const previous = TRACKING.reader
         TRACKING.reader = reader
         reader.cursor = 0
-        if (reader.probeSources.length !== 0) detachProbes(reader)
+        reader.probeCursor = 0
         reader.running = true
         try {
             WORK.wakes += 1
@@ -285,6 +285,8 @@ export function watchTracked(effect: Effect): Disposer {
             reader.running = false
             TRACKING.reader = previous
             if (reader.cursor < reader.sources.length) truncate(reader)
+            if (reader.probeCursor < reader.probeSources.length)
+                truncateProbes(reader)
             // The abort reaches here too: an effect that read a value which has
             // not landed is not an effect that failed, it is one whose turn has
             // not come. The read subscribed before it threw, so the value landing
@@ -299,6 +301,8 @@ export function watchTracked(effect: Effect): Disposer {
         reader.running = false
         TRACKING.reader = previous
         if (reader.cursor < reader.sources.length) truncate(reader)
+        if (reader.probeCursor < reader.probeSources.length)
+            truncateProbes(reader)
     }
     reader.notify()
     return (): void => {

package/src/shared/rpc.ts

@@ -446,12 +446,17 @@ export function declare(method: Method): Declare {
         // value produced, and holds no way back to it. A keyed value is looked up without a reach,
         // so asking starts nothing (11.55).
         if (method === 'GET' && !isForwarder(value))
-            GLOBAL_GETS.set(rpc, (args: unknown): unknown =>
+            GLOBAL_GETS.set(
+                rpc,
                 keyed
-                    ? (value as { entries: Map<string, unknown> }).entries.get(
-                          keyOf(contract, args),
-                      )
-                    : value,
+                    ? {
+                          key: (args) => keyOf(contract, args),
+                          at: (key) =>
+                              (
+                                  value as { entries: Map<string, unknown> }
+                              ).entries.get(key),
+                      }
+                    : { key: () => '', at: () => value },
             )
         return rpc
     }) as Declare