@typeonce/effect-machine 0.8.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<
@@ -883,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>,
@@ -957,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 },
@@ -1104,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>,
@@ -1494,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>
@@ -1532,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,
@@ -1587,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>
@@ -1703,7 +1377,7 @@ export const start: <
 ) => Effect.Effect<
   MachineRef<
     Machine.Snapshot<States>,
-    Machine.EventOf<InputEvents>,
+    Machine.EventInputOf<InputEvents>,
     | E
     | ActionError<R>
     | InfiniteTransitionError
@@ -1761,7 +1435,7 @@ export const resume: <
 ) => Effect.Effect<
   MachineRef<
     Machine.Snapshot<States>,
-    Machine.EventOf<InputEvents>,
+    Machine.EventInputOf<InputEvents>,
     | E
     | ActionError<R>
     | InfiniteTransitionError

package/src/internal/machine/planner.ts

@@ -38,6 +38,7 @@ import {
   validateInitialConfiguration
 } from "./configuration.js"
 import { InfiniteTransitionError, MachineSchemaDecodeError, StartupError } from "./errors.js"
+import * as InvocationEvent from "./invocationEvent.js"
 import { decodeEventSync, decodeInputSync, decodeStateValueSync } from "./protocol.js"
 import { InitialEventTypeId } from "./symbols.js"
 import {
@@ -798,6 +799,54 @@ const selectEventTransitions = <
   return selected
 }
 
+const selectInvocationTransition = <
+  const States extends Machine.StateSchemas,
+  const Events extends ReadonlyArray<Machine.TaggedSchema>,
+  const Emits extends ReadonlyArray<Machine.TaggedSchema>,
+  E,
+  R
+>(
+  machine: Machine.Any,
+  configuration: ActiveConfiguration,
+  event: InvocationEvent.InvocationEvent
+): ReadonlyArray<SelectedTransition<States, E, R, any>> => {
+  if (!configuration.active.has(event.path)) return []
+  const config = machine.handlers[event.path] as Machine.AnyStateConfig | undefined
+  const invoke = InvocationEvent.definitions(config?.invoke).find((definition) => {
+    const id = "child" in definition ? definition.child?.id : definition.id
+    return String(id) === event.id
+  })
+  if (invoke === undefined) return []
+  const handler = event.type === "done"
+    ? invoke.onDone
+    : event.type === "failure"
+    ? invoke.onFailure
+    : invoke.onSnapshot
+  const transition = normalizeTransition(handler)
+  if (transition === undefined) return []
+  const snapshot = snapshotFromConfiguration<States>(machine, configuration)
+  const context = {
+    state: configuration.values.get(event.path),
+    parent: getParentValue(machine, configuration, event.path),
+    parents: getParentValues(machine, configuration, event.path),
+    snapshot,
+    target: getTargetBuilder(machine, event.path),
+    id: event.id,
+    ...(event.type === "done"
+      ? { output: event.output }
+      : event.type === "failure"
+      ? { error: event.error }
+      : { snapshot: event.snapshot })
+  }
+  return [{
+    sourcePath: event.path,
+    leafPath: getActiveLeafPathFrom(machine, configuration, event.path),
+    trigger: { type: "invoke", id: event.id, outcome: event.type },
+    transition: transition as unknown as MicrostepTransition<States, E, R, any>,
+    context
+  }]
+}
+
 export const getTargetNodePath = <const States extends Machine.StateSchemas>(
   target:
     | Machine.Snapshot<States>
@@ -1812,11 +1861,11 @@ const macrostepConfiguration = <
 >(
   machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits>,
   configuration: ActiveConfiguration,
-  event: Machine.EventOf<Events>
+  event: Machine.EventOf<Events> | InvocationEvent.InvocationEvent
 ) => {
-  const decodedEvent = decodeEventSync<Events>(machine, event)
+  const decodedEvent = InvocationEvent.isInvocationEvent(event) ? event : decodeEventSync<Events>(machine, event)
   if (isActiveFinalConfiguration(machine, configuration)) {
-    const completed = completeConfigurationSync(machine, configuration, decodedEvent)
+    const completed = completeConfigurationSync(machine, configuration, decodedEvent as any)
     const root = getRootPath(machine, completed.configuration)
     if (!completed.configuration.outputs.has(root)) {
       throw new Error("Machine reached a terminal configuration without a completed root output")
@@ -1831,11 +1880,13 @@ const macrostepConfiguration = <
     }
   }
 
-  const selections = selectEventTransitions<States, Events, Emits, E, R>(
-    machine,
-    configuration,
-    decodedEvent as Machine.EventByTag<Events, Machine.TagOf<Events[number]>>
-  )
+  const selections = InvocationEvent.isInvocationEvent(decodedEvent)
+    ? selectInvocationTransition<States, Events, Emits, E, R>(machine, configuration, decodedEvent)
+    : selectEventTransitions<States, Events, Emits, E, R>(
+      machine,
+      configuration,
+      decodedEvent as Machine.EventByTag<Events, Machine.TagOf<Events[number]>>
+    )
   if (selections.length === 0) {
     return {
       next: configuration,
@@ -1849,14 +1900,14 @@ const macrostepConfiguration = <
   const step = microstep(
     machine,
     configuration,
-    decodedEvent,
+    decodedEvent as any,
     selections
   )
   const commands = [...step.commands]
   const raisedEvents = [...step.raisedEvents]
   const emittedEvents = [...step.emittedEvents]
   const microsteps = [step]
-  return settle(machine, step.next, decodedEvent, commands, raisedEvents, emittedEvents, microsteps)
+  return settle(machine, step.next, decodedEvent as any, commands, raisedEvents, emittedEvents, microsteps)
 }
 
 const snapshotMacrostep = <