effect-machine 0.17.1 → 0.19.0

package/v3/dist/machine.js

@@ -1,487 +0,0 @@
-import { __exportAll } from "./_virtual/_rolldown/runtime.js";
-import { getTag, makeDeferReply, makeReply, stubSystem } from "./internal/utils.js";
-import { ProvisionValidationError, SlotCodecError, SlotProvisionError } from "./errors.js";
-import { findTransitions, invalidateIndex, resolveTransition, runTransitionHandler, shouldPostpone } from "./internal/transition.js";
-import { emitWithTimestamp } from "./internal/inspection.js";
-import { Inspector } from "./inspection.js";
-import { MachineContextTag } from "./slot.js";
-import { ActorScope, createActor } from "./actor.js";
-import { Cause, Effect, Exit, Option, Random, Schema, Scope } from "effect";
-//#region src/machine.ts
-var machine_exports = /* @__PURE__ */ __exportAll({
-	Machine: () => Machine,
-	deferReply: () => deferReply,
-	findTransitions: () => findTransitions,
-	make: () => make,
-	materializeMachine: () => materializeMachine,
-	replay: () => replay,
-	reply: () => reply,
-	scoped: () => scoped,
-	spawn: () => spawn
-});
-const emitTaskInspection = (input) => Effect.flatMap(Effect.serviceOption(Inspector), (inspector) => Option.isNone(inspector) ? Effect.void : emitWithTimestamp(inspector.value, (timestamp) => ({
-	type: "@machine.task",
-	actorId: input.actorId,
-	state: input.state,
-	taskName: input.taskName,
-	phase: input.phase,
-	error: input.error,
-	timestamp
-})));
-/**
-* Bind slot handlers to a machine, returning a fresh copy with handlers installed.
-* If no handlers provided and machine has no slots, returns the machine as-is.
-* Validates that all required slots are provided and no extra slots are given.
-*
-* @internal — used by spawn, replay, simulate, test harness, entity-machine
-*/
-const materializeMachine = (machine, handlers) => {
-	if (handlers === void 0) {
-		if (machine._slotsSchema !== void 0 && Object.keys(machine._slotsSchema.definitions).length > 0) throw new ProvisionValidationError({
-			missing: Object.keys(machine._slotsSchema.definitions),
-			extra: []
-		});
-		return machine;
-	}
-	const requiredSlots = /* @__PURE__ */ new Set();
-	if (machine._slotsSchema !== void 0) for (const name of Object.keys(machine._slotsSchema.definitions)) requiredSlots.add(name);
-	const providedSlots = new Set(Object.keys(handlers));
-	const missing = [];
-	const extra = [];
-	for (const name of requiredSlots) if (!providedSlots.has(name)) missing.push(name);
-	for (const name of providedSlots) if (!requiredSlots.has(name)) extra.push(name);
-	if (missing.length > 0 || extra.length > 0) throw new ProvisionValidationError({
-		missing,
-		extra
-	});
-	const result = new Machine(machine.initial, machine.stateSchema, machine.eventSchema, machine._slotsSchema, machine._slotValidation);
-	result._transitions = [...machine._transitions];
-	result._finalStates = new Set(machine._finalStates);
-	result._spawnEffects = [...machine._spawnEffects];
-	result._backgroundEffects = [...machine._backgroundEffects];
-	result._postponeRules = [...machine._postponeRules];
-	result._replySchemas = machine._replySchemas;
-	if (machine._slotsSchema !== void 0) for (const name of Object.keys(machine._slotsSchema.definitions)) result._slotHandlers.set(name, handlers[name]);
-	return result;
-};
-/**
-* Machine definition with fluent builder API.
-*
-* Type parameters:
-* - `State`: The state union type
-* - `Event`: The event union type
-* - `R`: Effect requirements
-* - `_SD`: State schema definition (for compile-time validation)
-* - `_ED`: Event schema definition (for compile-time validation)
-* - `SD`: Slot definitions
-*/
-var Machine = class Machine {
-	initial;
-	/** @internal */ _transitions;
-	/** @internal */ _spawnEffects;
-	/** @internal */ _backgroundEffects;
-	/** @internal */ _finalStates;
-	/** @internal */ _postponeRules;
-	/** @internal */ _slotsSchema;
-	/** @internal */ _slotHandlers;
-	/** @internal */ _slots;
-	/** @internal */ _slotValidation;
-	stateSchema;
-	eventSchema;
-	/** @internal */ _replySchemas;
-	/**
-	* Context tag for accessing machine state/event/self in slot handlers.
-	* Uses shared module-level tag for all machines.
-	*/
-	Context = MachineContextTag;
-	get transitions() {
-		return this._transitions;
-	}
-	get spawnEffects() {
-		return this._spawnEffects;
-	}
-	get backgroundEffects() {
-		return this._backgroundEffects;
-	}
-	get finalStates() {
-		return this._finalStates;
-	}
-	get postponeRules() {
-		return this._postponeRules;
-	}
-	get slotsSchema() {
-		return this._slotsSchema;
-	}
-	get replySchemas() {
-		return this._replySchemas;
-	}
-	/** @internal */
-	constructor(initial, stateSchema, eventSchema, slotsSchema, slotValidation = true) {
-		this.initial = initial;
-		this._transitions = [];
-		this._spawnEffects = [];
-		this._backgroundEffects = [];
-		this._finalStates = /* @__PURE__ */ new Set();
-		this._postponeRules = [];
-		this._slotsSchema = slotsSchema;
-		this._replySchemas = eventSchema?._replySchemas ?? /* @__PURE__ */ new Map();
-		this._slotHandlers = /* @__PURE__ */ new Map();
-		this._slotValidation = slotValidation;
-		this.stateSchema = stateSchema;
-		this.eventSchema = eventSchema;
-		const validators = slotValidation && slotsSchema !== void 0 ? new Map(Object.entries(slotsSchema.definitions).map(([name, def]) => [name, {
-			decodeInput: Schema.decodeUnknownSync(def.inputSchema),
-			decodeOutput: Schema.decodeUnknownSync(def.outputSchema)
-		}])) : void 0;
-		const resolve = (name, params) => Effect.flatMap(Effect.serviceOption(this.Context), (maybeCtx) => {
-			if (Option.isNone(maybeCtx)) return Effect.die("MachineContext not available");
-			const handler = this._slotHandlers.get(name);
-			if (handler === void 0) return Effect.die(new SlotProvisionError({
-				slotName: name,
-				slotType: "slot"
-			}));
-			const validatedParams = validators !== void 0 ? (() => {
-				try {
-					const v = validators.get(name);
-					return v !== void 0 ? v.decodeInput(params) : params;
-				} catch (e) {
-					return Effect.die(new SlotCodecError({
-						slotName: name,
-						phase: "input",
-						message: e instanceof Error ? e.message : String(e)
-					}));
-				}
-			})() : params;
-			if (Effect.isEffect(validatedParams)) return validatedParams;
-			const result = handler(validatedParams);
-			let resultEffect;
-			if (result === void 0 || result === null) resultEffect = Effect.void;
-			else if (Effect.isEffect(result)) resultEffect = result;
-			else resultEffect = Effect.succeed(result);
-			if (validators !== void 0) {
-				const v = validators.get(name);
-				if (v !== void 0) return Effect.flatMap(resultEffect, (value) => {
-					try {
-						const decoded = v.decodeOutput(value);
-						return Effect.succeed(decoded);
-					} catch (e) {
-						return Effect.die(new SlotCodecError({
-							slotName: name,
-							phase: "output",
-							message: e instanceof Error ? e.message : String(e)
-						}));
-					}
-				});
-			}
-			return resultEffect;
-		});
-		this._slots = this._slotsSchema !== void 0 ? this._slotsSchema._createSlots(resolve) : {};
-	}
-	from(stateOrStates, build) {
-		const states = Array.isArray(stateOrStates) ? stateOrStates : [stateOrStates];
-		build(new TransitionScope(this, states));
-		return this;
-	}
-	/** @internal */
-	scopeTransition(states, event, handler, reenter) {
-		for (const state of states) this.addTransition(state, event, handler, reenter);
-		return this;
-	}
-	on(stateOrStates, event, handler) {
-		const states = Array.isArray(stateOrStates) ? stateOrStates : [stateOrStates];
-		for (const s of states) this.addTransition(s, event, handler, false);
-		return this;
-	}
-	reenter(stateOrStates, event, handler) {
-		const states = Array.isArray(stateOrStates) ? stateOrStates : [stateOrStates];
-		for (const s of states) this.addTransition(s, event, handler, true);
-		return this;
-	}
-	/**
-	* Register a wildcard transition that fires from any state when no specific transition matches.
-	* Specific `.on()` transitions always take priority over `.onAny()`.
-	*/
-	onAny(event, handler) {
-		const transition = {
-			stateTag: "*",
-			eventTag: getTag(event),
-			handler,
-			reenter: false
-		};
-		this._transitions.push(transition);
-		invalidateIndex(this);
-		return this;
-	}
-	/** @internal */
-	addTransition(state, event, handler, reenter) {
-		const transition = {
-			stateTag: getTag(state),
-			eventTag: getTag(event),
-			handler,
-			reenter
-		};
-		this._transitions.push(transition);
-		invalidateIndex(this);
-		return this;
-	}
-	spawn(stateOrStates, handler) {
-		const states = Array.isArray(stateOrStates) ? stateOrStates : [stateOrStates];
-		for (const s of states) {
-			const stateTag = getTag(s);
-			this._spawnEffects.push({
-				stateTag,
-				handler
-			});
-		}
-		invalidateIndex(this);
-		return this;
-	}
-	task(stateOrStates, run, options) {
-		const handler = Effect.fn("effect-machine.task")(function* (ctx) {
-			yield* emitTaskInspection({
-				actorId: ctx.actorId,
-				state: ctx.state,
-				taskName: options.name,
-				phase: "start"
-			});
-			const exit = yield* Effect.exit(run(ctx));
-			if (Exit.isSuccess(exit)) {
-				yield* emitTaskInspection({
-					actorId: ctx.actorId,
-					state: ctx.state,
-					taskName: options.name,
-					phase: "success"
-				});
-				const successEvent = options.onSuccess !== void 0 ? options.onSuccess(exit.value, ctx) : exit.value;
-				yield* ctx.self.send(successEvent);
-				yield* Effect.yieldNow();
-				return;
-			}
-			const cause = exit.cause;
-			if (Cause.isInterruptedOnly(cause)) {
-				yield* emitTaskInspection({
-					actorId: ctx.actorId,
-					state: ctx.state,
-					taskName: options.name,
-					phase: "interrupt"
-				});
-				return;
-			}
-			yield* emitTaskInspection({
-				actorId: ctx.actorId,
-				state: ctx.state,
-				taskName: options.name,
-				phase: "failure",
-				error: Cause.pretty(cause)
-			});
-			if (options.onFailure !== void 0) {
-				yield* ctx.self.send(options.onFailure(cause, ctx));
-				yield* Effect.yieldNow();
-				return;
-			}
-			return yield* Effect.failCause(cause).pipe(Effect.orDie);
-		});
-		return this.spawn(stateOrStates, handler);
-	}
-	/**
-	* State timeout — gen_statem's `state_timeout`.
-	*
-	* Entering the state starts a timer. Leaving cancels it (via state scope).
-	* `.reenter()` restarts the timer with fresh state values.
-	* Compiles to `.task()` internally — preserves `@machine.task` inspection events.
-	*
-	* @example
-	* ```ts
-	* machine
-	*   .timeout(State.Loading, {
-	*     duration: Duration.seconds(30),
-	*     event: Event.Timeout,
-	*   })
-	*   // Dynamic duration from state
-	*   .timeout(State.Retrying, {
-	*     duration: (state) => Duration.seconds(state.backoff),
-	*     event: Event.GiveUp,
-	*   })
-	* ```
-	*/
-	timeout(state, config) {
-		const stateTag = getTag(state);
-		const resolveDuration = typeof config.duration === "function" ? config.duration : () => config.duration;
-		const resolveEvent = typeof config.event === "function" ? config.event : () => config.event;
-		return this.task(state, (ctx) => Effect.sleep(resolveDuration(ctx.state)), {
-			onSuccess: (_, ctx) => resolveEvent(ctx.state),
-			name: `$timeout:${stateTag}`
-		});
-	}
-	/**
-	* Machine-lifetime effect that is forked on actor spawn and runs until the actor stops.
-	*
-	* @example
-	* ```ts
-	* machine.background(({ self }) =>
-	*   Effect.forever(
-	*     Effect.sleep("30 seconds").pipe(Effect.andThen(self.send(Event.Ping))),
-	*   ),
-	* );
-	* ```
-	*/
-	background(handler) {
-		this._backgroundEffects.push({ handler });
-		return this;
-	}
-	/**
-	* Postpone events — gen_statem's event postpone.
-	*
-	* When a matching event arrives in the given state, it is buffered instead of
-	* processed. After the next state transition (tag change), all buffered events
-	* are drained through the loop in FIFO order.
-	*
-	* Reply-bearing events (from `call`/`ask`) in the postpone buffer are settled
-	* with `ActorStoppedError` on stop/interrupt/final-state.
-	*
-	* @example
-	* ```ts
-	* machine
-	*   .postpone(State.Connecting, Event.Data)           // single event
-	*   .postpone(State.Connecting, [Event.Data, Event.Cmd]) // multiple events
-	* ```
-	*/
-	postpone(state, events) {
-		const stateTag = getTag(state);
-		const eventList = Array.isArray(events) ? events : [events];
-		for (const ev of eventList) {
-			const eventTag = getTag(ev);
-			this._postponeRules.push({
-				stateTag,
-				eventTag
-			});
-		}
-		return this;
-	}
-	final(state) {
-		const stateTag = getTag(state);
-		this._finalStates.add(stateTag);
-		return this;
-	}
-	static make(config) {
-		return new Machine(config.initial, config.state, config.event, config.slots, config.slotValidation ?? true);
-	}
-};
-var TransitionScope = class {
-	constructor(machine, states) {
-		this.machine = machine;
-		this.states = states;
-	}
-	on(event, handler) {
-		this.machine.scopeTransition(this.states, event, handler, false);
-		return this;
-	}
-	reenter(event, handler) {
-		this.machine.scopeTransition(this.states, event, handler, true);
-		return this;
-	}
-};
-const make = Machine.make;
-/**
-* Spawn an actor from a machine.
-*
-* For machines with slots, pass implementations via `{ slots: { ... } }`.
-*
-* @example
-* ```ts
-* // No slots
-* const actor = yield* Machine.spawn(machine);
-*
-* // With slots
-* const actor = yield* Machine.spawn(machine, {
-*   slots: { canRetry: ({ max }) => attempts < max },
-* });
-*
-* // With lifecycle (recovery + durability)
-* const actor = yield* Machine.spawn(machine, {
-*   lifecycle: {
-*     recovery: { resolve: ({ machineInitial }) => storage.get("actor-state") },
-*     durability: { save: ({ nextState }) => storage.set("actor-state", nextState) },
-*   },
-* });
-* ```
-*/
-const spawn = Effect.fn("effect-machine.spawn")(function* (machine, idOrOptions) {
-	const opts = typeof idOrOptions === "string" ? { id: idOrOptions } : idOrOptions;
-	const actor = yield* createActor(opts?.id ?? `actor-${(yield* Random.next).toString(36).slice(2)}`, materializeMachine(machine, opts?.slots), {
-		initialState: opts?.hydrate,
-		supervision: opts?.supervision,
-		lifecycle: opts?.lifecycle
-	});
-	const maybeScope = yield* Effect.serviceOption(ActorScope);
-	if (Option.isSome(maybeScope)) yield* Scope.addFinalizer(maybeScope.value, actor.stop);
-	return actor;
-});
-/**
-* Wrap an effect to provide an `ActorScope` from the current `Scope`.
-*
-* Actors spawned inside will attach cleanup finalizers to this scope,
-* so they are automatically stopped when the scope closes.
-*
-* @example
-* ```ts
-* yield* Effect.scoped(
-*   Machine.scoped(
-*     Effect.gen(function* () {
-*       const actor = yield* Machine.spawn(machine);
-*       yield* actor.start;
-*       // actor auto-stopped when scope closes
-*     }),
-*   ),
-* );
-* ```
-*/
-const scoped = (effect) => Effect.flatMap(Scope.Scope, (scope) => Effect.provideService(effect, ActorScope, scope));
-const replay = Effect.fn("effect-machine.replay")(function* (input, events, options) {
-	const machine = materializeMachine(input, options?.slots);
-	let state = options?.from ?? machine.initial;
-	const hasPostponeRules = machine.postponeRules.length > 0;
-	const postponed = [];
-	const dummySend = Effect.fn("effect-machine.replay.send")((_event) => Effect.void);
-	const self = {
-		send: dummySend,
-		cast: dummySend,
-		spawn: () => Effect.die("spawn not supported in replay"),
-		reply: () => Effect.succeed(false)
-	};
-	for (const event of events) {
-		if (machine.finalStates.has(state._tag)) break;
-		if (hasPostponeRules && shouldPostpone(machine, state._tag, event._tag)) {
-			postponed.push(event);
-			continue;
-		}
-		const transition = resolveTransition(machine, state, event);
-		if (transition !== void 0) {
-			const result = yield* runTransitionHandler(machine, transition, state, event, self, stubSystem, "replay");
-			const previousTag = state._tag;
-			state = result.newState;
-			if ((state._tag !== previousTag || transition.reenter === true) && postponed.length > 0) {
-				let drainTag = previousTag;
-				while (state._tag !== drainTag && postponed.length > 0) {
-					if (machine.finalStates.has(state._tag)) break;
-					drainTag = state._tag;
-					const drained = postponed.splice(0);
-					for (const postponedEvent of drained) {
-						if (machine.finalStates.has(state._tag)) break;
-						if (shouldPostpone(machine, state._tag, postponedEvent._tag)) {
-							postponed.push(postponedEvent);
-							continue;
-						}
-						const pTransition = resolveTransition(machine, state, postponedEvent);
-						if (pTransition !== void 0) state = (yield* runTransitionHandler(machine, pTransition, state, postponedEvent, self, stubSystem, "replay")).newState;
-					}
-				}
-			}
-		}
-	}
-	return state;
-});
-const reply = makeReply;
-const deferReply = makeDeferReply;
-//#endregion
-export { Machine, deferReply, findTransitions, machine_exports, make, materializeMachine, replay, reply, scoped, spawn };

package/v3/dist/schema.d.ts

@@ -1,174 +0,0 @@
-import { FullEventBrand, FullStateBrand, ReplyTypeBrand } from "./internal/brands.js";
-import { Schema } from "effect";
-
-//#region src/schema.d.ts
-declare const ReplySchemaSymbol: unique symbol;
-type ReplySchemaSymbol = typeof ReplySchemaSymbol;
-/**
- * Fields annotated with a reply schema.
- * Structurally identical to Schema.Struct.Fields at runtime,
- * but carries the reply schema type at compile time.
- */
-type ReplyFields<F extends Schema.Struct.Fields, RS extends Schema.Schema.Any> = F & {
-  readonly [ReplySchemaSymbol]: RS;
-};
-/**
- * Payload fields that actually flow through constructors and runtime values.
- * Reply schema metadata is type-only and must not leak into payload shapes.
- */
-type PayloadFields<F extends Schema.Struct.Fields> = { readonly [K in keyof F as K extends ReplySchemaSymbol ? never : K]: F[K] };
-/**
- * Extract the TypeScript type from a TaggedStruct schema
- */
-type TaggedStructType<Tag extends string, Fields extends Schema.Struct.Fields> = Schema.Schema.Type<Schema.TaggedStruct<Tag, PayloadFields<Fields>>>;
-/**
- * Build variant schemas type from definition
- */
-type VariantSchemas<D extends Record<string, Schema.Struct.Fields>> = { readonly [K in keyof D & string]: Schema.TaggedStruct<K, PayloadFields<D[K]>> };
-/**
- * Build union type from variant schemas.
- * Reply-bearing variants carry ReplyTypeBrand<R> for ask() inference.
- */
-type VariantsUnion<D extends Record<string, Schema.Struct.Fields>> = { [K in keyof D & string]: TaggedStructType<K, D[K]> & (D[K] extends {
-  readonly [ReplySchemaSymbol]: Schema.Schema<infer R>;
-} ? ReplyTypeBrand<R> : unknown) }[keyof D & string];
-/**
- * Check if fields are empty (no required string properties).
- * Symbol keys (like ReplySchemaSymbol) are metadata, not payload fields.
- */
-type IsEmptyFields<Fields extends Schema.Struct.Fields> = string & keyof Fields extends never ? true : false;
-/**
- * Resolve the reply brand for a variant's fields.
- * If fields carry ReplySchemaSymbol, adds ReplyTypeBrand<R>.
- */
-type VariantReplyBrand<Fields extends Schema.Struct.Fields> = Fields extends {
-  readonly [ReplySchemaSymbol]: Schema.Schema<infer R>;
-} ? ReplyTypeBrand<R> : unknown;
-/**
- * Constructor functions for each variant.
- * Empty structs: plain values with `_tag`: `State.Idle`
- * Non-empty structs require args: `State.Loading({ url })`
- *
- * Each variant also has a `with` method for constructing from a source object,
- * copying matching fields and overriding with a partial.
- * The source type uses `object` to accept branded state types without index signature issues.
- * Reply-bearing variants carry ReplyTypeBrand<R> for ask() type inference.
- */
-type VariantConstructors<D extends Record<string, Schema.Struct.Fields>, Brand> = { readonly [K in keyof D & string]: IsEmptyFields<D[K]> extends true ? TaggedStructType<K, D[K]> & Brand & VariantReplyBrand<D[K]> & {
-  readonly with: (source: object) => TaggedStructType<K, D[K]> & Brand;
-} : ((args: Schema.Struct.Type<PayloadFields<D[K]>>) => TaggedStructType<K, D[K]> & Brand & VariantReplyBrand<D[K]>) & {
-  readonly with: (source: object, partial?: Partial<Schema.Struct.Type<PayloadFields<D[K]>>>) => TaggedStructType<K, D[K]> & Brand;
-  readonly _tag: K;
-} };
-/**
- * Keys present in ALL variants (intersection of field names).
- * Used by union-level `with` to accept only fields safe to update
- * regardless of which variant the source is.
- */
-type SharedKeys<D extends Record<string, Schema.Struct.Fields>> = keyof D[keyof D & string] & string;
-/**
- * Pattern matching cases type
- */
-type MatchCases<D extends Record<string, Schema.Struct.Fields>, R> = { readonly [K in keyof D & string]: (value: TaggedStructType<K, D[K]>) => R };
-/**
- * Base schema interface with pattern matching helpers
- */
-interface MachineSchemaBase<D extends Record<string, Schema.Struct.Fields>, Brand> {
-  /**
-   * Raw definition record for introspection
-   */
-  readonly _definition: D;
-  /**
-   * Per-variant schemas for fine-grained operations
-   */
-  readonly variants: VariantSchemas<D>;
-  /**
-   * Type guard: `OrderState.$is("Pending")(value)`
-   */
-  readonly $is: <Tag extends keyof D & string>(tag: Tag) => (u: unknown) => u is TaggedStructType<Tag, D[Tag]> & Brand;
-  /**
-   * Pattern matching (curried and uncurried)
-   */
-  readonly $match: {
-    <R>(cases: MatchCases<D, R>): (value: VariantsUnion<D> & Brand) => R;
-    <R>(value: VariantsUnion<D> & Brand, cases: MatchCases<D, R>): R;
-  };
-  /**
-   * Copy fields from `source` into the same variant, overriding with `partial`.
-   * Preserves the specific variant subtype in the return.
-   *
-   * The partial accepts fields common to all variants, so it works safely
-   * when `S` is a generic type parameter (e.g., `<S extends MyState>`).
-   *
-   * @example
-   * ```ts
-   * // Per-variant field update
-   * const next = MyState.Streaming.with(state, { draft: newDraft })
-   *
-   * // Cross-variant shared field — works with generic state
-   * const updateQueue = <S extends MyState>(state: S, queue: Queue): S =>
-   *   MyState.with(state, { queue })
-   * ```
-   */
-  readonly with: <S extends VariantsUnion<D> & Brand>(source: S, partial?: Partial<Record<SharedKeys<D>, unknown>>) => S;
-  /**
-   * Reply schemas per variant tag. Only populated for event schemas
-   * with variants defined via `Event.reply()`.
-   */
-  readonly _replySchemas: ReadonlyMap<string, Schema.Schema.Any>;
-}
-/**
- * Schema-first state definition that provides:
- * - Schema for encode/decode/validate
- * - Variant constructors: `OrderState.Pending({ orderId: "x" })`
- * - Pattern matching: `$is`, `$match`
- * - Type inference: `typeof OrderState.Type`
- *
- * The D type parameter captures the definition, creating a unique brand
- * per distinct schema definition shape.
- */
-type MachineStateSchema<D extends Record<string, Schema.Struct.Fields>> = Schema.Schema<VariantsUnion<D> & FullStateBrand<D>, unknown> & MachineSchemaBase<D, FullStateBrand<D>> & VariantConstructors<D, FullStateBrand<D>> & {
-  /** Schema for persistence, config, and registration. */readonly schema: Schema.Schema<VariantsUnion<D> & FullStateBrand<D>>;
-};
-/**
- * Schema-first event definition (same structure as state, different brand)
- *
- * The D type parameter captures the definition, creating a unique brand
- * per distinct schema definition shape.
- */
-type MachineEventSchema<D extends Record<string, Schema.Struct.Fields>> = Schema.Schema<VariantsUnion<D> & FullEventBrand<D>, unknown> & MachineSchemaBase<D, FullEventBrand<D>> & VariantConstructors<D, FullEventBrand<D>>;
-/**
- * Create a schema-first State definition.
- *
- * The schema's definition type D creates a unique brand, preventing
- * accidental use of constructors from different state schemas
- * (unless they have identical definitions).
- *
- * @example
- * ```ts
- * const OrderState = MachineSchema.State({
- *   Pending: { orderId: Schema.String },
- *   Shipped: { trackingId: Schema.String },
- * })
- *
- * type OrderState = typeof OrderState.Type
- *
- * // Construct
- * const s = OrderState.Pending({ orderId: "123" })
- *
- * // Pattern match
- * OrderState.$match(s, {
- *   Pending: (v) => v.orderId,
- *   Shipped: (v) => v.trackingId,
- * })
- *
- * // Validate
- * Schema.decodeUnknownSync(OrderState)(rawJson)
- * ```
- */
-declare const State: <const D extends Record<string, Schema.Struct.Fields>>(definition: D) => MachineStateSchema<D>;
-declare const Event: (<const D extends Record<string, Schema.Struct.Fields>>(definition: D) => MachineEventSchema<D>) & {
-  reply: <F extends Schema.Struct.Fields, RS extends Schema.Schema.Any>(fields: F, replySchema: RS) => ReplyFields<F, RS>;
-};
-//#endregion
-export { Event, MachineEventSchema, MachineStateSchema, ReplyFields, ReplySchemaSymbol, State, VariantsUnion };