theokit 0.48.13 → 0.50.0

package/dist/index-CzxtQcnp.d.ts

@@ -0,0 +1,1058 @@
+import { a as TheoErrorCode, T as TheoErrorEnvelope, V as ValidationFieldsExt } from './error-envelope-DG47lt8E.js';
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { P as PluginContext, W as WebOnRequestHook, g as WebPreHandlerHook, h as WebOnResponseHook, i as WebOnErrorHook } from './plugin-types-BUVfUQ0V.js';
+import { P as PluginRunner } from './plugin-runner-BVMOSxvb.js';
+import { J as JobBackend } from './job-backend-CgC8Xf33.js';
+import { L as LoadModule, S as ServerRouteNode } from './match-DmGgxjIU.js';
+import { C as CsrfMode, D as DisallowedConfig } from './csrf-Dgot9qSM.js';
+import { z } from 'zod';
+import { R as RouteConfig } from './route-config-Cm_ZMA1C.js';
+
+interface ExecuteActionOptions {
+    filePath: string;
+    exportName: string;
+    req: IncomingMessage;
+    res: ServerResponse;
+    loadModule: LoadModule;
+    serverDir?: string;
+    requestId?: string;
+    pluginRunner?: PluginRunner;
+    csrfMode?: CsrfMode;
+    disallowed?: DisallowedConfig;
+}
+declare function executeAction(filePath: string, exportName: string, req: IncomingMessage, res: ServerResponse, loadModule: LoadModule, serverDir?: string, requestId?: string, pluginRunner?: PluginRunner, csrfMode?: CsrfMode, disallowed?: DisallowedConfig): Promise<void>;
+
+/**
+ * T5.2 — pluggable response/request transformer.
+ *
+ * `superjson` is the default, preserving Date/Map/Set/BigInt/etc.
+ * `json` is the lightweight option (plain JSON.stringify/parse).
+ * Users can supply a custom object implementing this contract.
+ */
+interface TheoTransformer {
+    name: string;
+    serialize: (value: unknown) => string;
+    deserialize: (raw: string) => unknown;
+}
+declare const superjsonTransformer: TheoTransformer;
+declare const jsonTransformer: TheoTransformer;
+declare function resolveTransformer(selector: 'json' | 'superjson' | TheoTransformer): TheoTransformer;
+
+/**
+ * server/http/execute-context.ts
+ *
+ * `ExecuteRouteContext` — the parameter object passed to `executeRoute()`
+ * and `executeAction()` per ADR-0016 (T3.1 of architecture-cleanup).
+ *
+ * Replaces the 12-positional-param signature with a single named-field
+ * object, eliminating 3 of 4 eslint-disable comments on `executeRoute`.
+ *
+ * Location: lives in `server/http/` (not `core/contracts/`) because the
+ * shape references server-side types (CsrfMode, JobBackend, PluginRunner,
+ * TheoTransformer, ServerRouteNode, LoadModule, DisallowedConfig). Keeping
+ * the type here preserves the existing module direction graph — no new
+ * `core → server` edges.
+ *
+ * Consumers within server/ build this object once per request; external
+ * callers (router-runner) see the same shape via the `ExecuteRouteContext`
+ * named export.
+ */
+
+/**
+ * The request-execution context. Each request builds one of these and passes
+ * it to `executeRoute(ctx)`.
+ *
+ * All fields are required EXCEPT those with optional `?` markers; defaults
+ * are applied inside `executeRoute` via destructure (e.g., `csrfMode = 'strict'`).
+ */
+interface ExecuteRouteContext {
+    route: ServerRouteNode;
+    method: string;
+    params: Record<string, string>;
+    req: IncomingMessage;
+    res: ServerResponse;
+    loadModule: LoadModule;
+    serverDir?: string;
+    requestId?: string;
+    pluginRunner?: PluginRunner;
+    transformer?: TheoTransformer;
+    /** Defaults to `'strict'` when omitted. */
+    csrfMode?: CsrfMode;
+    disallowed?: DisallowedConfig;
+    /** When provided, `ctx.queue` auto-injects + outbox lifecycle hooks attach. */
+    jobBackend?: JobBackend;
+}
+
+/**
+ * Canonical HTTP response helpers (T5.1 extraction).
+ *
+ * Moved out of execute.ts so request-pipeline stages (execute-stages.ts,
+ * handle-request-error.ts, etc.) can depend on these helpers without
+ * creating a cycle through execute.ts.
+ *
+ * Public surface re-exported from execute.ts for backward compat — every
+ * existing caller of `sendError` / `sendJson` continues to work via the
+ * `theokit/server` barrel.
+ */
+declare function sendJson(res: ServerResponse, data: unknown, status?: number, transformer?: TheoTransformer): void;
+interface SendErrorOptions {
+    custom404Html?: string;
+    custom500Html?: string;
+}
+/**
+ * Canonical error response.
+ *
+ * T6.3 (PV-17): the positional 7-param signature is preserved for backward
+ * compat. New call sites should use the options-bag form:
+ *
+ *   sendError(res, { code, message, status, issues?, requestId?, options? })
+ *
+ * Both shapes resolve to the same implementation.
+ */
+interface SendErrorInput {
+    code: string;
+    message: string;
+    status: number;
+    issues?: unknown[];
+    requestId?: string;
+    options?: SendErrorOptions;
+}
+declare function sendError(res: ServerResponse, input: SendErrorInput): void;
+declare function sendError(res: ServerResponse, code: string, message: string, status: number, issues?: unknown[], requestId?: string, options?: SendErrorOptions): void;
+
+declare function executeRoute(ctx: ExecuteRouteContext): Promise<void>;
+
+/**
+ * T1.4 — Server-side batch handler.
+ *
+ * Receives `{ requests: [...] }` POSTed to `/api/__theo_batch__` and returns
+ * `{ results: [...] }` with per-item error isolation. EC-2: items cannot
+ * override auth/forwarded headers (would be a session-bypass vector).
+ */
+
+declare const STRIPPED_HEADERS: readonly ["authorization", "cookie", "x-forwarded-for", "x-forwarded-host", "x-forwarded-proto", "x-real-ip", "host"];
+declare const BATCH_PATH = "/api/__theo_batch__";
+declare class BatchPathConflictError extends Error {
+    constructor(path: string);
+}
+declare const batchRequestSchema: z.ZodObject<{
+    path: z.ZodString;
+    method: z.ZodString;
+    query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    body: z.ZodOptional<z.ZodUnknown>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+declare const batchPayloadSchema: z.ZodObject<{
+    requests: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        method: z.ZodString;
+        query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        body: z.ZodOptional<z.ZodUnknown>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type BatchRequestItem = z.infer<typeof batchRequestSchema>;
+type BatchPayload = z.infer<typeof batchPayloadSchema>;
+type BatchExecuteFn = (req: BatchRequestItem) => Promise<{
+    data: unknown;
+} | {
+    error: {
+        message: string;
+        code?: string;
+    };
+}>;
+interface HandleBatchOptions {
+    execute: BatchExecuteFn;
+    /** Max number of items per batch. Default 32. */
+    max?: number;
+    /** Outer-request headers that override per-item headers in STRIPPED_HEADERS. */
+    outerHeaders?: Record<string, string>;
+}
+type BatchResultItem = {
+    data: unknown;
+} | {
+    error: {
+        message: string;
+        code?: string;
+    };
+};
+interface BatchResponse {
+    results: BatchResultItem[];
+}
+/**
+ * Validate + execute a batch request.
+ *
+ * CR-028 fix: previously the signature was `payload: BatchPayload`,
+ * suggesting the caller had already validated. In reality `api-middleware`
+ * passes `JSON.parse(rawBody) as BatchPayload` — an unsafe cast over raw
+ * HTTP input. We widen the input type to `unknown` so the type system
+ * forces validation, then run Zod once at this single trust boundary.
+ */
+declare function handleBatchRequest(payload: unknown, options: HandleBatchOptions): Promise<BatchResponse>;
+
+/**
+ * T1.2 — CORS middleware.
+ *
+ * Single global middleware that runs FIRST in the request pipeline:
+ *   CORS preflight → rate limit → CSRF → security headers → handler
+ *
+ * Preflight (`OPTIONS` with `Access-Control-Request-Method`) is handled
+ * by `handlePreflight`, which short-circuits the response with 204 +
+ * Access-Control-* headers.
+ *
+ * Non-preflight requests pass through; `applyHeaders` adds
+ * `Access-Control-Allow-Origin` (echoing the request's Origin),
+ * `Access-Control-Expose-Headers`, and `Access-Control-Allow-Credentials`.
+ *
+ * Per ADR D3: preflight responses are deterministic and only the matched
+ * origin is echoed back (never `'*'` when credentials are enabled —
+ * required by the CORS spec).
+ */
+type CorsOrigin = string | RegExp | readonly (string | RegExp)[] | ((origin: string) => boolean);
+interface CorsConfig {
+    origins: CorsOrigin;
+    methods?: readonly ('GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS' | 'HEAD')[];
+    allowedHeaders?: readonly string[];
+    exposedHeaders?: readonly string[];
+    credentials?: boolean;
+    maxAge?: number;
+}
+interface CorsHandler {
+    handlePreflight(req: IncomingMessage, res: ServerResponse): boolean;
+    applyHeaders(req: IncomingMessage, res: ServerResponse): void;
+}
+/**
+ * Test whether `origin` is allowed by `allowed`. Pure function — no I/O.
+ *
+ * EC-8: callback variants that throw are fail-closed (deny). Without
+ * this, a transient datastore outage would silently widen CORS during
+ * the failure window.
+ */
+declare function matchesOrigin(origin: string, allowed: CorsOrigin): boolean;
+declare function createCorsHandler(config: CorsConfig): CorsHandler;
+/**
+ * T5a.2 Phase B slice 5/6 — Web-Standards CORS handler.
+ *
+ * Mirror of `createCorsHandler(config): CorsHandler` for the Web `Request`
+ * shape. Same `CorsConfig`, same `matchesOrigin` logic (pure helper
+ * already), same security guarantees (echo matched origin only — never
+ * `'*'` when credentials enabled; EC-8 fail-closed on callback throw).
+ *
+ * Signature differences vs the IncomingMessage pair:
+ *   - `handlePreflightRequest(request, config): Response | null` — returns
+ *     `Response` when this is a CORS preflight; `null` when not. Caller
+ *     short-circuits accordingly (same control-flow semantic as boolean).
+ *   - `applyCorsHeaders(request, target, config): void` — mutates a
+ *     `Headers` instance in place. Caller passes the headers they're
+ *     building for their Response.
+ */
+interface CorsWebHandler {
+    handlePreflightRequest(request: Request): Response | null;
+    applyCorsHeaders(request: Request, target: Headers): void;
+}
+declare function createCorsWebHandler(config: CorsConfig): CorsWebHandler;
+
+/**
+ * Phase 7 — Observability: traceId propagation (D7).
+ *
+ * Extract a stable identifier from incoming requests so a single value
+ * correlates the client request, every server log line, the response
+ * envelope, and any downstream span. Precedence:
+ *
+ *   1. `traceparent` (W3C Trace Context — `00-{32-hex}-{16-hex}-{flags}`)
+ *   2. `x-request-id` (Heroku / GCP / generic proxy header)
+ *   3. Generated UUID (fresh per request)
+ *
+ * UUIDs are accepted as trace identifiers by every major vendor that
+ * does not enforce strict 32-hex (Datadog, Honeycomb, Sentry, Logflare,
+ * Axiom, etc). We don't need ULIDs to ship this surface.
+ */
+declare const TRACE_HEADER = "x-trace-id";
+declare const TRACE_PARENT_HEADER = "traceparent";
+/**
+ * What a valid `traceparent` says: the trace to join, and the caller's span
+ * inside it.
+ *
+ * Both halves are on the wire and only the first was ever read, so a span this
+ * process opened for an incoming request became a SECOND root of the caller's
+ * trace instead of a child of the caller's span — the trace correlated and the
+ * waterfall lost its shape (usetheokit/theokit#385).
+ */
+interface W3CTraceContext {
+    /** The trace this request belongs to. 32 hex chars. */
+    readonly traceId: string;
+    /**
+     * The caller's span, which a span opened for this request hangs under.
+     *
+     * Absent when the caller sent the reserved all-zero parent id, which W3C
+     * defines as "no parent" rather than as a span to point at.
+     */
+    readonly parentSpanId?: string;
+}
+/**
+ * Parse a W3C Trace Context `traceparent` header value into the trace it names
+ * and the caller's span within it. `null` when the value is not a well-formed
+ * `traceparent` or names the reserved all-zero trace.
+ */
+declare function parseTraceparentContext(value: string): W3CTraceContext | null;
+/**
+ * Parse a W3C Trace Context `traceparent` header value. Returns the
+ * 32-hex trace-id when valid (and not the reserved all-zeros), else
+ * `null`.
+ */
+declare function parseTraceparent(value: string): string | null;
+/**
+ * Resolve the request's traceId following the precedence above.
+ */
+declare function extractTraceId(req: IncomingMessage): string;
+/**
+ * T5a.2 Phase C slice 1/2 — Web-Standards-shaped traceId resolver.
+ *
+ * Mirror of `extractTraceId(req: IncomingMessage)` for the Web `Request`
+ * shape. Same precedence (`traceparent` → `x-request-id` → generated
+ * UUID). Uses `request.headers.get(name)` (native Web `Headers` API)
+ * instead of the Node indexer.
+ *
+ * **Multi-value note:** Web `Headers` collapses repeated headers into a
+ * single comma-separated string at parse. The IncomingMessage path's
+ * `pickHeader` "first non-empty value" semantic is naturally satisfied
+ * because there's no array to pick from on the Web side — `.get()`
+ * returns the comma-joined value, which for `traceparent` / `x-request-id`
+ * is treated as a single string anyway (both headers are conventionally
+ * single-valued).
+ */
+/**
+ * The request's W3C trace context — the trace to join and the caller's span
+ * within it — or `undefined` when the caller supplied no usable `traceparent`.
+ *
+ * Deliberately narrower than {@link extractTraceIdFromRequest}, which always
+ * returns something and may return an `x-request-id` or a generated UUID. Those
+ * are fine as a log correlation key and are NOT trace ids: OTLP wants 32 hex
+ * characters, and a dashed UUID exported as a `traceId` is a malformed span.
+ *
+ * So a span-emitting caller asks this question instead — "is there a real trace
+ * to join?" — and mints its own when the answer is no (usetheokit/theokit#368).
+ *
+ * It answers with the whole context rather than the trace id alone, because a
+ * span opened for this request belongs in the caller's trace AND under the
+ * caller's span. Returning only the first half is what made one request arrive
+ * as a trace with two roots (usetheokit/theokit#385).
+ */
+declare function extractW3CTraceContext(request: Request): W3CTraceContext | undefined;
+declare function extractTraceIdFromRequest(request: Request): string;
+
+/**
+ * `TheoError` — envelope-emitting `Error` subclass per plan
+ * g5-error-envelope-cross-layer v1.0 § Phase 1 / T1.2.
+ *
+ * Mirrors trpc's TRPCError ergonomic pattern (reference:
+ * trpc/packages/server/src/unstable-core-do-not-import/error/TRPCError.ts:65-87)
+ * adapted for theokit's hybrid envelope model (blueprint Form 4).
+ *
+ * Per ADR D5: `meta.stack` is auto-stripped in non-dev builds when serialized
+ * via `toJSON()` — defense against accidental stack leak to clients (encore
+ * `json:"-"` analog).
+ *
+ * Lives in `core/contracts/` per architecture.md v3 invariant #3.
+ */
+
+/**
+ * Constructor options. `code` and `message` are required; `cause` follows TC39
+ * proposal-error-cause; `meta` and `ext` are opt-in per blueprint ADR D2.
+ */
+interface TheoErrorOptions<TExt = unknown> {
+    readonly code: TheoErrorCode;
+    readonly message: string;
+    readonly cause?: unknown;
+    readonly meta?: Record<string, unknown>;
+    readonly ext?: TExt;
+}
+/**
+ * `TheoError` — envelope-emitting Error subclass. Use this anywhere in
+ * `theokit/server`, route handlers, or middleware to emit a typed,
+ * cross-layer-compatible error.
+ *
+ * Mirrors TRPCError pattern: `code` is required, `message` defaults to
+ * code if omitted, `cause` chain is preserved via TC39 proposal-error-cause.
+ */
+declare class TheoError<TExt = unknown> extends Error {
+    readonly name = "TheoError";
+    readonly code: TheoErrorCode;
+    readonly meta?: Record<string, unknown>;
+    readonly ext?: TExt;
+    constructor(opts: TheoErrorOptions<TExt>);
+    /**
+     * The canonical envelope view of this error. Use when crossing the wire
+     * boundary or feeding telemetry — exposes the shape consumers can rely on
+     * without depending on the class identity.
+     */
+    get envelope(): TheoErrorEnvelope<TExt>;
+    /**
+     * JSON serialization — emits envelope shape only (no name/stack class
+     * internals). Per ADR D5, `meta.stack` is auto-stripped in non-dev to
+     * prevent accidental leak; other meta keys are preserved.
+     */
+    toJSON(): TheoErrorEnvelope<TExt>;
+}
+/**
+ * Coerce any unknown value into a TheoError envelope.
+ *
+ * - If value is already a TheoError, returns it unchanged (no double-wrap).
+ * - If value is a plain Error, wraps it as `INTERNAL_SERVER_ERROR` with
+ *   `cause` chain preserving the original.
+ * - Other values (string, undefined, object) are coerced safely with a
+ *   meaningful message.
+ *
+ * Use at framework boundaries (route handler catch-all, middleware catch,
+ * SDK egress) to ensure every error crossing the wire carries an envelope.
+ */
+/**
+ * `NotFoundError` — typed 404. A `TheoError` with code `NOT_FOUND`, so it
+ * carries a stable `code` (not a bare status literal) and maps to HTTP 404 via
+ * `envelopeCodeToStatus`. Throw it from a `defineRoute` handler for ergonomic
+ * 404s (M7-1).
+ */
+declare class NotFoundError extends TheoError {
+    constructor(message?: string, meta?: Record<string, unknown>);
+}
+declare function fromUnknown(value: unknown): TheoError;
+
+/**
+ * G5 T2.5 — server-side boundary translation per blueprint ADR D3.
+ *
+ * Translates ad-hoc Error class instances (FileTooLargeError,
+ * AuthRequiredError, RouterConventionError, etc.) into the canonical
+ * `TheoErrorEnvelope` shape at the wire boundary. This is the SINGLE
+ * boundary translation point — class identities stay in place inside the
+ * codebase (no invasive call-site rewrites), but the envelope is what
+ * crosses to clients.
+ *
+ * Pure; no I/O. Lives in `core/contracts/` per architecture.md v3
+ * invariant #3 (canonical home for shared client↔server types). This file
+ * is the EXCEPTION-of-an-exception: it intentionally inspects Error names
+ * by string instead of `instanceof` to avoid `core/contracts/` taking a
+ * dependency on `server/`. The mapping table is small and grep-discoverable.
+ */
+
+/**
+ * Translate any server-side Error instance into a canonical envelope.
+ *
+ * Pass-through behavior:
+ * - `TheoError` instances return their `.envelope` unchanged.
+ * - Plain `Error` with unknown name → `INTERNAL_SERVER_ERROR`.
+ * - Non-Error values → wrapped via `TheoError.fromUnknown` semantics.
+ *
+ * Meta carries the source class `name` plus class-specific fields when an
+ * extractor is registered. This keeps wire-side telemetry useful without
+ * leaking implementation details.
+ */
+declare function serverErrorToEnvelope(value: unknown): TheoErrorEnvelope;
+
+/**
+ * Maps a TheoErrorEnvelope `code` to its canonical HTTP status.
+ *
+ * Single source of truth — previously duplicated in `web-handler.ts` and
+ * `handle-request-error.ts` (architecture-remediation plan T1.2, 2026-06-12).
+ *
+ * Every TheoErrorCode value MUST have an explicit entry here. SDK-domain codes
+ * (AGENT_RUN_ERROR, PROVIDER_KEY_MISSING, BUDGET_EXCEEDED, CREDENTIAL_POOL_EXHAUSTED)
+ * intentionally map to 500 — they represent internal failures, not client errors.
+ */
+declare function envelopeCodeToStatus(code: string): number;
+
+/**
+ * Canonical error handler for HTTP request pipelines (T3.4 of
+ * architecture-review-remediation-plan, PV-9 DRY).
+ *
+ * Replaces the duplicated catch-block logic in `executeRoute` (1 site) and
+ * `executeAction` (1 site, via `handleActionError`). Both code paths now
+ * share this implementation.
+ *
+ * Behavior contract (preserved from previous inline catches):
+ * - Plugin `onError` fires first (swallowed if it throws — never amplify failure).
+ * - `AuthRequiredError` is detected via `instanceof` AND a duck-type shape
+ *   check (`code === 'AUTH_REQUIRED' && status === 401`) — required because
+ *   under Vite dev / vitest the module-loader can produce a duplicate
+ *   AuthRequiredError class identity, breaking `instanceof`.
+ * - `onResponse({ inErrorPath: true })` always fires at the end (swallowed
+ *   if it throws — EC-9).
+ */
+interface HandleRequestErrorCtx {
+    req: IncomingMessage;
+    res: ServerResponse;
+    requestId: string | undefined;
+    pluginRunner: PluginRunner | undefined;
+    buildPluginCtx: (ctxObj: Record<string, unknown>) => PluginContext;
+}
+declare function handleRequestError(err: unknown, c: HandleRequestErrorCtx): Promise<void>;
+/**
+ * T5a.2 Phase G slice 3/N — Web-Standards request error handler.
+ *
+ * Mirror of `handleRequestError(err, c: HandleRequestErrorCtx)` for the
+ * Web `Request` shape. Returns a native `Response` directly instead of
+ * mutating `res`. Same behavioral contract:
+ *
+ *   1. Auth-error detection via `instanceof AuthRequiredError` PLUS a
+ *      duck-type fallback (`code === 'AUTH_REQUIRED' && status === 401`)
+ *      — needed because Vite dev / vitest can produce duplicate class
+ *      identities, breaking `instanceof`.
+ *   2. Envelope-shaped JSON body using `serverErrorToEnvelope` (G5 D3
+ *      boundary translation).
+ *   3. Status code derived from envelope.code via `envelopeCodeToStatus`
+ *      mirror (already implemented inline in web-handler.ts; this slice
+ *      uses the same mapping table).
+ *
+ * **Difference vs IncomingMessage path:** the Web path's plugin runner
+ * orchestration lives in `executeWebRequest`'s `runWithHooks` /
+ * `runErrorHooks` (Phase G slice 1/N) — `handleWebRequestError` is the
+ * leaf that builds the error Response WITHOUT touching plugin hooks.
+ * Callers compose: `executeWebRequest` (or future Web execute pipeline)
+ * catches a throw, calls `handleWebRequestError(err, { requestId })` to
+ * build the Response, then routes through onError hooks separately.
+ */
+interface HandleWebRequestErrorCtx {
+    requestId?: string;
+}
+declare function handleWebRequestError(err: unknown, ctx?: HandleWebRequestErrorCtx): Promise<Response>;
+
+interface MiddlewareResult {
+    ctx: unknown;
+    aborted: boolean;
+}
+declare function _resetMiddlewareCacheForTests(): void;
+declare function runMiddlewareAndContext(req: IncomingMessage, res: ServerResponse, loadModule: LoadModule, serverDir: string): Promise<MiddlewareResult>;
+/**
+ * Run ONLY the application's `server/context.ts` factory and return what it produced.
+ *
+ * Split out of {@link runMiddlewareAndContext} because the agent endpoints need the identity half
+ * of that function and must not take the middleware half with it (usetheokit/theokit#365).
+ *
+ * The split is not a shortcut, it is the whole of what those endpoints can honestly reuse today:
+ * middleware here is `(req, res, next)` and contributes NOTHING to `ctx` — only this factory does.
+ * So running the chain would buy the policy no identity it does not already get, while adding
+ * abort semantics and header side effects to a dispatch branch that has never had them. Running
+ * `server/middleware/` on agent URLs is a separate, larger behaviour change; it is not this one.
+ */
+declare function createServerContext(req: IncomingMessage, res: ServerResponse, loadModule: LoadModule, serverDir: string): Promise<unknown>;
+
+interface CookieOptions {
+    httpOnly?: boolean;
+    secure?: boolean;
+    sameSite?: 'strict' | 'lax' | 'none';
+    maxAge?: number;
+    path?: string;
+    domain?: string;
+}
+/**
+ * Parse a `Cookie` header into a Map (RFC 6265 §5.4).
+ * - Empty/missing input → empty Map.
+ * - Malformed entries (no `=`) skipped silently (defensive).
+ * - Duplicate names → last-wins.
+ * - Values URL-decoded if possible; raw on decode failure (CR-009 protection).
+ *
+ * Canonical helper (T3.2 of architecture-review-remediation-plan; PV-4 DRY).
+ * Consumed by `getCookie` here AND by `rate-limit/rate-limit-per-route.ts`.
+ */
+declare function parseCookieHeader(header: string | undefined): Map<string, string>;
+declare function getCookie(req: IncomingMessage, name: string): string | undefined;
+/**
+ * T5a.2 Phase B slice 6/6 — pure Set-Cookie serializer. Extracted from
+ * `setCookie(res, ...)` so the IncomingMessage path AND the Web Headers
+ * path can share the cookie attribute composition.
+ *
+ * Returns the canonical `Set-Cookie` header value string (no surrounding
+ * `Set-Cookie:` prefix — caller wraps via `res.setHeader('Set-Cookie', ...)`
+ * or `headers.append('Set-Cookie', ...)`).
+ *
+ * Defaults: `httpOnly: true`, `secure: NODE_ENV === 'production'`,
+ * `sameSite: 'lax'`, `path: '/'`.
+ */
+declare function serializeCookie(name: string, value: string, options?: CookieOptions): string;
+declare function setCookie(res: ServerResponse, name: string, value: string, options?: CookieOptions): void;
+declare function deleteCookie(res: ServerResponse, name: string, options?: {
+    path?: string;
+}): void;
+/**
+ * T5a.2 Phase B slice 6/6 — Web-Standards cookie getter.
+ *
+ * Mirror of `getCookie(req: IncomingMessage, name)` for the Web `Request`
+ * shape. Consumes `request.headers.get('cookie')` (native `Headers` API)
+ * instead of `req.headers.cookie`. Same parse logic + same malformed
+ * percent-encoding sanity (returns undefined when raw value contains a
+ * lone `%` that didn't decode, preserving the IncomingMessage path's
+ * "treat as unreadable" CR-009 semantics).
+ */
+declare function getCookieFromRequest(request: Request, name: string): string | undefined;
+/**
+ * T5a.2 Phase B slice 6/6 — Web-Standards cookie setter.
+ *
+ * Mirror of `setCookie(res, name, value, options)` for the Web `Headers`
+ * shape. Appends a `Set-Cookie` entry to the caller's `Headers` instance
+ * via `headers.append('Set-Cookie', ...)`. Multiple appends produce
+ * multiple `Set-Cookie` headers per the Web spec; `headers.getSetCookie()`
+ * retrieves them as an array (the one multi-value header the Web API
+ * exposes natively).
+ *
+ * Uses the shared `serializeCookie` pure helper — same defaults and
+ * attribute composition as the IncomingMessage path.
+ */
+declare function appendCookieToHeaders(target: Headers, name: string, value: string, options?: CookieOptions): void;
+/**
+ * T5a.2 Phase B slice 6/6 — Web-Standards cookie deleter.
+ *
+ * Mirror of `deleteCookie(res, name, options)` — emits a Set-Cookie with
+ * `Max-Age=0` so the browser drops the cookie immediately.
+ */
+declare function appendDeleteCookieToHeaders(target: Headers, name: string, options?: {
+    path?: string;
+}): void;
+
+/**
+ * T2.4 — Custom error pages loader.
+ *
+ * Loads optional `.theokit/client/404.html` and `500.html` from disk so adapters
+ * (Node, CF, Vercel, Bun, Netlify, AWS Lambda, Deno) can pass them to the
+ * shared `sendError` pipeline.
+ *
+ * EC-9: caps file size at 1MB. Files beyond the limit are skipped with a
+ * console.warn and the default JSON error path is used.
+ */
+declare const MAX_ERROR_HTML_BYTES = 1048576;
+interface CustomErrorPages {
+    custom404Html?: string;
+    custom500Html?: string;
+}
+/**
+ * Load `.theokit/client/{404,500}.html` from the given client directory.
+ * Returns object with both fields when present; missing pages remain undefined.
+ */
+declare function loadCustomErrorPages(clientDir: string): CustomErrorPages;
+
+declare function serveStaticFile(req: IncomingMessage, res: ServerResponse, clientDir: string): boolean;
+
+/**
+ * T3.2 — Web-Standards middleware runner for the `executeWebRequest` path.
+ *
+ * The Node request path (`http/execute.ts`) runs middleware via
+ * `runMiddlewareAndContext`, which is coupled to Node `req`/`res`. Per G8
+ * (Web Standards over Node APIs) the Web path needs a `Request`-shaped runner;
+ * this is it. Extracted to a sibling so `web-handler.ts` stays under its LoC
+ * budget (G6).
+ *
+ * Ordering invariant (EC-3): the caller runs the CSRF gate BEFORE invoking this
+ * runner, mirroring the Node path (CSRF stage precedes user middleware).
+ *
+ * NOTE (D4 / EC-12): this is its own middleware contract — `(request, context)`.
+ * Full semantic parity with the Node `defineMiddleware` contract is part of the
+ * deferred Node→Web pipeline convergence, not this slice.
+ */
+/** A Web-path middleware: mutate `context`, or return a `Response` to short-circuit. */
+type WebMiddleware = (request: Request, context: Record<string, unknown>) => Promise<Response | undefined> | Response | undefined | void;
+
+/**
+ * The route module exported by a `server/routes/*.ts` file (after T2.6 G6
+ * router lockdown). Method-named exports map to `defineRoute` results.
+ */
+type WebRouteModule = Partial<Record<'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE', unknown>>;
+/**
+ * Optional behavior knobs for `executeWebRequest`. Each knob defaults to
+ * the safe "no-op" stance so existing Phase A consumers (T1.2 fixture
+ * tests) keep working unchanged.
+ *
+ * **`csrfMode`** — the Web request gate runs `validateCsrfRequest` BEFORE
+ * method dispatch on state-changing methods (POST/PUT/PATCH/DELETE) and
+ * emits a `403 FORBIDDEN` envelope when the check fails. **Omitting the
+ * option enforces the gate**; only an explicit `'off'` disables it.
+ *
+ * The default used to be `'off'`, which meant a caller that never heard of
+ * the option served every state-changing request unchecked. A security
+ * control that has to be asked for is not a control, and this executor is
+ * the boundary the CF / Bun / Deno adapters are built on -- each of them a
+ * caller that would have had to remember. A route that legitimately takes
+ * third-party POSTs opts out by itself, per route, with `csrf: false` on
+ * `defineRoute`; `'off'` is for an application with another defense, such
+ * as one that ships no session cookie at all.
+ *
+ * Per the T5a.2 plan v1.0 § Phase B header-only leaves: csrf.ts is the
+ * first leaf to be migrated (slice 1/6); 5 more sibling leaves remain
+ * (csrf-multi-header, csrf-readiness-endpoint, csp-report, cors, cookies).
+ */
+interface ExecuteWebRequestOptions {
+    csrfMode?: 'off' | 'strict';
+    /**
+     * T3.1 — route params resolved upstream by `matchRoute` (e.g. `{ id: '42' }`
+     * for `/users/:id`). Threaded to the handler's `params` input and validated
+     * against `config.params` (Zod) when declared. Defaults to `{}` — callers
+     * that don't supply params keep the prior behavior (additive, backward-compat).
+     */
+    params?: Record<string, string>;
+    /**
+     * T3.2 — Web-Standards middleware chain. Runs in order AFTER the CSRF gate
+     * (EC-3) and BEFORE the handler. A middleware returning a `Response`
+     * short-circuits (handler not reached); mutating `context` passes data to
+     * the handler. Omitted → zero overhead (handler runs directly).
+     */
+    middleware?: readonly WebMiddleware[];
+    /**
+     * T5a.2 Phase E — body parser strategy.
+     *
+     * - `'inline'` (default): handle `application/json` + `text/*` only.
+     *   Returns the parsed value (object for JSON, string for text). Other
+     *   content-types (e.g., multipart) return `undefined`.
+     * - `'full'`: delegate to `parseWebRequestBody` for multipart support
+     *   + per-file size caps + max-files cap (Web Standards `request.formData()`
+     *   under the hood). Returns a `ParsedWebBody` object:
+     *   `{ json?, fields, files }`. Multipart consumers MUST opt into this
+     *   mode; JSON-only routes pay zero cost staying on `'inline'`.
+     */
+    bodyParser?: 'inline' | 'full';
+    /**
+     * T5a.2 Phase G slice 1/N — plugin lifecycle hooks.
+     *
+     * Adapters (Node, CF Workers, Bun, Deno) wire `WebPluginContext`-shaped
+     * hooks at the executeWebRequest lifecycle. Lifecycle order mirrors the
+     * Fastify / Hono convention:
+     *
+     *   1. CSRF check (when opts.csrfMode === 'strict')
+     *   2. onRequest — earliest, before body parsing. Plugins can short-circuit
+     *      by setting `ctx.response` (handler skipped; subsequent hooks see
+     *      the short-circuit response).
+     *   3. body parse (inline OR full per opts.bodyParser)
+     *   4. preHandler — after body parsed, before handler runs. Same
+     *      short-circuit semantic.
+     *   5. handler invocation
+     *   6. onResponse — after handler returns OR after a hook short-circuit.
+     *      `ctx.response` is populated.
+     *   7. onError — fires if any of (handler, onRequest, preHandler) throws.
+     *      `ctx.response` is the envelope-shaped error response built via
+     *      serverErrorToEnvelope.
+     *
+     * `responseHeaders` is shared across hooks; the final Response merges
+     * them with the handler's Response headers (handler headers win on
+     * conflict; hook headers add new ones). Decorations made via
+     * `ctx.ctx[key] = value` persist across hooks (request-scoped state).
+     *
+     * `hooks: undefined` (default) → no plugin lifecycle, Phase A behavior
+     * preserved. Production consumers wire via the WebPluginRunner facade
+     * (a future Phase G slice).
+     */
+    hooks?: {
+        onRequest?: readonly WebOnRequestHook[];
+        preHandler?: readonly WebPreHandlerHook[];
+        onResponse?: readonly WebOnResponseHook[];
+        onError?: readonly WebOnErrorHook[];
+    };
+    /**
+     * Stable request identifier propagated into hook contexts. Adapters
+     * resolve via traceparent / x-request-id / generated UUID (see
+     * `extractTraceIdFromRequest` from Phase C slice 1/2). Default:
+     * `globalThis.crypto.randomUUID()`.
+     */
+    requestId?: string;
+}
+declare function executeWebRequest(request: Request, routeModule: WebRouteModule, opts?: ExecuteWebRequestOptions): Promise<Response>;
+
+/**
+ * M33 — the SINGLE route-input validation pipeline, shared by the HTTP path (`web-handler.ts`
+ * `runHandler`) and the in-process caller (`in-process-caller.ts` `callProcedure`).
+ *
+ * Both surfaces validate the same three channels (`query`/`body`/`params`) against the same
+ * `RouteConfig` Zod schemas. Extracting the logic here means there is ONE validation pipeline
+ * (no duplication, no drift) — each caller only differs in how it MAPS a failure: the HTTP path
+ * emits a 400 Response, the in-process path throws a typed error.
+ */
+
+/** The three request-input channels a route may declare a Zod schema for. */
+type RouteInputChannel = 'query' | 'body' | 'params';
+/**
+ * The minimal structural shape the validator needs: the three optional channel schemas. Both
+ * `RouteConfig` (the 5-arity generic contract) and `WebRouteHandlerConfig` (the Web runtime shape)
+ * satisfy this — the validator depends only on the schemas, not the full route generic.
+ */
+interface RouteInputSchemas {
+    query?: z.ZodType;
+    body?: z.ZodType;
+    params?: z.ZodType;
+}
+/** Raw (pre-validation) channel values. A channel absent from the config passes through unchanged. */
+interface RawRouteInput {
+    query?: unknown;
+    body?: unknown;
+    params?: unknown;
+}
+/** Discriminated result — each caller maps `ok:false` to its own surface (Response vs throw). */
+type RouteInputValidation = {
+    ok: true;
+    query: unknown;
+    body: unknown;
+    params: unknown;
+} | {
+    ok: false;
+    channel: RouteInputChannel;
+    error: z.ZodError;
+};
+/**
+ * Validate the three input channels against the route's declared Zod schemas. A channel with no
+ * declared schema passes its raw value through. First failing channel short-circuits (query → body
+ * → params order, matching `runHandler`).
+ */
+declare function validateRouteInput(config: RouteInputSchemas, raw: RawRouteInput): RouteInputValidation;
+
+/**
+ * M33 Phase 1 — `callProcedure`, the in-process typed caller.
+ *
+ * The load-bearing seam for non-HTTP surfaces (TUI / Tauri / MCP-tools): invoke a route's shared
+ * logic with STRUCTURED input, WITHOUT going through the HTTP transport (no URL/body parsing, no
+ * middleware chain, no Response). It reuses the SAME Zod validation pipeline as the HTTP path
+ * (`validateRouteInput`) so there is no drift, and reuses the SAME `config.response` server-fault
+ * check. Failures throw typed errors (there is no HTTP status off-web).
+ *
+ * Prior art: tRPC `callProcedure` / `createCallerFactory`
+ *
+ * Design (ADR-0044 / blueprint §5.4): the AUTHOR passes structured input `{query?, body?, params?}`
+ * — never synthesizes a Request. A minimal in-process `Request` is provided to the handler ONLY so
+ * handlers that read `request.headers`/`request.url` still work (opencode's proven pattern); the
+ * input itself is NOT parsed from it.
+ */
+
+/** Structured input for an in-process procedure call — one object per declared channel. */
+type ProcedureInput = RawRouteInput;
+/**
+ * Thrown when structured input fails the route's Zod validation. The in-process analog of the HTTP
+ * 400 — carries the failing channel + the Zod issues (typed error, not a magic value; Rule 8).
+ */
+declare class ProcedureInputError extends Error {
+    readonly channel: RouteInputChannel;
+    readonly issues: z.core.$ZodIssue[];
+    constructor(channel: RouteInputChannel, error: z.ZodError);
+}
+/**
+ * Thrown when the handler's plain-object return drifts from `config.response` — a SERVER fault
+ * (the handler violated its own declared contract), mirroring the HTTP path's 500 as a throw.
+ */
+declare class ProcedureOutputError extends Error {
+    readonly issues: z.core.$ZodIssue[];
+    constructor(error: z.ZodError);
+}
+/**
+ * Invoke a route/procedure's handler in-process with structured, Zod-validated input.
+ *
+ * @param config  the `RouteConfig` (what `route().build()` produces).
+ * @param input   structured `{query?, body?, params?}` — validated by the route's schemas.
+ * @param ctx     the typed run-context the handler receives (built by the CALLER — a TUI/Tauri/MCP
+ *                surface supplies its own ctx factory; there is no HTTP middleware chain here).
+ * @returns       the handler's result (validated against `config.response` when declared).
+ * @throws ProcedureInputError  on invalid structured input (the off-web analog of a 400).
+ * @throws ProcedureOutputError on a handler output that drifts from `config.response` (server fault).
+ */
+declare function callProcedure(config: RouteConfig<z.ZodType, z.ZodType, z.ZodType>, input?: ProcedureInput, ctx?: unknown): Promise<unknown>;
+
+interface UploadedFile {
+    fieldname: string;
+    filename: string;
+    encoding: string;
+    mimeType: string;
+    buffer: Buffer;
+    size: number;
+}
+interface ParsedBody {
+    fields: Record<string, string>;
+    files: UploadedFile[];
+    json?: unknown;
+}
+interface BodyParserOptions {
+    maxFileSize?: number;
+    maxFiles?: number;
+    maxFieldSize?: number;
+}
+declare class FileTooLargeError extends Error {
+    readonly truncatedFilenames: string[];
+    readonly maxFileSize: number;
+    readonly code = "FILE_TOO_LARGE";
+    readonly status = 413;
+    constructor(message: string, truncatedFilenames: string[], maxFileSize: number);
+}
+declare function parseRequestBody(req: IncomingMessage, options?: BodyParserOptions): Promise<ParsedBody>;
+
+interface OpenApiDocsOptions {
+    /** Path to serve Scalar UI (default: '/api/docs'). */
+    docsPath?: string;
+    /** Path to serve the JSON spec (default: '/api/docs/openapi.json'). */
+    openapiJsonPath?: string;
+    /** Path to the spec file on disk (default: '.theokit/openapi.json'). */
+    specFilePath?: string;
+    /** Page title (default: 'API Reference'). */
+    pageTitle?: string;
+    /** Scalar CDN URL (default: jsdelivr). Must be HTTPS. */
+    cdnUrl?: string;
+}
+/**
+ * Creates a request handler that serves OpenAPI docs.
+ * Returns `null` for non-matching requests (passthrough).
+ */
+declare function createOpenApiHandler(opts?: OpenApiDocsOptions): (request: Request) => Response | null;
+
+/**
+ * Action protocol — cross-boundary contract for `defineAction` + `useAction`.
+ *
+ * Per plan g3-server-actions-and-useaction v1.2 § Phase 0 / T0.1, ADRs D1 (encoding)
+ * + D6 (full dot-notation path) + D7 (PII mask) — types and runtime referenced
+ * by server (`server/http/action-execute.ts`, `server/define/define-action.ts`)
+ * and client (`@theokit/react/useAction`, `vite-plugin/actions-virtual-module`).
+ *
+ * Lives in `core/contracts/` per architecture.md v3.1 exception — cross-module
+ * deep imports ALLOWED for this file. Core depends on NOTHING intra-monorepo;
+ * `extractUniversalIssues` is implemented INLINE (NOT imported from `@theokit/sdk`)
+ * to honor dep-cruiser `core-depends-on-nothing` invariant (EC-1 absorbed).
+ *
+ * Field-key convention (D6 + EC-13): dot-notation full path. Nested objects use
+ * `'user.address.zip'`; array indices use `'items.0.name'` (NOT bracket
+ * `'items[0].name'`). Root-level errors (path = []) use empty string `''`
+ * (EC-7). Consumers needing bracket notation can write a small `dotToBracket`
+ * helper in userland.
+ */
+
+/**
+ * HTTP-status mapping per IANA HTTP Status Code Registry (subset relevant to
+ * action surface). VALIDATION_ERROR → 422 is preferred over Astro's BAD_REQUEST/400
+ * (more semantic for input-shape mismatch). PAYLOAD_TOO_LARGE → 413 covers EC-3
+ * (response-side size limit; request-side reuses standard 413).
+ */
+type ActionErrorCode = 'VALIDATION_ERROR' | 'BAD_REQUEST' | 'UNAUTHORIZED' | 'FORBIDDEN' | 'NOT_FOUND' | 'METHOD_NOT_ALLOWED' | 'CONFLICT' | 'CONTENT_TOO_LARGE' | 'PAYLOAD_TOO_LARGE' | 'UNSUPPORTED_MEDIA_TYPE' | 'TOO_MANY_REQUESTS' | 'INTERNAL_SERVER_ERROR';
+/**
+ * Universal zod issue shape covering BOTH v3 (`z.ZodIssue`) and v4 (`$ZodIssue`).
+ * Duck-typed minimum surface: `{path, message}`. Implemented per EC-1 absorbed —
+ * consumers chain may ship either zod major; constructor accepts `unknown` and
+ * normalizes via `extractUniversalIssues`.
+ */
+interface UniversalZodIssue {
+    readonly path: readonly (string | number)[];
+    readonly message: string;
+    readonly code?: string;
+}
+/**
+ * `ActionError` — general server-side action failure. Discriminator `type` is
+ * literal `'TheoActionError'`; used by `ActionError.fromJson` to distinguish
+ * from `ActionInputError`.
+ */
+declare class ActionError extends Error {
+    readonly type: 'TheoActionError' | 'TheoActionInputError';
+    readonly code: ActionErrorCode;
+    readonly status: number;
+    constructor(params: {
+        code: ActionErrorCode;
+        message?: string;
+        stack?: string;
+    });
+    /**
+     * G5 T2.4 — canonical envelope view of the action error. Maps the G3
+     * ActionErrorCode to a canonical TheoErrorCode (VALIDATION_ERROR ↔
+     * UNPROCESSABLE_ENTITY, CONTENT_TOO_LARGE ↔ PAYLOAD_TOO_LARGE) so consumer
+     * UI / SDK code can switch on the unified envelope.
+     *
+     * Subclasses override to populate `ext` (see `ActionInputError.envelope`).
+     */
+    get envelope(): TheoErrorEnvelope;
+    /**
+     * Translate G3 ActionErrorCode → canonical TheoErrorCode (blueprint
+     * Recommendations § "G3 ActionError becomes inaugural envelope user").
+     */
+    static toTheoErrorCode(code: ActionErrorCode): TheoErrorCode;
+    static codeToStatus(code: ActionErrorCode): number;
+    static statusToCode(status: number): ActionErrorCode;
+    /**
+     * Parse a serialized error JSON back into the typed class hierarchy.
+     * Distinguishes `TheoActionInputError` (with `issues` array) from
+     * `TheoActionError` via the `type` discriminator. Falls back to
+     * `INTERNAL_SERVER_ERROR` for malformed bodies (non-object, missing
+     * `type`, unknown `code`).
+     */
+    static fromJson(body: unknown): ActionError;
+}
+/**
+ * `ActionInputError` — validation failure with field-level mapping.
+ *
+ * `fields` is auto-derived from `issues`: for each issue, key = full
+ * dot-notation path (`'user.address.zip'`; root-level `path:[]` → `''`;
+ * array indices as numeric segments → `'items.0.name'`). Multiple messages
+ * for the same key accumulate; duplicate (path, message) tuples are deduped.
+ */
+declare class ActionInputError extends ActionError {
+    readonly type: "TheoActionInputError";
+    readonly issues: readonly UniversalZodIssue[];
+    readonly fields: Record<string, string[]>;
+    constructor(rawIssues: unknown);
+    /**
+     * G5 T2.4 — envelope view with ValidationFieldsExt populated from .fields.
+     * UI consumers can `switch (env.code)` on `UNPROCESSABLE_ENTITY` and read
+     * `(env.ext as ValidationFieldsExt).fields` for field-level rendering.
+     */
+    get envelope(): TheoErrorEnvelope<ValidationFieldsExt>;
+}
+/**
+ * Normalize zod v3 (`z.ZodIssue`) and v4 (`$ZodIssue`) raw issues to
+ * `UniversalZodIssue[]` (EC-1 absorbed). Duck-typed on `{path, message}` —
+ * does NOT import zod types (`core/contracts/` depends on no intra-monorepo
+ * + zod is consumer-controlled across the boundary).
+ *
+ * Silently skips entries missing required fields or shape mismatches; returns
+ * empty array on non-array input.
+ */
+declare function extractUniversalIssues(raw: unknown): UniversalZodIssue[];
+/**
+ * Type guard for `ActionError` (and its subclass `ActionInputError`). True
+ * iff the value is an instance of `ActionError`. Use `isInputError` to
+ * narrow specifically to validation failures.
+ */
+declare function isActionError(value: unknown): value is ActionError;
+/**
+ * Type guard narrowing to `ActionInputError`. Requires `instanceof` check
+ * (not duck-typing on `type`) to prevent attacker-controlled JSON from
+ * being mistaken for a real error instance.
+ */
+declare function isInputError(value: unknown): value is ActionInputError;
+/**
+ * `ActionResult<TData, TError>` — discriminated union returned by client-side
+ * action invocation. Either `{data, error: undefined}` (success) or
+ * `{data: undefined, error}` (failure). Mirrors Astro `SafeResult` shape.
+ */
+type ActionResult<TData = unknown, TError extends ActionError = ActionError> = {
+    data: TData;
+    error: undefined;
+} | {
+    data: undefined;
+    error: TError;
+};
+/**
+ * `SerializedActionResult` — wire-shape emitted by `serializeActionResult`
+ * in `server/http/serialize-action-result.ts` (T1.3). Discriminator `type`
+ * distinguishes data (devalue-encoded), error (JSON), and empty (204) cases.
+ */
+type SerializedActionResult = {
+    type: 'data';
+    status: number;
+    contentType: 'application/json+devalue';
+    body: string;
+} | {
+    type: 'error';
+    status: number;
+    contentType: 'application/json';
+    body: string;
+} | {
+    type: 'empty';
+    status: 204;
+};
+/**
+ * `ActionManifestEntry` — per-action metadata emitted by `action-scan.ts`
+ * (T1.4) into `.theokit/actions-manifest.json`. Consumed by virtual module
+ * `@theo/actions` (T3.1) and G4 devtools "Actions" tab (T5.1).
+ */
+interface ActionManifestEntry {
+    readonly name: string;
+    readonly filePath: string;
+    readonly urlPath: string;
+    readonly accept: 'form' | 'json';
+    readonly hasInput: boolean;
+}
+
+export { createServerContext as $, ActionError as A, BATCH_PATH as B, type CookieOptions as C, type SerializedActionResult as D, type ExecuteActionOptions as E, FileTooLargeError as F, TRACE_PARENT_HEADER as G, type HandleBatchOptions as H, TheoError as I, type TheoTransformer as J, type UploadedFile as K, appendCookieToHeaders as L, MAX_ERROR_HTML_BYTES as M, NotFoundError as N, type OpenApiDocsOptions as O, type ParsedBody as P, appendDeleteCookieToHeaders as Q, type RawRouteInput as R, STRIPPED_HEADERS as S, TRACE_HEADER as T, type UniversalZodIssue as U, callProcedure as V, type W3CTraceContext as W, createCorsHandler as X, createCorsWebHandler as Y, createOpenApiHandler as Z, _resetMiddlewareCacheForTests as _, type ActionErrorCode as a, deleteCookie as a0, envelopeCodeToStatus as a1, executeAction as a2, executeRoute as a3, executeWebRequest as a4, extractTraceId as a5, extractTraceIdFromRequest as a6, extractUniversalIssues as a7, extractW3CTraceContext as a8, fromUnknown as a9, getCookie as aa, getCookieFromRequest as ab, handleBatchRequest as ac, handleRequestError as ad, handleWebRequestError as ae, isActionError as af, isInputError as ag, jsonTransformer as ah, loadCustomErrorPages as ai, matchesOrigin as aj, parseCookieHeader as ak, parseRequestBody as al, parseTraceparent as am, parseTraceparentContext as an, resolveTransformer as ao, runMiddlewareAndContext as ap, sendError as aq, sendJson as ar, serializeCookie as as, serveStaticFile as at, serverErrorToEnvelope as au, setCookie as av, superjsonTransformer as aw, validateRouteInput as ax, ActionInputError as b, type ActionManifestEntry as c, type ActionResult as d, type BatchExecuteFn as e, BatchPathConflictError as f, type BatchPayload as g, type BatchRequestItem as h, type BatchResponse as i, type BatchResultItem as j, type BodyParserOptions as k, type CorsConfig as l, type CorsHandler as m, type CorsOrigin as n, type CorsWebHandler as o, type CustomErrorPages as p, type ExecuteRouteContext as q, type MiddlewareResult as r, type ProcedureInput as s, ProcedureInputError as t, ProcedureOutputError as u, type RouteInputChannel as v, type RouteInputSchemas as w, type RouteInputValidation as x, type SendErrorInput as y, type SendErrorOptions as z };