foldkit 0.109.0 → 0.111.0

package/dist/devTools/historyQuery.d.ts

@@ -0,0 +1,85 @@
+import { Option, Order } from 'effect';
+import type { MessageTagCount } from './protocol.js';
+import { type HistoryEntry, type StoreState } from './store.js';
+/**
+ * Test a diff path against a dot-string pattern. Segments compare pairwise
+ * for the length of the shorter list; `*` in the pattern matches any single
+ * segment. Because the comparison stops at the shorter list, a pattern
+ * matches changes below it (`root.grid` matches a change at `root.grid.5.3`)
+ * and above it (`root.grid.5.3` matches a wholesale replacement recorded at
+ * `root.grid`).
+ */
+export declare const matchesPathPattern: (path: string, pattern: string) => boolean;
+/** Test a diff path against every pattern, succeeding on the first match. */
+export declare const matchesAnyPathPattern: (path: string, patterns: ReadonlyArray<string>) => boolean;
+/**
+ * Find the first pattern that can never match a diff path: one whose first
+ * segment is neither `root` nor `*`. Diff paths are always anchored at
+ * `root`, so accepting such a pattern would silently return no results.
+ */
+export declare const findUnanchoredPattern: (patterns: ReadonlyArray<string>) => Option.Option<string>;
+/** A retained history entry paired with its absolute history index. */
+export type IndexedEntry = Readonly<{
+    entry: HistoryEntry;
+    index: number;
+}>;
+/**
+ * Materialize the retained history entries with their absolute indices,
+ * dropping entries before `maybeSinceIndex` and entries whose `changedPaths`
+ * match none of the patterns. `Some([])` is treated as no filter so callers
+ * never have to special-case an empty pattern list. Entries that did not
+ * change the Model have no changed paths and never match a pattern filter.
+ */
+export declare const collectMatchingEntries: (state: StoreState, maybeSinceIndex: Option.Option<number>, maybeChangedPathsMatch: Option.Option<ReadonlyArray<string>>) => ReadonlyArray<IndexedEntry>;
+/** One page of matching history entries plus the cursor for the next page. */
+export type MessagesPage = Readonly<{
+    page: ReadonlyArray<IndexedEntry>;
+    maybeNextIndex: Option.Option<number>;
+}>;
+/**
+ * Page a filtered candidate list. Forward pages take the first `limit`
+ * candidates and report the absolute index of the next matching entry, which
+ * a follow-up call passes back as the since index. Tail pages (`isFromEnd`)
+ * take the final `limit` candidates, still in chronological order, and never
+ * have a next index.
+ */
+export declare const pageMatchingEntries: (candidates: ReadonlyArray<IndexedEntry>, limit: number, isFromEnd: boolean) => MessagesPage;
+/**
+ * Count entries by Message tag, sorted by count descending then tag ascending
+ * so the noisiest Messages surface first.
+ */
+export declare const countEntriesByTag: (entries: ReadonlyArray<IndexedEntry>) => ReadonlyArray<MessageTagCount>;
+/**
+ * The oldest non-init index `getModelAtIndex` can answer. The keyframe
+ * stored at `startIndex` is the Model right after entry `startIndex - 1`, so
+ * the index one before the oldest retained entry is still readable even
+ * though its entry was evicted.
+ */
+export declare const oldestReadableIndex: (state: StoreState) => number;
+/**
+ * Whether `getModelAtIndex` can answer for this index: `INIT_INDEX` once the
+ * init Model is recorded, otherwise an index between `oldestReadableIndex`
+ * and the latest entry. Indices outside this range have been evicted (or
+ * have not happened yet) and must be rejected rather than silently replayed
+ * from the wrong keyframe.
+ */
+export declare const isIndexReadable: (state: StoreState, index: number) => boolean;
+/**
+ * Format a clear error for an index `isIndexReadable` rejected, listing the
+ * index ranges the runtime can still answer for.
+ */
+export declare const formatIndexNotReadable: (state: StoreState, index: number) => string;
+/**
+ * Order diff paths for readability: segments compare pairwise, numeric
+ * segments compare as numbers so `root.items.2` sorts before
+ * `root.items.10`, and a path that is a prefix of another sorts first.
+ */
+export declare const pathOrder: Order.Order<string>;
+/**
+ * Read the summarized value at a diff path on a Model snapshot. `None` when
+ * the path does not exist on this side of the diff (a key or element that was
+ * added or removed). Resolution happens on the `toInspectableValue` transform
+ * of the Model, the same tree the diff handler walks.
+ */
+export declare const readSummarizedValueAt: (model: unknown, path: string) => Option.Option<unknown>;
+//# sourceMappingURL=historyQuery.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"historyQuery.d.ts","sourceRoot":"","sources":["../../src/devTools/historyQuery.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,MAAM,EAAE,KAAK,EAAgB,MAAM,QAAQ,CAAA;AAE3E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAEpD,OAAO,EACL,KAAK,YAAY,EAEjB,KAAK,UAAU,EAEhB,MAAM,YAAY,CAAA;AAOnB;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,GAAI,MAAM,MAAM,EAAE,SAAS,MAAM,KAAG,OAOhE,CAAA;AAEH,6EAA6E;AAC7E,eAAO,MAAM,qBAAqB,GAChC,MAAM,MAAM,EACZ,UAAU,aAAa,CAAC,MAAM,CAAC,KAC9B,OAA6E,CAAA;AAEhF;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,GAChC,UAAU,aAAa,CAAC,MAAM,CAAC,KAC9B,MAAM,CAAC,MAAM,CAAC,MAAM,CAQpB,CAAA;AAcH,uEAAuE;AACvE,MAAM,MAAM,YAAY,GAAG,QAAQ,CAAC;IAClC,KAAK,EAAE,YAAY,CAAA;IACnB,KAAK,EAAE,MAAM,CAAA;CACd,CAAC,CAAA;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,GACjC,OAAO,UAAU,EACjB,iBAAiB,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,EACtC,wBAAwB,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,KAC3D,aAAa,CAAC,YAAY,CAoB5B,CAAA;AAED,8EAA8E;AAC9E,MAAM,MAAM,YAAY,GAAG,QAAQ,CAAC;IAClC,IAAI,EAAE,aAAa,CAAC,YAAY,CAAC,CAAA;IACjC,cAAc,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;CACtC,CAAC,CAAA;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,GAC9B,YAAY,aAAa,CAAC,YAAY,CAAC,EACvC,OAAO,MAAM,EACb,WAAW,OAAO,KACjB,YAYI,CAAA;AAOP;;;GAGG;AACH,eAAO,MAAM,iBAAiB,GAC5B,SAAS,aAAa,CAAC,YAAY,CAAC,KACnC,aAAa,CAAC,eAAe,CAO7B,CAAA;AAEH;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAAI,OAAO,UAAU,KAAG,MACrB,CAAA;AAEnC;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,GAAI,OAAO,UAAU,EAAE,OAAO,MAAM,KAAG,OAGU,CAAA;AAE7E;;;GAGG;AACH,eAAO,MAAM,sBAAsB,GACjC,OAAO,UAAU,EACjB,OAAO,MAAM,KACZ,MAcF,CAAA;AAID;;;;GAIG;AACH,eAAO,MAAM,SAAS,EAAE,KAAK,CAAC,KAAK,CAAC,MAAM,CAgBxC,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,GAChC,OAAO,OAAO,EACd,MAAM,MAAM,KACX,MAAM,CAAC,MAAM,CAAC,OAAO,CAIrB,CAAA"}

package/dist/devTools/historyQuery.js

@@ -0,0 +1,123 @@
+import { Array, HashSet, Match, Option, Order, Record, pipe } from 'effect';
+import { toInspectableValue } from './serialize.js';
+import { INIT_INDEX, latestEntryIndex, } from './store.js';
+import { resolvePath, summarizeValue } from './summarize.js';
+const ROOT = 'root';
+const PATH_SEPARATOR = '.';
+const WILDCARD = '*';
+/**
+ * Test a diff path against a dot-string pattern. Segments compare pairwise
+ * for the length of the shorter list; `*` in the pattern matches any single
+ * segment. Because the comparison stops at the shorter list, a pattern
+ * matches changes below it (`root.grid` matches a change at `root.grid.5.3`)
+ * and above it (`root.grid.5.3` matches a wholesale replacement recorded at
+ * `root.grid`).
+ */
+export const matchesPathPattern = (path, pattern) => pipe(Array.zip(path.split(PATH_SEPARATOR), pattern.split(PATH_SEPARATOR)), Array.every(([pathSegment, patternSegment]) => patternSegment === WILDCARD || patternSegment === pathSegment));
+/** Test a diff path against every pattern, succeeding on the first match. */
+export const matchesAnyPathPattern = (path, patterns) => Array.some(patterns, pattern => matchesPathPattern(path, pattern));
+/**
+ * Find the first pattern that can never match a diff path: one whose first
+ * segment is neither `root` nor `*`. Diff paths are always anchored at
+ * `root`, so accepting such a pattern would silently return no results.
+ */
+export const findUnanchoredPattern = (patterns) => Array.findFirst(patterns, pattern => !Option.exists(Array.head(pattern.split(PATH_SEPARATOR)), firstSegment => firstSegment === ROOT || firstSegment === WILDCARD));
+const entryMatchesPatterns = (entry, maybePatterns) => Option.match(maybePatterns, {
+    onNone: () => true,
+    onSome: patterns => HashSet.some(entry.diff.changedPaths, path => matchesAnyPathPattern(path, patterns)),
+});
+/**
+ * Materialize the retained history entries with their absolute indices,
+ * dropping entries before `maybeSinceIndex` and entries whose `changedPaths`
+ * match none of the patterns. `Some([])` is treated as no filter so callers
+ * never have to special-case an empty pattern list. Entries that did not
+ * change the Model have no changed paths and never match a pattern filter.
+ */
+export const collectMatchingEntries = (state, maybeSinceIndex, maybeChangedPathsMatch) => {
+    const maybePatterns = Option.filter(maybeChangedPathsMatch, Array.isReadonlyArrayNonEmpty);
+    const startAbsolute = Option.getOrElse(maybeSinceIndex, () => state.startIndex);
+    const startRelative = Math.max(0, startAbsolute - state.startIndex);
+    return pipe(state.entries, Array.map((entry, relativeIndex) => ({
+        entry,
+        index: state.startIndex + relativeIndex,
+    })), Array.drop(startRelative), Array.filter(({ entry }) => entryMatchesPatterns(entry, maybePatterns)));
+};
+/**
+ * Page a filtered candidate list. Forward pages take the first `limit`
+ * candidates and report the absolute index of the next matching entry, which
+ * a follow-up call passes back as the since index. Tail pages (`isFromEnd`)
+ * take the final `limit` candidates, still in chronological order, and never
+ * have a next index.
+ */
+export const pageMatchingEntries = (candidates, limit, isFromEnd) => isFromEnd
+    ? {
+        page: Array.takeRight(candidates, limit),
+        maybeNextIndex: Option.none(),
+    }
+    : {
+        page: Array.take(candidates, limit),
+        maybeNextIndex: Option.map(Array.get(candidates, limit), ({ index }) => index),
+    };
+const tagCountOrder = Order.combine(Order.mapInput(Order.flip(Order.Number), ({ count }) => count), Order.mapInput(Order.String, ({ tag }) => tag));
+/**
+ * Count entries by Message tag, sorted by count descending then tag ascending
+ * so the noisiest Messages surface first.
+ */
+export const countEntriesByTag = (entries) => pipe(entries, Array.groupBy(({ entry }) => entry.tag), Record.toEntries, Array.map(([tag, group]) => ({ tag, count: group.length })), Array.sort(tagCountOrder));
+/**
+ * The oldest non-init index `getModelAtIndex` can answer. The keyframe
+ * stored at `startIndex` is the Model right after entry `startIndex - 1`, so
+ * the index one before the oldest retained entry is still readable even
+ * though its entry was evicted.
+ */
+export const oldestReadableIndex = (state) => Math.max(0, state.startIndex - 1);
+/**
+ * Whether `getModelAtIndex` can answer for this index: `INIT_INDEX` once the
+ * init Model is recorded, otherwise an index between `oldestReadableIndex`
+ * and the latest entry. Indices outside this range have been evicted (or
+ * have not happened yet) and must be rejected rather than silently replayed
+ * from the wrong keyframe.
+ */
+export const isIndexReadable = (state, index) => index === INIT_INDEX
+    ? Option.isSome(state.maybeInitModel)
+    : index >= oldestReadableIndex(state) && index <= latestEntryIndex(state);
+/**
+ * Format a clear error for an index `isIndexReadable` rejected, listing the
+ * index ranges the runtime can still answer for.
+ */
+export const formatIndexNotReadable = (state, index) => {
+    const latest = latestEntryIndex(state);
+    const initRange = Option.isSome(state.maybeInitModel) ? ['-1 (init)'] : [];
+    const entryRange = latest >= state.startIndex
+        ? [`${oldestReadableIndex(state)} to ${latest}`]
+        : [];
+    const ranges = [...initRange, ...entryRange];
+    return Array.match(ranges, {
+        onEmpty: () => `No Model at index ${index}: the runtime has not recorded init yet.`,
+        onNonEmpty: nonEmptyRanges => `No Model at index ${index}. Readable indices: ${nonEmptyRanges.join(' and ')}. Indices outside this range were either evicted from the rolling history buffer or have not been recorded yet.`,
+    });
+};
+const isArrayIndexSegment = (segment) => /^\d+$/.test(segment);
+/**
+ * Order diff paths for readability: segments compare pairwise, numeric
+ * segments compare as numbers so `root.items.2` sorts before
+ * `root.items.10`, and a path that is a prefix of another sorts first.
+ */
+export const pathOrder = Order.make((self, that) => {
+    const selfSegments = self.split(PATH_SEPARATOR);
+    const thatSegments = that.split(PATH_SEPARATOR);
+    const maybeFirstDifference = pipe(Array.zip(selfSegments, thatSegments), Array.findFirst(([selfSegment, thatSegment]) => selfSegment !== thatSegment));
+    return Option.match(maybeFirstDifference, {
+        onNone: () => Order.Number(selfSegments.length, thatSegments.length),
+        onSome: ([selfSegment, thatSegment]) => isArrayIndexSegment(selfSegment) && isArrayIndexSegment(thatSegment)
+            ? Order.Number(Number(selfSegment), Number(thatSegment))
+            : Order.String(selfSegment, thatSegment),
+    });
+});
+/**
+ * Read the summarized value at a diff path on a Model snapshot. `None` when
+ * the path does not exist on this side of the diff (a key or element that was
+ * added or removed). Resolution happens on the `toInspectableValue` transform
+ * of the Model, the same tree the diff handler walks.
+ */
+export const readSummarizedValueAt = (model, path) => Match.value(resolvePath(toInspectableValue(model), path)).pipe(Match.tag('Found', ({ value }) => Option.some(summarizeValue(value))), Match.orElse(() => Option.none()));

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,OAAO,EACP,MAAM,EAGN,OAAO,EAGP,MAAM,EAKN,MAAM,IAAI,CAAC,EAGX,eAAe,EAEhB,MAAM,QAAQ,CAAA;AAEf,OAAO,KAAK,OAAO,MAAM,qBAAqB,CAAA;AAa9C,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AAQ3E,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,aAAa,EAElB,KAAK,WAAW,EAChB,KAAK,UAAU,EAChB,MAAM,YAAY,CAAA;;oFAkaG,CAAC;;;;;;;;;;;;;;AAxHvB,cAAM,YAAa,SAAQ,iBAE1B;CAAG;;AAEJ,cAAM,iBAAkB,SAAQ,sBAGC;CAAG;AAEpC,eAAO,MAAM,UAAU;;iBAGsB,CAAA;AAE7C,eAAO,MAAM,YAAY;;iBAGwB,CAAA;AAWjD,eAAO,MAAM,MAAM;;;;wBAUlB,CAAA;AAED,eAAO,MAAM,YAAY;;;;;;;;wBAIqB,CAAA;AAE9C,eAAO,MAAM,aAAa;;;;;;wBAYzB,CAAA;AAED,eAAO,MAAM,MAAM;;wBASlB,CAAA;AAED,eAAO,MAAM,KAAK;;wBASjB,CAAA;AAED,eAAO,MAAM,WAAW;;6BAYvB,CAAA;AA+rDD,eAAO,MAAM,aAAa,GACxB,OAAO,aAAa,EACpB,UAAU,gBAAgB,EAC1B,MAAM,YAAY,EAClB,aAAa,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,6DAuEhC,CAAA"}
+{"version":3,"file":"overlay.d.ts","sourceRoot":"","sources":["../../src/devTools/overlay.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,OAAO,EACP,MAAM,EAGN,OAAO,EAGP,MAAM,EAKN,MAAM,IAAI,CAAC,EAGX,eAAe,EAEhB,MAAM,QAAQ,CAAA;AAEf,OAAO,KAAK,OAAO,MAAM,qBAAqB,CAAA;AAa9C,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AAQ3E,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,aAAa,EAElB,KAAK,WAAW,EAChB,KAAK,UAAU,EAEhB,MAAM,YAAY,CAAA;;oFAgbT,CAAF;;;;;;;;;;;;;;AAtIR,cAAM,YAAa,SAAQ,iBAE1B;CAAG;;AAEJ,cAAM,iBAAkB,SAAQ,sBAGC;CAAG;AAEpC,eAAO,MAAM,UAAU;;iBAGsB,CAAA;AAE7C,eAAO,MAAM,YAAY;;iBAGwB,CAAA;AAWjD,eAAO,MAAM,MAAM;;;;wBAUlB,CAAA;AAED,eAAO,MAAM,YAAY;;;;;;;;wBAIqB,CAAA;AAE9C,eAAO,MAAM,aAAa;;;;;;wBASzB,CAAA;AAED,eAAO,MAAM,MAAM;;wBASlB,CAAA;AAED,eAAO,MAAM,KAAK;;wBASjB,CAAA;AAED,eAAO,MAAM,WAAW;;6BAYvB,CAAA;AA+rDD,eAAO,MAAM,aAAa,GACxB,OAAO,aAAa,EACpB,UAAU,gBAAgB,EAC1B,MAAM,YAAY,EAClB,aAAa,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,6DAuEhC,CAAA"}

package/dist/devTools/overlay.js

@@ -13,7 +13,7 @@ import * as Slider from '../ui/slider/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, latestEntryIndex, } from './store.js';
 import { GOT_MESSAGE_PATTERN, extractSubmodelInfo, isTagged, } from './submodelPath.js';
 const SubmodelFilterListbox = Listbox.create();
 // MODEL
@@ -250,10 +250,7 @@ export const InspectState = Command.define('InspectState', { index: S.Number },
 export const InspectLatest = Command.define('InspectLatest', ReceivedInspectedState)(Effect.gen(function* () {
     const store = yield* StoreService;
     const state = yield* SubscriptionRef.get(store.stateRef);
-    const latestIndex = Array_.isReadonlyArrayEmpty(state.entries)
-        ? INIT_INDEX
-        : state.startIndex + state.entries.length - 1;
-    return yield* buildInspectionEffect(latestIndex);
+    return yield* buildInspectionEffect(latestEntryIndex(state));
 }));
 export const Resume = Command.define('Resume', CompletedResume)(Effect.gen(function* () {
     const store = yield* StoreService;

package/dist/devTools/protocol.d.ts

@@ -64,10 +64,23 @@ export declare const RequestGetModelAt: import("../schema/index.js").CallableTag
     maybePath: S.OptionFromNullOr<S.String>;
     expand: S.Boolean;
 }>;
-/** Request recent history entries, optionally starting from a given index. */
+/** Request recent history entries. `maybeSinceIndex` starts the page at an absolute index; `fromEnd` returns the final entries instead (the two are mutually exclusive). `maybeChangedPathsMatch` filters entries server-side to those whose `changedPaths` match at least one dot-string pattern: segments compare pairwise for the length of the shorter list and `*` matches any single segment, so `root.grid` matches changes anywhere inside the grid subtree and `root.grid.5.3` also matches a wholesale replacement recorded at `root.grid`. The two newer fields decode with defaults when absent, so requests from an older MCP server keep working against a newer runtime. */
 export declare const RequestListMessages: import("../schema/index.js").CallableTaggedStruct<"RequestListMessages", {
     limit: S.Number;
     maybeSinceIndex: S.OptionFromNullOr<S.Number>;
+    maybeChangedPathsMatch: S.withDecodingDefault<S.OptionFromNullOr<S.$Array<S.String>>, never>;
+    fromEnd: S.withDecodingDefault<S.Boolean, never>;
+}>;
+/** Request a histogram of retained history entries by Message tag. Accepts the same `maybeSinceIndex` / `maybeChangedPathsMatch` filters as `RequestListMessages` but returns only counts, so the response stays small regardless of history size. */
+export declare const RequestCountMessagesByTag: import("../schema/index.js").CallableTaggedStruct<"RequestCountMessagesByTag", {
+    maybeSinceIndex: S.OptionFromNullOr<S.Number>;
+    maybeChangedPathsMatch: S.OptionFromNullOr<S.$Array<S.String>>;
+}>;
+/** Request a path-level diff between the Models at two absolute history indices. Each index follows `RequestGetModelAt` semantics (the Model right after that entry was applied; -1 is the initial Model). `maybeChangedPathsMatch` narrows the reported changes with the same pattern semantics as `RequestListMessages`. */
+export declare const RequestDiffModels: import("../schema/index.js").CallableTaggedStruct<"RequestDiffModels", {
+    fromIndex: S.Number;
+    toIndex: S.Number;
+    maybeChangedPathsMatch: S.OptionFromNullOr<S.$Array<S.String>>;
 }>;
 /** Request a single history entry by index. To inspect the Model around the entry, call `RequestGetModelAt` with `index - 1` (before) and `index` (after). */
 export declare const RequestGetMessage: import("../schema/index.js").CallableTaggedStruct<"RequestGetMessage", {
@@ -106,6 +119,15 @@ export declare const Request: S.Union<readonly [import("../schema/index.js").Cal
 }>, import("../schema/index.js").CallableTaggedStruct<"RequestListMessages", {
     limit: S.Number;
     maybeSinceIndex: S.OptionFromNullOr<S.Number>;
+    maybeChangedPathsMatch: S.withDecodingDefault<S.OptionFromNullOr<S.$Array<S.String>>, never>;
+    fromEnd: S.withDecodingDefault<S.Boolean, never>;
+}>, import("../schema/index.js").CallableTaggedStruct<"RequestCountMessagesByTag", {
+    maybeSinceIndex: S.OptionFromNullOr<S.Number>;
+    maybeChangedPathsMatch: S.OptionFromNullOr<S.$Array<S.String>>;
+}>, import("../schema/index.js").CallableTaggedStruct<"RequestDiffModels", {
+    fromIndex: S.Number;
+    toIndex: S.Number;
+    maybeChangedPathsMatch: S.OptionFromNullOr<S.$Array<S.String>>;
 }>, import("../schema/index.js").CallableTaggedStruct<"RequestGetMessage", {
     index: S.Number;
 }>, import("../schema/index.js").CallableTaggedStruct<"RequestListKeyframes", {}>, import("../schema/index.js").CallableTaggedStruct<"RequestReplayToKeyframe", {
@@ -123,7 +145,7 @@ export declare const ResponseModel: import("../schema/index.js").CallableTaggedS
     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. */
+/** Response carrying a page of history entries. For forward reads, `maybeNextIndex` is `Some` of the absolute index of the next entry matching the request's filters (pass it as `RequestListMessages.maybeSinceIndex` to fetch the next page) and `None` when the page reaches the end of matching history. Tail reads (`fromEnd`) always carry `None`. */
 export declare const ResponseMessages: import("../schema/index.js").CallableTaggedStruct<"ResponseMessages", {
     entries: S.$Array<S.Struct<{
         readonly index: S.Number;
@@ -176,6 +198,61 @@ export declare const ResponseMessage: import("../schema/index.js").CallableTagge
         readonly maybeLeafTag: S.OptionFromNullOr<S.String>;
     }>;
 }>;
+/** One row of a Message-tag histogram. */
+export declare const MessageTagCount: S.Struct<{
+    readonly tag: S.String;
+    readonly count: S.Number;
+}>;
+/** One row of a Message-tag histogram. */
+export type MessageTagCount = typeof MessageTagCount.Type;
+/** Response carrying a Message-tag histogram, sorted by count descending then tag ascending. `totalCount` is the number of entries counted after filters. `scannedFromIndex` / `scannedToIndex` bound the absolute index range scanned (`scannedToIndex` is -1 when no entries are retained), so callers learn the live history bounds without a separate runtime-state call. */
+export declare const ResponseMessageCounts: import("../schema/index.js").CallableTaggedStruct<"ResponseMessageCounts", {
+    counts: S.$Array<S.Struct<{
+        readonly tag: S.String;
+        readonly count: S.Number;
+    }>>;
+    totalCount: S.Number;
+    scannedFromIndex: S.Number;
+    scannedToIndex: S.Number;
+}>;
+/** The value on one side of a Model diff path: `Present` carries the summarized value; `Absent` means the path does not exist on that side (an added or removed key or element). The tagged shape is deliberate: a nullable encoding could not distinguish an absent path from a path whose value is literally `null`. `undefined`, which JSON cannot represent, is reported as `null`. */
+export declare const DiffValueAbsent: import("../schema/index.js").CallableTaggedStruct<"Absent", {}>;
+/** The value on one side of a Model diff path. See `DiffValue`. */
+export declare const DiffValuePresent: import("../schema/index.js").CallableTaggedStruct<"Present", {
+    value: S.Unknown;
+}>;
+/** The value on one side of a Model diff path. */
+export declare const DiffValue: S.Union<readonly [import("../schema/index.js").CallableTaggedStruct<"Absent", {}>, import("../schema/index.js").CallableTaggedStruct<"Present", {
+    value: S.Unknown;
+}>]>;
+/** The value on one side of a Model diff path. */
+export type DiffValue = typeof DiffValue.Type;
+/** One changed path in a Model diff. `before` is the value at `fromIndex`, `after` the value at `toIndex`. */
+export declare const ModelDiffChange: S.Struct<{
+    readonly path: S.String;
+    readonly before: S.Union<readonly [import("../schema/index.js").CallableTaggedStruct<"Absent", {}>, import("../schema/index.js").CallableTaggedStruct<"Present", {
+        value: S.Unknown;
+    }>]>;
+    readonly after: S.Union<readonly [import("../schema/index.js").CallableTaggedStruct<"Absent", {}>, import("../schema/index.js").CallableTaggedStruct<"Present", {
+        value: S.Unknown;
+    }>]>;
+}>;
+/** One changed path in a Model diff. */
+export type ModelDiffChange = typeof ModelDiffChange.Type;
+/** Response carrying a path-level Model diff between two history indices. Changes list the leaf paths where the Models differ, sorted by path with numeric segments in numeric order; values are summarized with the same rules `ResponseModel` applies when `expand` is false. */
+export declare const ResponseModelDiff: import("../schema/index.js").CallableTaggedStruct<"ResponseModelDiff", {
+    fromIndex: S.Number;
+    toIndex: S.Number;
+    changes: S.$Array<S.Struct<{
+        readonly path: S.String;
+        readonly before: S.Union<readonly [import("../schema/index.js").CallableTaggedStruct<"Absent", {}>, import("../schema/index.js").CallableTaggedStruct<"Present", {
+            value: S.Unknown;
+        }>]>;
+        readonly after: S.Union<readonly [import("../schema/index.js").CallableTaggedStruct<"Absent", {}>, import("../schema/index.js").CallableTaggedStruct<"Present", {
+            value: S.Unknown;
+        }>]>;
+    }>>;
+}>;
 /** Response carrying the list of available keyframes. */
 export declare const ResponseKeyframes: import("../schema/index.js").CallableTaggedStruct<"ResponseKeyframes", {
     keyframes: S.$Array<S.Struct<{
@@ -338,6 +415,26 @@ export declare const Response: S.Union<readonly [import("../schema/index.js").Ca
         readonly submodelPath: S.$Array<S.String>;
         readonly maybeLeafTag: S.OptionFromNullOr<S.String>;
     }>;
+}>, import("../schema/index.js").CallableTaggedStruct<"ResponseMessageCounts", {
+    counts: S.$Array<S.Struct<{
+        readonly tag: S.String;
+        readonly count: S.Number;
+    }>>;
+    totalCount: S.Number;
+    scannedFromIndex: S.Number;
+    scannedToIndex: S.Number;
+}>, import("../schema/index.js").CallableTaggedStruct<"ResponseModelDiff", {
+    fromIndex: S.Number;
+    toIndex: S.Number;
+    changes: S.$Array<S.Struct<{
+        readonly path: S.String;
+        readonly before: S.Union<readonly [import("../schema/index.js").CallableTaggedStruct<"Absent", {}>, import("../schema/index.js").CallableTaggedStruct<"Present", {
+            value: S.Unknown;
+        }>]>;
+        readonly after: S.Union<readonly [import("../schema/index.js").CallableTaggedStruct<"Absent", {}>, import("../schema/index.js").CallableTaggedStruct<"Present", {
+            value: S.Unknown;
+        }>]>;
+    }>>;
 }>, import("../schema/index.js").CallableTaggedStruct<"ResponseKeyframes", {
     keyframes: S.$Array<S.Struct<{
         readonly index: S.Number;
@@ -424,6 +521,15 @@ export declare const RequestFrame: S.Struct<{
     }>, import("../schema/index.js").CallableTaggedStruct<"RequestListMessages", {
         limit: S.Number;
         maybeSinceIndex: S.OptionFromNullOr<S.Number>;
+        maybeChangedPathsMatch: S.withDecodingDefault<S.OptionFromNullOr<S.$Array<S.String>>, never>;
+        fromEnd: S.withDecodingDefault<S.Boolean, never>;
+    }>, import("../schema/index.js").CallableTaggedStruct<"RequestCountMessagesByTag", {
+        maybeSinceIndex: S.OptionFromNullOr<S.Number>;
+        maybeChangedPathsMatch: S.OptionFromNullOr<S.$Array<S.String>>;
+    }>, import("../schema/index.js").CallableTaggedStruct<"RequestDiffModels", {
+        fromIndex: S.Number;
+        toIndex: S.Number;
+        maybeChangedPathsMatch: S.OptionFromNullOr<S.$Array<S.String>>;
     }>, import("../schema/index.js").CallableTaggedStruct<"RequestGetMessage", {
         index: S.Number;
     }>, import("../schema/index.js").CallableTaggedStruct<"RequestListKeyframes", {}>, import("../schema/index.js").CallableTaggedStruct<"RequestReplayToKeyframe", {
@@ -492,6 +598,26 @@ export declare const ResponseFrame: S.Struct<{
             readonly submodelPath: S.$Array<S.String>;
             readonly maybeLeafTag: S.OptionFromNullOr<S.String>;
         }>;
+    }>, import("../schema/index.js").CallableTaggedStruct<"ResponseMessageCounts", {
+        counts: S.$Array<S.Struct<{
+            readonly tag: S.String;
+            readonly count: S.Number;
+        }>>;
+        totalCount: S.Number;
+        scannedFromIndex: S.Number;
+        scannedToIndex: S.Number;
+    }>, import("../schema/index.js").CallableTaggedStruct<"ResponseModelDiff", {
+        fromIndex: S.Number;
+        toIndex: S.Number;
+        changes: S.$Array<S.Struct<{
+            readonly path: S.String;
+            readonly before: S.Union<readonly [import("../schema/index.js").CallableTaggedStruct<"Absent", {}>, import("../schema/index.js").CallableTaggedStruct<"Present", {
+                value: S.Unknown;
+            }>]>;
+            readonly after: S.Union<readonly [import("../schema/index.js").CallableTaggedStruct<"Absent", {}>, import("../schema/index.js").CallableTaggedStruct<"Present", {
+                value: S.Unknown;
+            }>]>;
+        }>>;
     }>, import("../schema/index.js").CallableTaggedStruct<"ResponseKeyframes", {
         keyframes: S.$Array<S.Struct<{
             readonly index: S.Number;

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,4 +1,4 @@
-import { Schema as S } from 'effect';
+import { Effect, Schema as S } from 'effect';
 import { ts } from '../schema/index.js';
 // SHARED
 /** A serialized Command produced during a Message dispatch (or `init`). `args` is `Some` when the Command's definition declared an args record, and carries the runtime values used to construct the Command instance. */
@@ -48,10 +48,23 @@ export const RequestGetModelAt = ts('RequestGetModelAt', {
     maybePath: S.OptionFromNullOr(S.String),
     expand: S.Boolean,
 });
-/** Request recent history entries, optionally starting from a given index. */
+/** Request recent history entries. `maybeSinceIndex` starts the page at an absolute index; `fromEnd` returns the final entries instead (the two are mutually exclusive). `maybeChangedPathsMatch` filters entries server-side to those whose `changedPaths` match at least one dot-string pattern: segments compare pairwise for the length of the shorter list and `*` matches any single segment, so `root.grid` matches changes anywhere inside the grid subtree and `root.grid.5.3` also matches a wholesale replacement recorded at `root.grid`. The two newer fields decode with defaults when absent, so requests from an older MCP server keep working against a newer runtime. */
 export const RequestListMessages = ts('RequestListMessages', {
     limit: S.Number,
     maybeSinceIndex: S.OptionFromNullOr(S.Number),
+    maybeChangedPathsMatch: S.OptionFromNullOr(S.Array(S.String)).pipe(S.withDecodingDefault(Effect.succeed(null))),
+    fromEnd: S.Boolean.pipe(S.withDecodingDefault(Effect.succeed(false))),
+});
+/** Request a histogram of retained history entries by Message tag. Accepts the same `maybeSinceIndex` / `maybeChangedPathsMatch` filters as `RequestListMessages` but returns only counts, so the response stays small regardless of history size. */
+export const RequestCountMessagesByTag = ts('RequestCountMessagesByTag', {
+    maybeSinceIndex: S.OptionFromNullOr(S.Number),
+    maybeChangedPathsMatch: S.OptionFromNullOr(S.Array(S.String)),
+});
+/** Request a path-level diff between the Models at two absolute history indices. Each index follows `RequestGetModelAt` semantics (the Model right after that entry was applied; -1 is the initial Model). `maybeChangedPathsMatch` narrows the reported changes with the same pattern semantics as `RequestListMessages`. */
+export const RequestDiffModels = ts('RequestDiffModels', {
+    fromIndex: S.Number,
+    toIndex: S.Number,
+    maybeChangedPathsMatch: S.OptionFromNullOr(S.Array(S.String)),
 });
 /** Request a single history entry by index. To inspect the Model around the entry, call `RequestGetModelAt` with `index - 1` (before) and `index` (after). */
 export const RequestGetMessage = ts('RequestGetMessage', {
@@ -84,6 +97,8 @@ export const Request = S.Union([
     RequestGetModel,
     RequestGetModelAt,
     RequestListMessages,
+    RequestCountMessagesByTag,
+    RequestDiffModels,
     RequestGetMessage,
     RequestListKeyframes,
     RequestReplayToKeyframe,
@@ -101,7 +116,7 @@ export const ResponseModel = ts('ResponseModel', {
     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. */
+/** Response carrying a page of history entries. For forward reads, `maybeNextIndex` is `Some` of the absolute index of the next entry matching the request's filters (pass it as `RequestListMessages.maybeSinceIndex` to fetch the next page) and `None` when the page reaches the end of matching history. Tail reads (`fromEnd`) always carry `None`. */
 export const ResponseMessages = ts('ResponseMessages', {
     entries: S.Array(SerializedEntry),
     maybeNextIndex: S.OptionFromNullOr(S.Number),
@@ -110,6 +125,36 @@ export const ResponseMessages = ts('ResponseMessages', {
 export const ResponseMessage = ts('ResponseMessage', {
     entry: SerializedEntry,
 });
+/** One row of a Message-tag histogram. */
+export const MessageTagCount = S.Struct({
+    tag: S.String,
+    count: S.Number,
+});
+/** Response carrying a Message-tag histogram, sorted by count descending then tag ascending. `totalCount` is the number of entries counted after filters. `scannedFromIndex` / `scannedToIndex` bound the absolute index range scanned (`scannedToIndex` is -1 when no entries are retained), so callers learn the live history bounds without a separate runtime-state call. */
+export const ResponseMessageCounts = ts('ResponseMessageCounts', {
+    counts: S.Array(MessageTagCount),
+    totalCount: S.Number,
+    scannedFromIndex: S.Number,
+    scannedToIndex: S.Number,
+});
+/** The value on one side of a Model diff path: `Present` carries the summarized value; `Absent` means the path does not exist on that side (an added or removed key or element). The tagged shape is deliberate: a nullable encoding could not distinguish an absent path from a path whose value is literally `null`. `undefined`, which JSON cannot represent, is reported as `null`. */
+export const DiffValueAbsent = ts('Absent');
+/** The value on one side of a Model diff path. See `DiffValue`. */
+export const DiffValuePresent = ts('Present', { value: S.Unknown });
+/** The value on one side of a Model diff path. */
+export const DiffValue = S.Union([DiffValueAbsent, DiffValuePresent]);
+/** One changed path in a Model diff. `before` is the value at `fromIndex`, `after` the value at `toIndex`. */
+export const ModelDiffChange = S.Struct({
+    path: S.String,
+    before: DiffValue,
+    after: DiffValue,
+});
+/** Response carrying a path-level Model diff between two history indices. Changes list the leaf paths where the Models differ, sorted by path with numeric segments in numeric order; values are summarized with the same rules `ResponseModel` applies when `expand` is false. */
+export const ResponseModelDiff = ts('ResponseModelDiff', {
+    fromIndex: S.Number,
+    toIndex: S.Number,
+    changes: S.Array(ModelDiffChange),
+});
 /** Response carrying the list of available keyframes. */
 export const ResponseKeyframes = ts('ResponseKeyframes', {
     keyframes: S.Array(KeyframeInfo),
@@ -178,6 +223,8 @@ export const Response = S.Union([
     ResponseModel,
     ResponseMessages,
     ResponseMessage,
+    ResponseMessageCounts,
+    ResponseModelDiff,
     ResponseKeyframes,
     ResponseReplayed,
     ResponseResumed,

package/dist/devTools/public.d.ts

@@ -1,2 +1,2 @@
-export { EventConnected, EventDisconnected, EventFrame, Event, KeyframeInfo, RequestDispatchMessage, RequestFrame, RequestGetInit, RequestGetMessage, RequestGetMessageSchema, RequestGetModel, RequestGetModelAt, RequestGetRuntimeState, RequestListKeyframes, RequestListMessages, RequestListRuntimes, RequestReplayToKeyframe, RequestResume, Request, ResponseDispatched, ResponseError, ResponseFrame, ResponseInit, ResponseKeyframes, ResponseMessage, ResponseMessages, ResponseMessageSchema, ResponseModel, ResponseReplayed, ResponseResumed, ResponseRuntimes, ResponseRuntimeState, Response, RuntimeInfo, SerializedEntry, } from './protocol.js';
+export { EventConnected, EventDisconnected, EventFrame, Event, KeyframeInfo, DiffValue, DiffValueAbsent, DiffValuePresent, MessageTagCount, ModelDiffChange, RequestCountMessagesByTag, RequestDiffModels, RequestDispatchMessage, RequestFrame, RequestGetInit, RequestGetMessage, RequestGetMessageSchema, RequestGetModel, RequestGetModelAt, RequestGetRuntimeState, RequestListKeyframes, RequestListMessages, RequestListRuntimes, RequestReplayToKeyframe, RequestResume, Request, ResponseDispatched, ResponseError, ResponseFrame, ResponseInit, ResponseKeyframes, ResponseMessage, ResponseMessageCounts, ResponseMessages, ResponseMessageSchema, ResponseModel, ResponseModelDiff, 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,cAAc,EACd,iBAAiB,EACjB,uBAAuB,EACvB,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,qBAAqB,EACrB,aAAa,EACb,gBAAgB,EAChB,eAAe,EACf,gBAAgB,EAChB,oBAAoB,EACpB,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,SAAS,EACT,eAAe,EACf,gBAAgB,EAChB,eAAe,EACf,eAAe,EACf,yBAAyB,EACzB,iBAAiB,EACjB,sBAAsB,EACtB,YAAY,EACZ,cAAc,EACd,iBAAiB,EACjB,uBAAuB,EACvB,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,qBAAqB,EACrB,gBAAgB,EAChB,qBAAqB,EACrB,aAAa,EACb,iBAAiB,EACjB,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, RequestGetInit, RequestGetMessage, RequestGetMessageSchema, RequestGetModel, RequestGetModelAt, RequestGetRuntimeState, RequestListKeyframes, RequestListMessages, RequestListRuntimes, RequestReplayToKeyframe, RequestResume, Request, ResponseDispatched, ResponseError, ResponseFrame, ResponseInit, ResponseKeyframes, ResponseMessage, ResponseMessages, ResponseMessageSchema, ResponseModel, ResponseReplayed, ResponseResumed, ResponseRuntimes, ResponseRuntimeState, Response, RuntimeInfo, SerializedEntry, } from './protocol.js';
+export { EventConnected, EventDisconnected, EventFrame, Event, KeyframeInfo, DiffValue, DiffValueAbsent, DiffValuePresent, MessageTagCount, ModelDiffChange, RequestCountMessagesByTag, RequestDiffModels, RequestDispatchMessage, RequestFrame, RequestGetInit, RequestGetMessage, RequestGetMessageSchema, RequestGetModel, RequestGetModelAt, RequestGetRuntimeState, RequestListKeyframes, RequestListMessages, RequestListRuntimes, RequestReplayToKeyframe, RequestResume, Request, ResponseDispatched, ResponseError, ResponseFrame, ResponseInit, ResponseKeyframes, ResponseMessage, ResponseMessageCounts, ResponseMessages, ResponseMessageSchema, ResponseModel, ResponseModelDiff, ResponseReplayed, ResponseResumed, ResponseRuntimes, ResponseRuntimeState, Response, RuntimeInfo, SerializedEntry, } from './protocol.js';

package/dist/devTools/store.d.ts

@@ -40,6 +40,11 @@ export type Bridge = Readonly<{
     render: (model: unknown) => Effect.Effect<void>;
     markRenderPending: Effect.Effect<void>;
 }>;
+/**
+ * The absolute index of the most recently recorded entry, or `INIT_INDEX`
+ * when no Messages have been recorded yet.
+ */
+export declare const latestEntryIndex: (state: StoreState) => number;
 /**
  * Options for `createDevToolsStore`.
  *

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

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