Compile machine startup topology

Author: SandroMaglione

.changeset/compiled-machine-startup.md

@@ -0,0 +1,5 @@
+---
+"@typeonce/effect-machine": patch
+---
+
+Compile eligible machine initial-state normalization and reuse the validated startup configuration when initializing invoked children.

src/internal/machinePlanner.ts

@@ -1991,7 +1991,7 @@ const compileIndexedExecutionDescriptor = (
     const config = machine.handlers[node.path] as Machine.AnyStateConfig | undefined
     if (
       config?.entry !== undefined || config?.exit !== undefined || config?.always !== undefined ||
-      config?.onDone !== undefined || config?.invoke !== undefined || (config as any)?.choice !== undefined ||
+      config?.onDone !== undefined || (config as any)?.choice !== undefined ||
       (config as any)?.history !== undefined
     ) {
       return undefined
@@ -2710,6 +2710,16 @@ export interface CompiledExecutionPlan {
     state: unknown,
     event: unknown
   ) => MacrostepPlan<any, any, any, any, any>
+  readonly initial?: (
+    args: ReadonlyArray<unknown>
+  ) => {
+    readonly state: Machine.Snapshot<any>
+    readonly configuration: unknown
+    readonly activeConfiguration: ActiveConfiguration
+    readonly initialEntryPaths: ReadonlyArray<string>
+    readonly done: boolean
+    readonly output: unknown
+  }
 }
 
 const executionPlanCache = new WeakMap<Machine.Any, CompiledExecutionPlan>()
@@ -2733,7 +2743,43 @@ export const compileExecutionPlan = (machine: Machine.Any): CompiledExecutionPla
       fromConfiguration: (configuration) => indexedConfigurationFromActive(indexed, configuration),
       toConfiguration: (state) => activeConfigurationFromIndexed(indexed, state as IndexedConfiguration),
       snapshot: (state) => snapshotFromIndexed(indexed, state as IndexedConfiguration),
-      plan: (state, event) => planIndexedConfiguration(machine, indexed, state as IndexedConfiguration, event)
+      plan: (state, event) => planIndexedConfiguration(machine, indexed, state as IndexedConfiguration, event),
+      initial: (args) => {
+        const inputArgs = machine.input === undefined
+          ? args
+          : args.length === 0
+          ? (decodeInputSync(machine, machine.input, undefined), args)
+          : [decodeInputSync(machine, machine.input, args[0])]
+        const initial = machine.initial(...inputArgs as any)
+        const active = normalizeConfigurationSync(machine, initial as Machine.Snapshot<any>)
+        validateInitialConfiguration(machine, active)
+        const completed = completeConfigurationSync(machine, active, InitialEvent).configuration
+        const configuration = indexedConfigurationFromActive(indexed, completed)
+        const state = snapshotFromIndexed(indexed, configuration)
+        const done = isActiveFinalConfiguration(machine, completed)
+        if (!done) {
+          return {
+            state,
+            configuration,
+            activeConfiguration: completed,
+            initialEntryPaths: getInitialEntryPaths(machine, completed),
+            done: false,
+            output: undefined
+          }
+        }
+        const root = getRootPath(machine, completed)
+        if (!completed.outputs.has(root)) {
+          throw new Error("Machine reached a terminal configuration without a completed root output")
+        }
+        return {
+          state,
+          configuration,
+          activeConfiguration: completed,
+          initialEntryPaths: getInitialEntryPaths(machine, completed),
+          done: true,
+          output: completed.outputs.get(root)
+        }
+      }
     }
     : activePlan((configuration, event) => planConfiguration(machine as any, configuration, event as any))
   executionPlanCache.set(machine, compiled)

src/internal/machineProcess.ts

@@ -4,14 +4,20 @@
  * @since 4.0.0
  */
 
+import * as Cause from "effect/Cause"
 import * as Effect from "effect/Effect"
 import * as Exit from "effect/Exit"
 import * as Option from "effect/Option"
 import * as Queue from "effect/Queue"
 import type * as Schema from "effect/Schema"
 import type { ActionError, ExecutionServices, Machine, Runtime } from "../Machine.js"
-import { ChildAlreadyExistsError, InfiniteTransitionError, MachineSchemaDecodeError } from "./machineErrors.js"
-import type { StartupError, StoppedError } from "./machineErrors.js"
+import {
+  ChildAlreadyExistsError,
+  InfiniteTransitionError,
+  MachineSchemaDecodeError,
+  StartupError
+} from "./machineErrors.js"
+import type { StoppedError } from "./machineErrors.js"
 import * as Model from "./machineModel.js"
 import * as internalPlanner from "./machinePlanner.js"
 import * as internalRuntime from "./machineRuntime.js"
@@ -247,9 +253,21 @@ const makeChildlessCompiledDrain = (
 class InvokeExecutionKernel {
   readonly sessions: Map<string, InvokeSession>
   initialized = false
+  initial:
+    | {
+      readonly configuration: unknown
+      readonly activeConfiguration: Model.ActiveConfiguration
+      readonly entryPaths: ReadonlyArray<string>
+    }
+    | undefined
 
-  constructor() {
+  constructor(initial?: {
+    readonly configuration: unknown
+    readonly activeConfiguration: Model.ActiveConfiguration
+    readonly entryPaths: ReadonlyArray<string>
+  }) {
     this.sessions = new Map()
+    this.initial = initial
   }
 
   private makeSessionKey(path: string, id: string): string {
@@ -499,15 +517,17 @@ const makeInvokingCompiledDrain = (
       if (execution.initialized) {
         return loop
       }
-      const initialConfiguration = Model.normalizeConfigurationSync(machine, current)
-      configuration = executionPlan.fromConfiguration(initialConfiguration)
+      const seeded = execution.initial
+      const initialConfiguration = seeded?.activeConfiguration ?? Model.normalizeConfigurationSync(machine, current)
+      configuration = seeded?.configuration ?? executionPlan.fromConfiguration(initialConfiguration)
       const starting = execution.startAll(
         machine,
         context,
         initialConfiguration,
-        Model.getInitialEntryPaths(machine, initialConfiguration),
+        seeded?.entryPaths ?? Model.getInitialEntryPaths(machine, initialConfiguration),
         internalPlanner.InitialEvent
       )
+      execution.initial = undefined
       execution.initialized = true
       return starting === undefined ? loop : starting.pipe(Effect.andThen(loop))
     }
@@ -564,36 +584,63 @@ const makeProcessLogic: <
   entry: ProcessEntry<States, Input>
 ) => {
   const hasInvokes = hasInvokeCapability(machine)
+  const executionPlan = internalPlanner.compileExecutionPlan(machine)
   const initialArgs = entry._tag === "Initial" ? entry.args : []
+  const compiledInitial = entry._tag === "Initial" ? executionPlan.initial : undefined
   const makeInitial = (
     scope: internalRuntime.ProcessScope<Machine.EventOf<Events>>
   ) =>
-    internalRuntime.provideMachineRuntime(
-      internalPlanner.planInitial(machine, ...initialArgs).pipe(
-        Effect.flatMap((planned) => {
-          const commands = planned.commands.length === 0
-            ? undefined
-            : internalPlanner.runCommands(planned.commands, scope)
-          const emitted = planned.emittedEvents.length === 0
-            ? undefined
-            : internalPlanner.runEmittedEvents(
-              planned.emittedEvents,
-              internalPlanner.makeLiveRuntime<Machine.EventOf<Events>, Machine.EmitOf<Emits>>(machine, scope)
-            )
-          const result = Effect.succeed({
-            state: planned.state,
-            done: planned.done,
-            output: planned.output
+    compiledInitial === undefined
+      ? internalRuntime.provideMachineRuntime(
+        internalPlanner.planInitial(machine, ...initialArgs).pipe(
+          Effect.flatMap((planned) => {
+            const commands = planned.commands.length === 0
+              ? undefined
+              : internalPlanner.runCommands(planned.commands, scope)
+            const emitted = planned.emittedEvents.length === 0
+              ? undefined
+              : internalPlanner.runEmittedEvents(
+                planned.emittedEvents,
+                internalPlanner.makeLiveRuntime<Machine.EventOf<Events>, Machine.EmitOf<Emits>>(machine, scope)
+              )
+            const result = Effect.succeed({
+              state: planned.state,
+              done: planned.done,
+              output: planned.output
+            })
+            return commands === undefined
+              ? emitted === undefined ? result : emitted.pipe(Effect.andThen(result))
+              : emitted === undefined
+              ? commands.pipe(Effect.andThen(result))
+              : commands.pipe(Effect.andThen(emitted), Effect.andThen(result))
           })
-          return commands === undefined
-            ? emitted === undefined ? result : emitted.pipe(Effect.andThen(result))
-            : emitted === undefined
-            ? commands.pipe(Effect.andThen(result))
-            : commands.pipe(Effect.andThen(emitted), Effect.andThen(result))
-        })
-      ),
-      scope
-    )
+        ),
+        scope
+      )
+      : Effect.try({
+        try: () => {
+          const planned = compiledInitial(initialArgs)
+          const result = {
+            state: planned.state as Machine.Snapshot<States>,
+            done: planned.done,
+            output: planned.output as Output | undefined
+          }
+          return hasInvokes
+            ? {
+              ...result,
+              executionState: new InvokeExecutionKernel({
+                configuration: planned.configuration,
+                activeConfiguration: planned.activeConfiguration,
+                entryPaths: planned.initialEntryPaths
+              })
+            }
+            : result
+        },
+        catch: (error) =>
+          error instanceof InfiniteTransitionError || error instanceof MachineSchemaDecodeError
+            ? error
+            : new StartupError({ cause: Cause.die(error) })
+      })
   return ({
     [internalRuntime.childlessProcess]: hasInvokes ? undefined : true,
     [internalRuntime.compiledProcess]: true,

src/internal/machineRuntime.ts

@@ -284,7 +284,13 @@ export interface ProcessLogic<
     scope: ProcessScope<Event>
   ) => Effect.Effect<
     | { readonly state: State; readonly done: false; readonly output: undefined }
-    | { readonly state: State; readonly done: true; readonly output: Output },
+    | { readonly state: State; readonly done: true; readonly output: Output }
+    | {
+      readonly state: State
+      readonly done: boolean
+      readonly output: Output | undefined
+      readonly executionState: unknown
+    },
     InitialError,
     Requirements
   >
@@ -1358,6 +1364,9 @@ class CompiledProcess implements MachineRef<any, any, any, any> {
         }
       } else {
         self.compiledContext = new CompiledProcessContextImpl(self.processScope, self)
+        if ("executionState" in initialized) {
+          self.compiledContext.executionState = initialized.executionState
+        }
       }
 
       if (self.options.onReady !== undefined) {