foldkit 0.152.0 → 0.153.0

package/dist/devTools/protocol.d.ts

@@ -53,159 +53,59 @@ export declare const RuntimeInfo: S.Struct<{
 }>;
 /** Metadata about a connected browser runtime. */
 export type RuntimeInfo = typeof RuntimeInfo.Type;
-/** Request the current Model snapshot, optionally narrowed to a path and/or expanded. */
-export declare const RequestGetModel: import("../schema/index.js").CallableTaggedStruct<"RequestGetModel", {
-    maybePath: S.OptionFromNullOr<S.String>;
-    expand: S.Boolean;
-}>;
-/** Request a historical Model snapshot at an absolute history index, optionally narrowed to a path and/or expanded. Use `index: -1` for the initial Model. */
-export declare const RequestGetModelAt: import("../schema/index.js").CallableTaggedStruct<"RequestGetModelAt", {
-    index: S.Number;
-    maybePath: S.OptionFromNullOr<S.String>;
-    expand: S.Boolean;
-}>;
-/** Request recent history entries. `maybeSinceIndex` starts the page at an absolute index; `fromEnd` returns the final entries instead (the two are mutually exclusive). `maybeChangedPathsMatch` filters entries server-side to those whose `changedPaths` match at least one dot-string pattern: segments compare pairwise for the length of the shorter list and `*` matches any single segment, so `root.grid` matches changes anywhere inside the grid subtree and `root.grid.5.3` also matches a wholesale replacement recorded at `root.grid`. The two newer fields decode with defaults when absent, so requests from an older MCP server keep working against a newer runtime. */
-export declare const RequestListMessages: import("../schema/index.js").CallableTaggedStruct<"RequestListMessages", {
-    limit: S.Number;
-    maybeSinceIndex: S.OptionFromNullOr<S.Number>;
-    maybeChangedPathsMatch: S.withDecodingDefault<S.OptionFromNullOr<S.$Array<S.String>>, never>;
-    fromEnd: S.withDecodingDefault<S.Boolean, never>;
-}>;
-/** Request a histogram of retained history entries by Message tag. Accepts the same `maybeSinceIndex` / `maybeChangedPathsMatch` filters as `RequestListMessages` but returns only counts, so the response stays small regardless of history size. */
-export declare const RequestCountMessagesByTag: import("../schema/index.js").CallableTaggedStruct<"RequestCountMessagesByTag", {
-    maybeSinceIndex: S.OptionFromNullOr<S.Number>;
-    maybeChangedPathsMatch: S.OptionFromNullOr<S.$Array<S.String>>;
-}>;
-/** Request a path-level diff between the Models at two absolute history indices. Each index follows `RequestGetModelAt` semantics (the Model right after that entry was applied; -1 is the initial Model). `maybeChangedPathsMatch` narrows the reported changes with the same pattern semantics as `RequestListMessages`. */
-export declare const RequestDiffModels: import("../schema/index.js").CallableTaggedStruct<"RequestDiffModels", {
-    fromIndex: S.Number;
-    toIndex: S.Number;
-    maybeChangedPathsMatch: S.OptionFromNullOr<S.$Array<S.String>>;
-}>;
-/** Request a single history entry by index. To inspect the Model around the entry, call `RequestGetModelAt` with `index - 1` (before) and `index` (after). */
-export declare const RequestGetMessage: import("../schema/index.js").CallableTaggedStruct<"RequestGetMessage", {
-    index: S.Number;
-}>;
-/** Request the list of available keyframes. */
-export declare const RequestListKeyframes: import("../schema/index.js").CallableTaggedStruct<"RequestListKeyframes", {}>;
-/** Request the runtime jump to a specific keyframe. The runtime is paused on success; resume via RequestResume. */
-export declare const RequestReplayToKeyframe: import("../schema/index.js").CallableTaggedStruct<"RequestReplayToKeyframe", {
-    keyframeIndex: S.Number;
-}>;
-/** Request the runtime resume normal execution from a paused state. */
-export declare const RequestResume: import("../schema/index.js").CallableTaggedStruct<"RequestResume", {}>;
-/** Request the recorded init data: the initial Model and the names of Commands returned from `init`. */
-export declare const RequestGetInit: import("../schema/index.js").CallableTaggedStruct<"RequestGetInit", {}>;
-/** Request a snapshot of the runtime's DevTools state: history bounds, current paused/live status, and whether init is recorded. */
-export declare const RequestGetRuntimeState: import("../schema/index.js").CallableTaggedStruct<"RequestGetRuntimeState", {}>;
-/** Request the runtime dispatch a Message at the current state. The payload is opaque to the protocol; the runtime validates against the app's Message Schema. */
-export declare const RequestDispatchMessage: import("../schema/index.js").CallableTaggedStruct<"RequestDispatchMessage", {
-    message: S.Unknown;
-}>;
 /** The largest batch `RequestDispatchMessages` accepts. Matches the DevTools store's default history size, so a batch cannot evict its own earliest entries before the caller reads them back. The runtime rejects a larger batch with `ResponseError`, and MCP clients reject it earlier still, at their own input boundary. */
 export declare const MAX_DISPATCH_BATCH_SIZE = 100;
-/** Request the runtime dispatch an ordered batch of Messages at the current state. Payloads are opaque to the protocol; the runtime decodes every entry against the app's Message Schema before dispatching any of them, so one invalid entry rejects the whole batch and no Message from it is dispatched. Decoded Messages dispatch in array order through the same path as single dispatch, so the runtime may still record its own Messages between entries, exactly as with rapid user input. Batches larger than `MAX_DISPATCH_BATCH_SIZE` are rejected outright. */
-export declare const RequestDispatchMessages: import("../schema/index.js").CallableTaggedStruct<"RequestDispatchMessages", {
-    messages: S.$Array<S.Unknown>;
-}>;
-/** Request a description of the app's Message Schema. The runtime derives a JSON Schema document once at bridge boot from the configured `DevToolsConfig.Message`; the response is `None` when no Message Schema was configured. With `maybeVariantTag: None`, the response carries a small variant index (tag names plus payload field names and a tagged-union indicator) so MCP clients can enumerate the top-level variants without paying for the full schema. With `maybeVariantTag: Some(path)`, the value is interpreted as a dot-separated path of variant `_tag` values walked through each variant's single tagged-union payload field; the response carries the JSON Schema document narrowed along that chain, with any deeper unions collapsed to summary placeholders. Use the index to discover variants, then fetch one variant before calling `RequestDispatchMessage`. */
-export declare const RequestGetMessageSchema: import("../schema/index.js").CallableTaggedStruct<"RequestGetMessageSchema", {
-    maybeVariantTag: S.OptionFromNullOr<S.String>;
-}>;
-/** Request the list of currently connected browser runtimes. Handled by the Vite plugin, not forwarded to a runtime. */
-export declare const RequestListRuntimes: import("../schema/index.js").CallableTaggedStruct<"RequestListRuntimes", {}>;
-/** A request from the MCP server. RequestListRuntimes is handled at the Vite plugin layer; all other requests are routed to a browser runtime. */
-export declare const Request: S.Union<readonly [import("../schema/index.js").CallableTaggedStruct<"RequestGetModel", {
-    maybePath: S.OptionFromNullOr<S.String>;
-    expand: S.Boolean;
-}>, import("../schema/index.js").CallableTaggedStruct<"RequestGetModelAt", {
-    index: S.Number;
-    maybePath: S.OptionFromNullOr<S.String>;
-    expand: S.Boolean;
-}>, import("../schema/index.js").CallableTaggedStruct<"RequestListMessages", {
-    limit: S.Number;
-    maybeSinceIndex: S.OptionFromNullOr<S.Number>;
-    maybeChangedPathsMatch: S.withDecodingDefault<S.OptionFromNullOr<S.$Array<S.String>>, never>;
-    fromEnd: S.withDecodingDefault<S.Boolean, never>;
-}>, import("../schema/index.js").CallableTaggedStruct<"RequestCountMessagesByTag", {
-    maybeSinceIndex: S.OptionFromNullOr<S.Number>;
-    maybeChangedPathsMatch: S.OptionFromNullOr<S.$Array<S.String>>;
-}>, import("../schema/index.js").CallableTaggedStruct<"RequestDiffModels", {
-    fromIndex: S.Number;
-    toIndex: S.Number;
-    maybeChangedPathsMatch: S.OptionFromNullOr<S.$Array<S.String>>;
-}>, import("../schema/index.js").CallableTaggedStruct<"RequestGetMessage", {
-    index: S.Number;
-}>, import("../schema/index.js").CallableTaggedStruct<"RequestListKeyframes", {}>, import("../schema/index.js").CallableTaggedStruct<"RequestReplayToKeyframe", {
-    keyframeIndex: S.Number;
-}>, import("../schema/index.js").CallableTaggedStruct<"RequestResume", {}>, import("../schema/index.js").CallableTaggedStruct<"RequestDispatchMessage", {
-    message: S.Unknown;
-}>, import("../schema/index.js").CallableTaggedStruct<"RequestDispatchMessages", {
-    messages: S.$Array<S.Unknown>;
-}>, import("../schema/index.js").CallableTaggedStruct<"RequestListRuntimes", {}>, import("../schema/index.js").CallableTaggedStruct<"RequestGetInit", {}>, import("../schema/index.js").CallableTaggedStruct<"RequestGetRuntimeState", {}>, import("../schema/index.js").CallableTaggedStruct<"RequestGetMessageSchema", {
-    maybeVariantTag: S.OptionFromNullOr<S.String>;
-}>]>;
-/** A request from the MCP server. */
-export type Request = typeof Request.Type;
-/** Response carrying a Model snapshot. The `value` is the resolved subtree at `atPath` (or the whole Model when no path was supplied). When `summarized` is true, large arrays/records/strings have been collapsed to `_summary` placeholders to keep payloads small for AI agents; pass `expand: true` on the Request to receive the literal value. */
-export declare const ResponseModel: import("../schema/index.js").CallableTaggedStruct<"ResponseModel", {
-    value: S.Unknown;
-    atPath: S.String;
-    summarized: S.Boolean;
-}>;
-/** Response carrying a page of history entries. For forward reads, `maybeNextIndex` is `Some` of the absolute index of the next entry matching the request's filters (pass it as `RequestListMessages.maybeSinceIndex` to fetch the next page) and `None` when the page reaches the end of matching history. Tail reads (`fromEnd`) always carry `None`. */
-export declare const ResponseMessages: import("../schema/index.js").CallableTaggedStruct<"ResponseMessages", {
-    entries: S.$Array<S.Struct<{
+/** A request from the MCP server. The Vite plugin handles
+ * `Request.RequestListRuntimes`; it forwards every other request to a browser
+ * runtime. */
+export declare const Request: import("../schema/index.js").TaggedUnion<{
+    readonly RequestGetModel: {
+        readonly maybePath: S.OptionFromNullOr<S.String>;
+        readonly expand: S.Boolean;
+    };
+    readonly RequestGetModelAt: {
         readonly index: S.Number;
-        readonly tag: S.String;
-        readonly message: S.Unknown;
-        readonly commands: S.$Array<S.Struct<{
-            readonly name: S.String;
-            readonly args: S.OptionFromNullOr<S.$Record<S.String, S.Unknown>>;
-        }>>;
-        readonly mountStarts: S.$Array<S.Struct<{
-            readonly name: S.String;
-            readonly args: S.OptionFromNullOr<S.$Record<S.String, S.Unknown>>;
-        }>>;
-        readonly mountEnds: S.$Array<S.Struct<{
-            readonly name: S.String;
-            readonly args: S.OptionFromNullOr<S.$Record<S.String, S.Unknown>>;
-        }>>;
-        readonly timestamp: S.Number;
-        readonly isModelChanged: S.Boolean;
-        readonly changedPaths: S.$Array<S.String>;
-        readonly affectedPaths: S.$Array<S.String>;
-        readonly submodelPath: S.$Array<S.String>;
-        readonly maybeLeafTag: S.OptionFromNullOr<S.String>;
-    }>>;
-    maybeNextIndex: S.OptionFromNullOr<S.Number>;
-}>;
-/** Response carrying a single history entry. Model snapshots are not included; use `RequestGetModelAt` with `index - 1` and `index` to inspect Model state around the entry. */
-export declare const ResponseMessage: import("../schema/index.js").CallableTaggedStruct<"ResponseMessage", {
-    entry: S.Struct<{
+        readonly maybePath: S.OptionFromNullOr<S.String>;
+        readonly expand: S.Boolean;
+    };
+    readonly RequestListMessages: {
+        readonly limit: S.Number;
+        readonly maybeSinceIndex: S.OptionFromNullOr<S.Number>;
+        readonly maybeChangedPathsMatch: S.withDecodingDefault<S.OptionFromNullOr<S.$Array<S.String>>, never>;
+        readonly fromEnd: S.withDecodingDefault<S.Boolean, never>;
+    };
+    readonly RequestCountMessagesByTag: {
+        readonly maybeSinceIndex: S.OptionFromNullOr<S.Number>;
+        readonly maybeChangedPathsMatch: S.OptionFromNullOr<S.$Array<S.String>>;
+    };
+    readonly RequestDiffModels: {
+        readonly fromIndex: S.Number;
+        readonly toIndex: S.Number;
+        readonly maybeChangedPathsMatch: S.OptionFromNullOr<S.$Array<S.String>>;
+    };
+    readonly RequestGetMessage: {
         readonly index: S.Number;
-        readonly tag: S.String;
+    };
+    readonly RequestListKeyframes: {};
+    readonly RequestReplayToKeyframe: {
+        readonly keyframeIndex: S.Number;
+    };
+    readonly RequestResume: {};
+    readonly RequestDispatchMessage: {
         readonly message: S.Unknown;
-        readonly commands: S.$Array<S.Struct<{
-            readonly name: S.String;
-            readonly args: S.OptionFromNullOr<S.$Record<S.String, S.Unknown>>;
-        }>>;
-        readonly mountStarts: S.$Array<S.Struct<{
-            readonly name: S.String;
-            readonly args: S.OptionFromNullOr<S.$Record<S.String, S.Unknown>>;
-        }>>;
-        readonly mountEnds: S.$Array<S.Struct<{
-            readonly name: S.String;
-            readonly args: S.OptionFromNullOr<S.$Record<S.String, S.Unknown>>;
-        }>>;
-        readonly timestamp: S.Number;
-        readonly isModelChanged: S.Boolean;
-        readonly changedPaths: S.$Array<S.String>;
-        readonly affectedPaths: S.$Array<S.String>;
-        readonly submodelPath: S.$Array<S.String>;
-        readonly maybeLeafTag: S.OptionFromNullOr<S.String>;
-    }>;
+    };
+    readonly RequestDispatchMessages: {
+        readonly messages: S.$Array<S.Unknown>;
+    };
+    readonly RequestListRuntimes: {};
+    readonly RequestGetInit: {};
+    readonly RequestGetRuntimeState: {};
+    readonly RequestGetMessageSchema: {
+        readonly maybeVariantTag: S.OptionFromNullOr<S.String>;
+    };
 }>;
+/** A request from the MCP server. */
+export type Request = typeof Request.Type;
 /** One row of a Message-tag histogram. */
 export declare const MessageTagCount: S.Struct<{
     readonly tag: S.String;
@@ -213,74 +113,35 @@ export declare const MessageTagCount: S.Struct<{
 }>;
 /** One row of a Message-tag histogram. */
 export type MessageTagCount = typeof MessageTagCount.Type;
-/** Response carrying a Message-tag histogram, sorted by count descending then tag ascending. `totalCount` is the number of entries counted after filters. `scannedFromIndex` / `scannedToIndex` bound the absolute index range scanned (`scannedToIndex` is -1 when no entries are retained), so callers learn the live history bounds without a separate runtime-state call. */
-export declare const ResponseMessageCounts: import("../schema/index.js").CallableTaggedStruct<"ResponseMessageCounts", {
-    counts: S.$Array<S.Struct<{
-        readonly tag: S.String;
-        readonly count: S.Number;
-    }>>;
-    totalCount: S.Number;
-    scannedFromIndex: S.Number;
-    scannedToIndex: S.Number;
-}>;
-/** The value on one side of a Model diff path: `Present` carries the summarized value; `Absent` means the path does not exist on that side (an added or removed key or element). The tagged shape is deliberate: a nullable encoding could not distinguish an absent path from a path whose value is literally `null`. `undefined`, which JSON cannot represent, is reported as `null`. */
-export declare const DiffValueAbsent: import("../schema/index.js").CallableTaggedStruct<"Absent", {}>;
-/** The value on one side of a Model diff path. See `DiffValue`. */
-export declare const DiffValuePresent: import("../schema/index.js").CallableTaggedStruct<"Present", {
-    value: S.Unknown;
+/** The value on one side of a Model diff. `DiffValue.Present` carries the
+ * value. `DiffValue.Absent` means the path does not exist on that side, which
+ * keeps a missing path distinct from a path whose value is `null`. */
+export declare const DiffValue: import("../schema/index.js").TaggedUnion<{
+    readonly Absent: {};
+    readonly Present: {
+        readonly value: S.Unknown;
+    };
 }>;
 /** The value on one side of a Model diff path. */
-export declare const DiffValue: S.Union<readonly [import("../schema/index.js").CallableTaggedStruct<"Absent", {}>, import("../schema/index.js").CallableTaggedStruct<"Present", {
-    value: S.Unknown;
-}>]>;
-/** The value on one side of a Model diff path. */
 export type DiffValue = typeof DiffValue.Type;
 /** One changed path in a Model diff. `before` is the value at `fromIndex`, `after` the value at `toIndex`. */
 export declare const ModelDiffChange: S.Struct<{
     readonly path: S.String;
-    readonly before: S.Union<readonly [import("../schema/index.js").CallableTaggedStruct<"Absent", {}>, import("../schema/index.js").CallableTaggedStruct<"Present", {
-        value: S.Unknown;
-    }>]>;
-    readonly after: S.Union<readonly [import("../schema/index.js").CallableTaggedStruct<"Absent", {}>, import("../schema/index.js").CallableTaggedStruct<"Present", {
-        value: S.Unknown;
-    }>]>;
+    readonly before: import("../schema/index.js").TaggedUnion<{
+        readonly Absent: {};
+        readonly Present: {
+            readonly value: S.Unknown;
+        };
+    }>;
+    readonly after: import("../schema/index.js").TaggedUnion<{
+        readonly Absent: {};
+        readonly Present: {
+            readonly value: S.Unknown;
+        };
+    }>;
 }>;
 /** One changed path in a Model diff. */
 export type ModelDiffChange = typeof ModelDiffChange.Type;
-/** Response carrying a path-level Model diff between two history indices. Changes list the leaf paths where the Models differ, sorted by path with numeric segments in numeric order; values are summarized with the same rules `ResponseModel` applies when `expand` is false. */
-export declare const ResponseModelDiff: import("../schema/index.js").CallableTaggedStruct<"ResponseModelDiff", {
-    fromIndex: S.Number;
-    toIndex: S.Number;
-    changes: S.$Array<S.Struct<{
-        readonly path: S.String;
-        readonly before: S.Union<readonly [import("../schema/index.js").CallableTaggedStruct<"Absent", {}>, import("../schema/index.js").CallableTaggedStruct<"Present", {
-            value: S.Unknown;
-        }>]>;
-        readonly after: S.Union<readonly [import("../schema/index.js").CallableTaggedStruct<"Absent", {}>, import("../schema/index.js").CallableTaggedStruct<"Present", {
-            value: S.Unknown;
-        }>]>;
-    }>>;
-}>;
-/** Response carrying the list of available keyframes. */
-export declare const ResponseKeyframes: import("../schema/index.js").CallableTaggedStruct<"ResponseKeyframes", {
-    keyframes: S.$Array<S.Struct<{
-        readonly index: S.Number;
-    }>>;
-}>;
-/** Response confirming a successful replay. The runtime is paused at this Model. */
-export declare const ResponseReplayed: import("../schema/index.js").CallableTaggedStruct<"ResponseReplayed", {
-    model: S.Unknown;
-}>;
-/** Response confirming the runtime resumed normal execution. */
-export declare const ResponseResumed: import("../schema/index.js").CallableTaggedStruct<"ResponseResumed", {}>;
-/** Response confirming a Message was dispatched. The `acceptedAtIndex` is the absolute history index where the entry is predicted to land. Computed from the runtime's history length at dispatch time. The runtime processes Messages in arrival order, so the index is reliable whenever the bridge is the only Message source, but the app produces its own Messages too (user input, Subscription emissions, Command results); one recorded between the snapshot and the dispatch shifts the entry past this index. Messages excluded from history via `excludeFromHistory` still drive `update` but are never recorded, so no entry lands at the predicted index for them, and a Message dispatched into a crashed or disposed runtime is dropped without recording anything. */
-export declare const ResponseDispatched: import("../schema/index.js").CallableTaggedStruct<"ResponseDispatched", {
-    acceptedAtIndex: S.Number;
-}>;
-/** Response confirming a batch dispatch. `acceptedAtIndices` aligns with the request's `messages` order; each value is the absolute history index where that entry is predicted to land, computed from one history snapshot at dispatch time with the same caveats as `ResponseDispatched.acceptedAtIndex`. An `excludeFromHistory` Message inside the batch records no entry, so entries after it land below their predicted index. */
-export declare const ResponseDispatchedBatch: import("../schema/index.js").CallableTaggedStruct<"ResponseDispatchedBatch", {
-    acceptedAtIndices: S.$Array<S.Number>;
-}>;
 /** One variant entry in a `MessageSchemaIndex`. `payloadFields` lists the variant's payload property names (excluding `_tag`); `unionFields` lists the subset of those properties whose schemas are themselves `_tag`-discriminated unions. A Submodel-wrapper variant always shows up with `unionFields: ['message']`, but the same flag also catches plain tagged-union value types like `UrlRequest = Internal | External`. Either way, the agent will need to pick a variant when filling these fields. */
 export declare const MessageSchemaIndexEntry: S.Struct<{
     readonly tag: S.String;
@@ -299,274 +160,33 @@ export declare const MessageSchemaIndex: S.Struct<{
 }>;
 /** A flat directory of every top-level Message variant. */
 export type MessageSchemaIndex = typeof MessageSchemaIndex.Type;
-/** The result payload carried by `ResponseMessageSchema`. `MessageSchemaIndexResult` is returned when the request omitted `maybeVariantTag`; `MessageSchemaDocumentResult` carries a JSON Schema document narrowed to one variant when a tag was supplied. */
-export declare const MessageSchemaIndexResult: import("../schema/index.js").CallableTaggedStruct<"MessageSchemaIndexResult", {
-    index: S.Struct<{
-        readonly variants: S.$Array<S.Struct<{
-            readonly tag: S.String;
-            readonly payloadFields: S.$Array<S.String>;
-            readonly unionFields: S.$Array<S.String>;
-        }>>;
-    }>;
-}>;
-/** A JSON Schema document carrying a single variant of the runtime's Message union, plus the original `definitions` block so any `$ref`s the variant carries still resolve. */
-export declare const MessageSchemaDocumentResult: import("../schema/index.js").CallableTaggedStruct<"MessageSchemaDocumentResult", {
-    document: S.Unknown;
-}>;
-declare const MessageSchemaResult: S.Union<readonly [import("../schema/index.js").CallableTaggedStruct<"MessageSchemaIndexResult", {
-    index: S.Struct<{
-        readonly variants: S.$Array<S.Struct<{
-            readonly tag: S.String;
-            readonly payloadFields: S.$Array<S.String>;
-            readonly unionFields: S.$Array<S.String>;
-        }>>;
-    }>;
-}>, import("../schema/index.js").CallableTaggedStruct<"MessageSchemaDocumentResult", {
-    document: S.Unknown;
-}>]>;
-/** The result payload carried by `ResponseMessageSchema`. */
-export type MessageSchemaResult = typeof MessageSchemaResult.Type;
-/** Response describing the app's Message Schema. `maybeResult` is `Some(MessageSchemaIndexResult)` for index requests, `Some(MessageSchemaDocumentResult)` for variant-narrowed requests, and `None` when the runtime has not configured `DevToolsConfig.Message` or when JSON Schema derivation failed. Variant tags appear as `_tag` enums in the document, nested Submodel Messages recurse correctly, and `S.Option` fields render as `anyOf: [{_tag: 'Some', value}, {_tag: 'None'}]`. Apps using `S.OptionFromNullishOr(T)` (the Foldkit-canonical option codec for shapes that cross a JSON boundary) instead see the field as nullable `anyOf: [T, null]`; agents dispatching against that shape send either the bare value or `null`, not a tagged `Some`/`None` envelope. Fields with no JSON representation, such as `S.instanceOf(File)`, render as `{ type: 'null' }` rather than throwing; those variants cannot be dispatched via the bridge because their values live in browser memory. A few AST nodes (symbol-keyed structs, symbol-indexed records, tuples with post-rest elements) still cause the derivation to throw; the bridge guards the call and returns `None` in that case while logging a warning to the dev console. */
-export declare const ResponseMessageSchema: import("../schema/index.js").CallableTaggedStruct<"ResponseMessageSchema", {
-    maybeResult: S.OptionFromNullOr<S.Union<readonly [import("../schema/index.js").CallableTaggedStruct<"MessageSchemaIndexResult", {
-        index: S.Struct<{
+/** The result of requesting the app's Message Schema. It is either a compact
+ * index of Message variants or the JSON Schema document for one variant. */
+export declare const MessageSchemaResult: import("../schema/index.js").TaggedUnion<{
+    readonly MessageSchemaIndexResult: {
+        readonly index: S.Struct<{
             readonly variants: S.$Array<S.Struct<{
                 readonly tag: S.String;
                 readonly payloadFields: S.$Array<S.String>;
                 readonly unionFields: S.$Array<S.String>;
             }>>;
         }>;
-    }>, import("../schema/index.js").CallableTaggedStruct<"MessageSchemaDocumentResult", {
-        document: S.Unknown;
-    }>]>>;
-}>;
-/** Response carrying the list of connected runtimes. */
-export declare const ResponseRuntimes: import("../schema/index.js").CallableTaggedStruct<"ResponseRuntimes", {
-    runtimes: S.$Array<S.Struct<{
-        readonly connectionId: S.String;
-        readonly url: S.String;
-        readonly title: S.String;
-    }>>;
-}>;
-/** Response carrying the recorded init data. `maybeModel` is `None` until the runtime has finished its first render and recorded init; once set it stays set for the rest of the runtime's life. `commands` lists the Commands returned from the application's `init` function in the order they were produced, with their args when declared. `mountStarts` lists the Mounts that fired during the initial render, with their args when declared. */
-export declare const ResponseInit: import("../schema/index.js").CallableTaggedStruct<"ResponseInit", {
-    maybeModel: S.OptionFromNullOr<S.Unknown>;
-    commands: S.$Array<S.Struct<{
-        readonly name: S.String;
-        readonly args: S.OptionFromNullOr<S.$Record<S.String, S.Unknown>>;
-    }>>;
-    mountStarts: S.$Array<S.Struct<{
-        readonly name: S.String;
-        readonly args: S.OptionFromNullOr<S.$Record<S.String, S.Unknown>>;
-    }>>;
-}>;
-/** Response carrying a snapshot of the runtime's DevTools state. `currentIndex` is the absolute index of the most recently recorded Message, or -1 when no Messages have been recorded yet. `startIndex` is the earliest absolute index still retained in the rolling buffer (older entries are evicted past `maxEntries`). `totalEntries` is the number of retained entries. `isPaused` is true while the runtime is paused at a replayed snapshot; `maybePausedAtIndex` is `Some(index)` then and `None` otherwise. `hasInitModel` is true once the runtime has finished initialising. */
-export declare const ResponseRuntimeState: import("../schema/index.js").CallableTaggedStruct<"ResponseRuntimeState", {
-    currentIndex: S.Number;
-    startIndex: S.Number;
-    totalEntries: S.Number;
-    isPaused: S.Boolean;
-    maybePausedAtIndex: S.OptionFromNullOr<S.Number>;
-    hasInitModel: S.Boolean;
-}>;
-/** Response carrying an error reason for a failed Request. */
-export declare const ResponseError: import("../schema/index.js").CallableTaggedStruct<"ResponseError", {
-    reason: S.String;
+    };
+    readonly MessageSchemaDocumentResult: {
+        readonly document: S.Unknown;
+    };
 }>;
+/** The result of requesting the app's Message Schema. */
+export type MessageSchemaResult = typeof MessageSchemaResult.Type;
 /** A response replying to a Request. */
-export declare const Response: S.Union<readonly [import("../schema/index.js").CallableTaggedStruct<"ResponseModel", {
-    value: S.Unknown;
-    atPath: S.String;
-    summarized: S.Boolean;
-}>, import("../schema/index.js").CallableTaggedStruct<"ResponseMessages", {
-    entries: S.$Array<S.Struct<{
-        readonly index: S.Number;
-        readonly tag: S.String;
-        readonly message: S.Unknown;
-        readonly commands: S.$Array<S.Struct<{
-            readonly name: S.String;
-            readonly args: S.OptionFromNullOr<S.$Record<S.String, S.Unknown>>;
-        }>>;
-        readonly mountStarts: S.$Array<S.Struct<{
-            readonly name: S.String;
-            readonly args: S.OptionFromNullOr<S.$Record<S.String, S.Unknown>>;
-        }>>;
-        readonly mountEnds: S.$Array<S.Struct<{
-            readonly name: S.String;
-            readonly args: S.OptionFromNullOr<S.$Record<S.String, S.Unknown>>;
-        }>>;
-        readonly timestamp: S.Number;
-        readonly isModelChanged: S.Boolean;
-        readonly changedPaths: S.$Array<S.String>;
-        readonly affectedPaths: S.$Array<S.String>;
-        readonly submodelPath: S.$Array<S.String>;
-        readonly maybeLeafTag: S.OptionFromNullOr<S.String>;
-    }>>;
-    maybeNextIndex: S.OptionFromNullOr<S.Number>;
-}>, import("../schema/index.js").CallableTaggedStruct<"ResponseMessage", {
-    entry: S.Struct<{
-        readonly index: S.Number;
-        readonly tag: S.String;
-        readonly message: S.Unknown;
-        readonly commands: S.$Array<S.Struct<{
-            readonly name: S.String;
-            readonly args: S.OptionFromNullOr<S.$Record<S.String, S.Unknown>>;
-        }>>;
-        readonly mountStarts: S.$Array<S.Struct<{
-            readonly name: S.String;
-            readonly args: S.OptionFromNullOr<S.$Record<S.String, S.Unknown>>;
-        }>>;
-        readonly mountEnds: S.$Array<S.Struct<{
-            readonly name: S.String;
-            readonly args: S.OptionFromNullOr<S.$Record<S.String, S.Unknown>>;
-        }>>;
-        readonly timestamp: S.Number;
-        readonly isModelChanged: S.Boolean;
-        readonly changedPaths: S.$Array<S.String>;
-        readonly affectedPaths: S.$Array<S.String>;
-        readonly submodelPath: S.$Array<S.String>;
-        readonly maybeLeafTag: S.OptionFromNullOr<S.String>;
-    }>;
-}>, import("../schema/index.js").CallableTaggedStruct<"ResponseMessageCounts", {
-    counts: S.$Array<S.Struct<{
-        readonly tag: S.String;
-        readonly count: S.Number;
-    }>>;
-    totalCount: S.Number;
-    scannedFromIndex: S.Number;
-    scannedToIndex: S.Number;
-}>, import("../schema/index.js").CallableTaggedStruct<"ResponseModelDiff", {
-    fromIndex: S.Number;
-    toIndex: S.Number;
-    changes: S.$Array<S.Struct<{
-        readonly path: S.String;
-        readonly before: S.Union<readonly [import("../schema/index.js").CallableTaggedStruct<"Absent", {}>, import("../schema/index.js").CallableTaggedStruct<"Present", {
-            value: S.Unknown;
-        }>]>;
-        readonly after: S.Union<readonly [import("../schema/index.js").CallableTaggedStruct<"Absent", {}>, import("../schema/index.js").CallableTaggedStruct<"Present", {
-            value: S.Unknown;
-        }>]>;
-    }>>;
-}>, import("../schema/index.js").CallableTaggedStruct<"ResponseKeyframes", {
-    keyframes: S.$Array<S.Struct<{
-        readonly index: S.Number;
-    }>>;
-}>, import("../schema/index.js").CallableTaggedStruct<"ResponseReplayed", {
-    model: S.Unknown;
-}>, import("../schema/index.js").CallableTaggedStruct<"ResponseResumed", {}>, import("../schema/index.js").CallableTaggedStruct<"ResponseDispatched", {
-    acceptedAtIndex: S.Number;
-}>, import("../schema/index.js").CallableTaggedStruct<"ResponseDispatchedBatch", {
-    acceptedAtIndices: S.$Array<S.Number>;
-}>, import("../schema/index.js").CallableTaggedStruct<"ResponseRuntimes", {
-    runtimes: S.$Array<S.Struct<{
-        readonly connectionId: S.String;
-        readonly url: S.String;
-        readonly title: S.String;
-    }>>;
-}>, import("../schema/index.js").CallableTaggedStruct<"ResponseInit", {
-    maybeModel: S.OptionFromNullOr<S.Unknown>;
-    commands: S.$Array<S.Struct<{
-        readonly name: S.String;
-        readonly args: S.OptionFromNullOr<S.$Record<S.String, S.Unknown>>;
-    }>>;
-    mountStarts: S.$Array<S.Struct<{
-        readonly name: S.String;
-        readonly args: S.OptionFromNullOr<S.$Record<S.String, S.Unknown>>;
-    }>>;
-}>, import("../schema/index.js").CallableTaggedStruct<"ResponseRuntimeState", {
-    currentIndex: S.Number;
-    startIndex: S.Number;
-    totalEntries: S.Number;
-    isPaused: S.Boolean;
-    maybePausedAtIndex: S.OptionFromNullOr<S.Number>;
-    hasInitModel: S.Boolean;
-}>, import("../schema/index.js").CallableTaggedStruct<"ResponseMessageSchema", {
-    maybeResult: S.OptionFromNullOr<S.Union<readonly [import("../schema/index.js").CallableTaggedStruct<"MessageSchemaIndexResult", {
-        index: S.Struct<{
-            readonly variants: S.$Array<S.Struct<{
-                readonly tag: S.String;
-                readonly payloadFields: S.$Array<S.String>;
-                readonly unionFields: S.$Array<S.String>;
-            }>>;
-        }>;
-    }>, import("../schema/index.js").CallableTaggedStruct<"MessageSchemaDocumentResult", {
-        document: S.Unknown;
-    }>]>>;
-}>, import("../schema/index.js").CallableTaggedStruct<"ResponseError", {
-    reason: S.String;
-}>]>;
-/** A response replying to a Request. */
-export type Response = typeof Response.Type;
-/** A new browser runtime connected. */
-export declare const EventConnected: import("../schema/index.js").CallableTaggedStruct<"EventConnected", {
-    runtime: S.Struct<{
-        readonly connectionId: S.String;
-        readonly url: S.String;
-        readonly title: S.String;
-    }>;
-}>;
-/** A previously connected runtime disconnected. */
-export declare const EventDisconnected: import("../schema/index.js").CallableTaggedStruct<"EventDisconnected", {
-    connectionId: S.String;
-}>;
-/** A runtime lifecycle event used by the Vite plugin to track which browser tabs are connected. Not forwarded to MCP clients. */
-export declare const Event: S.Union<readonly [import("../schema/index.js").CallableTaggedStruct<"EventConnected", {
-    runtime: S.Struct<{
-        readonly connectionId: S.String;
-        readonly url: S.String;
-        readonly title: S.String;
-    }>;
-}>, import("../schema/index.js").CallableTaggedStruct<"EventDisconnected", {
-    connectionId: S.String;
-}>]>;
-/** A runtime lifecycle event. */
-export type Event = typeof Event.Type;
-/** A wire frame carrying a Request from the MCP server. The id is opaque, used only by the MCP server to correlate the matching Response. The maybeConnectionId routes the request to a specific runtime when present. */
-export declare const RequestFrame: S.Struct<{
-    readonly id: S.String;
-    readonly maybeConnectionId: S.OptionFromNullOr<S.String>;
-    readonly request: S.Union<readonly [import("../schema/index.js").CallableTaggedStruct<"RequestGetModel", {
-        maybePath: S.OptionFromNullOr<S.String>;
-        expand: S.Boolean;
-    }>, import("../schema/index.js").CallableTaggedStruct<"RequestGetModelAt", {
-        index: S.Number;
-        maybePath: S.OptionFromNullOr<S.String>;
-        expand: S.Boolean;
-    }>, import("../schema/index.js").CallableTaggedStruct<"RequestListMessages", {
-        limit: S.Number;
-        maybeSinceIndex: S.OptionFromNullOr<S.Number>;
-        maybeChangedPathsMatch: S.withDecodingDefault<S.OptionFromNullOr<S.$Array<S.String>>, never>;
-        fromEnd: S.withDecodingDefault<S.Boolean, never>;
-    }>, import("../schema/index.js").CallableTaggedStruct<"RequestCountMessagesByTag", {
-        maybeSinceIndex: S.OptionFromNullOr<S.Number>;
-        maybeChangedPathsMatch: S.OptionFromNullOr<S.$Array<S.String>>;
-    }>, import("../schema/index.js").CallableTaggedStruct<"RequestDiffModels", {
-        fromIndex: S.Number;
-        toIndex: S.Number;
-        maybeChangedPathsMatch: S.OptionFromNullOr<S.$Array<S.String>>;
-    }>, import("../schema/index.js").CallableTaggedStruct<"RequestGetMessage", {
-        index: S.Number;
-    }>, import("../schema/index.js").CallableTaggedStruct<"RequestListKeyframes", {}>, import("../schema/index.js").CallableTaggedStruct<"RequestReplayToKeyframe", {
-        keyframeIndex: S.Number;
-    }>, import("../schema/index.js").CallableTaggedStruct<"RequestResume", {}>, import("../schema/index.js").CallableTaggedStruct<"RequestDispatchMessage", {
-        message: S.Unknown;
-    }>, import("../schema/index.js").CallableTaggedStruct<"RequestDispatchMessages", {
-        messages: S.$Array<S.Unknown>;
-    }>, import("../schema/index.js").CallableTaggedStruct<"RequestListRuntimes", {}>, import("../schema/index.js").CallableTaggedStruct<"RequestGetInit", {}>, import("../schema/index.js").CallableTaggedStruct<"RequestGetRuntimeState", {}>, import("../schema/index.js").CallableTaggedStruct<"RequestGetMessageSchema", {
-        maybeVariantTag: S.OptionFromNullOr<S.String>;
-    }>]>;
-}>;
-/** A wire frame carrying a Request from the MCP server. */
-export type RequestFrame = typeof RequestFrame.Type;
-/** A wire frame carrying a Response, correlated to a Request by id. */
-export declare const ResponseFrame: S.Struct<{
-    readonly id: S.String;
-    readonly response: S.Union<readonly [import("../schema/index.js").CallableTaggedStruct<"ResponseModel", {
-        value: S.Unknown;
-        atPath: S.String;
-        summarized: S.Boolean;
-    }>, import("../schema/index.js").CallableTaggedStruct<"ResponseMessages", {
-        entries: S.$Array<S.Struct<{
+export declare const Response: import("../schema/index.js").TaggedUnion<{
+    readonly ResponseModel: {
+        readonly value: S.Unknown;
+        readonly atPath: S.String;
+        readonly summarized: S.Boolean;
+    };
+    readonly ResponseMessages: {
+        readonly entries: S.$Array<S.Struct<{
             readonly index: S.Number;
             readonly tag: S.String;
             readonly message: S.Unknown;
@@ -589,9 +209,10 @@ export declare const ResponseFrame: S.Struct<{
             readonly submodelPath: S.$Array<S.String>;
             readonly maybeLeafTag: S.OptionFromNullOr<S.String>;
         }>>;
-        maybeNextIndex: S.OptionFromNullOr<S.Number>;
-    }>, import("../schema/index.js").CallableTaggedStruct<"ResponseMessage", {
-        entry: S.Struct<{
+        readonly maybeNextIndex: S.OptionFromNullOr<S.Number>;
+    };
+    readonly ResponseMessage: {
+        readonly entry: S.Struct<{
             readonly index: S.Number;
             readonly tag: S.String;
             readonly message: S.Unknown;
@@ -614,91 +235,334 @@ export declare const ResponseFrame: S.Struct<{
             readonly submodelPath: S.$Array<S.String>;
             readonly maybeLeafTag: S.OptionFromNullOr<S.String>;
         }>;
-    }>, import("../schema/index.js").CallableTaggedStruct<"ResponseMessageCounts", {
-        counts: S.$Array<S.Struct<{
+    };
+    readonly ResponseMessageCounts: {
+        readonly counts: S.$Array<S.Struct<{
             readonly tag: S.String;
             readonly count: S.Number;
         }>>;
-        totalCount: S.Number;
-        scannedFromIndex: S.Number;
-        scannedToIndex: S.Number;
-    }>, import("../schema/index.js").CallableTaggedStruct<"ResponseModelDiff", {
-        fromIndex: S.Number;
-        toIndex: S.Number;
-        changes: S.$Array<S.Struct<{
+        readonly totalCount: S.Number;
+        readonly scannedFromIndex: S.Number;
+        readonly scannedToIndex: S.Number;
+    };
+    readonly ResponseModelDiff: {
+        readonly fromIndex: S.Number;
+        readonly toIndex: S.Number;
+        readonly changes: S.$Array<S.Struct<{
             readonly path: S.String;
-            readonly before: S.Union<readonly [import("../schema/index.js").CallableTaggedStruct<"Absent", {}>, import("../schema/index.js").CallableTaggedStruct<"Present", {
-                value: S.Unknown;
-            }>]>;
-            readonly after: S.Union<readonly [import("../schema/index.js").CallableTaggedStruct<"Absent", {}>, import("../schema/index.js").CallableTaggedStruct<"Present", {
-                value: S.Unknown;
-            }>]>;
+            readonly before: import("../schema/index.js").TaggedUnion<{
+                readonly Absent: {};
+                readonly Present: {
+                    readonly value: S.Unknown;
+                };
+            }>;
+            readonly after: import("../schema/index.js").TaggedUnion<{
+                readonly Absent: {};
+                readonly Present: {
+                    readonly value: S.Unknown;
+                };
+            }>;
         }>>;
-    }>, import("../schema/index.js").CallableTaggedStruct<"ResponseKeyframes", {
-        keyframes: S.$Array<S.Struct<{
+    };
+    readonly ResponseKeyframes: {
+        readonly keyframes: S.$Array<S.Struct<{
             readonly index: S.Number;
         }>>;
-    }>, import("../schema/index.js").CallableTaggedStruct<"ResponseReplayed", {
-        model: S.Unknown;
-    }>, import("../schema/index.js").CallableTaggedStruct<"ResponseResumed", {}>, import("../schema/index.js").CallableTaggedStruct<"ResponseDispatched", {
-        acceptedAtIndex: S.Number;
-    }>, import("../schema/index.js").CallableTaggedStruct<"ResponseDispatchedBatch", {
-        acceptedAtIndices: S.$Array<S.Number>;
-    }>, import("../schema/index.js").CallableTaggedStruct<"ResponseRuntimes", {
-        runtimes: S.$Array<S.Struct<{
+    };
+    readonly ResponseReplayed: {
+        readonly model: S.Unknown;
+    };
+    readonly ResponseResumed: {};
+    readonly ResponseDispatched: {
+        readonly acceptedAtIndex: S.Number;
+    };
+    readonly ResponseDispatchedBatch: {
+        readonly acceptedAtIndices: S.$Array<S.Number>;
+    };
+    readonly ResponseRuntimes: {
+        readonly runtimes: S.$Array<S.Struct<{
             readonly connectionId: S.String;
             readonly url: S.String;
             readonly title: S.String;
         }>>;
-    }>, import("../schema/index.js").CallableTaggedStruct<"ResponseInit", {
-        maybeModel: S.OptionFromNullOr<S.Unknown>;
-        commands: S.$Array<S.Struct<{
+    };
+    readonly ResponseInit: {
+        readonly maybeModel: S.OptionFromNullOr<S.Unknown>;
+        readonly commands: S.$Array<S.Struct<{
             readonly name: S.String;
             readonly args: S.OptionFromNullOr<S.$Record<S.String, S.Unknown>>;
         }>>;
-        mountStarts: S.$Array<S.Struct<{
+        readonly mountStarts: S.$Array<S.Struct<{
             readonly name: S.String;
             readonly args: S.OptionFromNullOr<S.$Record<S.String, S.Unknown>>;
         }>>;
-    }>, import("../schema/index.js").CallableTaggedStruct<"ResponseRuntimeState", {
-        currentIndex: S.Number;
-        startIndex: S.Number;
-        totalEntries: S.Number;
-        isPaused: S.Boolean;
-        maybePausedAtIndex: S.OptionFromNullOr<S.Number>;
-        hasInitModel: S.Boolean;
-    }>, import("../schema/index.js").CallableTaggedStruct<"ResponseMessageSchema", {
-        maybeResult: S.OptionFromNullOr<S.Union<readonly [import("../schema/index.js").CallableTaggedStruct<"MessageSchemaIndexResult", {
-            index: S.Struct<{
-                readonly variants: S.$Array<S.Struct<{
-                    readonly tag: S.String;
-                    readonly payloadFields: S.$Array<S.String>;
-                    readonly unionFields: S.$Array<S.String>;
+    };
+    readonly ResponseRuntimeState: {
+        readonly currentIndex: S.Number;
+        readonly startIndex: S.Number;
+        readonly totalEntries: S.Number;
+        readonly isPaused: S.Boolean;
+        readonly maybePausedAtIndex: S.OptionFromNullOr<S.Number>;
+        readonly hasInitModel: S.Boolean;
+    };
+    readonly ResponseMessageSchema: {
+        readonly maybeResult: S.OptionFromNullOr<import("../schema/index.js").TaggedUnion<{
+            readonly MessageSchemaIndexResult: {
+                readonly index: S.Struct<{
+                    readonly variants: S.$Array<S.Struct<{
+                        readonly tag: S.String;
+                        readonly payloadFields: S.$Array<S.String>;
+                        readonly unionFields: S.$Array<S.String>;
+                    }>>;
+                }>;
+            };
+            readonly MessageSchemaDocumentResult: {
+                readonly document: S.Unknown;
+            };
+        }>>;
+    };
+    readonly ResponseError: {
+        readonly reason: S.String;
+    };
+}>;
+/** A response replying to a Request. */
+export type Response = typeof Response.Type;
+/** A runtime lifecycle event used by the Vite plugin to track which browser tabs are connected. Not forwarded to MCP clients. */
+export declare const Event: import("../schema/index.js").TaggedUnion<{
+    readonly EventConnected: {
+        readonly runtime: S.Struct<{
+            readonly connectionId: S.String;
+            readonly url: S.String;
+            readonly title: S.String;
+        }>;
+    };
+    readonly EventDisconnected: {
+        readonly connectionId: S.String;
+    };
+}>;
+/** A runtime lifecycle event. */
+export type Event = typeof Event.Type;
+/** A wire frame carrying a Request from the MCP server. The id is opaque, used only by the MCP server to correlate the matching Response. The maybeConnectionId routes the request to a specific runtime when present. */
+export declare const RequestFrame: S.Struct<{
+    readonly id: S.String;
+    readonly maybeConnectionId: S.OptionFromNullOr<S.String>;
+    readonly request: import("../schema/index.js").TaggedUnion<{
+        readonly RequestGetModel: {
+            readonly maybePath: S.OptionFromNullOr<S.String>;
+            readonly expand: S.Boolean;
+        };
+        readonly RequestGetModelAt: {
+            readonly index: S.Number;
+            readonly maybePath: S.OptionFromNullOr<S.String>;
+            readonly expand: S.Boolean;
+        };
+        readonly RequestListMessages: {
+            readonly limit: S.Number;
+            readonly maybeSinceIndex: S.OptionFromNullOr<S.Number>;
+            readonly maybeChangedPathsMatch: S.withDecodingDefault<S.OptionFromNullOr<S.$Array<S.String>>, never>;
+            readonly fromEnd: S.withDecodingDefault<S.Boolean, never>;
+        };
+        readonly RequestCountMessagesByTag: {
+            readonly maybeSinceIndex: S.OptionFromNullOr<S.Number>;
+            readonly maybeChangedPathsMatch: S.OptionFromNullOr<S.$Array<S.String>>;
+        };
+        readonly RequestDiffModels: {
+            readonly fromIndex: S.Number;
+            readonly toIndex: S.Number;
+            readonly maybeChangedPathsMatch: S.OptionFromNullOr<S.$Array<S.String>>;
+        };
+        readonly RequestGetMessage: {
+            readonly index: S.Number;
+        };
+        readonly RequestListKeyframes: {};
+        readonly RequestReplayToKeyframe: {
+            readonly keyframeIndex: S.Number;
+        };
+        readonly RequestResume: {};
+        readonly RequestDispatchMessage: {
+            readonly message: S.Unknown;
+        };
+        readonly RequestDispatchMessages: {
+            readonly messages: S.$Array<S.Unknown>;
+        };
+        readonly RequestListRuntimes: {};
+        readonly RequestGetInit: {};
+        readonly RequestGetRuntimeState: {};
+        readonly RequestGetMessageSchema: {
+            readonly maybeVariantTag: S.OptionFromNullOr<S.String>;
+        };
+    }>;
+}>;
+/** A wire frame carrying a Request from the MCP server. */
+export type RequestFrame = typeof RequestFrame.Type;
+/** A wire frame carrying a Response, correlated to a Request by id. */
+export declare const ResponseFrame: S.Struct<{
+    readonly id: S.String;
+    readonly response: import("../schema/index.js").TaggedUnion<{
+        readonly ResponseModel: {
+            readonly value: S.Unknown;
+            readonly atPath: S.String;
+            readonly summarized: S.Boolean;
+        };
+        readonly ResponseMessages: {
+            readonly entries: S.$Array<S.Struct<{
+                readonly index: S.Number;
+                readonly tag: S.String;
+                readonly message: S.Unknown;
+                readonly commands: S.$Array<S.Struct<{
+                    readonly name: S.String;
+                    readonly args: S.OptionFromNullOr<S.$Record<S.String, S.Unknown>>;
+                }>>;
+                readonly mountStarts: S.$Array<S.Struct<{
+                    readonly name: S.String;
+                    readonly args: S.OptionFromNullOr<S.$Record<S.String, S.Unknown>>;
                 }>>;
+                readonly mountEnds: S.$Array<S.Struct<{
+                    readonly name: S.String;
+                    readonly args: S.OptionFromNullOr<S.$Record<S.String, S.Unknown>>;
+                }>>;
+                readonly timestamp: S.Number;
+                readonly isModelChanged: S.Boolean;
+                readonly changedPaths: S.$Array<S.String>;
+                readonly affectedPaths: S.$Array<S.String>;
+                readonly submodelPath: S.$Array<S.String>;
+                readonly maybeLeafTag: S.OptionFromNullOr<S.String>;
+            }>>;
+            readonly maybeNextIndex: S.OptionFromNullOr<S.Number>;
+        };
+        readonly ResponseMessage: {
+            readonly entry: S.Struct<{
+                readonly index: S.Number;
+                readonly tag: S.String;
+                readonly message: S.Unknown;
+                readonly commands: S.$Array<S.Struct<{
+                    readonly name: S.String;
+                    readonly args: S.OptionFromNullOr<S.$Record<S.String, S.Unknown>>;
+                }>>;
+                readonly mountStarts: S.$Array<S.Struct<{
+                    readonly name: S.String;
+                    readonly args: S.OptionFromNullOr<S.$Record<S.String, S.Unknown>>;
+                }>>;
+                readonly mountEnds: S.$Array<S.Struct<{
+                    readonly name: S.String;
+                    readonly args: S.OptionFromNullOr<S.$Record<S.String, S.Unknown>>;
+                }>>;
+                readonly timestamp: S.Number;
+                readonly isModelChanged: S.Boolean;
+                readonly changedPaths: S.$Array<S.String>;
+                readonly affectedPaths: S.$Array<S.String>;
+                readonly submodelPath: S.$Array<S.String>;
+                readonly maybeLeafTag: S.OptionFromNullOr<S.String>;
             }>;
-        }>, import("../schema/index.js").CallableTaggedStruct<"MessageSchemaDocumentResult", {
-            document: S.Unknown;
-        }>]>>;
-    }>, import("../schema/index.js").CallableTaggedStruct<"ResponseError", {
-        reason: S.String;
-    }>]>;
+        };
+        readonly ResponseMessageCounts: {
+            readonly counts: S.$Array<S.Struct<{
+                readonly tag: S.String;
+                readonly count: S.Number;
+            }>>;
+            readonly totalCount: S.Number;
+            readonly scannedFromIndex: S.Number;
+            readonly scannedToIndex: S.Number;
+        };
+        readonly ResponseModelDiff: {
+            readonly fromIndex: S.Number;
+            readonly toIndex: S.Number;
+            readonly changes: S.$Array<S.Struct<{
+                readonly path: S.String;
+                readonly before: import("../schema/index.js").TaggedUnion<{
+                    readonly Absent: {};
+                    readonly Present: {
+                        readonly value: S.Unknown;
+                    };
+                }>;
+                readonly after: import("../schema/index.js").TaggedUnion<{
+                    readonly Absent: {};
+                    readonly Present: {
+                        readonly value: S.Unknown;
+                    };
+                }>;
+            }>>;
+        };
+        readonly ResponseKeyframes: {
+            readonly keyframes: S.$Array<S.Struct<{
+                readonly index: S.Number;
+            }>>;
+        };
+        readonly ResponseReplayed: {
+            readonly model: S.Unknown;
+        };
+        readonly ResponseResumed: {};
+        readonly ResponseDispatched: {
+            readonly acceptedAtIndex: S.Number;
+        };
+        readonly ResponseDispatchedBatch: {
+            readonly acceptedAtIndices: S.$Array<S.Number>;
+        };
+        readonly ResponseRuntimes: {
+            readonly runtimes: S.$Array<S.Struct<{
+                readonly connectionId: S.String;
+                readonly url: S.String;
+                readonly title: S.String;
+            }>>;
+        };
+        readonly ResponseInit: {
+            readonly maybeModel: S.OptionFromNullOr<S.Unknown>;
+            readonly commands: S.$Array<S.Struct<{
+                readonly name: S.String;
+                readonly args: S.OptionFromNullOr<S.$Record<S.String, S.Unknown>>;
+            }>>;
+            readonly mountStarts: S.$Array<S.Struct<{
+                readonly name: S.String;
+                readonly args: S.OptionFromNullOr<S.$Record<S.String, S.Unknown>>;
+            }>>;
+        };
+        readonly ResponseRuntimeState: {
+            readonly currentIndex: S.Number;
+            readonly startIndex: S.Number;
+            readonly totalEntries: S.Number;
+            readonly isPaused: S.Boolean;
+            readonly maybePausedAtIndex: S.OptionFromNullOr<S.Number>;
+            readonly hasInitModel: S.Boolean;
+        };
+        readonly ResponseMessageSchema: {
+            readonly maybeResult: S.OptionFromNullOr<import("../schema/index.js").TaggedUnion<{
+                readonly MessageSchemaIndexResult: {
+                    readonly index: S.Struct<{
+                        readonly variants: S.$Array<S.Struct<{
+                            readonly tag: S.String;
+                            readonly payloadFields: S.$Array<S.String>;
+                            readonly unionFields: S.$Array<S.String>;
+                        }>>;
+                    }>;
+                };
+                readonly MessageSchemaDocumentResult: {
+                    readonly document: S.Unknown;
+                };
+            }>>;
+        };
+        readonly ResponseError: {
+            readonly reason: S.String;
+        };
+    }>;
 }>;
 /** A wire frame carrying a Response, correlated to a Request by id. */
 export type ResponseFrame = typeof ResponseFrame.Type;
 /** A wire frame carrying a runtime lifecycle event from the bridge to the Vite plugin. */
 export declare const EventFrame: S.Struct<{
     readonly maybeConnectionId: S.OptionFromNullOr<S.String>;
-    readonly event: S.Union<readonly [import("../schema/index.js").CallableTaggedStruct<"EventConnected", {
-        runtime: S.Struct<{
+    readonly event: import("../schema/index.js").TaggedUnion<{
+        readonly EventConnected: {
+            readonly runtime: S.Struct<{
+                readonly connectionId: S.String;
+                readonly url: S.String;
+                readonly title: S.String;
+            }>;
+        };
+        readonly EventDisconnected: {
             readonly connectionId: S.String;
-            readonly url: S.String;
-            readonly title: S.String;
-        }>;
-    }>, import("../schema/index.js").CallableTaggedStruct<"EventDisconnected", {
-        connectionId: S.String;
-    }>]>;
+        };
+    }>;
 }>;
 /** A wire frame carrying a runtime lifecycle event. */
 export type EventFrame = typeof EventFrame.Type;
-export {};
 //# sourceMappingURL=protocol.d.ts.map