foldkit 0.76.1 → 0.78.0

package/README.md

@@ -150,7 +150,7 @@ Foldkit is a complete system, not a collection of libraries you stitch together.
 - **Field Validation**: Per-field validation state modeled as a discriminated union. Define rules as data, apply them in update, and the Model tracks the result.
 - **Virtual DOM**: Declarative views powered by [Snabbdom](https://github.com/snabbdom/snabbdom), with lazy memoization and fast, keyed diffing. Views are plain functions of your Model.
 - **DevTools**: Built-in overlay for inspecting Messages, Model state, and Commands. Time-travel mode rewinds your UI to any past Model, Inspect mode browses snapshots without pausing, and Submodel drill-in filtering scopes the Message list to any nested module.
-- **DevTools MCP**: Expose a running Foldkit app to AI agents over the Model Context Protocol. Agents read the current Model, list and inspect Message history, rewind the UI to any past Model, and dispatch Messages into the runtime. The runtime's own Message Schema is published as JSON Schema so the agent discovers exactly what it can dispatch, and every payload is validated against the Schema before it reaches your update function. One command sets it up: `npx @foldkit/devtools-mcp init`.
+- **DevTools MCP**: Expose a running Foldkit app to AI agents over the Model Context Protocol. Agents read the current Model, list and inspect Message history, rewind the UI to any past Model, and dispatch Messages into the runtime. To dispatch, agents read your application source to learn the Message Schema; the runtime decodes every payload against the Schema and returns a clean error if the shape does not match. One command sets it up: `npx @foldkit/devtools-mcp init`.
 - **Crash View and Reporting**: Configure `crash.view` to render a custom fallback UI when the update loop throws. A `crash.report` callback fires first with the error, Model, and triggering Message, so you can ship it straight to Sentry or your logger.
 - **Story Testing**: Exercise the update function directly. Send Messages, resolve Commands inline with `resolve` and `resolveAll`, and assert with focused helpers: `Story.model`, `Story.expectHasCommands`, `Story.expectExactCommands`, `Story.expectNoCommands`, and `Story.expectOutMessage`. No mocking libraries, no fake timers.
 - **Scene Testing**: Drive your app the way a user does. Scene renders your real view, then clicks buttons, types into inputs, presses keys, and asserts on what's on screen. Accessible locators (`role`, `label`, `placeholder`, `altText`, `title`, `testId`, `displayValue`) with full options (`name`, `level`, `checked`, `selected`, `pressed`, `expanded`, `disabled`), multi-match `Scene.all` with `Scene.filter` and `Scene.nth`, scoped steps via `Scene.inside`, pointer events, event bubbling, and Vitest matchers like `toHaveText`, `toBeVisible`, `toHaveAccessibleName`, and `toHaveCount`. API parity with React Testing Library and Playwright, without a browser.

package/dist/devTools/overlay.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"overlay.d.ts","sourceRoot":"","sources":["../../src/devTools/overlay.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,MAAM,EAGN,OAAO,EAGP,MAAM,EASP,MAAM,QAAQ,CAAA;AAEf,OAAO,KAAK,OAAO,MAAM,qBAAqB,CAAA;AAK9C,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AAQ3E,OAAO,EACL,KAAK,aAAa,EAInB,MAAM,YAAY,CAAA;AAuOnB,eAAO,MAAM,MAAM;;EAA0C,CAAA;AAC7D,eAAO,MAAM,YAAY;;;;;;EAGxB,CAAA;AACD,eAAO,MAAM,aAAa;;;;;;EAGzB,CAAA;AACD,eAAO,MAAM,MAAM;;EAA4C,CAAA;AAC/D,eAAO,MAAM,KAAK;;EAA0C,CAAA;AAC5D,eAAO,MAAM,UAAU;;EAA6C,CAAA;AACpE,eAAO,MAAM,YAAY;;EAAiD,CAAA;AAC1E,eAAO,MAAM,WAAW;;EAA+C,CAAA;AAgzCvE,eAAO,MAAM,aAAa,GACxB,OAAO,aAAa,EACpB,UAAU,gBAAgB,EAC1B,MAAM,YAAY,EAClB,aAAa,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,sCAkDhC,CAAA"}
+{"version":3,"file":"overlay.d.ts","sourceRoot":"","sources":["../../src/devTools/overlay.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,MAAM,EAGN,OAAO,EAGP,MAAM,EASP,MAAM,QAAQ,CAAA;AAEf,OAAO,KAAK,OAAO,MAAM,qBAAqB,CAAA;AAU9C,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AAQ3E,OAAO,EAAE,KAAK,aAAa,EAA+B,MAAM,YAAY,CAAA;AA4M5E,eAAO,MAAM,MAAM;;EAA0C,CAAA;AAC7D,eAAO,MAAM,YAAY;;;;;;EAGxB,CAAA;AACD,eAAO,MAAM,aAAa;;;;;;EAGzB,CAAA;AACD,eAAO,MAAM,MAAM;;EAA4C,CAAA;AAC/D,eAAO,MAAM,KAAK;;EAA0C,CAAA;AAC5D,eAAO,MAAM,UAAU;;EAA6C,CAAA;AACpE,eAAO,MAAM,YAAY;;EAAiD,CAAA;AAC1E,eAAO,MAAM,WAAW;;EAA+C,CAAA;AAkzCvE,eAAO,MAAM,aAAa,GACxB,OAAO,aAAa,EACpB,UAAU,gBAAgB,EAC1B,MAAM,YAAY,EAClB,aAAa,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,sCAkDhC,CAAA"}

package/dist/devTools/overlay.js

@@ -2,7 +2,7 @@ import { clsx } from 'clsx';
 import { Array as Array_, Effect, Equal, Function, HashSet, Match as M, Number as Number_, Option, Order, Predicate, Record, Schema as S, Stream, String as String_, SubscriptionRef, pipe, } from 'effect';
 import * as Command from '../command/index.js';
 import { OptionExt } from '../effectExtensions/index.js';
-import { createKeyedLazy, html } from '../html/index.js';
+import { createKeyedLazy, html, } from '../html/index.js';
 import { m } from '../message/index.js';
 import { makeProgram } from '../runtime/runtime.js';
 import { makeSubscriptions } from '../runtime/subscription.js';
@@ -12,7 +12,8 @@ import * as Listbox from '../ui/listbox/public.js';
 import * as Tabs from '../ui/tabs/public.js';
 import { overlayStyles } from './overlay-styles.js';
 import { toInspectableValue } from './serialize.js';
-import { INIT_INDEX, } from './store.js';
+import { INIT_INDEX } from './store.js';
+import { GOT_MESSAGE_PATTERN, extractSubmodelInfo, isTagged, } from './submodelPath.js';
 // MODEL
 const DisplayEntry = S.Struct({
     tag: S.String,
@@ -107,26 +108,8 @@ const ALL_MESSAGES_VALUE = '';
 const formatTimeDelta = (deltaMs) => M.value(deltaMs).pipe(M.when(0, () => '0ms'), M.when(Number_.lessThan(MILLIS_PER_SECOND), ms => `+${Math.round(ms)}ms`), M.orElse(ms => `+${(ms / MILLIS_PER_SECOND).toFixed(1)}s`));
 const MESSAGE_LIST_SELECTOR = '.message-list';
 const computeSubmodelTags = (entries) => pipe(entries, Array_.flatMap(({ submodelPath }) => submodelPath), Array_.dedupe, Array_.sort(Order.string));
-const GOT_MESSAGE_PATTERN = /^Got.+Message$/;
-const extractSubmodelInfo = (entry) => {
-    if (!GOT_MESSAGE_PATTERN.test(entry.tag)) {
-        return { submodelPath: [], maybeLeafTag: Option.none() };
-    }
-    const path = [entry.tag];
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    let current = entry.message?.['message'];
-    while (isTagged(current) && GOT_MESSAGE_PATTERN.test(current._tag)) {
-        path.push(current._tag);
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        current = current?.['message'];
-    }
-    return {
-        submodelPath: path,
-        maybeLeafTag: pipe(current, Option.liftPredicate(isTagged), Option.map(({ _tag }) => _tag)),
-    };
-};
 const toDisplayEntries = ({ entries }) => Array_.map(entries, entry => {
-    const { submodelPath, maybeLeafTag } = extractSubmodelInfo(entry);
+    const { submodelPath, maybeLeafTag } = extractSubmodelInfo(entry.tag, entry.message);
     return {
         tag: entry.tag,
         submodelPath,
@@ -144,8 +127,6 @@ const toDisplayState = (state) => ({
     pausedAtIndex: state.pausedAtIndex,
 });
 const isExpandable = (value) => Predicate.isObject(value);
-const Tagged = S.Struct({ _tag: S.String });
-const isTagged = S.is(Tagged);
 const objectPreview = (value) => pipe(value, Record.keys, Array_.filter(key => key !== '_tag'), Array_.match({
     onEmpty: () => '{}',
     onNonEmpty: keys => {
@@ -817,11 +798,14 @@ const makeView = (position, mode, maybeBanner) => {
         ]),
     ]);
     const interactionBlocker = div([Class('dt-interaction-blocker')], []);
-    return (model) => div([], [
-        ...OptionExt.when(model.isPaused && mode === 'TimeTravel', interactionBlocker).pipe(Option.toArray),
-        ...OptionExt.when(model.isOpen, panelView(model)).pipe(Option.toArray),
-        badgeView(model),
-    ]);
+    return (model) => ({
+        title: 'Foldkit DevTools',
+        body: div([], [
+            ...OptionExt.when(model.isPaused && mode === 'TimeTravel', interactionBlocker).pipe(Option.toArray),
+            ...OptionExt.when(model.isOpen, panelView(model)).pipe(Option.toArray),
+            badgeView(model),
+        ]),
+    });
 };
 // CREATE
 const DEVTOOLS_HOST_ID = 'foldkit-devtools';

package/dist/devTools/protocol.d.ts

@@ -1,5 +1,5 @@
 import { Schema as S } from 'effect';
-/** A serialized history entry as it appears on the wire. */
+/** A serialized history entry as it appears on the wire. `submodelPath` lists `Got<Child>Message` wrapper tags from outer to inner when the entry came up through a Submodel chain; `maybeLeafTag` is `Some` with the innermost child Message tag when one exists. */
 export declare const SerializedEntry: S.Struct<{
     index: typeof S.Number;
     tag: typeof S.String;
@@ -9,6 +9,8 @@ export declare const SerializedEntry: S.Struct<{
     isModelChanged: typeof S.Boolean;
     changedPaths: S.Array$<typeof S.String>;
     affectedPaths: S.Array$<typeof S.String>;
+    submodelPath: S.Array$<typeof S.String>;
+    maybeLeafTag: S.Option<typeof S.String>;
 }>;
 /** A serialized history entry suitable for transmission over the WS protocol. */
 export type SerializedEntry = typeof SerializedEntry.Type;
@@ -18,23 +20,31 @@ export declare const KeyframeInfo: S.Struct<{
 }>;
 /** Metadata about a single keyframe. */
 export type KeyframeInfo = typeof KeyframeInfo.Type;
-/** Metadata about a connected browser runtime. The `maybeMessageSchema` carries the runtime's app-level Message Schema as JSON Schema for `dispatch_message` validation, when the runtime exposes one via `DevToolsConfig.Message`. */
+/** Metadata about a connected browser runtime. */
 export declare const RuntimeInfo: S.Struct<{
     connectionId: typeof S.String;
     url: typeof S.String;
     title: typeof S.String;
-    maybeMessageSchema: S.Option<typeof S.Unknown>;
 }>;
 /** Metadata about a connected browser runtime. */
 export type RuntimeInfo = typeof RuntimeInfo.Type;
-/** Request the current Model snapshot. */
-export declare const RequestGetModel: import("../schema/index.js").CallableTaggedStruct<"RequestGetModel", {}>;
+/** 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.Option<typeof S.String>;
+    expand: typeof 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: typeof S.Number;
+    maybePath: S.Option<typeof S.String>;
+    expand: typeof S.Boolean;
+}>;
 /** Request recent history entries, optionally starting from a given index. */
 export declare const RequestListMessages: import("../schema/index.js").CallableTaggedStruct<"RequestListMessages", {
     limit: typeof S.Number;
     maybeSinceIndex: S.Option<typeof S.Number>;
 }>;
-/** Request a single history entry by index, including before/after Model snapshots. */
+/** 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: typeof S.Number;
 }>;
@@ -46,6 +56,10 @@ export declare const RequestReplayToKeyframe: import("../schema/index.js").Calla
 }>;
 /** 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: typeof S.Unknown;
@@ -53,7 +67,14 @@ export declare const RequestDispatchMessage: import("../schema/index.js").Callab
 /** 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<[import("../schema/index.js").CallableTaggedStruct<"RequestGetModel", {}>, import("../schema/index.js").CallableTaggedStruct<"RequestListMessages", {
+export declare const Request: S.Union<[import("../schema/index.js").CallableTaggedStruct<"RequestGetModel", {
+    maybePath: S.Option<typeof S.String>;
+    expand: typeof S.Boolean;
+}>, import("../schema/index.js").CallableTaggedStruct<"RequestGetModelAt", {
+    index: typeof S.Number;
+    maybePath: S.Option<typeof S.String>;
+    expand: typeof S.Boolean;
+}>, import("../schema/index.js").CallableTaggedStruct<"RequestListMessages", {
     limit: typeof S.Number;
     maybeSinceIndex: S.Option<typeof S.Number>;
 }>, import("../schema/index.js").CallableTaggedStruct<"RequestGetMessage", {
@@ -62,12 +83,14 @@ export declare const Request: S.Union<[import("../schema/index.js").CallableTagg
     keyframeIndex: typeof S.Number;
 }>, import("../schema/index.js").CallableTaggedStruct<"RequestResume", {}>, import("../schema/index.js").CallableTaggedStruct<"RequestDispatchMessage", {
     message: typeof S.Unknown;
-}>, import("../schema/index.js").CallableTaggedStruct<"RequestListRuntimes", {}>]>;
+}>, import("../schema/index.js").CallableTaggedStruct<"RequestListRuntimes", {}>, import("../schema/index.js").CallableTaggedStruct<"RequestGetInit", {}>, import("../schema/index.js").CallableTaggedStruct<"RequestGetRuntimeState", {}>]>;
 /** A request from the MCP server. */
 export type Request = typeof Request.Type;
-/** Response carrying the current Model snapshot. */
+/** 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", {
-    model: typeof S.Unknown;
+    value: typeof S.Unknown;
+    atPath: typeof S.String;
+    summarized: typeof S.Boolean;
 }>;
 /** Response carrying a page of history entries. `maybeNextIndex` is `Some` when more entries are available beyond this page (pass it as `RequestListMessages.maybeSinceIndex` to fetch the next page) and `None` when this page reaches the current end of history. */
 export declare const ResponseMessages: import("../schema/index.js").CallableTaggedStruct<"ResponseMessages", {
@@ -80,10 +103,12 @@ export declare const ResponseMessages: import("../schema/index.js").CallableTagg
         isModelChanged: typeof S.Boolean;
         changedPaths: S.Array$<typeof S.String>;
         affectedPaths: S.Array$<typeof S.String>;
+        submodelPath: S.Array$<typeof S.String>;
+        maybeLeafTag: S.Option<typeof S.String>;
     }>>;
     maybeNextIndex: S.Option<typeof S.Number>;
 }>;
-/** Response carrying a single history entry with surrounding Model snapshots. */
+/** 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<{
         index: typeof S.Number;
@@ -94,9 +119,9 @@ export declare const ResponseMessage: import("../schema/index.js").CallableTagge
         isModelChanged: typeof S.Boolean;
         changedPaths: S.Array$<typeof S.String>;
         affectedPaths: S.Array$<typeof S.String>;
+        submodelPath: S.Array$<typeof S.String>;
+        maybeLeafTag: S.Option<typeof S.String>;
     }>;
-    modelBefore: typeof S.Unknown;
-    modelAfter: typeof S.Unknown;
 }>;
 /** Response carrying the list of available keyframes. */
 export declare const ResponseKeyframes: import("../schema/index.js").CallableTaggedStruct<"ResponseKeyframes", {
@@ -120,16 +145,31 @@ export declare const ResponseRuntimes: import("../schema/index.js").CallableTagg
         connectionId: typeof S.String;
         url: typeof S.String;
         title: typeof S.String;
-        maybeMessageSchema: S.Option<typeof S.Unknown>;
     }>>;
 }>;
+/** 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. `commandNames` lists the Commands returned from the application's `init` function in the order they were produced. */
+export declare const ResponseInit: import("../schema/index.js").CallableTaggedStruct<"ResponseInit", {
+    maybeModel: S.Option<typeof S.Unknown>;
+    commandNames: S.Array$<typeof S.String>;
+}>;
+/** 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: typeof S.Number;
+    startIndex: typeof S.Number;
+    totalEntries: typeof S.Number;
+    isPaused: typeof S.Boolean;
+    maybePausedAtIndex: S.Option<typeof S.Number>;
+    hasInitModel: typeof S.Boolean;
+}>;
 /** Response carrying an error reason for a failed Request. */
 export declare const ResponseError: import("../schema/index.js").CallableTaggedStruct<"ResponseError", {
     reason: typeof S.String;
 }>;
 /** A response replying to a Request. */
 export declare const Response: S.Union<[import("../schema/index.js").CallableTaggedStruct<"ResponseModel", {
-    model: typeof S.Unknown;
+    value: typeof S.Unknown;
+    atPath: typeof S.String;
+    summarized: typeof S.Boolean;
 }>, import("../schema/index.js").CallableTaggedStruct<"ResponseMessages", {
     entries: S.Array$<S.Struct<{
         index: typeof S.Number;
@@ -140,6 +180,8 @@ export declare const Response: S.Union<[import("../schema/index.js").CallableTag
         isModelChanged: typeof S.Boolean;
         changedPaths: S.Array$<typeof S.String>;
         affectedPaths: S.Array$<typeof S.String>;
+        submodelPath: S.Array$<typeof S.String>;
+        maybeLeafTag: S.Option<typeof S.String>;
     }>>;
     maybeNextIndex: S.Option<typeof S.Number>;
 }>, import("../schema/index.js").CallableTaggedStruct<"ResponseMessage", {
@@ -152,9 +194,9 @@ export declare const Response: S.Union<[import("../schema/index.js").CallableTag
         isModelChanged: typeof S.Boolean;
         changedPaths: S.Array$<typeof S.String>;
         affectedPaths: S.Array$<typeof S.String>;
+        submodelPath: S.Array$<typeof S.String>;
+        maybeLeafTag: S.Option<typeof S.String>;
     }>;
-    modelBefore: typeof S.Unknown;
-    modelAfter: typeof S.Unknown;
 }>, import("../schema/index.js").CallableTaggedStruct<"ResponseKeyframes", {
     keyframes: S.Array$<S.Struct<{
         index: typeof S.Number;
@@ -168,20 +210,28 @@ export declare const Response: S.Union<[import("../schema/index.js").CallableTag
         connectionId: typeof S.String;
         url: typeof S.String;
         title: typeof S.String;
-        maybeMessageSchema: S.Option<typeof S.Unknown>;
     }>>;
+}>, import("../schema/index.js").CallableTaggedStruct<"ResponseInit", {
+    maybeModel: S.Option<typeof S.Unknown>;
+    commandNames: S.Array$<typeof S.String>;
+}>, import("../schema/index.js").CallableTaggedStruct<"ResponseRuntimeState", {
+    currentIndex: typeof S.Number;
+    startIndex: typeof S.Number;
+    totalEntries: typeof S.Number;
+    isPaused: typeof S.Boolean;
+    maybePausedAtIndex: S.Option<typeof S.Number>;
+    hasInitModel: typeof S.Boolean;
 }>, import("../schema/index.js").CallableTaggedStruct<"ResponseError", {
     reason: typeof S.String;
 }>]>;
 /** A response replying to a Request. */
 export type Response = typeof Response.Type;
-/** A new browser runtime connected. The `runtime.maybeMessageSchema` field carries the runtime's Message Schema (as JSON Schema) when the runtime exposes one via `DevToolsConfig.Message`. */
+/** A new browser runtime connected. */
 export declare const EventConnected: import("../schema/index.js").CallableTaggedStruct<"EventConnected", {
     runtime: S.Struct<{
         connectionId: typeof S.String;
         url: typeof S.String;
         title: typeof S.String;
-        maybeMessageSchema: S.Option<typeof S.Unknown>;
     }>;
 }>;
 /** A previously connected runtime disconnected. */
@@ -194,7 +244,6 @@ export declare const Event: S.Union<[import("../schema/index.js").CallableTagged
         connectionId: typeof S.String;
         url: typeof S.String;
         title: typeof S.String;
-        maybeMessageSchema: S.Option<typeof S.Unknown>;
     }>;
 }>, import("../schema/index.js").CallableTaggedStruct<"EventDisconnected", {
     connectionId: typeof S.String;
@@ -205,7 +254,14 @@ export type Event = typeof Event.Type;
 export declare const RequestFrame: S.Struct<{
     id: typeof S.String;
     maybeConnectionId: S.Option<typeof S.String>;
-    request: S.Union<[import("../schema/index.js").CallableTaggedStruct<"RequestGetModel", {}>, import("../schema/index.js").CallableTaggedStruct<"RequestListMessages", {
+    request: S.Union<[import("../schema/index.js").CallableTaggedStruct<"RequestGetModel", {
+        maybePath: S.Option<typeof S.String>;
+        expand: typeof S.Boolean;
+    }>, import("../schema/index.js").CallableTaggedStruct<"RequestGetModelAt", {
+        index: typeof S.Number;
+        maybePath: S.Option<typeof S.String>;
+        expand: typeof S.Boolean;
+    }>, import("../schema/index.js").CallableTaggedStruct<"RequestListMessages", {
         limit: typeof S.Number;
         maybeSinceIndex: S.Option<typeof S.Number>;
     }>, import("../schema/index.js").CallableTaggedStruct<"RequestGetMessage", {
@@ -214,7 +270,7 @@ export declare const RequestFrame: S.Struct<{
         keyframeIndex: typeof S.Number;
     }>, import("../schema/index.js").CallableTaggedStruct<"RequestResume", {}>, import("../schema/index.js").CallableTaggedStruct<"RequestDispatchMessage", {
         message: typeof S.Unknown;
-    }>, import("../schema/index.js").CallableTaggedStruct<"RequestListRuntimes", {}>]>;
+    }>, import("../schema/index.js").CallableTaggedStruct<"RequestListRuntimes", {}>, import("../schema/index.js").CallableTaggedStruct<"RequestGetInit", {}>, import("../schema/index.js").CallableTaggedStruct<"RequestGetRuntimeState", {}>]>;
 }>;
 /** A wire frame carrying a Request from the MCP server. */
 export type RequestFrame = typeof RequestFrame.Type;
@@ -222,7 +278,9 @@ export type RequestFrame = typeof RequestFrame.Type;
 export declare const ResponseFrame: S.Struct<{
     id: typeof S.String;
     response: S.Union<[import("../schema/index.js").CallableTaggedStruct<"ResponseModel", {
-        model: typeof S.Unknown;
+        value: typeof S.Unknown;
+        atPath: typeof S.String;
+        summarized: typeof S.Boolean;
     }>, import("../schema/index.js").CallableTaggedStruct<"ResponseMessages", {
         entries: S.Array$<S.Struct<{
             index: typeof S.Number;
@@ -233,6 +291,8 @@ export declare const ResponseFrame: S.Struct<{
             isModelChanged: typeof S.Boolean;
             changedPaths: S.Array$<typeof S.String>;
             affectedPaths: S.Array$<typeof S.String>;
+            submodelPath: S.Array$<typeof S.String>;
+            maybeLeafTag: S.Option<typeof S.String>;
         }>>;
         maybeNextIndex: S.Option<typeof S.Number>;
     }>, import("../schema/index.js").CallableTaggedStruct<"ResponseMessage", {
@@ -245,9 +305,9 @@ export declare const ResponseFrame: S.Struct<{
             isModelChanged: typeof S.Boolean;
             changedPaths: S.Array$<typeof S.String>;
             affectedPaths: S.Array$<typeof S.String>;
+            submodelPath: S.Array$<typeof S.String>;
+            maybeLeafTag: S.Option<typeof S.String>;
         }>;
-        modelBefore: typeof S.Unknown;
-        modelAfter: typeof S.Unknown;
     }>, import("../schema/index.js").CallableTaggedStruct<"ResponseKeyframes", {
         keyframes: S.Array$<S.Struct<{
             index: typeof S.Number;
@@ -261,8 +321,17 @@ export declare const ResponseFrame: S.Struct<{
             connectionId: typeof S.String;
             url: typeof S.String;
             title: typeof S.String;
-            maybeMessageSchema: S.Option<typeof S.Unknown>;
         }>>;
+    }>, import("../schema/index.js").CallableTaggedStruct<"ResponseInit", {
+        maybeModel: S.Option<typeof S.Unknown>;
+        commandNames: S.Array$<typeof S.String>;
+    }>, import("../schema/index.js").CallableTaggedStruct<"ResponseRuntimeState", {
+        currentIndex: typeof S.Number;
+        startIndex: typeof S.Number;
+        totalEntries: typeof S.Number;
+        isPaused: typeof S.Boolean;
+        maybePausedAtIndex: S.Option<typeof S.Number>;
+        hasInitModel: typeof S.Boolean;
     }>, import("../schema/index.js").CallableTaggedStruct<"ResponseError", {
         reason: typeof S.String;
     }>]>;
@@ -277,7 +346,6 @@ export declare const EventFrame: S.Struct<{
             connectionId: typeof S.String;
             url: typeof S.String;
             title: typeof S.String;
-            maybeMessageSchema: S.Option<typeof S.Unknown>;
         }>;
     }>, import("../schema/index.js").CallableTaggedStruct<"EventDisconnected", {
         connectionId: typeof S.String;

package/dist/devTools/protocol.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../../src/devTools/protocol.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../../src/devTools/protocol.ts"],"names":[],"mappings":"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"}

package/dist/devTools/protocol.js

@@ -1,7 +1,7 @@
 import { Schema as S } from 'effect';
 import { ts } from '../schema/index.js';
 // SHARED
-/** A serialized history entry as it appears on the wire. */
+/** A serialized history entry as it appears on the wire. `submodelPath` lists `Got<Child>Message` wrapper tags from outer to inner when the entry came up through a Submodel chain; `maybeLeafTag` is `Some` with the innermost child Message tag when one exists. */
 export const SerializedEntry = S.Struct({
     index: S.Number,
     tag: S.String,
@@ -11,27 +11,37 @@ export const SerializedEntry = S.Struct({
     isModelChanged: S.Boolean,
     changedPaths: S.Array(S.String),
     affectedPaths: S.Array(S.String),
+    submodelPath: S.Array(S.String),
+    maybeLeafTag: S.Option(S.String),
 });
 /** Metadata about a single keyframe. The index identifies the point in history where the runtime can replay back to. */
 export const KeyframeInfo = S.Struct({
     index: S.Number,
 });
-/** Metadata about a connected browser runtime. The `maybeMessageSchema` carries the runtime's app-level Message Schema as JSON Schema for `dispatch_message` validation, when the runtime exposes one via `DevToolsConfig.Message`. */
+/** Metadata about a connected browser runtime. */
 export const RuntimeInfo = S.Struct({
     connectionId: S.String,
     url: S.String,
     title: S.String,
-    maybeMessageSchema: S.Option(S.Unknown),
 });
 // REQUEST
-/** Request the current Model snapshot. */
-export const RequestGetModel = ts('RequestGetModel');
+/** Request the current Model snapshot, optionally narrowed to a path and/or expanded. */
+export const RequestGetModel = ts('RequestGetModel', {
+    maybePath: S.Option(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 const RequestGetModelAt = ts('RequestGetModelAt', {
+    index: S.Number,
+    maybePath: S.Option(S.String),
+    expand: S.Boolean,
+});
 /** Request recent history entries, optionally starting from a given index. */
 export const RequestListMessages = ts('RequestListMessages', {
     limit: S.Number,
     maybeSinceIndex: S.Option(S.Number),
 });
-/** Request a single history entry by index, including before/after Model snapshots. */
+/** Request a single history entry by index. To inspect the Model around the entry, call `RequestGetModelAt` with `index - 1` (before) and `index` (after). */
 export const RequestGetMessage = ts('RequestGetMessage', {
     index: S.Number,
 });
@@ -43,6 +53,10 @@ export const RequestReplayToKeyframe = ts('RequestReplayToKeyframe', {
 });
 /** Request the runtime resume normal execution from a paused state. */
 export const RequestResume = ts('RequestResume');
+/** Request the recorded init data: the initial Model and the names of Commands returned from `init`. */
+export const RequestGetInit = ts('RequestGetInit');
+/** Request a snapshot of the runtime's DevTools state: history bounds, current paused/live status, and whether init is recorded. */
+export const RequestGetRuntimeState = ts('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 const RequestDispatchMessage = ts('RequestDispatchMessage', {
     message: S.Unknown,
@@ -50,22 +64,22 @@ export const RequestDispatchMessage = ts('RequestDispatchMessage', {
 /** Request the list of currently connected browser runtimes. Handled by the Vite plugin, not forwarded to a runtime. */
 export const RequestListRuntimes = ts('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 const Request = S.Union(RequestGetModel, RequestListMessages, RequestGetMessage, RequestListKeyframes, RequestReplayToKeyframe, RequestResume, RequestDispatchMessage, RequestListRuntimes);
+export const Request = S.Union(RequestGetModel, RequestGetModelAt, RequestListMessages, RequestGetMessage, RequestListKeyframes, RequestReplayToKeyframe, RequestResume, RequestDispatchMessage, RequestListRuntimes, RequestGetInit, RequestGetRuntimeState);
 // RESPONSE
-/** Response carrying the current Model snapshot. */
+/** 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 const ResponseModel = ts('ResponseModel', {
-    model: S.Unknown,
+    value: S.Unknown,
+    atPath: S.String,
+    summarized: S.Boolean,
 });
 /** Response carrying a page of history entries. `maybeNextIndex` is `Some` when more entries are available beyond this page (pass it as `RequestListMessages.maybeSinceIndex` to fetch the next page) and `None` when this page reaches the current end of history. */
 export const ResponseMessages = ts('ResponseMessages', {
     entries: S.Array(SerializedEntry),
     maybeNextIndex: S.Option(S.Number),
 });
-/** Response carrying a single history entry with surrounding Model snapshots. */
+/** 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 const ResponseMessage = ts('ResponseMessage', {
     entry: SerializedEntry,
-    modelBefore: S.Unknown,
-    modelAfter: S.Unknown,
 });
 /** Response carrying the list of available keyframes. */
 export const ResponseKeyframes = ts('ResponseKeyframes', {
@@ -85,14 +99,28 @@ export const ResponseDispatched = ts('ResponseDispatched', {
 export const ResponseRuntimes = ts('ResponseRuntimes', {
     runtimes: S.Array(RuntimeInfo),
 });
+/** 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. `commandNames` lists the Commands returned from the application's `init` function in the order they were produced. */
+export const ResponseInit = ts('ResponseInit', {
+    maybeModel: S.Option(S.Unknown),
+    commandNames: S.Array(S.String),
+});
+/** 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 const ResponseRuntimeState = ts('ResponseRuntimeState', {
+    currentIndex: S.Number,
+    startIndex: S.Number,
+    totalEntries: S.Number,
+    isPaused: S.Boolean,
+    maybePausedAtIndex: S.Option(S.Number),
+    hasInitModel: S.Boolean,
+});
 /** Response carrying an error reason for a failed Request. */
 export const ResponseError = ts('ResponseError', {
     reason: S.String,
 });
 /** A response replying to a Request. */
-export const Response = S.Union(ResponseModel, ResponseMessages, ResponseMessage, ResponseKeyframes, ResponseReplayed, ResponseResumed, ResponseDispatched, ResponseRuntimes, ResponseError);
+export const Response = S.Union(ResponseModel, ResponseMessages, ResponseMessage, ResponseKeyframes, ResponseReplayed, ResponseResumed, ResponseDispatched, ResponseRuntimes, ResponseInit, ResponseRuntimeState, ResponseError);
 // EVENT
-/** A new browser runtime connected. The `runtime.maybeMessageSchema` field carries the runtime's Message Schema (as JSON Schema) when the runtime exposes one via `DevToolsConfig.Message`. */
+/** A new browser runtime connected. */
 export const EventConnected = ts('EventConnected', {
     runtime: RuntimeInfo,
 });

package/dist/devTools/public.d.ts

@@ -1,2 +1,2 @@
-export { EventConnected, EventDisconnected, EventFrame, Event, KeyframeInfo, RequestDispatchMessage, RequestFrame, RequestGetMessage, RequestGetModel, RequestListKeyframes, RequestListMessages, RequestListRuntimes, RequestReplayToKeyframe, RequestResume, Request, ResponseDispatched, ResponseError, ResponseFrame, ResponseKeyframes, ResponseMessage, ResponseMessages, ResponseModel, ResponseReplayed, ResponseResumed, ResponseRuntimes, Response, RuntimeInfo, SerializedEntry, } from './protocol.js';
+export { EventConnected, EventDisconnected, EventFrame, Event, KeyframeInfo, RequestDispatchMessage, RequestFrame, RequestGetInit, RequestGetMessage, RequestGetModel, RequestGetModelAt, RequestGetRuntimeState, RequestListKeyframes, RequestListMessages, RequestListRuntimes, RequestReplayToKeyframe, RequestResume, Request, ResponseDispatched, ResponseError, ResponseFrame, ResponseInit, ResponseKeyframes, ResponseMessage, ResponseMessages, ResponseModel, ResponseReplayed, ResponseResumed, ResponseRuntimes, ResponseRuntimeState, Response, RuntimeInfo, SerializedEntry, } from './protocol.js';
 //# sourceMappingURL=public.d.ts.map

package/dist/devTools/public.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"public.d.ts","sourceRoot":"","sources":["../../src/devTools/public.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,iBAAiB,EACjB,UAAU,EACV,KAAK,EACL,YAAY,EACZ,sBAAsB,EACtB,YAAY,EACZ,iBAAiB,EACjB,eAAe,EACf,oBAAoB,EACpB,mBAAmB,EACnB,mBAAmB,EACnB,uBAAuB,EACvB,aAAa,EACb,OAAO,EACP,kBAAkB,EAClB,aAAa,EACb,aAAa,EACb,iBAAiB,EACjB,eAAe,EACf,gBAAgB,EAChB,aAAa,EACb,gBAAgB,EAChB,eAAe,EACf,gBAAgB,EAChB,QAAQ,EACR,WAAW,EACX,eAAe,GAChB,MAAM,eAAe,CAAA"}
+{"version":3,"file":"public.d.ts","sourceRoot":"","sources":["../../src/devTools/public.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,iBAAiB,EACjB,UAAU,EACV,KAAK,EACL,YAAY,EACZ,sBAAsB,EACtB,YAAY,EACZ,cAAc,EACd,iBAAiB,EACjB,eAAe,EACf,iBAAiB,EACjB,sBAAsB,EACtB,oBAAoB,EACpB,mBAAmB,EACnB,mBAAmB,EACnB,uBAAuB,EACvB,aAAa,EACb,OAAO,EACP,kBAAkB,EAClB,aAAa,EACb,aAAa,EACb,YAAY,EACZ,iBAAiB,EACjB,eAAe,EACf,gBAAgB,EAChB,aAAa,EACb,gBAAgB,EAChB,eAAe,EACf,gBAAgB,EAChB,oBAAoB,EACpB,QAAQ,EACR,WAAW,EACX,eAAe,GAChB,MAAM,eAAe,CAAA"}

package/dist/devTools/public.js

@@ -1 +1 @@
-export { EventConnected, EventDisconnected, EventFrame, Event, KeyframeInfo, RequestDispatchMessage, RequestFrame, RequestGetMessage, RequestGetModel, RequestListKeyframes, RequestListMessages, RequestListRuntimes, RequestReplayToKeyframe, RequestResume, Request, ResponseDispatched, ResponseError, ResponseFrame, ResponseKeyframes, ResponseMessage, ResponseMessages, ResponseModel, ResponseReplayed, ResponseResumed, ResponseRuntimes, Response, RuntimeInfo, SerializedEntry, } from './protocol.js';
+export { EventConnected, EventDisconnected, EventFrame, Event, KeyframeInfo, RequestDispatchMessage, RequestFrame, RequestGetInit, RequestGetMessage, RequestGetModel, RequestGetModelAt, RequestGetRuntimeState, RequestListKeyframes, RequestListMessages, RequestListRuntimes, RequestReplayToKeyframe, RequestResume, Request, ResponseDispatched, ResponseError, ResponseFrame, ResponseInit, ResponseKeyframes, ResponseMessage, ResponseMessages, ResponseModel, ResponseReplayed, ResponseResumed, ResponseRuntimes, ResponseRuntimeState, Response, RuntimeInfo, SerializedEntry, } from './protocol.js';

package/dist/devTools/serialize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serialize.d.ts","sourceRoot":"","sources":["../../src/devTools/serialize.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AACpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAE9C;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,GAAI,OAAO,OAAO,KAAG,OAiBjD,CAAA;AAEH;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,GAC5B,OAAO,YAAY,EACnB,OAAO,MAAM,KACZ,eASD,CAAA"}
+{"version":3,"file":"serialize.d.ts","sourceRoot":"","sources":["../../src/devTools/serialize.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AACpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAG9C;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,GAAI,OAAO,OAAO,KAAG,OAiBjD,CAAA;AAEH;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,GAC5B,OAAO,YAAY,EACnB,OAAO,MAAM,KACZ,eAkBF,CAAA"}

package/dist/devTools/serialize.js

@@ -1,4 +1,5 @@
 import { Array as Array_, Function, HashSet, Match as M, Predicate, Record, } from 'effect';
+import { extractSubmodelInfo } from './submodelPath.js';
 /**
  * Convert DOM-class instances (File, Blob, Date, URL) to plain-object
  * representations so the tree renderer's key-enumeration walk can see their
@@ -22,13 +23,18 @@ export const toInspectableValue = (value) => M.value(value).pipe(M.when(M.instan
  * plain string arrays for JSON transmission and runs the message body through
  * `toInspectableValue` so DOM-class instances become inspectable objects.
  */
-export const toSerializedEntry = (entry, index) => ({
-    index,
-    tag: entry.tag,
-    message: toInspectableValue(entry.message),
-    commandNames: entry.commandNames,
-    timestamp: entry.timestamp,
-    isModelChanged: entry.isModelChanged,
-    changedPaths: HashSet.toValues(entry.diff.changedPaths),
-    affectedPaths: HashSet.toValues(entry.diff.affectedPaths),
-});
+export const toSerializedEntry = (entry, index) => {
+    const { submodelPath, maybeLeafTag } = extractSubmodelInfo(entry.tag, entry.message);
+    return {
+        index,
+        tag: entry.tag,
+        message: toInspectableValue(entry.message),
+        commandNames: entry.commandNames,
+        timestamp: entry.timestamp,
+        isModelChanged: entry.isModelChanged,
+        changedPaths: HashSet.toValues(entry.diff.changedPaths),
+        affectedPaths: HashSet.toValues(entry.diff.affectedPaths),
+        submodelPath,
+        maybeLeafTag,
+    };
+};

package/dist/devTools/submodelPath.d.ts

@@ -0,0 +1,27 @@
+import { Option } from 'effect';
+export declare const GOT_MESSAGE_PATTERN: RegExp;
+export declare const isTagged: (u: unknown, overrideOptions?: import("effect/SchemaAST").ParseOptions | number) => u is {
+    readonly _tag: string;
+};
+/** Submodel chain information extracted from a recorded Message. */
+export type SubmodelInfo = Readonly<{
+    submodelPath: ReadonlyArray<string>;
+    maybeLeafTag: Option.Option<string>;
+}>;
+/**
+ * Walk a chain of `Got<Submodel>Message` wrappers in a recorded Message and
+ * return the wrapper tags plus the innermost leaf tag.
+ *
+ * The Submodel pattern propagates child Messages up to a parent by wrapping
+ * them in `GotChildMessage({ message: childMessage })`. Nested submodels stack
+ * those wrappers. Walking the chain reveals the parent → child → grandchild
+ * dispatch path that produced the entry.
+ *
+ * Returns an empty path and `Option.none` for top-level Messages whose tag
+ * doesn't match the `Got*Message` pattern. Otherwise the path lists wrapper
+ * tags from outer to inner, and `maybeLeafTag` is `Some` when the innermost
+ * wrapped value is itself a tagged Message (the underlying child Message that
+ * originated the chain).
+ */
+export declare const extractSubmodelInfo: (tag: string, message: unknown) => SubmodelInfo;
+//# sourceMappingURL=submodelPath.d.ts.map

package/dist/devTools/submodelPath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"submodelPath.d.ts","sourceRoot":"","sources":["../../src/devTools/submodelPath.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAqB,MAAM,QAAQ,CAAA;AAElD,eAAO,MAAM,mBAAmB,QAAmB,CAAA;AAGnD,eAAO,MAAM,QAAQ;;CAAe,CAAA;AAEpC,oEAAoE;AACpE,MAAM,MAAM,YAAY,GAAG,QAAQ,CAAC;IAClC,YAAY,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IACnC,YAAY,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;CACpC,CAAC,CAAA;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,mBAAmB,GAC9B,KAAK,MAAM,EACX,SAAS,OAAO,KACf,YAuBF,CAAA"}