Function boot

packages/experimental/src/Machine.ts:470–835

(
  self: M,
  ...[input, options]: [Machine.Input<M>] extends [void] ? [
      input?: Machine.Input<M>,
      options?: { readonly previousState?: Machine.State<M> }
    ] :
    [
      input: Machine.Input<M>,
      options?: { readonly previousState?: Machine.State<M> }
    ]
)

 * @category runtime
 */
export const boot = <
  M extends Machine.Any
>(
  self: M,
  ...[input, options]: [Machine.Input<M>] extends [void] ? [
      input?: Machine.Input<M>,
      options?: { readonly previousState?: Machine.State<M> }
    ] :
    [
      input: Machine.Input<M>,
      options?: { readonly previousState?: Machine.State<M> }
    ]
): Effect.Effect<
  M extends { readonly [SerializableTypeId]: SerializableTypeId } ? SerializableActor<M> : Actor<M>,
  never,
  Machine.Context<M> | Scope.Scope
> =>
  Effect.gen(function*() {
    const context = yield* Effect.context<Machine.Context<M>>()
    const requests = yield* Queue.unbounded<
      readonly [
        Procedure.TaggedRequest.Any,
        Deferred.Deferred<any, any>,
        Tracer.AnySpan | undefined,
        addSpans: boolean
      ]
    >()
    const pubsub = yield* Effect.acquireRelease(
      PubSub.unbounded<Machine.State<M>>(),
      PubSub.shutdown
    )
    const latch = yield* Deferred.make<void>()

    let currentState: Machine.State<M> = undefined as any
    let runState: {
      readonly identifier: string
      readonly publicTags: Set<string>
      readonly decodeRequest: (u: unknown) => Effect.Effect<Machine.Public<M>, ParseResult.ParseError>
    } = {
      identifier: "Unknown",
      publicTags: new Set<string>(),
      decodeRequest: undefined as any
    }

    const requestContext = <R extends Machine.Public<M>>(request: R) =>
      Effect.sync(() => {
        const fiber = Option.getOrThrow(Fiber.getCurrentFiber())
        const fiberRefs = fiber.getFiberRefs()
        const context = FiberRefs.getOrDefault(fiberRefs, FiberRef.currentContext)

        const deferred = Deferred.unsafeMake<Request.Success<R>, Request.Error<R>>(fiber.id())
        const span: Tracer.AnySpan | undefined = context.unsafeMap.get(Tracer.ParentSpan.key)
        const addSpans = FiberRefs.getOrDefault(fiberRefs, currentTracingEnabled)

        return [request, deferred, span, addSpans] as const
      })

    const send = <R extends Machine.Public<M>>(request: R) =>