@typeonce/effect-machine 0.15.0 → 0.17.0

package/src/internal/machine/activities.ts

@@ -22,6 +22,9 @@ export type StaticActivityMetadata =
     readonly type: "timer"
     readonly duration: string | "dynamic"
   }
+  | {
+    readonly type: "stream"
+  }
   | {
     readonly type: "machine"
     readonly child: {
@@ -94,6 +97,10 @@ const appendStaticDefinition = (
     })
     return
   }
+  if (Reflect.has(descriptor, "stream")) {
+    definitions.push({ source, id, type: "stream" })
+    return
+  }
   if (Reflect.has(descriptor, "logic")) {
     definitions.push({ source, id, type: "process" })
   }

package/src/internal/machine/atom.ts

@@ -106,9 +106,9 @@ const resumeMachineAtomEffect = (
   snapshot: Machine.Machine.Snapshot<any>
 ) => runMachineAtomEffect(get, internalMachine.resume(machine as any, snapshot as any))
 
-type RefState<Ref> = Ref extends Machine.MachineRef<infer State, any, any, any> ? State : never
-type RefError<Ref> = Ref extends Machine.MachineRef<any, any, infer Error, any> ? Error : never
-type RefOutput<Ref> = Ref extends Machine.MachineRef<any, any, any, infer Output> ? Output : never
+type RefState<Ref> = Ref extends Machine.MachineRef<infer State, any, any, any, any> ? State : never
+type RefError<Ref> = Ref extends Machine.MachineRef<any, any, infer Error, any, any> ? Error : never
+type RefOutput<Ref> = Ref extends Machine.MachineRef<any, any, any, infer Output, any> ? Output : never
 type RefEmitted<Ref> = Ref extends Machine.MachineRef<any, any, any, any, infer Emitted> ? Emitted : never
 
 export const emissions = <State, Event, Error, Output, StartError, Emitted>(
@@ -235,7 +235,7 @@ const makeChildRuntimeResultAtom = <State, Error, Output, StartError>(
 
 const makeChildRefAtom = <Child extends Machine.ChildMachine.Any, StartError>(
   parentRef: Atom.Atom<
-    AsyncResult.AsyncResult<Option.Option<Machine.MachineRef<any, any, any, any>>, StartError>
+    AsyncResult.AsyncResult<Option.Option<Machine.MachineRef<any, any, any, any, any>>, StartError>
   >,
   child: Child
 ): Atom.Atom<AsyncResult.AsyncResult<Option.Option<Machine.ChildMachine.Ref<Child>>, StartError>> =>
@@ -292,7 +292,7 @@ const makeChildFromRefAtom = <Child extends Machine.ChildMachine.Any, StartError
       return AsyncResult.success(Option.none())
     }
 
-    const handle = result.value.value as unknown as Machine.MachineRef<State, any, Error, Output>
+    const handle = result.value.value as unknown as Machine.MachineRef<State, any, Error, Output, any>
     const cancel = Effect.runCallback(
       handle.changes.pipe(
         Stream.runForEach((snapshot) => Effect.sync(() => get.setSelf(AsyncResult.success(Option.some(snapshot)))))
@@ -363,9 +363,9 @@ const makeChildFromRefAtom = <Child extends Machine.ChildMachine.Any, StartError
   }
 }
 
-const makeFromRefAtom = <State, Event, Error, Output, StartError>(
-  ref: Atom.Atom<AsyncResult.AsyncResult<Machine.MachineRef<State, Event, Error, Output>, StartError>>
-): MachineAtom<State, Event, Error, Output, StartError> => {
+const makeFromRefAtom = <State, Event, Error, Output, StartError, Emitted>(
+  ref: Atom.Atom<AsyncResult.AsyncResult<Machine.MachineRef<State, Event, Error, Output, Emitted>, StartError>>
+): MachineAtom<State, Event, Error, Output, StartError, Emitted> => {
   const snapshot = Atom.readable((
     get
   ): AsyncResult.AsyncResult<Machine.RuntimeSnapshot<State, Error, Output>, StartError> => {
@@ -513,9 +513,10 @@ export const select = <
   Error,
   Output,
   StartError,
+  Emitted,
   const Path extends ValuedSnapshotIdentifier<State>
 >(
-  self: MachineAtom<State, Event, Error, Output, StartError>,
+  self: MachineAtom<State, Event, Error, Output, StartError, Emitted>,
   path: Path
 ): Atom.Atom<
   AsyncResult.AsyncResult<Option.Option<SnapshotValueByIdentifier<State, Path>>, StartError | Error>
@@ -530,9 +531,10 @@ export const selectSnapshot = <
   Error,
   Output,
   StartError,
+  Emitted,
   const Path extends SnapshotIdentifier<State>
 >(
-  self: MachineAtom<State, Event, Error, Output, StartError>,
+  self: MachineAtom<State, Event, Error, Output, StartError, Emitted>,
   path: Path
 ): Atom.Atom<
   AsyncResult.AsyncResult<Option.Option<SnapshotByIdentifier<State, Path>>, StartError | Error>
@@ -583,9 +585,10 @@ export const matches = <
   Error,
   Output,
   StartError,
+  Emitted,
   const Path extends SnapshotIdentifier<State>
 >(
-  self: MachineAtom<State, Event, Error, Output, StartError>,
+  self: MachineAtom<State, Event, Error, Output, StartError, Emitted>,
   path: Path
 ): Atom.Atom<AsyncResult.AsyncResult<boolean, StartError | Error>> =>
   Atom.mapResult(self.result, (snapshot) => Option.isSome(Topology.getSnapshotByPath(snapshot, path))).pipe(
@@ -673,7 +676,8 @@ export const make: {
           Machine.Machine.EmitOf<Emits>
         >
       >
-      & EnsureExecutable<States, UnhandledStates, OutputStates>,
+      & EnsureExecutable<States, UnhandledStates, OutputStates>
+      & Machine.Machine.RootCompatible<ParentEvents>,
     ...args: [...Machine.Machine.InputArgs<Input>]
   ): MachineAtom<
     Machine.Machine.Snapshot<States>,
@@ -696,7 +700,8 @@ export const resume: {
     machine:
       & M
       & EnsureNoExternalRequirements<MachineResumeRequirementsOf<NoInfer<M>>>
-      & EnsureMachineExecutable<NoInfer<M>>,
+      & EnsureMachineExecutable<NoInfer<M>>
+      & Machine.Machine.RootCompatible<Machine.Machine.ParentEvents<NoInfer<M>>>,
     snapshot: Machine.Machine.Snapshot<Machine.Machine.States<M>>
   ): ResumedMachineAtomOf<M, never>
 } = ((machine: Machine.Machine.Any, snapshot: Machine.Machine.Snapshot<any>) => {
@@ -708,7 +713,7 @@ const makeWithRuntime = (
   runtime: Atom.AtomRuntime<any, any>,
   machine: Machine.Machine.Any,
   args: ReadonlyArray<unknown>
-): MachineAtom<any, any, any, any, any> => {
+): MachineAtom<any, any, any, any, any, any> => {
   const prepared = runtime.atom(() => internalMachine.prepare(machine as any, ...(args as [])))
   const ref = runtime.atom((get) => startPreparedMachineAtomEffect(get, prepared as any))
   const result = makeFromRefAtom(ref as any)
@@ -720,7 +725,7 @@ const resumeWithRuntime = (
   runtime: Atom.AtomRuntime<any, any>,
   machine: Machine.Machine.Any,
   snapshot: Machine.Machine.Snapshot<any>
-): MachineAtom<any, any, any, any, any> => {
+): MachineAtom<any, any, any, any, any, any> => {
   const ref = runtime.atom((get) => resumeMachineAtomEffect(get, machine, snapshot))
   return makeFromRefAtom(ref as any)
 }

package/src/internal/machine/cluster.ts

@@ -185,7 +185,8 @@ export const make = <
   Output,
   Emits extends ReadonlyArray<Machine.Machine.TaggedSchema>,
   OutputStates extends Machine.Machine.StateIdentifier<States>,
-  InputEvents extends ReadonlyArray<Machine.Machine.TaggedSchema> = Events
+  InputEvents extends ReadonlyArray<Machine.Machine.TaggedSchema> = Events,
+  ParentEvents extends ReadonlyArray<Machine.Machine.TaggedSchema> = readonly []
 >(
   type: Type,
   machine:
@@ -202,9 +203,11 @@ export const make = <
       Output,
       Emits,
       OutputStates,
-      InputEvents
+      InputEvents,
+      ParentEvents
     >
-    & EnsureExecutable<States, UnhandledStates, OutputStates>,
+    & EnsureExecutable<States, UnhandledStates, OutputStates>
+    & Machine.Machine.RootCompatible<ParentEvents>,
   options: {
     readonly version: string
   },
@@ -224,7 +227,8 @@ export const make = <
     Output,
     Emits,
     OutputStates,
-    InputEvents
+    InputEvents,
+    ParentEvents
   >,
   | ExcludeCompatibleRuntime<
     Machine.ExecutionServices<R | InitialR>,
@@ -249,6 +253,7 @@ export const make = <
     OutputStates,
     InputEvents
   >
+  const rootMachine = machine as M & EnsureExecutable<States, UnhandledStates, OutputStates>
   const eventSchema = Schema.Union(Protocol.inputEventSchemas(machine) as MachineEvents<M>)
   const rpc = Rpc.make("send", {
     payload: eventSchema,
@@ -305,7 +310,7 @@ export const make = <
                 `Expected version ${options.version}, received ${checkpoint.version}`
               )
             }
-            current = yield* internalMachine.decodeSnapshot(machine, checkpoint.snapshot).pipe(
+            current = yield* internalMachine.decodeSnapshot(rootMachine, checkpoint.snapshot).pipe(
               Effect.mapError((error) => reject("InvalidCheckpoint", String(error.cause)))
             )
           } else if (loaded.processed) {
@@ -313,7 +318,7 @@ export const make = <
           }
 
           if (current === undefined) {
-            const initial = yield* internalMachine.planInitial(machine, ...input as any)
+            const initial = yield* internalMachine.planInitial(rootMachine, ...input)
             if (initial.commands.length > 0) {
               return yield* fail(
                 "UnsupportedProcessLocal",
@@ -324,8 +329,8 @@ export const make = <
             emitted.push(...initial.emittedEvents as any)
           }
 
-          if (!internalMachine.isFinal(machine, current)) {
-            const planned = yield* internalMachine.plan(machine, current, request.payload)
+          if (!internalMachine.isFinal(rootMachine, current)) {
+            const planned = yield* internalMachine.plan(rootMachine, current, request.payload)
             if (planned.commands.length > 0) {
               return yield* fail(
                 "UnsupportedProcessLocal",
@@ -336,7 +341,7 @@ export const make = <
             emitted.push(...planned.emittedEvents as any)
           }
 
-          const encoded = yield* internalMachine.encodeSnapshot(machine, current)
+          const encoded = yield* internalMachine.encodeSnapshot(rootMachine, current)
           if (emitted.length > 0 && layerOptions?.enqueue === undefined) {
             return yield* fail("EmissionFailure", "No durable enqueue handler was configured")
           }

package/src/internal/machine/executionPlan.ts

@@ -86,10 +86,14 @@ const getPlanningMachineReferences = (machine: Machine.Any): PlanningMachineRefe
 const resolveMachineReferences = (
   machine: Machine.Any,
   machineReferences: PlanningMachineReferences | undefined
-): PlanningMachineReferences =>
-  machineReferences === undefined
+): { readonly self: MachineTarget<any>; readonly parent?: MachineTarget<any> | undefined } => {
+  const resolved = machineReferences === undefined
     ? getPlanningMachineReferences(machine)
-    : { self: machineReferences.self, parent: machineReferences.parent }
+    : machineReferences
+  return machine.parent === undefined
+    ? { self: resolved.self }
+    : { self: resolved.self, parent: resolved.parent }
+}
 
 const indexedStateConfigKeys: ReadonlySet<PropertyKey> = new Set([
   "initialize",
@@ -152,6 +156,7 @@ const compileIndexedExecutionDescriptor = (
     for (const tag of Reflect.ownKeys(config.on)) {
       const transition = normalizeTransition(config.on[tag] as Parameters<typeof normalizeTransition>[0])
       if (transition !== undefined) {
+        if (transition.declinable) return undefined
         byEvent.set(tag, transition)
       }
     }
@@ -445,11 +450,12 @@ const collectIndexedTransition = (
     }
   }
   const evaluated = evaluate === undefined
-    ? { result: transition(context, enqueue), branchIndex: 0 }
+    ? { result: transition(context, enqueue), branchIndex: 0, branchKey: undefined }
     : evaluate(context, enqueue)
   return {
     state: isNoTarget(evaluated.result) ? undefined : evaluated.result,
     branchIndex: evaluated.branchIndex,
+    branchKey: evaluated.branchKey,
     commands: commands ?? emptyExecutionValues,
     raisedEvents: raisedEvents ?? emptyExecutionValues,
     emittedEvents: emittedEvents ?? emptyExecutionValues
@@ -569,6 +575,7 @@ const collectIndexedEvaluatedTransition = (
     return {
       selection,
       branchIndex: transitionResult.branchIndex,
+      branchKey: transitionResult.branchKey,
       unresolvedTarget: unresolvedTarget as any,
       target: target as any,
       next,
@@ -593,6 +600,7 @@ const collectIndexedEvaluatedTransition = (
   return {
     selection,
     branchIndex: transitionResult.branchIndex,
+    branchKey: transitionResult.branchKey,
     unresolvedTarget: unresolvedTarget as any,
     target: target as any,
     next,
@@ -619,6 +627,7 @@ const indexedMicrostep = (
     trigger: transition.selection.trigger,
     reenter: transition.selection.transition.reenter,
     branchIndex: transition.branchIndex,
+    branchKey: transition.branchKey,
     target: transition.unresolvedTarget === undefined ? undefined : getTargetNodePath(transition.unresolvedTarget),
     resolvedTarget: transition.target === undefined ? undefined : getTargetNodePath(transition.target)
   })
@@ -804,6 +813,7 @@ const planIndexedFlatState = (
               trigger: { type: "event", event: event._tag },
               reenter: transition.reenter,
               branchIndex: transitionResult.branchIndex,
+              branchKey: transitionResult.branchKey,
               target: target === undefined ? undefined : getTargetNodePath(target as any),
               resolvedTarget: target === undefined ? undefined : getTargetNodePath(target as any)
             }]

package/src/internal/machine/invocation.ts

@@ -6,12 +6,13 @@
 
 import * as Cause from "effect/Cause"
 import * as Effect from "effect/Effect"
+import * as Stream from "effect/Stream"
 import type { ChildMachine, Inspection, Logic, Machine } from "../../Machine.js"
 import * as Configuration from "./configuration.js"
 import { InfiniteTransitionError, MachineSchemaDecodeError, StoppedError } from "./errors.js"
 import * as InvocationEvent from "./invocationEvent.js"
 import * as Planner from "./planner.js"
-import type * as Runtime from "./runtime.js"
+import * as Runtime from "./runtime.js"
 import { ChildMachineLogicTypeId } from "./symbols.js"
 
 /** @internal */
@@ -37,12 +38,35 @@ const oneShot = (effect: Effect.Effect<any, any, any>): Logic<void, never, any,
   run: () => effect
 })
 
+const streamLogic = (
+  stream: Stream.Stream<any, any, any>,
+  path: string,
+  id: string
+): Runtime.ProcessLogic<void, never, any, any, void> => ({
+  initial: () => Effect.void,
+  run: ({ parent }) => {
+    const send = parent?.[Runtime.acknowledgedSend]
+    if (send === undefined) {
+      return Effect.die(new Error("Stream invocation requires an acknowledged parent machine"))
+    }
+    return Stream.runForEach(
+      stream,
+      (element) =>
+        send(InvocationEvent.element(path, id, element)).pipe(
+          Effect.asVoid,
+          Effect.catchCause(() => Effect.interrupt)
+        )
+    )
+  }
+})
+
 const resolveValue = (value: unknown, context: Machine.InvokeContext<any, any, any, any>): unknown =>
   typeof value === "function" ? value(context) : value
 
 const resolveOne = (
   raw: Record<PropertyKey, any>,
-  context: Machine.InvokeContext<any, any, any, any>
+  context: Machine.InvokeContext<any, any, any, any>,
+  path: string
 ): AnyConfig => {
   if ("effect" in raw) {
     return {
@@ -78,6 +102,17 @@ const resolveOne = (
       activityKind: "Timer"
     }
   }
+  if ("stream" in raw) {
+    const id = String(raw.id)
+    return {
+      id,
+      src: () =>
+        streamLogic(raw.stream(context), path, id) as unknown as Runtime.ProcessLogic<any, any, any, any, any, any>,
+      onDone: raw.onDone,
+      onFailure: raw.onFailure,
+      activityKind: "Stream"
+    }
+  }
   if ("logic" in raw) {
     return {
       id: String(raw.id),
@@ -103,7 +138,7 @@ const resolveOne = (
       onSnapshot: raw.onSnapshot
     }
   }
-  throw new Error("Machine invoke must define exactly one of effect, after, logic, or child")
+  throw new Error("Machine invoke must define exactly one of effect, stream, after, logic, or child")
 }
 
 /** @internal */
@@ -269,7 +304,7 @@ export const startAll = (
       return InvocationEvent.definitions(Configuration.getStateConfigByPath(machine, path)?.invoke).map((definition) =>
         "child" in definition && !("input" in definition)
           ? startStaticChild(scope, ownedChildren, path, definition)
-          : start(scope, ownedChildren, path, resolveOne(definition, context))
+          : start(scope, ownedChildren, path, resolveOne(definition, context, path))
       )
     })
   return effects.length === 0 ? undefined : runSequentialDiscard(effects)

package/src/internal/machine/invocationEvent.ts

@@ -10,6 +10,13 @@ export const InvocationEventTypeId: unique symbol = Symbol("effect/Machine/Invoc
 
 /** @internal */
 export type InvocationEvent =
+  | {
+    readonly [InvocationEventTypeId]: true
+    readonly path: string
+    readonly id: string
+    readonly type: "element"
+    readonly element: unknown
+  }
   | {
     readonly [InvocationEventTypeId]: true
     readonly path: string
@@ -41,6 +48,15 @@ export const done = (path: string, id: string, output: unknown): InvocationEvent
   output
 })
 
+/** @internal */
+export const element = (path: string, id: string, value: unknown): InvocationEvent => ({
+  [InvocationEventTypeId]: true,
+  path,
+  id,
+  type: "element",
+  element: value
+})
+
 /** @internal */
 export const failure = (path: string, id: string, error: unknown): InvocationEvent => ({
   [InvocationEventTypeId]: true,