@typeonce/effect-machine 0.10.0 → 0.11.0

package/src/internal/machine/atom.ts

@@ -7,11 +7,12 @@
 import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
 import * as Equal from "effect/Equal"
+import * as Fiber from "effect/Fiber"
 import * as Option from "effect/Option"
 import type * as Schema from "effect/Schema"
 import type * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
-import { AsyncResult, Atom, type AtomRegistry } from "effect/unstable/reactivity"
+import { AsyncResult, Atom, AtomRegistry } from "effect/unstable/reactivity"
 import type * as Machine from "../../Machine.js"
 import type { Bound, ChildMachineAtom, MachineAtom } from "../../unstable/reactivity/AtomMachine.js"
 import * as internalMachine from "./machine.js"
@@ -72,6 +73,11 @@ type MachineStartError<InitialE, E, InitialR, R, RuntimeError = never> =
   | Machine.StoppedError
   | RuntimeError
 
+const preparedByMachineAtom = new WeakMap<
+  object,
+  Atom.Atom<AsyncResult.AsyncResult<Machine.Prepared<any, any, any, any, any, any, any>, any>>
+>()
+
 const runMachineAtomEffect = <State, Event, Error, Output, Emitted, StartError, Requirements>(
   get: Atom.AtomContext,
   start: Effect.Effect<Machine.MachineRef<State, Event, Error, Output, Emitted>, StartError, Requirements>
@@ -83,53 +89,16 @@ const runMachineAtomEffect = <State, Event, Error, Output, Emitted, StartError,
     )
   )
 
-const startMachineAtomEffect = <
-  const States extends Machine.Machine.StateSchemas,
-  const Events extends ReadonlyArray<Machine.Machine.TaggedSchema>,
-  const Emits extends ReadonlyArray<Machine.Machine.TaggedSchema> = any,
-  const Input extends Schema.Top = typeof Schema.Void,
-  UnhandledStates extends Machine.Machine.StateIdentifier<States> = Machine.Machine.StateIdentifier<States>,
-  E = never,
-  R = never,
-  InitialE = never,
-  InitialR = never,
-  FinalStates extends Machine.Machine.StateIdentifier<States> = never,
-  Output = never,
-  OutputStates extends Machine.Machine.StateIdentifier<States> = never,
-  InputEvents extends ReadonlyArray<Machine.Machine.TaggedSchema> = Events,
-  ParentEvents extends ReadonlyArray<Machine.Machine.TaggedSchema> = readonly []
->(
+const startPreparedMachineAtomEffect = <State, Event, Error, Output, Emitted, StartError, Requirements>(
   get: Atom.AtomContext,
-  machine:
-    & Machine.Machine<
-      States,
-      Events,
-      Input,
-      UnhandledStates,
-      E,
-      R,
-      InitialE,
-      InitialR,
-      FinalStates,
-      Output,
-      Emits,
-      OutputStates,
-      InputEvents,
-      ParentEvents
+  prepared: Atom.Atom<
+    AsyncResult.AsyncResult<
+      Machine.Prepared<State, Event, Error, Output, Emitted, StartError, Requirements>,
+      never
     >
-    & EnsureExecutable<States, UnhandledStates, OutputStates>,
-  args: [...Machine.Machine.InputArgs<Input>]
-): Effect.Effect<
-  Machine.MachineRef<
-    Machine.Machine.Snapshot<States>,
-    Machine.Machine.EventInputOf<InputEvents>,
-    MachineRuntimeError<E, R>,
-    Output,
-    Machine.Machine.EmittedEventOf<Emits>
-  >,
-  MachineStartError<InitialE, E, InitialR, R>,
-  MachineRequirements<InitialR, R, Machine.Machine.EventOf<Events>, Machine.Machine.EmitOf<Emits>>
-> => runMachineAtomEffect(get, internalMachine.start(machine as any, ...args) as any)
+  >
+): Effect.Effect<never, StartError, Requirements> =>
+  runMachineAtomEffect(get, get.result(prepared).pipe(Effect.flatMap((prepared) => prepared.start)))
 
 const resumeMachineAtomEffect = (
   get: Atom.AtomContext,
@@ -144,8 +113,31 @@ type RefEmitted<Ref> = Ref extends Machine.MachineRef<any, any, any, any, infer
 
 export const emissions = <State, Event, Error, Output, StartError, Emitted>(
   self: MachineAtom<State, Event, Error, Output, StartError, Emitted>
-): Stream.Stream<Emitted, StartError, AtomRegistry.AtomRegistry> =>
-  Atom.toStreamResult(self.ref).pipe(Stream.flatMap((ref) => ref.emissions))
+): Stream.Stream<Emitted, StartError, AtomRegistry.AtomRegistry> => {
+  const prepared = preparedByMachineAtom.get(self as object)
+  if (prepared === undefined) {
+    return Atom.toStreamResult(self.ref).pipe(Stream.flatMap((ref) => ref.emissions))
+  }
+  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.emissions as Stream.Stream<Emitted>)
+      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>
@@ -666,8 +658,11 @@ export const make: {
     Machine.Machine.EmittedEventOf<Emits>
   >
 } = ((machine: Machine.Machine.Any, ...args: ReadonlyArray<unknown>) => {
-  const ref = Atom.make((get) => startMachineAtomEffect(get, machine as any, args as []))
-  return makeFromRefAtom(ref as any)
+  const prepared = Atom.make(() => internalMachine.prepare(machine as any, ...(args as [])))
+  const ref = Atom.make((get) => startPreparedMachineAtomEffect(get, prepared as any))
+  const result = makeFromRefAtom(ref as any)
+  preparedByMachineAtom.set(result, prepared as any)
+  return result
 }) as any
 
 export const resume: {
@@ -688,8 +683,11 @@ const makeWithRuntime = (
   machine: Machine.Machine.Any,
   args: ReadonlyArray<unknown>
 ): MachineAtom<any, any, any, any, any> => {
-  const ref = runtime.atom((get) => startMachineAtomEffect(get, machine as any, args as []))
-  return makeFromRefAtom(ref as 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)
+  preparedByMachineAtom.set(result, prepared as any)
+  return result
 }
 
 const resumeWithRuntime = (

package/src/internal/machine/machine.ts

@@ -104,6 +104,8 @@ const Proto = {
   }
 }
 
+const makeBoundInvoke = (config: unknown): unknown => config
+
 const cloneWithHandlers = (
   self: Machine.Any,
   handlers: Machine.StateConfigs<any, any, any, any, any, any, any>
@@ -121,6 +123,7 @@ const cloneWithHandlers = (
   machine.makeTargetBuilder = self.makeTargetBuilder
   machine.handlers = handlers
   machine.handle = makeHandle(machine)
+  machine.invoke = makeBoundInvoke
   Protocol.copyProtocol(self, machine)
   return machine
 }
@@ -879,6 +882,7 @@ export const make: Make = (<
   self.makeTargetBuilder = makeTargetBuilder(config.states, self.stateNodes)
   self.handlers = Object.create(null)
   self.handle = makeHandle(self)
+  self.invoke = makeBoundInvoke
   Protocol.setProtocol(self)
   return self
 }) as Make
@@ -1358,6 +1362,8 @@ export const watch = <State, Event, Error = never, Output = never>(
   ref: MachineRef<State, Event, Error, Output>
 ): Stream.Stream<RuntimeOutcome<State, Error, Output>> => internalRuntime.watch(ref)
 
+export const prepare = internalProcess.prepare
+
 export const start: <
   const States extends Machine.StateSchemas,
   const Events extends ReadonlyArray<Machine.TaggedSchema>,

package/src/internal/machine/process.ts

@@ -825,6 +825,18 @@ export const startWithRuntimeStrategyForTesting = (
     machine.id === undefined ? undefined : { id: machine.id }
   )
 
+/** @internal Test-only prepared startup strategy selection for a fresh machine. */
+export const prepareWithRuntimeStrategyForTesting = (
+  machine: Machine.Any,
+  strategy: internalRuntime.ProcessRuntimeStrategy,
+  ...args: ReadonlyArray<unknown>
+): Effect.Effect<internalRuntime.PreparedProcess<any, any, any, any, any, any, any>, any, any> =>
+  internalRuntime.prepareProcessWithStrategyForTesting(
+    (toProcessLogic as any)(machine, ...args),
+    strategy,
+    machine.id === undefined ? undefined : { id: machine.id }
+  )
+
 /** @internal Test-only runtime strategy selection for a resumed machine. */
 export const resumeWithRuntimeStrategyForTesting = (
   machine: Machine.Any,
@@ -881,6 +893,51 @@ export const start: <
     machine.id === undefined ? undefined : { id: machine.id }
   ) as any
 
+export const prepare: <
+  const States extends Machine.StateSchemas,
+  const Events extends ReadonlyArray<Machine.TaggedSchema>,
+  const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
+  const Input extends Schema.Top = typeof Schema.Void,
+  UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>,
+  E = never,
+  R = never,
+  InitialE = never,
+  InitialR = never,
+  FinalStates extends Machine.StateIdentifier<States> = never,
+  Output = never
+>(
+  machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits>,
+  ...args: [...Machine.InputArgs<Input>]
+) => Effect.Effect<
+  internalRuntime.PreparedProcess<
+    Machine.Snapshot<States>,
+    Machine.EventOf<Events>,
+    | E
+    | ActionError<R>
+    | InfiniteTransitionError
+    | MachineSchemaDecodeError
+    | StoppedError,
+    Output,
+    Machine.EmittedEventOf<Emits>,
+    | InitialE
+    | E
+    | ActionError<InitialR | R>
+    | InfiniteTransitionError
+    | MachineSchemaDecodeError
+    | StartupError
+    | StoppedError,
+    ExcludeCompatibleRuntime<
+      Exclude<ExecutionServices<InitialR | R>, internalRuntime.MachineRuntime>,
+      Machine.EventOf<Events>,
+      Machine.EmitOf<Emits>
+    >
+  >
+> = (machine, ...args) =>
+  internalRuntime.prepareProcess(
+    toProcessLogic(machine, ...args),
+    machine.id === undefined ? undefined : { id: machine.id }
+  ) as any
+
 export const resume: <
   const States extends Machine.StateSchemas,
   const Events extends ReadonlyArray<Machine.TaggedSchema>,

package/src/internal/machine/runtime.ts

@@ -302,6 +302,22 @@ export interface MachineRef<out State, in Event, out Error = never, out Output =
   readonly childChanges: (child: any) => Stream.Stream<Option.Option<any>>
 }
 
+export interface PreparedProcess<
+  out State,
+  in Event,
+  out Error,
+  out Output,
+  out Emitted,
+  out StartError,
+  StartRequirements
+> {
+  readonly id: string
+  readonly sessionId: string
+  readonly changes: Stream.Stream<RuntimeSnapshot<State, Error, Output>, StartError>
+  readonly emissions: Stream.Stream<Emitted>
+  readonly start: Effect.Effect<MachineRef<State, Event, Error, Output, Emitted>, StartError, StartRequirements>
+}
+
 interface ProcessAddress<in Event> {
   readonly id: string
   readonly sessionId: string
@@ -609,6 +625,8 @@ const makeProcessRuntime: Effect.Effect<ProcessRuntime> = Effect.sync(() => {
 interface StartInternalOptions {
   readonly detached?: boolean
   readonly id?: string
+  readonly sessionId?: string
+  readonly emissions?: EmissionRuntime
   readonly onOutcome?: (outcome: RuntimeOutcome<any, any, any>) => Effect.Effect<void>
   readonly onSnapshot?: (
     snapshot: Extract<RuntimeSnapshot<any, any, any>, { readonly status: "active" }>
@@ -802,6 +820,54 @@ const EmissionsClosed: unique symbol = Symbol("effect/Machine/EmissionsClosed")
 
 type LazyEmissions = PubSub.PubSub<unknown> | typeof EmissionsClosed | undefined
 
+interface EmissionRuntime {
+  readonly emit: (event: unknown) => Effect.Effect<void>
+  readonly close: () => Effect.Effect<void>
+  readonly stream: Stream.Stream<unknown>
+}
+
+const makeEmissionRuntime = (): EmissionRuntime => {
+  let emissions: LazyEmissions
+  const getOrCreate: Effect.Effect<PubSub.PubSub<unknown> | undefined> = Effect.suspend(() => {
+    const observed = emissions
+    if (observed === EmissionsClosed) return Effect.succeed(undefined)
+    if (observed !== undefined) return Effect.succeed(observed)
+    return PubSub.unbounded<unknown>().pipe(
+      Effect.flatMap((candidate) =>
+        Effect.sync(() => {
+          const latest = emissions
+          if (latest === EmissionsClosed) return [undefined, true] as const
+          if (latest !== undefined) return [latest, true] as const
+          emissions = candidate
+          return [candidate, false] as const
+        }).pipe(
+          Effect.flatMap(([selected, discard]) =>
+            discard ? PubSub.shutdown(candidate).pipe(Effect.as(selected)) : Effect.succeed(selected)
+          )
+        )
+      )
+    )
+  })
+  return {
+    emit: (event) =>
+      Effect.suspend(() =>
+        emissions === undefined || emissions === EmissionsClosed
+          ? Effect.void
+          : PubSub.publish(emissions, event).pipe(Effect.asVoid)
+      ),
+    close: () => {
+      const observed = emissions
+      emissions = EmissionsClosed
+      return observed === undefined || observed === EmissionsClosed ? Effect.void : PubSub.shutdown(observed)
+    },
+    stream: Stream.unwrap(
+      getOrCreate.pipe(
+        Effect.map((emissions) => emissions === undefined ? Stream.empty : Stream.fromPubSub(emissions))
+      )
+    )
+  }
+}
+
 const childlessRuntime: ChildRuntime = {
   close: () => Effect.void,
   spawn: (() => Effect.die(new Error("Childless machine logic cannot spawn a process"))) as ProcessSpawn,
@@ -1104,41 +1170,10 @@ const startGenericInternal: <
     | { readonly _tag: "Done"; readonly output: Output }
     | { readonly _tag: "Failure"; readonly cause: Cause.Cause<Error> }
 
-  const sessionId = yield* runtime.nextSessionId
+  const sessionId = options.sessionId ?? (yield* runtime.nextSessionId)
   const id = requestedId ?? sessionId
   const queue = yield* Queue.unbounded<ProcessMessage<Event>>()
-  let emissions: LazyEmissions
-  const getOrCreateEmissions: Effect.Effect<PubSub.PubSub<unknown> | undefined> = Effect.suspend(() => {
-    const observed = emissions
-    if (observed === EmissionsClosed) return Effect.succeed(undefined)
-    if (observed !== undefined) return Effect.succeed(observed)
-    return PubSub.unbounded<unknown>().pipe(
-      Effect.flatMap((candidate) =>
-        Effect.sync(() => {
-          const latest = emissions
-          if (latest === EmissionsClosed) return [undefined, true] as const
-          if (latest !== undefined) return [latest, true] as const
-          emissions = candidate
-          return [candidate, false] as const
-        }).pipe(
-          Effect.flatMap(([selected, discard]) =>
-            discard ? PubSub.shutdown(candidate).pipe(Effect.as(selected)) : Effect.succeed(selected)
-          )
-        )
-      )
-    )
-  })
-  const closeEmissions = (): Effect.Effect<void> => {
-    const observed = emissions
-    emissions = EmissionsClosed
-    return observed === undefined || observed === EmissionsClosed ? Effect.void : PubSub.shutdown(observed)
-  }
-  const emit = (event: unknown): Effect.Effect<void> =>
-    Effect.suspend(() =>
-      emissions === undefined || emissions === EmissionsClosed
-        ? Effect.void
-        : PubSub.publish(emissions, event).pipe(Effect.asVoid)
-    )
+  const emissions = options.emissions ?? makeEmissionRuntime()
   const termination = yield* Deferred.make<ProcessTermination>()
   const done = yield* Deferred.make<Output, Error | StoppedError>()
   const awaitCompletion = Deferred.await(done).pipe(Effect.exit, Effect.asVoid)
@@ -1209,7 +1244,7 @@ const startGenericInternal: <
   }
   const cleanupStartupFailure = <A, E>(exit: Exit.Exit<A, E>): Effect.Effect<void> =>
     Exit.isFailure(exit)
-      ? closeChildren(exit).pipe(Effect.andThen(closeEmissions()))
+      ? closeChildren(exit).pipe(Effect.andThen(emissions.close()))
       : Effect.void
   const cleanup = onStopSync === undefined ? onStop ?? Effect.void : Effect.sync(onStopSync)
   const sendParent = overrideSendParent ?? (parent === undefined ? noParentSend : parent.send)
@@ -1219,7 +1254,7 @@ const startGenericInternal: <
     parent,
     spawn,
     sendParent,
-    emit,
+    emit: emissions.emit,
     sendTo: ((target: unknown, event: unknown) =>
       isProcessAddress(target) ? target.send(event) : sendTo(target as ChildSelector, event)) as ProcessScope<
         Event
@@ -1402,7 +1437,7 @@ const startGenericInternal: <
         Effect.andThen(Queue.shutdown(queue)),
         Effect.andThen(closeChildren(exit)),
         Effect.andThen(setAndPublishSnapshot(snapshot)),
-        Effect.andThen(closeEmissions()),
+        Effect.andThen(emissions.close()),
         Effect.andThen(Effect.sync(() => {
           if (Exit.isFailure(exit)) {
             failAcknowledgedMessage(inFlightMessage, exit.cause)
@@ -1559,11 +1594,7 @@ const startGenericInternal: <
     state: SynchronizedRef.get(current).pipe(Effect.map((current) => current.snapshot.state)),
     snapshot: SynchronizedRef.get(current).pipe(Effect.map((current) => current.snapshot)),
     changes: changesStream,
-    emissions: Stream.unwrap(
-      getOrCreateEmissions.pipe(
-        Effect.map((emissions) => emissions === undefined ? Stream.empty : Stream.fromPubSub(emissions))
-      )
-    ) as Stream.Stream<never>,
+    emissions: emissions.stream as Stream.Stream<never>,
     join: Deferred.await(done),
     stop,
     send: self.send,
@@ -1717,6 +1748,7 @@ class CompiledProcess implements MachineRef<any, any, any, any> {
   private interruptRequested = false
   private offerRevision = 0
   private inFlightMessage: ProcessMessage<unknown> | undefined
+  private readonly externalEmissions: EmissionRuntime | undefined
   private emissionsPubSub: LazyEmissions
 
   constructor(
@@ -1727,6 +1759,7 @@ class CompiledProcess implements MachineRef<any, any, any, any> {
   ) {
     this.sessionId = sessionId
     this.id = options.id ?? sessionId
+    this.externalEmissions = options.emissions
     this.send = (event) => this.offerMessage(event)
     this.address = {
       id: this.id,
@@ -1908,7 +1941,7 @@ class CompiledProcess implements MachineRef<any, any, any, any> {
   }
 
   get emissions(): Stream.Stream<never> {
-    return this.emissionsStream() as Stream.Stream<never>
+    return (this.externalEmissions?.stream ?? this.emissionsStream()) as Stream.Stream<never>
   }
 
   get join(): Effect.Effect<unknown, unknown> {
@@ -2268,6 +2301,7 @@ class CompiledProcess implements MachineRef<any, any, any, any> {
   }
 
   private emitEvent(event: unknown): Effect.Effect<void> {
+    if (this.externalEmissions !== undefined) return this.externalEmissions.emit(event)
     return Effect.suspend(() =>
       this.emissionsPubSub === undefined || this.emissionsPubSub === EmissionsClosed
         ? Effect.void
@@ -2280,6 +2314,7 @@ class CompiledProcess implements MachineRef<any, any, any, any> {
   }
 
   private closeEmissions(): Effect.Effect<void> {
+    if (this.externalEmissions !== undefined) return this.externalEmissions.close()
     const observed = this.emissionsPubSub
     this.emissionsPubSub = EmissionsClosed
     return observed === undefined || observed === EmissionsClosed ? Effect.void : PubSub.shutdown(observed)
@@ -2523,7 +2558,7 @@ const startCompactCompiledInternal: typeof startGenericInternal = Effect.fnUntra
   logic: ProcessLogic<any, any, any, any, any, any>,
   options: StartInternalOptions
 ) {
-  const sessionId = yield* options.runtime.nextSessionId
+  const sessionId = options.sessionId ?? (yield* options.runtime.nextSessionId)
   const services = yield* Effect.context<any>()
   const execution = logic.execution as CompiledProcessExecution<any, any, any, any, any, any>
   const process = new CompiledProcess(logic, options, services, sessionId)
@@ -2636,3 +2671,97 @@ export const startProcess: <
       }
   )
 })
+
+const prepareProcessWithStrategy = Effect.fnUntraced(function*<
+  State,
+  Event,
+  Error,
+  Requirements,
+  Output,
+  InitialError,
+  Emitted
+>(
+  logic: ProcessLogic<State, Event, Error, Requirements, Output, InitialError>,
+  strategy: ProcessRuntimeStrategy,
+  options?: {
+    readonly id?: string
+  }
+) {
+  const runtime = yield* makeProcessRuntime
+  const sessionId = yield* runtime.nextSessionId
+  const emissions = makeEmissionRuntime()
+  const started = yield* Deferred.make<MachineRef<State, Event, Error, Output, Emitted>, InitialError>()
+  const internalOptions: StartInternalOptions = options === undefined
+    ? {
+      detached: true,
+      emissions,
+      runtime,
+      sessionId
+    }
+    : {
+      ...options,
+      detached: true,
+      emissions,
+      runtime,
+      sessionId
+    }
+  const initialize = strategy === "generic"
+    ? startGenericInternal(logic, internalOptions)
+    : strategy === "compiled"
+    ? logic.execution?._tag === "Compiled"
+      ? startCompactCompiledInternal(logic, internalOptions)
+      : Effect.die(new Error("Machine cannot force the compiled runtime for generic process logic"))
+    : startLogicInternal(logic, internalOptions)
+  const start = yield* Effect.cached(
+    initialize.pipe(
+      Effect.onExit((exit) => Deferred.done(started, exit))
+    ) as Effect.Effect<MachineRef<State, Event, Error, Output, Emitted>, InitialError, Requirements>
+  )
+  return {
+    id: options?.id ?? sessionId,
+    sessionId,
+    changes: Stream.unwrap(
+      Deferred.await(started).pipe(Effect.map((ref) => ref.changes))
+    ),
+    emissions: emissions.stream as Stream.Stream<Emitted>,
+    start
+  }
+})
+
+export const prepareProcess: <
+  State,
+  Event,
+  Error = never,
+  Requirements = never,
+  Output = never,
+  InitialError = never,
+  Emitted = never
+>(
+  logic: ProcessLogic<State, Event, Error, Requirements, Output, InitialError>,
+  options?: {
+    readonly id?: string
+  }
+) => Effect.Effect<
+  PreparedProcess<State, Event, Error, Output, Emitted, InitialError, Requirements>
+> =
+  ((logic: ProcessLogic<any, any, any, any, any, any>, options?: { readonly id?: string }) =>
+    prepareProcessWithStrategy(logic, "auto", options)) as any
+
+/** @internal Test-only prepared startup strategy selection. */
+export const prepareProcessWithStrategyForTesting = <
+  State,
+  Event,
+  Error = never,
+  Requirements = never,
+  Output = never,
+  InitialError = never,
+  Emitted = never
+>(
+  logic: ProcessLogic<State, Event, Error, Requirements, Output, InitialError>,
+  strategy: ProcessRuntimeStrategy,
+  options?: {
+    readonly id?: string
+  }
+): Effect.Effect<
+  PreparedProcess<State, Event, Error, Output, Emitted, InitialError, Requirements>
+> => prepareProcessWithStrategy(logic, strategy, options) as any

package/src/unstable/reactivity/AtomMachine.ts

@@ -167,8 +167,10 @@ type RefOutput<Ref> = Ref extends Machine.MachineRef<any, any, any, infer Output
 type RefEmitted<Ref> = Ref extends Machine.MachineRef<any, any, any, any, infer Emitted> ? Emitted : never
 
 /**
- * Observes ephemeral notifications from the actor owned by a machine atom.
- * The stream requires an `AtomRegistry` and does not replay earlier emissions.
+ * Observes ephemeral notifications from the running machine owned by a machine
+ * atom. When this stream activates a fresh bridge, it subscribes before machine
+ * initialization and observes initial-entry emissions. It never replays
+ * emissions from a machine that was already running.
  *
  * @category getters
  * @since 0.10.0