@abide/abide 0.100.0 → 0.102.0

package/src/shared/reactive/Reactive.ts

@@ -10,7 +10,7 @@
 //
 // Every field `Cell` declares is written in its constructor, in one order, `undefined`
 // included — a shape that grows a field on a later path is two hidden classes and every
-// read downstream of it deoptimises.
+// read downstream of it deoptimizes.
 
 import { type Failed, isFailed, isFailedNamed } from '../Failed.ts'
 import { namedLogger } from '../log.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'
@@ -136,7 +139,7 @@ export type ReactiveOptions<
     /**
      * Shapes a settled value on the way in, or refuses it by returning a `Failed`.
      *
-     * RULEBOOK 4.6, 4.7: runs untracked, on the settled value, once per materialisation,
+     * RULEBOOK 4.6, 4.7: runs untracked, on the settled value, once per materialization,
      * and refuses by RETURNING a `Failed` rather than by throwing. A throw here would be
      * indistinguishable from the body having failed, and 4.9 has a refused write mint
      * nothing where a failed producer (2.3) may still have something to say.
@@ -177,7 +180,7 @@ export type ReactiveOptions<
      * What tells one array element from another.
      *
      * RULEBOOK 5.22, 32.32: what tells one element from another. The property-name form is the one
-     * that crosses a wire (18.4) — a function has no serialisation.
+     * that crosses a wire (18.4) — a function has no serialization.
      */
     by?:
         | (keyof ElementOf<Stored> & string)
@@ -371,7 +374,7 @@ type Persisted = {
  * A STREAMING PRODUCER'S OWN STATE (9.1, 9.2, 9.6), and `null` on every value whose body is
  * not an async generator — the shape `cap` and `adoption` already use.
  *
- * THE ACCUMULATION IS PUSHED INTO AND MATERIALISED ON THE READ. A chunk is one push and one
+ * THE ACCUMULATION IS PUSHED INTO AND MATERIALIZED ON THE READ. A chunk is one push and one
  * cascade; the copy a reader is handed is taken by the read that follows, so a hundred
  * chunks between two reads are one copy rather than a hundred (9.2). The copy is FRESH per
  * chunk count and has to be: a reader holding an earlier snapshot still holds what it read,
@@ -398,13 +401,13 @@ type Stream = {
      *
      * A version rather than a chunk count because a patch changes the accumulation without
      * changing its length (9.13), and a write stands at the version it was made at until the
-     * accumulation moves past it (9.11). -1 where nothing has been materialised.
+     * accumulation moves past it (9.11). -1 where nothing has been materialized.
      */
-    materialisedAt: number
+    materializedAt: number
     /**
-     * Whether `value` is a write rather than a materialisation.
+     * Whether `value` is a write rather than a materialization.
      *
-     * WHETHER `value` IS A WRITE rather than a materialisation, while `materialisedAt` stands. A value
+     * WHETHER `value` IS A WRITE rather than a materialization, while `materializedAt` stands. A value
      * forwarding this stream serves the write the way it would have served a production (11.59).
      */
     written: boolean
@@ -413,7 +416,7 @@ type Stream = {
      *
      * HOW MANY CHUNKS A READER HAS BEEN TOLD OF. Every chunk as it lands, without a cap; with one,
      * only what the window has released (5.18) — the rest are in `chunks` for a cursor (5.10) and
-     * out of what a read materialises until the release.
+     * out of what a read materializes until the release.
      */
     visible: number
     /** The run in flight, told to return when a newer run supersedes it. */
@@ -467,7 +470,7 @@ function newStream(source: Cell | null): Stream {
         chunks: EMPTY_RING,
         version: 0,
         visible: 0,
-        materialisedAt: -1,
+        materializedAt: -1,
         written: false,
         iterator: null,
         run: 0,
@@ -495,7 +498,7 @@ function becomeStream(cell: Cell, source: Cell | null): Stream {
  * every other producer's. A failed or superseded run never reaches here, so it starts no clock.
  */
 function closeRun(cell: Cell, stream: Stream): void {
-    // Materialised here so 9.8's gates run on the accumulation the run closed with.
+    // Materialized here so 9.8's gates run on the accumulation the run closed with.
     if (heldValue(cell) === undefined) return
     stream.closed = true
     const expiry = cell.expiry
@@ -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
@@ -728,7 +739,7 @@ class Cell {
      * Whether a read may ever take the field straight, fixed at construction.
      *
      * WHETHER A READ MAY EVER TAKE THE FIELD STRAIGHT, fixed at construction: no expiry to
-     * check and no accumulation to materialise. `setDirect` reads this one field where it
+     * check and no accumulation to materialize. `setDirect` reads this one field where it
      * would otherwise read one per mechanism that needs the read to go a frame in.
      */
     declare plain: boolean
@@ -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
@@ -951,7 +965,7 @@ function capFor(
  *
  * So the framework takes the cheap, predictable default — `===` is what JavaScript
  * means by "the same value" — and the app names `identity: structural` on the values
- * where re-materialisation is the common case. 5.5's "not equal wherever it cannot
+ * where re-materialization is the common case. 5.5's "not equal wherever it cannot
  * decide" is unchanged; it is just no longer the default reading.
  *
  * `identity` is discriminated by ARITY (5.3), once, at construction — not per compare.
@@ -1088,7 +1102,7 @@ export function flushSync(): void {
  * is never direct, so every read of it goes a frame in to `readIndirect` — which is
  * exactly where 6.5 and 6.6 are answered, and is why a value declaring no `ttl`
  * never reaches a clock. See `Expiry.ts`. A stream is never direct either, for the same
- * shape of reason: its read is where the accumulation is materialised (9.1).
+ * shape of reason: its read is where the accumulation is materialized (9.1).
  */
 function setDirect(cell: Cell, when: boolean): void {
     cell.direct = when && cell.plain
@@ -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)
@@ -1423,7 +1438,7 @@ function drainPending(): void {
         // derived CELL on 2.13's aborted-body path, and for one of those `state` is not a
         // reminder to run — it IS the pull the next read takes (`state !== CLEAN` is what sends
         // a read a frame in). Forced back to `CLEAN` it is not deaf, it is settled: the read
-        // path skips `resolve`, the aborted body is never re-run and the `ready()` guard that
+        // path skips `resolve`, the aborted body is never rerun and the `ready()` guard that
         // queued it answers false for the life of the page — undoing, on any throw anywhere in
         // the drain, exactly what that push was added to repair.
         for (let index = pendingAt; index < pendingCount; index += 1) {
@@ -1732,7 +1747,7 @@ function openWindow(cell: Cell, cap: Cap): void {
  *
  * THE WAY IN, AND THE ORDER IS 4.3 THEN 4.4: the schema gates, and what it RETURNS is
  * what `transform` receives — not the original value. A transform reading the raw input
- * where a schema had normalised it is a second answer to what this value holds.
+ * where a schema had normalized it is a second answer to what this value holds.
  * What it hands back is the ordinal, or the refusal a gate answered with (4.18) — `unknown`
  * because the one caller that cares tells the two apart by type.
  */
@@ -1754,7 +1769,7 @@ function accept(cell: Cell, value: unknown): unknown {
     if (transform === null) return produce(cell, checked)
     // 4.7 — A `transform` RUNS UNTRACKED: a write can be made from inside a tracked body
     // (`watch(() => target.set(…))`, a recompute that writes), and run tracked, the transform's
-    // reads were attributed to that reader — which then re-ran on a value it never read, with
+    // reads were attributed to that reader — which then reran on a value it never read, with
     // those reads spliced into its cursor-ordered `sources`.
     const shaped = untracked(transform, checked, undefined)
     // 4.6 AND 4.9: a `transform` that returned a refusal stops the write here — nothing is
@@ -1829,7 +1844,7 @@ function writeStream(cell: Cell, value: unknown): unknown {
 function standWrite(cell: Cell, stream: Stream, value: unknown): number {
     // 7.9, as `produce` settles it.
     if (cell.owes === OWES_RELOAD) cell.owes = OWES_NOTHING
-    // 5.2 against what is served now, which on a stream may not have been materialised yet.
+    // 5.2 against what is served now, which on a stream may not have been materialized yet.
     if (cell.servable) {
         const previous = heldValue(cell)
         if (
@@ -1840,7 +1855,7 @@ function standWrite(cell: Cell, stream: Stream, value: unknown): number {
             return cell.ordinal
     }
     cell.value = value
-    stream.materialisedAt = stream.version
+    stream.materializedAt = stream.version
     stream.written = true
     const moved = !cell.servable || cell.failure !== undefined
     landChunks(cell)
@@ -2015,13 +2030,13 @@ function follow(cell: Cell, stream: Stream, inner: Cell): Error | undefined {
     if (standing !== null) unfollow(cell)
     // What `standWrite`'s identity gate compares against is what is served now.
     heldValue(cell)
-    stream.materialisedAt = stream.version
+    stream.materializedAt = stream.version
     stream.written = true
     const stop = watchOver([inner], cell, (): undefined => {
         // The accumulation moved past the write. The drop is `wakeStreams`'s or the read's, not
         // this one's: a mirror runs inside the mark walk over `inner.readers`, and detaching here
         // would splice the list that walk is iterating.
-        if (!stream.written || stream.materialisedAt !== stream.version)
+        if (!stream.written || stream.materializedAt !== stream.version)
             return undefined
         if (inner.owes !== OWES_NOTHING) settleOwed(inner)
         // 11.16: the followed value has nothing to serve, so neither has this.
@@ -2060,7 +2075,7 @@ function unserve(cell: Cell): void {
 }
 
 function mirror(cell: Cell, inner: Cell): void {
-    // 7.13 through the adoption: the re-settle a re-run of the adopter makes reaches a reload the
+    // 7.13 through the adoption: the re-settle a rerun of the adopter makes reaches a reload the
     // adopted value owes, rather than finding it unservable and giving up.
     if (inner.owes !== OWES_NOTHING) settleOwed(inner)
     const adopted = inner.stream
@@ -2121,7 +2136,7 @@ function dropAdoption(cell: Cell): void {
  * Makes an adopter forward an adopted stream's buffer, ring and ordinals.
  *
  * 11.15 FOR A STREAM: the adopter takes the adopted value's buffer, ring and ordinals by
- * reference and materialises from them on its own reads, through its own gates (11.14, 9.8).
+ * reference and materializes from them on its own reads, through its own gates (11.14, 9.8).
  * Mirroring the value instead copied the accumulation once per wake whether or not anything
  * read it, and handed a cursor over the adopter whole accumulations where it wanted chunks.
  */
@@ -2136,8 +2151,8 @@ function forwardStream(cell: Cell, inner: Cell, adopted: Stream): void {
     stream.chunks = adopted.chunks
     stream.version = adopted.version
     stream.visible = adopted.visible
-    if (adopted.written && adopted.materialisedAt === adopted.version) {
-        stream.materialisedAt = stream.version
+    if (adopted.written && adopted.materializedAt === adopted.version) {
+        stream.materializedAt = stream.version
         stream.written = true
         gateInto(cell, inner.value)
     }
@@ -2173,9 +2188,9 @@ function stopForwarding(cell: Cell): void {
  * THE ABORT. A body that reads a value which has not landed throws `NotLanded`, and
  * this catches it and returns — the body is ABANDONED, not retried in place. The read
  * that threw has already registered this cell as a reader of it (tracking happens
- * before the throw), so the source landing is what re-runs the body.
+ * before the throw), so the source landing is what reruns the body.
  *
- * "Throw a sentinel and re-run" was refused once on three grounds. Two are answered
+ * "Throw a sentinel and rerun" was refused once on three grounds. Two are answered
  * by the reach starting the work (1.7) — the loads are in flight before the body
  * runs, so the abort costs a re-entry rather than a round trip. The third, that
  * nothing on a server wakes an abandoned body, is answered by the sink rather than
@@ -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.
@@ -2513,7 +2532,7 @@ function acceptChunk(cell: Cell, stream: Stream, chunk: unknown): void {
 /**
  * Tells readers of every chunk landed so far, waking them at most once per task.
  *
- * What a reader is told of: every chunk landed so far becomes what a read materialises, and the
+ * What a reader is told of: every chunk landed so far becomes what a read materializes, and the
  * wake goes out at most once per task (9.9).
  */
 function releaseChunks(cell: Cell, stream: Stream): void {
@@ -2527,7 +2546,7 @@ function releaseChunks(cell: Cell, stream: Stream): void {
  * The streams holding a wake, all drained by one task.
  *
  * THE STREAMS HOLDING A WAKE, and one task drains all of them — never a task per stream.
- * The pull is untouched: a read taken before the task runs materialises what has landed
+ * The pull is untouched: a read taken before the task runs materializes what has landed
  * (12.12), so what waits is only the telling.
  */
 const WAKING: Cell[] = []
@@ -2602,18 +2621,18 @@ function landChunks(cell: Cell): void {
 }
 
 /**
- * Materialises a stream's visible chunks into `value`, through both gates.
+ * Materializes a stream's visible chunks into `value`, through both gates.
  *
  * 9.1 AND 9.8: the read that asks is where the accumulation becomes a `Stored`, through both
  * gates, once per chunk count however many reads ask.
  */
-function materialise(cell: Cell, stream: Stream): void {
-    if (stream.materialisedAt === stream.version || !cell.servable) return
+function materialize(cell: Cell, stream: Stream): void {
+    if (stream.materializedAt === stream.version || !cell.servable) return
     // 9.11: the accumulation moved past a write following a `Reactive`, which lets go of it here
     // where no chunk's wake did — a patch, or a run that closed empty. Only an own stream follows;
     // a forwarding one's `adoption` is what it forwards.
     if (cell.adoption !== null && stream.source === null) unfollow(cell)
-    stream.materialisedAt = stream.version
+    stream.materializedAt = stream.version
     stream.written = false
     gateInto(cell, stream.chunks.slice(0, stream.visible))
 }
@@ -2658,7 +2677,7 @@ function gateThrough(cell: Cell, raw: unknown): void {
  */
 function heldValue(cell: Cell): unknown {
     const stream = cell.stream
-    if (stream !== null) materialise(cell, stream)
+    if (stream !== null) materialize(cell, stream)
     return cell.value
 }
 
@@ -2821,7 +2840,7 @@ function readIndirect(cell: Cell): unknown {
     // 6.5: THE READ THAT FOLLOWS. Every value carrying an expiry arrives here and no
     // other value does, which is the whole of what `setDirect` buys.
     if (cell.expiry !== null) expire(cell)
-    if (cell.stream !== null) materialise(cell, cell.stream)
+    if (cell.stream !== null) materialize(cell, cell.stream)
     if (!cell.servable) {
         // 2.3: a failed producer with nothing landed is the one case holding no value
         // and a refusal that explains the absence.
@@ -2847,7 +2866,7 @@ const EMPTY_RING = Object.freeze([]) as unknown as unknown[]
  * so a shared subgraph is re-walked once per path that reaches it, and a 26-cell DAG
  * with 130 edges cost 19,660 edge visits and 4,010 hash operations per probe read.
  *
- * The stamp MEMOISES, and it is sound for one reason worth stating: within a pass,
+ * The stamp MEMOIZES, and it is sound for one reason worth stating: within a pass,
  * "already visited while the walk is still running" IMPLIES "not busy", because a busy
  * node short-circuits the whole walk at its first visit. So a second arrival at a
  * stamped node answers false without descending.
@@ -2864,7 +2883,7 @@ let PROBE_PASS = 0
  * Propagation, derived on the read that asks (11.22) rather than held as a
  * subscription per source. 11.20: a value is busy where a source it read is busy —
  * and the premise is what `busy` MEANS, not which trigger produced it, so a refresh
- * over a landed source reports through here even though the body never re-ran.
+ * over a landed source reports through here even though the body never reran.
  */
 function walkBusy(cell: Cell, pass: number): boolean {
     if (cell.loading) return true
@@ -2948,7 +2967,7 @@ function busyNow(cell: Cell): boolean {
  * serving the figure it had computed before — right by its own lights, and a lie about the
  * data. Nothing in the output says so, which is why this is a walk and not a field.
  *
- * The stamp MEMOISES the same way `walkBusy`'s does and is sound for the mirrored reason:
+ * The stamp MEMOIZES the same way `walkBusy`'s does and is sound for the mirrored reason:
  * this walk short-circuits on NOT ready, so a second arrival at a node the walk is still
  * inside is a node that has not refused, and answering `true` there is answering what the
  * first visit will.
@@ -3034,7 +3053,7 @@ function settled(cell: Cell, untilStreaming = false): Promise<unknown> {
         const waiter: Subscriber = newSubscriber([cell], null)
         waiter.notify = (): void => {
             // THE WAITER PULLS. A value built from a source that has just landed is marked and
-            // not yet re-run — nothing else reads it — so asking whether it is busy before
+            // not yet rerun — nothing else reads it — so asking whether it is busy before
             // pulling it answers from the run that aborted, and the await never settles.
             if (cell.state !== CLEAN) resolve(cell)
             if (untilStreaming && cell.stream !== null) {
@@ -3074,7 +3093,7 @@ function settled(cell: Cell, untilStreaming = false): Promise<unknown> {
  * than discovered — and one source given is what `s.watch` means. What was here before was
  * a second copy of the subscriber, the disposer, the re-entrancy guard and 12.8, which is
  * exactly the divergence 12.9 forbids: the copy had no `catch` at all, so a throwing effect
- * re-ran into the same throw on every write where `watch` stops.
+ * reran into the same throw on every write where `watch` stops.
  *
  * The value is handed over rather than read, so the effect never reaches the tracked path
  * and never throws `NotLanded` from this source.
@@ -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
@@ -3701,7 +3721,7 @@ const TAGGED = new Map<string, Set<WeakRef<Cell>>>()
  * O(1) delete on eviction; here an evicted value drops its `ref` instead, and a handle whose value
  * no longer points back at it is dead, the same as one whose value was collected. Because a bare
  * sweep may never run, the filing that finds the array past `compactProducersAt` compacts it, and
- * the bar doubles past what survives, so the walk is amortised over the filings between two.
+ * the bar doubles past what survives, so the walk is amortized over the filings between two.
  */
 let filedProducers: WeakRef<Cell>[] = []
 let compactProducersAt = 1024
@@ -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
+ * The bare selection's one signal. Not a key in `SIGNALS`: `{ tags: [] }` canonicalizes 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
@@ -4151,7 +4171,7 @@ export function isStreaming(value: unknown): boolean {
  *
  * 16.32 — THE CHUNKS A STREAMING VALUE HAS TOLD ITS READERS OF PAST `from`, for a writer sending each
  * once. Ungated they are read out of the accumulation in place, to `visible` rather than its length
- * (5.18): a read materialises a copy of the whole of it (9.1), which for a writer woken per chunk is
+ * (5.18): a read materializes a copy of the whole of it (9.1), which for a writer woken per chunk is
  * n²/2 elements copied to send n. A schema or a transform has to see the whole accumulation (9.8),
  * so a gated value answers from what a read would.
  */
@@ -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/argsContract.ts

@@ -4,7 +4,7 @@
 // through `contractOf` so a transport reads it off whichever face it was handed.
 //
 // DEFAULTS BEFORE THE KEY, IN ONE PLACE. 11.27: a call that left a member to the parameter and one
-// that wrote it are one entry, so every reach, call and lookup takes the key through `normalised`
+// that wrote it are one entry, so every reach, call and lookup takes the key through `normalized`
 // — a caller that keyed the args as passed would file the same call twice, right in the value and
 // wrong in the work.
 //
@@ -54,7 +54,7 @@ export function gateOf(
  * `args` itself where the face has no defaults or nothing was missing, so a caller that passed
  * every member allocates nothing and a second application is free.
  */
-export function normalised<Args>(
+export function normalized<Args>(
     face: Pick<Gated<unknown>, typeof PARAMETER_DEFAULTS>,
     args: Args,
 ): Args {
@@ -62,12 +62,12 @@ export function normalised<Args>(
     return defaults === null ? args : withDefaults(args, defaults)
 }
 
-/** The entry key a call with `args` is filed under: `normalised`, then 11.24's canonical form. */
+/** The entry key a call with `args` is filed under: `normalized`, then 11.24's canonical form. */
 export function keyOf(
     face: Pick<Gated<unknown>, typeof PARAMETER_DEFAULTS>,
     args: unknown,
 ): string {
-    return canonicalKey(normalised(face, args))
+    return canonicalKey(normalized(face, args))
 }
 
 // ABSENT ARGS ARE `{}`: a wire writes the two alike (an empty query), so read apart they are one

package/src/shared/reactive/canonicalKey.ts

@@ -6,12 +6,12 @@ import { putOwn } from '../putOwn.ts'
  * RULEBOOK 11.24: members sorted by name, `undefined` members dropped, `Date` written ISO.
  *
  * 11.26: the key is taken BEFORE any gate runs, because a browser holds no copy of the gate — a
- * key taken after normalising is computed one way on a server and another in a browser, and every
- * handler with a normalising schema would miss its seed buffer and re-issue the call on hydration.
+ * key taken after normalizing is computed one way on a server and another in a browser, and every
+ * handler with a normalizing schema would miss its seed buffer and re-issue the call on hydration.
  *
  * 11.64: WHAT THE WIRE FORM CANNOT WRITE IS REFUSED AT THE REACH. `JSON.stringify` does not fail
  * on any of it — a `Set`, a `Map` and a class instance each have no own enumerable keys and
- * canonicalise to `{}`, and a non-finite number is written `null` — so two different reaches
+ * canonicalize to `{}`, and a non-finite number is written `null` — so two different reaches
  * produced one key and 1.8 joined the second to the first's standing work. The value was right
  * for the first caller and wrong for every other one, with nothing to see.
  */
@@ -55,7 +55,7 @@ function canonical(value: unknown, path: Steps): unknown {
     // AN ORDINARY OBJECT, AND `putOwn` FOR THE ONE KEY THAT NEEDS IT: `__proto__` is a SETTER on
     // `Object.prototype`, so `out[key] = …` for that key creates no own property and
     // `JSON.stringify` never sees it — `{id: 1, __proto__: {role: 'admin'}}` and `{id: 1}` then
-    // canonicalise to one string, and 1.8 joins the second reach to the first's standing work.
+    // canonicalize to one string, and 1.8 joins the second reach to the first's standing work.
     // `Object.create(null)` closed that too, and V8 builds it in DICTIONARY mode: the shipped key
     // took 49-56% of the time without it there, and a standing keyed reach 53%, where JSC reads
     // level to 110% (`harness/scripts/sharedCases.ts`, two runs per engine).

package/src/shared/reactive/chunksOfStream.ts

@@ -1,3 +1,4 @@
+import { isFailed } from '../Failed.ts'
 import { chunksFrom } from './Reactive.ts'
 
 /**
@@ -48,4 +49,9 @@ export async function* chunksOfStream(value: unknown): AsyncGenerator<unknown> {
         void cursor.return?.(undefined)
     }
     if (failure !== undefined) throw failure
+    // 16.59, 16.60 — A RUN ENDED BY ITS TIMEOUT SETTLES with the chunks it had and holds its refusal
+    // rather than rejecting, so the refusal is read off the value and thrown after them: a stream
+    // answered over http then ends on it (16.68) rather than as though it had finished.
+    const held = (value as { error?: () => unknown }).error?.()
+    if (isFailed(held)) throw held
 }

package/src/shared/reactive/index.ts

@@ -39,7 +39,7 @@ export { isKeyed, type Keyed } from './Keyed.ts'
 export { NotLanded } from './NotLanded.ts'
 // The server reaches the core through here rather than `./Reactive.ts`: `Reactive.ts` →
 // `log.ts` → this barrel → `scoped.ts` → `Reactive.ts` is a cycle, and a server module loaded
-// first that imports the core directly meets `MEMBER_KEYS` before it is initialised.
+// first that imports the core directly meets `MEMBER_KEYS` before it is initialized.
 export {
     abandonLoad,
     deadlineOf,