@abide/abide 0.58.0 → 0.100.0

package/src/lib/ui/html.ts

@@ -1,39 +0,0 @@
-import { RAW_HTML, type RawHtml } from '../shared/html.ts'
-
-/*
-Marks a string as trusted raw HTML so a `{expr}` interpolation inserts its nodes
-instead of escaped text — the abide idiom for raw markup (no `{@html}` mustache).
-Works two ways:
-
-  html(trustedString)        // plain call — insert the string verbatim
-  html`<b>${name}</b>`       // tagged — concatenate parts verbatim
-
-Calling `html` is the explicit opt-in to raw insertion; plain `{value}` always
-escapes. The tag does NOT auto-escape interpolations (it's raw by intent), so only
-build markup from values you trust, or escape them yourself. Imported by the author
-(`import { html } from 'abide/ui/html'`) — it is UI-authoring vocabulary, only ever
-written inside a template, so it lives in `ui/` (the reader, `rawHtmlString`, is the
-isomorphic plumbing and stays in `shared/`).
-*/
-// @documentation templating
-export function html(
-    strings: TemplateStringsArray | string | null | undefined,
-    ...values: unknown[]
-): RawHtml {
-    /* A plain call with a nullish argument renders nothing. A bare async read (ADR-0032)
-       hands `html()` `undefined` while pending — `{html(highlight(code)?.html)}` — so the
-       plain-call path degrades to empty raw instead of throwing on `strings[0]`, matching
-       how a bare `{value}` stringifies `undefined` to `""`. Mirrors the null-tolerance
-       ADR-0032 added to `done()`/`peek()` for the same inline-async ergonomics. */
-    if (strings === null || strings === undefined) {
-        return { [RAW_HTML]: '' }
-    }
-    if (typeof strings === 'string') {
-        return { [RAW_HTML]: strings }
-    }
-    let markup = strings[0] ?? ''
-    for (let index = 0; index < values.length; index += 1) {
-        markup += String(values[index]) + (strings[index + 1] ?? '')
-    }
-    return { [RAW_HTML]: markup }
-}

package/src/lib/ui/isolateCellBarrier.ts

@@ -1,17 +0,0 @@
-import { cellBarrierBacking } from './runtime/cellBarrierBacking.ts'
-
-/*
-Runs a hoisted child render (`$$isolateCellBarrier`) under its OWN async-cell barrier list, so its
-cells register and its `$$settleAsyncCells` drain are isolated from every concurrent sibling and from
-the page (ADR-0037 Phase 2). Wraps the render start emitted by the SSR flight hoist:
-`$$flight(() => $$isolateCellBarrier(() => $$withPath(ordinal, () => Child.render(props, $ctx))))`.
-The server backing runs it inside an AsyncLocalStorage so the fresh list is inherited across the
-child render's own awaits (its top-level script await, its barrier); the default (client / no server
-install) backing is an inert passthrough — the client mounts synchronously and has no SSR barrier, so
-there is nothing to isolate. Only the pending (barrier) list is isolated; resolved/streamed cell
-values still aggregate on the per-request store for the warm-seed snapshot.
-*/
-// @documentation plumbing
-export function isolateCellBarrier<T>(render: () => T): T {
-    return cellBarrierBacking.active.run({ promises: [] }, render)
-}

package/src/lib/ui/linked.ts

@@ -1,125 +0,0 @@
-import { isAsyncIterable } from '../shared/isAsyncIterable.ts'
-import type { AsyncState } from '../shared/types/AsyncState.ts'
-import type { NamedAsyncIterable } from '../shared/types/NamedAsyncIterable.ts'
-import { CURRENT_SCOPE } from './runtime/CURRENT_SCOPE.ts'
-import { createAsyncCell } from './runtime/createAsyncCell.ts'
-import { createEffectNode } from './runtime/createEffectNode.ts'
-import { isAsyncFunction } from './runtime/isAsyncFunction.ts'
-import { routeBareSeed } from './runtime/routeBareSeed.ts'
-import { SuspenseSignal } from './runtime/SuspenseSignal.ts'
-import type { State } from './runtime/types/State.ts'
-import { state } from './state.ts'
-import type { Scope } from './types/Scope.ts'
-
-/*
-A writable cell seeded reactively from upstream — the abide form of Angular's
-`linkedSignal`. Like `state` it owns a local value and can diverge from its
-source (an edit-form draft, a local working copy); unlike `state` the seed is a
-reactive thunk, so the cell reseeds whenever the thunk's dependencies change.
-Between reseeds it holds whatever was written to it, and edits never flow upstream
-(the seed reads, it does not write). The thunk is mandatory: it *is* the
-reactivity — a bare value can never reseed, which would just make this `state`.
-
-`transform` is the same coercion gate as on `state`, and it runs on *every* value
-entering the store — explicit `.value =` writes and reseeds alike — so the store
-never holds an un-coerced value (`return previous` rejects via the `Object.is`
-no-op). The seed is captured by reference: callers clone in the thunk
-(`linked(() => structuredClone(x))`) when they want isolation.
-
-When the seed tracks an async source it becomes a writable async cell (`AsyncState<T>`,
-ADR-0019 D1): an `async () => await …` thunk unwraps its promise, a `NamedAsyncIterable`
-seed auto-tracks its frames. Same probe surface as `AsyncComputed` plus `set()`, which
-latches until the next reseed — an arriving frame never clobbers an in-progress edit.
-*/
-export function linked<T>(
-    seed: () => NamedAsyncIterable<T>,
-    transform?: (next: T, previous: T) => T,
-): AsyncState<T>
-export function linked<T>(
-    seed: () => Promise<T>,
-    transform?: (next: T, previous: T) => T,
-): AsyncState<T>
-export function linked<T>(seed: () => T, transform?: (next: T, previous: T) => T): State<T>
-export function linked<T>(
-    seed: () => T | Promise<T> | NamedAsyncIterable<T>,
-    transform?: (next: T, previous: T) => T,
-): State<T> | AsyncState<T> {
-    const coerce = transform as ((next: unknown, previous: unknown) => unknown) | undefined
-    /* A BARE seed that reached the runtime literally (a branch-nested `<script>`, a direct
-       JS caller) — the compile-time `wrapSeed` normalization only covers the leading script,
-       so honor the authored contract (ADR-0045) by VALUE via the shared `routeBareSeed`,
-       exactly as `computed` does; a non-async value becomes a constant seed thunk (reseeds
-       never fire — nothing tracked — matching the wrapped `() => value` form). */
-    if (typeof seed !== 'function') {
-        const value: unknown = seed
-        const cell = routeBareSeed(value, true, coerce)
-        if (cell !== undefined) {
-            return cell as AsyncState<T>
-        }
-        seed = () => value as T
-    }
-    /* `await` marker: an async-function seed unwraps its promise into a writable async cell. */
-    if (isAsyncFunction(seed)) {
-        return createAsyncCell(seed as () => unknown, {
-            writable: true,
-            transform: coerce,
-        }) as AsyncState<T>
-    }
-    /* Peek the seed once to detect a self-identifying stream source (auto-track); `linked`
-       already runs its seed eagerly, so an early probe matches its semantics. A throw or a
-       non-stream value falls through to the plain synchronous cell. */
-    let probe: unknown
-    let threw = false
-    let suspended = false
-    try {
-        probe = seed()
-    } catch (error) {
-        threw = true
-        suspended = error instanceof SuspenseSignal
-    }
-    /* The seed SUSPENDED — it read a pending BLOCKING cell (`await`-marked). A sync `state`
-       here would hold `undefined` while the reseed effect re-threw the suspend, letting it
-       escape at construction. Route to the eager async cell instead: `createAsyncCell` already
-       treats a synchronously-suspending seed as "pending" — it stays in flight, the throwing
-       read subscribed its effect to the blocking dependency, and it re-runs on settle — and it
-       marks the cell BLOCKING so its own reads pause too, matching a lazy `computed(() =>
-       blockingCell)`. This makes a blocking read behave the same in a `linked` seed as in a
-       `computed` seed or a template. A real (non-suspense) throw keeps the sync fall-through. */
-    if (suspended) {
-        return createAsyncCell(seed as () => unknown, {
-            writable: true,
-            transform: coerce,
-        }) as AsyncState<T>
-    }
-    if (!threw && isAsyncIterable(probe)) {
-        return createAsyncCell(seed as () => unknown, {
-            writable: true,
-            transform: coerce,
-        }) as AsyncState<T>
-    }
-    /* Reserve this cell's async-cell ordinal even though the seed resolved synchronously to a
-       plain `state`. Whether a `linked` seed suspends (→ `createAsyncCell`, which draws a
-       `nextCellIndex()` for its warm-seed key) or resolves synchronously (→ this plain `state`,
-       drawing none) is DATA-dependent, and that data can differ across the SSR→client handoff: a
-       blocking dependency still in flight on the server (→ suspend → async cell → index drawn) is
-       already warm-adopted on the warm client (→ sync resolve → plain state → no index). Without
-       this reserve, every async cell declared AFTER a `linked` in the same scope would key
-       off-by-one between sides and adopt the wrong warm seed. Drawing the index here makes a
-       `linked` ALWAYS occupy exactly one ordinal — the invariant `computed` gets for free from its
-       static `isAsyncFunction` routing — so downstream keys align regardless of which path ran. A
-       detached cell (no scope) never warm-seeds, so it draws nothing, mirroring `createAsyncCell`. */
-    const scope = CURRENT_SCOPE.current as (Scope & { nextCellIndex: () => number }) | undefined
-    scope?.nextCellIndex()
-    /* The cell is a plain `state` — same store, same write path, so `transform` gates
-       reseeds and explicit writes identically. */
-    const cell = state<T>(undefined as T, transform)
-    /* Reactive reseed: the effect tracks the seed thunk and writes the cell when its
-       sources change. The cell is only written (its setter reads the store as a plain
-       field, never `readNode`), so it stays off the effect's dependency list — only
-       what `seed` reads can retrigger it. `createEffectNode` registers the disposer
-       with the enclosing scope. */
-    createEffectNode(() => {
-        cell.value = seed() as T
-    })
-    return cell
-}

package/src/lib/ui/navigate.ts

@@ -1,77 +0,0 @@
-import { parseRouteSegments } from '../shared/parseRouteSegments.ts'
-import type { PageRoutes, PathParams } from '../shared/url.ts'
-import { url } from '../shared/url.ts'
-import { historyEntries } from './runtime/historyEntries.ts'
-import { runtimePath } from './runtime/runtimePath.ts'
-
-/* Options for `navigate`. `replace` swaps the current history entry instead of pushing.
-   `keepScroll` carries the live scroll offset onto the destination so it isn't reset. */
-export type NavigateOptions = {
-    replace?: boolean
-    keepScroll?: boolean
-}
-
-/* Writes an ALREADY-RESOLVED path into history + the reactive route. The router uses this
-   for paths it built from a real URL (a clicked link, a popstate, a server redirect) — they
-   already carry the mount base, so they must NOT pass through `url()` again. Each entry
-   carries a monotonic `abideEntry` id so the router can bucket/restore its scroll offset
-   across the page teardown the rebuild does. A push leaves the current entry behind — its
-   scroll is bucketed so back restores it — and mints a fresh id. A replace destroys the
-   current entry and lands fresh content (a redirect), so its saved scroll no longer applies:
-   the bucket is discarded and the id kept, so the new page restores to top/anchor.
-   `keepScroll` opts the destination out of that reset — for an in-page URL swap (e.g.
-   selecting another episode on the same detail page) where a top jump is jarring: the live
-   offset is bucketed under the destination entry id, so the post-rebuild `restore` reapplies
-   it instead of scrolling to top. */
-export function navigatePath(
-    path: string,
-    { replace = false, keepScroll = false }: NavigateOptions = {},
-): void {
-    if (typeof history !== 'undefined') {
-        if (replace) {
-            /* keepScroll buckets the live offset under the (unchanged) entry id so
-               restore reapplies it; otherwise the superseded content drops its bucket. */
-            if (keepScroll) {
-                historyEntries.save()
-            } else {
-                historyEntries.discard()
-            }
-            history.replaceState({ abideEntry: historyEntries.current }, '', path)
-        } else {
-            historyEntries.save()
-            history.pushState({ abideEntry: historyEntries.next() }, '', path)
-            /* Re-bucket the same offset under the freshly minted id so the pushed entry
-               restores to it rather than to top. */
-            if (keepScroll) {
-                historyEntries.save()
-            }
-        }
-    }
-    runtimePath.value = path
-}
-
-/* Navigates to a typed in-app path: a route literal with `[name]` segments takes its params
-   first (`navigate('/p/[id]', { id })`), then options; a paramless or already-interpolated
-   path takes options directly (`navigate('/p', { replace })`). The path is built through
-   `url()` — base-correct, params interpolated — exactly as a link href would be, so a
-   dynamic `/p/${x}` falls through url()'s paramless branch and is base-prefixed too. */
-// @documentation navigate
-export function navigate<P extends keyof PageRoutes | (string & {})>(
-    path: P,
-    ...rest: keyof PathParams<P> extends never
-        ? [options?: NavigateOptions]
-        : [params: PathParams<P>, options?: NavigateOptions]
-): void {
-    /* A path declaring `[name]` segments takes params first, options second — mirroring
-       url()'s own arg discrimination; otherwise the first arg is options. */
-    const hasParams = parseRouteSegments(path).some((segment) => segment.kind === 'param')
-    const [first, second] = rest as [unknown, NavigateOptions?]
-    /* Params ride url()'s first vararg slot — a path with `[name]` segments interpolates
-       them, a paramless one ignores undefined and just base-prefixes. Widen `path` to
-       string so url() takes its plain-path overload; its runtime keys off the segments. */
-    const params = hasParams
-        ? (first as Record<string, string | number | boolean | undefined>)
-        : undefined
-    const options = (hasParams ? second : (first as NavigateOptions | undefined)) ?? {}
-    navigatePath(url(path as string, params), options)
-}

package/src/lib/ui/probeNavigation.ts

@@ -1,33 +0,0 @@
-import { NAV_HEADER } from '../shared/NAV_HEADER.ts'
-import type { NavVerdict } from './runtime/types/NavVerdict.ts'
-
-/*
-The client router's SPA navigation probe: runs `path` through the server's
-app.handle without a render. It's a fetch stamped with NAV_HEADER, which the page
-dispatcher answers 204 once handle() has cleared it — so the round trip pays for
-handle()'s auth/redirect gating, not a server render. fetch follows handle()'s
-redirects server-side, so a redirected response's `url` is the final cleared
-location: same-origin yields a soft client redirect (the router re-probes there),
-cross-origin a full browser load. A non-OK status (handle() blocked it) or a thrown
-fetch (offline) also hands off to the browser, so the server's real response —
-a login page, an error page — is what renders.
-*/
-// @documentation plumbing
-export async function probeNavigation(path: string): Promise<NavVerdict> {
-    let response: Response
-    try {
-        response = await fetch(path, { headers: { [NAV_HEADER]: '1' } })
-    } catch {
-        return { kind: 'reload', url: path }
-    }
-    if (response.redirected) {
-        const target = new URL(response.url)
-        return target.origin === location.origin
-            ? { kind: 'redirect', path: target.pathname + target.search }
-            : { kind: 'reload', url: response.url }
-    }
-    if (!response.ok) {
-        return { kind: 'reload', url: path }
-    }
-    return { kind: 'mount' }
-}

package/src/lib/ui/props.ts

@@ -1,17 +0,0 @@
-/*
-The prop reader. In a `.abide` component the compiler rewrites `const { name } =
-props()` to reads off the component's prop bag (`$props`), so this runtime body
-never executes there — it exists for import resolution and for typing `props()`
-in plain `.ts` modules. Called directly (only possible outside a compiled
-component) it throws, like `request()` outside a request scope, rather than
-silently returning undefined.
-
-The return type is `T` (default `Record<string, unknown>`); inside a `.abide`
-file the check shadow supplies the file-contextual `RouteShape & T` instead.
-*/
-// @documentation reactive-state
-export function props<T = Record<string, unknown>>(): T {
-    throw new Error(
-        '[abide] props() is compiler-lowered inside a .abide component and has no runtime meaning when called directly',
-    )
-}

package/src/lib/ui/remoteProxy.ts

@@ -1,256 +0,0 @@
-import { browserClientFlags } from '../shared/browserClientFlags.ts'
-import { buildRpcRequest } from '../shared/buildRpcRequest.ts'
-import { cacheManagedSlot } from '../shared/cacheManagedSlot.ts'
-import { createRemoteFunction } from '../shared/createRemoteFunction.ts'
-import { HttpError } from '../shared/HttpError.ts'
-import { OFFLINE_HEADER } from '../shared/OFFLINE_HEADER.ts'
-import { rpcTimeoutSlot } from '../shared/rpcTimeoutSlot.ts'
-import { trace } from '../shared/trace.ts'
-import type { CachePolicy } from '../shared/types/CachePolicy.ts'
-import type { HttpMethod } from '../shared/types/HttpMethod.ts'
-import type { OutputWirePlan } from '../shared/types/OutputWirePlan.ts'
-import type { RemoteFunction } from '../shared/types/RemoteFunction.ts'
-import type { RpcOptions } from '../shared/types/RpcOptions.ts'
-import type { StandardSchemaV1 } from '../shared/types/StandardSchemaV1.ts'
-import type { StreamPolicy } from '../shared/types/StreamPolicy.ts'
-import { validationHttpError } from '../shared/validationHttpError.ts'
-import { withBase } from '../shared/withBase.ts'
-import { currentAbortSignal } from './runtime/currentAbortSignal.ts'
-import { REQUEST_SUPERSEDED } from './runtime/REQUEST_SUPERSEDED.ts'
-import { watch } from './watch.ts'
-
-/* The proxy's third argument. ADR-0022 D2: the client rpc transform passes the endpoint's LIVE
-   `opts` object here verbatim, so the type widens to the endpoint opts shape — remoteProxy reads
-   only the keys below and IGNORES the rest (`crossOrigin` / `timeout` / `maxBodySize`), which ride
-   along harmlessly. `streaming: true` (handler returns jsonl()/sse(), build-injected) makes the
-   bare call return the NamedAsyncIterable directly; `cache` / `stream` carry the endpoint's declared
-   policy (ADR-0020) so the client honours the ttl (staleness/SWR), the refetch clock
-   (throttle/debounce), and tags. `schemas` — its live `input` validator now reaches the stub (ADR-0022
-   D2) — drives the ADR-0026 client-side pre-flight. */
-export type RemoteProxyOptions<Args = unknown> = {
-    streaming?: boolean
-    /* The client output wire codec plan (ADR-0029) the resolver plugin baked onto the stub — the
-       handler's structured success fields, so the proxy revives a `Set`/`Map`/`bigint`/`Date` off a
-       decoded response. Absent on the fail-open path (a response array then stays an array). */
-    outputWirePlan?: OutputWirePlan
-    cache?: CachePolicy<Args>
-    stream?: StreamPolicy
-    /* The endpoint's live schema group (ADR-0022 D2 forwards it verbatim). `input` is the
-       Standard Schema the ADR-0026 pre-flight validates the typed args against. */
-    schemas?: {
-        input?: StandardSchemaV1
-        output?: StandardSchemaV1
-        files?: StandardSchemaV1
-    }
-    /* Ignored endpoint opts keys, present only so the author's live `opts` object type-checks
-       when the client transform forwards it verbatim (ADR-0022). `clients` (surface flags) is
-       read only on the server. */
-    clients?: unknown
-    crossOrigin?: unknown
-    timeout?: unknown
-    maxBodySize?: unknown
-}
-
-/*
-Client-side substitute for a rpc-defined handler. The bundler emits one
-call per rpc export inside an `$rpc/**` module (GET / POST / …): server
-target uses defineRpc (real handler), browser target uses remoteProxy
-(fetch over the network). Both paths produce identical RemoteFunction
-shapes and identical WeakMap metadata so cache() works the same on either
-side.
-
-`url` is the flat rpc route. Args go in the JSON body (POST/PUT/PATCH) or
-the query string (GET/DELETE/HEAD). Plain `fn(args)` decodes the Response
-by Content-Type and throws HttpError on non-2xx; `.raw(args)` is the
-escape hatch that returns the Response untouched.
-*/
-// @documentation plumbing
-export function remoteProxy<Args, Return>(
-    method: HttpMethod,
-    url: string,
-    options?: RemoteProxyOptions<Args>,
-): RemoteFunction<Args, Return> {
-    /* ADR-0026 client-side pre-flight: validate the typed args against the endpoint's input
-       schema (forwarded to the stub, ADR-0022 D2) BEFORE the fetch whenever one is present — always
-       on, no opt-in. This is a UX optimization ONLY: the server's unconditional inputSchema validate
-       → 422 (defineRpc.ts `validateThenHandle`) stays the trust boundary, so a client that skips or
-       fakes this check is still fully validated on the server. undefined here (no input schema)
-       keeps today's behaviour — the client serializes and sends unvalidated. */
-    const preflightSchema = options?.schemas?.input
-    const fn = createRemoteFunction<Args, Return>({
-        method,
-        url,
-        clients: browserClientFlags,
-        streaming: options?.streaming ?? false,
-        /* The client revives a decoded response's structured fields through this plan (ADR-0029
-           output path); undefined leaves the honest-JSON body untouched. */
-        outputWirePlan: options?.outputWirePlan,
-        /* Endpoint policy the resolver plugin spliced onto the stub — governs client cache
-           behaviour (ttl/staleness, refetch clock, tags). createRemoteFunction stamps it onto
-           `fn.cache` / `fn.stream` so readThrough reads it as the bottom policy layer. */
-        cache: options?.cache,
-        stream: options?.stream,
-        /*
-        The Request URL carries the mount base so the fetch routes through the
-        proxy (/v2/rpc/…); the cache key keeps the bare `url` (keyForRemoteCall
-        reads fn.url), so SSR snapshots round-trip base-independently.
-        */
-        buildRequest: (args, opts) =>
-            buildRpcRequest({
-                method,
-                url: withBase(url),
-                args,
-                baseUrl: window.location.href,
-                headers: rpcHeaders(opts?.headers),
-            }),
-        /*
-        Forcing `getRequest()` once builds the Request and seeds the cache meta thunk in
-        createRemoteFunction with the same instance, so cache() readers don't reconstruct
-        it.
-        */
-        invoke: (args, getRequest, opts) => {
-            /* ADR-0026 D2/D3: an input schema present → validate the TYPED args (pre-serialization
-               — NOT the string-shaped serialized form, which sidesteps parseArgs's query-coercion
-               gap) before any fetch. The validate may return a Promise (StandardSchemaV1), so await
-               it (D3). On a returned failure throw an HttpError shaped IDENTICALLY to the server's
-               422 (validationHttpError) and make NO fetch — saving the round-trip. */
-            if (preflightSchema !== undefined) {
-                return (
-                    Promise.resolve()
-                        .then(() => preflightSchema['~standard'].validate(args))
-                        .then(
-                            (result) => {
-                                /* A returned `issues` result is a definitive "this input is invalid" —
-                               throw the same 422-shaped HttpError the server would (validationHttpError)
-                               so it rejects the chain and makes NO fetch, saving the round-trip. */
-                                if (result.issues) {
-                                    throw validationHttpError(result.issues)
-                                }
-                            },
-                            () => {
-                                /* A validate REJECTION (not an `issues` verdict) means the validator itself
-                               could not run here (a non-portable / async-resource refinement), which is
-                               NOT a verdict on the input: swallow it and fall through to the fetch, letting
-                               the server (the authoritative validator) decide. So a schema can never break
-                               a call merely by failing to run client-side. */
-                            },
-                        )
-                        /* Fetch exactly ONCE, only after validation settles — outside the validate handlers
-                       so a fetch/timeout rejection propagates to the caller untouched rather than being
-                       mistaken for a "validator couldn't run" fall-through and resending the request. */
-                        .then(() => fetchWithTimeout(getRequest(), opts))
-                )
-            }
-            return fetchWithTimeout(getRequest(), opts)
-        },
-    })
-    /* Overwrite the inert `.watch` the shared attach bound: on the client the real reaction
-       sugar routes to the `watch` ui primitive (`fn.watch(handler)` / `fn.watch(args, handler)`).
-       Attached here — not in the shared attach — so `watch` never rides into a server bundle. */
-    Object.assign(fn, {
-        watch: (argsOrHandler: unknown, handler?: unknown) =>
-            (watch as (source: unknown, a?: unknown, b?: unknown) => () => void)(
-                fn,
-                argsOrHandler,
-                handler,
-            ),
-    })
-    return fn
-}
-
-/*
-Fetches under three optional aborts: the reactive scope that fired the call (so a
-superseded/torn-down read cancels its in-flight request — currentAbortSignal), the
-caller-supplied opts.signal, and the env-configured client timeout
-(ABIDE_CLIENT_TIMEOUT, ms). None present and no transport opts → the unbounded
-fetch, exactly as before. A timeout surfaces as a 504 HttpError so a consumer reads
-an honest status instead of a raw DOMException → 500. Our scope abort (reason
-REQUEST_SUPERSEDED) is swallowed into a never-settling promise: the reactive owner is
-gone, so the result must neither resolve into a dead tree nor surface as a rejection.
-Other rejections (genuine network failure) propagate untouched. The caller's
-keepalive/priority/cache opts pass through to fetch unchanged.
-*/
-function fetchWithTimeout(request: Request, opts?: RpcOptions): Promise<Response> {
-    const timeout = rpcTimeoutSlot.ms
-    const timeoutSignal = timeout === undefined ? undefined : AbortSignal.timeout(timeout)
-    /*
-    A cache-managed flight is shared across readers (cache() owns its lifetime), so a
-    single caller's signal must not abort it for the others — the same opt-out
-    currentAbortSignal makes for the scope signal. keepalive/priority/cache are
-    harmless to keep there.
-    */
-    const callerSignal = cacheManagedSlot.active ? undefined : (opts?.signal ?? undefined)
-    const signal = combineSignals(currentAbortSignal(), callerSignal, timeoutSignal)
-    const init = fetchInit(signal, opts)
-    if (init === undefined) {
-        return fetch(request)
-    }
-    return fetch(request, init).catch((error: unknown) => {
-        if (error === REQUEST_SUPERSEDED) {
-            return new Promise<Response>(() => {})
-        }
-        if (error instanceof DOMException && error.name === 'TimeoutError') {
-            throw new HttpError(
-                new Response('client timeout', { status: 504, statusText: 'Gateway Timeout' }),
-            )
-        }
-        throw error
-    })
-}
-
-/*
-The fetch init from the merged abort signal plus the caller's transport opts
-(keepalive/priority/cache). headers are deliberately absent — they live on the
-Request built in buildRequest, since fetch(request, { headers }) replaces rather than
-merges. undefined when nothing applies, preserving the allocation-free unbounded
-fetch for the common reactive-free call.
-*/
-function fetchInit(signal: AbortSignal | undefined, opts?: RpcOptions): RequestInit | undefined {
-    const init: RequestInit = {}
-    if (signal !== undefined) {
-        init.signal = signal
-    }
-    if (opts?.keepalive !== undefined) {
-        init.keepalive = opts.keepalive
-    }
-    if (opts?.priority !== undefined) {
-        init.priority = opts.priority
-    }
-    if (opts?.cache !== undefined) {
-        init.cache = opts.cache
-    }
-    return Object.keys(init).length === 0 ? undefined : init
-}
-
-/* One AbortSignal merging the scope abort, the caller signal, and the timeout:
-   AbortSignal.any over those present, the lone one when one, undefined when none
-   (the unbounded fetch). */
-function combineSignals(...signals: Array<AbortSignal | undefined>): AbortSignal | undefined {
-    const present = signals.filter((signal): signal is AbortSignal => signal !== undefined)
-    if (present.length <= 1) {
-        return present[0]
-    }
-    return AbortSignal.any(present)
-}
-
-/*
-abide's per-RPC headers, merged onto the caller's opts.headers: the page traceparent
-(continues the server trace) and, only while offline, the offline marker so the
-handler's online() reflects the caller's connectivity. Caller headers go in first and
-the framework's are set last, so a caller adds transport metadata (idempotency-key,
-authorization) but can never overwrite traceparent or the offline marker; content-type
-stays owned by buildRpcRequest. Returns undefined when neither caller nor framework set
-a header, so the allocation-free fetch path stays the common case.
-*/
-function rpcHeaders(callerHeaders?: HeadersInit): Headers | undefined {
-    const headers = new Headers(callerHeaders)
-    const traceparent = trace()
-    if (traceparent) {
-        headers.set('traceparent', traceparent)
-    }
-    /* Presence = offline; absence = online/unknown. navigator.onLine's offline signal is the reliable direction. */
-    if (typeof navigator !== 'undefined' && navigator.onLine === false) {
-        headers.set(OFFLINE_HEADER, '1')
-    }
-    return headers.keys().next().done ? undefined : headers
-}