foldkit 0.77.0 → 0.78.0

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;AAU9C,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;AAkzCvE,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

@@ -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 => {

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;
@@ -26,14 +28,23 @@ export declare const RuntimeInfo: S.Struct<{
 }>;
 /** 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;
 }>;
@@ -45,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;
@@ -52,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", {
@@ -61,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", {
@@ -79,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;
@@ -93,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", {
@@ -121,13 +147,29 @@ export declare const ResponseRuntimes: import("../schema/index.js").CallableTagg
         title: typeof 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. `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;
@@ -138,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", {
@@ -150,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;
@@ -167,6 +211,16 @@ export declare const Response: S.Union<[import("../schema/index.js").CallableTag
         url: typeof S.String;
         title: typeof S.String;
     }>>;
+}>, 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;
 }>]>;
@@ -200,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", {
@@ -209,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;
@@ -217,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;
@@ -228,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", {
@@ -240,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;
@@ -257,6 +322,16 @@ export declare const ResponseFrame: S.Struct<{
             url: typeof S.String;
             title: typeof S.String;
         }>>;
+    }>, 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;
     }>]>;

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,6 +11,8 @@ 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({
@@ -23,14 +25,23 @@ export const RuntimeInfo = S.Struct({
     title: S.String,
 });
 // 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,
 });
@@ -42,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,
@@ -49,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', {
@@ -84,12 +99,26 @@ 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. */
 export const EventConnected = ts('EventConnected', {

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"}

package/dist/devTools/submodelPath.js

@@ -0,0 +1,36 @@
+import { Option, Schema as S, pipe } from 'effect';
+export const GOT_MESSAGE_PATTERN = /^Got.+Message$/;
+const Tagged = S.Struct({ _tag: S.String });
+export const isTagged = S.is(Tagged);
+/**
+ * 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 const extractSubmodelInfo = (tag, message) => {
+    if (!GOT_MESSAGE_PATTERN.test(tag)) {
+        return { submodelPath: [], maybeLeafTag: Option.none() };
+    }
+    const path = [tag];
+    /* eslint-disable @typescript-eslint/consistent-type-assertions */
+    let current = message?.['message'];
+    while (isTagged(current) && GOT_MESSAGE_PATTERN.test(current._tag)) {
+        path.push(current._tag);
+        current = current?.['message'];
+    }
+    /* eslint-enable @typescript-eslint/consistent-type-assertions */
+    return {
+        submodelPath: path,
+        maybeLeafTag: pipe(current, Option.liftPredicate(isTagged), Option.map(({ _tag }) => _tag)),
+    };
+};

package/dist/devTools/summarize.d.ts

@@ -0,0 +1,46 @@
+import { Schema as S } from 'effect';
+declare const PathResolution: S.Union<[import("../schema/index.js").CallableTaggedStruct<"Found", {
+    value: typeof S.Unknown;
+    atPath: typeof S.String;
+}>, import("../schema/index.js").CallableTaggedStruct<"NotFound", {
+    failedAt: typeof S.String;
+    reason: typeof S.String;
+    availableKeys: S.Array$<typeof S.String>;
+}>]>;
+/**
+ * Result of resolving a dot-string path against a Model snapshot.
+ *
+ * The path representation matches `SerializedEntry.changedPaths` exactly:
+ * dot-separated, anchored at the literal segment `root`. `Found.atPath`
+ * echoes the canonicalized path; `NotFound.availableKeys` lists the keys
+ * present at the deepest segment that resolved, so an agent can recover with
+ * one follow-up call.
+ */
+export type PathResolution = typeof PathResolution.Type;
+/**
+ * Walk a dot-string path against a Model snapshot. Returns the resolved value
+ * on success, or a structured `NotFound` describing the deepest segment that
+ * resolved plus its available keys so an agent can refine.
+ */
+export declare const resolvePath: (root: unknown, path: string) => PathResolution;
+/**
+ * Apply structural summarization rules to a value:
+ * - Arrays collapse to `{ _summary, length, sample: [head, last] }` at every depth.
+ * - Records walk to a depth of 3, then collapse to `{ _summary, keys }`.
+ * - Long strings collapse to `{ _summary, length, head }`.
+ * - Tagged values (`{ _tag, ... }`) keep their `_tag` since it's a record key.
+ *
+ * The result is JSON-serializable and intended for transmission to MCP clients
+ * with `expand: false`. Use raw values directly when `expand: true`.
+ */
+export declare const summarizeValue: (value: unknown) => unknown;
+/**
+ * Format a `NotFound` resolution as a single human-readable line for the
+ * `ResponseError.reason` channel. Includes the available keys at the failure
+ * point so an agent can refine the path on the next call.
+ */
+export declare const formatPathNotFound: (notFound: Extract<PathResolution, {
+    _tag: "NotFound";
+}>) => string;
+export {};
+//# sourceMappingURL=summarize.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"summarize.d.ts","sourceRoot":"","sources":["../../src/devTools/summarize.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,MAAM,IAAI,CAAC,EACZ,MAAM,QAAQ,CAAA;AAwBf,QAAA,MAAM,cAAc;;;;;;;IAA2B,CAAA;AAE/C;;;;;;;;GAQG;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC,IAAI,CAAA;AAiCvD;;;;GAIG;AACH,eAAO,MAAM,WAAW,GAAI,MAAM,OAAO,EAAE,MAAM,MAAM,KAAG,cAmCzD,CAAA;AA2DD;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,GAAI,OAAO,OAAO,KAAG,OAAgC,CAAA;AAYhF;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,GAC7B,UAAU,OAAO,CAAC,cAAc,EAAE;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CAAC,KACtD,MAIC,CAAA"}

package/dist/devTools/summarize.js

@@ -0,0 +1,111 @@
+import { Array as Array_, Function, Match as M, Option, Predicate, Record, Schema as S, } from 'effect';
+import { OptionExt } from '../effectExtensions/index.js';
+import { ts } from '../schema/index.js';
+const ROOT = 'root';
+const PATH_SEPARATOR = '.';
+const MAX_DEPTH = 3;
+const STRING_TRUNCATE = 200;
+const ARRAY_SAMPLE = 2;
+// PATH
+const Found = ts('Found', {
+    value: S.Unknown,
+    atPath: S.String,
+});
+const NotFound = ts('NotFound', {
+    failedAt: S.String,
+    reason: S.String,
+    availableKeys: S.Array(S.String),
+});
+const PathResolution = S.Union(Found, NotFound);
+const isExpandable = (value) => Predicate.isReadonlyRecord(value) || Array.isArray(value);
+const keysOf = (value) => M.value(value).pipe(M.when(Array.isArray, items => Array_.makeBy(items.length, index => index.toString())), M.when(Predicate.isReadonlyRecord, Record.keys), M.orElse(() => []));
+const segmentsOf = (path) => path === ROOT ? [] : path.split(PATH_SEPARATOR).slice(1);
+const isRootAnchored = (path) => path === ROOT || path.startsWith(`${ROOT}${PATH_SEPARATOR}`);
+const descend = (parent, segment) => M.value(parent).pipe(M.when(Array.isArray, array => Option.liftPredicate(Number(segment), Number.isInteger).pipe(Option.flatMap(index => Array_.get(array, index)))), M.when(Predicate.isReadonlyRecord, record => Record.get(record, segment)), M.orElse(() => Option.none()));
+/**
+ * Walk a dot-string path against a Model snapshot. Returns the resolved value
+ * on success, or a structured `NotFound` describing the deepest segment that
+ * resolved plus its available keys so an agent can refine.
+ */
+export const resolvePath = (root, path) => {
+    if (!isRootAnchored(path)) {
+        return NotFound({
+            failedAt: '',
+            reason: `Path must start with '${ROOT}'. Received: '${path}'.`,
+            availableKeys: [],
+        });
+    }
+    const initial = Found({ value: root, atPath: ROOT });
+    return Array_.reduce(segmentsOf(path), initial, (resolution, segment) => {
+        if (resolution._tag === 'NotFound') {
+            return resolution;
+        }
+        return Option.match(descend(resolution.value, segment), {
+            onNone: () => NotFound({
+                failedAt: resolution.atPath,
+                reason: isExpandable(resolution.value)
+                    ? `No '${segment}' at '${resolution.atPath}'.`
+                    : `Cannot descend into a primitive at '${resolution.atPath}' (looking for '${segment}').`,
+                availableKeys: keysOf(resolution.value),
+            }),
+            onSome: descended => Found({
+                value: descended,
+                atPath: `${resolution.atPath}${PATH_SEPARATOR}${segment}`,
+            }),
+        });
+    });
+};
+// SUMMARIZE
+const truncateString = (value) => value.length <= STRING_TRUNCATE
+    ? value
+    : {
+        _summary: 'string',
+        length: value.length,
+        head: value.slice(0, STRING_TRUNCATE),
+    };
+const sampleArray = (items, depth) => {
+    const sample = items.length <= ARRAY_SAMPLE
+        ? items
+        : [
+            ...Array_.take(items, ARRAY_SAMPLE - 1),
+            ...Option.toArray(Array_.last(items)),
+        ];
+    return Array_.map(sample, item => summarizeAt(item, depth + 1));
+};
+const summarizeArray = (items, depth) => ({
+    _summary: 'array',
+    length: items.length,
+    sample: sampleArray(items, depth),
+});
+const summarizeRecord = (value, depth) => {
+    if (depth >= MAX_DEPTH) {
+        return {
+            _summary: 'record',
+            keys: Record.keys(value),
+        };
+    }
+    return Record.map(value, child => summarizeAt(child, depth + 1));
+};
+const summarizeAt = (value, depth) => M.value(value).pipe(M.when(Predicate.isString, truncateString), M.when(Array.isArray, items => summarizeArray(items, depth)), M.when(Predicate.isReadonlyRecord, record => summarizeRecord(record, depth)), M.orElse(Function.identity));
+/**
+ * Apply structural summarization rules to a value:
+ * - Arrays collapse to `{ _summary, length, sample: [head, last] }` at every depth.
+ * - Records walk to a depth of 3, then collapse to `{ _summary, keys }`.
+ * - Long strings collapse to `{ _summary, length, head }`.
+ * - Tagged values (`{ _tag, ... }`) keep their `_tag` since it's a record key.
+ *
+ * The result is JSON-serializable and intended for transmission to MCP clients
+ * with `expand: false`. Use raw values directly when `expand: true`.
+ */
+export const summarizeValue = (value) => summarizeAt(value, 0);
+// FORMAT
+const formatAvailableKeys = (keys) => OptionExt.when(Array_.isNonEmptyReadonlyArray(keys), `Available keys: ${keys.join(', ')}.`);
+/**
+ * Format a `NotFound` resolution as a single human-readable line for the
+ * `ResponseError.reason` channel. Includes the available keys at the failure
+ * point so an agent can refine the path on the next call.
+ */
+export const formatPathNotFound = (notFound) => Option.match(formatAvailableKeys(notFound.availableKeys), {
+    onNone: () => notFound.reason,
+    onSome: hint => `${notFound.reason} ${hint}`,
+});

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

@@ -1 +1 @@
-{"version":3,"file":"webSocketBridge.d.ts","sourceRoot":"","sources":["../../src/devTools/webSocketBridge.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,MAAM,EAIN,MAAM,EAGN,MAAM,IAAI,CAAC,EAGZ,MAAM,QAAQ,CAAA;AAuBf,OAAO,EAAE,KAAK,aAAa,EAAc,MAAM,YAAY,CAAA;AAE3D,KAAK,GAAG,GAAG,WAAW,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAA;AAczC;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,oBAAoB,GAC/B,OAAO,aAAa,EACpB,KAAK,GAAG,EACR,UAAU,CAAC,OAAO,EAAE,OAAO,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EACnD,oBAAoB,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC,KAC3D,MAAM,CAAC,MAAM,CAAC,IAAI,CA0EjB,CAAA"}
+{"version":3,"file":"webSocketBridge.d.ts","sourceRoot":"","sources":["../../src/devTools/webSocketBridge.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,MAAM,EAIN,MAAM,EAGN,MAAM,IAAI,CAAC,EAGZ,MAAM,QAAQ,CAAA;AAyBf,OAAO,EAAE,KAAK,aAAa,EAAc,MAAM,YAAY,CAAA;AAQ3D,KAAK,GAAG,GAAG,WAAW,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAA;AAczC;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,oBAAoB,GAC/B,OAAO,aAAa,EACpB,KAAK,GAAG,EACR,UAAU,CAAC,OAAO,EAAE,OAAO,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EACnD,oBAAoB,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC,KAC3D,MAAM,CAAC,MAAM,CAAC,IAAI,CA0EjB,CAAA"}

package/dist/devTools/webSocketBridge.js

@@ -1,8 +1,9 @@
 import { Array, Cause, Effect, Either, HashMap, Match, Option, Order, Runtime, Schema as S, SubscriptionRef, pipe, } from 'effect';
 import { OptionExt } from '../effectExtensions/index.js';
-import { EventConnected, EventDisconnected, KeyframeInfo, RequestFrame, ResponseDispatched, ResponseError, ResponseKeyframes, ResponseMessage, ResponseMessages, ResponseModel, ResponseReplayed, ResponseResumed, RuntimeInfo, } from './protocol.js';
+import { EventConnected, EventDisconnected, KeyframeInfo, RequestFrame, ResponseDispatched, ResponseError, ResponseInit, ResponseKeyframes, ResponseMessage, ResponseMessages, ResponseModel, ResponseReplayed, ResponseResumed, ResponseRuntimeState, RuntimeInfo, } from './protocol.js';
 import { toInspectableValue, toSerializedEntry } from './serialize.js';
 import { INIT_INDEX } from './store.js';
+import { formatPathNotFound, resolvePath, summarizeValue, } from './summarize.js';
 const REQUEST_CHANNEL = 'foldkit:devTools:request';
 const RESPONSE_CHANNEL = 'foldkit:devTools:response';
 const EVENT_CHANNEL = 'foldkit:devTools:event';
@@ -80,14 +81,25 @@ export const startWebSocketBridge = (store, hot, dispatch, maybeMessageSchema) =
     });
     window.addEventListener('beforeunload', emitDisconnect, { once: true });
 });
+const presentResolution = (resolution, expand) => Match.value(resolution).pipe(Match.tag('Found', ({ value, atPath }) => ResponseModel({
+    value: expand ? value : summarizeValue(value),
+    atPath,
+    summarized: !expand,
+})), Match.orElse(notFound => ResponseError({ reason: formatPathNotFound(notFound) })));
+const readModelResponse = (store, index, maybePath, expand) => Effect.gen(function* () {
+    const model = yield* store.getModelAtIndex(index);
+    const path = Option.getOrElse(maybePath, () => 'root');
+    return presentResolution(resolvePath(toInspectableValue(model), path), expand);
+}).pipe(Effect.catchAllCause(cause => Effect.succeed(ResponseError({
+    reason: `Failed to read Model at index ${index}: ${Cause.pretty(cause)}`,
+}))));
 const dispatchRequest = (store, dispatch, maybeMessageSchema, request) => Match.value(request).pipe(Match.tagsExhaustive({
-    RequestGetModel: () => Effect.gen(function* () {
+    RequestGetModel: ({ maybePath, expand }) => Effect.gen(function* () {
         const state = yield* SubscriptionRef.get(store.stateRef);
         const index = currentAbsoluteIndex(state.entries.length, state.startIndex);
-        return yield* pipe(index, store.getModelAtIndex, Effect.map(model => ResponseModel({ model: toInspectableValue(model) })), Effect.catchAllCause(cause => Effect.succeed(ResponseError({
-            reason: `Failed to read current Model: ${Cause.pretty(cause)}`,
-        }))));
+        return yield* readModelResponse(store, index, maybePath, expand);
     }),
+    RequestGetModelAt: ({ index, maybePath, expand }) => readModelResponse(store, index, maybePath, expand),
     RequestListMessages: ({ limit, maybeSinceIndex }) => Effect.gen(function* () {
         const state = yield* SubscriptionRef.get(store.stateRef);
         const startAbsolute = Option.getOrElse(maybeSinceIndex, () => state.startIndex);
@@ -106,16 +118,9 @@ const dispatchRequest = (store, dispatch, maybeMessageSchema, request) => Match.
             onNone: () => Effect.succeed(ResponseError({
                 reason: `No entry at index ${index} (have ${state.startIndex} to ${state.startIndex + state.entries.length - 1})`,
             })),
-            onSome: entry => pipe({
-                modelBefore: store.getModelAtIndex(index - 1),
-                modelAfter: store.getModelAtIndex(index),
-            }, Effect.all, Effect.map(({ modelBefore, modelAfter }) => ResponseMessage({
+            onSome: entry => Effect.succeed(ResponseMessage({
                 entry: toSerializedEntry(entry, index),
-                modelBefore: toInspectableValue(modelBefore),
-                modelAfter: toInspectableValue(modelAfter),
-            })), Effect.catchAllCause(cause => Effect.succeed(ResponseError({
-                reason: `Failed to read Models around index ${index}: ${Cause.pretty(cause)}`,
-            })))),
+            })),
         });
     }),
     RequestListKeyframes: () => Effect.gen(function* () {
@@ -158,4 +163,23 @@ const dispatchRequest = (store, dispatch, maybeMessageSchema, request) => Match.
     RequestListRuntimes: () => Effect.succeed(ResponseError({
         reason: 'RequestListRuntimes is plugin-handled and should not reach the runtime bridge',
     })),
+    RequestGetInit: () => Effect.gen(function* () {
+        const state = yield* SubscriptionRef.get(store.stateRef);
+        return ResponseInit({
+            maybeModel: Option.map(state.maybeInitModel, toInspectableValue),
+            commandNames: state.initCommandNames,
+        });
+    }),
+    RequestGetRuntimeState: () => Effect.gen(function* () {
+        const state = yield* SubscriptionRef.get(store.stateRef);
+        const currentIndex = currentAbsoluteIndex(state.entries.length, state.startIndex);
+        return ResponseRuntimeState({
+            currentIndex,
+            startIndex: state.startIndex,
+            totalEntries: state.entries.length,
+            isPaused: state.isPaused,
+            maybePausedAtIndex: OptionExt.when(state.isPaused, state.pausedAtIndex),
+            hasInitModel: Option.isSome(state.maybeInitModel),
+        });
+    }),
 }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "foldkit",
-  "version": "0.77.0",
+  "version": "0.78.0",
   "description": "A frontend framework for TypeScript, built on Effect, using The Elm Architecture",
   "type": "module",
   "main": "./dist/index.js",