@typeonce/effect-machine 0.17.0 → 0.19.0

package/src/internal/machine/cluster.ts

@@ -72,6 +72,7 @@ export const RejectionReason = Schema.Literals([
   "InvalidCheckpoint",
   "UnsupportedProcessLocal",
   "TransitionFailure",
+  "SnapshotEncodeFailure",
   "PersistenceFailure",
   "EmissionFailure"
 ])
@@ -341,7 +342,9 @@ export const make = <
             emitted.push(...planned.emittedEvents as any)
           }
 
-          const encoded = yield* internalMachine.encodeSnapshot(rootMachine, current)
+          const encoded = yield* internalMachine.encodeSnapshot(rootMachine, current).pipe(
+            Effect.mapError((error) => reject("SnapshotEncodeFailure", String(error.cause)))
+          )
           if (emitted.length > 0 && layerOptions?.enqueue === undefined) {
             return yield* fail("EmissionFailure", "No durable enqueue handler was configured")
           }

package/src/internal/machine/invocation.ts

@@ -31,7 +31,7 @@ export interface AnyConfig {
 export const makeKey = (path: string, id: string): string => `${path.length}:${path}${id}`
 
 /** @internal */
-export const makeChildId = (path: string, id: string): string => `Machine.invoke:${makeKey(path, id)}`
+export const makeChildId = (path: string, id: string): string => `Machine.invocation:${makeKey(path, id)}`
 
 const oneShot = (effect: Effect.Effect<any, any, any>): Logic<void, never, any, any, any> => ({
   initial: () => Effect.void,

package/src/internal/machine/machine.ts

@@ -54,6 +54,7 @@ const TypeId = "~effect/Machine"
 const ParentTypeId = "~effect/Machine/Parent"
 export const InvokeTypeId: unique symbol = Symbol.for("effect/Machine/Invoke")
 export const TransitionTypeId: unique symbol = Symbol.for("effect/Machine/Transition")
+const InvokeBuilderDescriptorTypeId: unique symbol = Symbol("effect/Machine/InvokeBuilderDescriptor")
 const ChildMachineTypeId = "~effect/Machine/ChildMachine"
 type IsAny<A> = 0 extends 1 & A ? true : false
 type MachineRuntimeRequirement = internalRuntime.MachineRuntime
@@ -788,20 +789,75 @@ const captureEventHandlers = (
   return captured
 }
 
+interface InvokeBuilderDescriptor {
+  readonly [InvokeBuilderDescriptorTypeId]: typeof InvokeBuilderDescriptorTypeId
+  readonly config: Readonly<Record<PropertyKey, unknown>>
+}
+
+type InvokeBuilderChannel = "onDone" | "onFailure" | "onElement" | "onSnapshot"
+
+const makeInvokeBuilder = (
+  config: Readonly<Record<PropertyKey, unknown>>,
+  channels: ReadonlyArray<InvokeBuilderChannel>
+): InvokeBuilderDescriptor => {
+  const builder: Record<PropertyKey, unknown> = {
+    [InvokeBuilderDescriptorTypeId]: InvokeBuilderDescriptorTypeId as typeof InvokeBuilderDescriptorTypeId,
+    config
+  }
+  for (const channel of channels) {
+    if (!hasProperty(config, channel)) {
+      builder[channel] = (handler: unknown) => makeInvokeBuilder({ ...config, [channel]: handler }, channels)
+    }
+  }
+  return Object.freeze(builder) as unknown as InvokeBuilderDescriptor
+}
+
+const invokeSelector = Object.freeze({
+  effect: (id: string, effect: unknown) => makeInvokeBuilder({ id, effect }, ["onDone", "onFailure"]),
+  stream: (id: string, stream: unknown) => makeInvokeBuilder({ id, stream }, ["onElement", "onDone", "onFailure"]),
+  timer: (id: string, after: unknown) => makeInvokeBuilder({ id, after }, ["onDone"]),
+  logic: (id: string, options: Readonly<Record<PropertyKey, unknown>>) =>
+    makeInvokeBuilder({ id, ...options }, ["onSnapshot", "onDone", "onFailure"]),
+  child: (child: unknown, options?: Readonly<Record<PropertyKey, unknown>>) =>
+    makeInvokeBuilder(options === undefined ? { child } : { child, ...options }, [
+      "onSnapshot",
+      "onDone",
+      "onFailure"
+    ])
+})
+
+const invokeBuilderConfig = (value: unknown, path: string): Readonly<Record<PropertyKey, unknown>> => {
+  if (
+    typeof value !== "object" || value === null ||
+    !hasProperty(value, InvokeBuilderDescriptorTypeId) ||
+    value[InvokeBuilderDescriptorTypeId] !== InvokeBuilderDescriptorTypeId
+  ) {
+    throw new Error(`Machine invocation for state "${path}" must be constructed from its source selector`)
+  }
+  return (value as unknown as InvokeBuilderDescriptor).config
+}
+
 const captureInvokeDefinition = (
   invoke: unknown,
   stateNodes: Machine.StateNodes,
   path: string
 ): unknown => {
-  if (Array.isArray(invoke)) return invoke.map((item) => captureInvokeDefinition(item, stateNodes, path))
-  if (typeof invoke !== "object" || invoke === null) return invoke
-  const captured = { ...(invoke as Record<PropertyKey, unknown>) }
-  for (const key of ["onElement", "onDone", "onFailure", "onSnapshot"] as const) {
-    if (captured[key] !== undefined) {
-      captured[key] = captureTransition(captured[key], stateNodes, path, key)
+  if (typeof invoke !== "function") {
+    throw new Error(`Machine invocation for state "${path}" must be a source-first callback`)
+  }
+  const authored = invoke(invokeSelector)
+  const definitions = Array.isArray(authored) ? authored : [authored]
+  const capturedDefinitions = definitions.map((definition) => {
+    const captured = { ...invokeBuilderConfig(definition, path) }
+    for (const key of ["onElement", "onDone", "onFailure", "onSnapshot"] as const) {
+      if (captured[key] !== undefined) {
+        captured[key] = captureTransition(captured[key], stateNodes, path, key)
+      }
     }
-  }
-  return captured
+    return captured
+  })
+  if (Array.isArray(authored)) return capturedDefinitions
+  return capturedDefinitions[0]
 }
 
 const flattenHandlers = (

package/src/internal/machine/serialization.ts

@@ -31,22 +31,48 @@ const EncodedSnapshotSchema = Schema.Struct({
   _tag: Schema.Literal("MachineSnapshot"),
   active: Schema.Array(Schema.Struct({
     path: Schema.String,
-    value: Schema.optional(Schema.Unknown)
+    value: Schema.optionalKey(Schema.Json)
   })),
-  completed: Schema.optional(Schema.Array(Schema.Struct({
+  completed: Schema.optionalKey(Schema.Array(Schema.Struct({
     path: Schema.String,
-    output: Schema.optional(Schema.Unknown)
+    output: Schema.optionalKey(Schema.Json)
   }))),
-  history: Schema.optional(Schema.Record(
+  history: Schema.optionalKey(Schema.Record(
     Schema.String,
     Schema.Struct({
       mode: Schema.Literals(["shallow", "deep"]),
       active: Schema.Array(Schema.String),
-      values: Schema.Record(Schema.String, Schema.Unknown)
+      values: Schema.Record(Schema.String, Schema.Json)
     })
   ))
 })
 
+const jsonCodecCache = new WeakMap<object, Schema.Top>()
+
+const getJsonCodec = (schema: Schema.Top): Schema.Top => {
+  const key = schema as object
+  const cached = jsonCodecCache.get(key)
+  if (cached !== undefined) return cached
+  const codec = Schema.toCodecJson(schema)
+  jsonCodecCache.set(key, codec)
+  return codec
+}
+
+const encodeError = (
+  machine: Machine.Any,
+  options: {
+    readonly boundary: "state" | "output" | "history"
+    readonly state: string
+  },
+  cause: Schema.SchemaError | Cause.Cause<unknown>
+): MachineSchemaEncodeError =>
+  new MachineSchemaEncodeError({
+    machineId: machine.id,
+    boundary: options.boundary,
+    state: options.state,
+    cause
+  })
+
 const encodeBoundary = (
   machine: Machine.Any,
   schema: Schema.Top,
@@ -55,16 +81,14 @@ const encodeBoundary = (
     readonly boundary: "state" | "output" | "history"
     readonly state: string
   }
-): Effect.Effect<unknown, MachineSchemaEncodeError, unknown> =>
-  Schema.encodeUnknownEffect(schema)(value).pipe(
-    Effect.mapError((cause) =>
-      new MachineSchemaEncodeError({
-        machineId: machine.id,
-        boundary: options.boundary,
-        state: options.state,
-        cause
-      })
-    )
+): Effect.Effect<Schema.Json, MachineSchemaEncodeError, unknown> =>
+  Effect.try({
+    try: () => getJsonCodec(schema),
+    catch: (cause) => encodeError(machine, options, Cause.die(cause))
+  }).pipe(
+    Effect.flatMap((codec) => Schema.encodeUnknownEffect(codec)(value)),
+    Effect.flatMap(Schema.decodeUnknownEffect(Schema.Json)),
+    Effect.mapError((cause) => cause instanceof MachineSchemaEncodeError ? cause : encodeError(machine, options, cause))
   )
 
 const decodeEncodedBoundary = (
@@ -76,14 +100,26 @@ const decodeEncodedBoundary = (
     readonly state: string
   }
 ): Effect.Effect<unknown, MachineSchemaDecodeError, unknown> =>
-  Schema.decodeUnknownEffect(schema)(value).pipe(
-    Effect.mapError((cause) =>
+  Effect.try({
+    try: () => getJsonCodec(schema),
+    catch: (cause) =>
       new MachineSchemaDecodeError({
         machineId: machine.id,
         boundary: options.boundary,
         state: options.state,
-        cause
+        cause: Cause.die(cause)
       })
+  }).pipe(
+    Effect.flatMap((codec) => Schema.decodeUnknownEffect(codec)(value)),
+    Effect.mapError((cause) =>
+      cause instanceof MachineSchemaDecodeError ?
+        cause :
+        new MachineSchemaDecodeError({
+          machineId: machine.id,
+          boundary: options.boundary,
+          state: options.state,
+          cause
+        })
     )
   )
 
@@ -91,7 +127,7 @@ const getCompletionSchema = (
   machine: Machine.Any,
   configuration: ActiveConfiguration,
   path: string
-): Schema.Top => {
+): Schema.Top | undefined => {
   const node = getNode(machine, path)
   if (node.type === "compound") {
     const child = getActiveChildPath(machine, configuration, path)
@@ -100,7 +136,7 @@ const getCompletionSchema = (
     }
     return getCompletionSchema(machine, configuration, child)
   }
-  return node.output ?? Schema.Void
+  return node.output
 }
 
 /** Defensively validates and normalizes an in-memory logical snapshot. Unlike
@@ -132,9 +168,17 @@ export const normalizeSnapshotEffect = <const States extends Machine.StateSchema
         throw new Error(`Machine snapshot contains invalid completion "${path}"`)
       }
       completionPaths.add(path)
+      const schema = getCompletionSchema(machine, configuration, path)
+      if (schema === undefined) {
+        if (completion.output !== undefined) {
+          throw new Error(`Machine snapshot contains an output for state "${path}" without an output schema`)
+        }
+        outputs.set(path, undefined)
+        continue
+      }
       outputs.set(
         path,
-        yield* decodeBoundary(machine, getCompletionSchema(machine, configuration, path), completion.output, {
+        yield* decodeBoundary(machine, schema, completion.output, {
           boundary: "output",
           state: path
         })
@@ -242,9 +286,17 @@ export const encodeSnapshot = (
       if (!configuration.active.has(path) || !isActiveFinalNode(machine, configuration, path)) {
         throw new Error(`Machine encoded snapshot contains invalid completion "${path}"`)
       }
+      const schema = getCompletionSchema(machine, configuration, path)
+      if (schema === undefined) {
+        if (output !== undefined) {
+          throw new Error(`Machine snapshot contains an output for state "${path}" without an output schema`)
+        }
+        completed.push({ path })
+        continue
+      }
       const encodedOutput = yield* encodeBoundary(
         machine,
-        getCompletionSchema(machine, configuration, path),
+        schema,
         output,
         {
           boundary: "output",
@@ -289,7 +341,7 @@ export const encodeSnapshot = (
           })
         )
       }
-      const encodedValues: Record<string, unknown> = {}
+      const encodedValues: Record<string, Schema.Json> = {}
       for (const path of record.active) {
         const stateNode = machine.stateNodes.byPath.get(path)
         if (
@@ -338,12 +390,21 @@ export const encodeSnapshot = (
       }
     }
 
-    return {
+    const encoded: Machine.EncodedSnapshot = {
       _tag: "MachineSnapshot" as const,
       active,
       ...(completed.length === 0 ? {} : { completed }),
       ...(Object.keys(history).length === 0 ? {} : { history })
     }
+    return yield* Schema.decodeUnknownEffect(EncodedSnapshotSchema)(encoded).pipe(
+      Effect.mapError((cause) =>
+        new MachineSchemaEncodeError({
+          machineId: machine.id,
+          boundary: "configuration",
+          cause
+        })
+      )
+    )
   }).pipe(Effect.catchCause((cause) => failEncodeCause(machine, cause)))
 
 export const decodeSnapshot = (
@@ -501,11 +562,25 @@ export const decodeSnapshot = (
         throw new Error(`Machine encoded snapshot contains invalid completion "${completion.path}"`)
       }
       completionPaths.add(completion.path)
+      const schema = getCompletionSchema(machine, configuration, completion.path)
+      const hasOutput = Object.prototype.hasOwnProperty.call(completion, "output")
+      if (schema === undefined) {
+        if (hasOutput) {
+          throw new Error(
+            `Machine encoded snapshot contains an output for state "${completion.path}" without an output schema`
+          )
+        }
+        completions.push({ path: completion.path, output: undefined })
+        continue
+      }
+      if (!hasOutput) {
+        throw new Error(`Machine encoded snapshot omits output for state "${completion.path}"`)
+      }
       completions.push({
         path: completion.path,
         output: yield* decodeEncodedBoundary(
           machine,
-          getCompletionSchema(machine, configuration, completion.path),
+          schema,
           completion.output,
           {
             boundary: "output",

package/src/internal/testing/machine/exploration.ts

@@ -34,7 +34,7 @@ import { makeTransitionCoverageCollector } from "./transitionCoverage.js"
 
 type AnyMachine = Machine.Machine.Any
 
-type InputValue<M extends AnyMachine> = Machine.Machine.Input<M>["Type"]
+type InputValue<M extends AnyMachine> = Machine.Machine.Input<M>
 
 type ReadyMachine<M extends AnyMachine> =
   & M

package/src/internal/testing/machine/trace.ts

@@ -22,7 +22,7 @@ import type { EnsureExecutable } from "../../machine/readiness.js"
 
 type AnyMachine = Machine.Machine.Any
 
-type InputValue<M extends AnyMachine> = Machine.Machine.Input<M>["Type"]
+type InputValue<M extends AnyMachine> = Machine.Machine.Input<M>
 
 type StatePath<M extends AnyMachine> = Machine.Machine.StateIdentifier<Machine.Machine.States<M>>
 

package/src/internal/testing/machine/verification.ts

@@ -152,7 +152,7 @@ export const interpretModel = ReferenceModel.interpretModel
 
 type AnyMachine = Machine.Machine.Any
 
-type InputValue<M extends AnyMachine> = Machine.Machine.Input<M>["Type"]
+type InputValue<M extends AnyMachine> = Machine.Machine.Input<M>
 
 type StatePath<M extends AnyMachine> = Machine.Machine.StateIdentifier<Machine.Machine.States<M>>
 
@@ -772,7 +772,7 @@ export const observedGraph: <M extends AnyMachine>(
   traceOrTraces: Trace<M> | ReadonlyArray<Trace<M>>
 ) => Effect.Effect<
   ObservedGraph<M>,
-  Machine.MachineSchemaEncodeError,
+  never,
   Machine.Machine.SnapshotEncodingServices<Machine.Machine.States<M>>
 > = Effect.fnUntraced(function*<M extends AnyMachine>(
   machine: M,
@@ -837,19 +837,24 @@ export const observedGraph: <M extends AnyMachine>(
     }
   })
 
-  const encoded = yield* Effect.forEach(
+  const representations = yield* Effect.forEach(
     occurrences,
     ({ snapshot }) =>
-      (Machine.encodeSnapshot as any)(machine, snapshot) as Effect.Effect<
+      ((Machine.encodeSnapshot as any)(machine, snapshot) as Effect.Effect<
         Machine.Machine.EncodedSnapshot,
         Machine.MachineSchemaEncodeError,
         Machine.Machine.SnapshotEncodingServices<Machine.Machine.States<M>>
-      >
+      >).pipe(
+        Effect.match({
+          onFailure: () => ({ identity: snapshot, encoded: undefined }),
+          onSuccess: (encoded) => ({ identity: encoded, encoded })
+        })
+      )
   )
-  const encodedIdentity = makeStructuralIdentityIndex()
-  const occurrenceIds = encoded.map(encodedIdentity)
+  const representationIdentity = makeStructuralIdentityIndex()
+  const occurrenceIds = representations.map(({ identity }) => representationIdentity(identity))
   const grouped = new Map<string, {
-    readonly encoded: Machine.Machine.EncodedSnapshot
+    readonly encoded: Machine.Machine.EncodedSnapshot | undefined
     readonly snapshot: Machine.Machine.Snapshot<Machine.Machine.States<M>>
     startup: number
     event: number
@@ -862,7 +867,7 @@ export const observedGraph: <M extends AnyMachine>(
       grouped.set(
         id,
         group = {
-          encoded: encoded[index]!,
+          encoded: representations[index]!.encoded,
           snapshot: occurrence.snapshot,
           startup: 0,
           event: 0,
@@ -879,8 +884,8 @@ export const observedGraph: <M extends AnyMachine>(
       const node = Graph.addNode(mutable, {
         id,
         snapshot: group.snapshot,
-        encoded: group.encoded,
-        configuration: group.encoded.active.map(({ path }) => path) as unknown as ReadonlyArray<StatePath<M>>,
+        ...(group.encoded === undefined ? {} : { encoded: group.encoded }),
+        configuration: rawConfigurationPaths(machine, group.snapshot) as ReadonlyArray<StatePath<M>>,
         observations: {
           total: group.startup + group.event + group.microstep,
           startup: group.startup,

package/src/testing/MachineTest.ts

@@ -122,7 +122,7 @@ export const interpretModel: (model: FiniteModel, events: ReadonlyArray<string>)
 
 type AnyMachine = Machine.Machine.Any
 
-type InputValue<M extends AnyMachine> = Machine.Machine.Input<M>["Type"]
+type InputValue<M extends AnyMachine> = Machine.Machine.Input<M>
 
 type StatePath<M extends AnyMachine> = Machine.Machine.StateIdentifier<Machine.Machine.States<M>>
 
@@ -151,7 +151,7 @@ type RootReadyMachine<M extends AnyMachine> =
  * @category models
  * @since 0.4.0
  */
-export type Scenario<M extends AnyMachine> = Machine.Machine.Input<M> extends typeof Schema.Void ? {
+export type Scenario<M extends AnyMachine> = Machine.Machine.InputSchema<M> extends typeof Schema.Void ? {
     readonly events: ReadonlyArray<Machine.Machine.InputEvent<M>>
   }
   : {
@@ -174,7 +174,7 @@ export type ScenarioOptions<M extends AnyMachine> =
     readonly maxEvents?: number
     readonly eventsArbitrary?: FastCheck.Arbitrary<ReadonlyArray<Machine.Machine.InputEvent<M>>>
   }
-  & (Machine.Machine.Input<M> extends typeof Schema.Void ? {
+  & (Machine.Machine.InputSchema<M> extends typeof Schema.Void ? {
       readonly inputArbitrary?: never
     }
     : {
@@ -1410,7 +1410,7 @@ interface ExploreOptionsBase<M extends AnyMachine, Key extends ExplorationKey> {
  */
 export type ExploreOptions<M extends AnyMachine, Key extends ExplorationKey = ExplorationKey> =
   & ExploreOptionsBase<M, Key>
-  & (Machine.Machine.Input<M> extends typeof Schema.Void ? {
+  & (Machine.Machine.InputSchema<M> extends typeof Schema.Void ? {
       readonly input?: never
     }
     : {
@@ -1935,7 +1935,7 @@ export interface ObservedGraphNodeObservations {
 }
 
 /**
- * One full encoded logical snapshot stored in the observed Effect graph.
+ * One decoded logical snapshot stored in the observed Effect graph.
  *
  * @category models
  * @since 0.4.0
@@ -1943,7 +1943,8 @@ export interface ObservedGraphNodeObservations {
 export interface ObservedGraphNode<M extends AnyMachine> {
   readonly id: string
   readonly snapshot: Machine.Machine.Snapshot<Machine.Machine.States<M>>
-  readonly encoded: Machine.Machine.EncodedSnapshot
+  /** Canonical JSON representation when this local snapshot is portable. */
+  readonly encoded?: Machine.Machine.EncodedSnapshot
   readonly configuration: ReadonlyArray<StatePath<M>>
   readonly observations: ObservedGraphNodeObservations
 }
@@ -2004,9 +2005,11 @@ export interface ObservedGraph<M extends AnyMachine> {
 
 /**
  * Converts concrete planner traces into an observed logical-state graph.
- * Nodes are deduplicated by the public snapshot encoding and every edge is a
- * concrete startup or public-event macrostep. This intentionally does not
- * claim to be a static or exhaustive graph of the machine.
+ * Portable nodes are deduplicated by the public snapshot encoding. If encoding
+ * fails, process-local values are instead compared by cycle-safe structural
+ * identity and `ObservedGraphNode.encoded` is omitted. Every edge is a concrete
+ * startup or public-event macrostep. This intentionally does not claim to be a
+ * static or exhaustive graph of the machine.
  *
  * @category verification
  * @since 0.4.0
@@ -2016,7 +2019,7 @@ export const observedGraph: <M extends AnyMachine>(
   traceOrTraces: Trace<M> | ReadonlyArray<Trace<M>>
 ) => Effect.Effect<
   ObservedGraph<M>,
-  Machine.MachineSchemaEncodeError,
+  never,
   Machine.Machine.SnapshotEncodingServices<Machine.Machine.States<M>>
 > = internal.observedGraph
 

package/src/unstable/cluster/ClusterMachine.ts

@@ -153,6 +153,7 @@ export const RejectionReason = Schema.Literals([
   "InvalidCheckpoint",
   "UnsupportedProcessLocal",
   "TransitionFailure",
+  "SnapshotEncodeFailure",
   "PersistenceFailure",
   "EmissionFailure"
 ])
@@ -246,6 +247,51 @@ type MachineServices<M extends Machine.Machine.Any> =
 
 type IsAny<A> = 0 extends (1 & A) ? true : false
 
+type IsNever<A> = [A] extends [never] ? true : false
+
+type IsUnknown<A> = IsAny<A> extends true ? false : unknown extends A ? true : false
+
+type IsJsonEncoded<S extends Schema.Top> = IsAny<S["Encoded"]> extends true ? false
+  : IsNever<S["Encoded"]> extends true ? false
+  : IsUnknown<S["Encoded"]> extends true ? false
+  : [S["Encoded"]] extends [Schema.Json] ? true
+  : false
+
+type NonJsonState<States extends Machine.Machine.StateSchemas> = Machine.Machine.ValuedStateIdentifier<States> extends
+  infer StateId
+  ? StateId extends Machine.Machine.ValuedStateIdentifier<States> ?
+    IsJsonEncoded<Machine.Machine.SchemaByIdentifier<States, StateId>> extends true ? never : StateId
+  : never
+  : never
+
+type NonJsonOutput<States extends Machine.Machine.StateSchemas> = Machine.Machine.DeclaredOutputState<States> extends
+  infer StateId
+  ? StateId extends Machine.Machine.DeclaredOutputState<States> ?
+    Machine.Machine.NodeByIdentifier<States, StateId> extends {
+      readonly output: infer Output extends Schema.Top
+    } ? IsJsonEncoded<Output> extends true ? never : StateId
+    : never
+  : never
+  : never
+
+type NonJsonInputEvent<Events extends ReadonlyArray<Machine.Machine.TaggedSchema>> = {
+  readonly [Index in keyof Events]: Events[Index] extends infer EventSchema extends Machine.Machine.TaggedSchema
+    ? IsJsonEncoded<EventSchema> extends true ? never : Machine.Machine.TagOf<EventSchema>
+    : never
+}[number]
+
+type EnsureJsonEncoded<
+  States extends Machine.Machine.StateSchemas,
+  InputEvents extends ReadonlyArray<Machine.Machine.TaggedSchema>
+> = [NonJsonState<States> | NonJsonOutput<States> | NonJsonInputEvent<InputEvents>] extends [never] ? unknown
+  : {
+    readonly "~effect/ClusterMachine/NonJsonEncoded": {
+      readonly states: NonJsonState<States>
+      readonly outputs: NonJsonOutput<States>
+      readonly inputEvents: NonJsonInputEvent<InputEvents>
+    }
+  }
+
 type ExcludeCompatibleRuntime<Requirements, Events, Emits> = Requirements extends Machine.Runtime.Requirement<
   infer RequiredEvents,
   infer RequiredEmits
@@ -303,6 +349,9 @@ export const layerMemory: Layer.Layer<Storage> = internal.layerMemory
  * rejected. Planning-time raised events remain part of the current macrostep.
  * Arbitrary action effects may run again after a crash before checkpoint
  * commit, so the bridge does not provide exactly-once external effects.
+ * State values, completion outputs, and public input events must declare
+ * JSON-compatible encoded representations. Local and internal event protocols
+ * remain unrestricted because they do not cross the Cluster boundary.
  *
  * **Example**
  *
@@ -364,7 +413,8 @@ export const make: <
       ParentEvents
     >
     & EnsureExecutable<States, UnhandledStates, OutputStates>
-    & Machine.Machine.RootCompatible<ParentEvents>,
+    & Machine.Machine.RootCompatible<ParentEvents>
+    & EnsureJsonEncoded<States, InputEvents>,
   options: {
     readonly version: string
   },

package/src/unstable/reactivity/AtomMachine.ts

@@ -582,7 +582,7 @@ type EnsureMachineExecutable<M extends Machine.Machine.Any> = IsAny<Machine.Mach
   >
 
 type MachineInputArgsOf<M extends Machine.Machine.Any> = [
-  ...Machine.Machine.InputArgs<Machine.Machine.Input<M>>
+  ...Machine.Machine.InputArgs<Machine.Machine.InputSchema<M>>
 ]
 
 type MachineAtomOf<M extends Machine.Machine.Any, RuntimeError> = MachineAtom<