@typeonce/effect-machine 0.12.0 → 0.13.0

package/src/internal/machine/atom.ts

@@ -139,6 +139,32 @@ export const emissions = <State, Event, Error, Output, StartError, Emitted>(
   )
 }
 
+export const inspection = <State, Event, Error, Output, StartError, Emitted>(
+  self: MachineAtom<State, Event, Error, Output, StartError, Emitted>
+): Stream.Stream<Machine.Inspection.Event, StartError, AtomRegistry.AtomRegistry> => {
+  const prepared = preparedByMachineAtom.get(self as object)
+  if (prepared === undefined) return Stream.empty
+  return Stream.unwrap(
+    Effect.gen(function*() {
+      const registry = yield* AtomRegistry.AtomRegistry
+      const releasePrepared = yield* Effect.sync(() => registry.mount(prepared))
+      yield* Effect.addFinalizer(() => Effect.sync(releasePrepared))
+      const machine = yield* Atom.getResult(prepared)
+      const pull = yield* Stream.toPull(machine.inspection)
+      const firstPull = yield* pull.pipe(Effect.forkScoped({ startImmediately: true }))
+      const releaseRef = yield* Effect.sync(() => registry.mount(self.ref))
+      yield* Effect.addFinalizer(() => Effect.sync(releaseRef))
+      yield* Atom.getResult(self.ref)
+      let first = true
+      return Stream.fromPull(Effect.succeed(Effect.suspend(() => {
+        if (!first) return pull
+        first = false
+        return Fiber.join(firstPull)
+      })))
+    })
+  )
+}
+
 export const childEmissions = <Child extends Machine.ChildMachine.Any, StartError>(
   self: ChildMachineAtom<Child, StartError>
 ): Stream.Stream<RefEmitted<Machine.ChildMachine.Ref<Child>>, StartError, AtomRegistry.AtomRegistry> =>

package/src/internal/machine/commandRuntime.ts

@@ -10,18 +10,13 @@ import type { RuntimeCommand } from "./command.js"
 import { decodeEmit, decodeEvent } from "./protocol.js"
 import type { ProcessScope } from "./runtime.js"
 
-const isMachineTarget = (
-  target: unknown
-): target is { readonly send: (event: unknown) => Effect.Effect<void, unknown> } =>
-  typeof target === "object" && target !== null && "send" in target && typeof target.send === "function"
-
 export const makeLiveRuntime = <Events, Emits>(
   machine: Machine.Any,
   scope: ProcessScope<Events>
 ): Runtime<Events, Emits> => ({
   raise: (event) =>
     decodeEvent(machine, event).pipe(
-      Effect.flatMap((event) => scope.self.send(event as Events))
+      Effect.flatMap((event) => scope.sendTo(scope.self, event as Events))
     ),
   emit: (event) =>
     decodeEmit(machine, event).pipe(
@@ -35,9 +30,7 @@ export const runCommands = <Event>(
 ) =>
   Effect.forEach(commands, (command) =>
     command._tag === "SendTo"
-      ? isMachineTarget(command.target)
-        ? command.target.send(command.event)
-        : scope.sendTo(command.target as never, command.event)
+      ? scope.sendTo(command.target as never, command.event)
       : scope.stopChild(command.child as never), { discard: true })
 
 export const runEmittedEvents = <Events, Emits>(

package/src/internal/machine/configuration.ts

@@ -17,7 +17,14 @@ import {
   decodeStateValue,
   decodeStateValueSync
 } from "./protocol.js"
-import { getNode, getStateNodeSchema, isSnapshot, isTarget, TargetSnapshotTypeId } from "./topology.js"
+import {
+  getNode,
+  getStateNodeSchema,
+  type InitialTarget as InitialTargetInstruction,
+  isSnapshot,
+  isTarget,
+  TargetSnapshotTypeId
+} from "./topology.js"
 
 export interface HistoryRecord {
   readonly mode: "shallow" | "deep"
@@ -952,7 +959,8 @@ const configurationFromTargetPathSync = (
   current: ActiveConfiguration,
   path: string,
   value: unknown,
-  providedValues: Readonly<Record<string, unknown>> | undefined
+  providedValues: Readonly<Record<string, unknown>> | undefined,
+  allowIncomplete = false
 ): ActiveConfiguration => {
   const node = getNode(machine, path)
   const active = new Set<string>()
@@ -998,12 +1006,29 @@ const configurationFromTargetPathSync = (
     }
   }
 
-  if (node.type === "compound" || node.type === "parallel") {
+  if (!allowIncomplete && (node.type === "compound" || node.type === "parallel")) {
     throw new Error(`Machine target "${node.path}" must include an active child state`)
   }
   return { active, values, outputs, history: current.history }
 }
 
+/** Builds the selected path and its ancestors without requiring nested active
+ * children. The planner completes those children through declared initial
+ * topology and `initialize` handlers before normalization continues. */
+export const configurationFromInitialTargetSync = (
+  machine: Machine.Any,
+  current: ActiveConfiguration,
+  target: InitialTargetInstruction
+): ActiveConfiguration =>
+  configurationFromTargetPathSync(
+    machine,
+    current,
+    target.path,
+    target.value,
+    target.values as Readonly<Record<string, unknown>> | undefined,
+    true
+  )
+
 const configurationFromTargetSnapshotSync = (
   machine: Machine.Any,
   current: ActiveConfiguration,

package/src/internal/machine/executionPlan.ts

@@ -38,6 +38,7 @@ import {
   normalizeTransition,
   planConfiguration,
   removeConflictingTransitions,
+  resolveInitialTarget,
   type SelectedTransition,
   sortEntryPaths,
   sortEvaluatedTransitions,
@@ -46,7 +47,7 @@ import {
   validateDeclaredTransitionTarget
 } from "./planner.js"
 import { decodeEmitSync, decodeEventSync, decodeInputSync, decodeStateValueSync } from "./protocol.js"
-import { isNoTarget, isSnapshot, isTarget, TargetSnapshotTypeId } from "./topology.js"
+import { isInitialTarget, isNoTarget, isSnapshot, isTarget, TargetSnapshotTypeId } from "./topology.js"
 
 interface IndexedExecutionDescriptor {
   readonly flat: boolean
@@ -91,7 +92,7 @@ const resolveMachineReferences = (
     : { self: machineReferences.self, parent: machineReferences.parent }
 
 const indexedStateConfigKeys: ReadonlySet<PropertyKey> = new Set([
-  "initial",
+  "initialize",
   "invoke",
   "on",
   "output"
@@ -402,6 +403,7 @@ const emptyExecutionValues: ReadonlyArray<never> = Object.freeze([])
 export interface ExecutionMicrostep<State = unknown> {
   readonly next: State
   readonly event: unknown
+  readonly transitions?: ReadonlyArray<Machine.RetainedTransition>
   readonly commands: ReadonlyArray<RuntimeCommand>
   readonly raisedEvents: ReadonlyArray<unknown>
   readonly emittedEvents: ReadonlyArray<unknown>
@@ -530,13 +532,22 @@ const collectIndexedEvaluatedTransition = (
   selection: IndexedSelectedTransition
 ): IndexedEvaluatedTransition => {
   const transitionResult = collectIndexedTransition(machine, selection.transition.transition, selection.context)
-  const target = transitionResult.state
+  const unresolvedTarget = transitionResult.state
   validateDeclaredTransitionTarget(
     selection.sourcePath,
     selection.trigger,
     selection.transition.targets,
-    target
+    unresolvedTarget
   )
+  const initialResolution = unresolvedTarget !== undefined && isInitialTarget(unresolvedTarget)
+    ? resolveInitialTarget(
+      machine,
+      activeConfigurationFromIndexedState(descriptor, state),
+      unresolvedTarget,
+      (selection.context as any).event
+    )
+    : undefined
+  const target = initialResolution?.target ?? unresolvedTarget
   if (target !== undefined && !isTarget(target) && !isSnapshot(target)) {
     throw new Error("Machine expected indexed transition target to be a snapshot or target builder result")
   }
@@ -547,16 +558,16 @@ const collectIndexedEvaluatedTransition = (
   if (!changed) {
     return {
       selection,
-      unresolvedTarget: target as any,
+      unresolvedTarget: unresolvedTarget as any,
       target: target as any,
       next,
-      commands: transitionResult.commands,
-      raisedEvents: transitionResult.raisedEvents,
-      emittedEvents: transitionResult.emittedEvents,
+      commands: [...transitionResult.commands, ...(initialResolution?.commands ?? [])],
+      raisedEvents: [...transitionResult.raisedEvents, ...(initialResolution?.raisedEvents ?? [])],
+      emittedEvents: [...transitionResult.emittedEvents, ...(initialResolution?.emittedEvents ?? [])],
       changed: false,
       exitPaths: [],
       entryPaths: [],
-      choiceTransitions: []
+      choiceTransitions: initialResolution?.transitions ?? []
     }
   }
 
@@ -570,16 +581,16 @@ const collectIndexedEvaluatedTransition = (
     : naturalBoundary
   return {
     selection,
-    unresolvedTarget: target as any,
+    unresolvedTarget: unresolvedTarget as any,
     target: target as any,
     next,
-    commands: transitionResult.commands,
-    raisedEvents: transitionResult.raisedEvents,
-    emittedEvents: transitionResult.emittedEvents,
+    commands: [...transitionResult.commands, ...(initialResolution?.commands ?? [])],
+    raisedEvents: [...transitionResult.raisedEvents, ...(initialResolution?.raisedEvents ?? [])],
+    emittedEvents: [...transitionResult.emittedEvents, ...(initialResolution?.emittedEvents ?? [])],
     changed: true,
     exitPaths: getExitPaths(machine, activeConfigurationFromIndexedState(descriptor, state), boundary),
     entryPaths: getEntryPaths(machine, activeConfigurationFromIndexedState(descriptor, next), boundary),
-    choiceTransitions: []
+    choiceTransitions: initialResolution?.transitions ?? []
   }
 }
 
@@ -588,13 +599,22 @@ const indexedMicrostep = (
   descriptor: IndexedExecutionDescriptor,
   state: OwnedIndexedState,
   event: any,
-  selections: ReadonlyArray<IndexedSelectedTransition>
+  selections: ReadonlyArray<IndexedSelectedTransition>,
+  retainTransitions: boolean
 ): ExecutionMicrostep<OwnedIndexedState> => {
+  const retain = (transition: IndexedEvaluatedTransition): Machine.RetainedTransition => ({
+    source: transition.selection.sourcePath,
+    trigger: transition.selection.trigger,
+    reenter: transition.selection.transition.reenter,
+    target: transition.unresolvedTarget === undefined ? undefined : getTargetNodePath(transition.unresolvedTarget),
+    resolvedTarget: transition.target === undefined ? undefined : getTargetNodePath(transition.target)
+  })
   if (selections.length === 1) {
     const transition = collectIndexedEvaluatedTransition(machine, descriptor, state, selections[0]!)
     return {
       next: transition.next,
       event,
+      ...(retainTransitions ? { transitions: [retain(transition)] } : undefined),
       commands: transition.commands,
       raisedEvents: transition.raisedEvents,
       emittedEvents: transition.emittedEvents,
@@ -645,6 +665,7 @@ const indexedMicrostep = (
   return {
     next,
     event,
+    ...(retainTransitions ? { transitions: transitions.map(retain) } : undefined),
     commands,
     raisedEvents,
     emittedEvents,
@@ -762,6 +783,17 @@ const planIndexedFlatState = (
       const step: ExecutionMicrostep<OwnedIndexedState> = {
         next,
         event,
+        ...(retainMicrosteps
+          ? {
+            transitions: [{
+              source: sourcePath,
+              trigger: { type: "event", event: event._tag },
+              reenter: transition.reenter,
+              target: target === undefined ? undefined : getTargetNodePath(target as any),
+              resolvedTarget: target === undefined ? undefined : getTargetNodePath(target as any)
+            }]
+          }
+          : undefined),
         commands: transitionResult.commands,
         raisedEvents: transitionResult.raisedEvents,
         emittedEvents: transitionResult.emittedEvents,
@@ -828,6 +860,7 @@ const planIndexedState = (
       microsteps: planned.microsteps.map((step) => ({
         next: ownedIndexedStateFromActive(descriptor, step.next),
         event: step.event,
+        transitions: step.transitions,
         commands: step.commands,
         raisedEvents: step.raisedEvents,
         emittedEvents: step.emittedEvents,
@@ -874,7 +907,7 @@ const planIndexedState = (
     }
   }
 
-  const first = indexedMicrostep(machine, descriptor, configuration, decoded, selections)
+  const first = indexedMicrostep(machine, descriptor, configuration, decoded, selections, retainMicrosteps)
   let current = first.next
   let currentEvent: any = decoded
   const commands = [...first.commands]
@@ -932,7 +965,7 @@ const planIndexedState = (
     currentEvent = raised
     const raisedSelections = selectIndexedEventTransitions(machine, descriptor, current, raised, machineReferences)
     if (raisedSelections.length === 0) continue
-    const step = indexedMicrostep(machine, descriptor, current, raised, raisedSelections)
+    const step = indexedMicrostep(machine, descriptor, current, raised, raisedSelections, retainMicrosteps)
     current = step.next
     commands.push(...step.commands)
     raisedEvents.push(...step.raisedEvents)

package/src/internal/machine/initialization.ts

@@ -0,0 +1,73 @@
+/** Internal builders for schema-valued default state entry. */
+
+import { hasProperty } from "effect/Predicate"
+import type { Machine } from "../../Machine.js"
+import { SnapshotBuilderStateTypeId } from "./symbols.js"
+import * as Topology from "./topology.js"
+
+const getNode = (machine: Machine.Any, path: string): Machine.StateNode => {
+  const node = machine.stateNodes.byPath.get(path)
+  if (node === undefined) {
+    throw new Error(`Machine expected state path "${path}" to exist`)
+  }
+  return node
+}
+
+const withFrom = <Method extends (value: unknown) => unknown>(method: Method) => {
+  Object.defineProperty(method, "from", {
+    value: (...args: ReadonlyArray<unknown>) => method(Topology.makeStateInput(args.length === 0 ? {} : args[0])),
+    enumerable: false
+  })
+  return method as Method & { readonly from: (...args: ReadonlyArray<unknown>) => unknown }
+}
+
+const makeCompletion = (values: Readonly<Record<string, unknown>>): object => {
+  const completion = {}
+  Object.defineProperty(completion, SnapshotBuilderStateTypeId, {
+    value: values,
+    enumerable: false
+  })
+  return completion
+}
+
+const makeParallelBuilder = (
+  machine: Machine.Any,
+  node: Machine.StateNode,
+  values: Readonly<Record<string, unknown>>
+): object => {
+  const builder = makeCompletion(values) as Record<string | symbol, unknown>
+  for (const childPath of node.children) {
+    const child = getNode(machine, childPath)
+    if (child.schema === undefined || hasProperty(values, child.key)) continue
+    builder[child.key] = withFrom((value: unknown) => {
+      const nextValues: Record<string, unknown> = Object.assign({}, values)
+      nextValues[child.key] = value
+      return makeParallelBuilder(machine, node, nextValues)
+    })
+  }
+  return builder
+}
+
+export const makeStateInitializeBuilder = (machine: Machine.Any, path: string): object => {
+  const node = getNode(machine, path)
+  if (node.type === "parallel") {
+    return makeParallelBuilder(machine, node, {})
+  }
+  if (node.type !== "compound") {
+    throw new Error(`Machine state "${path}" cannot initialize child states`)
+  }
+  const child = getNode(machine, node.initial)
+  if (child.schema === undefined) {
+    throw new Error(`Machine state "${path}" has no schema-valued initial child`)
+  }
+  return withFrom((value: unknown) => makeCompletion({ [child.key]: value }))
+}
+
+export const getStateInitializeValues = (path: string, result: unknown): Readonly<Record<string, unknown>> => {
+  if (typeof result !== "object" || result === null || !hasProperty(result, SnapshotBuilderStateTypeId)) {
+    throw new Error(`Machine initialize handler for "${path}" must return its builder result`)
+  }
+  return (result as { readonly [SnapshotBuilderStateTypeId]: Readonly<Record<string, unknown>> })[
+    SnapshotBuilderStateTypeId
+  ]
+}

package/src/internal/machine/inspectionRuntime.ts

@@ -0,0 +1,102 @@
+/**
+ * Root-scoped live inspection publication and evidence projection.
+ *
+ * @since 0.13.0
+ */
+
+import * as Effect from "effect/Effect"
+import * as PubSub from "effect/PubSub"
+import * as Stream from "effect/Stream"
+import type { Inspection } from "../../Machine.js"
+
+export type Draft<Event extends Inspection.Event = Inspection.Event> = Event extends Inspection.Event
+  ? Omit<Event, "sequence" | "rootSessionId">
+  : never
+
+export interface Runtime {
+  readonly rootSessionId: string
+  readonly stream: Stream.Stream<Inspection.Event>
+  readonly isActive: () => boolean
+  readonly nextDeliveryId: () => number
+  readonly nextMacrostepId: () => number
+  readonly publishUnsafe: (event: Draft) => void
+  readonly close: Effect.Effect<void>
+}
+
+export const make = (rootSessionId: string): Effect.Effect<Runtime> =>
+  Effect.gen(function*() {
+    const pubsub = yield* PubSub.unbounded<Inspection.Event>()
+    let subscribers = 0
+    let sequence = 0
+    let deliveryId = 0
+    let macrostepId = 0
+    return {
+      rootSessionId,
+      stream: Stream.fromPubSub(pubsub).pipe(
+        Stream.onStart(Effect.sync(() => {
+          subscribers += 1
+        })),
+        Stream.ensuring(Effect.sync(() => {
+          subscribers -= 1
+        }))
+      ),
+      isActive: () => subscribers > 0,
+      nextDeliveryId: () => deliveryId++,
+      nextMacrostepId: () => macrostepId++,
+      publishUnsafe: (event) => {
+        if (subscribers === 0) return
+        PubSub.publishUnsafe(pubsub, {
+          ...event,
+          sequence: sequence++,
+          rootSessionId
+        } as Inspection.Event)
+      },
+      close: PubSub.shutdown(pubsub)
+    }
+  })
+
+export const endpoint = (
+  target: { readonly id: string; readonly sessionId: string }
+): Inspection.Endpoint => ({
+  id: target.id,
+  sessionId: target.sessionId
+})
+
+const commands = (values: ReadonlyArray<unknown>): ReadonlyArray<Inspection.Command> =>
+  values.flatMap((command): ReadonlyArray<Inspection.Command> => {
+    if (typeof command !== "object" || command === null || !("_tag" in command)) return []
+    if (command._tag === "SendTo" && "target" in command && "event" in command) {
+      const target = command.target
+      return typeof target === "object" && target !== null && "id" in target
+        ? [{
+          _tag: "SendTo",
+          target: "sessionId" in target ? endpoint(target as any) : { id: String(target.id) },
+          event: command.event
+        }]
+        : []
+    }
+    if (command._tag === "Stop" && "child" in command) {
+      const child = command.child
+      if (typeof child === "string") return [{ _tag: "Stop", target: { id: child } }]
+      return typeof child === "object" && child !== null && "id" in child
+        ? [{ _tag: "Stop", target: "sessionId" in child ? endpoint(child as any) : { id: String(child.id) } }]
+        : []
+    }
+    return []
+  })
+
+export const microsteps = (plan: unknown): ReadonlyArray<Inspection.Microstep> => {
+  if (typeof plan !== "object" || plan === null || !("microsteps" in plan) || !Array.isArray(plan.microsteps)) {
+    return []
+  }
+  return plan.microsteps.map((step: any) => ({
+    event: step.event,
+    transitions: Array.isArray(step.transitions) ? step.transitions : [],
+    raisedEvents: Array.isArray(step.raisedEvents) ? step.raisedEvents : [],
+    emittedEvents: Array.isArray(step.emittedEvents) ? step.emittedEvents : [],
+    commands: commands(Array.isArray(step.commands) ? step.commands : []),
+    exitPaths: Array.isArray(step.exitPaths) ? step.exitPaths : [],
+    entryPaths: Array.isArray(step.entryPaths) ? step.entryPaths : [],
+    changed: step.changed === true
+  }))
+}

package/src/internal/machine/invocation.ts

@@ -6,7 +6,7 @@
 
 import * as Cause from "effect/Cause"
 import * as Effect from "effect/Effect"
-import type { ChildMachine, Logic, Machine } from "../../Machine.js"
+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"
@@ -23,6 +23,7 @@ export interface AnyConfig {
   readonly onDone?: unknown
   readonly onFailure?: unknown
   readonly onSnapshot?: unknown
+  readonly activityKind?: Inspection.Activity["kind"]
 }
 
 /** @internal */
@@ -47,7 +48,7 @@ const resolveOne = (
     return {
       id: String(raw.id),
       src: () =>
-        oneShot(resolveValue(raw.effect, context) as Effect.Effect<any, any, any>) as unknown as Runtime.ProcessLogic<
+        oneShot(raw.effect(context) as Effect.Effect<any, any, any>) as unknown as Runtime.ProcessLogic<
           any,
           any,
           any,
@@ -57,7 +58,8 @@ const resolveOne = (
         >,
       onDone: raw.onDone,
       onFailure: raw.onFailure,
-      onSnapshot: raw.onSnapshot
+      onSnapshot: raw.onSnapshot,
+      activityKind: "Effect"
     }
   }
   if ("after" in raw) {
@@ -72,7 +74,8 @@ const resolveOne = (
           any,
           any
         >,
-      onDone: raw.onDone
+      onDone: raw.onDone,
+      activityKind: "Timer"
     }
   }
   if ("logic" in raw) {
@@ -115,8 +118,18 @@ const runSequentialDiscard = <E, R>(
 
 const sendLifecycle = (
   scope: Runtime.ProcessScope<any>,
-  event: InvocationEvent.InvocationEvent
-): Effect.Effect<void> => scope.self.send(event).pipe(Effect.catchTag("StoppedError", () => Effect.void))
+  event: InvocationEvent.InvocationEvent,
+  activitySessionId?: string
+): Effect.Effect<void> =>
+  (activitySessionId === undefined
+    ? scope.self.send(event)
+    : scope.self.sendInspected === undefined
+    ? scope.self.send(event)
+    : scope.self.sendInspected(
+      event,
+      scope.self.inspectionSubject,
+      { _tag: "Activity", activitySessionId }
+    )).pipe(Effect.catchTag("StoppedError", () => Effect.void))
 
 const isFrameworkFailure = (error: unknown): boolean =>
   error instanceof InfiniteTransitionError || error instanceof MachineSchemaDecodeError || error instanceof StoppedError
@@ -131,7 +144,8 @@ const startResolved = (
   src: () => Runtime.ProcessLogic<any, any, any, any, any, any>,
   onDone: unknown,
   onFailure: unknown,
-  onSnapshot: unknown
+  onSnapshot: unknown,
+  activityKind?: Inspection.Activity["kind"]
 ): Effect.Effect<void, any, any> =>
   Effect.suspend(() => {
     const key = makeKey(path, invokeId)
@@ -141,8 +155,9 @@ const startResolved = (
       id: childId,
       duplicateId: invokeId,
       ...(descriptor === undefined ? undefined : { descriptor }),
+      ...(activityKind === undefined ? undefined : { activityKind }),
       sendParent: (isCurrent, event) => isCurrent() ? scope.self.send(event) : Effect.void,
-      onOutcome: (isCurrent, outcome) => {
+      onOutcome: (isCurrent, outcome, activitySessionId) => {
         if (outcome._tag === "Stopped" || !isCurrent()) return Effect.void
         if (outcome._tag === "Done") {
           if (onDone === undefined) {
@@ -152,14 +167,22 @@ const startResolved = (
               )
             ))
           }
-          return sendLifecycle(scope, InvocationEvent.done(path, invokeId, outcome.output))
+          return sendLifecycle(
+            scope,
+            InvocationEvent.done(path, invokeId, outcome.output),
+            activityKind === undefined ? undefined : activitySessionId
+          )
         }
         if (
           outcome._tag === "Failure" &&
           onFailure !== undefined &&
           (descriptor === undefined || !isFrameworkFailure(outcome.error))
         ) {
-          return sendLifecycle(scope, InvocationEvent.failure(path, invokeId, outcome.error))
+          return sendLifecycle(
+            scope,
+            InvocationEvent.failure(path, invokeId, outcome.error),
+            activityKind === undefined ? undefined : activitySessionId
+          )
         }
         return scope.failCause(outcome.cause)
       },
@@ -189,7 +212,8 @@ const start = (
     config.src,
     config.onDone,
     config.onFailure,
-    config.onSnapshot
+    config.onSnapshot,
+    config.activityKind
   )
 }
 
@@ -213,7 +237,8 @@ const startStaticChild = (
     descriptor[ChildMachineLogicTypeId],
     raw.onDone,
     raw.onFailure,
-    raw.onSnapshot
+    raw.onSnapshot,
+    undefined
   )
 }