foldkit 0.152.0 → 0.153.0

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,5 +1,5 @@
 import { Effect, Schema as S } from 'effect';
-import { ts } from '../schema/index.js';
+import { defineTaggedUnion } 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. */
 export const SerializedCommand = S.Struct({
@@ -37,149 +37,66 @@ export const RuntimeInfo = S.Struct({
     title: S.String,
 });
 // REQUEST
-/** Request the current Model snapshot, optionally narrowed to a path and/or expanded. */
-export const RequestGetModel = ts('RequestGetModel', {
-    maybePath: S.OptionFromNullOr(S.String),
-    expand: S.Boolean,
-});
-/** Request a historical Model snapshot at an absolute history index, optionally narrowed to a path and/or expanded. Use `index: -1` for the initial Model. */
-export const RequestGetModelAt = ts('RequestGetModelAt', {
-    index: S.Number,
-    maybePath: S.OptionFromNullOr(S.String),
-    expand: S.Boolean,
-});
-/** Request recent history entries. `maybeSinceIndex` starts the page at an absolute index; `fromEnd` returns the final entries instead (the two are mutually exclusive). `maybeChangedPathsMatch` filters entries server-side to those whose `changedPaths` match at least one dot-string pattern: segments compare pairwise for the length of the shorter list and `*` matches any single segment, so `root.grid` matches changes anywhere inside the grid subtree and `root.grid.5.3` also matches a wholesale replacement recorded at `root.grid`. The two newer fields decode with defaults when absent, so requests from an older MCP server keep working against a newer runtime. */
-export 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', {
-    index: S.Number,
-});
-/** Request the list of available keyframes. */
-export const RequestListKeyframes = ts('RequestListKeyframes');
-/** Request the runtime jump to a specific keyframe. The runtime is paused on success; resume via RequestResume. */
-export const RequestReplayToKeyframe = ts('RequestReplayToKeyframe', {
-    keyframeIndex: S.Number,
-});
-/** 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,
-});
 /** The largest batch `RequestDispatchMessages` accepts. Matches the DevTools store's default history size, so a batch cannot evict its own earliest entries before the caller reads them back. The runtime rejects a larger batch with `ResponseError`, and MCP clients reject it earlier still, at their own input boundary. */
 export const MAX_DISPATCH_BATCH_SIZE = 100;
-/** Request the runtime dispatch an ordered batch of Messages at the current state. Payloads are opaque to the protocol; the runtime decodes every entry against the app's Message Schema before dispatching any of them, so one invalid entry rejects the whole batch and no Message from it is dispatched. Decoded Messages dispatch in array order through the same path as single dispatch, so the runtime may still record its own Messages between entries, exactly as with rapid user input. Batches larger than `MAX_DISPATCH_BATCH_SIZE` are rejected outright. */
-export const RequestDispatchMessages = ts('RequestDispatchMessages', {
-    messages: S.Array(S.Unknown),
+/** A request from the MCP server. The Vite plugin handles
+ * `Request.RequestListRuntimes`; it forwards every other request to a browser
+ * runtime. */
+export const Request = defineTaggedUnion({
+    RequestGetModel: {
+        maybePath: S.OptionFromNullOr(S.String),
+        expand: S.Boolean,
+    },
+    RequestGetModelAt: {
+        index: S.Number,
+        maybePath: S.OptionFromNullOr(S.String),
+        expand: S.Boolean,
+    },
+    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))),
+    },
+    RequestCountMessagesByTag: {
+        maybeSinceIndex: S.OptionFromNullOr(S.Number),
+        maybeChangedPathsMatch: S.OptionFromNullOr(S.Array(S.String)),
+    },
+    RequestDiffModels: {
+        fromIndex: S.Number,
+        toIndex: S.Number,
+        maybeChangedPathsMatch: S.OptionFromNullOr(S.Array(S.String)),
+    },
+    RequestGetMessage: { index: S.Number },
+    RequestListKeyframes: {},
+    RequestReplayToKeyframe: { keyframeIndex: S.Number },
+    RequestResume: {},
+    RequestDispatchMessage: { message: S.Unknown },
+    RequestDispatchMessages: { messages: S.Array(S.Unknown) },
+    RequestListRuntimes: {},
+    RequestGetInit: {},
+    RequestGetRuntimeState: {},
+    RequestGetMessageSchema: { maybeVariantTag: S.OptionFromNullOr(S.String) },
 });
-/** Request a description of the app's Message Schema. The runtime derives a JSON Schema document once at bridge boot from the configured `DevToolsConfig.Message`; the response is `None` when no Message Schema was configured. With `maybeVariantTag: None`, the response carries a small variant index (tag names plus payload field names and a tagged-union indicator) so MCP clients can enumerate the top-level variants without paying for the full schema. With `maybeVariantTag: Some(path)`, the value is interpreted as a dot-separated path of variant `_tag` values walked through each variant's single tagged-union payload field; the response carries the JSON Schema document narrowed along that chain, with any deeper unions collapsed to summary placeholders. Use the index to discover variants, then fetch one variant before calling `RequestDispatchMessage`. */
-export const RequestGetMessageSchema = ts('RequestGetMessageSchema', {
-    maybeVariantTag: S.OptionFromNullOr(S.String),
-});
-/** Request the list of currently connected browser runtimes. Handled by the Vite plugin, not forwarded to a runtime. */
-export 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,
-    RequestGetModelAt,
-    RequestListMessages,
-    RequestCountMessagesByTag,
-    RequestDiffModels,
-    RequestGetMessage,
-    RequestListKeyframes,
-    RequestReplayToKeyframe,
-    RequestResume,
-    RequestDispatchMessage,
-    RequestDispatchMessages,
-    RequestListRuntimes,
-    RequestGetInit,
-    RequestGetRuntimeState,
-    RequestGetMessageSchema,
-]);
 // RESPONSE
-/** 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', {
-    value: S.Unknown,
-    atPath: S.String,
-    summarized: S.Boolean,
-});
-/** Response carrying a page of history entries. For forward reads, `maybeNextIndex` is `Some` of the absolute index of the next entry matching the request's filters (pass it as `RequestListMessages.maybeSinceIndex` to fetch the next page) and `None` when the page reaches the end of matching history. Tail reads (`fromEnd`) always carry `None`. */
-export const ResponseMessages = ts('ResponseMessages', {
-    entries: S.Array(SerializedEntry),
-    maybeNextIndex: S.OptionFromNullOr(S.Number),
-});
-/** Response carrying a single history entry. Model snapshots are not included; use `RequestGetModelAt` with `index - 1` and `index` to inspect Model state around the entry. */
-export 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. `DiffValue.Present` carries the
+ * value. `DiffValue.Absent` means the path does not exist on that side, which
+ * keeps a missing path distinct from a path whose value is `null`. */
+export const DiffValue = defineTaggedUnion({
+    Absent: {},
+    Present: { value: S.Unknown },
 });
-/** 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),
-});
-/** Response confirming a successful replay. The runtime is paused at this Model. */
-export const ResponseReplayed = ts('ResponseReplayed', {
-    model: S.Unknown,
-});
-/** Response confirming the runtime resumed normal execution. */
-export const ResponseResumed = ts('ResponseResumed');
-/** Response confirming a Message was dispatched. The `acceptedAtIndex` is the absolute history index where the entry is predicted to land. Computed from the runtime's history length at dispatch time. The runtime processes Messages in arrival order, so the index is reliable whenever the bridge is the only Message source, but the app produces its own Messages too (user input, Subscription emissions, Command results); one recorded between the snapshot and the dispatch shifts the entry past this index. Messages excluded from history via `excludeFromHistory` still drive `update` but are never recorded, so no entry lands at the predicted index for them, and a Message dispatched into a crashed or disposed runtime is dropped without recording anything. */
-export const ResponseDispatched = ts('ResponseDispatched', {
-    acceptedAtIndex: S.Number,
-});
-/** Response confirming a batch dispatch. `acceptedAtIndices` aligns with the request's `messages` order; each value is the absolute history index where that entry is predicted to land, computed from one history snapshot at dispatch time with the same caveats as `ResponseDispatched.acceptedAtIndex`. An `excludeFromHistory` Message inside the batch records no entry, so entries after it land below their predicted index. */
-export const ResponseDispatchedBatch = ts('ResponseDispatchedBatch', {
-    acceptedAtIndices: S.Array(S.Number),
-});
 /** One variant entry in a `MessageSchemaIndex`. `payloadFields` lists the variant's payload property names (excluding `_tag`); `unionFields` lists the subset of those properties whose schemas are themselves `_tag`-discriminated unions. A Submodel-wrapper variant always shows up with `unionFields: ['message']`, but the same flag also catches plain tagged-union value types like `UrlRequest = Internal | External`. Either way, the agent will need to pick a variant when filling these fields. */
 export const MessageSchemaIndexEntry = S.Struct({
     tag: S.String,
@@ -190,74 +107,61 @@ export const MessageSchemaIndexEntry = S.Struct({
 export const MessageSchemaIndex = S.Struct({
     variants: S.Array(MessageSchemaIndexEntry),
 });
-/** The result payload carried by `ResponseMessageSchema`. `MessageSchemaIndexResult` is returned when the request omitted `maybeVariantTag`; `MessageSchemaDocumentResult` carries a JSON Schema document narrowed to one variant when a tag was supplied. */
-export const MessageSchemaIndexResult = ts('MessageSchemaIndexResult', {
-    index: MessageSchemaIndex,
-});
-/** A JSON Schema document carrying a single variant of the runtime's Message union, plus the original `definitions` block so any `$ref`s the variant carries still resolve. */
-export const MessageSchemaDocumentResult = ts('MessageSchemaDocumentResult', {
-    document: S.Unknown,
-});
-const MessageSchemaResult = S.Union([
-    MessageSchemaIndexResult,
-    MessageSchemaDocumentResult,
-]);
-/** Response describing the app's Message Schema. `maybeResult` is `Some(MessageSchemaIndexResult)` for index requests, `Some(MessageSchemaDocumentResult)` for variant-narrowed requests, and `None` when the runtime has not configured `DevToolsConfig.Message` or when JSON Schema derivation failed. Variant tags appear as `_tag` enums in the document, nested Submodel Messages recurse correctly, and `S.Option` fields render as `anyOf: [{_tag: 'Some', value}, {_tag: 'None'}]`. Apps using `S.OptionFromNullishOr(T)` (the Foldkit-canonical option codec for shapes that cross a JSON boundary) instead see the field as nullable `anyOf: [T, null]`; agents dispatching against that shape send either the bare value or `null`, not a tagged `Some`/`None` envelope. Fields with no JSON representation, such as `S.instanceOf(File)`, render as `{ type: 'null' }` rather than throwing; those variants cannot be dispatched via the bridge because their values live in browser memory. A few AST nodes (symbol-keyed structs, symbol-indexed records, tuples with post-rest elements) still cause the derivation to throw; the bridge guards the call and returns `None` in that case while logging a warning to the dev console. */
-export const ResponseMessageSchema = ts('ResponseMessageSchema', {
-    maybeResult: S.OptionFromNullOr(MessageSchemaResult),
-});
-/** Response carrying the list of connected runtimes. */
-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. `commands` lists the Commands returned from the application's `init` function in the order they were produced, with their args when declared. `mountStarts` lists the Mounts that fired during the initial render, with their args when declared. */
-export const ResponseInit = ts('ResponseInit', {
-    maybeModel: S.OptionFromNullOr(S.Unknown),
-    commands: S.Array(SerializedCommand),
-    mountStarts: S.Array(SerializedMount),
-});
-/** 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.OptionFromNullOr(S.Number),
-    hasInitModel: S.Boolean,
-});
-/** Response carrying an error reason for a failed Request. */
-export const ResponseError = ts('ResponseError', {
-    reason: S.String,
+/** The result of requesting the app's Message Schema. It is either a compact
+ * index of Message variants or the JSON Schema document for one variant. */
+export const MessageSchemaResult = defineTaggedUnion({
+    MessageSchemaIndexResult: { index: MessageSchemaIndex },
+    MessageSchemaDocumentResult: { document: S.Unknown },
 });
 /** A response replying to a Request. */
-export const Response = S.Union([
-    ResponseModel,
-    ResponseMessages,
-    ResponseMessage,
-    ResponseMessageCounts,
-    ResponseModelDiff,
-    ResponseKeyframes,
-    ResponseReplayed,
-    ResponseResumed,
-    ResponseDispatched,
-    ResponseDispatchedBatch,
-    ResponseRuntimes,
-    ResponseInit,
-    ResponseRuntimeState,
-    ResponseMessageSchema,
-    ResponseError,
-]);
-// EVENT
-/** A new browser runtime connected. */
-export const EventConnected = ts('EventConnected', {
-    runtime: RuntimeInfo,
-});
-/** A previously connected runtime disconnected. */
-export const EventDisconnected = ts('EventDisconnected', {
-    connectionId: S.String,
+export const Response = defineTaggedUnion({
+    ResponseModel: { value: S.Unknown, atPath: S.String, summarized: S.Boolean },
+    ResponseMessages: {
+        entries: S.Array(SerializedEntry),
+        maybeNextIndex: S.OptionFromNullOr(S.Number),
+    },
+    ResponseMessage: { entry: SerializedEntry },
+    ResponseMessageCounts: {
+        counts: S.Array(MessageTagCount),
+        totalCount: S.Number,
+        scannedFromIndex: S.Number,
+        scannedToIndex: S.Number,
+    },
+    ResponseModelDiff: {
+        fromIndex: S.Number,
+        toIndex: S.Number,
+        changes: S.Array(ModelDiffChange),
+    },
+    ResponseKeyframes: { keyframes: S.Array(KeyframeInfo) },
+    ResponseReplayed: { model: S.Unknown },
+    ResponseResumed: {},
+    ResponseDispatched: { acceptedAtIndex: S.Number },
+    ResponseDispatchedBatch: { acceptedAtIndices: S.Array(S.Number) },
+    ResponseRuntimes: { runtimes: S.Array(RuntimeInfo) },
+    ResponseInit: {
+        maybeModel: S.OptionFromNullOr(S.Unknown),
+        commands: S.Array(SerializedCommand),
+        mountStarts: S.Array(SerializedMount),
+    },
+    ResponseRuntimeState: {
+        currentIndex: S.Number,
+        startIndex: S.Number,
+        totalEntries: S.Number,
+        isPaused: S.Boolean,
+        maybePausedAtIndex: S.OptionFromNullOr(S.Number),
+        hasInitModel: S.Boolean,
+    },
+    ResponseMessageSchema: {
+        maybeResult: S.OptionFromNullOr(MessageSchemaResult),
+    },
+    ResponseError: { reason: S.String },
 });
+// EVENT
 /** A runtime lifecycle event used by the Vite plugin to track which browser tabs are connected. Not forwarded to MCP clients. */
-export const Event = S.Union([EventConnected, EventDisconnected]);
+export const Event = defineTaggedUnion({
+    EventConnected: { runtime: RuntimeInfo },
+    EventDisconnected: { connectionId: S.String },
+});
 // FRAME
 /** A wire frame carrying a Request from the MCP server. The id is opaque, used only by the MCP server to correlate the matching Response. The maybeConnectionId routes the request to a specific runtime when present. */
 export const RequestFrame = S.Struct({

package/dist/devTools/public.d.ts

@@ -1,2 +1,2 @@
-export { EventConnected, EventDisconnected, EventFrame, Event, KeyframeInfo, DiffValue, DiffValueAbsent, DiffValuePresent, MAX_DISPATCH_BATCH_SIZE, MessageTagCount, ModelDiffChange, RequestCountMessagesByTag, RequestDiffModels, RequestDispatchMessage, RequestDispatchMessages, RequestFrame, RequestGetInit, RequestGetMessage, RequestGetMessageSchema, RequestGetModel, RequestGetModelAt, RequestGetRuntimeState, RequestListKeyframes, RequestListMessages, RequestListRuntimes, RequestReplayToKeyframe, RequestResume, Request, ResponseDispatched, ResponseDispatchedBatch, ResponseError, ResponseFrame, ResponseInit, ResponseKeyframes, ResponseMessage, ResponseMessageCounts, ResponseMessages, ResponseMessageSchema, ResponseModel, ResponseModelDiff, ResponseReplayed, ResponseResumed, ResponseRuntimes, ResponseRuntimeState, Response, RuntimeInfo, SerializedEntry, } from './protocol.js';
+export { DiffValue, Event, EventFrame, KeyframeInfo, MAX_DISPATCH_BATCH_SIZE, MessageSchemaResult, MessageTagCount, ModelDiffChange, Request, RequestFrame, Response, ResponseFrame, 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,SAAS,EACT,eAAe,EACf,gBAAgB,EAChB,uBAAuB,EACvB,eAAe,EACf,eAAe,EACf,yBAAyB,EACzB,iBAAiB,EACjB,sBAAsB,EACtB,uBAAuB,EACvB,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,uBAAuB,EACvB,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"}
+{"version":3,"file":"public.d.ts","sourceRoot":"","sources":["../../src/devTools/public.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,KAAK,EACL,UAAU,EACV,YAAY,EACZ,uBAAuB,EACvB,mBAAmB,EACnB,eAAe,EACf,eAAe,EACf,OAAO,EACP,YAAY,EACZ,QAAQ,EACR,aAAa,EACb,WAAW,EACX,eAAe,GAChB,MAAM,eAAe,CAAA"}

package/dist/devTools/public.js

@@ -1 +1 @@
-export { EventConnected, EventDisconnected, EventFrame, Event, KeyframeInfo, DiffValue, DiffValueAbsent, DiffValuePresent, MAX_DISPATCH_BATCH_SIZE, MessageTagCount, ModelDiffChange, RequestCountMessagesByTag, RequestDiffModels, RequestDispatchMessage, RequestDispatchMessages, RequestFrame, RequestGetInit, RequestGetMessage, RequestGetMessageSchema, RequestGetModel, RequestGetModelAt, RequestGetRuntimeState, RequestListKeyframes, RequestListMessages, RequestListRuntimes, RequestReplayToKeyframe, RequestResume, Request, ResponseDispatched, ResponseDispatchedBatch, ResponseError, ResponseFrame, ResponseInit, ResponseKeyframes, ResponseMessage, ResponseMessageCounts, ResponseMessages, ResponseMessageSchema, ResponseModel, ResponseModelDiff, ResponseReplayed, ResponseResumed, ResponseRuntimes, ResponseRuntimeState, Response, RuntimeInfo, SerializedEntry, } from './protocol.js';
+export { DiffValue, Event, EventFrame, KeyframeInfo, MAX_DISPATCH_BATCH_SIZE, MessageSchemaResult, MessageTagCount, ModelDiffChange, Request, RequestFrame, Response, ResponseFrame, RuntimeInfo, SerializedEntry, } from './protocol.js';

package/dist/devTools/summarize.d.ts

@@ -1,27 +1,24 @@
 import { Schema as S } from 'effect';
-declare const PathResolution: S.Union<readonly [import("../schema/index.js").CallableTaggedStruct<"Found", {
-    value: S.Unknown;
-    atPath: S.String;
-}>, import("../schema/index.js").CallableTaggedStruct<"NotFound", {
-    failedAt: S.String;
-    reason: S.String;
-    availableKeys: S.$Array<S.String>;
-}>]>;
+declare const PathResolution: import("../schema/index.js").TaggedUnion<{
+    readonly Found: {
+        readonly value: S.Unknown;
+        readonly atPath: S.String;
+    };
+    readonly NotFound: {
+        readonly failedAt: S.String;
+        readonly reason: S.String;
+        readonly availableKeys: S.$Array<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.
+ * The result of looking up a `root.foo.bar` path in a Model snapshot.
+ * `PathResolution.Found` returns the value and the path where it was found.
+ * `PathResolution.NotFound` reports where the lookup stopped and which keys
+ * were available there.
  */
 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.
- */
+/** Looks up a `root.foo.bar` path in a Model snapshot. On failure, returns the
+ * deepest path reached and the keys available there. */
 export declare const resolvePath: (root: unknown, path: string) => PathResolution;
 /**
  * Apply structural summarization rules to a value:
@@ -34,11 +31,8 @@ export declare const resolvePath: (root: unknown, path: string) => PathResolutio
  * 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.
- */
+/** Formats a `NotFound` result for `ResponseError.reason`, including the keys
+ * available where the lookup stopped. */
 export declare const formatPathNotFound: (notFound: Extract<PathResolution, {
     _tag: "NotFound";
 }>) => string;

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

@@ -1 +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;;;;;;;IAA6B,CAAA;AAEjD;;;;;;;;GAQG;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC,IAAI,CAAA;AA8BvD;;;;GAIG;AACH,eAAO,MAAM,WAAW,GAAI,MAAM,OAAO,EAAE,MAAM,MAAM,KAAG,cAmCzD,CAAA;AAyDD;;;;;;;;;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"}
+{"version":3,"file":"summarize.d.ts","sourceRoot":"","sources":["../../src/devTools/summarize.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,MAAM,IAAI,CAAC,EACZ,MAAM,QAAQ,CAAA;AAaf,QAAA,MAAM,cAAc;;;;;;;;;;EAOlB,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC,IAAI,CAAA;AA8BvD;wDACwD;AACxD,eAAO,MAAM,WAAW,GAAI,MAAM,OAAO,EAAE,MAAM,MAAM,KAAG,cAsCzD,CAAA;AAyDD;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,GAAI,OAAO,OAAO,KAAG,OAAgC,CAAA;AAYhF;yCACyC;AACzC,eAAO,MAAM,kBAAkB,GAC7B,UAAU,OAAO,CAAC,cAAc,EAAE;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CAAC,KACtD,MAIC,CAAA"}

package/dist/devTools/summarize.js

@@ -1,54 +1,52 @@
 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';
+import { defineTaggedUnion } 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 PathResolution = defineTaggedUnion({
+    Found: { value: S.Unknown, atPath: S.String },
+    NotFound: {
+        failedAt: S.String,
+        reason: S.String,
+        availableKeys: S.Array(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 = Predicate.isObjectOrArray;
 const keysOf = (value) => M.value(value).pipe(M.when(Array.isArray, items => Array_.makeBy(items.length, index => index.toString())), M.when(Predicate.isObject, 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.isObject, 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.
- */
+/** Looks up a `root.foo.bar` path in a Model snapshot. On failure, returns the
+ * deepest path reached and the keys available there. */
 export const resolvePath = (root, path) => {
     if (!isRootAnchored(path)) {
-        return NotFound({
+        return PathResolution.NotFound({
             failedAt: '',
             reason: `Path must start with '${ROOT}'. Received: '${path}'.`,
             availableKeys: [],
         });
     }
-    const initial = Found({ value: root, atPath: ROOT });
+    const initial = PathResolution.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({
+            onNone: () => PathResolution.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({
+            onSome: descended => PathResolution.Found({
                 value: descended,
                 atPath: `${resolution.atPath}${PATH_SEPARATOR}${segment}`,
             }),
@@ -100,11 +98,8 @@ const summarizeAt = (value, depth) => M.value(value).pipe(M.when(Predicate.isStr
 export const summarizeValue = (value) => summarizeAt(value, 0);
 // FORMAT
 const formatAvailableKeys = (keys) => OptionExt.when(Array_.isReadonlyArrayNonEmpty(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.
- */
+/** Formats a `NotFound` result for `ResponseError.reason`, including the keys
+ * available where the lookup stopped. */
 export const formatPathNotFound = (notFound) => Option.match(formatAvailableKeys(notFound.availableKeys), {
     onNone: () => notFound.reason,
     onSome: hint => `${notFound.reason} ${hint}`,

package/dist/devTools/webSocketBridge.d.ts

@@ -1,5 +1,5 @@
 import { Effect, Option, Schema as S, Scope } from 'effect';
-import { type Request, type Response } from './protocol.js';
+import { type Request, Response } from './protocol.js';
 import { type DevToolsStore } from './store.js';
 type Hot = NonNullable<ImportMeta['hot']>;
 /** HMR channel the bridge announces connection lifecycle events on. */

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,EAEN,MAAM,IAAI,CAAC,EACX,KAAK,EAGN,MAAM,QAAQ,CAAA;AAcf,OAAO,EAYL,KAAK,OAAO,EAEZ,KAAK,QAAQ,EAiBd,MAAM,eAAe,CAAA;AAatB,OAAO,EACL,KAAK,aAAa,EAKnB,MAAM,YAAY,CAAA;AAQnB,KAAK,GAAG,GAAG,WAAW,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAA;AAKzC,uEAAuE;AACvE,eAAO,MAAM,aAAa,2BAA2B,CAAA;AAmBrD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;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,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,KACnD,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,CAsHrC,CAAA;AAsIJ;;;;GAIG;AACH,eAAO,MAAM,eAAe,GAC1B,OAAO,aAAa,EACpB,UAAU,CAAC,OAAO,EAAE,OAAO,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EACnD,qBAAqB,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,EACrD,yBAAyB,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,EAC/C,SAAS,OAAO,KACf,MAAM,CAAC,MAAM,CAAC,QAAQ,CA4UtB,CAAA"}
+{"version":3,"file":"webSocketBridge.d.ts","sourceRoot":"","sources":["../../src/devTools/webSocketBridge.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,MAAM,EAIN,MAAM,EAEN,MAAM,IAAI,CAAC,EACX,KAAK,EAGN,MAAM,QAAQ,CAAA;AAcf,OAAO,EAOL,KAAK,OAAO,EAEZ,QAAQ,EAGT,MAAM,eAAe,CAAA;AAatB,OAAO,EACL,KAAK,aAAa,EAKnB,MAAM,YAAY,CAAA;AAQnB,KAAK,GAAG,GAAG,WAAW,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAA;AAKzC,uEAAuE;AACvE,eAAO,MAAM,aAAa,2BAA2B,CAAA;AAmBrD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;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,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,KACnD,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,CAsHrC,CAAA;AAyIJ;;;;GAIG;AACH,eAAO,MAAM,eAAe,GAC1B,OAAO,aAAa,EACpB,UAAU,CAAC,OAAO,EAAE,OAAO,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EACnD,qBAAqB,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,EACrD,yBAAyB,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,EAC/C,SAAS,OAAO,KACf,MAAM,CAAC,MAAM,CAAC,QAAQ,CA8UtB,CAAA"}