@abide/abide 0.123.2 → 0.124.0

package/src/shared/RPC_SERVER.ts

@@ -1,9 +1,10 @@
 /**
  * What an `Rpc` asks of the server it runs on, as slots the server fills.
  *
- * Filled by `#server/installServer.ts`, and `raw` by `bootApp`: the request a rung is handed (16.11),
- * the app a `raw` call is answered by in process (16.42), and where a call reports the value it
- * reached, so a page's render can leave it for the browser's own call (41.13). A leaf, for
+ * Filled by `#server/installServer.ts`, `raw` by `bootApp` and `following` by each app's followers:
+ * the request a rung is handed (16.11), the app a `raw` call is answered by in process (16.42), where
+ * a call reports the value it reached, so a page's render can leave it for the browser's own call
+ * (41.13), and who a trigger reaches (18.3). A leaf, for
  * `CURRENT_ROUTER`'s reason: the isomorphic `Rpc` reads these and a browser bundle must not reach
  * what fills them.
  */
@@ -18,33 +19,30 @@ export const RPC_SERVER: {
      */
     timeout: () => number | undefined
     /**
-     * A trigger on an `Rpc`, sent to every browser following what its pattern names.
+     * Every app's followers while anyone follows (`#server/Followers.ts`), which a trigger reaches.
      *
-     * 7.10, 7.18.
+     * Empty in a browser, where a trigger is the copy's own.
      */
-    broadcast:
-        | ((
-              rpc: object,
-              member: 'invalidate' | 'refresh',
-              pattern: unknown,
-          ) => void)
-        | null
-    /**
-     * A free trigger, sent to every followed copy carrying one of `tags`, or to every one where
-     * `tags` is `null`.
-     *
-     * 13.15.
-     */
-    swept:
-        | ((member: 'invalidate' | 'refresh', tags: string[] | null) => void)
-        | null
-    /**
-     * 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, key: string) => void) | null
+    following: Set<{
+        /** A trigger on an `Rpc`, sent to every browser following what its pattern names. 7.10, 7.18. */
+        broadcast(
+            rpc: object,
+            member: 'invalidate' | 'refresh',
+            pattern: unknown,
+        ): void
+        /**
+         * A free trigger, sent to every followed copy carrying one of `tags`, or to every one where
+         * `tags` is `null`. 13.15.
+         */
+        sweep(member: 'invalidate' | 'refresh', tags: string[] | null): void
+        /**
+         * 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, key: string): void
+    }>
     /**
      * How long a handler's own body took inside its rungs.
      *
@@ -60,8 +58,6 @@ export const RPC_SERVER: {
     raw: null,
     reached: null,
     timeout: () => undefined,
-    broadcast: null,
-    swept: null,
-    served: null,
+    following: new Set(),
     handled: null,
 }

package/src/shared/Schema.ts

@@ -11,9 +11,8 @@
 // 19.6 IS THE OTHER HALF: coercion belongs to the pipeline and is never asked of a schema.
 // Together they are what lets 19.3 be enforced at all — see `runSchema`.
 
+import { issuesOf, note } from './issueReport.ts'
 import type { Issues } from './Issues.ts'
-import { issuesOf } from './issuesOf.ts'
-import { note } from './note.ts'
 import { isThenable } from './reactive/isThenable.ts'
 import { untracked } from './reactive/tracking.ts'
 

package/src/shared/applyPatch.ts

@@ -6,7 +6,7 @@
 // patch records passes, so the check costs a browser replaying its server nothing, and an op naming
 // `__proto__` or a member off the prototype chain is refused at 400 rather than reached. A `test` that fails is 409, the patch's precondition rather than its form.
 import { putOwn } from './putOwn.ts'
-import type { PatchOp } from './reactive/PATCH_SINKS.ts'
+import type { PatchOp } from './reactive/patchLog.ts'
 import { structural } from './reactive/structural.ts'
 import { refuse } from './refuse.ts'
 

package/src/shared/index.ts

@@ -119,4 +119,4 @@ export {
     url,
 } from './url.ts'
 export { validateJson } from './validateJson.ts'
-export { writePath } from './writePath.ts'
+export { mutatePath, writePath } from './writePath.ts'

package/src/shared/{note.ts → issueReport.ts}

@@ -1,3 +1,6 @@
+// AN ISSUES RECORD — what a refusal found, keyed by path (`Issues`, 15.8): filled one issue at a time
+// by `note`, and handed out by `issuesOf` in the shape the value refused calls for.
+
 import { putOwn } from './putOwn.ts'
 
 /**
@@ -22,3 +25,22 @@ export function note(
     if (Object.hasOwn(found, path)) (found[path] as string[]).push(said)
     else putOwn(found, path, [said])
 }
+
+/**
+ * Issues in the shape `Issues<T>` gives them for the value refused: by path for an object or an
+ * array, the bare list for anything else.
+ *
+ * DECIDED BY THE VALUE, because the value is all the runtime holds — `T` is erased. A scalar has
+ * no path to key by, so every issue about one stands on `''`, and handing back `{ '': [...] }`
+ * there is the wrapper `Issues<T>` says a reader never unwraps: `error().data[0]` read `undefined`.
+ */
+export function issuesOf(
+    found: Record<string, string[]>,
+    value: unknown,
+): Record<string, string[]> | string[] {
+    if (typeof value === 'object' && value !== null) return found
+    const listed: string[] = []
+    for (const path in found)
+        for (const said of found[path] as string[]) listed.push(said)
+    return listed
+}

package/src/shared/loadCall.ts

@@ -0,0 +1,66 @@
+// THE CALL STARTING A LOAD, while it starts (16.49, 16.81, 46.7). `callLoad` opens it around the
+// synchronous reach and closes it after, and a transport's body — the browser's wire — reads it as
+// it starts: the core runs a body's first step inside the reach, so the call is still open there
+// and closed by the time anything the body awaits comes back.
+//
+// THE ORDER IS THE INTERFACE. A body asks once, with `startingLoadCall`, and is handed what the call
+// carried rather than the live record, so a read made after an await cannot see a closed call — it
+// holds what it was handed. The writer's three verbs are the only way the record moves.
+//
+// A module of its own because `callLoad` (shared) opens it and the wire (ui) reads it.
+
+const STARTING: {
+    signal: AbortSignal | undefined
+    offline: ((args: unknown) => unknown) | undefined
+    /**
+     * Where the body that queues the call asks for the value the call reached, filled once the reach
+     * returns: what the delivered answer lands in (46.7).
+     */
+    standing: { value: unknown } | undefined
+} = { signal: undefined, offline: undefined, standing: undefined }
+
+/**
+ * Opens the call starting a load: the load's own abort `signal` (16.49) and the call's `offline`
+ * (16.81), for the body the reach runs.
+ */
+export function beginLoadCall(
+    signal: AbortSignal | undefined,
+    offline: ((args: unknown) => unknown) | undefined,
+): void {
+    STARTING.signal = signal
+    STARTING.offline = offline
+}
+
+/** Hands what the reach returned to a body that queued the call (46.7), where one asked. */
+export function reachedInLoadCall(reached: unknown): void {
+    const standing = STARTING.standing
+    if (standing !== undefined) standing.value = reached
+}
+
+/** Closes the call: a body started after this reads no signal, no `offline` and no stand. */
+export function endLoadCall(): void {
+    STARTING.signal = undefined
+    STARTING.offline = undefined
+    STARTING.standing = undefined
+}
+
+/**
+ * What the call starting this load carries, read by the body before anything awaits — both
+ * `undefined` for a load no call started (a refresh, a reload).
+ */
+export function startingLoadCall(): {
+    signal: AbortSignal | undefined
+    offline: ((args: unknown) => unknown) | undefined
+} {
+    return { signal: STARTING.signal, offline: STARTING.offline }
+}
+
+/**
+ * Where the value the call reaches will land, for a body that queues the call (46.7) — filled by
+ * `reachedInLoadCall` once the reach returns.
+ */
+export function standForLoadCall(): { value: unknown } {
+    const standing = { value: undefined }
+    STARTING.standing = standing
+    return standing
+}

package/src/shared/muxFrames.ts

@@ -3,7 +3,7 @@
 // `patch` an event stream writes as events (18.20), multiplexed by `id`.
 
 import type { Problem } from './Failed.ts'
-import type { PatchOp } from './reactive/PATCH_SINKS.ts'
+import type { PatchOp } from './reactive/patchLog.ts'
 
 /**
  * What a browser sends over the mux: a subscription, naming the version it holds (18.9), or its end.

package/src/shared/reactive/Keyed.ts

@@ -11,13 +11,13 @@ import { checkArgs } from '../refuse.ts'
 import type { Schema } from '../Schema.ts'
 import {
     ARGS_GATE,
+    canonicalKey,
     type Gated,
     normalized,
     PARAMETER_DEFAULTS,
 } from './argsContract.ts'
-import { canonicalKey } from './canonicalKey.ts'
 import { CELL } from './CELL.ts'
-import { ENTRY_LIVES } from './ENTRY_LIVES.ts'
+import { type Callable, type Cell, refuseBothCaps } from './cellShape.ts'
 import { armTimer } from './Expiry.ts'
 import { KEYED_BRAND } from './KEYED_BRAND.ts'
 import { matchesPattern } from './matchesPattern.ts'
@@ -28,14 +28,13 @@ import {
     createReactive,
     failedTransiently,
     isStreamBody,
-    leaveSelections,
     type Reactive,
     type ReactiveOptions,
-    refuseBothCaps,
     signalMoved,
     startDeferred,
     unwatchStore,
 } from './Reactive.ts'
+import { leaveSelections } from './selections.ts'
 import {
     detach,
     detachProbes,
@@ -43,7 +42,6 @@ import {
     newSubscriber,
     newTracked,
     type Subscriber,
-    type Tracked,
     TRACKING,
     trackProbe,
 } from './tracking.ts'
@@ -89,7 +87,7 @@ export function isKeyed(
  * The args are the entry's body argument and its cell already holds them for every run.
  */
 function argsOf(entry: unknown): unknown {
-    return (entry as { [CELL]: { args: unknown } })[CELL].args
+    return (entry as Callable)[CELL].args
 }
 
 // One entry of `Lifetime.followed`, which is in recency order: what an eviction needs beside when
@@ -97,11 +95,25 @@ function argsOf(entry: unknown): unknown {
 type Follower = {
     at: number
     ms: number
-    cell: Tracked & { servable: boolean; loading: boolean }
+    cell: Cell
     reader: Subscriber
     evict: () => void
 }
 
+/**
+ * Each followed entry's `Follower`, by its cell: when it last produced, and how long it lives (11.45).
+ */
+const ENTRY_LIVES = new WeakMap<Cell, Follower>()
+
+/**
+ * When the entry `cell` is stops being servable, by its `Keyed`'s `ttl` — infinity where it is no
+ * followed entry. What `deadlineOf` reads beside the value's own `ttl` (21.8).
+ */
+export function entryDeadline(cell: Cell): number {
+    const entry = ENTRY_LIVES.get(cell)
+    return entry === undefined ? Number.POSITIVE_INFINITY : entry.at + entry.ms
+}
+
 /**
  * The life of every entry of one `Keyed`, evicting each once `ttl` passes without a production.
  *
@@ -138,10 +150,10 @@ class Lifetime {
         this.timer = null
     }
 
-    follow(key: string, entry: { [CELL]: Tracked }, evict: () => void): void {
+    follow(key: string, entry: Callable, evict: () => void): void {
         // 11.33: `Infinity` is the life of the scope, which no timer here can reach.
         if (this.ms === Number.POSITIVE_INFINITY) return
-        const cell = entry[CELL] as Follower['cell']
+        const cell = entry[CELL]
         // A MIRROR WITH NO ADOPTER — `Subscriber.isMirror` says why.
         const reader = newSubscriber([cell], null, true)
         const follower: Follower = { at: 0, ms: this.ms, cell, reader, evict }
@@ -424,13 +436,9 @@ export function createKeyed<
         )
         entries.set(key, created)
         if (lifetime !== null)
-            lifetime.follow(
-                key,
-                created as unknown as { [CELL]: Tracked },
-                () => {
-                    release(key, created)
-                },
-            )
+            lifetime.follow(key, created as unknown as Callable, () => {
+                release(key, created)
+            })
         if (starts !== null)
             starts.reached(created, () => {
                 // 5.20: superseded before it started — not held, so a later reach starts afresh.