@abide/abide 0.58.0 → 0.101.0

package/src/lib/shared/types/CacheStore.ts

@@ -1,45 +0,0 @@
-import type { CacheEntry } from './CacheEntry.ts'
-import type { CacheStats } from './CacheStats.ts'
-
-/*
-Cache map paired with a reactive per-key subscriber. Calling
-`subscribe(key)` from inside a tracking scope (derived / effect) registers
-that scope to re-run when the entry is invalidated; called outside tracking
-it's a no-op. Subscribers live for the lifetime of the store: the server
-uses a fresh store per request (so subscribers die with the response), the
-client uses a single module-level store (so subscribers persist for the tab).
-
-`trackLifecycle`/`markLifecycle` are the probes' lifecycle channels, scoped
-by selector prefix. `trackLifecycle(prefix)` taps a channel keyed to that
-fn selector's entries (see selectorPrefix), so a `pending(fn)` reader
-re-derives only when fn's calls change state; `trackLifecycle()` taps the
-store-wide channel — bare and scope selectors scan many entries, so they
-(deliberately) wake on every event. `markLifecycle(key)` — fired whenever a
-call starts, settles, is evicted, or is invalidated — marks the store-wide
-channel plus every probed prefix channel owning `key`.
-*/
-export type CacheStore = {
-    entries: Map<string, CacheEntry>
-    events: EventTarget
-    subscribe: (key: string) => void
-    /* True while a reactive scope is reading `key` (a value held on screen).
-       invalidate() gates its reload marker on this — see pendingRefresh. */
-    hasReader: (key: string) => boolean
-    trackLifecycle: (keyPrefix?: string) => void
-    markLifecycle: (key?: string) => void
-    /*
-    Keys dropped by a (policy-less) invalidate while a reader was holding the
-    value, awaiting their next read. The drop erases the entry, so the next
-    cache() call is a cold miss with no memory it followed an invalidate; this set
-    carries that signal across the gap so the replacement entry is flagged a reload
-    (refreshing() true) rather than a first-ever load. Consumed when that entry is
-    created. Bounded on the long-lived tab store from both ends: a marker is only
-    added when `hasReader(key)` (no on-screen value → the next read is a first
-    load, not a reload, so no marker), and a marker whose reader tears down before
-    re-reading is pruned by the subscriber's cleanup. The server's request-scoped
-    store discards the whole set with the response.
-    */
-    pendingRefresh: Set<string>
-    /* Read tallies for the closing log record + Server-Timing; see CacheStats. */
-    stats: CacheStats
-}

package/src/lib/shared/types/ChannelLog.ts

@@ -1,13 +0,0 @@
-/*
-The log shape a channel returns — the same callable + levels + trace as the
-root logger, every record tagged with the channel name and emitted only when
-DEBUG matches it. Levels are presentation, never gates: a channeled warn is
-yellow when the channel is on and silent when it's off.
-*/
-export type ChannelLog = {
-    (message: string, data?: unknown): void
-    warn(message: string, data?: unknown): void
-    error(value: unknown, data?: unknown): void
-    /* Times `work`, logs `name` with the duration at settle; rethrows failures. */
-    trace<Return>(name: string, work: () => Return | Promise<Return>): Promise<Return>
-}

package/src/lib/shared/types/ClientFlags.ts

@@ -1,13 +0,0 @@
-/*
-Which client surfaces a rpc or socket is exposed to. Browser is the
-historical default. CLI flips on for any rpc or socket with a Standard
-Schema. MCP flips on automatically only for read-only rpcs (GET/HEAD)
-with a schema, and for any socket with a schema — mutating rpcs require
-an explicit clients.mcp even when a schema is present. Explicit values
-always win.
-*/
-export type ClientFlags = {
-    browser: boolean
-    mcp: boolean
-    cli: boolean
-}

package/src/lib/shared/types/CompileTarget.ts

@@ -1,6 +0,0 @@
-export type CompileTarget =
-    | 'bun-darwin-arm64'
-    | 'bun-darwin-x64'
-    | 'bun-linux-arm64'
-    | 'bun-linux-x64'
-    | 'bun-windows-x64'

package/src/lib/shared/types/DebugGate.ts

@@ -1,10 +0,0 @@
-/*
-The two questions a DEBUG string answers for one channel name. `enabled` gates a
-diagnostic channel (inclusion, with exclusions winning); `negated` is the off
-switch for always-on channels (a `-name` pattern silencing the app's own or
-abide's framework voice). Returned by debugGate, already bound to one env value.
-*/
-export type DebugGate = {
-    enabled(name: string): boolean
-    negated(name: string): boolean
-}

package/src/lib/shared/types/DocSnapshots.ts

@@ -1,12 +0,0 @@
-/*
-The per-request list of reactive-document snapshots captured during an SSR render, each keyed by
-its scope's serialization-stable render-path id. A rendered scope registers a lazy `take` at
-creation; the page renderer calls it at render-return (after the synchronous `state` inits have
-run), encodes the non-empty result (ref-json) into `__SSR__.docs`, and the client seeds it so a
-plain `state(initial)` — a uuid, a timestamp — hydrates to the SERVER's value instead of
-recomputing a divergent one. Sibling of `ResolvedCells` (async-cell values); this holds the
-synchronous document state, taken lazily rather than at settle.
-*/
-export type DocSnapshots = {
-    entries: { id: string; take: () => unknown }[]
-}

package/src/lib/shared/types/ErrorJsonSchemas.ts

@@ -1,8 +0,0 @@
-/*
-Status-keyed map of a handler's typed-error data schemas (ADR-0030), baked at build time from the
-handler's `error.typed(name, status, schema?)` return branches. Each key is an HTTP status, each
-value the error's `data` type projected to JSON Schema (multiple errors sharing a status combine
-under `anyOf`; a nullary error with no data contributes a bare `{}`). Feeds the OpenAPI
-`responses[status]` surface — the error-branch sibling of the success `outputJsonSchema`.
-*/
-export type ErrorJsonSchemas = Record<number, Record<string, unknown>>

package/src/lib/shared/types/ErrorSpec.ts

@@ -1,11 +0,0 @@
-import type { StandardSchemaV1 } from './StandardSchemaV1.ts'
-
-/*
-A rpc's error set, keyed by error NAME (not status, so two errors can share a
-status). Each entry names its HTTP `status` and an optional `data` schema whose
-inferred input the error constructor requires. Built at the type level from the
-`error.typed(...)` constructors a handler RETURNS (see `TypedError` +
-`InferredErrors` in RpcHelper); the client's `rpc.isError` narrows `.kind` /
-`.data` off it (see `RpcErrorGuard`).
-*/
-export type ErrorSpec = Record<string, { status: number; data?: StandardSchemaV1 }>

package/src/lib/shared/types/FrameworkLog.ts

@@ -1,13 +0,0 @@
-import type { Log } from './Log.ts'
-
-/*
-The framework's internal voice — the public Log shape bound to the always-on
-'abide' channel, plus the CLI/build styling voices: info (plain message),
-success (green), detail (dim secondary text). Internal only; apps speak
-through their own channel via the public log.
-*/
-export type FrameworkLog = Log & {
-    info(message: string): void
-    success(message: string): void
-    detail(message: string): void
-}

package/src/lib/shared/types/HttpMethod.ts

@@ -1,3 +0,0 @@
-import type { HTTP_METHODS } from '../HTTP_METHODS.ts'
-
-export type HttpMethod = (typeof HTTP_METHODS)[number]

package/src/lib/shared/types/InputCoercion.ts

@@ -1,17 +0,0 @@
-import type { WireKind } from './WireKind.ts'
-
-/*
-The build-time wire codec plan for a rpc's input args, keyed by field name (ADR-0028 for the
-scalar `number`/`boolean` kinds, generalized by ADR-0029 to the structured `date`/`bigint`/`set`/
-`map` kinds). A GET/form request delivers every field as a string, and a non-abide JSON client
-sends a `Date` as an ISO string / a `Set` as an array, so parseArgs uses this plan to revive each
-declared field into the typed value the input schema expects — before validation, on the exact
-fields the author declared. String and other-typed fields are never listed, so a value that merely
-looks numeric (an id, a zip code, `'1.0'`) stays a string. The plan is derived by the warm server
-program from the real type graph and stamped into the server `defineRpc` call; a field is absent
-when its type is anything but a recognized WireKind (or an array / optional thereof), so the codec
-is precise and fail-open — no plan ⇒ today's string-through behavior. The abide client's own
-POST/PUT/PATCH body already round-trips these kinds via ref-json; the plan covers the query-string
-and non-abide-client paths where ref-json isn't in play.
-*/
-export type InputCoercion = Record<string, WireKind>

package/src/lib/shared/types/LastConnection.ts

@@ -1,9 +0,0 @@
-/*
-The launcher/CLI-owned record of the last connection, kept in the data dir so it
-survives relaunch and is readable before any window or session opens. It records
-the *intent*, not a concrete embedded URL — an embedded server picks a fresh port
-each launch, so only `{ kind: 'embedded' }` is durable; a remote connection keeps
-its url. resolveLaunchTarget / resolveCliTarget read it; /connect and /start write
-it; /__abide/disconnect clears it.
-*/
-export type LastConnection = { kind: 'embedded' } | { kind: 'url'; url: string }

package/src/lib/shared/types/Log.ts

@@ -1,13 +0,0 @@
-import type { ChannelLog } from './ChannelLog.ts'
-
-/*
-The public logger: a ChannelLog on the app's own always-on channel (named
-after the app, so every record carries who spoke), plus the factory for
-DEBUG-gated diagnostic channels. Framework voices live on the internal
-abideLog; the closing request record is emitted via internal
-logClosingRecord — neither is part of this surface.
-*/
-export type Log = ChannelLog & {
-    /* Diagnostic channel: same shape, tagged with `name`, emits only when DEBUG matches. */
-    channel(name: string): ChannelLog
-}

package/src/lib/shared/types/LogRecord.ts

@@ -1,42 +0,0 @@
-/*
-One log event, built once per emission and rendered by either formatter
-(tab-separated tsv line or ABIDE_LOG_FORMAT=json). The json rendering of these
-keys is a documented contract — ingestion pipelines (Splunk, Loki) extract
-fields by these names, so renames are breaking changes. Absent context is
-omitted, never null: trace/elapsedMs/method/path exist only inside a request
-scope, status/durationMs only on closing request records, name/spanId only on
-log.trace operation records, stack only when an Error was captured.
-*/
-export type LogRecord = {
-    /* Epoch ms; the json format renders it as an ISO timestamp. */
-    ts: number
-    level: 'info' | 'warn' | 'error'
-    msg: string
-    /* DEBUG-gated diagnostic channel that emitted this record. */
-    channel?: string
-    /* Full 32-hex trace id; tsv mode prints the first 8 chars. */
-    trace?: string
-    /* The emitting request's own trace span id (TraceContext.spanId). Stable across
-       every record one request emits, so a consumer can split a multi-request trace
-       (a propagated session) back into its individual requests. */
-    requestSpan?: string
-    /* The span this request descends from (TraceContext.parentSpanId); absent when
-       abide started the trace — the journey's root request. Lets a consumer nest
-       requests within a trace. */
-    parentSpan?: string
-    /* Ms since the request scope opened (navigation start in the browser). */
-    elapsedMs?: number
-    method?: string
-    path?: string
-    /* Structured payload passed as the second argument. */
-    data?: unknown
-    /* Closing request record: response status + total duration at settle. */
-    status?: number
-    durationMs?: number
-    /* Closing request record: the request's cache read tallies, frozen at settle. */
-    cache?: { hits: number; misses: number; coalesced: number }
-    /* log.trace operation record: chosen operation name + minted span id. */
-    name?: string
-    spanId?: string
-    stack?: string
-}

package/src/lib/shared/types/LogVoice.ts

@@ -1,7 +0,0 @@
-/*
-Presentation hints for the tsv formatter only — the framework's styling
-voices on the 'abide' channel: 'success' paints green, 'detail' dims
-secondary text. Never serialised: the json format renders these records as
-ordinary info lines.
-*/
-export type LogVoice = 'success' | 'detail'

package/src/lib/shared/types/NamedAsyncIterable.ts

@@ -1,26 +0,0 @@
-import type { TailHooks } from './TailHooks.ts'
-
-/*
-A named async stream: an AsyncIterable carrying a stable `name` used as the
-subscription registry key. Both `Socket<T>` (the declared broadcast
-primitive) and a streaming rpc's bare call (a `jsonl`/`sse` handler makes
-the call return the stream itself) satisfy this shape, so the consume path
-(`watch` → `cache.on`) and the stream probes (`pending`/`refreshing`/
-`done`/`error`) handle either source through one contract.
-
-The name on a Socket comes from the file path under `src/server/sockets/`.
-The name on a streaming rpc call is `keyForRemoteCall(method, url, args)` —
-the same key the smart call's cache store uses — so two readers of the same
-remote-call args dedupe to one underlying fetch.
-
-`tail` is the optional retention capability: a source that keeps a tail of
-recent frames hands back an iterable seeded with at most the last `count`
-before going live. Sockets implement it verbatim (it also backs the socket's
-HTTP/SSE read face); one-shot rpc streams omit it. Implementers must signal
-`hooks.replayed` in-band once the seed portion is delivered (even when
-empty) so a seeded reader can commit its window atomically; see TailHooks.
-*/
-export interface NamedAsyncIterable<T> extends AsyncIterable<T> {
-    readonly name: string
-    tail?(count: number, hooks?: TailHooks): AsyncIterable<T>
-}

package/src/lib/shared/types/OutputWirePlan.ts

@@ -1,17 +0,0 @@
-import type { WireKind } from './WireKind.ts'
-
-/*
-The build-time wire codec plan for a rpc's success RESPONSE body, keyed by top-level field name
-(ADR-0029 output path — the response-side sibling of `InputCoercion`). The server serializes a
-handler's structured return through a value-directed replacer (`wireJsonReplacer`), so a `Set`
-crosses as a JSON array, a `Map` as an `[K,V]` entries array, and a `bigint` as a digit string —
-honest JSON a non-abide client still reads. But a wire array is ambiguous (a real `T[]` vs an
-encoded `Set<T>`), so an abide client needs the DECLARED kind to revive: this plan carries only the
-structured kinds (`date`/`bigint`/`set`/`map`) the client proxy revives from a decoded response body.
-It is resolved by the warm server program from the handler's success-body type and baked onto the
-CLIENT `remoteProxy` stub (next to the live `schemas`, ADR-0022 D2). A field absent from the plan (a
-genuine array, a scalar, a `number`/`boolean` JSON already carries) is left untouched. Fail-open —
-no plan / an unrevivable value keeps the honest-JSON form, never a throw. Top-level fields only in
-this increment; a structured value nested inside another value is not descended into.
-*/
-export type OutputWirePlan = Record<string, WireKind>

package/src/lib/shared/types/PageSnapshot.ts

@@ -1,14 +0,0 @@
-/*
-Side-agnostic shape of the active page state: the matched route, its decoded
-params, the live request/location URL, and whether a client SPA navigation is
-in flight. The browser `page` proxy reads its public fields through this; the
-server resolver reads them off the per-request store, the client resolver off
-the module singleton. `navigating` is always false server-side — there is no
-in-flight navigation during a synchronous render.
-*/
-export type PageSnapshot = {
-    route: string
-    params: Record<string, string>
-    url: URL
-    navigating: boolean
-}

package/src/lib/shared/types/PagesScan.ts

@@ -1,7 +0,0 @@
-/* The classification scanPages returns for src/ui/pages: route leaves
-   (page.abide) and layout leaves (layout.abide), each an array of paths
-   relative to the pages dir. */
-export type PagesScan = {
-    pageFiles: string[]
-    layoutFiles: string[]
-}

package/src/lib/shared/types/PendingAsyncCells.ts

@@ -1,10 +0,0 @@
-/*
-The per-request list of in-flight async-cell promises registered during an SSR
-render. `createAsyncCell` pushes each settling promise here (server-side only);
-`settleAsyncCells` drains and awaits them between a component's cell declarations
-and its template, so the resolved values bake into the first-pass HTML (ADR-0019
-Tier-2) instead of the template peeking `undefined`.
-*/
-export type PendingAsyncCells = {
-    promises: Promise<unknown>[]
-}

package/src/lib/shared/types/PromptArgument.ts

@@ -1,12 +0,0 @@
-/*
-A single declared argument of a markdown prompt, parsed from the file's
-YAML frontmatter `arguments:` list. `name` is the placeholder the body
-interpolates via `{{name}}`; `description` + `required` feed the argument
-list MCP advertises in `prompts/list`. Build-time only — markdown prompts
-carry no runtime schema object, so this drives the generated JSON Schema.
-*/
-export type PromptArgument = {
-    name: string
-    description?: string
-    required?: boolean
-}

package/src/lib/shared/types/RawRemoteFunction.ts

@@ -1,20 +0,0 @@
-import type { CachePolicy } from './CachePolicy.ts'
-import type { HttpMethod } from './HttpMethod.ts'
-import type { RemoteCallable } from './RemoteCallable.ts'
-import type { StreamPolicy } from './StreamPolicy.ts'
-
-/*
-Bare-response remote function — same call shape as RemoteFunction but
-resolves to the underlying Response without Content-Type decode and
-without throwing on non-2xx. Produced as `.raw` on every RemoteFunction
-so callers that need status / headers / body streaming or want to
-implement custom error handling can opt out of the decode.
-*/
-export type RawRemoteFunction<Args> = RemoteCallable<Args, Response> & {
-    readonly method: HttpMethod
-    readonly url: string
-    /* Endpoint cache/stream policy (ADR-0020), stamped on this variant too so readThrough can
-       read it whether the caller passed `fn` or `fn.raw`. Same value as the decoded sibling's. */
-    readonly cache?: CachePolicy<Args>
-    readonly stream?: StreamPolicy
-}

package/src/lib/shared/types/RemoteCallable.ts

@@ -1,40 +0,0 @@
-import type { NamedAsyncIterable } from './NamedAsyncIterable.ts'
-import type { RpcOptions } from './RpcOptions.ts'
-
-/*
-Call signature shared by RemoteFunction and RawRemoteFunction. The base
-signature keeps `args` required so a schema'd rpc can't silently drop its
-input; when `Args` admits undefined (no-input rpcs) an intersected
-optional-arg signature lets call sites write `fn()` instead of
-`fn(undefined)`. Intersection rather than a bare conditional so the type
-stays callable while `Args` is still generic (cache() invokes producers
-before `Args` resolves). FormData is the multipart upload escape hatch —
-see RemoteFunction. The trailing `Opts` differs by variant: the smart bare
-call (RemoteFunction) takes no second argument at all (`Opts = never` — all
-cache/stream policy lives on the rpc definition per ADR-0020), while `.raw`
-(RawRemoteFunction) carries per-call transport options (RpcOptions:
-signal/keepalive/priority/cache/headers). The server ignores either, so the
-callable stays isomorphic.
-
-A streaming `Resolved` (an `AsyncIterable<Frame>`, branded by jsonl()/sse()) makes
-the bare call return a `NamedAsyncIterable<Frame>` synchronously — the iterable IS the
-value, consumed by `for await` or `state(fn(args))`, no `.stream()`. Every other
-`Resolved` stays `Promise<Resolved>`. `await`-ing a streaming call is a compile
-error (a NamedAsyncIterable is not awaitable), which replaces the old runtime guard.
-*/
-/* `[Resolved] extends [never]` first: a handler that only ever returns error() resolves to
-   `never`, and `never extends AsyncIterable` is vacuously true — without this guard its call
-   would mistype as a NamedAsyncIterable. A real streaming rpc's `Resolved` is `AsyncIterable<Frame>`. */
-type CallResult<Resolved> = [Resolved] extends [never]
-    ? Promise<Resolved>
-    : Resolved extends AsyncIterable<infer Frame>
-      ? NamedAsyncIterable<Frame>
-      : Promise<Resolved>
-
-export type RemoteCallable<Args, Resolved, Opts = RpcOptions> = ((
-    args: Args | FormData,
-    opts?: Opts,
-) => CallResult<Resolved>) &
-    (undefined extends Args
-        ? (args?: Args | FormData, opts?: Opts) => CallResult<Resolved>
-        : unknown)

package/src/lib/shared/types/RemoteFunction.ts

@@ -1,116 +0,0 @@
-import type { CachePolicy } from './CachePolicy.ts'
-import type { ClientFlags } from './ClientFlags.ts'
-import type { ErrorSpec } from './ErrorSpec.ts'
-import type { HttpMethod } from './HttpMethod.ts'
-import type { RawRemoteFunction } from './RawRemoteFunction.ts'
-import type { RemoteCallable } from './RemoteCallable.ts'
-import type { RpcError } from './RpcError.ts'
-import type { RpcErrorGuard } from './RpcErrorGuard.ts'
-import type { StreamPolicy } from './StreamPolicy.ts'
-
-/*
-Remote function reference produced by GET/POST/... inside an `$rpc/**`
-module and consumed by rpc dispatch, cache(), SSR auto-hydration, and
-direct calls. Same callable signature on server and client — the bundler
-swaps the implementation for browser builds.
-
-The plain call resolves to the decoded body shape (sniffed from
-Content-Type) and throws HttpError on non-2xx. `.raw` is a sibling
-RemoteFunction whose call resolves to the underlying Response — same
-method, same url, same args, no decode. Pass `fn.raw` to cache() to
-memoise raw Responses against the same cache key as `fn` (both share one
-stored entry — the decode just happens on the way out for callers of
-`fn`). A streaming handler (jsonl()/sse()) makes the bare call return a
-`NamedAsyncIterable<Frame>` directly (the iterable IS the value) — consume it with
-`for await (… of fn(args))` or `state(fn(args))`; there is no `.stream()`, and
-`await`-ing a streaming call is a compile error. For sustained broadcast /
-pub-sub use the `abide/server/socket` primitive — HTTP rpc isn't the place for
-long-lived multi-publisher subscriptions.
-`.fetch(req)` is the framework's request-dispatch entry point — used by
-the router to invoke the handler from an incoming HTTP request, not
-for user code.
-`crossOrigin` (server-side only, set via the rpc's opts) exempts a
-mutating rpc from the router's same-origin CSRF gate, accepting browser
-requests whose Origin doesn't match the app's own host.
-*/
-/*
-A body rpc (POST/PUT/PATCH) also accepts a FormData in place of typed args:
-buildRpcRequest ships it as a multipart body and the server splits text fields
-into args (still schema-validated) and File parts into files(). FormData is
-stringly-typed, so this is the upload escape hatch — typed object args remain
-the default for everything else.
-*/
-export type RemoteFunction<
-    Args,
-    Return,
-    Errors extends ErrorSpec = Record<never, never>,
-> = RemoteCallable<Args, Return, never> & {
-    readonly method: HttpMethod
-    readonly url: string
-    readonly clients: ClientFlags
-    readonly crossOrigin?: boolean
-    /* Endpoint cache/stream policy declared on the rpc definition (ADR-0020), stamped
-       here so the smart read (readThrough) reads it as the bottom policy layer. Ships to
-       the client too — it governs client cache behaviour and is behaviour, not secrets
-       (`shared` is a client no-op). Absent on a plainly-defined rpc (method defaults only). */
-    readonly cache?: CachePolicy<Args>
-    readonly stream?: StreamPolicy
-    readonly raw: RawRemoteFunction<Args>
-    fetch(request: Request): Promise<Response>
-    /* Type-guard a caught error against this rpc's declared `errors` (plus the framework
-       `'validation'`): narrows `.kind` and, for a known kind, `.data` — the per-rpc
-       replacement for a global guard, since the error name → data type mapping lives in
-       the rpc's own spec. */
-    readonly isError: RpcErrorGuard<Errors>
-    /* Pre-bound selector sugar: `fn.pending(args?)` ≡ `pending(fn, args?)`, and likewise for
-       refreshing / refresh / invalidate / peek — the rpc is the leading selector, bound in. The
-       argument is this rpc's typed `Args` (the by-args refinement); tags / cross-cutting selection
-       stay on the globals. The bare call `fn(args)` IS the cached read (was `fn.cache`) — all cache
-       policy lives on the definition, so there is no second options argument. The two staleness
-       verbs are distinct again (ADR-0041): `invalidate(args?)` DROPS the entry so the next read
-       reloads lazily, while `refresh(args?)` REFETCHES now keeping the stale value visible — both
-       apply locally on the client and broadcast to every connected client from the server.
-       `peek(args?)` reads the retained value synchronously (a streaming rpc peeks its latest
-       frame). `amend` is fetch-only, so it is omitted for a streaming rpc (a stream isn't a
-       memoized value) via the intersection below. */
-    pending(args?: Args): boolean
-    refreshing(args?: Args): boolean
-    refresh(args?: Args): void
-    invalidate(args?: Args): void
-    peek(args?: Args): ([Return] extends [AsyncIterable<infer Frame>] ? Frame : Return) | undefined
-    /* This rpc's last error, typed off `Errors` (a discriminated union already narrowed on
-       `.kind`/`.data`). `args` scopes to one call; omitted aggregates the most-recent across
-       this rpc. Truthiness is the "isError" check. Instance-only — no bare global (it would
-       shadow the server `error()` thrower). Reads the rpc error registry captured at the call
-       boundary; the cache is untouched. */
-    error(args?: Args): RpcError<Errors> | undefined
-} /* Client-only reaction sugar: `fn.watch(handler)` / `fn.watch(args, handler)` ≡ `watch(fn, …)`
-     — runs the smart read reactively and pipes each resolved value to the handler, returning a
-     scope-tied disposer. Inert no-op server-side (reaction is a ui concern; the real method is
-     attached client-side by remoteProxy). The keyed overload collapses away for a no-input rpc
-     (`undefined extends Args`) — there is no key to scope to (ADR-0043 §5, type-only). */ & (undefined extends Args
-        ? {
-              watch(handler: (value: Return) => void): () => void
-          }
-        : {
-              watch(handler: (value: Return) => void): () => void
-              watch(args: Args, handler: (value: Return) => void): () => void
-          }) /* `amend` is fetch-only: a streaming rpc has no single memoized value to mutate, so the
-     method is present only when `Return` is not an AsyncIterable. The last argument is a
-     replacement `Return` value (broadcastable — ADR-0043) or an updater `(current) => Return`
-     (a local closure). For a keyed rpc the value/updater takes the args key first; the bare
-     `amend(updater)` covers every args-variant (local-only). For a no-input rpc the key
-     collapses away (`amend(value)` / `amend(updater)`). Tuple-wrapped so the conditional
-     doesn't distribute over a `never` Return (an error-only rpc). */ &
-    ([Return] extends [AsyncIterable<unknown>]
-        ? Record<never, never>
-        : undefined extends Args
-          ? {
-                amend(value: Return): void
-                amend(updater: (current: Return) => Return): void
-            }
-          : {
-                amend(args: Args, value: Return): void
-                amend(args: Args, updater: (current: Return) => Return): void
-                amend(updater: (current: Return) => Return): void
-            })

package/src/lib/shared/types/ReplayableMethod.ts

@@ -1,7 +0,0 @@
-/*
-Method of a cache entry that may re-fire unprompted — snapshot replay on the
-client, invalidate-policy refetch. Mirrors REPLAYABLE_METHODS (the runtime
-gate; narrow via isReplayableMethod): only GET qualifies, the one safe
-read-only method.
-*/
-export type ReplayableMethod = 'GET'

package/src/lib/shared/types/RequestScopeInfo.ts

@@ -1,16 +0,0 @@
-import type { TraceContext } from './TraceContext.ts'
-
-/*
-The request-scope facts the shared layer reads through requestScopeSlot:
-trace position, elapsed ms since the scope opened (request start on the
-server, navigation start in the browser), and the method+path that anchors log
-lines. Resolved fresh per read so `elapsedMs` is current at the call.
-*/
-export type RequestScopeInfo = {
-    trace: TraceContext
-    elapsedMs: number
-    method: string
-    path: string
-    /* The calling client's reported connectivity (server only, from OFFLINE_HEADER); drives server-side online(). Omitted client-side — online() reads navigator there. */
-    online?: boolean
-}

package/src/lib/shared/types/ResolvedCells.ts

@@ -1,11 +0,0 @@
-/*
-The per-request list of async-cell values that RESOLVED during an SSR render, each keyed by the
-cell's serialization-stable render-path id (`${scope.id}:${index}`). `createAsyncCell` pushes an
-entry when its seed settles server-side; the page renderer stamps them into `__SSR__.cells`
-(ref-json-encoded) so the client hydrates the cell WARM — reading the value instead of re-running
-the seed (no refetch, no pending flash). The sibling of `PendingAsyncCells` (the barrier's
-in-flight list); this one holds settled VALUES, read at render-return rather than awaited.
-*/
-export type ResolvedCells = {
-    entries: { key: string; value: unknown }[]
-}

package/src/lib/shared/types/ResolverSlot.ts

@@ -1,13 +0,0 @@
-/*
-One resolved runtime value's whole seam: the mutable cell a runtime entry
-registers its resolver into, the single lazy/value fallback used when no
-resolver is registered, and the read. createServer and startClient install
-side-specific resolvers by assigning `.resolver`; isolated tests poke
-`.resolver` / `.fallback` directly, so both fields stay public and mutable.
-*/
-export type ResolverSlot<T> = {
-    resolver: (() => T | undefined) | undefined
-    fallback: T | undefined
-    // The resolved value: the registered resolver's, else the (lazy) fallback.
-    get(): T | undefined
-}

package/src/lib/shared/types/ReturnBody.ts

@@ -1,15 +0,0 @@
-/*
-The build-time success-body descriptor for an rpc, derived from the handler's return type by the
-warm server program (ADR-0030). Mirrors `RpcHelper`'s `SuccessBody<R>` projection: the handler's
-`Awaited<ReturnType>` union has its `TypedError` branches dropped, and each success
-`TypedResponse<Body>` contributes its `Body`. `type` is that body rendered as a TS type string
-(the union of the surviving branches). For a streaming endpoint (`jsonl()`/`sse()` →
-`TypedResponse<AsyncIterable<Frame>>`) `streaming` is true and `type` is the per-FRAME type — the
-AsyncIterable element — so a consumer describes one streamed item rather than the iterable itself.
-The query fails open to undefined (no handler/body resolvable), matching every other server-program
-query.
-*/
-export type ReturnBody = {
-    type: string
-    streaming: boolean
-}

package/src/lib/shared/types/RpcBuildStamps.ts

@@ -1,32 +0,0 @@
-import type { ErrorJsonSchemas } from './ErrorJsonSchemas.ts'
-import type { InputCoercion } from './InputCoercion.ts'
-import type { OutputWirePlan } from './OutputWirePlan.ts'
-
-/*
-The build-time facts the warm rpc server program resolves for one `$rpc/**` handler, gathered into
-a single named payload that `prepareRpcModule` destructures (each rewrite direction picks the fields
-it needs). Replaces a positional argument list where ordering was load-bearing — a new build stamp
-is now one field on this shape rather than a new positional slot every caller must thread. Every
-field is optional: an absent field means the warm program resolved no verdict (no program built, an
-unresolvable node), and the rewrite falls open to its char-scan / today's behaviour exactly as
-before. `streaming` overrides the char-scan streaming verdict; the rest are stamped as server opts
-(`coercion`→`coerce`, `inputSchema`→`inputJsonSchema`, `outputSchema`→`outputJsonSchema`,
-`errorSchemas`→`errorJsonSchemas`) or the client opt (`outputWirePlan`).
-
-`clientKeep` is the reachability plan for the CLIENT rewrite: the source text of the top-level
-statements the emitted client module must retain (imports + declarations transitively reachable from
-the endpoint `opts`), computed through the binder/checker. Present → `rewriteForClient` emits a
-MINIMAL module (`remoteProxy(opts)` plus only those statements), so the handler and every
-declaration/import only it reaches is never emitted — nothing server-side is loaded, tree-shaken, or
-flagged (superseding ADR-0022 D2/D3's "keep the file, trust DCE"). Absent (no warm program /
-unresolvable rpc call) falls open to the keep-the-file char-scan rewrite.
-*/
-export type RpcBuildStamps = {
-    streaming?: boolean
-    coercion?: InputCoercion
-    inputSchema?: Record<string, unknown>
-    outputSchema?: Record<string, unknown>
-    errorSchemas?: ErrorJsonSchemas
-    outputWirePlan?: OutputWirePlan
-    clientKeep?: string[]
-}