@kitn.ai/ui 0.20.1 → 0.21.0

package/dist/wire/chunk.d.ts

@@ -0,0 +1,171 @@
+import { RawOrigin, ToolPart } from '../components/tool-types.js';
+import { MessagePart, MessageSource } from '../elements/chat-types.js';
+import { ReasoningOpts } from '../state/parts.js';
+/** One fragment of a tool call. */
+export interface ModelToolCallDelta {
+    /**
+     * The ONLY thing correlating fragments, and its NAMESPACE IS FORMAT-DEFINED.
+     * `openaiChatFormat` uses the position in `delta.tool_calls`;
+     * `anthropicMessagesFormat` uses the content-block index. Both are correct and
+     * both are stable within one stream, but they are not the same number, so a
+     * third-party format must pick one and stay consistent with itself.
+     */
+    index: number;
+    id?: string;
+    /** Usually whole on the first fragment; a few providers split it. */
+    name?: string;
+    /** A FRAGMENT of the JSON arguments string, not valid JSON on its own. */
+    arguments?: string;
+    /** A result the PROVIDER executed (Anthropic web_search_tool_result, an OpenAI
+     *  built-in). Completes the panel with no host work. */
+    output?: Record<string, unknown>;
+    /** A provider-executed tool that failed. */
+    outputError?: string;
+}
+/** Field names are deliberately provider-neutral. OpenAI says prompt/completion,
+ *  Anthropic says input/output; input/output is the one that reads correctly for
+ *  both. */
+export interface ModelUsage {
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+    /** Non-zero proves the model reasoned even when no reasoning text streamed. */
+    reasoningTokens?: number;
+    cachedInputTokens?: number;
+    costUsd?: number;
+}
+export interface ModelStreamChunk {
+    text?: string;
+    /**
+     * Reasoning delta. `''` is MEANINGFUL, not a no-op: a redacted block has no
+     * readable text but still carries a payload that must round-trip, and a format
+     * uses an empty delta to OPEN a reasoning part at the right position in the
+     * stream so block order survives into `parts`.
+     */
+    reasoning?: string;
+    /** The provider's BLOCK index. Keeps parallel reasoning blocks distinct.
+     *  Omitted means block 0, the single-block case every provider degrades to. */
+    reasoningIndex?: number;
+    /**
+     * The UNTRANSLATED provider payload for this reasoning block. Valid on a chunk
+     * with NO reasoning text at all, which is the whole point: Anthropic returns
+     * 400 if a `thinking` block is modified, reordered or RECONSTRUCTED, so an
+     * encoder has to echo the original block rather than rebuild one from `text`
+     * plus `signature`.
+     */
+    reasoningRaw?: RawOrigin;
+    /** Informational. `reasoningRaw` is the round-trip channel, not this. */
+    reasoningSignature?: string;
+    toolCalls?: ModelToolCallDelta[];
+    /** Citations the model produced. A run of consecutive `source` parts renders
+     *  as one citation row (`part="citations"`), outside the message bubble. */
+    sources?: MessageSource[];
+    /** Provider VERBATIM: 'stop' | 'tool_calls' | 'end_turn' | 'max_tokens' | ...
+     *  Normalizing in place would destroy information consumers branch on. */
+    finishReason?: string | null;
+    usage?: ModelUsage;
+    /** An in-band provider error (the HTTP response was already 200). */
+    error?: {
+        code?: string | number;
+        message: string;
+    };
+}
+/** One vocabulary across formats, for code that has to BRANCH. `finishReason`
+ *  stays beside it, verbatim, for code that has to REPORT. */
+export type StopReason = 'stop' | 'length' | 'tool-calls' | 'content-filter' | 'error' | 'other';
+/** Unknown reasons degrade to 'other' rather than throwing: providers add stop
+ *  reasons without warning and a new one must not take a turn down. */
+export declare function normalizeStopReason(finishReason: string | null | undefined): StopReason | undefined;
+/**
+ * The subset of the kit's `AssistantStream` the adapter drives. Declared
+ * STRUCTURALLY so the adapter has no runtime dependency on a stream
+ * implementation and can be tested against a recorder. The kit's real
+ * `AssistantStream` satisfies it as-is: same method names, same arities, and its
+ * `AssistantStream` returns are assignable to `unknown`.
+ *
+ * `addSource` is optional so a hand-rolled three-method sink still compiles.
+ */
+export interface AssistantStreamSink {
+    appendText(delta: string): unknown;
+    appendReasoning(delta: string, opts?: ReasoningOpts): unknown;
+    /** Create-or-merge. There is no separate "announce" call: handing a patch for
+     *  an unknown `toolCallId` creates the ToolPart, and every later patch merges. */
+    upsertTool(toolCallId: string, patch: Partial<ToolPart>): unknown;
+    addSource?(source: MessageSource): unknown;
+}
+/** One tool call reassembled out of the stream's fragments. */
+export interface ModelToolCall {
+    /** The delta index that correlated this call's fragments. */
+    index: number;
+    /** Provider call id (synthesised as `call_<index>` if the provider omits it). */
+    id: string;
+    name: string;
+    /** The RAW accumulated argument fragments. Echo THIS back on the next turn,
+     *  not a re-stringified parse. */
+    argumentsText: string;
+    /** Parsed arguments: present only when `argumentsText` was a valid JSON object. */
+    input?: Record<string, unknown>;
+    /** Present only for a call the PROVIDER executed. */
+    output?: Record<string, unknown>;
+    /** True when the provider ran the tool and returned its result in-stream. The
+     *  host must NOT execute these. */
+    providerExecuted?: boolean;
+    /** Why this call is unusable (malformed or truncated args, missing name). */
+    error?: string;
+}
+/** Everything one assistant turn produced. */
+export interface ModelTurn {
+    /** The turn as ORDERED MESSAGE PARTS, built with the kit's own part builders,
+     *  so it is exactly what the sink was driven with. Covers this turn only. */
+    parts: MessagePart[];
+    /** Flat concatenation of the text deltas. The provider wire format is a flat
+     *  string, so this is kept for encoders. Not the content model. */
+    text: string;
+    /** Flat concatenation of the reasoning deltas, for the same reason. */
+    reasoning: string;
+    toolCalls: ModelToolCall[];
+    sources: MessageSource[];
+    /** The provider's own word for why it stopped. Never normalized. */
+    finishReason: string | null;
+    /** The same fact in one vocabulary. Branch on this. */
+    stopReason?: StopReason;
+    error?: {
+        code?: string | number;
+        message: string;
+    };
+    usage?: ModelUsage;
+    /** How many chunks carried a NON-EMPTY reasoning delta. Zero with a non-zero
+     *  `usage.reasoningTokens` means the provider hid the thinking text. */
+    reasoningChunks: number;
+    chunks: number;
+}
+export interface ConsumeOptions {
+    /** Label for the reasoning disclosure. Defaults to 'Thinking'. */
+    reasoningLabel?: string;
+    /** Fires once per tool call the moment its arguments parse cleanly. This is
+     *  the hook a host's tool loop waits on. There is deliberately no
+     *  per-fragment callback: `ToolPart.rawInput` is written on every fragment,
+     *  so the streaming text is already on the part. */
+    onToolCallReady?: (call: ModelToolCall) => void;
+}
+/** Per-stream state for one format. */
+export interface WireFormatReader {
+    /**
+     * Map one decoded frame onto zero or more neutral chunks. Returns an ARRAY
+     * because the mapping is not one-to-one: an Anthropic `message_start` yields
+     * usage, a `content_block_start` for `tool_use` yields an id-plus-name delta,
+     * a `ping` yields nothing.
+     *
+     * MUST NOT throw on an unrecognized frame. Return `[]` instead: providers add
+     * event types without warning.
+     */
+    push(frame: unknown): ModelStreamChunk[];
+}
+/** A pluggable wire format. Values, not a flag, so a third party can add one
+ *  without a PR to this repo. */
+export interface WireFormat {
+    readonly id: string;
+    /** Called once per stream so a format can hold per-stream state. Two calls
+     *  must share NOTHING. */
+    open(): WireFormatReader;
+}

package/dist/wire/consume.d.ts

@@ -0,0 +1,26 @@
+import { AssistantStreamSink, ConsumeOptions, ModelStreamChunk, ModelToolCall, ModelToolCallDelta, ModelTurn, StopReason } from './chunk.js';
+/**
+ * Correlate tool-call fragments by `index` and drive the ToolPart lifecycle.
+ * THE HARD PART: `id`, `name` and each slice of `arguments` arrive across
+ * arbitrarily many chunks in provider-dependent order.
+ *
+ * A ToolPart is pushed (`input-streaming`) the first time a call has BOTH an id
+ * and a non-empty name: announcing earlier would create a panel whose `type` is
+ * the empty string. Everything before that is buffered and flushed at announce.
+ */
+export declare function createToolCallAccumulator(sink: AssistantStreamSink, opts?: ConsumeOptions): {
+    apply: (raw: ModelToolCallDelta) => void;
+    settle: (stopReason: StopReason | undefined, streamError?: string) => ModelToolCall[];
+};
+/**
+ * Read one turn's worth of `ModelStreamChunk`s and drive `sink` with them.
+ *
+ * The sink is expected to be the kit's `AssistantStream`, which produces a NEW
+ * message object (and a new `parts` array) on every real mutation: that is what
+ * makes `<kai-thread>` re-render. This adapter calls the sink once per delta and
+ * never batches; batching is a host concern.
+ *
+ * This is also the escape hatch for a consumer who already has neutral chunks
+ * from somewhere else and does not need a WireFormat at all.
+ */
+export declare function consumeModelStream(chunks: AsyncIterable<ModelStreamChunk>, sink: AssistantStreamSink, opts?: ConsumeOptions): Promise<ModelTurn>;

package/dist/wire/encode.d.ts

@@ -0,0 +1,148 @@
+import { ChatMessage } from '../elements/chat-types.js';
+export interface OpenAIToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+/** One `reasoning_details` entry. Provider-owned open shape, kept as a record
+ *  for the same reason `AnthropicContentBlock` is: an opaque entry has to pass
+ *  through UNTOUCHED, and a closed type would be a list of the fields we happen
+ *  to have seen. */
+export type OpenAIReasoningDetail = Record<string, unknown>;
+export interface OpenAIWireMessage {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string | null;
+    tool_calls?: OpenAIToolCall[];
+    tool_call_id?: string;
+    name?: string;
+    /** Only ever present when `toOpenAIMessages` was asked for it. See
+     *  `OpenAIEncodeOptions.reasoning`. */
+    reasoning_details?: OpenAIReasoningDetail[];
+}
+export interface OpenAIEncodeOptions {
+    /**
+     * Whether to send the assistant's own reasoning back with the thread.
+     *
+     * DEFAULT `'omit'`, and that default is a measurement, not caution. Omitting
+     * reasoning is accepted by every configuration tested -- five live omission
+     * trials plus 28 recorded live requests per configuration across the spike's
+     * conformance sweep, zero 400s -- so the path that ships today demonstrably
+     * works, while including reasoning cost about 25% more prompt tokens per round
+     * when measured (665 -> 834 on a two-round loop). A library does not get to
+     * raise every consumer's bill and add a new provider-validation surface as a
+     * side effect of a bug fix.
+     *
+     * `'include'` is for a multi-round TOOL loop, which is where OpenRouter says it
+     * pays: "when you post tool results, including the original reasoning ensures
+     * the model can continue its reasoning from where it left off". Measured
+     * accepted (HTTP 200) for a signed Anthropic block and for an OpenAI encrypted
+     * block, over the OpenAI-compatible wire.
+     *
+     * The Anthropic wire has no such knob because it has no such choice: a filtered
+     * or rebuilt thinking block there is a hard 400.
+     */
+    reasoning?: 'omit' | 'include';
+}
+/** Anthropic content blocks are an open, provider-owned union. Keeping them as
+ *  records is what lets a verbatim `thinking` payload pass through UNTOUCHED,
+ *  which is the entire point of this encoder. */
+export type AnthropicContentBlock = Record<string, unknown>;
+export interface AnthropicWireMessage {
+    role: 'user' | 'assistant';
+    content: AnthropicContentBlock[];
+}
+/** A message cannot be encoded without losing something the provider will reject.
+ *  Thrown at encode time, on purpose: a throw here beats a 400 at request time,
+ *  because here you still know which message and which part caused it. */
+export declare class WireEncodeError extends Error {
+    readonly messageId: string;
+    readonly partIndex: number;
+    constructor(message: string, messageId: string, partIndex: number);
+}
+/**
+ * ChatMessage[] to an OpenAI chat-completions `messages` array.
+ *
+ * ONE ChatMessage CAN BECOME SEVERAL WIRE MESSAGES. The kit streams a whole
+ * assistant turn into a single message, so text, a tool call and the model's
+ * answer to that call all live in one `parts` array. The OpenAI wire has no such
+ * shape: a `role:'tool'` result must sit between the assistant message that
+ * announced the call and whatever the model said afterwards. So the turn is
+ * SPLIT at each tool boundary, into
+ *
+ *   assistant(pre-tool text + tool_calls) -> tool(result)... -> assistant(answer)
+ *
+ * Flattening instead would put the model's answer BEFORE the result it was based
+ * on. No endpoint rejects that, which is exactly why it is worth spelling out:
+ * it quietly degrades every later round of a tool loop.
+ *
+ * Consecutive tool parts stay in ONE assistant message, because parallel calls
+ * are announced together and their results follow together.
+ *
+ * A turn that encodes to nothing is SKIPPED, never sent as `{ content: null }`
+ * with no `tool_calls`: OpenAI treats `content` as required unless `tool_calls`
+ * is present, and strict-compatible endpoints reject it.
+ *
+ * REASONING IS OPT-IN, and off by default. OpenRouter's OpenAI-compatible
+ * endpoint does have a channel on the way back in -- `reasoning_details` on the
+ * assistant message -- and `{ reasoning: 'include' }` uses it, one entry per
+ * reasoning part, in part order, reassembled by `reasoningDetailOf` rather than
+ * echoed out of `part.raw`. Read that function for which blocks make it and why.
+ * The default omits, because omitting is measured-accepted everywhere and costs
+ * about 25% fewer prompt tokens per round; see `OpenAIEncodeOptions.reasoning`.
+ *
+ * Reasoning alone still encodes to NOTHING. A block is content the model already
+ * produced, not a reason to send a turn, so a message carrying reasoning and no
+ * text and no settled tool is skipped exactly as before, rather than becoming
+ * `{ content: null }` with no `tool_calls`.
+ *
+ * `card`, `source` and `file` parts are never encoded; they are kit-side. File
+ * attachments are a documented v1 limitation, which is why a user turn carrying
+ * only an attachment encodes to nothing and is skipped.
+ */
+export declare function toOpenAIMessages(messages: ChatMessage[], options?: OpenAIEncodeOptions): OpenAIWireMessage[];
+/**
+ * ChatMessage[] to an Anthropic Messages `messages` array. THE ROUND-TRIP
+ * ENCODER.
+ *
+ * A reasoning block is emitted as `part.raw.payload` verbatim and is NEVER
+ * rebuilt from `text` plus `signature`: Anthropic returns 400 if a thinking
+ * block in the most recent assistant message is modified, reordered, filtered or
+ * reconstructed. A reasoning part with no `raw`, or with a `raw` captured from
+ * some other format, therefore THROWS rather than silently producing a request
+ * that will fail.
+ *
+ * Block order follows part order, which follows stream order, with no filtering,
+ * because the API validates order too. An empty-text reasoning part (an omitted
+ * or redacted block) is still emitted: the docs require sending back every block
+ * "including any blocks with empty thinking fields".
+ *
+ * ONE ChatMessage CAN BECOME SEVERAL WIRE MESSAGES, for the same reason as
+ * `toOpenAIMessages`: the kit streams a whole assistant turn into one message, so
+ * the tool call and the model's answer to it share a `parts` array, but Anthropic
+ * carries the result in a SEPARATE user message that has to sit between them. So
+ * the turn is SPLIT at each tool boundary, into
+ *
+ *   assistant(pre-tool blocks + tool_use) -> user(tool_result)... -> assistant(answer)
+ *
+ * Flattening instead puts the model's answer BEFORE the result it was based on,
+ * and strands every later round's thinking block in the first assistant message.
+ * Consecutive tool parts stay in ONE assistant message, because parallel calls are
+ * announced together and their results come back together.
+ *
+ * Adjacent user messages are MERGED. The API combines consecutive same-role turns
+ * itself rather than rejecting them, so this is not what stands between you and a
+ * 400; it is emitted anyway because the tool-result turn and a following user turn
+ * are one turn, several OpenAI-compatible Anthropic proxies do enforce strict
+ * alternation, and the merged form is what the models are trained on. Ordering is
+ * safe by construction: `results` is only non-empty when `blocks` is, so a
+ * tool_result message always follows its assistant message and can never be
+ * appended after a plain user turn.
+ *
+ * Asymmetry worth knowing: `tool_use.input` is a parsed OBJECT on this wire, not
+ * a string, so it uses `input` and not `rawInput`. Only thinking blocks carry a
+ * verbatim requirement.
+ */
+export declare function toAnthropicMessages(messages: ChatMessage[]): AnthropicWireMessage[];

package/dist/wire/formats/anthropic.d.ts

@@ -0,0 +1,2 @@
+import { WireFormat } from '../chunk.js';
+export declare const anthropicMessagesFormat: WireFormat;

package/dist/wire/formats/openai.d.ts

@@ -0,0 +1,5 @@
+import { WireFormat } from '../chunk.js';
+/** Stateless: every frame is self-describing, so `open()` returns a reader with
+ *  no closure state. The interface still calls it per stream, which is what lets
+ *  the stateful Anthropic format use the same seam. */
+export declare const openaiChatFormat: WireFormat;

package/dist/wire/index.d.ts

@@ -0,0 +1,14 @@
+export { readModelStream, readOpenAIStream, readAnthropicStream, WireError } from './read.js';
+export type { StreamSource, ReadOptions } from './read.js';
+export { consumeModelStream, createToolCallAccumulator } from './consume.js';
+export { applyToolOutput, applyToolFailure, bufferText } from './sink-helpers.js';
+export { toOpenAIMessages, toAnthropicMessages, WireEncodeError } from './encode.js';
+export type { AnthropicContentBlock, AnthropicWireMessage, OpenAIEncodeOptions, OpenAIReasoningDetail, OpenAIToolCall, OpenAIWireMessage, } from './encode.js';
+export { openaiChatFormat } from './formats/openai.js';
+export { anthropicMessagesFormat } from './formats/anthropic.js';
+export { sseDataFrames, sseJson, readableToAsyncIterable } from './sse.js';
+export type { ByteSource } from './sse.js';
+export { normalizeStopReason } from './chunk.js';
+export type { AssistantStreamSink, ConsumeOptions, ModelStreamChunk, ModelToolCall, ModelToolCallDelta, ModelTurn, ModelUsage, StopReason, WireFormat, WireFormatReader, } from './chunk.js';
+export type { ChatMessage, MessagePart, MessageSource, RawOrigin } from '../elements/chat-types.js';
+export type { ToolPart } from '../components/tool-types.js';

package/dist/wire/read.d.ts

@@ -0,0 +1,26 @@
+import { AssistantStreamSink, ConsumeOptions, ModelTurn, WireFormat } from './chunk.js';
+export type StreamSource = Response | ReadableStream<Uint8Array> | AsyncIterable<Uint8Array | string>;
+export interface ReadOptions extends ConsumeOptions {
+    format: WireFormat;
+}
+/** A non-ok HTTP response from the model endpoint, with the provider's own error
+ *  body attached when there is one. Thrown before a single chunk is read, so a
+ *  caller can distinguish "the request failed" from "the stream carried an
+ *  error", which is `ModelTurn.error`. */
+export declare class WireError extends Error {
+    readonly status: number;
+    readonly statusText: string;
+    /** The response body parsed as JSON, or undefined when it was not JSON (an
+     *  HTML error page from a proxy, most often). */
+    readonly body: unknown;
+    /** The raw response body, always. */
+    readonly bodyText: string;
+    constructor(status: number, statusText: string, bodyText: string, body: unknown);
+}
+/** Read one turn off the wire in `opts.format` and drive `sink` with it. */
+export declare function readModelStream(source: StreamSource, sink: AssistantStreamSink, opts: ReadOptions): Promise<ModelTurn>;
+/** OpenAI chat-completions SSE. Also what all nine catalog integrations except
+ *  `mock` re-frame to server-side, so this is the common path. */
+export declare function readOpenAIStream(source: StreamSource, sink: AssistantStreamSink, opts?: ConsumeOptions): Promise<ModelTurn>;
+/** Anthropic Messages SSE. */
+export declare function readAnthropicStream(source: StreamSource, sink: AssistantStreamSink, opts?: ConsumeOptions): Promise<ModelTurn>;

package/dist/wire/sink-helpers.d.ts

@@ -0,0 +1,21 @@
+import { AssistantStreamSink } from './chunk.js';
+/** Mark a tool call's panel done with the result the host computed. */
+export declare function applyToolOutput(sink: AssistantStreamSink, toolCallId: string, output: Record<string, unknown>): void;
+/** Mark a tool call's panel failed. */
+export declare function applyToolFailure(sink: AssistantStreamSink, toolCallId: string, message: string): void;
+/**
+ * A sink wrapper that swallows text instead of appending it, and hands the
+ * buffered text back at the end.
+ *
+ * Needed for STRUCTURED OUTPUTS: when `response_format` is a JSON schema the
+ * assistant's whole message is raw JSON, so streaming it into `<kai-thread>`
+ * shows the user a wall of braces. Buffer, parse, then `appendText` the human
+ * part, which behaves as a SET because nothing text-shaped ever reached the
+ * message (the kit has no replace-the-text operation; `appendTextPart` only ever
+ * extends or opens a text part).
+ *
+ * Reasoning, tools and sources pass straight through. Only text is held back.
+ */
+export declare function bufferText(sink: AssistantStreamSink): AssistantStreamSink & {
+    buffered(): string;
+};

package/dist/wire/sse.d.ts

@@ -0,0 +1,33 @@
+export type ByteSource = AsyncIterable<Uint8Array | string> | ReadableStream<Uint8Array>;
+/** Adapt a WHATWG ReadableStream to an async iterable. Never rely on
+ *  `for await (... of res.body)`: Safari still lacks async iteration on it.
+ *
+ *  On EARLY EXIT the underlying stream is CANCELLED, not just unlocked.
+ *  `releaseLock()` alone hands the reader back while the body stays open, which
+ *  leaks the socket. The adapter stops reading mid-stream on a real and
+ *  not-rare path (an in-band provider error after a 200), and every consumer
+ *  `break`/`throw` inside `for await` lands here too, so this is where the
+ *  connection has to be closed.
+ *
+ *  What must NOT land here is normal completion. `drained` is only honest if
+ *  every layer above reads to EOF rather than returning on a sentinel — see
+ *  `sseJson` and `[DONE]`. */
+export declare function readableToAsyncIterable(stream: ReadableStream<Uint8Array>): AsyncGenerator<Uint8Array>;
+/** Yield the payload of each SSE `data:` frame. `[DONE]` is yielded as-is; the
+ *  caller decides to stop. */
+export declare function sseDataFrames(source: ByteSource): AsyncGenerator<string>;
+/** Decode an SSE byte stream into JSON payloads, stopping at `[DONE]` and
+ *  skipping frames that are not JSON. A provider that emits a stray non-JSON
+ *  line should not take the turn down.
+ *
+ *  `[DONE]` stops the YIELDING, not the READING. Returning at the sentinel
+ *  unwinds the generator chain while the reader has not yet seen `done: true`,
+ *  so `readableToAsyncIterable` treats normal completion as an early exit and
+ *  CANCELS the body — and since every OpenAI-format stream ends in `[DONE]`,
+ *  that aborts the response on the normal path, one `net::ERR_ABORTED` per
+ *  turn. Reading on to EOF instead lets the producer's own close end the
+ *  iteration, which is the only thing that makes `drained` mean what it says.
+ *  In practice that costs exactly one more `read()`: a server that has sent
+ *  `[DONE]` has finished the response body. Frames after the sentinel are
+ *  dropped, so what a caller sees is unchanged. */
+export declare function sseJson<T>(source: ByteSource): AsyncGenerator<T>;

package/dist/wire.d.ts

@@ -1,53 +1,5 @@
-import { CardEnvelope, CardContext, CardEvent } from '../primitives/card-contract';
-export declare const CARD_WIRE_PROTOCOL: "kitn-card";
-export interface WireFrame<M extends WireMessage = WireMessage> {
-    protocol: typeof CARD_WIRE_PROTOCOL;
-    /** The NEGOTIATED contract version (set by the per-bridge packer). */
-    version: string;
-    /** Per-bridge instance nonce (host-minted, echoed on every up-frame). */
-    nonce: string;
-    message: M;
-}
-export type DownMessage = {
-    dir: 'down';
-    kind: 'hello';
-    supportedVersions: string[];
-} | {
-    dir: 'down';
-    kind: 'render';
-    envelope: CardEnvelope;
-} | {
-    dir: 'down';
-    kind: 'context';
-    context: CardContext;
-} | {
-    dir: 'down';
-    kind: 'teardown';
-};
-export type UpMessage = {
-    dir: 'up';
-    kind: 'ready';
-    acceptedVersion: string;
-    capabilities?: {
-        types?: string[];
-    };
-} | {
-    dir: 'up';
-    kind: 'event';
-    event: CardEvent;
-} | {
-    dir: 'up';
-    kind: 'focus-edge';
-    edge: 'start' | 'end';
-} | {
-    dir: 'up';
-    kind: 'fault';
-    code: WireFaultCode;
-    message: string;
-};
-export type WireFaultCode = 'version-unsupported' | 'bad-frame' | 'render-failed' | 'origin-rejected';
-export type WireMessage = DownMessage | UpMessage;
-export declare function createPacker(version: string, nonce: string): <M extends WireMessage>(message: M) => WireFrame<M>;
-/** Structural + direction guard. Host calls with 'up', runtime with 'down'.
- *  STRUCTURAL only — nonce/version equality + schema validation happen after. */
-export declare function isCardWireFrame(data: unknown, expectedDir: 'up' | 'down'): data is WireFrame;
+// GENERATED by scripts/emit-subpath-dts.mjs — do not edit.
+// Sibling declarations for dist/wire.js, so that RELATIVE imports
+// of this bundle (which bypass package.json "exports") still resolve to types.
+// Without this, tsc resolves the path to the .js and reports TS7016.
+export * from './wire/index.js';