foldkit 0.99.0 → 0.100.0

package/dist/devTools/protocol.d.ts

@@ -89,6 +89,10 @@ export declare const RequestGetRuntimeState: import("../schema/index.js").Callab
 export declare const RequestDispatchMessage: import("../schema/index.js").CallableTaggedStruct<"RequestDispatchMessage", {
     message: S.Unknown;
 }>;
+/** 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 declare const RequestGetMessageSchema: import("../schema/index.js").CallableTaggedStruct<"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 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. */
@@ -108,7 +112,9 @@ export declare const Request: S.Union<readonly [import("../schema/index.js").Cal
     keyframeIndex: S.Number;
 }>, import("../schema/index.js").CallableTaggedStruct<"RequestResume", {}>, import("../schema/index.js").CallableTaggedStruct<"RequestDispatchMessage", {
     message: S.Unknown;
-}>, import("../schema/index.js").CallableTaggedStruct<"RequestListRuntimes", {}>, import("../schema/index.js").CallableTaggedStruct<"RequestGetInit", {}>, import("../schema/index.js").CallableTaggedStruct<"RequestGetRuntimeState", {}>]>;
+}>, import("../schema/index.js").CallableTaggedStruct<"RequestListRuntimes", {}>, import("../schema/index.js").CallableTaggedStruct<"RequestGetInit", {}>, import("../schema/index.js").CallableTaggedStruct<"RequestGetRuntimeState", {}>, import("../schema/index.js").CallableTaggedStruct<"RequestGetMessageSchema", {
+    maybeVariantTag: S.OptionFromNullOr<S.String>;
+}>]>;
 /** A request from the MCP server. */
 export type Request = typeof Request.Type;
 /** 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. */
@@ -186,6 +192,65 @@ export declare const ResponseResumed: import("../schema/index.js").CallableTagge
 export declare const ResponseDispatched: import("../schema/index.js").CallableTaggedStruct<"ResponseDispatched", {
     acceptedAtIndex: 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 declare const MessageSchemaIndexEntry: S.Struct<{
+    readonly tag: S.String;
+    readonly payloadFields: S.$Array<S.String>;
+    readonly unionFields: S.$Array<S.String>;
+}>;
+/** One variant entry in a `MessageSchemaIndex`. */
+export type MessageSchemaIndexEntry = typeof MessageSchemaIndexEntry.Type;
+/** A flat directory of every top-level Message variant the runtime accepts, designed to fit in an agent context regardless of Message-union size. Use the tag names to make a follow-up `RequestGetMessageSchema` with `maybeVariantTag` set to fetch the full JSON Schema for one variant. */
+export declare const MessageSchemaIndex: S.Struct<{
+    readonly variants: S.$Array<S.Struct<{
+        readonly tag: S.String;
+        readonly payloadFields: S.$Array<S.String>;
+        readonly unionFields: S.$Array<S.String>;
+    }>>;
+}>;
+/** A flat directory of every top-level Message variant. */
+export type MessageSchemaIndex = typeof MessageSchemaIndex.Type;
+/** 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 declare const MessageSchemaIndexResult: import("../schema/index.js").CallableTaggedStruct<"MessageSchemaIndexResult", {
+    index: S.Struct<{
+        readonly variants: S.$Array<S.Struct<{
+            readonly tag: S.String;
+            readonly payloadFields: S.$Array<S.String>;
+            readonly unionFields: S.$Array<S.String>;
+        }>>;
+    }>;
+}>;
+/** 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 declare const MessageSchemaDocumentResult: import("../schema/index.js").CallableTaggedStruct<"MessageSchemaDocumentResult", {
+    document: S.Unknown;
+}>;
+declare const MessageSchemaResult: S.Union<readonly [import("../schema/index.js").CallableTaggedStruct<"MessageSchemaIndexResult", {
+    index: S.Struct<{
+        readonly variants: S.$Array<S.Struct<{
+            readonly tag: S.String;
+            readonly payloadFields: S.$Array<S.String>;
+            readonly unionFields: S.$Array<S.String>;
+        }>>;
+    }>;
+}>, import("../schema/index.js").CallableTaggedStruct<"MessageSchemaDocumentResult", {
+    document: S.Unknown;
+}>]>;
+/** The result payload carried by `ResponseMessageSchema`. */
+export type MessageSchemaResult = typeof MessageSchemaResult.Type;
+/** 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 declare const ResponseMessageSchema: import("../schema/index.js").CallableTaggedStruct<"ResponseMessageSchema", {
+    maybeResult: S.OptionFromNullOr<S.Union<readonly [import("../schema/index.js").CallableTaggedStruct<"MessageSchemaIndexResult", {
+        index: S.Struct<{
+            readonly variants: S.$Array<S.Struct<{
+                readonly tag: S.String;
+                readonly payloadFields: S.$Array<S.String>;
+                readonly unionFields: S.$Array<S.String>;
+            }>>;
+        }>;
+    }>, import("../schema/index.js").CallableTaggedStruct<"MessageSchemaDocumentResult", {
+        document: S.Unknown;
+    }>]>>;
+}>;
 /** Response carrying the list of connected runtimes. */
 export declare const ResponseRuntimes: import("../schema/index.js").CallableTaggedStruct<"ResponseRuntimes", {
     runtimes: S.$Array<S.Struct<{
@@ -304,6 +369,18 @@ export declare const Response: S.Union<readonly [import("../schema/index.js").Ca
     isPaused: S.Boolean;
     maybePausedAtIndex: S.OptionFromNullOr<S.Number>;
     hasInitModel: S.Boolean;
+}>, import("../schema/index.js").CallableTaggedStruct<"ResponseMessageSchema", {
+    maybeResult: S.OptionFromNullOr<S.Union<readonly [import("../schema/index.js").CallableTaggedStruct<"MessageSchemaIndexResult", {
+        index: S.Struct<{
+            readonly variants: S.$Array<S.Struct<{
+                readonly tag: S.String;
+                readonly payloadFields: S.$Array<S.String>;
+                readonly unionFields: S.$Array<S.String>;
+            }>>;
+        }>;
+    }>, import("../schema/index.js").CallableTaggedStruct<"MessageSchemaDocumentResult", {
+        document: S.Unknown;
+    }>]>>;
 }>, import("../schema/index.js").CallableTaggedStruct<"ResponseError", {
     reason: S.String;
 }>]>;
@@ -353,7 +430,9 @@ export declare const RequestFrame: S.Struct<{
         keyframeIndex: S.Number;
     }>, import("../schema/index.js").CallableTaggedStruct<"RequestResume", {}>, import("../schema/index.js").CallableTaggedStruct<"RequestDispatchMessage", {
         message: S.Unknown;
-    }>, import("../schema/index.js").CallableTaggedStruct<"RequestListRuntimes", {}>, import("../schema/index.js").CallableTaggedStruct<"RequestGetInit", {}>, import("../schema/index.js").CallableTaggedStruct<"RequestGetRuntimeState", {}>]>;
+    }>, import("../schema/index.js").CallableTaggedStruct<"RequestListRuntimes", {}>, import("../schema/index.js").CallableTaggedStruct<"RequestGetInit", {}>, import("../schema/index.js").CallableTaggedStruct<"RequestGetRuntimeState", {}>, import("../schema/index.js").CallableTaggedStruct<"RequestGetMessageSchema", {
+        maybeVariantTag: S.OptionFromNullOr<S.String>;
+    }>]>;
 }>;
 /** A wire frame carrying a Request from the MCP server. */
 export type RequestFrame = typeof RequestFrame.Type;
@@ -444,6 +523,18 @@ export declare const ResponseFrame: S.Struct<{
         isPaused: S.Boolean;
         maybePausedAtIndex: S.OptionFromNullOr<S.Number>;
         hasInitModel: S.Boolean;
+    }>, import("../schema/index.js").CallableTaggedStruct<"ResponseMessageSchema", {
+        maybeResult: S.OptionFromNullOr<S.Union<readonly [import("../schema/index.js").CallableTaggedStruct<"MessageSchemaIndexResult", {
+            index: S.Struct<{
+                readonly variants: S.$Array<S.Struct<{
+                    readonly tag: S.String;
+                    readonly payloadFields: S.$Array<S.String>;
+                    readonly unionFields: S.$Array<S.String>;
+                }>>;
+            }>;
+        }>, import("../schema/index.js").CallableTaggedStruct<"MessageSchemaDocumentResult", {
+            document: S.Unknown;
+        }>]>>;
     }>, import("../schema/index.js").CallableTaggedStruct<"ResponseError", {
         reason: S.String;
     }>]>;
@@ -465,4 +556,5 @@ export declare const EventFrame: S.Struct<{
 }>;
 /** A wire frame carrying a runtime lifecycle event. */
 export type EventFrame = typeof EventFrame.Type;
+export {};
 //# sourceMappingURL=protocol.d.ts.map

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

@@ -73,6 +73,10 @@ export const RequestGetRuntimeState = ts('RequestGetRuntimeState');
 export const RequestDispatchMessage = ts('RequestDispatchMessage', {
     message: S.Unknown,
 });
+/** 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. */
@@ -88,6 +92,7 @@ export const Request = S.Union([
     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. */
@@ -119,6 +124,32 @@ export const ResponseResumed = ts('ResponseResumed');
 export const ResponseDispatched = ts('ResponseDispatched', {
     acceptedAtIndex: 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,
+    payloadFields: S.Array(S.String),
+    unionFields: S.Array(S.String),
+});
+/** A flat directory of every top-level Message variant the runtime accepts, designed to fit in an agent context regardless of Message-union size. Use the tag names to make a follow-up `RequestGetMessageSchema` with `maybeVariantTag` set to fetch the full JSON Schema for one variant. */
+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),
@@ -154,6 +185,7 @@ export const Response = S.Union([
     ResponseRuntimes,
     ResponseInit,
     ResponseRuntimeState,
+    ResponseMessageSchema,
     ResponseError,
 ]);
 // EVENT

package/dist/devTools/public.d.ts

@@ -1,2 +1,2 @@
-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';
+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';
 //# 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,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"}
+{"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"}

package/dist/devTools/public.js

@@ -1 +1 @@
-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';
+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';

package/dist/devTools/schemaSummarize.d.ts

@@ -0,0 +1,82 @@
+import { Option } from 'effect';
+import type { MessageSchemaIndexEntry } from './protocol.js';
+/**
+ * Build a flat directory of every top-level Message variant from a JSON Schema
+ * document produced by `Schema.toJsonSchemaDocument`. The directory is small
+ * even for hundreds of variants, so an MCP client can paginate by tag without
+ * paying for the full schema.
+ *
+ * Returns `None` when the document's top-level `schema` is not a discriminated
+ * union of `_tag`-keyed structs (e.g. a single-variant Message Schema, or a
+ * shape produced by a future Effect Schema release that the summarizer does
+ * not yet understand). The caller should fall back to fetching the full
+ * document in that case.
+ */
+export declare const indexMessageSchemaDocument: (document: unknown) => Option.Option<ReadonlyArray<MessageSchemaIndexEntry>>;
+/**
+ * Split a dot-separated variant path into its segments. Empty segments are
+ * dropped so callers can pass user-supplied strings without first trimming
+ * leading/trailing dots.
+ */
+export declare const splitVariantPath: (variantPath: string) => ReadonlyArray<string>;
+/**
+ * Enumerate the variant tags available as the next segment of a variant path.
+ * Given a partial path that resolves to a tagged-union field, returns the tags
+ * of every variant in that union. Useful for crafting `not-found` error
+ * messages: if `narrowToVariant` fails on `"a.b.c"`, calling this with `["a", "b"]`
+ * yields the valid choices for the third segment.
+ *
+ * Returns `None` when the prefix cannot be resolved at all (e.g. the first
+ * segment names no top-level variant, or an intermediate variant lacks a
+ * tagged-union payload field).
+ */
+export declare const variantTagsAtPathPrefix: (document: unknown, pathPrefix: ReadonlyArray<string>) => Option.Option<ReadonlyArray<string>>;
+/**
+ * Diagnose where a variant-path walk would fail. Walks back from one segment
+ * before the supplied path length, returning the deepest prefix whose
+ * tagged-union level resolves cleanly, the tags available at that level, and
+ * the next segment from the original path (the one that broke the walk). When
+ * the offending segment is a known tag at that level, the failure means the
+ * variant exists but has no tagged-union field to step into further. When it
+ * is unknown, the failure is a simple typo. Returns `None` when not even the
+ * empty prefix resolves (i.e. the document is not a discriminated union at
+ * the top level).
+ */
+export declare const diagnoseVariantPath: (document: unknown, segments: ReadonlyArray<string>) => Option.Option<{
+    prefix: ReadonlyArray<string>;
+    failingSegment: Option.Option<string>;
+    available: ReadonlyArray<string>;
+}>;
+/**
+ * Replace the top-level `anyOf` in a JSON Schema document with a single-element
+ * `anyOf` containing the variant(s) selected by a dot-separated variant path.
+ *
+ * `variantPath` is a dot-string of variant `_tag` values, walked through the
+ * one tagged-union payload field at each step. For example, `"GotChildMessage"`
+ * narrows the top-level union to that wrapper variant, and
+ * `"GotChildMessage.Opened"` walks into the wrapper's nested union and narrows
+ * to the inner variant. Any deeper discriminated unions inside the deepest
+ * variant's payload are collapsed to `{ _summary: 'union', variants: [...] }`
+ * placeholders so the response stays small even for deeply-nested Submodel
+ * trees; agents drill further by extending the path.
+ *
+ * The `definitions` block is kept (any `$ref` targets the narrowed variant
+ * relies on still resolve, and dead refs left over from trimmed variants are
+ * harmless), but any discriminated unions inside it are collapsed to the same
+ * `_summary` placeholder shape so a shared union annotated with an
+ * `identifier` does not balloon the response. The path walker does not
+ * resolve `$ref` indirection through `definitions`; agents that need to step
+ * through a `$ref`-shared union look up the definition by name and use the
+ * placeholder's variant list directly.
+ *
+ * Returns `None` when the document is not a top-level discriminated union, the
+ * path is empty, a segment names no variant in the current union, or an
+ * intermediate variant lacks exactly one tagged-union payload field to step
+ * into (zero or multiple union fields are both ambiguous). The "exactly one"
+ * rule encodes the Foldkit idiom (`Got<Child>Message { message }` Submodel
+ * wrappers, single-union value-type fields); apps whose Message variants need
+ * additional surrounding state should pass it as an argument to the child's
+ * `update`/`view` rather than as a sibling field on the parent Message.
+ */
+export declare const narrowToVariant: (document: unknown, variantPath: string) => Option.Option<unknown>;
+//# sourceMappingURL=schemaSummarize.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemaSummarize.d.ts","sourceRoot":"","sources":["../../src/devTools/schemaSummarize.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,MAAM,EAMP,MAAM,QAAQ,CAAA;AAEf,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAA;AAgH5D;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,0BAA0B,GACrC,UAAU,OAAO,KAChB,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,uBAAuB,CAAC,CACG,CAAA;AA0H1D;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,GAAI,aAAa,MAAM,KAAG,aAAa,CAAC,MAAM,CAKxE,CAAA;AA8BH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,uBAAuB,GAClC,UAAU,OAAO,EACjB,YAAY,aAAa,CAAC,MAAM,CAAC,KAChC,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,CAGnC,CAAA;AAEH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,GAC9B,UAAU,OAAO,EACjB,UAAU,aAAa,CAAC,MAAM,CAAC,KAC9B,MAAM,CAAC,MAAM,CAAC;IACf,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IAC7B,cAAc,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;IACrC,SAAS,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CACjC,CAuBA,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,eAAe,GAC1B,UAAU,OAAO,EACjB,aAAa,MAAM,KAClB,MAAM,CAAC,MAAM,CAAC,OAAO,CAiBvB,CAAA"}

package/dist/devTools/schemaSummarize.js

@@ -0,0 +1,264 @@
+import { Array as Array_, Option, Predicate, Record, String as String_, flow, pipe, } from 'effect';
+const PATH_SEPARATOR = '.';
+const isRecord = (value) => Predicate.isObject(value) && !Array_.isArray(value);
+const isReadonlyArray = (value) => Array_.isArray(value);
+const isStringArray = (values) => Array_.every(values, Predicate.isString);
+const stringEnumOf = (schema) => {
+    if (!isRecord(schema)) {
+        return Option.none();
+    }
+    const candidate = schema['enum'];
+    if (!Array_.isArray(candidate)) {
+        return Option.none();
+    }
+    return Option.liftPredicate(candidate, isStringArray);
+};
+const variantTagOf = (schema) => {
+    if (!isRecord(schema) || schema['type'] !== 'object') {
+        return Option.none();
+    }
+    const properties = schema['properties'];
+    if (!isRecord(properties)) {
+        return Option.none();
+    }
+    return stringEnumOf(properties['_tag']).pipe(Option.flatMap(tags => tags.length === 1 ? Array_.head(tags) : Option.none()));
+};
+const anyOfOf = (schema) => {
+    if (!isRecord(schema)) {
+        return Option.none();
+    }
+    return Option.liftPredicate(schema['anyOf'], isReadonlyArray);
+};
+const isDiscriminatedUnion = (schema) => Option.exists(anyOfOf(schema), Predicate.and(Array_.isReadonlyArrayNonEmpty, Array_.every(flow(variantTagOf, Option.isSome))));
+const payloadFieldsOf = (variant) => {
+    if (!isRecord(variant)) {
+        return [];
+    }
+    const properties = variant['properties'];
+    if (!isRecord(properties)) {
+        return [];
+    }
+    return pipe(Record.keys(properties), Array_.filter(name => name !== '_tag'));
+};
+const unionFieldsOf = (variant) => {
+    if (!isRecord(variant)) {
+        return [];
+    }
+    const properties = variant['properties'];
+    if (!isRecord(properties)) {
+        return [];
+    }
+    return pipe(Record.toEntries(properties), Array_.filter(([name, schema]) => name !== '_tag' && isDiscriminatedUnion(schema)), Array_.map(([name]) => name));
+};
+const entryOf = (variant) => variantTagOf(variant).pipe(Option.map(tag => ({
+    tag,
+    payloadFields: payloadFieldsOf(variant),
+    unionFields: unionFieldsOf(variant),
+})));
+const topLevelVariantsOf = (document) => {
+    if (!isRecord(document)) {
+        return Option.none();
+    }
+    return anyOfOf(document['schema']);
+};
+const indexEntriesOf = (members) => pipe(members, Array_.map(entryOf), Array_.getSomes);
+/**
+ * Build a flat directory of every top-level Message variant from a JSON Schema
+ * document produced by `Schema.toJsonSchemaDocument`. The directory is small
+ * even for hundreds of variants, so an MCP client can paginate by tag without
+ * paying for the full schema.
+ *
+ * Returns `None` when the document's top-level `schema` is not a discriminated
+ * union of `_tag`-keyed structs (e.g. a single-variant Message Schema, or a
+ * shape produced by a future Effect Schema release that the summarizer does
+ * not yet understand). The caller should fall back to fetching the full
+ * document in that case.
+ */
+export const indexMessageSchemaDocument = (document) => Option.map(topLevelVariantsOf(document), indexEntriesOf);
+const collapseUnionsInValue = (value) => {
+    if (Array_.isArray(value)) {
+        return Array_.map(value, collapseUnionsInValue);
+    }
+    if (!isRecord(value)) {
+        return value;
+    }
+    if (isDiscriminatedUnion(value)) {
+        return Option.match(anyOfOf(value), {
+            onNone: () => value,
+            onSome: members => ({
+                _summary: 'union',
+                variants: indexEntriesOf(members),
+            }),
+        });
+    }
+    return Record.map(value, child => collapseUnionsInValue(child));
+};
+const collapseUnionsInVariantPayload = (variant) => {
+    if (!isRecord(variant)) {
+        return variant;
+    }
+    const properties = variant['properties'];
+    if (!isRecord(properties)) {
+        return variant;
+    }
+    const collapsed = Record.map(properties, (schema, name) => name === '_tag' ? schema : collapseUnionsInValue(schema));
+    return { ...variant, properties: collapsed };
+};
+const findVariantByTag = (members, tag) => Array_.findFirst(members, variant => Option.exists(variantTagOf(variant), candidate => candidate === tag));
+/**
+ * Idiomatic Foldkit Messages carry at most one tagged-union payload field per
+ * variant: either a `Got<Child>Message { message }` Submodel wrapper or a
+ * regular Message with one tagged-union value-type payload (e.g. `ClickedLink {
+ * request: UrlRequest }`). Multi-union-field variants are non-idiomatic;
+ * surrounding state that a child Submodel needs belongs as an argument to
+ * the child's `update`/`view`, not as a sibling field on the parent Message.
+ * Returns `None` when zero or multiple union fields exist so the path walker
+ * can produce an actionable error rather than silently picking one.
+ */
+const singleUnionFieldOf = (variant) => {
+    if (!isRecord(variant)) {
+        return Option.none();
+    }
+    const properties = variant['properties'];
+    if (!isRecord(properties)) {
+        return Option.none();
+    }
+    const unionEntries = pipe(Record.toEntries(properties), Array_.filter(([name, schema]) => name !== '_tag' && isDiscriminatedUnion(schema)));
+    if (unionEntries.length !== 1) {
+        return Option.none();
+    }
+    return Option.gen(function* () {
+        const [name, schema] = yield* Array_.head(unionEntries);
+        const members = yield* anyOfOf(schema);
+        return { name, members };
+    });
+};
+const replaceUnionField = (variant, fieldName, narrowedChild) => {
+    if (!isRecord(variant)) {
+        return variant;
+    }
+    const properties = variant['properties'];
+    if (!isRecord(properties)) {
+        return variant;
+    }
+    const updated = {
+        ...properties,
+        [fieldName]: { anyOf: [narrowedChild] },
+    };
+    return { ...variant, properties: updated };
+};
+const stepIntoVariant = (variant, rest) => Option.gen(function* () {
+    const field = yield* singleUnionFieldOf(variant);
+    const narrowedChild = yield* narrowAtPath(field.members, rest);
+    return replaceUnionField(variant, field.name, narrowedChild);
+});
+const narrowAtPath = (members, segments) => Option.gen(function* () {
+    const tag = yield* Array_.head(segments);
+    const variant = yield* findVariantByTag(members, tag);
+    const rest = Array_.drop(segments, 1);
+    if (Array_.isReadonlyArrayEmpty(rest)) {
+        return collapseUnionsInVariantPayload(variant);
+    }
+    return yield* stepIntoVariant(variant, rest);
+});
+/**
+ * Split a dot-separated variant path into its segments. Empty segments are
+ * dropped so callers can pass user-supplied strings without first trimming
+ * leading/trailing dots.
+ */
+export const splitVariantPath = (variantPath) => pipe(variantPath, String_.split(PATH_SEPARATOR), Array_.filter(String_.isNonEmpty));
+const stepToNextUnionMembers = (members, segment) => Option.gen(function* () {
+    const variant = yield* findVariantByTag(members, segment);
+    const field = yield* singleUnionFieldOf(variant);
+    return field.members;
+});
+const variantsAtPathPrefix = (document, segments) => Option.flatMap(topLevelVariantsOf(document), topMembers => Array_.reduce(segments, Option.some(topMembers), (currentMembers, segment) => Option.flatMap(currentMembers, members => stepToNextUnionMembers(members, segment))));
+/**
+ * Enumerate the variant tags available as the next segment of a variant path.
+ * Given a partial path that resolves to a tagged-union field, returns the tags
+ * of every variant in that union. Useful for crafting `not-found` error
+ * messages: if `narrowToVariant` fails on `"a.b.c"`, calling this with `["a", "b"]`
+ * yields the valid choices for the third segment.
+ *
+ * Returns `None` when the prefix cannot be resolved at all (e.g. the first
+ * segment names no top-level variant, or an intermediate variant lacks a
+ * tagged-union payload field).
+ */
+export const variantTagsAtPathPrefix = (document, pathPrefix) => Option.map(variantsAtPathPrefix(document, pathPrefix), members => Array_.map(indexEntriesOf(members), entry => entry.tag));
+/**
+ * Diagnose where a variant-path walk would fail. Walks back from one segment
+ * before the supplied path length, returning the deepest prefix whose
+ * tagged-union level resolves cleanly, the tags available at that level, and
+ * the next segment from the original path (the one that broke the walk). When
+ * the offending segment is a known tag at that level, the failure means the
+ * variant exists but has no tagged-union field to step into further. When it
+ * is unknown, the failure is a simple typo. Returns `None` when not even the
+ * empty prefix resolves (i.e. the document is not a discriminated union at
+ * the top level).
+ */
+export const diagnoseVariantPath = (document, segments) => {
+    const tryLength = (length) => {
+        if (length < 0) {
+            return Option.none();
+        }
+        const prefix = Array_.take(segments, length);
+        return Option.match(variantTagsAtPathPrefix(document, prefix), {
+            onNone: () => tryLength(length - 1),
+            onSome: available => Option.some({
+                prefix,
+                failingSegment: Array_.get(segments, length),
+                available,
+            }),
+        });
+    };
+    return tryLength(segments.length - 1);
+};
+/**
+ * Replace the top-level `anyOf` in a JSON Schema document with a single-element
+ * `anyOf` containing the variant(s) selected by a dot-separated variant path.
+ *
+ * `variantPath` is a dot-string of variant `_tag` values, walked through the
+ * one tagged-union payload field at each step. For example, `"GotChildMessage"`
+ * narrows the top-level union to that wrapper variant, and
+ * `"GotChildMessage.Opened"` walks into the wrapper's nested union and narrows
+ * to the inner variant. Any deeper discriminated unions inside the deepest
+ * variant's payload are collapsed to `{ _summary: 'union', variants: [...] }`
+ * placeholders so the response stays small even for deeply-nested Submodel
+ * trees; agents drill further by extending the path.
+ *
+ * The `definitions` block is kept (any `$ref` targets the narrowed variant
+ * relies on still resolve, and dead refs left over from trimmed variants are
+ * harmless), but any discriminated unions inside it are collapsed to the same
+ * `_summary` placeholder shape so a shared union annotated with an
+ * `identifier` does not balloon the response. The path walker does not
+ * resolve `$ref` indirection through `definitions`; agents that need to step
+ * through a `$ref`-shared union look up the definition by name and use the
+ * placeholder's variant list directly.
+ *
+ * Returns `None` when the document is not a top-level discriminated union, the
+ * path is empty, a segment names no variant in the current union, or an
+ * intermediate variant lacks exactly one tagged-union payload field to step
+ * into (zero or multiple union fields are both ambiguous). The "exactly one"
+ * rule encodes the Foldkit idiom (`Got<Child>Message { message }` Submodel
+ * wrappers, single-union value-type fields); apps whose Message variants need
+ * additional surrounding state should pass it as an argument to the child's
+ * `update`/`view` rather than as a sibling field on the parent Message.
+ */
+export const narrowToVariant = (document, variantPath) => {
+    if (!isRecord(document)) {
+        return Option.none();
+    }
+    const segments = splitVariantPath(variantPath);
+    if (Array_.isReadonlyArrayEmpty(segments)) {
+        return Option.none();
+    }
+    return Option.gen(function* () {
+        const members = yield* topLevelVariantsOf(document);
+        const narrowed = yield* narrowAtPath(members, segments);
+        return {
+            ...document,
+            schema: { anyOf: [narrowed] },
+            definitions: collapseUnionsInValue(document['definitions']),
+        };
+    });
+};

package/dist/devTools/webSocketBridge.d.ts

@@ -20,6 +20,15 @@ type Hot = NonNullable<ImportMeta['hot']>;
  * without author-side changes. When `maybeMessageSchema` is `None`, dispatch
  * requests are rejected with an informative error.
  *
+ * The bridge also derives a JSON Schema document from `maybeMessageSchema`
+ * once at boot (via `Schema.toJsonSchemaDocument`) to fulfill
+ * `RequestGetMessageSchema`, so MCP clients can discover the exact Message
+ * shapes the runtime accepts without reading the application source. A few
+ * AST nodes (symbol-keyed structs, symbol-indexed records, tuples with
+ * post-rest elements) cause `Schema.toJsonSchemaDocument` to throw; the
+ * derivation is guarded so a failure logs a warning and the schema-discovery
+ * tool returns `None` rather than crashing the bridge.
+ *
  * Production-safe: callers must check `import.meta.hot` is defined before
  * invoking this. The function assumes a live HMR connection.
  */

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,EAGZ,MAAM,QAAQ,CAAA;AA+Bf,OAAO,EAAE,KAAK,aAAa,EAAc,MAAM,YAAY,CAAA;AAQ3D,KAAK,GAAG,GAAG,WAAW,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAA;AAczC;;;;;;;;;;;;;;;;;;;;;GAqBG;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,CAiFjB,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,EAGZ,MAAM,QAAQ,CAAA;AAwCf,OAAO,EAAE,KAAK,aAAa,EAAc,MAAM,YAAY,CAAA;AAQ3D,KAAK,GAAG,GAAG,WAAW,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAA;AA4BzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;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,CAsFjB,CAAA"}

package/dist/devTools/webSocketBridge.js

@@ -1,6 +1,7 @@
 import { Array, Cause, Effect, Exit, HashMap, Match, Option, Order, Schema as S, SubscriptionRef, pipe, } from 'effect';
 import { OptionExt } from '../effectExtensions/index.js';
-import { EventConnected, EventDisconnected, EventFrame, KeyframeInfo, RequestFrame, ResponseDispatched, ResponseError, ResponseFrame, ResponseInit, ResponseKeyframes, ResponseMessage, ResponseMessages, ResponseModel, ResponseReplayed, ResponseResumed, ResponseRuntimeState, RuntimeInfo, } from './protocol.js';
+import { EventConnected, EventDisconnected, EventFrame, KeyframeInfo, MessageSchemaDocumentResult, MessageSchemaIndexResult, RequestFrame, ResponseDispatched, ResponseError, ResponseFrame, ResponseInit, ResponseKeyframes, ResponseMessage, ResponseMessageSchema, ResponseMessages, ResponseModel, ResponseReplayed, ResponseResumed, ResponseRuntimeState, RuntimeInfo, } from './protocol.js';
+import { diagnoseVariantPath, indexMessageSchemaDocument, narrowToVariant, splitVariantPath, } from './schemaSummarize.js';
 import { toInspectableValue, toSerializedCommand, toSerializedEntry, toSerializedMount, } from './serialize.js';
 import { INIT_INDEX } from './store.js';
 import { formatPathNotFound, resolvePath, summarizeValue, } from './summarize.js';
@@ -9,6 +10,15 @@ const RESPONSE_CHANNEL = 'foldkit:devTools:response';
 const EVENT_CHANNEL = 'foldkit:devTools:event';
 const generateConnectionId = () => `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
 const currentAbsoluteIndex = (entriesLength, startIndex) => (entriesLength === 0 ? INIT_INDEX : startIndex + entriesLength - 1);
+const tryDeriveJsonSchemaDocument = (schema) => {
+    try {
+        return Option.some(S.toJsonSchemaDocument(schema));
+    }
+    catch (error) {
+        console.warn('[foldkit:devTools] Failed to derive JSON Schema from Message Schema; foldkit_get_message_schema will return None.', error);
+        return Option.none();
+    }
+};
 /**
  * Start the browser-side WebSocket bridge that exposes a Foldkit runtime's
  * DevToolsStore to an external MCP server (via the Vite plugin relay).
@@ -28,6 +38,15 @@ const currentAbsoluteIndex = (entriesLength, startIndex) => (entriesLength === 0
  * without author-side changes. When `maybeMessageSchema` is `None`, dispatch
  * requests are rejected with an informative error.
  *
+ * The bridge also derives a JSON Schema document from `maybeMessageSchema`
+ * once at boot (via `Schema.toJsonSchemaDocument`) to fulfill
+ * `RequestGetMessageSchema`, so MCP clients can discover the exact Message
+ * shapes the runtime accepts without reading the application source. A few
+ * AST nodes (symbol-keyed structs, symbol-indexed records, tuples with
+ * post-rest elements) cause `Schema.toJsonSchemaDocument` to throw; the
+ * derivation is guarded so a failure logs a warning and the schema-discovery
+ * tool returns `None` rather than crashing the bridge.
+ *
  * Production-safe: callers must check `import.meta.hot` is defined before
  * invoking this. The function assumes a live HMR connection.
  */
@@ -35,6 +54,7 @@ export const startWebSocketBridge = (store, hot, dispatch, maybeMessageSchema) =
     const connectionId = generateConnectionId();
     const capturedContext = yield* Effect.context();
     const maybeDispatchSchema = Option.map(maybeMessageSchema, S.toCodecJson);
+    const maybeJsonSchemaDocument = Option.flatMap(maybeMessageSchema, tryDeriveJsonSchemaDocument);
     const encodeEventFrame = S.encodeUnknownSync(EventFrame);
     const encodeResponseFrame = S.encodeUnknownSync(ResponseFrame);
     const sendEvent = (event) => {
@@ -54,7 +74,7 @@ export const startWebSocketBridge = (store, hot, dispatch, maybeMessageSchema) =
         }),
     }));
     const handleRequest = (id, request) => Effect.gen(function* () {
-        const response = yield* dispatchRequest(store, dispatch, maybeDispatchSchema, request);
+        const response = yield* dispatchRequest(store, dispatch, maybeDispatchSchema, maybeJsonSchemaDocument, request);
         sendResponse(id, response);
     });
     const handleRequestFrame = (frame) => {
@@ -99,7 +119,47 @@ const readModelResponse = (store, index, maybePath, expand) => Effect.gen(functi
 }).pipe(Effect.catchCause(cause => Effect.succeed(ResponseError({
     reason: `Failed to read Model at index ${index}: ${Cause.pretty(cause)}`,
 }))));
-const dispatchRequest = (store, dispatch, maybeDispatchSchema, request) => Match.value(request).pipe(Match.tagsExhaustive({
+const indexResponse = (document) => Option.match(indexMessageSchemaDocument(document), {
+    onNone: () => ResponseError({
+        reason: "Could not index Message Schema: the top-level shape is not a discriminated union of '_tag'-keyed structs. Open an issue if you see this against an Effect Schema released after foldkit's last sync.",
+    }),
+    onSome: variants => ResponseMessageSchema({
+        maybeResult: Option.some(MessageSchemaIndexResult({ index: { variants } })),
+    }),
+});
+const narrowResponse = (document, variantPath) => Option.match(narrowToVariant(document, variantPath), {
+    onNone: () => formatUnknownVariantError(document, variantPath),
+    onSome: narrowed => ResponseMessageSchema({
+        maybeResult: Option.some(MessageSchemaDocumentResult({ document: narrowed })),
+    }),
+});
+const buildMessageSchemaResponse = (maybeJsonSchemaDocument, maybeVariantTag) => Option.match(maybeJsonSchemaDocument, {
+    onNone: () => ResponseMessageSchema({ maybeResult: Option.none() }),
+    onSome: document => Option.match(maybeVariantTag, {
+        onNone: () => indexResponse(document),
+        onSome: variantTag => narrowResponse(document, variantTag),
+    }),
+});
+const formatUnknownVariantError = (document, variantPath) => {
+    const segments = splitVariantPath(variantPath);
+    return Option.match(diagnoseVariantPath(document, segments), {
+        onNone: () => ResponseError({
+            reason: `No Message variant at path '${variantPath}'. The runtime's Message Schema is not a discriminated union of '_tag'-keyed structs.`,
+        }),
+        onSome: ({ prefix, failingSegment, available }) => {
+            const prefixLabel = Array.isReadonlyArrayNonEmpty(prefix)
+                ? prefix.join('.')
+                : '<top level>';
+            const failingIsKnownTag = Option.exists(failingSegment, tag => available.includes(tag));
+            const failingTag = Option.getOrElse(failingSegment, () => '');
+            const reason = failingIsKnownTag
+                ? `No further structure to drill into at path '${variantPath}'. The variant '${failingTag}' at ${prefixLabel} does not carry exactly one tagged-union payload field, which is what the walker steps through. Idiomatic Foldkit Messages have at most one tagged-union field per variant (the 'message' field on Submodel wrappers, or a single value-type union); state surrounding a Submodel call belongs as an argument to the child's update/view, not as a sibling field on the parent Message.`
+                : `No Message variant at path '${variantPath}'. Available variants at ${prefixLabel}: ${available.join(', ')}.`;
+            return ResponseError({ reason });
+        },
+    });
+};
+const dispatchRequest = (store, dispatch, maybeDispatchSchema, maybeJsonSchemaDocument, request) => Match.value(request).pipe(Match.tagsExhaustive({
     RequestGetModel: ({ maybePath, expand }) => Effect.gen(function* () {
         const state = yield* SubscriptionRef.get(store.stateRef);
         const index = currentAbsoluteIndex(state.entries.length, state.startIndex);
@@ -166,6 +226,7 @@ const dispatchRequest = (store, dispatch, maybeDispatchSchema, request) => Match
             reason: `Invalid Message: ${error instanceof Error ? error.message : String(error)}\n\nReceived (typeof ${typeof message}): ${JSON.stringify(message)}`,
         })))),
     }),
+    RequestGetMessageSchema: ({ maybeVariantTag }) => Effect.succeed(buildMessageSchemaResponse(maybeJsonSchemaDocument, maybeVariantTag)),
     RequestListRuntimes: () => Effect.succeed(ResponseError({
         reason: 'RequestListRuntimes is plugin-handled and should not reach the runtime bridge',
     })),

package/dist/runtime/browserListeners.d.ts

@@ -1,4 +1,5 @@
 import { RoutingConfig } from './runtime.js';
 export declare const addNavigationEventListeners: <Message>(dispatch: (message: Message) => void, routingConfig: RoutingConfig<Message>) => void;
+export declare const addLinkClickListener: <Message>(dispatch: (message: Message) => void, routingConfig: RoutingConfig<Message>) => void;
 export declare const addBfcacheRestoreListener: () => void;
 //# sourceMappingURL=browserListeners.d.ts.map

package/dist/runtime/browserListeners.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"browserListeners.d.ts","sourceRoot":"","sources":["../../src/runtime/browserListeners.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAE5C,eAAO,MAAM,2BAA2B,GAAI,OAAO,EACjD,UAAU,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,EACpC,eAAe,aAAa,CAAC,OAAO,CAAC,SAKtC,CAAA;AA6ED,eAAO,MAAM,yBAAyB,YASrC,CAAA"}
+{"version":3,"file":"browserListeners.d.ts","sourceRoot":"","sources":["../../src/runtime/browserListeners.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAE5C,eAAO,MAAM,2BAA2B,GAAI,OAAO,EACjD,UAAU,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,EACpC,eAAe,aAAa,CAAC,OAAO,CAAC,SAKtC,CAAA;AAaD,eAAO,MAAM,oBAAoB,GAAI,OAAO,EAC1C,UAAU,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,EACpC,eAAe,aAAa,CAAC,OAAO,CAAC,SAoDtC,CAAA;AA4BD,eAAO,MAAM,yBAAyB,YASrC,CAAA"}

package/dist/runtime/browserListeners.js

@@ -12,20 +12,32 @@ const addPopStateListener = (dispatch, routingConfig) => {
     };
     window.addEventListener('popstate', onPopState);
 };
-const addLinkClickListener = (dispatch, routingConfig) => {
+export const addLinkClickListener = (dispatch, routingConfig) => {
     const onLinkClick = (event) => {
-        const target = event.target;
-        if (!(target instanceof Element)) {
+        const isNonPrimaryButton = event.button !== 0;
+        const isModifierKeyPressed = event.metaKey || event.ctrlKey || event.shiftKey || event.altKey;
+        const isDefaultPrevented = event.defaultPrevented;
+        if (isNonPrimaryButton || isModifierKeyPressed || isDefaultPrevented) {
             return;
         }
-        const maybeLink = Option.fromNullishOr(target.closest('a'));
+        const eventTarget = event.target;
+        if (!(eventTarget instanceof Element)) {
+            return;
+        }
+        const maybeLink = Option.fromNullishOr(eventTarget.closest('a'));
         if (Option.isNone(maybeLink)) {
             return;
         }
-        const { href } = maybeLink.value;
+        const link = maybeLink.value;
+        const { href } = link;
         if (String.isEmpty(href)) {
             return;
         }
+        const isNonSelfTarget = !String.isEmpty(link.target) && link.target !== '_self';
+        const isDownloadLink = link.hasAttribute('download');
+        if (isNonSelfTarget || isDownloadLink) {
+            return;
+        }
         event.preventDefault();
         const linkUrl = new URL(href);
         const currentUrl = new URL(window.location.href);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "foldkit",
-  "version": "0.99.0",
+  "version": "0.100.0",
   "description": "A TypeScript frontend framework, built on Effect and architected like Elm",
   "type": "module",
   "main": "./dist/index.js",