@abide/abide 0.53.0 → 0.54.0

package/src/lib/ui/watch.ts

@@ -8,6 +8,7 @@ import { effect } from './effect.ts'
 import { generationGuard } from './runtime/generationGuard.ts'
 import type { EffectResult } from './runtime/types/EffectResult.ts'
 import type { State } from './runtime/types/State.ts'
+import { untrack } from './runtime/untrack.ts'
 
 /*
 The single reaction primitive: `watch(source, handler)` names its trigger and runs
@@ -25,6 +26,14 @@ into a server bundle; server-side it is an inert no-op. Unlike bare `watch(…)`
 the SSR back-end strips — a `.watch(…)` member call survives to the server and relies on
 that inert stub.
 
+Tracking contract (ADR-0044): the named source(s) are the sole triggers — the handler
+is a sink, run untracked, so a reactive read in its body never becomes an accidental
+extra trigger. Only the bare `watch(thunk)` form auto-tracks everything it reads (that
+IS its job — it is the compiler binding). This makes all explicit-source forms uniform:
+the subscribable (cache.on, per-frame) and rpc (handler in a .then microtask) branches
+already ran their handlers out of the tracking window; the two synchronous cell branches
+now match by wrapping the handler in `untrack`.
+
 Sources (discriminated at runtime, monomorphic per branch):
   watch(thunk)                       // compiler binding form — auto-tracked, == effect(thunk)
   watch(count, n => …)               // a state cell → handler(newValue)
@@ -93,18 +102,22 @@ export function watch(
     ) {
         return reactToRpc(source, undefined, handler)
     }
-    /* Multiple cells → fire on any change; hand the handler the current values. */
+    /* Multiple cells → fire on any change; hand the handler the current values. Read every
+       cell (the tracked triggers), then run the handler untracked so a reactive read in its
+       body is not captured as an extra trigger (ADR-0044). */
     if (Array.isArray(source)) {
         const cells = source as ReadonlyArray<State<unknown>>
         return effect(() => {
             const values = cells.map((cell) => cell.value)
-            handler(values)
+            untrack(() => handler(values))
         })
     }
-    /* A single state cell → handler(newValue) on change. */
+    /* A single state cell → handler(newValue) on change. The cell read is the tracked
+       trigger; the handler is a sink, run untracked (ADR-0044). */
     const cell = source as State<unknown>
     return effect(() => {
-        handler(cell.value)
+        const value = cell.value
+        untrack(() => handler(value))
     })
 }
 
@@ -120,7 +133,7 @@ function isSubscribable(source: unknown): boolean {
 /*
 Reacts to an rpc's cached value: an effect that runs the smart read (subscribing
 its key synchronously, so the effect re-runs when the value changes — a refresh,
-a patch, an invalidate) and pipes the resolved value to the handler. Triggers the
+an amend, an invalidate) and pipes the resolved value to the handler. Triggers the
 read, unlike peek: `watch` observes a live query, so it keeps it flowing.
 */
 function reactToRpc(fn: unknown, args: unknown, handler: (value: unknown) => void): () => void {

package/src/serverEntry.ts

@@ -26,10 +26,12 @@ import { shell } from './_virtual/shell.ts'
 import { sockets } from './_virtual/sockets.ts'
 import { exitWithParent } from './lib/bundle/exitWithParent.ts'
 import { loadEnvFromBinaryDir } from './lib/cli/loadEnvFromBinaryDir.ts'
+import { broadcastAmend } from './lib/server/runtime/amendBroadcaster.ts'
 import { broadcastCacheStaleness } from './lib/server/runtime/cacheStalenessBroadcaster.ts'
 import { createServer } from './lib/server/runtime/createServer.ts'
 import { requestContext } from './lib/server/runtime/requestContext.ts'
 import { resolvePageSnapshot } from './lib/server/runtime/resolvePageSnapshot.ts'
+import { amendBroadcastSlot } from './lib/shared/amendBroadcastSlot.ts'
 import { cacheStalenessSlot } from './lib/shared/cacheStalenessSlot.ts'
 import { cacheStoreSlot } from './lib/shared/cacheStoreSlot.ts'
 import { createCacheStore } from './lib/shared/createCacheStore.ts'
@@ -40,6 +42,7 @@ import { pendingAsyncCellsSlot } from './lib/shared/pendingAsyncCellsSlot.ts'
 import { resolvedCellsSlot } from './lib/shared/resolvedCellsSlot.ts'
 import { runningAsStandaloneBinary } from './lib/shared/runningAsStandaloneBinary.ts'
 import { sharedCacheStoreSlot } from './lib/shared/sharedCacheStoreSlot.ts'
+import { socketTailsSlot } from './lib/shared/socketTailsSlot.ts'
 import { streamedCellsSlot } from './lib/shared/streamedCellsSlot.ts'
 
 /*
@@ -89,6 +92,14 @@ so its server socket code never enters the client reachability graph.
 */
 cacheStalenessSlot.resolver = () => broadcastCacheStaleness
 
+/*
+Server-side amend(args, value) broadcasts the keyed value to every authorized reader
+instead of mutating a throwaway request store (ADR-0043). Imported ONLY here so the
+broadcaster's socket code never enters the client reachability graph — the same import
+discipline as the staleness broadcaster above.
+*/
+amendBroadcastSlot.resolver = () => broadcastAmend
+
 /* One process-wide fallback list for reads with no request in flight (boot/cron/socket) —
    real requests each carry their own `pendingAsyncCells`, so the SSR barrier drains a
    per-request list and concurrent renders never cross-contaminate. */
@@ -99,6 +110,10 @@ const sharedResolvedCells = { entries: [] }
 resolvedCellsSlot.resolver = () => requestContext.getStore()?.resolvedCells ?? sharedResolvedCells
 const sharedStreamedCells = { entries: [] }
 streamedCellsSlot.resolver = () => requestContext.getStore()?.streamedCells ?? sharedStreamedCells
+/* No shared fallback: `defineSocket.peek` records into this on every retained-frame read, including
+   reads outside any request (ws handlers, boot) — a fallback list would accumulate entries no render
+   ever drains. Off-request this resolves undefined and the record is skipped (see socketTailsSlot). */
+socketTailsSlot.resolver = () => requestContext.getStore()?.socketTails
 const sharedDocSnapshots = { entries: [] }
 docSnapshotsSlot.resolver = () => requestContext.getStore()?.docSnapshots ?? sharedDocSnapshots
 

package/src/lib/shared/patch.ts

@@ -1,41 +0,0 @@
-import { cache } from './cache.ts'
-import type { CacheOptions } from './types/CacheOptions.ts'
-import type { CacheSelector } from './types/CacheSelector.ts'
-import type { RemoteFunction } from './types/RemoteFunction.ts'
-
-/*
-Mutate the retained value of the matching cached read(s) in place — reactive
-(readers re-render), no network. The optimistic-update / real-time primitive:
-patch a cached list from a socket frame (`on(chat, m => getList.patch(l => [...l,
-m]))`) or apply an optimistic edit before a write lands. The updater receives the
-current decoded value and returns the next.
-
-  patch(getFoo, args, updater)   → that exact call
-  patch(getFoo, updater)         → every args-variant of that rpc
-  patch({ tags }, updater)       → every entry sharing a tag
-
-Instance sugar `getFoo.patch(args?, updater)` ≡ `patch(getFoo, args, updater)`.
-The updater is always the last argument; a not-yet-read key has nothing to patch.
-*/
-// @documentation cache
-export function patch<Args, Return>(
-    fn: RemoteFunction<Args, Return> | ((args?: Args) => Promise<Return>),
-    args: Args | undefined,
-    updater: (current: Return) => Return,
-): void
-export function patch<Args, Return>(
-    fn: RemoteFunction<Args, Return> | ((args?: Args) => Promise<Return>),
-    updater: (current: Return) => Return,
-): void
-export function patch<Return>(
-    selector: Pick<CacheOptions, 'tags'>,
-    updater: (current: Return) => Return,
-): void
-export function patch(selector: unknown, argsOrUpdater: unknown, maybeUpdater?: unknown): void {
-    /* Updater is always last: 3 args → (selector, args, updater); 2 args → (selector, updater). */
-    const updater = (maybeUpdater !== undefined ? maybeUpdater : argsOrUpdater) as (
-        current: unknown,
-    ) => unknown
-    const args = maybeUpdater !== undefined ? argsOrUpdater : undefined
-    cache.patch(selector as CacheSelector<unknown, unknown>, args, updater)
-}

package/src/lib/ui/compile/COMPOUND_ASSIGNMENT_OPERATORS.ts

@@ -1,19 +0,0 @@
-import ts from 'typescript'
-
-/*
-Maps a compound-assignment operator to its plain binary counterpart, for lowering
-`x += y` into an unconditional read-combine-write. Logical assignments
-(`||=`/`&&=`/`??=`) lower the same way — the patch/cell write always fires,
-consistent with how `+=` lowers. Shared by lowerDocAccess (the `$$model` write path)
-and renameSignalRefs (the `$$writeCell` linked-cell path) so the two lowerings can't
-drift.
-*/
-export const COMPOUND_ASSIGNMENT_OPERATORS = new Map<ts.SyntaxKind, ts.BinaryOperator>([
-    [ts.SyntaxKind.PlusEqualsToken, ts.SyntaxKind.PlusToken],
-    [ts.SyntaxKind.MinusEqualsToken, ts.SyntaxKind.MinusToken],
-    [ts.SyntaxKind.AsteriskEqualsToken, ts.SyntaxKind.AsteriskToken],
-    [ts.SyntaxKind.SlashEqualsToken, ts.SyntaxKind.SlashToken],
-    [ts.SyntaxKind.BarBarEqualsToken, ts.SyntaxKind.BarBarToken],
-    [ts.SyntaxKind.AmpersandAmpersandEqualsToken, ts.SyntaxKind.AmpersandAmpersandToken],
-    [ts.SyntaxKind.QuestionQuestionEqualsToken, ts.SyntaxKind.QuestionQuestionToken],
-])