@typeonce/effect-machine 0.16.0 → 0.18.0

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)
       }
     }

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,