xstate 5.0.0-beta.12 → 5.0.0-beta.14

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

@@ -1,4 +1,4 @@
-import { MachineConfig, EventObject, AnyEventObject, MachineContext, ActorMap, InternalMachineImplementations, ParameterizedObject } from './types.ts';
-import { TypegenConstraint, TypegenDisabled, ResolveTypegenMeta } from './typegenTypes.ts';
-import { StateMachine } from './StateMachine.ts';
+import { MachineConfig, EventObject, AnyEventObject, MachineContext, ActorMap, InternalMachineImplementations, ParameterizedObject } from "./types.js";
+import { TypegenConstraint, TypegenDisabled, ResolveTypegenMeta } from "./typegenTypes.js";
+import { StateMachine } from "./StateMachine.js";
 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.ts';
+import { Clock } from "./interpreter.js";
 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.ts';
-import { TypegenDisabled, TypegenEnabled } from './typegenTypes.ts';
-import type { ActorRef, AnyState, AnyStateMachine, BaseActionObject, EventObject, HistoryValue, MachineContext, PersistedMachineState, Prop, StateConfig, StateValue, TransitionDefinition } from './types.ts';
+import type { StateNode } from "./StateNode.js";
+import { TypegenDisabled, TypegenEnabled } from "./typegenTypes.js";
+import type { ActorRef, AnyState, AnyStateMachine, EventObject, HistoryValue, MachineContext, PersistedMachineState, Prop, StateConfig, StateValue } from "./types.js";
 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.
@@ -20,8 +20,6 @@ export declare class State<TContext extends MachineContext, TEvent extends Event
     output: any;
     context: TContext;
     historyValue: Readonly<HistoryValue<TContext, TEvent>>;
-    actions: BaseActionObject[];
-    event: TEvent;
     _internalQueue: Array<TEvent>;
     _initial: boolean;
     /**
@@ -37,10 +35,6 @@ export declare class State<TContext extends MachineContext, TEvent extends Event
      * The enabled state nodes representative of the state value.
      */
     configuration: Array<StateNode<TContext, TEvent>>;
-    /**
-     * The transition definitions that resulted in this state.
-     */
-    transitions: Array<TransitionDefinition<TContext, TEvent>>;
     /**
      * An object mapping actor names to spawned/invoked actors.
      */
@@ -63,7 +57,7 @@ export declare class State<TContext extends MachineContext, TEvent extends Event
      * @param delimiter The character(s) that separate each subpath in the string state node path.
      */
     toStrings(stateValue?: StateValue, delimiter?: string): string[];
-    toJSON(): Omit<this, "meta" | "toJSON" | "configuration" | "transitions" | "tags" | "machine" | "toStrings" | "matches" | "hasTag" | "can" | "nextEvents"> & {
+    toJSON(): Omit<this, "meta" | "toJSON" | "configuration" | "tags" | "machine" | "toStrings" | "matches" | "hasTag" | "can" | "nextEvents"> & {
         tags: string[];
         meta: Record<string, any>;
     };

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

@@ -1,11 +1,11 @@
-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, MachineTypes, NoInfer, StateConfig, StateMachineDefinition, StateValue, TransitionDefinition, PersistedMachineState, ParameterizedObject, AnyActorContext } from './types.ts';
+import { State } from "./State.js";
+import { StateNode } from "./StateNode.js";
+import type { AreAllImplementationsAssumedToBeProvided, MarkAllImplementationsAsProvided, ResolveTypegenMeta, TypegenDisabled } from "./typegenTypes.js";
+import type { ActorContext, ActorLogic, ActorMap, EventObject, InternalMachineImplementations, MachineConfig, MachineContext, MachineImplementationsSimplified, MachineTypes, NoInfer, StateConfig, StateMachineDefinition, StateValue, TransitionDefinition, PersistedMachineState, ParameterizedObject, AnyActorContext } from "./types.js";
 export declare const NULL_EVENT = "";
 export declare const STATE_IDENTIFIER = "#";
 export declare const WILDCARD = "*";
-export declare class StateMachine<TContext extends MachineContext, TEvent extends EventObject = EventObject, TAction extends ParameterizedObject = ParameterizedObject, TActorMap extends ActorMap = ActorMap, TResolvedTypesMeta = ResolveTypegenMeta<TypegenDisabled, NoInfer<TEvent>, TAction, TActorMap>> implements ActorBehavior<TEvent, State<TContext, TEvent, TResolvedTypesMeta>, State<TContext, TEvent, TResolvedTypesMeta>, PersistedMachineState<State<TContext, TEvent, TResolvedTypesMeta>>> {
+export declare class StateMachine<TContext extends MachineContext, TEvent extends EventObject = EventObject, TAction extends ParameterizedObject = ParameterizedObject, TActorMap extends ActorMap = ActorMap, TResolvedTypesMeta = ResolveTypegenMeta<TypegenDisabled, NoInfer<TEvent>, TAction, TActorMap>> implements ActorLogic<TEvent, State<TContext, TEvent, TResolvedTypesMeta>, State<TContext, TEvent, TResolvedTypesMeta>, PersistedMachineState<State<TContext, TEvent, TResolvedTypesMeta>>> {
     /**
      * The raw config used to create the machine.
      */
@@ -59,7 +59,7 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
      * @param state The current State instance or state value
      * @param event The received event
      */
-    transition(state: StateValue | State<TContext, TEvent, TResolvedTypesMeta> | undefined, event: TEvent, actorCtx?: ActorContext<TEvent, State<TContext, TEvent, any>>): State<TContext, TEvent, TResolvedTypesMeta>;
+    transition(state: State<TContext, TEvent, TResolvedTypesMeta>, event: TEvent, actorCtx: ActorContext<TEvent, State<TContext, TEvent, any>>): State<TContext, TEvent, TResolvedTypesMeta>;
     /**
      * Determines the next state given the current `state` and `event`.
      * Calculates a microstep.
@@ -67,22 +67,17 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
      * @param state The current state
      * @param event The received event
      */
-    microstep(state: State<TContext, TEvent, TResolvedTypesMeta> | undefined, event: TEvent, actorCtx?: AnyActorContext | undefined): Array<State<TContext, TEvent, TResolvedTypesMeta>>;
+    microstep(state: State<TContext, TEvent, TResolvedTypesMeta>, event: TEvent, actorCtx: AnyActorContext): Array<State<TContext, TEvent, TResolvedTypesMeta>>;
     getTransitionData(state: State<TContext, TEvent, TResolvedTypesMeta>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>>;
     /**
      * The initial state _before_ evaluating any microsteps.
      * This "pre-initial" state is provided to initial actions executed in the initial state.
      */
     private getPreInitialState;
-    /**
-     * The initial State instance, which includes all actions to be executed from
-     * entering the initial state.
-     */
-    get initialState(): State<TContext, TEvent, TResolvedTypesMeta>;
     /**
      * Returns the initial `State` instance, with reference to `self` as an `ActorRef`.
      */
-    getInitialState(actorCtx?: ActorContext<TEvent, State<TContext, TEvent, TResolvedTypesMeta>>, input?: any): State<TContext, TEvent, TResolvedTypesMeta>;
+    getInitialState(actorCtx: ActorContext<TEvent, State<TContext, TEvent, TResolvedTypesMeta>>, input?: any): State<TContext, TEvent, TResolvedTypesMeta>;
     start(state: State<TContext, TEvent, TResolvedTypesMeta>, actorCtx: ActorContext<TEvent, State<TContext, TEvent, TResolvedTypesMeta>>): void;
     getStateNodeById(stateId: string): StateNode<TContext, TEvent>;
     get definition(): StateMachineDefinition<TContext, TEvent>;

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

@@ -1,6 +1,6 @@
-import type { EventObject, StateNodeDefinition, TransitionDefinition, DelayedTransitionDefinition, StateNodeConfig, StateNodesConfig, InvokeDefinition, Mapper, PropertyMapper, TransitionDefinitionMap, InitialTransitionDefinition, MachineContext, BaseActionObject } from './types.ts';
-import type { State } from './State.ts';
-import type { StateMachine } from './StateMachine.ts';
+import type { EventObject, StateNodeDefinition, TransitionDefinition, DelayedTransitionDefinition, StateNodeConfig, StateNodesConfig, InvokeDefinition, Mapper, PropertyMapper, TransitionDefinitionMap, InitialTransitionDefinition, MachineContext, BaseActionObject } from "./types.js";
+import type { State } from "./State.js";
+import type { StateMachine } from "./StateMachine.js";
 interface StateNodeOptions<TContext extends MachineContext, TEvent extends EventObject> {
     _key: string;
     _parent?: StateNode<TContext, TEvent>;
@@ -88,7 +88,7 @@ export declare class StateNode<TContext extends MachineContext = MachineContext,
     get definition(): StateNodeDefinition<TContext, TEvent>;
     toJSON(): StateNodeDefinition<TContext, TEvent>;
     /**
-     * The behaviors invoked as actors by this state node.
+     * The logic invoked as actors by this state node.
      */
     get invoke(): Array<InvokeDefinition<TContext, TEvent>>;
     /**

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

@@ -1,4 +1,4 @@
-import { ActionTypes } from './types.ts';
+import { ActionTypes } from "./types.js";
 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.ts';
+import type { EventObject, Assigner, PropertyAssigner, MachineContext, DynamicAssignAction, LowInfer } from "../types.js";
 /**
  * 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.ts';
-import { BaseDynamicActionObject, CancelActionObject, DynamicCancelActionObject } from '../index.ts';
+import { EventObject, ExprWithMeta, MachineContext } from "../types.js";
+import { BaseDynamicActionObject, CancelActionObject, DynamicCancelActionObject } from "../index.js";
 /**
  * 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.ts';
-import { BaseDynamicActionObject, ChooseAction, ResolvedChooseAction } from '../index.ts';
+import { EventObject, ChooseCondition, MachineContext } from "../types.js";
+import { BaseDynamicActionObject, ChooseAction, ResolvedChooseAction } from "../index.js";
 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/log.d.ts

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

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

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

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

@@ -1,4 +1,4 @@
-import { EventObject, MachineContext, RaiseActionObject, BaseDynamicActionObject, RaiseActionOptions, SendExpr, RaiseActionParams, NoInfer } from '../types.ts';
+import { EventObject, MachineContext, RaiseActionObject, BaseDynamicActionObject, RaiseActionOptions, SendExpr, RaiseActionParams, NoInfer } from "../types.js";
 /**
  * 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.ts';
-import { AnyActorRef, BaseDynamicActionObject, Cast, EventFrom, ExprWithMeta, InferEvent, SendActionObject, SendActionOptions } from '../index.ts';
+import { EventObject, SendActionParams, SendExpr, AnyEventObject, MachineContext } from "../types.js";
+import { AnyActorRef, BaseDynamicActionObject, Cast, EventFrom, ExprWithMeta, InferEvent, SendActionObject, SendActionOptions } from "../index.js";
 /**
  * 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.ts';
+import { ActorRef, BaseDynamicActionObject, DynamicStopActionObject, EventObject, Expr, MachineContext, StopActionObject } from "../types.js";
 /**
  * Stops an actor.
  *

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

@@ -1,13 +1,13 @@
-import { Action, EventObject, SingleOrArray, ActionFunction, ActionFunctionMap, ActionTypes, DoneEvent, ErrorPlatformEvent, DoneEventObject, MachineContext, BaseActionObject } from './types.ts';
-import * as actionTypes from './actionTypes.ts';
-export { send, sendTo, sendParent, 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 { pure } from './actions/pure.ts';
+import { Action, EventObject, SingleOrArray, ActionFunction, ActionFunctionMap, ActionTypes, DoneEvent, ErrorPlatformEvent, DoneEventObject, MachineContext, BaseActionObject } from "./types.js";
+import * as actionTypes from "./actionTypes.js";
+export { send, sendTo, sendParent, 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";
+export { pure } from "./actions/pure.js";
 export { actionTypes };
 export declare const initEvent: {
     type: ActionTypes;

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

@@ -1,8 +1,8 @@
-import { InvokeCallback, ActorBehavior, EventObject } from '../types';
+import { InvokeCallback, ActorLogic, EventObject } from "../types.js";
 export interface CallbackInternalState {
     canceled: boolean;
     receivers: Set<(e: EventObject) => void>;
     dispose: void | (() => void) | Promise<any>;
     input?: any;
 }
-export declare function fromCallback<TEvent extends EventObject>(invokeCallback: InvokeCallback): ActorBehavior<TEvent, undefined>;
+export declare function fromCallback<TEvent extends EventObject>(invokeCallback: InvokeCallback): ActorLogic<TEvent, undefined, CallbackInternalState>;

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

@@ -1,8 +1,8 @@
-import type { EventObject, ActorRef, BaseActorRef, AnyEventObject } from '../types.ts';
-export { fromTransition } from './transition.ts';
-export { fromPromise } from './promise.ts';
-export { fromObservable, fromEventObservable } from './observable.ts';
-export { fromCallback } from './callback.ts';
+import type { EventObject, ActorRef, BaseActorRef, AnyEventObject } from "../types.js";
+export { fromTransition } from "./transition.js";
+export { fromPromise } from "./promise.js";
+export { fromObservable, fromEventObservable } from "./observable.js";
+export { fromCallback } from "./callback.js";
 export declare const startSignalType = "xstate.init";
 export declare const stopSignalType = "xstate.stop";
 export declare const startSignal: StartSignal;
@@ -16,7 +16,7 @@ export interface StopSignal {
 export type LifecycleSignal = StartSignal | StopSignal;
 export type LifecycleSignalType = typeof startSignalType | typeof stopSignalType;
 /**
- * An object that expresses the behavior of an actor in reaction to received events,
+ * An object that expresses the actor logic in reaction to received events,
  * as well as an optionally emitted stream of values.
  *
  * @template TReceived The received event

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

@@ -1,4 +1,4 @@
-import { Subscribable, ActorBehavior, EventObject, Subscription } from '../types';
+import { Subscribable, ActorLogic, EventObject, Subscription, AnyActorSystem } from "../types.js";
 export interface ObservableInternalState<T> {
     subscription: Subscription | undefined;
     status: 'active' | 'done' | 'error' | 'canceled';
@@ -6,17 +6,19 @@ export interface ObservableInternalState<T> {
     input?: any;
 }
 export type ObservablePersistedState<T> = Omit<ObservableInternalState<T>, 'subscription'>;
-export declare function fromObservable<T, TEvent extends EventObject>(observableCreator: ({ input }: {
+export declare function fromObservable<T, TEvent extends EventObject>(observableCreator: ({ input, system }: {
     input: any;
-}) => Subscribable<T>): ActorBehavior<TEvent, T | undefined, ObservableInternalState<T>, ObservablePersistedState<T>>;
+    system: AnyActorSystem;
+}) => Subscribable<T>): ActorLogic<TEvent, T | undefined, ObservableInternalState<T>, ObservablePersistedState<T>>;
 /**
- * Creates an event observable behavior that listens to an observable
+ * Creates event observable logic that listens to an observable
  * that delivers event objects.
  *
  *
  * @param lazyObservable A function that creates an observable
- * @returns An event observable behavior
+ * @returns Event observable logic
  */
 export declare function fromEventObservable<T extends EventObject>(lazyObservable: ({ input }: {
     input: any;
-}) => Subscribable<T>): ActorBehavior<EventObject, T | undefined>;
+    system: AnyActorSystem;
+}) => Subscribable<T>): ActorLogic<EventObject, T | undefined, ObservableInternalState<T>, ObservablePersistedState<T>>;

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

@@ -1,11 +1,12 @@
-import { ActorBehavior } from '../types';
+import { ActorLogic, AnyActorSystem } from "../types.js";
 export interface PromiseInternalState<T> {
     status: 'active' | 'error' | 'done' | 'canceled';
     data: T | undefined;
     input?: any;
 }
-export declare function fromPromise<T>(promiseCreator: ({ input }: {
+export declare function fromPromise<T>(promiseCreator: ({ input, system }: {
     input: any;
-}) => PromiseLike<T>): ActorBehavior<{
+    system: AnyActorSystem;
+}) => PromiseLike<T>): ActorLogic<{
     type: string;
 }, T | undefined, PromiseInternalState<T>>;

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

@@ -1,13 +1,13 @@
-import { ActorBehavior, ActorContext, ActorSystem, EventObject } from '../types';
+import { ActorLogic, ActorContext, ActorSystem, EventObject } from "../types.js";
 /**
- * Returns an actor behavior from a transition function and its initial state.
+ * Returns actor logic from a transition function and its initial state.
  *
  * A transition function is a function that takes the current state and an event and returns the next state.
  *
  * @param transition The transition function that returns the next state given the current state and event.
  * @param initialState The initial state of the transition function.
- * @returns An actor behavior
+ * @returns Actor logic
  */
 export declare function fromTransition<TState, TEvent extends EventObject, TSystem extends ActorSystem<any>>(transition: (state: TState, event: TEvent, actorContext: ActorContext<TEvent, TState, TSystem>) => TState, initialState: TState | (({ input }: {
     input: any;
-}) => TState)): ActorBehavior<TEvent, TState, TState>;
+}) => TState)): ActorLogic<TEvent, TState, TState>;

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

@@ -1,4 +1,4 @@
-import { AnyInterpreter, DevToolsAdapter } from '../types.ts';
+import { AnyInterpreter, DevToolsAdapter } from "../types.js";
 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, GuardPredicate, MachineContext } from './types.ts';
-import type { State } from './State.ts';
+import type { EventObject, StateValue, BooleanGuardDefinition, GuardConfig, GuardDefinition, GuardPredicate, MachineContext } from "./types.js";
+import type { State } from "./State.js";
 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,26 +1,26 @@
-import { doneInvoke, forwardTo, sendParent, sendTo } from './actions.ts';
-export { assign } from './actions/assign.ts';
-export { cancel } from './actions/cancel.ts';
-export { choose } from './actions/choose.ts';
-export { log } from './actions/log.ts';
-export { pure } from './actions/pure.ts';
-export { raise } from './actions/raise.ts';
-export { 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 { SimulatedClock } from './SimulatedClock.ts';
-export { StateMachine } from './StateMachine.ts';
-export { getStateNodes } from './stateUtils.ts';
-export { waitFor } from './waitFor.ts';
-export * from './typegenTypes.ts';
-export * from './types.ts';
-export { matchesState, pathToStateValue, toObserver } from './utils.ts';
+import { doneInvoke, forwardTo, sendParent, sendTo } from "./actions.js";
+export { assign } from "./actions/assign.js";
+export { cancel } from "./actions/cancel.js";
+export { choose } from "./actions/choose.js";
+export { log } from "./actions/log.js";
+export { pure } from "./actions/pure.js";
+export { raise } from "./actions/raise.js";
+export { 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 { SimulatedClock } from "./SimulatedClock.js";
+export { StateMachine } from "./StateMachine.js";
+export { getStateNodes } from "./stateUtils.js";
+export { waitFor } from "./waitFor.js";
+export * from "./typegenTypes.js";
+export * from "./types.js";
+export { matchesState, pathToStateValue, toObserver } from "./utils.js";
 export { StateNode, State, mapState, sendTo, sendParent, forwardTo, interpret, Interpreter, ActorStatus as InterpreterStatus, doneInvoke, createMachine };
-export { fromPromise, fromObservable, fromCallback, fromEventObservable, fromTransition } from './actors/index.ts';
-export { stateIn, not, and, or } from './guards.ts';
+export { fromPromise, fromObservable, fromCallback, fromEventObservable, fromTransition } from "./actors/index.js";
+export { stateIn, not, and, or } from "./guards.js";
 declare global {
     interface SymbolConstructor {
         readonly observable: symbol;

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

@@ -1,8 +1,8 @@
-import { symbolObservable } from './symbolObservable.ts';
-import { AreAllImplementationsAssumedToBeProvided, MissingImplementationsError } from './typegenTypes.ts';
-import type { ActorSystem, AnyActorBehavior, AnyStateMachine, EventFromBehavior, InterpreterFrom, PersistedStateFrom, RaiseActionObject, SnapshotFrom } from './types.ts';
-import { ActorRef, EventObject, InteropSubscribable, InterpreterOptions, Observer, SendActionObject, Subscription } from './types.ts';
-export type SnapshotListener<TBehavior extends AnyActorBehavior> = (state: SnapshotFrom<TBehavior>) => void;
+import { symbolObservable } from "./symbolObservable.js";
+import { AreAllImplementationsAssumedToBeProvided, MissingImplementationsError } from "./typegenTypes.js";
+import type { ActorSystem, AnyActorLogic, AnyStateMachine, EventFromLogic, InterpreterFrom, PersistedStateFrom, RaiseActionObject, SnapshotFrom } from "./types.js";
+import { ActorRef, EventObject, InteropSubscribable, InterpreterOptions, Observer, SendActionObject, Subscription } from "./types.js";
+export type SnapshotListener<TLogic extends AnyActorLogic> = (state: SnapshotFrom<TLogic>) => void;
 export type EventListener<TEvent extends EventObject = EventObject> = (event: TEvent) => void;
 export type Listener = () => void;
 export type ErrorListener = (error: any) => void;
@@ -15,17 +15,17 @@ export declare enum ActorStatus {
     Running = 1,
     Stopped = 2
 }
-export declare class Interpreter<TBehavior extends AnyActorBehavior, TEvent extends EventObject = EventFromBehavior<TBehavior>> implements ActorRef<TEvent, SnapshotFrom<TBehavior>> {
-    behavior: TBehavior;
+export declare class Interpreter<TLogic extends AnyActorLogic, TEvent extends EventObject = EventFromLogic<TLogic>> implements ActorRef<TEvent, SnapshotFrom<TLogic>> {
+    logic: TLogic;
     /**
-     * The current state of the interpreted behavior.
+     * The current state of the interpreted logic.
      */
     private _state;
     /**
      * The clock that is responsible for setting and clearing timeouts, such as delayed events and transitions.
      */
     clock: Clock;
-    options: Readonly<InterpreterOptions<TBehavior>>;
+    options: Readonly<InterpreterOptions<TLogic>>;
     /**
      * The unique identifier for this actor relative to its parent.
      */
@@ -50,17 +50,17 @@ export declare class Interpreter<TBehavior extends AnyActorBehavior, TEvent exte
     private _doneEvent?;
     src?: string;
     /**
-     * Creates a new Interpreter instance (i.e., service) for the given behavior with the provided options, if any.
+     * Creates a new Interpreter instance (i.e., service) for the given logic with the provided options, if any.
      *
-     * @param behavior The behavior to be interpreted
+     * @param logic The logic to be interpreted
      * @param options Interpreter options
      */
-    constructor(behavior: TBehavior, options?: InterpreterOptions<TBehavior>);
+    constructor(logic: TLogic, options?: InterpreterOptions<TLogic>);
     private _initState;
     private _deferred;
     private update;
-    subscribe(observer: Observer<SnapshotFrom<TBehavior>>): Subscription;
-    subscribe(nextListener?: (state: SnapshotFrom<TBehavior>) => void, errorListener?: (error: any) => void, completeListener?: () => void): Subscription;
+    subscribe(observer: Observer<SnapshotFrom<TLogic>>): Subscription;
+    subscribe(nextListener?: (state: SnapshotFrom<TLogic>) => void, errorListener?: (error: any) => void, completeListener?: () => void): Subscription;
     /**
      * Starts the interpreter from the initial state
      */
@@ -86,9 +86,9 @@ export declare class Interpreter<TBehavior extends AnyActorBehavior, TEvent exte
     toJSON(): {
         id: string;
     };
-    getPersistedState(): PersistedStateFrom<TBehavior> | undefined;
-    [Symbol.observable](): InteropSubscribable<SnapshotFrom<TBehavior>>;
-    getSnapshot(): SnapshotFrom<TBehavior>;
+    getPersistedState(): PersistedStateFrom<TLogic> | undefined;
+    [Symbol.observable](): InteropSubscribable<SnapshotFrom<TLogic>>;
+    getSnapshot(): SnapshotFrom<TLogic>;
 }
 /**
  * Creates a new Interpreter instance for the given machine with the provided options, if any.
@@ -97,4 +97,4 @@ export declare class Interpreter<TBehavior extends AnyActorBehavior, TEvent exte
  * @param options Interpreter options
  */
 export declare function interpret<TMachine extends AnyStateMachine>(machine: AreAllImplementationsAssumedToBeProvided<TMachine['__TResolvedTypesMeta']> extends true ? TMachine : MissingImplementationsError<TMachine['__TResolvedTypesMeta']>, options?: InterpreterOptions<TMachine>): InterpreterFrom<TMachine>;
-export declare function interpret<TBehavior extends AnyActorBehavior>(behavior: TBehavior, options?: InterpreterOptions<TBehavior>): Interpreter<TBehavior>;
+export declare function interpret<TLogic extends AnyActorLogic>(logic: TLogic, options?: InterpreterOptions<TLogic>): Interpreter<TLogic>;

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

@@ -1,8 +1,8 @@
-import { BaseActionObject, EventObject, StateValue, TransitionConfig, TransitionDefinition, SingleOrArray, 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 '.';
+import { BaseActionObject, EventObject, StateValue, TransitionConfig, TransitionDefinition, SingleOrArray, StateValueMap, InitialTransitionConfig, MachineContext } from "./types.js";
+import { State } from "./State.js";
+import { NULL_EVENT } from "./constants.js";
+import type { StateNode } from "./StateNode.js";
+import { AnyActorContext, AnyHistoryValue, AnyState, AnyStateNode, AnyTransitionDefinition, DelayedTransitionDefinition, InitialTransitionDefinition } from "./index.js";
 type Configuration<TContext extends MachineContext, TE extends EventObject> = Iterable<StateNode<TContext, TE>>;
 type AnyConfiguration = Configuration<any, any>;
 type AdjList = Map<AnyStateNode, Array<AnyStateNode>>;
@@ -52,11 +52,9 @@ export declare function removeConflictingTransitions(enabledTransitions: Array<A
  * @param currentState
  * @param mutConfiguration
  */
-export declare function microstep<TContext extends MachineContext, TEvent extends EventObject>(transitions: Array<TransitionDefinition<TContext, TEvent>>, currentState: State<TContext, TEvent, any>, actorCtx: AnyActorContext | undefined, event: TEvent): State<TContext, TEvent, any>;
-export declare function resolveActionsAndContext<TContext extends MachineContext, TEvent extends EventObject>(actions: BaseActionObject[], event: TEvent, currentState: State<TContext, TEvent, any>, actorCtx: AnyActorContext | undefined): {
-    nextState: AnyState;
-};
-export declare function macrostep<TMachine extends AnyStateMachine>(state: StateFromMachine<TMachine>, event: TMachine['__TEvent'], actorCtx: AnyActorContext | undefined): {
+export declare function microstep<TContext extends MachineContext, TEvent extends EventObject>(transitions: Array<TransitionDefinition<TContext, TEvent>>, currentState: State<TContext, TEvent, any>, actorCtx: AnyActorContext, event: TEvent): State<TContext, TEvent, any>;
+export declare function resolveActionsAndContext<TContext extends MachineContext, TEvent extends EventObject>(actions: BaseActionObject[], event: TEvent, currentState: State<TContext, TEvent, any>, actorCtx: AnyActorContext | undefined): [AnyState, BaseActionObject[]];
+export declare function macrostep(state: AnyState, event: EventObject, actorCtx: AnyActorContext): {
     state: typeof state;
     microstates: Array<typeof state>;
 };

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

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