xstate 6.0.0-alpha.47 → 6.0.0-alpha.49

package/dist/index-70d56425.development.esm.js

@@ -1,937 +0,0 @@
-import { K as createInitEvent, e as XSTATE_STOP, L as createCustomEffect, M as XSTATE_LOGIC_EFFECT_START, N as XSTATE_LOGIC_EFFECT_RESOLVE, O as XSTATE_LOGIC_EFFECT_REJECT, f as finalizeTransitionResult, P as createEmitEffect, h as createSendToEffect, X as XSTATE_INIT, p as parseDelayToMilliseconds, H as runStep, k as createActor } from './createActor-ff132afa.development.esm.js';
-
-function assertValid(validator, request) {
-  const error = validator.check(request);
-  if (error) {
-    throw error;
-  }
-}
-
-const effectStates = new WeakMap();
-function getEffectState(self) {
-  let state = effectStates.get(self);
-  if (!state) {
-    state = new Map();
-    effectStates.set(self, state);
-  }
-  return state;
-}
-function executeLogicEffect(self, key, effect) {
-  const state = getEffectState(self);
-  if (key !== undefined && state.has(key)) {
-    return;
-  }
-  const cleanup = effect();
-  state.set(key ?? Symbol(), {
-    cleanup: typeof cleanup === 'function' ? cleanup : undefined
-  });
-}
-function cleanupLogicEffects(self) {
-  const state = effectStates.get(self);
-  if (!state) {
-    return;
-  }
-  for (const {
-    cleanup
-  } of state.values()) {
-    cleanup?.();
-  }
-  effectStates.delete(self);
-}
-function resolveContext(context, input) {
-  return typeof context === 'function' ? context({
-    input
-  }) : context;
-}
-function createLogic(config) {
-  const calculateTransition = (snapshot, event, actorScope) => {
-    if (snapshot.status !== 'active') {
-      return [snapshot, []];
-    }
-    if (event.type === XSTATE_STOP) {
-      return [{
-        ...snapshot,
-        status: 'stopped',
-        input: undefined
-      }, [createCustomEffect('xstate.logic.cleanup', () => cleanupLogicEffects(actorScope.self))]];
-    }
-    if (event.type === XSTATE_LOGIC_EFFECT_START) {
-      return [{
-        ...snapshot,
-        effects: {
-          ...snapshot.effects,
-          [event.key]: {
-            status: 'active'
-          }
-        }
-      }, []];
-    }
-    if (event.type === XSTATE_LOGIC_EFFECT_RESOLVE) {
-      return [{
-        ...snapshot,
-        effects: {
-          ...snapshot.effects,
-          [event.key]: {
-            status: 'done',
-            output: event.output
-          }
-        }
-      }, []];
-    }
-    if (event.type === XSTATE_LOGIC_EFFECT_REJECT) {
-      return [{
-        ...snapshot,
-        effects: {
-          ...snapshot.effects,
-          [event.key]: {
-            status: 'error',
-            error: event.error
-          }
-        }
-      }, []];
-    }
-    const effects = [];
-    const trackedEffects = {};
-    const enqueueEffect = (key, exec) => {
-      if (snapshot.effects?.[key]) {
-        return;
-      }
-      effects.push(createCustomEffect('xstate.logic.effect', (runtime = actorScope.self.system) => executeLogicEffect(actorScope.self, key, () => exec(runtime)), {
-        key
-      }));
-      trackedEffects[key] = {
-        status: 'active'
-      };
-    };
-    const enq = {
-      emit: emitted => {
-        effects.push(createEmitEffect(actorScope, emitted));
-      },
-      sendBack: sentEvent => {
-        const parent = actorScope.self._parent;
-        if (parent) {
-          effects.push(createSendToEffect(actorScope, parent, sentEvent));
-        }
-      },
-      raise: raisedEvent => {
-        effects.push(createSendToEffect(actorScope, actorScope.self, raisedEvent));
-      },
-      effect: (keyOrExec, maybeExec) => {
-        if (typeof keyOrExec === 'string') {
-          enqueueEffect(keyOrExec, maybeExec);
-          return;
-        }
-        const exec = keyOrExec;
-        effects.push(createCustomEffect('xstate.logic.effect', (runtime = actorScope.self.system) => executeLogicEffect(actorScope.self, undefined, () => exec(runtime))));
-      }
-    };
-    const patch = config.run({
-      context: snapshot.context,
-      event,
-      input: snapshot.input,
-      system: actorScope.system,
-      self: actorScope.self,
-      emit: actorScope.emit
-    }, enq);
-    const nextSnapshot = {
-      ...snapshot,
-      ...(patch || {})
-    };
-    if ('context' in snapshot || patch?.context !== undefined) {
-      nextSnapshot.context = patch?.context ?? snapshot.context;
-    }
-    if (patch?.effects || Object.keys(trackedEffects).length) {
-      nextSnapshot.effects = {
-        ...snapshot.effects,
-        ...patch?.effects,
-        ...trackedEffects
-      };
-    }
-    return finalizeTransitionResult(actorScope, snapshot, [nextSnapshot, effects]);
-  };
-  const transition = (snapshot, event, actorScope) => {
-    if (config.validator) {
-      assertValid(config.validator, {
-        kind: 'event',
-        logic,
-        event,
-        eventOrigin: actorScope.self._lastSourceRef ? 'actor' : 'external'
-      });
-    }
-    const result = calculateTransition(snapshot, event, actorScope);
-    if (config.validator) {
-      assertValid(config.validator, {
-        kind: 'result',
-        logic,
-        snapshot: result[0],
-        effects: result[1]
-      });
-    }
-    return result;
-  };
-  const logic = {
-    id: config.id,
-    config,
-    validator: config.validator,
-    transition,
-    start: (snapshot, actorScope, options) => {
-      if (!options?.restored) {
-        return;
-      }
-      const [nextSnapshot, effects] = transition(snapshot, createInitEvent(snapshot.input), actorScope);
-      Object.assign(snapshot, nextSnapshot);
-      for (const effect of effects) {
-        actorScope.actionExecutor(effect);
-      }
-    },
-    initialTransition: (input, actorScope) => {
-      if (config.validator) {
-        assertValid(config.validator, {
-          kind: 'input',
-          logic,
-          input
-        });
-      }
-      const context = resolveContext(config.context, input);
-      const snapshot = {
-        status: 'active',
-        output: undefined,
-        error: undefined,
-        input
-      };
-      if (context !== undefined) {
-        snapshot.context = context;
-      }
-      return transition({
-        ...snapshot
-      }, createInitEvent(input), actorScope);
-    },
-    getInitialSnapshot: (actorScope, input) => logic.initialTransition(input, actorScope)[0],
-    getPersistedSnapshot: snapshot => snapshot,
-    restoreSnapshot: snapshot => snapshot
-  };
-  return logic;
-}
-
-const instanceStates = /* #__PURE__ */new WeakMap();
-
-/**
- * Represents an actor created by `createCallbackLogic`.
- *
- * The type of `self` within the actor's logic.
- *
- * @example
- *
- * ```ts
- * import { createCallbackLogic, createActor } from 'xstate';
- *
- * // The events the actor receives.
- * type Event = { type: 'someEvent' };
- * // The actor's input.
- * type Input = { name: string };
- *
- * // Actor logic that logs whenever it receives an event of type `someEvent`.
- * const logic = createCallbackLogic<Event, Input>(
- *   ({ self, input, receive }) => {
- *     self;
- *     // ^? CallbackActorRef<Event, Input>
- *
- *     receive((event) => {
- *       if (event.type === 'someEvent') {
- *         console.log(`${input.name}: received "someEvent" event`);
- *         // logs 'myActor: received "someEvent" event'
- *       }
- *     });
- *   }
- * );
- *
- * const actor = createActor(logic, { input: { name: 'myActor' } });
- * //    ^? CallbackActorRef<Event, Input>
- * ```
- *
- * @see {@link createCallbackLogic}
- */
-
-/**
- * An actor logic creator which returns callback logic as defined by a callback
- * function.
- *
- * @remarks
- * Useful for subscription-based or other free-form logic that can send events
- * back to the parent actor.
- *
- * Actors created from callback logic (“callback actors”) can:
- *
- * - Receive events via the `receive` function
- * - Send events to the parent actor via the `sendBack` function
- *
- * Callback actors are a bit different from other actors in that they:
- *
- * - Do not work with `onDone`
- * - Do not produce a snapshot using `.getSnapshot()`
- * - Do not emit values when used with `.subscribe()`
- * - Can not be stopped with `.stop()`
- *
- * @example
- *
- * ```typescript
- * const callbackLogic = createCallbackLogic(({ sendBack, receive }) => {
- *   let lockStatus = 'unlocked';
- *
- *   const handler = (event) => {
- *     if (lockStatus === 'locked') {
- *       return;
- *     }
- *     sendBack(event);
- *   };
- *
- *   receive((event) => {
- *     if (event.type === 'lock') {
- *       lockStatus = 'locked';
- *     } else if (event.type === 'unlock') {
- *       lockStatus = 'unlocked';
- *     }
- *   });
- *
- *   document.body.addEventListener('click', handler);
- *
- *   return () => {
- *     document.body.removeEventListener('click', handler);
- *   };
- * });
- * ```
- *
- * @param callback - The callback function used to describe the callback logic
- *   The callback function is passed an object with the following properties:
- *
- *   - `receive` - A function that can send events back to the parent actor; the
- *       listener is then called whenever events are received by the callback
- *       actor
- *   - `sendBack` - A function that can send events back to the parent actor
- *   - `input` - Data that was provided to the callback actor
- *   - `self` - The parent actor of the callback actor
- *   - `system` - The actor system to which the callback actor belongs The callback
- *       function can (optionally) return a cleanup function, which is called
- *       when the actor is stopped.
- *
- * @returns Callback logic
- * @see {@link CallbackLogicFunction} for more information about the callback function and its object argument
- * @see {@link https://stately.ai/docs/input | Input docs} for more information about how input is passed
- */
-
-function createCallbackLogic(callbackOrConfig) {
-  const callback = typeof callbackOrConfig === 'function' ? callbackOrConfig : callbackOrConfig.run;
-  const schemas = typeof callbackOrConfig === 'function' ? undefined : callbackOrConfig.schemas;
-  const validator = typeof callbackOrConfig === 'function' ? undefined : callbackOrConfig.validator;
-  return createLogic({
-    validator,
-    schemas,
-    context: undefined,
-    run: (args, enq) => {
-      const {
-        event,
-        input,
-        self,
-        system
-      } = args;
-      const emit = args.emit;
-      const callbackState = instanceStates.get(self);
-      callbackState?.receivers?.forEach(receiver => receiver(event));
-      enq.effect('callback', () => {
-        const callbackState = {
-          receivers: undefined,
-          dispose: undefined
-        };
-        instanceStates.set(self, callbackState);
-        callbackState.dispose = callback({
-          input,
-          system,
-          self: self,
-          sendBack: event => {
-            if (self.getSnapshot().status === 'stopped') {
-              return;
-            }
-            const parent = self._parent;
-            if (parent) {
-              system._relay(self, parent, event);
-            }
-          },
-          receive: listener => {
-            callbackState.receivers ??= new Set();
-            callbackState.receivers.add(listener);
-          },
-          emit: emit
-        });
-        return () => {
-          instanceStates.delete(self);
-          callbackState.receivers?.clear();
-          callbackState.dispose?.();
-        };
-      });
-    }
-  });
-}
-
-const XSTATE_OBSERVABLE_NEXT = 'xstate.observable.next';
-const XSTATE_OBSERVABLE_ERROR = 'xstate.observable.error';
-const XSTATE_OBSERVABLE_COMPLETE = 'xstate.observable.complete';
-
-/**
- * Represents an actor created by `createObservableLogic` or
- * `createEventObservableLogic`.
- *
- * The type of `self` within the actor's logic.
- *
- * @example
- *
- * ```ts
- * import { createObservableLogic, createActor } from 'xstate';
- * import { interval } from 'rxjs';
- *
- * // The type of the value observed by the actor's logic.
- * type Context = number;
- * // The actor's input.
- * type Input = { period?: number };
- *
- * // Actor logic that observes a number incremented every `input.period`
- * // milliseconds (default: 1_000).
- * const logic = createObservableLogic<Context, Input>(
- *   ({ input, self }) => {
- *     self;
- *     // ^? ObservableActor<Event, Input>
- *
- *     return interval(input.period ?? 1_000);
- *   }
- * );
- *
- * const actor = createActor(logic, { input: { period: 2_000 } });
- * //    ^? ObservableActor<Event, Input>
- * ```
- *
- * @see {@link createObservableLogic}
- * @see {@link createEventObservableLogic}
- */
-
-/**
- * Observable actor logic is described by an observable stream of values. Actors
- * created from observable logic (“observable actors”) can:
- *
- * - Emit snapshots of the observable’s emitted value
- *
- * The observable’s emitted value is used as its observable actor’s `context`.
- *
- * Sending events to observable actors will have no effect.
- *
- * @example
- *
- * ```ts
- * import { createObservableLogic, createActor } from 'xstate';
- * import { interval } from 'rxjs';
- *
- * const logic = createObservableLogic((obj) => interval(1000));
- *
- * const actor = createActor(logic);
- *
- * actor.subscribe((snapshot) => {
- *   console.log(snapshot.context);
- * });
- *
- * actor.start();
- * // At every second:
- * // Logs 0
- * // Logs 1
- * // Logs 2
- * // ...
- * ```
- *
- * @param observableCreator A function that creates an observable. It receives
- *   one argument, an object with the following properties:
- *
- *   - `input` - Data that was provided to the observable actor
- *   - `self` - The parent actor
- *   - `system` - The actor system to which the observable actor belongs
- *
- *   It should return a {@link Subscribable}, which is compatible with an RxJS
- *   Observable, although RxJS is not required to create them.
- * @see {@link https://rxjs.dev} for documentation on RxJS Observable and observable creators.
- * @see {@link Subscribable} interface in XState, which is based on and compatible with RxJS Observable.
- */
-
-function createObservableLogic(observableCreatorOrConfig) {
-  const observableCreator = typeof observableCreatorOrConfig === 'function' ? observableCreatorOrConfig : observableCreatorOrConfig.run;
-  const schemas = typeof observableCreatorOrConfig === 'function' ? undefined : observableCreatorOrConfig.schemas;
-  const validator = typeof observableCreatorOrConfig === 'function' ? undefined : observableCreatorOrConfig.validator;
-  return createLogic({
-    validator,
-    schemas,
-    context: undefined,
-    run: (args, enq) => {
-      const {
-        event,
-        input,
-        self,
-        system
-      } = args;
-      switch (event.type) {
-        case XSTATE_OBSERVABLE_NEXT:
-          {
-            return {
-              context: event.data
-            };
-          }
-        case XSTATE_OBSERVABLE_ERROR:
-          return {
-            status: 'error',
-            error: event.data,
-            input: undefined,
-            effects: {
-              observable: {
-                status: 'error',
-                error: event.data
-              }
-            }
-          };
-        case XSTATE_OBSERVABLE_COMPLETE:
-          return {
-            status: 'done',
-            input: undefined,
-            effects: {
-              observable: {
-                status: 'done'
-              }
-            }
-          };
-      }
-      if (event.type !== XSTATE_INIT) {
-        return;
-      }
-      enq.effect((runtime = system) => {
-        const actorSelf = self;
-        const sendSelf = event => void runtime.sendEvent(actorSelf, actorSelf, event);
-        const subscription = observableCreator({
-          input,
-          system,
-          self: self,
-          emit: event => void runtime.emitEvent(actorSelf, event)
-        }).subscribe({
-          next: value => {
-            sendSelf({
-              type: XSTATE_OBSERVABLE_NEXT,
-              data: value
-            });
-          },
-          error: err => {
-            sendSelf({
-              type: XSTATE_OBSERVABLE_ERROR,
-              data: err
-            });
-          },
-          complete: () => {
-            sendSelf({
-              type: XSTATE_OBSERVABLE_COMPLETE
-            });
-          }
-        });
-        return () => subscription.unsubscribe();
-      });
-    }
-  });
-}
-
-/**
- * Creates event observable logic that listens to an observable that delivers
- * event objects.
- *
- * Event observable actor logic is described by an observable stream of
- * {@link https://stately.ai/docs/transitions#event-objects | event objects}.
- * Actors created from event observable logic (“event observable actors”) can:
- *
- * - Implicitly send events to its parent actor
- * - Emit snapshots of its emitted event objects
- *
- * Sending events to event observable actors will have no effect.
- *
- * @example
- *
- * ```ts
- * import {
- *   createEventObservableLogic,
- *   Subscribable,
- *   EventObject,
- *   createMachine,
- *   createActor
- * } from 'xstate';
- * import { fromEvent } from 'rxjs';
- *
- * const mouseClickLogic = createEventObservableLogic(
- *   () => fromEvent(document.body, 'click') as Subscribable<EventObject>
- * );
- *
- * const canvasMachine = createMachine({
- *   invoke: {
- *     // Will send mouse `click` events to the canvas actor
- *     src: mouseClickLogic
- *   }
- * });
- *
- * const canvasActor = createActor(canvasMachine);
- * canvasActor.start();
- * ```
- *
- * @param lazyObservable A function that creates an observable that delivers
- *   event objects. It receives one argument, an object with the following
- *   properties:
- *
- *   - `input` - Data that was provided to the event observable actor
- *   - `self` - The parent actor
- *   - `system` - The actor system to which the event observable actor belongs.
- *
- *   It should return a {@link Subscribable}, which is compatible with an RxJS
- *   Observable, although RxJS is not required to create them.
- */
-
-function createEventObservableLogic(lazyObservableOrConfig) {
-  const lazyObservable = typeof lazyObservableOrConfig === 'function' ? lazyObservableOrConfig : lazyObservableOrConfig.run;
-  const validator = typeof lazyObservableOrConfig === 'function' ? undefined : lazyObservableOrConfig.validator;
-
-  // TODO: event types
-  const logic = {
-    config: lazyObservableOrConfig,
-    validator,
-    transition: (state, event, actorScope) => {
-      if (state.status !== 'active') {
-        return [state, []];
-      }
-      switch (event.type) {
-        case XSTATE_OBSERVABLE_ERROR:
-          return finalizeTransitionResult(actorScope, state, [{
-            ...state,
-            status: 'error',
-            error: event.data,
-            input: undefined,
-            _subscription: undefined
-          }, []]);
-        case XSTATE_OBSERVABLE_COMPLETE:
-          return finalizeTransitionResult(actorScope, state, [{
-            ...state,
-            status: 'done',
-            input: undefined,
-            _subscription: undefined
-          }, []]);
-        case XSTATE_STOP:
-          state._subscription.unsubscribe();
-          return [{
-            ...state,
-            status: 'stopped',
-            input: undefined,
-            _subscription: undefined
-          }, []];
-        default:
-          return [state, []];
-      }
-    },
-    initialTransition: (input, _) => {
-      if (validator) {
-        assertValid(validator, {
-          kind: 'input',
-          logic,
-          input
-        });
-      }
-      const snapshot = {
-        status: 'active',
-        output: undefined,
-        error: undefined,
-        context: undefined,
-        input,
-        _subscription: undefined
-      };
-      return [snapshot, []];
-    },
-    getInitialSnapshot: (actorScope, input) => logic.initialTransition(input, actorScope)[0],
-    start: (state, {
-      self,
-      system,
-      emit
-    }) => {
-      if (state.status === 'done') {
-        // Do not restart a completed observable
-        return;
-      }
-      state._subscription = lazyObservable({
-        input: state.input,
-        system,
-        self,
-        emit: event => {
-          void emit(event);
-        }
-      }).subscribe({
-        next: value => {
-          if (self._parent) {
-            system._relay(self, self._parent, value);
-          }
-        },
-        error: err => {
-          system._relay(self, self, {
-            type: XSTATE_OBSERVABLE_ERROR,
-            data: err
-          });
-        },
-        complete: () => {
-          system._relay(self, self, {
-            type: XSTATE_OBSERVABLE_COMPLETE
-          });
-        }
-      });
-    },
-    getPersistedSnapshot: ({
-      _subscription,
-      ...snapshot
-    }) => snapshot,
-    restoreSnapshot: snapshot => ({
-      ...snapshot,
-      _subscription: undefined
-    })
-  };
-  return logic;
-}
-
-const XSTATE_ASYNC_RESOLVE = 'xstate.async.resolve';
-const XSTATE_ASYNC_REJECT = 'xstate.async.reject';
-class TimeoutError extends Error {
-  constructor(timeout) {
-    super(`Async logic timed out after ${timeout}.`);
-    this.name = 'TimeoutError';
-  }
-}
-
-/**
- * Represents an actor created by `createAsyncLogic`.
- *
- * The type of `self` within the actor's logic.
- *
- * @example
- *
- * ```ts
- * import { createAsyncLogic, createActor } from 'xstate';
- *
- * // The actor's resolved output
- * type Output = string;
- * // The actor's input.
- * type Input = { message: string };
- *
- * // Actor logic that fetches the url of an image of a cat saying `input.message`.
- * const logic = createAsyncLogic<Output, Input>({
- *   run: async ({ input, self }, enq) => {
- *     self;
- *     // ^? AsyncActor<Output, Input>
- *     enq.emit({ type: 'request.start' });
- *
- *     const data = await fetch(
- *       `https://cataas.com/cat/says/${input.message}`
- *     );
- *     const url = await data.json();
- *     return url;
- *   }
- * });
- *
- * const actor = createActor(logic, { input: { message: 'hello world' } });
- * //    ^? AsyncActor<Output, Input>
- * ```
- *
- * @see {@link createAsyncLogic}
- */
-
-/**
- * An actor logic creator which returns async logic as defined by an async
- * process that resolves or rejects after some time.
- *
- * Actors created from async actor logic can:
- *
- * - Output the resolved value of the async process
- * - Error with the rejected value of the async process
- * - Abort when stopped or timed out
- *
- * Sending events to async actors will have no effect.
- *
- * @example
- *
- * ```ts
- * const asyncLogic = createAsyncLogic({
- *   id: 'fetch-user',
- *   timeout: '30s',
- *   run: async ({ signal }, enq) => {
- *     enq.emit({ type: 'request.start' });
- *     const result = await fetch('https://example.com/...', {
- *       signal
- *     }).then((data) => data.json());
- *
- *     return result;
- *   }
- * });
- *
- * const asyncActor = createActor(asyncLogic);
- * asyncActor.subscribe((snapshot) => {
- *   console.log(snapshot);
- * });
- * asyncActor.start();
- * // => {
- * //   output: undefined,
- * //   status: 'active'
- * //   ...
- * // }
- *
- * // After promise resolves
- * // => {
- * //   output: { ... },
- * //   status: 'done',
- * //   ...
- * // }
- * ```
- *
- * @param asyncLogic A config object with a `run` function which returns a
- *   Promise, and accepts an object with the following properties:
- *
- *   - `input` - Data that was provided to the async actor
- *   - `self` - The async actor ref
- *   - `system` - The actor system to which the async actor belongs
- *   - `signal` - An abort signal for cancellation
- *
- *   `run` also receives an `enq` object with the following properties:
- *
- *   - `emit` - Emits an event that can be observed with `actor.on(...)`
- *
- * @see {@link https://stately.ai/docs/input | Input docs} for more information about how input is passed
- */
-
-function createAsyncLogic(asyncLogic) {
-  const config = asyncLogic;
-  return createLogic({
-    id: config.id,
-    validator: config.validator,
-    schemas: config.schemas,
-    context: undefined,
-    run: ({
-      event,
-      input,
-      self,
-      system
-    }, enq) => {
-      switch (event.type) {
-        case XSTATE_ASYNC_RESOLVE:
-          {
-            const resolvedValue = event.data ?? event.output;
-            return {
-              status: 'done',
-              output: resolvedValue,
-              input: undefined,
-              effects: {
-                async: {
-                  status: 'done',
-                  output: resolvedValue
-                }
-              }
-            };
-          }
-        case XSTATE_ASYNC_REJECT:
-          {
-            const error = event.data ?? event.error;
-            return {
-              status: 'error',
-              error,
-              input: undefined,
-              effects: {
-                async: {
-                  status: 'error',
-                  error
-                }
-              }
-            };
-          }
-      }
-      if (event.type !== XSTATE_INIT) {
-        return;
-      }
-      enq.effect((runtime = system) => {
-        const actorSelf = self;
-        const sendSelf = event => void runtime.sendEvent(actorSelf, actorSelf, event);
-        const controller = new AbortController();
-        const timeout = config.timeout;
-        const timeoutMs = parseDelayToMilliseconds(timeout);
-        const timeoutId = timeoutMs === undefined ? undefined : system._clock.setTimeout(() => {
-          if (self.getSnapshot().status !== 'active') {
-            return;
-          }
-          controller.abort();
-          sendSelf({
-            type: XSTATE_ASYNC_REJECT,
-            data: new TimeoutError(timeout)
-          });
-        }, timeoutMs);
-        const clearTimeout = () => {
-          if (timeoutId !== undefined) {
-            system._clock.clearTimeout(timeoutId);
-          }
-        };
-        const runBody = () => Promise.resolve(config.run({
-          input,
-          system,
-          self: self,
-          signal: controller.signal
-        }, {
-          emit: event => void runtime.emitEvent(actorSelf, event),
-          // Steps route through the runtime: a durable host that
-          // implements `runStep` owns the step journal; otherwise the
-          // built-in behavior memoizes into this actor's own snapshot,
-          // self-sending through the same runtime as the other effects.
-          step: (key, exec) => runtime.runStep ? Promise.resolve(runtime.runStep(actorSelf, key, exec)) : runStep(actorSelf, key, exec, sendSelf)
-        }));
-        // The whole body is one durable unit: a host that implements
-        // `runLogic` journals it by the actor's address — or re-runs the
-        // registered logic from (src, input) on a remote executor, ignoring
-        // the closure. The default runs it here, unjournaled.
-        const resolvedPromise = runtime.runLogic ? Promise.resolve(runtime.runLogic(actorSelf, runBody)) : runBody();
-        resolvedPromise.then(response => {
-          clearTimeout();
-          if (self.getSnapshot().status !== 'active') {
-            return;
-          }
-          sendSelf({
-            type: XSTATE_ASYNC_RESOLVE,
-            data: response
-          });
-        }, errorData => {
-          clearTimeout();
-          if (self.getSnapshot().status !== 'active') {
-            return;
-          }
-          sendSelf({
-            type: XSTATE_ASYNC_REJECT,
-            data: errorData
-          });
-        });
-        return () => {
-          controller.abort();
-          clearTimeout();
-        };
-      });
-      return {
-        effects: {
-          async: {
-            status: 'active'
-          }
-        }
-      };
-    }
-  });
-}
-
-const emptyLogic = /* #__PURE__ */createLogic({
-  context: undefined,
-  run: () => undefined
-});
-function createEmptyActor() {
-  return createActor(emptyLogic);
-}
-
-export { TimeoutError as T, createCallbackLogic as a, createEmptyActor as b, createAsyncLogic as c, createEventObservableLogic as d, createLogic as e, createObservableLogic as f, assertValid as g };