xstate 6.0.0-alpha.11 → 6.0.0-alpha.12

package/dist/{StateMachine-aef700df.cjs.js → StateMachine-7af634f9.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var dist_xstateActors = require('./index-559ceab3.cjs.js');
+var dist_xstateActors = require('./index-698a3320.cjs.js');
 
 function createSpawner(actorScope, {
   machine,
@@ -266,7 +266,7 @@ function formatChoiceTransitions(stateNode) {
     if (!result || result.target === undefined) {
       throw new Error(`Choice state "${stateNode.id}" must resolve to a target.`);
     }
-    for (const key of ['actions', 'to', 'context']) {
+    for (const key of ['actions', 'to']) {
       if (result[key] !== undefined) {
         throw new Error(`Choice state "${stateNode.id}" cannot declare \`${key}\` on a choice.`);
       }

package/dist/{StateMachine-0aa98f54.development.esm.js → StateMachine-8a9e6cb4.development.esm.js}

@@ -1,4 +1,4 @@
-import { P as ProcessingStatus, C as resolveReferencedActor, c as createActor, S as STATE_DELIMITER, D as mapValues, t as toArray, E as createInvokeId, F as getDelayedTransitions, G as evaluateCandidate, H as formatTransition, N as NULL_EVENT, I as toTransitionConfigArray, J as createInvokeTimeoutEvent, K as getCandidates, L as formatRouteTransitions, M as resolveStateValue, O as getAllStateNodes, f as getStateNodes, Q as createMachineSnapshot, R as isInFinalState, a as macrostep, U as transitionNode, m as matchesEventDescriptor, V as resolveActionsWithContext, b as createInitEvent, d as initialMicrostep, W as toStatePath, X as isStateId, Y as getStateNodeByPath, Z as getPersistedSnapshot, $ as $$ACTOR_TYPE } from './index-2f2fbd9b.development.esm.js';
+import { P as ProcessingStatus, C as resolveReferencedActor, c as createActor, S as STATE_DELIMITER, D as mapValues, t as toArray, E as createInvokeId, F as getDelayedTransitions, G as evaluateCandidate, H as formatTransition, N as NULL_EVENT, I as toTransitionConfigArray, J as createInvokeTimeoutEvent, K as getCandidates, L as formatRouteTransitions, M as resolveStateValue, O as getAllStateNodes, f as getStateNodes, Q as createMachineSnapshot, R as isInFinalState, a as macrostep, U as transitionNode, m as matchesEventDescriptor, V as resolveActionsWithContext, b as createInitEvent, d as initialMicrostep, W as toStatePath, X as isStateId, Y as getStateNodeByPath, Z as getPersistedSnapshot, $ as $$ACTOR_TYPE } from './index-be3d4c2d.development.esm.js';
 
 function createSpawner(actorScope, {
   machine,
@@ -264,7 +264,7 @@ function formatChoiceTransitions(stateNode) {
     if (!result || result.target === undefined) {
       throw new Error(`Choice state "${stateNode.id}" must resolve to a target.`);
     }
-    for (const key of ['actions', 'to', 'context']) {
+    for (const key of ['actions', 'to']) {
       if (result[key] !== undefined) {
         throw new Error(`Choice state "${stateNode.id}" cannot declare \`${key}\` on a choice.`);
       }

package/dist/{StateMachine-d4931336.esm.js → StateMachine-97ef0e5e.esm.js}

@@ -1,4 +1,4 @@
-import { P as ProcessingStatus, C as resolveReferencedActor, c as createActor, S as STATE_DELIMITER, D as mapValues, t as toArray, E as createInvokeId, F as getDelayedTransitions, G as evaluateCandidate, H as formatTransition, N as NULL_EVENT, I as toTransitionConfigArray, J as createInvokeTimeoutEvent, K as getCandidates, L as formatRouteTransitions, M as resolveStateValue, O as getAllStateNodes, f as getStateNodes, Q as createMachineSnapshot, R as isInFinalState, a as macrostep, U as transitionNode, m as matchesEventDescriptor, V as resolveActionsWithContext, b as createInitEvent, d as initialMicrostep, W as toStatePath, X as isStateId, Y as getStateNodeByPath, Z as getPersistedSnapshot, $ as $$ACTOR_TYPE } from './index-8828376f.esm.js';
+import { P as ProcessingStatus, C as resolveReferencedActor, c as createActor, S as STATE_DELIMITER, D as mapValues, t as toArray, E as createInvokeId, F as getDelayedTransitions, G as evaluateCandidate, H as formatTransition, N as NULL_EVENT, I as toTransitionConfigArray, J as createInvokeTimeoutEvent, K as getCandidates, L as formatRouteTransitions, M as resolveStateValue, O as getAllStateNodes, f as getStateNodes, Q as createMachineSnapshot, R as isInFinalState, a as macrostep, U as transitionNode, m as matchesEventDescriptor, V as resolveActionsWithContext, b as createInitEvent, d as initialMicrostep, W as toStatePath, X as isStateId, Y as getStateNodeByPath, Z as getPersistedSnapshot, $ as $$ACTOR_TYPE } from './index-45856a94.esm.js';
 
 function createSpawner(actorScope, {
   machine,
@@ -264,7 +264,7 @@ function formatChoiceTransitions(stateNode) {
     if (!result || result.target === undefined) {
       throw new Error(`Choice state "${stateNode.id}" must resolve to a target.`);
     }
-    for (const key of ['actions', 'to', 'context']) {
+    for (const key of ['actions', 'to']) {
       if (result[key] !== undefined) {
         throw new Error(`Choice state "${stateNode.id}" cannot declare \`${key}\` on a choice.`);
       }

package/dist/{StateMachine-da872dde.development.cjs.js → StateMachine-c7e1996c.development.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var dist_xstateActors = require('./index-219cb621.development.cjs.js');
+var dist_xstateActors = require('./index-3d018b1e.development.cjs.js');
 
 function createSpawner(actorScope, {
   machine,
@@ -266,7 +266,7 @@ function formatChoiceTransitions(stateNode) {
     if (!result || result.target === undefined) {
       throw new Error(`Choice state "${stateNode.id}" must resolve to a target.`);
     }
-    for (const key of ['actions', 'to', 'context']) {
+    for (const key of ['actions', 'to']) {
       if (result[key] !== undefined) {
         throw new Error(`Choice state "${stateNode.id}" cannot declare \`${key}\` on a choice.`);
       }

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

@@ -41,6 +41,7 @@ export interface LogicEnqueue<TEmitted extends EventObject> {
     step: <TStepOutput>(key: string, exec: () => TStepOutput | PromiseLike<TStepOutput>) => Promise<TStepOutput>;
 }
 export type LogicFunction<TOutput, TInput = NonReducibleUnknown, TEmitted extends EventObject = EventObject> = (args: LogicArgs<TOutput, TInput>, enq: LogicEnqueue<TEmitted>) => PromiseLike<TOutput>;
+type AsyncLogicFunctionOutput<TLogicFunction extends (...args: any[]) => PromiseLike<any>> = Awaited<ReturnType<TLogicFunction>>;
 export interface LogicConfig<TOutput, TInput = NonReducibleUnknown, TEmitted extends EventObject = EventObject, TInputSchema extends StandardSchemaV1 = StandardSchemaV1, TOutputSchema extends StandardSchemaV1 = StandardSchemaV1> {
     /**
      * Stable identifier for this async logic. This identifies the logic, not a
@@ -165,12 +166,13 @@ export declare function createAsyncLogic<const TInputSchema extends StandardSche
 }): AsyncActorLogic<StandardSchemaV1.InferOutput<TOutputSchema>, StandardSchemaV1.InferOutput<TInputSchema>, TEmitted> & {
     id?: string;
 };
-export declare function createAsyncLogic<TOutput, const TInputSchema extends StandardSchemaV1, TEmitted extends EventObject = EventObject>(asyncLogic: LogicConfig<TOutput, StandardSchemaV1.InferOutput<TInputSchema>, TEmitted, TInputSchema> & {
+export declare function createAsyncLogic<const TInputSchema extends StandardSchemaV1, TEmitted extends EventObject = EventObject, TLogicFunction extends LogicFunction<any, StandardSchemaV1.InferOutput<TInputSchema>, TEmitted> = LogicFunction<any, StandardSchemaV1.InferOutput<TInputSchema>, TEmitted>>(asyncLogic: Omit<LogicConfig<never, StandardSchemaV1.InferOutput<TInputSchema>, TEmitted, TInputSchema>, 'run' | 'schemas'> & {
     schemas: {
         input: TInputSchema;
         output?: never;
     };
-}): AsyncActorLogic<TOutput, StandardSchemaV1.InferOutput<TInputSchema>, TEmitted> & {
+    run: TLogicFunction;
+}): AsyncActorLogic<AsyncLogicFunctionOutput<TLogicFunction>, StandardSchemaV1.InferOutput<TInputSchema>, TEmitted> & {
     id?: string;
 };
 export declare function createAsyncLogic<const TOutputSchema extends StandardSchemaV1, TInput = NonReducibleUnknown, TEmitted extends EventObject = EventObject>(asyncLogic: LogicConfig<StandardSchemaV1.InferOutput<TOutputSchema>, TInput, TEmitted, StandardSchemaV1, TOutputSchema> & {

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

@@ -1,6 +1,6 @@
 import { symbolObservable } from "./symbolObservable.js";
 import { AnyActorSystem, Clock } from "./system.js";
-import type { AnyActor, AnyActorLogic, EmittedFrom, EventFromLogic, SendableEventFromLogic, InputFrom, Snapshot, SnapshotFrom, Readable } from "./types.js";
+import type { ActorTrigger, AnyActor, AnyActorLogic, EmittedFrom, EventFromLogic, SendableEventFromLogic, InputFrom, Snapshot, SnapshotFrom, Readable } from "./types.js";
 import { ActorOptions, ActorInstance, ActorRef, InteropSubscribable, Observer, Subscription } from "./types.js";
 export declare const $$ACTOR_TYPE = 1;
 export declare enum ProcessingStatus {
@@ -45,13 +45,7 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorInstanc
     sessionId: string;
     /** The system to which this actor belongs. */
     system: AnyActorSystem;
-    trigger: {
-        [K in SendableEventFromLogic<TLogic>['type']]: {} extends Omit<Extract<SendableEventFromLogic<TLogic>, {
-            type: K;
-        }>, 'type'> ? () => void : (payload: Omit<Extract<SendableEventFromLogic<TLogic>, {
-            type: K;
-        }>, 'type'>) => void;
-    };
+    trigger: ActorTrigger<SendableEventFromLogic<TLogic>>;
     src: string | AnyActorLogic;
     /**
      * Creates a new actor instance for the given logic with the provided options,

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

@@ -90,44 +90,64 @@ interface ScxmlIfJSON {
 }
 interface CustomActionJSON {
     type: string;
-    params?: Record<string, unknown>;
+    params?: unknown;
 }
-export type ActionJSON = CustomActionJSON | RaiseJSON | CancelJSON | LogJSON | EmitJSON | AssignJSON | ScxmlAssignJSON | ScxmlRaiseJSON | ScxmlScriptJSON | ScxmlIfJSON | ScxmlForeachJSON | ScxmlCancelJSON | ScxmlBlockJSON;
+export type ActionJSON = CustomActionJSON | RaiseJSON | CancelJSON | LogJSON | EmitJSON | AssignJSON | ScxmlAssignJSON | ScxmlRaiseJSON | ScxmlScriptJSON | ScxmlIfJSON | ScxmlForeachJSON | ScxmlCancelJSON | ScxmlBlockJSON | ExpressionJSON | CodeJSON;
 export interface GuardJSON {
     type: string;
-    params?: Record<string, unknown>;
+    params?: unknown;
+}
+interface ExpressionJSON {
+    '@expr': string;
+    '@lang'?: string;
+}
+interface CodeJSON {
+    '@code': string;
+    '@lang'?: string;
+}
+type ResolvableJSON = ExpressionJSON | CodeJSON;
+type ConditionJSON = GuardJSON | ResolvableJSON;
+interface ChoiceBranchJSON {
+    when?: ConditionJSON;
+    target: string | string[];
+    context?: MachineContext;
+    input?: unknown;
+    description?: string;
+    reenter?: boolean;
+    meta?: MetaObject;
 }
 export interface InvokeJSON {
     id?: string;
     registryKey?: string;
-    src: string | UnserializableMarker;
+    src: string;
     input?: unknown;
-    onDone?: TransitionJSON | TransitionJSON[];
-    onError?: TransitionJSON | TransitionJSON[];
-    onSnapshot?: TransitionJSON | TransitionJSON[];
-    timeout?: number | string;
-    onTimeout?: TransitionJSON | TransitionJSON[];
+    onDone?: TransitionConfigJSON | TransitionConfigJSON[];
+    onError?: TransitionConfigJSON | TransitionConfigJSON[];
+    onSnapshot?: TransitionConfigJSON | TransitionConfigJSON[];
+    timeout?: number | string | ResolvableJSON;
+    onTimeout?: TransitionConfigJSON | TransitionConfigJSON[];
 }
 export interface TransitionJSON {
     target?: string | string[];
     context?: MachineContext;
     actions?: ActionJSON[];
-    guard?: GuardJSON;
+    guard?: ConditionJSON;
     description?: string;
     reenter?: boolean;
     meta?: MetaObject;
     input?: unknown;
 }
+type TransitionConfigJSON = TransitionJSON | ResolvableJSON;
 export interface StateNodeJSON {
     id?: string;
     key?: string;
     type?: 'atomic' | 'compound' | 'parallel' | 'final' | 'history' | 'choice';
     initial?: string;
     states?: Record<string, StateNodeJSON>;
-    on?: Record<string, TransitionJSON | TransitionJSON[]>;
-    after?: Record<string, TransitionJSON | TransitionJSON[]>;
-    always?: TransitionJSON | TransitionJSON[];
-    choice?: TransitionJSON;
+    on?: Record<string, TransitionConfigJSON | TransitionConfigJSON[]>;
+    after?: Record<string, TransitionConfigJSON | TransitionConfigJSON[]>;
+    always?: TransitionConfigJSON | TransitionConfigJSON[];
+    choice?: ChoiceBranchJSON[] | ResolvableJSON;
     /**
      * JSON route config. Unlike the authoring API (a function), the JSON layer
      * allows an object form whose `guard` may be a named guard reference (string)
@@ -139,16 +159,16 @@ export interface StateNodeJSON {
         meta?: MetaObject;
         guard?: string;
         input?: Record<string, unknown>;
-    };
+    } | ResolvableJSON;
     invoke?: InvokeJSON | InvokeJSON[];
-    entry?: ActionJSON[];
-    exit?: ActionJSON[];
+    entry?: ActionJSON | ActionJSON[];
+    exit?: ActionJSON | ActionJSON[];
     meta?: MetaObject;
     description?: string;
     tags?: string[];
     input?: unknown;
-    timeout?: number | string;
-    onTimeout?: TransitionJSON | TransitionJSON[];
+    timeout?: number | string | ResolvableJSON;
+    onTimeout?: TransitionConfigJSON | TransitionConfigJSON[];
     history?: 'shallow' | 'deep';
     target?: string;
     output?: unknown;
@@ -156,22 +176,33 @@ export interface StateNodeJSON {
     _scxmlDonedata?: ScxmlDonedataJSON;
 }
 export interface MachineJSON extends StateNodeJSON {
+    '@exprLang'?: string;
     version?: string;
-    actions?: Record<string, unknown>;
-    guards?: Record<string, unknown>;
+    actions?: Record<string, ActionJSON | ActionJSON[]>;
+    guards?: Record<string, {
+        when: ConditionJSON;
+    }>;
     actorSources?: Record<string, unknown>;
-    delays?: Record<string, unknown>;
+    delays?: Record<string, number | string | {
+        duration: number | string | ResolvableJSON;
+    }>;
     schemas?: Record<string, unknown>;
 }
-interface UnserializableMarker {
-    $unserializable: 'function' | 'actor' | 'schema' | 'value';
-    id?: string;
+type EvaluatorSlot = 'context' | 'guard' | 'choice' | 'action' | 'actionParams' | 'transition' | 'input' | 'output' | 'delay' | 'transitionContext' | 'unknown';
+type EvaluatorKind = 'expr' | 'code';
+interface EvaluatorArgs {
+    source: string;
+    kind: EvaluatorKind;
+    slot: EvaluatorSlot;
+    scope: Record<string, unknown>;
+    path: string;
 }
 interface MachineImplementations {
     actions?: Record<string, (...args: any[]) => unknown>;
     guards?: Record<string, (...args: any[]) => boolean>;
     actorSources?: Record<string, AnyActorLogic>;
     delays?: Record<string, number | ((...args: any[]) => number)>;
+    evaluators?: Record<string, (args: EvaluatorArgs) => unknown>;
 }
 export declare function createMachineFromConfig(json: MachineJSON, implementations?: MachineImplementations): AnyStateMachine;
 export {};

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

@@ -4,7 +4,7 @@ export { Actor, createActor, type RequiredActorOptionsKeys as RequiredActorOptio
 export { createMachine, createStateConfig } from "./createMachine.js";
 export { createMachineFromConfig } from "./createMachineFromConfig.js";
 export type { ActionJSON, GuardJSON, InvokeJSON, MachineJSON, StateNodeJSON, TransitionJSON } from "./createMachineFromConfig.js";
-export { machineConfigToJSON, serializeMachine, type CodeExpression, type UnserializableMarker } from "./serialize.js";
+export { machineConfigToJSON, serializeMachine, type CodeExpression } from "./serialize.js";
 export { mapState } from "./mapState.js";
 export { types, isTypeSchema, type StandardSchemaV1, type TypeSchema } from "./schema.types.js";
 export { createSystem, setup } from "./setup.js";

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

@@ -4,34 +4,20 @@
  * `machineConfigToJSON` converts a machine config into a JSON-safe structure
  * (the `MachineJSON` shape accepted by `createMachineFromConfig`). The boundary
  * between serializable structure and runtime implementations is explicit:
- * functions are represented as code expressions, while actor logic, runtime
- * schemas, and other non-code runtime values are replaced with an `{
- * "$unserializable": <kind> }` marker rather than silently dropped.
- *
- * A machine definition is fully portable iff its JSON contains no
- * `$unserializable` markers; reviving a definition that has markers requires
- * re-providing those implementations (e.g. via `machine.provide(...)` or the
- * `actions`/`guards`/`actorSources` maps on `createMachineFromConfig`
- * revival).
+ * functions are represented as `@code` source objects, while actor logic,
+ * runtime schemas, and other non-data runtime values are omitted.
  */
 import type { AnyStateMachine } from "./types.js";
-export interface UnserializableMarker {
-    $unserializable: 'function' | 'actor' | 'schema' | 'value';
-    /** Best-effort identifier (function name, actor logic id) for diagnostics. */
-    id?: string;
-}
 export interface CodeExpression {
-    '@type': 'code';
-    lang: 'ts';
-    expr: string;
+    '@code': string;
+    '@lang': 'ts';
 }
 /**
  * Returns the JSON-serializable definition of a machine.
  *
- * Inline functions are represented as `{ "@type": "code", lang: "ts", expr }`.
- * Actor logic and runtime schemas appear as `{ "$unserializable": ... }`
- * markers. A machine created via `createMachineFromConfig` returns its original
- * JSON config (lossless round-trip):
+ * Inline functions are represented as `{ "@code": string, "@lang": "ts" }`. A
+ * machine created via `createMachineFromConfig` returns its original JSON
+ * config (lossless round-trip):
  *
  * ```ts
  * import { serializeMachine, createMachineFromConfig } from 'xstate';
@@ -45,6 +31,6 @@ export interface CodeExpression {
 export declare function serializeMachine(machine: AnyStateMachine): Record<string, unknown>;
 /**
  * Converts a machine config (as passed to `createMachine`) to its JSON-safe
- * definition. See module docs for the `$unserializable` marker contract.
+ * definition.
  */
 export declare function machineConfigToJSON(config: Record<string, unknown>): Record<string, unknown>;

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

@@ -4,7 +4,7 @@ import { type Actor, type RequiredActorOptionsKeys } from "./createActor.js";
 import { AnyActorRef, AnyActorLogic, ActorRefFromLogic, AnyStateNode, EventObject, AnyEventObject, EventDescriptor, ExtractEvent, MachineContext, ProvidedActor, RoutableStateId, StateSchema, StateValue, ToChildren, MetaObject, Cast, Compute, EnqueueObject, SystemRegistry, RegistryKeyForLogic, ActorOptions, Observer, Subscription, OutputArg } from "./types.js";
 import { AnyActorSystem } from "./system.js";
 import { InspectionEvent } from "./inspection.js";
-import { DelayMapFromNames, InferChildren, Implementations, InferOutput, InferEvents, Next_MachineConfig, Next_StateNodeConfig, WithDefault } from "./types.v6.js";
+import { ActionSchemas, DelayMapFromNames, GuardSchemas, InferChildren, InferActions, InferGuards, Implementations, InferOutput, InferEvents, Next_MachineConfig, Next_StateNodeConfig, WithDefault } from "./types.v6.js";
 export type SetupConfig<TSchemas extends SetupSchemas, TStates extends Record<string, SetupStateSchema>, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actorSources'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays']> = {
     schemas?: TSchemas & SetupSchemas;
     states?: TStates;
@@ -57,6 +57,8 @@ export type SetupStateSchemas = {
 export type SetupSchemas = {
     context?: StandardSchemaV1;
     events?: Record<string, StandardSchemaV1>;
+    actions?: ActionSchemas;
+    guards?: GuardSchemas;
     emitted?: Record<string, StandardSchemaV1>;
     input?: StandardSchemaV1;
     output?: StandardSchemaV1;
@@ -71,7 +73,9 @@ export interface SetupStateSchema {
 }
 type SetupSchema<TSchemas, TKey extends keyof SetupSchemas> = TKey extends keyof TSchemas ? TSchemas[TKey] extends StandardSchemaV1 ? TSchemas[TKey] : never : never;
 type SetupSchemaMap<TSchemas, TKey extends 'events' | 'emitted' | 'children'> = TKey extends keyof TSchemas ? TSchemas[TKey] extends Record<string, StandardSchemaV1> ? TSchemas[TKey] : never : never;
-type SetupOrConfigSchema<TSchemas, TKey extends Exclude<keyof SetupSchemas, 'events' | 'emitted'>, TConfigSchema extends StandardSchemaV1> = [SetupSchema<TSchemas, TKey>] extends [never] ? TConfigSchema : SetupSchema<TSchemas, TKey>;
+type SetupActionSchemaMap<TSchemas> = 'actions' extends keyof TSchemas ? TSchemas['actions'] extends ActionSchemas ? TSchemas['actions'] : never : never;
+type SetupGuardSchemaMap<TSchemas> = 'guards' extends keyof TSchemas ? TSchemas['guards'] extends GuardSchemas ? TSchemas['guards'] : never : never;
+type SetupOrConfigSchema<TSchemas, TKey extends Exclude<keyof SetupSchemas, 'events' | 'actions' | 'guards' | 'emitted' | 'children'>, TConfigSchema extends StandardSchemaV1> = [SetupSchema<TSchemas, TKey>] extends [never] ? TConfigSchema : SetupSchema<TSchemas, TKey>;
 type SetupOrConfigSchemaMap<TSchemas, TKey extends 'events' | 'emitted' | 'children', TConfigSchemaMap extends Record<string, StandardSchemaV1>> = [SetupSchemaMap<TSchemas, TKey>] extends [never] ? TConfigSchemaMap : SetupSchemaMap<TSchemas, TKey>;
 type SetupStateKeys<TStateSchemas extends Record<string, SetupStateSchema>> = keyof TStateSchemas & string;
 type SetupStateKey<TStateSchemas extends Record<string, SetupStateSchema>> = string extends SetupStateKeys<TStateSchemas> ? string : [SetupStateKeys<TStateSchemas>] extends [never] ? string : SetupStateKeys<TStateSchemas>;
@@ -115,6 +119,12 @@ type SetupMeta<TSchemas, TMetaSchema extends StandardSchemaV1> = [
     SetupSchema<TSchemas, 'meta'>
 ] extends [never] ? InferOutput<TMetaSchema, MetaObject> : InferOutput<SetupSchema<TSchemas, 'meta'>, MetaObject>;
 type SetupChildren<TSchemas, TChildrenSchemaMap extends Record<string, StandardSchemaV1>> = [SetupSchemaMap<TSchemas, 'children'>] extends [never] ? InferChildren<TChildrenSchemaMap> : InferChildren<SetupSchemaMap<TSchemas, 'children'>>;
+type SetupActions<TSchemas, TActionMap extends Implementations['actions']> = [
+    SetupActionSchemaMap<TSchemas>
+] extends [never] ? TActionMap : MergeImplementationMaps<InferActions<SetupActionSchemaMap<TSchemas>>, TActionMap>;
+type SetupGuards<TSchemas, TGuardMap extends Implementations['guards']> = [
+    SetupGuardSchemaMap<TSchemas>
+] extends [never] ? TGuardMap : MergeImplementationMaps<InferGuards<SetupGuardSchemaMap<TSchemas>>, TGuardMap>;
 type MergeChildren<TChildren extends Record<string, AnyActorRef | undefined>, TActor extends ProvidedActor> = [keyof TChildren] extends [never] ? Compute<ToChildren<TActor>> : Compute<TChildren>;
 type MergeImplementationMaps<TBase extends Record<string, unknown>, TExtension extends Record<string, unknown>> = Compute<TBase & TExtension>;
 type DelayNamesFromConfigOrString<TConfig> = TConfig extends {
@@ -212,22 +222,22 @@ type SetupMachineConfig<TStateSchemas extends Record<string, SetupStateSchema>,
     initial?: SetupStateKey<TStateSchemas> | InitialTransitionWithInput<TStateSchemas, TContext, TEvent> | undefined;
     on?: StateTransitions<TStateSchemas, TContext, SetupContextShape<TSchemas, TContextSchema, TContext>, TEvent, TEmitted, TChildren, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry>;
     always?: StateTransitionConfigOrTarget<TStateSchemas, TContext, SetupContextShape<TSchemas, TContextSchema, TContext>, TEvent, TEvent, TEmitted, TChildren, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry>;
-    states?: StatesWithInput<TStateSchemas, TStateSchemas, TContext, SetupContextShape<TSchemas, TContextSchema, TContext>, TEvent, TChildren, TDelays, TTag, TEmitted, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry>;
+    states?: StatesWithInput<TStateSchemas, TStateSchemas, TContext, SetupContextShape<TSchemas, TContextSchema, TContext>, TEvent, TChildren, TDelays, TTag, SetupOutput<TSchemas, TOutputSchema>, TEmitted, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry>;
 };
 /** States config type that provides typed input for known states */
-type StatesWithInput<TRootStateSchemas extends Record<string, SetupStateSchema>, TStateSchemas extends Record<string, SetupStateSchema>, TContext extends MachineContext, TContextShape, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TDelays extends string, TTag extends string, TEmitted extends EventObject, TMeta extends MetaObject, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actorSources'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays'], TSystemRegistry extends SystemRegistry> = {
-    [K in keyof TStateSchemas & string]?: StateNodeConfigWithNestedInput<TRootStateSchemas, TStateSchemas[K], TContext, TContextShape, TEvent, TChildren, TDelays, TTag, TEmitted, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry>;
+type StatesWithInput<TRootStateSchemas extends Record<string, SetupStateSchema>, TStateSchemas extends Record<string, SetupStateSchema>, TContext extends MachineContext, TContextShape, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TDelays extends string, TTag extends string, TOutput, TEmitted extends EventObject, TMeta extends MetaObject, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actorSources'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays'], TSystemRegistry extends SystemRegistry> = {
+    [K in keyof TStateSchemas & string]?: StateNodeConfigWithNestedInput<TRootStateSchemas, TStateSchemas[K], TContext, TContextShape, TEvent, TChildren, TDelays, TTag, TOutput, TEmitted, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry>;
 };
 /** State node config that recursively applies typed input for nested states */
-type StateNodeConfigWithNestedInput<TSiblingStateSchemas extends Record<string, SetupStateSchema>, TStateSchema extends SetupStateSchema, TContext extends MachineContext, TContextShape, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TDelays extends string, TTag extends string, TEmitted extends EventObject, TMeta extends MetaObject, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actorSources'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays'], TSystemRegistry extends SystemRegistry> = WithNestedStates<Omit<Next_StateNodeConfig<StateContext<TStateSchema, TContext>, TEvent, TDelays, TTag, any, TEmitted, TMeta, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, StateInput<TStateSchema>, Record<string, unknown>, TSystemRegistry>, 'on' | 'always' | 'initial'> & {
+type StateNodeConfigWithNestedInput<TSiblingStateSchemas extends Record<string, SetupStateSchema>, TStateSchema extends SetupStateSchema, TContext extends MachineContext, TContextShape, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TDelays extends string, TTag extends string, TOutput, TEmitted extends EventObject, TMeta extends MetaObject, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actorSources'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays'], TSystemRegistry extends SystemRegistry> = WithNestedStates<Omit<Next_StateNodeConfig<StateContext<TStateSchema, TContext>, TEvent, TDelays, TTag, TOutput, TEmitted, TMeta, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, StateInput<TStateSchema>, Record<string, unknown>, TSystemRegistry>, 'on' | 'always' | 'initial'> & {
     initial?: TStateSchema['states'] extends Record<string, SetupStateSchema> ? SetupStateKey<TStateSchema['states']> | InitialTransitionWithInput<TStateSchema['states'], StateContext<TStateSchema, TContext>, TEvent> : string | {
         target: string;
         input?: Record<string, unknown>;
     } | undefined;
     on?: StateTransitions<TSiblingStateSchemas, StateContext<TStateSchema, TContext>, StateContextShape<TStateSchema, TContextShape>, TEvent, TEmitted, TChildren, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry>;
     always?: StateTransitionConfigOrTarget<TSiblingStateSchemas, StateContext<TStateSchema, TContext>, StateContextShape<TStateSchema, TContextShape>, TEvent, TEvent, TEmitted, TChildren, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry>;
-}, TStateSchema['states'] extends Record<string, SetupStateSchema> ? StatesWithInput<TStateSchema['states'], TStateSchema['states'], TContext, StateContextShape<TStateSchema, TContextShape>, TEvent, TChildren, TDelays, TTag, TEmitted, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry> : {
-    [K in string]?: Next_StateNodeConfig<TContext, TEvent, TDelays, TTag, any, TEmitted, TMeta, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, undefined, Record<string, unknown>, TSystemRegistry>;
+}, TStateSchema['states'] extends Record<string, SetupStateSchema> ? StatesWithInput<TStateSchema['states'], TStateSchema['states'], TContext, StateContextShape<TStateSchema, TContextShape>, TEvent, TChildren, TDelays, TTag, TOutput, TEmitted, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry> : {
+    [K in string]?: Next_StateNodeConfig<TContext, TEvent, TDelays, TTag, TOutput, TEmitted, TMeta, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, undefined, Record<string, unknown>, TSystemRegistry>;
 }>;
 type StateTransitions<TStateSchemas extends Record<string, SetupStateSchema>, TContext extends MachineContext, TContextShape, TEvent extends EventObject, TEmitted extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TMeta extends MetaObject, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actorSources'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays'], TSystemRegistry extends SystemRegistry> = {
     [K in EventDescriptor<TEvent>]?: StateTransitionConfigOrTarget<TStateSchemas, TContext, TContextShape, ExtractEvent<TEvent, K>, TEvent, TEmitted, TChildren, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry>;
@@ -305,11 +315,13 @@ export interface SetupReturn<TStates extends Record<string, SetupStateSchema> =
     /** Extends the setup configuration */
     extend<const TExtendSchemas extends SetupSchemas = {}, const TExtendStates extends Record<string, SetupStateSchema> = {}, TExtendActionMap extends Implementations['actions'] = {}, TExtendActorMap extends Implementations['actorSources'] = {}, TExtendGuardMap extends Implementations['guards'] = {}, TExtendDelayMap extends Implementations['delays'] = {}>(config: SetupConfig<TExtendSchemas, TExtendStates, TExtendActionMap, TExtendActorMap, TExtendGuardMap, TExtendDelayMap>): SetupReturn<MergeImplementationMaps<TStates, TExtendStates>, MergeImplementationMaps<TSchemas, TExtendSchemas>, MergeImplementationMaps<TSetupActionMap, TExtendActionMap>, MergeImplementationMaps<TSetupActorMap, TExtendActorMap>, MergeImplementationMaps<TSetupGuardMap, TExtendGuardMap>, MergeImplementationMaps<TSetupDelayMap, TExtendDelayMap>, TSetupDelays | Extract<keyof TExtendDelayMap, string>, TSystemRegistry>;
     /** Creates a state machine with the setup configuration */
-    createMachine<TContextSchema extends StandardSchemaV1 = StandardSchemaV1, const TEventSchemaMap extends Record<string, StandardSchemaV1> = Record<string, StandardSchemaV1>, TEmittedSchemaMap extends Record<string, StandardSchemaV1> = Record<string, StandardSchemaV1>, TInputSchema extends StandardSchemaV1 = StandardSchemaV1, TOutputSchema extends StandardSchemaV1 = StandardSchemaV1, TMetaSchema extends StandardSchemaV1 = StandardSchemaV1, TTagSchema extends StandardSchemaV1 = StandardSchemaV1, const TChildrenSchemaMap extends Record<string, StandardSchemaV1> = Record<string, StandardSchemaV1>, _TEvent extends EventObject = EventObject, TActor extends ProvidedActor = ProvidedActor, TActionMap extends Implementations['actions'] = {}, TActorMap extends Implementations['actorSources'] = {}, TGuardMap extends Implementations['guards'] = {}, TDelayMap extends Implementations['delays'] = {}, TDelays extends string = Extract<keyof TDelayMap, string>, TTag extends SetupTags<TSchemas, TTagSchema> = SetupTags<TSchemas, TTagSchema>, TInput = unknown, TConfig extends SetupMachineConfig<TStates, TSchemas, TContextSchema, TEventSchemaMap, TEmittedSchemaMap, TInputSchema, TOutputSchema, TMetaSchema, TTagSchema, TChildrenSchemaMap, SetupContext<TSchemas, TContextSchema>, SetupEvents<TSchemas, TEventSchemaMap>, Cast<MergeChildren<SetupChildren<TSchemas, TChildrenSchemaMap>, TActor>, Record<string, AnyActorRef | undefined>>, TSetupDelays | TDelays, TTag, SetupEmitted<TSchemas, TEmittedSchemaMap>, SetupMeta<TSchemas, TMetaSchema>, MergeImplementationMaps<TSetupActionMap, TActionMap>, MergeImplementationMaps<TSetupActorMap, TActorMap>, MergeImplementationMaps<TSetupGuardMap, TGuardMap>, MergeImplementationMaps<TSetupDelayMap, TDelayMap>, TSystemRegistry, SetupContextRequired<TSchemas, TContextSchema>, TDelays, TActionMap, TActorMap, TGuardMap> = SetupMachineConfig<TStates, TSchemas, TContextSchema, TEventSchemaMap, TEmittedSchemaMap, TInputSchema, TOutputSchema, TMetaSchema, TTagSchema, TChildrenSchemaMap, SetupContext<TSchemas, TContextSchema>, SetupEvents<TSchemas, TEventSchemaMap>, Cast<MergeChildren<SetupChildren<TSchemas, TChildrenSchemaMap>, TActor>, Record<string, AnyActorRef | undefined>>, TSetupDelays | TDelays, TTag, SetupEmitted<TSchemas, TEmittedSchemaMap>, SetupMeta<TSchemas, TMetaSchema>, MergeImplementationMaps<TSetupActionMap, TActionMap>, MergeImplementationMaps<TSetupActorMap, TActorMap>, MergeImplementationMaps<TSetupGuardMap, TGuardMap>, MergeImplementationMaps<TSetupDelayMap, TDelayMap>, TSystemRegistry, SetupContextRequired<TSchemas, TContextSchema>, TDelays, TActionMap, TActorMap, TGuardMap>>(config: {
+    createMachine<TContextSchema extends StandardSchemaV1 = StandardSchemaV1, const TEventSchemaMap extends Record<string, StandardSchemaV1> = Record<string, StandardSchemaV1>, TEmittedSchemaMap extends Record<string, StandardSchemaV1> = Record<string, StandardSchemaV1>, TInputSchema extends StandardSchemaV1 = StandardSchemaV1, TOutputSchema extends StandardSchemaV1 = StandardSchemaV1, TMetaSchema extends StandardSchemaV1 = StandardSchemaV1, TTagSchema extends StandardSchemaV1 = StandardSchemaV1, const TChildrenSchemaMap extends Record<string, StandardSchemaV1> = Record<string, StandardSchemaV1>, const TActionSchemaMap extends ActionSchemas = {}, const TGuardSchemaMap extends GuardSchemas = {}, _TEvent extends EventObject = EventObject, TActor extends ProvidedActor = ProvidedActor, TActionMap extends Implementations['actions'] = {}, TActorMap extends Implementations['actorSources'] = {}, TGuardMap extends Implementations['guards'] = {}, TDelayMap extends Implementations['delays'] = {}, TDelays extends string = Extract<keyof TDelayMap, string>, TTag extends SetupTags<TSchemas, TTagSchema> = SetupTags<TSchemas, TTagSchema>, TInput = unknown, TConfig extends SetupMachineConfig<TStates, TSchemas, TContextSchema, TEventSchemaMap, TEmittedSchemaMap, TInputSchema, TOutputSchema, TMetaSchema, TTagSchema, TChildrenSchemaMap, SetupContext<TSchemas, TContextSchema>, SetupEvents<TSchemas, TEventSchemaMap>, Cast<MergeChildren<SetupChildren<TSchemas, TChildrenSchemaMap>, TActor>, Record<string, AnyActorRef | undefined>>, TSetupDelays | TDelays, TTag, SetupEmitted<TSchemas, TEmittedSchemaMap>, SetupMeta<TSchemas, TMetaSchema>, MergeImplementationMaps<SetupActions<TSchemas, TSetupActionMap>, MergeImplementationMaps<InferActions<TActionSchemaMap>, TActionMap>>, MergeImplementationMaps<TSetupActorMap, TActorMap>, MergeImplementationMaps<SetupGuards<TSchemas, TSetupGuardMap>, MergeImplementationMaps<InferGuards<TGuardSchemaMap>, TGuardMap>>, MergeImplementationMaps<TSetupDelayMap, TDelayMap>, TSystemRegistry, SetupContextRequired<TSchemas, TContextSchema>, TDelays, TActionMap, TActorMap, TGuardMap> = SetupMachineConfig<TStates, TSchemas, TContextSchema, TEventSchemaMap, TEmittedSchemaMap, TInputSchema, TOutputSchema, TMetaSchema, TTagSchema, TChildrenSchemaMap, SetupContext<TSchemas, TContextSchema>, SetupEvents<TSchemas, TEventSchemaMap>, Cast<MergeChildren<SetupChildren<TSchemas, TChildrenSchemaMap>, TActor>, Record<string, AnyActorRef | undefined>>, TSetupDelays | TDelays, TTag, SetupEmitted<TSchemas, TEmittedSchemaMap>, SetupMeta<TSchemas, TMetaSchema>, MergeImplementationMaps<SetupActions<TSchemas, TSetupActionMap>, MergeImplementationMaps<InferActions<TActionSchemaMap>, TActionMap>>, MergeImplementationMaps<TSetupActorMap, TActorMap>, MergeImplementationMaps<SetupGuards<TSchemas, TSetupGuardMap>, MergeImplementationMaps<InferGuards<TGuardSchemaMap>, TGuardMap>>, MergeImplementationMaps<TSetupDelayMap, TDelayMap>, TSystemRegistry, SetupContextRequired<TSchemas, TContextSchema>, TDelays, TActionMap, TActorMap, TGuardMap>>(config: {
         schemas?: {
             events?: TEventSchemaMap;
             context?: TContextSchema;
             emitted?: TEmittedSchemaMap;
+            actions?: TActionSchemaMap;
+            guards?: TGuardSchemaMap;
             input?: TInputSchema;
             output?: TOutputSchema;
             meta?: TMetaSchema;
@@ -325,9 +337,9 @@ export interface SetupReturn<TStates extends Record<string, SetupStateSchema> =
         to: RoutableStateId<Cast<TConfig, StateSchema>>;
     }), Cast<MergeChildren<SetupChildren<TSchemas, TChildrenSchemaMap>, TActor>, Record<string, AnyActorRef | undefined>>, StateValue, TTag & string, [
         SetupSchema<TSchemas, 'input'>
-    ] extends [never] ? TInput : SetupInput<TSchemas, TInputSchema>, SetupOutput<TSchemas, TOutputSchema>, SetupEmitted<TSchemas, TEmittedSchemaMap>, SetupMeta<TSchemas, TMetaSchema>, MergeStateSchema<Cast<TConfig, StateSchema>, SetupStatesToStateSchema<TStates>>, MergeImplementationMaps<TSetupActionMap, TActionMap>, MergeImplementationMaps<TSetupActorMap, TActorMap>, MergeImplementationMaps<TSetupGuardMap, TGuardMap>, DelayMapFromNames<TSetupDelays | TDelays, MergeImplementationMaps<TSetupDelayMap, TDelayMap>>>;
+    ] extends [never] ? TInput : SetupInput<TSchemas, TInputSchema>, SetupOutput<TSchemas, TOutputSchema>, SetupEmitted<TSchemas, TEmittedSchemaMap>, SetupMeta<TSchemas, TMetaSchema>, MergeStateSchema<Cast<TConfig, StateSchema>, SetupStatesToStateSchema<TStates>>, MergeImplementationMaps<SetupActions<TSchemas, TSetupActionMap>, MergeImplementationMaps<InferActions<TActionSchemaMap>, TActionMap>>, MergeImplementationMaps<TSetupActorMap, TActorMap>, MergeImplementationMaps<SetupGuards<TSchemas, TSetupGuardMap>, MergeImplementationMaps<InferGuards<TGuardSchemaMap>, TGuardMap>>, DelayMapFromNames<TSetupDelays | TDelays, MergeImplementationMaps<TSetupDelayMap, TDelayMap>>>;
     /** Creates a state node config with the setup configuration */
-    createStateConfig<const TConfig extends StateNodeConfigWithNestedInput<TStates, SetupStateSchema, SetupContext<TSchemas, StandardSchemaV1>, SetupContextShape<TSchemas, StandardSchemaV1, SetupContext<TSchemas, StandardSchemaV1>>, SetupEvents<TSchemas, Record<string, StandardSchemaV1>>, Cast<SetupChildren<TSchemas, Record<string, StandardSchemaV1>>, Record<string, AnyActorRef | undefined>>, string, SetupTags<TSchemas, StandardSchemaV1>, SetupEmitted<TSchemas, Record<string, StandardSchemaV1>>, SetupMeta<TSchemas, StandardSchemaV1>, TSetupActionMap, TSetupActorMap, TSetupGuardMap, TSetupDelayMap, TSystemRegistry>>(config: TConfig): TConfig;
+    createStateConfig<const TConfig extends StateNodeConfigWithNestedInput<TStates, SetupStateSchema, SetupContext<TSchemas, StandardSchemaV1>, SetupContextShape<TSchemas, StandardSchemaV1, SetupContext<TSchemas, StandardSchemaV1>>, SetupEvents<TSchemas, Record<string, StandardSchemaV1>>, Cast<SetupChildren<TSchemas, Record<string, StandardSchemaV1>>, Record<string, AnyActorRef | undefined>>, string, SetupTags<TSchemas, StandardSchemaV1>, SetupOutput<TSchemas, StandardSchemaV1>, SetupEmitted<TSchemas, Record<string, StandardSchemaV1>>, SetupMeta<TSchemas, StandardSchemaV1>, SetupActions<TSchemas, TSetupActionMap>, TSetupActorMap, SetupGuards<TSchemas, TSetupGuardMap>, TSetupDelayMap, TSystemRegistry>>(config: TConfig): TConfig;
     /** State input schemas from setup config */
     states: TStates;
 }
@@ -339,13 +351,13 @@ type SetupConfigStates<TConfig> = TConfig extends {
 } ? TStates extends Record<string, SetupStateSchema> ? TStates : Record<string, SetupStateSchema> : Record<string, SetupStateSchema>;
 type SetupConfigActions<TConfig> = TConfig extends {
     actions?: infer TActions;
-} ? TActions extends Implementations['actions'] ? TActions : {} : {};
+} ? TActions extends Implementations['actions'] ? MergeImplementationMaps<SetupActions<SetupConfigSchemas<TConfig>, {}>, TActions> : SetupActions<SetupConfigSchemas<TConfig>, {}> : SetupActions<SetupConfigSchemas<TConfig>, {}>;
 type SetupConfigActorSources<TConfig> = TConfig extends {
     actorSources?: infer TActorSources;
 } ? TActorSources extends Implementations['actorSources'] ? TActorSources : {} : {};
 type SetupConfigGuards<TConfig> = TConfig extends {
     guards?: infer TGuards;
-} ? TGuards extends Implementations['guards'] ? TGuards : {} : {};
+} ? TGuards extends Implementations['guards'] ? MergeImplementationMaps<SetupGuards<SetupConfigSchemas<TConfig>, {}>, TGuards> : SetupGuards<SetupConfigSchemas<TConfig>, {}> : SetupGuards<SetupConfigSchemas<TConfig>, {}>;
 type SetupConfigDelays<TConfig> = TConfig extends {
     delays?: infer TDelays;
 } ? TDelays extends Implementations['delays'] ? TDelays : {} : {};

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

@@ -40,7 +40,9 @@ export declare function getTransitionResult(transition: Pick<AnyTransitionDefini
     reenter?: AnyTransitionDefinition['reenter'];
     input?: AnyTransitionDefinition['input'];
     context?: AnyTransitionDefinition['context'];
-}, snapshot: AnyMachineSnapshot, event: AnyEventObject, actorScope: AnyActorScope): {
+}, snapshot: AnyMachineSnapshot, event: AnyEventObject, actorScope: AnyActorScope, options?: {
+    resolveActions?: boolean;
+}): {
     targets: Readonly<AnyStateNode[]> | undefined;
     context: MachineContext | undefined;
     actions: AnyAction[] | undefined;

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

@@ -1,4 +1,4 @@
 import type { AnyAction, AnyActorScope, AnyEventObject, AnyMachineSnapshot, EnqueueObject, EventObject, ExecutableActionObject, SpecialExecutableAction } from "./types.js";
-export declare function createTransitionEnqueue(actorScope: AnyActorScope, actions: any[], internalEvents: EventObject[], actorSubscriptions?: boolean): EnqueueObject<any, any>;
+export declare function createTransitionEnqueue(actorScope: AnyActorScope, actions: any[], internalEvents: EventObject[], actorSubscriptions?: boolean, createActors?: boolean): EnqueueObject<any, any>;
 export declare function isBuiltInExecutableAction(action: ExecutableActionObject): action is SpecialExecutableAction;
 export declare function resolveActionsWithContext(currentSnapshot: AnyMachineSnapshot, event: AnyEventObject, actorScope: AnyActorScope, actions: AnyAction[]): [AnyMachineSnapshot, ExecutableActionObject[]];

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

@@ -679,6 +679,10 @@ export interface ActorRef<TSnapshot extends Snapshot<unknown>, TEvent extends Ev
         type: TType;
     })) => void) => Subscription;
 }
+type EventPayload<TEvent extends EventObject, TType extends TEvent['type']> = HomomorphicOmit<ExtractEvent<TEvent, TType>, 'type'>;
+export type ActorTrigger<TEvent extends EventObject> = {
+    [K in TEvent['type']]: {} extends EventPayload<TEvent, K> ? () => void : (payload: EventPayload<TEvent, K>) => void;
+};
 /**
  * Runtime-only actor capabilities.
  *
@@ -687,7 +691,7 @@ export interface ActorRef<TSnapshot extends Snapshot<unknown>, TEvent extends Ev
  * genuinely need lifecycle control such as starting, stopping, or accessing
  * system-owned runtime state.
  */
-export interface ActorRuntime<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, _TEmitted extends EventObject = EventObject> {
+export interface ActorRuntime<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, _TEmitted extends EventObject = EventObject, TSendEvent extends EventObject = TEvent> {
     /** The unique identifier for this actor relative to its parent. */
     id: string;
     /**
@@ -704,7 +708,7 @@ export interface ActorRuntime<TSnapshot extends Snapshot<unknown>, TEvent extend
     _parent?: any;
     system: any;
     src: string | AnyActorLogic;
-    trigger: any;
+    trigger: ActorTrigger<TSendEvent>;
     select<TSelected>(selector: (snapshot: TSnapshot) => TSelected, equalityFn?: (a: TSelected, b: TSelected) => boolean): Readable<TSelected>;
 }
 /**
@@ -714,7 +718,7 @@ export interface ActorRuntime<TSnapshot extends Snapshot<unknown>, TEvent extend
  * lifecycle capabilities. Values returned by `createActor(...)` and
  * `spawn(...)` naturally satisfy narrower `ActorRef` contracts.
  */
-export interface ActorInstance<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TEmitted extends EventObject = EventObject, TSendEvent extends EventObject = TEvent> extends ActorRuntime<TSnapshot, TEvent, TEmitted>, ActorRef<TSnapshot, TEvent, TEmitted, TSendEvent> {
+export interface ActorInstance<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TEmitted extends EventObject = EventObject, TSendEvent extends EventObject = TEvent> extends ActorRuntime<TSnapshot, TEvent, TEmitted, TSendEvent>, ActorRef<TSnapshot, TEvent, TEmitted, TSendEvent> {
 }
 /**
  * The actor's own full self handle.
@@ -723,7 +727,7 @@ export interface ActorInstance<TSnapshot extends Snapshot<unknown>, TEvent exten
  * can participate in runtime-owned behavior while still being usable wherever
  * an `ActorRef` is expected.
  */
-export type ActorSelf<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TEmitted extends EventObject = EventObject, TSendEvent extends EventObject = TEvent> = ActorRuntime<TSnapshot, TEvent, TEmitted> & ActorRef<TSnapshot, TEvent, TEmitted, TSendEvent>;
+export type ActorSelf<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TEmitted extends EventObject = EventObject, TSendEvent extends EventObject = TEvent> = ActorRuntime<TSnapshot, TEvent, TEmitted, TSendEvent> & ActorRef<TSnapshot, TEvent, TEmitted, TSendEvent>;
 export type ActorRefFrom<T> = T extends StateMachine<infer TContext, infer TEvent, infer TChildren, infer TStateValue, infer TTag, infer _TInput, infer TOutput, infer TEmitted, infer TMeta, infer TConfig, infer _TActionMap, infer _TActorMap, infer _TGuardMap, infer _TDelayMap> ? TConfig extends {
     internalEvents?: readonly EventDescriptor<TEvent>[];
 } ? ActorRef<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, any>, TEvent, TEmitted, ExcludeInternalEvents<TEvent, TConfig['internalEvents'] extends readonly EventDescriptor<TEvent>[] ? TConfig['internalEvents'] extends readonly (infer TDesc)[] ? Extract<TDesc, string> : never : never>> : ActorRef<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, any>, TEvent, TEmitted> : T extends Promise<infer U> ? ActorRefFrom<AsyncActorLogic<U>> : T extends ActorLogic<infer TSnapshot, infer TEvent, infer _TInput, infer _TSystem, infer TEmitted> ? ActorRef<TSnapshot, TEvent, TEmitted> : never;

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

@@ -11,7 +11,9 @@ export type InferOutput<T extends StandardSchemaV1, U> = Compute<StandardSchemaV
  * are required on the event.
  */
 export type InferEvents<TEventSchemaMap extends Record<string, StandardSchemaV1>> = Values<{
-    [K in keyof TEventSchemaMap & string]: StandardSchemaV1.InferOutput<TEventSchemaMap[K]> extends infer O ? unknown extends O ? O & {
+    [K in keyof TEventSchemaMap & string]: StandardSchemaV1.InferOutput<TEventSchemaMap[K]> extends infer O ? [O] extends [never] ? never : unknown extends O ? O & {
+        type: K;
+    } : [O] extends [void] ? {
         type: K;
     } : string extends keyof O ? [O[string]] extends [never] ? {
         type: K;
@@ -24,6 +26,21 @@ export type InferEvents<TEventSchemaMap extends Record<string, StandardSchemaV1>
 export type InferChildren<TChildrenSchemaMap extends Record<string, StandardSchemaV1>> = string extends keyof TChildrenSchemaMap ? {} : {
     [K in keyof TChildrenSchemaMap & string]?: StandardSchemaV1.InferOutput<TChildrenSchemaMap[K]> extends AnyActorRef ? NormalizeActorRef<StandardSchemaV1.InferOutput<TChildrenSchemaMap[K]>> : never;
 };
+export type ActionSchemas = Record<string, {
+    params: StandardSchemaV1;
+}>;
+export type GuardSchemas = Record<string, {
+    params: StandardSchemaV1;
+}>;
+export type InferActions<TActionSchemaMap extends ActionSchemas> = string extends keyof TActionSchemaMap ? {} : {
+    [K in keyof TActionSchemaMap & string]: (params: StandardSchemaV1.InferOutput<TActionSchemaMap[K]['params']>) => void | {
+        context?: any;
+        children?: any;
+    };
+};
+export type InferGuards<TGuardSchemaMap extends GuardSchemas> = string extends keyof TGuardSchemaMap ? {} : {
+    [K in keyof TGuardSchemaMap & string]: (params: StandardSchemaV1.InferOutput<TGuardSchemaMap[K]['params']>) => boolean;
+};
 type OutputConfig<TContext extends MachineContext, TEvent extends EventObject, TOutput> = unknown extends TOutput ? Mapper<TContext, TEvent, NonReducibleUnknown, TEvent> | NonReducibleUnknown : Mapper<TContext, TEvent, TOutput, TEvent> | TOutput;
 export type ValidateTopLevelFinalOutputs<TConfig, TContext extends MachineContext, TEvent extends EventObject> = TConfig extends {
     schemas: {
@@ -71,6 +88,8 @@ export interface MachineOptions {
 }
 type MachineSchemas<TContextSchema extends StandardSchemaV1, TEventSchemaMap extends Record<string, StandardSchemaV1>, TEmittedSchemaMap extends Record<string, StandardSchemaV1>, TInputSchema extends StandardSchemaV1, TOutputSchema extends StandardSchemaV1, TMetaSchema extends StandardSchemaV1, TTagSchema extends StandardSchemaV1, TChildrenSchemaMap extends Record<string, StandardSchemaV1>> = {
     events?: TEventSchemaMap;
+    actions?: ActionSchemas;
+    guards?: GuardSchemas;
     context?: TContextSchema;
     emitted?: TEmittedSchemaMap;
     input?: TInputSchema;