xstate 6.0.0-alpha.37 → 6.0.0-alpha.39

package/dist/{StateMachine-7197482a.development.cjs.js → StateMachine-144215d2.development.cjs.js}

@@ -1,7 +1,7 @@
 'use strict';
 
-var createActor = require('./createActor-8462b9cc.development.cjs.js');
-var dist_xstateActors = require('./index-14478488.development.cjs.js');
+var createActor = require('./createActor-c0f78b8a.development.cjs.js');
+var dist_xstateActors = require('./index-3d1368f7.development.cjs.js');
 
 function createSpawner(actorScope, actors, spawnedChildren) {
   return (src, options) => {
@@ -975,6 +975,26 @@ class StateMachine {
       return revived;
     };
     const revivedHistoryValue = reviveHistoryValue(snapshotData.historyValue);
+    const validateStateValue = (stateValue, node, path) => {
+      const missingStateError = statePath => new Error(`Persisted snapshot references state '${statePath.join('.')}' which does not exist on machine '${this.id}'.`);
+      if (typeof stateValue === 'string') {
+        if (!node.states[stateValue]) {
+          throw missingStateError(path.concat(stateValue));
+        }
+        return;
+      }
+      if (!stateValue || typeof stateValue !== 'object') {
+        return;
+      }
+      for (const key of Object.keys(stateValue)) {
+        const childNode = node.states[key];
+        if (!childNode) {
+          throw missingStateError(path.concat(key));
+        }
+        validateStateValue(stateValue[key], childNode, path.concat(key));
+      }
+    };
+    validateStateValue(snapshotData.value, this.root, []);
     const nodes = Array.from(createActor.getAllStateNodes(createActor.getStateNodes(this.root, snapshotData.value)));
     const {
       version: _persistedSnapshotVersion,

package/dist/{StateMachine-009b5bc4.esm.js → StateMachine-2f47d890.esm.js}

@@ -1,5 +1,5 @@
-import { S as STATE_DELIMITER, I as mapValues, t as toArray, J as createInvokeId, K as getDelayedTransitions, L as getEventDescriptorKey, M as getCandidates, N as evaluateCandidate, O as formatTransition, P as NULL_EVENT, Q as toTransitionConfigArray, R as createInvokeTimeoutEventId, T as matchesActorSession, U as formatRouteTransitions, V as resolveStateValue, W as getAllStateNodes, o as getStateNodes, Y as createMachineSnapshot, Z as isInFinalState, _ as createInertActorScope, $ as setInertActorScopeSnapshot, a0 as attachSnapshotActorRef, a1 as macrostep, a2 as isInertActorScope, a3 as setSnapshotActorRef, a4 as cloneMachineSnapshot, a5 as transitionNode, e as XSTATE_TIMER, m as matchesEventDescriptor, a6 as getTransitionResult, a7 as hasEffect, a8 as createErrorPlatformEvent, a9 as withActorSelf, r as resolveActionsWithContext, F as createInitEvent, aa as createSpawnEffect, ab as initialMicrostep, ac as toStatePath, ad as isStateId, ae as getStateNodeByPath, af as getPersistedSnapshot, ag as resolveReferencedActor, ah as createInvokeTimeoutEvent, ai as $$ACTOR_TYPE, j as createActor } from './createActor-19e83fb9.esm.js';
-import { g as assertValid } from './index-abf9ab72.esm.js';
+import { S as STATE_DELIMITER, I as mapValues, t as toArray, J as createInvokeId, K as getDelayedTransitions, L as getEventDescriptorKey, M as getCandidates, N as evaluateCandidate, O as formatTransition, P as NULL_EVENT, Q as toTransitionConfigArray, R as createInvokeTimeoutEventId, T as matchesActorSession, U as formatRouteTransitions, V as resolveStateValue, W as getAllStateNodes, v as getStateNodes, Y as createMachineSnapshot, Z as isInFinalState, _ as createInertActorScope, $ as setInertActorScopeSnapshot, a0 as attachSnapshotActorRef, a1 as macrostep, a2 as isInertActorScope, a3 as setSnapshotActorRef, a4 as cloneMachineSnapshot, a5 as transitionNode, e as XSTATE_TIMER, m as matchesEventDescriptor, a6 as getTransitionResult, a7 as hasEffect, a8 as createErrorPlatformEvent, a9 as withActorSelf, r as resolveActionsWithContext, F as createInitEvent, aa as createSpawnEffect, ab as initialMicrostep, ac as toStatePath, ad as isStateId, ae as getStateNodeByPath, af as getPersistedSnapshot, ag as resolveReferencedActor, ah as createInvokeTimeoutEvent, ai as $$ACTOR_TYPE, j as createActor } from './createActor-a211c276.esm.js';
+import { g as assertValid } from './index-7020402e.esm.js';
 
 function createSpawner(actorScope, actors, spawnedChildren) {
   return (src, options) => {
@@ -941,6 +941,26 @@ class StateMachine {
       return revived;
     };
     const revivedHistoryValue = reviveHistoryValue(snapshotData.historyValue);
+    const validateStateValue = (stateValue, node, path) => {
+      const missingStateError = statePath => new Error(`Persisted snapshot references state '${statePath.join('.')}' which does not exist on machine '${this.id}'.`);
+      if (typeof stateValue === 'string') {
+        if (!node.states[stateValue]) {
+          throw missingStateError(path.concat(stateValue));
+        }
+        return;
+      }
+      if (!stateValue || typeof stateValue !== 'object') {
+        return;
+      }
+      for (const key of Object.keys(stateValue)) {
+        const childNode = node.states[key];
+        if (!childNode) {
+          throw missingStateError(path.concat(key));
+        }
+        validateStateValue(stateValue[key], childNode, path.concat(key));
+      }
+    };
+    validateStateValue(snapshotData.value, this.root, []);
     const nodes = Array.from(getAllStateNodes(getStateNodes(this.root, snapshotData.value)));
     const {
       version: _persistedSnapshotVersion,

package/dist/{StateMachine-5d0aac92.cjs.js → StateMachine-94084ac7.cjs.js}

@@ -1,7 +1,7 @@
 'use strict';
 
-var createActor = require('./createActor-fd53ec92.cjs.js');
-var dist_xstateActors = require('./index-13e54113.cjs.js');
+var createActor = require('./createActor-d5305cc9.cjs.js');
+var dist_xstateActors = require('./index-21d08fff.cjs.js');
 
 function createSpawner(actorScope, actors, spawnedChildren) {
   return (src, options) => {
@@ -943,6 +943,26 @@ class StateMachine {
       return revived;
     };
     const revivedHistoryValue = reviveHistoryValue(snapshotData.historyValue);
+    const validateStateValue = (stateValue, node, path) => {
+      const missingStateError = statePath => new Error(`Persisted snapshot references state '${statePath.join('.')}' which does not exist on machine '${this.id}'.`);
+      if (typeof stateValue === 'string') {
+        if (!node.states[stateValue]) {
+          throw missingStateError(path.concat(stateValue));
+        }
+        return;
+      }
+      if (!stateValue || typeof stateValue !== 'object') {
+        return;
+      }
+      for (const key of Object.keys(stateValue)) {
+        const childNode = node.states[key];
+        if (!childNode) {
+          throw missingStateError(path.concat(key));
+        }
+        validateStateValue(stateValue[key], childNode, path.concat(key));
+      }
+    };
+    validateStateValue(snapshotData.value, this.root, []);
     const nodes = Array.from(createActor.getAllStateNodes(createActor.getStateNodes(this.root, snapshotData.value)));
     const {
       version: _persistedSnapshotVersion,

package/dist/{StateMachine-9da92cbf.development.esm.js → StateMachine-da29dd2e.development.esm.js}

@@ -1,5 +1,5 @@
-import { S as STATE_DELIMITER, I as mapValues, t as toArray, J as createInvokeId, K as getDelayedTransitions, L as getEventDescriptorKey, M as getCandidates, N as evaluateCandidate, O as formatTransition, P as NULL_EVENT, Q as toTransitionConfigArray, R as createInvokeTimeoutEventId, T as matchesActorSession, U as formatRouteTransitions, V as resolveStateValue, W as getAllStateNodes, o as getStateNodes, Y as createMachineSnapshot, Z as isInFinalState, _ as createInertActorScope, $ as setInertActorScopeSnapshot, a0 as attachSnapshotActorRef, a1 as macrostep, a2 as isInertActorScope, a3 as setSnapshotActorRef, a4 as cloneMachineSnapshot, a5 as transitionNode, e as XSTATE_TIMER, m as matchesEventDescriptor, a6 as getTransitionResult, a7 as hasEffect, a8 as createErrorPlatformEvent, a9 as withActorSelf, r as resolveActionsWithContext, F as createInitEvent, aa as createSpawnEffect, ab as initialMicrostep, ac as toStatePath, ad as isStateId, ae as getStateNodeByPath, af as getPersistedSnapshot, ag as resolveReferencedActor, ah as createInvokeTimeoutEvent, ai as $$ACTOR_TYPE, j as createActor } from './createActor-164c86f5.development.esm.js';
-import { g as assertValid } from './index-acf2bd02.development.esm.js';
+import { S as STATE_DELIMITER, I as mapValues, t as toArray, J as createInvokeId, K as getDelayedTransitions, L as getEventDescriptorKey, M as getCandidates, N as evaluateCandidate, O as formatTransition, P as NULL_EVENT, Q as toTransitionConfigArray, R as createInvokeTimeoutEventId, T as matchesActorSession, U as formatRouteTransitions, V as resolveStateValue, W as getAllStateNodes, v as getStateNodes, Y as createMachineSnapshot, Z as isInFinalState, _ as createInertActorScope, $ as setInertActorScopeSnapshot, a0 as attachSnapshotActorRef, a1 as macrostep, a2 as isInertActorScope, a3 as setSnapshotActorRef, a4 as cloneMachineSnapshot, a5 as transitionNode, e as XSTATE_TIMER, m as matchesEventDescriptor, a6 as getTransitionResult, a7 as hasEffect, a8 as createErrorPlatformEvent, a9 as withActorSelf, r as resolveActionsWithContext, F as createInitEvent, aa as createSpawnEffect, ab as initialMicrostep, ac as toStatePath, ad as isStateId, ae as getStateNodeByPath, af as getPersistedSnapshot, ag as resolveReferencedActor, ah as createInvokeTimeoutEvent, ai as $$ACTOR_TYPE, j as createActor } from './createActor-2a03d4b2.development.esm.js';
+import { g as assertValid } from './index-17f889df.development.esm.js';
 
 function createSpawner(actorScope, actors, spawnedChildren) {
   return (src, options) => {
@@ -973,6 +973,26 @@ class StateMachine {
       return revived;
     };
     const revivedHistoryValue = reviveHistoryValue(snapshotData.historyValue);
+    const validateStateValue = (stateValue, node, path) => {
+      const missingStateError = statePath => new Error(`Persisted snapshot references state '${statePath.join('.')}' which does not exist on machine '${this.id}'.`);
+      if (typeof stateValue === 'string') {
+        if (!node.states[stateValue]) {
+          throw missingStateError(path.concat(stateValue));
+        }
+        return;
+      }
+      if (!stateValue || typeof stateValue !== 'object') {
+        return;
+      }
+      for (const key of Object.keys(stateValue)) {
+        const childNode = node.states[key];
+        if (!childNode) {
+          throw missingStateError(path.concat(key));
+        }
+        validateStateValue(stateValue[key], childNode, path.concat(key));
+      }
+    };
+    validateStateValue(snapshotData.value, this.root, []);
     const nodes = Array.from(getAllStateNodes(getStateNodes(this.root, snapshotData.value)));
     const {
       version: _persistedSnapshotVersion,

package/dist/{createActor-164c86f5.development.esm.js → createActor-2a03d4b2.development.esm.js}

@@ -669,6 +669,11 @@ function createTransitionEnqueue(actorScope, actions, internalEvents, actorSubsc
   if (actorSubscriptions) {
     Object.assign(props, {
       listen: (actor, eventType, mapper) => {
+        if (!createActors) {
+          return {
+            id: undefined
+          };
+        }
         const input = {
           actor,
           eventType,
@@ -682,6 +687,11 @@ function createTransitionEnqueue(actorScope, actions, internalEvents, actorSubsc
         return listenerActor;
       },
       subscribeTo: (actor, mappers) => {
+        if (!createActors) {
+          return {
+            id: undefined
+          };
+        }
         const normalizedMappers = typeof mappers === 'function' ? {
           snapshot: mappers
         } : mappers;
@@ -2804,7 +2814,7 @@ function getTransitionResult(transition, snapshot, event, actorScope, options) {
   if (transition.to) {
     const actions = [];
     const internalEvents = [];
-    const res = options?.selectionResult?.reusable ? options.selectionResult.result : transition.to(getTransitionArgs(), createTransitionEnqueue(actorScope, actions, internalEvents, false, options?.resolveActions ?? true));
+    const res = options?.selectionResult?.reusable ? options.selectionResult.result : transition.to(getTransitionArgs(), createTransitionEnqueue(actorScope, actions, internalEvents, true, options?.resolveActions ?? true));
     const targets = res?.target ? resolveTarget(transition.source, toArray(res.target)) : undefined;
     const resolvedInput = res?.input ?? (typeof transition.input === 'function' ? transition.input({
       context: snapshot.context,
@@ -3027,7 +3037,9 @@ function getTransitionEffectEnqueue() {
     raise: triggerTransitionEffect,
     spawn: triggerTransitionEffect,
     sendTo: triggerTransitionEffect,
-    stop: triggerTransitionEffect
+    stop: triggerTransitionEffect,
+    listen: triggerTransitionEffect,
+    subscribeTo: triggerTransitionEffect
   }, triggerTransitionEffect);
 }
 function evaluateTransitionFunction(transitionTo, context, event, snapshot, actorScope, sources, sourceId) {
@@ -4900,4 +4912,4 @@ function createActor(logic, options) {
   return new Actor(logic, options);
 }
 
-export { setInertActorScopeSnapshot as $, Actor as A, createListenerLogic as B, listenerLogic as C, createSubscriptionLogic as D, subscriptionLogic as E, createInitEvent as F, createCustomEffect as G, createEmitEffect as H, mapValues as I, createInvokeId as J, getDelayedTransitions as K, getEventDescriptorKey as L, getCandidates as M, evaluateCandidate as N, formatTransition as O, NULL_EVENT as P, toTransitionConfigArray as Q, createInvokeTimeoutEventId as R, STATE_DELIMITER as S, matchesActorSession as T, formatRouteTransitions as U, resolveStateValue as V, getAllStateNodes as W, XSTATE_INIT as X, createMachineSnapshot as Y, isInFinalState as Z, createInertActorScope as _, XSTATE_STOP as a, attachSnapshotActorRef as a0, macrostep as a1, isInertActorScope as a2, setSnapshotActorRef as a3, cloneMachineSnapshot as a4, transitionNode as a5, getTransitionResult as a6, hasEffect as a7, createErrorPlatformEvent as a8, withActorSelf as a9, createSpawnEffect as aa, initialMicrostep as ab, toStatePath as ac, isStateId as ad, getStateNodeByPath as ae, getPersistedSnapshot as af, resolveReferencedActor as ag, createInvokeTimeoutEvent as ah, $$ACTOR_TYPE as ai, getProperAncestors as aj, getAllOwnEvents as ak, matchesEvent as al, builtInActions as b, createTransitionEnqueue as c, deriveDeferredStarts as d, XSTATE_TIMER as e, finalizeTransitionResult as f, createSendToEffect as g, isAtomicStateNode as h, isLazyActorScope as i, createActor as j, getInitialSnapshot as k, getNextSnapshot as l, matchesEventDescriptor as m, isMachineSnapshot as n, getStateNodes as o, parseDelayToMilliseconds as p, getAllOwnEventDescriptors as q, resolveActionsWithContext as r, matchesState as s, toArray as t, checkStateIn as u, pathToStateValue as v, withActorScope as w, toObserver as x, executeEffects as y, isBuiltInExecutableAction as z };
+export { setInertActorScopeSnapshot as $, Actor as A, pathToStateValue as B, toObserver as C, executeEffects as D, isBuiltInExecutableAction as E, createInitEvent as F, createCustomEffect as G, createEmitEffect as H, mapValues as I, createInvokeId as J, getDelayedTransitions as K, getEventDescriptorKey as L, getCandidates as M, evaluateCandidate as N, formatTransition as O, NULL_EVENT as P, toTransitionConfigArray as Q, createInvokeTimeoutEventId as R, STATE_DELIMITER as S, matchesActorSession as T, formatRouteTransitions as U, resolveStateValue as V, getAllStateNodes as W, XSTATE_INIT as X, createMachineSnapshot as Y, isInFinalState as Z, createInertActorScope as _, XSTATE_STOP as a, attachSnapshotActorRef as a0, macrostep as a1, isInertActorScope as a2, setSnapshotActorRef as a3, cloneMachineSnapshot as a4, transitionNode as a5, getTransitionResult as a6, hasEffect as a7, createErrorPlatformEvent as a8, withActorSelf as a9, createSpawnEffect as aa, initialMicrostep as ab, toStatePath as ac, isStateId as ad, getStateNodeByPath as ae, getPersistedSnapshot as af, resolveReferencedActor as ag, createInvokeTimeoutEvent as ah, $$ACTOR_TYPE as ai, getProperAncestors as aj, getAllOwnEvents as ak, matchesEvent as al, builtInActions as b, createTransitionEnqueue as c, deriveDeferredStarts as d, XSTATE_TIMER as e, finalizeTransitionResult as f, createSendToEffect as g, isAtomicStateNode as h, isLazyActorScope as i, createActor as j, createListenerLogic as k, createSubscriptionLogic as l, matchesEventDescriptor as m, listenerLogic as n, getInitialSnapshot as o, parseDelayToMilliseconds as p, getNextSnapshot as q, resolveActionsWithContext as r, subscriptionLogic as s, toArray as t, isMachineSnapshot as u, getStateNodes as v, withActorScope as w, getAllOwnEventDescriptors as x, matchesState as y, checkStateIn as z };

package/dist/{createActor-19e83fb9.esm.js → createActor-a211c276.esm.js}

@@ -668,6 +668,11 @@ function createTransitionEnqueue(actorScope, actions, internalEvents, actorSubsc
   if (actorSubscriptions) {
     Object.assign(props, {
       listen: (actor, eventType, mapper) => {
+        if (!createActors) {
+          return {
+            id: undefined
+          };
+        }
         const input = {
           actor,
           eventType,
@@ -681,6 +686,11 @@ function createTransitionEnqueue(actorScope, actions, internalEvents, actorSubsc
         return listenerActor;
       },
       subscribeTo: (actor, mappers) => {
+        if (!createActors) {
+          return {
+            id: undefined
+          };
+        }
         const normalizedMappers = typeof mappers === 'function' ? {
           snapshot: mappers
         } : mappers;
@@ -2793,7 +2803,7 @@ function getTransitionResult(transition, snapshot, event, actorScope, options) {
   if (transition.to) {
     const actions = [];
     const internalEvents = [];
-    const res = options?.selectionResult?.reusable ? options.selectionResult.result : transition.to(getTransitionArgs(), createTransitionEnqueue(actorScope, actions, internalEvents, false, options?.resolveActions ?? true));
+    const res = options?.selectionResult?.reusable ? options.selectionResult.result : transition.to(getTransitionArgs(), createTransitionEnqueue(actorScope, actions, internalEvents, true, options?.resolveActions ?? true));
     const targets = res?.target ? resolveTarget(transition.source, toArray(res.target)) : undefined;
     const resolvedInput = res?.input ?? (typeof transition.input === 'function' ? transition.input({
       context: snapshot.context,
@@ -3016,7 +3026,9 @@ function getTransitionEffectEnqueue() {
     raise: triggerTransitionEffect,
     spawn: triggerTransitionEffect,
     sendTo: triggerTransitionEffect,
-    stop: triggerTransitionEffect
+    stop: triggerTransitionEffect,
+    listen: triggerTransitionEffect,
+    subscribeTo: triggerTransitionEffect
   }, triggerTransitionEffect);
 }
 function evaluateTransitionFunction(transitionTo, context, event, snapshot, actorScope, sources, sourceId) {
@@ -4861,4 +4873,4 @@ function createActor(logic, options) {
   return new Actor(logic, options);
 }
 
-export { setInertActorScopeSnapshot as $, Actor as A, createListenerLogic as B, listenerLogic as C, createSubscriptionLogic as D, subscriptionLogic as E, createInitEvent as F, createCustomEffect as G, createEmitEffect as H, mapValues as I, createInvokeId as J, getDelayedTransitions as K, getEventDescriptorKey as L, getCandidates as M, evaluateCandidate as N, formatTransition as O, NULL_EVENT as P, toTransitionConfigArray as Q, createInvokeTimeoutEventId as R, STATE_DELIMITER as S, matchesActorSession as T, formatRouteTransitions as U, resolveStateValue as V, getAllStateNodes as W, XSTATE_INIT as X, createMachineSnapshot as Y, isInFinalState as Z, createInertActorScope as _, XSTATE_STOP as a, attachSnapshotActorRef as a0, macrostep as a1, isInertActorScope as a2, setSnapshotActorRef as a3, cloneMachineSnapshot as a4, transitionNode as a5, getTransitionResult as a6, hasEffect as a7, createErrorPlatformEvent as a8, withActorSelf as a9, createSpawnEffect as aa, initialMicrostep as ab, toStatePath as ac, isStateId as ad, getStateNodeByPath as ae, getPersistedSnapshot as af, resolveReferencedActor as ag, createInvokeTimeoutEvent as ah, $$ACTOR_TYPE as ai, getProperAncestors as aj, getAllOwnEvents as ak, matchesEvent as al, builtInActions as b, createTransitionEnqueue as c, deriveDeferredStarts as d, XSTATE_TIMER as e, finalizeTransitionResult as f, createSendToEffect as g, isAtomicStateNode as h, isLazyActorScope as i, createActor as j, getInitialSnapshot as k, getNextSnapshot as l, matchesEventDescriptor as m, isMachineSnapshot as n, getStateNodes as o, parseDelayToMilliseconds as p, getAllOwnEventDescriptors as q, resolveActionsWithContext as r, matchesState as s, toArray as t, checkStateIn as u, pathToStateValue as v, withActorScope as w, toObserver as x, executeEffects as y, isBuiltInExecutableAction as z };
+export { setInertActorScopeSnapshot as $, Actor as A, pathToStateValue as B, toObserver as C, executeEffects as D, isBuiltInExecutableAction as E, createInitEvent as F, createCustomEffect as G, createEmitEffect as H, mapValues as I, createInvokeId as J, getDelayedTransitions as K, getEventDescriptorKey as L, getCandidates as M, evaluateCandidate as N, formatTransition as O, NULL_EVENT as P, toTransitionConfigArray as Q, createInvokeTimeoutEventId as R, STATE_DELIMITER as S, matchesActorSession as T, formatRouteTransitions as U, resolveStateValue as V, getAllStateNodes as W, XSTATE_INIT as X, createMachineSnapshot as Y, isInFinalState as Z, createInertActorScope as _, XSTATE_STOP as a, attachSnapshotActorRef as a0, macrostep as a1, isInertActorScope as a2, setSnapshotActorRef as a3, cloneMachineSnapshot as a4, transitionNode as a5, getTransitionResult as a6, hasEffect as a7, createErrorPlatformEvent as a8, withActorSelf as a9, createSpawnEffect as aa, initialMicrostep as ab, toStatePath as ac, isStateId as ad, getStateNodeByPath as ae, getPersistedSnapshot as af, resolveReferencedActor as ag, createInvokeTimeoutEvent as ah, $$ACTOR_TYPE as ai, getProperAncestors as aj, getAllOwnEvents as ak, matchesEvent as al, builtInActions as b, createTransitionEnqueue as c, deriveDeferredStarts as d, XSTATE_TIMER as e, finalizeTransitionResult as f, createSendToEffect as g, isAtomicStateNode as h, isLazyActorScope as i, createActor as j, createListenerLogic as k, createSubscriptionLogic as l, matchesEventDescriptor as m, listenerLogic as n, getInitialSnapshot as o, parseDelayToMilliseconds as p, getNextSnapshot as q, resolveActionsWithContext as r, subscriptionLogic as s, toArray as t, isMachineSnapshot as u, getStateNodes as v, withActorScope as w, getAllOwnEventDescriptors as x, matchesState as y, checkStateIn as z };

package/dist/{createActor-8462b9cc.development.cjs.js → createActor-c0f78b8a.development.cjs.js}

@@ -671,6 +671,11 @@ function createTransitionEnqueue(actorScope, actions, internalEvents, actorSubsc
   if (actorSubscriptions) {
     Object.assign(props, {
       listen: (actor, eventType, mapper) => {
+        if (!createActors) {
+          return {
+            id: undefined
+          };
+        }
         const input = {
           actor,
           eventType,
@@ -684,6 +689,11 @@ function createTransitionEnqueue(actorScope, actions, internalEvents, actorSubsc
         return listenerActor;
       },
       subscribeTo: (actor, mappers) => {
+        if (!createActors) {
+          return {
+            id: undefined
+          };
+        }
         const normalizedMappers = typeof mappers === 'function' ? {
           snapshot: mappers
         } : mappers;
@@ -2806,7 +2816,7 @@ function getTransitionResult(transition, snapshot, event, actorScope, options) {
   if (transition.to) {
     const actions = [];
     const internalEvents = [];
-    const res = options?.selectionResult?.reusable ? options.selectionResult.result : transition.to(getTransitionArgs(), createTransitionEnqueue(actorScope, actions, internalEvents, false, options?.resolveActions ?? true));
+    const res = options?.selectionResult?.reusable ? options.selectionResult.result : transition.to(getTransitionArgs(), createTransitionEnqueue(actorScope, actions, internalEvents, true, options?.resolveActions ?? true));
     const targets = res?.target ? resolveTarget(transition.source, toArray(res.target)) : undefined;
     const resolvedInput = res?.input ?? (typeof transition.input === 'function' ? transition.input({
       context: snapshot.context,
@@ -3029,7 +3039,9 @@ function getTransitionEffectEnqueue() {
     raise: triggerTransitionEffect,
     spawn: triggerTransitionEffect,
     sendTo: triggerTransitionEffect,
-    stop: triggerTransitionEffect
+    stop: triggerTransitionEffect,
+    listen: triggerTransitionEffect,
+    subscribeTo: triggerTransitionEffect
   }, triggerTransitionEffect);
 }
 function evaluateTransitionFunction(transitionTo, context, event, snapshot, actorScope, sources, sourceId) {

package/dist/{createActor-fd53ec92.cjs.js → createActor-d5305cc9.cjs.js}

@@ -670,6 +670,11 @@ function createTransitionEnqueue(actorScope, actions, internalEvents, actorSubsc
   if (actorSubscriptions) {
     Object.assign(props, {
       listen: (actor, eventType, mapper) => {
+        if (!createActors) {
+          return {
+            id: undefined
+          };
+        }
         const input = {
           actor,
           eventType,
@@ -683,6 +688,11 @@ function createTransitionEnqueue(actorScope, actions, internalEvents, actorSubsc
         return listenerActor;
       },
       subscribeTo: (actor, mappers) => {
+        if (!createActors) {
+          return {
+            id: undefined
+          };
+        }
         const normalizedMappers = typeof mappers === 'function' ? {
           snapshot: mappers
         } : mappers;
@@ -2795,7 +2805,7 @@ function getTransitionResult(transition, snapshot, event, actorScope, options) {
   if (transition.to) {
     const actions = [];
     const internalEvents = [];
-    const res = options?.selectionResult?.reusable ? options.selectionResult.result : transition.to(getTransitionArgs(), createTransitionEnqueue(actorScope, actions, internalEvents, false, options?.resolveActions ?? true));
+    const res = options?.selectionResult?.reusable ? options.selectionResult.result : transition.to(getTransitionArgs(), createTransitionEnqueue(actorScope, actions, internalEvents, true, options?.resolveActions ?? true));
     const targets = res?.target ? resolveTarget(transition.source, toArray(res.target)) : undefined;
     const resolvedInput = res?.input ?? (typeof transition.input === 'function' ? transition.input({
       context: snapshot.context,
@@ -3018,7 +3028,9 @@ function getTransitionEffectEnqueue() {
     raise: triggerTransitionEffect,
     spawn: triggerTransitionEffect,
     sendTo: triggerTransitionEffect,
-    stop: triggerTransitionEffect
+    stop: triggerTransitionEffect,
+    listen: triggerTransitionEffect,
+    subscribeTo: triggerTransitionEffect
   }, triggerTransitionEffect);
 }
 function evaluateTransitionFunction(transitionTo, context, event, snapshot, actorScope, sources, sourceId) {

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

@@ -1,6 +1,6 @@
 import { StandardSchemaV1 } from "./schema.types.js";
 import { StateMachine } from "./StateMachine.js";
-import { AnyActorRef, EventObject, AnyEventObject, Cast, MachineContext, ProvidedActor, StateValue, ToChildren, MetaObject, StateSchema, DoNotInfer, RoutableStateId, Compute } from "./types.js";
+import { AnyActorRef, EventObject, AnyEventObject, Cast, MachineContext, ProvidedActor, StateValueFromStateSchema, ToChildren, MetaObject, StateSchema, DoNotInfer, RoutableStateId, Compute } from "./types.js";
 import { Sources, DelayMapFromNames, InferChildren, InferOutput, InferEvents, Next_MachineConfig, Next_StateNodeConfig, ValidateDelayReferences, ValidateHistoryDefaults, ValidateStateTargets, ValidateTopLevelFinalOutputs, WidenLiterals, WithDefault } from "./types.v6.js";
 type MergeChildren<TChildren extends Record<string, AnyActorRef | undefined>, TActor extends ProvidedActor> = [keyof TChildren] extends [never] ? Compute<ToChildren<TActor>> : Compute<TChildren>;
 type MachineIdentity<TConfig> = {
@@ -61,7 +61,7 @@ export declare function createMachine<TContextSchema extends StandardSchemaV1, c
 } & ValidateTopLevelFinalOutputs<TSS, InferOutput<TContextSchema, MachineContext>, InferEvents<TEventSchemaMap>>): StateMachine<InferOutput<TContextSchema, MachineContext>, InferEvents<TEventSchemaMap> | ([RoutableStateId<TSS>] extends [never] ? never : {
     type: 'xstate.route';
     to: RoutableStateId<TSS>;
-}), Cast<MergeChildren<InferChildren<TChildrenSchemaMap>, TActor>, Record<string, AnyActorRef | undefined>>, StateValue, TTag & string, TInput, InferOutput<TOutputSchema, unknown>, WithDefault<InferEvents<TEmittedSchemaMap>, AnyEventObject>, InferOutput<TMetaSchema, MetaObject>, // TMeta
+}), Cast<MergeChildren<InferChildren<TChildrenSchemaMap>, TActor>, Record<string, AnyActorRef | undefined>>, StateValueFromStateSchema<TSS>, TTag & string, TInput, InferOutput<TOutputSchema, unknown>, WithDefault<InferEvents<TEmittedSchemaMap>, AnyEventObject>, InferOutput<TMetaSchema, MetaObject>, // TMeta
 TSS, // TStateSchema
 TActionMap, TActorMap, TGuardMap, DelayMapFromNames<TDelays, TDelayMap>> & {
     states: TSS;
@@ -79,7 +79,7 @@ export declare function createMachine<TContext extends MachineContext = never, c
 } & ValidateTopLevelFinalOutputs<TSS, WidenLiterals<TContext>, InferEvents<TEventSchemaMap>>): StateMachine<WidenLiterals<TContext>, InferEvents<TEventSchemaMap> | ([RoutableStateId<TSS>] extends [never] ? never : {
     type: 'xstate.route';
     to: RoutableStateId<TSS>;
-}), Cast<MergeChildren<InferChildren<TChildrenSchemaMap>, TActor>, Record<string, AnyActorRef | undefined>>, StateValue, TTag & string, TInput, InferOutput<TOutputSchema, unknown>, WithDefault<InferEvents<TEmittedSchemaMap>, AnyEventObject>, InferOutput<TMetaSchema, MetaObject>, // TMeta
+}), Cast<MergeChildren<InferChildren<TChildrenSchemaMap>, TActor>, Record<string, AnyActorRef | undefined>>, StateValueFromStateSchema<TSS>, TTag & string, TInput, InferOutput<TOutputSchema, unknown>, WithDefault<InferEvents<TEmittedSchemaMap>, AnyEventObject>, InferOutput<TMetaSchema, MetaObject>, // TMeta
 TSS, // TStateSchema
 TActionMap, TActorMap, TGuardMap, DelayMapFromNames<TDelays, TDelayMap>> & {
     states: TSS;

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

@@ -1,4 +1,4 @@
-export * from "./actors/index.js";
+export { createAsyncLogic, createCallbackLogic, createEmptyActor, createEventObservableLogic, createListenerLogic, createLogic, createObservableLogic, createSubscriptionLogic, listenerLogic, subscriptionLogic, TimeoutError, type AsyncActorLogic, type AsyncActorRef, type AsyncLogicArgs, type AsyncLogicConfig, type AsyncLogicEnqueue, type AsyncLogicFunction, type AsyncSnapshot, type CallbackActorLogic, type CallbackActorRef, type CallbackLogicConfig, type CallbackLogicFunction, type CallbackSnapshot, type EventObservableLogicConfig, type EventObservableLogicFunction, type ListenerActorLogic, type ListenerActorRef, type ListenerInput, type ListenerSnapshot, type LogicActorLogic, type LogicActorRef, type LogicArgs, type LogicConfig, type LogicEffect, type LogicEffectState, type LogicEnqueue, type LogicFunction, type LogicPatch, type LogicSnapshot, type ObservableActorLogic, type ObservableActorRef, type ObservableLogicConfig, type ObservableLogicFunction, type ObservableSnapshot, type SubscriptionActorLogic, type SubscriptionActorRef, type SubscriptionInput, type SubscriptionMappers, type SubscriptionSnapshot } from "./actors/index.js";
 export { assertEvent } from "./assert.js";
 export { Actor, createActor, type RequiredActorOptionsKeys as RequiredActorOptionsKeys } from "./createActor.js";
 export { createMachine, createStateConfig } from "./createMachine.js";
@@ -22,7 +22,8 @@ export { StateNode } from "./StateNode.js";
 export { getStateNodes } from "./stateUtils.js";
 export type { ActorSystem, ActorSystemRuntime, AnyActorSystem } from "./system.js";
 export { toPromise } from "./toPromise.js";
-export * from "./types.js";
+export type * from "./types.js";
+export { SpecialTargets } from "./types.js";
 export type { Next_MachineConfig as MachineConfig, Next_StateNodeConfig as StateNodeConfig, Next_InvokeConfig as InvokeConfig, Next_TransitionConfigOrTarget as TransitionConfigOrTarget, Sources, InferEvents, WidenLiterals } from "./types.v6.js";
 export { getAllOwnEventDescriptors as __unsafe_getAllOwnEventDescriptors, matchesState, checkStateIn, pathToStateValue, toObserver } from "./utils.js";
 export { transition, initialTransition, getMicrosteps, getInitialMicrosteps, getNextTransitions } from "./transition.js";

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

@@ -2,7 +2,7 @@ import { SetupStateSchemas, StandardSchemaV1 } from "./schema.types.js";
 import type { ActorLogicValidator } from "./validation.types.js";
 import { StateMachine } from "./StateMachine.js";
 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, DoneActorEvent, DoneStateEvent, ErrorActorEvent, SystemRegistry, RegistryKeyForLogic, ActorOptions, Observer, Subscription, OutputArg, SnapshotEvent, SingleOrArray, AfterEvent, TimeoutEvent, ErrorEvent } from "./types.js";
+import { AnyActorRef, AnyActorLogic, ActorRefFromLogic, AnyStateNode, EventObject, AnyEventObject, EventDescriptor, ExtractEvent, MachineContext, ProvidedActor, RoutableStateId, StateSchema, StateValue, StateValueFromStateSchema, ToChildren, MetaObject, Cast, Compute, EnqueueObject, DoneActorEvent, DoneStateEvent, ErrorActorEvent, SystemRegistry, RegistryKeyForLogic, ActorOptions, Observer, Subscription, OutputArg, SnapshotEvent, SingleOrArray, AfterEvent, TimeoutEvent, ErrorEvent } from "./types.js";
 import { AnyActorSystem } from "./system.js";
 import { InspectionEvent } from "./inspection.js";
 import { ActionSchemas, DelayMapFromNames, GuardSchemas, InferChildren, InferActions, InferGuards, Sources, InferOutput, InferEvents, Next_MachineConfig, Next_InvokeConfig, Next_StateNodeConfig, Next_TransitionConfigOrTarget, ValidateHistoryDefaults, ValidateStateTargets, WithDefault } from "./types.v6.js";
@@ -47,6 +47,9 @@ type RuntimeValidationConstraint<TSchemas, TStates, TValidator> = [
     schemas?: ValidateSetupSchemas<TSchemas>;
     states?: ValidateSetupStates<TStates>;
 } : unknown;
+type RuntimeValidationCompatibility<TSchemas, TStates, TValidator> = [
+    TValidator
+] extends [ActorLogicValidator] ? [TSchemas] extends [ValidateSetupSchemas<TSchemas>] ? [TStates] extends [ValidateSetupStates<TStates>] ? unknown : RuntimeValidationDoesNotSupportTransformingSchemas : RuntimeValidationDoesNotSupportTransformingSchemas : unknown;
 declare const inheritedValidator: unique symbol;
 type InheritedValidator = typeof inheritedValidator;
 type ResolveExtendedValidator<TBase, TExtension> = [TExtension] extends [
@@ -59,9 +62,7 @@ type ExtendValidatorConfig<TExtension> = [TExtension] extends [
 } : {
     validator: TExtension;
 };
-type SetupExtensionConfig<TBaseSchemas, TBaseStates, TBaseValidator, TExtendSchemas extends SetupSchemas, TExtendStates extends Record<string, SetupStateSchema>, TExtendActionMap extends Sources['actions'], TExtendActorMap extends Sources['actors'], TExtendGuardMap extends Sources['guards'], TExtendDelayMap extends Sources['delays'], TExtendValidator extends ActorLogicValidator | undefined | InheritedValidator> = Omit<SetupConfig<TExtendSchemas, TExtendStates, TExtendActionMap, TExtendActorMap, TExtendGuardMap, TExtendDelayMap>, 'validator'> & ExtendValidatorConfig<TExtendValidator> & (TBaseValidator extends ActorLogicValidator ? unknown : {
-    validator?: never;
-}) & RuntimeValidationConstraint<NoInfer<TBaseSchemas>, NoInfer<TBaseStates>, ResolveExtendedValidator<TBaseValidator, TExtendValidator>> & RuntimeValidationConstraint<NoInfer<TExtendSchemas>, NoInfer<TExtendStates>, ResolveExtendedValidator<TBaseValidator, TExtendValidator>>;
+type SetupExtensionConfig<TBaseSchemas, TBaseStates, TBaseValidator, TExtendSchemas extends SetupSchemas, TExtendStates extends Record<string, SetupStateSchema>, TExtendActionMap extends Sources['actions'], TExtendActorMap extends Sources['actors'], TExtendGuardMap extends Sources['guards'], TExtendDelayMap extends Sources['delays'], TExtendValidator extends ActorLogicValidator | undefined | InheritedValidator> = Omit<SetupConfig<TExtendSchemas, TExtendStates, TExtendActionMap, TExtendActorMap, TExtendGuardMap, TExtendDelayMap>, 'validator'> & ExtendValidatorConfig<TExtendValidator> & RuntimeValidationCompatibility<NoInfer<TBaseSchemas>, NoInfer<TBaseStates>, ResolveExtendedValidator<TBaseValidator, TExtendValidator>> & RuntimeValidationConstraint<NoInfer<TExtendSchemas>, NoInfer<TExtendStates>, ResolveExtendedValidator<TBaseValidator, TExtendValidator>>;
 type InlineMachineSchemas<TContextSchema, TEventSchemaMap, TEmittedSchemaMap, TActionSchemaMap, TGuardSchemaMap, TInputSchema, TOutputSchema, TMetaSchema, TTagSchema, TChildrenSchemaMap> = {
     context?: TContextSchema;
     events?: TEventSchemaMap;
@@ -463,7 +464,7 @@ export interface SetupReturn<TStates extends Record<string, SetupStateSchema> =
     } & TConfig & RuntimeValidationConstraint<NoInfer<MachineConfigSchemas<TConfig>>, NoInfer<MachineConfigStates<TConfig>>, TValidator> & ValidateSetupDelayReferences<TConfig, TSetupDelays> & ValidateHistoryDefaults<TConfig> & ValidateStateTargets<TConfig> & ValidateRegistryKeys<TConfig, TSystemRegistry, MergeSourceMaps<TSetupActorMap, TActorMap>>): StateMachine<SetupContext<TSchemas, TContextSchema>, SetupEvents<TSchemas, TEventSchemaMap> | ([RoutableStateId<Cast<TConfig, StateSchema>>] extends [never] ? never : {
         type: 'xstate.route';
         to: RoutableStateId<Cast<TConfig, StateSchema>>;
-    }), Cast<MergeChildren<SetupChildren<TSchemas, TChildrenSchemaMap>, TActor>, Record<string, AnyActorRef | undefined>>, StateValue, TTag & string, [
+    }), Cast<MergeChildren<SetupChildren<TSchemas, TChildrenSchemaMap>, TActor>, Record<string, AnyActorRef | undefined>>, StateValueFromStateSchema<MergeStateSchema<Cast<TConfig, StateSchema>, SetupStatesToStateSchema<TStates>>>, 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>>, MergeSourceMaps<SetupActions<TSchemas, TSetupActionMap>, MergeSourceMaps<InferActions<TActionSchemaMap>, TActionMap>>, MergeSourceMaps<TSetupActorMap, TActorMap>, MergeSourceMaps<SetupGuards<TSchemas, TSetupGuardMap>, MergeSourceMaps<InferGuards<TGuardSchemaMap>, TGuardMap>>, DelayMapFromNames<TSetupDelays | TDelays, MergeSourceMaps<TSetupDelayMap, TDelayMap>>> & MachineIdentity<TConfig>;
     /**
@@ -497,9 +498,16 @@ type SetupConfigGuards<TConfig> = TConfig extends {
 type SetupConfigDelays<TConfig> = TConfig extends {
     delays?: infer TDelays;
 } ? TDelays extends Sources['delays'] ? TDelays : {} : {};
-export type SetupReturnFromConfig<TConfig extends AnySetupConfig> = SetupReturn<SetupConfigStates<TConfig>, SetupConfigSchemas<TConfig>, SetupConfigActions<TConfig>, SetupConfigActors<TConfig>, SetupConfigGuards<TConfig>, SetupConfigDelays<TConfig>, Extract<keyof SetupConfigDelays<TConfig>, string>, SystemRegistry, TConfig extends {
+export type SetupReturnFromConfig<TConfig extends AnySetupConfig, TSystemRegistry extends SystemRegistry = SystemRegistry> = SetupReturn<SetupConfigStates<TConfig>, SetupConfigSchemas<TConfig>, SetupConfigActions<TConfig>, SetupConfigActors<TConfig>, SetupConfigGuards<TConfig>, SetupConfigDelays<TConfig>, Extract<keyof SetupConfigDelays<TConfig>, string>, TSystemRegistry, TConfig extends {
     validator: infer TValidator extends ActorLogicValidator;
 } ? TValidator : undefined>;
+type SetupFunction<TSystemRegistry extends SystemRegistry = SystemRegistry> = {
+    (): SetupReturn<Record<string, SetupStateSchema>, {}, {}, {}, {}, {}, never, TSystemRegistry>;
+    <const TSchemas extends SetupSchemas = {}, const TStates extends Record<string, SetupStateSchema> = Record<string, SetupStateSchema>, TActionMap extends Sources['actions'] = {}, TActorMap extends Sources['actors'] = {}, TGuardMap extends Sources['guards'] = {}, TDelayMap extends Sources['delays'] = {}, const TValidator extends ActorLogicValidator | undefined = undefined>(config: SetupConfig<TSchemas, TStates, TActionMap, TActorMap, TGuardMap, TDelayMap, TValidator> & RuntimeValidationConstraint<NoInfer<TSchemas>, NoInfer<TStates>, TValidator>): SetupReturn<TStates, TSchemas, TActionMap, TActorMap, TGuardMap, TDelayMap, Extract<keyof TDelayMap, string>, TSystemRegistry, TValidator>;
+    <const TConfig extends AnySetupConfig>(config: TConfig & RuntimeValidationConstraint<NoInfer<SetupConfigSchemas<TConfig>>, NoInfer<SetupConfigStates<TConfig>>, TConfig extends {
+        validator: infer TValidator;
+    } ? TValidator : undefined>): SetupReturnFromConfig<TConfig, TSystemRegistry>;
+};
 /**
  * Sets up a state machine with state input schemas and other configuration.
  *
@@ -536,11 +544,7 @@ export type SetupReturnFromConfig<TConfig extends AnySetupConfig> = SetupReturn<
  * });
  * ```
  */
-export declare function setup(): SetupReturn;
-export declare function setup<const TSchemas extends SetupSchemas = {}, const TStates extends Record<string, SetupStateSchema> = Record<string, SetupStateSchema>, TActionMap extends Sources['actions'] = {}, TActorMap extends Sources['actors'] = {}, TGuardMap extends Sources['guards'] = {}, TDelayMap extends Sources['delays'] = {}, const TValidator extends ActorLogicValidator | undefined = undefined>(config: SetupConfig<TSchemas, TStates, TActionMap, TActorMap, TGuardMap, TDelayMap, TValidator> & RuntimeValidationConstraint<NoInfer<TSchemas>, NoInfer<TStates>, TValidator>): SetupReturn<TStates, TSchemas, TActionMap, TActorMap, TGuardMap, TDelayMap, Extract<keyof TDelayMap, string>, SystemRegistry, TValidator>;
-export declare function setup<const TConfig extends AnySetupConfig>(config: TConfig & RuntimeValidationConstraint<NoInfer<SetupConfigSchemas<TConfig>>, NoInfer<SetupConfigStates<TConfig>>, TConfig extends {
-    validator: infer TValidator;
-} ? TValidator : undefined>): SetupReturnFromConfig<TConfig>;
+export declare const setup: SetupFunction;
 type SystemBuilder<TSystemRegistry extends SystemRegistry> = {
     createActor<TLogic extends AnyActorLogic>(logic: TLogic, options?: Omit<ActorOptions<TLogic>, 'registryKey'> & {
         registryKey?: RegistryKeyForLogic<TLogic, TSystemRegistry>;
@@ -550,6 +554,6 @@ type SystemBuilder<TSystemRegistry extends SystemRegistry> = {
     get: SystemRuntime<TSystemRegistry>['get'];
     getAll: SystemRuntime<TSystemRegistry>['getAll'];
     inspect(observer: Observer<InspectionEvent> | ((inspectionEvent: InspectionEvent) => void)): Subscription;
-    setup<const TSchemas extends SetupSchemas = {}, const TStates extends Record<string, SetupStateSchema> = Record<string, SetupStateSchema>, TActionMap extends Sources['actions'] = {}, TActorMap extends Sources['actors'] = {}, TGuardMap extends Sources['guards'] = {}, TDelayMap extends Sources['delays'] = {}>(config?: SetupConfig<TSchemas, TStates, TActionMap, TActorMap, TGuardMap, TDelayMap>): SetupReturn<TStates, TSchemas, TActionMap, TActorMap, TGuardMap, TDelayMap, Extract<keyof TDelayMap, string>, TSystemRegistry>;
+    setup: SetupFunction<TSystemRegistry>;
 };
 export declare function createSystem<const TSystemRegistry extends SystemRegistry = {}>(_config?: SystemConfig<TSystemRegistry>): SystemBuilder<TSystemRegistry>;

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

@@ -400,7 +400,7 @@ export type PersistedHistoryValue = Record<string, Array<{
 }>>;
 export type AnyHistoryValue = HistoryValue;
 export type StateFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine)> = T extends AnyStateMachine ? StateSnapshotFromMachine<T> : T extends (...args: any[]) => AnyStateMachine ? StateSnapshotFromMachine<ReturnType<T>> : never;
-type StateValueFromStateSchema<T extends StateSchema> = StateSchema extends T ? StateValue : ToStateValue<T> extends infer TStateValue ? TStateValue extends StateValue ? TStateValue : StateValue : StateValue;
+export type StateValueFromStateSchema<T extends StateSchema> = StateSchema extends T ? StateValue : ToStateValue<T> extends infer TStateValue ? TStateValue extends StateValue ? TStateValue : StateValue : StateValue;
 type MatchingStateValueForStateFrom<TStateValue extends StateValue, TTestStateValue extends StateValue> = TStateValue extends unknown ? TTestStateValue extends string ? TStateValue extends string ? TTestStateValue extends TStateValue ? TTestStateValue : Extract<TStateValue, TTestStateValue> : TStateValue extends StateValueMap ? TStateValue & Record<TTestStateValue, StateValue | undefined> : never : TTestStateValue extends StateValueMap ? TStateValue extends StateValueMap ? MatchingStateValueMapForStateFrom<TStateValue, TTestStateValue> : never : never : never;
 type MatchingStateValueMapForStateFrom<TStateValue extends StateValueMap, TTestStateValue extends StateValueMap> = false extends {
     [K in keyof TTestStateValue & string]: K extends keyof TStateValue ? IsNever<MatchingStateValueForStateFrom<NonNullable<TStateValue[K]>, NonNullable<TTestStateValue[K]>>> extends true ? false : true : false;

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

@@ -1,4 +1,4 @@
-import { SetupStateSchemas, StandardSchemaV1 } from "./schema.types.js";
+import { SetupStateSchemas, StandardSchemaV1, TypeSchema } from "./schema.types.js";
 import { MachineSnapshot } from "./State.js";
 import { Action, ActorTimeoutEvent, AfterEvent, ActorLogic, ActorRef, ActorRefFromLogic, ActorSelf, AnyActorLogic, AnyActorRef, Compute, DoneActorEvent, DoNotInfer, ErrorActorEvent, EventDescriptor, ErrorEvent, EventObject, EventPayloadPattern, ExtractEvent, InitialContext, InputFrom, IsNever, MetaObject, NonReducibleUnknown, OutputFrom, SingleOrArray, SnapshotEvent, StateValue, TODO, TransitionContextMapper, TransitionContextPatch, TransitionConfigFunction, Values, AnyStateNode, SystemRegistry, TimeoutEvent } from "./types.js";
 import { MachineContext, Mapper } from "./types.js";
@@ -8,7 +8,9 @@ export type InferOutput<T extends StandardSchemaV1, U> = Compute<StandardSchemaV
 /**
  * Event payloads from schemas (e.g. Zod) are often inferred as optional in
  * output types. Wrapping in Required<> ensures properties defined in the schema
- * are required on the event.
+ * are required on the event. Type-only schemas created with the `types()`
+ * helper are exempt: their declared type is authoritative, so optional
+ * properties stay optional.
  */
 export type InferEvents<TEventSchemaMap extends Record<string, StandardSchemaV1>> = Values<{
     [K in keyof TEventSchemaMap & string]: StandardSchemaV1.InferOutput<TEventSchemaMap[K]> extends infer O ? [O] extends [never] ? never : unknown extends O ? O & {
@@ -17,12 +19,17 @@ export type InferEvents<TEventSchemaMap extends Record<string, StandardSchemaV1>
         type: K;
     } : string extends keyof O ? [O[string]] extends [never] ? {
         type: K;
-    } : Required<O> & {
+    } : NormalizeEventPayload<TEventSchemaMap[K], O> & {
         type: K;
-    } : Required<O> & {
+    } : NormalizeEventPayload<TEventSchemaMap[K], O> & {
         type: K;
     } : never;
 }>;
+/**
+ * Keeps a type-only schema's payload verbatim; applies Required<> to payloads
+ * from validator libraries (see {@link InferEvents}).
+ */
+type NormalizeEventPayload<TSchema extends StandardSchemaV1, O> = TSchema extends TypeSchema<any> ? O : Required<O>;
 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;
 };

package/dist/{index-acf2bd02.development.esm.js → index-17f889df.development.esm.js}

@@ -1,4 +1,4 @@
-import { F as createInitEvent, a as XSTATE_STOP, G as createCustomEffect, f as finalizeTransitionResult, H as createEmitEffect, g as createSendToEffect, X as XSTATE_INIT, p as parseDelayToMilliseconds, j as createActor } from './createActor-164c86f5.development.esm.js';
+import { F as createInitEvent, a as XSTATE_STOP, G as createCustomEffect, f as finalizeTransitionResult, H as createEmitEffect, g as createSendToEffect, X as XSTATE_INIT, p as parseDelayToMilliseconds, j as createActor } from './createActor-2a03d4b2.development.esm.js';
 
 function assertValid(validator, request) {
   const error = validator.check(request);
@@ -973,4 +973,4 @@ function createEmptyActor() {
   return createActor(emptyLogic);
 }
 
-export { TimeoutError as T, createCallbackLogic as a, createObservableLogic as b, createEmptyActor as c, createEventObservableLogic as d, createLogic as e, createAsyncLogic as f, assertValid as g };
+export { TimeoutError as T, createCallbackLogic as a, createEmptyActor as b, createAsyncLogic as c, createEventObservableLogic as d, createLogic as e, createObservableLogic as f, assertValid as g };

package/dist/{index-13e54113.cjs.js → index-21d08fff.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var createActor = require('./createActor-fd53ec92.cjs.js');
+var createActor = require('./createActor-d5305cc9.cjs.js');
 
 function assertValid(validator, request) {
   const error = validator.check(request);

package/dist/{index-14478488.development.cjs.js → index-3d1368f7.development.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var createActor = require('./createActor-8462b9cc.development.cjs.js');
+var createActor = require('./createActor-c0f78b8a.development.cjs.js');
 
 function assertValid(validator, request) {
   const error = validator.check(request);

package/dist/{index-abf9ab72.esm.js → index-7020402e.esm.js}

@@ -1,4 +1,4 @@
-import { F as createInitEvent, a as XSTATE_STOP, G as createCustomEffect, f as finalizeTransitionResult, H as createEmitEffect, g as createSendToEffect, X as XSTATE_INIT, p as parseDelayToMilliseconds, j as createActor } from './createActor-19e83fb9.esm.js';
+import { F as createInitEvent, a as XSTATE_STOP, G as createCustomEffect, f as finalizeTransitionResult, H as createEmitEffect, g as createSendToEffect, X as XSTATE_INIT, p as parseDelayToMilliseconds, j as createActor } from './createActor-a211c276.esm.js';
 
 function assertValid(validator, request) {
   const error = validator.check(request);
@@ -973,4 +973,4 @@ function createEmptyActor() {
   return createActor(emptyLogic);
 }
 
-export { TimeoutError as T, createCallbackLogic as a, createObservableLogic as b, createEmptyActor as c, createEventObservableLogic as d, createLogic as e, createAsyncLogic as f, assertValid as g };
+export { TimeoutError as T, createCallbackLogic as a, createEmptyActor as b, createAsyncLogic as c, createEventObservableLogic as d, createLogic as e, createObservableLogic as f, assertValid as g };

package/dist/{transition-169651ca.cjs.js → transition-2dcabac8.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var createActor = require('./createActor-fd53ec92.cjs.js');
+var createActor = require('./createActor-d5305cc9.cjs.js');
 
 function attachMicrostepActorRefs(microsteps, actorScope, inputSnapshot) {
   if (!microsteps.length) {

package/dist/{transition-a306226e.development.cjs.js → transition-4ba58b71.development.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var createActor = require('./createActor-8462b9cc.development.cjs.js');
+var createActor = require('./createActor-c0f78b8a.development.cjs.js');
 
 function attachMicrostepActorRefs(microsteps, actorScope, inputSnapshot) {
   if (!microsteps.length) {

package/dist/{transition-760b0fc6.esm.js → transition-e8a13c00.esm.js}

@@ -1,4 +1,4 @@
-import { _ as createInertActorScope, $ as setInertActorScopeSnapshot, f as finalizeTransitionResult, a0 as attachSnapshotActorRef, a1 as macrostep, F as createInitEvent, aa as createSpawnEffect, ab as initialMicrostep, h as isAtomicStateNode, aj as getProperAncestors } from './createActor-19e83fb9.esm.js';
+import { _ as createInertActorScope, $ as setInertActorScopeSnapshot, f as finalizeTransitionResult, a0 as attachSnapshotActorRef, a1 as macrostep, F as createInitEvent, aa as createSpawnEffect, ab as initialMicrostep, h as isAtomicStateNode, aj as getProperAncestors } from './createActor-a211c276.esm.js';
 
 function attachMicrostepActorRefs(microsteps, actorScope, inputSnapshot) {
   if (!microsteps.length) {

package/dist/{transition-61a126e0.development.esm.js → transition-f581ffa6.development.esm.js}

@@ -1,4 +1,4 @@
-import { _ as createInertActorScope, $ as setInertActorScopeSnapshot, f as finalizeTransitionResult, a0 as attachSnapshotActorRef, a1 as macrostep, F as createInitEvent, aa as createSpawnEffect, ab as initialMicrostep, h as isAtomicStateNode, aj as getProperAncestors } from './createActor-164c86f5.development.esm.js';
+import { _ as createInertActorScope, $ as setInertActorScopeSnapshot, f as finalizeTransitionResult, a0 as attachSnapshotActorRef, a1 as macrostep, F as createInitEvent, aa as createSpawnEffect, ab as initialMicrostep, h as isAtomicStateNode, aj as getProperAncestors } from './createActor-2a03d4b2.development.esm.js';
 
 function attachMicrostepActorRefs(microsteps, actorScope, inputSnapshot) {
   if (!microsteps.length) {