@abide/abide 0.57.1 → 0.100.0

package/CHANGELOG.md

@@ -1,1777 +1,7 @@
-# abide
+# @abide/abide
 
-## 0.57.1
-
-### Patch Changes
-
-- 866c96d: degrade a mangled **SSR** payload to a cold boot (ADR-0051) ([`adfee02`](https://github.com/briancray/abide/commit/adfee024d570e8bf46230fac1fa2521fcaae056f))
-- 1abc943: Reuse the keyed-list (`{#for}`) reconcile scratch across passes so a steady-state reconcile allocates nothing
-
-    Each `each` reconcile built two fresh arrays per list change — `list.map(keyOf)` for the desired keys and `new Array(n)` for the resolved rows — then threw them away. On a list re-reconciled per keystroke that churn showed up as avoidable minor-GC pressure mid-interaction. The two buffers are now hoisted into persistent per-`each` scratch, reused every pass and cleared down to the live length on shrink (so no disposed-row references are retained). The `keyOf` pass is fused into the resolve loop — still exactly one `keyOf` call per item. Behaviour is unchanged: keyed diffing, in-place row updates, duplicate-key collapse, and prune-before-place all resolve identically; only the per-pass allocation is gone. The `[...source]` materialization for non-array iterables (generators must be drained) is unchanged.
-
-- e137242: `spreadAttrs` — swallow a per-key suspend on a `{...rest}` spread
-
-    A `{...rest}` spread guards its enumeration against a pending blocking `await` read, but not the per-key value read. When `source()` is a restProps proxy (the `<Button {...rest}>` case), its `get` invokes the underlying prop thunk, so a key whose expression reads a still-pending blocking cell suspends inside `bindKeys` — after the enumeration guard has already passed — and the `SuspenseSignal` escaped the render, killing the mount (seen as a crash on a cold client remount, e.g. navigating back to a page whose top-level blocking cells re-fetch and are briefly `pending()`). The per-key read now catches the suspend and binds the key as a deferred attribute (its `attr` effect swallows the signal and fills the value in on settle), matching `attr` and the deferred-enumeration branch; event handlers, whose thunks return a function without reading a cell, never suspend and stay on the listener path.
-
-- 7367a23: SSR hydration payload ships as inert JSON instead of executable JavaScript (ADR-0051)
-
-    The `window.__SSR__` boot payload now ships as `<script type="application/json">` parsed once by the deferred client bundle with `JSON.parse`, rather than a `window.__SSR__ = {…}` statement the browser had to compile and evaluate as a multi-MB program on the critical path. The global still exists for debugging — the bundle republishes it after parsing. Additionally, a json cache body is now seeded pre-parsed (`data`) rather than as a re-escaped JSON string nested in the payload, so it's single-encoded (roughly half the wire bytes and gzip for a json-heavy grid) and read without a second parse. Warm-seed semantics — zero refetch, zero hydration divergence — are unchanged.
-
-## 0.57.0
-
-### Minor Changes
-
-- d09e821: `errorTtl` — opt a failed RPC load into the negative cache
-
-    By default a failed load evicts immediately so the next read retries. Setting `errorTtl` on an endpoint's `cache` policy (or a producer's `cache()` options) retains the failure for that many milliseconds instead: reads within the window re-surface the same rejection with no network round-trip — backing off a failing or rate-limited backend rather than hammering it — then the entry hard-evicts and the next read retries. The function form `errorTtl: (status) => number | undefined` returns a per-status window (`status` is `0` for a network-level fault), or `undefined` to keep the immediate-retry default for that status (e.g. back off a 429/503, retry a 500 at once). A `Retry-After` response header overrides the configured window as the authoritative delay. A negative-cached error is never shipped in the SSR snapshot, so it can't warm-hydrate a poisoned client entry.
-
-### Patch Changes
-
-- 3ce8963: Fix an async-cell warm-seed ordering bug where a `linked` cell reading a blocking dependency could desync SSR and client
-
-    An async cell's warm-seed key is `${scope.id}:${index}`, where `index` is a per-scope counter drawn in construction order. Only a cell that actually becomes async draws one — and a `linked` seed becomes async (drawing an index) only when it _suspends_ by reading a still-pending blocking dependency, otherwise it resolves synchronously to a plain `state` and drew none. Because a blocking dependency is typically in flight on the server (the `linked` suspends → index drawn) but already warm-adopted on the client (the `linked` resolves synchronously → no index), every async cell declared _after_ the `linked` in the same scope keyed off-by-one across the handoff and warm-adopted the wrong cell's value (e.g. a grid cell rendering the layout string it followed). `linked` now reserves its ordinal on the synchronous path too, so it always occupies exactly one index — the same invariant `computed` already has from its static `async`-function routing — and downstream keys line up on both sides.
-
-- e8fb019: Type a bare no-`await` promise/stream `state.computed` seed as pending (`T | undefined`)
-
-    `state.computed(getRates())` (no `await`) routes to a STREAMING cell at runtime — it peeks `undefined` while pending — but the type-check shadow projected it as the resolved `T`, so an unguarded read (`rates.map(...)`) type-checked yet could hit `undefined` at first paint. It now projects through `$$cellValuePending` (`T | undefined`), matching the runtime and the semantically identical `state.computed(async () => getRates())` form. A blocking `state.computed(await getRates())` (suspends until resolved) and a genuinely sync seed are unchanged.
-
-    Consuming such a cell with `{#await rates}{:then data}` still binds `data` as the RESOLVED value: the shadow's `{#await}` lowering now strips the pending `undefined` off a bare pending-cell subject (mirroring the runtime's `$$awaitSubject`, ADR-0047), so the idiomatic await/then path stays free of `| undefined` noise. Direct reads should guard with `?.`/`??`.
-
-## 0.56.0
-
-### Minor Changes
-
-- lift buried async sub-expressions in state/linked/computed seeds (ADR-0032, script side) ([`6b269f4`](https://github.com/briancray/abide/commit/6b269f45d8ab2e117d62684620542cfd1199631e))
-- a linked seed that reads a pending blocking cell becomes a blocking AsyncState ([`8329365`](https://github.com/briancray/abide/commit/83293652689d6a95c8cf4ffe66722e33be1aa63b))
-- a034b2d: `linked` seed that reads a pending blocking cell becomes a blocking `AsyncState`
-
-    A `linked()` whose seed transitively reads a blocking (`await`-marked) async cell used to throw a `SuspenseSignal` out of its eager reseed effect at construction — the effect is a leaf with no reader to swallow the suspend, so it escaped to the caller. The classification probe now routes a seed that suspends to a writable async cell, and that cell marks itself blocking when its seed synchronously suspends, so its own reads pause too. A blocking read now behaves the same inside a `linked` seed as it does in a `computed` seed or a template binding.
-
-- a034b2d: Lift buried async sub-expressions in `state` / `state.linked` / `state.computed` seeds
-
-    A script seed whose argument buries a promise/stream call — `state.linked(getSession()?.filteredSources ?? [])` — now lifts that call to an injected streaming peek-cell, exactly as a `{#if getSession()?.x}` template position already does. It reads `undefined` while pending (composing with `?.`/`??`) instead of type-erroring on `Promise.filteredSources`, and reseeds when the source resolves. A bare whole-seed call/identifier (`state.computed(getRates())`, `chat.done()`) is unchanged — only a compound seed that buries an async call is lifted. This closes the gap where the script side was less forgiving than the template side.
-
-## 0.55.0
-
-### Minor Changes
-
-- b000b40: accept a cache policy on mutating helpers ([`4ddc496`](https://github.com/briancray/abide/commit/4ddc496a1a4c9250f83d6dcbb8711be96f1aeded))
-- dcf9868: Hydration internals consolidated — one pass owner, shared claim verbs, one recovery dance, one child adopter.
-
-    - `runHydrationPass` now owns the hydration pass lifecycle (claim cursor, cache-withhold window, render pass, and the two-phase seed consume) — both entry sites (`hydrate`, the router's hydrating first mount) run the same bracket.
-    - The claim-cursor mechanics live in four verbs (`claimMarker`, `claimRun`, `claimText`, `parkCursor`) instead of ~15 hand-rolled advance sites across the dom helpers; helpers keep their hydrate-vs-create branch and divergence policy.
-    - `discardAndRebuild` carries the shared divergence-recovery dance (remove the SSR boundary, build fresh with the cursor cleared) for the await/try blocks and the child adopter.
-    - **Removed export:** `abide/ui/dom/mountStreamedChild` — `abide/ui/dom/mountChild` is now the single dual-mode child adopter (it probes the markup for inlined vs streamed, so the client build needs no hoistable-child knowledge). Both are compiler-emitted plumbing an author never imports; compiled output now always emits `$$mountChild`.
-    - Congruence decisions once mirrored by hand across the two compiler back-ends are now single shared sites: the branch render-path segment alphabet (`BRANCH_SEGMENT`), the `{#await}` bare-cell subject classification (`awaitSubjectExpr`), and `<Child/>` render-path ordinals (`componentOrdinals`, one document-order walk — fixing a latent SSR↔client ordinal desync for a `{:default}` case that isn't last and for components in slot content).
-    - Warm-seed adoption is two-phase (ADR-0048 first slice): a hydration pass marks the `CELL_SEED`/`DOC_SEED` entries it adopts and deletes them only on a clean exit, so a desync throw hands the seeds to the cold rebuild directly — the `warmSeedBackup`/`restoreWarmSeeds` shadow-copy recovery is deleted.
-
-    Server markup and authored APIs are untouched (the `__abideSeeds` wire-global change ships separately).
-
-- f1e925e: `await` now blocks a **script** read the same way it blocks a template read — pending propagates through the whole dependency graph (ADR-0046).
-
-    Previously only _template_ reads of an `await`-marked `computed`/`linked` cell suspended; a _script_ read (a `computed`/derive seed like `computed(() => result.root)` over a blocking `result`) peeked `undefined` while pending, so on a cold client navigation a downstream script derivation dereferenced `undefined` and crashed. Now a read of a pending blocking cell suspends its reader wherever it happens: a derive over it withholds and re-runs on settle, an async seed that reads a pending blocking dependency stays pending (not error), and the SSR barrier drains to a fixpoint so chained blocking cells resolve in order and bake correct values into the first-pass HTML.
-
-    Whether a read pauses is now a property of the **cell** (its `blocking`/`await` bit — the same one that decides SSR-barrier registration), not of the read site: there is one read callee, `$$readCell`, script and template, client and server. The separate `$$readCellBlocking` codegen path and the `abide/ui/dom/readCellBlocking` export are removed; bare/streaming reads (no `await`) are unchanged.
-
-    **Breaking:** a script read of an `await` cell now suspends where it previously returned `undefined` while pending. Read a blocking cell inside a `computed`/derive or the template — a plain top-level `const x = cell.field` cannot pause (it is not a graph node) and is fatal at mount, exactly as `undefined.field` already was.
-
-### Patch Changes
-
-- b000b40: runHydrationPass owns the hydration pass lifecycle ([`0ede531`](https://github.com/briancray/abide/commit/0ede531971e6c351397c2c8c4eea248c37bdd399))
-- b000b40: abide check reads a bare async {#for} source as its resolved peek ([`10b78cf`](https://github.com/briancray/abide/commit/10b78cfe46ef5c6719087ed29f6238ed0d91f348))
-- b000b40: code-review fixes across the reactive core, hydration seeds, and {#await} ([`1d91f49`](https://github.com/briancray/abide/commit/1d91f491bc16f3120f1e513a0db0a6e2e225c77f))
-- b000b40: anchoredBranch owns anchor parking; await/try use advanceClaim ([`473f289`](https://github.com/briancray/abide/commit/473f2894ae02bcbcd67c4ca5d6b45b7de9b1439c))
-- b000b40: name the hydration-cursor advance (advanceClaim) ([`50a2d3d`](https://github.com/briancray/abide/commit/50a2d3d69cfbd82effb2980ba53e58011928dc47))
-- b000b40: consolidate simplify cleanups across shared/ui ([`5956928`](https://github.com/briancray/abide/commit/595692861152619c95a8a7eb83f48fd6d016ec37))
-- b000b40: two-phase warm-seed consume replaces the shadow-copy recovery ([`5b07997`](https://github.com/briancray/abide/commit/5b07997bb7cd01112161f5e67f698e438a96ce1b))
-- b000b40: one degradation site for every hydration seed ([`5bb7fd4`](https://github.com/briancray/abide/commit/5bb7fd490ba2b401cf5c88d616b5ba6c1e420aa5))
-- b000b40: branch segments, await subjects, and child ordinals decided once ([`6f2981d`](https://github.com/briancray/abide/commit/6f2981d5ac49c14b693228c41c14dc54e92a3367))
-- b000b40: appendTextAt's create path delegates to appendText ([`a178acd`](https://github.com/briancray/abide/commit/a178acd4a2dc21477b722a95da99c63d77b794bd))
-- b000b40: hydration claim verbs own the cursor mechanics ([`a624939`](https://github.com/briancray/abide/commit/a624939eb2ff625e4a52c06bf324c45b02ec6d51))
-- b000b40: auto-wrap nested-<script> state.computed/linked bare seeds ([`c4aa0eb`](https://github.com/briancray/abide/commit/c4aa0ebb686875236ba945c15de88278098b10b8))
-- b000b40: mountStreamedChild delegates every mount to mountChild ([`d794580`](https://github.com/briancray/abide/commit/d794580572610304019b698340b5477b7a326241))
-- b000b40: regenerate AGENTS.md + README for amend and cache-on-mutating surface ([`ddef71c`](https://github.com/briancray/abide/commit/ddef71c8ffceab01dcea2a2e49397df29795be2e))
-- 856901e: `{#await <cell>}` now awaits an async cell's resolution instead of peeking its `undefined`-while-pending value (ADR-0047).
-
-    `{#await rates}` where `const rates = state.computed(getRates(...))` used to lower its subject to `$$readCell(rates)` — a peek — so a pending cell read `undefined`, fired `{:then}` immediately, and `{:then data}` crashed dereferencing `data.foo` on `undefined`. (`{#if}`/`{#switch}` cell subjects already avoided this with a `cellPending` guard; `{#await}` never got the equivalent, so it regressed the day a `computed`/`linked` of an async source became a peek-cell.) A bare cell subject is now passed raw and normalised by `$$awaitSubject`, which resolves an async cell to a promise-of-its-value (showing the pending branch until it settles, then `{:then}`, or `{:catch}` on error — SWR on a refresh) and unwraps a lazy `computed(promise)` to its held promise. `{#await getFoo()}` (a plain promise) is byte-identical, on the client, on hydrate, and in the SSR stream.
-
-- d33ed87: `computed`/`linked` now honor the bare-seed contract (ADR-0045) when a bare seed reaches the runtime literally — a branch-nested `<script>` (`{:then names}` + `let total = state.computed(names.length)`) or a direct JS caller. The compile-time `wrapSeed` normalization only covers a component's leading script; a nested branch script keeps its calls literal, so the raw value hit the primitive: `computed(3)` stored `3` as the node's compute and the first read crashed (`node.compute is not a function`), killing the SSR stream mid-drain — a blank page after the shell. Both primitives now route a non-function seed by value: a promise → a streaming async cell, a stream → a frame cell, any other value → a constant seed. Regression-tested against the kitchen-sink templating/async live demo shape.
-- f4e98bd: A bare rpc read (`fn(args)`) no longer derives its cache key twice. The callable already computes `keyForRemoteCall(method, url, args)` to tag its rpc-error registry entries, then `readThrough` re-derived the identical string (`callable.raw` carries the same method/url) on every read — a query-string encode for GET/DELETE or a canonical-JSON stringify for body methods, warm cache hits included. The callable now threads its key into `cache.read` and `readThrough` reuses it; the public `cache()` and raw paths still derive their own. Behavior is unchanged — the two keys were provably identical — this just removes the duplicate work from the framework's primary read path.
-- e8f2144: `invalidate(fn, args)`, `refresh(fn, args)`, and `amend(fn, args)` now resolve their target entry with a direct store lookup instead of scanning every cache entry in every store. A `fn + args` selector identifies exactly one key, so the full-store scan it previously ran was O(total cache entries) work to act on a single known key — noticeable for `amend`, which the real-time path can fire once per incoming socket frame. Behavior is unchanged (the scan is still used for bare-fn, tag, and wire-driven selectors that can match many entries); this is purely a hot-path optimization.
-- 171fdee: One hydration seed manifest: the four passive warm-seed globals (`__abideResume`, `__abideCells`, `__abideDocs`, `__abideSockets`) collapse into one kind-partitioned `window.__abideSeeds` (ADR-0048). The in-bundle names (`RESUME`, `CELL_SEED`, `DOC_SEED`, `SOCKET_SEED`) stay as views onto its partitions, so consumers are unchanged; the inline SSR swap/seed scripts write the `resume` partition. Each partition self-initializes, so the vanilla scripts and the bundle compose in either run order. The live streamed-cell machinery and the head collector buffer stay separate — they are apply-timing phases (ADR-0040), not passive manifests. Internal wire-shape change only; `__SSR__` and all authored APIs are untouched.
-
-## 0.54.0
-
-### Minor Changes
-
-- 7cd75d7: `amend` is now isomorphic like `invalidate`/`refresh` (ADR-0043): called on the client it mutates the local cache, but called on the **server** with a concrete value it broadcasts that value to every client reading the call — a push-refresh with zero refetches.
-
-    `amend` gains a value form alongside the updater form. The last argument may be a concrete `Return` (set it) or an updater `(current) => Return` (transform it); for a no-input rpc the args collapse (`getFoo.amend(value)`), matching how `fn()` vs `fn(args)` already read. From the server, only the value form broadcasts — an updater is a closure with no wire form and throws, and the value must target a keyed remote call (a producer/`{ tags }` selector throws). Delivery is confined to clients already reading that exact call (over a per-call reserved `__abide/amend/<key>` topic), so a pushed value reaches only readers already authorized for that key; a dropped frame heals on the next reconnect refresh. The updater form and client-side `amend` are unchanged.
-
-- 42354ba: A bare `state.computed(getFoo())` over an rpc now unwraps to the resolved value, so `{foo?.field}` renders and reactively updates — the pattern the docs and examples already teach.
-
-    Previously a no-`await` `state.computed(getFoo())` was classified as an opaque `Computed<Promise>` (ADR-0023 routing), so a template read like `{foo?.messages}` read `.messages` off a Promise and always showed `undefined`, with no cache reactivity reaching it. Now `getFoo()` and `await getFoo()` inside `state.computed(...)` differ only by SSR tier and are both unwrapped value cells (ADR-0045):
-
-    - `state.computed(getFoo())` — **streaming**: SSR ships the pending branch, the client resolves after hydration.
-    - `state.computed(await getFoo())` — **blocking**: SSR waits and bakes the value into the HTML (warm hydrate, never pending).
-
-    **Breaking behavior change:** `foo` is now a reactive value cell in both forms, never a `Promise`. Code that treated the bare binding as a thenable — `state.computed(getFoo()).then(…)` or `await foo` — no longer gets the fetch promise (it gets the unwrapped value, or `undefined` while pending). For an imperative one-off, call `await getFoo()` directly (cached/coalesced); to render with an await block use `{#await getFoo()}` inline; for a genuinely opaque `Computed<Promise>` binding use an explicit thunk, `state.computed(() => getFoo())`. `{#await foo}` on a bare computed still works (it reads the async-cell subject reactively).
-
-- 7bc2bfb: Rename the cache-mutation verb `patch` → `amend`. The word "patch" collided with the HTTP `PATCH` method (`abide/server/PATCH`) and the internal DOM-tree `Patch` type; `amend` names the same intent — mutate the retained value of matching cached reads in place, reactive, no network — without the overload.
-
-    **Breaking:**
-
-    - **`abide/shared/patch` is now `abide/shared/amend`.** The standalone `patch(fn, args?, updater)` / `patch({ tags }, updater)` is now `amend(...)` with identical signatures.
-    - **The rpc selector method `fn.patch(...)` is now `fn.amend(...)`.** `fn.amend(args?, updater)` ≡ `amend(fn, args, updater)`. Still fetch-only (omitted for a streaming rpc).
-
-    Mechanical rename — no behavior change. Update imports (`abide/shared/patch` → `abide/shared/amend`) and call sites (`.patch(` → `.amend(`). The HTTP `PATCH` method export is unaffected.
-
-- 88959d7: `watch(source, handler)` now runs the handler untracked — the named source(s) are the sole triggers (ADR-0044).
-
-    Previously the two cell forms (`watch(cell, h)` / `watch([a, b], h)`) wrapped the handler in an effect that captured _every_ reactive read in the handler body, so `watch(foo, () => { id = bar.id })` silently re-ran on `bar.id` as well as `foo`. The handler is now a sink: reactive reads inside it no longer become extra triggers. This makes the cell forms match the socket and rpc forms, whose handlers already ran outside the tracking window. Only the bare `watch(() => …)` binding form still auto-tracks everything it reads. If you relied on a handler-body read re-triggering the watch, name it as a source instead (`watch([foo, bar], …)`) or use the auto-track form (`watch(() => { id = bar.id })`).
-
-### Patch Changes
-
-- dc4ddfc: normalize pre-existing format drift ([`757f142`](https://github.com/briancray/abide/commit/757f1420b4e37064da1b5048d2f5d3b1a556b6fe))
-- 11965e9: Fix the JS semantics of reactive-state mutation expressions so `{ }` code behaves like plain TypeScript.
-
-    - **Logical assignments now short-circuit.** `count ??= 5` / `x ||= v` / `x &&= v` on reactive state (`state` slot or `linked` cell) now write **only when the guard passes** — `count ??= 5` no longer fires a redundant patch (and reseed) when `count` is already non-nullish. Previously every logical assignment lowered to an unconditional write.
-    - **Postfix `x++` / `x--` now evaluates to the previous value** (and prefix `++x` to the new value), matching JS. Previously postfix returned the stepped value.
-    - As a consequence, reactive writes now evaluate to the written value, so chained assignment (`a = b = count`) through a state slot works too.
-
-    Internally, `Cell.set` and `Doc.replace` now return the written value, and the two lowering sites share `lowerCompoundAssignment` / `lowerUpdateExpression` helpers so they can't drift.
-
-- 9773885: Warn when the type program for a project can't be built, instead of silently disabling async detection.
-
-    The type-directed async lowering (deciding whether `{getFoo()}` is a promise/stream and streaming it) depends on a warm shadow program built once per project root. If that program failed to build (e.g. a broken `tsconfig`), the failure was swallowed and **every** async interpolation in the project silently degraded to plain text — a bare `{getFoo()}` shipping as the literal `[object Promise]` with no signal. It now emits a one-time `console.warn` per root naming the cause, so a build with async detection disabled is visible. Behavior is otherwise unchanged (the build still never breaks on a program-build failure).
-
-- 0d9316e: `watch(cell.foo, handler)` is now a compile error instead of a silent no-op.
-
-    abide has no per-property cells — a member access on a cell is read once as a plain value, so `watch(s.foo, handler)` subscribed to nothing and the handler silently never fired. It was only flagged by a `console.warn` (easily lost in build output). It now fails compilation with a message pointing at the corrective forms: wrap it in a thunk (`watch(() => …(s.foo))`) or watch the whole cell (`watch(s, v => …)`). A member of a cell is never itself a cell, so this can never reject a valid `watch`.
-
-- 66e5d3b: Fix a hydration desync (and the dead page it could cascade into) when a render reads a `tail`-retaining socket's `peek(socket)`. At SSR the server holds the socket's retained frame so `peek` returns it; a not-yet-connected client's `peek` returned `undefined`, so any markup derived from it (e.g. `state.computed(() => peek(refreshStatus))`) disagreed with the server HTML and tripped a hydration mismatch — which discards the server markup and cold-renders.
-
-    Sockets now warm-seed their retained frame across SSR→client like async cells do: the server records each frame read via `peek(socket)` during the render, ships it in `__SSR__.sockets` keyed by socket name, and the client seeds the socket's latest frame before mount so `peek(socket)` returns the same value the server rendered. (Contrast `cache.peek`, which withholds on the client because the server materializes no cache value — sockets carry a real server value forward, so they seed instead.)
-
-    Also hardens the hydration-desync recovery: the discard→cold-rebuild path now re-primes the async-cell and doc-state warm-seed manifests the failed hydration pass consumed, so the cold rebuild re-adopts the SSR-resolved values instead of refetching. A cold refetch left blocking `await` cells pending, and a top-level blocking read sits in no suspense region, so its `SuspenseSignal` escaped the rebuild and killed the mount ("page threw while mounting"). The rebuild now reads settled — a live page with real data, no loading flash.
-
-    No public API change.
-
-## 0.53.0
-
-### Minor Changes
-
-- shadow narrows streaming cells to T|undefined + D7 barrier tripwire (ADR-0042 D5.2/D7) ([`034a384`](https://github.com/briancray/abide/commit/034a384bdfb5b482f818de757e10c2e2e88ac52c))
-- suspend interpolations/attributes on a pending blocking read (ADR-0042) ([`88da27c`](https://github.com/briancray/abide/commit/88da27c998666b7cca9149effd5f171f3adca8d1))
-- flip async-thunk blocking marker + emit $$readCellBlocking on the client (ADR-0042 D5/D6) ([`a3468fe`](https://github.com/briancray/abide/commit/a3468feacbb67ac9cd337ffa2e220b10af309324))
-- dormant client-suspense foundation for await-means-resolved (ADR-0042) ([`b5f6104`](https://github.com/briancray/abide/commit/b5f6104c41ea1d57d3347ae007cdb1b316a09784))
-- complete the client suspense withhold surface across all template effects (ADR-0042) ([`c5db314`](https://github.com/briancray/abide/commit/c5db314fa3e0ce18294f609be5fb43e5128970d0))
-- fa7bfed: `await` now means "resolved" for a cell and its dependents, with the client suspending to mirror the server flush barrier (ADR-0042). A blocking `await` read (`{await foo()}`, `const x = state.computed(await …)`, `{#if await …}`) reads as a resolved value on both sides: the server already blocks the flush until it settles, and the client now **withholds the reading region** (interpolation, attribute, `{#if}`/`{#each}`/`{#switch}` block) until the value resolves rather than rendering against a pending `undefined`. So `{sources.length}` on an `await` binding no longer needs `?.` and no longer crashes while pending — the region simply shows nothing until it settles, then reveals. After the first resolution a refetch never re-suspends (stale-while-revalidate); on hydrate the warm-seed keeps the read `refreshing()`, never `pending()`, so there is no flash.
-
-    **Breaking:**
-
-    - **The async modifier alone is no longer a blocking marker — `await` is.** `computed(async () => getFoo())` (an `async` thunk with no top-level `await`) now creates a **streaming** cell (ships pending, resolves on the client) instead of a blocking one. Add `await` — `computed(async () => await getFoo())` — to keep the blocking/inline-SSR behavior. `computed(await …)` and `computed(async () => await …)` are unchanged (blocking).
-    - **A streaming (no-`await`) async `computed`/`linked` now types as `T | undefined`.** Its read is honestly pending-able, so guard it with `?.`/`??` (matching the runtime). A blocking `await` binding stays `T`.
-
-    No new public API — the change is in how `await` lowers and types.
-
-### Patch Changes
-
-- document await-means-resolved (ADR-0042) ([`16ec341`](https://github.com/briancray/abide/commit/16ec341a6ea7da509919b37a1cdcc2f237e04c1c))
-- close await-suspense gaps and simplify the boundary (ADR-0042 review) ([`7f9fcbb`](https://github.com/briancray/abide/commit/7f9fcbbec862eba6da3103a6aca77d505ef6f58d))
-- type {:catch} bindings as unknown, not any (ADR-0042) ([`9a91522`](https://github.com/briancray/abide/commit/9a915229caf92914b5bcd9e5625153831783049d))
-- withhold pending blocking reads in {#await}/{#for await} subjects (ADR-0042) ([`e58b538`](https://github.com/briancray/abide/commit/e58b538f477c2bfcec654fd1a7aab65466cc956c))
-
-## 0.52.0
-
-### Minor Changes
-
-- 83f4e5e: warn on the inert watch(cell.member) source ([`554d3ff`](https://github.com/briancray/abide/commit/554d3ffbdef39a40ccb77c58017b759dbdcb17c2))
-- e0c200b: `abide check` now type-checks the project's `.ts` files too, not only `.abide` templates. The `.ts` files were already loaded into the shadow program to resolve component imports, but their own diagnostics were never reported — so a mistyped `navigate('/p/[id]', {})`, `url()`, or `fn.patch()` call (or any type error) in an rpc handler, `app.ts`, or a `$shared` helper passed `abide check` silently. It now surfaces there, making `abide check` a complete type-check (templates + `.ts`) rather than templates only. Scoped to the project's own root files — a dependency or monorepo sibling resolved on demand is not reported. No new public API.
-- 0858cd6: add `/completions <bash|zsh|fish>` to the generated CLI binary — prints a shell completion script that tab-completes command names and their `--flags` (with `--no-<flag>` for booleans). Candidates derive from the baked manifest via a live `/completions --query` callback, so completion always reflects the binary's real surface and can't drift from dispatch. No new public export.
-- f42c33c: Add a path-addressed hydration-divergence signal on the DEBUG-gated `hydrate` channel (`DEBUG=hydrate`, or `localStorage['abide-debug'] = 'hydrate'` in the browser). With the channel off, behavior is unchanged — a claim divergence still throws the hard guard and the router recovers cold. With it on: a **text** divergence warns with the render-path of the enclosing component/branch/row and keeps hydrating, so one reload surfaces every mismatch instead of aborting at the first; a **structural** divergence names its path before throwing; and an **attribute** divergence — previously invisible, since binding always overwrote the server value — now warns too. The render-path is coarse (it locates the component, the detail names the value) and the compiled class/style/prop setters aren't covered yet. No new public API.
-- fca2f95: add `abide/shared/invalidate` and broadcast both staleness verbs across clients (ADR-0041).
-
-    `invalidate(selector?, args?)` is reintroduced as the distinct DROP verb (next read reloads lazily; a mounted retained reader revalidates stale-in-place), paired with the existing `refresh` REFETCH verb. Instance sugar `fn.invalidate(args?)` sits beside `fn.refresh(args?)`.
-
-    Both verbs are now isomorphic: applied locally on the client, and on the SERVER they broadcast to every connected client over a reserved, server-publish-only `__abide/cache` socket (live-only, no replay — an offline client falls back to SWR staleness). **`refresh`'s server behaviour changed** from a local throwaway refetch that reached zero browsers to a cross-client broadcast — a semantic change to an existing public verb. Producer/closure and bare match-all selectors are not cross-client serializable and are rejected when broadcast from the server. The `__abide/*` socket namespace is now reserved (a user socket file may not declare it).
-
-- 1c1d115: add `abide/server/render` — `render(path, params?, query?)` renders a page route to its HTML string in-process, through the same pipeline (app.html shell, layout chain, params, inline rpc reads) an HTTP GET of that URL runs, so a page stays directly linkable and its emailed form is one call away. Arg shape mirrors `url()`/`navigate`.
-- ee96a2e: Plain `state(initial)` now warm-seeds from the server across hydration, so a nondeterministic initializer carries the server's value through instead of recomputing a divergent one on the client. `state(crypto.randomUUID())`, `state(Date.now())`, `state(Math.random())` — previously the client re-ran the initializer on hydrate and produced a different value than the SSR HTML (a divergence class the `hydrate` channel now reports). Each rendered scope's document snapshot is serialized into `__SSR__.docs` keyed by its render-path id (the same keying the async-cell warm-seed uses), and on hydration the first write to each slot adopts the server value (consume-once) while the throwaway fresh init is discarded. No new public API — same `state()` call, same authoring. Values that don't round-trip the wire codec (functions, class instances) or state read only client-side fall back to a cold init, unchanged.
-
-### Patch Changes
-
-- 83f4e5e: generate .d.ts augmentations before type-checking .ts files ([`5da85e2`](https://github.com/briancray/abide/commit/5da85e2a2f411c221bb552b60b187ebee836d3ba))
-- 83f4e5e: forward a 0-based completion index from the zsh wrapper ([`6d14ccd`](https://github.com/briancray/abide/commit/6d14ccd3aaa8467948fe78dbc4462b40c6ea6750))
-- 83f4e5e: dedupe mirrored maps, skip the inert reaction pass ([`b938e10`](https://github.com/briancray/abide/commit/b938e1058b10d0fa7881d9cd4e3f774bb1dc35c2))
-- 83f4e5e: reflect .ts checking, the hydrate channel, and state seeding ([`e97f0e0`](https://github.com/briancray/abide/commit/e97f0e0c3b4c5bafde99335663cb88d476ff64cc))
-- 83f4e5e: make the bare seed the idiomatic computed/linked form ([`f889416`](https://github.com/briancray/abide/commit/f889416eedab23346c870d491c75b7e0f361bd8e))
-- 83f4e5e: document invalidate, server-side broadcast, and CLI completions ([`fccc4b4`](https://github.com/briancray/abide/commit/fccc4b4e833ea49871c1a955743ce807d1902a28))
-- 090d28e: `abide check` (and the editor shadow) now type-check a `computed`/`linked` seed written with a top-level `await` — `state.computed(await load())` — as its resolved value, instead of flagging a spurious "top-level await" error and mis-typing the binding (which forced `as unknown as Awaited<…>` casts downstream). The shadow now mirrors the compiler's `wrapSeed` lowering: a non-thunk seed is normalised to a thunk (async when it carries a top-level await) and read through a helper that unwraps a promise/stream to the value a bare cell read peeks. A bare `state(await …)` — not a `computed`/`linked` seed — is still correctly flagged, since it genuinely breaks the synchronous build.
-- 129b404: Writing to a `linked` cell from a component `<script>` now works — `let draft = state.linked(() => source); draft = draft + 1` (and `+=`, `++`, `--`, `??=`). Previously the compiler lowered every `linked` reference through `$$readCell(name)` (a call), so an assignment target became `$$readCell(draft) = …` and the build failed with "Invalid assignment target" — only `bind:value={draft}` could write a linked cell, despite `linked` being documented as writable. Assignments to a `linked` binding now lower through a new `$$writeCell` helper (`abide/ui/dom/writeCell`) that dispatches `.value =` for a sync `State` seed and `.set(...)` for an async/stream `AsyncState` seed.
-- 9154f36: The client build of an `$rpc` module now emits a minimal module — the `remoteProxy` fetch plus only the top-level statements the endpoint `opts` transitively reaches — instead of keeping the whole handler file and trusting tree-shaking to drop the server bits. Previously, server code reachable from module-level handler support (the common `const db = getDb()` shape, where `getDb` imports `bun:sqlite`) survived handler-elision and was _loaded_ on the browser target, failing the build with a raw `Browser build cannot import Bun builtin: "bun:sqlite"` before abide's own reachability guard could give a guided message. Reachability is resolved through the warm rpc `ts.Program` (binder/checker), so an `opts` value built from a module-level const — `schemas: { input: inputSchema }` where `const inputSchema = z.object(...)` — keeps that const and its imports, while anything only the handler touches is never emitted. No public API change; the reachability guard for every other client-reaches-server edge is unchanged, and builds with no warm program fall back to the previous keep-the-file transform.
-
-## 0.51.0
-
-### Minor Changes
-
-- aec503f: make watch(cell, handler) reactive ([`4db4e3d`](https://github.com/briancray/abide/commit/4db4e3d21cb04dcad5463831621140ec00ccbbe2))
-
-### Patch Changes
-
-- aec503f: correct README/AGENTS and lead the async story with the bare call ([`c96e936`](https://github.com/briancray/abide/commit/c96e93682cc8e05762bcde7bb808850dfdb40b6f))
-
-## 0.50.1
-
-### Patch Changes
-
-- ef143f5: regenerate README + AGENTS surface map ([`8665efa`](https://github.com/briancray/abide/commit/8665efa7eb9f4106882cf246738c08e465d7e8d7))
-
-## 0.50.0
-
-### Minor Changes
-
-- 8fb06cf: Async values — `state` holds, `computed`/`linked` track, and a reactive `{#try}` (ADR-0019)
-
-    `state` is now a pure value-taker; `computed`/`linked` track an async source. A `computed(await …)` / `linked(await …)` seed unwraps its promise into an async cell, and a seed producing a stream (`NamedAsyncIterable`) auto-tracks its frames. Async cells wear the probe family (`peek`/`pending`/`refreshing`/`error`/`refresh`, standalone + instance) and have no `.value` — sync → `.value`, async → probes. `AsyncState` adds `set()`, latching a local write until the next reseed.
-
-    `computed(EXPR)` / `linked(EXPR)` now accept a bare expression (wrapped into a thunk unless it is already a `() => …`); a top-level `await` lowers to an eager `async () => …` so independent cells load in parallel, not in a waterfall.
-
-    `{#try}` is a fully reactive error boundary — it catches a throw from a _later_ re-run (where async errors live), not just the initial render, and heals back to the guarded content when the failing cell recovers (`refresh()` or a dependency change), no manual retry.
-
-    Also renames the internal `Subscribable<T>` type to `NamedAsyncIterable<T>` (shape unchanged).
-
-- b790726: Async template interpolation — `{await foo()}`, `{foo()}`, `{getStream()}` (ADR-0019 follow-up)
-
-    A template interpolation now understands async expressions, chosen by the expression's type (resolved through the shadow TypeChecker at build time — zero runtime cost, dev/prod consistent):
-
-    - `{await foo()}` — awaits the promise, **blocking** (bakes into the SSR HTML). Syntactic; desugars to a blocking `{#await … then}` block.
-    - `{foo()}` where `foo()` is a `Promise<T>` — **streaming** (real Tier-3 out-of-order SSR); desugars to a streaming `{#await}` block.
-    - `{getStream()}` where the expression is any `AsyncIterable<T>` (a socket, a streaming rpc, or a plain async generator) — renders the **latest frame**, live, as a stream cell.
-    - A `Promise`/`AsyncIterable` in a value slot that can't be rendered (an attribute, an `{#if}`/`{#switch}` head, a sync `{#each}` iterable) is a **compile error** with a hint, never a silent `[object Promise]`. `{#for await}` stays the sanctioned async-iterable position.
-
-    Errors compose with `{#try}`: a catch-less `{#await}` / `{#for await}` (and these new bare forms) now bubbles a rejection to the nearest enclosing `{#try}` instead of an unhandled rejection.
-
-    The type-directed lowering fails open to a plain read on any type-resolution hiccup, so it can never break a build; a component with no async interpolations is unaffected.
-
-- 53ad08f: Endpoint-declared cache policy; namespace the rpc opts (ADR-0020). All cache/stream policy moves onto the rpc definition and the smart bare call becomes `fn(args)` with no call-site options. Opts are namespaced and kind-scoped by type: `schemas: { input, output, files }`, `cache: { ttl, tags, throttle, debounce, shared }` and `stream: { n }` on read helpers, `outbox` on mutating helpers (a `cache` on a write, or `outbox` on a read, is a compile error). `cache.tags` accepts an arg-derived function. `swr` is removed — SWR is unconditional for replayable reads. `ttl` now defaults to Infinity: an entry is retained for its store's lifetime (the request on the server, the tab on the client), and `shared` alone memoises across requests; a write coalesces only. Endpoint policy also ships to the client so client-side reads honor the declared ttl/refetch clock/tags.
-
-    BREAKING: `inputSchema`/`outputSchema`/`filesSchema` → `schemas: { … }`; call-site cache options (`fn(args, { ttl, tags, … })`) → endpoint `cache: { … }`, and the smart bare call drops its second argument (`fn(args)`). `.raw(args, init)` keeps per-call transport options unchanged.
-
-- 5b2df3f: Type-directed async-cell classification (ADR-0023). A no-marker `computed`/`linked` stream seed now routes by the seed's checker type instead of a syntax heuristic: a stream produced by _any_ expression shape (`computed(obj.stream)`, a conditional) auto-tracks, where before only a bare call/identifier did, and a provably-sync seed skips the runtime probe. Resolved through the warm shadow program and **fails open** to the previous syntactic routing when no program is available; the `await`-marker path is unchanged.
-- 8a61f5b: SSR auto-streaming for pending bare async reads (ADR-0024). A triggered point read still pending at render-return now streams its value into the HTML (shell first, then a resolve chunk) instead of shipping buffered — the server triggers the read and drains it as it settles. A pending read is bounded by its own endpoint `timeout` (which 504s the in-process handler during SSR, shipping a `{ key, miss }` so the client refetches) — there is no separate SSR-stream deadline. A page with no async reads still ships buffered; the Tier-2 blocking barrier and Tier-3 `{#await}` streaming are unchanged.
-- bc83c22: Surface a handler's typed error branches into the generated OpenAPI (ADR-0030)
-
-    A handler's `error.typed(name, status, schema?)` return branches now flow into the generated OpenAPI spec the same way the success body reaches the 200. The warm server program's new `errorSchemasForModule` query walks the handler's return union, reads each `TypedError` brand's numeric status and projects its `data` type to JSON Schema; errors sharing a status combine under `anyOf`, and a nullary error surfaces its status with no body. The resolved map is baked at build time as `errorJsonSchemas` (paralleling `outputJsonSchema`) and `buildOpenApiSpec` merges each into `responses[status]` — never clobbering the 200. So one plainly-typed handler return documents the full contract: the 200 success body plus every typed error's status and payload, nothing declared twice.
-
-    `error.typed` now captures the status as a literal type (`Status extends number`) so the brand carries the exact code — a backward-compatible tightening of its return type.
-
-- 43289e5: Handler-input-typed RPC surface (ADR-0030 input side). The input-side mirror of the return-typed output surface: the warm server program (ADR-0025) gains an `inputSchemaForModule` query that projects the endpoint's input args to JSON Schema through `jsonSchemaForType` — the SAME `Args` bag `inputCoercionForModule` reads (the exported RemoteFunction's first call-signature parameter, `FormData` dropped), with File/Blob members excluded exactly as `filesSchema` stays out of `inputSchema`. The resolved schema is baked into `RpcRegistryEntry.inputJsonSchema`, and the OpenAPI parameters/request body, MCP `inputSchema`, and inspector input surface fall back to it when the author declared no `schemas.input` VALIDATOR (which still overrides it on every surface). This is a SHAPE description only — it is never wired into runtime validation, so it can't produce a 422; an author who wants runtime narrowing still declares `schemas.input`. A build-projected `inputJsonSchema` also makes a plainly-typed read handler advertisable to MCP/CLI without a hand-written `schemas.input` (shape-only, no runtime gate) — the same role a declared input schema plays. Fails open to `undefined` (no warm program / unresolvable Args / File-only body), so a surface behaves exactly as before.
-- fcbdeb2: error-recovering template parser ([`13244a4`](https://github.com/briancray/abide/commit/13244a43f0d73f7873cafc7e351285b89db2b245))
-- fcbdeb2: render-path survives a render's awaits via a server ALS pathStore (ADR-0033) ([`16d76fc`](https://github.com/briancray/abide/commit/16d76fc8c52d047740e9b1b520a8d045c5fb7ac8))
-- fcbdeb2: hoist independent SSR awaits to the render prefix (ADR-0034) ([`20f017c`](https://github.com/briancray/abide/commit/20f017ceb0646c71d8e9d1f352665801b259419f))
-- fcbdeb2: asyncIterable interpolation → stream cell (ADR-0019 stage D) ([`3293e45`](https://github.com/briancray/abide/commit/3293e45355ded950d487c63d1b5e6c9868e8fadc))
-- fcbdeb2: async-cell classify accepts any async iterable (ADR-0019) ([`41d78e7`](https://github.com/briancray/abide/commit/41d78e791d4260f23ceefc691c7504f3a7f4edec))
-- fcbdeb2: catch→catch updates err in place in reactive {#try} (ADR-0019 D3) ([`439dbd3`](https://github.com/briancray/abide/commit/439dbd3843845a9e74c0334b5cbc3d990897bdcb))
-- fcbdeb2: catch-less {#await}/{#for await} bubbles to enclosing {#try} (ADR-0019) ([`5f8dea8`](https://github.com/briancray/abide/commit/5f8dea8912af37ef20c8eb2a684cb20d4584ff89))
-- fcbdeb2: blocking Tier-2 barrier bakes async-cell values into HTML (ADR-0019) ([`659ed41`](https://github.com/briancray/abide/commit/659ed41cecadd8d5c2e74d2d3a11556d5ac9ff63))
-- fcbdeb2: async (sub)expressions lift to a peek-cell in every template position (ADR-0032) ([`72aaef6`](https://github.com/briancray/abide/commit/72aaef680dffd12b8ff9596c7ec9064b651b3445))
-- fcbdeb2: value-position guard for async interpolations (ADR-0019 stage E) ([`748fcb0`](https://github.com/briancray/abide/commit/748fcb00b6eb35b50650e0320f512e43e419a0ef))
-- fcbdeb2: Breaking: ttl defaults to Infinity — store lifetime, not ttl, ends a read (ADR-0020) ([`7715fd8`](https://github.com/briancray/abide/commit/7715fd8d368c8bd65a533452cbf8ba782355c26f))
-- fcbdeb2: render-path identity for async cells — warm-seed across SSR→client ([`8f123b3`](https://github.com/briancray/abide/commit/8f123b37cf07f6f836dfe034a4b2f68f8559d013))
-- fcbdeb2: type-directed interpolation — warm checker + promise→streaming (ADR-0019 stages B+C) ([`91cb6c6`](https://github.com/briancray/abide/commit/91cb6c65670709f53b2b90d300fcb4b84a95540a))
-- fcbdeb2: interpolation type classifier (ADR-0019, type-directed lowering stage A) ([`9351b18`](https://github.com/briancray/abide/commit/9351b18eadfe6cc4b6e9a690a84204a67e58a964))
-- fcbdeb2: Breaking: endpoint-declared cache policy; namespace rpc opts (ADR-0020) ([`95fa41c`](https://github.com/briancray/abide/commit/95fa41c81ccb62b8f16881a96a878ab6be2872bd))
-- fcbdeb2: reactive {#try} error boundary — both directions (ADR-0019 D3) ([`9b38fe6`](https://github.com/briancray/abide/commit/9b38fe65cc512e245eb6fe6a32ec8cd705a5227d))
-- fcbdeb2: warm-seed a streamed child's late async cells (ADR-0039) ([`a8acee3`](https://github.com/briancray/abide/commit/a8acee3ccf8a1c8f5d6813a844c7129615b3beb5))
-- fcbdeb2: ship endpoint cache/stream policy to the client stub (ADR-0020) ([`ae56080`](https://github.com/briancray/abide/commit/ae5608044e92057be224ee7967ce209bf9dc1005))
-- fcbdeb2: source-agnostic async cells for computed/linked (ADR-0019 D1) ([`bc04cbe`](https://github.com/briancray/abide/commit/bc04cbef933d72243c4d5d082431453e418ef2ee))
-- fcbdeb2: value-aware throwing peek for async-cell reads (ADR-0019 D3.2) ([`c19af9b`](https://github.com/briancray/abide/commit/c19af9b7e18e8d03cc24f8f2dd527ac346ff3476))
-- fcbdeb2: computed/linked wrap + await lowering (ADR-0019 D2) ([`c1dc57d`](https://github.com/briancray/abide/commit/c1dc57dcfab12bd11081e157a653b97cd951db70))
-- fcbdeb2: revive Date/Set/Map/bigint input args via a type-directed wire codec (ADR-0029) ([`c70e2f7`](https://github.com/briancray/abide/commit/c70e2f73d9946763f5fa8a1853942d6174cccb0e))
-- fcbdeb2: {await expr} interpolation → blocking await block (ADR-0019) ([`d11cbc2`](https://github.com/briancray/abide/commit/d11cbc2e995fdce6c1003b1db4ead6996431078e))
-- fcbdeb2: client rpc transform via module graph + reachability guard (ADR-0022 D2/D3) ([`ddf1fd2`](https://github.com/briancray/abide/commit/ddf1fd215cca169421cb0d5bcfba0a728ec196d8))
-- fcbdeb2: computed(getStream()) compile auto-track via trackedComputed (ADR-0019 D1) ([`e964253`](https://github.com/briancray/abide/commit/e964253dbb9d21e9a57acf0f2f94026561cdca86))
-- fcbdeb2: stream non-cache streaming-cell values, adopt post-hydration (ADR-0035 phase 1) ([`f553731`](https://github.com/briancray/abide/commit/f5537310af6396ea9359e5dc8f7fddafe301c4a1))
-- fcbdeb2: render-boundary streaming foundation + ADR-0039 ([`f83d828`](https://github.com/briancray/abide/commit/f83d82865eeb6a3e4ccc1cb824f24a9180755a89))
-- fcbdeb2: project handler input type into mcp/cli/openapi surfaces (ADR-0030 input side) ([`fd13fa1`](https://github.com/briancray/abide/commit/fd13fa185ba2617f350d416199016bd523c14d0d))
-- 6749824: Client-side input validation, always on (ADR-0026). When an rpc endpoint declares `schemas: { input }`, the client `remoteProxy` now validates the typed args against that schema before the fetch and, on a definitive failure, throws an `HttpError` shaped identically to the server's 422 (`kind: 'validation'`, the same field-error `data`) — no round-trip. A validator that _throws_ (a non-portable / async-resource refinement that can't run in the browser) falls through to the server instead of failing the call, so adding a schema can never break a request. Server validation stays authoritative and unconditional — the client check is a UX optimization only. No configuration: it runs whenever an input schema is present.
-- b0cb79a: Remove the durable outbox and other unreachable surface — a tighter core
-
-    **Breaking:** the durable-delivery outbox is gone. The `@abide/abide/ui/outbox` export (`outbox()`, `outbox.retry()`, `GlobalOutbox`), the `outbox: true` rpc option (POST/PUT/PATCH/DELETE), the reserved `kind: 'queued'` error, and `OutboxEntry` are all removed. A mutating rpc now simply fetches and throws; durable local-first delivery is left to userspace (wrap the call, park failures in your own persisted queue via `fn.raw`). `RemoteFunction` loses its `Durable` type parameter and `.outbox` face; `remoteProxy`'s `DurableOptions` is renamed `RemoteProxyOptions`.
-
-    Removing outbox also drops the client persistence stack it was the only caller of (`persist`, `localStoragePersistence`, `PersistenceStore`/`PersistHandle`) and a whole build-time type-query (`outboxForModule`) from the warm server program.
-
-    Alongside it, several never-wired internals were deleted: the withdrawn `Scope` capability methods (`record`/`persist`/`broadcast`/`undo`/`redo`/`canUndo`/`canRedo`) and their `history`/`sync` backends, the unused `Scope.child`/`Scope.root` tree helpers, and the per-patch `PatchEvent.inverse` pre-image (computed on every mutation but read by nothing since the journal left). No behavioural change for app code that didn't use these.
-
-### Patch Changes
-
-- d5c3a04: Route the rpc method + `outbox` build transforms through the warm server program (ADR-0025 phase 2)
-
-    Phase 1 warmed one per-root `ts.Program` over the server module graph and used it only for streaming detection (gated on a build-cost budget). Phase 2 lifts that budget — the ~0.5 s cold cost is paid once per root, amortized, and always fail-open — and routes the two remaining text-scanners through the same warm program:
-
-    - **HTTP method** now resolves off the export helper's _symbol_ (following import aliases and re-exports), so `export const x = read(fn)` where `import { GET as read }` correctly types as `GET` in the generated `rpc.d.ts`, where the `RPC_EXPORT` regex read nothing.
-    - **`outbox`** now resolves off the opts object's property _type_, lifting "must be an inline literal" to "must be statically known" — an imported const (`outbox: OUTBOX_ENABLED`) resolves to its literal `true` instead of erroring, and an `outbox:` mention inside the handler body is ignored.
-
-    Every query fails open to today's regex/char-scan (no warm program, an unresolvable node, or a checker throw → byte-identical to before), so this can only harden, never break, a build. The hand-rolled scanners remain as that fallback and as the residual span-finder for splicing.
-
-    Also adds a one-line build-start log (`[abide] building client bundle…`, one-shot builds only) so the program-warming pause at the start of `abide build`/`compile` isn't mistaken for a hang.
-
-- 831ae88: Streaming rpc detection resolves through a warm `ts.Program` (ADR-0025). Whether a handler streams (returns `jsonl()`/`sse()`) is now decided by the handler's **return type** via a warm per-project-root program, instead of scanning the handler body for the call name — which fixes the wrapper-indirection blind spot where a handler returning a stream through a helper function was misclassified as a point read on the client. Built once per project root (a one-time boot cost, reused across every rpc in the build) and **fails open** to the previous char-scan.
-- 95b4b13: Server-side type-directed query/form coercion (ADR-0028). A GET or form-encoded request delivers every field as a string, so a plain `z.object({ n: z.number() })` used to 422 on `?n=2`. The warm server program (ADR-0025) now reads the endpoint's wire `Args` type and stamps a build-time `coerce` plan of exactly which fields are numeric/boolean; `parseArgs` coerces those string values to their typed value before validation. Only fields the type declares numeric/boolean are coerced, so a string field that merely looks numeric (an id, a zip code, `'1.0'`) stays a string; a self-coercing schema's loose input is left for the schema to coerce; and with no warm program every field stays a string exactly as before (fail-open). Closes the long-standing `parseArgs` query-coercion TODO and completes the server half of client-side validation (ADR-0026).
-- aa21b7c: Type-directed wire codec — output/response path (ADR-0029)
-
-    A handler's structured RETURN values now round-trip to the client instead of being lost or crashing. Previously `json()` serialized via plain `JSON.stringify`, which dropped a `Set`/`Map` to `{}` and threw a 500 on a `bigint`.
-
-    - **Server encode (all clients).** `json()` now serializes through a value-directed wire replacer: a `Set` crosses as a JSON array, a `Map` as an array of `[key, value]` entries, a `bigint` as a digit string, a `Date` as an ISO string. The wire stays honest, tag-free JSON, so curl / OpenAPI SDKs read it and it matches the generated schema.
-    - **Client decode (abide clients).** The warm server program resolves the handler's success-body type to a per-field output plan (`date`/`bigint`/`set`/`map`) and bakes it onto the client `remoteProxy` stub. The proxy revives those fields off a decoded response, so a `Set`/`Map`/`bigint`/`Date` return arrives as the real runtime type. A genuine array is untouched; no plan / an unrevivable value fails open to the honest-JSON form.
-    - **Projector coherence.** The `ts.Type` → JSON Schema projection now maps `Set<T>` → `array` and `Map<K,V>` → an array of `[K,V]` tuples, so the generated OpenAPI 200 matches the actual bytes.
-
-    Deferred: nested/recursive descent, streaming-frame (`jsonl`/`sse`) encoding, and server-side in-process revival.
-
-- 52a7e5c: Type-directed structured input wire codec (ADR-0029). Generalizes ADR-0028's scalar query coercion to structured value kinds: the same warm server program now classifies a top-level `Args` field as a `Date`/`Set`/`Map` (by symbol identity through the checker) or a `bigint` (by type flag) and stamps it into the endpoint's build-time `coerce` plan. `parseArgs` revives each declared field from its plain-JSON wire form before validation — an ISO string → `Date`, a numeric string → `bigint`, a JSON array → `Set`, a JSON entries array (or object) → `Map` — so a `Date` GET argument or a non-abide JSON client's structured body reaches the handler as the right runtime type instead of a raw string/array. Top-level fields only; the wire stays tag-free (type-directed, not tag-directed) so a plain-JSON / OpenAPI client still reads it. Fail-open throughout: no plan, an unrevivable value, or an already-typed value (the abide client's own ref-json body, which already round-trips these kinds) passes through as today's behavior — never a throw. The symmetric response/output codec is deferred (the response path serializes with plain `Response.json`, which needs a server-side encode step first).
-- 8b9505d: Handler-return-typed RPC output surface (ADR-0030 D2). A `ts.Type` → JSON-Schema projector (`jsonSchemaForType`) generates an rpc's OpenAPI 200 / MCP `outputSchema` / inspector output shape from the handler's return type when no `schemas.output` validator is declared — the complement of `jsonSchemaForSchema` (which projects a runtime validator). It covers the subset abide's `json()`/`jsonl()` emit (primitives, string-literal `const`/`enum`, objects with `required`, `Record` → `additionalProperties`, arrays, tuples, unions with optional-stripping, `Date` → `date-time`, `bigint` → string per ADR-0029) and fails OPEN — an unsupported/unresolvable type projects to permissive `{}` (omitted at the top level), with a mandatory cycle guard so a recursive type can't infinite-loop; it never throws, so a projection gap can't break a build.
-
-    The warm server program gains a `returnBodySchemaForModule` query that resolves the same success-body `ts.Type`(s) as `returnBodyForModule` and runs the projector. Since the OpenAPI/MCP/inspector surfaces render off the runtime rpc registry (not the build-time program), the resolver plugin BAKES the projected schema into the server `defineRpc` call — stamped as `outputJsonSchema`, exactly like the ADR-0028 `coerce` plan — so the registry entry carries it at runtime. A declared `schemas.output` validator still overrides the projection (a runtime narrowing the type can't express); with neither, the surface omits the response schema exactly as before.
-
-- 32a2203: Handler-return-typed RPC surface foundation (ADR-0030). The warm server program (ADR-0025) gains a `returnBodyForModule` query: it reads the endpoint's success-BODY type off the handler's return type the same way streaming detection already reads it — unwrap `Promise`, drop the `TypedError` branches, take each success `TypedResponse<Body>` body (the type-side mirror of `RpcHelper`'s `SuccessBody<R>`). A streaming endpoint reports its per-FRAME type (the `AsyncIterable` element) and `streaming: true`, so a surface can describe one streamed item. Like every other server-program query it fails open to `undefined`. This is the output-side sibling of ADR-0028's `inputCoercionForModule` — the handler's return becomes the single source for the generated surfaces so a plainly-typed handler needs no redundant `schemas.output`. Consumer wiring (OpenAPI 200 / MCP `outputSchema` / `.d.ts`) is deferred: those surfaces want JSON Schema and the only projector today (`jsonSchemaForSchema`) runs off a runtime Standard-Schema object, not a TS type — a TS-type→JSON-Schema projector is the follow-up. Client typing needs nothing here: the caller's `Return` already flows natively from the imported rpc module (ADR-0022).
-- 3160daa: Factor the post-DCE metafile walk into a reusable analysis seam and add a bundle-budget diagnostic (ADR-0031 D2). The client build's `build.onEnd` reachability pass is now `bundleGraphFromMetafile` — one walk of `Bun.build`'s metafile into a `BundleGraph` (`{ modules, importerChain }`) that both the side-crossing guard (unchanged behavior) and a new consumer read. First consumer: a non-blocking bundle-budget warning — a project `src/` module that survives tree-shaking into the client bundle over 512 KiB earns an `abideLog.warn` with its import chain, so an accidentally-huge input becomes observable without a new bundler pass. Never fails the build; the only hard `onEnd` failure remains a real client-reachable `$server/*` violation. ADR-0031 D1 (sharpening the post-await tracking lint with the script-region classifier) is deferred: the spike found the classifier precise but the current warning already never fires on the inert captures it was meant to stop flagging.
-- 43289e5: Render-path identity now holds for async cells nested in control flow and across a render's awaits (ADR-0033), fixing warm-seed misses that made such cells refetch and flash on hydrate. Two parts. First, `generateSSR` pushes the same render-path segment the client pushes inside `{#each}`/`{#if}`/`{#switch}` (keyed key / keyless row index for each; `then`/`else` or switch branch-index) — previously only child components got a segment, so a cell in a loop/branch composed a divergent scope id server-vs-client. Second, the render-path base itself now survives a render's `await`s: `withPath`/`withPathFrom` set `CURRENT_PATH` and restored it synchronously, but an SSR render's `build()` returns a pending promise awaited outside the wrapper, so the base was restored the instant a render yielded — any scope created past that await (a 2nd sibling child, anything after a page-level cell barrier, a child two awaits deep) composed against an ancestor's path. The swappable `ambientPathBacking` widens from `{get,set}` to `{run,get}`; the server backs `run` with a dedicated `AsyncLocalStorage` (`pathStore`) whose value is inherited by the render's post-await continuations, and `CURRENT_PATH.current` becomes read-only. The client keeps its synchronous save/restore (its mount is synchronous). No codegen change; `CURRENT_SCOPE` was audited and does not share the bug.
-- a6c5749: Independent SSR awaits now render in parallel, not in series (ADR-0034). An independent blocking `{await X}` and streaming `{#await Y}` used to render in the SUM of their latencies: the blocking await halts the sequential render walk, and the streaming flight is a deferred thunk drained only after `render()` returns, so a streaming read behind a blocking await couldn't start until it settled. The SSR back-end now hoists each _hoistable_ await's promise-START into the synchronous render prefix (server-only, via a new plumbing `$$flight` helper) so independent flights overlap — an await is hoistable when its promise references only component-scope names (no `{#for}`/`{:then}`/snippet binder, no async cell), is not inside a conditional branch, and is statically-single. The block's boundary markers, `$ctx` block-id, the RESUME/streaming wire, and the entire client build are untouched, so hydration is byte-identical and the client stays fully reactive. On the kitchen-sink `templating/async` page this cuts SSR from ~842ms to ~427ms (max, not sum). Transparent: no code change for app authors; a page with a single or no async await is unaffected.
-- a6c5749: Non-cache streaming peeks stop flashing `loading…` on hydrate (ADR-0035). A bare async peek whose loader is a plain (non-cache) promise — `{loadProfile(attempt)?.name}` — shipped pending in the SSR shell and the client cold-re-ran its seed on hydrate, so it showed `loading…` for the full latency even though the server had already computed the value. Unlike a `{#await}` block (streams its resolved HTML fragment) or a cache-backed peek (streams its cache entry via `__abideResolve`), a plain-promise peek had no server→client value channel. It now does: a streaming cell records its settled value in a per-request partition, the page renderer streams it after the shell as an `__abideResolve({ cellKey, value })` chunk keyed by the cell's render-path id, and the client adopts it as a POST-hydration reactive update (deferred a microtask so it lands after the pending markup is claimed — no `assertClaimedText` desync). Values (not promises) are recorded so a cell that stays pending all request can never hang the response; only cells settled by the drain are streamed (a page with a blocking `{await}` or barrier — the common case — is covered; a pure-streaming-peek page cold-runs as before). Reactivity and the RESUME/`$resume` wire are untouched. Transparent behaviour improvement; no API or config change.
-- 56b948e: An inline (bare smart read) rpc call now seeds the SSR warm snapshot regardless of HTTP method, so it hydrates warm instead of re-firing after render (ADR-0036). Previously only GET entries rode the warm snapshot: a non-GET rpc consumed inline in render position — e.g. `{html(highlightCode({ code, lang })?.html)}` where `highlightCode` is a POST (POST so the large `code` payload rides the body, not a multi-KB query string) — ran the handler in-process during SSR **and** re-fetched on the client after hydration, firing the call twice per page load (a second POST can 500 on a unique constraint / double-mutate). The `{ GET }` gate conflated two concerns: _seeding_ the SSR-computed body (safe for any method — the value already exists) and _re-firing_ the stored request unprompted on invalidate/refresh/staleness (safe only for GET). They're now decoupled: seeding is gated on "the entry carries a wire request" (any method), while re-firing stays GET-only — `REPLAYABLE_METHODS` is unchanged, so a write is still coalesce-only (re-submittable), never SWR-retained, and never auto-replayed from the snapshot. A seeded write is read warm once during hydration; a later reactive re-read re-issues it live with real args. Keying already includes canonical-JSON body args, so each inline write seeds under its own distinct key. Verified: an inline POST hydrates warm with zero post-hydration refetch. No API or config change.
-- 126474d: SSR await/try block ids are now keyed by render-path instead of a single flat counter (ADR-0037), making block-id allocation congruent SSR↔client even under concurrent renders. Previously every `await`/`try` block drew from one monotonic counter shared across a component and the children it inlines (`$ctx.next++` server / `RENDER.blockId` client), which only stayed congruent because sibling child renders ran strictly sequentially — the blocker to parallelizing them. A block id is now `${render-path}:${n}` (a per-path counter), reusing the ADR-0033 AsyncLocalStorage render-path so each child's ids live in their own namespace; a pathless render (a top-level page with an empty route key, or a bare test component) keeps the plain `0,1,2…` form, so the common case is unchanged. DOM adoption was already positional (boundary-marker ids are not compared, only the `RESUME` manifest key is), so the id widened `number → string` with no parser change. This is a transparent refactor — id allocation order is unchanged, so behaviour is identical and the full hydration suite stays green. On that foundation, **sibling `<Child/>` renders now run in parallel during SSR** (ADR-0037 Phase 2): a hoistable top-level-spine child render (childless, prefix-evaluable props, no `bind:`) starts in the render prefix as an isolated `$$flight` and is awaited at its position, so independent cards render in ~max not ~sum of their latencies while the HTML still assembles in source order. Each hoisted render runs under its own async-cell barrier list (`isolateCellBarrier`, a server-only per-render AsyncLocalStorage) so concurrent siblings never `splice(0)`-drain each other's cells. Transparent — same HTML, same hydration; only independent child work overlaps. No API or config change.
-- dc064ac: A route's layout layers now render in parallel during SSR (ADR-0038). Previously `renderChain` rendered the layout chain (outermost layout → … → page) sequentially, so a route with N layouts each doing an independent I/O read flushed its shell in the sum of their latencies. Now the layers render via `Promise.all`, each under `isolateCellBarrier` (so their async-cell barriers don't cross-drain) and its distinct route-key `withPath` (so path-keyed block ids stay collision-free) — the html fold and state/awaits/resume aggregation run after all settle and are order-independent, so output and hydration are byte-identical, just faster. A lone page with no layouts still renders directly (no wrapping overhead, same bare-read streaming timing). Server-only; reuses the ADR-0037 primitives. Verified with a timing test (three layers ~40ms each render in ~max not ~sum) and the full hydration suite. No API or config change.
-- 3bfdcb6: A slow hoistable child component now STREAMS its fragment during SSR instead of blocking the shell (ADR-0039). Previously every hoistable `<Child/>` was awaited inline, so a page's shell couldn't flush until its slowest child settled. Now `generateSSR` reserves each hoistable child's output slot and, after the walk, `finalizeStreamedChildren` decides per render: a child whose isolated flight has already SETTLED inlines its html byte-identically to before (so an all-fast page is completely unchanged — one microtask, no macrotask, same wire), while a still-PENDING child gets an empty `abide:await:CHILDPATH` boundary in the shell and streams its `<abide-resolve>` fragment when it settles. The boundary id is the child's render-path, congruent with the client. The client emits a dual-mode `mountStreamedChild` for the same children: it probes the hydration cursor and adopts either an inlined `[ … ]` range or a swapped-in streamed boundary, with a plain create-mode mount on client navigation. Verified: three ~40ms sibling cards stream in ~max not ~sum, a streamed child hydrates with no desync, and fast/existing children stay byte-identical. Remaining refinement: warm-seeding a streamed child's late-resolving async cells (a blocking `{#await}` inside it already adopts via its resume delta). No API change.
-- fcbdeb2: clear stale rows on eachAsync reseed ([`0173073`](https://github.com/briancray/abide/commit/01730732141c7a7f54001a4a9ba35b6749757412))
-- fcbdeb2: reap embedded server on failed boot, bound readiness probe, escape plist XML ([`04cee1c`](https://github.com/briancray/abide/commit/04cee1c0f60098b55f69321d407886bbf23fae53))
-- fcbdeb2: green up main — biome lint errors block the release run ([`0833487`](https://github.com/briancray/abide/commit/08334878be6191f7994543997a4b8403f36c4ebe))
-- fcbdeb2: single source of truth for the proxied server subdirs ([`094892b`](https://github.com/briancray/abide/commit/094892b7de07751277bf735271080971daaa2384))
-- fcbdeb2: guard streamed cancel race that logged a stray "Controller is already closed" ([`0bbc93c`](https://github.com/briancray/abide/commit/0bbc93cea4192cb2104e6ff83dd231c858d25fd4))
-- fcbdeb2: one schema resolver for all surfaces — fixes CLI drift ([`1083327`](https://github.com/briancray/abide/commit/10833276b5ddb00d1267f6736cc375de732c15a2))
-- fcbdeb2: stop the SSE face dropping Set/Map/bigint; unify the wire codec ([`17ca2d2`](https://github.com/briancray/abide/commit/17ca2d219450af1300ef25182eb16c4db6f5c7ca))
-- fcbdeb2: mint the warm-seed cell key through one shared warmSeedKey ([`233787e`](https://github.com/briancray/abide/commit/233787e0c330e8c43926fcc46df6de77ece3116c))
-- fcbdeb2: rename Socket.broadcast() to publish() to match Bun ([`250c883`](https://github.com/briancray/abide/commit/250c883a035cf9748129d4aa3e17b65a5a5a6189))
-- fcbdeb2: fold REACTIVE_CALLEES into signal-ref lowering ([`269b762`](https://github.com/briancray/abide/commit/269b7623d422f4b1e556e46e8f8c7b68017f874d))
-- fcbdeb2: rename Subscribable to NamedAsyncIterable ([`2d17ed2`](https://github.com/briancray/abide/commit/2d17ed23b9c3c5c18adb56feadaf1882c4d991c3))
-- fcbdeb2: share one lenient percent-decode helper ([`3b7f320`](https://github.com/briancray/abide/commit/3b7f32088b514f49dd088893ebd7318c4cc0b8bb))
-- fcbdeb2: drive LSP tokens from the parse, delete both lexers ([`4301e97`](https://github.com/briancray/abide/commit/4301e97abd8b612ebcfb6639426447947046c6b5))
-- fcbdeb2: swap streamed SSR fragments via an inline script, dropping the resolved-frame runtime path ([`431aee3`](https://github.com/briancray/abide/commit/431aee3c406b8181e039a86b04c74192b4222964))
-- fcbdeb2: drop the separate SSR-stream deadline; endpoint timeout governs (ADR-0024) ([`48e45d9`](https://github.com/briancray/abide/commit/48e45d9cf7c922cb9a846829f7ef5b2acee527de))
-- fcbdeb2: thread rpc build stamps as one named RpcBuildStamps payload ([`493a6ac`](https://github.com/briancray/abide/commit/493a6ac0467e6d77ef180e807d769747270c1fd4))
-- fcbdeb2: one-shot cell warm-seed + structural render-path key alignment ([`4a5383f`](https://github.com/briancray/abide/commit/4a5383f64ebadc511a8f55809f899b98d0a734d2))
-- fcbdeb2: migrate disconnected.abide to {#if}/{#for} block syntax ([`57bd904`](https://github.com/briancray/abide/commit/57bd904fd84250c7e1cfd97d84483907fc25cbf3))
-- fcbdeb2: pin the runtime and shadow front-ends to one async-lift plan ([`58e9691`](https://github.com/briancray/abide/commit/58e9691eea870650bf219a33cef2b523f3c5dc10))
-- fcbdeb2: replace reachable's poll registry with a TTL memoize ([`5bd426e`](https://github.com/briancray/abide/commit/5bd426ef4701b2da11531cc30779bd2a953cac20))
-- fcbdeb2: restore in-place HMR for streamed children; review cleanups ([`5eec25d`](https://github.com/briancray/abide/commit/5eec25d0fb27d688e2caa0f180968de5fbefe9c2))
-- fcbdeb2: remove the inspector Reactive tab + PATCH_BUS ([`64e4da9`](https://github.com/briancray/abide/commit/64e4da957144fea6f7a6ecbd4415bf1db219f7c3))
-- fcbdeb2: sync AGENTS.md/README to the ADR-0020 rpc API; format touched files ([`6dcc3dd`](https://github.com/briancray/abide/commit/6dcc3dd5a21cb334bf742e0fd6ef461013eb3cfb))
-- fcbdeb2: refresh getHello templates for NamedAsyncIterable + schemas.input/output ([`7233a9b`](https://github.com/briancray/abide/commit/7233a9b11e663655f87f32e08b5ea98d20cdba7d))
-- fcbdeb2: cache parsed SourceFiles across shadow programs ([`7241ca2`](https://github.com/briancray/abide/commit/7241ca244e1c6bd84dfb94d3c20ff1cfe70cc752))
-- fcbdeb2: remove component hot-module replacement ([`7469c1d`](https://github.com/briancray/abide/commit/7469c1d1b1f2c175c2facfe4288ad81b0f89d063))
-- fcbdeb2: stop stale-worker 500s; move codegen off the boot hot path ([`7c5b241`](https://github.com/briancray/abide/commit/7c5b2417c3ba6737d897c264837ca66a79282a99))
-- fcbdeb2: sort imports ([`7fcd071`](https://github.com/briancray/abide/commit/7fcd0714ce337359bc11347fa243dff64ed682de))
-- fcbdeb2: share block-keyword vocabulary so LSP highlighting can't drift ([`95ac19a`](https://github.com/briancray/abide/commit/95ac19a058574f8bba36aae64d20791c84a4e820))
-- fcbdeb2: drop the runtime-helper binding backstop ([`9ba3513`](https://github.com/briancray/abide/commit/9ba3513432dd5639f93c0a61555d70ba510ff359))
-- fcbdeb2: share the anchored-branch skeleton across await and try blocks ([`a301f0e`](https://github.com/briancray/abide/commit/a301f0e101e314ef904f4f26cd157937de2a8bd2))
-- fcbdeb2: green up main CI — biome lint + strict-consumer typecheck ([`a39e030`](https://github.com/briancray/abide/commit/a39e0307e69e738717d9827464141a85a99dd1e4))
-- fcbdeb2: remove the client→inspector BroadcastChannel bridge ([`a4920ea`](https://github.com/briancray/abide/commit/a4920ea3d969bd0812e4146acb80b775ba8807cf))
-- fcbdeb2: surface diagnostics when the .abide source can't be read ([`a6b1881`](https://github.com/briancray/abide/commit/a6b188138e354fee2b4adb6ae80c4882d78c28c4))
-- fcbdeb2: log streaming rpc handler errors server-side ([`a81d99d`](https://github.com/briancray/abide/commit/a81d99d442ae1f1ba73a98e5c5dc2a51078ba2d2))
-- fcbdeb2: bound the stream-swap node removal to the matching close marker ([`aa3bce6`](https://github.com/briancray/abide/commit/aa3bce6bcb5ddfe1d29f76d8abae3e58d2b4a89d))
-- fcbdeb2: revive wire fields in cache()/peek(); evict idle lifecycle channels ([`b1ffe5a`](https://github.com/briancray/abide/commit/b1ffe5a7676066e71af4ce3bfc7124ddb9ab4bd9))
-- fcbdeb2: consolidate framework plain-text responses ([`b8cbb72`](https://github.com/briancray/abide/commit/b8cbb721e7cb6fbe86016db197d942ec413fc211))
-- fcbdeb2: hoist three duplicated constants to shared origins ([`d0ee9df`](https://github.com/briancray/abide/commit/d0ee9dfeb35582646e33bb317f4c219141fad4d1))
-- fcbdeb2: push render-path segments for each/if/switch rows and branches ([`d2d927a`](https://github.com/briancray/abide/commit/d2d927ac814622e4b258db944d75c930d64733c7))
-- fcbdeb2: guard linked seed arg for noUncheckedIndexedAccess (consumer tsconfig) ([`d643b2b`](https://github.com/briancray/abide/commit/d643b2b467a1ec03b493af8f38a4e3e1f5b74bde))
-- fcbdeb2: satisfy noUncheckedIndexedAccess in the template parser ([`dad539d`](https://github.com/briancray/abide/commit/dad539dd039f2ae44e159c2b544a9d27953b780b))
-- fcbdeb2: fold hydratingSlot + wakeHydrationPeeks into hydrationWindow ([`dd9c682`](https://github.com/briancray/abide/commit/dd9c682d732f9d89c3412018f9c5656b58025ddc))
-- fcbdeb2: move URL-shape route decisions behind createAppRouteResolver ([`e639324`](https://github.com/briancray/abide/commit/e63932426d81268f9fbc75806a7e26263f310ca0))
-- fcbdeb2: refresh AGENTS/README for the wire codec, typed-error OpenAPI surface, and inline {await} ([`eecfe14`](https://github.com/briancray/abide/commit/eecfe145389e8c11f7e83c8d2babbc4ea3e92732))
-- fcbdeb2: remove the dead scope-label plumbing ([`f068887`](https://github.com/briancray/abide/commit/f0688875b77677b670b145ce90982e93e9a1a545))
-- fcbdeb2: gate refresh/invalidate reload on a live tracking reader ([`f0af782`](https://github.com/briancray/abide/commit/f0af782936a87a18cbb4f70c3926315cf6180b31))
-- fcbdeb2: one origin for the rpc/socket shim global names ([`f0baaaf`](https://github.com/briancray/abide/commit/f0baaaffc04d55b32b906fff454221f27b190366))
-- fcbdeb2: one wire-field decoder for input and output ([`f16f005`](https://github.com/briancray/abide/commit/f16f005933509dc5b1e1ee824a3bdca5cf036acd))
-- fcbdeb2: extract the /__abide/* plumbing router from createServer ([`f8f5e22`](https://github.com/briancray/abide/commit/f8f5e227eff0149766281cd254193544099a638b))
-- fcbdeb2: props type honors the destructure annotation — types work like TS (ADR-0022 D4) ([`fd3f74f`](https://github.com/briancray/abide/commit/fd3f74ffa9e938f1c87ec648fe1e4ccad20bde9b))
-- afccb13: `abide check` now counts slotted content toward a required `children` prop. The shadow's completeness check treated `children` like any other prop, so `<Card>text</Card>` mounting a component that declares `children: Snippet` was falsely flagged as missing `children` — forcing `children?` optional as a workaround. Slotted content now satisfies the requirement (matching the runtime, which lowers it to the `children` layer), while a childless `<Card />` is still flagged. All other completeness and excess-prop checks are unchanged.
-- 7e4309e: `bind:prop` now works on components, mirroring `bind:attr` on elements. `<Child bind:value={target} />` passes the prop with a two-way write-back channel — `target` takes the same forms an element bind does (an lvalue, or a `{ get, set }` accessor). The child reads the prop as usual; if it writes the prop (`value += 1`) or forwards it to another `bind:` (`<input bind:value={value} />`), those writes flow back to the parent's `target`.
-
-    There is no child-side marker: bindability is inferred from usage. A prop the child only reads stays a cheap read-only derive (unchanged); one it writes/forwards is upgraded to a writable cell that is a pass-through to the parent when bound, and a local reseeding cell when not (so a component still works standalone). Previously `bind:` on a component was a silent no-op passed through under a `bind:`-prefixed prop key.
-
-- 4020519: Reactive-doc `Set`/`Map` mutations now emit a patch. The doc codec already serializes `Map` and `Set`, but a mutating method on a doc-held collection (`model.tags.add(x)`, `model.byId.set(k, v)`, `.delete`/`.clear`) lowered to a bare in-place call that mutated the live tree by reference and fired no patch — so readers never re-rendered and undo/persistence/sync never saw the change. These now route through the same clone-apply-replace path the in-place array methods use (`$$mutateDocArray` generalized to `$$mutateDocContainer`, covering Array, Map and Set); the mutating method names are disjoint across the three kinds, so the container kind is decided at runtime with no compile-time type check.
-- eaa1829: `done()` / `peek()` are null-tolerant, so a probe fed a pending peek-lift no longer 500s
-
-    Under ADR-0032 a promise/iterable subexpression peek-lifts to `undefined` while pending, so writing a probe inline in a template — `{done(getFeed())}` / `{peek(getFeed())}` — hands the probe `undefined` on the first render pass. `done()` now returns `false` and `peek()` returns `undefined` on a nullish argument instead of throwing on `subscribable.name`, turning that pending render from an SSR 500 into a graceful empty state. Probing in script (`const closed = state.computed(() => done(feed))`) remains the correct idiom for an accurate stream probe, since a lifted `AsyncIterable` peek yields the latest frame, not the source.
-
-## 0.49.0
-
-### Minor Changes
-
-- dfb4f13: props import required + additive route-shape type; drop ambient children ([`0dbe248`](https://github.com/briancray/abide/commit/0dbe248fc959f3ca8168fb83e6f30619a17eff3b))
-- dfb4f13: slotted content rides the children prop key as a Snippet ([`0de19e5`](https://github.com/briancray/abide/commit/0de19e594dabb6ddd92b08d5e473f13296f17247))
-- dfb4f13: publish abide/ui/props module for the props reader ([`197c1a9`](https://github.com/briancray/abide/commit/197c1a900c0ea81b40d1cbb4a6bec1e021b9e932))
-- dfb4f13: type element attach node param from the element tag ([`444ef35`](https://github.com/briancray/abide/commit/444ef356372f8fc39a0b5786bca2f70dcf750c53))
-- 951e90b: `props` is now a required import (`@abide/abide/ui/props`), resolved by import binding like `state` — a bare ambient `props()` no longer works, and every component that reads props must `import { props } from '@abide/abide/ui/props'`.
-
-    `children` is now an ordinary declared prop instead of an ambient callable: read it with `const { children } = props<{ children: Snippet }>()` (`Snippet` from `@abide/abide/shared/snippet`). Slotted content (`<Panel>…</Panel>`) and an explicit `children={aSnippet}` attribute now set the same `children` prop key (slotted content wins if both are present). `props<T>()` stays additive — a page/layout still gets its route-param shape auto-typed, and declaring `children` (or any other prop) only adds to it.
-
-    The `Snippet` type's generic changed from its internal payload to its call arguments: `Snippet<Args extends unknown[] = []>` is now `(...args: Args) => SnippetValue` — `children` is `Snippet` (invoked `children()`), a row/label snippet is `Snippet<[Item]>` (invoked `row(item)`). The former payload-generic form (`Snippet<Payload>` describing the value flowing through) is gone; the internal payload is the newly exported `SnippetValue`.
-
-    **Behavior change:** an unguarded `{children()}` on a component mounted without children now throws at render, where it previously rendered nothing. Guard with `{#if children}{children()}{:else}…{/if}`, or declare `children: Snippet` as a required (non-optional) prop so `abide check` catches missing children at the call site.
-
-    Migration: add `import { props } from '@abide/abide/ui/props'` to every component that calls `props()`; for any component that reads `children`, add `import type { Snippet } from '@abide/abide/shared/snippet'` and declare it — `const { children } = props<{ children: Snippet }>()` (or `children?: Snippet` if optional).
-
-### Patch Changes
-
-- 4a6bf93: mount a reactive/loop-bound component tag by its value, not the cell ([`32a7cb8`](https://github.com/briancray/abide/commit/32a7cb8bdef0800d76b418eefbe550b0a939cd73))
-- dfb4f13: correct UiProps.children to the ordinary prop-thunk shape ([`33a0de7`](https://github.com/briancray/abide/commit/33a0de72dc2fe6ce4a0e025e4158ab192e47f1f0))
-- c7d25e4: type state<T>(undefined) and binding-annotated state() as T | undefined ([`3c40d99`](https://github.com/briancray/abide/commit/3c40d9981617968330a00bc2f034456b80365419))
-- c7d25e4: await a snippet whose body fills a {children()} slot ([`4c2744b`](https://github.com/briancray/abide/commit/4c2744bc1aa42728a80adb3426a77c02c79b30d4))
-- dfb4f13: repair pre-existing gate failures blocking release ([`4c55a4a`](https://github.com/briancray/abide/commit/4c55a4a1cbcb0b2afc842f7cc7134aed590006ce))
-- dfb4f13: layout child sentinel + restProps skip move to the children key ([`500d1d8`](https://github.com/briancray/abide/commit/500d1d8d696147602eb1ce34706cbbbf724ceb0b))
-- dfb4f13: fix stale props-declaration comment in compileShadow ([`532e079`](https://github.com/briancray/abide/commit/532e0796c54aa77c7b155145ae2d16193b7de4e5))
-- c7d25e4: expand a thrown Bun.build AggregateError into per-file diagnostics ([`5643d95`](https://github.com/briancray/abide/commit/5643d95691dd9211bc5f3edb5a2ae77aa3989f63))
-- dfb4f13: children lowers as a destructured prop, not $children ([`60bbbeb`](https://github.com/briancray/abide/commit/60bbbeb15cae41d34e5f5b4f07590bf0a5a1b795))
-- dfb4f13: resolve 35 correctness/ergonomics findings from full-tree audit ([`73a72ac`](https://github.com/briancray/abide/commit/73a72ac1946f901f76d790b38fa3ebbf29b661fe))
-- dfb4f13: extract buildArtifact (build-or-die primitive) ([`938e312`](https://github.com/briancray/abide/commit/938e3129f03cb6787624703422cd9472fbdcb83b))
-- dfb4f13: format spreadProps + renderChain to canonical prettier ([`97b1565`](https://github.com/briancray/abide/commit/97b1565670eb0977b8079425f8e92becd6deb68e))
-- dfb4f13: thunk-wrap layout children sentinel so {#if children} presence reads truthy ([`a884de1`](https://github.com/briancray/abide/commit/a884de1bbb0fcffaea91268cf49aa1d1b24a3d7a))
-- 4a6bf93: drop an await settle whose anchor was detached from the tree ([`ad3d00c`](https://github.com/briancray/abide/commit/ad3d00c36ecfd935721164e7ebff7a7b3fffca4e))
-- dfb4f13: resolve props by import binding, not ambient special-case ([`b624893`](https://github.com/briancray/abide/commit/b624893745aa0e1fdb407047b15f29ac0ceac3ec))
-- dfb4f13: shadow declares props under the author's local alias ([`b821a5b`](https://github.com/briancray/abide/commit/b821a5bfef17233b2aa24502ea397eede62329a0))
-- dfb4f13: extract withoutHydration (5 sites -> 1 helper) ([`c36be09`](https://github.com/briancray/abide/commit/c36be09d64846f76216bfcc7932cdbc026631f04))
-- dfb4f13: redefine Snippet<Args> as a callable; add SnippetValue ([`ecc861f`](https://github.com/briancray/abide/commit/ecc861f589d5149a299b92ba6d08fd362644bcd1))
-
-## 0.48.0
-
-### Minor Changes
-
-- 182cdf5: server reads coalesce-only by default, SWR retain client-only ([`98a3e84`](https://github.com/briancray/abide/commit/98a3e84b1e6bdb50b8950a4197ec4a255c560d2a))
-- 182cdf5: warn on a request-scoped ttl>0 read (add shared or drop ttl) ([`b55425c`](https://github.com/briancray/abide/commit/b55425c986fb4c7cebcb1e8c29d1c616466d7d63))
-
-### Patch Changes
-
-- 182cdf5: rename global option/exports/comments to shared ([`1256934`](https://github.com/briancray/abide/commit/125693481ba23152a44375bbe200d575b66fdf9a))
-- 182cdf5: evict outside-request coalesce-only entries; correct shared help copy ([`1b73e21`](https://github.com/briancray/abide/commit/1b73e21c33c8ee985f7109fdedcbe302322ce7d1))
-- 182cdf5: route outside-a-request server reads to the shared store ([`456cfa6`](https://github.com/briancray/abide/commit/456cfa662405714df99545e02ed6e3b851da84df))
-- 182cdf5: Breaking: the `global` cache option is renamed `shared`, and it no longer implies retention. `{ global: true }` (memoise across requests forever) becomes `{ shared: true, ttl: Infinity }` — `shared` now only selects the process store, while `ttl` alone controls retention (default `0` on the server = coalesce-only, `Infinity` on the client). Reads made with no request in flight resolve to the shared store instead of an orphan fallback. ([`d94f0f9`](https://github.com/briancray/abide/commit/d94f0f9cb15a5822b2d5824db7e32da27368fe04))
-
-## 0.47.0
-
-### Minor Changes
-
-- 981c53f: server-side streaming — defineRpc opts.streaming + rewriteForServer injects it ([`00f6fa8`](https://github.com/briancray/abide/commit/00f6fa8fdedc412808108c959c8ad9cced2b643b))
-- 981c53f: socket/rpc instance methods + reactive-surface follow-through ([`0d3d686`](https://github.com/briancray/abide/commit/0d3d686125d7906e1360af4f040f40f39892caa6))
-- 981c53f: on(source, handler) reaction primitive ([`1cfa4f9`](https://github.com/briancray/abide/commit/1cfa4f94bf2e6cd5b612ae26a449007d2b1e1769))
-- 981c53f: syntactic import-resolved reactive recognition (alias-safe, checker-free) ([`1e3e041`](https://github.com/briancray/abide/commit/1e3e041865541058d36c0f5d759d6b09f1256bb4))
-- 981c53f: capture call errors at the boundary, clear on success/invalidate ([`32f3ee7`](https://github.com/briancray/abide/commit/32f3ee7ae495149a7873b5102b215b1d8c07ca04))
-- 981c53f: bare call reads through the cache store (coalesced, reactive) ([`410e552`](https://github.com/briancray/abide/commit/410e552f5b233a814640737954cb01bf5825e816))
-- 981c53f: typed fn.error(args?) probe over the rpc error registry ([`41f4d4a`](https://github.com/briancray/abide/commit/41f4d4a2127a35327bbc573f3656eda9dcf9307a))
-- 981c53f: parked durable writes are pending, not errored ([`41fefbc`](https://github.com/briancray/abide/commit/41fefbc2d4f25c9364bd3e866edb90e1eb82df4e))
-- 981c53f: .refresh/.patch/.peek instance methods ([`55d4051`](https://github.com/briancray/abide/commit/55d40512d6113a20960d128c3d47b5a54d4d6f98))
-- 981c53f: patch() — optimistic/real-time local value mutation ([`67a2df7`](https://github.com/briancray/abide/commit/67a2df733d4e3948e68d253671daf322816737b0))
-- 981c53f: rpc error registry (last error per call identity, reactive) ([`7138e23`](https://github.com/briancray/abide/commit/7138e23bf0285da2f90fdc08e918a4abe3b749ad))
-- 981c53f: export ./ui/state; withdraw scope()/effect from author doc surface ([`77b5221`](https://github.com/briancray/abide/commit/77b52217d5baa9fa22b26d8aba8b0111237434eb))
-- 981c53f: peek() — synchronous non-triggering value probe ([`78469a8`](https://github.com/briancray/abide/commit/78469a89dac0cc014b8958f8e1ffa85e4fb189ba))
-- 981c53f: pre-bound selector methods on rpc instances (pending/refreshing/invalidate/cache) ([`8154dd0`](https://github.com/briancray/abide/commit/8154dd03ca4a1ac1b8c26292a43f72a85f3a9dab))
-- 981c53f: SWR retention always-on for smart reads; type the smart call ([`844a8b7`](https://github.com/briancray/abide/commit/844a8b79a9b526d5d82e5e7febe57f61f23aa98d))
-- 981c53f: done(sub) terminal reader + tail prober reports done/error ([`8a11ab3`](https://github.com/briancray/abide/commit/8a11ab31417edc59f062042b8181e5eaaa6bc140))
-- 981c53f: state() gains .linked/.computed/.share/.shared ([`b02aead`](https://github.com/briancray/abide/commit/b02aeade95173ddea2ea363f6de2f9e1cc23fc90))
-- 981c53f: refresh() — always-refetch over the selector grammar ([`b7bddb2`](https://github.com/briancray/abide/commit/b7bddb2dba94c269449ba2f52193f8c5ace6d5c1))
-- 981c53f: wire client streaming — detectStreaming codegen + proxy flag ([`bac63fe`](https://github.com/briancray/abide/commit/bac63fe94d08a94cbf887600bf2f61764170dbc0))
-- 981c53f: refresh() + peek() ([`d2f8f1a`](https://github.com/briancray/abide/commit/d2f8f1a5f541707a627a9e196ee0b53a060b721a))
-- 981c53f: broadcast() + tail defaults to 1 ([`dc280e9`](https://github.com/briancray/abide/commit/dc280e9e76a781994ee92af8c98967220e4f793e))
-- 981c53f: type-driven streaming — bare call returns Subscribable, drop .stream() ([`f457a2c`](https://github.com/briancray/abide/commit/f457a2c9c716a35ac398217196af92cf5751d650))
-- 981c53f: emit $$watch for bindings; watch recognized + SSR-stripped (renames on) ([`f4f7812`](https://github.com/briancray/abide/commit/f4f781201c82fdfe28d50e5535d93766b0e130c8))
-- c0db71d: Rebuild the data & reactivity surface around one smart call plus thin modifiers/probes/reactions.
-
-    **Breaking changes:**
-
-    - The **bare rpc call is now the smart read** — cached, coalesced, reactive, and stale-while-revalidate by default for replayable (GET/HEAD) reads; writes are coalesce-only. `cache(getFoo, args)` → `getFoo(args)`. The `cache()` function and the `./shared/cache` export are removed (the store remains the internal substrate). Per-call transport options (`signal`/`headers`/`keepalive`/`priority`/`cache`) move to `getFoo.raw(args, init)`; the smart call's second arg is cache/stream options (`ttl`/`tags`/`throttle`/`debounce`/`n`).
-    - **`.refresh` / `.patch` / `.peek`** — new global functions (`./shared/refresh`, `./shared/patch`, `./shared/peek`) and rpc instance methods. `.refresh` replaces `.invalidate` (refetch keeping the stale value visible, never blanking); `.patch` mutates the retained value locally with no network; `.peek` reads the retained value synchronously. `fn.invalidate`/`fn.cache` instance methods are removed (`fn.refresh` / the bare call replace them).
-    - **`watch(source, handler)`** (`./ui/watch`) is the single reaction primitive, replacing `effect`, `socket.on`, and `cache.on` for authors and the compiler (bindings emit `$$watch`). `effect` is off the taught surface (internal plumbing). Instance sugar mirrors the global for the two subscribable/rpc sources — `socket.watch(handler)` and `fn.watch(handler)` / `fn.watch(args, handler)` (client-only; SSR-inert no-op).
-    - **Sockets:** `socket.broadcast(msg)` replaces `.publish`; retention (`tail`) defaults to `1`; `socket.peek()` / `socket.refresh()` added. The `tail()` reactive-consumer function (`./ui/tail`) and `socket.tail()` are off the taught surface — consume the socket directly (`for await` / `watch`) and window via `watch` + `state`; `pending`/`refreshing`/`done`(socket) now register on consumption.
-
-- 2a42d90: Remove all later-hydration: the inferred deferred `{#await cache()}` inert path and the explicit `client:idle` / `client:visible` component islands. Both traded eager hydration for a wake-later heuristic, and the inference was the source of the "control renders dead until the wake fires" bug class. A blocking `{#await cache()}` now renders on the server, seeds warm, and hydrates eagerly — live on the first frame. `client:idle` / `client:visible` are no longer recognized directives. Very large grids that relied on island deferral should adopt their own virtualization.
-- f0f8d77: Close the `<select>` and boolean/numeric binding gaps.
-
-    - **`<select bind:value>` now handles late-mounting options.** Options produced by a `{#for}` block or async data mount _after_ the binding runs, and the browser drops a `value` set that names a not-yet-present option — so the initial value silently failed to apply. The bind now routes through a new `bindSelectValue` runtime helper (`./ui/dom/bindSelectValue`) that re-applies the selection whenever the option set changes (via a `MutationObserver`), covering static, `{#for}`, and async options uniformly.
-    - **`<select multiple bind:value>`** binds an array of the selected option values (two-way): the bound array drives which options are `selected`, and a user's picks are collected back into it.
-    - **SSR selects the matching option.** A server-rendered `<select bind:value>` now emits `selected` on the matching `<option>` (single) or every member (multiple) — the browser ignores a `value="…"` on the select, so the pre-hydration/no-JS state was wrong before. Option value is taken from its `value` attribute, else its static text.
-    - **`<details bind:open>` SSR fix.** `open` is a boolean attribute, so the old generic path emitted `open="false"` and rendered the element _open_ when closed. It now emits the bare attribute only when truthy, like `checked`.
-    - **Numeric input coercion.** `bind:value` on `<input type="number">` / `type="range"` now writes back a number (via `valueAsNumber`, empty field → `undefined`) instead of a string, so number-typed state stays a number.
-
-### Patch Changes
-
-- 981c53f: rpc error registry is client-only — no cross-request SSR leak ([`00c6efb`](https://github.com/briancray/abide/commit/00c6efb0053c0bcd0e44748ebcb85826ec382b27))
-- 981c53f: decide the tool namespace once — mcpTools replaces buildTools/callTool ([`05b31f1`](https://github.com/briancray/abide/commit/05b31f18a02c2ec344f8d17bcbda50d534aad104))
-- 981c53f: migrate .abide fixtures off scope() onto the imported reactive surface ([`0d487db`](https://github.com/briancray/abide/commit/0d487dbf02c6368bd1f889c6679951fc49c364ca))
-- 981c53f: Breaking: re-home subscribable probes onto consume; remove tail() ([`1e0ae9f`](https://github.com/briancray/abide/commit/1e0ae9ff75f2c48921c807c6c4445930933533c6))
-- 981c53f: desugar via import-resolution; bare imported primitives are the surface ([`21a52a5`](https://github.com/briancray/abide/commit/21a52a5b733da810a155eab6863d35b9e9ddd459))
-- 981c53f: keep SSR/client text claims congruent ([`383f7ab`](https://github.com/briancray/abide/commit/383f7ab5582533f7ecaad7c76b01c6ce7c114818))
-- 981c53f: shadow + nested-script recognize imported reactives; effect author-imported ([`415a232`](https://github.com/briancray/abide/commit/415a23223b44ff60776f5f68226d93dc9c2c5c7c))
-- 981c53f: regenerate README + AGENTS.md for the imported-reactive / flat-cache / bare-streaming surface ([`42a7404`](https://github.com/briancray/abide/commit/42a7404c00fa90334d14d715d2a17095f5b5456d))
-- 981c53f: extract finalizeResponse — the dynamic route's wire-handling step ([`4369119`](https://github.com/briancray/abide/commit/4369119ae41e3338af2769790ccd4a2b3cad68de))
-- 981c53f: regenerate README + AGENTS.md for the new data/reactivity surface ([`4c6d6eb`](https://github.com/briancray/abide/commit/4c6d6eb1033f64770c8e2154e856f00f6a5a834f))
-- 981c53f: hoist value consts above __Props so keyof typeof prop annotations resolve ([`581eebe`](https://github.com/briancray/abide/commit/581eebefd41f05d2875f96a3965d90c2c7a1da63))
-- 981c53f: import-resolution is the sole reactive recognition path ([`5b13721`](https://github.com/briancray/abide/commit/5b13721741e5c7bd85844b21f23372b588f05d24))
-- 981c53f: bump scaffold @abide/abide floor to ^0.46.0 ([`5d10cb5`](https://github.com/briancray/abide/commit/5d10cb5b2388fd45e0403b798ca8908b08f0a0e4))
-- 981c53f: reject streaming rpcs at compile time (@deprecated overload → never) ([`7277533`](https://github.com/briancray/abide/commit/7277533c74eec1103c4021844bbb5547f8b452de))
-- 981c53f: narrow the select-bind indexed access so tsgo passes under noUncheckedIndexedAccess ([`796340c`](https://github.com/briancray/abide/commit/796340c5aed2e21a1a46411fda30a4cb9450a95d))
-- 981c53f: resolve full-codebase review findings (22 bugs + cleanups) ([`8523d25`](https://github.com/briancray/abide/commit/8523d25d596d435ffea989ce93da75b4210bb655))
-- 981c53f: server streaming rewrite handles trailing comma / empty opts ([`89eb801`](https://github.com/briancray/abide/commit/89eb80142cae47fc53b3654e0c81f1bd9a394ecc))
-- 981c53f: unify **SSR** payload behind a shared contract + exhaustive boot seed ([`8b242f1`](https://github.com/briancray/abide/commit/8b242f1d0dab035a3bd439370b6a5066d5254d86))
-- 981c53f: sync examples, README, and AGENTS.md to {#snippet} block syntax ([`8fa8e72`](https://github.com/briancray/abide/commit/8fa8e7256eb2ddb1df48ab19c39ebfa1a86ac7c8))
-- 981c53f: repoint scope host to plumbing exports; drop dead reactive imports ([`a58aee6`](https://github.com/briancray/abide/commit/a58aee6418136de675a56190e4b7ee7dc84d54cc))
-- 981c53f: type {#snippet} as Snippet-returning in the check shadow ([`b2bca21`](https://github.com/briancray/abide/commit/b2bca217dfc12a6fe5870bdecf0bca2ef4e4b628))
-- 981c53f: Breaking: flatten cache(fn, args, options) — direct read-through, drop the wrapper ([`b8d356f`](https://github.com/briancray/abide/commit/b8d356fb078a548433311dd19a2bec930c30e29a))
-- 981c53f: migrate template + scaffold to the new surface ([`bc1ccfd`](https://github.com/briancray/abide/commit/bc1ccfdc7699cc0de034bdadcf79b7cc5e3695bd))
-- 981c53f: guard detectStreaming indexed access under noUncheckedIndexedAccess ([`bc5cecb`](https://github.com/briancray/abide/commit/bc5cecbf5b6669297a90e16cf8762110b928b641))
-- 981c53f: one module per resolved runtime value — the slot is the seam ([`c2dcde4`](https://github.com/briancray/abide/commit/c2dcde496e43868aeb94c23773e9f6630820b3c9))
-- 981c53f: declare pending/refreshing/invalidate/cache instance methods ([`c743df8`](https://github.com/briancray/abide/commit/c743df80777f6dcf1c7d326713c6124254a4bca4))
-- 981c53f: record why the type-check shadow stays off the Plan model (ADR-0014) ([`c9f77dd`](https://github.com/briancray/abide/commit/c9f77ddb44832354e71d711d035be497fa258ef6))
-- 981c53f: flatten cache() and update .stream() doc to bare streaming-rpc call ([`cfdf715`](https://github.com/briancray/abide/commit/cfdf71546bf14c2e29714d057307b14081e048a9))
-- 981c53f: Breaking: remove .invalidate/.cache instance methods ([`e809b22`](https://github.com/briancray/abide/commit/e809b22280ff851e51dbbbc3e65c6e8e6fb86a81))
-- 981c53f: Breaking: remove ./shared/cache export; retag ./ui/effect as plumbing ([`e9b5e94`](https://github.com/briancray/abide/commit/e9b5e9463f6f201bbf7e7b9455e5090e4c4c6ba6))
-- 981c53f: fold route matching into shared matchRoute ([`f00630b`](https://github.com/briancray/abide/commit/f00630bd2366f968e412d61b7b791e679d985414))
-- 981c53f: Breaking: remove .publish, migrate all call sites to .broadcast ([`fa0fd00`](https://github.com/briancray/abide/commit/fa0fd00f5f891d9f804155aaf496f6cf0eb9c535))
-
-## 0.46.0
-
-### Minor Changes
-
-- 162296f: wake a below-the-fold deferred {#await cache()} on visible, not idle ([`193ff2f`](https://github.com/briancray/abide/commit/193ff2f7ad4a40f3dde39537260d76e7317a6013))
-- 162296f: client:idle / client:visible island directive on components ([`a50f0bc`](https://github.com/briancray/abide/commit/a50f0bce451f00f292eea90419feaa6ff1a708bd))
-- 162296f: wake deferred {#await cache()} on idle + size-gate the defer decision ([`a5a1a7f`](https://github.com/briancray/abide/commit/a5a1a7fea3dfe35cad08ea17fad7016fb8cca6cb))
-- 162296f: component-island hydration boundary (mountRange) + shared wake helpers ([`e0ed9ba`](https://github.com/briancray/abide/commit/e0ed9ba58d41ad7d1605717b1f4ec9207d2454a5))
-
-### Patch Changes
-
-- 162296f: rename shadowed `constructor` local in whenVisible ([`2f25fdf`](https://github.com/briancray/abide/commit/2f25fdfcb21e05807dd26c876acd8cd9f49d3004))
-- 162296f: shared observer + frame-budgeted wake flush for islands at scale ([`3c2db3b`](https://github.com/briancray/abide/commit/3c2db3bce43ad8cc30b6cab279246a033db4bd61))
-- 162296f: apply formatter to drifted files ([`5960d3c`](https://github.com/briancray/abide/commit/5960d3c5db44c925cf3c1fc9566156a8886db195))
-- 162296f: restore multi-line union wrapping in generateBuild ([`92ce908`](https://github.com/briancray/abide/commit/92ce908c3369759d8b55c695ed2deed410be1ef5))
-
-## 0.45.0
-
-### Minor Changes
-
-- 3fadd43: defer large {#await cache()} with inert hydration + lazy seed ([`2b87f5d`](https://github.com/briancray/abide/commit/2b87f5de270d91c9ffc9f5467051a221e6f9c204))
-- 7aa4032: thread durable outbox bit into RemoteFunction return type ([`4fa34b4`](https://github.com/briancray/abide/commit/4fa34b43fdac7a0aaa91a965f1aca488e1378a27))
-- 3fadd43: Breaking: collapse rpc handler generics into one inferred function type ([`f22bfd3`](https://github.com/briancray/abide/commit/f22bfd3f189214209ff3debb2b4916bd3b3680c7))
-- 6d82974: BREAKING: `CacheOptions.tags` (and the `cache.invalidate` / `pending` `{ tags }` selector) now accepts only a `string[]`, not `string | string[]`. Wrap a single tag in an array:
-
-    ```ts
-    cache(getOrder, { tags: ['orders'] })({ id })
-    cache.invalidate({ tags: ['orders'] })
-    ```
-
-    A bare-string tag previously auto-wrapped; the array-only form removes the `typeof` branch and the silent-splat foot-gun (a JS caller passing a multi-char string got it iterated into per-character tags).
-
-- ce61cd0: Add `error.typed(name, status, schema?)` — declare a single, reusable typed-error constructor. Returning it from a handler IS the error (it serializes a `{ $abideError, data }` body at `status`), and the rpc reads the constructor's branded return type to expose the error on the client's `rpc.isError(caught, 'name')` (narrowing `.kind` and typed `.data`). Compose by returning whichever constructors you want — no set, no registration:
-
-    ```ts
-    const outOfStock = error.typed('outOfStock', 409, z.object({ sku: z.string() }))
-    export const buy = POST(({ sku }) => (inStock(sku) ? json(place(sku)) : outOfStock({ sku })))
-    // buy.isError(e, 'outOfStock') → e.data: { sku: string }, inferred from the body
-    ```
-
-    The rpc's typed-error surface is now **inferred from the handler's return type** — the errors a handler returns are the errors it can raise — so there is no `errors:` rpc option and no `ctx.errors` handler param. A typed error you only ever `throw` (rather than `return`) narrows kind-only, like a plain `error()`.
-
-    BREAKING: removes the rpc `errors:` option and the handler's `{ errors }` second argument. Replace `POST((args, { errors }) => error(errors.x(data)), { inputSchema, errors: { x: { status, data } } })` with a module-scope `const x = error.typed('x', status, schema)` constructor returned from the handler: `POST((args) => x(data), { inputSchema })`.
-
-### Patch Changes
-
-- 7aa4032: percent-decode client route params to match SSR ([`1034dfb`](https://github.com/briancray/abide/commit/1034dfb3d451be117da7416f5f0bae611f82e3df))
-- 7aa4032: drop in-flight await settle after owner teardown ([`109e56e`](https://github.com/briancray/abide/commit/109e56e52851382a53a259d614671d0fb0e1fd08))
-- 7aa4032: make effect flush non-reentrant and pin effect teardown scope ([`28c9e79`](https://github.com/briancray/abide/commit/28c9e79b4e7a1905483c469182a58d7df8388c0e))
-- 7aa4032: drop scope('/') address param ([`3b3400d`](https://github.com/briancray/abide/commit/3b3400d5c87f151701da927d66912c2715e511fe))
-- 3fadd43: remove cell from the public Scope surface ([`408bd25`](https://github.com/briancray/abide/commit/408bd25864f67fc88da531793b6233806f7ab3a4))
-- 7aa4032: isolate SSR ambient scope per request ([`52d3e1c`](https://github.com/briancray/abide/commit/52d3e1cfc941df5d044fb2e6e6477bbf85c96ed4))
-- 7aa4032: extract shared generationGuard for async teardown invalidation ([`5775422`](https://github.com/briancray/abide/commit/5775422acb2625cb4bb864c0b9f77611e1a530a2))
-- 7aa4032: dispose scope children in reverse (LIFO) ([`9f56ea2`](https://github.com/briancray/abide/commit/9f56ea20dacb6ae28161b3a604dbc94d2f69ca98))
-- 18d9eb1: fix hydration null-deref when a reactive text binding first renders an empty string — the server emits no text node, so the client now synthesizes its own node at the claim cursor instead of dereferencing null in the bind effect
-
-## 0.44.1
-
-### Patch Changes
-
-- 767b415: 02-zod-plugin-memo ([`0e00b21`](https://github.com/briancray/abide/commit/0e00b217f99352a7d3def4841172c5bff287bc5c))
-- 767b415: 06-wakeSubtree-prefix-index ([`23ab920`](https://github.com/briancray/abide/commit/23ab9202fd0cb41e01811e78b76eac2843c9cf8f))
-- 767b415: 09-when-via-switch ([`48f8d50`](https://github.com/briancray/abide/commit/48f8d5063cf74060004ad38691f584abcff0cab2))
-- 767b415: 08-dts-codegen ([`5170542`](https://github.com/briancray/abide/commit/51705426e55a700140cc7bc38f7e21f30759fce3))
-- 767b415: 03-socket-publish-gate ([`56fae49`](https://github.com/briancray/abide/commit/56fae49bf393fdfb3aa35cecc618a39443354ce4))
-- 767b415: 10-cli-tokenizer ([`5e305c1`](https://github.com/briancray/abide/commit/5e305c154efd5f77d0a57e78831b72a30b4d9155))
-- 767b415: 14-resolver-slot-factory-JUDGMENT ([`6e00809`](https://github.com/briancray/abide/commit/6e00809c343e24599d54b2304a50a9cecd90619f))
-- 767b415: catch top-level await in a .abide <script> during abide check ([`76ff64e`](https://github.com/briancray/abide/commit/76ff64e9fb9ffed108ae2fde53f2ded2bf3a0abe))
-- 767b415: 12-warm-clone-PARTIAL ([`8e58e0b`](https://github.com/briancray/abide/commit/8e58e0b2c1891174cc809797f949f01619529b89))
-- 767b415: 05-compiler-double-pass ([`9216dae`](https://github.com/briancray/abide/commit/9216dae4c26e27fce49f39b116bd8b1dcf1dd226))
-- 767b415: 04-lsp-shadow-cache ([`9f9f5fc`](https://github.com/briancray/abide/commit/9f9f5fc84792204259d591fa4aff261b2a19c46d))
-- 767b415: 13-dev-rebuild-scoping-JUDGMENT ([`b5a1d49`](https://github.com/briancray/abide/commit/b5a1d49e6607a8fcf37efe03e9fe6f6b2c31ea45))
-- 767b415: gate skeleton fragment-staging on a connected parent ([`c9380ee`](https://github.com/briancray/abide/commit/c9380eebdd9f6773ccffd446665b1acbc78b1123))
-- 767b415: 07-debug-gate ([`c96466e`](https://github.com/briancray/abide/commit/c96466e73ea1f521d728b11aac44262530c3b09c))
-- 767b415: rename paint's escape var to avoid shadowing the global ([`caf1322`](https://github.com/briancray/abide/commit/caf1322adc6598bc6ea32e0ba9047ba768b6f5e1))
-- 767b415: reflow generateBuild attr-kind union to biome's multiline form ([`f9b3669`](https://github.com/briancray/abide/commit/f9b36690e4add2c955abb8f0127a9af9d513be53))
-- 767b415: 01-bugs-B1-B2 ([`fa8659d`](https://github.com/briancray/abide/commit/fa8659d276265c0fbb4f7ca0740fc74702f00168))
-- 767b415: address code-review findings ([`fb02df5`](https://github.com/briancray/abide/commit/fb02df58c924d7206fce35874cc80309949c9e59))
-- 767b415: 11-server-log-micro ([`fb689bc`](https://github.com/briancray/abide/commit/fb689bc05bee9ba127ddf206e925e3a9e04841fd))
-
-## 0.44.0
-
-### Minor Changes
-
-- 24444a8: add zod→CommonJS shim plugin for bun ESM-cycle bug ([`0424b20`](https://github.com/briancray/abide/commit/0424b20151f4d1a98d7b022bbacbbb974d469b47))
-- 24444a8: {children()} replaces the <slot> element ([`0bdfbe5`](https://github.com/briancray/abide/commit/0bdfbe5c3efd621492cdef09b745f9262c5be937))
-- 24444a8: type page params via props(); declare children in the shadow ([`2e58768`](https://github.com/briancray/abide/commit/2e58768cfbfb5a2be2aec48c77482e7bf5ee1b8d))
-- 24444a8: syntactic markup token classifier and zed grammar tokens ([`5cdef1f`](https://github.com/briancray/abide/commit/5cdef1f81762d9c1b8c63a418499335c6524b0a5))
-- 24444a8: {#snippet} block replaces <template name> declarations ([`620c2c3`](https://github.com/briancray/abide/commit/620c2c3ba7d8b797ccb770664db47468e4265131))
-- 24444a8: wire {#if children} lowering; migrate snippet/slot test fixtures ([`861b30b`](https://github.com/briancray/abide/commit/861b30be19deb83b5749b8bb2ca8dd526b29b1b3))
-- 24444a8: page/layout params as reactive props() thunks; layout {#if children} ([`991cea7`](https://github.com/briancray/abide/commit/991cea79a08b09508285769a35494b03111b5113))
-- 24444a8: attribute and prop value interpolation ([`ae0a3da`](https://github.com/briancray/abide/commit/ae0a3daa13411d6de71917efde4cb76c57c855c7))
-- 24444a8: {#if children} lowers children to $props.$children ([`f749f47`](https://github.com/briancray/abide/commit/f749f47836cdf69ccbc51d7b7fb9fafa7d7189a4))
-
-### Patch Changes
-
-- 24444a8: effect queue Set -> double-buffered array ([`03c6d09`](https://github.com/briancray/abide/commit/03c6d09334559a2a24c3c953cbf57e5f231ea9c6))
-- 24444a8: prune each reconcile by generation stamp, not a per-pass Set ([`1b48eed`](https://github.com/briancray/abide/commit/1b48eedc9b1657946321cad8c9843930b0bec5d0))
-- 24444a8: accumulated working-tree changes ([`1df2999`](https://github.com/briancray/abide/commit/1df2999b3f4b381334d365b1ff2df53711ad6b50))
-- 24444a8: Breaking: reserve $$ injected namespace, relocate html to abide/ui/html ([`1ef8c2a`](https://github.com/briancray/abide/commit/1ef8c2a047cfaf086df1676d498cdcd2bcbe45d0))
-- 24444a8: shadow block value-params on both back-ends ([`25f719a`](https://github.com/briancray/abide/commit/25f719a17c69aee71e2bc7884080231c35ef6578))
-- 24444a8: shared element-emission plan across build/SSR backends ([`2a6cec5`](https://github.com/briancray/abide/commit/2a6cec5361051c1da021dba50ce40a656106e5a7))
-- 24444a8: typed auto-popping shadow scope for compile lowering ([`2fd04a0`](https://github.com/briancray/abide/commit/2fd04a0ed8dc5453461efa0af920d046549a8877))
-- 24444a8: dedup deref-scope push/pop into withScoped ([`3552fff`](https://github.com/briancray/abide/commit/3552fffd2dc2e69708b8268b42609c4e971eb932))
-- 24444a8: lower await {:finally} outside the then/catch value-param shadow ([`4b33813`](https://github.com/briancray/abide/commit/4b33813433fc42455c6b069da1eb118d71b9af1b))
-- 24444a8: iterate mark down single-subscriber chains ([`4ca3fd4`](https://github.com/briancray/abide/commit/4ca3fd419d58667eb074dd033afc2e29b10f56cd))
-- 24444a8: unify warm-seed shippability + decode symmetry ([`5675e37`](https://github.com/briancray/abide/commit/5675e37ec240ab785e3e83eed7b2723f6dcce090))
-- 24444a8: accumulated feat/arch-deepening working-tree changes ([`60cef30`](https://github.com/briancray/abide/commit/60cef30c2405db94ded7e708abddf2c18b4db555))
-- 24444a8: clear typecheck and lint errors in the arch-deepening compile/dom backlog ([`782fb42`](https://github.com/briancray/abide/commit/782fb42769e495addd57904ccd1fb0148f81f9bb))
-- 24444a8: add eachPlan + snippetPlan, route structure through plans (phase 1) ([`8cfffcc`](https://github.com/briancray/abide/commit/8cfffcc958b63b62da51e670f8f8f4c64a3ca5e5))
-- 24444a8: {children()}/{#snippet}/props() route params ([`8f1dc89`](https://github.com/briancray/abide/commit/8f1dc89bfbf052c07082b939e893c9aee65aeea9))
-- 24444a8: single-source bindings via plans + withBindings, exhaustive dispatch (phase 2) ([`9228e30`](https://github.com/briancray/abide/commit/9228e30d4ba16c3ef1bc14b7d243b9628bde1b59))
-- 24444a8: resolve each key to its row once per reconcile ([`ce3e160`](https://github.com/briancray/abide/commit/ce3e160c8837ec5df4cf5cf625c1db50402defde))
-- 24444a8: reorganize kitchen-sink nav and refresh README/scaffold ([`e31ba15`](https://github.com/briancray/abide/commit/e31ba159d9cc1db88cdebb96f40ff8d5c89b7e0f))
-- 24444a8: scope the children slot reader through the signal transformer ([`e4a901d`](https://github.com/briancray/abide/commit/e4a901da9858f3b307363f98c97c3e72c3569640))
-- 24444a8: faster structural descend via no-alloc walkPath + suffix walk ([`ef14dac`](https://github.com/briancray/abide/commit/ef14dace7c4eb870fe9b0487d4111ecfe635831c))
-- 24444a8: elementPlan over skeletonContext, share emission decisions (phase 3) ([`f75703e`](https://github.com/briancray/abide/commit/f75703e0a276c37ce1fbbfde6b4c4b6064d551b8))
-- 24444a8: effect is not ambient — it is a scope primitive ([`f8942ed`](https://github.com/briancray/abide/commit/f8942ed675d6d6493b3d53bd1cc4e991d1d1b7dd))
-
-## 0.43.1
-
-### Patch Changes
-
-- 943402b: restore reload scroll flash-free via native restoration ([`876b99c`](https://github.com/briancray/abide/commit/876b99cd6e285b6a41afe87ca053cf0631099c03))
-- ed96096: abide check: quote hyphenated component prop keys (`aria-label`, `data-*`) so the props shim parses, and treat `on*` callbacks as ordinary declared props (not DOM passthrough) so a passed required `onsave`/`oncancel` no longer reads as missing while an undeclared handler is still caught
-
-## 0.43.0
-
-### Minor Changes
-
-- 6453cf9: repurpose the bare outbox() export to the global reactive aggregate ([`003713d`](https://github.com/briancray/abide/commit/003713dab125b3df72d6cf832ec18ea546922c79))
-- 6453cf9: typed navigate params, scope-destructured primitives, precise prop diagnostics ([`0769896`](https://github.com/briancray/abide/commit/07698966147e96970c27e0278e2152a23e48b219))
-- 6453cf9: OutboxEntry type + status ([`08d9b03`](https://github.com/briancray/abide/commit/08d9b036501110ab24c18258cc79364f9ac71ea8))
-- 6453cf9: migrate kitchen-sink to rpc-native outbox; AGENTS.md surface ([`1b8aa3f`](https://github.com/briancray/abide/commit/1b8aa3fe631181e7798d0703eb09a0f22dba0f88))
-- 6453cf9: persist request body + content-type, replay on reload ([`26c309f`](https://github.com/briancray/abide/commit/26c309f20bf573e512b74477ba2319c22218f7d9))
-- 6453cf9: client registry of durable rpc queues ([`2b89c20`](https://github.com/briancray/abide/commit/2b89c20b1f1f1794f90152f46958ee760333bab5))
-- 6453cf9: reject server-only imports in the client bundle with an evidence chain ([`2de1730`](https://github.com/briancray/abide/commit/2de1730872898d320c240a89b570dfaa9acace7a))
-- 6453cf9: name-keyed typed errors via a handler errors ctx ([`62f75a8`](https://github.com/briancray/abide/commit/62f75a8341d61ac9cfd1e7cbeccc66ddec991643))
-- 6453cf9: createOutboxQueue enqueue + reactive/persisted entries ([`88560c9`](https://github.com/briancray/abide/commit/88560c942d0f28623a68ed1315bb2341ad66a9c3))
-- 6453cf9: bundler threads outbox:true into the client proxy emission ([`b279960`](https://github.com/briancray/abide/commit/b27996089f4a3c8786fcd1ade530057a34f086fc))
-- 6453cf9: pending() reflects the durable queue (in-flight or queued) ([`bfa505d`](https://github.com/briancray/abide/commit/bfa505d8d5326f0464be35568ac8ae6fc4bd1901))
-- 6453cf9: class: and style: directives for surgical reactive class/style writes ([`c5ee6d1`](https://github.com/briancray/abide/commit/c5ee6d13faad82ac45c6c1627c6e9435c9c59c5f))
-- 6453cf9: durable return type — outbox:true overload on mutating rpc helpers ([`d916c6b`](https://github.com/briancray/abide/commit/d916c6b5b563ddc4dee07a015cde08d32e6dd750))
-- 6453cf9: outbox:true rpc option, gated to mutating methods ([`e37f2a3`](https://github.com/briancray/abide/commit/e37f2a333e201ef40303dd25bafb9f0ca82dd220))
-- 6453cf9: drain loop — deliver/retry/error/cancel under the entry signal ([`ec32868`](https://github.com/briancray/abide/commit/ec32868eb860b6185f21c196b18f03c7b3605ba8))
-- 6453cf9: durable client invoke path + rpc.outbox face ([`f96a0c0`](https://github.com/briancray/abide/commit/f96a0c025cfda5f6daf713f4d69857854b8f3459))
-
-### Patch Changes
-
-- 6453cf9: notify() forEach callback must not return a value ([`1c7f20f`](https://github.com/briancray/abide/commit/1c7f20fa5b6a24f3a5e90ab20521f7d24ba55d57))
-- 6453cf9: Breaking: rename defineVerb export to defineRpc ([`29fe778`](https://github.com/briancray/abide/commit/29fe7782844e0de15c53fad711d6616cc90a27e0))
-- 6453cf9: rename VERB*\* constants to RPC*\* ([`391687a`](https://github.com/briancray/abide/commit/391687a252a33ba355ba929944cd1a2cef83c1ef))
-- 6453cf9: rename verb-named rpc helpers to rpc ([`4ebdd8f`](https://github.com/briancray/abide/commit/4ebdd8ff862121a48a39fbdb7b2893a14fd52022))
-- 6453cf9: rename verbRegistry to rpcRegistry ([`507adf5`](https://github.com/briancray/abide/commit/507adf5d5ae3a1b66ef85fc495ba1a974a530abf))
-- 6453cf9: rename Verb-named types/helpers/files to Rpc ([`8342e96`](https://github.com/briancray/abide/commit/8342e963babbddcb9a87dcc99fc2e4958dbc5750))
-- 6453cf9: refresh AGENTS surface map ({#…} blocks, scaffold flags, migration error) ([`88cc4d9`](https://github.com/briancray/abide/commit/88cc4d97205bd3de74a08a6dbae3f2221f0275fe))
-- 6453cf9: commit working tree — outbox, rpc errors, compile plans, cache refactor ([`c673dc7`](https://github.com/briancray/abide/commit/c673dc71522e33ad4f9b48f41ac73fa6c4f03a02))
-- 6453cf9: rename HttpVerb type to HttpMethod ([`d64a59a`](https://github.com/briancray/abide/commit/d64a59a045f77c627b98dbb1b3a12b545f3d3c60))
-- 6453cf9: scrub verb from comments, AGENTS.md, and inspector surface (rpc/method) ([`d9356ce`](https://github.com/briancray/abide/commit/d9356ce9eeba6b03d43ef67fc500cf697e34d39c))
-
-## 0.42.0
-
-### Minor Changes
-
-- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - reject stray {:…}/{/…} tokens outside a block ([`1b5d54e`](https://github.com/briancray/abide/commit/1b5d54e7798acfa7c9b15ce6b65b0c2b6a8c2c07))
-
-- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - parse {#switch}/{:case}/{:default} blocks to the switch AST ([`448da38`](https://github.com/briancray/abide/commit/448da3840c120ac3b15d239c090f123c25527fec))
-
-- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - parse {#for … of … by …} blocks to the each AST ([`7bb2ac8`](https://github.com/briancray/abide/commit/7bb2ac8f3012e3d40cfcbe8ddf277d6a8732ee93))
-
-- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - LSP semantic-token encoder + extract offsetToPosition ([`7daeb92`](https://github.com/briancray/abide/commit/7daeb926f045058aa452b5f539ddd75b0d8efa67))
-
-- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - semantic-token legend + TS-classification mapping for abide lsp ([`892f97b`](https://github.com/briancray/abide/commit/892f97bbc6dfd8af9301297276995f7060fe3f9a))
-
-- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - type-aware semanticClassifications on the shadow language service ([`9377dd2`](https://github.com/briancray/abide/commit/9377dd24d855cde790d960fceef00255904ee926))
-
-- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - block control-flow grammar formatting + shared helpers ([`b39c0a7`](https://github.com/briancray/abide/commit/b39c0a70696b031b63ef157c67360c2da0fd60b0))
-
-- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - zed onboarding — auto-install extension + enable semantic tokens ([`b47acc7`](https://github.com/briancray/abide/commit/b47acc7cc106956f115c70b110c29ce017a71cd0))
-
-- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - parse {#if}/{:else if}/{:else} blocks to the if AST ([`b662397`](https://github.com/briancray/abide/commit/b66239765bae2ec7a24d70bc7b2edbcbe400614c))
-
-- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - parse {#try}/{:catch}/{:finally} blocks to the try AST ([`b82c3dd`](https://github.com/briancray/abide/commit/b82c3ddaaec3db3941639df952e568f017d6c767))
-
-- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - Breaking: remove <template> control-flow directives in favor of {#…} blocks ([`bf5cf89`](https://github.com/briancray/abide/commit/bf5cf89813a8dcbc967e1303bd2509e18e701761))
-
-- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - color of/by connectors in {#for} block heads ([`c958614`](https://github.com/briancray/abide/commit/c9586147f8196e9e6301b14cdb08986b36da2751))
-
-- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - parse {#await} streaming + blocking blocks to the await AST ([`cfd7ff0`](https://github.com/briancray/abide/commit/cfd7ff0102b2be2ac241a6c0b1965949aa6621bf))
-
-- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - serve textDocument/semanticTokens/full for .abide ([`e152663`](https://github.com/briancray/abide/commit/e152663dae9e60e13d16f0edf4b0a140a99b1bfb))
-
-- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - structural {#…} block framing tokenizer ([`e1e85e8`](https://github.com/briancray/abide/commit/e1e85e847e9442f8c6140df5346b1d37f8cfad54))
-
-### Patch Changes
-
-- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - point block-construct loc at its primary expression (shadow source-map fidelity) ([`0fb0efa`](https://github.com/briancray/abide/commit/0fb0efab43639331c856969fdb6a7b83bd7ab604))
-
-- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - unify block/branch child-scan loops behind a shared helper ([`4683098`](https://github.com/briancray/abide/commit/4683098df96edd0321dc66d200372e0fbedce2e2))
-
-- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - document {#…} control-flow blocks in the AGENTS surface map ([`68fe96f`](https://github.com/briancray/abide/commit/68fe96f3294a228b91eef5cde37c0300673eb88a))
-
-- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - map {#for}/{:then}/{:catch} bindings + by-key to source so hover & semantic tokens land on them ([`e8447e8`](https://github.com/briancray/abide/commit/e8447e8d54934737b80c2f49d4f4d1b134786531))
-
-- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - map <template args> snippet param + await/try {:catch} bindings (+ index/catch/snippet tests) ([`f724d10`](https://github.com/briancray/abide/commit/f724d101f5baed79de2d39a1ab9598eb9d1eb818))
-
-- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - satisfy noUncheckedIndexedAccess in block-token + shadow paths ([`fbb6e44`](https://github.com/briancray/abide/commit/fbb6e4443932e92277fb332b639c746663c7759b))
-
-## 0.41.1
-
-### Patch Changes
-
-- [`74f5312`](https://github.com/briancray/abide/commit/74f531260e17f48162397142fb19b3df9e081b2c) - shared replaceRange region-update seam ([`184cf41`](https://github.com/briancray/abide/commit/184cf41157ef0a5340a4a916d6cfc4f4e09b6c71))
-
-- [`74f5312`](https://github.com/briancray/abide/commit/74f531260e17f48162397142fb19b3df9e081b2c) - single-source the marker-depth and isElement helpers ([`188c6ff`](https://github.com/briancray/abide/commit/188c6ff29fcaff2c9c206b971a2f04daf9a18cb3))
-
-- [`74f5312`](https://github.com/briancray/abide/commit/74f531260e17f48162397142fb19b3df9e081b2c) - guard against double-dispose on reentrant branch swap ([`40600c7`](https://github.com/briancray/abide/commit/40600c7921c9fee9b6be947472c770af795f60c6))
-
-- [`74f5312`](https://github.com/briancray/abide/commit/74f531260e17f48162397142fb19b3df9e081b2c) - await block on marker ranges, not a node array ([`5d12e83`](https://github.com/briancray/abide/commit/5d12e83b7313a04a925df3464ef5c7669bcbc1e6))
-
-- [`74f5312`](https://github.com/briancray/abide/commit/74f531260e17f48162397142fb19b3df9e081b2c) - refresh AGENTS surface map, README, and kitchen-sink example ([`6cd7a3f`](https://github.com/briancray/abide/commit/6cd7a3f5686a69f4dd5faf87026d7f1ab0362bdb))
-
-- [`74f5312`](https://github.com/briancray/abide/commit/74f531260e17f48162397142fb19b3df9e081b2c) - single client warm-seed intake (seedResolved) ([`8c3c19e`](https://github.com/briancray/abide/commit/8c3c19ed0a4d4244cb2634c025ef9ff88b7c9670))
-
-- [`74f5312`](https://github.com/briancray/abide/commit/74f531260e17f48162397142fb19b3df9e081b2c) - centralize comment-marker sentinels and detached-range builder ([`99d4499`](https://github.com/briancray/abide/commit/99d44991c499b96fc016c3d204cb4dafa340cbe1))
-
-- [`74f5312`](https://github.com/briancray/abide/commit/74f531260e17f48162397142fb19b3df9e081b2c) - unify skeleton positional model on shared walks ([`cbb9daa`](https://github.com/briancray/abide/commit/cbb9daaa6f31532331df44136dd029f3e32cdfd7))
-
-- [`f3e0a13`](https://github.com/briancray/abide/commit/f3e0a132f9f9fbb020a8c783a0b54d3b37457e39) - Coalesce reactive writes inside event handlers
-
-    Event handlers now batch their writes: a handler that sets several signals re-runs
-    each dependent effect/computed/DOM-binding once on the handler's exit instead of once
-    per write (the previous default flushed eagerly per write). The change stays fully
-    synchronous — the flush runs at handler-end before it returns — so the causal stack
-    (`dispatch → handler → effects`) is intact and server/client scheduling stays identical.
-
-    Factored the batch idiom `createDoc`/`clientPage` inlined into a shared, nesting-safe
-    `batch()` (flushes only on the depth-0 exit) and migrated both onto it, so a handler
-    that triggers a doc patch now coalesces end-to-end rather than flushing mid-handler.
-
-    A handler writing N fields cuts dependent re-runs N× (bench: an 8-field form handler
-    drops aggregate re-runs 8× and runs ~4.8× faster). Single-write handlers and navigation
-    (already batched) are unchanged. New contract, pinned by tests: a handler that writes
-    then synchronously reads the bound DOM sees the pre-write value until it returns; signal
-    reads stay current.
-
-- [`f26cba2`](https://github.com/briancray/abide/commit/f26cba22b92683f7316cc7212c5fe10500bdad13) - `abide check`: declare the `each` `index` binding in the type-check shadow
-
-    `index="i"` (0.41.0) was bound in the build and SSR passes but not in the shadow the
-    type-checker reads, so `{i}` in a row body false-positived "Cannot find name 'i'". The
-    shadow now declares the index as a `number` inside the loop body, matching the runtime.
-
-## 0.41.0
-
-### Minor Changes
-
-- [`ba08127`](https://github.com/briancray/abide/commit/ba081270c4721d64655457681e4ebcc79681f1d4) - `index="i"` on `<template each>` — bind the row's reactive position
-
-    `<template each={list} as="item" key="item.id" index="i">` binds the iteration index to a name. In a keyed `each` the index is reactive: a reorder/insert/remove that shifts a surviving row repaints its `{i}` in place (same DOM, no rebuild), riding the same `Object.is` cell-write path as the item binding. SSR renders the index via `entries()` so hydration stays congruent; async `each await` carries the stream arrival ordinal.
-
-- [`ba08127`](https://github.com/briancray/abide/commit/ba081270c4721d64655457681e4ebcc79681f1d4) - In-place reactive updates for `<template await>` `then` values and keyed `each` items
-
-    A re-settling `await` block and a re-keyed `each` row no longer rebuild their subtree — they update through a reactive value cell instead, so a live cache patch updates only what changed and never flashes the surrounding DOM.
-
-    - `awaitBlock` keeps the mounted `then`-branch across a re-run, setting a reactive value cell rather than detaching + rebuilding. A revalidation now keeps the stale branch visible and patches in place; the branch is rebuilt only across a pending/catch ↔ then kind change.
-    - The `then` binding is lowered to read that cell reactively — both a single identifier (`then="value"`) and a destructure (`then="[a, b]"` / `{ x, y }`), where each leaf is derived per-read so only the leaves whose value changed propagate.
-    - Keyed `each` holds each row's item in a reactive cell; a re-key with a changed value (same key, new object) writes the cell through `Object.is`, re-running only that row's effects with no DOM rebuild. The row `render` now receives `State<T>` (the compiler binds the `as` name to read it).
-    - A destructuring `each … as="[a, b]"` (or `{ x, y }`) with no explicit `key` now defaults the key to the row's raw item identity, like a plain `as`. Previously the default key re-emitted the destructure pattern, allocating a fresh array/object per reconcile, so keys never matched and every row rebuilt on any list change.
-    - A block value binding (`then="x"` / `each … as="x"`) now correctly shadows a same-named component `state`/`computed`/`derived`: it is a nearer lexical scope, so `{x}` in the block reads the resolved/row cell rather than the component signal. A destructure pattern's default/computed-key initializer is also lowered, so `then="{ id, label = fallback }"` resolves `fallback` against the component scope instead of emitting it raw.
-
-## 0.40.2
-
-### Patch Changes
-
-- [`315bc88`](https://github.com/briancray/abide/commit/315bc8859e03a81c845f9919a759b6b1f8fb0ea1) - document the abide lsp command and add an if/else template example ([`98b7555`](https://github.com/briancray/abide/commit/98b755509e4788712b7e0516a1cb05f04355a75b))
-
-## 0.40.1
-
-### Patch Changes
-
-- [`32d6cb9`](https://github.com/briancray/abide/commit/32d6cb97a9ce2ad63b3fd768c02379e708c6d599) - share a single TS printer across compile passes ([`0626e68`](https://github.com/briancray/abide/commit/0626e68500b6cc8e7e2c770184ec4aa0fd06106d))
-
-- [`32d6cb9`](https://github.com/briancray/abide/commit/32d6cb97a9ce2ad63b3fd768c02379e708c6d599) - bind-check generated modules and collect identifiers via AST ([`1e9d350`](https://github.com/briancray/abide/commit/1e9d3506873121ffd978039653f920edbed6c9ce))
-
-- [`32d6cb9`](https://github.com/briancray/abide/commit/32d6cb97a9ce2ad63b3fd768c02379e708c6d599) - value-memoised push-pull reactivity (CLEAN/CHECK/DIRTY) ([`2ae8f14`](https://github.com/briancray/abide/commit/2ae8f141da5873bea0eb31a9a59d81182ca5a12a))
-
-- [`32d6cb9`](https://github.com/briancray/abide/commit/32d6cb97a9ce2ad63b3fd768c02379e708c6d599) - syntax fuzz corpus for the identifier-rewrite passes ([`2e7d604`](https://github.com/briancray/abide/commit/2e7d6043aeeb9ca894bdb45f3f27893fbc5bf2f8))
-
-- [`32d6cb9`](https://github.com/briancray/abide/commit/32d6cb97a9ce2ad63b3fd768c02379e708c6d599) - build control-flow subtrees untracked ([`33c0d8e`](https://github.com/briancray/abide/commit/33c0d8e834e5145a84d872ff496df122bbb0da95))
-
-- [`32d6cb9`](https://github.com/briancray/abide/commit/32d6cb97a9ce2ad63b3fd768c02379e708c6d599) - lower the component script in a single parse ([`53098f8`](https://github.com/briancray/abide/commit/53098f8c2fe36e46e61b41d8a617aba6ac75e96f))
-
-- [`32d6cb9`](https://github.com/briancray/abide/commit/32d6cb97a9ce2ad63b3fd768c02379e708c6d599) - regenerate README and AGENTS surface map ([`6bb6a39`](https://github.com/briancray/abide/commit/6bb6a3906d5aba522a4fe33bffae0911adf0b0fe))
-
-- [`32d6cb9`](https://github.com/briancray/abide/commit/32d6cb97a9ce2ad63b3fd768c02379e708c6d599) - spread reactive page.params before postMessage in inspector bridge ([`7c99395`](https://github.com/briancray/abide/commit/7c993959e9dfc0c7f7038f694f95b59093a10dfc))
-
-- [`32d6cb9`](https://github.com/briancray/abide/commit/32d6cb97a9ce2ad63b3fd768c02379e708c6d599) - make signal-rewrite parent-independent ([`868717a`](https://github.com/briancray/abide/commit/868717a6f7ff824b24ef8a96e5e5f59add5ceed1))
-
-- [`32d6cb9`](https://github.com/briancray/abide/commit/32d6cb97a9ce2ad63b3fd768c02379e708c6d599) - pick runtime imports by tokenizing the output, not substring grep ([`a102986`](https://github.com/briancray/abide/commit/a102986bef90609297246ea001528a32e111be53))
-
-- [`32d6cb9`](https://github.com/briancray/abide/commit/32d6cb97a9ce2ad63b3fd768c02379e708c6d599) - re-apply saved scroll offset until async content grows the page ([`a813b47`](https://github.com/briancray/abide/commit/a813b47387289c0049e63997a72a6805e461b18c))
-
-- [`32d6cb9`](https://github.com/briancray/abide/commit/32d6cb97a9ce2ad63b3fd768c02379e708c6d599) - aliased import mangled when its name collides with a signal ([`abfe25d`](https://github.com/briancray/abide/commit/abfe25dcf7c00e61156b5d36fe82f290fc6c4cfb))
-
-- [`32d6cb9`](https://github.com/briancray/abide/commit/32d6cb97a9ce2ad63b3fd768c02379e708c6d599) - granular reactive page snapshot + in-place same-route navigation ([`b561eb5`](https://github.com/briancray/abide/commit/b561eb52439577d3a75a7872befee4b9f0e98267))
-
-- [`32d6cb9`](https://github.com/briancray/abide/commit/32d6cb97a9ce2ad63b3fd768c02379e708c6d599) - lower the component script in a literal single parse ([`b72b238`](https://github.com/briancray/abide/commit/b72b238377ff6545de549589d36b49ad4ecebb2d))
-
-- [`32d6cb9`](https://github.com/briancray/abide/commit/32d6cb97a9ce2ad63b3fd768c02379e708c6d599) - chain per-expression lowering over a single parse ([`d808317`](https://github.com/briancray/abide/commit/d808317d817ae8a414695b7bfb037b8aff7017c3))
-
-- [`32d6cb9`](https://github.com/briancray/abide/commit/32d6cb97a9ce2ad63b3fd768c02379e708c6d599) - classify signal-rewrite positions at visit time ([`d99577e`](https://github.com/briancray/abide/commit/d99577e2ac77d8742088608fba554ff5c2e799a4))
-
-- [`32d6cb9`](https://github.com/briancray/abide/commit/32d6cb97a9ce2ad63b3fd768c02379e708c6d599) - make template-node generators exhaustive ([`e0f246d`](https://github.com/briancray/abide/commit/e0f246dfbbf4ea4f2dc481fc543a6e9f0a6fa43b))
-
-- [`32d6cb9`](https://github.com/briancray/abide/commit/32d6cb97a9ce2ad63b3fd768c02379e708c6d599) - lower ++/-- on a doc path; guard the whole generated module ([`f49c122`](https://github.com/briancray/abide/commit/f49c122354fc4ef65f4c44db820d703078dd57f4))
-
-- [`32d6cb9`](https://github.com/briancray/abide/commit/32d6cb97a9ce2ad63b3fd768c02379e708c6d599) - fold SSR effect-stripping into the single-parse chain ([`fa4515d`](https://github.com/briancray/abide/commit/fa4515d07164765ea0ee609cf1847535a41f95ed))
-
-## 0.40.0
-
-### Minor Changes
-
-- [`05ea7e2`](https://github.com/briancray/abide/commit/05ea7e235b1e7c035d3b4313e12fc83733fa814b) - <template elseif> conditional chains ([`c3237cc`](https://github.com/briancray/abide/commit/c3237ccc0d222c36e8b00ce68595eb92609ef856))
-
-- [`15c0ad3`](https://github.com/briancray/abide/commit/15c0ad334f698dfb49a9dcd0e0361925afc4f6c8) - `navigate` takes an options object — `navigate(path, { replace?, keepScroll? })` — replacing the old `navigate(path, replace?)` boolean. **Breaking:** a caller passing a boolean (`navigate(path, true)`) must migrate to `navigate(path, { replace: true })`; a bare `navigate(path)` is unchanged. The new `keepScroll` flag carries the live scroll offset onto the destination entry so an in-page URL swap — e.g. selecting another episode on the same detail page — restores to the current position instead of jumping to top. A push re-buckets the offset under the freshly minted entry id; a `replace` keeps the entry's bucket instead of discarding it.
-
-- [`ba56bb2`](https://github.com/briancray/abide/commit/ba56bb28be06fa0a11ab57fb10fa2d6b75ab8656) - Add `share`/`shared` context to `scope()`. The reactive doc does not inherit down the scope tree (each scope owns a separate document), so passing a value from an ancestor to a descendant previously meant threading it through every layer as props. `scope().share(key, value)` now puts a named value on a scope's own side-map, and `scope().shared(key)` reads the closest ancestor (self included) that has the key — an existence-checked, non-tracking upward walk, returning `undefined` when no scope provides it. The value is held by reference and the lookup never subscribes, so reactive context is expressed by sharing a `cell` (or a scope) rather than a plain object — reactivity rides what you share, not the share itself. A shared `undefined` shadows an ancestor (the walk stops on `has`, not truthiness). The shared map is released on `dispose`.
-
-### Patch Changes
-
-- [`a5a37f9`](https://github.com/briancray/abide/commit/a5a37f94258a56c4f24eb2b5539a280ce877bdfc) - extract resolveBranches for branch lookup ([`19a28a1`](https://github.com/briancray/abide/commit/19a28a1236e38a78c53a2adff0a981c8ad20b698))
-
-- [`a5a37f9`](https://github.com/briancray/abide/commit/a5a37f94258a56c4f24eb2b5539a280ce877bdfc) - sync AGENTS.md surface map for scope share/shared and navigate options ([`3e41255`](https://github.com/briancray/abide/commit/3e4125516164c94cfe9c9e6baa35f9ff9ec9c3e0))
-
-- [`a5a37f9`](https://github.com/briancray/abide/commit/a5a37f94258a56c4f24eb2b5539a280ce877bdfc) - use Promise.withResolvers in runWithVerbTimeout ([`504bdca`](https://github.com/briancray/abide/commit/504bdcac285cfd3762c8390fd1b6d640e62029bc))
-
-- [`a5a37f9`](https://github.com/briancray/abide/commit/a5a37f94258a56c4f24eb2b5539a280ce877bdfc) - extract VerbBaseOpts for shared verb options ([`d7414ca`](https://github.com/briancray/abide/commit/d7414cab7a557b54395321026d818b9fba82ba34))
-
-- [`ccc7f87`](https://github.com/briancray/abide/commit/ccc7f879d0506af084335785026200aeb38fdde4) - `on()` no longer attaches a non-function event handler. A component that omits an optional `on*` prop forwards it as `undefined`, yet the compiler still emits the `on()` call — so the listener fired `undefined(event)` and threw "handler is not a function" on every matching event (a keystroke or input on a search box, a click, …). `on()` now skips attaching when the handler is not a function, so an omitted optional handler is a no-op rather than a per-event crash.
-
-- [`c29dcd2`](https://github.com/briancray/abide/commit/c29dcd2796b5caa3ee41857aa612322b1e4220fa) - Parse `html`-branded raw markup in the parent's namespace. The client-side raw-HTML
-  binding parsed markup by setting `innerHTML` on a throwaway `<div>`, so the fragment
-  parser always used the HTML namespace — markup bound inside an `<svg>` produced
-  HTML-namespaced `<path>`/`<circle>` elements that exist in the DOM but never render.
-  This only surfaced on client-created or re-rendered nodes; the initial SSR/hydration
-  path adopts the server markup verbatim and kept the correct namespace, so an icon
-  component (`{html(svgInnerMarkup)}` inside `<svg>`) rendered on first paint but
-  vanished the moment its subtree was rebuilt on the client (e.g. a live cache delta).
-  A new `parseRawNodes` helper picks an SVG holder when the parent is SVG-namespaced,
-  shared by both `appendText` and `appendTextAt`.
-
-- [`9a74da6`](https://github.com/briancray/abide/commit/9a74da67c1f65cdb37e7a47af2e7b104cfe7620f) - Stop the signal-ref rewrite from descending into type space. `renameSignalRefs` rewrote every value-position identifier matching a signal name, but never skipped TypeScript type aliases, interfaces, or type annotations — so a component that destructures a prop (`const { option, ...rest } = props<Props>()`) and names that prop in its own type (`type Props = { option?: (value: T) => unknown; … }`) had the type member rewritten into a call (`option(): …`). This only surfaced once a `...rest` binding forced the named prop type to be emitted into the build (a no-rest `props<{…}>()` strips its type argument); with simple property types the mangle landed as accidentally-valid method-signature syntax, but optional/function/union members (`option?: (v) => unknown`, `value?: T | T[] | string`) became invalid TS and failed the page build. The visitor now leaves type aliases, interfaces, and any type node untouched — type space never holds a runtime read, and types erase at build regardless.
-
-- [`92597f0`](https://github.com/briancray/abide/commit/92597f0cbabc1e44449c0f0f812048481c38c579) - RPC bodies and socket frames now ship as ref-json (cycles, shared references, and
-  the types JSON drops/coerces — `undefined`, `bigint`, `Date`, `Map`, `Set`, `NaN`,
-  `±Infinity`, `-0` — survive the wire), and the server still accepts ordinary JSON from
-  non-abide clients. abide's own client flags a ref-json body with the `abide-ref-json`
-  header so the server decodes it with the matching codec; a request without the header
-  (curl, an OpenAPI-generated SDK, a webhook) is read with plain `JSON.parse`, so the
-  documented HTTP/OpenAPI body contract keeps working. The header is the discriminator
-  rather than the payload shape because ref-json's `[root, slots]` envelope is ambiguous
-  with a legitimate plain-JSON two-element array body. Socket frames need no header — a
-  frame is always an object, never the envelope array, so a plain-JSON frame falls back
-  to `JSON.parse` unambiguously.
-
-## 0.39.0
-
-### Minor Changes
-
-- [`ae15b27`](https://github.com/briancray/abide/commit/ae15b2733c3c569b9bde9e4d79f9b768836b3a46) - async SSR render with inline nested-blocking awaits and spread/rest props ([`514a796`](https://github.com/briancray/abide/commit/514a796833c5be4caa296b295d63fda6c8452a36))
-
-- [`527795d`](https://github.com/briancray/abide/commit/527795d1035f7cb169723a03571603a9ce8556e1) - Remote functions now accept an optional trailing options bag — `fn(args, opts)` — for per-call transport control: `signal`, `keepalive`, `priority`, `cache`, and `headers`. It's a curated `Pick` of `RequestInit`, not a raw passthrough: the server handler never observes these, so the call stays isomorphic, and a caller can't clobber the method, body, or framework headers the RPC contract owns. `opts.signal` merges with the scope abort and client timeout (`AbortSignal.any`) rather than replacing them, and is ignored under `cache()` so one reader can't abort a coalesced flight the others share. `opts.headers` merge onto abide's headers with the framework winning — a caller adds transport metadata (idempotency-key, authorization) but can't overwrite `traceparent`, the offline marker, or `content-type`.
-
-### Patch Changes
-
-- [`ae15b27`](https://github.com/briancray/abide/commit/ae15b2733c3c569b9bde9e4d79f9b768836b3a46) - harden client router, asset serving, sockets, and runtime edge cases ([`4735920`](https://github.com/briancray/abide/commit/4735920edea942dcd2954c522673b0c8af5a9a7f))
-
-- [`ae15b27`](https://github.com/briancray/abide/commit/ae15b2733c3c569b9bde9e4d79f9b768836b3a46) - consolidate escapeHtml and safeJsonForScript into shared/ ([`ae2d602`](https://github.com/briancray/abide/commit/ae2d6022f6dc23994164d1764bf5b812b136e383))
-
-- [`76a4a19`](https://github.com/briancray/abide/commit/76a4a19048fd5373b0d3ed75f2c6de017e33c7a3) - Make reactive errors and stack traces read in authored terms. A method call lowered onto a reactive-doc read now routes through a guard (`readCall`) that throws naming the scope path and member (`cannot call .close() — scope value "modal" is undefined`) instead of the engine's opaque `undefined is not an object`. The client build's source maps ignore-list abide's own framework sources, so a debugger collapses the mount-stack wall (`scope`/`mountRange`/`runNode`/…) and shows only authored `.abide`/`.ts` frames. Reactive bindings emit named thunks (`attr_title`/`text`/`bind_value`) so those surviving frames carry a name instead of `(anonymous)`.
-
-## 0.38.1
-
-### Patch Changes
-
-- [`67ac25f`](https://github.com/briancray/abide/commit/67ac25faf78b029d0b14659df1e4ec1a05ae7a10) - document outlet marker-range in AGENTS.md surface map ([`ab23673`](https://github.com/briancray/abide/commit/ab236733ee1f81e19ce09ee35fe44624e955a6e4))
-
-- [`67ac25f`](https://github.com/briancray/abide/commit/67ac25faf78b029d0b14659df1e4ec1a05ae7a10) - unify pages/layouts/outlets on marker-range model ([`df1c95f`](https://github.com/briancray/abide/commit/df1c95f89ff8d6d6806606dbece531c6be7aabdf))
-
-## 0.38.0
-
-### Minor Changes
-
-- [`bcfd15a`](https://github.com/briancray/abide/commit/bcfd15af169787d733355d5879bf95aec164e698) - feat(dom): make `{snippet(args)}` interpolations reactive in their arguments. Previously `appendSnippet` read the call once at mount and never re-ran, so an argument derived from reactive state froze its initial value (e.g. `{grouped(Object.groupBy([...aired, ...upcoming]))}` rendered with `upcoming` still `[]`, never updating when a later effect populated it). The call is now bounded by a range and wrapped in an effect — like `when`/`each` — so an argument change tears the snippet down and re-mounts it with fresh args (the body's own reads stay fine-grained within a mount; args behave like props). Create mode now emits the `<!--abide:snippet-->` range markers the server already rendered, so the markers are congruent on both sides rather than a server-only asymmetry.
-
-### Patch Changes
-
-- [`2efd4ad`](https://github.com/briancray/abide/commit/2efd4ad1e572c46a0611d3d1d5cd1a02f80da629) - restart ttl on revalidation and don't clobber a live streamed seed ([`2d07d53`](https://github.com/briancray/abide/commit/2d07d53b5aec54681e34f7490f636de2bf47fc7a))
-
-- [`2efd4ad`](https://github.com/briancray/abide/commit/2efd4ad1e572c46a0611d3d1d5cd1a02f80da629) - harden rpc/runtime/socket edge cases ([`39581f4`](https://github.com/briancray/abide/commit/39581f46601b71ccad6c6112e37c55a03b069068))
-
-- [`2efd4ad`](https://github.com/briancray/abide/commit/2efd4ad1e572c46a0611d3d1d5cd1a02f80da629) - propagate control-server worker start failure ([`3bb529b`](https://github.com/briancray/abide/commit/3bb529b00dc939c73212215cf6ae027b1078c053))
-
-- [`2efd4ad`](https://github.com/briancray/abide/commit/2efd4ad1e572c46a0611d3d1d5cd1a02f80da629) - handle JSON-RPC notifications without replying ([`4315aa1`](https://github.com/briancray/abide/commit/4315aa11c7b834607e315e6403bc41c4c9bd6a8c))
-
-- [`2efd4ad`](https://github.com/briancray/abide/commit/2efd4ad1e572c46a0611d3d1d5cd1a02f80da629) - drop unused error-page manifest ([`7f4f78a`](https://github.com/briancray/abide/commit/7f4f78af9829dca10a6062dd76b6e7fb9fddf739))
-
-- [`2efd4ad`](https://github.com/briancray/abide/commit/2efd4ad1e572c46a0611d3d1d5cd1a02f80da629) - auto-vivify nested bind paths and escape persisted doc keys ([`a2f7d15`](https://github.com/briancray/abide/commit/a2f7d1546201b6edb3b645ffede56519890415cf))
-
-- [`2efd4ad`](https://github.com/briancray/abide/commit/2efd4ad1e572c46a0611d3d1d5cd1a02f80da629) - avoid stdin hang and reject blank numeric flags ([`f1d47ef`](https://github.com/briancray/abide/commit/f1d47ef731235d7a4c4ebb727a83bb642102aac0))
-
-- [`2efd4ad`](https://github.com/briancray/abide/commit/2efd4ad1e572c46a0611d3d1d5cd1a02f80da629) - parse unquoted attributes and skip destructured binding rewrites ([`ff66d57`](https://github.com/briancray/abide/commit/ff66d57f5362af68f06d0e62dfc78d5f95322f99))
-
-- [`fab46dd`](https://github.com/briancray/abide/commit/fab46ddb0d3b8c4c8a1fa4f4615e8c5b1dfbf9e9) - fix(dom): skip control-flow rebuild when the end marker is detached. An effect for a `when`/`switch` block could fire one final time after an enclosing await/each block tore its branch down in the same microtask flush (before the owner scope disposed it), making `fillBefore` insert a fragment before a parentless comment — `HierarchyRequestError: The operation would yield an incorrect node tree`. `fillBefore` now bails when `end.parentNode` is null.
-
-- [`b081dd5`](https://github.com/briancray/abide/commit/b081dd5f7087c9f88960349d2477eab2c8d78005) - fix(compile): unify the layout `<slot/>` outlet rewrite across both back-ends and emit it scope-free. The hole-numbering refactor keys skeleton hole indices by node identity, but `generateBuild` ran `skeletonContext` over the original nodes while traversing `nodes.map(asOutlet)` — and `asOutlet` clones every element it descends, so a layout with any reactive hole (e.g. the kitchen-sink `layout.abide`'s active-link `<a href={url('/')}>`) threw `[abide] skeleton hole not numbered by the shared positional walk` at compile time, failing the page render. Both back-ends now apply the shared `asOutlet` before `skeletonContext`, so the indexed tree and the traversed tree are one. The rewrite also strips the outlet's style scope: the client cloned `<abide-outlet>` with the slot's annotated `data-a-…` scope while the server emitted it bare, a hydration mismatch (and `renderChain` folds the child layer via an exact bare-`<abide-outlet></abide-outlet>` match) — the outlet is a structural mount container, not styled content, so it now carries no attributes or scope on either side.
-
-- [`b081dd5`](https://github.com/briancray/abide/commit/b081dd5f7087c9f88960349d2477eab2c8d78005) - refactor(compile): fold skeleton hole numbering into the single `skeletonContext` walk. `generateBuild` previously threaded its own mutable `{ el, an }` counter through a second document-order walk parallel to the decision walk, free to drift from it — the compiler half of the hand-mirrored hole-ordering protocol. `skeletonContext` now assigns each hole its `el`/`an` index in the same pass that records `inSkeleton`/`markText` (el keyed by node, an keyed by node or by the reactive-text part), and `generateBuild` reads them via `holeIndex` instead of counting. One walk owns both the decisions and the numbering, so a counter-vs-decision drift is structurally impossible; a hole the shared walk didn't number now throws at compile time rather than surfacing as a runtime hydration desync. Behavior-preserving — no API or output change.
-
-## 0.37.0
-
-### Minor Changes
-
-- [`dfd9d9e`](https://github.com/briancray/abide/commit/dfd9d9e9149c16761c539f7b45358e9a969174d8) - manual scroll restoration + hash-only navigation ([`1b71ef1`](https://github.com/briancray/abide/commit/1b71ef195186c0cee5a36527307f5f981833b546))
-
-- [`dfd9d9e`](https://github.com/briancray/abide/commit/dfd9d9e9149c16761c539f7b45358e9a969174d8) - lead every tsv line with a wall-clock column ([`5784d47`](https://github.com/briancray/abide/commit/5784d47ddd2d52696fb9db111092c6f571270086))
-
-- [`dfd9d9e`](https://github.com/briancray/abide/commit/dfd9d9e9149c16761c539f7b45358e9a969174d8) - always-`abide-` component wrapper tag ([`711de46`](https://github.com/briancray/abide/commit/711de46f8b5210cbbff5c73cd7aceda410d87f47))
-
-- [`dfd9d9e`](https://github.com/briancray/abide/commit/dfd9d9e9149c16761c539f7b45358e9a969174d8) - inspector in-flight requests + prompts surface ([`823392d`](https://github.com/briancray/abide/commit/823392d0e644b3a84661293f86b28ca10d9a9de9))
-
-- [`dfd9d9e`](https://github.com/briancray/abide/commit/dfd9d9e9149c16761c539f7b45358e9a969174d8) - inspector client scope/router bridge ([`c25b45e`](https://github.com/briancray/abide/commit/c25b45e778f6f17eeaf0875a4b7ecdd63fccb978))
-
-## 0.36.0
-
-### Minor Changes
-
-- [`ec48c80`](https://github.com/briancray/abide/commit/ec48c805b019a299cf193c0228646af18605938a) - scope-bound RPC abort + shared control-flow teardown ([`de3b2d4`](https://github.com/briancray/abide/commit/de3b2d44b944a0906eccab3be564caa96ada8bc1))
-
-### Patch Changes
-
-- [`ec48c80`](https://github.com/briancray/abide/commit/ec48c805b019a299cf193c0228646af18605938a) - regenerate AGENTS.md and README for current surface ([`08b5fc9`](https://github.com/briancray/abide/commit/08b5fc9a1822dc6477963bdce2a0b9160ad9e323))
-
-## 0.35.0
-
-### Minor Changes
-
-- [`c7ad3be`](https://github.com/briancray/abide/commit/c7ad3be781797ec3e2e4f66892f0711624d4a40f) - Breaking: replace prop() with destructuring props() as the sole prop reader ([`bb050d2`](https://github.com/briancray/abide/commit/bb050d2cd5b235212423f70ceef29dd8b53fcfc7))
-
-### Patch Changes
-
-- [`c7ad3be`](https://github.com/briancray/abide/commit/c7ad3be781797ec3e2e4f66892f0711624d4a40f) - make the streamed-gzip and preload-manifest sources typecheck ([`d5b093d`](https://github.com/briancray/abide/commit/d5b093dd37d3f0a2c381389d9308eddd1267cb2b))
-
-- [`b8a0080`](https://github.com/briancray/abide/commit/b8a00807d29dfcacd299b1fe30797dba74166684) - feat(ui): a bare attribute on a child component now coerces to `true` instead of the empty string. `<Toggle on />` passes `on: true`, matching HTML's presence-means-true semantics and a `boolean` prop's declared type (previously it passed `""`, which the type-checking shadow flagged against `on: boolean` — leaving no way to write a bare boolean that both read naturally and type-checked). An explicit `<Toggle on="" />` still passes the empty string, and native DOM elements are unchanged (`<button disabled>` still serialises to `disabled=""`). Behavior change: a component reading a bare prop and expecting `""` now receives `true`.
-
-- [`a0474f3`](https://github.com/briancray/abide/commit/a0474f3eca36d101b4c5a0b35edb8ffa7f02c906) - fix(ui): JSON-Pointer-escape reactive-document path keys so a key containing `/` or `~` addresses one segment instead of mis-splitting. `lowerDocAccess` lowered `model.byId[key]` to a raw `/`-joined path (`"byId/" + key`), and `model["a/b"]` to a raw literal — but the read side (`walkPath`) splits on `/` and `unescapeKey`s each segment. So a composite key (a date, a URL id, a slash-bearing string) round-tripped wrong: `model.byId["a/b"]` read/removed `byId → a → b` instead of the `"a/b"` entry. The `escapeKey` helper was written for exactly this (its doc cites "a URL id, a date, a composite key") and AGENTS.md documents scope keys as escaped — but it was never called.
-
-    The lowering now escapes both halves: literal keys at compile time (`model["a/b"]` → `read("byId/a~1b")`), dynamic segments at runtime (`model.byId[key]` → `read("byId/" + escapeKey(key))`). `escapeKey` joins `UI_RUNTIME_IMPORTS` (DCE-filtered, so only emitted when a component uses a dynamic/special key) and is exported at `abide/ui/runtime/escapeKey`; it now coerces (`String(key)`) since a dynamic segment is often a numeric array index. Plain identifier/index paths are unaffected.
-
-- [`d188eae`](https://github.com/briancray/abide/commit/d188eaeffd75ba80e30c3c16db714d4582c06468) - perf(ssr): preload the client entry in `<head>` so it downloads during a streamed render. The entry `<script type="module">` sits before `</body>`, which on a streaming page (top-level `{#await}`) arrives only after the whole stream — so the browser couldn't start fetching the bundle until the stream closed. `injectShellAssets` now also emits `<link rel="modulepreload" href="/_app/client.js">` in `<head>` (rebased + hashed like the other entry refs), overlapping the entry transfer with the streamed body. Execution still defers to parse-end (module script), so hydration ordering — including the trailing `__abideResolve(...)` cache seeds — is unchanged.
-
-- [`d188eae`](https://github.com/briancray/abide/commit/d188eaeffd75ba80e30c3c16db714d4582c06468) - perf(ssr): preload the client entry's static runtime chunks in `<head>` so the whole hydration graph downloads during a streamed render. The entry `modulepreload` only covered `client.js` itself; its ~dozen static `clientEntry-<hash>.js` runtime chunks (one abide-ui primitive each, split out by `splitting:true`) are discovered only after the browser downloads and _parses_ the entry — which on a streamed page is ~stream-close — so the runtime waterfalled in a second wave after the body finished. `rewriteHashedClientEntries` now reads the built entry, extracts its static import specifiers (regex excludes dynamic `import("./page-…")`, so route chunks stay lazy and code-splitting still pays off), and emits a `<link rel="modulepreload">` for each into `<head>`. The runtime graph now transfers alongside the entry during the stream, so hydration is network-ready at stream-close instead of waterfalling after it. Builds on the entry-preload + per-chunk-flushing-gzip work that made `<head>` decodable mid-stream.
-
-- [`e507a8b`](https://github.com/briancray/abide/commit/e507a8bd0ba5072974d472b4123193510b8f6257) - perf(ssr): preload the matched route's page + layout chunks (and their runtime deps) per render so the whole hydration chain downloads during a streamed render. The shell's `modulepreload`s cover the entry's shared runtime, but a route's page/layout chunks are dynamically imported — the browser can't discover them until it has downloaded, parsed, and _run_ the entry, which on a streamed page is ~stream-close, so the route's chunks (and the runtime only they import) waterfalled in a second wave after the body finished. A new `buildPreloadManifest` parses the built bundle once at server boot — route → chunk from the entry's compiled pages/layouts manifest, the static-import closure from each chunk's source — into a `route → chunks` map (excluding the entry graph the shell already preloads, reading disk under dev/`abide start` or the embedded gzip asset map for standalone compile). `createUiPageRenderer` injects a `<link rel="modulepreload">` per chunk into `<head>` for the matched route (page + full layout chain), rebased onto the mount base, in both the streamed and buffered paths. The route's whole chain now transfers alongside the entry during the stream, so hydration is network-ready at stream-close. Degrades to the entry-only preload when the bundle is absent or unparseable.
-
-- [`40dce51`](https://github.com/briancray/abide/commit/40dce514a4a46a507310ebb5007a73d875f1232d) - fix(ui): make signal-ref lowering lexically scope-aware so a callback parameter (or nested local) that shadows a component signal is no longer rewritten to the signal's doc form. Previously `renameSignalRefs` skipped only declaration-site identifiers, so in a component with `prop('option')`, a callback like `list.map(option => option.toUpperCase())` had its loop variable rewritten to `option()` — throwing `option is not a function` at runtime against the array element. The rewrite now threads a per-branch shadowed-name set down the AST (function/arrow params, nested `let`/`const`/`function`/`class`, `for`-headers, `catch` bindings), leaving inner references untouched while un-shadowed signals still lower.
-
-- [`e121179`](https://github.com/briancray/abide/commit/e121179965b9bd833a2148c61dd7828970eb8262) - fix(ssr): compress streamed SSR documents with a per-chunk-flushing gzip so the head reaches the browser decodable mid-stream. `gzipResponse` piped every dynamic body through the web `CompressionStream`, which buffers until its deflate window fills — for a streamed `text/html` page that held the whole head until ~stream close, so the browser couldn't preload-scan the entry/CSS links or paint the pending shell until the document nearly finished (defeating streaming for every gzip-accepting client, i.e. all browsers; curl missed it by not sending `Accept-Encoding: gzip`). The renderer now marks its streamed document (`STREAMED_HTML_HEADER`, stripped before send) and `gzipResponse` routes it through `flushingGzipStream` (node:zlib gzip with `Z_SYNC_FLUSH` after each chunk — the web `CompressionStream` exposes no flush). Buffered responses keep the one-shot `CompressionStream` (best ratio). Net: streamed pages stay compressed **and** flush progressively — head decodes in ~2 ms instead of ~stream-end.
-
-- [`2246463`](https://github.com/briancray/abide/commit/22464634a78febe8dde20d612fd96dcdffc01620) - fix(cache): seed the client cache store for streamed `{#await}` reads so they hydrate warm instead of refetching. The SSR snapshot only inlined entries settled by render-return into `__SSR__.cache`; a `<template await>` read shipped its resolved tuple to `window.__abideResume` for no-flash DOM adoption, but its cache key was never seeded. `awaitBlock`'s effect re-reads the promise on the first hydrate pass (to subscribe the key for `cache.invalidate`), so that read cold-missed straight to the network — correct first paint, redundant fetch per streamed block.
-
-    The root cause is a timing one: a `{#await cache()}` expression is a thunk the SSR stream runs lazily, so its cache entry is created (and settled) _during_ the stream — after the render-return snapshot, which is therefore empty for it. The renderer now snapshots the store again once the stream has drained and emits an inline `__abideResolve(...)` chunk per entry (a warm `CacheSnapshotEntry`, or a `{ key, miss }` marker for an unshippable body → live refetch), keyed-diffed against what already shipped inline. `startClient` seeds both partitions through one sink (`seedStreamedResolution`) before the deferred bundle hydrates, so the subscription read resolves synchronously and adopts the SSR DOM with no wire round-trip.
-
-    Also hardens the reserved bundle-side stream path so it can't silently reintroduce the refetch: `startClient` installs a live, store-connected `window.__abideResolve`, and `applyResolved` seeds the store from `<abide-cache>` data frames (a script set via innerHTML never runs, so a bundle-consumed stream — streaming SPA navigation, socket-delivered SSR — carries the cache channel as data) — pairing the cache seed with the DOM swap.
-
-    Internal cleanup: `serializeCacheSnapshot` now returns `CacheSnapshotEntry[]` (the settled snapshots) instead of an `{ inline, pending }` partition. The `pending` half encoded the false premise that a `{#await}` read is in-flight at render-return — it is created lazily mid-stream, so `pending` only ever caught the rare eagerly-fired-unawaited read. The unused `CacheSnapshot` type is removed.
-
-    Guarded by a real-HTTP-entrypoint integration test (`bootTestServer` → `createServer` → stream) that reads a gated verb through `cache()` inside `{#await}` and asserts the warm `__abideResolve(...)` seed ships over the wire while `__SSR__.cache` stays empty — it reproduces the original cold-miss when the seed pass is reverted.
-
-## 0.34.2
-
-### Patch Changes
-
-- [`91b03c5`](https://github.com/briancray/abide/commit/91b03c540e7139205f1518a6e2429411df43b859) - enforce the msg frame against the shared wire type ([`77fedf1`](https://github.com/briancray/abide/commit/77fedf17787b8bd8fbcdc56c722016ec4e905836))
-
-- [`91b03c5`](https://github.com/briancray/abide/commit/91b03c540e7139205f1518a6e2429411df43b859) - extract the shared sub registry + frame routing ([`b81dcce`](https://github.com/briancray/abide/commit/b81dcceb63ccd92dd04f9108173510e8c132a02c))
-
-- [`91b03c5`](https://github.com/briancray/abide/commit/91b03c540e7139205f1518a6e2429411df43b859) - classify response body kind once for live and warm decode ([`bd4fb4c`](https://github.com/briancray/abide/commit/bd4fb4cec2813f3d58ee6b277d2428ba75e521ae))
-
-- [`c1242f3`](https://github.com/briancray/abide/commit/c1242f3bd4343c760362950d7953a172b2d112f5) - fix(cache): honor the streaming guard in the SSR cache-snapshot round-trip. The snapshot path's content-type classifiers were hand-mirrored against `decodeResponse` but omitted its `isStreamingResponse` refusal, so a `cache()`d GET to a streaming endpoint (SSE / NDJSON / JSONL) would (a) hang SSR — `snapshotEntryFromCache` called `response.text()` on a never-ending body — and (b) break isomorphism — `warmValueFromSnapshot` warm-decoded the body to a value while a live read throws the "use tail()/stream()" error. The server now skips streaming responses (shared `isStreamingResponse`) and the warm decoder defers them to the async path, keeping it a strict subset of `decodeResponse`.
-
-- [`f710ba8`](https://github.com/briancray/abide/commit/f710ba8a6266f67c7ff03d9117e1484a7c63f59a) - fix(ui): single shared `skeletonContext` pass drives `<!--a-->` anchor placement for both back-ends, so the SSR string and client build can't disagree about skeleton markers. Previously the server tracked skeleton position as mutable traversal state reset at each fresh-context boundary; a forgotten reset (component slot content, snippet bodies) leaked an anchor the client never emitted, desyncing hydration. Boundaries are now enumerated once, declaratively. Adds a generative, reference-checked congruence harness (`uiRenderCongruenceFuzz`) that combinatorially nests every fresh-context boundary inside skeletonable parents and checks marker congruence + content against a by-construction reference + a hydration round-trip — catching this whole drift class without hand-enumerating shapes.
-
-## 0.34.1
-
-### Patch Changes
-
-- [`fcaf01b`](https://github.com/briancray/abide/commit/fcaf01bf160e300258568a0614f6b3cbef11e585) - project linked as a writable let in the typecheck shadow ([`cc9f3aa`](https://github.com/briancray/abide/commit/cc9f3aa0573be03318cbd8c8e389035fc6683408))
-
-## 0.34.0
-
-### Minor Changes
-
-- [`3697394`](https://github.com/briancray/abide/commit/3697394b693f82266dadd227033d08cacd9df0bf) - make scope() the sole reactive surface ([`7484b44`](https://github.com/briancray/abide/commit/7484b44034542a9bdbdaeedd6c8b9bb08c71f2cf))
-
-### Patch Changes
-
-- [`1593504`](https://github.com/briancray/abide/commit/159350461d6b1070bd0981c7a8ae049655eb1c7d) - drop unused Doc import from Scope type ([`383669b`](https://github.com/briancray/abide/commit/383669b957648e4393e4df341dc9e1b01303fab5))
-
-- [`3697394`](https://github.com/briancray/abide/commit/3697394b693f82266dadd227033d08cacd9df0bf) - rename selector "scope" to "tags" ([`38c41c8`](https://github.com/briancray/abide/commit/38c41c838091448c1477f588e6fafc4e566f9830))
-
-- [`3697394`](https://github.com/briancray/abide/commit/3697394b693f82266dadd227033d08cacd9df0bf) - rename @readme export tag to @documentation ([`7045cfb`](https://github.com/briancray/abide/commit/7045cfbe5a9d3f69d165cb91fd01355f76162495))
-
-- [`3697394`](https://github.com/briancray/abide/commit/3697394b693f82266dadd227033d08cacd9df0bf) - preserve template-literal whitespace when indenting module bodies ([`89d975a`](https://github.com/briancray/abide/commit/89d975ae58dc4459c85909f414e0e46431924103))
-
-- [`3697394`](https://github.com/briancray/abide/commit/3697394b693f82266dadd227033d08cacd9df0bf) - resolve scope() in the shadow program and map binding names ([`a06c38a`](https://github.com/briancray/abide/commit/a06c38a08d417bd45509c58d661caa5f45b34ae3))
-
-- [`3697394`](https://github.com/briancray/abide/commit/3697394b693f82266dadd227033d08cacd9df0bf) - migrate to the scope() authoring surface ([`b0691fc`](https://github.com/briancray/abide/commit/b0691fc56746e516b7196eec008c063c0dda5e6d))
-
-- [`3697394`](https://github.com/briancray/abide/commit/3697394b693f82266dadd227033d08cacd9df0bf) - rewrite scope() to avoid assignment-in-expression ([`c6e021b`](https://github.com/briancray/abide/commit/c6e021b68401bb30e55f11cf587a4b1bdf6f41c9))
-
-- [`3697394`](https://github.com/briancray/abide/commit/3697394b693f82266dadd227033d08cacd9df0bf) - regenerate README/AGENTS and refocus the write-readme skill ([`d40a3fe`](https://github.com/briancray/abide/commit/d40a3fec152c339f267327a95348af51c1f62027))
-
-## 0.33.1
-
-### Patch Changes
-
-- [`e9fb88f`](https://github.com/briancray/abide/commit/e9fb88f517d9c7eac24044a6b65f473263525a6e) - keep a wedged dev orchestrator from orphaning the server on the port ([`a29800d`](https://github.com/briancray/abide/commit/a29800d76300ff4d1c99a4d27dc790562a4af57b))
-
-## 0.33.0
-
-### Minor Changes
-
-- [`8af031e`](https://github.com/briancray/abide/commit/8af031e74ff3f3ab9cef05df75c0bbc22bd370d6) - feat(cache): rename the cache invalidation-policy option from `invalidate` to `swr` (stale-while-revalidate). `swr: true` keeps the entry and refetches in the background on a `cache.invalidate` hit — the stale value stays visible and `refreshing()` reports the in-flight reload — instead of dropping the entry to `pending()`. An optional window coalesces a burst of invalidations: `swr: { throttle: N }` refetches on the leading edge then at most once per N ms, `swr: { debounce: N }` refetches only after N ms of quiet. `cache()` still throws at wrap time on throttle+debounce set together, on `ttl: 0`, and on a non-replayable remote method. Replaces the former `invalidate: { throttle, debounce }` option (same coalescing semantics, clearer name).
-
-### Patch Changes
-
-- [`9d4d899`](https://github.com/briancray/abide/commit/9d4d8992499bc7ef6e9cfc963dafc819725adabe) - fix: keyed `each`, `when`, and `switch` no longer crash when a synchronous write rebuilds them mid-hydrate. A page seeding shared reactive state during the hydrate pass (e.g. `breadcrumbs.crumbs = [...]`, or flipping an `if`/`switch` condition) re-ran the block's effect while `RENDER.hydration` was still active, so its fresh build claimed SSR nodes that were never adopted — surfacing as `null is not an object (element.setAttribute)` in `attr`/`openChild`. The reactive rebuild now runs with the global claim cursor cleared (restored after, mirroring `awaitBlock`/`tryBlock`): `each` clears it around its reconcile body, and `when`/`switch` get it for free via `fillBefore`, their single fresh-build path — adopt happens in place, so `fillBefore` is only ever create mode.
-
-- [`9d4d899`](https://github.com/briancray/abide/commit/9d4d8992499bc7ef6e9cfc963dafc819725adabe) - fix: SVG and MathML now render correctly on the client. The imperative element builder used `document.createElement`, so a foreign element built on the client (an `<svg>` with a binding, a bound `<path>` inside an svg, foreign content with reactive children, or foreign elements generated by `if`/`each`/`await`) landed in the HTML namespace and rendered as nothing — SSR was unaffected, the divergence appeared only on the client-create path. Three changes close it: a static foreign subtree carrying bindings builds through a new parser-backed `skeleton` (one clone of a `<template>`-parsed skeleton, holes located and wired by index — the browser parser namespaces foreign content for free); the imperative path (`openChild`/`cloneStatic`) now namespaces elements off their parent via `createElementNS`/a foreign parse wrapper; and control-flow blocks (`when`/`switch`/`each`/`eachAsync`/`await`/`try`) carry an ambient foreign-namespace context (`RENDER.namespace`) across the detached fragment they build into, which `skeleton`/`openChild`/`cloneStatic` consult. Hydration was already correct (it adopts server-namespaced nodes).
-
-- [`9d4d899`](https://github.com/briancray/abide/commit/9d4d8992499bc7ef6e9cfc963dafc819725adabe) - refactor(ui): unify the client render backend on the parser-backed `skeleton` and delete the imperative `openChild` element builder. Every bound element now builds through one clone-with-located-holes path — element holes by element-only path, and reactive text / control-flow blocks / `<slot>` outlets positioned by `<!--a-->` anchors (`anchorCursor`), so a block or slot can sit anywhere among static siblings (not just in a `[prefix][contiguous blocks][suffix]` shape). Nested `<script>`/snippet children build through the skeleton too. Foreign content (SVG/MathML) keeps its namespace in every case (the browser parser is the sole tree-builder). New plumbing: `abide/ui/dom/anchorCursor`, `abide/ui/dom/mountSlot`. Removed: `abide/ui/dom/openChild`, `abide/ui/dom/cursorAfterElements` (and the internal `childNamespace`). SSR emits the matching `<!--a-->` anchors, so the SSR == client DOM invariant holds. No public `.abide` behaviour change.
-
-    Also fixes `<template await>` hydration when the block is genuinely pending (no resume value, not warm-sync): it discards the SSR boundary and rebuilds, and now (a) inserts at the node _after_ the discarded boundary rather than the captured insertion ref — which for a skeleton-anchored block was the await's own open boundary, removed by the discard, so reusing it threw `NotFoundError` in a strict DOM (WebKit) — and (b) clears the claim cursor while rebuilding the pending branch, so its static content actually builds instead of trying to claim discarded nodes. The test mini-DOM's `insertBefore` is now strict (throws on a non-child reference) so this class of bug surfaces in tests, not only the browser.
-
-## 0.32.2
-
-### Patch Changes
-
-- [`786f07a`](https://github.com/briancray/abide/commit/786f07a3c23986e988b2f0c0b3326e050129c959) - sync examples and ui README to current API ([`923bb86`](https://github.com/briancray/abide/commit/923bb8674814e8efcacc954beac0f1c7982b0e2c))
-
-- [`786f07a`](https://github.com/briancray/abide/commit/786f07a3c23986e988b2f0c0b3326e050129c959) - reject a static import in a nested <template> script ([`b9e7c76`](https://github.com/briancray/abide/commit/b9e7c76509d2401484d3f997b0cb904af4b5080c))
-
-- [`786f07a`](https://github.com/briancray/abide/commit/786f07a3c23986e988b2f0c0b3326e050129c959) - merge valueAtPath + pathExists into a single-pass walkPath ([`bad087b`](https://github.com/briancray/abide/commit/bad087b39c4b5427bf44fec6c3f2eb1fdbccf9c2))
-
-- [`786f07a`](https://github.com/briancray/abide/commit/786f07a3c23986e988b2f0c0b3326e050129c959) - remap any HTML-element-named component wrapper, not just void ([`bbbbe35`](https://github.com/briancray/abide/commit/bbbbe353e22b5d016cd47e81eb8bc9a786fbe336))
-
-- [`786f07a`](https://github.com/briancray/abide/commit/786f07a3c23986e988b2f0c0b3326e050129c959) - extract the static-clone template cache, keyed per document ([`d35beaa`](https://github.com/briancray/abide/commit/d35beaa956a449b79a5be63034473262226ad44d))
-
-## 0.32.1
-
-### Patch Changes
-
-- [`660ce08`](https://github.com/briancray/abide/commit/660ce08109160156dc9697fcb223fbb335229243) - fold asset-serve request logging into a timedServe helper ([`17aa14a`](https://github.com/briancray/abide/commit/17aa14aa3f04abe76a2e06b0c2fb0a8d4e725603))
-
-- [`660ce08`](https://github.com/briancray/abide/commit/660ce08109160156dc9697fcb223fbb335229243) - swallow the superseded each-async iterator's return rejection ([`5e2898f`](https://github.com/briancray/abide/commit/5e2898ff8a785508aa8fde70f3fc351dcdc8e014))
-
-- [`9643066`](https://github.com/briancray/abide/commit/9643066cf19bb944a55509333fd1421a3a8cce7a) - fix(check): narrow `<template else>` against the condition's negation. The shadow type-checker emitted a nested `else` child inside the `if` block, so the else body inherited the if's positive narrowing — a literal-union compare read as "no overlap" and a `typeof`-narrowed branch saw the wrong member. It now pairs the `else` child as a real `if (…) {…} else {…}`, matching the runtime's pairing.
-
-- [`9643066`](https://github.com/briancray/abide/commit/9643066cf19bb944a55509333fd1421a3a8cce7a) - fix(check): value-project a nested control-flow `<script>` like the leading one. The shadow type-checker emitted a branch-scoped `<script>` body raw, so its `state`/`derived` declarations kept their `State<T>`/`Derived<T>` types — every read of a nested signal in the branch's markup false-positived (`'Derived<string>' and 'string' have no overlap`, `Property 'length' does not exist on type 'Derived<…>'`). It now rewrites a nested script's reactive declarations to their value types, matching the runtime, which derefs nested-script signals through the rest of the branch.
-
-- [`0c54e5a`](https://github.com/briancray/abide/commit/0c54e5a025eef96ebc7eece3f51b8a167241434d) - fix(ui): don't emit a void element as a component's mount wrapper. A component instance mounts into a wrapper tag derived from its name (`<Search>`→`<search>`); when the name lowercases to a void element (`<Input>`→`<input>`, `<Img>`→`<img>`) the wrapper self-closes and the HTML parser reparents the component's own markup as the wrapper's siblings, so on hydration `openChild` finds the wrapper empty, claims `null`, and `attr` throws `null is not an object (setAttribute)` — aborting hydration. Such names now map to a hyphenated custom-element tag (`abide-input`, never void) made layout-transparent with `display:contents`, so the child's real root still lays out as a direct child of the parent. Both the SSR string and the client build go through the shared `componentWrapperTag`, keeping them in agreement.
-
-- [`9695bea`](https://github.com/briancray/abide/commit/9695bea26309b693d6b61a4dec1641559421c714) - perf(ui): carry the streamed await-block resume value in a `<script type="application/json">` child instead of a `data-resume` attribute. The attribute form HTML-escaped the JSON (`"` → `&quot;`, plus `&`/`<` passes), inflating the raw payload ~38% and costing two full-string regex passes per render (~2.6 ms/MB; ~10 ms for a 3.7 MB payload). Script content is raw text, so only `<` is neutralized as the JSON escape — ~130–150× cheaper to encode and no quote inflation. `applyResolved` and the inline `SSR_SWAP_SCRIPT` now read the value via `.textContent` and drop the script before swapping the resolved markup into its boundary.
-
-## 0.32.0
-
-### Minor Changes
-
-- [`786a496`](https://github.com/briancray/abide/commit/786a4965fa3c94954ea8d66aa41b0f94e0ec8320) - render control-flow branches into marker-bounded ranges ([`23efa06`](https://github.com/briancray/abide/commit/23efa0606b90b69ff262679673d660a71baf443c))
-
-### Patch Changes
-
-- [`786a496`](https://github.com/briancray/abide/commit/786a4965fa3c94954ea8d66aa41b0f94e0ec8320) - report checked component count on success ([`9ea83bb`](https://github.com/briancray/abide/commit/9ea83bb3c072d72e67486906b191964505e872f2))
-
-## 0.31.1
-
-### Patch Changes
-
-- [`a9f7b3b`](https://github.com/briancray/abide/commit/a9f7b3b09f1db15fa784844a2672b1058dde2b25) - stop the type-check shadow merging a semicolon-less call into the next component ([`7d863d7`](https://github.com/briancray/abide/commit/7d863d7b1f2d4d973a5eafd94cf5002fdeb519c4))
-
-## 0.31.0
-
-### Minor Changes
-
-- [`ea69bad`](https://github.com/briancray/abide/commit/ea69bad96d516dc6884d8a8c014b47c4864ebbe6) - linked() reactive cell, writable derived, state write-transform ([`82301ea`](https://github.com/briancray/abide/commit/82301eabcda0866eec471f95048f74079ea93ab7))
-
-- [`ea69bad`](https://github.com/briancray/abide/commit/ea69bad96d516dc6884d8a8c014b47c4864ebbe6) - sharper template type-checking in the shadow ([`f280619`](https://github.com/briancray/abide/commit/f280619778c23200a0f11cf8e6344edf2ea39884))
-
-- [`ea69bad`](https://github.com/briancray/abide/commit/ea69bad96d516dc6884d8a8c014b47c4864ebbe6) - pass component on\*/bind/attach attributes through as props ([`f9a9202`](https://github.com/briancray/abide/commit/f9a9202d8555d7246fcc4338e833551f54ee8968))
-
-### Patch Changes
-
-- [`ea69bad`](https://github.com/briancray/abide/commit/ea69bad96d516dc6884d8a8c014b47c4864ebbe6) - extract messageFromError, contentTypeOf, discardBoundary helpers ([`1bfb721`](https://github.com/briancray/abide/commit/1bfb721a8a8d3c8907bc9d4d0c6d97ddc265ed1e))
-
-- [`ea69bad`](https://github.com/briancray/abide/commit/ea69bad96d516dc6884d8a8c014b47c4864ebbe6) - resolve the chained route on the page proxy ([`ed518c1`](https://github.com/briancray/abide/commit/ed518c1e8232c04496fe3fd04783f750164bc378))
-
-- [`ea69bad`](https://github.com/briancray/abide/commit/ea69bad96d516dc6884d8a8c014b47c4864ebbe6) - share one component analysis across client and SSR back-ends ([`f330664`](https://github.com/briancray/abide/commit/f33066441625c08077b1b413603204ec2afe59eb))
-
-- [`ea69bad`](https://github.com/briancray/abide/commit/ea69bad96d516dc6884d8a8c014b47c4864ebbe6) - format .abide <script> bodies via Biome ([`f4fc64e`](https://github.com/briancray/abide/commit/f4fc64ecb838a449dfb669af5fcaf40bcf7fa8ca))
-
-## 0.30.0
-
-### Minor Changes
-
-- [`311f3e7`](https://github.com/briancray/abide/commit/311f3e76732eb2b98d2739f2f7eff0fbbb667645) - cross-fade navigations via the View Transition API ([`d3ea6c0`](https://github.com/briancray/abide/commit/d3ea6c001c47748dd2be3ae47dfc3624ae7c65ee))
-
-### Patch Changes
-
-- [`311f3e7`](https://github.com/briancray/abide/commit/311f3e76732eb2b98d2739f2f7eff0fbbb667645) - surface attach= binding and named-template snippets in .abide grammar ([`51a37ee`](https://github.com/briancray/abide/commit/51a37ee0b0cef708d0571de272ace3584d45a8c0))
-
-- [`311f3e7`](https://github.com/briancray/abide/commit/311f3e76732eb2b98d2739f2f7eff0fbbb667645) - hoist component-local types above \_\_Props so prop annotations resolve ([`8d674c5`](https://github.com/briancray/abide/commit/8d674c543be53ae5775124f392ee44fd8731204f))
-
-## 0.29.0
-
-### Minor Changes
-
-- [`2d2c141`](https://github.com/briancray/abide/commit/2d2c141a59d3643f997ef4bb16773d29e4149c95) - add 'abide init-agent' command ([`b5e9158`](https://github.com/briancray/abide/commit/b5e915862a74febffb8df28c68f444a73bd371da))
-
-### Patch Changes
-
-- [`2d2c141`](https://github.com/briancray/abide/commit/2d2c141a59d3643f997ef4bb16773d29e4149c95) - add AGENTS.md complete public-surface map for agents ([`b0539ec`](https://github.com/briancray/abide/commit/b0539ec69c880106dc1b0cb8573203e7113964ed))
-
-## 0.28.0
-
-### Minor Changes
-
-- [`6379ac1`](https://github.com/briancray/abide/commit/6379ac1d4551d1d87183907ccb56a0f7a7b3ba8a) - client-side navigate ([`151a932`](https://github.com/briancray/abide/commit/151a932f4b5f5d4fa5409487ca0707f1929ae255))
-
-- shadow type-check + import resolution; fix entity escaping & cell method calls ([`422a975`](https://github.com/briancray/abide/commit/422a97575a6efc8c00861b2d600bb07f043cd8e9))
-
-- [`6379ac1`](https://github.com/briancray/abide/commit/6379ac1d4551d1d87183907ccb56a0f7a7b3ba8a) - bound RPC calls with timeout, offline detection, and reachability ([`4b8c932`](https://github.com/briancray/abide/commit/4b8c9321edbd6ca9a4dc1185fbf2e30b8623c122))
-
-- component hot-module reload ([`e42e638`](https://github.com/briancray/abide/commit/e42e6381e3639b0093b97cb730abd93c53cb2e6c))
-
-- attach directive and effect/attachment teardowns ([`e65be44`](https://github.com/briancray/abide/commit/e65be442847f5f96ccb659fb18cf7edb29080324))
-
-- [`0cf889b`](https://github.com/briancray/abide/commit/0cf889b859b9169be2abd35c2624ff762bd08e91) - Add `@abide/inspector` — an opt-in inspector activated by `ABIDE_ENABLE_INSPECTOR=true`. Install it (`bun add -d @abide/inspector`) and the flag mounts a UI at `/__abide/inspector`.
-
-    Three tabs over one event stream:
-
-    - **Logs** (default) — a live tail of request traffic, app/diagnostic channels, cache tallies, and published socket frames, with filters by channel, trace id, and free text. Click a trace id to pivot the feed to that trace.
-    - **Traces** — records grouped by trace id. Because abide propagates W3C trace context (a page session is one trace — the SSR render plus every RPC its interactions fire), a trace holds many requests; the tab splits each trace into nested per-request lanes (each on its own time axis, children indented under the request they descend from) with a span waterfall per request. Records now carry `requestSpan` / `parentSpan` (from the request's `TraceContext`) so this split is possible.
-    - **Cache** — the persistent (`global: true`) cache store: each entry's key, lifecycle state (settled / in-flight / refreshing), kind, ttl, time-to-expiry, scope tags, invalidate policy, and a value preview. Refreshes on open and on demand. (Request-scoped caches are ephemeral, so they surface as per-request tallies in Logs/Traces instead.)
-    - **Surface** — the static machine catalog: RPC verbs (with their declared `timeout` / `maxBodySize` / `crossOrigin` / `files` options as columns, and input/output JSON Schemas on expand) and sockets.
-
-    The framework now self-instruments the request lifecycle with `log.trace` spans on DEBUG-gated diagnostic channels — `abide:render` (SSR render), `abide:view` (view/module resolution), `abide:rpc` (verb dispatch + validation; reveals in-process RPC→RPC calls as nested spans in the same trace), `abide:cache` (producer run on a miss + coalesced wait), `abide:mcp` (tool dispatch), and `abide:sockets` (REST tail/publish). They're zero-cost when their channel is off and fill the Traces waterfall when enabled (`DEBUG=abide:*`). The verb registry now records `timeout` / `maxBodySize` / `crossOrigin` so introspection can report them.
-
-    Core stays clean: a guarded, non-literal dynamic import keeps the package out of the compiled binary, and core injects an `InspectorContext` so the package imports no abide internals. Two passive observation seams feed the inspector — the existing log tap plus a new socket-frame tap in `defineSocket`'s `publish()` — both no-ops when no inspector is mounted. The inspector is privileged operator tooling: it answers ahead of `app.handle` and warns loudly on mount, so enable it only in trusted/dev environments.
-
-### Patch Changes
-
-- [`6379ac1`](https://github.com/briancray/abide/commit/6379ac1d4551d1d87183907ccb56a0f7a7b3ba8a) - replace test client with createTestApp harness ([`02b846b`](https://github.com/briancray/abide/commit/02b846b11c0179f610644935c9137d2dbd288e18))
-
-- remove dead code surfaced by sweep ([`038b78c`](https://github.com/briancray/abide/commit/038b78cfad1154c7e79c7f1bb5cd823012e5671f))
-
-- rename project belte → abide ([`3ed697b`](https://github.com/briancray/abide/commit/3ed697bd3c804bdd79642d9edb5d3f3045ecdb53))
-
-- clear biome errors blocking the release gate ([`456962a`](https://github.com/briancray/abide/commit/456962ab4aa33bf854e33b7d2bdb1c961b8b7095))
-
-- swap zstd asset compression for gzip ([`51f3cfd`](https://github.com/briancray/abide/commit/51f3cfd126c3b5694564db91b9197627d5b84d4d))
-
-- robust flag/help parsing and SIGINT listener cleanup ([`61a29e3`](https://github.com/briancray/abide/commit/61a29e39c0e58d2590b77785639fcc4b8bb86552))
-
-- finish @abide/abide rename in template + smoke CI ([`678635b`](https://github.com/briancray/abide/commit/678635b19ea51b9351864a31cb726e62b829211d))
-
-- compile correctness — escaping, void tags, scoped css, runtime imports ([`7f549a4`](https://github.com/briancray/abide/commit/7f549a4661ab2f16f9a44bdb4a78fc5d8b78ae50))
-
-- linked-list reactivity graph + scope teardown ([`80ba57a`](https://github.com/briancray/abide/commit/80ba57a7f1ebd611a230b4d7f997d9e4f9afce66))
-
-- harden compile-time HTML/CSS handling ([`a65b678`](https://github.com/briancray/abide/commit/a65b6788a4dcfb0894994d1f8a76629cfcb29602))
-
-- static-template cloning + child-mount primitive ([`a8cb9c7`](https://github.com/briancray/abide/commit/a8cb9c70429d35512a2f5560ac6336ee6ec2e94b))
-
-- re-fire coalesced invalidations and harden hydration/iteration ([`cdf7887`](https://github.com/briancray/abide/commit/cdf7887422892cb58a9074c940add8c413b48aaa))
-
-- harden request handling against edge inputs ([`cf2db7c`](https://github.com/briancray/abide/commit/cf2db7ce6d565a6b4be8d63a4d3cfee24c630c92))
-
-- [`cdd8a58`](https://github.com/briancray/abide/commit/cdd8a587d55db05da5bb2d0b0e694f7bf532db8d) - tag InspectorContext export for the @readme gate ([`d2157de`](https://github.com/briancray/abide/commit/d2157de56f00c9aed99cd7b4d4d267c6f296f167))
-
-- inject shell assets case-insensitively, append when tag absent ([`de61b55`](https://github.com/briancray/abide/commit/de61b55e569926233357620e853fe665a0e09e4c))
-
-- drop dead stream-resume subsystem; fix layout + README-symlink docs ([`e39debb`](https://github.com/briancray/abide/commit/e39debb1952169067d3b5c7a66208049a99d23a7))
-
-- remove Svelte references across code, docs, and tooling ([`e77872a`](https://github.com/briancray/abide/commit/e77872ae3c1f799b5defba9b051ec35a3c6f5a88))
-
-- [`9d71d45`](https://github.com/briancray/abide/commit/9d71d45186153eec2b7be094f2e3a9ceae952212) - Fix an infinite loop when a `derived` over a `createSubscriber`-backed resource (e.g. `tail()` of a socket) is read by an effect. `trigger` walked the live observer `Set` while the flush it fired synchronously recomputed the derived, whose `runNode` deletes-then-re-adds itself to that same set — re-yielding it to the in-progress `for…of` forever. Invalidation now snapshots each observer set and the queued effects flush once at the outermost trigger, never mid-propagation.
-
-## 0.27.0
-
-### Minor Changes
-
-- [`f93e490`](https://github.com/briancray/abide/commit/f93e4902a87766978b9ea90d10705ef7bd4ebb2b) - cache.on context.patch for server-pushed deltas ([`70acb1d`](https://github.com/briancray/abide/commit/70acb1d2ff73980d97a2bddeb28e5ee184a3781b))
-
-## 0.26.1
-
-### Patch Changes
-
-- [#73](https://github.com/briancray/abide/pull/73) [`9397ef5`](https://github.com/briancray/abide/commit/9397ef515b5f9f7a8f42532463368ebd8195aa10) Thanks [@briancray](https://github.com/briancray)! - remaining `noUncheckedIndexedAccess` errors in shipped source (parsePromptMarkdown, logExposedSurfaces, createPageRenderer, createMcpResourceServer) — and CI now type-checks the shipped surface under the scaffolded consumer tsconfig plus that flag, so this class of strict-consumer breakage fails CI instead of an app's `bun check`
-
-- [#73](https://github.com/briancray/abide/pull/73) [`9397ef5`](https://github.com/briancray/abide/commit/9397ef515b5f9f7a8f42532463368ebd8195aa10) Thanks [@briancray](https://github.com/briancray)! - fix(abide): parseTraceparent type-checks under `noUncheckedIndexedAccess` — abide ships raw TS, so the destructured regex groups read as possibly undefined in strict consumer tsconfigs and failed the app-side check
-
-## 0.26.0
-
-### Minor Changes
-
-- [`863b74f`](https://github.com/briancray/abide/commit/863b74f3a2ea117993bf407d6aa23f8fc62793ee) - cache read stats with abide:cache diagnostics channel ([`1f46eb1`](https://github.com/briancray/abide/commit/1f46eb16dafcb1f8d165ce9d30a7f5bfb3a47885))
-
-- [`863b74f`](https://github.com/briancray/abide/commit/863b74f3a2ea117993bf407d6aa23f8fc62793ee) - per-verb maxBodySize cap on received body bytes ([`bf7086b`](https://github.com/briancray/abide/commit/bf7086be583129e1cd0abf10c97ff1379f496074))
-
-- [`863b74f`](https://github.com/briancray/abide/commit/863b74f3a2ea117993bf407d6aa23f8fc62793ee) - unified log with trace context and DEBUG-gated channels ([`ddf6146`](https://github.com/briancray/abide/commit/ddf61460893fbdc26f04b9f7050db45c3aa71efa))
-
-- [`863b74f`](https://github.com/briancray/abide/commit/863b74f3a2ea117993bf407d6aa23f8fc62793ee) - /\_\_abide/health endpoint, app health hook, and online() probe ([`f933e16`](https://github.com/briancray/abide/commit/f933e16856fdd9b35f8dd99a12791b5d557025a2))
-
-## 0.25.2
-
-### Patch Changes
-
-- [`f9cd269`](https://github.com/briancray/abide/commit/f9cd269b44b065702275422ac710019117f69a2c) - fix(abide): `json(undefined)` returns 204 No Content instead of throwing
-
-    `Response.json(undefined)` throws TypeError because JSON has no encoding for
-    `undefined`, so any handler returning `json(undefined)` — e.g. a
-    `Shape | undefined` route signalling "not found" — 500ed instead of degrading.
-    `json()` now emits 204 No Content for `undefined`, which `decodeResponse`
-    already maps back to `undefined` on both the fetch and in-process paths, so
-    the `Shape | undefined` RPC contract round-trips the wire. The helper owns
-    the 204; it wins over any `init.status`.
-
-## 0.25.1
-
-### Patch Changes
-
-- [`ee6c2a3`](https://github.com/briancray/abide/commit/ee6c2a3e2f7506a77540ff12bc4c45d0f84dc083) - sync examples and scaffold template to the restructured README ([`5ec6cf7`](https://github.com/briancray/abide/commit/5ec6cf7ad2b99f12904605d34a1fafb05a1196ab))
-
-- [`ee6c2a3`](https://github.com/briancray/abide/commit/ee6c2a3e2f7506a77540ff12bc4c45d0f84dc083) - dedupe framework paths, helpers, and boot/request hot paths ([`6d4b0f8`](https://github.com/briancray/abide/commit/6d4b0f8ace9ec66445fdd68e033475cfb1742e4c))
-
-- [`7389826`](https://github.com/briancray/abide/commit/7389826331434b252c6fd1ac9b9809a376fb563f) - cache: a policy refetch that hits a 404 now evicts the entry instead of retaining it — the resource is gone, so keeping the stale value made the entry immortal (every later invalidation re-fired the dead fetch). Transient failures (network errors, 5xx) still keep the stale value; a non-2xx Response from a remote refetch is no longer swapped in as fresh data.
-
-## 0.25.0
-
-### Minor Changes
-
-- [`b0fd235`](https://github.com/briancray/abide/commit/b0fd2353a98008ae306b1cc1b8f112cdbda420a2) - cache.on event-driven invalidation and per-call selectors ([`fe7e0e6`](https://github.com/briancray/abide/commit/fe7e0e6ff45875e59e044280379d119a635a6193))
-
-### Patch Changes
-
-- [`b0fd235`](https://github.com/briancray/abide/commit/b0fd2353a98008ae306b1cc1b8f112cdbda420a2) - scope probe lifecycle channels and trip runaway invalidate loops ([`7aad405`](https://github.com/briancray/abide/commit/7aad4050edaccf2c95f479fa64ec16b00c2141d7))
-
-## 0.24.3
-
-### Patch Changes
-
-- [`cc26576`](https://github.com/briancray/abide/commit/cc265765b468a4534f3b33e02ec52b9d9b197f13) - `abide dev` no longer reloads the browser after server-only edits. Each dev worker announces a fingerprint of the browser-visible surface (client build contents, public/ stamps, shell) as the first event on the live-reload channel; the page reloads on reconnect only when the fingerprint changed, so editing rpc/socket/server code keeps the page — and all of its UI state — alive while the new server behavior applies on the next request.
-
-- [`40b5273`](https://github.com/briancray/abide/commit/40b52732f1162ddc6b5796457a2942b78334fb4a) - `abide dev` restarts are now zero-downtime: the replacement worker boots alongside the incumbent (both bind the dev port via `reusePort`) and the old worker is retired only once the new one reports ready, so requests never hit a dead port mid-rebuild. A worker that crashes while active is respawned automatically (bounded, so a crash-on-boot loop gives up until the next save), and a replacement that dies or hangs booting is discarded while the last-good server keeps serving.
-
-- [`b4ab65c`](https://github.com/briancray/abide/commit/b4ab65cb5520a9cfd0b9537e2bd85c0cbe6be1d6) - Hidden tabs release their long-lived connections instead of holding them open. The dev live-reload EventSource and the multiplexed sockets WebSocket both close on `visibilitychange: hidden` and reconnect on visible, riding the existing drop paths: the reload client re-captures the worker fingerprint on reconnect (a rebuild while the tab slept still reloads it), and socket consumers resync through the typed disconnect — their fresh sub frames queue while hidden and flush when the tab returns. Backgrounded tabs no longer accumulate idle connections the browser throttles or the server counts against per-host limits.
-
-## 0.24.2
-
-### Patch Changes
-
-- [`021f6f0`](https://github.com/briancray/abide/commit/021f6f0f17108ad8703613d75209087936af359f) - adopt Map.getOrInsertComputed in server-side caches ([`03c342f`](https://github.com/briancray/abide/commit/03c342fd3db5dceaf4de35f1b13f1587384b7482))
-
-- [`021f6f0`](https://github.com/briancray/abide/commit/021f6f0f17108ad8703613d75209087936af359f) - snapshot entry method narrows through ReplayableMethod ([`500af03`](https://github.com/briancray/abide/commit/500af03fd525d4528c59e636e301570cdaf219f8))
-
-- [`021f6f0`](https://github.com/briancray/abide/commit/021f6f0f17108ad8703613d75209087936af359f) - no-input rpc verbs no longer require an explicit undefined argument ([`b57c6b0`](https://github.com/briancray/abide/commit/b57c6b0cab45f40c8adfe943c0c357a0854aa2e7))
-
-- [`dc8cf0f`](https://github.com/briancray/abide/commit/dc8cf0fce2f59c0e7c9d3169f8faa3bf282932a3) - fix(url): keep `[name]` params declared before a `[...rest]` catch-all in `PathParams` — the catch-all branch swallowed its head, so `url('/media/[id]/[...rest]', { id, rest })` rejected `id`
-
-- [`da7544a`](https://github.com/briancray/abide/commit/da7544a21e8b076f6c756d9648baa181167e6b3e) - fix: type-check cleanly under strict consumer flags — abide ships raw TS, so app-side tsconfig flags type-check it. Bind layout/error loaders before invoking (`noUncheckedIndexedAccess`), pin asset/tarball bytes to `Uint8Array<ArrayBuffer>` so they satisfy `BodyInit`, cast the FFI window handle to `Pointer`, and add `erasableSyntaxOnly` to the shipped `tsconfig.app.json`
-
-## 0.24.1
-
-### Patch Changes
-
-- [`529597c`](https://github.com/briancray/abide/commit/529597c974f36f1767bcc597c623041e8bb4a742) - page.url is browser-space on both sides under a mount base ([`455e3ca`](https://github.com/briancray/abide/commit/455e3ca4498274ab98e7dfa14d7752c0b4453109))
-
-- [`529597c`](https://github.com/briancray/abide/commit/529597c974f36f1767bcc597c623041e8bb4a742) - url() accepts undefined query values ([`abb739e`](https://github.com/briancray/abide/commit/abb739e5086f46c8e8870f83ee8eee9a706ce513))
-
-## 0.24.0
-
-### Minor Changes
-
-- [`429dea8`](https://github.com/briancray/abide/commit/429dea81761cd4da6e2cd316a2ee78e8a60ae71e) - scaffold installs deps and starts the dev server ([`986cd72`](https://github.com/briancray/abide/commit/986cd725b82cf49d3dadaa52be00f8a222af638e))
-
-- [`429dea8`](https://github.com/briancray/abide/commit/429dea81761cd4da6e2cd316a2ee78e8a60ae71e) - same-origin CSRF gate + symbol-branded remotes ([`b5570ba`](https://github.com/briancray/abide/commit/b5570ba9a1e5e852d7b791df4a3e177eb82b78a9))
-
-- [`429dea8`](https://github.com/briancray/abide/commit/429dea81761cd4da6e2cd316a2ee78e8a60ae71e) - typed url() helper + APP_URL subpath mount ([`e5bdb57`](https://github.com/briancray/abide/commit/e5bdb57437d0b69cb46013d24ae1bef416b531bd))
-
-- [`429dea8`](https://github.com/briancray/abide/commit/429dea81761cd4da6e2cd316a2ee78e8a60ae71e) - client-side page error boundary ([`f70d885`](https://github.com/briancray/abide/commit/f70d8852568f41b8377a9cc99ff0251aecfc2e5b))
-
-## 0.23.1
-
-### Patch Changes
-
-- [`d8fe8fc`](https://github.com/briancray/abide/commit/d8fe8fcae7863407d7b55774e19762715d311450) - **Fixed**
-
-    - The lifecycle channel defers its notify to a microtask, coalescing marks within a tick. With a live `pending()`/`refreshing()` probe armed, a cold cache read inside a `$derived` — the documented `$derived(await cache(fn)())` idiom — registered its entry mid-derived and wrote the subscriber's version source synchronously, throwing `state_unsafe_mutation` and killing the flush (seen as an unhandled rejection plus a follow-on `active_reaction` TypeError, with UI updates in that batch silently dropped). Probes scan the registry at re-derive time, so the deferred ping reads state that is already current.
-
-## 0.23.0
-
-### Minor Changes
-
-- [`13f841c`](https://github.com/briancray/abide/commit/13f841c4f3ec92727414715c1bb5eeabc12b60a7) - **Breaking**
-
-    - `bundled()` moved to the bundle namespace alongside `onMenu`: `import { bundled } from '@abide/abide/bundle/bundled'` (was `abide/shared/bundled`).
-
-- [`bbc82a1`](https://github.com/briancray/abide/commit/bbc82a12c948acbb2f82fe1dfc46165678fafb04) - Registries act, probes report: standalone `pending`/`refreshing` spanning cache and streams, the `ttl: 0` mutation idiom made sound, and tail reconnect-with-retained-value.
-
-    **Breaking**
-
-    - `cache.pending` / `cache.refreshing` moved to their own modules: `import { pending } from '@abide/abide/shared/pending'`, `import { refreshing } from '@abide/abide/shared/refreshing'`. `cache.invalidate` stays on `cache`.
-    - SSR snapshots ship GET entries only (`REPLAYABLE_METHODS`): DELETE is idempotent but still a write and no longer replays from hydration.
-    - `cache()` now throws at wrap time on invalid policy combinations: `invalidate` policy on a non-GET remote, policy with `ttl: 0`, or `throttle` and `debounce` together.
-
-    **Fixed**
-
-    - Invalidate policies attach on read to entries that lack one (like scope tags), so a snapshot-hydrated entry revalidates stale-in-place from its first invalidate instead of hard-dropping to a pending flash, and a policy-less first read no longer permanently wins.
-    - Hydrated snapshot entries adopt the first reading call site's `ttl` (the snapshot ships no wrap options): omitted keeps the entry as before, `ttl > 0` starts the expiry clock at that read, and `ttl: 0` serves the hydration pass only, evicting a macrotask later — previously any ttl was ignored, so a `ttl: 0` key warm-hit forever and never refetched.
-    - Eviction clears armed policy timers — a TTL-expired or rejected key can no longer ghost-refetch.
-
-    **Added**
-
-    - `pending(x)` / `refreshing(x)` probe both registries: cache selectors (bare / fn / `{ scope }`) plus Subscribables — `pending(chat)` is "awaiting first frame", `refreshing(chat)` is "reconnecting with last value retained" (never merely open). Bare forms span registries. Probes report, never act: they open no fetch and no stream.
-    - `tail()` (né `subscribe()` — renamed in this release) self-heals transport loss: on the typed `SocketDisconnectedError` it keeps its value, flags `refreshing`, and reopens under the channel's backoff (retained-tail replay converges the value — correct for a latest-wins/window consumer). Server `err` frames stay terminal; raw `for await` consumers keep the explicit-disconnect contract.
-    - `cache()` warns once per call site when handed an anonymous producer (fresh identity per call — it can never coalesce and probes can never match it).
-
-- [`c77fc89`](https://github.com/briancray/abide/commit/c77fc89a12f07b9356b5ad68cd4a92f4764e52b8) - Replay is demarcated on the wire: a sub's seed now arrives as one per-sub `{ type: 'replay', sub, messages }` frame (sent even when empty) instead of socket-keyed `msg` frames.
-
-    - `tail()` windows commit their seed atomically at the boundary — no more shrink-regrow rebuild on reconnect or first paint — and an **empty** replay keeps the held window across a gap (nothing replayed = nothing to duplicate; live frames append). Previously the first post-gap frame wiped the window even on non-retaining sockets.
-    - Per-sub addressing fixes cross-sub replay leakage: two subs on the same socket no longer receive each other's replay.
-    - `Subscribable.tail(count, hooks?)` gains optional `TailHooks`: retaining sources must signal `hooks.replayed` in-band once the seed is delivered (sockets do; a source that ends without signalling commits at `done`).
-    - Internal: `createPushIterator` gains `control(run)` — in-band signal slots, strictly ordered against pushed values, invisible to consumers. Raw `for await` iteration is unchanged.
-
-- [`c77fc89`](https://github.com/briancray/abide/commit/c77fc89a12f07b9356b5ad68cd4a92f4764e52b8) - `subscribe()` is now `tail()`, and "history" is dead: one word for reading the retained end of a stream at every altitude — declaration (`socket<T>({ tail: n })`), raw iteration (`chat.tail(count)`), and the reactive consumer (`tail(x)` / `tail(x, { last: n })`).
-
-    **Breaking**
-
-    - `import { subscribe } from '@abide/abide/browser/subscribe'` → `import { tail } from '@abide/abide/browser/tail'`; `subscribe.status`/`subscribe.error` → `tail.status`/`tail.error` (both accept the same `{ last }` options to address a window entry).
-    - Socket declaration option `history` → `tail` (`socket<T>({ tail: 100 })`). Retention is opt-in: an undeclared socket is a pure live pipe and storage is the consumer's concern.
-    - Bare socket iteration (`for await (const m of chat)`) is now live-only — replay is exclusively `.tail`'s job. `chat.tail()` no-arg replays the whole retained tail (the old bare behavior); `chat.tail(n)` the last n. The ws wire is unchanged; only the local defaults flipped.
-    - The reactive bare form seeds a socket via `tail(1)` instead of full replay — retained frames no longer churn through `latest` on open.
-
-    **Added**
-
-    - `tail(x, { last: n })` → `T[]`: a live rolling window of the last ≤n frames, however they arrived ([] while pending and on SSR, never undefined). Retaining sockets seed it by replaying up to `last` (clamped to the declared `tail`); rpc streams and undeclared sockets fill it from live frames. The bare form and each window size are independent subscriptions (`last` is registry-keyed). On reconnect the replay replaces the window, so a gap can't duplicate frames.
-    - `Subscribable.tail(count)` is the optional retention capability: sources that keep recent frames implement it (sockets do verbatim) and the consumer bounds replay to what the reader keeps — no consumer special-casing per source type.
-
-    **Fixed**
-
-    - An untracked `tail.status()`/`tail.error()` read (outside `$derived`/`$effect`) no longer leaks a permanently-pending registry entry that held the bare `pending()` probe true forever.
-
-## 0.22.0
-
-### Minor Changes
-
-- [`80786f1`](https://github.com/briancray/abide/commit/80786f13d2fcaaa1bdb6f1913959010fd1de66a6) - agent test surface — test/createScriptedSurface + test/assertAgentFrameConformance ([`f7dae05`](https://github.com/briancray/abide/commit/f7dae05336d126d7957876180865afb57d6daeea))
-
-### Patch Changes
-
-- [`80786f1`](https://github.com/briancray/abide/commit/80786f13d2fcaaa1bdb6f1913959010fd1de66a6) - domain-language CONTEXT.md, first ADRs, forwardHeaders in app hooks comment ([`1512a33`](https://github.com/briancray/abide/commit/1512a33a10cdccd338411d7a7f3d230dd3779c8a))
-
-- [`80786f1`](https://github.com/briancray/abide/commit/80786f13d2fcaaa1bdb6f1913959010fd1de66a6) - extract view resolver, page renderer, and app asset server from createServer ([`effd6fa`](https://github.com/briancray/abide/commit/effd6fa1f8316347e14e15a1fa5569c2ef4e8b34))
-
-- [`80786f1`](https://github.com/briancray/abide/commit/80786f13d2fcaaa1bdb6f1913959010fd1de66a6) - biome whitespaceSensitivity css + repair collapsed inline spacing ([`f3ac186`](https://github.com/briancray/abide/commit/f3ac1866e1adb66336ad4641f2223aeb724b82b9))
-
-## 0.21.0
-
-### Minor Changes
-
-- [`0a5c25c`](https://github.com/briancray/abide/commit/0a5c25c39c9894f6504f804c1c69e44f997eca6d) - Add `page.navigating` — a boolean on `abide/browser/page` that is true while a pathname-changing SPA navigation resolves its view, and false otherwise (always false during SSR). Read it inside a `$derived`/`$effect` to drive loading indicators.
-
-## 0.20.1
-
-### Patch Changes
-
-- [`b24f689`](https://github.com/briancray/abide/commit/b24f689f06d32c47a0636f5e834758401b8933a7) - degrade un-serializable schemas to opaque instead of throwing ([`9477216`](https://github.com/briancray/abide/commit/94772166c5c1d435bfcd013c8c2bcf75e699bb51))
-
-## 0.20.0
-
-### Minor Changes
-
-- [`9cbca7d`](https://github.com/briancray/abide/commit/9cbca7d28c258d4574ac450811628f107e502711) - Bundle apps auto-start the local assistant. When a bundled abide app connects (embedded or remote) and the app ships `@abide/claude-code` (its UI uses `browser/assistant`) with `claude` on PATH, the bundle launcher runs the loopback bridge for you and hands the page its port+token via the URL fragment — no copy-paste command. The bridge is loopback-only and dies with the connection. abide takes **no dependency** on `@abide/claude-code`: it's a guarded optional import that no-ops (and compiles fine) when the app doesn't ship it.
-
-    `assistant()` gains a `status` — `'ready' | 'starting' | 'manual' | 'unavailable'` — so the same UI works in a browser (`manual` → show `command`) and a bundle (`starting`/`ready` auto-managed, or `unavailable` when `claude` isn't installed → show an install hint). `command` is now `string | undefined` (undefined whenever a host manages the bridge).
-
-## 0.19.4
-
-### Patch Changes
-
-- [`946b6c4`](https://github.com/briancray/abide/commit/946b6c44b09ca30f28f4ab38d43ad5f9db452c2a) - clear lint findings in abide helpers and examples ([`55583cc`](https://github.com/briancray/abide/commit/55583ccd3cfa96e98ec94d0bb87210eaf3c047de))
-
-- [`946b6c4`](https://github.com/briancray/abide/commit/946b6c44b09ca30f28f4ab38d43ad5f9db452c2a) - repair stale package references and sync to current API ([`f33a7b2`](https://github.com/briancray/abide/commit/f33a7b29aa14965790e53bdc3d34082972278abc))
-
-## 0.19.3
-
-### Patch Changes
-
-- [`ae17e17`](https://github.com/briancray/abide/commit/ae17e17cac4a52a7506e411a572857cdf6f2d5d1) - type the warm sync return as Promise<Return> | Return ([`a00afa7`](https://github.com/briancray/abide/commit/a00afa7955fef3755f91b8a4da935916701c070a))
-
-## 0.19.2
-
-### Patch Changes
-
-- [`e772716`](https://github.com/briancray/abide/commit/e772716a190f826f0041b8358271604ad5a230a5) - single prompt renderer and lazy-built agent surface ([`224d348`](https://github.com/briancray/abide/commit/224d34852a63122bb53ba85a5f37af729cc987a7))
-
-- [`e772716`](https://github.com/briancray/abide/commit/e772716a190f826f0041b8358271604ad5a230a5) - surface abnormal engine stops and bound the tool loops ([`d2c3215`](https://github.com/briancray/abide/commit/d2c3215bb50ba41b2407eb8878e426a164927d9d))
-
-- [`e772716`](https://github.com/briancray/abide/commit/e772716a190f826f0041b8358271604ad5a230a5) - populate the page proxy on error and 404 renders ([`e680ae6`](https://github.com/briancray/abide/commit/e680ae6b12c773f1516fe0ab128be9a208d855f0))
-
-## 0.19.1
-
-### Patch Changes
-
-- [`c392c5a`](https://github.com/briancray/abide/commit/c392c5abf08a070617e7bfa1094cc38a20cba002) - read the page store during SSR via a request-scoped resolver ([`85f4c7a`](https://github.com/briancray/abide/commit/85f4c7a486191847772553cd62b34315a15a6438))
-
-## 0.18.0
-
-### Minor Changes
-
-- [`e21b424`](https://github.com/briancray/abide/commit/e21b424e775e893a6d2655045223743c655e366d) - add a same-origin manual rebuild trigger to dev: `POST /__abide/reload` (sibling of the `/__abide/dev` live-reload channel) signals the orchestrator over IPC to rebuild + restart on command. Pair it with `ABIDE_DEV_NO_WATCH=1 abide dev`, which skips the src/ file watcher so a long-lived in-process job (e.g. an agent editing the app's own source) isn't torn down by a save. Default `abide dev` is unchanged; the trigger adds no extra port.
-
-### Patch Changes
-
-- [`b1e00c8`](https://github.com/briancray/abide/commit/b1e00c89e9d18fefaa84aff43fcf08fd5ee703bb) - rename constants to UPPERCASE_SNAKE_CASE ([`d1cc5d2`](https://github.com/briancray/abide/commit/d1cc5d2b09f4344167cfd09d698aef3fb49382c3))
-
-## 0.17.1
-
-### Patch Changes
-
-- [`e643a7e`](https://github.com/briancray/abide/commit/e643a7e74850e4d17435a868f6b71f20b37d7612) - isolate dev builds to staging dirs and reap the server child on exit ([`0f4d97e`](https://github.com/briancray/abide/commit/0f4d97e3194d6dff652a434ab78c8bb651cdefe4))
-
-## 0.17.0
-
-### Minor Changes
-
-- [`41625d6`](https://github.com/briancray/abide/commit/41625d6be7b2e86030a9811039317b8396c1e702) - report post-invalidate reloads via cache.refreshing ([`0008664`](https://github.com/briancray/abide/commit/00086640bc957f6fb65fb5bd00a06d622dc96996))
-
-### Patch Changes
-
-- [`41625d6`](https://github.com/briancray/abide/commit/41625d6be7b2e86030a9811039317b8396c1e702) - sync examples and template with 0.16 (bundled, DEBUG=abide) ([`590152d`](https://github.com/briancray/abide/commit/590152d71cd2cba77d9f39970c6590cc8285b2e6))
-
-## 0.16.0
-
-### Minor Changes
-
-- [`38bdca6`](https://github.com/briancray/abide/commit/38bdca60b6a05496f16b87a89660c0e4742b894c) - add bundled() to detect the desktop bundle ([`3cdca36`](https://github.com/briancray/abide/commit/3cdca36d5d31b6ffc3eaf88adc296ee5f285eb83))
-
-### Patch Changes
-
-- [`38bdca6`](https://github.com/briancray/abide/commit/38bdca60b6a05496f16b87a89660c0e4742b894c) - extract clientBuildPlugins for the page and connect-screen builds ([`0974367`](https://github.com/briancray/abide/commit/0974367947b4619780b8d60f959c9067974f437b))
-
-- [`38bdca6`](https://github.com/briancray/abide/commit/38bdca60b6a05496f16b87a89660c0e4742b894c) - share a defaultPort across server, dev, and embedded launcher ([`27f91e5`](https://github.com/briancray/abide/commit/27f91e512963b0a82d39f66c20778ee9191c9f07))
-
-- [`38bdca6`](https://github.com/briancray/abide/commit/38bdca60b6a05496f16b87a89660c0e4742b894c) - extract importNamesToStrip for the server-stub strip ([`2b28922`](https://github.com/briancray/abide/commit/2b28922576202daee109170774e2b763de786b7e))
-
-- [`38bdca6`](https://github.com/briancray/abide/commit/38bdca60b6a05496f16b87a89660c0e4742b894c) - render the boot surface map as aligned page/socket/rpc tables ([`2b336af`](https://github.com/briancray/abide/commit/2b336af13c8b2a375d4e2d9e6bebfcdce8ab2c9d))
-
-- [`38bdca6`](https://github.com/briancray/abide/commit/38bdca60b6a05496f16b87a89660c0e4742b894c) - resolve the SPA target view before writing history ([`5685e05`](https://github.com/briancray/abide/commit/5685e051eedda4267ced59c12d92441285d48d41))
-
-- [`38bdca6`](https://github.com/briancray/abide/commit/38bdca60b6a05496f16b87a89660c0e4742b894c) - avoid per-call array allocation in forwardHeaders ([`acc859b`](https://github.com/briancray/abide/commit/acc859b7f213a1349e1fefd106ff146aa1dd0a24))
-
-## 0.15.0
-
-### Minor Changes
-
-- [`c9d0d8b`](https://github.com/briancray/abide/commit/c9d0d8bb3102c5baabf680cef310963626558658) - dev orchestrator with browser live-reload ([`5d2b392`](https://github.com/briancray/abide/commit/5d2b392a41a659bf3b198a29930dde4caf4f44d0))
-
-## 0.14.0
-
-### Minor Changes
-
-- [`559772c`](https://github.com/briancray/abide/commit/559772cdee4f496629a3e2cb5c38a1f4206703d9) - configurable SSR/MCP header forwarding and a boot-time surface map ([`6f03a53`](https://github.com/briancray/abide/commit/6f03a5367cd3d16a7f51910a992cf081fb6e0b02))
-
-- [`559772c`](https://github.com/briancray/abide/commit/559772cdee4f496629a3e2cb5c38a1f4206703d9) - add cache.refreshing() reactive revalidation probe ([`8ab8666`](https://github.com/briancray/abide/commit/8ab866670888970c728aa68c4d20999e19d46756))
-
-### Patch Changes
-
-- [`559772c`](https://github.com/briancray/abide/commit/559772cdee4f496629a3e2cb5c38a1f4206703d9) - prevent cache-key collisions for Date/Map/Set/bigint args ([`3910cbf`](https://github.com/briancray/abide/commit/3910cbf3d3a3e7204df91a8a55284b00a5c052a0))
-
-## 0.13.2
-
-### Patch Changes
-
-- [`0dfb38f`](https://github.com/briancray/abide/commit/0dfb38f16ab42d9d25806a9fad8fdfd6846b708f) - wire bun test preload and complete abide command scripts in scaffold + examples ([`6bd497a`](https://github.com/briancray/abide/commit/6bd497a065190f0afdd4445848e7322a8b120d50))
-
-## 0.13.1
-
-### Patch Changes
-
-- [`bfbc36c`](https://github.com/briancray/abide/commit/bfbc36c940ace6422c873693258d5c409d6406e9) - Publish an up-to-date README and include `CHANGELOG.md` in the package tarball. The npm copy of the README had drifted from the maintained source; the changelog is now shipped alongside it.
-
-## 0.13.0
-
-### Minor Changes
-
-- [`e052e54`](https://github.com/briancray/abide/commit/e052e5457bec12774b56e095c7ede98c6eb5a945) - add 'abide run' to execute scripts under the abide preload ([`fc77a20`](https://github.com/briancray/abide/commit/fc77a20ec535223cfe56c5f134d812449558047f))
-
-### Patch Changes
-
-- [`e052e54`](https://github.com/briancray/abide/commit/e052e5457bec12774b56e095c7ede98c6eb5a945) - resolve server() in-process so handler idioms don't throw in tests ([`03cc3c1`](https://github.com/briancray/abide/commit/03cc3c1a6fb0ebc3b42156b450952dfc5336819e))
-
-## 0.12.0
-
-### Minor Changes
-
-- [#40](https://github.com/briancray/abide/pull/40) [`26ba6fe`](https://github.com/briancray/abide/commit/26ba6fe710002f84b99947f7b198fa3b3f235d53) Thanks [@briancray](https://github.com/briancray)! - Namespace the CLI's baked env under `ABIDE_` and add data-dir controls.
-
-    **Breaking:** `APP_URL` → `ABIDE_APP_URL` and `APP_TOKEN` → `ABIDE_APP_TOKEN`. These are the values baked into a downloaded CLI's `.env` (the hosted server URL, derived from the request origin, plus the bearer token when the download was authenticated) and read by the thin client to resolve its connection target. `ABIDE_APP_URL` is now public, documented surface — app code can read it to refer to the app's hosted location. Existing baked binaries and any shell `APP_URL`/`APP_TOKEN` overrides must switch to the prefixed names.
-
-    **Added:** `abide/server/appDataDir` — a zero-arg accessor returning the running bundle's per-user data dir, keyed to the same program name abide uses for the user's `.env`/`last-connection.json`, so an app's DB/cache lands beside abide's own config rather than a drifted sibling directory.
-
-    **Added:** `ABIDE_DATA_DIR` — overrides the data dir on every platform, used as-is. A cross-platform `XDG_DATA_HOME` (which the helper otherwise honours on Linux only), letting dev point at a throwaway dir without touching app code. Must come from a layer above the data-dir `.env` (shell, CWD `.env`, or binary-dir `.env`), since it decides where that file lives.
-
-- [#40](https://github.com/briancray/abide/pull/40) [`310eceb`](https://github.com/briancray/abide/commit/310ecebebd018df62155d18ac01a376f5a0f42ba) Thanks [@briancray](https://github.com/briancray)! - Remove the `key` option from `cache()`.
-
-    **Breaking:** `cache(fn, { key })` and the `{ key }` selector form of `cache.invalidate` / `cache.pending` are gone. Cache keys are always auto-derived — method+url+args for a remote function, producer-reference+args for a plain producer. To share an entry across calls, hoist the producer to a stable reference (an inline arrow gets a fresh identity every call and never dedupes). To target a set of unrelated calls with one `cache.invalidate`, tag them with a `scope`; a unique tag (e.g. a uuid) gives a set of calls their own private invalidation group.
-
-## 0.11.1
-
-### Patch Changes
-
-- [#38](https://github.com/briancray/abide/pull/38) [`cb22ce9`](https://github.com/briancray/abide/commit/cb22ce91b83b755e480f2ff0abdb8a246f5e7ff9) Thanks [@briancray](https://github.com/briancray)! - Restore `abide/shared/log` as a public export. The 0.11 switch from `./shared/*` globs to an explicit allowlist dropped this isomorphic utility along with the genuinely-internal machinery: `log` is the framework's `[abide]` logger (browser + server, color-aware, with `log.debug(scope, message)` gated by `DEBUG`), documented public surface rather than an internal, so it is listed again. The `isDebugEnabled` matcher stays internal — `log.debug` already gates on it, so consumers reach for `log.debug`/`console.debug`, never the matcher directly.
-
-## 0.11.0
-
-### Minor Changes
-
-- [`a1d1d56`](https://github.com/briancray/abide/commit/a1d1d56efe4887bebb74dd6707cf7cb38d8b4771) - `cache` and `HttpError` move from the `browser`/`server` namespaces to `shared`, which now denotes the isomorphic surface — names that are the same callable with the same behaviour on both sides. `cache()` runs in SSR and MCP request scope just as it does on the client, so importing it as a "browser" module misrepresented it; its client-only streaming/hydration helpers stay in `browser/` and its server-only snapshot helpers stay in `server/runtime/`. Update imports: `abide/browser/cache` → `abide/shared/cache`, and `abide/browser/HttpError` (or `abide/server/HttpError`) → `abide/shared/HttpError`.
-
-    The package `exports` map is now an explicit allowlist of the public API instead of per-directory `*` globs, so internal modules (machinery under `shared/`, runtime/registry internals under `server/`, launcher internals under `bundle/`, and all `types/` subtrees) are no longer reachable via the package specifier. Only documented names — the verb/response/context helpers, `cache`, `HttpError`, `page`/`navigate`/`subscribe`, the `bundle` window config, the test client, and the build/plugin entries — resolve. Importing an unlisted internal path now fails; use the public name instead.
-
-- [`a1d1d56`](https://github.com/briancray/abide/commit/a1d1d56efe4887bebb74dd6707cf7cb38d8b4771) - `cache()` now memoises plain producers, not just rpc verb helpers — pass any `() => Promise<T>` to dedupe and retain external calls (e.g. a third-party `fetch` the server makes). Producers key on the function's reference plus args (so hoist the function, or pass an explicit `key`; an inline arrow is a fresh reference every call and never dedupes), and the value promise is stored as-is — no Response decode and no SSR snapshot. A new `global: true` option puts the entry in a process-level store instead of the request-scoped one, so a value computed in one request is reused by later ones; omit it to keep per-request data from leaking across requests, and note it is a no-op on the client (one tab store). `cache.invalidate` / `cache.pending` accept a producer reference and span both stores.
-
-- [`a1d1d56`](https://github.com/briancray/abide/commit/a1d1d56efe4887bebb74dd6707cf7cb38d8b4771) - `cache()` gains an `invalidate` option — `{ throttle: ms }` or `{ debounce: ms }` — that controls how a `cache.invalidate` hit on the key is applied, coalescing invalidation-driven refetches so a burst of invalidations (e.g. a socket spraying updates) no longer fires a burst of underlying calls. `throttle` refetches on the leading edge then at most once per N ms while invalidations keep arriving; `debounce` refetches only after N ms of quiet. Both keep serving the existing (stale) value until the refetch resolves — stale-while-revalidate — and affect only the refetch-after-invalidate, leaving the first fetch and arg-change fetches immediate. Set at most one. Input-debounce (search-as-you-type, where the args change every keystroke) is deliberately not this — debounce the reactive value feeding the args instead.
-
-- [`a1d1d56`](https://github.com/briancray/abide/commit/a1d1d56efe4887bebb74dd6707cf7cb38d8b4771) - Add an `error.svelte` page convention. Drop `error.svelte` anywhere under `src/browser/pages/` and it renders on the server for an unknown route (404) or a throw during a page render, inside the nearest layout, receiving `{ status, message, stack }` props. The props are never serialized to the client, so the message and stack reach the browser only where the template renders them — a bare `error.svelte` leaks nothing while a dev page can show the stack. Resolution is nearest-only by directory prefix, mirroring layouts — `pages/admin/error.svelte` covers `/admin/*`, `pages/error.svelte` covers the rest. For page renders `error.svelte` takes precedence over the `app.handleError` hook, which remains the fallback when no `error.svelte` covers the path (and for rpc throws). The error document is static — the client skips hydration — and a failed SPA navigation hard-navigates so it lands on the server-rendered error page.
-
-- [`a1d1d56`](https://github.com/briancray/abide/commit/a1d1d56efe4887bebb74dd6707cf7cb38d8b4771) - Run in-process rpc dispatch inside the request scope for the MCP tool dispatcher and the in-process CLI client. Previously both invoked handlers without a per-request scope, so `cache()` silently shared one process-wide store across calls (leaking state between unrelated tool/CLI invocations) and `cookies()`/`request()` threw. Both now cross the same `runWithRequestScope` seam the HTTP router uses, giving per-call cache isolation and resolving the scope-bound helpers.
-
-    Behavior change for MCP: a tool handler that throws is now caught by the scope and returned as a tool result with `isError: true` (framed from the 500 response), instead of surfacing as a JSON-RPC `-32603` error on the envelope. The JSON-RPC call itself succeeds; the failure is reported at the tool-result level, which is the correct MCP shape.
-
-- [`a1d1d56`](https://github.com/briancray/abide/commit/a1d1d56efe4887bebb74dd6707cf7cb38d8b4771) - Project JSON Schema from a schema's own `toJSONSchema()` everywhere it's needed (OpenAPI, MCP tools, CLI flags, the bundle setup form). Drop the `inputJsonSchema` / `outputJsonSchema` / `filesJsonSchema` verb opts and the socket `jsonSchema` opt — a schema whose library doesn't expose a method wraps once with the new `abide/shared/withJsonSchema` helper. Multipart file parts are now advertised generically as binary in OpenAPI rather than named per field.
-
-    Add `src/server/config.ts` as the home for typed env: `export const config = env(schema)`, imported as `$server/config` and eager-imported at boot so validation fails fast. The file is optional and scaffolded — when absent you read `Bun.env` directly.
-
-    The bundle's first-run setup form is now derived from that same env schema by default, so one declaration drives boot validation and the form. `BundleWindow.config` still works but now _replaces_ the derived schema (for a form that should differ from the env schema) rather than being the only source.
-
-- [`a1d1d56`](https://github.com/briancray/abide/commit/a1d1d56efe4887bebb74dd6707cf7cb38d8b4771) - Add two server primitives. `abide/server/env` validates the process environment against a Standard Schema at module load, returning typed config and failing the boot with every issue listed when a variable is missing or malformed. `abide/server/cookies` exposes the request's cookie jar — Bun's native `CookieMap` parsed from the inbound `Cookie` header, with `set`/`delete` writes flushed to `Set-Cookie` on the outgoing response when the handler returns. `cookies` resolves from the request scope like `request()`, materialized lazily so a request that never touches them parses and emits nothing; `env` reads `Bun.env` once at module load, independent of any request.
-
-- [`a1d1d56`](https://github.com/briancray/abide/commit/a1d1d56efe4887bebb74dd6707cf7cb38d8b4771) - Add `abide/test/createTestClient` — an in-process client for testing rpc handlers without a running server. It discovers verbs from the registry (populated by `defineVerb`) and routes through the same synthesize-and-fetch the CLI and MCP surfaces use, but runs each call inside the request scope so request-scoped helpers behave exactly as under a live HTTP request: a fresh per-request `cache()`, the cookie jar with `Set-Cookie` flush, `request()`/`server()` resolution, and `app.handleError` (or the 500 fallback) on a throw. Accepts `headers` to pre-populate inbound auth/cookies and `app` for custom error handling. Pairs with `abide/test/clearVerbRegistry` to isolate suites that define verbs inline. `dispatchVerbInProcess` gains an opt-in `requestScope` flag to back this; the CLI and MCP paths are unchanged.
-
-## 0.10.0
-
-### Minor Changes
-
-- stream deferred cache resolutions from server to client ([`a608a8e`](https://github.com/briancray/abide/commit/a608a8e02cdfaa19114ce323a0e6c1aedd83c31a))
-
-- [`6a511c4`](https://github.com/briancray/abide/commit/6a511c4961eb124fa9b21a595e0a11886ef10cda) - Stream deferred cache resolutions from the server to the client. Cache entries left pending when SSR flushes are now snapshotted on the server, their resolutions streamed over the response, and reinstalled on the client as streaming placeholders that settle as each resolution arrives. This keeps the SSR/stream split driven by `await` vs `{#await}` without blocking the initial HTML on slow cache reads.
-
-## 0.9.1
-
-### Patch Changes
-
-- [#33](https://github.com/briancray/abide/pull/33) [`e8c6d74`](https://github.com/briancray/abide/commit/e8c6d74be8c4033c58fb4b23fd1861a68df640ca) Thanks [@briancray](https://github.com/briancray)! - Root-absolute `url()` references in bundled stylesheets (e.g. `url(/fonts/x.woff2)`) are now marked external instead of being resolved against the project root at build time. Those paths are served from `public/` at the site root at runtime, so Bun's CSS bundler previously failed the whole build trying to find them on disk. The literal `/…` path now survives into the emitted CSS, where the public asset server serves it. Relative `url()`s still resolve and bundle as before.
-
-## 0.9.0
-
-### Minor Changes
-
-- [#31](https://github.com/briancray/abide/pull/31) [`7f43099`](https://github.com/briancray/abide/commit/7f43099e6d9bab1d3de50b37ce241c4b3e171849) Thanks [@briancray](https://github.com/briancray)! - The standalone CLI (`abide cli`) now ships the compiled server beside it and gains an interactive session. `<app> /connect <url>` connects to a remote server, `<app> /start` boots a local instance, `<app> /disconnect` forgets the saved connection, and `<app>` alone resumes it — each opening a prompt where bare words run RPC commands and `/connect` / `/start` / `/disconnect` / `/help` / `/exit` manage the connection. One-shot dispatch (`<app> <command> --flags`) is unchanged for scripting. The connection is remembered in the per-user data dir; with none saved the CLI uses the baked `APP_URL`. The download tarball now bundles the server binary so `/start` works out of the box.
-
-- [#31](https://github.com/briancray/abide/pull/31) [`9f4500a`](https://github.com/briancray/abide/commit/9f4500a953579534088396c11da14538b56edb65) Thanks [@briancray](https://github.com/briancray)! - `abide bundle` now reads the shipped default-config file from `bundle.env` instead of `.env.bundle`. The old name masqueraded as a member of Bun's `.env.*` autoload family, implying `bun dev`/`bun start` would load it (they never did) and that it should be gitignored like `.env` (it should be committed — it's ship-safe defaults, and a compiled bundle is extractable anyway). The new name reflects what the file is: a build input, not a runtime env overlay. Rename your project's `.env.bundle` to `bundle.env`.
-
-### Patch Changes
-
-- [#31](https://github.com/briancray/abide/pull/31) [`a03d4ac`](https://github.com/briancray/abide/commit/a03d4acfbc6e2d596a9d7e9481fb91e437378ca7) Thanks [@briancray](https://github.com/briancray)! - `abide dev` and `abide start` no longer load the bundle's config layers (the per-user data-dir `.env` and the shipped binary-dir `bundle.env`). Those layers exist for the compiled standalone app — a bundle launched via `open` has cwd `/` and gets its config there — but the server entry loaded them unconditionally, so dev/start would also inherit them. A `PORT` saved in the data-dir `.env` (written by a bundle's connect screen) then defeated dev's auto port-scan, binding that exact port and throwing `EADDRINUSE` instead of moving on. Dev/start now keep to their project-local CWD `.env` alone; the data-dir/binary-dir layers load only when running as a `bun build --compile` standalone binary.
-
-## 0.8.1
-
-### Patch Changes
-
-- [#29](https://github.com/briancray/abide/pull/29) [`f85ee72`](https://github.com/briancray/abide/commit/f85ee722cd2b659aad7d8f250ae595b0b2ccdcae) Thanks [@briancray](https://github.com/briancray)! - With no `PORT` set, the server now scans upward from 3000 at bind time, binding the listener that wins the port instead of probing a throwaway server and releasing it first. This closes the gap where the chosen port could be stolen between probe and bind, which crashed boot on `EADDRINUSE` rather than stepping to the next port. A configured `PORT` still binds that exact port and surfaces a collision loudly.
-
-## 0.8.0
-
-### Minor Changes
-
-- keep streams alive past Bun's idle timeout ([`9339175`](https://github.com/briancray/abide/commit/9339175a4b73d336704bbd8ff61ecf88f8582cfa))
-
-- [#27](https://github.com/briancray/abide/pull/27) [`78305d1`](https://github.com/briancray/abide/commit/78305d18392cd916e39475a37eaafc486d3cdabf) Thanks [@briancray](https://github.com/briancray)! - Streaming responses (sse / jsonl / socket SSE tail) now opt out of Bun's per-connection idle timeout, so a stream that stays quiet between frames is no longer closed mid-flight. A new `idleTimeout` option (and `ABIDE_IDLE_TIMEOUT` env, 0–255 seconds, default 10) sets the floor for ordinary unary handlers that legitimately compute longer than Bun's 10s default.
-
-### Patch Changes
-
-- dedup env-int parsing and route-dispatch 405s ([`617cc3c`](https://github.com/briancray/abide/commit/617cc3c0c5a763cd8d5e8c4bb0e74ee852500a94))
-
-- extract route dispatch into a testable createRouteDispatcher ([`a684227`](https://github.com/briancray/abide/commit/a6842275a3fa444162571c6fccfcbadd13b712a5))
-
-- extract request-scope runner into a testable seam ([`ce6f65c`](https://github.com/briancray/abide/commit/ce6f65c6cde3f070d4d55574979d21b362765aee))
-
-## 0.7.0
-
-### Minor Changes
-
-- [#23](https://github.com/briancray/abide/pull/23) [`46f62ef`](https://github.com/briancray/abide/commit/46f62efebcdd9415b97435f17a70c91a0319a402) Thanks [@briancray](https://github.com/briancray)! - `cache()`'s `scope` option now accepts an array of tags, not just a single tag, so a call can join multiple invalidation groups (`scope: ['media', 'sources']`). `cache.invalidate({ scope })` drops every entry sharing any of the requested tags, and a re-read merges new tags into an entry rather than replacing them.
-  </content>
-  </invoke>
-
-## 0.6.0
-
-### Minor Changes
-
-- [#21](https://github.com/briancray/abide/pull/21) [`5fbf023`](https://github.com/briancray/abide/commit/5fbf023c7de46457ae652c1738613ee2ceaf7dd7) Thanks [@briancray](https://github.com/briancray)! - `cache()` gains a `scope` option, and `cache.invalidate({ scope })` drops every entry sharing that tag in one call. `cache.invalidate` now takes `() | (fn) | ({ key?, scope? })`.
-
-- [#21](https://github.com/briancray/abide/pull/21) [`56cd195`](https://github.com/briancray/abide/commit/56cd1950cf39e13dd06c90309efd35296c6c7e81) Thanks [@briancray](https://github.com/briancray)! - Breaking: `abide/cli/*` is no longer a public export — `createClient` is now internal. Nothing in the documented API referenced it.
-
-- [#21](https://github.com/briancray/abide/pull/21) [`6776396`](https://github.com/briancray/abide/commit/67763968b13dd88173aeaf42242df6239fdc713b) Thanks [@briancray](https://github.com/briancray)! - When `PORT` is unset, the server now binds the first open port at or above 3000 instead of hardcoding 3000, so a second app boots without colliding. An explicit `PORT` is still honored as-is.
-
-## 0.5.3
-
-### Patch Changes
-
-- extract shared build helpers and centralize bundle layout ([`64d71de`](https://github.com/briancray/abide/commit/64d71de9d4b28130775545f1047fa985545b3aaa))
-
-- [#18](https://github.com/briancray/abide/pull/18) [`90a1713`](https://github.com/briancray/abide/commit/90a17136f53bab6f860c486e415547364fd54ca5) Thanks [@briancray](https://github.com/briancray)! - Extract repeated build-time logic into single-purpose shared helpers and collapse the per-virtual manifest codegen. `manifestModule` builds the `abide:rpc`/`sockets`/`prompts`/`pages`/`layouts` virtual modules from one path; `bundleLayout` derives `libDir`/`resourcesDir`/`envPath` from `binDir` (replacing the narrower `shippedEnvPath`) so the build writer and boot readers agree; `readPackageJson`, `exeSuffix`, `browserClientFlags`, and `memoizeByKey` deduplicate the package.json reader, the windows `.exe` suffix, the browser proxies, and the server route loaders. No public API change; behaviour preserved.
-
-## 0.5.2
-
-### Patch Changes
-
-- [#15](https://github.com/briancray/abide/pull/15) [`7e3c96c`](https://github.com/briancray/abide/commit/7e3c96cd969e3f59c4be0e773478e56d21688874) Thanks [@briancray](https://github.com/briancray)! - Ship the bundle's `.env` under `Contents/Resources/` in a macOS `.app` instead of `Contents/MacOS/`. `codesign` seals `Contents/MacOS/` as code, so a data file there couldn't survive signing and reloading; `Resources` is sealed as a resource. A new `shippedEnvPath` helper centralizes the layout so the build writer and both boot readers agree on the path. The flat (non-macOS) layout is unchanged.
-
-## 0.5.1
-
-### Patch Changes
-
-- [#12](https://github.com/briancray/abide/pull/12) [`47ecf72`](https://github.com/briancray/abide/commit/47ecf72c0a112461eacc9e1cd406e743c95423c5) Thanks [@briancray](https://github.com/briancray)! - A bundle's embedded server now honors a configured `PORT` instead of always picking a random free port. The launcher resolves `PORT` from the same env stack the server uses (shell, then the data-dir `.env` the config form writes, then the shipped binary-dir `.env`) and binds it as-is; with none set it falls back to a free port as before. This lets you start the embedded server at a fixed, known address on one machine and reliably connect to it from another via the connect screen.
-
-## 0.5.0
-
-### Minor Changes
-
-- [#10](https://github.com/briancray/abide/pull/10) [`6ceb71b`](https://github.com/briancray/abide/commit/6ceb71b28e3b1a4c9726483d2c7dd3f40be3be59) Thanks [@briancray](https://github.com/briancray)! - Bundles now resolve config from a cwd-independent source instead of relying on Bun's cwd-based `.env` autoload (which a launched `.app`, whose cwd is `/`, silently misses). Config flows entirely through `process.env`, so app code keeps reading `Bun.env.*` and never learns where a value came from.
-
-    - The compiled server loads two `.env` layers into `process.env` at boot, before anything reads it: the per-user data dir first (user config), then the binary dir (shipped default). Both back-fill only what a shell export or Bun's CWD `.env` didn't already set, so the precedence is `shell > CWD .env > data-dir .env > binary-dir .env > code default`.
-    - Add `abide/shared/appDataDir` — the platform-standard per-user data directory keyed by program name, where the data-dir `.env` lives.
-    - `abide bundle` ships an optional project `.env.bundle` as the binary-dir `.env` (the shipped default layer). Skipped when absent; use a dedicated file, never the working `.env`, since a compiled bundle is extractable.
-    - Start now races server readiness against the child's exit, so a misconfigured bundle reports the crash immediately instead of stalling for the full readiness timeout.
-    - A bundle resolves its last connection before the window opens: the launcher records the choice (embedded, or a remote URL) in the data dir, and on relaunch boots/probes it first, opening the window straight at the live server — so the connect screen never flashes. A boot that fails or exceeds a short ceiling, an unconfigured embedded resume, a dead saved server, or no saved choice falls back to opening the connect screen.
-    - A bundle can declare `config` on its `BundleWindow` as a Standard Schema (the same kind abide accepts for RPC/MCP). Its JSON Schema drives a first-run settings modal on the connect screen — `title` → label, `description` → hint, `format: 'password'` → masked input, `default` → prefill — and answers persist to the data-dir `.env`. An explicit Start (button or File-menu click) always opens the modal prefilled with the last-used values, so re-running Start after a disconnect is how you reconfigure; an auto-start on relaunch never opens the modal — it boots a fully-configured app, or stays on the connect screen when a required key is still unset. Apps with no schema always boot straight through.
-
-### Patch Changes
-
-- harden PORT parsing and make shutdown signal-safe ([`9cca848`](https://github.com/briancray/abide/commit/9cca848b08a786b6abfe7920d4775a1f76c11fe6))
-
-## 0.4.0
-
-### Minor Changes
-
-- [`a432d00`](https://github.com/briancray/abide/commit/a432d00d3c58dea7f4968307e9c82590ff07ef8a) - `abide bundle` now ad-hoc code-signs the assembled macOS `.app` so it launches on other Macs instead of being silently killed by Gatekeeper. A quarantined copy may still need `xattr -cr` once; full distribution still requires a Developer ID signature and notarization.
-
-- [`a432d00`](https://github.com/briancray/abide/commit/a432d00d3c58dea7f4968307e9c82590ff07ef8a) - The native webview inspector in a bundle is now gated behind `ABIDE_INSPECT`, so release bundles ship without DevTools while debugging remains one env var away.
-
-- [`a432d00`](https://github.com/briancray/abide/commit/a432d00d3c58dea7f4968307e9c82590ff07ef8a) - `cache()` now returns synchronously for keys already warm in the SSR hydration snapshot, so the first client read of server-rendered data skips the microtask round-trip.
-
-- [`d0a733d`](https://github.com/briancray/abide/commit/d0a733dd238e634baa1dd9fdf0adf99114612893) - Add a name-filtered `onMenu(name, handler)` overload alongside the existing catch-all `onMenu((name) => …)` form, so a bundle menu item can bind one handler without switching on the emit name.
-
-- [`a432d00`](https://github.com/briancray/abide/commit/a432d00d3c58dea7f4968307e9c82590ff07ef8a) - **Breaking:** verb helpers now take `inputSchema` (and optional `outputSchema`) instead of `schema`. `inputSchema` validates incoming args and feeds OpenAPI params / the MCP tool input; `outputSchema` describes the success body for the OpenAPI `200` response and MCP tool output. Client exposure (`browser` / `mcp` / `cli`) now defaults per-surface from the schema — read-only verbs auto-expose to MCP, mutating verbs opt in via `clients`. Migrate by renaming `{ schema }` to `{ inputSchema }`.
-
-- [`a432d00`](https://github.com/briancray/abide/commit/a432d00d3c58dea7f4968307e9c82590ff07ef8a) - Sockets are now exposed to MCP and the CLI over an HTTP face: each schema-bearing socket contributes a `<name>-tail` read tool/command, plus `<name>-publish` when `clientPublish` is set.
-
-### Patch Changes
-
-- [`a432d00`](https://github.com/briancray/abide/commit/a432d00d3c58dea7f4968307e9c82590ff07ef8a) - Public asset paths are snapshotted on disk at boot rather than stat'd per request, and browser-only routes are logged at startup.
-
-- [`a432d00`](https://github.com/briancray/abide/commit/a432d00d3c58dea7f4968307e9c82590ff07ef8a) - Scaffolded apps now ship a default `src/bundle/icon.png`, so `abide bundle` produces an icon'd macOS `.app` out of the box.
-
-## 0.3.1
-
-### Patch Changes
-
-- [`63fe0b6`](https://github.com/briancray/abide/commit/63fe0b6cdec4d1073252a68c8185f86b74ebe48e) - Default bundle connect screen now follows the OS dark-mode setting. Added
-  Tailwind `dark:` variants (driven by `prefers-color-scheme`) across the
-  background, card, input, buttons, divider, and footer — all grayscale except the
-  red error message. A project that ships its own `src/bundle/disconnected.svelte`
-  is unaffected.
-
-## 0.3.0
-
-### Minor Changes
-
-- [`3daa1cd`](https://github.com/briancray/abide/commit/3daa1cdf793ddca5efdce8027293003d177b4a48) - Bundle (macOS webview): support file downloads. The webview now installs a
-  navigation + download delegate, so `<a download>`, blob:/data: links, and
-  `Content-Disposition: attachment` responses save a real file to the user's
-  Downloads folder and reveal it in Finder — previously the bare WKWebView set no
-  navigation delegate and silently dropped them. No-op on macOS before 11.3.
-
-## 0.2.2
-
-### Patch Changes
-
-- [`465928b`](https://github.com/briancray/abide/commit/465928b411b8f8aff582df87f9e2ba3782d8b275) - The generated route-types file (`src/.abide/routes.d.ts`) now augments the `Routes` interface on the module name the project imports abide under (canonical `abide` or an alias), matching the rpc/socket/prompt codegen. It previously hardcoded `abide/browser/page`, so `page.route` / `page.params` autocomplete only resolved when abide was installed under the `abide` alias.
-
-## 0.2.1
-
-### Patch Changes
-
-- [`1d84fb8`](https://github.com/briancray/abide/commit/1d84fb8d64d8bb7b4d0eb3b1d24e0ea2f18b4c31) - RPC, socket, and prompt codegen now emit imports under the name abide is installed as in the consuming project — the canonical `abide` for a direct dependency, or the alias key for a package alias (`"abide": "npm:abide@..."`) — instead of a hardcoded `abide`. A plain `bun add abide` now builds with no alias required; the `abide` alias remains supported for the bare `abide/...` import surface.
-
-## 0.2.0
-
-### Minor Changes
-
-- [`cf136c7`](https://github.com/briancray/abide/commit/cf136c7b763283570ef431b3aad269626bea7824) - Add a `abide bundle` desktop app and make the CLI a thin remote-only client.
-
-    - `abide bundle` assembles a movable, self-contained desktop app (a `.app` on macOS, a flat dir elsewhere) that boots into a connect screen — start the embedded server or connect to a remote one by URL.
-    - **Breaking:** the CLI binary is now always a thin remote client (talks to a running server over HTTP, `APP_URL` required). Dropped the `--thin`/full split and in-process fallback — use `abide bundle` for the embedded-backend case.
-    - **Breaking:** MCP prompts are now markdown files (`src/mcp/prompts/**.md`) with YAML frontmatter, replacing the `.ts` prompt modules.
-    - **Breaking:** handlers read the inbound request via `request()` and the live server via `server()` rather than `RequestStore` fields.
-    - `json` / `jsonl` / `sse` / `error` / `redirect` accept a trailing `ResponseInit`.
-    - Static-asset header caching is shared across asset servers, and zstd decompression moved to the async API.
-
-## 0.1.0
+## 0.100.0
 
 ### Minor Changes
 
-- [`c863e56`](https://github.com/briancray/abide/commit/c863e563338fe704fc96a7054e27a35d271261fb) - Initial public release of abide — an isomorphic multimodal HTTP framework for Bun and Svelte. Declare a backend once and consume it over the web (SSR Svelte), the CLI, and MCP.
+- 12e5725: Breaking: the rewrite. `@abide/abide` is now the isomorphic, type-safe framework for reactive async interfaces built from compiled `.abide` files — a new surface, not an upgrade of 0.58. Apps import `@abide/abide`, `@abide/abide/runtime` and `@abide/abide/server`; `abide scaffold <name>` writes a starter. The 0.58 line lives on the `og` branch.