@typeonce/effect-machine 0.7.0 → 0.9.0

package/src/internal/machine/machine.ts

@@ -1,4 +1,3 @@
-import * as Duration from "effect/Duration"
 import * as Effect from "effect/Effect"
 import * as Inspectable from "effect/Inspectable"
 import * as Option from "effect/Option"
@@ -34,6 +33,7 @@ import type { EnsureExecutable } from "./readiness.js"
 import * as internalRuntime from "./runtime.js"
 import * as Serialization from "./serialization.js"
 import * as StateDefinition from "./stateDefinition.js"
+import { ChildMachineLogicTypeId } from "./symbols.js"
 import * as Topology from "./topology.js"
 
 export {
@@ -45,13 +45,12 @@ export {
   StartupError,
   StoppedError
 } from "./errors.js"
-export { InitialEventTypeId } from "./symbols.js"
+export { ChildMachineLogicTypeId, InitialEventTypeId } from "./symbols.js"
 
 const TypeId = "~effect/Machine"
 export const SnapshotBuilderStateTypeId: unique symbol = Symbol("effect/Machine/SnapshotBuilderState")
 export const InvokeTypeId: unique symbol = Symbol.for("effect/Machine/Invoke")
 const ChildMachineTypeId = "~effect/Machine/ChildMachine"
-type InvokeLifecycleId = string
 type IsAny<A> = 0 extends 1 & A ? true : false
 type MachineRuntimeRequirement = internalRuntime.MachineRuntime
 type ExcludeCompatibleRuntime<Requirements, Events, Emits> = Requirements extends Runtime.Requirement<
@@ -278,10 +277,14 @@ type FromMethodKind = "leaf" | "nested"
 
 const withFrom = <Method extends (value: unknown, ...args: ReadonlyArray<any>) => unknown>(
   method: Method,
-  kind: FromMethodKind
+  kind: FromMethodKind,
+  valued: boolean
 ): Method & { readonly from: (...args: ReadonlyArray<any>) => unknown } => {
   Object.defineProperty(method, "from", {
     value: (...args: ReadonlyArray<any>) => {
+      if (!valued) {
+        return method(undefined, ...args)
+      }
       const omitted = args.length === 0 || (kind === "nested" && args.length === 1 && typeof args[0] === "function")
       const input = omitted ? {} : args[0]
       const rest = omitted ? args : args.slice(1)
@@ -312,7 +315,8 @@ const makeSnapshotBuilder = (
     builder[key] = withFrom(
       (value: unknown, selector?: (builder: unknown) => unknown) =>
         makeSnapshotForNode(definition, key, value, selector, options),
-      node.states === undefined ? "leaf" : "nested"
+      node.states === undefined ? "leaf" : "nested",
+      node.schema !== undefined
     )
   }
   return builder
@@ -339,14 +343,18 @@ const makeParallelSnapshotBuilder = (
     }
     const path = options.prefix === "" ? key : `${options.prefix}.${key}`
     const node = Topology.getStateNodeDefinition(path, definition)
-    builder[key] = withFrom((value: unknown, selector?: (builder: unknown) => unknown) => {
-      const nextRegions: Record<string, unknown> = {}
-      for (const regionKey of Object.keys(regions)) {
-        nextRegions[regionKey] = regions[regionKey]
-      }
-      nextRegions[key] = makeSnapshotForNode(definition, key, value, selector, options)
-      return makeParallelSnapshotBuilder(states, options, nextRegions)
-    }, node.states === undefined ? "leaf" : "nested")
+    builder[key] = withFrom(
+      (value: unknown, selector?: (builder: unknown) => unknown) => {
+        const nextRegions: Record<string, unknown> = {}
+        for (const regionKey of Object.keys(regions)) {
+          nextRegions[regionKey] = regions[regionKey]
+        }
+        nextRegions[key] = makeSnapshotForNode(definition, key, value, selector, options)
+        return makeParallelSnapshotBuilder(states, options, nextRegions)
+      },
+      node.states === undefined ? "leaf" : "nested",
+      node.schema !== undefined
+    )
   }
   return builder
 }
@@ -525,13 +533,25 @@ const makeLocalTargetChildBuilder = (
       builder[child.key] = () => Topology.makeChoiceTarget(child.path, parent.path, values)
       continue
     }
-    builder[child.key] = withFrom((value: unknown, selector?: (builder: unknown) => unknown) => {
-      if (child.type === "atomic" || child.type === "final") {
-        return makeTargetWithValues(child.path, value, values)
-      }
-      if (child.type === "parallel") {
-        if (source !== child.path && !source.startsWith(`${child.path}.`)) {
-          return makeParallelTarget(states, child, value, selector, values)
+    builder[child.key] = withFrom(
+      (value: unknown, selector?: (builder: unknown) => unknown) => {
+        if (child.type === "atomic" || child.type === "final") {
+          return makeTargetWithValues(child.path, value, values)
+        }
+        if (child.type === "parallel") {
+          if (source !== child.path && !source.startsWith(`${child.path}.`)) {
+            return makeParallelTarget(states, child, value, selector, values)
+          }
+          if (selector === undefined) {
+            throw new Error(`Machine expected target "${child.path}" builder to provide an active child state`)
+          }
+          return selector(makeLocalTargetChildBuilder(
+            states,
+            stateNodes,
+            child.path,
+            child.schema === undefined ? values : extendTargetValues(values, child.path, value),
+            source
+          ))
         }
         if (selector === undefined) {
           throw new Error(`Machine expected target "${child.path}" builder to provide an active child state`)
@@ -540,21 +560,13 @@ const makeLocalTargetChildBuilder = (
           states,
           stateNodes,
           child.path,
-          extendTargetValues(values, child.path, value),
+          child.schema === undefined ? values : extendTargetValues(values, child.path, value),
           source
         ))
-      }
-      if (selector === undefined) {
-        throw new Error(`Machine expected target "${child.path}" builder to provide an active child state`)
-      }
-      return selector(makeLocalTargetChildBuilder(
-        states,
-        stateNodes,
-        child.path,
-        extendTargetValues(values, child.path, value),
-        source
-      ))
-    }, child.type === "atomic" || child.type === "final" ? "leaf" : "nested")
+      },
+      child.type === "atomic" || child.type === "final" ? "leaf" : "nested",
+      child.schema !== undefined
+    )
   }
   return builder
 }
@@ -569,12 +581,19 @@ const makeLocalTargetBuilder = (
     return {}
   }
   const builder = makeLocalTargetChildBuilder(states, stateNodes, scope, undefined, source) as Record<string, unknown>
-  builder.with = withFrom((value: unknown, selector?: (builder: unknown) => unknown) => {
-    if (selector === undefined) {
-      throw new Error(`Machine expected target "${scope}" builder to provide an active child state`)
-    }
-    return selector(makeLocalTargetChildBuilder(states, stateNodes, scope, { [scope]: value }, source))
-  }, "nested")
+  const scopeNode = getTargetBuilderNode(stateNodes, scope)
+  if (scopeNode.schema !== undefined) {
+    builder.with = withFrom(
+      (value: unknown, selector?: (builder: unknown) => unknown) => {
+        if (selector === undefined) {
+          throw new Error(`Machine expected target "${scope}" builder to provide an active child state`)
+        }
+        return selector(makeLocalTargetChildBuilder(states, stateNodes, scope, { [scope]: value }, source))
+      },
+      "nested",
+      true
+    )
+  }
   return builder
 }
 
@@ -610,12 +629,31 @@ const makeBranchTargetNodeBuilder = (
 ): unknown => {
   const node = getTargetBuilderNode(stateNodes, path)
   if (node.type === "atomic" || node.type === "final") {
-    return withFrom((value: unknown) => makeTargetWithValues(node.path, value, values), "leaf")
+    return withFrom(
+      (value: unknown) => makeTargetWithValues(node.path, value, values),
+      "leaf",
+      node.schema !== undefined
+    )
   }
-  const builder = withFrom((value: unknown, selector?: (builder: unknown) => unknown) => {
-    if (node.type === "parallel") {
-      if (source !== node.path && !source.startsWith(`${node.path}.`)) {
-        return makeParallelTarget(states, node, value, selector, values)
+  const builder = withFrom(
+    (value: unknown, selector?: (builder: unknown) => unknown) => {
+      if (node.type === "parallel") {
+        if (source !== node.path && !source.startsWith(`${node.path}.`)) {
+          return makeParallelTarget(states, node, value, selector, values)
+        }
+        if (selector === undefined) {
+          throw new Error(`Machine expected target "${node.path}" builder to provide an active child state`)
+        }
+        const nextBuilder: Record<string, unknown> = {}
+        addBranchTargetChildren(
+          nextBuilder,
+          states,
+          stateNodes,
+          node.path,
+          node.schema === undefined ? values : extendTargetValues(values, node.path, value),
+          source
+        )
+        return selector(nextBuilder)
       }
       if (selector === undefined) {
         throw new Error(`Machine expected target "${node.path}" builder to provide an active child state`)
@@ -626,25 +664,14 @@ const makeBranchTargetNodeBuilder = (
         states,
         stateNodes,
         node.path,
-        extendTargetValues(values, node.path, value),
+        node.schema === undefined ? values : extendTargetValues(values, node.path, value),
         source
       )
       return selector(nextBuilder)
-    }
-    if (selector === undefined) {
-      throw new Error(`Machine expected target "${node.path}" builder to provide an active child state`)
-    }
-    const nextBuilder: Record<string, unknown> = {}
-    addBranchTargetChildren(
-      nextBuilder,
-      states,
-      stateNodes,
-      node.path,
-      extendTargetValues(values, node.path, value),
-      source
-    )
-    return selector(nextBuilder)
-  }, "nested") as unknown as Record<string, unknown>
+    },
+    "nested",
+    node.schema !== undefined
+  ) as unknown as Record<string, unknown>
   if (node.type !== "parallel" || source === node.path || source.startsWith(`${node.path}.`)) {
     addBranchTargetChildren(builder, states, stateNodes, node.path, values, source)
   }
@@ -855,6 +882,16 @@ export const event = <
   ...args: EventConstructorArgs<EventSchema>
 ): EventSchema["Type"] => Protocol.makeEvent(machine, schema, args.length === 0 ? {} : args[0])
 
+export const events = <M extends Machine.Any>(
+  machine: M
+): Machine.EventConstructors<Machine.InputEvents<M>> =>
+  Protocol.eventConstructors(machine.events) as Machine.EventConstructors<Machine.InputEvents<M>>
+
+export const internalEvents = <M extends Machine.Any>(
+  machine: M
+): Machine.EventConstructors<Machine.InternalEvents<M>> =>
+  Protocol.eventConstructors(machine.internalEvents) as Machine.EventConstructors<Machine.InternalEvents<M>>
+
 export const encodeSnapshot: <
   const States extends Machine.StateSchemas,
   const Events extends ReadonlyArray<Machine.TaggedSchema>,
@@ -929,145 +966,6 @@ export const decodeSnapshot: <
   Machine.SnapshotDecodingServices<States>
 > = Serialization.decodeSnapshot as any
 
-export const invoke = <
-  ChildState,
-  ChildEvent,
-  ChildError = never,
-  ChildRequirements = never,
-  ChildOutput = never,
-  ChildInitialError = never,
-  Event = never,
-  Address extends ChildAddress<never> | undefined = undefined
->(
-  config:
-    & {
-      readonly id: InvokeLifecycleId
-      readonly src: () => Logic<
-        ChildState,
-        ChildEvent,
-        ChildError,
-        ChildRequirements,
-        ChildOutput,
-        ChildInitialError
-      >
-      readonly snapshot?: (
-        context: Machine.InvokeSnapshotContext<ChildState, ChildError, ChildOutput>
-      ) => Event | undefined
-    }
-    & ([Address] extends [undefined] ? {
-        readonly address?: never
-      }
-      : {
-        readonly address: Exclude<Address, undefined>
-      } & ChildAddress.Compatibility<Exclude<Address, undefined>, NoInfer<ChildEvent>>)
-): Machine.InvokeConfig<
-  any,
-  any,
-  any,
-  any,
-  Event,
-  ChildState,
-  ChildEvent,
-  ChildError,
-  ChildRequirements,
-  ChildOutput,
-  ChildInitialError
-> => ({
-  ...config,
-  [InvokeTypeId]: undefined as any,
-  [Activities.ActivityMetadataTypeId]: { type: "process" }
-})
-
-type InvokeEffectResult<Requirements, Event> = Machine.InvokeConfig<
-  any,
-  any,
-  any,
-  any,
-  never,
-  void,
-  never,
-  never,
-  Requirements,
-  Event | void,
-  never
->
-
-type InvokeEffectIsInfallible<Fx extends Effect.Effect<any, any, any>> = IsAny<Effect.Error<Fx>> extends true ? false
-  : [Effect.Error<Fx>] extends [never] ? true
-  : false
-
-type InvokeEffectConfig<
-  Fx extends Effect.Effect<any, any, any>,
-  SuccessEvent,
-  FailureEvent
-> =
-  & {
-    readonly id: InvokeLifecycleId
-    readonly effect: Fx
-    readonly onSuccess: (value: NoInfer<Effect.Success<Fx>>) => SuccessEvent | void
-  }
-  & (
-    InvokeEffectIsInfallible<Fx> extends true ? {
-        readonly onFailure?: never
-      }
-      : {
-        readonly onFailure: (error: NoInfer<Effect.Error<Fx>>) => FailureEvent | void
-      }
-  )
-
-export const invokeEffect = <
-  const Fx extends Effect.Effect<any, any, any>,
-  SuccessEvent,
-  FailureEvent = never
->(
-  config: InvokeEffectConfig<Fx, SuccessEvent, FailureEvent>
-): InvokeEffectResult<
-  Effect.Services<Fx>,
-  SuccessEvent | (InvokeEffectIsInfallible<Fx> extends true ? never : FailureEvent)
-> =>
-  ((config: {
-    readonly id: string
-    readonly effect: Effect.Effect<unknown, unknown, unknown>
-    readonly onSuccess: (value: unknown) => unknown
-    readonly onFailure?: (error: unknown) => unknown
-  }) => ({
-    ...invoke({
-      id: config.id,
-      src: () =>
-        effect(
-          config.onFailure === undefined
-            ? Effect.map(config.effect, config.onSuccess)
-            : Effect.matchEffect(config.effect, {
-              onFailure: (error) => Effect.succeed(config.onFailure!(error)),
-              onSuccess: (value) => Effect.succeed(config.onSuccess(value))
-            })
-        )
-    }),
-    [Activities.ActivityMetadataTypeId]: {
-      type: "effect",
-      outcomes: {
-        success: "dynamic",
-        failure: config.onFailure === undefined ? "none" : "dynamic"
-      }
-    }
-  }))(config as any) as any
-
-export const after = <Event extends { readonly _tag: PropertyKey }>(
-  duration: Duration.Input,
-  event: Event,
-  options?: { readonly id?: InvokeLifecycleId }
-): InvokeEffectResult<never, Event> => ({
-  ...invoke({
-    id: options?.id ?? `Machine.after:${String(event._tag)}`,
-    src: () => effect(Effect.as(Effect.sleep(duration), event))
-  }),
-  [Activities.ActivityMetadataTypeId]: {
-    type: "timer",
-    duration: Duration.format(Duration.fromInputUnsafe(duration)),
-    event: String(event._tag)
-  }
-})
-
 export const retag = (
   target: Machine.TaggedSchema,
   source: { readonly _tag: PropertyKey },
@@ -1076,199 +974,6 @@ export const retag = (
   const { _tag: _, ...fields } = source
   return target.make({ ...fields, ...((patch ?? {}) as object) } as never)
 }
-
-type InvokeMachineInput<Input extends Schema.Top> = Input extends typeof Schema.Void ? {
-    readonly input?: never
-  }
-  : {
-    readonly input: Input["Type"]
-  }
-
-export const invokeMachine: {
-  <
-    const States extends Machine.StateSchemas,
-    const Events extends ReadonlyArray<Machine.TaggedSchema>,
-    const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
-    const Input extends Schema.Top = typeof Schema.Void,
-    UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>,
-    E = never,
-    R = never,
-    InitialE = never,
-    InitialR = never,
-    FinalStates extends Machine.StateIdentifier<States> = never,
-    Output = never,
-    SnapshotEvent = never,
-    DoneEvent = never,
-    Id extends string = string,
-    OutputStates extends Machine.StateIdentifier<States> = never,
-    InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events
-  >(
-    config:
-      & {
-        readonly child: ChildMachine<
-          Id,
-          & Machine<
-            States,
-            Events,
-            Input,
-            UnhandledStates,
-            E,
-            R,
-            InitialE,
-            InitialR,
-            FinalStates,
-            Output,
-            Emits,
-            OutputStates,
-            InputEvents
-          >
-          & EnsureExecutable<States, UnhandledStates, OutputStates>
-        >
-        readonly snapshot?: (
-          context: Machine.InvokeSnapshotContext<
-            Machine.Snapshot<States>,
-            | E
-            | ActionError<R>
-            | InfiniteTransitionError
-            | MachineSchemaDecodeError
-            | StoppedError,
-            Output
-          >
-        ) => SnapshotEvent | undefined
-        readonly onDone: (context: Machine.InvokeDoneContext<Output>) => DoneEvent | undefined
-      }
-      & InvokeMachineInput<Input>
-  ): Machine.InvokeConfig<
-    any,
-    any,
-    any,
-    any,
-    SnapshotEvent,
-    Machine.Snapshot<States>,
-    Machine.EventOf<InputEvents>,
-    E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError,
-    ExcludeCompatibleRuntime<
-      Exclude<ExecutionServices<InitialR | R>, internalRuntime.MachineRuntime>,
-      Machine.EventOf<Events>,
-      Machine.EmitOf<Emits>
-    >,
-    Output,
-    | InitialE
-    | E
-    | ActionError<InitialR | R>
-    | InfiniteTransitionError
-    | MachineSchemaDecodeError
-    | StartupError
-    | StoppedError,
-    Machine.EmitOf<Emits>,
-    DoneEvent
-  >
-  <
-    const States extends Machine.StateSchemas,
-    const Events extends ReadonlyArray<Machine.TaggedSchema>,
-    const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
-    const Input extends Schema.Top = typeof Schema.Void,
-    UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>,
-    E = never,
-    R = never,
-    InitialE = never,
-    InitialR = never,
-    FinalStates extends Machine.StateIdentifier<States> = never,
-    Output = never,
-    SnapshotEvent = never,
-    Id extends string = string,
-    OutputStates extends Machine.StateIdentifier<States> = never,
-    InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events
-  >(
-    config:
-      & {
-        readonly child: ChildMachine<
-          Id,
-          & Machine<
-            States,
-            Events,
-            Input,
-            UnhandledStates,
-            E,
-            R,
-            InitialE,
-            InitialR,
-            FinalStates,
-            Output,
-            Emits,
-            OutputStates,
-            InputEvents
-          >
-          & EnsureExecutable<States, UnhandledStates, OutputStates>
-        >
-        readonly snapshot?: (
-          context: Machine.InvokeSnapshotContext<
-            Machine.Snapshot<States>,
-            | E
-            | ActionError<R>
-            | InfiniteTransitionError
-            | MachineSchemaDecodeError
-            | StoppedError,
-            Output
-          >
-        ) => SnapshotEvent | undefined
-        readonly onDone?: never
-      }
-      & InvokeMachineInput<Input>
-  ): Machine.InvokeConfig<
-    any,
-    any,
-    any,
-    any,
-    SnapshotEvent,
-    Machine.Snapshot<States>,
-    Machine.EventOf<InputEvents>,
-    E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError,
-    ExcludeCompatibleRuntime<
-      Exclude<ExecutionServices<InitialR | R>, internalRuntime.MachineRuntime>,
-      Machine.EventOf<Events>,
-      Machine.EmitOf<Emits>
-    >,
-    Output,
-    | InitialE
-    | E
-    | ActionError<InitialR | R>
-    | InfiniteTransitionError
-    | MachineSchemaDecodeError
-    | StartupError
-    | StoppedError,
-    Machine.EmitOf<Emits>
-  >
-} = ((config: {
-  readonly child: ChildMachine.Any
-  readonly input?: unknown
-  readonly snapshot?: (context: Machine.InvokeSnapshotContext<any, any, any>) => unknown
-  readonly onDone?: (context: Machine.InvokeDoneContext<any>) => unknown
-}) => {
-  const machine = config.child.machine
-  // An invoke descriptor fixes both its machine and input. Compile its process
-  // logic once; all mutable execution state belongs to the process instance.
-  const logic = machine.input === undefined
-    ? (internalProcess.toProcessLogic as any)(machine)
-    : (internalProcess.toProcessLogic as any)(machine, config.input)
-  return {
-    id: config.child.id,
-    address: config.child.id,
-    descriptor: config.child,
-    src: () => logic,
-    snapshot: config.snapshot,
-    onDone: config.onDone,
-    [Activities.ActivityMetadataTypeId]: {
-      type: "machine",
-      child: {
-        id: config.child.id,
-        machineId: machine.id ?? null
-      }
-    },
-    [InvokeTypeId]: undefined as any
-  }
-}) as any
-
 export const planInitial: <
   const States extends Machine.StateSchemas,
   const Events extends ReadonlyArray<Machine.TaggedSchema>,
@@ -1466,7 +1171,7 @@ export const plan: <
     >
     & EnsureExecutable<States, UnhandledStates, OutputStates>,
   state: Machine.Snapshot<States>,
-  event: Machine.EventOf<InputEvents>
+  event: Machine.EventInputOf<InputEvents>
 ) => Effect.Effect<
   & {
     readonly next: Machine.Snapshot<States>
@@ -1504,13 +1209,6 @@ export const plan: <
   never
 > = internalPlanner.plan as any
 
-export const effect = <Output, Error = never, Requirements = never>(
-  effect: Effect.Effect<Output, Error, Requirements>
-): Logic<void, never, Error, Requirements, Output> => ({
-  initial: () => Effect.void,
-  run: () => effect
-})
-
 export const logic = <
   State,
   Event = never,
@@ -1559,7 +1257,11 @@ export const child = <const Id extends string, M extends Machine.Any>(
 ): ChildMachine<Id, M> => ({
   [ChildMachineTypeId]: ChildMachineTypeId,
   id,
-  machine
+  machine,
+  [ChildMachineLogicTypeId]: (input) =>
+    machine.input === undefined
+      ? (internalProcess.toProcessLogic as any)(machine)
+      : (internalProcess.toProcessLogic as any)(machine, input)
 })
 
 export const childAddress = <Event = never>(id: string): ChildAddress<Event> => id as ChildAddress<Event>
@@ -1675,7 +1377,7 @@ export const start: <
 ) => Effect.Effect<
   MachineRef<
     Machine.Snapshot<States>,
-    Machine.EventOf<InputEvents>,
+    Machine.EventInputOf<InputEvents>,
     | E
     | ActionError<R>
     | InfiniteTransitionError
@@ -1733,7 +1435,7 @@ export const resume: <
 ) => Effect.Effect<
   MachineRef<
     Machine.Snapshot<States>,
-    Machine.EventOf<InputEvents>,
+    Machine.EventInputOf<InputEvents>,
     | E
     | ActionError<R>
     | InfiniteTransitionError