foldkit 0.77.0 → 0.79.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/dist/ui/virtualList/index.d.ts

@@ -68,8 +68,26 @@ export declare const update: (model: Model, message: Message) => readonly [Model
  *
  *  Should be called after the container has rendered. If the container is not
  *  yet in the DOM the Command silently no-ops (the model still transitions
- *  through `ScrollingToIndex` → `Idle` via the version-matched completion). */
+ *  through `ScrollingToIndex` → `Idle` via the version-matched completion).
+ *
+ *  Assumes uniform row heights: target scroll position is computed as
+ *  `index * model.rowHeightPx`. For variable-height rows, use
+ *  `scrollToIndexVariable`. */
 export declare const scrollToIndex: (model: Model, index: number) => readonly [Model, ReadonlyArray<Command.Command<Message>>];
+/** Variable-height counterpart of `scrollToIndex`. Walks the heights of items
+ *  before `index` to compute the target `scrollTop`. Use this when rendering
+ *  the list with `itemToRowHeightPx`; use `scrollToIndex` for uniform heights.
+ *
+ *  Out-of-range indices clamp to the corresponding edge: negative or zero
+ *  scrolls to the top, indices past the end scroll past the last row.
+ *
+ *  Note: when restoring `initialScrollTop` on the first measurement of a
+ *  variable-height list, the runtime falls back to uniform-height math (using
+ *  `model.rowHeightPx`) because items aren't reachable from the `update`
+ *  function. Consumers who need an accurate initial scroll on a
+ *  variable-height list should call `scrollToIndexVariable` after the first
+ *  `MeasuredContainer` arrives. */
+export declare const scrollToIndexVariable: <Item>(model: Model, items: ReadonlyArray<Item>, itemToRowHeightPx: (item: Item, index: number) => number, index: number) => readonly [Model, ReadonlyArray<Command.Command<Message>>];
 /** Slice of the data array that the view should render, plus the spacer
  *  heights that keep the scrollbar physically correct. The first row in the
  *  slice corresponds to data index `startIndex`. */
@@ -82,10 +100,25 @@ export type VisibleWindow = Readonly<{
 /** Computes the visible slice of a data array given the current scroll
  *  position, container height, row height, and an overscan buffer.
  *
+ *  Assumes uniform row heights via `model.rowHeightPx`. For variable-height
+ *  rows, use `visibleWindowVariable`.
+ *
  *  Returns `Option.none()` when the container has not yet been measured;
  *  callers should render a placeholder (or `Html.empty`) and wait for the
  *  first `MeasuredContainer` message. */
 export declare const visibleWindow: (model: Model, itemCount: number, overscan: number) => Option.Option<VisibleWindow>;
+/** Variable-height counterpart of `visibleWindow`. Walks the heights of every
+ *  item to build a prefix-sum array, then locates the visible slice with two
+ *  linear searches.
+ *
+ *  Cost is O(N) per call, walking the whole `items` array once to build the
+ *  prefix sums. For lists in the 10k-item range, this comfortably fits inside
+ *  a 60Hz scroll budget. Larger lists or hotter scroll paths can layer a
+ *  prefix-sum cache invalidated when items change; that lives behind the same
+ *  return shape so consumers don't have to know.
+ *
+ *  Returns `Option.none()` when the container has not yet been measured. */
+export declare const visibleWindowVariable: <Item>(model: Model, items: ReadonlyArray<Item>, itemToRowHeightPx: (item: Item, index: number) => number, overscan: number) => Option.Option<VisibleWindow>;
 /** Schema describing the subscription dependencies for container scroll and
  *  resize tracking. */
 export declare const SubscriptionDeps: S.Struct<{
@@ -150,6 +183,14 @@ export type ViewConfig<Message, Item> = Readonly<{
     items: ReadonlyArray<Item>;
     itemToKey: (item: Item, index: number) => string;
     itemToView: (item: Item, index: number) => Html;
+    /** Optional per-item row height in pixels. When provided, the list renders
+     *  with variable-height rows: each row's wrapper takes the height returned
+     *  by this callback, and scroll math walks the items to compute the visible
+     *  slice and spacers. When absent, all rows use `model.rowHeightPx`. Use
+     *  this for tables with wrapping cells, taller detail rows, or any list
+     *  where rows differ. Prefer the uniform `rowHeightPx` path when row
+     *  heights are stable: it avoids the per-render walk over `items`. */
+    itemToRowHeightPx?: (item: Item, index: number) => number;
     /** Number of rows rendered above and below the visible viewport. Higher
      *  values smooth out fast scroll at the cost of mounting more DOM. Default
      *  is 5; react-window uses 1 and react-virtualized uses 3. Pick a value

package/dist/ui/virtualList/index.d.ts.map

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

package/dist/ui/virtualList/index.js

@@ -1,4 +1,4 @@
-import { Array, Effect, Match as M, Number, Option, Schema as S, Stream, } from 'effect';
+import { Array, Effect, Match as M, Number, Option, Schema as S, Stream, pipe, } from 'effect';
 import * as Command from '../../command/index.js';
 import { createLazy, html, } from '../../html/index.js';
 import { m } from '../../message/index.js';
@@ -110,6 +110,16 @@ export const update = (model, message) => M.value(message).pipe(M.withReturnType
         }
     },
 }));
+const buildScrollToIndex = (model, index, targetScrollTop) => {
+    const nextVersion = Number.increment(model.pendingScrollVersion);
+    return [
+        evo(model, {
+            pendingScrollVersion: () => nextVersion,
+            pendingScroll: () => ScrollingToIndex({ index, version: nextVersion }),
+        }),
+        [applyScroll(model.id, targetScrollTop, nextVersion)],
+    ];
+};
 /** Programmatically scrolls the container so the row at `index` is visible.
  *  Returns the next model and a Command that mutates `element.scrollTop`. The
  *  natural scroll event then flows back through `ScrolledContainer` and the
@@ -121,22 +131,42 @@ export const update = (model, message) => M.value(message).pipe(M.withReturnType
  *
  *  Should be called after the container has rendered. If the container is not
  *  yet in the DOM the Command silently no-ops (the model still transitions
- *  through `ScrollingToIndex` → `Idle` via the version-matched completion). */
-export const scrollToIndex = (model, index) => {
-    const nextVersion = Number.increment(model.pendingScrollVersion);
-    const targetScrollTop = index * model.rowHeightPx;
-    return [
-        evo(model, {
-            pendingScrollVersion: () => nextVersion,
-            pendingScroll: () => ScrollingToIndex({ index, version: nextVersion }),
-        }),
-        [applyScroll(model.id, targetScrollTop, nextVersion)],
-    ];
+ *  through `ScrollingToIndex` → `Idle` via the version-matched completion).
+ *
+ *  Assumes uniform row heights: target scroll position is computed as
+ *  `index * model.rowHeightPx`. For variable-height rows, use
+ *  `scrollToIndexVariable`. */
+export const scrollToIndex = (model, index) => buildScrollToIndex(model, index, index * model.rowHeightPx);
+/** Variable-height counterpart of `scrollToIndex`. Walks the heights of items
+ *  before `index` to compute the target `scrollTop`. Use this when rendering
+ *  the list with `itemToRowHeightPx`; use `scrollToIndex` for uniform heights.
+ *
+ *  Out-of-range indices clamp to the corresponding edge: negative or zero
+ *  scrolls to the top, indices past the end scroll past the last row.
+ *
+ *  Note: when restoring `initialScrollTop` on the first measurement of a
+ *  variable-height list, the runtime falls back to uniform-height math (using
+ *  `model.rowHeightPx`) because items aren't reachable from the `update`
+ *  function. Consumers who need an accurate initial scroll on a
+ *  variable-height list should call `scrollToIndexVariable` after the first
+ *  `MeasuredContainer` arrives. */
+export const scrollToIndexVariable = (model, items, itemToRowHeightPx, index) => {
+    const cumulativeOffsets = prefixSum(items, itemToRowHeightPx);
+    const targetScrollTop = pipe(cumulativeOffsets, Array.get(Math.max(0, index)), Option.getOrElse(() => lastOrZero(cumulativeOffsets)));
+    return buildScrollToIndex(model, index, targetScrollTop);
 };
 const clampIndex = (index, itemCount) => Math.max(0, Math.min(index, itemCount));
+const prefixSum = (items, itemToRowHeightPx) => {
+    const heights = Array.map(items, itemToRowHeightPx);
+    return Array.scan(heights, 0, (cumulative, height) => cumulative + height);
+};
+const lastOrZero = (values) => pipe(values, Array.last, Option.getOrElse(() => 0));
 /** Computes the visible slice of a data array given the current scroll
  *  position, container height, row height, and an overscan buffer.
  *
+ *  Assumes uniform row heights via `model.rowHeightPx`. For variable-height
+ *  rows, use `visibleWindowVariable`.
+ *
  *  Returns `Option.none()` when the container has not yet been measured;
  *  callers should render a placeholder (or `Html.empty`) and wait for the
  *  first `MeasuredContainer` message. */
@@ -157,6 +187,41 @@ export const visibleWindow = (model, itemCount, overscan) => M.value(model.measu
         });
     },
 }));
+/** Variable-height counterpart of `visibleWindow`. Walks the heights of every
+ *  item to build a prefix-sum array, then locates the visible slice with two
+ *  linear searches.
+ *
+ *  Cost is O(N) per call, walking the whole `items` array once to build the
+ *  prefix sums. For lists in the 10k-item range, this comfortably fits inside
+ *  a 60Hz scroll budget. Larger lists or hotter scroll paths can layer a
+ *  prefix-sum cache invalidated when items change; that lives behind the same
+ *  return shape so consumers don't have to know.
+ *
+ *  Returns `Option.none()` when the container has not yet been measured. */
+export const visibleWindowVariable = (model, items, itemToRowHeightPx, overscan) => M.value(model.measurement).pipe(M.withReturnType(), M.tagsExhaustive({
+    Unmeasured: () => Option.none(),
+    Measured: ({ containerHeight }) => {
+        const itemCount = items.length;
+        const cumulativeOffsets = prefixSum(items, itemToRowHeightPx);
+        const totalHeight = lastOrZero(cumulativeOffsets);
+        const firstVisibleIndex = pipe(cumulativeOffsets, Array.findFirstIndex(Number.greaterThan(model.scrollTop)), Option.match({
+            onNone: () => itemCount,
+            onSome: index => Math.max(0, index - 1),
+        }));
+        const lastVisibleIndex = pipe(cumulativeOffsets, Array.findFirstIndex(Number.greaterThanOrEqualTo(model.scrollTop + containerHeight)), Option.getOrElse(() => itemCount));
+        const startIndex = clampIndex(firstVisibleIndex - overscan, itemCount);
+        const endIndex = clampIndex(lastVisibleIndex + overscan, itemCount);
+        const topSpacerHeight = pipe(cumulativeOffsets, Array.get(startIndex), Option.getOrElse(() => 0));
+        const offsetAtEnd = pipe(cumulativeOffsets, Array.get(endIndex), Option.getOrElse(() => totalHeight));
+        const bottomSpacerHeight = totalHeight - offsetAtEnd;
+        return Option.some({
+            startIndex,
+            endIndex,
+            topSpacerHeight,
+            bottomSpacerHeight,
+        });
+    },
+}));
 // SUBSCRIPTION
 const containerElement = (id) => Option.fromNullable(document.getElementById(id));
 /** Schema describing the subscription dependencies for container scroll and
@@ -278,7 +343,7 @@ const DEFAULT_OVERSCAN = 5;
  *  count of currently mounted rows. */
 export const view = (config) => {
     const { AriaPosinset, AriaSetsize, Class, DataAttribute, Id, Role, Style, keyed, } = html();
-    const { model, items, itemToKey, itemToView, overscan = DEFAULT_OVERSCAN, rowElement = 'li', className, attributes = [], } = config;
+    const { model, items, itemToKey, itemToView, itemToRowHeightPx, overscan = DEFAULT_OVERSCAN, rowElement = 'li', className, attributes = [], } = config;
     const containerAttributes = [
         Id(model.id),
         Role('list'),
@@ -293,7 +358,13 @@ export const view = (config) => {
         ...attributes,
     ];
     const renderContainer = (children) => keyed('ul')(model.id, containerAttributes, children);
-    return Option.match(visibleWindow(model, items.length, overscan), {
+    const maybeWindow = itemToRowHeightPx !== undefined
+        ? visibleWindowVariable(model, items, itemToRowHeightPx, overscan)
+        : visibleWindow(model, items.length, overscan);
+    const rowHeightFor = (item, dataIndex) => itemToRowHeightPx !== undefined
+        ? itemToRowHeightPx(item, dataIndex)
+        : model.rowHeightPx;
+    return Option.match(maybeWindow, {
         onNone: () => renderContainer([]),
         onSome: ({ startIndex, endIndex, topSpacerHeight, bottomSpacerHeight }) => {
             const visibleItems = items.slice(startIndex, endIndex);
@@ -306,7 +377,10 @@ export const view = (config) => {
                     DataAttribute('virtual-list-item-index', String(dataIndex)),
                     AriaSetsize(items.length),
                     AriaPosinset(dataIndex + 1),
-                    Style({ height: `${model.rowHeightPx}px`, display: 'grid' }),
+                    Style({
+                        height: `${rowHeightFor(item, dataIndex)}px`,
+                        display: 'grid',
+                    }),
                 ], [itemToView(item, dataIndex)]);
             });
             return renderContainer([topSpacer, ...renderedRows, bottomSpacer]);

package/dist/ui/virtualList/public.d.ts

@@ -1,3 +1,3 @@
-export { init, update, scrollToIndex, view, lazy, subscriptions, visibleWindow, Model, Message, ScrolledContainer, MeasuredContainer, CompletedApplyScroll, SubscriptionDeps, } from './index.js';
+export { init, update, scrollToIndex, scrollToIndexVariable, view, lazy, subscriptions, visibleWindow, visibleWindowVariable, Model, Message, ScrolledContainer, MeasuredContainer, CompletedApplyScroll, SubscriptionDeps, } from './index.js';
 export type { InitConfig, ViewConfig, VisibleWindow } from './index.js';
 //# sourceMappingURL=public.d.ts.map

package/dist/ui/virtualList/public.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"public.d.ts","sourceRoot":"","sources":["../../../src/ui/virtualList/public.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EACJ,MAAM,EACN,aAAa,EACb,IAAI,EACJ,IAAI,EACJ,aAAa,EACb,aAAa,EACb,KAAK,EACL,OAAO,EACP,iBAAiB,EACjB,iBAAiB,EACjB,oBAAoB,EACpB,gBAAgB,GACjB,MAAM,YAAY,CAAA;AAEnB,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA"}
+{"version":3,"file":"public.d.ts","sourceRoot":"","sources":["../../../src/ui/virtualList/public.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EACJ,MAAM,EACN,aAAa,EACb,qBAAqB,EACrB,IAAI,EACJ,IAAI,EACJ,aAAa,EACb,aAAa,EACb,qBAAqB,EACrB,KAAK,EACL,OAAO,EACP,iBAAiB,EACjB,iBAAiB,EACjB,oBAAoB,EACpB,gBAAgB,GACjB,MAAM,YAAY,CAAA;AAEnB,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA"}

package/dist/ui/virtualList/public.js

@@ -1 +1 @@
-export { init, update, scrollToIndex, view, lazy, subscriptions, visibleWindow, Model, Message, ScrolledContainer, MeasuredContainer, CompletedApplyScroll, SubscriptionDeps, } from './index.js';
+export { init, update, scrollToIndex, scrollToIndexVariable, view, lazy, subscriptions, visibleWindow, visibleWindowVariable, Model, Message, ScrolledContainer, MeasuredContainer, CompletedApplyScroll, SubscriptionDeps, } from './index.js';

package/package.json

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