xstate 5.0.0-beta.48 → 5.0.0-beta.50

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

@@ -1,15 +1,13 @@
-import { ActorLogic, EventObject, AnyActorSystem, AnyEventObject, ActorSystem, ActorRefFrom, Snapshot } from "../types.js";
-type CallbackSnapshot<TInput, TEvent> = Snapshot<undefined> & {
+import { ActorLogic, EventObject, AnyActorSystem, AnyEventObject, ActorSystem, ActorRefFrom, Snapshot, NonReducibleUnknown } from "../types.js";
+export type CallbackSnapshot<TInput> = Snapshot<undefined> & {
     input: TInput;
-    _receivers: Set<(e: TEvent) => void>;
-    _dispose: (() => void) | void;
 };
-export type CallbackActorLogic<TEvent extends EventObject, TInput = unknown> = ActorLogic<CallbackSnapshot<TInput, TEvent>, TEvent, TInput, ActorSystem<any>>;
-export type CallbackActorRef<TEvent extends EventObject, TInput = unknown> = ActorRefFrom<CallbackActorLogic<TEvent, TInput>>;
+export type CallbackActorLogic<TEvent extends EventObject, TInput = NonReducibleUnknown> = ActorLogic<CallbackSnapshot<TInput>, TEvent, TInput, ActorSystem<any>>;
+export type CallbackActorRef<TEvent extends EventObject, TInput = NonReducibleUnknown> = ActorRefFrom<CallbackActorLogic<TEvent, TInput>>;
 export type Receiver<TEvent extends EventObject> = (listener: {
     bivarianceHack(event: TEvent): void;
 }['bivarianceHack']) => void;
-export type InvokeCallback<TEvent extends EventObject = AnyEventObject, TSentEvent extends EventObject = AnyEventObject, TInput = unknown> = ({ input, system, self, sendBack, receive }: {
+export type InvokeCallback<TEvent extends EventObject = AnyEventObject, TSentEvent extends EventObject = AnyEventObject, TInput = NonReducibleUnknown> = ({ input, system, self, sendBack, receive }: {
     /**
      * Data that was provided to the callback actor
      * @see {@link https://stately.ai/docs/input | Input docs}
@@ -90,5 +88,4 @@ export type InvokeCallback<TEvent extends EventObject = AnyEventObject, TSentEve
  * });
  * ```
  */
-export declare function fromCallback<TEvent extends EventObject, TInput = unknown>(invokeCallback: InvokeCallback<TEvent, AnyEventObject, TInput>): CallbackActorLogic<TEvent, TInput>;
-export {};
+export declare function fromCallback<TEvent extends EventObject, TInput = NonReducibleUnknown>(invokeCallback: InvokeCallback<TEvent, AnyEventObject, TInput>): CallbackActorLogic<TEvent, TInput>;

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

@@ -1,6 +1,6 @@
 import type { ActorRef, AnyEventObject, Snapshot } from "../types.js";
-export { fromCallback, type CallbackActorLogic } from "./callback.js";
-export { fromEventObservable, fromObservable, type ObservableActorLogic } from "./observable.js";
-export { fromPromise, type PromiseActorLogic } from "./promise.js";
+export { fromCallback, type CallbackActorLogic, type CallbackSnapshot } from "./callback.js";
+export { fromEventObservable, fromObservable, type ObservableActorLogic, type ObservableSnapshot } from "./observable.js";
+export { fromPromise, type PromiseActorLogic, type PromiseSnapshot } from "./promise.js";
 export { fromTransition, type TransitionActorLogic, type TransitionSnapshot } from "./transition.js";
 export declare function createEmptyActor(): ActorRef<AnyEventObject, Snapshot<undefined>>;

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

@@ -1,10 +1,10 @@
-import { Subscribable, ActorLogic, EventObject, Subscription, AnyActorSystem, ActorRefFrom, Snapshot } from "../types.js";
-export type ObservableSnapshot<TContext, TInput> = Snapshot<undefined> & {
+import { Subscribable, ActorLogic, EventObject, Subscription, AnyActorSystem, ActorRefFrom, Snapshot, NonReducibleUnknown } from "../types.js";
+export type ObservableSnapshot<TContext, TInput extends NonReducibleUnknown> = Snapshot<undefined> & {
     context: TContext | undefined;
     input: TInput | undefined;
     _subscription: Subscription | undefined;
 };
-export type ObservableActorLogic<TContext, TInput> = ActorLogic<ObservableSnapshot<TContext, TInput>, {
+export type ObservableActorLogic<TContext, TInput extends NonReducibleUnknown> = ActorLogic<ObservableSnapshot<TContext, TInput>, {
     type: string;
     [k: string]: unknown;
 }, TInput, AnyActorSystem>;
@@ -49,7 +49,7 @@ export type ObservableActorRef<TContext> = ActorRefFrom<ObservableActorLogic<TCo
  * @see {@link https://rxjs.dev} for documentation on RxJS Observable and observable creators.
  * @see {@link Subscribable} interface in XState, which is based on and compatible with RxJS Observable.
  */
-export declare function fromObservable<TContext, TInput>(observableCreator: ({ input, system }: {
+export declare function fromObservable<TContext, TInput extends NonReducibleUnknown>(observableCreator: ({ input, system }: {
     input: TInput;
     system: AnyActorSystem;
     self: ObservableActorRef<TContext>;
@@ -98,7 +98,7 @@ export declare function fromObservable<TContext, TInput>(observableCreator: ({ i
  * canvasActor.start();
  * ```
  */
-export declare function fromEventObservable<T extends EventObject, TInput>(lazyObservable: ({ input, system }: {
+export declare function fromEventObservable<T extends EventObject, TInput extends NonReducibleUnknown>(lazyObservable: ({ input, system }: {
     input: TInput;
     system: AnyActorSystem;
     self: ObservableActorRef<T>;

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

@@ -1,15 +1,15 @@
-import { ActorLogic, ActorRefFrom, ActorSystem, AnyActorSystem, Snapshot } from "../types.js";
 import { XSTATE_STOP } from "../constants.js";
+import { ActorLogic, ActorRefFrom, ActorSystem, AnyActorSystem, NonReducibleUnknown, Snapshot } from "../types.js";
 export type PromiseSnapshot<TOutput, TInput> = Snapshot<TOutput> & {
     input: TInput | undefined;
 };
-declare const resolveEventType = "$$xstate.resolve";
-declare const rejectEventType = "$$xstate.reject";
+declare const XSTATE_PROMISE_RESOLVE = "xstate.promise.resolve";
+declare const XSTATE_PROMISE_REJECT = "xstate.promise.reject";
 export type PromiseActorEvents<T> = {
-    type: typeof resolveEventType;
+    type: typeof XSTATE_PROMISE_RESOLVE;
     data: T;
 } | {
-    type: typeof rejectEventType;
+    type: typeof XSTATE_PROMISE_REJECT;
     data: any;
 } | {
     type: typeof XSTATE_STOP;
@@ -64,7 +64,7 @@ export type PromiseActorRef<TOutput> = ActorRefFrom<PromiseActorLogic<TOutput, u
  * // }
  * ```
  */
-export declare function fromPromise<TOutput, TInput = unknown>(promiseCreator: ({ input, system }: {
+export declare function fromPromise<TOutput, TInput = NonReducibleUnknown>(promiseCreator: ({ input, system }: {
     /**
      * Data that was provided to the promise actor
      */

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

@@ -1,8 +1,8 @@
-import { ActorLogic, ActorScope, ActorSystem, EventObject, ActorRefFrom, AnyActorSystem, Snapshot } from "../types.js";
+import { ActorLogic, ActorScope, ActorSystem, EventObject, ActorRefFrom, AnyActorSystem, Snapshot, NonReducibleUnknown } from "../types.js";
 export type TransitionSnapshot<TContext> = Snapshot<undefined> & {
     context: TContext;
 };
-export type TransitionActorLogic<TContext, TEvent extends EventObject, TInput> = ActorLogic<TransitionSnapshot<TContext>, TEvent, TInput, AnyActorSystem>;
+export type TransitionActorLogic<TContext, TEvent extends EventObject, TInput extends NonReducibleUnknown> = ActorLogic<TransitionSnapshot<TContext>, TEvent, TInput, AnyActorSystem>;
 export type TransitionActorRef<TContext, TEvent extends EventObject> = ActorRefFrom<TransitionActorLogic<TransitionSnapshot<TContext>, TEvent, unknown>>;
 /**
  * Returns actor logic given a transition function and its initial state.
@@ -62,7 +62,7 @@ export type TransitionActorRef<TContext, TEvent extends EventObject> = ActorRefF
  * // }
  * ```
  */
-export declare function fromTransition<TContext, TEvent extends EventObject, TSystem extends ActorSystem<any>, TInput>(transition: (state: TContext, event: TEvent, actorScope: ActorScope<TransitionSnapshot<TContext>, TEvent, TSystem>) => TContext, initialContext: TContext | (({ input, self }: {
+export declare function fromTransition<TContext, TEvent extends EventObject, TSystem extends ActorSystem<any>, TInput extends NonReducibleUnknown>(transition: (state: TContext, event: TEvent, actorScope: ActorScope<TransitionSnapshot<TContext>, TEvent, TSystem>) => TContext, initialContext: TContext | (({ input, self }: {
     input: TInput;
     self: TransitionActorRef<TContext, TEvent>;
 }) => TContext)): TransitionActorLogic<TContext, TEvent, TInput>;

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

@@ -1,5 +1,20 @@
 import { StateMachine } from "./StateMachine.js";
 import { ResolveTypegenMeta, TypegenConstraint, TypegenDisabled } from "./typegenTypes.js";
-import { AnyActorRef, AnyEventObject, Cast, InternalMachineImplementations, MachineConfig, MachineContext, NonReducibleUnknown, ParameterizedObject, Prop, ProvidedActor, ToChildren } from "./types.js";
+import { AnyActorRef, AnyEventObject, Cast, InternalMachineImplementations, IsNever, MachineConfig, MachineContext, NonReducibleUnknown, ParameterizedObject, Prop, ProvidedActor, StateValue, ToChildren } from "./types.js";
+type TestValue = string | {
+    [k: string]: TestValue | undefined;
+};
+type _GroupTestValues<TTestValue extends string | TestValue> = TTestValue extends string ? TTestValue extends `${string}.${string}` ? [never, never] : [TTestValue, never] : [never, TTestValue];
+type GroupTestValues<TTestValue extends string | TestValue> = {
+    leafCandidates: _GroupTestValues<TTestValue>[0];
+    nonLeaf: _GroupTestValues<TTestValue>[1];
+};
+type FilterLeafValues<TLeafCandidate extends string, TNonLeaf extends {
+    [k: string]: TestValue | undefined;
+}> = IsNever<TNonLeaf> extends true ? TLeafCandidate : TLeafCandidate extends string ? TLeafCandidate extends keyof TNonLeaf ? never : TLeafCandidate : never;
+type ToStateValue<TTestValue extends string | TestValue> = FilterLeafValues<GroupTestValues<TTestValue>['leafCandidates'], GroupTestValues<TTestValue>['nonLeaf']> | (IsNever<GroupTestValues<TTestValue>['nonLeaf']> extends false ? {
+    [K in keyof GroupTestValues<TTestValue>['nonLeaf']]: ToStateValue<NonNullable<GroupTestValues<TTestValue>['nonLeaf'][K]>>;
+} : never);
 export declare function createMachine<TContext extends MachineContext, TEvent extends AnyEventObject, // TODO: consider using a stricter `EventObject` here
-TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TTag extends string, TInput, TOutput extends NonReducibleUnknown, TTypesMeta extends TypegenConstraint = TypegenDisabled>(config: MachineConfig<TContext, TEvent, TActor, TAction, TGuard, TDelay, TTag, TInput, TOutput, TTypesMeta>, implementations?: InternalMachineImplementations<TContext, ResolveTypegenMeta<TTypesMeta, TEvent, TActor, TAction, TGuard, TDelay, TTag>>): StateMachine<TContext, TEvent, Cast<ToChildren<TActor>, Record<string, AnyActorRef | undefined>>, TActor, TAction, TGuard, TDelay, Prop<ResolveTypegenMeta<TTypesMeta, TEvent, TActor, TAction, TGuard, TDelay, TTag>['resolved'], 'tags'> & string, TInput, TOutput, ResolveTypegenMeta<TTypesMeta, TEvent, TActor, TAction, TGuard, TDelay, TTag>>;
+TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TTag extends string, TInput, TOutput extends NonReducibleUnknown, TTypesMeta extends TypegenConstraint = TypegenDisabled>(config: MachineConfig<TContext, TEvent, TActor, TAction, TGuard, TDelay, TTag, TInput, TOutput, TTypesMeta>, implementations?: InternalMachineImplementations<TContext, ResolveTypegenMeta<TTypesMeta, TEvent, TActor, TAction, TGuard, TDelay, TTag>>): StateMachine<TContext, TEvent, Cast<ToChildren<TActor>, Record<string, AnyActorRef | undefined>>, TActor, TAction, TGuard, TDelay, 'matchesStates' extends keyof TTypesMeta ? ToStateValue<Cast<TTypesMeta['matchesStates'], TestValue>> : StateValue, Prop<ResolveTypegenMeta<TTypesMeta, TEvent, TActor, TAction, TGuard, TDelay, TTag>['resolved'], 'tags'> & string, TInput, TOutput, ResolveTypegenMeta<TTypesMeta, TEvent, TActor, TAction, TGuard, TDelay, TTag>>;
+export {};

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

@@ -124,6 +124,7 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorRef<Eve
      */
     stop(): this;
     private _complete;
+    private _reportError;
     private _error;
     private _stopProcedure;
     /**
@@ -199,8 +200,7 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorRef<Eve
  * @param logic - The actor logic to create an actor from. For a state machine actor logic creator, see {@link createMachine}. Other actor logic creators include {@link fromCallback}, {@link fromEventObservable}, {@link fromObservable}, {@link fromPromise}, and {@link fromTransition}.
  * @param options - Actor options
  */
-export declare function createActor<TLogic extends AnyActorLogic>(logic: TLogic, options?: ActorOptions<TLogic>): Actor<TLogic>;
-export declare function createActor<TMachine extends AnyStateMachine>(machine: AreAllImplementationsAssumedToBeProvided<TMachine['__TResolvedTypesMeta']> extends true ? TMachine : MissingImplementationsError<TMachine['__TResolvedTypesMeta']>, options?: ActorOptions<TMachine>): Actor<TMachine>;
+export declare function createActor<TLogic extends AnyActorLogic>(logic: TLogic extends AnyStateMachine ? AreAllImplementationsAssumedToBeProvided<TLogic['__TResolvedTypesMeta']> extends true ? TLogic : MissingImplementationsError<TLogic['__TResolvedTypesMeta']> : TLogic, options?: ActorOptions<TLogic>): Actor<TLogic>;
 /**
  * Creates a new Interpreter instance for the given machine with the provided options, if any.
  *

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

@@ -1,7 +1,7 @@
 import { StateMachine } from "./StateMachine.js";
 import { GuardPredicate } from "./guards.js";
 import { ResolveTypegenMeta, TypegenDisabled } from "./typegenTypes.js";
-import { ActionFunction, AnyActorLogic, AnyActorRef, AnyEventObject, Cast, DelayConfig, Invert, IsNever, MachineConfig, MachineContext, NonReducibleUnknown, ParameterizedObject, SetupTypes, ToChildren, Values } from "./types.js";
+import { ActionFunction, AnyActorLogic, AnyActorRef, AnyEventObject, Cast, ConditionalRequired, DelayConfig, Invert, IsNever, MachineConfig, MachineContext, NonReducibleUnknown, ParameterizedObject, SetupTypes, StateSchema, ToChildren, UnknownActorLogic, Values } from "./types.js";
 type ToParameterizedObject<TParameterizedMap extends Record<string, ParameterizedObject['params'] | undefined>> = Values<{
     [K in keyof TParameterizedMap & string]: {
         type: K;
@@ -16,8 +16,24 @@ type ToProvidedActor<TChildrenMap extends Record<string, string>, TActors extend
         id: IsNever<TChildrenMap> extends true ? string | undefined : K extends keyof Invert<TChildrenMap> ? Invert<TChildrenMap>[K] : string | undefined;
     };
 }>;
+type _GroupStateKeys<T extends StateSchema, S extends keyof T['states']> = S extends any ? T['states'][S] extends {
+    type: 'history';
+} ? [never, never] : T extends {
+    type: 'parallel';
+} ? [S, never] : 'states' extends keyof T['states'][S] ? [S, never] : [never, S] : never;
+type GroupStateKeys<T extends StateSchema, S extends keyof T['states']> = {
+    nonLeaf: _GroupStateKeys<T, S & string>[0];
+    leaf: _GroupStateKeys<T, S & string>[1];
+};
+type ToStateValue<T extends StateSchema> = T extends {
+    states: Record<infer S, any>;
+} ? IsNever<S> extends true ? {} : GroupStateKeys<T, S>['leaf'] | (IsNever<GroupStateKeys<T, S>['nonLeaf']> extends false ? ConditionalRequired<{
+    [K in GroupStateKeys<T, S>['nonLeaf']]?: ToStateValue<T['states'][K]>;
+}, T extends {
+    type: 'parallel';
+} ? true : false> : never) : {};
 export declare function setup<TContext extends MachineContext, TEvent extends AnyEventObject, // TODO: consider using a stricter `EventObject` here
-TActors extends Record<Values<TChildrenMap>, AnyActorLogic>, TActions extends Record<string, ParameterizedObject['params'] | undefined>, TGuards extends Record<string, ParameterizedObject['params'] | undefined>, TDelay extends string, TTag extends string, TInput, TOutput extends NonReducibleUnknown, TChildrenMap extends Record<string, string> = never>({ actors, actions, guards, delays }: {
+TActors extends Record<Values<TChildrenMap>, UnknownActorLogic>, TActions extends Record<string, ParameterizedObject['params'] | undefined>, TGuards extends Record<string, ParameterizedObject['params'] | undefined>, TDelay extends string, TTag extends string, TInput, TOutput extends NonReducibleUnknown, TChildrenMap extends Record<string, string> = never>({ actors, actions, guards, delays }: {
     types?: SetupTypes<TContext, TEvent, TChildrenMap, TTag, TInput, TOutput>;
     actors?: TActors;
     actions?: {
@@ -30,6 +46,6 @@ TActors extends Record<Values<TChildrenMap>, AnyActorLogic>, TActions extends Re
         [K in TDelay]: DelayConfig<TContext, TEvent, ToParameterizedObject<TActions>['params'], TEvent>;
     };
 }): {
-    createMachine: <const TConfig extends MachineConfig<TContext, TEvent, ToProvidedActor<TChildrenMap, TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, TTag, TInput, TOutput, ResolveTypegenMeta<TypegenDisabled, TEvent, ToProvidedActor<TChildrenMap, TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, TTag>>>(config: TConfig) => StateMachine<TContext, TEvent, Cast<ToChildren<ToProvidedActor<TChildrenMap, TActors>>, Record<string, AnyActorRef | undefined>>, ToProvidedActor<TChildrenMap, TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, TTag, TInput, TOutput, ResolveTypegenMeta<TypegenDisabled, TEvent, ToProvidedActor<TChildrenMap, TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, TTag>>;
+    createMachine: <const TConfig extends MachineConfig<TContext, TEvent, ToProvidedActor<TChildrenMap, TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, TTag, TInput, TOutput, ResolveTypegenMeta<TypegenDisabled, TEvent, ToProvidedActor<TChildrenMap, TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, TTag>>>(config: TConfig) => StateMachine<TContext, TEvent, Cast<ToChildren<ToProvidedActor<TChildrenMap, TActors>>, Record<string, AnyActorRef | undefined>>, ToProvidedActor<TChildrenMap, TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, ToStateValue<TConfig>, TTag, TInput, TOutput, ResolveTypegenMeta<TypegenDisabled, TEvent, ToProvidedActor<TChildrenMap, TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, TTag>>;
 };
 export {};

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

@@ -40,7 +40,7 @@ export declare function getStateNodes<TContext extends MachineContext, TEvent ex
 export declare function transitionAtomicNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: string, state: MachineSnapshot<TContext, TEvent, any, any, any, any>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
 export declare function transitionCompoundNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValueMap, state: MachineSnapshot<TContext, TEvent, any, any, any, any>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
 export declare function transitionParallelNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValueMap, state: MachineSnapshot<TContext, TEvent, any, any, any, any>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
-export declare function transitionNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValue, state: MachineSnapshot<TContext, TEvent, any, any, any, any>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
+export declare function transitionNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValue, state: MachineSnapshot<TContext, TEvent, any, any, any, any, any>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
 export declare function removeConflictingTransitions(enabledTransitions: Array<AnyTransitionDefinition>, stateNodeSet: Set<AnyStateNode>, historyValue: AnyHistoryValue): Array<AnyTransitionDefinition>;
 /**
  * https://www.w3.org/TR/scxml/#microstepProcedure

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

@@ -81,13 +81,13 @@ export interface UnifiedArg<TContext extends MachineContext, TExpressionEvent ex
     context: TContext;
     event: TExpressionEvent;
     self: ActorRef<TEvent, MachineSnapshot<TContext, TEvent, Record<string, AnyActorRef | undefined>, // TODO: this should be replaced with `TChildren`
-    string, unknown>>;
+    StateValue, string, unknown>>;
     system: ActorSystem<any>;
 }
 export type MachineContext = Record<string, any>;
 export interface ActionArgs<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject> extends UnifiedArg<TContext, TExpressionEvent, TEvent> {
 }
-export type InputFrom<T extends AnyActorLogic> = T extends StateMachine<infer _TContext, infer _TEvent, infer _TChildren, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TTag, infer TInput, infer _TOutput, infer _TResolvedTypesMeta> ? TInput : T extends ActorLogic<infer _TSnapshot, infer _TEvent, infer TInput, infer _TSystem> ? TInput : never;
+export type InputFrom<T extends AnyActorLogic> = T extends StateMachine<infer _TContext, infer _TEvent, infer _TChildren, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TStateValue, infer _TTag, infer TInput, infer _TOutput, infer _TResolvedTypesMeta> ? TInput : T extends ActorLogic<infer _TSnapshot, infer _TEvent, infer TInput, infer _TSystem> ? TInput : never;
 export type OutputFrom<T extends AnyActorLogic> = T extends ActorLogic<infer TSnapshot, infer _TEvent, infer _TInput, infer _TSystem> ? (TSnapshot & {
     status: 'done';
 })['output'] : never;
@@ -349,7 +349,7 @@ export interface StateMachineDefinition<TContext extends MachineContext, TEvent
 }
 export type AnyStateNode = StateNode<any, any>;
 export type AnyStateNodeDefinition = StateNodeDefinition<any, any>;
-export type AnyMachineSnapshot = MachineSnapshot<any, any, any, any, any, any>;
+export type AnyMachineSnapshot = MachineSnapshot<any, any, any, any, any, any, any>;
 /** @deprecated use `AnyMachineSnapshot` instead */
 export type AnyState = AnyMachineSnapshot;
 export type AnyStateMachine = StateMachine<any, // context
@@ -359,6 +359,7 @@ any, // actor
 any, // action
 any, // guard
 any, // delay
+any, // state value
 any, // tag
 any, // input
 any, // output
@@ -521,7 +522,7 @@ export type Mapper<TContext extends MachineContext, TExpressionEvent extends Eve
     context: TContext;
     event: TExpressionEvent;
     self: ActorRef<TEvent, MachineSnapshot<TContext, TEvent, Record<string, AnyActorRef>, // TODO: this should be replaced with `TChildren`
-    string, unknown>>;
+    StateValue, string, unknown>>;
 }) => TResult;
 export interface TransitionDefinition<TContext extends MachineContext, TEvent extends EventObject> extends Omit<TransitionConfig<TContext, TEvent, TEvent, TODO, TODO, TODO, TODO>, 'target' | 'guard'> {
     target: ReadonlyArray<StateNode<TContext, TEvent>> | undefined;
@@ -735,7 +736,7 @@ export interface ActorRef<TEvent extends EventObject, TSnapshot extends Snapshot
     id: string;
     sessionId: string;
     send: (event: TEvent) => void;
-    start?: () => void;
+    start: () => void;
     getSnapshot: () => TSnapshot;
     getPersistedState: () => Snapshot<unknown>;
     stop: () => void;
@@ -746,13 +747,13 @@ export interface ActorRef<TEvent extends EventObject, TSnapshot extends Snapshot
 }
 export type AnyActorRef = ActorRef<any, any>;
 export type ActorLogicFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<any, any, any, any, any, any, any, any, any, any, any> ? R : R extends Promise<infer U> ? PromiseActorLogic<U> : never : never;
-export type ActorRefFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer TContext, infer TEvent, infer TChildren, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer TTag, infer _TInput, infer TOutput, infer TResolvedTypesMeta> ? ActorRef<TEvent, MachineSnapshot<TContext, TEvent, TChildren, TTag, TOutput, AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta> extends false ? MarkAllImplementationsAsProvided<TResolvedTypesMeta> : TResolvedTypesMeta>> : R extends Promise<infer U> ? ActorRefFrom<PromiseActorLogic<U>> : R extends ActorLogic<infer TSnapshot, infer TEvent, infer _TInput, infer _TSystem> ? ActorRef<TEvent, TSnapshot> : never : never;
+export type ActorRefFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer TContext, infer TEvent, infer TChildren, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer TStateValue, infer TTag, infer _TInput, infer TOutput, infer TResolvedTypesMeta> ? ActorRef<TEvent, MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta> extends false ? MarkAllImplementationsAsProvided<TResolvedTypesMeta> : TResolvedTypesMeta>> : R extends Promise<infer U> ? ActorRefFrom<PromiseActorLogic<U>> : R extends ActorLogic<infer TSnapshot, infer TEvent, infer _TInput, infer _TSystem> ? ActorRef<TEvent, TSnapshot> : never : never;
 export type DevToolsAdapter = (service: AnyActor) => void;
 /**
  * @deprecated Use `Actor<T>` instead.
  */
-export type InterpreterFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine)> = ReturnTypeOrValue<T> extends StateMachine<infer TContext, infer TEvent, infer TChildren, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer TTag, infer TInput, infer TOutput, infer TResolvedTypesMeta> ? Actor<ActorLogic<MachineSnapshot<TContext, TEvent, TChildren, TTag, TOutput, TResolvedTypesMeta>, TEvent, TInput, ActorSystem<any>>> : never;
-export type MachineImplementationsFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine), TRequireMissingImplementations extends boolean = false> = ReturnTypeOrValue<T> extends StateMachine<infer TContext, infer _TEvent, infer _TChildren, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TTag, infer _TInput, infer _TOutput, infer TResolvedTypesMeta> ? InternalMachineImplementations<TContext, TResolvedTypesMeta, TRequireMissingImplementations> : never;
+export type InterpreterFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine)> = ReturnTypeOrValue<T> extends StateMachine<infer TContext, infer TEvent, infer TChildren, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer TStateValue, infer TTag, infer TInput, infer TOutput, infer TResolvedTypesMeta> ? Actor<ActorLogic<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TResolvedTypesMeta>, TEvent, TInput, ActorSystem<any>>> : never;
+export type MachineImplementationsFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine), TRequireMissingImplementations extends boolean = false> = ReturnTypeOrValue<T> extends StateMachine<infer TContext, infer _TEvent, infer _TChildren, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TStateValue, infer _TTag, infer _TInput, infer _TOutput, infer TResolvedTypesMeta> ? InternalMachineImplementations<TContext, TResolvedTypesMeta, TRequireMissingImplementations> : never;
 export type __ResolvedTypesMetaFrom<T> = T extends StateMachine<any, // context
 any, // event
 any, // children
@@ -799,7 +800,7 @@ export type Snapshot<TOutput> = {
  * @template TInput - The type of the input.
  * @template TSystem - The type of the actor system.
  */
-export interface ActorLogic<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TInput = unknown, TSystem extends ActorSystem<any> = ActorSystem<any>> {
+export interface ActorLogic<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TInput = NonReducibleUnknown, TSystem extends ActorSystem<any> = ActorSystem<any>> {
     /** The initial setup/configuration used to create the actor logic. */
     config?: unknown;
     /**
@@ -810,7 +811,7 @@ export interface ActorLogic<TSnapshot extends Snapshot<unknown>, TEvent extends
      * @param ctx - The actor scope.
      * @returns The new state.
      */
-    transition: (state: TSnapshot, message: TEvent, ctx: ActorScope<TSnapshot, TEvent, TSystem>) => TSnapshot;
+    transition: (snapshot: TSnapshot, message: TEvent, ctx: ActorScope<TSnapshot, TEvent, TSystem>) => TSnapshot;
     /**
      * Called to provide the initial state of the actor.
      * @param actorScope - The actor scope.
@@ -844,11 +845,13 @@ export type AnyActorLogic = ActorLogic<any, // snapshot
 any, // event
 any, // input
 any>;
-export type SnapshotFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends ActorRef<infer _, infer TSnapshot> ? TSnapshot : R extends Actor<infer TLogic> ? SnapshotFrom<TLogic> : R extends StateMachine<infer _TContext, infer _TEvent, infer _TChildren, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TTag, infer _TInput, infer _TOutput, infer _TResolvedTypesMeta> ? StateFrom<R> : R extends ActorLogic<any, any, any, any> ? ReturnType<R['transition']> : R extends ActorScope<infer TSnapshot, infer _, infer __> ? TSnapshot : never : never;
+export type UnknownActorLogic = ActorLogic<any, // this is invariant and it's hard to figure out a better default than `any`
+EventObject, NonReducibleUnknown, ActorSystem<any>>;
+export type SnapshotFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends ActorRef<infer _, infer TSnapshot> ? TSnapshot : R extends Actor<infer TLogic> ? SnapshotFrom<TLogic> : R extends ActorLogic<infer _, infer __, infer ___, infer ____> ? ReturnType<R['transition']> : R extends ActorScope<infer TSnapshot, infer _, infer __> ? TSnapshot : never : never;
 export type EventFromLogic<TLogic extends ActorLogic<any, any, any, any>> = TLogic extends ActorLogic<infer _, infer TEvent, infer __, infer _____> ? TEvent : never;
-type ResolveEventType<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer _TContext, infer TEvent, infer _TChildren, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TTag, infer _TInput, infer _TOutput, infer _TResolvedTypesMeta> ? TEvent : R extends MachineSnapshot<infer _TContext, infer TEvent, infer _TChildren, infer _TTag, infer _TOutput, infer _TResolvedTypesMeta> ? TEvent : R extends ActorRef<infer TEvent, infer _> ? TEvent : never : never;
+type ResolveEventType<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer _TContext, infer TEvent, infer _TChildren, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TStateValue, infer _TTag, infer _TInput, infer _TOutput, infer _TResolvedTypesMeta> ? TEvent : R extends MachineSnapshot<infer _TContext, infer TEvent, infer _TChildren, infer _TTag, infer _TOutput, infer _TResolvedTypesMeta> ? TEvent : R extends ActorRef<infer TEvent, infer _> ? TEvent : never : never;
 export type EventFrom<T, K extends Prop<TEvent, 'type'> = never, TEvent extends EventObject = ResolveEventType<T>> = IsNever<K> extends true ? TEvent : ExtractEvent<TEvent, K>;
-export type ContextFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer TContext, infer _TEvent, infer _TChildren, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TTag, infer _TInput, infer _TOutput, infer _TTypesMeta> ? TContext : R extends MachineSnapshot<infer TContext, infer _TEvent, infer _TChildren, infer _TTag, infer _TOutput, infer _TResolvedTypesMeta> ? TContext : R extends Actor<infer TActorLogic> ? TActorLogic extends StateMachine<infer TContext, infer _TEvent, infer _TChildren, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TTag, infer _TInput, infer _TOutput, infer _TTypesMeta> ? TContext : never : never : never;
+export type ContextFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer TContext, infer _TEvent, infer _TChildren, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TStateValue, infer _TTag, infer _TInput, infer _TOutput, infer _TTypesMeta> ? TContext : R extends MachineSnapshot<infer TContext, infer _TEvent, infer _TChildren, infer _TTag, infer _TOutput, infer _TResolvedTypesMeta> ? TContext : R extends Actor<infer TActorLogic> ? TActorLogic extends StateMachine<infer TContext, infer _TEvent, infer _TChildren, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TTag, infer _TInput, infer _TOutput, infer _TTypesMeta> ? TContext : never : never : never;
 export type InferEvent<E extends EventObject> = {
     [T in E['type']]: {
         type: T;
@@ -878,4 +881,7 @@ export type ToChildren<TActor extends ProvidedActor> = string extends TActor['sr
     };
     exclude: {};
 }[undefined extends TActor['id'] ? 'include' : string extends TActor['id'] ? 'include' : 'exclude']>;
+export type StateSchema = {
+    states?: Record<string, StateSchema>;
+};
 export {};

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

@@ -21,7 +21,6 @@ export declare function mapFilterValues<T, P>(collection: {
  */
 export declare function path<T extends Record<string, any>>(props: string[]): any;
 export declare function toStatePaths(stateValue: StateValue | undefined): string[][];
-export declare function flatten<T>(array: Array<T | T[]>): T[];
 export declare function toArrayStrict<T>(value: readonly T[] | T): readonly T[];
 export declare function toArray<T>(value: readonly T[] | T | undefined): readonly T[];
 export declare function resolveOutput<TContext extends MachineContext, TExpressionEvent extends EventObject>(mapper: Mapper<TContext, TExpressionEvent, unknown, EventObject> | NonReducibleUnknown, context: TContext, event: TExpressionEvent, self: AnyActorRef): unknown;

package/dist/{raise-84fd7a92.esm.js → raise-32ec7226.esm.js}

@@ -248,9 +248,6 @@ function mapValues(collection, iteratee) {
   }
   return result;
 }
-function flatten(array) {
-  return [].concat(...array);
-}
 function toArrayStrict(value) {
   if (isArray(value)) {
     return value;
@@ -317,7 +314,7 @@ function resolveReferencedActor(machine, src) {
   return machine.implementations.actors[src];
 }
 function getAllOwnEventDescriptors(snapshot) {
-  return [...new Set(flatten([...snapshot._nodes.map(sn => sn.ownEvents)]))];
+  return [...new Set([...snapshot._nodes.flatMap(sn => sn.ownEvents)])];
 }
 
 const $$ACTOR_TYPE = 1;
@@ -452,7 +449,18 @@ class Actor {
     }
   }
   _initState(persistedState) {
-    this._state = persistedState ? this.logic.restoreState ? this.logic.restoreState(persistedState, this._actorScope) : persistedState : this.logic.getInitialState(this._actorScope, this.options?.input);
+    try {
+      this._state = persistedState ? this.logic.restoreState ? this.logic.restoreState(persistedState, this._actorScope) : persistedState : this.logic.getInitialState(this._actorScope, this.options?.input);
+    } catch (err) {
+      // if we get here then it means that we assign a value to this._state that is not of the correct type
+      // we can't get the true `TSnapshot & { status: 'error'; }`, it's impossible
+      // so right now this is a lie of sorts
+      this._state = {
+        status: 'error',
+        output: undefined,
+        error: err
+      };
+    }
   }
   update(snapshot, event) {
     // Update state
@@ -461,17 +469,46 @@ class Actor {
     // Execute deferred effects
     let deferredFn;
     while (deferredFn = this._deferred.shift()) {
-      deferredFn();
-    }
-    for (const observer of this.observers) {
       try {
-        observer.next?.(snapshot);
+        deferredFn();
       } catch (err) {
-        reportUnhandledError(err);
+        // this error can only be caught when executing *initial* actions
+        // it's the only time when we call actions provided by the user through those deferreds
+        // when the actor is already running we always execute them synchronously while transitioning
+        // no "builtin deferred" should actually throw an error since they are either safe
+        // or the control flow is passed through the mailbox and errors should be caught by the `_process` used by the mailbox
+        this._deferred.length = 0;
+        this._state = {
+          ...snapshot,
+          status: 'error',
+          error: err
+        };
       }
     }
     switch (this._state.status) {
+      case 'active':
+        for (const observer of this.observers) {
+          try {
+            observer.next?.(snapshot);
+          } catch (err) {
+            reportUnhandledError(err);
+          }
+        }
+        break;
       case 'done':
+        // next observers are meant to be notified about done snapshots
+        // this can be seen as something that is different from how observable work
+        // but with observables `complete` callback is called without any arguments
+        // it's more ergonomic for XState to treat a done snapshot as a "next" value
+        // and the completion event as something that is separate,
+        // something that merely follows emitting that done snapshot
+        for (const observer of this.observers) {
+          try {
+            observer.next?.(snapshot);
+          } catch (err) {
+            reportUnhandledError(err);
+          }
+        }
         this._stopProcedure();
         this._complete();
         this._doneEvent = createDoneActorEvent(this.id, this._state.output);
@@ -480,11 +517,7 @@ class Actor {
         }
         break;
       case 'error':
-        this._stopProcedure();
         this._error(this._state.error);
-        if (this._parent) {
-          this.system._relay(this, this._parent, createErrorActorEvent(this.id, this._state.error));
-        }
         break;
     }
     this.system._sendInspectionEvent({
@@ -574,7 +607,7 @@ class Actor {
       this.subscribe({
         next: snapshot => {
           if (snapshot.status === 'active') {
-            this._parent.send({
+            this.system._relay(this, this._parent, {
               type: `xstate.snapshot.${this.id}`,
               snapshot
             });
@@ -603,18 +636,22 @@ class Actor {
         // a state machine can be "done" upon initialization (it could reach a final state using initial microsteps)
         // we still need to complete observers, flush deferreds etc
         this.update(this._state, initEvent);
-      // fallthrough
-      case 'error':
         // TODO: rethink cleanup of observers, mailbox, etc
         return this;
+      case 'error':
+        this._error(this._state.error);
+        return this;
     }
     if (this.logic.start) {
       try {
         this.logic.start(this._state, this._actorScope);
       } catch (err) {
-        this._stopProcedure();
+        this._state = {
+          ...this._state,
+          status: 'error',
+          error: err
+        };
         this._error(err);
-        this._parent?.send(createErrorActorEvent(this.id, err));
         return this;
       }
     }
@@ -630,7 +667,6 @@ class Actor {
     return this;
   }
   _process(event) {
-    // TODO: reexamine what happens when an action (or a guard or smth) throws
     let nextState;
     let caughtError;
     try {
@@ -645,9 +681,12 @@ class Actor {
       const {
         err
       } = caughtError;
-      this._stopProcedure();
+      this._state = {
+        ...this._state,
+        status: 'error',
+        error: err
+      };
       this._error(err);
-      this._parent?.send(createErrorActorEvent(this.id, err));
       return;
     }
     this.update(nextState, event);
@@ -690,7 +729,7 @@ class Actor {
     }
     this.observers.clear();
   }
-  _error(err) {
+  _reportError(err) {
     if (!this.observers.size) {
       if (!this._parent) {
         reportUnhandledError(err);
@@ -712,6 +751,18 @@ class Actor {
       reportUnhandledError(err);
     }
   }
+  _error(err) {
+    this._stopProcedure();
+    this._reportError(err);
+    if (this._parent) {
+      this.system._relay(this, this._parent, createErrorActorEvent(this.id, err));
+    }
+  }
+  // TODO: atm children don't belong entirely to the actor so
+  // in a way - it's not even super aware of them
+  // so we can't stop them from here but we really should!
+  // right now, they are being stopped within the machine's transition
+  // but that could throw and leave us with "orphaned" active actors
   _stopProcedure() {
     if (this._processingStatus !== ProcessingStatus.Running) {
       // Actor already stopped; do nothing
@@ -957,12 +1008,7 @@ function executeSpawn(actorScope, {
     if (actorRef._processingStatus === ProcessingStatus.Stopped) {
       return;
     }
-    try {
-      actorRef.start?.();
-    } catch (err) {
-      actorScope.self.send(createErrorActorEvent(id, err));
-      return;
-    }
+    actorRef.start();
   });
 }
 function spawnChild(...[src, {
@@ -2017,7 +2063,23 @@ function macrostep(state, event, actorScope, internalQueue = []) {
   // Assume the state is at rest (no raised events)
   // Determine the next state based on the next microstep
   if (nextEvent.type !== XSTATE_INIT) {
-    const transitions = selectTransitions(nextEvent, nextState);
+    const currentEvent = nextEvent;
+    const isErr = isErrorActorEvent(currentEvent);
+    const transitions = selectTransitions(currentEvent, nextState);
+    if (isErr && !transitions.length) {
+      // TODO: we should likely only allow transitions selected by very explicit descriptors
+      // `*` shouldn't be matched, likely `xstate.error.*` shouldnt be either
+      // similarly `xstate.error.actor.*` and `xstate.error.actor.todo.*` have to be considered too
+      nextState = cloneMachineSnapshot(state, {
+        status: 'error',
+        error: currentEvent.data
+      });
+      states.push(nextState);
+      return {
+        state: nextState,
+        microstates: states
+      };
+    }
     nextState = microstep(transitions, state, actorScope, nextEvent, false, internalQueue);
     states.push(nextState);
   }
@@ -2131,10 +2193,9 @@ function createMachineSnapshot(config, machine) {
     context: config.context,
     _nodes: config._nodes,
     value: getStateValue(machine.root, config._nodes),
-    tags: new Set(flatten(config._nodes.map(sn => sn.tags))),
+    tags: new Set(config._nodes.flatMap(sn => sn.tags)),
     children: config.children,
     historyValue: config.historyValue || {},
-    // this one is generic in the target and it's hard to create a matching non-generic source signature
     matches: machineSnapshotMatches,
     hasTag: machineSnapshotHasTag,
     can: machineSnapshotCan,
@@ -2258,4 +2319,4 @@ function raise(eventOrExpr, options) {
   return raise;
 }
 
-export { $$ACTOR_TYPE as $, getPersistedState as A, resolveReferencedActor as B, createActor as C, Actor as D, interpret as E, isMachineSnapshot as F, matchesState as G, pathToStateValue as H, toObserver as I, and as J, not as K, or as L, stateIn as M, NULL_EVENT as N, cancel as O, raise as P, stop as Q, stopChild as R, STATE_DELIMITER as S, spawnChild as T, ProcessingStatus as U, createErrorActorEvent as V, XSTATE_ERROR as W, XSTATE_STOP as X, toTransitionConfigArray as a, formatTransition as b, createInvokeId as c, formatInitialTransition as d, evaluateGuard as e, formatTransitions as f, getDelayedTransitions as g, getCandidates as h, getAllStateNodes as i, getStateNodes as j, createMachineSnapshot as k, isInFinalState as l, mapValues as m, isErrorActorEvent as n, getAllOwnEventDescriptors as o, cloneMachineSnapshot as p, macrostep as q, resolveStateValue as r, transitionNode as s, toArray as t, resolveActionsAndContext as u, createInitEvent as v, microstep as w, getInitialStateNodes as x, isStateId as y, getStateNodeByPath as z };
+export { $$ACTOR_TYPE as $, Actor as A, interpret as B, isMachineSnapshot as C, matchesState as D, pathToStateValue as E, toObserver as F, getAllOwnEventDescriptors as G, and as H, not as I, or as J, stateIn as K, cancel as L, raise as M, NULL_EVENT as N, stop as O, stopChild as P, spawnChild as Q, ProcessingStatus as R, STATE_DELIMITER as S, cloneMachineSnapshot as T, XSTATE_ERROR as U, createErrorActorEvent as V, XSTATE_STOP as X, toTransitionConfigArray as a, formatTransition as b, createInvokeId as c, formatInitialTransition as d, evaluateGuard as e, formatTransitions as f, getDelayedTransitions as g, getCandidates as h, getAllStateNodes as i, getStateNodes as j, createMachineSnapshot as k, isInFinalState as l, mapValues as m, macrostep as n, transitionNode as o, resolveActionsAndContext as p, createInitEvent as q, resolveStateValue as r, microstep as s, toArray as t, getInitialStateNodes as u, isStateId as v, getStateNodeByPath as w, getPersistedState as x, resolveReferencedActor as y, createActor as z };