@abide/abide 0.58.0 → 0.100.0

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

@@ -1,160 +0,0 @@
-import { rawHtmlString } from '../../shared/html.ts'
-import { snippetPayload } from '../../shared/snippet.ts'
-import { effect } from '../effect.ts'
-import { claimChild } from '../runtime/claimChild.ts'
-import { parkCursor } from '../runtime/parkCursor.ts'
-import { RENDER } from '../runtime/RENDER.ts'
-import { SuspenseSignal } from '../runtime/SuspenseSignal.ts'
-import { appendSnippet } from './appendSnippet.ts'
-import { claimText } from './claimText.ts'
-import { isComment } from './isComment.ts'
-import { parseRawNodes } from './parseRawNodes.ts'
-import { readTextOrSuspend } from './readTextOrSuspend.ts'
-
-const CLOSE = '/abide:html'
-
-/*
-A reactive `{expr}` interpolation under `parent`. A plain value is an escaped text
-node: created and appended (create), or the server-rendered text node claimed
-(hydrate) and bound. Adjacent SSR text merges into one node, so on hydrate the
-claimed node is split at the current value's length — deterministic, because
-`read()` returns the same value the server rendered.
-
-A value branded by `html\`…\`` (see abide/ui/html) inserts raw markup instead:
-its parsed nodes go between an anchor (create), or the server-rendered nodes
-between `<!--abide:html-->`/`<!--/abide:html-->` markers are adopted (hydrate), and
-a change re-parses and swaps. A binding is text or raw for its lifetime (decided by
-its first value), so plain text — the common case — stays a cheap single node.
-
-A blocking `await` read that is pending throws a `SuspenseSignal` (ADR-0042): the
-interpolation SUSPENDS — it renders empty and withholds until the value resolves,
-never evaluating the surrounding expression against a pending `undefined`. The read
-tracked the cell, so the bind effect re-runs on settle. A suspend can only occur on a
-cold client render (on hydrate the warm-seed makes the cell `refreshing()`, not
-`pending()`, D4), and a suspended value is treated as text — its snippet/html shape is
-decided from the first resolved value.
-*/
-// @documentation plumbing
-export function appendText(
-    parent: Node,
-    read: () => unknown,
-    splitAlways = false,
-    /* Create-mode insertion reference: content lands before this node instead of at the end of
-       `parent` (`null` appends). Lets `appendTextAt` mount at a skeleton anchor through this one
-       create path. Ignored on hydrate, where the cursor decides position. */
-    before: Node | null = null,
-): void {
-    /* Probe the first value once, tolerating a suspend (a pending blocking read) — a suspended
-       interpolation skips snippet/html detection and takes the text path, starting empty. */
-    let probe: unknown
-    let suspended = false
-    try {
-        probe = read()
-    } catch (signal) {
-        if (!(signal instanceof SuspenseSignal)) {
-            throw signal
-        }
-        suspended = true
-    }
-    /* A snippet call (`{row(args)}`) mounts its builder; a `html\`\`` value inserts
-       raw markup; everything else is escaped text — decided by the first value. */
-    if (!suspended && typeof snippetPayload(probe) === 'function') {
-        if (before === null) {
-            appendSnippet(parent, read)
-            return
-        }
-        /* Positioned mount: buffer the snippet in a fragment, then splice it in at `before` —
-           `appendSnippet` itself only appends, and its markers track position from then on. */
-        const fragment = document.createDocumentFragment()
-        appendSnippet(fragment, read)
-        parent.insertBefore(fragment, before)
-        return
-    }
-    if (!suspended && rawHtmlString(probe) !== undefined) {
-        appendRawHtml(parent, read, before)
-        return
-    }
-    const hydration = RENDER.hydration
-    if (hydration !== undefined) {
-        /* Nullish reads render as empty text, never the literal `"undefined"` — so a
-           pending async read (undefined-while-pending, ADR-0032 D3) shows nothing. A blocking
-           read never suspends here (warm-seeded → `refreshing()`), so `probe` holds its value. */
-        const firstValue = probe
-        const value = firstValue == null ? '' : String(firstValue)
-        /* Claim this binding's portion of the merged SSR text node (assert + split +
-           advance — see `claimText`). A value that first rendered empty produced NO server
-           text node, so the cursor points at the following node (an element/comment) or past
-           the end — the miss arm: bind a synthesized empty Text at the cursor and leave the
-           unclaimed node for the next consumer (a following element hole, a sibling binding,
-           or nothing). Without it the bind effect below derefs a null/element node. */
-        let node = claimText(hydration, parent, value, splitAlways)
-        if (node === undefined) {
-            const unclaimed = claimChild(hydration, parent)
-            node = parent.insertBefore(document.createTextNode(''), unclaimed)
-            /* Pin the cursor on the still-unclaimed node — the synthesized node is this
-               binding's own, and an unset cursor would default back to the (now synthesized)
-               first child. */
-            parkCursor(hydration, parent, unclaimed)
-        }
-        const bound = node
-        effect(() => {
-            bound.data = readTextOrSuspend(read)
-        })
-        return
-    }
-    const node = document.createTextNode('')
-    parent.insertBefore(node, before)
-    effect(() => {
-        node.data = readTextOrSuspend(read)
-    })
-}
-
-/* Raw-markup interpolation: parse the branded string into nodes behind an anchor,
-   re-parsing on change; on hydrate adopt the server markup between its markers. */
-function appendRawHtml(parent: Node, read: () => unknown, before: Node | null): void {
-    const hydration = RENDER.hydration
-    const markup = (): string => rawHtmlString(read()) ?? ''
-    const anchor = document.createTextNode('')
-    let nodes: Node[] = []
-
-    const set = (value: string): void => {
-        /* Insert/remove via the anchor's LIVE parent, not the build-time `parent` — when
-           this interpolation is a bare child of a control-flow branch, `parent` is the
-           branch's build fragment, which the enclosing block has since emptied into the
-           document (same reason each/awaitBlock use the anchor's parentNode). */
-        const liveParent = anchor.parentNode ?? parent
-        for (const node of nodes) {
-            liveParent.removeChild(node)
-        }
-        nodes = parseRawNodes(liveParent, value)
-        for (const node of nodes) {
-            liveParent.insertBefore(node, anchor)
-        }
-    }
-
-    if (hydration !== undefined) {
-        const open = claimChild(hydration, parent)
-        let node: Node | null = open === null ? null : open.nextSibling
-        while (node !== null && !isComment(node, CLOSE)) {
-            nodes.push(node)
-            node = node.nextSibling
-        }
-        parkCursor(hydration, parent, node === null ? null : node.nextSibling)
-        parent.insertBefore(anchor, node)
-        let first = true
-        effect(() => {
-            const value = markup()
-            if (first) {
-                first = false // adopt the server markup as-is
-                return
-            }
-            set(value)
-        })
-        return
-    }
-
-    parent.insertBefore(anchor, before)
-    effect(() => {
-        set(markup())
-    })
-}

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

@@ -1,39 +0,0 @@
-import { parkCursor } from '../runtime/parkCursor.ts'
-import { RENDER } from '../runtime/RENDER.ts'
-import { appendText } from './appendText.ts'
-
-/*
-A reactive `{expr}` interpolation mounted at a skeleton anchor comment (`<!--a-->`), used
-for reactive text INTERLEAVED with element siblings (where element-only positioning can't
-reach it). The anchor is located by `skeleton`'s scan, and content mounts immediately
-after it. Handles the same three value kinds as `appendText` — escaped text, a
-`{snippet(args)}` builder, and `html\`\``-branded raw markup — since the kind is only
-known at runtime.
-
-The anchor is KEPT (in both the SSR markup and the client DOM, like control flow's
-`<!--[-->` range markers), so server and client render identical markup — `appendTextAt`
-never strips it.
-
-Both paths delegate to `appendText`: hydrate with the cursor temporarily pointed at the
-anchor's content (the server rendered `<!--a-->value`, so the value is the anchor's next
-sibling), create with the anchor's next sibling as the insertion reference — one
-text-split / snippet / raw-html implementation, positioned two ways.
-*/
-// @documentation plumbing
-export function appendTextAt(anchor: Node, read: () => unknown): void {
-    const parent = anchor.parentNode as Node
-    const hydration = RENDER.hydration
-    if (hydration !== undefined) {
-        const had = hydration.next.has(parent)
-        const saved = hydration.next.get(parent)
-        parkCursor(hydration, parent, anchor.nextSibling)
-        appendText(parent, read)
-        if (had) {
-            parkCursor(hydration, parent, saved ?? null)
-        } else {
-            hydration.next.delete(parent)
-        }
-        return
-    }
-    appendText(parent, read, false, anchor.nextSibling)
-}

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

@@ -1,30 +0,0 @@
-import { CURRENT_PATH } from '../runtime/CURRENT_PATH.ts'
-import { reportHydrationDivergence } from '../runtime/reportHydrationDivergence.ts'
-
-/*
-A text claim that MUST match the server's rendered text. On hydrate,
-appendStatic/appendText adopt a merged SSR text node and split it at the CLIENT
-value's length, trusting the client renders the same string the server did. When
-they diverge — a binding whose value only materializes client-side (a peeked cache
-value, `Date.now()`, a random) — the split lands mid-run and orphans the tail,
-silently corrupting the DOM several nodes downstream. This turns that into a legible
-desync AT the divergence, the text counterpart of `claimExpected` for structure.
-
-The claimed node's data must BEGIN with this binding's value: a merged run appends
-the following siblings' text AFTER it, so the value is exactly the leading slice. A
-mismatch means SSR and the client build disagree on the text here.
-*/
-export function assertClaimedText(node: Text, value: string): void {
-    if (node.data.startsWith(value)) {
-        return
-    }
-    /* Report on the `hydrate` channel with the render-path. With the channel on, keep hydrating
-       (re-split proceeds below on the client length) so one reload surfaces every text divergence;
-       off, the hard throw stays the default. A text miss is cursor-safe to continue past. */
-    if (!reportHydrationDivergence('text desync', { expected: value, server: node.data })) {
-        return
-    }
-    throw new Error(
-        `[abide] hydration desync at ${CURRENT_PATH.current || '(root)'}: expected server text beginning with ${JSON.stringify(value)} here, but the server DOM had ${JSON.stringify(node.data)} — SSR markup and the client build disagree on the text at this position.`,
-    )
-}

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

@@ -1,25 +0,0 @@
-import { CURRENT_SCOPE } from '../runtime/CURRENT_SCOPE.ts'
-import { inScope } from '../runtime/inScope.ts'
-import { OWNER } from '../runtime/OWNER.ts'
-import { toTeardown } from '../runtime/toTeardown.ts'
-import type { EffectResult } from '../runtime/types/EffectResult.ts'
-
-/*
-Runs an attachment against an element at build time and registers its optional
-teardown with the current ownership scope, so it detaches when the component
-disposes. The dual of `on`: where `on` owns a listener, `attach` owns whatever
-the attachment sets up. Node-lifetime, not reactive — for param reactivity put an
-`effect` inside the attachment and return its dispose. The attachment may be
-async; its teardown then runs once the promise settles. Runtime target for an
-`attach={…}` binding.
-*/
-// @documentation plumbing
-export function attach(element: Element, attachment: (node: Element) => EffectResult): void {
-    /* The attachment body runs now (scope already current); pin the teardown, which
-       fires on dispose, so an ambient `scope()` in it resolves the component. */
-    const captured = CURRENT_SCOPE.current
-    const teardown = toTeardown(attachment(element))
-    if (teardown !== undefined && OWNER.current !== undefined) {
-        OWNER.current.push(() => inScope(captured, teardown))
-    }
-}

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

@@ -1,57 +0,0 @@
-import { effect } from '../effect.ts'
-import { RENDER } from '../runtime/RENDER.ts'
-import { reportHydrationDivergence } from '../runtime/reportHydrationDivergence.ts'
-import { SuspenseSignal } from '../runtime/SuspenseSignal.ts'
-
-/* The attribute string an element carries for `value`, or `null` when absent — the present/absent +
-   stringify semantics below, factored so the hydration compare and the write agree exactly. */
-function attributeText(value: unknown): string | null {
-    if (value === false || value === null || value === undefined) {
-        return null
-    }
-    return value === true ? '' : String(value)
-}
-
-/*
-Binds an element attribute to `read()`. A boolean true sets the bare attribute,
-and false/null/undefined removes it (the standard present/absent semantics);
-anything else is stringified. One effect per bound attribute, so only the
-changed attribute touches the DOM.
-*/
-// @documentation plumbing
-export function attr(element: Element, name: string, read: () => unknown): void {
-    /* Captured at bind time (inside the hydrating build) so the first effect run can compare the
-       server-rendered attribute before overwriting it — an attribute divergence is otherwise
-       invisible, since the effect always overwrites. */
-    let hydrating = RENDER.hydration !== undefined
-    effect(() => {
-        let value: unknown
-        try {
-            value = read()
-        } catch (signal) {
-            /* A pending blocking `await` read (ADR-0042) suspends this attribute: leave it
-               unset until the value resolves. The read tracked its cell, so this effect
-               re-runs on settle. A suspend can only occur on a cold client render (warm-seed
-               keeps a hydrating read `refreshing()`, never `pending()`), so the hydration
-               compare below is never reached while suspended. */
-            if (!(signal instanceof SuspenseSignal)) {
-                throw signal
-            }
-            element.removeAttribute(name)
-            return
-        }
-        const next = attributeText(value)
-        if (hydrating) {
-            hydrating = false
-            const server = element.getAttribute(name)
-            if (server !== next) {
-                reportHydrationDivergence(`attr "${name}" desync`, { server, client: next })
-            }
-        }
-        if (next === null) {
-            element.removeAttribute(name)
-        } else {
-            element.setAttribute(name, next)
-        }
-    })
-}

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

@@ -1,314 +0,0 @@
-import { decodeRefJson } from '../../shared/decodeRefJson.ts'
-import { isThenable } from '../../shared/isThenable.ts'
-import { effect } from '../effect.ts'
-import { CURRENT_BOUNDARY } from '../runtime/CURRENT_BOUNDARY.ts'
-import { claimMarker } from '../runtime/claimMarker.ts'
-import { generationGuard } from '../runtime/generationGuard.ts'
-import { RANGE_CLOSE, RANGE_OPEN } from '../runtime/RANGE_MARKER.ts'
-import { RENDER } from '../runtime/RENDER.ts'
-import type { ResumeEntry } from '../runtime/RESUME.ts'
-import { RESUME } from '../runtime/RESUME.ts'
-import { SuspenseSignal } from '../runtime/SuspenseSignal.ts'
-import { scopeGroup } from '../runtime/scopeGroup.ts'
-import type { State } from '../runtime/types/State.ts'
-import { state } from '../state.ts'
-import { anchoredBranch } from './anchoredBranch.ts'
-import { discardAndRebuild } from './discardAndRebuild.ts'
-
-/*
-Async binding — the runtime for `<template await>`. Renders the pending branch,
-then swaps to the resolved branch (with the value) or the error branch on settle.
-Each branch's content lives in a RANGE bounded by two comment markers (`[`…`]`), the
-same model `when`/`switch`/`each` use — so a multi-root branch inserts as a unit
-(`buildDetachedRange`) and detaches as a unit (`removeRange`), rather than tracking and
-removing a node array by hand.
-
-The read runs inside a abide-ui `effect`, so it's reactive: `abide/shared/cache`'s
-store subscribes the key it reads to this effect (createSubscriber is abide-ui-
-native), so `cache.invalidate()` of that key re-runs the block — pending, then the
-fresh value swaps in. A read that touches no reactive source runs exactly once.
-
-Hydration adopts in place, by precedence:
-  1. a streamed resume value (`RESUME[id]`) → adopt the resolved branch the stream
-     swapped in, no read (the promise never runs — a plain producer resume);
-  2. a warm-sync read (a non-thenable result) → adopt the SSR branch with it;
-  3. otherwise (genuinely pending) → discard the SSR boundary and run fresh.
-After the first (adopting) run, later invalidations swap content before an anchor
-parked just before the close marker.
-*/
-// @documentation plumbing
-export function awaitBlock(
-    parent: Node,
-    id: string,
-    promiseThunk: () => unknown,
-    renderPending: ((parent: Node) => void) | undefined,
-    renderThen: (parent: Node, value: unknown) => void,
-    /* Absent when the block has no catch branch — a rejection then routes to the enclosing
-       {#try} boundary captured at build (if any), else surfaces (re-throws to the
-       unhandled-rejection path) instead of rendering an empty branch. */
-    renderCatch: ((parent: Node, error: unknown) => void) | undefined,
-    /* A static node located by the skeleton: the block's anchor inserts before it on
-       create (block before a static suffix). Null appends (tail). insertBefore(x, null)
-       === appendChild, so the default is the prior behaviour. */
-    before: Node | null = null,
-): void {
-    const hydration = RENDER.hydration
-    /* The enclosing {#try} boundary ambient at BUILD (like createEffectNode captures it). A
-       catch-less rejection settles LATER, after CURRENT_BOUNDARY has been restored, so we must
-       capture it into this closure now rather than read it at settle time. */
-    const capturedBoundary = CURRENT_BOUNDARY.current
-    /* The live branch's scope, registered with the owner so it disposes on owner
-       teardown — not only when a settle/re-run swaps branches via detach. */
-    const group = scopeGroup()
-    /* The single active branch mounted before an anchor — owns `active`/`detach`/`place`/
-       adopt-strand guard (shared with `tryBlock`); this block keeps its bespoke settlement. */
-    const branch = anchoredBranch(parent, group)
-    let first = true
-    /* Bumped each run so a prior run's in-flight promise can't clobber a newer one, AND on
-       owner teardown so an in-flight promise that settles AFTER the enclosing `{#if}`/
-       `{#for}`/component tears this block out is abandoned — otherwise its settle runs
-       `place` on the block's now-detached anchor and `insertBefore` throws NotFoundError. */
-    const guard = generationGuard()
-    /* The resolved value, held as a reactive cell so the then-branch reads it through its
-       own effects. A re-run that resolves to a NEW value SETS this cell instead of rebuilding
-       the branch — the branch (and any keyed `each` inside it) survives and updates in place,
-       so a live cache patch no longer flashes the whole subtree. The branch is rebuilt only
-       across a kind change (pending/catch ↔ then), where it has to be. */
-    let valueCell: State<unknown> | undefined
-    /* Which branch is currently mounted, so a settle knows whether it can update the cell in
-       place (then→then) or must build a fresh branch. */
-    let activeKind: 'pending' | 'then' | 'catch' | undefined
-
-    /* Settle to a resolved value. then→then updates the cell in place — the branch and its
-       inner each survive (no flash); any other prior kind builds a fresh then-branch around
-       a new cell. renderThen receives the CELL (not the raw value), so the branch reads it
-       reactively and re-runs its own effects when a later settle sets it. */
-    const settleThen = (value: unknown): void => {
-        if (activeKind === 'then' && valueCell !== undefined) {
-            valueCell.value = value
-            return
-        }
-        const cell = state(value)
-        valueCell = cell
-        branch.place((host) => renderThen(host, cell))
-        activeKind = 'then'
-    }
-
-    /* Settle to a rejection: with a local catch branch, swap to it. With no local catch, route
-       to the enclosing {#try} boundary captured at build if one was ambient; otherwise surface
-       (unhandled rejection), preserving the prior behaviour when there's no boundary. */
-    const settleError = (error: unknown): void => {
-        if (renderCatch === undefined) {
-            if (capturedBoundary !== undefined) {
-                capturedBoundary.handle(error)
-                return
-            }
-            throw error
-        }
-        valueCell = undefined
-        branch.place((host) => renderCatch(host, error))
-        activeKind = 'catch'
-    }
-
-    /* Show the pending branch (or detach when there is none), UNLESS a then-branch is already
-       mounted — a revalidation keeps it visible and updates in place when the new value settles
-       (the no-flash live-update path). Shared by an in-flight promise and a suspended subject read. */
-    const showPending = (): void => {
-        if (activeKind !== 'then') {
-            if (renderPending !== undefined) {
-                branch.place((host) => renderPending(host))
-                activeKind = 'pending'
-            } else {
-                branch.detach()
-                activeKind = undefined
-            }
-        }
-    }
-
-    /* Render a settled-or-pending result into the current generation. */
-    const render = (result: unknown): void => {
-        const gen = guard.token()
-        if (!isThenable(result)) {
-            settleThen(result) // warm-sync → resolved now, no flash
-            return
-        }
-        /* A first load (or a prior pending/catch) shows the pending branch while the promise is in
-           flight; a live then-branch stays put (see `showPending`). */
-        showPending()
-        result.then(
-            (value) => {
-                if (guard.live(gen)) {
-                    settleThen(value)
-                }
-            },
-            (error) => {
-                if (guard.live(gen)) {
-                    settleError(error)
-                }
-            },
-        )
-    }
-
-    /* Adopt an SSR-resolved branch in place (its content claims the existing nodes), then
-       wrap the adopted region in `[`…`]` markers and park an anchor just before the close
-       marker for later swaps. The adopted content is everything the build claimed between
-       the open and close markers; bracketing it makes the adopted branch a marker-bounded
-       range identical to a freshly-`place`d one, so the FIRST swap detaches it with
-       `removeRange` like every later swap (no node-array special case). `adoptStrand` carries
-       the shared strand-dispose guard; the `afterBuild` closure below is await's bespoke
-       bracketing — it runs only after a clean build. */
-    const adopt = (open: Node | null, build: (parent: Node) => void): void => {
-        const cursor = hydration as NonNullable<typeof hydration>
-        /* The cursor already sits here (claiming `open` advanced past it); kept for the
-           bracketing below. */
-        const firstAdopted = open?.nextSibling ?? null
-        branch.adoptStrand(build, () => {
-            /* A guaranteed control-flow marker — the claim throws on a desync (caught by
-               firstHydrate's adopt try/catch → rebuildCold) instead of silently claiming null
-               and over-clearing the parent. */
-            const close = claimMarker(cursor, parent, `/abide:await:${id} close marker`)
-            /* Bracket the adopted nodes: `[` before the first claimed node (or before `close`
-               for an empty branch), `]` then the anchor just before `close`. */
-            const start = document.createComment(RANGE_OPEN)
-            parent.insertBefore(start, firstAdopted ?? close)
-            const end = document.createComment(RANGE_CLOSE)
-            parent.insertBefore(end, close)
-            branch.parkAnchor(close)
-            return { start, end }
-        })
-    }
-
-    /* Discard the SSR boundary and (re)build the block from `result`, fresh (hydration
-       off) — the recovery path when adoption can't use the server markup. Insert the
-       anchor at the node AFTER the discarded boundary — NOT the captured `before`, which
-       for a skeleton-anchored block is the open boundary itself and is removed here, so
-       reusing it throws `NotFoundError` in a strict DOM. */
-    const rebuildCold = (open: Node | null, result: () => unknown): void => {
-        branch.detach()
-        discardAndRebuild(
-            hydration as NonNullable<typeof hydration>,
-            parent,
-            open,
-            `/abide:await:${id}`,
-            (after) => {
-                branch.parkAnchor(after)
-                render(result())
-            },
-        )
-    }
-
-    /* The first run when hydrating: adopt by precedence (resume / warm-sync), else
-       discard the boundary and mount fresh. Adoption is guarded: a resume value that
-       didn't round-trip (e.g. a non-serializable Response) throws while building the
-       branch — fall back to the live promise, which reads the properly-reconstructed
-       warm cache (or re-fetches) instead of crashing hydration. */
-    const firstHydrate = (): void => {
-        const cursor = hydration as NonNullable<typeof hydration>
-        /* The await block's open marker is compiler-guaranteed — the claim throws a
-           legible desync here rather than propagating a null that over-clears the parent. */
-        const open = claimMarker(cursor, parent, `abide:await:${id} open marker`)
-        /* RESUME holds the ref-json-encoded entry STRING; decode here, where the codec
-           lives. A decode failure (malformed/absent payload) reads as "no resume" — fall
-           through to the live promise rather than crash hydration. */
-        const raw = RESUME[id]
-        let decoded: ResumeEntry | undefined
-        if (raw !== undefined) {
-            try {
-                decoded = decodeRefJson(raw) as ResumeEntry
-            } catch {
-                decoded = undefined
-            }
-        }
-        /* Read the promise now so the block subscribes to its reactive source (a cache key) —
-           warm on resume, so no round-trip — then adopt the resume value / warm-sync result
-           below, or discard and build the pending branch fresh. */
-        const result = promiseThunk()
-        const entry = decoded
-        if (entry !== undefined) {
-            /* The resume entry drives the adopted branch below; the live `result` read to
-               subscribe the reactive source is discarded here. Swallow its rejection — a
-               cold-cache warm-seed miss starts a real fetch, and if that fetch rejects it
-               would otherwise surface as an unhandledrejection at boot (process-fatal under
-               Bun) instead of being harmlessly dropped. */
-            if (isThenable(result)) {
-                void result.then(undefined, () => undefined)
-            }
-            /* Build the adopted branch around a value CELL (then) so a later re-run updates
-               it in place, exactly like a fresh mount. The `throw` for a catch-less rejection
-               stays OUTSIDE the adopt try/catch so it surfaces rather than triggering the
-               cold-rebuild fallback. */
-            let build: (host: Node) => void
-            let cell: State<unknown> | undefined
-            let kind: 'then' | 'catch'
-            if (entry.ok) {
-                cell = state(entry.value)
-                const resolved = cell
-                build = (host) => renderThen(host, resolved)
-                kind = 'then'
-            } else if (renderCatch !== undefined) {
-                build = (host) => renderCatch(host, entry.error)
-                kind = 'catch'
-            } else {
-                /* A resumed rejection with no catch branch surfaces (mirrors the cold
-                   path); in practice the server 500s such a block, so none resumes. */
-                throw entry.error
-            }
-            try {
-                adopt(open, build)
-                valueCell = cell
-                activeKind = kind
-            } catch {
-                rebuildCold(open, promiseThunk)
-            }
-            return
-        }
-        if (!isThenable(result)) {
-            const cell = state(result)
-            try {
-                adopt(open, (host) => renderThen(host, cell))
-                valueCell = cell
-                activeKind = 'then'
-            } catch {
-                rebuildCold(open, promiseThunk)
-            }
-            return
-        }
-        /* Genuinely pending — no resume, not warm: the boundary's server nodes can't be
-           adopted, so discard them and build the pending branch fresh from the already-read
-           promise (nothing was placed yet; the detach inside is a no-op). */
-        rebuildCold(open, () => result)
-    }
-
-    effect(() => {
-        guard.renew()
-        if (first) {
-            first = false
-            if (hydration !== undefined) {
-                /* firstHydrate reads the promise ITSELF so the block subscribes to its reactive
-                   source (a cache key), then adopts the resume value / warm-sync result. */
-                firstHydrate()
-                return
-            }
-            branch.parkAnchor(before)
-        }
-        /* Read the promise every subsequent run so an invalidate re-runs the block. ONLY this
-           read is tracked (the branch builds untracked via `scope`), so the block re-runs only
-           when its promise source does, not on any branch-state change. A blocking `await` cell
-           embedded in the subject (`{#await loadMore(user.id)}` where `user` is an `await` cell)
-           throws a `SuspenseSignal` while pending (ADR-0042) — on a COLD client render the read
-           runs synchronously here, so withhold to the pending branch until it settles (mirroring
-           the local suspense withhold every other reading region does), rather than letting the
-           throw escape the build. The read tracked its cell, so this effect re-runs on resolve. */
-        let result: unknown
-        try {
-            result = promiseThunk()
-        } catch (signal) {
-            if (!(signal instanceof SuspenseSignal)) {
-                throw signal
-            }
-            showPending()
-            return
-        }
-        render(result)
-    })
-}