theokit 0.11.7 → 0.12.0

package/dist/client/index.d.ts

@@ -1,362 +0,0 @@
-import { z } from 'zod';
-import { T as TheoErrorEnvelope } from '../error-envelope-BsNzzAV5.js';
-export { FetchOptionsLike, Fetcher, QueryKey, UseTheoQueryConfig, buildUseTheoQueryConfig, stableQueryKey } from '../react-query/index.js';
-import { A as AgentEvent, a as AgentErrorEvent } from '../agent-events-DosDXkSV.js';
-export { b as AgentMessageEvent, c as AgentThinkingEvent, d as AgentToolCallEvent, e as AgentToolResultEvent } from '../agent-events-DosDXkSV.js';
-import * as react from 'react';
-import { LinkProps as LinkProps$1 } from 'react-router';
-
-/** Infer the response type from a route's handler return */
-type InferResponse<T> = T extends {
-    handler: (...args: never[]) => infer R;
-} ? Awaited<R> : unknown;
-/** Extract the query Zod schema type, handling optional properties */
-type ExtractQuery<T> = T extends {
-    query?: infer Q;
-} ? (Q extends z.ZodType ? Q : never) : never;
-/** Extract the body Zod schema type, handling optional properties */
-type ExtractBody<T> = T extends {
-    body?: infer B;
-} ? (B extends z.ZodType ? B : never) : never;
-/** Infer query type from a route's query Zod schema */
-type InferQuery<T> = [ExtractQuery<T>] extends [never] ? undefined : ExtractQuery<T> extends z.ZodUndefined ? undefined : z.infer<ExtractQuery<T>>;
-/** Infer body type from a route's body Zod schema */
-type InferBody<T> = [ExtractBody<T>] extends [never] ? undefined : ExtractBody<T> extends z.ZodUndefined ? undefined : z.infer<ExtractBody<T>>;
-/** Build the options type based on what schemas the route has */
-type TheoFetchOptions<T> = Omit<RequestInit, 'body' | 'method'> & (InferQuery<T> extends undefined ? {
-    query?: never;
-} : {
-    query: InferQuery<T>;
-}) & (InferBody<T> extends undefined ? {
-    body?: never;
-} : {
-    body: InferBody<T>;
-});
-declare class TheoFetchError extends Error {
-    status: number;
-    code?: string;
-    issues?: unknown[];
-    /**
-     * G5 T2.1 — canonical envelope view of the server-side error. Use this in
-     * consumer code that wants to switch on a typed TheoErrorCode instead of
-     * coupling to the legacy `.status` / `.code` flat fields.
-     */
-    readonly envelope: TheoErrorEnvelope;
-    constructor(status: number, body?: unknown);
-}
-declare function theoFetch<T>(url: string, options?: TheoFetchOptions<T>): Promise<InferResponse<T>>;
-
-/**
- * Phase 3 of G1 (g1-client-codegen-plan.md):
- *
- * `createAppClient(baseUrl?, fetchImpl?)` returns a Proxy that walks property
- * access (`client.posts.id.get(...)`) into a `theoFetch` invocation against
- * `{baseUrl}/posts/{params.id}` with method `GET`.
- *
- * Type safety is delivered by the `.d.ts` file emitted in Phase 2 — this
- * runtime is structurally untyped. Power users may use `theoFetch` directly
- * when they need to escape the Proxy facade.
- *
- * Edge cases absorbed:
- *  - EC-1 (thenable trap): `then` / `catch` / `finally` / `toJSON` / `Symbol.*`
- *    return `undefined` so that accidental `await client.posts` resolves to a
- *    plain Proxy value (it is NOT thenable) instead of looping.
- *  - EC-7 (abort signal): `opts.signal` is spread through to the underlying
- *    fetchImpl unchanged — verified in unit tests.
- *
- * Bundle target: ≤ 2KB gzipped.
- */
-
-type FetchImpl = typeof theoFetch;
-interface CreateAppClientOptions {
-    /** Base URL for the API. Defaults to `/api`. */
-    baseUrl?: string;
-    /** Test-only fetch override. Production callers should not pass this. */
-    fetchImpl?: FetchImpl;
-}
-declare function createAppClient<TAppClient = unknown>(baseUrlOrOptions?: string | CreateAppClientOptions, legacyFetchImpl?: FetchImpl): TAppClient;
-
-/**
- * T5.1 — client-side microtask batching.
- *
- * Collects all `dispatch` calls within the same microtask and sends them as a
- * single HTTP POST to the configured transport. Each caller's promise resolves
- * with its own result; one failed item does not break the others (per-item
- * error isolation).
- *
- * Designed as a transport-agnostic primitive so unit tests do not require
- * network access. The default transport (fetch to `/api/__theo_batch__`)
- * lives alongside this module but is created by the consumer (e.g., theoFetch).
- */
-interface BatchRequest {
-    path: string;
-    method: string;
-    query?: Record<string, unknown>;
-    body?: unknown;
-    headers?: Record<string, string>;
-}
-type BatchResponse = {
-    index: number;
-    data: unknown;
-} | {
-    index: number;
-    error: {
-        message: string;
-        code?: string;
-    };
-};
-type BatchTransport = (requests: BatchRequest[]) => Promise<BatchResponse[]>;
-interface BatcherOptions {
-    transport: BatchTransport;
-    /** Maximum batch size before flushing into multiple parallel batches. */
-    max?: number;
-}
-interface Batcher {
-    dispatch(req: BatchRequest): Promise<unknown>;
-}
-declare function createBatcher(options: BatcherOptions): Batcher;
-
-/**
- * Accumulated assistant text (M5-1): the concatenation of every `message`
- * event's `content`. Pure. Assumes append/delta semantics — a server that
- * emits full-snapshot messages should read `events` directly.
- */
-declare function deriveLiveText(events: readonly AgentEvent[]): string;
-/**
- * The current error (M5-1): the last `error` event, or `undefined`. Surfaces
- * the full `AgentErrorEvent` (with `code`/`retriable`) so the UI can branch.
- * Pure.
- */
-declare function deriveError(events: readonly AgentEvent[]): AgentErrorEvent | undefined;
-/**
- * T5.2 — useAgentStream
- *
- * React hook to consume an agent endpoint defined with `defineAgentEndpoint`.
- *
- * Transport (ADR D7, EC-3): fetch + ReadableStream — NOT EventSource.
- * EventSource is GET-only; agent endpoints need POST + body.
- *
- * Returns:
- *   events  — array of AgentEvents accumulated so far
- *   send    — call with a payload to (re)open a stream
- *   status  — 'idle' | 'streaming' | 'done' | 'error'
- *   abort   — manually cancel an in-flight stream
- *
- * Cleanup (EC-8): on unmount, the current AbortController fires .abort(),
- * which propagates to the underlying fetch and the ReadableStream reader.
- * Safe under React.StrictMode double-mount.
- */
-type AgentStreamStatus = 'idle' | 'streaming' | 'done' | 'error';
-interface UseAgentStreamReturn<TBody = unknown> {
-    events: AgentEvent[];
-    status: AgentStreamStatus;
-    /** Accumulated assistant text — concatenation of all `message` contents (M5-1). */
-    liveText: string;
-    /** The last `error` event, or `undefined` (M5-1). */
-    error: AgentErrorEvent | undefined;
-    send: (body: TBody) => void;
-    abort: () => void;
-    reset: () => void;
-}
-interface UseAgentStreamOptions {
-    /** Extra headers (e.g., auth). */
-    headers?: Record<string, string>;
-    /** Override fetch (rare — primarily for tests). */
-    fetch?: typeof fetch;
-}
-declare function useAgentStream<TBody = unknown>(path: string, options?: UseAgentStreamOptions): UseAgentStreamReturn<TBody>;
-
-/**
- * A correlated, UI-facing view of one tool invocation (M5-2).
- *
- * `foldAgentToolCards` correlates a `tool_call` with its `tool_result` (by
- * `id`, falling back to FIFO-by-name) into a single card so consumers stop
- * hand-rolling `switch(event.type)`.
- */
-interface AgentToolCard {
-    /** Correlation id (the event `id`, or a synthesized `tool-<index>`). */
-    id: string;
-    name: string;
-    args: Record<string, unknown>;
-    status: 'running' | 'success' | 'error';
-    /** The `tool_result.data` payload, once the result arrives. */
-    result?: unknown;
-}
-/**
- * Classifies a `tool_result.data` payload as success/error. Injectable so the
- * correlator is decoupled from any specific tool-result envelope shape.
- */
-type ToolEnvelopeResolver = (data: unknown) => {
-    error: boolean;
-};
-interface FoldAgentToolCardsOptions {
-    /** Override the default envelope classifier. */
-    resolveEnvelope?: ToolEnvelopeResolver;
-}
-/**
- * Default envelope resolver: an object (or a JSON STRING parsing to an object)
- * with `ok === false` is an error; everything else is success (conservative).
- * sdk-tools handlers return a JSON STRING, so string parsing is intentional.
- */
-declare function defaultResolveEnvelope(data: unknown): {
-    error: boolean;
-};
-/**
- * Fold an `AgentEvent[]` into correlated {@link AgentToolCard}s (M5-2). Pure.
- *
- * Correlation: a `tool_result` matches its `tool_call` by `id` when both carry
- * one; otherwise it matches the oldest still-`running` card with the same
- * `name` (FIFO). An unmatched `tool_result` becomes its own finished card.
- * A `tool_call` with no result stays `running`. The error status comes from
- * `options.resolveEnvelope` (default {@link defaultResolveEnvelope}).
- */
-declare function foldAgentToolCards(events: readonly AgentEvent[], options?: FoldAgentToolCardsOptions): AgentToolCard[];
-
-/** {@link useAgentToolCards} return — the stream result plus correlated tool cards. */
-interface UseAgentToolCardsReturn<TBody = unknown> extends UseAgentStreamReturn<TBody> {
-    /** Correlated tool cards folded from the stream events (M5-2). */
-    toolCards: AgentToolCard[];
-}
-/**
- * `useAgentStream` + correlated tool cards (M5-2). Composes the stream hook with
- * the pure {@link foldAgentToolCards} reducer; pass `resolveEnvelope` to classify
- * tool-result payloads (default flags `{ ok: false }` envelopes as errors).
- */
-declare function useAgentToolCards<TBody = unknown>(path: string, options?: UseAgentStreamOptions & FoldAgentToolCardsOptions): UseAgentToolCardsReturn<TBody>;
-
-/**
- * T5.2 — Pure SSE consumer used by useAgentStream.
- *
- * Split out from the React hook so the wire behavior can be tested
- * without a DOM. The hook is glue: useState + useEffect + this primitive.
- *
- * Transport (ADR D7, EC-3): fetch + ReadableStream — NOT EventSource.
- * EventSource is GET-only and cannot carry a body. Agent endpoints need
- * POST + JSON body, so we use fetch + manual SSE chunk parsing.
- */
-interface ConsumeOptions<TBody = unknown> {
-    /** Request body — JSON-serialized into the POST. */
-    body: TBody;
-    /** Called once per SSE event parsed off the stream. */
-    onEvent: (event: AgentEvent) => void;
-    /** Optional fetch override (tests). */
-    fetch?: typeof fetch;
-    /** Optional abort signal — passed through to fetch. */
-    signal?: AbortSignal;
-    /** Extra headers (e.g., auth). */
-    headers?: Record<string, string>;
-}
-/**
- * Parse a single SSE line of the form `data: <json>`.
- * Returns null for non-data lines, comments, or malformed JSON.
- */
-declare function parseSSEChunk(line: string): AgentEvent | null;
-/**
- * POSTs to `path` with `body`, reads the SSE response, and invokes
- * `onEvent` for each parsed AgentEvent. Resolves when the server
- * closes the stream or the signal aborts.
- *
- * T1.1 — Attaches `X-Theo-Action: '1'` so 0.3.0 strict CSRF mode accepts
- * the request. The user can override (or suppress) by passing the header
- * in `options.headers` — spread order ensures their value wins.
- */
-declare function consumeAgentStream<TBody = unknown>(path: string, options: ConsumeOptions<TBody>): Promise<void>;
-
-type PrefetchBehavior = 'none' | 'intent' | 'viewport';
-interface LinkProps extends LinkProps$1 {
-    /** Prefetch strategy. Default: 'intent' (on hover + focus). */
-    prefetch?: PrefetchBehavior;
-}
-/**
- * TheoKit Link — drop-in replacement for react-router Link with prefetch.
- *
- * @example
- * ```tsx
- * import { Link } from 'theokit/client'
- *
- * <Link to="/contacts">Contacts</Link>
- * <Link to="/dashboard" prefetch="viewport">Dashboard</Link>
- * <Link to="/settings" prefetch="none">Settings</Link>
- * ```
- */
-declare function Link({ prefetch, to, onMouseEnter, onFocus, ...rest }: LinkProps): react.JSX.Element;
-
-/**
- * <Metadata> — SEO-ready head tags from a single component.
- *
- * Uses React 19's native <title>/<meta>/<link> hoisting to <head>.
- * No build-time extraction needed — works in SSR and client.
- *
- * @example
- * ```tsx
- * import { Metadata } from 'theokit/client'
- *
- * export default function ContactsPage() {
- *   return (
- *     <>
- *       <Metadata
- *         title="Contacts | My CRM"
- *         description="Manage your contacts"
- *         ogImage="/og/contacts.png"
- *         canonical="https://mycrm.com/contacts"
- *       />
- *       <h1>Contacts</h1>
- *     </>
- *   )
- * }
- * ```
- */
-interface MetadataProps {
-    title?: string;
-    description?: string;
-    canonical?: string;
-    ogTitle?: string;
-    ogDescription?: string;
-    ogImage?: string;
-    ogType?: string;
-    ogUrl?: string;
-    twitterCard?: 'summary' | 'summary_large_image';
-    /** Custom meta tags rendered as children */
-    children?: React.ReactNode;
-}
-declare function Metadata(props: MetadataProps): react.JSX.Element;
-
-/**
- * <Image> — optimized image component with lazy loading.
- *
- * Renders a standard <img> with:
- *   - loading="lazy" by default (eager with priority={true})
- *   - decoding="async" for non-blocking decode
- *   - width/height for CLS prevention
- *   - srcSet/sizes forwarded for responsive images
- *
- * No CDN, no Sharp, no build-time optimization — pure HTML attributes
- * that deliver 80% of the performance value at zero complexity.
- *
- * @example
- * ```tsx
- * import { Image } from 'theokit/client'
- *
- * <Image src="/team.jpg" alt="Team photo" width={800} height={600} />
- * <Image src="/hero.jpg" alt="Hero" priority />
- * <Image
- *   src="/product.jpg"
- *   alt="Product"
- *   width={400}
- *   height={300}
- *   srcSet="/product-400.jpg 400w, /product-800.jpg 800w"
- *   sizes="(max-width: 768px) 100vw, 400px"
- * />
- * ```
- */
-interface ImageProps extends React.ImgHTMLAttributes<HTMLImageElement> {
-    /** Image source URL (required). */
-    src: string;
-    /** Alt text for accessibility (required). */
-    alt: string;
-    /** If true, loading="eager" — use for above-the-fold images. */
-    priority?: boolean;
-}
-declare function Image({ priority, loading, decoding, ...props }: ImageProps): react.JSX.Element;
-
-export { AgentErrorEvent, AgentEvent, type AgentStreamStatus, type AgentToolCard, type BatchRequest, type BatchResponse, type BatchTransport, type Batcher, type BatcherOptions, type ConsumeOptions, type CreateAppClientOptions, type FoldAgentToolCardsOptions, Image, type ImageProps, type InferBody, type InferQuery, type InferResponse, Link, type LinkProps, Metadata, type MetadataProps, type PrefetchBehavior, TheoFetchError, type TheoFetchOptions, type ToolEnvelopeResolver, type UseAgentStreamOptions, type UseAgentStreamReturn, type UseAgentToolCardsReturn, consumeAgentStream, createAppClient, createBatcher, defaultResolveEnvelope, deriveError, deriveLiveText, foldAgentToolCards, parseSSEChunk, theoFetch, useAgentStream, useAgentToolCards };

package/dist/csrf-BBrEZSBW.d.ts

@@ -1,107 +0,0 @@
-import { IncomingMessage } from 'node:http';
-import { A as AuditLogger } from './audit-log-BQWM5YLG.js';
-
-/**
- * CSRF enforcement mode.
- *
- * - `off`     — skip CSRF entirely. Use only when you have another defense
- *               (e.g. you don't ship session cookies, all auth is bearer).
- * - `warn`    — log a structured warning when the check would fail, but
- *               still serve the request. Default for 0.2.0. Migration mode.
- * - `strict`  — reject failing requests with 403 + code `CSRF_INVALID`.
- *               Will become the default in 0.3.0.
- */
-type CsrfMode = 'off' | 'warn' | 'strict';
-/**
- * Per-request structured logger surface. Only `warn` is used by enforceCsrf;
- * we don't require a full Logger here so callers can pass a mock or the
- * console directly.
- */
-interface CsrfLogger {
-    warn: (payload: CsrfWarnPayload) => void;
-    /** Optional path the request was destined for — used for log correlation. */
-    path?: string;
-}
-/**
- * T5.1 — Rails-inspired per-route escalation.
- *
- * `routes` accepts string (exact match) or RegExp entries. When a request
- * path matches AND the request would otherwise emit a warning, the
- * `behavior` field decides what happens:
- *
- *   - `'warn'`  → normal warn dispatch (no-op vs default)
- *   - `'raise'` → escalate to 403 regardless of global `csrf` mode
- *
- * `'raise'` never downgrades: when global mode is `'off'`, validation is
- * skipped entirely and disallowed dispatch never runs.
- */
-interface DisallowedConfig {
-    routes: (string | RegExp)[];
-    behavior: 'warn' | 'raise';
-}
-/**
- * Test whether `path` matches any of the supplied patterns. String
- * patterns are EXACT (trailing slash matters — use RegExp for tolerance).
- *
- * EC-5: when a RegExp carries the `/g` flag, `.test()` mutates
- * `lastIndex` and the next invocation may miss. We reset `lastIndex`
- * before each test so the matcher is a pure function.
- */
-declare function matchDisallowed(path: string, patterns: readonly (string | RegExp)[]): boolean;
-/**
- * T2.2 — Stable cutover identifier shipped with every csrf.warn payload.
- *
- * Convention borrowed from Vite's `deprecations.ts:74` — a `code` plus a
- * `docsUrl` lets users (a) grep their logs for a single stable identifier
- * to find every csrf.warn line, and (b) click through directly to the
- * migration guide. Strings are exported constants so the analyzer (T2.3)
- * and migration guide can reference the same source of truth.
- */
-declare const CSRF_WARN_CODE: "CSRF_STRICT_CUTOVER";
-declare const CSRF_WARN_DOCS_URL: "https://theokit.dev/upgrade/csrf-strict-cutover";
-interface CsrfWarnPayload {
-    event: 'csrf.warn';
-    method: string;
-    path: string | undefined;
-    reason: string;
-    /**
-     * Stable identifier for the 0.2 → 0.3 CSRF strict cutover. Always
-     * `'CSRF_STRICT_CUTOVER'`. Grep-able from prod logs.
-     */
-    code: string;
-    /**
-     * Link to the section of the migration guide explaining how to clear
-     * this specific warning class.
-     */
-    docsUrl: string;
-}
-declare function validateCsrf(req: IncomingMessage): {
-    valid: true;
-} | {
-    valid: false;
-    reason: string;
-};
-/**
- * T5a.2 Phase B (slice 1/6) — Web-Standards-shaped CSRF validator.
- *
- * Mirror of `validateCsrf(req: IncomingMessage)` for the Web `Request`
- * shape. Consumes `request.headers.get(name)` (native Web `Headers` API)
- * instead of `req.headers[name]` (Node `IncomingMessage` indexer). Same
- * CSRF policy + same return shape — the difference is only the input
- * extraction.
- *
- * Used by `executeWebRequest` (T5a.2 Phase A) to enforce CSRF on the
- * Web-Standards request handler entry-point.
- */
-declare function validateCsrfRequest(request: Request): {
-    valid: true;
-} | {
-    valid: false;
-    reason: string;
-};
-declare function enforceCsrf(req: IncomingMessage, mode: CsrfMode, logger?: CsrfLogger, disallowed?: DisallowedConfig, auditLogger?: AuditLogger): {
-    allow: boolean;
-    reason?: string;
-};
-
-export { CSRF_WARN_CODE as C, type DisallowedConfig as D, CSRF_WARN_DOCS_URL as a, type CsrfLogger as b, type CsrfMode as c, type CsrfWarnPayload as d, enforceCsrf as e, validateCsrfRequest as f, matchDisallowed as m, validateCsrf as v };

package/dist/csrf-readiness-store-CjIoub3U.d.ts

@@ -1,43 +0,0 @@
-/**
- * T2.2 — In-memory bounded counter for CSRF warn events.
- *
- * Aggregates `csrf.warn` payloads by `(method, path, reason)` triple.
- * Used by the `/__theo/csrf-readiness` endpoint to expose a summary the
- * developer (or devtools tab) can inspect, so users do NOT need to grep
- * stdout to know which endpoints will break under 0.3.0 strict CSRF.
- *
- * Bounded at 1000 distinct keys (EC-22). Eviction is LRU-by-insertion —
- * when the cap is hit, the oldest key is dropped and a re-record of an
- * evicted key starts fresh (count: 1).
- *
- * Single-threaded by virtue of the JS event loop; Map operations are
- * atomic. NOT shared across processes — each worker has its own store.
- */
-interface CsrfWarnRecord {
-    method: string;
-    path: string;
-    reason: string;
-}
-interface CsrfReadinessRouteSummary {
-    method: string;
-    path: string;
-    reason: string;
-    count: number;
-    firstSeen: string;
-    lastSeen: string;
-}
-interface CsrfReadinessSummary {
-    generatedAt: string;
-    totalEvents: number;
-    routes: CsrfReadinessRouteSummary[];
-}
-declare class CsrfReadinessStore {
-    static readonly MAX_ENTRIES = 1000;
-    private readonly entries;
-    private keyFor;
-    record(event: CsrfWarnRecord): void;
-    summary(): CsrfReadinessSummary;
-    reset(): void;
-}
-
-export { CsrfReadinessStore as C, type CsrfReadinessRouteSummary as a, type CsrfReadinessSummary as b, type CsrfWarnRecord as c };

package/dist/define-websocket-CdK94O-D.d.ts

@@ -1,64 +0,0 @@
-import { IncomingMessage } from 'node:http';
-
-interface WebSocketLike {
-    send(data: string | Buffer): void;
-    close(code?: number, reason?: string): void;
-}
-interface WebSocketHandler {
-    onOpen?: (ws: WebSocketLike, req: IncomingMessage) => void;
-    onMessage?: (ws: WebSocketLike, data: string | Buffer) => void;
-    onClose?: (ws: WebSocketLike, code: number, reason: Buffer) => void;
-    onError?: (ws: WebSocketLike, error: Error) => void;
-}
-/**
- * Define a WebSocket endpoint handler.
- * Identity function — provides type inference for WebSocket handlers.
- */
-declare function defineWebSocket(handler: WebSocketHandler): WebSocketHandler;
-/**
- * T5a.2 Phase F slice 3/3 — Web-Standards WebSocket endpoint handler.
- *
- * Mirror of `WebSocketHandler` for the Web `Request` shape. `onOpen`
- * receives `request: Request` instead of `req: IncomingMessage`. The
- * rest of the lifecycle (onMessage, onClose, onError) is shape-agnostic
- * (`WebSocketLike` is already Web-standards-compatible per the existing
- * design — `send(string | Buffer)` works on both Node `ws` and Web
- * `WebSocket` instances; CF Workers / Bun / Deno coerce as needed at
- * the adapter boundary).
- *
- * Per `docs/plans/t5a2-incoming-message-to-request-shape-refactor-plan.md`
- * v1.0 § Phase F (closes Phase F).
- *
- * **Architectural note — WebSocket upgrade semantics differ across runtimes:**
- *   - Node + `ws`: `WebSocketServer.handleUpgrade(req, socket, head, cb)` —
- *     `req` is `IncomingMessage`. Use `WebSocketHandler`.
- *   - CF Workers: `new WebSocketPair()` + `request.headers` (the upgrade
- *     handshake IS a Web Request). Use `WebSocketHandlerWeb`.
- *   - Bun: `server.upgrade(request, { data })` — same Web Request shape.
- *   - Deno: `Deno.upgradeWebSocket(request)` — same Web Request shape.
- *
- * Cross-runtime WebSocket endpoints ship BOTH `WebSocketHandler` +
- * `WebSocketHandlerWeb` exports; the runtime adapter picks the matching
- * one. This is the canonical Hono / Nitric pattern.
- */
-interface WebSocketHandlerWeb {
-    onOpen?: (ws: WebSocketLike, request: Request) => void;
-    onMessage?: (ws: WebSocketLike, data: string | Uint8Array) => void;
-    onClose?: (ws: WebSocketLike, code: number, reason: string) => void;
-    onError?: (ws: WebSocketLike, error: Error) => void;
-}
-/**
- * Web-Standards `defineWebSocket` sibling. Identity function — provides
- * type inference for Web WebSocket handlers.
- *
- * **Type difference note vs Node path:**
- *   - `onMessage` data is `string | Uint8Array` instead of `string | Buffer`
- *     (Web standards have no `Buffer`; Node's Buffer is a Uint8Array
- *     subclass so the Node path's Buffer values flow through unchanged
- *     when adapters wrap them).
- *   - `onClose` reason is `string` instead of `Buffer` (Web `CloseEvent`
- *     exposes the reason as a UTF-8 string natively).
- */
-declare function defineWebSocketWeb(handler: WebSocketHandlerWeb): WebSocketHandlerWeb;
-
-export { type WebSocketHandler as W, type WebSocketHandlerWeb as a, type WebSocketLike as b, defineWebSocketWeb as c, defineWebSocket as d };

package/dist/devtools/entry.d.ts

@@ -1,5 +0,0 @@
-declare global {
-    interface Window {
-        __theoDevtoolsMounted?: boolean;
-    }
-}

package/dist/error-envelope-BsNzzAV5.d.ts

@@ -1,62 +0,0 @@
-/**
- * Error envelope — canonical cross-layer contract for theokit framework, SDK,
- * and UI per plan g5-error-envelope-cross-layer v1.0 § Phase 1 / T1.1.
- *
- * Blueprint G5 (SHIPPABLE_WITH_CAVEATS 89/100) — Form 4 Hybrid: shared CODE
- * enum + per-domain extensions + 2-layer SDK boundary translation.
- *
- * 3/3 references convergence: code + message + cause base (trpc TRPCError
- * + hono HTTPException + encore Error). Wasp confirms ecosystem gap.
- *
- * Reference anchors (verified file:line):
- * - referencia: trpc/packages/server/src/unstable-core-do-not-import/error/TRPCError.ts:65-87
- * - referencia: trpc/packages/server/src/unstable-core-do-not-import/rpc/codes.ts:11-44,76-81
- * - referencia: hono/src/http-exception.ts:46-78
- * - referencia: encore/runtimes/go/beta/errs/error.go:38-55 (Go — D4 disclaimer applied)
- *
- * Per blueprint ADR D2: retryable + hint are extension slots, NOT base fields
- * (3/3 references derive retryability from code identity; no reference ships
- * a `retryable: boolean` on envelope; `hint` is novel).
- *
- * Per blueprint ADR D5: server-only `meta` filtered at serializer boundary
- * (encore `json:"-"` analog).
- *
- * Lives in `core/contracts/` per architecture.md v3 — canonical home for
- * shared client↔server types. Zero intra-monorepo deps; zero runtime deps
- * (trpc + hono ship envelope with zero runtime deps per blueprint Q5).
- */
-/**
- * Canonical TheoKit error code union. HTTP-status flavor + SDK/agent-domain
- * additions per blueprint Recommendations § concrete shape.
- *
- * String-literal union mirrors trpc's TRPC_ERROR_CODE_KEY pattern — enables
- * exhaustive `switch (env.code)` narrowing in consumer code (UI display
- * dispatch, retry-policy gates, telemetry classification).
- */
-type TheoErrorCode = 'BAD_REQUEST' | 'UNAUTHORIZED' | 'FORBIDDEN' | 'NOT_FOUND' | 'METHOD_NOT_ALLOWED' | 'CONFLICT' | 'PRECONDITION_FAILED' | 'PAYLOAD_TOO_LARGE' | 'UNSUPPORTED_MEDIA_TYPE' | 'UNPROCESSABLE_ENTITY' | 'TOO_MANY_REQUESTS' | 'INTERNAL_SERVER_ERROR' | 'NOT_IMPLEMENTED' | 'BAD_GATEWAY' | 'SERVICE_UNAVAILABLE' | 'GATEWAY_TIMEOUT' | 'AGENT_RUN_ERROR' | 'PROVIDER_KEY_MISSING' | 'BUDGET_EXCEEDED' | 'RATE_LIMITED' | 'CREDENTIAL_POOL_EXHAUSTED';
-/**
- * Base envelope shape — `{ code, message, cause?, meta?, ext? }`.
- *
- * `cause` follows TC39 proposal-error-cause (universal pattern, 3/3 references).
- * `meta` is server-only metadata filtered at serializer boundary per ADR D5
- * (`stack` is auto-stripped in non-dev builds — see T1.2 `TheoError.toJSON()`).
- * `ext` carries opt-in per-domain extensions (`ValidationFieldsExt`,
- * `RetryableExt`, `HintExt`, or arbitrary user-defined types via formatter hook).
- */
-interface TheoErrorEnvelope<TExt = unknown> {
-    readonly code: TheoErrorCode;
-    readonly message: string;
-    readonly cause?: unknown;
-    readonly meta?: Record<string, unknown>;
-    readonly ext?: TExt;
-}
-/**
- * `ValidationFieldsExt` — validation-failure extension carrying the dot-notation
- * field map identical to G3 `ActionInputError.fields`. Empty-string key for
- * root-level errors (mirrors G3 EC-7). Multiple messages per key are preserved.
- */
-interface ValidationFieldsExt {
-    readonly fields: Record<string, string[]>;
-}
-
-export type { TheoErrorEnvelope as T, ValidationFieldsExt as V, TheoErrorCode as a };