@abide/abide 0.58.0 → 0.101.0

package/src/lib/server/rpc/rpcRegistry.ts

@@ -1,11 +0,0 @@
-import type { RpcRegistryEntry } from './types/RpcRegistryEntry.ts'
-
-/*
-Process-wide registry of every rpc-bound RPC declared in the app.
-defineRpc inserts on first construction (which happens at module-load
-time inside the rpc dispatcher cache or eagerly when MCP / CLI walks the
-rpc manifest). MCP server reads this to build its tools list; the CLI
-binary reads it to generate subcommands. The browser path never touches
-this — the client stub has no schema or clients metadata to register.
-*/
-export const rpcRegistry = new Map<string, RpcRegistryEntry>()

package/src/lib/server/rpc/runWithRpcTimeout.ts

@@ -1,58 +0,0 @@
-import { abideLog } from '../../shared/abideLog.ts'
-import { error } from '../error.ts'
-
-/*
-Bounds a rpc handler's execution: races the in-flight `work` against `ms`.
-On the deadline it resolves a 504 — so the caller (an SSR cache read, an
-MCP/CLI invocation, or the network response) is unblocked in time with an
-honest status — and calls `onTimeout` to cancel any
-cooperating outbound work (the network path composes the rpc's deadline into
-request().signal; see defineRpc).
-
-`work` keeps running after the deadline — JS can't cancel a running async
-function, only stop awaiting it — so its eventual settlement is swallowed to
-avoid an unhandled rejection, and a late-resolved streaming Response has its
-body cancelled to release the underlying source. A handler that wants its own
-outbound I/O torn down should pass request().signal to it.
-*/
-export function runWithRpcTimeout(
-    work: Promise<Response>,
-    ms: number,
-    onTimeout: () => void,
-): Promise<Response> {
-    let timedOut = false
-    const deadline = Promise.withResolvers<Response>()
-    const timer = setTimeout(() => {
-        timedOut = true
-        onTimeout()
-        deadline.resolve(error(504, 'handler timeout'))
-    }, ms)
-    return (async () => {
-        try {
-            return await Promise.race([work, deadline.promise])
-        } finally {
-            clearTimeout(timer)
-            if (timedOut) {
-                // The race already returned a 504. Swallow a late rejection, and
-                // cancel a late-resolved streaming Response's body so its source
-                // (DB cursor, file handle) is released rather than leaked.
-                void work.then(
-                    (late) => {
-                        void late.body?.cancel()
-                    },
-                    (rejection) => {
-                        /* The handler outlived its timeout and then rejected. A cooperative
-                           abort (it honoured the composed signal) is expected and stays quiet;
-                           any other error is a genuine handler bug and would otherwise leave
-                           zero server-side trace behind the client's 504 — log it. */
-                        const aborted =
-                            (rejection as { name?: string } | undefined)?.name === 'AbortError'
-                        if (!aborted) {
-                            abideLog.error(rejection)
-                        }
-                    },
-                )
-            }
-        }
-    })()
-}

package/src/lib/server/rpc/types/RemoteHandler.ts

@@ -1,31 +0,0 @@
-import type { TypedResponse } from './TypedResponse.ts'
-
-/*
-Handler signature for rpc-defined remote functions. Args is `undefined` for
-GETs/DELETEs with no query, JSON-shaped objects for json bodies, and
-form-shaped objects for form-encoded bodies. For a multipart upload it's the
-text fields (`inputSchema`) intersected with the validated File parts
-(`filesSchema`), merged into one bag. For a raw binary body Args is `undefined`
-— read the stream via `request()` from `abide/server` instead.
-
-Return is the value type the call site sees after Content-Type-driven
-decoding (a parsed object for JSON, a string for text/*, a Blob otherwise,
-`undefined` for 204). The handler must return a Response at runtime; the
-`TypedResponse<Return>` brand on `json`/`error`/`redirect`/`jsonl`/`sse`
-carries the body shape through the function's inferred return type so the
-rpc helper can infer `Return` automatically — no need to annotate
-`GET<Args, Return>` when the handler returns one of the respond helpers.
-A bare `new Response(...)` is still acceptable: the brand is optional, so
-untagged Responses fall back to `Return = unknown`.
-
-Handlers that need the inbound Request (headers, `request.signal`, …) read
-it via `request()` from `abide/server` rather than a handler parameter, so
-the signature stays a single parsed-`args` bag.
-
-A typed error is raised by returning an `error.typed(name, status, schema?)`
-constructor (`return outOfStock({…})`) — there is no `ctx` param; the rpc reads
-the error surface off the returned constructors' brands.
-*/
-export type RemoteHandler<Args, Return> = (
-    args: Args,
-) => TypedResponse<Return> | Promise<TypedResponse<Return>>

package/src/lib/server/rpc/types/RemoteRoutes.ts

@@ -1,13 +0,0 @@
-import type { RemoteFunction } from '../../../shared/types/RemoteFunction.ts'
-
-/*
-Manifest of RPC URL → module loader. Produced by the resolver plugin from
-every `.ts` under src/server/rpc — each file maps to one URL (derived from its
-path under `$rpc`, prefixed with `/rpc/`). Each module has exactly one
-named export, a RemoteFunction whose `.method` and `.url` were stamped in
-by the bundler rewrite.
-*/
-export type RemoteRoutes = Record<
-    string,
-    () => Promise<Record<string, RemoteFunction<unknown, unknown>>>
->

package/src/lib/server/rpc/types/RpcHelper.ts

@@ -1,185 +0,0 @@
-import type { CachePolicy } from '../../../shared/types/CachePolicy.ts'
-import type { ClientFlags } from '../../../shared/types/ClientFlags.ts'
-import type { ErrorSpec } from '../../../shared/types/ErrorSpec.ts'
-import type { RemoteFunction } from '../../../shared/types/RemoteFunction.ts'
-import type { StandardSchemaV1 } from '../../../shared/types/StandardSchemaV1.ts'
-import type { StreamPolicy } from '../../../shared/types/StreamPolicy.ts'
-import type { TypedError } from './TypedError.ts'
-import type { TypedResponse } from './TypedResponse.ts'
-
-/*
-The success body carried by a handler's return type `R`. Error branches
-(`TypedError`, checked first since they're also Responses) drop to `never` and
-union away, so `Return` is the body of the success `TypedResponse` members alone
-— an untagged `Response` falls back to `unknown`, matching hand-built responses.
-*/
-type SuccessBody<R> =
-    R extends TypedError<string, ErrorSpec[string]>
-        ? never
-        : R extends TypedResponse<infer Body>
-          ? Body
-          : unknown
-
-/*
-The error spec a handler's return type `R` declares — rebuilt name→entry from the
-`TypedError` brands among its branches (distributes over the union; no error
-branches → `{}`). This is what gives `rpc.isError` its typed surface with no
-`errors:` option: the errors a handler RETURNS are the errors it can raise.
-*/
-type ErrorBrand<R> =
-    R extends TypedError<infer Name, infer Entry> ? { name: Name; entry: Entry } : never
-type InferredErrors<R> = { [Brand in ErrorBrand<R> as Brand['name']]: Brand['entry'] }
-
-/*
-The handler every bare (schemaless) overload accepts: any args in, a Response (or a
-Promise of one) out. Collapsing the old `<Args, R>` pair into this single inferred
-function type is deliberate. TypeScript has no partial type-argument inference, so
-`GET<Args>(fn)` used to drop `R` to its `Response` default and silently erase the body
-to `unknown`. With one generic constrained to `RpcFn`, that same call is instead a loud
-`does not satisfy the constraint 'RpcFn'`, and `Args`/`Return`/`Errors` all read
-structurally off the handler — args from its parameter, body + errors from its return —
-which is where a normal TS function declares them anyway (no mainstream rpc framework
-parameterises the call with generics). `any` is load-bearing: `never`/`unknown` in the
-parameter position break return inference by contextually widening the handler's body.
-*/
-type RpcFn = (args: any) => Response | Promise<Response>
-
-/* The handler's declared args: its first parameter, or `undefined` for a nullary handler. */
-type RpcArgs<F extends RpcFn> = Parameters<F> extends [infer Args, ...unknown[]] ? Args : undefined
-
-/*
-The RemoteFunction a bare overload produces from handler `F`. `SuccessBody`/`InferredErrors`
-run over `Awaited<ReturnType<F>>` INLINE (not via an intermediate `extends RpcFn`-constrained
-alias) — such an alias resolves `ReturnType` against the constraint bound and degrades the
-body to `any`.
-*/
-type RpcOf<F extends RpcFn> = RemoteFunction<
-    RpcArgs<F>,
-    SuccessBody<Awaited<ReturnType<F>>>,
-    InferredErrors<Awaited<ReturnType<F>>>
->
-
-/*
-The schema namespace (ADR-0020): `schemas: { input?, output?, files? }` replaces the
-flat `inputSchema`/`outputSchema`/`filesSchema`. `input` drives the handler's arg type,
-`output` is the success-body schema (OpenAPI 200 / MCP outputSchema — never drives arg
-inference), `files` validates multipart File parts. The schema-bearing helper overloads
-tighten specific members to required.
-*/
-type RpcSchemas = {
-    input?: StandardSchemaV1
-    output?: StandardSchemaV1
-    files?: StandardSchemaV1
-}
-
-/*
-Options every rpc overload accepts: the `schemas` namespace, the `clients` surface
-flags (browser/mcp/cli), the same-origin CSRF exemption (`crossOrigin`), the pre-parse
-body-byte ceiling (`maxBodySize`), the per-surface handler `timeout` (ms), and the
-endpoint `cache` policy (ADR-0020). `cache` is shared by both kinds: a mutating rpc
-whose method is a transport choice (a POST that carries a large `code` payload in its
-body yet is a pure function of its args) still coalesces/memoises like a read — the
-runtime already routes `fn.cache` through `readThrough` regardless of method. What stays
-read-only is `stream` (`RpcReadOpts`) — a write has no replayable value to stream.
-Generic over `Args` so `cache.tags`'s `(args) => string[]` form is typed against the
-rpc's own argument shape. The single canonical source both `defineRpc` and
-`RpcRegistryEntry` project from.
-*/
-type RpcSharedOpts<Args> = {
-    schemas?: RpcSchemas
-    clients?: Partial<ClientFlags>
-    crossOrigin?: boolean
-    maxBodySize?: number
-    timeout?: number
-    cache?: CachePolicy<Args>
-}
-
-/*
-Read-helper (GET/HEAD) options: the shared base (including `cache`) plus the endpoint
-`stream` policy (`n`, replay depth) — the one option kind-scoped to replayable reads,
-since a write has no replayable stream. Generic over `Args`, threaded into the shared
-base so `cache.tags`'s `(args) => string[]` form is typed against the rpc's own args.
-*/
-type RpcReadOpts<Args> = RpcSharedOpts<Args> & {
-    stream?: StreamPolicy
-}
-
-/*
-The read helpers (GET/HEAD). The handler's return type is inferred whole
-(`Awaited<ReturnType<F>>`), then split: `SuccessBody` becomes the caller's `Return`,
-`InferredErrors` becomes the rpc's `Errors` (driving `isError`). Typed errors are raised
-by returning an `error.typed(name, status, schema?)` constructor — there is no `errors:`
-opt. Four overloads by argument source (most-specific first):
-
-  - `GET(fn, { schemas: { input, files, output? }, cache?, … })` — multipart upload.
-    The handler receives the text fields (`InferOutput<input>`) intersected with the
-    validated File parts (`InferOutput<files>`); the call site sends a FormData. `files`
-    stays off the JSON-Schema projection (a File has no honest conversion) — only `input`
-    feeds MCP/CLI/OpenAPI. `Args` (the RemoteFunction's call type) is `InferInput<input>`.
-  - `GET(fn, { schemas: { input, output? }, cache?, … })` — `Args` = `InferInput<input>`,
-    the handler receives `InferOutput<input>`. `output` feeds the OpenAPI 200 / MCP tool
-    outputSchema and never drives arg inference.
-  - `GET(fn, opts)` — schemaless-with-opts (includes `schemas: { output }`-only): args
-    read off the handler `F`. `cache`/`clients`/`timeout`/… live here.
-  - `GET(fn)` — bare handler; everything reads off `F`: `Args` from its parameter, `Return`
-    from the `TypedResponse<T>` brand, `Errors` from any `error.typed(...)` branches. You
-    never pass `<Args, Return>` generics; a stray one is a loud constraint error.
-*/
-export type RpcHelper = {
-    <
-        R extends Response,
-        InputSchema extends StandardSchemaV1 = StandardSchemaV1,
-        FilesSchema extends StandardSchemaV1 = StandardSchemaV1,
-    >(
-        fn: (
-            args: StandardSchemaV1.InferOutput<InputSchema> &
-                StandardSchemaV1.InferOutput<FilesSchema>,
-        ) => R | Promise<R>,
-        opts: RpcReadOpts<StandardSchemaV1.InferInput<InputSchema>> & {
-            schemas: { input: InputSchema; files: FilesSchema; output?: StandardSchemaV1 }
-        },
-    ): RemoteFunction<StandardSchemaV1.InferInput<InputSchema>, SuccessBody<R>, InferredErrors<R>>
-    <R extends Response, InputSchema extends StandardSchemaV1 = StandardSchemaV1>(
-        fn: (args: StandardSchemaV1.InferOutput<InputSchema>) => R | Promise<R>,
-        opts: RpcReadOpts<StandardSchemaV1.InferInput<InputSchema>> & {
-            schemas: { input: InputSchema; output?: StandardSchemaV1 }
-        },
-    ): RemoteFunction<StandardSchemaV1.InferInput<InputSchema>, SuccessBody<R>, InferredErrors<R>>
-    <F extends RpcFn>(fn: F, opts: RpcReadOpts<RpcArgs<F>>): RpcOf<F>
-    <F extends RpcFn>(fn: F): RpcOf<F>
-}
-
-/*
-The mutating helpers (POST/PUT/PATCH/DELETE). The base opts is the shared `RpcSharedOpts`,
-which carries `cache` — a mutating rpc still accepts a cache policy (a POST that is a pure
-function of its args, using the body only to carry a large payload, coalesces/memoises like
-a read; the runtime honours `fn.cache` regardless of method). Note the method default for a
-write stays coalesce-only: a no-ttl write is dropped on settle (the mutation idiom), so
-retention across the in-flight window needs an explicit `cache.ttl` (or `shared`). Only
-`stream` stays read-only (`RpcReadOpts`) — a write has no replayable stream — so `POST(fn,
-{ stream })` remains a compile error while `POST(fn, { cache })` is legal. Overloads mirror
-the read helpers by argument source (multipart-upload, schema'd, schemaless-with-opts, bare).
-*/
-export type MutatingRpcHelper = {
-    <
-        R extends Response,
-        InputSchema extends StandardSchemaV1 = StandardSchemaV1,
-        FilesSchema extends StandardSchemaV1 = StandardSchemaV1,
-    >(
-        fn: (
-            args: StandardSchemaV1.InferOutput<InputSchema> &
-                StandardSchemaV1.InferOutput<FilesSchema>,
-        ) => R | Promise<R>,
-        opts: RpcSharedOpts<StandardSchemaV1.InferInput<InputSchema>> & {
-            schemas: { input: InputSchema; files: FilesSchema; output?: StandardSchemaV1 }
-        },
-    ): RemoteFunction<StandardSchemaV1.InferInput<InputSchema>, SuccessBody<R>, InferredErrors<R>>
-    <R extends Response, InputSchema extends StandardSchemaV1 = StandardSchemaV1>(
-        fn: (args: StandardSchemaV1.InferOutput<InputSchema>) => R | Promise<R>,
-        opts: RpcSharedOpts<StandardSchemaV1.InferInput<InputSchema>> & {
-            schemas: { input: InputSchema; output?: StandardSchemaV1 }
-        },
-    ): RemoteFunction<StandardSchemaV1.InferInput<InputSchema>, SuccessBody<R>, InferredErrors<R>>
-    <F extends RpcFn>(fn: F, opts: RpcSharedOpts<RpcArgs<F>>): RpcOf<F>
-    <F extends RpcFn>(fn: F): RpcOf<F>
-}

package/src/lib/server/rpc/types/RpcRegistryEntry.ts

@@ -1,50 +0,0 @@
-import type { ErrorJsonSchemas } from '../../../shared/types/ErrorJsonSchemas.ts'
-import type { RemoteFunction } from '../../../shared/types/RemoteFunction.ts'
-import type { StandardSchemaV1 } from '../../../shared/types/StandardSchemaV1.ts'
-
-/*
-Per-rpc registry record on the server side. MCP and CLI enumerate this
-to discover what shapes an rpc expects/returns. The schemas stay off the
-public RemoteFunction shape so the browser-side proxy doesn't need to carry
-server-only state; the resolved `clients` and `crossOrigin` ride on
-`entry.remote` (ADR-0020 sweep finding #4 — no duplicate fields), so readers
-reach them via `entry.remote.clients` / `entry.remote.crossOrigin`.
-
-`inputSchema` validates the argument bag and feeds the MCP tool
-`inputSchema` / OpenAPI parameters; `outputSchema` describes the success
-body and feeds the OpenAPI 200 response + MCP tool `outputSchema`. Each
-projects to JSON Schema via its own `toJSONSchema()` (jsonSchemaForSchema) —
-schemas whose library lacks one are wrapped with withJsonSchema.
-
-`filesSchema` validates the File parts of a multipart body, kept separate
-from `inputSchema` because a File has no honest JSON-Schema conversion — it
-stays out of the MCP/CLI projection that `inputSchema` feeds, and the OpenAPI
-multipart body advertises the file parts generically as binary.
-*/
-export type RpcRegistryEntry = {
-    remote: RemoteFunction<unknown, unknown>
-    inputSchema: StandardSchemaV1 | undefined
-    /* The handler's input args projected to JSON Schema at build time (ADR-0030 input side) — the
-       input surface's fallback when no `inputSchema` VALIDATOR is declared, mirroring how
-       `outputJsonSchema` backs the output surface. Already JSON Schema (not a validator), so surfaces
-       use it verbatim; `inputSchema`, when present, overrides it. It also makes the endpoint
-       advertisable (MCP/CLI) — the same role a declared `inputSchema` plays — but purely as a SHAPE
-       description: it is never run as runtime validation, so it can't produce a 422. */
-    inputJsonSchema: Record<string, unknown> | undefined
-    outputSchema: StandardSchemaV1 | undefined
-    /* The handler's return type projected to JSON Schema at build time (ADR-0030 D2) — the output
-       surface's fallback when no `outputSchema` VALIDATOR is declared. Already JSON Schema (not a
-       validator), so surfaces use it verbatim; `outputSchema`, when present, overrides it. */
-    outputJsonSchema: Record<string, unknown> | undefined
-    /* The handler's typed-error branches projected to a status-keyed JSON-Schema map at build time
-       (ADR-0030) — each `error.typed(...)` return branch's status + `data` payload. Feeds the OpenAPI
-       `responses[status]` entries alongside the 200; undefined when the handler declares no typed
-       errors or the build couldn't resolve them, so the surface omits the error responses. */
-    errorJsonSchemas: ErrorJsonSchemas | undefined
-    filesSchema: StandardSchemaV1 | undefined
-    /* The rpc's declared opts, recorded so introspection (inspector) can report
-       the deadline/body-cap a handler runs under. Undefined = the framework default
-       (no deadline, Bun's server-wide body ceiling). */
-    timeout: number | undefined
-    maxBodySize: number | undefined
-}

package/src/lib/server/rpc/types/TypedError.ts

@@ -1,18 +0,0 @@
-import type { ErrorSpec } from '../../../shared/types/ErrorSpec.ts'
-
-/*
-A `Response` branded with the typed error a handler RETURNED — the name it
-travels as (`$abideError`) plus its spec entry (`{ status, data? }`). The rpc
-helper reads this brand off the handler's inferred return union to build the
-function's `Errors` surface, so `rpc.isError(e, 'name')` narrows `.kind` / `.data`
-with no `errors:` option to declare.
-
-Unlike `TypedResponse`'s `__body?` (optional, so a bare `new Response()` stays
-assignable), the brand here is REQUIRED: it's the discriminant that tells the
-helper an error branch from a success branch (the success body is extracted from
-the non-error members, the error spec from these). The runtime value is a plain
-serialized Response cast to this type — the brand is phantom, never assigned.
-*/
-export type TypedError<Name extends string, Entry extends ErrorSpec[string]> = Response & {
-    readonly __abideError: { name: Name; entry: Entry }
-}

package/src/lib/server/rpc/types/TypedResponse.ts

@@ -1,18 +0,0 @@
-/*
-A `Response` tagged with the body type the framework will hand back to
-callers after Content-Type-driven decoding. The tag is phantom — it
-adds no runtime field, only a type-level slot so the rpc helpers can
-infer `Return` from the handler's return type instead of forcing every
-route to annotate it via `GET<Args, Return>`.
-
-The respond helpers (`json<T>`, `error`, `redirect`, `jsonl<F>`,
-`sse<F>`) all return a `TypedResponse<T>`, so a handler ending in
-`return json({ user })` exposes `{ user: ... }` as its body type; the
-rpc overload picks it up via `RemoteHandler<Args, Return>`.
-
-`T` is optional on the brand so a plain `new Response(...)` (untagged)
-remains assignable to `TypedResponse<unknown>`; in that case `Return`
-just falls back to its `unknown` default, matching pre-existing
-behaviour for handlers that build Responses by hand.
-*/
-export type TypedResponse<T> = Response & { readonly __body?: T }

package/src/lib/server/rpc/unprocessed.ts

@@ -1,13 +0,0 @@
-/*
-Rpc helpers (GET / POST / …) are placeholders — the bundler rewrites every
-`export const x = GET(fn)` inside `src/server/rpc/<file>.ts` into a call to
-defineRpc (server target) or remoteProxy (client target). If a call slips
-through, the bundler plugin didn't process the file; throwing here surfaces
-that cleanly instead of silently returning undefined. Returns `never` (it always
-throws), so a helper's arrow satisfies every overload of RpcHelper/MutatingRpcHelper.
-*/
-export function unprocessed(method: string): never {
-    throw new Error(
-        `[abide] \`${method}\` was called outside an $rpc module — rpc helpers are only valid as the value of \`export const <filename> = ...\` inside a file under src/server/rpc/`,
-    )
-}

package/src/lib/server/rpc/validationError.ts

@@ -1,17 +0,0 @@
-import { fieldErrorsFromIssues } from '../../shared/fieldErrorsFromIssues.ts'
-import type { StandardSchemaV1 } from '../../shared/types/StandardSchemaV1.ts'
-import type { ValidationErrorData } from '../../shared/types/ValidationErrorData.ts'
-import { typedErrorResponse } from '../runtime/typedErrorResponse.ts'
-
-/*
-The framework-reserved `validation` typed error a 422 carries: the raw Standard
-Schema `issues` plus the form-friendly field → first-message map. Routed through
-the shared `typedErrorResponse` serializer so it emits the same
-`{ $abideError, data }` body every typed error uses, and so the 422's reason
-phrase reaches `HttpError.statusText`. The client parses it back onto
-`HttpError.kind = 'validation'` / `.data: ValidationErrorData`.
-*/
-export function validationError(issues: readonly StandardSchemaV1.Issue[]): Response {
-    const data: ValidationErrorData = { issues, fields: fieldErrorsFromIssues(issues) }
-    return typedErrorResponse('validation', 422, data)
-}

package/src/lib/server/runtime/DEFAULT_PORT.ts

@@ -1,6 +0,0 @@
-/*
-The port scanning starts from when no PORT is configured. Every selector (the
-real listener, the embedded launcher, the dev orchestrator) scans upward from
-here so all modes land on the same predictable 3000+ address.
-*/
-export const DEFAULT_PORT = 3000

package/src/lib/server/runtime/DEV_READY_MESSAGE.ts

@@ -1,6 +0,0 @@
-// IPC payload the dev server sends its orchestrator parent (via process.send)
-// once its listener is up and init() has run. The orchestrator retires the
-// previous worker only after this arrives — workers overlap on the dev port via
-// reusePort, so the port never goes dark across a restart. Shared so producer
-// (createServer) and consumer (devEntry) can't drift.
-export const DEV_READY_MESSAGE = 'abide:ready'

package/src/lib/server/runtime/DEV_REBUILD_MESSAGE.ts

@@ -1,4 +0,0 @@
-// IPC payload the dev server sends its orchestrator parent (via process.send) to
-// request a rebuild + restart. Shared so producer (createServer) and consumer
-// (devEntry) can't drift.
-export const DEV_REBUILD_MESSAGE = 'abide:reload'

package/src/lib/server/runtime/DEV_RELOAD_CLIENT_SCRIPT.ts

@@ -1,92 +0,0 @@
-/*
-Dev-only live-reload client, injected into the served shell when the server
-runs under `abide dev`. It opens an EventSource to /__abide/dev; each
-connection's first event carries the worker's reload stamp — `{ structure,
-cssHref }` (devClientFingerprint). The channel only drops when the dev
-orchestrator swaps the server after a rebuild, and on reconnect:
-  - `structure` changed → reload (any non-CSS edit).
-  - only `cssHref` changed → swap the entry stylesheet's `<link>` in place,
-    so a CSS edit restyles the live page with no reload and no state loss.
-  - both equal (server-only edit) → keep the page alive.
-Self-managed retry keeps the first reconnect fast (250ms) so a rebuild swap
-recovers quickly, then backs off exponentially up to a 5s cap — a server that
-stays down (dev stopped) settles to one attempt every 5s instead of flooding
-the network, and still reconnects on its own if the server comes back. The
-backoff resets once a connection opens.
-
-Hidden tabs hold no connection: the channel closes on `visibilitychange:
-hidden` and reopens on visible, where the reconnect's first event carries
-whatever the current worker announces — a rebuild that happened while the tab
-slept still reloads it. The initial connect runs even when the page loads
-hidden (the baseline must be the serving worker's stamp, captured before a swap
-can replace it) and releases itself once that first event lands.
-*/
-import { DEV_RELOAD_PATH } from '../../shared/DEV_RELOAD_PATH.ts'
-
-export const DEV_RELOAD_CLIENT_SCRIPT = `<script>
-;(() => {
-  let stamp
-  let source
-  let retryTimer
-  let retryDelay = 250
-  function disconnect() {
-    clearTimeout(retryTimer)
-    if (source) {
-      source.close()
-      source = undefined
-    }
-  }
-  function swapCss(href) {
-    const links = document.querySelectorAll('link[rel="stylesheet"]')
-    for (const link of links) {
-      const current = link.getAttribute('href') || ''
-      if (current.indexOf('/_app/') !== -1 && current.slice(-4) === '.css') {
-        link.href = href
-        return
-      }
-    }
-  }
-  function connect() {
-    if (source) {
-      return
-    }
-    source = new EventSource('${DEV_RELOAD_PATH}')
-    source.onopen = () => {
-      retryDelay = 250
-    }
-    source.onmessage = (event) => {
-      const next = JSON.parse(event.data)
-      if (stamp === undefined) {
-        stamp = next
-        if (document.hidden) {
-          disconnect()
-        }
-        return
-      }
-      if (next.structure !== stamp.structure) {
-        location.reload()
-        return
-      }
-      if (next.cssHref && next.cssHref !== stamp.cssHref) {
-        swapCss(next.cssHref)
-      }
-      stamp = next
-    }
-    source.onerror = () => {
-      disconnect()
-      if (!document.hidden) {
-        retryTimer = setTimeout(connect, retryDelay)
-        retryDelay = Math.min(retryDelay * 2, 5000)
-      }
-    }
-  }
-  document.addEventListener('visibilitychange', () => {
-    if (document.hidden) {
-      disconnect()
-    } else {
-      connect()
-    }
-  })
-  connect()
-})()
-</script>`

package/src/lib/server/runtime/SSR_SWAP_SCRIPT.ts

@@ -1,19 +0,0 @@
-/*
-The tiny inline script the abide-ui SSR stream ships in <head>. For each streamed
-`<abide-resolve data-id>` frame it reads the leading `<script type=application/json>`,
-stores its raw ref-json text into `window.__abideSeeds.resume` (the resume partition of the
-one seed manifest, ADR-0048 — the store hydration
-reads, decoding each entry at read time) and swaps the resolved markup into the matching
-`<!--abide:await:ID-->…<!--/abide:await:ID-->` boundary — so the pending shell paints
-instantly and each value lands as it arrives, before the client bundle even loads. It
-stores the text undecoded precisely because it's vanilla and self-contained — no framework
-runtime, hence no ref-json decoder; the bundle decodes on read. Minified to one line so it
-inlines cheaply ahead of the document body.
-*/
-export const SSR_SWAP_SCRIPT =
-    "function __abideSwap(){var f=document.querySelector('abide-resolve');while(f){" +
-    "var id=f.getAttribute('data-id'),p=f.firstChild,w=document.createTreeWalker(document.body,NodeFilter.SHOW_COMMENT),o=null,c;" +
-    "if(p&&p.nodeName==='SCRIPT'){var s=window.__abideSeeds=window.__abideSeeds||{};(s.resume=s.resume||{})[id]=p.textContent||'';p.remove();}" +
-    "while((c=w.nextNode())){if(c.data==='abide:await:'+id){o=c;break;}}" +
-    "if(o){var n=o.nextSibling;while(n&&!(n.nodeType===8&&n.data==='/abide:await:'+id)){var x=n.nextSibling;n.remove();n=x;}" +
-    "while(f.firstChild){o.parentNode.insertBefore(f.firstChild,n);}}f.remove();f=document.querySelector('abide-resolve');}}"

package/src/lib/server/runtime/STATUS_TEXT.ts

@@ -1,22 +0,0 @@
-/*
-Standard reason phrases for the statuses abide sets explicitly. Bun's `Response`
-does not populate `statusText` from the status code, so there's no platform table
-to read. Unlisted codes fall back to `HTTP <status>` at the call site.
-*/
-export const STATUS_TEXT: Record<number, string> = {
-    400: 'Bad Request',
-    401: 'Unauthorized',
-    403: 'Forbidden',
-    404: 'Not Found',
-    405: 'Method Not Allowed',
-    409: 'Conflict',
-    410: 'Gone',
-    413: 'Content Too Large',
-    422: 'Unprocessable Content',
-    429: 'Too Many Requests',
-    500: 'Internal Server Error',
-    501: 'Not Implemented',
-    502: 'Bad Gateway',
-    503: 'Service Unavailable',
-    504: 'Gateway Timeout',
-}

package/src/lib/server/runtime/STREAMED_HTML_HEADER.ts

@@ -1,13 +0,0 @@
-/*
-Internal response-header marker the streaming SSR renderer stamps on its
-progressively-flushed `text/html` document. `gzipResponse` reads it to pick a
-per-chunk-flushing gzip over the buffering web CompressionStream (then strips it
-before send): a plain CompressionStream holds the head until its deflate window
-flushes, defeating progressive delivery — the browser can't preload-scan the head
-or paint the pending shell until the stream nearly closes. A streamed `text/html`
-body is otherwise indistinguishable from a buffered one (both expose a
-ReadableStream), and `isStreamingResponse` can't be widened to cover it without
-also opting these pages out of the idle-timeout cap they rely on (see
-disableIdleTimeoutForStream).
-*/
-export const STREAMED_HTML_HEADER = 'abide-streamed-html'

package/src/lib/server/runtime/acceptsGzip.ts

@@ -1,33 +0,0 @@
-/*
-Whether the client advertised gzip in Accept-Encoding. The static-asset
-servers and the dynamic-response gzip wrapper gate compressed output on this,
-so the check lives in one place. Effectively always true for browsers and most
-HTTP clients; a bare client that omits the header gets identity bytes.
-*/
-export function acceptsGzip(req: Request): boolean {
-    const header = (req.headers.get('accept-encoding') ?? '').toLowerCase()
-    /*
-    Honour q-values: `gzip;q=0` is an explicit refusal even though the substring
-    is present. Find the gzip (or wildcard) directive and reject only when its
-    quality is zero.
-    */
-    const directives = header.split(',').map((part) => part.trim())
-    // An explicit gzip directive wins over the wildcard; fall back to `*` otherwise.
-    const directive =
-        directives.find((part) => part === 'gzip' || part.startsWith('gzip;')) ??
-        directives.find((part) => part === '*' || part.startsWith('*;'))
-    if (directive === undefined) {
-        return false
-    }
-    const quality = directive.match(/;\s*q=([\d.]+)/)
-    if (quality === null) {
-        return true
-    }
-    /*
-    A malformed q (e.g. `q=.` → NaN) is not an explicit refusal — fall back to
-    the default-accept path, matching how an absent q is treated. Only a parsed
-    quality of exactly 0 denies compression.
-    */
-    const parsed = Number(quality[1])
-    return Number.isNaN(parsed) || parsed > 0
-}