@systemfsoftware/xstate 0.0.0-stage → 6.0.0-beta.65

package/dist/actors-LxMBvgxO.mjs

@@ -0,0 +1,472 @@
+import { C as createCustomEffect, E as createSendToEffect, H as systemLogicMetadata, T as createEmitEffect, at as parseDelayToMilliseconds, gt as runStep, j as finalizeTransitionResult, r as createActor, w as createDeadLetterEffect, wt as createInitEvent } from "./createActor-BGHd7i8Q.mjs";
+import { S as XSTATE_STOP } from "./utils-CXBxxp3Z.mjs";
+// src/validation.ts
+function assertValid(validator, request) {
+	const error = validator.check(request);
+	if (error) throw error;
+}
+// src/actors/logic.ts
+const effectStates = /* @__PURE__ */ new WeakMap();
+function getEffectState(self) {
+	let state = effectStates.get(self);
+	if (!state) {
+		state = /* @__PURE__ */ new Map();
+		effectStates.set(self, state);
+	}
+	return state;
+}
+function executeLogicEffect(self, key, effect) {
+	const state = getEffectState(self);
+	if (key !== void 0 && state.has(key)) return;
+	const cleanup = effect();
+	state.set(key ?? Symbol(), { cleanup: typeof cleanup === "function" ? cleanup : void 0 });
+}
+function cleanupLogicEffects(self) {
+	const state = effectStates.get(self);
+	if (!state) return;
+	effectStates.delete(self);
+	let failure;
+	for (const { cleanup } of state.values()) try {
+		cleanup?.();
+	} catch (error) {
+		failure ??= { error };
+	}
+	if (failure) throw failure.error;
+}
+function resolveContext(context, input) {
+	return typeof context === "function" ? context({ input }) : context;
+}
+function createLogic(config) {
+	const calculateTransition = ((snapshot, event, actorScope) => {
+		if (snapshot.status !== "active") return [snapshot, []];
+		if (event.type === "@xstate.stop") return [{
+			...snapshot,
+			status: "stopped",
+			input: void 0
+		}, [createCustomEffect("xstate.logic.cleanup", () => cleanupLogicEffects(actorScope.self))]];
+		if (event.type === "xstate.logic.effect.start") return [{
+			...snapshot,
+			effects: {
+				...snapshot.effects,
+				[event.key]: { status: "active" }
+			}
+		}, []];
+		if (event.type === "xstate.logic.effect.resolve") return [{
+			...snapshot,
+			effects: {
+				...snapshot.effects,
+				[event.key]: {
+					status: "done",
+					output: event.output
+				}
+			}
+		}, []];
+		if (event.type === "xstate.logic.effect.reject") return [{
+			...snapshot,
+			effects: {
+				...snapshot.effects,
+				[event.key]: {
+					status: "error",
+					error: event.error
+				}
+			}
+		}, []];
+		const effects = [];
+		const trackedEffects = Object.create(null);
+		const enqueueEffect = (key, exec) => {
+			const recorded = snapshot.effects && Object.prototype.hasOwnProperty.call(snapshot.effects, key) ? snapshot.effects[key] : void 0;
+			if (recorded && !(event.type === "@xstate.init" && recorded.status === "active")) return;
+			effects.push(createCustomEffect("xstate.logic.effect", (runtime = actorScope.self.system) => executeLogicEffect(actorScope.self, key, () => exec(runtime)), { key }));
+			trackedEffects[key] = { status: "active" };
+		};
+		const patch = config.run({
+			context: snapshot.context,
+			event,
+			input: snapshot.input,
+			system: actorScope.system,
+			self: actorScope.self,
+			emit: actorScope.emit
+		}, {
+			emit: (emitted) => {
+				effects.push(createEmitEffect(actorScope, emitted));
+			},
+			sendBack: (sentEvent) => {
+				const parent = actorScope.self._parent;
+				if (parent) effects.push(createSendToEffect(actorScope, parent, sentEvent));
+			},
+			raise: (raisedEvent) => {
+				effects.push(createSendToEffect(actorScope, actorScope.self, raisedEvent));
+			},
+			effect: ((keyOrExec, maybeExec) => {
+				if (typeof keyOrExec === "string") {
+					enqueueEffect(keyOrExec, maybeExec);
+					return;
+				}
+				const exec = keyOrExec;
+				effects.push(createCustomEffect("xstate.logic.effect", (runtime = actorScope.self.system) => executeLogicEffect(actorScope.self, void 0, () => exec(runtime))));
+			})
+		});
+		const nextSnapshot = {
+			...snapshot,
+			...patch || {}
+		};
+		if ("context" in snapshot || patch?.context !== void 0) nextSnapshot.context = patch?.context ?? snapshot.context;
+		if (patch?.effects || Object.keys(trackedEffects).length) nextSnapshot.effects = {
+			...snapshot.effects,
+			...patch?.effects,
+			...trackedEffects
+		};
+		return finalizeTransitionResult(actorScope, snapshot, [nextSnapshot, effects]);
+	});
+	const transition = ((snapshot, event, actorScope) => {
+		if (config.validator) {
+			const sourceRef = actorScope.self._lastSourceRef;
+			const eventOrigin = sourceRef ? "actor" : "external";
+			const error = config.validator.check({
+				kind: "event",
+				logic,
+				event,
+				eventOrigin
+			});
+			if (error) return [snapshot, [createDeadLetterEffect(actorScope, sourceRef, event, "invalidEvent", {
+				issues: error.issues,
+				error
+			})]];
+		}
+		const result = calculateTransition(snapshot, event, actorScope);
+		if (config.validator) assertValid(config.validator, {
+			kind: "result",
+			logic,
+			snapshot: result[0],
+			effects: result[1]
+		});
+		return result;
+	});
+	const logic = {
+		id: config.id,
+		config,
+		validator: config.validator,
+		transition,
+		start: (snapshot, actorScope, options) => {
+			if (!options?.restored) return;
+			const [nextSnapshot, effects] = transition(snapshot, createInitEvent(snapshot.input), actorScope);
+			Object.assign(snapshot, nextSnapshot);
+			for (const effect of effects) actorScope.actionExecutor(effect);
+		},
+		initialTransition: (input, actorScope) => {
+			if (config.validator) assertValid(config.validator, {
+				kind: "input",
+				logic,
+				input
+			});
+			const context = resolveContext(config.context, input);
+			const snapshot = {
+				status: "active",
+				output: void 0,
+				error: void 0,
+				input
+			};
+			if (context !== void 0) snapshot.context = context;
+			return transition({ ...snapshot }, createInitEvent(input), actorScope);
+		},
+		getInitialSnapshot: (actorScope, input) => logic.initialTransition(input, actorScope)[0],
+		getPersistedSnapshot: (snapshot) => snapshot,
+		restoreSnapshot: (snapshot) => snapshot
+	};
+	return logic;
+}
+// src/actors/callback.ts
+const instanceStates = /* #__PURE__ */ new WeakMap();
+function createCallbackLogic(callbackOrConfig) {
+	const callback = typeof callbackOrConfig === "function" ? callbackOrConfig : callbackOrConfig.run;
+	const schemas = typeof callbackOrConfig === "function" ? void 0 : callbackOrConfig.schemas;
+	return createLogic({
+		validator: typeof callbackOrConfig === "function" ? void 0 : callbackOrConfig.validator,
+		schemas,
+		context: void 0,
+		run: (args, enq) => {
+			const { event, input, self, system } = args;
+			const emit = args.emit;
+			instanceStates.get(self)?.receivers?.forEach((receiver) => receiver(event));
+			enq.effect("callback", () => {
+				const callbackState = {
+					receivers: void 0,
+					dispose: void 0
+				};
+				instanceStates.set(self, callbackState);
+				callbackState.dispose = callback({
+					input,
+					system,
+					self,
+					sendBack: (event) => {
+						if (self.getSnapshot().status === "stopped") return;
+						const parent = self._parent;
+						if (parent) system._relay(self, parent, event);
+					},
+					receive: (listener) => {
+						callbackState.receivers ??= /* @__PURE__ */ new Set();
+						callbackState.receivers.add(listener);
+					},
+					emit
+				});
+				return () => {
+					instanceStates.delete(self);
+					callbackState.receivers?.clear();
+					callbackState.dispose?.();
+				};
+			});
+		}
+	});
+}
+// src/actors/observable.ts
+const XSTATE_OBSERVABLE_NEXT = "xstate.observable.next";
+const XSTATE_OBSERVABLE_ERROR = "xstate.observable.error";
+const XSTATE_OBSERVABLE_COMPLETE = "xstate.observable.complete";
+function createObservableLogic(observableCreatorOrConfig) {
+	const observableCreator = typeof observableCreatorOrConfig === "function" ? observableCreatorOrConfig : observableCreatorOrConfig.run;
+	const schemas = typeof observableCreatorOrConfig === "function" ? void 0 : observableCreatorOrConfig.schemas;
+	return createLogic({
+		validator: typeof observableCreatorOrConfig === "function" ? void 0 : observableCreatorOrConfig.validator,
+		schemas,
+		context: void 0,
+		run: (args, enq) => {
+			const { event, input, self, system } = args;
+			switch (event.type) {
+				case XSTATE_OBSERVABLE_NEXT: return { context: event["data"] };
+				case XSTATE_OBSERVABLE_ERROR: return {
+					status: "error",
+					error: event.data,
+					input: void 0,
+					effects: { observable: {
+						status: "error",
+						error: event.data
+					} }
+				};
+				case XSTATE_OBSERVABLE_COMPLETE: return {
+					status: "done",
+					input: void 0,
+					effects: { observable: { status: "done" } }
+				};
+			}
+			if (event.type !== "@xstate.init") return;
+			enq.effect((runtime = system) => {
+				const actorSelf = self;
+				const sendSelf = (event) => void runtime.sendEvent(actorSelf, actorSelf, event);
+				const subscription = observableCreator({
+					input,
+					system,
+					self,
+					emit: ((event) => void runtime.emitEvent(actorSelf, event))
+				}).subscribe({
+					next: (value) => {
+						sendSelf({
+							type: XSTATE_OBSERVABLE_NEXT,
+							data: value
+						});
+					},
+					error: (err) => {
+						sendSelf({
+							type: XSTATE_OBSERVABLE_ERROR,
+							data: err
+						});
+					},
+					complete: () => {
+						sendSelf({ type: XSTATE_OBSERVABLE_COMPLETE });
+					}
+				});
+				return () => subscription.unsubscribe();
+			});
+		}
+	});
+}
+function createEventObservableLogic(lazyObservableOrConfig) {
+	const lazyObservable = typeof lazyObservableOrConfig === "function" ? lazyObservableOrConfig : lazyObservableOrConfig.run;
+	const validator = typeof lazyObservableOrConfig === "function" ? void 0 : lazyObservableOrConfig.validator;
+	const logic = {
+		config: lazyObservableOrConfig,
+		validator,
+		transition: (state, event, actorScope) => {
+			if (state.status !== "active") return [state, []];
+			switch (event.type) {
+				case XSTATE_OBSERVABLE_ERROR: return finalizeTransitionResult(actorScope, state, [{
+					...state,
+					status: "error",
+					error: event.data,
+					input: void 0,
+					_subscription: void 0
+				}, []]);
+				case XSTATE_OBSERVABLE_COMPLETE: return finalizeTransitionResult(actorScope, state, [{
+					...state,
+					status: "done",
+					input: void 0,
+					_subscription: void 0
+				}, []]);
+				case XSTATE_STOP:
+					state._subscription.unsubscribe();
+					return [{
+						...state,
+						status: "stopped",
+						input: void 0,
+						_subscription: void 0
+					}, []];
+				default: return [state, []];
+			}
+		},
+		initialTransition: (input, _) => {
+			if (validator) assertValid(validator, {
+				kind: "input",
+				logic,
+				input
+			});
+			return [{
+				status: "active",
+				output: void 0,
+				error: void 0,
+				context: void 0,
+				input,
+				_subscription: void 0
+			}, []];
+		},
+		getInitialSnapshot: (actorScope, input) => logic.initialTransition(input, actorScope)[0],
+		start: (state, { self, system, emit }) => {
+			if (state.status === "done") return;
+			state._subscription = lazyObservable({
+				input: state.input,
+				system,
+				self,
+				emit: (event) => {
+					emit(event);
+				}
+			}).subscribe({
+				next: (value) => {
+					if (self._parent) system._relay(self, self._parent, value);
+				},
+				error: (err) => {
+					system._relay(self, self, {
+						type: XSTATE_OBSERVABLE_ERROR,
+						data: err
+					});
+				},
+				complete: () => {
+					system._relay(self, self, { type: XSTATE_OBSERVABLE_COMPLETE });
+				}
+			});
+		},
+		getPersistedSnapshot: ({ _subscription, ...snapshot }) => snapshot,
+		restoreSnapshot: (snapshot) => ({
+			...snapshot,
+			_subscription: void 0
+		})
+	};
+	return logic;
+}
+// src/actors/promise.ts
+const XSTATE_ASYNC_RESOLVE = "xstate.async.resolve";
+const XSTATE_ASYNC_REJECT = "xstate.async.reject";
+/** @public */
+var TimeoutError = class extends Error {
+	constructor(timeout) {
+		super(`Async logic timed out after ${timeout}.`);
+		this.name = "TimeoutError";
+	}
+};
+function createAsyncLogic(asyncLogic) {
+	const config = asyncLogic;
+	const logic = createLogic({
+		id: config.id,
+		validator: config.validator,
+		schemas: config.schemas,
+		context: void 0,
+		run: ({ event, input, self, system }, enq) => {
+			switch (event.type) {
+				case XSTATE_ASYNC_RESOLVE: {
+					const resolvedValue = event.data ?? event.output;
+					return {
+						status: "done",
+						output: resolvedValue,
+						input: void 0,
+						effects: { async: {
+							status: "done",
+							output: resolvedValue
+						} }
+					};
+				}
+				case XSTATE_ASYNC_REJECT: {
+					const error = event.data ?? event.error;
+					return {
+						status: "error",
+						error,
+						input: void 0,
+						effects: { async: {
+							status: "error",
+							error
+						} }
+					};
+				}
+			}
+			if (event.type !== "@xstate.init") return;
+			enq.effect((runtime = system) => {
+				const actorSelf = self;
+				const sendSelf = (event) => void runtime.sendEvent(actorSelf, actorSelf, event);
+				const controller = new AbortController();
+				const timeout = config.timeout;
+				const timeoutMs = parseDelayToMilliseconds(timeout);
+				const timeoutId = timeoutMs === void 0 ? void 0 : system._clock.setTimeout(() => {
+					if (self.getSnapshot().status !== "active") return;
+					controller.abort();
+					sendSelf({
+						type: XSTATE_ASYNC_REJECT,
+						data: new TimeoutError(timeout)
+					});
+				}, timeoutMs);
+				const clearTimeout = () => {
+					if (timeoutId !== void 0) system._clock.clearTimeout(timeoutId);
+				};
+				const runBody = () => Promise.resolve(config.run({
+					input,
+					system,
+					self,
+					signal: controller.signal
+				}, {
+					emit: (event) => void runtime.emitEvent(actorSelf, event),
+					step: (key, exec) => runtime.runStep ? Promise.resolve(runtime.runStep(actorSelf, key, exec)) : runStep(actorSelf, key, exec, sendSelf)
+				}));
+				(runtime.runLogic ? Promise.resolve(runtime.runLogic(actorSelf, runBody)) : runBody()).then((response) => {
+					clearTimeout();
+					if (self.getSnapshot().status !== "active") return;
+					sendSelf({
+						type: XSTATE_ASYNC_RESOLVE,
+						data: response
+					});
+				}, (errorData) => {
+					clearTimeout();
+					if (self.getSnapshot().status !== "active") return;
+					sendSelf({
+						type: XSTATE_ASYNC_REJECT,
+						data: errorData
+					});
+				});
+				return () => {
+					controller.abort();
+					clearTimeout();
+				};
+			});
+			return { effects: { async: { status: "active" } } };
+		}
+	});
+	Object.defineProperty(logic, systemLogicMetadata, { value: {
+		kind: "async",
+		timeout: config.timeout
+	} });
+	return logic;
+}
+// src/actors/index.ts
+const emptyLogic = /* #__PURE__ */ createLogic({
+	context: void 0,
+	run: () => void 0
+});
+/** @public */
+function createEmptyActor() {
+	return createActor(emptyLogic);
+}
+export { createObservableLogic as a, assertValid as c, createEventObservableLogic as i, TimeoutError as n, createCallbackLogic as o, createAsyncLogic as r, createLogic as s, createEmptyActor as t };

package/dist/actors.d.ts

@@ -0,0 +1,3 @@
+import { Cr as LogicArgs, Dr as TimeoutError, Er as LogicFunction, Or as createAsyncLogic, Sr as AsyncSnapshot, Tr as LogicEnqueue, br as AsyncActorLogic, wr as LogicConfig, xr as AsyncActorRef } from "./types-B2EAwOk-.js";
+import { A as LogicActorLogic, B as createLogic, C as listenerLogic, D as CallbackLogicFunction, E as CallbackLogicConfig, F as LogicEffectState, I as LogicEnqueue$1, L as LogicFunction$1, M as LogicArgs$1, N as LogicConfig$1, O as CallbackSnapshot, P as LogicEffect, R as LogicPatch, S as createListenerLogic, T as CallbackActorRef, _ as createObservableLogic, a as SubscriptionMappers, b as ListenerInput, c as subscriptionLogic, d as ObservableActorLogic, f as ObservableActorRef, g as createEventObservableLogic, h as ObservableSnapshot, i as SubscriptionInput, j as LogicActorRef, k as createCallbackLogic, l as EventObservableLogicConfig, m as ObservableLogicFunction, n as SubscriptionActorLogic, o as SubscriptionSnapshot, p as ObservableLogicConfig, r as SubscriptionActorRef, s as createSubscriptionLogic, t as createEmptyActor, u as EventObservableLogicFunction, v as ListenerActorLogic, w as CallbackActorLogic, x as ListenerSnapshot, y as ListenerActorRef, z as LogicSnapshot } from "./index-DDWoKIF5.js";
+export { type AsyncActorLogic, type AsyncActorRef, type LogicArgs as AsyncLogicArgs, type LogicConfig as AsyncLogicConfig, type LogicEnqueue as AsyncLogicEnqueue, type LogicFunction as 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$1 as LogicArgs, type LogicConfig$1 as LogicConfig, type LogicEffect, type LogicEffectState, type LogicEnqueue$1 as LogicEnqueue, type LogicFunction$1 as 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, TimeoutError, createAsyncLogic, createCallbackLogic, createEmptyActor, createEventObservableLogic, createListenerLogic, createLogic, createObservableLogic, createSubscriptionLogic, listenerLogic, subscriptionLogic };

package/dist/actors.mjs

@@ -0,0 +1,3 @@
+import { B as createListenerLogic, R as createSubscriptionLogic, V as listenerLogic, z as subscriptionLogic } from "./createActor-BGHd7i8Q.mjs";
+import { a as createObservableLogic, i as createEventObservableLogic, n as TimeoutError, o as createCallbackLogic, r as createAsyncLogic, s as createLogic, t as createEmptyActor } from "./actors-LxMBvgxO.mjs";
+export { TimeoutError, createAsyncLogic, createCallbackLogic, createEmptyActor, createEventObservableLogic, createListenerLogic, createLogic, createObservableLogic, createSubscriptionLogic, listenerLogic, subscriptionLogic };

package/dist/base.types-DF8ZPiXj.d.ts

@@ -0,0 +1,210 @@
+/**
+ * The Standard Schema interface.
+ *
+ * @public
+ */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly '~standard': StandardSchemaV1.Props<Input, Output>;
+}
+/**
+ * Schemas that can be declared for an individual state node.
+ *
+ * @public
+ */
+type SetupStateSchemas = {
+  /** Refines the machine's root context schema while this state is active. */
+  context?: StandardSchemaV1 | undefined;
+  input?: StandardSchemaV1 | undefined;
+  /** The output emitted when this state node completes. */
+  output?: StandardSchemaV1 | undefined;
+};
+/**
+ * A type-only Standard Schema produced by {@link types}.
+ *
+ * @public
+ */
+interface TypeSchema<T> extends StandardSchemaV1<T, T> {
+  readonly '~standard': StandardSchemaV1.Props<T, T> & {
+    readonly vendor: 'xstate.types';
+  };
+}
+/**
+ * Declares schema types for inference only — no runtime validation.
+ *
+ * Use in a machine's `schemas` when you want TypeScript types without pulling
+ * in a schema library like Zod. The returned value is a valid Standard Schema
+ * whose validation is the identity function, so it carries types but never
+ * rejects input.
+ *
+ * @example
+ *
+ * ```ts
+ * import { createMachine, types } from '@systemfsoftware/xstate';
+ *
+ * const machine = createMachine({
+ *   schemas: {
+ *     context: types<{ count: number }>(),
+ *     events: {
+ *       inc: types<{ by: number }>(),
+ *       reset: types<void>()
+ *     }
+ *   },
+ *   context: { count: 0 }
+ *   // ...
+ * });
+ * ```
+ *
+ * Use `types<void>()` for events without a payload.
+ * @public
+ */
+declare function types<T>(): TypeSchema<T>;
+/**
+ * Returns true if the value is a type-only schema created by {@link types}.
+ *
+ * @public
+ */
+declare function isTypeSchema(value: unknown): value is TypeSchema<unknown>;
+declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /** The result interface of the validate function. */
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+  /** The result interface if validation succeeds. */
+  interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** The non-existent issues. */
+    readonly issues?: undefined;
+  }
+  /** The result interface if validation fails. */
+  interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /** The issue interface of the failure output. */
+  interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /** The path segment interface of the issue. */
+  interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+  /** The Standard Schema types interface. */
+  interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+  /** Infers the input type of a Standard Schema. */
+  type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['input'];
+  /** Infers the output type of a Standard Schema. */
+  type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['output'];
+}
+declare global {
+  interface SymbolConstructor {
+    readonly observable: symbol;
+  }
+}
+/**
+ * The full definition of an event, with a string `type`.
+ *
+ * @public
+ */
+type EventObject = {
+  /** The type of event that is sent. */
+  type: string;
+};
+/** @public */
+type MachineContext = Record<string, any>;
+/** @public */
+type Values<T> = T[keyof T];
+type ActionSchemas = Record<string, {
+  params: StandardSchemaV1;
+}>;
+type GuardSchemas = Record<string, {
+  params: StandardSchemaV1;
+}>;
+/**
+ * State node types that can be declared in a setup state contract.
+ *
+ * @public
+ */
+type SetupStateType = 'atomic' | 'compound' | 'parallel' | 'final' | 'history' | 'choice';
+/** @public */
+type SetupSchemas = {
+  context?: StandardSchemaV1 | undefined;
+  events?: Record<string, StandardSchemaV1> | undefined;
+  internalEvents?: Record<string, StandardSchemaV1> | undefined;
+  actions?: ActionSchemas | undefined;
+  guards?: GuardSchemas | undefined;
+  emitted?: Record<string, StandardSchemaV1> | undefined;
+  input?: StandardSchemaV1 | undefined;
+  output?: StandardSchemaV1 | undefined;
+  meta?: StandardSchemaV1 | undefined;
+  transitionMeta?: StandardSchemaV1 | undefined;
+  tags?: StandardSchemaV1 | undefined;
+  children?: Record<string, StandardSchemaV1> | undefined;
+};
+/**
+ * State schema with optional input/output schemas, structural metadata, and
+ * nested states.
+ *
+ * Structural fields are contracts/defaults for `createMachine(...)`; machine
+ * behavior remains authored in the machine config.
+ *
+ * @public
+ */
+interface SetupStateSchema {
+  type?: SetupStateType | undefined;
+  id?: string | undefined;
+  initial?: string | undefined;
+  history?: 'shallow' | 'deep' | true | undefined;
+  target?: string | readonly [string, ...string[]] | undefined;
+  route?: true | undefined;
+  schemas?: SetupStateSchemas | undefined;
+  states?: Record<string, SetupStateSchema> | undefined;
+}
+/**
+ * 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. Type-only schemas created with the `types()`
+ * helper are exempt: their declared type is authoritative, so optional
+ * properties stay optional.
+ *
+ * @public
+ */
+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 & {
+  type: K;
+} : [O] extends [void] ? {
+  type: K;
+} : string extends keyof O ? [O[string]] extends [never] ? {
+  type: EventTypeFromSchemaKey<K>;
+} : NormalizeEventPayload<TEventSchemaMap[K], O> & {
+  type: EventTypeFromSchemaKey<K>;
+} : NormalizeEventPayload<TEventSchemaMap[K], O> & {
+  type: EventTypeFromSchemaKey<K>;
+} : never; }>;
+/** Infers internal events only from explicitly declared schema keys. */
+type InferInternalEvents<TEventSchemaMap extends Record<string, StandardSchemaV1>> = string extends keyof TEventSchemaMap ? never : InferEvents<TEventSchemaMap>;
+type EventTypeFromSchemaKey<TKey extends string> = TKey extends '*' ? string : TKey extends `${infer TLeading}.*` ? `${TLeading}.${string}` : TKey;
+/**
+ * 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 { InferInternalEvents as a, SetupStateSchema as c, SetupStateSchemas as d, StandardSchemaV1 as f, types as h, InferEvents as i, SetupStateType as l, isTypeSchema as m, EventObject as n, MachineContext as o, TypeSchema as p, GuardSchemas as r, SetupSchemas as s, ActionSchemas as t, Values as u };