Merge pull request #5 from typeonce-dev/codex/fix-bound-machine-inference

fix: preserve bound machine inference

Author: SandroMaglione

.changeset/steady-machines-bind.md

@@ -0,0 +1,5 @@
+---
+"@typeonce/effect-machine": patch
+---
+
+Preserve every machine protocol channel when creating bound AtomMachine bridges from deeply composed handled machines. Inline invoked children also retain their exact error, service, event, and output types instead of inheriting erased contextual `any` channels.

scripts/fixtures/consumer/deep-bound.ts

@@ -0,0 +1,221 @@
+import { Context, Effect, Layer, Schema } from "effect"
+import { Atom } from "effect/unstable/reactivity"
+import { Machine } from "@typeonce/effect-machine"
+import { AtomMachine } from "@typeonce/effect-machine/reactivity"
+
+type Equal<Left, Right> =
+  (<Type>() => Type extends Left ? 1 : 2) extends <Type>() => Type extends Right ? 1 : 2 ? true : false
+type Expect<Type extends true> = Type
+
+class ExternalService extends Context.Service<ExternalService, string>()("consumer/ExternalService") {}
+class InitialService extends Context.Service<InitialService, string>()("consumer/InitialService") {}
+
+class InitialFailure {
+  readonly _tag = "InitialFailure"
+}
+class TransitionFailure {
+  readonly _tag = "TransitionFailure"
+}
+class ActionFailure {
+  readonly _tag = "ActionFailure"
+}
+class RuntimeFailure {
+  readonly _tag = "RuntimeFailure"
+}
+
+const State = Schema.TaggedUnion({
+  Idle: {},
+  Ready: {},
+  Editor: {},
+  Editing: { value: Schema.String },
+  Saving: { value: Schema.String },
+  Done: { value: Schema.String }
+})
+const Event = Schema.TaggedUnion({
+  Begin: {},
+  Save: { value: Schema.String }
+})
+const Internal = Schema.TaggedUnion({
+  Loaded: { value: Schema.String },
+  ChildCompleted: { value: Schema.String },
+  ChildNotice: { value: Schema.String }
+})
+const Emitted = Schema.TaggedUnion({
+  Notice: { value: Schema.String }
+})
+const ChildState = Schema.TaggedUnion({
+  Done: { value: Schema.String }
+})
+
+const ChildStates = Machine.defineStates({
+  Done: {
+    schema: ChildState.cases.Done,
+    type: "final",
+    output: Schema.String
+  }
+})
+const childMachine = Machine.make({
+  states: ChildStates.states,
+  events: [],
+  emits: [Internal.cases.ChildNotice],
+  input: Schema.Struct({ value: Schema.String }),
+  initial: ({ value }) => ChildStates.initial.Done(ChildState.cases.Done.make({ value }))
+}).handle({
+  Done: {
+    entry: ({ state }) =>
+      Machine.action(
+        Effect.gen(function* () {
+          const runtime = yield* Machine.runtime<{ readonly emits: typeof Internal.cases.ChildNotice.Type }>()
+          yield* runtime.sendParent(Internal.cases.ChildNotice.make({ value: state.value }))
+        })
+      ),
+    output: ({ state }) => state.value
+  }
+})
+const Child = Machine.child("child", childMachine)
+
+const States = Machine.defineStates({
+  Idle: State.cases.Idle,
+  Ready: {
+    schema: State.cases.Ready,
+    initial: "Editor",
+    states: {
+      Editor: {
+        schema: State.cases.Editor,
+        initial: "Editing",
+        states: {
+          Editing: State.cases.Editing,
+          Saving: State.cases.Saving
+        }
+      }
+    }
+  },
+  Done: {
+    schema: State.cases.Done,
+    type: "final",
+    output: Schema.String
+  }
+})
+
+const machine = Machine.make({
+  states: States.states,
+  events: [Event.cases.Begin, Event.cases.Save],
+  internalEvents: [Internal.cases.Loaded, Internal.cases.ChildCompleted, ...childMachine.emits],
+  emits: [Emitted.cases.Notice],
+  input: Schema.Struct({ seed: Schema.String }),
+  initial: ({ seed }) =>
+    Effect.gen(function* () {
+      yield* InitialService
+      if (seed.length < 0) return yield* Effect.fail(new InitialFailure())
+      return States.initial.Idle(State.cases.Idle.make({}))
+    })
+}).handle({
+  Idle: {
+    invoke: Machine.invoke({
+      id: "deep-inline-invoke",
+      src: () => Machine.effect(Effect.as(ExternalService, Internal.cases.Loaded.make({ value: "loaded" })))
+    }),
+    on: {
+      Begin: ({ target }) =>
+        target.full.Ready(State.cases.Ready.make({}), (ready) =>
+          ready.Editor(State.cases.Editor.make({}), (editor) =>
+            editor.Editing(State.cases.Editing.make({ value: "ready" }))
+          )
+        )
+    }
+  },
+  Ready: {
+    states: {
+      Editor: {
+        states: {
+          Editing: {
+            on: {
+              Save: ({ event, target }) =>
+                Machine.action(
+                  Effect.gen(function* () {
+                    yield* ExternalService
+                    return yield* Effect.fail(new ActionFailure())
+                  }),
+                  target.local.Saving(State.cases.Saving.make({ value: event.value }))
+                ),
+              Loaded: () => Effect.fail(new TransitionFailure())
+            }
+          },
+          Saving: {
+            invoke: ({ state }) =>
+              Machine.invokeMachine({
+                child: Child,
+                input: { value: state.value },
+                onDone: ({ output }) => Internal.cases.ChildCompleted.make({ value: output })
+              }),
+            on: {
+              ChildNotice: ({ event, target }) =>
+                Machine.action(
+                  Effect.gen(function* () {
+                    const runtime = yield* Machine.runtime<{ readonly emits: typeof Emitted.cases.Notice.Type }>()
+                    yield* runtime.sendParent(Emitted.cases.Notice.make({ value: event.value }))
+                  }),
+                  target.local.Saving(State.cases.Saving.make({ value: event.value }))
+                ),
+              ChildCompleted: ({ event, target }) => target.full.Done(State.cases.Done.make({ value: event.value }))
+            }
+          }
+        }
+      }
+    }
+  },
+  Done: {
+    output: ({ state }) => state.value
+  }
+})
+
+const runtime = Atom.runtime(
+  Layer.mergeAll(
+    Layer.succeed(ExternalService, "provided"),
+    Layer.succeed(InitialService, "provided"),
+    Layer.effectDiscard(Effect.fail(new RuntimeFailure()))
+  )
+)
+const Bound = AtomMachine.bind(runtime)
+const machineAtom = Bound.make(machine, { seed: "initial" })
+
+type Snapshot = Machine.Machine.Snapshot<typeof States.states>
+type StateSuccess = Atom.Success<typeof machineAtom.state>
+type SendEvent = typeof machineAtom.send extends Atom.Writable<any, infer InputEvent> ? InputEvent : never
+type Output = typeof machineAtom extends AtomMachine.MachineAtom<any, any, any, infer Value, any> ? Value : never
+type Failure = Atom.Failure<typeof machineAtom.result>
+
+type StateIsExact = Expect<Equal<StateSuccess, Snapshot>>
+type EventsArePublicOnly = Expect<Equal<SendEvent, typeof Event.Type>>
+type OutputIsExact = Expect<Equal<Output, string>>
+type InitialErrorIsPreserved = Expect<Equal<Extract<Failure, InitialFailure>, InitialFailure>>
+type TransitionErrorIsPreserved = Expect<Equal<Extract<Failure, TransitionFailure>, TransitionFailure>>
+type ActionErrorIsPreserved = Expect<Equal<Extract<Failure, ActionFailure>, ActionFailure>>
+type RuntimeErrorIsPreserved = Expect<Equal<Extract<Failure, RuntimeFailure>, RuntimeFailure>>
+type FailureIsNotUnknown = Expect<Equal<unknown extends Failure ? true : false, false>>
+type MachineServicesAreNotAny = Expect<
+  Equal<0 extends 1 & Machine.Machine.Services<typeof machine> ? true : false, false>
+>
+
+// @ts-expect-error Input is required.
+Bound.make(machine)
+// @ts-expect-error Input retains its exact decoded type.
+Bound.make(machine, { seed: 1 })
+// @ts-expect-error The bound runtime must provide every external service.
+AtomMachine.bind(Atom.runtime(Layer.empty)).make(machine, { seed: "initial" })
+const erased: Machine.Machine.Any = machine
+// @ts-expect-error Machine.Any erasure cannot manufacture concrete protocol or output proof.
+Bound.make(erased, { seed: "initial" })
+
+void machineAtom
+export type {
+  ActionErrorIsPreserved,
+  EventsArePublicOnly,
+  FailureIsNotUnknown,
+  InitialErrorIsPreserved,
+  MachineServicesAreNotAny,
+  OutputIsExact,
+  RuntimeErrorIsPreserved,
+  StateIsExact,
+  TransitionErrorIsPreserved
+}

scripts/fixtures/consumer/tsconfig.json

@@ -11,5 +11,5 @@
     "exactOptionalPropertyTypes": true,
     "types": ["node"]
   },
-  "include": ["consumer.ts", "effect-beta-compat.d.ts"]
+  "include": ["consumer.ts", "deep-bound.ts", "effect-beta-compat.d.ts"]
 }

scripts/test-consumer.mjs

@@ -46,6 +46,9 @@ try {
     [join(root, "node_modules", "typescript", "bin", "tsc"), "-p", join(consumer, "tsconfig.json")],
     { cwd: consumer }
   )
+  if (process.env.TSGO_BIN !== undefined) {
+    run(process.env.TSGO_BIN, ["-p", join(consumer, "tsconfig.json")], { cwd: consumer })
+  }
   run(process.execPath, [join(consumer, "runtime.mjs")], { cwd: consumer })
 
   console.log("packed root, reactivity, and cluster entrypoints passed strict consumer validation")

src/AtomMachine.ts

@@ -761,27 +761,12 @@ export const matchesChild = <
 
 const BoundRequirementsTypeId = "~effect/reactivity/AtomMachine/BoundRequirements"
 
-type MachineRequirementsOf<M extends Machine.Machine.Any> = M extends Machine.Machine<
-    any,
-    infer Events,
-    any,
-    any,
-    any,
-    infer R,
-    any,
-    infer InitialR,
-    any,
-    any,
-    infer Emits,
-    any,
-    any
-  > ? MachineRequirements<
-      InitialR,
-      R,
-      Machine.Machine.EventOf<Events>,
-      Machine.Machine.EmitOf<Emits>
-    >
-  : never
+type MachineRequirementsOf<M extends Machine.Machine.Any> = MachineRequirements<
+  Machine.Machine.InitialServices<M>,
+  Machine.Machine.Services<M>,
+  Machine.Machine.Event<M>,
+  Machine.Machine.Emit<M>
+>
 
 type MissingBoundRequirements<Services, M extends Machine.Machine.Any> = Exclude<
   ExternalRequirements<MachineRequirementsOf<M>>,
@@ -797,65 +782,29 @@ type EnsureBoundRequirements<Services, M extends Machine.Machine.Any> =
       readonly [BoundRequirementsTypeId]: MissingBoundRequirements<Services, M>
     }
 
-type EnsureMachineOutputImplementations<M extends Machine.Machine.Any> = M extends Machine.Machine<
-  infer States,
-  any,
-  any,
-  any,
-  any,
-  any,
-  any,
-  any,
-  any,
-  any,
-  any,
-  infer OutputStates,
-  any
-> ? IsAny<States> extends true ? {
+type EnsureMachineOutputImplementations<M extends Machine.Machine.Any> =
+  IsAny<Machine.Machine.States<M>> extends true ? {
       readonly "~effect/reactivity/AtomMachine/ConcreteMachineRequired": M
     }
-  : Machine.Machine.EnsureOutputImplementations<States, OutputStates>
-  : never
+  : Machine.Machine.EnsureOutputImplementations<Machine.Machine.States<M>, Machine.Machine.OutputStates<M>>
 
-type MachineInputArgsOf<M extends Machine.Machine.Any> = M extends Machine.Machine<
-  any,
-  any,
-  infer Input,
-  any,
-  any,
-  any,
-  any,
-  any,
-  any,
-  any,
-  any,
-  any,
-  any
-> ? [...Machine.Machine.InputArgs<Input>]
-  : never
+type MachineInputArgsOf<M extends Machine.Machine.Any> = [
+  ...Machine.Machine.InputArgs<Machine.Machine.Input<M>>
+]
 
-type MachineAtomOf<M extends Machine.Machine.Any, RuntimeError> = M extends Machine.Machine<
-  infer States,
-  any,
-  any,
-  any,
-  infer E,
-  infer R,
-  infer InitialE,
-  infer InitialR,
-  any,
-  infer Output,
-  any,
-  any,
-  any
-> ? MachineAtom<
-    Machine.Machine.Snapshot<States>,
+type MachineAtomOf<M extends Machine.Machine.Any, RuntimeError> = MachineAtom<
+    Machine.Machine.Snapshot<Machine.Machine.States<M>>,
     Machine.Machine.InputEvent<M>,
-    MachineRuntimeError<E, R>,
-    Output,
-    MachineStartError<InitialE, E, InitialR, R, RuntimeError>
+    MachineRuntimeError<Machine.Machine.Error<M>, Machine.Machine.Services<M>>,
+    Machine.Machine.Output<M>,
+    MachineStartError<
+      Machine.Machine.InitialError<M>,
+      Machine.Machine.Error<M>,
+      Machine.Machine.InitialServices<M>,
+      Machine.Machine.Services<M>,
+      RuntimeError
+    >
   >
-  : never
 
 /**
  * An `AtomMachine` factory with one owned Effect runtime.
@@ -873,7 +822,10 @@ export interface Bound<Services, RuntimeError = never> {
    * @since 4.0.0
    */
   readonly make: <M extends Machine.Machine.Any>(
-    machine: M & EnsureBoundRequirements<Services, M> & EnsureMachineOutputImplementations<M>,
+    machine:
+      & M
+      & EnsureBoundRequirements<Services, NoInfer<M>>
+      & EnsureMachineOutputImplementations<NoInfer<M>>,
     ...args: MachineInputArgsOf<M>
   ) => MachineAtomOf<M, RuntimeError>
 }