xstate 5.0.0-alpha.3 → 5.0.0-alpha.5

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

@@ -1,4 +1,4 @@
-import { MachineConfig, EventObject, AnyEventObject, MachineContext, ActorMap, InternalMachineImplementations, ParameterizedObject } from './types.js';
-import { TypegenConstraint, TypegenDisabled, ResolveTypegenMeta } from './typegenTypes.js';
-import { StateMachine } from './StateMachine.js';
+import { MachineConfig, EventObject, AnyEventObject, MachineContext, ActorMap, InternalMachineImplementations, ParameterizedObject } from './types.ts';
+import { TypegenConstraint, TypegenDisabled, ResolveTypegenMeta } from './typegenTypes.ts';
+import { StateMachine } from './StateMachine.ts';
 export declare function createMachine<TContext extends MachineContext, TEvent extends EventObject = AnyEventObject, TActorMap extends ActorMap = ActorMap, TTypesMeta extends TypegenConstraint = TypegenDisabled>(config: MachineConfig<TContext, TEvent, ParameterizedObject, TActorMap, TTypesMeta>, implementations?: InternalMachineImplementations<TContext, TEvent, ResolveTypegenMeta<TTypesMeta, TEvent, ParameterizedObject, TActorMap>>): StateMachine<TContext, TEvent, ParameterizedObject, TActorMap, ResolveTypegenMeta<TTypesMeta, TEvent, ParameterizedObject, TActorMap>>;

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

@@ -1,4 +1,4 @@
-import { Clock } from './interpreter.js';
+import { Clock } from './interpreter.ts';
 export interface SimulatedClock extends Clock {
     start(speed: number): void;
     increment(ms: number): void;

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

@@ -1,6 +1,6 @@
-import type { StateNode } from './StateNode.js';
-import { TypegenDisabled, TypegenEnabled } from './typegenTypes.js';
-import type { ActorRef, AnyState, AnyStateMachine, BaseActionObject, EventObject, HistoryValue, MachineContext, PersistedMachineState, Prop, SCXML, StateConfig, StateValue, TransitionDefinition } from './types.js';
+import type { StateNode } from './StateNode.ts';
+import { TypegenDisabled, TypegenEnabled } from './typegenTypes.ts';
+import type { ActorRef, AnyState, AnyStateMachine, BaseActionObject, EventObject, HistoryValue, MachineContext, PersistedMachineState, Prop, SCXML, StateConfig, StateValue, TransitionDefinition } from './types.ts';
 export declare function isStateConfig<TContext extends MachineContext, TEvent extends EventObject>(state: any): state is StateConfig<TContext, TEvent>;
 /**
  * @deprecated Use `isStateConfig(object)` or `state instanceof State` instead.

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

@@ -1,7 +1,7 @@
-import { State } from './State.js';
-import { StateNode } from './StateNode.js';
-import type { AreAllImplementationsAssumedToBeProvided, MarkAllImplementationsAsProvided, ResolveTypegenMeta, TypegenDisabled } from './typegenTypes.js';
-import type { ActorContext, ActorMap, ActorBehavior, EventObject, InternalMachineImplementations, MachineConfig, MachineContext, MachineImplementationsSimplified, MachineSchema, NoInfer, SCXML, StateConfig, StateMachineDefinition, StateValue, TransitionDefinition, AnyActorContext, PersistedMachineState, ParameterizedObject } from './types.js';
+import { State } from './State.ts';
+import { StateNode } from './StateNode.ts';
+import type { AreAllImplementationsAssumedToBeProvided, MarkAllImplementationsAsProvided, ResolveTypegenMeta, TypegenDisabled } from './typegenTypes.ts';
+import type { ActorContext, ActorMap, ActorBehavior, EventObject, InternalMachineImplementations, MachineConfig, MachineContext, MachineImplementationsSimplified, MachineSchema, NoInfer, SCXML, StateConfig, StateMachineDefinition, StateValue, TransitionDefinition, PersistedMachineState, ParameterizedObject, AnyActorContext } from './types.ts';
 export declare const NULL_EVENT = "";
 export declare const STATE_IDENTIFIER = "#";
 export declare const WILDCARD = "*";

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

@@ -1,6 +1,6 @@
-import type { EventObject, StateNodeDefinition, TransitionDefinition, DelayedTransitionDefinition, StateNodeConfig, StateNodesConfig, InvokeDefinition, Mapper, PropertyMapper, SCXML, TransitionDefinitionMap, InitialTransitionDefinition, MachineContext, BaseActionObject } from './types.js';
-import type { State } from './State.js';
-import type { StateMachine } from './StateMachine.js';
+import type { EventObject, StateNodeDefinition, TransitionDefinition, DelayedTransitionDefinition, StateNodeConfig, StateNodesConfig, InvokeDefinition, Mapper, PropertyMapper, SCXML, TransitionDefinitionMap, InitialTransitionDefinition, MachineContext, BaseActionObject } from './types.ts';
+import type { State } from './State.ts';
+import type { StateMachine } from './StateMachine.ts';
 interface StateNodeOptions<TContext extends MachineContext, TEvent extends EventObject> {
     _key: string;
     _parent?: StateNode<TContext, TEvent>;

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

@@ -1,4 +1,4 @@
-import { ActionTypes } from './types.js';
+import { ActionTypes } from './types.ts';
 export declare const stop = ActionTypes.Stop;
 export declare const raise = ActionTypes.Raise;
 export declare const send = ActionTypes.Send;

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

@@ -1,4 +1,4 @@
-import type { EventObject, Assigner, PropertyAssigner, MachineContext, DynamicAssignAction, LowInfer } from '../types.js';
+import type { EventObject, Assigner, PropertyAssigner, MachineContext, DynamicAssignAction, LowInfer } from '../types.ts';
 /**
  * Updates the current context of the machine.
  *

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

@@ -1,5 +1,5 @@
-import { EventObject, ExprWithMeta, MachineContext } from '../types.js';
-import { BaseDynamicActionObject, CancelActionObject, DynamicCancelActionObject } from '../index.js';
+import { EventObject, ExprWithMeta, MachineContext } from '../types.ts';
+import { BaseDynamicActionObject, CancelActionObject, DynamicCancelActionObject } from '../index.ts';
 /**
  * Cancels an in-flight `send(...)` action. A canceled sent action will not
  * be executed, nor will its event be sent, unless it has already been sent

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

@@ -1,3 +1,3 @@
-import { EventObject, ChooseCondition, MachineContext } from '../types.js';
-import { BaseDynamicActionObject, ChooseAction, ResolvedChooseAction } from '../index.js';
+import { EventObject, ChooseCondition, MachineContext } from '../types.ts';
+import { BaseDynamicActionObject, ChooseAction, ResolvedChooseAction } from '../index.ts';
 export declare function choose<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject>(guards: Array<ChooseCondition<TContext, TExpressionEvent>>): BaseDynamicActionObject<TContext, TExpressionEvent, TEvent, ResolvedChooseAction, ChooseAction<TContext, TExpressionEvent>['params']>;

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

@@ -1,3 +1,3 @@
-import { EventObject, InvokeDefinition, MachineContext } from '../types.js';
-import { BaseDynamicActionObject, DynamicInvokeActionObject, InvokeActionObject } from '../index.js';
+import { EventObject, InvokeDefinition, MachineContext } from '../types.ts';
+import { BaseDynamicActionObject, DynamicInvokeActionObject, InvokeActionObject } from '../index.ts';
 export declare function invoke<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject>(invokeDef: InvokeDefinition<TContext, TEvent>): BaseDynamicActionObject<TContext, TExpressionEvent, TEvent, InvokeActionObject, DynamicInvokeActionObject<TContext, TEvent>['params']>;

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

@@ -1,5 +1,5 @@
-import { EventObject, LogExpr, MachineContext, LogActionObject } from '../types.js';
-import { BaseDynamicActionObject, DynamicLogAction } from '../index.js';
+import { EventObject, LogExpr, MachineContext, LogActionObject } from '../types.ts';
+import { BaseDynamicActionObject, DynamicLogAction } from '../index.ts';
 /**
  *
  * @param expr The expression function to evaluate which will be logged.

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

@@ -1,4 +1,4 @@
-import { EventObject, SingleOrArray, MachineContext } from '../types.js';
+import { EventObject, SingleOrArray, MachineContext } from '../types.ts';
 import { BaseActionObject, BaseDynamicActionObject, DynamicPureActionObject, PureActionObject } from '..';
 export declare function pure<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent>(getActions: ({ context, event }: {
     context: TContext;

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

@@ -1,4 +1,4 @@
-import { EventObject, MachineContext, RaiseActionObject, BaseDynamicActionObject, RaiseActionOptions, SendExpr, RaiseActionParams, NoInfer } from '../types.js';
+import { EventObject, MachineContext, RaiseActionObject, BaseDynamicActionObject, RaiseActionOptions, SendExpr, RaiseActionParams, NoInfer } from '../types.ts';
 /**
  * Raises an event. This places the event in the internal event queue, so that
  * the event is immediately consumed by the machine in the current step.

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

@@ -1,5 +1,5 @@
-import { EventObject, SendActionParams, SendExpr, AnyEventObject, MachineContext } from '../types.js';
-import { AnyActorRef, BaseDynamicActionObject, Cast, EventFrom, ExprWithMeta, InferEvent, SendActionObject, SendActionOptions } from '../index.js';
+import { EventObject, SendActionParams, SendExpr, AnyEventObject, MachineContext } from '../types.ts';
+import { AnyActorRef, BaseDynamicActionObject, Cast, EventFrom, ExprWithMeta, InferEvent, SendActionObject, SendActionOptions } from '../index.ts';
 /**
  * Sends an event. This returns an action that will be read by an interpreter to
  * send the event in the next step, after the current step is finished executing.

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

@@ -1,4 +1,4 @@
-import { ActorRef, BaseDynamicActionObject, DynamicStopActionObject, EventObject, Expr, MachineContext, StopActionObject } from '../types.js';
+import { ActorRef, BaseDynamicActionObject, DynamicStopActionObject, EventObject, Expr, MachineContext, StopActionObject } from '../types.ts';
 /**
  * Stops an actor.
  *

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

@@ -1,19 +1,19 @@
-import { Action, EventObject, SingleOrArray, ActionFunction, ActionFunctionMap, ActionTypes, DoneEvent, ErrorPlatformEvent, DoneEventObject, MachineContext, BaseActionObject, SCXML } from './types.js';
-import * as actionTypes from './actionTypes.js';
-export { send, sendTo, sendParent, respond, forwardTo, escalate } from './actions/send.js';
-export { stop } from './actions/stop.js';
-export { log } from './actions/log.js';
-export { cancel } from './actions/cancel.js';
-export { assign } from './actions/assign.js';
-export { raise } from './actions/raise.js';
-export { choose } from './actions/choose.js';
+import { Action, EventObject, SingleOrArray, ActionFunction, ActionFunctionMap, ActionTypes, DoneEvent, ErrorPlatformEvent, DoneEventObject, MachineContext, BaseActionObject, SCXML } from './types.ts';
+import * as actionTypes from './actionTypes.ts';
+export { send, sendTo, sendParent, respond, forwardTo, escalate } from './actions/send.ts';
+export { stop } from './actions/stop.ts';
+export { log } from './actions/log.ts';
+export { cancel } from './actions/cancel.ts';
+export { assign } from './actions/assign.ts';
+export { raise } from './actions/raise.ts';
+export { choose } from './actions/choose.ts';
 export { actionTypes };
 export declare const initEvent: SCXML.Event<{
     type: ActionTypes;
 }>;
 export declare function resolveActionObject(actionObject: BaseActionObject, actionFunctionMap: ActionFunctionMap<any, any>): BaseActionObject;
 export declare function toActionObject<TContext extends MachineContext, TEvent extends EventObject>(action: BaseActionObject | ActionFunction<TContext, TEvent> | string): BaseActionObject;
-export declare const toActionObjects: <TContext extends MachineContext, TEvent extends EventObject>(action?: SingleOrArray<Action<TContext, TEvent, TEvent>> | undefined) => BaseActionObject[];
+export declare const toActionObjects: <TContext extends MachineContext, TEvent extends EventObject>(action?: SingleOrArray<Action<TContext, TEvent>> | undefined) => BaseActionObject[];
 /**
  * Returns an event type that represents an implicit event that
  * is sent after the specified `delay`.

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

@@ -1,8 +1,8 @@
-import type { EventObject, ActorRef, BaseActorRef } from '../types.js';
-export { fromTransition } from './transition.js';
-export { fromPromise } from './promise.js';
-export { fromObservable, fromEventObservable } from './observable.js';
-export { fromCallback } from './callback.js';
+import type { EventObject, ActorRef, BaseActorRef } from '../types.ts';
+export { fromTransition } from './transition.ts';
+export { fromPromise } from './promise.ts';
+export { fromObservable, fromEventObservable } from './observable.ts';
+export { fromCallback } from './callback.ts';
 export declare const startSignalType = "xstate.init";
 export declare const stopSignalType = "xstate.stop";
 export declare const startSignal: StartSignal;

package/dist/declarations/src/dev/index.d.ts

@@ -1,4 +1,4 @@
-import { AnyInterpreter, DevToolsAdapter } from '../types.js';
+import { AnyInterpreter, DevToolsAdapter } from '../types.ts';
 type ServiceListener = (service: AnyInterpreter) => void;
 export interface XStateDevInterface {
     register: (service: AnyInterpreter) => void;

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

@@ -1,5 +1,5 @@
-import type { EventObject, StateValue, BooleanGuardDefinition, GuardConfig, GuardDefinition, SCXML, GuardPredicate, MachineContext } from './types.js';
-import type { State } from './State.js';
+import type { EventObject, StateValue, BooleanGuardDefinition, GuardConfig, GuardDefinition, SCXML, GuardPredicate, MachineContext } from './types.ts';
+import type { State } from './State.ts';
 export declare function stateIn<TContext extends MachineContext, TEvent extends EventObject>(stateValue: StateValue): GuardDefinition<TContext, TEvent>;
 export declare function not<TContext extends MachineContext, TEvent extends EventObject>(guard: GuardConfig<TContext, TEvent>): BooleanGuardDefinition<TContext, TEvent>;
 export declare function and<TContext extends MachineContext, TEvent extends EventObject>(guards: Array<GuardConfig<TContext, TEvent>>): BooleanGuardDefinition<TContext, TEvent>;

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

@@ -1,24 +1,24 @@
-import { after, done, doneInvoke, escalate, forwardTo, respond, sendParent, sendTo } from './actions.js';
-import { assign } from './actions/assign.js';
-import { cancel } from './actions/cancel.js';
-import { choose } from './actions/choose.js';
-import { log } from './actions/log.js';
-import { pure } from './actions/pure.js';
-import { raise } from './actions/raise.js';
-import { send } from './actions/send.js';
-import { stop } from './actions/stop.js';
-import { interpret, Interpreter, ActorStatus } from './interpreter.js';
-import { createMachine } from './Machine.js';
-import { mapState } from './mapState.js';
-import { State } from './State.js';
-import { StateNode } from './StateNode.js';
-export { createSchema, t } from './schema.js';
-export { SimulatedClock } from './SimulatedClock.js';
-export { StateMachine } from './StateMachine.js';
-export { getStateNodes } from './stateUtils.js';
-export * from './typegenTypes.js';
-export * from './types.js';
-export { matchesState, pathToStateValue, toObserver, toSCXMLEvent } from './utils.js';
+import { after, done, doneInvoke, escalate, forwardTo, respond, sendParent, sendTo } from './actions.ts';
+import { assign } from './actions/assign.ts';
+import { cancel } from './actions/cancel.ts';
+import { choose } from './actions/choose.ts';
+import { log } from './actions/log.ts';
+import { pure } from './actions/pure.ts';
+import { raise } from './actions/raise.ts';
+import { send } from './actions/send.ts';
+import { stop } from './actions/stop.ts';
+import { interpret, Interpreter, ActorStatus } from './interpreter.ts';
+import { createMachine } from './Machine.ts';
+import { mapState } from './mapState.ts';
+import { State } from './State.ts';
+import { StateNode } from './StateNode.ts';
+export { createSchema, t } from './schema.ts';
+export { SimulatedClock } from './SimulatedClock.ts';
+export { StateMachine } from './StateMachine.ts';
+export { getStateNodes } from './stateUtils.ts';
+export * from './typegenTypes.ts';
+export * from './types.ts';
+export { matchesState, pathToStateValue, toObserver, toSCXMLEvent } from './utils.ts';
 export { StateNode, State, mapState, actions, assign, send, sendTo, sendParent, forwardTo, interpret, Interpreter, ActorStatus as InterpreterStatus, doneInvoke, createMachine };
 declare const actions: {
     raise: typeof raise;

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

@@ -1,7 +1,7 @@
-import type { AnyStateMachine, EventFromBehavior, InterpreterFrom, PersistedStateFrom, SnapshotFrom, ActorSystem, AnyActorBehavior, RaiseActionObject } from './types.js';
-import { AreAllImplementationsAssumedToBeProvided } from './typegenTypes.js';
-import { ActorRef, DoneEvent, EventObject, InteropSubscribable, InterpreterOptions, Observer, SCXML, SendActionObject, Subscription } from './types.js';
-import { symbolObservable } from './symbolObservable.js';
+import { symbolObservable } from './symbolObservable.ts';
+import { AreAllImplementationsAssumedToBeProvided } from './typegenTypes.ts';
+import type { ActorSystem, AnyActorBehavior, AnyStateMachine, EventFromBehavior, InterpreterFrom, PersistedStateFrom, RaiseActionObject, SnapshotFrom } from './types.ts';
+import { ActorRef, DoneEvent, EventObject, InteropSubscribable, InterpreterOptions, Observer, SCXML, SendActionObject, Subscription } from './types.ts';
 export type SnapshotListener<TBehavior extends AnyActorBehavior> = (state: SnapshotFrom<TBehavior>) => void;
 export type EventListener<TEvent extends EventObject = EventObject> = (event: TEvent) => void;
 export type Listener = () => void;

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

@@ -1,2 +1,2 @@
-import { InvokeActionObject, AnyStateMachine, Spawner, ActorRef, MachineContext, EventObject, SCXML } from '.';
+import { InvokeActionObject, AnyStateMachine, Spawner, ActorRef, MachineContext, EventObject, SCXML } from './index.ts';
 export declare function createSpawner<TContext extends MachineContext, TEvent extends EventObject>(self: ActorRef<any, any> | undefined, machine: AnyStateMachine, context: TContext, _event: SCXML.Event<TEvent>, mutCapturedActions: InvokeActionObject[]): Spawner;

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

@@ -1,7 +1,7 @@
-import { BaseActionObject, EventObject, StateValue, TransitionConfig, TransitionDefinition, SingleOrArray, SCXML, StateValueMap, InitialTransitionConfig, MachineContext } from './types.js';
-import { State } from './State.js';
-import { NULL_EVENT } from './constants.js';
-import type { StateNode } from './StateNode.js';
+import { BaseActionObject, EventObject, StateValue, TransitionConfig, TransitionDefinition, SingleOrArray, SCXML, StateValueMap, InitialTransitionConfig, MachineContext } from './types.ts';
+import { State } from './State.ts';
+import { NULL_EVENT } from './constants.ts';
+import type { StateNode } from './StateNode.ts';
 import { AnyActorContext, AnyHistoryValue, AnyState, AnyStateMachine, AnyStateNode, AnyTransitionDefinition, DelayedTransitionDefinition, InitialTransitionDefinition, StateFromMachine } from '.';
 type Configuration<TContext extends MachineContext, TE extends EventObject> = Iterable<StateNode<TContext, TE>>;
 type AnyConfiguration = Configuration<any, any>;

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

@@ -1,4 +1,4 @@
-import { EventObject, IndexByType, IsNever, Prop, Values, IsAny, ActorMap, Cast, ParameterizedObject } from './types.js';
+import { EventObject, IndexByType, IsNever, Prop, Values, IsAny, ActorMap, Cast, ParameterizedObject } from './types.ts';
 export interface TypegenDisabled {
     '@@xstate/typegen': false;
 }

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

@@ -1,9 +1,9 @@
-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 type { StateNode } from './StateNode.ts';
+import type { State } from './State.ts';
+import type { ActorStatus, Clock, Interpreter } from './interpreter.ts';
+import type { StateMachine } from './StateMachine.ts';
+import type { LifecycleSignal } from './actors/index.ts';
+import { TypegenDisabled, ResolveTypegenMeta, TypegenConstraint, MarkAllImplementationsAsProvided, AreAllImplementationsAssumedToBeProvided } from './typegenTypes.ts';
 export type AnyFunction = (...args: any[]) => any;
 type ReturnTypeOrValue<T> = T extends AnyFunction ? ReturnType<T> : T;
 export type IsNever<T> = [T] extends [never] ? true : false;
@@ -70,10 +70,10 @@ export interface BaseDynamicActionObject<TContext extends MachineContext, TExpre
     (args: {
         context: TContext;
         event: TExpressionEvent;
-    } & ActionMeta<TContext, TEvent, ParameterizedObject>): void;
+    } & ActionMeta<TEvent, ParameterizedObject>): void;
 }
 export type MachineContext = Record<string, any>;
-export interface ActionMeta<TContext extends MachineContext, TEvent extends EventObject, TAction extends ParameterizedObject = ParameterizedObject> extends StateMeta<TContext, TEvent> {
+export interface ActionMeta<TEvent extends EventObject, TAction extends ParameterizedObject = ParameterizedObject> extends StateMeta<TEvent> {
     action: TAction;
     _event: SCXML.Event<TEvent>;
 }
@@ -82,7 +82,7 @@ behavior: T, options?: Partial<{
     id: string;
     input: any;
 }>) => T extends ActorBehavior<infer TActorEvent, infer TActorEmitted> ? ActorRef<TActorEvent, TActorEmitted> : ActorRef<any, any>;
-export interface AssignMeta<TContext extends MachineContext, TExpressionEvent extends EventObject, _TEvent extends EventObject> extends StateMeta<TContext, TExpressionEvent> {
+export interface AssignMeta<TExpressionEvent extends EventObject, _TEvent extends EventObject> extends StateMeta<TExpressionEvent> {
     action: BaseActionObject;
     _event: SCXML.Event<TExpressionEvent>;
     spawn: Spawner;
@@ -90,7 +90,7 @@ export interface AssignMeta<TContext extends MachineContext, TExpressionEvent ex
 export type ActionFunction<TContext extends MachineContext, TExpressionEvent extends EventObject, TAction extends ParameterizedObject = ParameterizedObject, TEvent extends EventObject = TExpressionEvent> = (args: {
     context: TContext;
     event: TExpressionEvent;
-} & ActionMeta<TContext, TEvent, TAction>) => void;
+} & ActionMeta<TEvent, TAction>) => void;
 export interface ChooseCondition<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent> {
     guard?: GuardConfig<TContext, TEvent>;
     actions: Actions<TContext, TExpressionEvent, TEvent>;
@@ -336,7 +336,6 @@ export interface StateNodeConfig<TContext extends MachineContext, TEvent extends
      * @private
      */
     parent?: StateNode<TContext, TEvent>;
-    strict?: boolean | undefined;
     /**
      * The meta data associated with this state node, which will be returned in State instances.
      */
@@ -635,7 +634,7 @@ export interface SendActionObject<TSentEvent extends EventObject = AnyEventObjec
     };
 }
 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<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 declare enum SpecialTargets {
     Parent = "#_parent",
@@ -669,11 +668,11 @@ export interface CancelActionObject extends BaseActionObject {
 export type Assigner<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent> = (args: {
     context: TContext;
     event: TExpressionEvent;
-} & AssignMeta<TContext, TExpressionEvent, TEvent>) => Partial<TContext>;
+} & 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<TContext, TExpressionEvent, TEvent>) => TContext[TKey];
+} & 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];
 };
@@ -782,8 +781,7 @@ export interface Segment<TContext extends MachineContext, TEvent extends EventOb
      */
     event: TEvent;
 }
-export interface StateMeta<TContext extends MachineContext, TEvent extends EventObject> {
-    state: State<TContext, TEvent, any>;
+export interface StateMeta<TEvent extends EventObject> {
     _event: SCXML.Event<TEvent>;
     self: ActorRef<TEvent>;
     system: ActorSystem<any>;

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

@@ -1,7 +1,7 @@
-import { AnyActorBehavior, AnyState } from '.';
-import { NULL_EVENT } from './constants.js';
-import type { StateNode } from './StateNode.js';
-import type { ActorBehavior, EventObject, EventType, InvokeConfig, MachineContext, Mapper, Observer, PropertyMapper, SCXML, SCXMLErrorEvent, SingleOrArray, StateLike, StateValue, Subscribable, TransitionConfig, TransitionConfigTarget } from './types.js';
+import { AnyActorBehavior, AnyState } from './index.ts';
+import { NULL_EVENT } from './constants.ts';
+import type { StateNode } from './StateNode.ts';
+import type { ActorBehavior, EventObject, EventType, InvokeConfig, MachineContext, Mapper, Observer, PropertyMapper, SCXML, SCXMLErrorEvent, SingleOrArray, StateLike, StateValue, Subscribable, TransitionConfig, TransitionConfigTarget } from './types.ts';
 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[];

package/dist/xstate.cjs.dev.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var actors_dist_xstateActors = require('./actions-3f0ba11b.cjs.dev.js');
+var actors_dist_xstateActors = require('./actions-96f799fc.cjs.dev.js');
 require('./index-ebaab3c9.cjs.dev.js');
 
 function pure(getActions) {
@@ -754,6 +754,7 @@ var StateMachine = /*#__PURE__*/function () {
           });
         }
       });
+      restoredState.actions = [];
       return restoredState;
     }
 

package/dist/xstate.cjs.prod.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var actors_dist_xstateActors = require('./actions-3910d35f.cjs.prod.js');
+var actors_dist_xstateActors = require('./actions-2479953d.cjs.prod.js');
 require('../dev/dist/xstate-dev.cjs.prod.js');
 
 function pure(getActions) {
@@ -754,6 +754,7 @@ var StateMachine = /*#__PURE__*/function () {
           });
         }
       });
+      restoredState.actions = [];
       return restoredState;
     }
 

package/dist/xstate.esm.js

@@ -1,5 +1,5 @@
-import { c as createDynamicAction, p as pure$1, t as toArray, a as toActionObjects, _ as _createClass, f as formatTransitions, b as toTransitionConfigArray, N as NULL_EVENT, d as formatTransition, m as mapValues, e as memo, g as _createForOfIteratorHelper, h as evaluateGuard, i as _toConsumableArray, j as flatten, k as _classCallCheck, l as _defineProperty, n as createInvokeId, o as toInvokeConfig, q as _objectSpread2, r as invoke, s as _objectWithoutProperties, u as getDelayedTransitions, v as formatInitialTransition, w as getCandidates, x as isString, y as createSpawner, z as createInitEvent, A as getConfiguration, B as getStateNodes, C as resolveStateValue, D as isInFinalState, S as State, E as toSCXMLEvent, F as isSCXMLErrorEvent, G as macrostep, H as transitionNode, I as _slicedToArray, J as getInitialConfiguration, K as resolveActionsAndContext, L as microstep, M as error, O as isStateId, P as getPersistedState, Q as resolveReferencedActor, R as interpret, T as STATE_DELIMITER, U as initEvent, V as matchesState, W as raise, X as send, Y as sendParent, Z as sendTo, $ as log, a0 as cancel, a1 as stop, a2 as assign, a3 as after, a4 as done, a5 as respond, a6 as forwardTo, a7 as escalate, a8 as choose } from './actions-4fe4ada8.esm.js';
-export { ae as ActionTypes, a9 as Interpreter, aa as InterpreterStatus, af as SpecialTargets, S as State, a2 as assign, ab as doneInvoke, a6 as forwardTo, B as getStateNodes, R as interpret, V as matchesState, ac as pathToStateValue, X as send, Y as sendParent, Z as sendTo, ad as toObserver, E as toSCXMLEvent } from './actions-4fe4ada8.esm.js';
+import { c as createDynamicAction, p as pure$1, t as toArray, a as toActionObjects, _ as _createClass, f as formatTransitions, b as toTransitionConfigArray, N as NULL_EVENT, d as formatTransition, m as mapValues, e as memo, g as _createForOfIteratorHelper, h as evaluateGuard, i as _toConsumableArray, j as flatten, k as _classCallCheck, l as _defineProperty, n as createInvokeId, o as toInvokeConfig, q as _objectSpread2, r as invoke, s as _objectWithoutProperties, u as getDelayedTransitions, v as formatInitialTransition, w as getCandidates, x as isString, y as createSpawner, z as createInitEvent, A as getConfiguration, B as getStateNodes, C as resolveStateValue, D as isInFinalState, S as State, E as toSCXMLEvent, F as isSCXMLErrorEvent, G as macrostep, H as transitionNode, I as _slicedToArray, J as getInitialConfiguration, K as resolveActionsAndContext, L as microstep, M as error, O as isStateId, P as getPersistedState, Q as resolveReferencedActor, R as interpret, T as STATE_DELIMITER, U as initEvent, V as matchesState, W as raise, X as send, Y as sendParent, Z as sendTo, $ as log, a0 as cancel, a1 as stop, a2 as assign, a3 as after, a4 as done, a5 as respond, a6 as forwardTo, a7 as escalate, a8 as choose } from './actions-7678b87b.esm.js';
+export { ae as ActionTypes, a9 as Interpreter, aa as InterpreterStatus, af as SpecialTargets, S as State, a2 as assign, ab as doneInvoke, a6 as forwardTo, B as getStateNodes, R as interpret, V as matchesState, ac as pathToStateValue, X as send, Y as sendParent, Z as sendTo, ad as toObserver, E as toSCXMLEvent } from './actions-7678b87b.esm.js';
 import './index-50bd0aff.esm.js';
 
 function pure(getActions) {
@@ -751,6 +751,7 @@ var StateMachine = /*#__PURE__*/function () {
           });
         }
       });
+      restoredState.actions = [];
       return restoredState;
     }