xstate 5.0.0-beta.14 → 5.0.0-beta.16

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

@@ -2,8 +2,8 @@ import type { StateNode } from "./StateNode.js";
 import type { State } from "./State.js";
 import type { ActorStatus, Clock, Interpreter } from "./interpreter.js";
 import type { StateMachine } from "./StateMachine.js";
-import type { LifecycleSignal } from "./actors/index.js";
 import { TypegenDisabled, ResolveTypegenMeta, TypegenConstraint, MarkAllImplementationsAsProvided, AreAllImplementationsAssumedToBeProvided } from "./typegenTypes.js";
+import { PromiseEvent } from "./actors/promise.js";
 export type AnyFunction = (...args: any[]) => any;
 type ReturnTypeOrValue<T> = T extends AnyFunction ? ReturnType<T> : T;
 export type IsNever<T> = [T] extends [never] ? true : false;
@@ -54,6 +54,8 @@ export interface BuiltInActionObject extends ParameterizedObject {
 export interface UnifiedArg<TContext extends MachineContext, TEvent extends EventObject> {
     context: TContext;
     event: TEvent;
+    self: ActorRef<TEvent>;
+    system: ActorSystem<any>;
 }
 export interface BaseDynamicActionObject<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TResolvedAction extends BaseActionObject, TDynamicParams extends Record<string, any>> {
     type: `xstate.${string}`;
@@ -64,16 +66,13 @@ export interface BaseDynamicActionObject<TContext extends MachineContext, TExpre
          * The original action object
          */
         action: ParameterizedObject;
-        actorContext: AnyActorContext | undefined;
+        actorContext: AnyActorContext;
     }) => [AnyState, TResolvedAction];
     /** @deprecated an internal signature that doesn't exist at runtime. Its existence helps TS to choose a better code path in the inference algorithm  */
-    (args: {
-        context: TContext;
-        event: TExpressionEvent;
-    } & ActionMeta<TEvent, ParameterizedObject>): void;
+    (args: ActionArgs<TContext, TExpressionEvent, ParameterizedObject>): void;
 }
 export type MachineContext = Record<string, any>;
-export interface ActionMeta<TEvent extends EventObject, TAction extends ParameterizedObject = ParameterizedObject> extends StateMeta<TEvent> {
+export interface ActionArgs<TContext extends MachineContext, TEvent extends EventObject, TAction extends ParameterizedObject = ParameterizedObject> extends UnifiedArg<TContext, TEvent> {
     action: TAction;
 }
 export type Spawner = <T extends ActorLogic<any, any> | string>(// TODO: read string from machine logic keys
@@ -82,26 +81,23 @@ logic: T, options?: Partial<{
     systemId?: string;
     input: any;
 }>) => T extends ActorLogic<infer TActorEvent, infer TActorEmitted, infer _, infer __, infer ___> ? ActorRef<TActorEvent, TActorEmitted> : ActorRef<any, any>;
-export interface AssignMeta<TExpressionEvent extends EventObject, _TEvent extends EventObject> extends StateMeta<TExpressionEvent> {
+export interface AssignArgs<TContext extends MachineContext, TExpressionEvent extends EventObject> extends ActionArgs<TContext, TExpressionEvent> {
     action: BaseActionObject;
     event: TExpressionEvent;
     spawn: Spawner;
 }
-export type ActionFunction<TContext extends MachineContext, TExpressionEvent extends EventObject, TAction extends ParameterizedObject = ParameterizedObject, TEvent extends EventObject = TExpressionEvent> = (args: {
-    context: TContext;
-    event: TExpressionEvent;
-} & ActionMeta<TEvent, TAction>) => void;
+export type ActionFunction<TContext extends MachineContext, TExpressionEvent extends EventObject, TAction extends ParameterizedObject = ParameterizedObject> = (args: ActionArgs<TContext, TExpressionEvent, TAction>) => void;
 export interface ChooseCondition<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent> {
     guard?: GuardConfig<TContext, TExpressionEvent>;
     actions: Actions<TContext, TExpressionEvent, TEvent>;
 }
-export type Action<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent> = ActionType | ParameterizedObject | ActionFunction<TContext, TExpressionEvent, ParameterizedObject, TEvent> | BaseDynamicActionObject<TContext, TExpressionEvent, TEvent, any, any>;
+export type Action<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent> = ActionType | ParameterizedObject | ActionFunction<TContext, TExpressionEvent, ParameterizedObject> | BaseDynamicActionObject<TContext, TExpressionEvent, TEvent, any, any>;
 /**
  * Extracts action objects that have no extra properties.
  */
 type SimpleActionsFrom<T extends ParameterizedObject> = ParameterizedObject extends T ? T : ExtractWithSimpleSupport<T>;
 export type BaseAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TAction extends ParameterizedObject, TEvent extends EventObject> = BaseDynamicActionObject<TContext, TExpressionEvent, TEvent, any, // TODO: at the very least this should include TAction, but probably at a covariant position or something, we really need to rethink how action objects are typed
-any> | TAction | SimpleActionsFrom<TAction>['type'] | ActionFunction<TContext, TExpressionEvent, TAction, TEvent>;
+any> | TAction | SimpleActionsFrom<TAction>['type'] | ActionFunction<TContext, TExpressionEvent, TAction>;
 export type BaseActions<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TAction extends ParameterizedObject> = SingleOrArray<BaseAction<TContext, TExpressionEvent, TAction, TEvent>>;
 export type Actions<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent> = SingleOrArray<Action<TContext, TEvent>>;
 export type StateKey = string | AnyState;
@@ -118,7 +114,7 @@ export type StateValue = string | StateValueMap;
 export type GuardPredicate<TContext extends MachineContext, TEvent extends EventObject> = (args: {
     context: TContext;
     event: TEvent;
-} & GuardMeta<TContext, TEvent>) => boolean;
+} & GuardArgs<TContext, TEvent>) => boolean;
 export interface DefaultGuardObject<TContext extends MachineContext, TEvent extends EventObject> extends ParameterizedObject {
     /**
      * Nested guards
@@ -127,7 +123,7 @@ export interface DefaultGuardObject<TContext extends MachineContext, TEvent exte
     predicate?: GuardPredicate<TContext, TEvent>;
 }
 export type GuardEvaluator<TContext extends MachineContext, TEvent extends EventObject> = (guard: GuardDefinition<TContext, TEvent>, context: TContext, event: TEvent, state: State<TContext, TEvent>) => boolean;
-export interface GuardMeta<TContext extends MachineContext, TEvent extends EventObject> {
+export interface GuardArgs<TContext extends MachineContext, TEvent extends EventObject> {
     state: State<TContext, TEvent, any>;
     guard: GuardDefinition<TContext, TEvent>;
     evaluate: GuardEvaluator<TContext, TEvent>;
@@ -218,7 +214,7 @@ export interface Delay {
     delay: number;
 }
 export type DelayedTransitions<TContext extends MachineContext, TEvent extends EventObject> = Record<string | number, string | SingleOrArray<TransitionConfig<TContext, TEvent>>> | Array<TransitionConfig<TContext, TEvent> & {
-    delay: number | string | Expr<TContext, TEvent, number>;
+    delay: number | string | ((args: UnifiedArg<TContext, TEvent>) => number);
 }>;
 export type StateTypes = 'atomic' | 'compound' | 'parallel' | 'final' | 'history' | string;
 export type SingleOrArray<T> = T[] | T;
@@ -344,10 +340,6 @@ export interface StateNodeConfig<TContext extends MachineContext, TEvent extends
      * `#id` syntax.
      */
     id?: string | undefined;
-    /**
-     * The string delimiter for serializing the path to a string. The default is "."
-     */
-    delimiter?: string;
     /**
      * The order this state node appears. Corresponds to the implicit document order.
      */
@@ -385,7 +377,6 @@ export interface StateNodeDefinition<TContext extends MachineContext, TEvent ext
     tags: string[];
 }
 export interface StateMachineDefinition<TContext extends MachineContext, TEvent extends EventObject> extends StateNodeDefinition<TContext, TEvent> {
-    context: TContext;
 }
 export type AnyStateNode = StateNode<any, any>;
 export type AnyStateNodeDefinition = StateNodeDefinition<any, any>;
@@ -429,14 +420,13 @@ export interface MachineImplementationsSimplified<TContext extends MachineContex
 }
 type MachineImplementationsActions<TContext extends MachineContext, TResolvedTypesMeta, TEventsCausingActions = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'eventsCausingActions'>, TIndexedEvents = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedEvents'>> = {
     [K in keyof TEventsCausingActions]?: BaseDynamicActionObject<TContext, Cast<Prop<TIndexedEvents, TEventsCausingActions[K]>, EventObject>, Cast<Prop<TIndexedEvents, keyof TIndexedEvents>, EventObject>, any, // TODO: this should receive something like `Cast<Prop<TIndexedActions, K>, ParameterizedObject>`, but at the moment builtin actions expect Resolved*Action here and this should be simplified somehow
-    any> | ActionFunction<TContext, Cast<Prop<TIndexedEvents, TEventsCausingActions[K]>, EventObject>, ParameterizedObject, // TODO: when bringing back parametrized actions this should accept something like `Cast<Prop<TIndexedActions, K>, ParameterizedObject>`. At the moment we need to keep this type argument consistent with what is provided to the fake callable signature within `BaseDynamicActionObject`
-    Cast<Prop<TIndexedEvents, keyof TIndexedEvents>, EventObject>>;
+    any> | ActionFunction<TContext, Cast<Prop<TIndexedEvents, TEventsCausingActions[K]>, EventObject>, ParameterizedObject>;
 };
 type MachineImplementationsDelays<TContext extends MachineContext, TResolvedTypesMeta, TEventsCausingDelays = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'eventsCausingDelays'>, TIndexedEvents = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedEvents'>> = {
     [K in keyof TEventsCausingDelays]?: DelayConfig<TContext, Cast<Prop<TIndexedEvents, TEventsCausingDelays[K]>, EventObject>>;
 };
 type MachineImplementationsGuards<TContext extends MachineContext, TResolvedTypesMeta, TEventsCausingGuards = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'eventsCausingGuards'>, TIndexedEvents = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedEvents'>> = {
-    [K in keyof TEventsCausingGuards]?: GuardPredicate<TContext, Cast<Prop<TIndexedEvents, TEventsCausingGuards[K]>, EventObject>>;
+    [K in keyof TEventsCausingGuards]?: GuardPredicate<TContext, Cast<Prop<TIndexedEvents, TEventsCausingGuards[K]>, EventObject>> | GuardConfig<TContext, Cast<Prop<TIndexedEvents, TEventsCausingGuards[K]>, EventObject>>;
 };
 type MachineImplementationsActors<TContext extends MachineContext, TResolvedTypesMeta, TEventsCausingActors = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'eventsCausingActors'>, TIndexedEvents = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedEvents'>, _TInvokeSrcNameMap = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'invokeSrcNameMap'>> = {
     [K in keyof TEventsCausingActors]?: AnyActorLogic | {
@@ -450,19 +440,19 @@ type MakeKeysRequired<T extends string> = {
 type MaybeMakeMissingImplementationsRequired<TImplementationType, TMissingImplementationsForType, TRequireMissingImplementations> = TRequireMissingImplementations extends true ? IsNever<TMissingImplementationsForType> extends true ? {} : {
     [K in Cast<TImplementationType, string>]: MakeKeysRequired<Cast<TMissingImplementationsForType, string>>;
 } : {};
-type GenerateActionsImplementationsPart<TContext extends MachineContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> = MaybeMakeMissingImplementationsRequired<'actions', Prop<TMissingImplementations, 'actions'>, TRequireMissingImplementations> & {
+type GenerateActionsImplementationsPart<TContext extends MachineContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> = Compute<MaybeMakeMissingImplementationsRequired<'actions', Prop<TMissingImplementations, 'actions'>, TRequireMissingImplementations> & {
     actions?: MachineImplementationsActions<TContext, TResolvedTypesMeta>;
-};
-type GenerateDelaysImplementationsPart<TContext extends MachineContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> = MaybeMakeMissingImplementationsRequired<'delays', Prop<TMissingImplementations, 'delays'>, TRequireMissingImplementations> & {
+}>;
+type GenerateActorsImplementationsPart<TContext extends MachineContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> = Compute<MaybeMakeMissingImplementationsRequired<'actors', Prop<TMissingImplementations, 'actors'>, TRequireMissingImplementations> & {
+    actors?: MachineImplementationsActors<TContext, TResolvedTypesMeta>;
+}>;
+type GenerateDelaysImplementationsPart<TContext extends MachineContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> = Compute<MaybeMakeMissingImplementationsRequired<'delays', Prop<TMissingImplementations, 'delays'>, TRequireMissingImplementations> & {
     delays?: MachineImplementationsDelays<TContext, TResolvedTypesMeta>;
-};
-type GenerateGuardsImplementationsPart<TContext extends MachineContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> = MaybeMakeMissingImplementationsRequired<'guards', Prop<TMissingImplementations, 'guards'>, TRequireMissingImplementations> & {
+}>;
+type GenerateGuardsImplementationsPart<TContext extends MachineContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> = Compute<MaybeMakeMissingImplementationsRequired<'guards', Prop<TMissingImplementations, 'guards'>, TRequireMissingImplementations> & {
     guards?: MachineImplementationsGuards<TContext, TResolvedTypesMeta>;
-};
-type GenerateActorsImplementationsPart<TContext extends MachineContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> = MaybeMakeMissingImplementationsRequired<'actors', Prop<TMissingImplementations, 'actors'>, TRequireMissingImplementations> & {
-    actors?: MachineImplementationsActors<TContext, TResolvedTypesMeta>;
-};
-export type InternalMachineImplementations<TContext extends MachineContext, _TEvent extends EventObject, TResolvedTypesMeta, TRequireMissingImplementations extends boolean = false, TMissingImplementations = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'missingImplementations'>> = GenerateActionsImplementationsPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateDelaysImplementationsPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateGuardsImplementationsPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateActorsImplementationsPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations>;
+}>;
+export type InternalMachineImplementations<TContext extends MachineContext, _TEvent extends EventObject, TResolvedTypesMeta, TRequireMissingImplementations extends boolean = false, TMissingImplementations = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'missingImplementations'>> = GenerateActionsImplementationsPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateActorsImplementationsPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateDelaysImplementationsPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateGuardsImplementationsPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations>;
 export type MachineImplementations<TContext extends MachineContext, TEvent extends EventObject, TAction extends ParameterizedObject = ParameterizedObject, TActorMap extends ActorMap = ActorMap, TTypesMeta extends TypegenConstraint = TypegenDisabled> = InternalMachineImplementations<TContext, TEvent, ResolveTypegenMeta<TTypesMeta, TEvent, TAction, TActorMap>>;
 type InitialContext<TContext extends MachineContext> = TContext | ContextFactory<TContext>;
 export type ContextFactory<TContext extends MachineContext> = ({ spawn, input }: {
@@ -508,7 +498,7 @@ export type Transitions<TContext extends MachineContext, TEvent extends EventObj
 export declare enum ActionTypes {
     Stop = "xstate.stop",
     Raise = "xstate.raise",
-    Send = "xstate.send",
+    SendTo = "xstate.sendTo",
     Cancel = "xstate.cancel",
     Assign = "xstate.assign",
     After = "xstate.after",
@@ -581,7 +571,7 @@ export interface InvokeActionObject extends BaseActionObject {
 export interface DynamicStopActionObject<TContext extends MachineContext, TExpressionEvent extends EventObject> {
     type: ActionTypes.Stop;
     params: {
-        actor: string | ActorRef<any> | Expr<TContext, TExpressionEvent, ActorRef<any> | string>;
+        actor: string | ActorRef<any> | ((args: UnifiedArg<TContext, TExpressionEvent>) => ActorRef<any> | string);
     };
 }
 export interface StopActionObject {
@@ -590,8 +580,8 @@ export interface StopActionObject {
         actor: ActorRef<any>;
     };
 }
-export type DelayExpr<TContext extends MachineContext, TEvent extends EventObject> = ExprWithMeta<TContext, TEvent, number>;
-export type LogExpr<TContext extends MachineContext, TEvent extends EventObject> = ExprWithMeta<TContext, TEvent, any>;
+export type DelayExpr<TContext extends MachineContext, TEvent extends EventObject> = (args: UnifiedArg<TContext, TEvent>) => number;
+export type LogExpr<TContext extends MachineContext, TEvent extends EventObject> = (args: UnifiedArg<TContext, TEvent>) => unknown;
 export interface DynamicLogAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject> extends BaseDynamicActionObject<TContext, TExpressionEvent, TEvent, LogActionObject, {
     label: string | undefined;
     expr: string | LogExpr<TContext, TExpressionEvent>;
@@ -605,25 +595,21 @@ export interface LogActionObject extends BuiltInActionObject {
         value: any;
     };
 }
-export interface SendActionObject<TSentEvent extends EventObject = AnyEventObject> extends BaseActionObject {
-    type: 'xstate.send';
+export interface SendToActionObject<TSentEvent extends EventObject = AnyEventObject> extends BaseActionObject {
+    type: 'xstate.sendTo';
     params: {
-        to: ActorRef<TSentEvent> | undefined;
+        to: ActorRef<TSentEvent>;
         event: TSentEvent;
         delay?: number;
         id: string | number;
-        internal: boolean;
     };
 }
-export type Expr<TContext extends MachineContext, TEvent extends EventObject, T> = (arg: UnifiedArg<TContext, TEvent>) => T;
-export type ExprWithMeta<TContext extends MachineContext, TEvent extends EventObject, T> = (args: UnifiedArg<TContext, TEvent> & StateMeta<TEvent>) => T;
-export type SendExpr<TContext extends MachineContext, TEvent extends EventObject, TSentEvent extends EventObject = AnyEventObject> = ExprWithMeta<TContext, TEvent, TSentEvent>;
+export type SendExpr<TContext extends MachineContext, TExpressionEvent extends EventObject, TSentEvent extends EventObject = AnyEventObject> = (args: UnifiedArg<TContext, TExpressionEvent>) => TSentEvent;
 export declare enum SpecialTargets {
     Parent = "#_parent",
     Internal = "#_internal"
 }
-export interface SendActionOptions<TContext extends MachineContext, TEvent extends EventObject> extends RaiseActionOptions<TContext, TEvent> {
-    to?: string | ActorRef<any, any> | ExprWithMeta<TContext, TEvent, string | ActorRef<any, any>>;
+export interface SendToActionOptions<TContext extends MachineContext, TEvent extends EventObject> extends RaiseActionOptions<TContext, TEvent> {
 }
 export interface RaiseActionOptions<TContext extends MachineContext, TEvent extends EventObject> {
     id?: string | number;
@@ -632,13 +618,13 @@ export interface RaiseActionOptions<TContext extends MachineContext, TEvent exte
 export interface RaiseActionParams<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject> extends RaiseActionOptions<TContext, TExpressionEvent> {
     event: TEvent | SendExpr<TContext, TExpressionEvent, TEvent>;
 }
-export interface SendActionParams<TContext extends MachineContext, TEvent extends EventObject, TSentEvent extends EventObject = EventObject> extends SendActionOptions<TContext, TEvent> {
+export interface SendToActionParams<TContext extends MachineContext, TEvent extends EventObject, TSentEvent extends EventObject = EventObject> extends SendToActionOptions<TContext, TEvent> {
     event: TSentEvent | SendExpr<TContext, TEvent, TSentEvent>;
 }
 export interface DynamicCancelActionObject<TContext extends MachineContext, TExpressionEvent extends EventObject> {
     type: ActionTypes.Cancel;
     params: {
-        sendId: string | ExprWithMeta<TContext, TExpressionEvent, string>;
+        sendId: string | ((args: UnifiedArg<TContext, TExpressionEvent>) => string);
     };
 }
 export interface CancelActionObject extends BaseActionObject {
@@ -647,16 +633,10 @@ export interface CancelActionObject extends BaseActionObject {
         sendId: string;
     };
 }
-export type Assigner<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent> = (args: {
-    context: TContext;
-    event: TExpressionEvent;
-} & AssignMeta<TExpressionEvent, TEvent>) => Partial<TContext>;
-export type PartialAssigner<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TKey extends keyof TContext> = (args: {
-    context: TContext;
-    event: TExpressionEvent;
-} & AssignMeta<TExpressionEvent, TEvent>) => TContext[TKey];
-export type PropertyAssigner<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent> = {
-    [K in keyof TContext]?: PartialAssigner<TContext, TExpressionEvent, TEvent, K> | TContext[K];
+export type Assigner<TContext extends MachineContext, TExpressionEvent extends EventObject> = (args: AssignArgs<TContext, TExpressionEvent>) => Partial<TContext>;
+export type PartialAssigner<TContext extends MachineContext, TExpressionEvent extends EventObject, TKey extends keyof TContext> = (args: AssignArgs<TContext, TExpressionEvent>) => TContext[TKey];
+export type PropertyAssigner<TContext extends MachineContext, TExpressionEvent extends EventObject> = {
+    [K in keyof TContext]?: PartialAssigner<TContext, TExpressionEvent, K> | TContext[K];
 };
 export type Mapper<TContext extends MachineContext, TEvent extends EventObject, TParams extends {}> = (args: {
     context: TContext;
@@ -673,7 +653,7 @@ export interface AnyAssignAction extends BaseActionObject {
     assignment: any;
 }
 export type DynamicAssignAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent> = BaseDynamicActionObject<TContext, TExpressionEvent, TEvent, AssignActionObject<TContext> | RaiseActionObject<TContext, TExpressionEvent>, {
-    assignment: Assigner<TContext, TExpressionEvent, TEvent> | PropertyAssigner<TContext, TExpressionEvent, TEvent>;
+    assignment: Assigner<TContext, TExpressionEvent> | PropertyAssigner<TContext, TExpressionEvent>;
 }>;
 export interface AssignActionObject<TContext extends MachineContext> extends BaseActionObject {
     type: ActionTypes.Assign;
@@ -763,10 +743,6 @@ export interface Segment<TContext extends MachineContext, TEvent extends EventOb
      */
     event: TEvent;
 }
-export interface StateMeta<TEvent extends EventObject> {
-    self: ActorRef<TEvent>;
-    system: ActorSystem<any>;
-}
 export interface StateLike<TContext extends MachineContext> {
     value: StateValue;
     context: TContext;
@@ -778,7 +754,6 @@ export interface StateConfig<TContext extends MachineContext, TEvent extends Eve
     historyValue?: HistoryValue<TContext, TEvent>;
     meta?: any;
     configuration?: Array<StateNode<TContext, TEvent>>;
-    transitions?: Array<TransitionDefinition<TContext, TEvent>>;
     children: Record<string, ActorRef<any>>;
     done?: boolean;
     output?: any;
@@ -827,7 +802,7 @@ export interface InterpreterOptions<_TActorLogic extends AnyActorLogic> {
      */
     src?: string;
 }
-export type AnyInterpreter = Interpreter<any>;
+export type AnyInterpreter = Interpreter<any, any>;
 export type Observer<T> = {
     next?: (value: T) => void;
     error?: (err: any) => void;
@@ -871,9 +846,7 @@ export interface ActorRef<TEvent extends EventObject, TSnapshot = any> extends S
     src?: string;
 }
 export type AnyActorRef = ActorRef<any, any>;
-export type ActorRefFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer TContext, infer TEvent, any, any, infer TResolvedTypesMeta> ? ActorRef<TEvent, State<TContext, TEvent, AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta> extends false ? MarkAllImplementationsAsProvided<TResolvedTypesMeta> : TResolvedTypesMeta>> : R extends Promise<infer U> ? ActorRef<{
-    type: string;
-}, U | undefined> : R extends ActorLogic<infer TEvent, infer TSnapshot> ? ActorRef<TEvent, TSnapshot> : never : never;
+export type ActorRefFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer TContext, infer TEvent, any, any, infer TResolvedTypesMeta> ? ActorRef<TEvent, State<TContext, TEvent, AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta> extends false ? MarkAllImplementationsAsProvided<TResolvedTypesMeta> : TResolvedTypesMeta>> : R extends Promise<infer U> ? ActorRef<PromiseEvent<U>, U | undefined> : R extends ActorLogic<infer TEvent, infer TSnapshot, infer _, infer __, infer ___> ? ActorRef<TEvent, TSnapshot> : never : never;
 export type DevToolsAdapter = (service: AnyInterpreter) => void;
 export type InterpreterFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine)> = ReturnTypeOrValue<T> extends StateMachine<infer TContext, infer TEvent, any, any, infer TResolvedTypesMeta> ? Interpreter<ActorLogic<TEvent, State<TContext, TEvent, TResolvedTypesMeta>, State<TContext, TEvent, TResolvedTypesMeta>, PersistedMachineState<State<TContext, TEvent, TResolvedTypesMeta>>>> : never;
 export type MachineImplementationsFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine), TRequireMissingImplementations extends boolean = false> = ReturnTypeOrValue<T> extends StateMachine<infer TContext, infer TEvent, any, any, infer TResolvedTypesMeta> ? InternalMachineImplementations<TContext, TEvent, TResolvedTypesMeta, TRequireMissingImplementations> : never;
@@ -895,7 +868,7 @@ export interface ActorLogic<TEvent extends EventObject, TSnapshot = any, TIntern
  */
 TPersisted = TInternalState, TSystem extends ActorSystem<any> = ActorSystem<any>> {
     config?: unknown;
-    transition: (state: TInternalState, message: TEvent | LifecycleSignal, ctx: ActorContext<TEvent, TSnapshot, TSystem>) => TInternalState;
+    transition: (state: TInternalState, message: TEvent, ctx: ActorContext<TEvent, TSnapshot, TSystem>) => TInternalState;
     getInitialState: (actorCtx: ActorContext<TEvent, TSnapshot, any>, input: any) => TInternalState;
     restoreState?: (persistedState: TPersisted, actorCtx: ActorContext<TEvent, TSnapshot>) => TInternalState;
     getSnapshot?: (state: TInternalState) => TSnapshot;

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

@@ -3,10 +3,10 @@ import { NULL_EVENT } from "./constants.js";
 import type { StateNode } from "./StateNode.js";
 import type { ActorLogic, AnyEventObject, EventObject, EventType, InvokeConfig, MachineContext, Mapper, Observer, PropertyMapper, ErrorEvent, SingleOrArray, StateLike, StateValue, Subscribable, TransitionConfig, TransitionConfigTarget } from "./types.js";
 export declare function keys<T extends object>(value: T): Array<keyof T & string>;
-export declare function matchesState(parentStateId: StateValue, childStateId: StateValue, delimiter?: string): boolean;
-export declare function toStatePath(stateId: string | string[], delimiter: string): string[];
+export declare function matchesState(parentStateId: StateValue, childStateId: StateValue): boolean;
+export declare function toStatePath(stateId: string | string[]): string[];
 export declare function isStateLike(state: any): state is AnyState;
-export declare function toStateValue(stateValue: StateLike<any> | StateValue | string[], delimiter: string): StateValue;
+export declare function toStateValue(stateValue: StateLike<any> | StateValue | string[]): StateValue;
 export declare function pathToStateValue(statePath: string[]): StateValue;
 export declare function mapValues<P, O extends Record<string, unknown>>(collection: O, iteratee: (item: O[keyof O], key: keyof O, collection: O, i: number) => P): {
     [key in keyof O]: P;

package/dist/xstate.cjs.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var actors_dist_xstateActors = require('./actions-17c3bcfa.cjs.js');
+var actors_dist_xstateActors = require('./actions-6b9073db.cjs.js');
 require('../dev/dist/xstate-dev.cjs.js');
 
 const EMPTY_OBJECT = {};
@@ -95,7 +95,7 @@ class StateNode {
     this.key = options._key;
     this.machine = options._machine;
     this.path = this.parent ? this.parent.path.concat(this.key) : [];
-    this.id = this.config.id || [this.machine.id, ...this.path].join(this.machine.delimiter);
+    this.id = this.config.id || [this.machine.id, ...this.path].join(actors_dist_xstateActors.STATE_DELIMITER);
     this.type = this.config.type || (this.config.states && Object.keys(this.config.states).length ? 'compound' : this.config.history ? 'history' : 'atomic');
     this.description = this.config.description;
     this.order = this.machine.idMap.size;
@@ -185,9 +185,9 @@ class StateNode {
         systemId
       } = invokeConfig;
       const resolvedSrc = actors_dist_xstateActors.isString(src) ? src : !('type' in src) ? resolvedId : src;
-      if (!this.machine.options.actors[resolvedId] && typeof src !== 'string' && !('type' in src)) {
-        this.machine.options.actors = {
-          ...this.machine.options.actors,
+      if (!this.machine.implementations.actors[resolvedId] && typeof src !== 'string' && !('type' in src)) {
+        this.machine.implementations.actors = {
+          ...this.machine.implementations.actors,
           // TODO: this should accept `src` as-is
           [resolvedId]: src
         };
@@ -318,33 +318,7 @@ class StateNode {
 }
 
 const STATE_IDENTIFIER = '#';
-function createDefaultOptions() {
-  return {
-    actions: {},
-    actors: {},
-    delays: {},
-    guards: {},
-    context: {}
-  };
-}
 class StateMachine {
-  // TODO: this getter should be removed
-  getContext(input) {
-    return this.getContextAndActions(undefined, input)[0];
-  }
-  getContextAndActions(actorCtx, input) {
-    const actions = [];
-    const {
-      context
-    } = this.config;
-    const resolvedContext = typeof context === 'function' ? context({
-      spawn: actors_dist_xstateActors.createSpawner(actorCtx?.self, this, undefined,
-      // TODO: this requires `| undefined` for all referenced dynamic inputs that are spawnable in the context factory,
-      actors_dist_xstateActors.createInitEvent(input), actions),
-      input
-    }) : context;
-    return [resolvedContext || {}, actions];
-  }
   /**
    * The machine's own version.
    */
@@ -353,11 +327,10 @@ class StateMachine {
   /**
    * The raw config used to create the machine.
    */
-  config, options) {
+  config, implementations) {
     this.config = config;
     this.version = void 0;
-    this.delimiter = void 0;
-    this.options = void 0;
+    this.implementations = void 0;
     this.types = void 0;
     this.__xstatenode = true;
     this.idMap = new Map();
@@ -371,8 +344,12 @@ class StateMachine {
     this.__TActorMap = void 0;
     this.__TResolvedTypesMeta = void 0;
     this.id = config.id || '(machine)';
-    this.options = Object.assign(createDefaultOptions(), options);
-    this.delimiter = this.config.delimiter || actors_dist_xstateActors.STATE_DELIMITER;
+    this.implementations = {
+      actors: implementations?.actors ?? {},
+      actions: implementations?.actions ?? {},
+      delays: implementations?.delays ?? {},
+      guards: implementations?.guards ?? {}
+    };
     this.version = this.config.version;
     this.types = this.config.types ?? {};
     this.transition = this.transition.bind(this);
@@ -400,7 +377,7 @@ class StateMachine {
       guards,
       actors,
       delays
-    } = this.options;
+    } = this.implementations;
     return new StateMachine(this.config, {
       actions: {
         ...actions,
@@ -438,10 +415,9 @@ class StateMachine {
       done: actors_dist_xstateActors.isInFinalState(configuration)
     });
   }
-  resolveStateValue(stateValue) {
+  resolveStateValue(stateValue, ...[context]) {
     const resolvedStateValue = actors_dist_xstateActors.resolveStateValue(this.root, stateValue);
-    const resolvedContext = this.getContext();
-    return this.resolveState(actors_dist_xstateActors.State.from(resolvedStateValue, resolvedContext, this));
+    return this.resolveState(actors_dist_xstateActors.State.from(resolvedStateValue, context, this));
   }
 
   /**
@@ -480,22 +456,27 @@ class StateMachine {
    * The initial state _before_ evaluating any microsteps.
    * This "pre-initial" state is provided to initial actions executed in the initial state.
    */
-  getPreInitialState(actorCtx, input) {
-    const [context, actions] = this.getContextAndActions(actorCtx, input);
-    const config = actors_dist_xstateActors.getInitialConfiguration(this.root);
+  getPreInitialState(actorCtx, initEvent) {
+    const {
+      context
+    } = this.config;
     const preInitial = this.resolveState(this.createState({
       value: {},
       // TODO: this is computed in state constructor
-      context,
+      context: typeof context !== 'function' && context ? context : {},
       meta: undefined,
-      configuration: config,
-      transitions: [],
+      configuration: actors_dist_xstateActors.getInitialConfiguration(this.root),
       children: {}
     }));
-    preInitial._initial = true;
-    if (actorCtx) {
-      const [nextState] = actors_dist_xstateActors.resolveActionsAndContext(actions, actors_dist_xstateActors.initEvent, preInitial, actorCtx);
-      preInitial.children = nextState.children;
+    if (typeof context === 'function') {
+      const assignment = ({
+        spawn,
+        event
+      }) => context({
+        spawn,
+        input: event.input
+      });
+      return actors_dist_xstateActors.resolveActionsAndContext([actors_dist_xstateActors.assign(assignment)], initEvent, preInitial, actorCtx);
     }
     return preInitial;
   }
@@ -506,8 +487,15 @@ class StateMachine {
   getInitialState(actorCtx, input) {
     const initEvent = actors_dist_xstateActors.createInitEvent(input); // TODO: fix;
 
-    const preInitialState = this.getPreInitialState(actorCtx, input);
-    const nextState = actors_dist_xstateActors.microstep([], preInitialState, actorCtx, initEvent);
+    const preInitialState = this.getPreInitialState(actorCtx, initEvent);
+    const nextState = actors_dist_xstateActors.microstep([{
+      target: [...preInitialState.configuration].filter(actors_dist_xstateActors.isAtomicStateNode),
+      source: this.root,
+      reenter: true,
+      actions: [],
+      eventType: null,
+      toJSON: null // TODO: fix
+    }], preInitialState, actorCtx, initEvent, true);
     const {
       state: macroState
     } = actors_dist_xstateActors.macrostep(nextState, initEvent, actorCtx);
@@ -526,7 +514,7 @@ class StateMachine {
     });
   }
   getStateNodeById(stateId) {
-    const fullPath = stateId.split(this.delimiter);
+    const fullPath = stateId.split(actors_dist_xstateActors.STATE_DELIMITER);
     const relativePath = fullPath.slice(1);
     const resolvedStateId = actors_dist_xstateActors.isStateId(fullPath[0]) ? fullPath[0].slice(STATE_IDENTIFIER.length) : fullPath[0];
     const stateNode = this.idMap.get(resolvedStateId);
@@ -536,10 +524,7 @@ class StateMachine {
     return actors_dist_xstateActors.getStateNodeByPath(stateNode, relativePath);
   }
   get definition() {
-    return {
-      context: this.getContext(),
-      ...this.root.definition
-    };
+    return this.root.definition;
   }
   toJSON() {
     return this.definition;
@@ -564,7 +549,7 @@ class StateMachine {
       const actorData = state.children[actorId];
       const childState = actorData.state;
       const src = actorData.src;
-      const logic = src ? actors_dist_xstateActors.resolveReferencedActor(this.options.actors[src])?.src : undefined;
+      const logic = src ? actors_dist_xstateActors.resolveReferencedActor(this.implementations.actors[src])?.src : undefined;
       if (!logic) {
         return;
       }
@@ -591,7 +576,7 @@ class StateMachine {
           if (children[id]) {
             return;
           }
-          const referenced = actors_dist_xstateActors.resolveReferencedActor(this.options.actors[src]);
+          const referenced = actors_dist_xstateActors.resolveReferencedActor(this.implementations.actors[src]);
           if (referenced) {
             const actorRef = actors_dist_xstateActors.interpret(referenced.src, {
               id,