xstate 5.0.0-beta.42 → 5.0.0-beta.43

package/dist/declarations/src/State.d.ts

@@ -36,14 +36,14 @@ interface MachineSnapshotBase<TContext extends MachineContext, TEvent extends Ev
     meta: Record<string, any>;
     /**
      * Whether the current state value is a subset of the given parent state value.
-     * @param parentStateValue
+     * @param testValue
      */
-    matches: <TSV extends TResolvedTypesMeta extends TypegenEnabled ? Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'matchesStates'> : StateValue>(parentStateValue: TSV) => boolean;
+    matches: <TSV extends TResolvedTypesMeta extends TypegenEnabled ? Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'matchesStates'> : StateValue>(this: MachineSnapshotBase<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>, testValue: TSV) => boolean;
     /**
      * Whether the current state configuration has a state node with the specified `tag`.
      * @param tag
      */
-    hasTag: (tag: TTag) => boolean;
+    hasTag: (this: MachineSnapshotBase<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>, tag: TTag) => boolean;
     /**
      * Determines whether sending the `event` will cause a non-forbidden transition
      * to be selected, even if the transitions have no actions nor
@@ -52,8 +52,8 @@ interface MachineSnapshotBase<TContext extends MachineContext, TEvent extends Ev
      * @param event The event to test
      * @returns Whether the event will cause a transition
      */
-    can: (event: TEvent) => boolean;
-    toJSON: () => unknown;
+    can: (this: MachineSnapshotBase<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>, event: TEvent) => boolean;
+    toJSON: (this: MachineSnapshotBase<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>) => unknown;
 }
 interface ActiveMachineSnapshot<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TTag extends string, TOutput, TResolvedTypesMeta = TypegenDisabled> extends MachineSnapshotBase<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta> {
     status: 'active';

package/dist/declarations/src/actions/spawn.d.ts

@@ -1,4 +1,4 @@
-import { ActionArgs, EventObject, MachineContext, ParameterizedObject, AnyActorLogic, ProvidedActor, IsLiteralString, InputFrom, UnifiedArg } from "../types.js";
+import { ActionArgs, EventObject, MachineContext, ParameterizedObject, AnyActorLogic, ProvidedActor, IsLiteralString, InputFrom, UnifiedArg, Mapper } from "../types.js";
 type ResolvableActorId<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TId extends string | undefined> = TId | ((args: UnifiedArg<TContext, TExpressionEvent, TEvent>) => TId);
 export interface SpawnAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TActor extends ProvidedActor> {
     (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams): void;
@@ -9,7 +9,7 @@ type DistributeActors<TContext extends MachineContext, TExpressionEvent extends
     options: {
         id: ResolvableActorId<TContext, TExpressionEvent, TEvent, TActor['id']>;
         systemId?: string;
-        input?: InputFrom<TActor['logic']>;
+        input?: Mapper<TContext, TEvent, InputFrom<TActor['logic']>, TEvent> | InputFrom<TActor['logic']>;
         syncSnapshot?: boolean;
     }
 ] : [
@@ -17,7 +17,7 @@ type DistributeActors<TContext extends MachineContext, TExpressionEvent extends
     options?: {
         id?: ResolvableActorId<TContext, TExpressionEvent, TEvent, string>;
         systemId?: string;
-        input?: InputFrom<TActor['logic']>;
+        input?: Mapper<TContext, TEvent, InputFrom<TActor['logic']>, TEvent> | InputFrom<TActor['logic']>;
         syncSnapshot?: boolean;
     }
 ] : never;

package/dist/declarations/src/actors/promise.d.ts

@@ -20,9 +20,62 @@ export type PromiseActorLogic<TOutput, TInput = unknown> = ActorLogic<PromiseSna
 }, TInput, // input
 ActorSystem<any>>;
 export type PromiseActorRef<TOutput> = ActorRefFrom<PromiseActorLogic<TOutput, unknown>>;
+/**
+ * An actor logic creator which returns promise logic as defined by an async process that resolves or rejects after some time.
+ *
+ * Actors created from promise actor logic (“promise actors”) can:
+ * - Emit the resolved value of the promise
+ * - Output the resolved value of the promise
+ *
+ * Sending events to promise actors will have no effect.
+ *
+ * @param promiseCreator
+ *   A function which returns a Promise, and accepts an object with the following properties:
+ *   - `input` - Data that was provided to the promise actor
+ *   - `self` - The parent actor of the promise actor
+ *   - `system` - The actor system to which the promise actor belongs
+ * @see {@link https://stately.ai/docs/input | Input docs} for more information about how input is passed
+ *
+ * @example
+ * ```ts
+ * const promiseLogic = fromPromise(async () => {
+ *   const result = await fetch('https://example.com/...')
+ *     .then((data) => data.json());
+ *
+ *   return result;
+ * });
+ *
+ * const promiseActor = createActor(promiseLogic);
+ * promiseActor.subscribe((snapshot) => {
+ *   console.log(snapshot);
+ * });
+ * promiseActor.start();
+ * // => {
+ * //   output: undefined,
+ * //   status: 'active'
+ * //   ...
+ * // }
+ *
+ * // After promise resolves
+ * // => {
+ * //   output: { ... },
+ * //   status: 'done',
+ * //   ...
+ * // }
+ * ```
+ */
 export declare function fromPromise<TOutput, TInput = unknown>(promiseCreator: ({ input, system }: {
+    /**
+     * Data that was provided to the promise actor
+     */
     input: TInput;
+    /**
+     * The actor system to which the promise actor belongs
+     */
     system: AnyActorSystem;
+    /**
+     * The parent actor of the promise actor
+     */
     self: PromiseActorRef<TOutput>;
 }) => PromiseLike<TOutput>): PromiseActorLogic<TOutput, TInput>;
 export {};

package/dist/declarations/src/types.d.ts

@@ -387,11 +387,8 @@ type MaybeNarrowedEvent<TIndexedEvents, TCausingLookup, K> = Cast<Prop<TIndexedE
 type MachineImplementationsActions<TContext extends MachineContext, TResolvedTypesMeta, TEventsCausingActions = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'eventsCausingActions'>, TIndexedEvents = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedEvents'>, TIndexedActors = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedActors'>, TIndexedActions = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedActions'>, TIndexedGuards = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedGuards'>, TIndexedDelays = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedDelays'>> = {
     [K in keyof TIndexedActions]?: ActionFunction<TContext, MaybeNarrowedEvent<TIndexedEvents, TEventsCausingActions, K>, Cast<Prop<TIndexedEvents, keyof TIndexedEvents>, EventObject>, GetParameterizedParams<Cast<TIndexedActions[K], ParameterizedObject>>, Cast<Prop<TIndexedActors, keyof TIndexedActors>, ProvidedActor>, Cast<Prop<TIndexedActions, keyof TIndexedActions>, ParameterizedObject>, Cast<Prop<TIndexedGuards, keyof TIndexedGuards>, ParameterizedObject>, Cast<Prop<TIndexedDelays, keyof TIndexedDelays>, ParameterizedObject>['type']>;
 };
-type MachineImplementationsActors<TContext extends MachineContext, TResolvedTypesMeta, TEventsCausingActors = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'eventsCausingActors'>, TIndexedActors = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedActors'>, TIndexedEvents = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedEvents'>, _TInvokeSrcNameMap = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'invokeSrcNameMap'>> = {
-    [K in keyof TIndexedActors]?: Cast<Prop<TIndexedActors[K], 'logic'>, AnyActorLogic> | {
-        src: Cast<Prop<TIndexedActors[K], 'logic'>, AnyActorLogic>;
-        input: Mapper<TContext, MaybeNarrowedEvent<TIndexedEvents, TEventsCausingActors, K>, InputFrom<Cast<Prop<TIndexedActors[K], 'logic'>, AnyActorLogic>>, Cast<Prop<TIndexedEvents, keyof TIndexedEvents>, EventObject>> | InputFrom<Cast<Prop<TIndexedActors[K], 'logic'>, AnyActorLogic>>;
-    };
+type MachineImplementationsActors<_TContext extends MachineContext, TResolvedTypesMeta, TIndexedActors = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedActors'>, _TInvokeSrcNameMap = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'invokeSrcNameMap'>> = {
+    [K in keyof TIndexedActors]?: Cast<Prop<TIndexedActors[K], 'logic'>, AnyActorLogic>;
 };
 type MachineImplementationsDelays<TContext extends MachineContext, TResolvedTypesMeta, TEventsCausingDelays = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'eventsCausingDelays'>, TIndexedEvents = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedEvents'>, TIndexedActions = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedActions'>, TIndexedDelays = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedDelays'>> = {
     [K in keyof TIndexedDelays]?: DelayConfig<TContext, MaybeNarrowedEvent<TIndexedEvents, TEventsCausingDelays, K>, Cast<Prop<Prop<TIndexedActions, keyof TIndexedActions>, 'params'>, ParameterizedObject['params'] | undefined> | undefined, Cast<Prop<TIndexedEvents, keyof TIndexedEvents>, EventObject>>;
@@ -777,14 +774,52 @@ export type Snapshot<TOutput> = {
     output: undefined;
     error: undefined;
 };
+/**
+ * Represents logic which can be used by an actor.
+ *
+ * @template TSnapshot - The type of the snapshot.
+ * @template TEvent - The type of the event object.
+ * @template TInput - The type of the input.
+ * @template TSystem - The type of the actor system.
+ */
 export interface ActorLogic<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TInput = unknown, TSystem extends ActorSystem<any> = ActorSystem<any>> {
+    /** The initial setup/configuration used to create the actor logic. */
     config?: unknown;
+    /**
+     * Transition function that processes the current state and an incoming message
+     * to produce a new state.
+     * @param state - The current state.
+     * @param message - The incoming message.
+     * @param ctx - The actor scope.
+     * @returns The new state.
+     */
     transition: (state: TSnapshot, message: TEvent, ctx: ActorScope<TSnapshot, TEvent, TSystem>) => TSnapshot;
+    /**
+     * Called to provide the initial state of the actor.
+     * @param actorScope - The actor scope.
+     * @param input - The input for the initial state.
+     * @returns The initial state.
+     */
     getInitialState: (actorScope: ActorScope<TSnapshot, TEvent, TSystem>, input: TInput) => TSnapshot;
+    /**
+     * Called when Actor is created to restore the internal state of the actor given a persisted state.
+     * The persisted state can be created by `getPersistedState`.
+     * @param persistedState - The persisted state to restore from.
+     * @param actorScope - The actor scope.
+     * @returns The restored state.
+     */
     restoreState?: (persistedState: Snapshot<unknown>, actorScope: ActorScope<TSnapshot, TEvent>) => TSnapshot;
+    /**
+     * Called when the actor is started.
+     * @param state - The starting state.
+     * @param actorScope - The actor scope.
+     */
     start?: (state: TSnapshot, actorScope: ActorScope<TSnapshot, TEvent>) => void;
     /**
-     * @returns Persisted state
+     * Obtains the internal state of the actor in a representation which can be be persisted.
+     * The persisted state can be restored by `restoreState`.
+     * @param state - The current state.
+     * @returns The a representation of the internal state to be persisted.
      */
     getPersistedState: (state: TSnapshot, options?: unknown) => Snapshot<unknown>;
 }

package/dist/declarations/src/utils.d.ts

@@ -1,4 +1,4 @@
-import { AnyActorLogic, AnyState } from "./index.js";
+import { AnyState } from "./index.js";
 import type { StateNode } from "./StateNode.js";
 import type { ActorLogic, AnyEventObject, EventObject, MachineContext, Mapper, Observer, ErrorActorEvent, SingleOrArray, StateLike, StateValue, Subscribable, TransitionConfigTarget, AnyActorRef, AnyTransitionConfig, NonReducibleUnknown, AnyStateMachine } from "./types.js";
 export declare function keys<T extends object>(value: T): Array<keyof T & string>;
@@ -39,10 +39,4 @@ export declare function normalizeTarget<TContext extends MachineContext, TEvent
 export declare function reportUnhandledExceptionOnInvocation(originalError: any, currentError: any, id: string): void;
 export declare function toObserver<T>(nextHandler?: Observer<T> | ((value: T) => void), errorHandler?: (error: any) => void, completionHandler?: () => void): Observer<T>;
 export declare function createInvokeId(stateNodeId: string, index: number): string;
-export declare function resolveReferencedActor(machine: AnyStateMachine, src: string): {
-    src: AnyActorLogic;
-    input: NonReducibleUnknown | Mapper<any, any, unknown, any>;
-} | {
-    src: any;
-    input: undefined;
-} | undefined;
+export declare function resolveReferencedActor(machine: AnyStateMachine, src: string): any;

package/dist/{interpreter-b6bdd134.cjs.js → interpreter-36d5556e.cjs.js}

@@ -320,16 +320,9 @@ function resolveReferencedActor(machine, src) {
     const [, indexStr] = src.match(/\[(\d+)\]$/);
     const node = machine.getStateNodeById(src.slice(7, -(indexStr.length + 2)));
     const invokeConfig = node.config.invoke;
-    return {
-      src: (Array.isArray(invokeConfig) ? invokeConfig[indexStr] : invokeConfig).src,
-      input: undefined
-    };
+    return (Array.isArray(invokeConfig) ? invokeConfig[indexStr] : invokeConfig).src;
   }
-  const referenced = machine.implementations.actors[src];
-  return referenced ? 'transition' in referenced ? {
-    src: referenced,
-    input: undefined
-  } : referenced : undefined;
+  return machine.implementations.actors[src];
 }
 
 const $$ACTOR_TYPE = 1;

package/dist/{interpreter-23e4041c.development.cjs.js → interpreter-4e8e2a0d.development.cjs.js}

@@ -323,16 +323,9 @@ function resolveReferencedActor(machine, src) {
     const [, indexStr] = src.match(/\[(\d+)\]$/);
     const node = machine.getStateNodeById(src.slice(7, -(indexStr.length + 2)));
     const invokeConfig = node.config.invoke;
-    return {
-      src: (Array.isArray(invokeConfig) ? invokeConfig[indexStr] : invokeConfig).src,
-      input: undefined
-    };
+    return (Array.isArray(invokeConfig) ? invokeConfig[indexStr] : invokeConfig).src;
   }
-  const referenced = machine.implementations.actors[src];
-  return referenced ? 'transition' in referenced ? {
-    src: referenced,
-    input: undefined
-  } : referenced : undefined;
+  return machine.implementations.actors[src];
 }
 
 const $$ACTOR_TYPE = 1;

package/dist/{interpreter-3d0c0ff2.esm.js → interpreter-63c80754.esm.js}

@@ -318,16 +318,9 @@ function resolveReferencedActor(machine, src) {
     const [, indexStr] = src.match(/\[(\d+)\]$/);
     const node = machine.getStateNodeById(src.slice(7, -(indexStr.length + 2)));
     const invokeConfig = node.config.invoke;
-    return {
-      src: (Array.isArray(invokeConfig) ? invokeConfig[indexStr] : invokeConfig).src,
-      input: undefined
-    };
+    return (Array.isArray(invokeConfig) ? invokeConfig[indexStr] : invokeConfig).src;
   }
-  const referenced = machine.implementations.actors[src];
-  return referenced ? 'transition' in referenced ? {
-    src: referenced,
-    input: undefined
-  } : referenced : undefined;
+  return machine.implementations.actors[src];
 }
 
 const $$ACTOR_TYPE = 1;

package/dist/{interpreter-f2620ea7.development.esm.js → interpreter-80eb3bec.development.esm.js}

@@ -321,16 +321,9 @@ function resolveReferencedActor(machine, src) {
     const [, indexStr] = src.match(/\[(\d+)\]$/);
     const node = machine.getStateNodeById(src.slice(7, -(indexStr.length + 2)));
     const invokeConfig = node.config.invoke;
-    return {
-      src: (Array.isArray(invokeConfig) ? invokeConfig[indexStr] : invokeConfig).src,
-      input: undefined
-    };
+    return (Array.isArray(invokeConfig) ? invokeConfig[indexStr] : invokeConfig).src;
   }
-  const referenced = machine.implementations.actors[src];
-  return referenced ? 'transition' in referenced ? {
-    src: referenced,
-    input: undefined
-  } : referenced : undefined;
+  return machine.implementations.actors[src];
 }
 
 const $$ACTOR_TYPE = 1;

package/dist/{raise-8f482ce9.development.cjs.js → raise-23dea0d7.development.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var interpreter = require('./interpreter-23e4041c.development.cjs.js');
+var interpreter = require('./interpreter-4e8e2a0d.development.cjs.js');
 
 const cache = new WeakMap();
 function memo(object, key, fn) {
@@ -52,25 +52,20 @@ function resolveSpawn(actorScope, state, actionArgs, _actionParams, {
   input,
   syncSnapshot
 }) {
-  const referenced = typeof src === 'string' ? interpreter.resolveReferencedActor(state.machine, src) : {
-    src,
-    input: undefined
-  };
+  const logic = typeof src === 'string' ? interpreter.resolveReferencedActor(state.machine, src) : src;
   const resolvedId = typeof id === 'function' ? id(actionArgs) : id;
   let actorRef;
-  if (referenced) {
-    // TODO: inline `input: undefined` should win over the referenced one
-    const configuredInput = input || referenced.input;
-    actorRef = interpreter.createActor(referenced.src, {
+  if (logic) {
+    actorRef = interpreter.createActor(logic, {
       id: resolvedId,
       src,
       parent: actorScope?.self,
       systemId,
-      input: typeof configuredInput === 'function' ? configuredInput({
+      input: typeof input === 'function' ? input({
         context: state.context,
         event: actionArgs.event,
         self: actorScope?.self
-      }) : configuredInput
+      }) : input
     });
     if (syncSnapshot) {
       actorRef.subscribe({
@@ -1257,8 +1252,53 @@ function resolveStateValue(rootNode, stateValue) {
   return getStateValue(rootNode, [...configuration]);
 }
 
-function createMachineSnapshot(config, machine) {
+const machineSnapshotMatches = function matches(testValue) {
+  return interpreter.matchesState(testValue, this.value);
+};
+const machineSnapshotHasTag = function hasTag(tag) {
+  return this.tags.has(tag);
+};
+const machineSnapshotCan = function can(event) {
+  if (!this.machine) {
+    console.warn(`state.can(...) used outside of a machine-created State object; this will always return false.`);
+  }
+  const transitionData = this.machine.getTransitionData(this, event);
+  return !!transitionData?.length &&
+  // Check that at least one transition is not forbidden
+  transitionData.some(t => t.target !== undefined || t.actions.length);
+};
+const machineSnapshotToJSON = function toJSON() {
+  const {
+    configuration,
+    tags,
+    machine,
+    nextEvents,
+    toJSON,
+    can,
+    hasTag,
+    matches,
+    ...jsonValues
+  } = this;
   return {
+    ...jsonValues,
+    tags: Array.from(tags)
+  };
+};
+const machineSnapshotNextEvents = function nextEvents() {
+  return memo(this, 'nextEvents', () => {
+    return [...new Set(interpreter.flatten([...this.configuration.map(sn => sn.ownEvents)]))];
+  });
+};
+const machineSnapshotMeta = function nextEvents() {
+  return this.configuration.reduce((acc, stateNode) => {
+    if (stateNode.meta !== undefined) {
+      acc[stateNode.id] = stateNode.meta;
+    }
+    return acc;
+  }, {});
+};
+function createMachineSnapshot(config, machine) {
+  const snapshot = {
     status: config.status,
     output: config.output,
     error: config.error,
@@ -1269,52 +1309,25 @@ function createMachineSnapshot(config, machine) {
     tags: new Set(interpreter.flatten(config.configuration.map(sn => sn.tags))),
     children: config.children,
     historyValue: config.historyValue || {},
-    matches(parentStateValue) {
-      return interpreter.matchesState(parentStateValue, this.value);
-    },
-    hasTag(tag) {
-      return this.tags.has(tag);
-    },
-    can(event) {
-      if (!this.machine) {
-        console.warn(`state.can(...) used outside of a machine-created State object; this will always return false.`);
-      }
-      const transitionData = this.machine.getTransitionData(this, event);
-      return !!transitionData?.length &&
-      // Check that at least one transition is not forbidden
-      transitionData.some(t => t.target !== undefined || t.actions.length);
-    },
-    get nextEvents() {
-      return memo(this, 'nextEvents', () => {
-        return [...new Set(interpreter.flatten([...this.configuration.map(sn => sn.ownEvents)]))];
-      });
-    },
-    get meta() {
-      return this.configuration.reduce((acc, stateNode) => {
-        if (stateNode.meta !== undefined) {
-          acc[stateNode.id] = stateNode.meta;
-        }
-        return acc;
-      }, {});
+    // this one is generic in the target and it's hard to create a matching non-generic source signature
+    matches: machineSnapshotMatches,
+    hasTag: machineSnapshotHasTag,
+    can: machineSnapshotCan,
+    toJSON: machineSnapshotToJSON
+  };
+  Object.defineProperties(snapshot, {
+    nextEvents: {
+      get: machineSnapshotNextEvents,
+      configurable: true,
+      enumerable: true
     },
-    toJSON() {
-      const {
-        configuration,
-        tags,
-        machine,
-        nextEvents,
-        toJSON,
-        can,
-        hasTag,
-        matches,
-        ...jsonValues
-      } = this;
-      return {
-        ...jsonValues,
-        tags: Array.from(tags)
-      };
+    meta: {
+      get: machineSnapshotMeta,
+      configurable: true,
+      enumerable: true
     }
-  };
+  });
+  return snapshot;
 }
 function cloneMachineSnapshot(state, config = {}) {
   return createMachineSnapshot(

package/dist/{raise-d2084327.esm.js → raise-8dc8e1aa.esm.js}

@@ -1,4 +1,4 @@
-import { r as resolveReferencedActor, d as createActor, P as ProcessingStatus, h as createErrorActorEvent, j as STATE_IDENTIFIER, n as normalizeTarget, t as toArray, N as NULL_EVENT, a as toTransitionConfigArray, S as STATE_DELIMITER, k as toStatePath, l as createDoneStateEvent, o as resolveOutput, X as XSTATE_STOP, q as XSTATE_INIT, W as WILDCARD, s as createAfterEvent, u as flatten, f as matchesState, $ as $$ACTOR_TYPE } from './interpreter-3d0c0ff2.esm.js';
+import { r as resolveReferencedActor, d as createActor, P as ProcessingStatus, h as createErrorActorEvent, j as STATE_IDENTIFIER, n as normalizeTarget, t as toArray, N as NULL_EVENT, a as toTransitionConfigArray, S as STATE_DELIMITER, k as toStatePath, l as createDoneStateEvent, o as resolveOutput, X as XSTATE_STOP, q as XSTATE_INIT, W as WILDCARD, s as createAfterEvent, u as flatten, $ as $$ACTOR_TYPE, f as matchesState } from './interpreter-63c80754.esm.js';
 
 const cache = new WeakMap();
 function memo(object, key, fn) {
@@ -47,25 +47,20 @@ function resolveSpawn(actorScope, state, actionArgs, _actionParams, {
   input,
   syncSnapshot
 }) {
-  const referenced = typeof src === 'string' ? resolveReferencedActor(state.machine, src) : {
-    src,
-    input: undefined
-  };
+  const logic = typeof src === 'string' ? resolveReferencedActor(state.machine, src) : src;
   const resolvedId = typeof id === 'function' ? id(actionArgs) : id;
   let actorRef;
-  if (referenced) {
-    // TODO: inline `input: undefined` should win over the referenced one
-    const configuredInput = input || referenced.input;
-    actorRef = createActor(referenced.src, {
+  if (logic) {
+    actorRef = createActor(logic, {
       id: resolvedId,
       src,
       parent: actorScope?.self,
       systemId,
-      input: typeof configuredInput === 'function' ? configuredInput({
+      input: typeof input === 'function' ? input({
         context: state.context,
         event: actionArgs.event,
         self: actorScope?.self
-      }) : configuredInput
+      }) : input
     });
     if (syncSnapshot) {
       actorRef.subscribe({
@@ -1221,8 +1216,50 @@ function resolveStateValue(rootNode, stateValue) {
   return getStateValue(rootNode, [...configuration]);
 }
 
-function createMachineSnapshot(config, machine) {
+const machineSnapshotMatches = function matches(testValue) {
+  return matchesState(testValue, this.value);
+};
+const machineSnapshotHasTag = function hasTag(tag) {
+  return this.tags.has(tag);
+};
+const machineSnapshotCan = function can(event) {
+  const transitionData = this.machine.getTransitionData(this, event);
+  return !!transitionData?.length &&
+  // Check that at least one transition is not forbidden
+  transitionData.some(t => t.target !== undefined || t.actions.length);
+};
+const machineSnapshotToJSON = function toJSON() {
+  const {
+    configuration,
+    tags,
+    machine,
+    nextEvents,
+    toJSON,
+    can,
+    hasTag,
+    matches,
+    ...jsonValues
+  } = this;
   return {
+    ...jsonValues,
+    tags: Array.from(tags)
+  };
+};
+const machineSnapshotNextEvents = function nextEvents() {
+  return memo(this, 'nextEvents', () => {
+    return [...new Set(flatten([...this.configuration.map(sn => sn.ownEvents)]))];
+  });
+};
+const machineSnapshotMeta = function nextEvents() {
+  return this.configuration.reduce((acc, stateNode) => {
+    if (stateNode.meta !== undefined) {
+      acc[stateNode.id] = stateNode.meta;
+    }
+    return acc;
+  }, {});
+};
+function createMachineSnapshot(config, machine) {
+  const snapshot = {
     status: config.status,
     output: config.output,
     error: config.error,
@@ -1233,49 +1270,25 @@ function createMachineSnapshot(config, machine) {
     tags: new Set(flatten(config.configuration.map(sn => sn.tags))),
     children: config.children,
     historyValue: config.historyValue || {},
-    matches(parentStateValue) {
-      return matchesState(parentStateValue, this.value);
-    },
-    hasTag(tag) {
-      return this.tags.has(tag);
-    },
-    can(event) {
-      const transitionData = this.machine.getTransitionData(this, event);
-      return !!transitionData?.length &&
-      // Check that at least one transition is not forbidden
-      transitionData.some(t => t.target !== undefined || t.actions.length);
-    },
-    get nextEvents() {
-      return memo(this, 'nextEvents', () => {
-        return [...new Set(flatten([...this.configuration.map(sn => sn.ownEvents)]))];
-      });
-    },
-    get meta() {
-      return this.configuration.reduce((acc, stateNode) => {
-        if (stateNode.meta !== undefined) {
-          acc[stateNode.id] = stateNode.meta;
-        }
-        return acc;
-      }, {});
+    // this one is generic in the target and it's hard to create a matching non-generic source signature
+    matches: machineSnapshotMatches,
+    hasTag: machineSnapshotHasTag,
+    can: machineSnapshotCan,
+    toJSON: machineSnapshotToJSON
+  };
+  Object.defineProperties(snapshot, {
+    nextEvents: {
+      get: machineSnapshotNextEvents,
+      configurable: true,
+      enumerable: true
     },
-    toJSON() {
-      const {
-        configuration,
-        tags,
-        machine,
-        nextEvents,
-        toJSON,
-        can,
-        hasTag,
-        matches,
-        ...jsonValues
-      } = this;
-      return {
-        ...jsonValues,
-        tags: Array.from(tags)
-      };
+    meta: {
+      get: machineSnapshotMeta,
+      configurable: true,
+      enumerable: true
     }
-  };
+  });
+  return snapshot;
 }
 function cloneMachineSnapshot(state, config = {}) {
   return createMachineSnapshot(