@abide/abide 0.58.0 → 0.100.0

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

@@ -1,26 +0,0 @@
-import type { HttpError } from '../HttpError.ts'
-import type { ErrorSpec } from './ErrorSpec.ts'
-import type { StandardSchemaV1 } from './StandardSchemaV1.ts'
-
-/* Payload a declared error name carries: its data schema's inferred input, or `unknown`
-   for a nullary error (no data schema) — mirrors RpcErrorGuard's DeclaredErrorData. */
-type DeclaredData<
-    Errors extends ErrorSpec,
-    Name extends keyof Errors,
-> = Errors[Name]['data'] extends StandardSchemaV1
-    ? StandardSchemaV1.InferInput<Errors[Name]['data']>
-    : unknown
-
-/*
-The typed error value `fn.error()` returns: the discriminated union of this rpc's declared
-errors (name → data), each an HttpError narrowed on `.kind` / `.data`. The read-side mirror
-of RpcErrorGuard's narrowing, as a value rather than a guard — so `getUser.error()?.name`
-is already narrowed with no guard call. `never` (collapses to `undefined`-only at the call
-site) for an rpc that declares no errors.
-*/
-export type RpcError<Errors extends ErrorSpec> = {
-    [Name in keyof Errors & string]: HttpError & {
-        kind: Name
-        data: DeclaredData<Errors, Name>
-    }
-}[keyof Errors & string]

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

@@ -1,35 +0,0 @@
-import type { HttpError } from '../HttpError.ts'
-import type { ErrorSpec } from './ErrorSpec.ts'
-import type { StandardSchemaV1 } from './StandardSchemaV1.ts'
-import type { ValidationErrorData } from './ValidationErrorData.ts'
-
-/* The payload a declared error name carries: its data schema's inferred input, or
-   `unknown` for a nullary error (no data schema). */
-type DeclaredErrorData<
-    Errors extends ErrorSpec,
-    Name extends keyof Errors,
-> = Errors[Name]['data'] extends StandardSchemaV1
-    ? StandardSchemaV1.InferInput<Errors[Name]['data']>
-    : unknown
-
-/*
-A rpc's `isError` guard — branch a caught error on a kind THIS rpc knows, with the
-data type narrowed from the rpc's own `errors` spec. `rpc.isError(err, 'outOfStock')`
-narrows `.data` to that error's payload; the framework-reserved `'validation'` to its
-fixed shape; any other string narrows `.kind` only (`.data` stays `unknown` — it
-belongs to a different rpc, whose type isn't in scope here).
-
-The declared-name overload comes first so an app error shadows the reserved ones on a
-name collision, and so the kind argument autocompletes to the rpc's declared names.
-*/
-export interface RpcErrorGuard<Errors extends ErrorSpec> {
-    <Name extends keyof Errors & string>(
-        error: unknown,
-        kind: Name,
-    ): error is HttpError & { kind: Name; data: DeclaredErrorData<Errors, Name> }
-    (
-        error: unknown,
-        kind: 'validation',
-    ): error is HttpError & { kind: 'validation'; data: ValidationErrorData }
-    <Kind extends string>(error: unknown, kind: Kind): error is HttpError & { kind: Kind }
-}

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

@@ -1,6 +0,0 @@
-/* A rpc invoker mirrors the rpc's own call: a plain call decodes the body
-   (throws HttpError on non-2xx), `.raw` returns the Response untouched. Shared
-   by every name→callable RPC proxy (the CLI client, the test harness). */
-export type RpcInvoker = ((args?: unknown) => Promise<unknown>) & {
-    raw: (args?: unknown) => Promise<Response>
-}

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

@@ -1,22 +0,0 @@
-/*
-Per-call transport options for a remote function — a curated slice of RequestInit,
-not the whole thing. Only fields the server handler never observes are exposed, so
-the call stays isomorphic (same behaviour both sides) and a caller can't clobber the
-method, body, or framework headers the RPC contract owns.
-
-- `signal` merges with the scope abort + client timeout (AbortSignal.any), never
-  replacing them; under cache() it's ignored so one reader can't abort a coalesced
-  flight the others share.
-- `keepalive` lets a small fire-and-forget write survive page unload (the browser
-  caps the total keepalive body at ~64KB).
-- `priority` is a fetch scheduling hint; ignored where unsupported.
-- `cache` is the browser HTTP cache mode (distinct from abide's own cache()).
-- `headers` are MERGED onto the framework headers, which win — a caller adds
-  transport metadata (idempotency-key, authorization) but can't overwrite
-  traceparent/content-type/offline. Application data still belongs in `args` (the
-  only schema-validated channel); headers bypass validation.
-*/
-export type RpcOptions = Pick<
-    RequestInit,
-    'signal' | 'keepalive' | 'priority' | 'cache' | 'headers'
->

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

@@ -1,54 +0,0 @@
-import type { CacheOnContext } from './CacheOnContext.ts'
-import type { ClientFlags } from './ClientFlags.ts'
-import type { TailHooks } from './TailHooks.ts'
-
-/*
-Bidirectional named broadcast primitive. Declared once with `socket<T>()`
-inside a file under `src/server/sockets/`; the same import resolves to a server-side
-fan-out and a client-side ws proxy by build target. Iterating the socket
-is the live stream — no replay. `.tail(count)` opens a subscription seeded
-with the last `count` frames of the retained tail (declared via
-`{ tail: n }`; no-arg = the whole retained tail) before going live — the
-optional NamedAsyncIterable retention capability a reactive `watch(socket, …)`
-seeds from. `publish` is isomorphic: server code publishes in-process
-and fans out to remote subscribers; client code sends a `pub` frame the
-dispatcher validates against the topic's `clientPublish` flag. `clients`
-exposes which adapter surfaces (browser / mcp / cli) advertise this
-socket.
-*/
-export interface Socket<T> extends AsyncIterable<T> {
-    readonly name: string
-    readonly clients: ClientFlags
-    /* Send a frame to every subscriber (server always; client only when `clientPublish` is
-       set). Isomorphic: server code fans out in-process + to remote subscribers; client code
-       sends a validated `pub` frame. Mirrors Bun's `server.publish()`. */
-    publish(message: T): void
-    tail(count?: number, hooks?: TailHooks): AsyncIterable<T>
-    /* The latest retained frame, synchronously — `T | undefined` when none. The value
-       member of the probe family for a stream; `peek(socket)` routes here. */
-    peek(): T | undefined
-    /* Reactive probe sugar mirroring the rpc instance — the socket is the pre-bound stream
-       selector: `socket.pending()` ≡ `pending(socket)` (no frame yet), `socket.refreshing()` ≡
-       `refreshing(socket)` (a held frame revalidating, e.g. across a reconnect gap),
-       `socket.done()` ≡ `done(socket)` (the stream closed). Client-reactive; on the server (and
-       the raw test builder) they read the same fallbacks the globals give with no tail prober
-       registered (pending true until a frame, refreshing/done false). */
-    pending(): boolean
-    refreshing(): boolean
-    done(): boolean
-    /* The stream's terminal error, or undefined. Instance-only — like the rpc's `.error`, since a
-       bare `error` global would shadow the server `error()` thrower. Reactive off the tail prober's
-       error field; undefined on the server. */
-    error(): Error | undefined
-    /* Drop local frames and re-pull the server's retained tail — the socket analog of
-       getFoo.refresh(), for a ttl-expired frame or a reconnect resync. Server-side it is a
-       no-op (the server IS the source). */
-    refresh(): void
-    /* Client-only reaction sugar: `socket.watch(handler)` ≡ `watch(socket, handler)` — the
-       handler runs per delivered frame with reconnect-replay and returns a scope-tied disposer.
-       Reaction is a client concern (`watch` is a ui primitive that never rides into a server
-       bundle), so server-side — and in the raw test builder — this is an inert no-op like
-       `.refresh`; the SSR effect-strip leaves member calls intact, so an author `socket.watch(…)`
-       reaching the server is a safe no-op. The real method is attached client-side by socketProxy. */
-    watch(handler: (frame: T, context: CacheOnContext) => void | Promise<void>): () => void
-}

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

@@ -1,17 +0,0 @@
-import type { SocketSubCallbacks } from './SocketSubCallbacks.ts'
-
-/* The multiplexed-ws abstraction a Socket<T> drives: open/close a per-sub
-   subscription and publish to a topic. The browser singleton (socketChannel)
-   and the test harness (createTestSocketChannel) each implement it;
-   buildSocketOverChannel turns either into Socket<T> objects, so the two
-   surfaces can't drift on the Socket contract. */
-export type SocketChannel = {
-    subscribe(
-        sub: string,
-        socket: string,
-        replay: number | undefined,
-        callbacks: SocketSubCallbacks,
-    ): void
-    unsubscribe(sub: string): void
-    publish(socket: string, message: unknown): void
-}

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

@@ -1,19 +0,0 @@
-/*
-Wire frame the browser sends over the multiplexed socket connection.
-`sub` opens a subscription against `socket`. The optional `replay`
-controls seeding from the retained tail: omitted = the whole retained
-tail (`.tail()` no-arg); a number = at most that many trailing frames,
-clamped server-side to what the topic retains — `0` (bare `for await`)
-is live-only. `unsub` closes one. `pub` publishes a message —
-the dispatcher checks the topic's `clientPublish` flag before fanning
-out.
-
-`sub` is the per-subscription id minted client-side; the server treats
-it as opaque and routes inbound `replay|err|end` frames back to the same
-id — `msg` frames are broadcast keyed by socket name; the client
-demuxes them against every local sub for that socket.
-*/
-export type SocketClientFrame =
-    | { type: 'sub'; sub: string; socket: string; replay?: number }
-    | { type: 'unsub'; sub: string }
-    | { type: 'pub'; socket: string; message: unknown }

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

@@ -1,24 +0,0 @@
-/*
-Wire frame the server sends over the multiplexed socket connection.
-
-`msg` is keyed by socket name (not sub id) because one publish fans
-out to every client subscribed to the socket via Bun's native
-publish — the client demuxes against every local sub of that socket.
-
-`replay` is per-sub and batched: one frame carries the sub's requested
-slice of the retained tail (possibly empty), sent on sub before live
-fan-out reaches it. The batch is the wire's replay/live demarcation —
-a window reader commits its seed atomically at the boundary — and the
-per-sub address keeps one sub's replay out of sibling subs on the same
-socket.
-
-`end` and `err` are per-sub because they're subscription-lifecycle
-events; `err.message` is the only thrown-value field forwarded so the
-wire stays JSON-safe and server-side stack traces never reach the
-client.
-*/
-export type SocketServerFrame =
-    | { type: 'msg'; socket: string; message: unknown }
-    | { type: 'replay'; sub: string; messages: unknown[] }
-    | { type: 'end'; sub: string }
-    | { type: 'err'; sub: string; message: string }

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

@@ -1,13 +0,0 @@
-/* The callback contract a SocketChannel drives per subscription — how the
-   channel hands a sub its frames and lifecycle. Shared by every channel
-   implementation (the browser multiplex, the test harness) and the Socket<T>
-   builder that wires these onto a push iterator. */
-export type SocketSubCallbacks = {
-    onMessage(message: unknown): void
-    /* The sub's batched seed from the retained tail (possibly empty) — the replay/live boundary. */
-    onReplay(messages: unknown[]): void
-    onError(message: string): void
-    onEnd(): void
-    /* Transport loss (ws close), as opposed to a per-sub server `err` frame — recoverable. */
-    onDisconnect(): void
-}

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

@@ -1,13 +0,0 @@
-/*
-The per-request list of retained socket frames read via `peek(socket)` during an SSR render, each
-keyed by the socket's name. `defineSocket`'s server `peek()` pushes an entry when a retained frame is
-read server-side; the page renderer stamps them into `__SSR__.sockets` (ref-json-encoded, last write
-per name winning) so the client seeds the socket's latest frame WARM — a not-yet-connected client's
-`peek(socket)` then returns the same retained value the SSR render committed to instead of `undefined`,
-which would otherwise diverge from the server HTML and trip a hydration desync. Sibling of
-`ResolvedCells` — sockets carry a server value forward like cells, not withhold on the client like
-cache (whose server peek is uniformly undefined).
-*/
-export type SocketTails = {
-    entries: { name: string; value: unknown }[]
-}

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

@@ -1,14 +0,0 @@
-/*
-A source-map JSON object, narrowed to the fields abide reads or writes when
-post-processing emitted maps. `sources` is the list of original files (a null
-entry means an unknown source); `ignoreList` (Source Map v3 / ECMA-426) and its
-legacy Chrome alias `x_google_ignoreList` carry the indices into `sources` a
-debugger should skip. Other standard fields (`version`, `mappings`, …) are passed
-through untouched, so the type stays open.
-*/
-export type SourceMap = {
-    sources?: (string | null)[]
-    ignoreList?: number[]
-    x_google_ignoreList?: number[]
-    [field: string]: unknown
-}

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

@@ -1,27 +0,0 @@
-/*
-The subset of the `__SSR__` payload the client seeds into ambient slots at boot: the
-mount base, the default log channel (app name), the warm health payload, and the
-env-configured RPC client timeout. Every field here is stamped by the server's SSR
-state tag and MUST be seeded client-side by `seedBootState`, whose seed map is keyed
-EXHAUSTIVELY off this type — so a field added here fails to compile until both sides
-wire it. That compile error is the guard closing the silent stamped-but-unseeded gap
-(the bug that left `ABIDE_CLIENT_TIMEOUT` inoperative in the browser while every test
-still passed).
-*/
-export type SsrBootState = {
-    /* The mount base (`base || undefined`); seeds the base resolver so call keys and
-       navigation resolve rooted paths. Seeded first — the cache seed that follows keys
-       through it. */
-    base?: string
-    /* The app name — the default log channel; falls back to `'app'` when absent. */
-    app?: string
-    /* The health payload, so `health()`'s first client probe is warm rather than cold. */
-    health?: Record<string, unknown>
-    /* The env-configured RPC client timeout (`ABIDE_CLIENT_TIMEOUT`), shipped per request;
-       absent → unbounded client fetches. */
-    clientTimeout?: number
-    /* The SSR request's W3C traceparent; seeds the browser request scope so trace(), log
-       prefixes, and RPC traceparent headers continue the document's trace. Absent → a
-       fresh sampled trace is minted at boot. */
-    trace?: string
-}

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

@@ -1,36 +0,0 @@
-import type { CacheSnapshotEntry } from './CacheSnapshotEntry.ts'
-import type { SsrBootState } from './SsrBootState.ts'
-
-/*
-The `window.__SSR__` payload: the single contract between the server's SSR state tag
-(`createUiPageRenderer.stateTag`) and the client entry (`startClient`). Both sides
-import THIS type — the server stamps its object with `satisfies SsrPayload` (an unknown
-or mis-typed field is a compile error) and the client reads through it — so the
-write-set and read-set can't drift apart on a matching-string-key handshake.
-
-Three partitions:
-  - `SsrBootState` fields seed ambient slots via the exhaustive `seedBootState` map;
-  - `cache` / `cells` are the warm-seed partitions (settled `cache()` values / resolved async-cell
-    values), drained into their client stores before mount;
-  - `route`/`params` are stamped for inspectability and are NOT read by the client
-    (the router re-resolves the route from the URL).
-*/
-export type SsrPayload = SsrBootState & {
-    route: string
-    params: Record<string, string>
-    cache?: CacheSnapshotEntry[]
-    /* Async-cell values that resolved during SSR, keyed by render-path id → ref-json string.
-       `startClient` seeds these into `CELL_SEED`; a hydrating cell reads its key to warm-hydrate. */
-    cells?: Record<string, string>
-    /* Reactive-document snapshots that carried synchronous `state` during SSR, keyed by render-path
-       id → ref-json string. `startClient` seeds these into `DOC_SEED`; a hydrating scope's first
-       write to each slot adopts the server value, so a plain `state(uuid())`/`state(Date.now())`
-       keeps the SSR value instead of recomputing a divergent one. */
-    docs?: Record<string, string>
-    /* Retained socket frames read via `peek(socket)` during SSR, keyed by socket name → ref-json
-       string. `startClient` seeds these into `SOCKET_SEED`; a hydrating `socketProxy` adopts the frame
-       as its `lastFrame` so `peek(socket)` returns the SAME retained value the server rendered instead
-       of `undefined` on the not-yet-connected client — otherwise the two disagree and hydration
-       discards the server markup. */
-    sockets?: Record<string, string>
-}

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

@@ -1,56 +0,0 @@
-/*
-Mirror of the Standard Schema v1 spec interface (standardschema.dev). Any
-library that implements the spec — zod, valibot, arktype, etc. — produces
-values whose `~standard` property structurally matches this shape, so users
-can pass their existing schemas to rpc helpers without an adapter.
-
-Kept inline (no `@standard-schema/spec` dep) because the spec is type-only
-and tiny; adding a package for ~30 lines of interface would be churn. The
-namespace pattern below is the spec's own convention — `InferInput` /
-`InferOutput` ride along the same export.
-*/
-export interface StandardSchemaV1<Input = unknown, Output = Input> {
-    readonly '~standard': StandardSchemaV1.Props<Input, Output>
-}
-
-export namespace StandardSchemaV1 {
-    export interface Props<Input = unknown, Output = Input> {
-        readonly version: 1
-        readonly vendor: string
-        readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>
-        readonly types?: Types<Input, Output> | undefined
-    }
-
-    export type Result<Output> = SuccessResult<Output> | FailureResult
-
-    export interface SuccessResult<Output> {
-        readonly value: Output
-        readonly issues?: undefined
-    }
-
-    export interface FailureResult {
-        readonly issues: ReadonlyArray<Issue>
-    }
-
-    export interface Issue {
-        readonly message: string
-        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined
-    }
-
-    export interface PathSegment {
-        readonly key: PropertyKey
-    }
-
-    export interface Types<Input = unknown, Output = Input> {
-        readonly input: Input
-        readonly output: Output
-    }
-
-    export type InferInput<Schema extends StandardSchemaV1> = NonNullable<
-        Schema['~standard']['types']
-    >['input']
-
-    export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<
-        Schema['~standard']['types']
-    >['output']
-}

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

@@ -1,11 +0,0 @@
-/*
-Endpoint stream policy, declared once on a streaming rpc definition (ADR-0020).
-`n` is the replay depth — how many retained frames a fresh reader gets before
-going live, pairing with the server-side `tail` retention. Endpoint-fixed: a
-late joiner can't request deeper replay than a fresh view. No runtime consumer
-today (subscribableFromResponse ignores it); threaded onto the definition for
-completeness and future use.
-*/
-export type StreamPolicy = {
-    n?: number
-}

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

@@ -1,19 +0,0 @@
-/*
-The per-request list of STREAMING async-cell values that SETTLED during this SSR pass, each keyed by
-the cell's serialization-stable render-path id (`${scope.id}:${index}`) (ADR-0035). A streaming cell
-ships pending in the shell (excluded from the pre-mount `__SSR__.cells` warm-seed, which would
-diverge from that pending markup), so instead `createAsyncCell.settleValue` records its resolved
-VALUE here when it settles server-side. The page renderer reads this AFTER the shell — streaming an
-`__abideResolve({ cellKey, value })` chunk per entry — so the client adopts the server-resolved
-value post-hydration (no `loading…` flash) instead of only cold-re-running the seed.
-
-Values (not promises) so the drain never AWAITS — a streaming cell may legitimately stay pending
-through the whole request (the `{#if getFoo()}`-holds case), and awaiting it would hang the
-response. Only cells that settled before the drain point are streamed; one still pending is simply
-not (the client cold-runs it, unchanged). The streaming sibling of `ResolvedCells` (the BLOCKING
-warm-seed, read at render-return and stamped into `__SSR__.cells`); this one is read later in the
-stream and shipped out-of-order as chunks.
-*/
-export type StreamedCells = {
-    entries: { key: string; value: unknown }[]
-}

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

@@ -1,28 +0,0 @@
-import type { CacheSnapshotEntry } from './CacheSnapshotEntry.ts'
-
-/*
-Payload of one streamed `window.__abideResolve(...)` call. Three arms:
-
-  - a full `CacheSnapshotEntry` (has `key` + body) settles a cache placeholder with warm data;
-  - a `{ key, miss }` marker means the server couldn't snapshot that cache body (binary, rejected,
-    evicted) so the client settles the placeholder with a live re-fetch instead;
-  - a `{ cellKey, value }` (ADR-0035) carries a STREAMING CELL's server-resolved value, keyed by its
-    render-path warm-key and `encodeRefJson`-encoded, applied post-hydration as a reactive update so
-    a non-cache peek stops flashing `loading…` on hydrate.
-  - a `{ cellSeed, value }` (ADR-0039) carries a STREAMED CHILD's blocking async-cell value that
-    resolved AFTER the head `__SSR__.cells` snapshot (its render was deferred to the drain), seeded
-    PRE-mount into `CELL_SEED` — the same warm partition as `__SSR__.cells` — so the child's cell
-    constructs resolved on hydrate rather than re-running.
-
-Discriminate on `cellSeed` then `cellKey` (cell) then `miss` (cache miss) then default (cache entry).
-*/
-
-/* The cache arms — a warm snapshot entry or a `{ key, miss }` marker. `streamCacheResolutions`
-   yields exactly these (never the cell arm), so its element type is `CacheResolution`, keeping a
-   `.key` access on its results well-typed. */
-export type CacheResolution = CacheSnapshotEntry | { key: string; miss: true }
-
-export type StreamedResolution =
-    | CacheResolution
-    | { cellKey: string; value: string }
-    | { cellSeed: string; value: string }

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

@@ -1,13 +0,0 @@
-/*
-Hooks a `tail(count, hooks)` caller passes to a NamedAsyncIterable's retention
-capability.
-`replayed` must be signalled in-band exactly once per iteration — after the
-last replayed frame, before any live frame, and even when nothing was
-replayed — so a window reader can commit its seed atomically instead of
-guessing where replay ends (an empty replay keeps the reader's held window;
-nothing was replayed, so nothing can duplicate). Sources without the
-capability never see hooks.
-*/
-export interface TailHooks {
-    readonly replayed?: () => void
-}

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

@@ -1,17 +0,0 @@
-/*
-The request's W3C Trace Context position. `traceId` identifies the whole
-end-to-end operation (inherited from an inbound `traceparent` or minted at the
-boundary); `spanId` is the id abide mints for this request — it rides outbound
-`traceparent` headers as the parent of downstream work, and a future span
-exporter materialises the request's root span under this exact id.
-`parentSpanId` preserves the inbound header's span id so that root span can
-parent under the upstream caller; absent when abide started the trace.
-`flags` echo the inbound sampling flags ('01' when abide starts the trace, so
-downstream recorders don't drop what the developer is trying to see).
-*/
-export type TraceContext = {
-    traceId: string
-    spanId: string
-    parentSpanId?: string
-    flags: string
-}

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

@@ -1,20 +0,0 @@
-import type { StandardSchemaV1 } from './StandardSchemaV1.ts'
-
-/*
-The `data` payload an input/file validation failure carries on its HttpError —
-`kind: 'validation'`, status 422. `issues` is the raw Standard Schema issue list
-(every message + full path); `fields` is the form-friendly top-level-field →
-first-message map (fieldErrorsFromIssues). Because a throw can't carry the rpc's
-per-kind type to the catch, `HttpError.data` is typed `unknown` — narrow it with
-this when `err.kind === 'validation'`:
-
-  if (err instanceof HttpError && err.kind === 'validation') {
-      const { fields } = err.data as ValidationErrorData
-      // fields.email === 'Required', …
-  }
-*/
-// @documentation response
-export type ValidationErrorData = {
-    readonly issues: readonly StandardSchemaV1.Issue[]
-    readonly fields: Record<string, string>
-}

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

@@ -1,11 +0,0 @@
-/*
-The wire codec kind for a single top-level Args field (ADR-0029). Generalizes ADR-0028's scalar
-`number`/`boolean` query coercion to the structured value kinds the warm server program can name
-through the type graph — a `Date` / `Set` / `Map` by symbol identity, a `bigint` by type flag.
-parseArgs revives a field's plain-JSON wire form into the runtime value the handler's declared
-type expects: an ISO string → `Date`, a numeric string → `bigint`, a JSON array → `Set`, a JSON
-entries array (or object) → `Map`. Top-level fields only in this increment — a structured value
-NESTED inside another value is not descended into. Reviving is fail-open: an unrevivable value is
-left as its JSON form, never thrown, so the plain-JSON / OpenAPI contract still works.
-*/
-export type WireKind = 'number' | 'boolean' | 'date' | 'bigint' | 'set' | 'map'