@abide/abide 0.44.0 → 0.45.0

package/src/lib/ui/dom/eachAsync.ts

@@ -1,6 +1,6 @@
 import { effect } from '../effect.ts'
 import { claimChild } from '../runtime/claimChild.ts'
-import { OWNER } from '../runtime/OWNER.ts'
+import { generationGuard } from '../runtime/generationGuard.ts'
 import { RENDER } from '../runtime/RENDER.ts'
 import { scopeGroup } from '../runtime/scopeGroup.ts'
 import type { State } from '../runtime/types/State.ts'
@@ -74,12 +74,16 @@ export function eachAsync<T>(
         }
     }
 
-    /* Bumped each run so a superseded drain stops appending and pruning. */
-    let generation = 0
     let iterator: AsyncIterator<T> | undefined
+    /* Bumped each run so a superseded drain stops appending and pruning, and on owner teardown
+       — which also `return()`s the live iterator to release the source (rows and the error
+       branch are disposed by the group, whose scopes were tracked). */
+    const guard = generationGuard(() => {
+        iterator?.return?.(undefined)?.catch(() => undefined)
+        iterator = undefined
+    })
     effect(() => {
-        generation += 1
-        const generationAtStart = generation
+        const generationAtStart = guard.renew()
         iterator?.return?.(undefined)?.catch(() => undefined) // close the superseded run's iterator before re-streaming
         iterator = undefined
         clearError() // a fresh run drops a prior error branch
@@ -92,7 +96,7 @@ export function eachAsync<T>(
             while (true) {
                 const result = await active.next()
                 /* A re-run or teardown bumped the generation while we awaited. */
-                if (generationAtStart !== generation) {
+                if (!guard.live(generationAtStart)) {
                     return
                 }
                 if (result.done === true) {
@@ -126,7 +130,7 @@ export function eachAsync<T>(
             }
         }
         drain().catch((error: unknown) => {
-            if (generationAtStart !== generation) {
+            if (!guard.live(generationAtStart)) {
                 return
             }
             /* No catch branch → surface the rejection (mirrors `<template await>`). */
@@ -137,15 +141,4 @@ export function eachAsync<T>(
             errorRange = insertRange((host) => renderCatch(host, error))
         })
     })
-
-    /* Stop the live stream when the enclosing scope tears down: bump the generation so
-       the drain abandons its loop and `return()` the iterator to release the source. The
-       rows and error branch are disposed by the group (their scopes were tracked). */
-    if (OWNER.current !== undefined) {
-        OWNER.current.push(() => {
-            generation += 1
-            iterator?.return?.(undefined)?.catch(() => undefined)
-            iterator = undefined
-        })
-    }
 }

package/src/lib/ui/dom/mountSwappableRange.ts

@@ -0,0 +1,79 @@
+import { effect } from '../effect.ts'
+import { RANGE_CLOSE, RANGE_OPEN } from '../runtime/RANGE_MARKER.ts'
+import { RENDER } from '../runtime/RENDER.ts'
+import { scope } from '../runtime/scope.ts'
+import { scopeGroup } from '../runtime/scopeGroup.ts'
+import { fillBefore } from './fillBefore.ts'
+import { openMarker } from './openMarker.ts'
+import { replaceRange } from './replaceRange.ts'
+
+/*
+The shared lifecycle of every single-slot control-flow block (`when`, `switchBlock`):
+a marker-bounded RANGE that holds at most one piece of content at a time, swapped as a
+unit when a `key` changes. The block supplies a `key()` thunk (the identity of the
+chosen branch — `'then'|'else'` for `when`, the case index for `switchBlock`) and a
+`contentFor(key)` resolver returning that branch's builder, or `undefined` for an
+empty branch. This module owns the marker setup, the hydrate-vs-create fork, and the
+swap effect with its reentrancy/teardown dance — the structure both blocks copy-pasted.
+
+The chosen branch builds through `scope` (directly on hydrate, via `fillBefore` on a
+swap), which builds untracked — so a raw reactive read in the branch content doesn't
+subscribe the swap effect; only `key()` (which reads the block's source) drives the
+toggle. The branch's own interpolations still track, each through its own effect.
+
+On hydrate it adopts the server-rendered range: claim the start marker, run the chosen
+branch in place (its content claims the existing nodes), then claim the end marker. The
+effect's first run sees the same key and is a no-op; later changes clear the range and
+build fresh into a fragment.
+
+`before` (a static node located by the skeleton) places the range among siblings on
+create, so the block sits before a static suffix rather than at the parent's end.
+Hydrate ignores it — the claim cursor (positioned past the prefix) drives placement.
+*/
+export function mountSwappableRange<Key>(
+    parent: Node,
+    key: () => Key,
+    contentFor: (key: Key) => ((parent: Node) => void) | undefined,
+    before: Node | null = null,
+): void {
+    const hydration = RENDER.hydration
+    /* The live branch's scope, registered with the owner so it disposes on owner
+       teardown — not only on a branch swap via replaceRange. */
+    const group = scopeGroup()
+    let dispose: (() => void) | undefined
+    let activeKey: Key
+    let end: Comment
+
+    const start = openMarker(parent, RANGE_OPEN, before)
+    if (hydration !== undefined) {
+        activeKey = key()
+        const chosen = contentFor(activeKey)
+        if (chosen !== undefined) {
+            dispose = group.track(scope(() => chosen(parent))) // content claims the SSR nodes in place
+        }
+        end = openMarker(parent, RANGE_CLOSE)
+    } else {
+        end = openMarker(parent, RANGE_CLOSE, before)
+        activeKey = key()
+        const chosen = contentFor(activeKey)
+        if (chosen !== undefined) {
+            dispose = group.track(fillBefore(end, chosen))
+        }
+    }
+
+    effect(() => {
+        const next = key()
+        if (next === activeKey) {
+            return
+        }
+        activeKey = next
+        const chosen = contentFor(next)
+        /* Null `dispose` before `replaceRange` builds the new branch: a reentrant swap
+           during that build (an effect in the new content writing the source) would
+           otherwise re-enter with the already-disposed disposer and clear it twice. */
+        const prior = dispose
+        dispose = undefined
+        const built = replaceRange(start, end, prior, chosen)
+        dispose = built !== undefined ? group.track(built) : undefined
+    })
+}

package/src/lib/ui/dom/skeleton.ts

@@ -129,10 +129,19 @@ export function skeleton(parent: Node, html: string): SkeletonHoles {
         hydration.next.set(parent, node)
     } else {
         const children = source.childNodes
+        /* Stage clones in a fragment ONLY for a live (connected) parent, where one
+           append reflows once instead of per clone. A detached parent triggers no
+           reflow on append, so the fragment is pure overhead there — skip it and
+           append direct. `topLevel` collects each clone either way for anchor/
+           element-hole resolution. */
+        const target: Node = parent.isConnected ? document.createDocumentFragment() : parent
         for (let index = 0; index < children.length; index += 1) {
             const clone = (children[index] as Node).cloneNode(true)
             topLevel.push(clone)
-            parent.appendChild(clone)
+            target.appendChild(clone)
+        }
+        if (target !== parent) {
+            parent.appendChild(target)
         }
     }
     /* Anchor holes via the ONE shared ordering rule (`walkAnchorOrder`) — the same traversal

package/src/lib/ui/dom/switchBlock.ts

@@ -1,26 +1,16 @@
-import { effect } from '../effect.ts'
-import { RANGE_CLOSE, RANGE_OPEN } from '../runtime/RANGE_MARKER.ts'
-import { RENDER } from '../runtime/RENDER.ts'
-import { scope } from '../runtime/scope.ts'
-import { scopeGroup } from '../runtime/scopeGroup.ts'
-import { fillBefore } from './fillBefore.ts'
-import { openMarker } from './openMarker.ts'
-import { replaceRange } from './replaceRange.ts'
+import { mountSwappableRange } from './mountSwappableRange.ts'
 import type { SwitchCase } from './types/SwitchCase.ts'
 
 /*
 Multi-branch binding — the runtime for `{#switch}` blocks and for `{#if}` chains that
 include `{:elseif}` branches (compiled as a switch over `true` with Boolean-coerced
-match thunks so the first truthy branch wins). An effect evaluates the
+match thunks so the first truthy branch wins). A swappable range evaluates the
 subject, picks the first case whose `match` equals it (strict `===`), falling back
 to the default (`match` undefined); the chosen case's content lives in a RANGE
 bounded by two comment markers, so a case holds any content. Staying on the same
 case across a subject change leaves it mounted; switching clears the range and
-builds the new case fresh.
-
-On hydrate it adopts the case the server rendered: claim the start marker, run the
-matching case in place, claim the end marker. The effect's first run picks the same
-case and is a no-op; later changes swap the range.
+builds the new case fresh. See `mountSwappableRange` for the shared
+hydrate/swap/teardown semantics — the case index is the swap key.
 */
 // @documentation plumbing
 export function switchBlock(
@@ -29,59 +19,21 @@ export function switchBlock(
     cases: SwitchCase[],
     before: Node | null = null,
 ): void {
-    const hydration = RENDER.hydration
-    /* The live case's scope, registered with the owner so it disposes on owner
-       teardown — not only when the subject switches cases via replaceRange. */
-    const group = scopeGroup()
-    let dispose: (() => void) | undefined
-    let activeIndex: number
-    let end: Comment
-
+    /* Pick the first case matching the subject (`===`), else the default (`match`
+       undefined), else -1 for no match. */
     const select = (value: unknown): number => {
         const matched = cases.findIndex(
             (entry) => entry.match !== undefined && entry.match() === value,
         )
         return matched === -1 ? cases.findIndex((entry) => entry.match === undefined) : matched
     }
-    const caseAt = (index: number): SwitchCase | undefined =>
-        index === -1 ? undefined : cases[index]
-    /* The chosen case builds through `scope` (directly on hydrate, via `fillBefore` on a
-       swap), which builds untracked — so a raw reactive read in the case content doesn't
-       subscribe the swap effect below; only `subject()` (and each case's `match()`) drives
-       the swap. The case's own interpolations still track, each through its own effect. */
-
-    /* `before` places the range among static siblings on create (block before a suffix);
-       hydrate ignores it and uses the parked claim cursor. */
-    const start = openMarker(parent, RANGE_OPEN, before)
-    if (hydration !== undefined) {
-        activeIndex = select(subject())
-        const chosen = caseAt(activeIndex)
-        if (chosen !== undefined) {
-            dispose = group.track(scope(() => chosen.render(parent))) // claim the SSR nodes in place
-        }
-        end = openMarker(parent, RANGE_CLOSE)
-    } else {
-        end = openMarker(parent, RANGE_CLOSE, before)
-        activeIndex = select(subject())
-        const chosen = caseAt(activeIndex)
-        if (chosen !== undefined) {
-            dispose = group.track(fillBefore(end, (p) => chosen.render(p)))
-        }
-    }
-
-    effect(() => {
-        const index = select(subject())
-        if (index === activeIndex) {
-            return
-        }
-        activeIndex = index
-        const chosen = caseAt(index)
-        /* Null `dispose` before `replaceRange` builds the new case: a reentrant switch
-           during that build (an effect in the new content writing the subject) would
-           otherwise re-enter with the already-disposed disposer and clear it twice. */
-        const prior = dispose
-        dispose = undefined
-        const next = replaceRange(start, end, prior, chosen && ((p) => chosen.render(p)))
-        dispose = next !== undefined ? group.track(next) : undefined
-    })
+    mountSwappableRange(
+        parent,
+        () => select(subject()),
+        (index) => {
+            const chosen = index === -1 ? undefined : cases[index]
+            return chosen && ((p) => chosen.render(p))
+        },
+        before,
+    )
 }

package/src/lib/ui/dom/when.ts

@@ -1,24 +1,13 @@
-import { effect } from '../effect.ts'
-import { RANGE_CLOSE, RANGE_OPEN } from '../runtime/RANGE_MARKER.ts'
-import { RENDER } from '../runtime/RENDER.ts'
-import { scope } from '../runtime/scope.ts'
-import { scopeGroup } from '../runtime/scopeGroup.ts'
-import { fillBefore } from './fillBefore.ts'
-import { openMarker } from './openMarker.ts'
-import { replaceRange } from './replaceRange.ts'
+import { mountSwappableRange } from './mountSwappableRange.ts'
 
 /*
 Conditional binding — the runtime for `<template if>` (with optional `else`). The
 branch's content lives in a RANGE bounded by two comment markers, so a branch may
 hold anything — elements, components, text, nested control-flow, snippets — not
-just element roots. An effect tracks `condition()` and swaps the range's content
-on a truthy↔falsy flip (`render` truthy, `renderElse` falsy); an unchanged
-condition is a no-op.
-
-On hydrate it adopts the server-rendered range: claim the start marker, run the
-matching render in place (its content claims the existing nodes), then claim the
-end marker. The effect's first run sees the same branch and is a no-op; later
-toggles clear the range and build fresh into a fragment.
+just element roots. A 2-case swappable range tracks `condition()` and swaps the
+range's content on a truthy↔falsy flip (`render` truthy, `renderElse` falsy); an
+unchanged condition is a no-op. See `mountSwappableRange` for the shared
+hydrate/swap/teardown semantics.
 */
 // @documentation plumbing
 export function when(
@@ -28,52 +17,10 @@ export function when(
     renderElse?: (parent: Node) => void,
     before: Node | null = null,
 ): void {
-    const hydration = RENDER.hydration
-    /* The chosen branch builds through `scope` (directly on hydrate, via `fillBefore`
-       on a swap), which builds untracked — so a raw reactive read in the branch content
-       doesn't subscribe the swap effect below; only `condition()` drives the toggle. The
-       branch's own interpolations still track, each through its own effect. */
-    const chosenFor = (branch: 'then' | 'else') => (branch === 'then' ? render : renderElse)
-    /* The live branch's scope, registered with the owner so it disposes on owner
-       teardown — not only on a branch flip via replaceRange. */
-    const group = scopeGroup()
-    let dispose: (() => void) | undefined
-    let activeBranch: 'then' | 'else'
-    let end: Comment
-
-    /* `before` (a static node located by the skeleton) places the range among siblings on
-       create, so the block sits before a static suffix rather than at the parent's end.
-       Hydrate ignores it — the claim cursor (positioned past the prefix) drives placement. */
-    const start = openMarker(parent, RANGE_OPEN, before)
-    if (hydration !== undefined) {
-        activeBranch = condition() ? 'then' : 'else'
-        const chosen = chosenFor(activeBranch)
-        if (chosen !== undefined) {
-            dispose = group.track(scope(() => chosen(parent))) // content claims the SSR nodes in place
-        }
-        end = openMarker(parent, RANGE_CLOSE)
-    } else {
-        end = openMarker(parent, RANGE_CLOSE, before)
-        activeBranch = condition() ? 'then' : 'else'
-        const chosen = chosenFor(activeBranch)
-        if (chosen !== undefined) {
-            dispose = group.track(fillBefore(end, chosen))
-        }
-    }
-
-    effect(() => {
-        const branch = condition() ? 'then' : 'else'
-        if (branch === activeBranch) {
-            return
-        }
-        activeBranch = branch
-        const chosen = chosenFor(branch)
-        /* Null `dispose` before `replaceRange` builds the new branch: a reentrant flip
-           during that build (an effect in the new content writing the condition) would
-           otherwise re-enter with the already-disposed disposer and clear it twice. */
-        const prior = dispose
-        dispose = undefined
-        const next = replaceRange(start, end, prior, chosen)
-        dispose = next !== undefined ? group.track(next) : undefined
-    })
+    mountSwappableRange(
+        parent,
+        () => (condition() ? 'then' : 'else'),
+        (branch) => (branch === 'then' ? render : renderElse),
+        before,
+    )
 }

package/src/lib/ui/installHotBridge.ts

@@ -25,6 +25,7 @@ import { spreadProps } from './dom/spreadProps.ts'
 import { switchBlock } from './dom/switchBlock.ts'
 import { tryBlock } from './dom/tryBlock.ts'
 import { when } from './dom/when.ts'
+import { deferResume } from './deferResume.ts'
 import { effect } from './effect.ts'
 import { enterScope } from './enterScope.ts'
 import { exitScope } from './exitScope.ts'
@@ -68,6 +69,7 @@ export function installHotBridge(): void {
         eachAsync,
         when,
         awaitBlock,
+        deferResume,
         tryBlock,
         switchBlock,
         mountSlot,

package/src/lib/ui/matchRoute.ts

@@ -52,6 +52,18 @@ export function matchRoute(
     return best === undefined ? undefined : { route: best.route, params: best.params }
 }
 
+/* Percent-decodes a captured `[name]` value. Bun's `req.params` decoding is
+   lenient (malformed sequences pass through), so mirror that by falling back to
+   the raw value rather than throwing on a malformed `%` a page navigation would
+   otherwise crash on. */
+function decodeParam(value: string): string {
+    try {
+        return decodeURIComponent(value)
+    } catch {
+        return value
+    }
+}
+
 /* Matches one parsed pattern against the path's segments, capturing params;
    undefined on mismatch. A catch-all consumes every remaining segment. */
 function matchSegments(
@@ -81,7 +93,12 @@ function matchSegments(
             if (value === '') {
                 return undefined
             }
-            params[segment.name] = value
+            /* `url()` encodes a `[name]` value whole, and Bun decodes `req.params`
+               server-side, so decode here to hand the page the same value SSR does
+               (e.g. `The%20Daily%20Show` → `The Daily Show`). The catch-all above
+               stays raw to match the server, which reconstructs it from the raw
+               pathname. */
+            params[segment.name] = decodeParam(value)
         }
     }
     /* No catch-all consumed the tail, so the path must have no extra segments. */

package/src/lib/ui/remoteProxy.ts

@@ -53,11 +53,21 @@ HttpError; and once a backlog exists, a fresh call parks straight to the TAIL
 the app owns when to replay. `rpc.outbox()` exposes the queue.
 */
 // @documentation plumbing
+export function remoteProxy<Args, Return>(
+    method: HttpMethod,
+    url: string,
+    durable: DurableOptions & { outbox: true },
+): RemoteFunction<Args, Return, Record<never, never>, true>
+export function remoteProxy<Args, Return>(
+    method: HttpMethod,
+    url: string,
+    durable?: DurableOptions,
+): RemoteFunction<Args, Return>
 export function remoteProxy<Args, Return>(
     method: HttpMethod,
     url: string,
     durable?: DurableOptions,
-): RemoteFunction<Args, Return> {
+): RemoteFunction<Args, Return, Record<never, never>, boolean> {
     /* Assigned after `createRemoteFunction` so the invoke closure (which runs later, per
        call) parks through the shared queue; undefined leaves the plain fetch path. */
     let queue: OutboxQueue<Args> | undefined

package/src/lib/ui/renderToStream.ts

@@ -1,5 +1,6 @@
+import { deferResume } from './deferResume.ts'
 import { resumeSeedScript } from './resumeSeedScript.ts'
-import type { ResumeEntry } from './runtime/RESUME.ts'
+import type { DeferMarker, ResumeEntry } from './runtime/RESUME.ts'
 import type { SsrAwait, SsrRender } from './runtime/types/SsrRender.ts'
 import { tryEncodeResume } from './tryEncodeResume.ts'
 
@@ -39,8 +40,8 @@ export async function* renderToStream(
        instead of refetching. (`resume` is the render body's live object, so late writes
        appear here.) */
     const seededResume = new Set<number>(Object.keys(resume).map(Number))
-    const resumeDelta = (): Record<number, ResumeEntry> => {
-        const delta: Record<number, ResumeEntry> = {}
+    const resumeDelta = (): Record<number, ResumeEntry | DeferMarker> => {
+        const delta: Record<number, ResumeEntry | DeferMarker> = {}
         for (const [key, entry] of Object.entries(resume)) {
             const id = Number(key)
             if (!seededResume.has(id)) {
@@ -83,18 +84,22 @@ export async function* renderToStream(
     }
 }
 
-type Settled = { id: number; html: string; resume: ResumeEntry }
+type Settled = { id: number; html: string; resume: ResumeEntry | DeferMarker }
 
 /* Awaits one streaming block's promise and renders the resolved or error branch to
    HTML (the renderers are async so a nested `await` block composes), capturing the
    value (serializable) for the resume manifest. Errors serialize as their message —
-   enough for the catch branch, without leaking a stack. */
+   enough for the catch branch, without leaking a stack. A cache-backed value defers via
+   `deferResume` (a `{defer,key}` marker + lazy body seed) — the client adopts the streamed
+   branch inert instead of decoding the value; a non-cache value ships inline as before. */
 function settle(block: SsrAwait): Promise<Settled> {
-    return Promise.resolve(block.promise()).then(
+    /* Keep the promise: cache() tagged it with its key, which `deferResume` reads to defer. */
+    const pending = block.promise()
+    return Promise.resolve(pending).then(
         async (value) => ({
             id: block.id,
             html: await block.then(value),
-            resume: { ok: true, value },
+            resume: deferResume(pending, value),
         }),
         async (error) => {
             /* No catch branch → surface the rejection (500 before the first flush,
@@ -118,6 +123,6 @@ function settle(block: SsrAwait): Promise<Settled> {
    strings. `tryEncodeResume` handles the serialize-or-refetch policy (undefined → no
    script → the swap consumers skip registration → hydration re-runs that one promise).
    `applyResolved`/the inline swap script store it via `.textContent`; `awaitBlock` decodes it. */
-function encodeStreamResume(resume: ResumeEntry, id: number): string | undefined {
+function encodeStreamResume(resume: ResumeEntry | DeferMarker, id: number): string | undefined {
     return tryEncodeResume(resume, id)?.replace(/</g, '\\u003c')
 }

package/src/lib/ui/resumeSeedScript.ts

@@ -1,5 +1,5 @@
 import { safeJsonForScript } from '../shared/safeJsonForScript.ts'
-import type { ResumeEntry } from './runtime/RESUME.ts'
+import type { DeferMarker, ResumeEntry } from './runtime/RESUME.ts'
 import { tryEncodeResume } from './tryEncodeResume.ts'
 
 /* A self-contained `<script>` seeding the await-resume manifest with the blocking
@@ -11,7 +11,7 @@ import { tryEncodeResume } from './tryEncodeResume.ts'
    early or parse as a line terminator. Shared by the buffered (`createUiPageRenderer`)
    and streaming (`renderToStream`) paths. */
 // @documentation plumbing
-export function resumeSeedScript(resume: Record<number, ResumeEntry>): string {
+export function resumeSeedScript(resume: Record<number, ResumeEntry | DeferMarker>): string {
     /* ref-json (not JSON) so a value carrying cycles or shared back-references — a
        media tree with parent↔child links — seeds instead of being dropped. `tryEncodeResume`
        drops just an unserializable entry (the client re-runs that one branch's promise),

package/src/lib/ui/runtime/CURRENT_SCOPE.ts

@@ -1,4 +1,5 @@
 import type { Scope } from '../types/Scope.ts'
+import { ambientScopeBacking } from './ambientScopeBacking.ts'
 
 /*
 The ambient lexical scope. The compiler establishes one per lexical level (a
@@ -6,5 +7,17 @@ component, a control-flow branch) by setting `current` around the build, so the
 bare `scope()` accessor and the scope-bound primitives resolve "where they are"
 with no handle threaded. Undefined outside any scope, where `scope()` mints a
 detached root on first use.
+
+`current` reads/writes through a SWAPPABLE backing (`ambientScopeBacking`) rather
+than a raw field: the default is a module variable, but the server installs an
+AsyncLocalStorage-backed holder so concurrent async SSR renders don't clobber one
+shared global across the inline `await`s they suspend on. See `ambientScopeBacking`.
 */
-export const CURRENT_SCOPE: { current: Scope | undefined } = { current: undefined }
+export const CURRENT_SCOPE: { current: Scope | undefined } = {
+    get current(): Scope | undefined {
+        return ambientScopeBacking.active.get()
+    },
+    set current(value: Scope | undefined) {
+        ambientScopeBacking.active.set(value)
+    },
+}

package/src/lib/ui/runtime/RESUME.ts

@@ -16,6 +16,12 @@
    same reference. */
 export type ResumeEntry = { ok: true; value: unknown } | { ok: false; error: unknown }
 
+/* Deferred-resume marker (Tier 2): a large cache-backed `{#await cache()}` ships this in
+   place of its value — just the cache key, so hydration adopts the server branch inert and
+   pays no value decode. The client seeds that key lazily and materializes it only on a later
+   re-read. Discriminated from a ResumeEntry by the `defer` field. */
+export type DeferMarker = { defer: true; key: string }
+
 const globalScope = globalThis as { __abideResume?: Record<number, string> }
 globalScope.__abideResume ??= {}
 

package/src/lib/ui/runtime/ambientScopeBacking.ts

@@ -0,0 +1,26 @@
+import type { Scope } from '../types/Scope.ts'
+
+/*
+The swappable backing behind `CURRENT_SCOPE.current`. The default is a module
+variable — correct on the client (one render tree) and on the server outside any
+request. The server swaps in an AsyncLocalStorage-backed holder at boot
+(`installAmbientScopeStore`), because SSR is partly async: a render brackets itself
+with `enterScope`/`exitScope` and `await`s inline between them (blocking `{#await}`,
+child renders, slots, a top-level `await`). A module global held across those awaits
+interleaves across concurrent requests — one render resumes to read another's scope.
+Keying the ambient off the per-request store (which the async context propagates
+correctly) isolates it. Mirrors `requestScopeResolver`'s server-installed slot; the
+indirection cost lands at build/effect-creation time, never on the signal hot path.
+*/
+type ScopeBacking = { get(): Scope | undefined; set(value: Scope | undefined): void }
+
+let moduleCurrent: Scope | undefined
+
+export const ambientScopeBacking: { active: ScopeBacking } = {
+    active: {
+        get: () => moduleCurrent,
+        set: (value) => {
+            moduleCurrent = value
+        },
+    },
+}