xstate 5.0.0-beta.47 → 5.0.0-beta.49

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/promise.d.ts

@@ -3,13 +3,13 @@ import { XSTATE_STOP } from "../constants.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;

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

@@ -168,13 +168,38 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorRef<Eve
     getSnapshot(): SnapshotFrom<TLogic>;
 }
 /**
- * Creates a new `ActorRef` instance for the given machine with the provided options, if any.
+ * Creates a new actor instance for the given actor logic with the provided options, if any.
  *
- * @param machine The machine to create an actor from
- * @param options `ActorRef` options
+ * @remarks
+ * When you create an actor from actor logic via `createActor(logic)`, you implicitly create an actor system where the created actor is the root actor.
+ * Any actors spawned from this root actor and its descendants are part of that actor system.
+ *
+ * @example
+ * ```ts
+ * import { createActor } from 'xstate';
+ * import { someActorLogic } from './someActorLogic.ts';
+ *
+ * // Creating the actor, which implicitly creates an actor system with itself as the root actor
+ * const actor = createActor(someActorLogic);
+ *
+ * actor.subscribe((snapshot) => {
+ *   console.log(snapshot);
+ * });
+ *
+ * // Actors must be started by calling `actor.start()`, which will also start the actor system.
+ * actor.start();
+ *
+ * // Actors can receive events
+ * actor.send({ type: 'someEvent' });
+ *
+ * // You can stop root actors by calling `actor.stop()`, which will also stop the actor system and all actors in that system.
+ * actor.stop();
+ * ```
+ *
+ * @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<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, options?: ActorOptions<TLogic>): Actor<TLogic>;
+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, Values } from "./types.js";
 type ToParameterizedObject<TParameterizedMap extends Record<string, ParameterizedObject['params'] | undefined>> = Values<{
     [K in keyof TParameterizedMap & string]: {
         type: K;
@@ -9,13 +9,29 @@ type ToParameterizedObject<TParameterizedMap extends Record<string, Parameterize
     };
 }>;
 type DefaultToAnyActors<TActors extends Record<string, AnyActorLogic>> = IsNever<keyof TActors> extends true ? Record<string, AnyActorLogic> : TActors;
-type ToProvidedActor<TChildrenMap extends Record<string, string>, TActors extends Record<Values<TChildrenMap>, AnyActorLogic>> = Values<{
-    [K in keyof DefaultToAnyActors<TActors> & string]: {
+type ToProvidedActor<TChildrenMap extends Record<string, string>, TActors extends Record<Values<TChildrenMap>, AnyActorLogic>, TResolvedActors extends Record<string, AnyActorLogic> = DefaultToAnyActors<TActors>> = Values<{
+    [K in keyof TResolvedActors & string]: {
         src: K;
-        logic: TActors[K];
+        logic: TResolvedActors[K];
         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 }: {
     types?: SetupTypes<TContext, TEvent, TChildrenMap, TTag, TInput, TOutput>;
@@ -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;
@@ -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
@@ -844,11 +845,11 @@ 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 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 +879,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-156f5f68.development.esm.js → raise-1873c645.development.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;
@@ -320,7 +317,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;
@@ -849,10 +846,36 @@ class Actor {
 }
 
 /**
- * Creates a new `ActorRef` instance for the given machine with the provided options, if any.
+ * Creates a new actor instance for the given actor logic with the provided options, if any.
+ *
+ * @remarks
+ * When you create an actor from actor logic via `createActor(logic)`, you implicitly create an actor system where the created actor is the root actor.
+ * Any actors spawned from this root actor and its descendants are part of that actor system.
+ *
+ * @example
+ * ```ts
+ * import { createActor } from 'xstate';
+ * import { someActorLogic } from './someActorLogic.ts';
+ *
+ * // Creating the actor, which implicitly creates an actor system with itself as the root actor
+ * const actor = createActor(someActorLogic);
+ *
+ * actor.subscribe((snapshot) => {
+ *   console.log(snapshot);
+ * });
+ *
+ * // Actors must be started by calling `actor.start()`, which will also start the actor system.
+ * actor.start();
+ *
+ * // Actors can receive events
+ * actor.send({ type: 'someEvent' });
+ *
+ * // You can stop root actors by calling `actor.stop()`, which will also stop the actor system and all actors in that system.
+ * actor.stop();
+ * ```
  *
- * @param machine The machine to create an actor from
- * @param options `ActorRef` options
+ * @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
  */
 
 function createActor(logic, options) {
@@ -2153,10 +2176,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,

package/dist/{raise-7dc97582.development.cjs.js → raise-495f4b9f.development.cjs.js}

@@ -250,9 +250,6 @@ function mapValues(collection, iteratee) {
   }
   return result;
 }
-function flatten(array) {
-  return [].concat(...array);
-}
 function toArrayStrict(value) {
   if (isArray(value)) {
     return value;
@@ -322,7 +319,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;
@@ -851,10 +848,36 @@ class Actor {
 }
 
 /**
- * Creates a new `ActorRef` instance for the given machine with the provided options, if any.
+ * Creates a new actor instance for the given actor logic with the provided options, if any.
+ *
+ * @remarks
+ * When you create an actor from actor logic via `createActor(logic)`, you implicitly create an actor system where the created actor is the root actor.
+ * Any actors spawned from this root actor and its descendants are part of that actor system.
+ *
+ * @example
+ * ```ts
+ * import { createActor } from 'xstate';
+ * import { someActorLogic } from './someActorLogic.ts';
+ *
+ * // Creating the actor, which implicitly creates an actor system with itself as the root actor
+ * const actor = createActor(someActorLogic);
+ *
+ * actor.subscribe((snapshot) => {
+ *   console.log(snapshot);
+ * });
+ *
+ * // Actors must be started by calling `actor.start()`, which will also start the actor system.
+ * actor.start();
+ *
+ * // Actors can receive events
+ * actor.send({ type: 'someEvent' });
+ *
+ * // You can stop root actors by calling `actor.stop()`, which will also stop the actor system and all actors in that system.
+ * actor.stop();
+ * ```
  *
- * @param machine The machine to create an actor from
- * @param options `ActorRef` options
+ * @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
  */
 
 function createActor(logic, options) {
@@ -2155,10 +2178,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,

package/dist/{raise-7af24c22.cjs.js → raise-8f9c4a5a.cjs.js}

@@ -250,9 +250,6 @@ function mapValues(collection, iteratee) {
   }
   return result;
 }
-function flatten(array) {
-  return [].concat(...array);
-}
 function toArrayStrict(value) {
   if (isArray(value)) {
     return value;
@@ -319,7 +316,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;
@@ -840,10 +837,36 @@ class Actor {
 }
 
 /**
- * Creates a new `ActorRef` instance for the given machine with the provided options, if any.
+ * Creates a new actor instance for the given actor logic with the provided options, if any.
+ *
+ * @remarks
+ * When you create an actor from actor logic via `createActor(logic)`, you implicitly create an actor system where the created actor is the root actor.
+ * Any actors spawned from this root actor and its descendants are part of that actor system.
+ *
+ * @example
+ * ```ts
+ * import { createActor } from 'xstate';
+ * import { someActorLogic } from './someActorLogic.ts';
+ *
+ * // Creating the actor, which implicitly creates an actor system with itself as the root actor
+ * const actor = createActor(someActorLogic);
+ *
+ * actor.subscribe((snapshot) => {
+ *   console.log(snapshot);
+ * });
+ *
+ * // Actors must be started by calling `actor.start()`, which will also start the actor system.
+ * actor.start();
+ *
+ * // Actors can receive events
+ * actor.send({ type: 'someEvent' });
+ *
+ * // You can stop root actors by calling `actor.stop()`, which will also stop the actor system and all actors in that system.
+ * actor.stop();
+ * ```
  *
- * @param machine The machine to create an actor from
- * @param options `ActorRef` options
+ * @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
  */
 
 function createActor(logic, options) {
@@ -2107,10 +2130,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,

package/dist/{raise-91ec8b4f.esm.js → raise-e4cc6d4f.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;
@@ -838,10 +835,36 @@ class Actor {
 }
 
 /**
- * Creates a new `ActorRef` instance for the given machine with the provided options, if any.
+ * Creates a new actor instance for the given actor logic with the provided options, if any.
+ *
+ * @remarks
+ * When you create an actor from actor logic via `createActor(logic)`, you implicitly create an actor system where the created actor is the root actor.
+ * Any actors spawned from this root actor and its descendants are part of that actor system.
+ *
+ * @example
+ * ```ts
+ * import { createActor } from 'xstate';
+ * import { someActorLogic } from './someActorLogic.ts';
+ *
+ * // Creating the actor, which implicitly creates an actor system with itself as the root actor
+ * const actor = createActor(someActorLogic);
+ *
+ * actor.subscribe((snapshot) => {
+ *   console.log(snapshot);
+ * });
+ *
+ * // Actors must be started by calling `actor.start()`, which will also start the actor system.
+ * actor.start();
+ *
+ * // Actors can receive events
+ * actor.send({ type: 'someEvent' });
+ *
+ * // You can stop root actors by calling `actor.stop()`, which will also stop the actor system and all actors in that system.
+ * actor.stop();
+ * ```
  *
- * @param machine The machine to create an actor from
- * @param options `ActorRef` options
+ * @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
  */
 
 function createActor(logic, options) {
@@ -2105,10 +2128,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,

package/dist/{send-7489590c.development.esm.js → send-0a381ca2.development.esm.js}

@@ -1,4 +1,4 @@
-import { U as ProcessingStatus, V as createErrorActorEvent, B as resolveReferencedActor, C as createActor, p as cloneMachineSnapshot, e as evaluateGuard, t as toArray, W as XSTATE_ERROR } from './raise-156f5f68.development.esm.js';
+import { U as ProcessingStatus, V as createErrorActorEvent, B as resolveReferencedActor, C as createActor, p as cloneMachineSnapshot, e as evaluateGuard, t as toArray, W as XSTATE_ERROR } from './raise-1873c645.development.esm.js';
 
 function createSpawner(actorScope, {
   machine,

package/dist/{send-ed326064.esm.js → send-22880315.esm.js}

@@ -1,4 +1,4 @@
-import { U as ProcessingStatus, V as createErrorActorEvent, B as resolveReferencedActor, C as createActor, p as cloneMachineSnapshot, e as evaluateGuard, t as toArray, W as XSTATE_ERROR } from './raise-91ec8b4f.esm.js';
+import { U as ProcessingStatus, V as createErrorActorEvent, B as resolveReferencedActor, C as createActor, p as cloneMachineSnapshot, e as evaluateGuard, t as toArray, W as XSTATE_ERROR } from './raise-e4cc6d4f.esm.js';
 
 function createSpawner(actorScope, {
   machine,

package/dist/{send-bc0d3e22.development.cjs.js → send-8d30b415.development.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var guards_dist_xstateGuards = require('./raise-7dc97582.development.cjs.js');
+var guards_dist_xstateGuards = require('./raise-495f4b9f.development.cjs.js');
 
 function createSpawner(actorScope, {
   machine,

package/dist/{send-401f5c30.cjs.js → send-8ed5c8b2.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var guards_dist_xstateGuards = require('./raise-7af24c22.cjs.js');
+var guards_dist_xstateGuards = require('./raise-8f9c4a5a.cjs.js');
 
 function createSpawner(actorScope, {
   machine,