@typeonce/effect-machine-devtools 0.23.0 → 0.24.0

package/dist/DevToolsProtocol.d.ts

@@ -10,7 +10,7 @@ import * as Schema from "effect/Schema";
  * @category models
  * @since 0.23.0
  */
-export declare const protocolVersion: 1;
+export declare const protocolVersion: 2;
 /**
  * @category schemas
  * @since 0.23.0
@@ -56,7 +56,7 @@ export type Diagnostic = Schema.Schema.Type<typeof Diagnostic>;
 export declare const Ready: Schema.Struct<{
     readonly _tag: Schema.tag<"Ready">;
     readonly document: Schema.Struct<{
-        readonly schemaVersion: Schema.Literal<1>;
+        readonly schemaVersion: Schema.Literal<2>;
         readonly revision: Schema.Natural;
         readonly source: Schema.NullOr<Schema.Struct<{
             readonly file: Schema.String;
@@ -165,6 +165,21 @@ export declare const Ready: Schema.Struct<{
             readonly source: Schema.String;
             readonly lifecycleId: Schema.String;
         }>]>>;
+        readonly inputs: Schema.Struct<{
+            readonly machine: Schema.NullOr<Schema.Struct<{
+                readonly dialect: Schema.Literal<"draft-2020-12">;
+                readonly schema: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly definitions: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            }>>;
+            readonly events: Schema.$Array<Schema.Struct<{
+                readonly event: Schema.String;
+                readonly schema: Schema.Struct<{
+                    readonly dialect: Schema.Literal<"draft-2020-12">;
+                    readonly schema: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                    readonly definitions: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                }>;
+            }>>;
+        }>;
         readonly snapshot: Schema.NullOr<Schema.Struct<{
             readonly activePaths: Schema.$Array<Schema.String>;
             readonly candidateEvents: Schema.$Array<Schema.String>;
@@ -181,7 +196,7 @@ export declare const Ready: Schema.Struct<{
         }>>;
         readonly statePath: Schema.NullOr<Schema.String>;
     }>>;
-    readonly protocolVersion: Schema.Literal<1>;
+    readonly protocolVersion: Schema.Literal<2>;
     readonly key: Schema.String;
 }>;
 /**
@@ -198,7 +213,7 @@ export type Ready = Schema.Schema.Type<typeof Ready>;
 export declare const Partial: Schema.Struct<{
     readonly _tag: Schema.tag<"Partial">;
     readonly document: Schema.Struct<{
-        readonly schemaVersion: Schema.Literal<1>;
+        readonly schemaVersion: Schema.Literal<2>;
         readonly revision: Schema.Natural;
         readonly source: Schema.NullOr<Schema.Struct<{
             readonly file: Schema.String;
@@ -307,6 +322,21 @@ export declare const Partial: Schema.Struct<{
             readonly source: Schema.String;
             readonly lifecycleId: Schema.String;
         }>]>>;
+        readonly inputs: Schema.Struct<{
+            readonly machine: Schema.NullOr<Schema.Struct<{
+                readonly dialect: Schema.Literal<"draft-2020-12">;
+                readonly schema: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly definitions: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            }>>;
+            readonly events: Schema.$Array<Schema.Struct<{
+                readonly event: Schema.String;
+                readonly schema: Schema.Struct<{
+                    readonly dialect: Schema.Literal<"draft-2020-12">;
+                    readonly schema: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                    readonly definitions: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                }>;
+            }>>;
+        }>;
         readonly snapshot: Schema.NullOr<Schema.Struct<{
             readonly activePaths: Schema.$Array<Schema.String>;
             readonly candidateEvents: Schema.$Array<Schema.String>;
@@ -323,7 +353,7 @@ export declare const Partial: Schema.Struct<{
         }>>;
         readonly statePath: Schema.NullOr<Schema.String>;
     }>>;
-    readonly protocolVersion: Schema.Literal<1>;
+    readonly protocolVersion: Schema.Literal<2>;
     readonly key: Schema.String;
 }>;
 /**
@@ -355,7 +385,7 @@ export declare const Failed: Schema.Struct<{
         }>>;
         readonly statePath: Schema.NullOr<Schema.String>;
     }>>;
-    readonly protocolVersion: Schema.Literal<1>;
+    readonly protocolVersion: Schema.Literal<2>;
     readonly key: Schema.String;
 }>;
 /**
@@ -372,7 +402,7 @@ export type Failed = Schema.Schema.Type<typeof Failed>;
 export declare const MachineResult: Schema.Union<readonly [Schema.Struct<{
     readonly _tag: Schema.tag<"Ready">;
     readonly document: Schema.Struct<{
-        readonly schemaVersion: Schema.Literal<1>;
+        readonly schemaVersion: Schema.Literal<2>;
         readonly revision: Schema.Natural;
         readonly source: Schema.NullOr<Schema.Struct<{
             readonly file: Schema.String;
@@ -481,6 +511,21 @@ export declare const MachineResult: Schema.Union<readonly [Schema.Struct<{
             readonly source: Schema.String;
             readonly lifecycleId: Schema.String;
         }>]>>;
+        readonly inputs: Schema.Struct<{
+            readonly machine: Schema.NullOr<Schema.Struct<{
+                readonly dialect: Schema.Literal<"draft-2020-12">;
+                readonly schema: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly definitions: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            }>>;
+            readonly events: Schema.$Array<Schema.Struct<{
+                readonly event: Schema.String;
+                readonly schema: Schema.Struct<{
+                    readonly dialect: Schema.Literal<"draft-2020-12">;
+                    readonly schema: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                    readonly definitions: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                }>;
+            }>>;
+        }>;
         readonly snapshot: Schema.NullOr<Schema.Struct<{
             readonly activePaths: Schema.$Array<Schema.String>;
             readonly candidateEvents: Schema.$Array<Schema.String>;
@@ -497,12 +542,12 @@ export declare const MachineResult: Schema.Union<readonly [Schema.Struct<{
         }>>;
         readonly statePath: Schema.NullOr<Schema.String>;
     }>>;
-    readonly protocolVersion: Schema.Literal<1>;
+    readonly protocolVersion: Schema.Literal<2>;
     readonly key: Schema.String;
 }>, Schema.Struct<{
     readonly _tag: Schema.tag<"Partial">;
     readonly document: Schema.Struct<{
-        readonly schemaVersion: Schema.Literal<1>;
+        readonly schemaVersion: Schema.Literal<2>;
         readonly revision: Schema.Natural;
         readonly source: Schema.NullOr<Schema.Struct<{
             readonly file: Schema.String;
@@ -611,6 +656,21 @@ export declare const MachineResult: Schema.Union<readonly [Schema.Struct<{
             readonly source: Schema.String;
             readonly lifecycleId: Schema.String;
         }>]>>;
+        readonly inputs: Schema.Struct<{
+            readonly machine: Schema.NullOr<Schema.Struct<{
+                readonly dialect: Schema.Literal<"draft-2020-12">;
+                readonly schema: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly definitions: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            }>>;
+            readonly events: Schema.$Array<Schema.Struct<{
+                readonly event: Schema.String;
+                readonly schema: Schema.Struct<{
+                    readonly dialect: Schema.Literal<"draft-2020-12">;
+                    readonly schema: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                    readonly definitions: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                }>;
+            }>>;
+        }>;
         readonly snapshot: Schema.NullOr<Schema.Struct<{
             readonly activePaths: Schema.$Array<Schema.String>;
             readonly candidateEvents: Schema.$Array<Schema.String>;
@@ -627,7 +687,7 @@ export declare const MachineResult: Schema.Union<readonly [Schema.Struct<{
         }>>;
         readonly statePath: Schema.NullOr<Schema.String>;
     }>>;
-    readonly protocolVersion: Schema.Literal<1>;
+    readonly protocolVersion: Schema.Literal<2>;
     readonly key: Schema.String;
 }>, Schema.Struct<{
     readonly _tag: Schema.tag<"Failed">;
@@ -647,7 +707,7 @@ export declare const MachineResult: Schema.Union<readonly [Schema.Struct<{
         }>>;
         readonly statePath: Schema.NullOr<Schema.String>;
     }>>;
-    readonly protocolVersion: Schema.Literal<1>;
+    readonly protocolVersion: Schema.Literal<2>;
     readonly key: Schema.String;
 }>]>;
 /**
@@ -662,12 +722,12 @@ export type MachineResult = Schema.Schema.Type<typeof MachineResult>;
  * @since 0.23.0
  */
 export declare const RegistrySnapshot: Schema.Struct<{
-    readonly protocolVersion: Schema.Literal<1>;
+    readonly protocolVersion: Schema.Literal<2>;
     readonly revision: Schema.Natural;
     readonly results: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
         readonly _tag: Schema.tag<"Ready">;
         readonly document: Schema.Struct<{
-            readonly schemaVersion: Schema.Literal<1>;
+            readonly schemaVersion: Schema.Literal<2>;
             readonly revision: Schema.Natural;
             readonly source: Schema.NullOr<Schema.Struct<{
                 readonly file: Schema.String;
@@ -776,6 +836,21 @@ export declare const RegistrySnapshot: Schema.Struct<{
                 readonly source: Schema.String;
                 readonly lifecycleId: Schema.String;
             }>]>>;
+            readonly inputs: Schema.Struct<{
+                readonly machine: Schema.NullOr<Schema.Struct<{
+                    readonly dialect: Schema.Literal<"draft-2020-12">;
+                    readonly schema: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                    readonly definitions: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                }>>;
+                readonly events: Schema.$Array<Schema.Struct<{
+                    readonly event: Schema.String;
+                    readonly schema: Schema.Struct<{
+                        readonly dialect: Schema.Literal<"draft-2020-12">;
+                        readonly schema: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                        readonly definitions: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                    }>;
+                }>>;
+            }>;
             readonly snapshot: Schema.NullOr<Schema.Struct<{
                 readonly activePaths: Schema.$Array<Schema.String>;
                 readonly candidateEvents: Schema.$Array<Schema.String>;
@@ -792,12 +867,12 @@ export declare const RegistrySnapshot: Schema.Struct<{
             }>>;
             readonly statePath: Schema.NullOr<Schema.String>;
         }>>;
-        readonly protocolVersion: Schema.Literal<1>;
+        readonly protocolVersion: Schema.Literal<2>;
         readonly key: Schema.String;
     }>, Schema.Struct<{
         readonly _tag: Schema.tag<"Partial">;
         readonly document: Schema.Struct<{
-            readonly schemaVersion: Schema.Literal<1>;
+            readonly schemaVersion: Schema.Literal<2>;
             readonly revision: Schema.Natural;
             readonly source: Schema.NullOr<Schema.Struct<{
                 readonly file: Schema.String;
@@ -906,6 +981,21 @@ export declare const RegistrySnapshot: Schema.Struct<{
                 readonly source: Schema.String;
                 readonly lifecycleId: Schema.String;
             }>]>>;
+            readonly inputs: Schema.Struct<{
+                readonly machine: Schema.NullOr<Schema.Struct<{
+                    readonly dialect: Schema.Literal<"draft-2020-12">;
+                    readonly schema: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                    readonly definitions: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                }>>;
+                readonly events: Schema.$Array<Schema.Struct<{
+                    readonly event: Schema.String;
+                    readonly schema: Schema.Struct<{
+                        readonly dialect: Schema.Literal<"draft-2020-12">;
+                        readonly schema: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                        readonly definitions: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                    }>;
+                }>>;
+            }>;
             readonly snapshot: Schema.NullOr<Schema.Struct<{
                 readonly activePaths: Schema.$Array<Schema.String>;
                 readonly candidateEvents: Schema.$Array<Schema.String>;
@@ -922,7 +1012,7 @@ export declare const RegistrySnapshot: Schema.Struct<{
             }>>;
             readonly statePath: Schema.NullOr<Schema.String>;
         }>>;
-        readonly protocolVersion: Schema.Literal<1>;
+        readonly protocolVersion: Schema.Literal<2>;
         readonly key: Schema.String;
     }>, Schema.Struct<{
         readonly _tag: Schema.tag<"Failed">;
@@ -942,7 +1032,7 @@ export declare const RegistrySnapshot: Schema.Struct<{
             }>>;
             readonly statePath: Schema.NullOr<Schema.String>;
         }>>;
-        readonly protocolVersion: Schema.Literal<1>;
+        readonly protocolVersion: Schema.Literal<2>;
         readonly key: Schema.String;
     }>]>>;
 }>;
@@ -951,4 +1041,628 @@ export declare const RegistrySnapshot: Schema.Struct<{
  * @since 0.23.0
  */
 export type RegistrySnapshot = Schema.Schema.Type<typeof RegistrySnapshot>;
+/**
+ * JSON-safe representation of a persisted machine snapshot.
+ *
+ * @category schemas
+ * @since 0.24.0
+ */
+export declare const EncodedSnapshot: Schema.Struct<{
+    readonly _tag: Schema.Literal<"MachineSnapshot">;
+    readonly active: Schema.$Array<Schema.Struct<{
+        readonly path: Schema.String;
+        readonly value: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    }>>;
+    readonly completed: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly path: Schema.String;
+        readonly output: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    }>>>;
+    readonly history: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Struct<{
+        readonly mode: Schema.Literals<readonly ["shallow", "deep"]>;
+        readonly active: Schema.$Array<Schema.String>;
+        readonly values: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    }>>>;
+}>;
+/**
+ * @category models
+ * @since 0.24.0
+ */
+export type EncodedSnapshot = Schema.Schema.Type<typeof EncodedSnapshot>;
+/**
+ * Starts an isolated planner session. Omitting `input` calls a machine that
+ * declares no input; otherwise the JSON value is decoded by its input schema.
+ *
+ * @category schemas
+ * @since 0.24.0
+ */
+export declare const StartSimulation: Schema.Struct<{
+    readonly _tag: Schema.tag<"StartSimulation">;
+    readonly input: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly protocolVersion: Schema.Literal<2>;
+    readonly key: Schema.String;
+    readonly revision: Schema.Natural;
+    readonly source: Schema.Struct<{
+        readonly file: Schema.String;
+        readonly exportName: Schema.NullOr<Schema.String>;
+    }>;
+}>;
+/**
+ * @category models
+ * @since 0.24.0
+ */
+export type StartSimulation = Schema.Schema.Type<typeof StartSimulation>;
+/**
+ * Plans one JSON event from an encoded session snapshot.
+ *
+ * @category schemas
+ * @since 0.24.0
+ */
+export declare const SendSimulationEvent: Schema.Struct<{
+    readonly _tag: Schema.tag<"SendSimulationEvent">;
+    readonly step: Schema.Natural;
+    readonly snapshot: Schema.Struct<{
+        readonly _tag: Schema.Literal<"MachineSnapshot">;
+        readonly active: Schema.$Array<Schema.Struct<{
+            readonly path: Schema.String;
+            readonly value: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        }>>;
+        readonly completed: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly path: Schema.String;
+            readonly output: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        }>>>;
+        readonly history: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Struct<{
+            readonly mode: Schema.Literals<readonly ["shallow", "deep"]>;
+            readonly active: Schema.$Array<Schema.String>;
+            readonly values: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        }>>>;
+    }>;
+    readonly event: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly protocolVersion: Schema.Literal<2>;
+    readonly key: Schema.String;
+    readonly revision: Schema.Natural;
+    readonly source: Schema.Struct<{
+        readonly file: Schema.String;
+        readonly exportName: Schema.NullOr<Schema.String>;
+    }>;
+}>;
+/**
+ * @category models
+ * @since 0.24.0
+ */
+export type SendSimulationEvent = Schema.Schema.Type<typeof SendSimulationEvent>;
+/**
+ * Request accepted by the isolated machine planner.
+ *
+ * @category schemas
+ * @since 0.24.0
+ */
+export declare const SimulationRequest: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.tag<"StartSimulation">;
+    readonly input: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly protocolVersion: Schema.Literal<2>;
+    readonly key: Schema.String;
+    readonly revision: Schema.Natural;
+    readonly source: Schema.Struct<{
+        readonly file: Schema.String;
+        readonly exportName: Schema.NullOr<Schema.String>;
+    }>;
+}>, Schema.Struct<{
+    readonly _tag: Schema.tag<"SendSimulationEvent">;
+    readonly step: Schema.Natural;
+    readonly snapshot: Schema.Struct<{
+        readonly _tag: Schema.Literal<"MachineSnapshot">;
+        readonly active: Schema.$Array<Schema.Struct<{
+            readonly path: Schema.String;
+            readonly value: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        }>>;
+        readonly completed: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly path: Schema.String;
+            readonly output: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        }>>>;
+        readonly history: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Struct<{
+            readonly mode: Schema.Literals<readonly ["shallow", "deep"]>;
+            readonly active: Schema.$Array<Schema.String>;
+            readonly values: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        }>>>;
+    }>;
+    readonly event: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly protocolVersion: Schema.Literal<2>;
+    readonly key: Schema.String;
+    readonly revision: Schema.Natural;
+    readonly source: Schema.Struct<{
+        readonly file: Schema.String;
+        readonly exportName: Schema.NullOr<Schema.String>;
+    }>;
+}>]>;
+/**
+ * @category models
+ * @since 0.24.0
+ */
+export type SimulationRequest = Schema.Schema.Type<typeof SimulationRequest>;
+/**
+ * A compact view of one logical machine snapshot.
+ *
+ * @category schemas
+ * @since 0.24.0
+ */
+export declare const SimulationSnapshot: Schema.Struct<{
+    readonly activePaths: Schema.$Array<Schema.String>;
+    readonly candidateEvents: Schema.$Array<Schema.String>;
+}>;
+/**
+ * @category models
+ * @since 0.24.0
+ */
+export type SimulationSnapshot = Schema.Schema.Type<typeof SimulationSnapshot>;
+/**
+ * Transition selected by the planner after hierarchy and conflict resolution.
+ *
+ * @category schemas
+ * @since 0.24.0
+ */
+export declare const PlannedTransition: Schema.Struct<{
+    readonly source: Schema.String;
+    readonly trigger: Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.tag<"event">;
+        readonly event: Schema.String;
+    }>, Schema.Struct<{
+        readonly type: Schema.tag<"always">;
+    }>, Schema.Struct<{
+        readonly type: Schema.tag<"done">;
+    }>, Schema.Struct<{
+        readonly type: Schema.tag<"choice">;
+    }>, Schema.Struct<{
+        readonly type: Schema.tag<"invoke">;
+        readonly id: Schema.String;
+        readonly outcome: Schema.Literals<readonly ["element", "done", "failure", "snapshot"]>;
+    }>]>;
+    readonly reenter: Schema.Boolean;
+    readonly branchIndex: Schema.Natural;
+    readonly branchKey: Schema.NullOr<Schema.String>;
+    readonly target: Schema.NullOr<Schema.String>;
+    readonly resolvedTarget: Schema.NullOr<Schema.String>;
+    readonly updates: Schema.$Array<Schema.String>;
+}>;
+/**
+ * @category models
+ * @since 0.24.0
+ */
+export type PlannedTransition = Schema.Schema.Type<typeof PlannedTransition>;
+/**
+ * Closed command produced by planning. Commands are displayed but never
+ * committed by the visualizer.
+ *
+ * @category schemas
+ * @since 0.24.0
+ */
+export declare const PlannedCommand: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.tag<"SendTo">;
+    readonly target: Schema.String;
+    readonly event: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.Struct<{
+    readonly _tag: Schema.tag<"Stop">;
+    readonly target: Schema.String;
+}>]>;
+/**
+ * @category models
+ * @since 0.24.0
+ */
+export type PlannedCommand = Schema.Schema.Type<typeof PlannedCommand>;
+/**
+ * One statechart microstep retained in a planned macrostep.
+ *
+ * @category schemas
+ * @since 0.24.0
+ */
+export declare const SimulationMicrostep: Schema.Struct<{
+    readonly index: Schema.Natural;
+    readonly event: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly transitions: Schema.$Array<Schema.Struct<{
+        readonly source: Schema.String;
+        readonly trigger: Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.tag<"event">;
+            readonly event: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.tag<"always">;
+        }>, Schema.Struct<{
+            readonly type: Schema.tag<"done">;
+        }>, Schema.Struct<{
+            readonly type: Schema.tag<"choice">;
+        }>, Schema.Struct<{
+            readonly type: Schema.tag<"invoke">;
+            readonly id: Schema.String;
+            readonly outcome: Schema.Literals<readonly ["element", "done", "failure", "snapshot"]>;
+        }>]>;
+        readonly reenter: Schema.Boolean;
+        readonly branchIndex: Schema.Natural;
+        readonly branchKey: Schema.NullOr<Schema.String>;
+        readonly target: Schema.NullOr<Schema.String>;
+        readonly resolvedTarget: Schema.NullOr<Schema.String>;
+        readonly updates: Schema.$Array<Schema.String>;
+    }>>;
+    readonly raisedEvents: Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly emittedEvents: Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly commands: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly _tag: Schema.tag<"SendTo">;
+        readonly target: Schema.String;
+        readonly event: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"Stop">;
+        readonly target: Schema.String;
+    }>]>>;
+    readonly exitPaths: Schema.$Array<Schema.String>;
+    readonly entryPaths: Schema.$Array<Schema.String>;
+    readonly activePaths: Schema.$Array<Schema.String>;
+    readonly changed: Schema.Boolean;
+}>;
+/**
+ * @category models
+ * @since 0.24.0
+ */
+export type SimulationMicrostep = Schema.Schema.Type<typeof SimulationMicrostep>;
+/**
+ * Structured trace for an initial plan or one received event.
+ *
+ * @category schemas
+ * @since 0.24.0
+ */
+export declare const SimulationFrame: Schema.Struct<{
+    readonly step: Schema.Natural;
+    readonly trigger: Schema.Union<readonly [Schema.Struct<{
+        readonly _tag: Schema.tag<"Initial">;
+        readonly input: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"Event">;
+        readonly event: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>]>;
+    readonly before: Schema.Struct<{
+        readonly activePaths: Schema.$Array<Schema.String>;
+        readonly candidateEvents: Schema.$Array<Schema.String>;
+    }>;
+    readonly after: Schema.Struct<{
+        readonly activePaths: Schema.$Array<Schema.String>;
+        readonly candidateEvents: Schema.$Array<Schema.String>;
+    }>;
+    readonly microsteps: Schema.$Array<Schema.Struct<{
+        readonly index: Schema.Natural;
+        readonly event: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly transitions: Schema.$Array<Schema.Struct<{
+            readonly source: Schema.String;
+            readonly trigger: Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.tag<"event">;
+                readonly event: Schema.String;
+            }>, Schema.Struct<{
+                readonly type: Schema.tag<"always">;
+            }>, Schema.Struct<{
+                readonly type: Schema.tag<"done">;
+            }>, Schema.Struct<{
+                readonly type: Schema.tag<"choice">;
+            }>, Schema.Struct<{
+                readonly type: Schema.tag<"invoke">;
+                readonly id: Schema.String;
+                readonly outcome: Schema.Literals<readonly ["element", "done", "failure", "snapshot"]>;
+            }>]>;
+            readonly reenter: Schema.Boolean;
+            readonly branchIndex: Schema.Natural;
+            readonly branchKey: Schema.NullOr<Schema.String>;
+            readonly target: Schema.NullOr<Schema.String>;
+            readonly resolvedTarget: Schema.NullOr<Schema.String>;
+            readonly updates: Schema.$Array<Schema.String>;
+        }>>;
+        readonly raisedEvents: Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        readonly emittedEvents: Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        readonly commands: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly _tag: Schema.tag<"SendTo">;
+            readonly target: Schema.String;
+            readonly event: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.tag<"Stop">;
+            readonly target: Schema.String;
+        }>]>>;
+        readonly exitPaths: Schema.$Array<Schema.String>;
+        readonly entryPaths: Schema.$Array<Schema.String>;
+        readonly activePaths: Schema.$Array<Schema.String>;
+        readonly changed: Schema.Boolean;
+    }>>;
+    readonly commands: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly _tag: Schema.tag<"SendTo">;
+        readonly target: Schema.String;
+        readonly event: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"Stop">;
+        readonly target: Schema.String;
+    }>]>>;
+    readonly emittedEvents: Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly done: Schema.Boolean;
+    readonly output: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+}>;
+/**
+ * @category models
+ * @since 0.24.0
+ */
+export type SimulationFrame = Schema.Schema.Type<typeof SimulationFrame>;
+/**
+ * Successful planner response containing the next portable session state.
+ *
+ * @category schemas
+ * @since 0.24.0
+ */
+export declare const SimulationReady: Schema.Struct<{
+    readonly protocolVersion: Schema.Literal<2>;
+    readonly _tag: Schema.tag<"SimulationReady">;
+    readonly key: Schema.String;
+    readonly revision: Schema.Natural;
+    readonly step: Schema.Natural;
+    readonly snapshot: Schema.Struct<{
+        readonly _tag: Schema.Literal<"MachineSnapshot">;
+        readonly active: Schema.$Array<Schema.Struct<{
+            readonly path: Schema.String;
+            readonly value: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        }>>;
+        readonly completed: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly path: Schema.String;
+            readonly output: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        }>>>;
+        readonly history: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Struct<{
+            readonly mode: Schema.Literals<readonly ["shallow", "deep"]>;
+            readonly active: Schema.$Array<Schema.String>;
+            readonly values: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        }>>>;
+    }>;
+    readonly current: Schema.Struct<{
+        readonly activePaths: Schema.$Array<Schema.String>;
+        readonly candidateEvents: Schema.$Array<Schema.String>;
+    }>;
+    readonly frame: Schema.Struct<{
+        readonly step: Schema.Natural;
+        readonly trigger: Schema.Union<readonly [Schema.Struct<{
+            readonly _tag: Schema.tag<"Initial">;
+            readonly input: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.tag<"Event">;
+            readonly event: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>]>;
+        readonly before: Schema.Struct<{
+            readonly activePaths: Schema.$Array<Schema.String>;
+            readonly candidateEvents: Schema.$Array<Schema.String>;
+        }>;
+        readonly after: Schema.Struct<{
+            readonly activePaths: Schema.$Array<Schema.String>;
+            readonly candidateEvents: Schema.$Array<Schema.String>;
+        }>;
+        readonly microsteps: Schema.$Array<Schema.Struct<{
+            readonly index: Schema.Natural;
+            readonly event: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly transitions: Schema.$Array<Schema.Struct<{
+                readonly source: Schema.String;
+                readonly trigger: Schema.Union<readonly [Schema.Struct<{
+                    readonly type: Schema.tag<"event">;
+                    readonly event: Schema.String;
+                }>, Schema.Struct<{
+                    readonly type: Schema.tag<"always">;
+                }>, Schema.Struct<{
+                    readonly type: Schema.tag<"done">;
+                }>, Schema.Struct<{
+                    readonly type: Schema.tag<"choice">;
+                }>, Schema.Struct<{
+                    readonly type: Schema.tag<"invoke">;
+                    readonly id: Schema.String;
+                    readonly outcome: Schema.Literals<readonly ["element", "done", "failure", "snapshot"]>;
+                }>]>;
+                readonly reenter: Schema.Boolean;
+                readonly branchIndex: Schema.Natural;
+                readonly branchKey: Schema.NullOr<Schema.String>;
+                readonly target: Schema.NullOr<Schema.String>;
+                readonly resolvedTarget: Schema.NullOr<Schema.String>;
+                readonly updates: Schema.$Array<Schema.String>;
+            }>>;
+            readonly raisedEvents: Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly emittedEvents: Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly commands: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly _tag: Schema.tag<"SendTo">;
+                readonly target: Schema.String;
+                readonly event: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            }>, Schema.Struct<{
+                readonly _tag: Schema.tag<"Stop">;
+                readonly target: Schema.String;
+            }>]>>;
+            readonly exitPaths: Schema.$Array<Schema.String>;
+            readonly entryPaths: Schema.$Array<Schema.String>;
+            readonly activePaths: Schema.$Array<Schema.String>;
+            readonly changed: Schema.Boolean;
+        }>>;
+        readonly commands: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly _tag: Schema.tag<"SendTo">;
+            readonly target: Schema.String;
+            readonly event: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.tag<"Stop">;
+            readonly target: Schema.String;
+        }>]>>;
+        readonly emittedEvents: Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        readonly done: Schema.Boolean;
+        readonly output: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    }>;
+}>;
+/**
+ * @category models
+ * @since 0.24.0
+ */
+export type SimulationReady = Schema.Schema.Type<typeof SimulationReady>;
+/**
+ * One authoritative Effect Schema issue associated with a machine or event
+ * input path.
+ *
+ * @category schemas
+ * @since 0.24.0
+ */
+export declare const InputIssue: Schema.Struct<{
+    readonly path: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Number]>>;
+    readonly message: Schema.String;
+}>;
+/**
+ * @category models
+ * @since 0.24.0
+ */
+export type InputIssue = Schema.Schema.Type<typeof InputIssue>;
+/**
+ * Recoverable failure produced while loading, decoding, or planning a session.
+ *
+ * @category schemas
+ * @since 0.24.0
+ */
+export declare const SimulationFailed: Schema.Struct<{
+    readonly protocolVersion: Schema.Literal<2>;
+    readonly _tag: Schema.tag<"SimulationFailed">;
+    readonly key: Schema.String;
+    readonly revision: Schema.Natural;
+    readonly diagnostics: Schema.$Array<Schema.Struct<{
+        readonly severity: Schema.Literals<readonly ["warning", "error"]>;
+        readonly code: Schema.String;
+        readonly message: Schema.String;
+        readonly location: Schema.NullOr<Schema.Struct<{
+            readonly file: Schema.String;
+            readonly line: Schema.NullOr<Schema.Natural>;
+            readonly column: Schema.NullOr<Schema.Natural>;
+        }>>;
+        readonly statePath: Schema.NullOr<Schema.String>;
+    }>>;
+    readonly inputIssues: Schema.$Array<Schema.Struct<{
+        readonly path: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Number]>>;
+        readonly message: Schema.String;
+    }>>;
+}>;
+/**
+ * @category models
+ * @since 0.24.0
+ */
+export type SimulationFailed = Schema.Schema.Type<typeof SimulationFailed>;
+/**
+ * Result returned by the isolated machine planner.
+ *
+ * @category schemas
+ * @since 0.24.0
+ */
+export declare const SimulationResult: Schema.Union<readonly [Schema.Struct<{
+    readonly protocolVersion: Schema.Literal<2>;
+    readonly _tag: Schema.tag<"SimulationReady">;
+    readonly key: Schema.String;
+    readonly revision: Schema.Natural;
+    readonly step: Schema.Natural;
+    readonly snapshot: Schema.Struct<{
+        readonly _tag: Schema.Literal<"MachineSnapshot">;
+        readonly active: Schema.$Array<Schema.Struct<{
+            readonly path: Schema.String;
+            readonly value: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        }>>;
+        readonly completed: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly path: Schema.String;
+            readonly output: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        }>>>;
+        readonly history: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Struct<{
+            readonly mode: Schema.Literals<readonly ["shallow", "deep"]>;
+            readonly active: Schema.$Array<Schema.String>;
+            readonly values: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        }>>>;
+    }>;
+    readonly current: Schema.Struct<{
+        readonly activePaths: Schema.$Array<Schema.String>;
+        readonly candidateEvents: Schema.$Array<Schema.String>;
+    }>;
+    readonly frame: Schema.Struct<{
+        readonly step: Schema.Natural;
+        readonly trigger: Schema.Union<readonly [Schema.Struct<{
+            readonly _tag: Schema.tag<"Initial">;
+            readonly input: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.tag<"Event">;
+            readonly event: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>]>;
+        readonly before: Schema.Struct<{
+            readonly activePaths: Schema.$Array<Schema.String>;
+            readonly candidateEvents: Schema.$Array<Schema.String>;
+        }>;
+        readonly after: Schema.Struct<{
+            readonly activePaths: Schema.$Array<Schema.String>;
+            readonly candidateEvents: Schema.$Array<Schema.String>;
+        }>;
+        readonly microsteps: Schema.$Array<Schema.Struct<{
+            readonly index: Schema.Natural;
+            readonly event: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly transitions: Schema.$Array<Schema.Struct<{
+                readonly source: Schema.String;
+                readonly trigger: Schema.Union<readonly [Schema.Struct<{
+                    readonly type: Schema.tag<"event">;
+                    readonly event: Schema.String;
+                }>, Schema.Struct<{
+                    readonly type: Schema.tag<"always">;
+                }>, Schema.Struct<{
+                    readonly type: Schema.tag<"done">;
+                }>, Schema.Struct<{
+                    readonly type: Schema.tag<"choice">;
+                }>, Schema.Struct<{
+                    readonly type: Schema.tag<"invoke">;
+                    readonly id: Schema.String;
+                    readonly outcome: Schema.Literals<readonly ["element", "done", "failure", "snapshot"]>;
+                }>]>;
+                readonly reenter: Schema.Boolean;
+                readonly branchIndex: Schema.Natural;
+                readonly branchKey: Schema.NullOr<Schema.String>;
+                readonly target: Schema.NullOr<Schema.String>;
+                readonly resolvedTarget: Schema.NullOr<Schema.String>;
+                readonly updates: Schema.$Array<Schema.String>;
+            }>>;
+            readonly raisedEvents: Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly emittedEvents: Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly commands: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly _tag: Schema.tag<"SendTo">;
+                readonly target: Schema.String;
+                readonly event: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            }>, Schema.Struct<{
+                readonly _tag: Schema.tag<"Stop">;
+                readonly target: Schema.String;
+            }>]>>;
+            readonly exitPaths: Schema.$Array<Schema.String>;
+            readonly entryPaths: Schema.$Array<Schema.String>;
+            readonly activePaths: Schema.$Array<Schema.String>;
+            readonly changed: Schema.Boolean;
+        }>>;
+        readonly commands: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly _tag: Schema.tag<"SendTo">;
+            readonly target: Schema.String;
+            readonly event: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.tag<"Stop">;
+            readonly target: Schema.String;
+        }>]>>;
+        readonly emittedEvents: Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        readonly done: Schema.Boolean;
+        readonly output: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    }>;
+}>, Schema.Struct<{
+    readonly protocolVersion: Schema.Literal<2>;
+    readonly _tag: Schema.tag<"SimulationFailed">;
+    readonly key: Schema.String;
+    readonly revision: Schema.Natural;
+    readonly diagnostics: Schema.$Array<Schema.Struct<{
+        readonly severity: Schema.Literals<readonly ["warning", "error"]>;
+        readonly code: Schema.String;
+        readonly message: Schema.String;
+        readonly location: Schema.NullOr<Schema.Struct<{
+            readonly file: Schema.String;
+            readonly line: Schema.NullOr<Schema.Natural>;
+            readonly column: Schema.NullOr<Schema.Natural>;
+        }>>;
+        readonly statePath: Schema.NullOr<Schema.String>;
+    }>>;
+    readonly inputIssues: Schema.$Array<Schema.Struct<{
+        readonly path: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Number]>>;
+        readonly message: Schema.String;
+    }>>;
+}>]>;
+/**
+ * @category models
+ * @since 0.24.0
+ */
+export type SimulationResult = Schema.Schema.Type<typeof SimulationResult>;
 //# sourceMappingURL=DevToolsProtocol.d.ts.map