xstate 5.0.0-beta.37 → 5.0.0-beta.38

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

@@ -1,6 +1,6 @@
 import { ActionArgs, EventObject, MachineContext, NoInfer, RaiseActionOptions, SendExpr, ParameterizedObject } from "../types.js";
-export interface RaiseAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TEvent extends EventObject, TDelay extends string> {
-    (_: ActionArgs<TContext, TExpressionEvent, TExpressionAction, TEvent>): void;
+export interface RaiseAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TDelay extends string> {
+    (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams): void;
     _out_TEvent?: TEvent;
     _out_TDelay?: TDelay;
 }
@@ -10,4 +10,4 @@ export interface RaiseAction<TContext extends MachineContext, TExpressionEvent e
  *
  * @param eventType The event to raise.
  */
-export declare function raise<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent, TExpressionAction extends ParameterizedObject | undefined = ParameterizedObject | undefined, TDelay extends string = string>(eventOrExpr: NoInfer<TEvent> | SendExpr<TContext, TExpressionEvent, TExpressionAction, NoInfer<TEvent>, TEvent>, options?: RaiseActionOptions<TContext, TExpressionEvent, TExpressionAction, NoInfer<TEvent>, NoInfer<TDelay>>): RaiseAction<TContext, TExpressionEvent, TExpressionAction, TEvent, TDelay>;
+export declare function raise<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent, TParams extends ParameterizedObject['params'] | undefined = ParameterizedObject['params'] | undefined, TDelay extends string = string>(eventOrExpr: NoInfer<TEvent> | SendExpr<TContext, TExpressionEvent, TParams, NoInfer<TEvent>, TEvent>, options?: RaiseActionOptions<TContext, TExpressionEvent, TParams, NoInfer<TEvent>, NoInfer<TDelay>>): RaiseAction<TContext, TExpressionEvent, TParams, TEvent, TDelay>;

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

@@ -1,6 +1,6 @@
 import { ActionArgs, ActorRef, AnyActorRef, AnyEventObject, Cast, EventFrom, EventObject, InferEvent, MachineContext, SendExpr, SendToActionOptions, SendToActionParams, UnifiedArg, ParameterizedObject, NoInfer } from "../types.js";
-export interface SendToAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TEvent extends EventObject, TDelay extends string> {
-    (_: ActionArgs<TContext, TExpressionEvent, TExpressionAction, TEvent>): void;
+export interface SendToAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TDelay extends string> {
+    (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams): void;
     _out_TDelay?: TDelay;
 }
 /**
@@ -12,22 +12,22 @@ export interface SendToAction<TContext extends MachineContext, TExpressionEvent
  *  - `id` - The unique send event identifier (used with `cancel()`).
  *  - `delay` - The number of milliseconds to delay the sending of the event.
  */
-export declare function sendTo<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TTargetActor extends AnyActorRef, TEvent extends EventObject, TDelay extends string>(to: TTargetActor | string | ((args: ActionArgs<TContext, TExpressionEvent, TExpressionAction, TEvent>) => TTargetActor | string), eventOrExpr: EventFrom<TTargetActor> | SendExpr<TContext, TExpressionEvent, TExpressionAction, InferEvent<Cast<EventFrom<TTargetActor>, EventObject>>, TEvent>, options?: SendToActionOptions<TContext, TExpressionEvent, TExpressionAction, NoInfer<TEvent>, NoInfer<TDelay>>): SendToAction<TContext, TExpressionEvent, TExpressionAction, TEvent, TDelay>;
+export declare function sendTo<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TTargetActor extends AnyActorRef, TEvent extends EventObject, TDelay extends string>(to: TTargetActor | string | ((args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams) => TTargetActor | string), eventOrExpr: EventFrom<TTargetActor> | SendExpr<TContext, TExpressionEvent, TParams, InferEvent<Cast<EventFrom<TTargetActor>, EventObject>>, TEvent>, options?: SendToActionOptions<TContext, TExpressionEvent, TParams, NoInfer<TEvent>, NoInfer<TDelay>>): SendToAction<TContext, TExpressionEvent, TParams, TEvent, TDelay>;
 /**
  * Sends an event to this machine's parent.
  *
  * @param event The event to send to the parent machine.
  * @param options Options to pass into the send event.
  */
-export declare function sendParent<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TSentEvent extends EventObject = AnyEventObject, TEvent extends EventObject = AnyEventObject, TDelay extends string = string>(event: TSentEvent | SendExpr<TContext, TExpressionEvent, TExpressionAction, TSentEvent, TEvent>, options?: SendToActionOptions<TContext, TExpressionEvent, TExpressionAction, TEvent, TDelay>): SendToAction<TContext, TExpressionEvent, TExpressionAction, TEvent, TDelay>;
-type Target<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TEvent extends EventObject> = string | ActorRef<any, any> | ((args: ActionArgs<TContext, TExpressionEvent, TExpressionAction, TEvent>) => string | ActorRef<any, any>);
+export declare function sendParent<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TSentEvent extends EventObject = AnyEventObject, TEvent extends EventObject = AnyEventObject, TDelay extends string = string>(event: TSentEvent | SendExpr<TContext, TExpressionEvent, TParams, TSentEvent, TEvent>, options?: SendToActionOptions<TContext, TExpressionEvent, TParams, TEvent, TDelay>): SendToAction<TContext, TExpressionEvent, TParams, TEvent, TDelay>;
+type Target<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject> = string | ActorRef<any, any> | ((args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams) => string | ActorRef<any, any>);
 /**
  * Forwards (sends) an event to a specified service.
  *
  * @param target The target service to forward the event to.
  * @param options Options to pass into the send action creator.
  */
-export declare function forwardTo<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TEvent extends EventObject, TDelay extends string>(target: Target<TContext, TExpressionEvent, TExpressionAction, TEvent>, options?: SendToActionOptions<TContext, TExpressionEvent, TExpressionAction, TEvent, TDelay>): SendToAction<TContext, TExpressionEvent, TExpressionAction, TEvent, TDelay>;
+export declare function forwardTo<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TDelay extends string>(target: Target<TContext, TExpressionEvent, TParams, TEvent>, options?: SendToActionOptions<TContext, TExpressionEvent, TParams, TEvent, TDelay>): SendToAction<TContext, TExpressionEvent, TParams, TEvent, TDelay>;
 /**
  * Escalates an error by sending it as an event to this machine's parent.
  *
@@ -35,5 +35,5 @@ export declare function forwardTo<TContext extends MachineContext, TExpressionEv
  * takes in the `context`, `event`, and `meta`, and returns the error data to send.
  * @param options Options to pass into the send action creator.
  */
-export declare function escalate<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TErrorData = any, TEvent extends EventObject = AnyEventObject>(errorData: TErrorData | ((args: UnifiedArg<TContext, TExpressionEvent, TEvent>) => TErrorData), options?: SendToActionParams<TContext, TExpressionEvent, TExpressionAction, EventObject, TEvent, string>): SendToAction<TContext, TExpressionEvent, TExpressionAction, TEvent, string>;
+export declare function escalate<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TErrorData = any, TEvent extends EventObject = AnyEventObject>(errorData: TErrorData | ((args: UnifiedArg<TContext, TExpressionEvent, TEvent>) => TErrorData), options?: SendToActionParams<TContext, TExpressionEvent, TParams, EventObject, TEvent, string>): SendToAction<TContext, TExpressionEvent, TParams, TEvent, string>;
 export {};

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

@@ -0,0 +1,34 @@
+import { ActionArgs, EventObject, MachineContext, ParameterizedObject, AnyActorLogic, ProvidedActor, IsLiteralString, InputFrom, UnifiedArg } from "../types.js";
+type ResolvableActorId<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TId extends string | undefined> = TId | ((args: UnifiedArg<TContext, TExpressionEvent, TEvent>) => TId);
+export interface SpawnAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TActor extends ProvidedActor> {
+    (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams): void;
+    _out_TActor?: TActor;
+}
+type DistributeActors<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TActor extends ProvidedActor> = TActor extends any ? 'id' extends keyof TActor ? [
+    src: TActor['src'],
+    options: {
+        id: ResolvableActorId<TContext, TExpressionEvent, TEvent, TActor['id']>;
+        systemId?: string;
+        input?: InputFrom<TActor['logic']>;
+        syncSnapshot?: boolean;
+    }
+] : [
+    src: TActor['src'],
+    options?: {
+        id?: ResolvableActorId<TContext, TExpressionEvent, TEvent, string>;
+        systemId?: string;
+        input?: InputFrom<TActor['logic']>;
+        syncSnapshot?: boolean;
+    }
+] : never;
+type SpawnArguments<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TActor extends ProvidedActor> = IsLiteralString<TActor['src']> extends true ? DistributeActors<TContext, TExpressionEvent, TEvent, TActor> : [
+    src: string | AnyActorLogic,
+    options?: {
+        id?: ResolvableActorId<TContext, TExpressionEvent, TEvent, string>;
+        systemId?: string;
+        input?: unknown;
+        syncSnapshot?: boolean;
+    }
+];
+export declare function spawn<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TActor extends ProvidedActor>(...[src, { id, systemId, input, syncSnapshot }]: SpawnArguments<TContext, TExpressionEvent, TEvent, TActor>): SpawnAction<TContext, TExpressionEvent, TParams, TEvent, TActor>;
+export {};

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

@@ -1,12 +1,12 @@
 import { ActionArgs, ActorRef, EventObject, MachineContext, ParameterizedObject } from "../types.js";
-type ResolvableActorRef<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TEvent extends EventObject> = string | ActorRef<any, any> | ((args: ActionArgs<TContext, TExpressionEvent, TExpressionAction, TEvent>) => ActorRef<any, any> | string);
-export interface StopAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TEvent extends EventObject> {
-    (_: ActionArgs<TContext, TExpressionEvent, TExpressionAction, TEvent>): void;
+type ResolvableActorRef<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject> = string | ActorRef<any, any> | ((args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams) => ActorRef<any, any> | string);
+export interface StopAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject> {
+    (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams): void;
 }
 /**
  * Stops an actor.
  *
  * @param actorRef The actor to stop.
  */
-export declare function stop<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TEvent extends EventObject>(actorRef: ResolvableActorRef<TContext, TExpressionEvent, TExpressionAction, TEvent>): StopAction<TContext, TExpressionEvent, TExpressionAction, TEvent>;
+export declare function stop<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject>(actorRef: ResolvableActorRef<TContext, TExpressionEvent, TParams, TEvent>): StopAction<TContext, TExpressionEvent, TParams, TEvent>;
 export {};

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

@@ -6,3 +6,4 @@ export { pure, type PureAction } from "./actions/pure.js";
 export { raise, type RaiseAction } from "./actions/raise.js";
 export { escalate, forwardTo, sendParent, sendTo, type SendToAction } from "./actions/send.js";
 export { stop, type StopAction } from "./actions/stop.js";
+export { spawn, type SpawnAction } from "./actions/spawn.js";

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

@@ -1,10 +1,10 @@
-import { ActorLogic, EventObject, AnyActorSystem, AnyEventObject, ActorSystem, ActorRefFrom, Snapshot, HomomorphicOmit } from "../types.js";
+import { ActorLogic, EventObject, AnyActorSystem, AnyEventObject, ActorSystem, ActorRefFrom, Snapshot } from "../types.js";
 type CallbackSnapshot<TInput, TEvent> = 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, HomomorphicOmit<CallbackSnapshot<TInput, TEvent>, '_receivers' | '_dispose'>, ActorSystem<any>>;
+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 Receiver<TEvent extends EventObject> = (listener: {
     bivarianceHack(event: TEvent): void;

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

@@ -1,14 +1,13 @@
-import { Subscribable, ActorLogic, EventObject, Subscription, AnyActorSystem, ActorRefFrom, Snapshot, HomomorphicOmit } from "../types.js";
+import { Subscribable, ActorLogic, EventObject, Subscription, AnyActorSystem, ActorRefFrom, Snapshot } from "../types.js";
 export type ObservableSnapshot<TContext, TInput> = Snapshot<undefined> & {
     context: TContext | undefined;
     input: TInput | undefined;
     _subscription: Subscription | undefined;
 };
-export type ObservablePersistedState<TContext, TInput> = HomomorphicOmit<ObservableSnapshot<TContext, TInput>, '_subscription'>;
 export type ObservableActorLogic<TContext, TInput> = ActorLogic<ObservableSnapshot<TContext, TInput>, {
     type: string;
     [k: string]: unknown;
-}, TInput, ObservablePersistedState<TContext, TInput>, AnyActorSystem>;
+}, TInput, AnyActorSystem>;
 export type ObservableActorRef<TContext> = ActorRefFrom<ObservableActorLogic<TContext, any>>;
 export declare function fromObservable<TContext, TInput>(observableCreator: ({ input, system }: {
     input: TInput;

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

@@ -18,7 +18,6 @@ export type PromiseActorLogic<TOutput, TInput = unknown> = ActorLogic<PromiseSna
     type: string;
     [k: string]: unknown;
 }, TInput, // input
-PromiseSnapshot<TOutput, TInput>, // persisted state
 ActorSystem<any>>;
 export type PromiseActorRef<TOutput> = ActorRefFrom<PromiseActorLogic<TOutput, unknown>>;
 export declare function fromPromise<TOutput, TInput = unknown>(promiseCreator: ({ input, system }: {

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

@@ -2,7 +2,7 @@ import { ActorLogic, ActorContext, ActorSystem, EventObject, ActorRefFrom, AnyAc
 export type TransitionSnapshot<TContext> = Snapshot<undefined> & {
     context: TContext;
 };
-export type TransitionActorLogic<TContext, TEvent extends EventObject, TInput> = ActorLogic<TransitionSnapshot<TContext>, TEvent, TInput, TransitionSnapshot<TContext>, AnyActorSystem>;
+export type TransitionActorLogic<TContext, TEvent extends EventObject, TInput> = ActorLogic<TransitionSnapshot<TContext>, TEvent, TInput, AnyActorSystem>;
 export type TransitionActorRef<TContext, TEvent extends EventObject> = ActorRefFrom<TransitionActorLogic<TransitionSnapshot<TContext>, TEvent, unknown>>;
 /**
  * Returns actor logic from a transition function and its initial state.

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

@@ -1,20 +1,19 @@
 import type { EventObject, StateValue, MachineContext, ParameterizedObject, AnyState, NoRequiredParams, NoInfer, WithDynamicParams } from "./types.js";
-export type GuardPredicate<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionGuard extends ParameterizedObject | undefined, TGuard extends ParameterizedObject> = {
-    (args: GuardArgs<TContext, TExpressionEvent, TExpressionGuard>): boolean;
+export type GuardPredicate<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TGuard extends ParameterizedObject> = {
+    (args: GuardArgs<TContext, TExpressionEvent>, params: TParams): boolean;
     _out_TGuard?: TGuard;
 };
-export interface GuardArgs<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionGuard extends ParameterizedObject | undefined> {
+export interface GuardArgs<TContext extends MachineContext, TExpressionEvent extends EventObject> {
     context: TContext;
     event: TExpressionEvent;
-    guard: TExpressionGuard;
 }
-export type Guard<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionGuard extends ParameterizedObject | undefined, TGuard extends ParameterizedObject> = NoRequiredParams<TGuard> | WithDynamicParams<TContext, TExpressionEvent, TGuard> | GuardPredicate<TContext, TExpressionEvent, TExpressionGuard, TGuard>;
+export type Guard<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TGuard extends ParameterizedObject> = NoRequiredParams<TGuard> | WithDynamicParams<TContext, TExpressionEvent, TGuard> | GuardPredicate<TContext, TExpressionEvent, TParams, TGuard>;
 export type UnknownGuard = UnknownReferencedGuard | UnknownInlineGuard;
-type UnknownReferencedGuard = Guard<MachineContext, EventObject, ParameterizedObject, ParameterizedObject>;
+type UnknownReferencedGuard = Guard<MachineContext, EventObject, ParameterizedObject['params'], ParameterizedObject>;
 type UnknownInlineGuard = Guard<MachineContext, EventObject, undefined, ParameterizedObject>;
-export declare function stateIn<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionGuard extends ParameterizedObject | undefined>(stateValue: StateValue): GuardPredicate<TContext, TExpressionEvent, TExpressionGuard, any>;
-export declare function not<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionGuard extends ParameterizedObject | undefined, TGuard extends ParameterizedObject>(guard: Guard<TContext, TExpressionEvent, TExpressionGuard, NoInfer<TGuard>>): GuardPredicate<TContext, TExpressionEvent, TExpressionGuard, TGuard>;
-export declare function and<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionGuard extends ParameterizedObject | undefined, TGuard extends ParameterizedObject>(guards: ReadonlyArray<Guard<TContext, TExpressionEvent, TExpressionGuard, NoInfer<TGuard>>>): GuardPredicate<TContext, TExpressionEvent, TExpressionGuard, TGuard>;
-export declare function or<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionGuard extends ParameterizedObject | undefined, TGuard extends ParameterizedObject>(guards: ReadonlyArray<Guard<TContext, TExpressionEvent, TExpressionGuard, NoInfer<TGuard>>>): GuardPredicate<TContext, TExpressionEvent, TExpressionGuard, TGuard>;
+export declare function stateIn<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined>(stateValue: StateValue): GuardPredicate<TContext, TExpressionEvent, TParams, any>;
+export declare function not<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TGuard extends ParameterizedObject>(guard: Guard<TContext, TExpressionEvent, TParams, NoInfer<TGuard>>): GuardPredicate<TContext, TExpressionEvent, TParams, TGuard>;
+export declare function and<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TGuard extends ParameterizedObject>(guards: ReadonlyArray<Guard<TContext, TExpressionEvent, TParams, NoInfer<TGuard>>>): GuardPredicate<TContext, TExpressionEvent, TParams, TGuard>;
+export declare function or<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TGuard extends ParameterizedObject>(guards: ReadonlyArray<Guard<TContext, TExpressionEvent, TParams, NoInfer<TGuard>>>): GuardPredicate<TContext, TExpressionEvent, TParams, TGuard>;
 export declare function evaluateGuard<TContext extends MachineContext, TExpressionEvent extends EventObject>(guard: UnknownGuard | UnknownInlineGuard, context: TContext, event: TExpressionEvent, state: AnyState): boolean;
 export {};

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

@@ -1,6 +1,6 @@
 import { symbolObservable } from "./symbolObservable.js";
 import { AreAllImplementationsAssumedToBeProvided, MissingImplementationsError } from "./typegenTypes.js";
-import type { ActorSystem, AnyActorLogic, AnyStateMachine, EventFromLogic, PersistedStateFrom, SnapshotFrom, AnyActorRef } from "./types.js";
+import type { ActorSystem, AnyActorLogic, AnyStateMachine, EventFromLogic, SnapshotFrom, AnyActorRef, Snapshot } from "./types.js";
 import { ActorRef, EventObject, InteropSubscribable, ActorOptions, Observer, Subscription } from "./types.js";
 export declare const $$ACTOR_TYPE = 1;
 export type SnapshotListener<TLogic extends AnyActorLogic> = (state: SnapshotFrom<TLogic>) => void;
@@ -97,7 +97,7 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorRef<Eve
         xstate$$type: number;
         id: string;
     };
-    getPersistedState(): PersistedStateFrom<TLogic> | undefined;
+    getPersistedState(): Snapshot<unknown>;
     [symbolObservable](): InteropSubscribable<SnapshotFrom<TLogic>>;
     getSnapshot(): SnapshotFrom<TLogic>;
 }

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

@@ -1,5 +1,5 @@
 import { ActorRefFrom, AnyActorContext, AnyActorLogic, AnyActorRef, AnyEventObject, AnyState, InputFrom, IsLiteralString, ProvidedActor } from "./types.js";
-type SpawnOptions<TActor extends ProvidedActor, TSrc extends TActor['src']> = TActor extends {
+export type SpawnOptions<TActor extends ProvidedActor, TSrc extends TActor['src']> = TActor extends {
     src: TSrc;
 } ? 'id' extends keyof TActor ? [
     options: {
@@ -25,4 +25,3 @@ export type Spawner<TActor extends ProvidedActor> = IsLiteralString<TActor['src'
     syncSnapshot?: boolean;
 }) => TLogic extends string ? AnyActorRef : ActorRefFrom<TLogic>;
 export declare function createSpawner(actorContext: AnyActorContext, { machine, context }: AnyState, event: AnyEventObject, spawnedChildren: Record<string, AnyActorRef>): Spawner<any>;
-export {};

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

@@ -44,11 +44,6 @@ export declare function transitionNode<TContext extends MachineContext, TEvent e
 export declare function removeConflictingTransitions(enabledTransitions: Array<AnyTransitionDefinition>, configuration: Set<AnyStateNode>, historyValue: AnyHistoryValue): Array<AnyTransitionDefinition>;
 /**
  * https://www.w3.org/TR/scxml/#microstepProcedure
- *
- * @private
- * @param transitions
- * @param currentState
- * @param mutConfiguration
  */
 export declare function microstep<TContext extends MachineContext, TEvent extends EventObject>(transitions: Array<AnyTransitionDefinition>, currentState: AnyState, actorCtx: AnyActorContext, event: AnyEventObject, isInitial: boolean, internalQueue: Array<AnyEventObject>): AnyState;
 export declare function resolveActionsAndContext(currentState: AnyState, event: AnyEventObject, actorCtx: AnyActorContext, actions: UnknownAction[], internalQueue: AnyEventObject[], deferredActorIds?: string[]): AnyState;

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

@@ -14,7 +14,11 @@ export type HomomorphicPick<T, K extends keyof any> = {
 export type HomomorphicOmit<T, K extends keyof any> = {
     [P in keyof T as Exclude<P, K>]: T[P];
 };
+export type GetParameterizedParams<T extends ParameterizedObject | undefined> = T extends any ? ('params' extends keyof T ? T['params'] : undefined) : never;
 /**
+ *
+ * @remarks
+ *
  * `T | unknown` reduces to `unknown` and that can be problematic when it comes to contextual typing.
  * It especially is a problem when the union has a function member, like here:
  *
@@ -72,15 +76,14 @@ export interface UnifiedArg<TContext extends MachineContext, TExpressionEvent ex
     system: ActorSystem<any>;
 }
 export type MachineContext = Record<string, any>;
-export interface ActionArgs<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TEvent extends EventObject> extends UnifiedArg<TContext, TExpressionEvent, TEvent> {
-    action: TExpressionAction;
+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 _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 _TPersisted, infer _TSystem> ? TInput : never;
-export type OutputFrom<T extends AnyActorLogic> = T extends ActorLogic<infer TSnapshot, infer _TEvent, infer _TInput, infer _TPersisted, infer _TSystem> ? (TSnapshot & {
+export type InputFrom<T extends AnyActorLogic> = T extends StateMachine<infer _TContext, infer _TEvent, 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 OutputFrom<T extends AnyActorLogic> = T extends ActorLogic<infer TSnapshot, infer _TEvent, infer _TInput, infer _TSystem> ? (TSnapshot & {
     status: 'done';
 })['output'] : never;
-export type ActionFunction<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string> = {
-    (args: ActionArgs<TContext, TExpressionEvent, TExpressionAction, TEvent>): void;
+export type ActionFunction<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string> = {
+    (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams): void;
     _out_TEvent?: TEvent;
     _out_TActor?: TActor;
     _out_TAction?: TAction;
@@ -102,9 +105,9 @@ export type WithDynamicParams<TContext extends MachineContext, TExpressionEvent
         event: TExpressionEvent;
     }) => T['params']);
 }, undefined extends T['params'] ? false : true> : never;
-export type Action<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string> = NoRequiredParams<TAction> | WithDynamicParams<TContext, TExpressionEvent, TAction> | ActionFunction<TContext, TExpressionEvent, TEvent, TExpressionAction, TActor, TAction, TGuard, TDelay>;
-export type UnknownAction = Action<MachineContext, EventObject, EventObject, ParameterizedObject | undefined, ProvidedActor, ParameterizedObject, ParameterizedObject, string>;
-export type Actions<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string> = SingleOrArray<Action<TContext, TExpressionEvent, TEvent, TExpressionAction, TActor, TAction, TGuard, TDelay>>;
+export type Action<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string> = NoRequiredParams<TAction> | WithDynamicParams<TContext, TExpressionEvent, TAction> | ActionFunction<TContext, TExpressionEvent, TEvent, TParams, TActor, TAction, TGuard, TDelay>;
+export type UnknownAction = Action<MachineContext, EventObject, EventObject, ParameterizedObject['params'] | undefined, ProvidedActor, ParameterizedObject, ParameterizedObject, string>;
+export type Actions<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string> = SingleOrArray<Action<TContext, TExpressionEvent, TEvent, TParams, TActor, TAction, TGuard, TDelay>>;
 export type StateKey = string | AnyState;
 export interface StateValueMap {
     [key: string]: StateValue;
@@ -112,7 +115,10 @@ export interface StateValueMap {
 /**
  * The string or object representing the state value relative to the parent state node.
  *
+ * @remarks
+ *
  * - For a child atomic state node, this is a string, e.g., `"pending"`.
+ *
  * - For complex state nodes, this is an object, e.g., `{ success: "someChildState" }`.
  */
 export type StateValue = string | StateValueMap;
@@ -283,9 +289,6 @@ export interface StateNodeConfig<TContext extends MachineContext, TEvent extends
      * An eventless transition that is always taken when this state node is active.
      */
     always?: TransitionConfigOrTarget<TContext, TEvent, TEvent, TActor, TAction, TGuard, TDelay>;
-    /**
-     * @private
-     */
     parent?: StateNode<TContext, TEvent>;
     /**
      * The meta data associated with this state node, which will be returned in State instances.
@@ -364,17 +367,17 @@ export interface HistoryStateNodeConfig<TContext extends MachineContext, TEvent
 }
 export type SimpleOrStateNodeConfig<TContext extends MachineContext, TEvent extends EventObject> = AtomicStateNodeConfig<TContext, TEvent> | StateNodeConfig<TContext, TEvent, TODO, TODO, TODO, TODO, TODO, TODO>;
 export type ActionFunctionMap<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject = ParameterizedObject, TGuard extends ParameterizedObject = ParameterizedObject, TDelay extends string = string> = {
-    [K in TAction['type']]?: ActionFunction<TContext, TEvent, TEvent, TAction extends {
+    [K in TAction['type']]?: ActionFunction<TContext, TEvent, TEvent, GetParameterizedParams<TAction extends {
         type: K;
-    } ? TAction : never, TActor, TAction, TGuard, TDelay>;
+    } ? TAction : never>, TActor, TAction, TGuard, TDelay>;
 };
 type GuardMap<TContext extends MachineContext, TEvent extends EventObject, TGuard extends ParameterizedObject> = {
-    [K in TGuard['type']]?: GuardPredicate<TContext, TEvent, TGuard extends {
+    [K in TGuard['type']]?: GuardPredicate<TContext, TEvent, GetParameterizedParams<TGuard extends {
         type: K;
-    } ? TGuard : never, TGuard>;
+    } ? TGuard : never>, TGuard>;
 };
-export type DelayFunctionMap<TContext extends MachineContext, TEvent extends EventObject, TAction extends ParameterizedObject> = Record<string, DelayConfig<TContext, TEvent, TAction, TEvent>>;
-export type DelayConfig<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TEvent extends EventObject> = number | DelayExpr<TContext, TExpressionEvent, TExpressionAction, TEvent>;
+export type DelayFunctionMap<TContext extends MachineContext, TEvent extends EventObject, TAction extends ParameterizedObject> = Record<string, DelayConfig<TContext, TEvent, TAction['params'], TEvent>>;
+export type DelayConfig<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject> = number | DelayExpr<TContext, TExpressionEvent, TParams, TEvent>;
 export interface MachineImplementationsSimplified<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor = ProvidedActor, TAction extends ParameterizedObject = ParameterizedObject, TGuard extends ParameterizedObject = ParameterizedObject> {
     guards: GuardMap<TContext, TEvent, TGuard>;
     actions: ActionFunctionMap<TContext, TEvent, TActor, TAction>;
@@ -386,7 +389,7 @@ export interface MachineImplementationsSimplified<TContext extends MachineContex
 }
 type MaybeNarrowedEvent<TIndexedEvents, TCausingLookup, K> = Cast<Prop<TIndexedEvents, K extends keyof TCausingLookup ? TCausingLookup[K] : TIndexedEvents[keyof TIndexedEvents]>, EventObject>;
 type MachineImplementationsActions<TContext extends MachineContext, TResolvedTypesMeta, TEventsCausingActions = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'eventsCausingActions'>, TIndexedEvents = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedEvents'>, TIndexedActors = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedActors'>, TIndexedActions = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedActions'>, TIndexedGuards = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedGuards'>, TIndexedDelays = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedDelays'>> = {
-    [K in keyof TIndexedActions]?: ActionFunction<TContext, MaybeNarrowedEvent<TIndexedEvents, TEventsCausingActions, K>, Cast<Prop<TIndexedEvents, keyof TIndexedEvents>, EventObject>, Cast<TIndexedActions[K], ParameterizedObject>, Cast<Prop<TIndexedActors, keyof TIndexedActors>, ProvidedActor>, Cast<Prop<TIndexedActions, keyof TIndexedActions>, ParameterizedObject>, Cast<Prop<TIndexedGuards, keyof TIndexedGuards>, ParameterizedObject>, Cast<Prop<TIndexedDelays, keyof TIndexedDelays>, ParameterizedObject>['type']>;
+    [K in keyof TIndexedActions]?: ActionFunction<TContext, MaybeNarrowedEvent<TIndexedEvents, TEventsCausingActions, K>, Cast<Prop<TIndexedEvents, keyof TIndexedEvents>, EventObject>, GetParameterizedParams<Cast<TIndexedActions[K], ParameterizedObject>>, Cast<Prop<TIndexedActors, keyof TIndexedActors>, ProvidedActor>, Cast<Prop<TIndexedActions, keyof TIndexedActions>, ParameterizedObject>, Cast<Prop<TIndexedGuards, keyof TIndexedGuards>, ParameterizedObject>, Cast<Prop<TIndexedDelays, keyof TIndexedDelays>, ParameterizedObject>['type']>;
 };
 type MachineImplementationsActors<TContext extends MachineContext, TResolvedTypesMeta, TEventsCausingActors = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'eventsCausingActors'>, TIndexedActors = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedActors'>, TIndexedEvents = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedEvents'>, _TInvokeSrcNameMap = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'invokeSrcNameMap'>> = {
     [K in keyof TIndexedActors]?: Cast<Prop<TIndexedActors[K], 'logic'>, AnyActorLogic> | {
@@ -395,10 +398,10 @@ type MachineImplementationsActors<TContext extends MachineContext, TResolvedType
     };
 };
 type MachineImplementationsDelays<TContext extends MachineContext, TResolvedTypesMeta, TEventsCausingDelays = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'eventsCausingDelays'>, TIndexedEvents = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedEvents'>, TIndexedActions = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedActions'>, TIndexedDelays = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedDelays'>> = {
-    [K in keyof TIndexedDelays]?: DelayConfig<TContext, MaybeNarrowedEvent<TIndexedEvents, TEventsCausingDelays, K>, Cast<Prop<TIndexedActions, keyof TIndexedActions>, ParameterizedObject> | undefined, Cast<Prop<TIndexedEvents, keyof TIndexedEvents>, EventObject>>;
+    [K in keyof TIndexedDelays]?: DelayConfig<TContext, MaybeNarrowedEvent<TIndexedEvents, TEventsCausingDelays, K>, Cast<Prop<Prop<TIndexedActions, keyof TIndexedActions>, 'params'>, ParameterizedObject['params'] | undefined> | undefined, Cast<Prop<TIndexedEvents, keyof TIndexedEvents>, EventObject>>;
 };
 type MachineImplementationsGuards<TContext extends MachineContext, TResolvedTypesMeta, TEventsCausingGuards = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'eventsCausingGuards'>, TIndexedEvents = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedEvents'>, TIndexedGuards = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedGuards'>> = {
-    [K in keyof TIndexedGuards]?: Guard<TContext, MaybeNarrowedEvent<TIndexedEvents, TEventsCausingGuards, K>, Cast<TIndexedGuards[K], ParameterizedObject>, Cast<Prop<TIndexedGuards, keyof TIndexedGuards>, ParameterizedObject>>;
+    [K in keyof TIndexedGuards]?: Guard<TContext, MaybeNarrowedEvent<TIndexedEvents, TEventsCausingGuards, K>, GetParameterizedParams<Cast<TIndexedGuards[K], ParameterizedObject | undefined>>, Cast<Prop<TIndexedGuards, keyof TIndexedGuards>, ParameterizedObject>>;
 };
 type MakeKeysRequired<T extends string> = {
     [K in T]: unknown;
@@ -481,29 +484,29 @@ export interface DoneStateEvent<TOutput = unknown> extends EventObject {
     type: `xstate.done.state.${string}`;
     output: TOutput;
 }
-export type DelayExpr<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TEvent extends EventObject> = (args: ActionArgs<TContext, TExpressionEvent, TExpressionAction, TEvent>) => number;
-export type LogExpr<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TEvent extends EventObject> = (args: ActionArgs<TContext, TExpressionEvent, TExpressionAction, TEvent>) => unknown;
-export type SendExpr<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TSentEvent extends EventObject, TEvent extends EventObject> = (args: ActionArgs<TContext, TExpressionEvent, TExpressionAction, TEvent>) => TSentEvent;
+export type DelayExpr<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject> = (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams) => number;
+export type LogExpr<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject> = (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams) => unknown;
+export type SendExpr<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TSentEvent extends EventObject, TEvent extends EventObject> = (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams) => TSentEvent;
 export declare enum SpecialTargets {
     Parent = "#_parent",
     Internal = "#_internal"
 }
-export interface SendToActionOptions<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TEvent extends EventObject, TDelay extends string> extends RaiseActionOptions<TContext, TExpressionEvent, TExpressionAction, TEvent, TDelay> {
+export interface SendToActionOptions<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TDelay extends string> extends RaiseActionOptions<TContext, TExpressionEvent, TParams, TEvent, TDelay> {
 }
-export interface RaiseActionOptions<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TEvent extends EventObject, TDelay extends string> {
+export interface RaiseActionOptions<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TDelay extends string> {
     id?: string;
-    delay?: Delay<TDelay> | DelayExpr<TContext, TExpressionEvent, TExpressionAction, TEvent>;
+    delay?: Delay<TDelay> | DelayExpr<TContext, TExpressionEvent, TParams, TEvent>;
 }
-export interface RaiseActionParams<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TEvent extends EventObject, TDelay extends string> extends RaiseActionOptions<TContext, TExpressionEvent, TExpressionAction, TEvent, TDelay> {
-    event: TEvent | SendExpr<TContext, TExpressionEvent, TExpressionAction, TEvent, TEvent>;
+export interface RaiseActionParams<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TDelay extends string> extends RaiseActionOptions<TContext, TExpressionEvent, TParams, TEvent, TDelay> {
+    event: TEvent | SendExpr<TContext, TExpressionEvent, TParams, TEvent, TEvent>;
 }
-export interface SendToActionParams<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TSentEvent extends EventObject, TEvent extends EventObject, TDelay extends string> extends SendToActionOptions<TContext, TExpressionEvent, TExpressionAction, TEvent, TDelay> {
-    event: TSentEvent | SendExpr<TContext, TExpressionEvent, TExpressionAction, TSentEvent, TEvent>;
+export interface SendToActionParams<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TSentEvent extends EventObject, TEvent extends EventObject, TDelay extends string> extends SendToActionOptions<TContext, TExpressionEvent, TParams, TEvent, TDelay> {
+    event: TSentEvent | SendExpr<TContext, TExpressionEvent, TParams, TSentEvent, TEvent>;
 }
-export type Assigner<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TEvent extends EventObject, TActor extends ProvidedActor> = (args: AssignArgs<TContext, TExpressionEvent, TExpressionAction, TEvent, TActor>) => Partial<TContext>;
-export type PartialAssigner<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TEvent extends EventObject, TActor extends ProvidedActor, TKey extends keyof TContext> = (args: AssignArgs<TContext, TExpressionEvent, TExpressionAction, TEvent, TActor>) => TContext[TKey];
-export type PropertyAssigner<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TEvent extends EventObject, TActor extends ProvidedActor> = {
-    [K in keyof TContext]?: PartialAssigner<TContext, TExpressionEvent, TExpressionAction, TEvent, TActor, K> | TContext[K];
+export type Assigner<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TActor extends ProvidedActor> = (args: AssignArgs<TContext, TExpressionEvent, TEvent, TActor>, params: TParams) => Partial<TContext>;
+export type PartialAssigner<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TActor extends ProvidedActor, TKey extends keyof TContext> = (args: AssignArgs<TContext, TExpressionEvent, TEvent, TActor>, params: TParams) => TContext[TKey];
+export type PropertyAssigner<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TActor extends ProvidedActor> = {
+    [K in keyof TContext]?: PartialAssigner<TContext, TExpressionEvent, TParams, TEvent, TActor, K> | TContext[K];
 };
 export type Mapper<TContext extends MachineContext, TExpressionEvent extends EventObject, TResult, TEvent extends EventObject> = (args: {
     context: TContext;
@@ -628,7 +631,7 @@ export interface ActorRef<TEvent extends EventObject, TSnapshot extends Snapshot
     send: (event: TEvent) => void;
     start?: () => void;
     getSnapshot: () => TSnapshot;
-    getPersistedState?: () => any;
+    getPersistedState: () => Snapshot<unknown>;
     stop: () => void;
     toJSON?: () => any;
     _parent?: ActorRef<any, any>;
@@ -638,12 +641,12 @@ 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> ? 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 TActor, infer _TAction, infer _TGuard, infer _TDelay, infer TTag, infer _TInput, infer TOutput, infer TResolvedTypesMeta> ? ActorRef<TEvent, MachineSnapshot<TContext, TEvent, TActor, 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 _TPersisted, infer _TSystem> ? ActorRef<TEvent, TSnapshot> : never : never;
+export type ActorRefFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer TContext, infer TEvent, infer TActor, infer _TAction, infer _TGuard, infer _TDelay, infer TTag, infer _TInput, infer TOutput, infer TResolvedTypesMeta> ? ActorRef<TEvent, MachineSnapshot<TContext, TEvent, TActor, 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 TActor, infer _TAction, infer _TGuard, infer _TDelay, infer TTag, infer TInput, infer TOutput, infer TResolvedTypesMeta> ? Actor<ActorLogic<MachineSnapshot<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>, TEvent, TInput, PersistedMachineState<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>, ActorSystem<any>>> : never;
+export type InterpreterFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine)> = ReturnTypeOrValue<T> extends StateMachine<infer TContext, infer TEvent, infer TActor, infer _TAction, infer _TGuard, infer _TDelay, infer TTag, infer TInput, infer TOutput, infer TResolvedTypesMeta> ? Actor<ActorLogic<MachineSnapshot<TContext, TEvent, TActor, 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 TActor, infer TAction, infer _TGuard, infer TDelay, infer _TTag, infer _TInput, infer _TOutput, infer TResolvedTypesMeta> ? InternalMachineImplementations<TContext, TEvent, TActor, TAction, TDelay, TResolvedTypesMeta, TRequireMissingImplementations> : never;
 export type __ResolvedTypesMetaFrom<T> = T extends StateMachine<any, // context
 any, // event
@@ -682,29 +685,23 @@ export type Snapshot<TOutput> = {
     output: undefined;
     error: undefined;
 };
-export interface ActorLogic<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TInput = unknown, 
-/**
- * Serialized internal state used for persistence & restoration
- */
-TPersisted = TSnapshot, TSystem extends ActorSystem<any> = ActorSystem<any>> {
+export interface ActorLogic<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TInput = unknown, TSystem extends ActorSystem<any> = ActorSystem<any>> {
     config?: unknown;
     transition: (state: TSnapshot, message: TEvent, ctx: ActorContext<TSnapshot, TEvent, TSystem>) => TSnapshot;
     getInitialState: (actorCtx: ActorContext<TSnapshot, TEvent, TSystem>, input: TInput) => TSnapshot;
-    restoreState?: (persistedState: TPersisted, actorCtx: ActorContext<TSnapshot, TEvent>) => TSnapshot;
+    restoreState?: (persistedState: Snapshot<unknown>, actorCtx: ActorContext<TSnapshot, TEvent>) => TSnapshot;
     start?: (state: TSnapshot, actorCtx: ActorContext<TSnapshot, TEvent>) => void;
     /**
      * @returns Persisted state
      */
-    getPersistedState?: (state: TSnapshot) => TPersisted;
+    getPersistedState: (state: TSnapshot) => Snapshot<unknown>;
 }
 export type AnyActorLogic = ActorLogic<any, // snapshot
 any, // event
 any, // input
-any, // persisted state
 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 _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TTag, infer _TInput, infer _TOutput, infer _TResolvedTypesMeta> ? StateFrom<R> : R extends ActorLogic<any, any, any, any, any> ? ReturnType<R['transition']> : R extends ActorContext<infer TSnapshot, infer _, infer __> ? TSnapshot : never : never;
-export type EventFromLogic<TLogic extends ActorLogic<any, any, any, any, any>> = TLogic extends ActorLogic<infer _, infer TEvent, infer __, infer _____, infer ______> ? TEvent : never;
-export type PersistedStateFrom<TLogic extends ActorLogic<any, any, any, any, any>> = TLogic extends ActorLogic<infer _TSnapshot, infer _TEvent, infer _TInput, infer TPersisted, infer _TSystem> ? TPersisted : 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 StateMachine<infer _TContext, infer _TEvent, 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 ActorContext<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 _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TTag, infer _TInput, infer _TOutput, infer _TResolvedTypesMeta> ? TEvent : R extends State<infer _TContext, infer TEvent, infer _TActor, 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 _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TTag, infer _TInput, infer _TOutput, infer _TTypesMeta> ? TContext : R extends State<infer TContext, infer _TEvent, infer _TActor, infer _TOutput, infer _TResolvedTypesMeta> ? TContext : R extends Actor<infer TActorLogic> ? TActorLogic extends StateMachine<infer TContext, infer _TEvent, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TTag, infer _TInput, infer _TOutput, infer _TTypesMeta> ? TContext : never : never : never;
@@ -726,12 +723,4 @@ export interface ActorSystem<T extends ActorSystemInfo> {
     inspect: (observer: Observer<InspectionEvent>) => void;
 }
 export type AnyActorSystem = ActorSystem<any>;
-export type PersistedMachineState<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TTag extends string, TOutput, TResolvedTypesMeta = TypegenDisabled> = HomomorphicPick<MachineSnapshot<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>, 'value' | 'output' | 'error' | 'context' | 'status' | 'historyValue'> & {
-    children: {
-        [K in keyof MachineSnapshot<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>['children']]: {
-            state: any;
-            src?: string;
-        };
-    };
-};
 export {};

package/dist/{interpreter-1c52b23c.development.esm.js → interpreter-4005eb36.development.esm.js}

@@ -751,7 +751,7 @@ class Actor {
     };
   }
   getPersistedState() {
-    return this.logic.getPersistedState?.(this._state);
+    return this.logic.getPersistedState(this._state);
   }
   [symbolObservable]() {
     return this;

package/dist/{interpreter-97aff8d2.cjs.js → interpreter-b6f22ee2.cjs.js}

@@ -742,7 +742,7 @@ class Actor {
     };
   }
   getPersistedState() {
-    return this.logic.getPersistedState?.(this._state);
+    return this.logic.getPersistedState(this._state);
   }
   [symbolObservable]() {
     return this;

package/dist/{interpreter-8def682e.esm.js → interpreter-c80ce92e.esm.js}

@@ -740,7 +740,7 @@ class Actor {
     };
   }
   getPersistedState() {
-    return this.logic.getPersistedState?.(this._state);
+    return this.logic.getPersistedState(this._state);
   }
   [symbolObservable]() {
     return this;

package/dist/{interpreter-e58ca48d.development.cjs.js → interpreter-ed3f81f7.development.cjs.js}

@@ -753,7 +753,7 @@ class Actor {
     };
   }
   getPersistedState() {
-    return this.logic.getPersistedState?.(this._state);
+    return this.logic.getPersistedState(this._state);
   }
   [symbolObservable]() {
     return this;