effect-machine 0.17.1 → 0.19.0

package/dist/machine.js

@@ -1,69 +1,46 @@
 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 { getTag, makeDeferReply, makeReply } from "./internal/utils.js";
+import { getReplySchemas } from "./schema.js";
+import { makeEventAdvancement } from "./internal/event-advancement.js";
+import { executeTransition, 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";
+import { Cause, Effect, Exit, Option, Random, 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
-})));
+const isStateResolver = (value) => typeof value === "function";
 /**
-* 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
+* `Array.isArray` widens to `any[]` and does not narrow a
+* `T | ReadonlyArray<T>` union, so the normalization below needs an explicit
+* predicate to stay cast-free.
 */
-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;
+const isReadonlyArray = (value) => Array.isArray(value);
+/** Normalize a single value or a readonly array of values into a readonly array. */
+const toReadonlyArray = (valueOrValues) => {
+	if (isReadonlyArray(valueOrValues)) return valueOrValues;
+	return [valueOrValues];
 };
+const emitTaskInspection = (input) => Effect.flatMap(Effect.serviceOption(Inspector), (inspector) => {
+	if (Option.isNone(inspector)) return Effect.void;
+	return emitWithTimestamp(inspector.value, (timestamp) => ({
+		type: "@machine.task",
+		actorId: input.actorId,
+		state: input.state,
+		taskName: input.taskName,
+		phase: input.phase,
+		error: input.error,
+		timestamp
+	}));
+});
 /**
 * Machine definition with fluent builder API.
 *
@@ -73,112 +50,31 @@ const materializeMachine = (machine, handlers) => {
 * - `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;
+	#backgroundEffects;
+	#finalStates;
+	#postponeRules;
 	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;
-	}
+	#replySchemas;
+	#transitionIndex;
+	#spawnIndex;
 	/** @internal */
-	constructor(initial, stateSchema, eventSchema, slotsSchema, slotValidation = true) {
+	constructor(initial, stateSchema, eventSchema) {
 		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.#backgroundEffects = [];
+		this.#finalStates = /* @__PURE__ */ new Set();
+		this.#postponeRules = [];
+		this.#transitionIndex = /* @__PURE__ */ new Map();
+		this.#spawnIndex = /* @__PURE__ */ new Map();
+		this.#replySchemas = getReplySchemas(eventSchema) ?? /* @__PURE__ */ new Map();
 		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];
+		const states = toReadonlyArray(stateOrStates);
 		build(new TransitionScope(this, states));
 		return this;
 	}
@@ -188,12 +84,14 @@ var Machine = class Machine {
 		return this;
 	}
 	on(stateOrStates, event, handler) {
-		const states = Array.isArray(stateOrStates) ? stateOrStates : [stateOrStates];
+		const states = toReadonlyArray(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];
+		let states;
+		if (Array.isArray(stateOrStates)) states = stateOrStates;
+		else states = [stateOrStates];
 		for (const s of states) this.addTransition(s, event, handler, true);
 		return this;
 	}
@@ -208,8 +106,7 @@ var Machine = class Machine {
 			handler,
 			reenter: false
 		};
-		this._transitions.push(transition);
-		invalidateIndex(this);
+		this.registerTransition(transition);
 		return this;
 	}
 	/** @internal */
@@ -220,22 +117,74 @@ var Machine = class Machine {
 			handler,
 			reenter
 		};
-		this._transitions.push(transition);
-		invalidateIndex(this);
+		this.registerTransition(transition);
 		return this;
 	}
 	spawn(stateOrStates, handler) {
-		const states = Array.isArray(stateOrStates) ? stateOrStates : [stateOrStates];
+		const states = toReadonlyArray(stateOrStates);
 		for (const s of states) {
 			const stateTag = getTag(s);
-			this._spawnEffects.push({
+			const spawnEffect = {
 				stateTag,
 				handler
-			});
+			};
+			const effects = this.#spawnIndex.get(stateTag) ?? [];
+			effects.push(spawnEffect);
+			this.#spawnIndex.set(stateTag, effects);
 		}
-		invalidateIndex(this);
 		return this;
 	}
+	/** @internal */
+	_findTransitions(stateTag, eventTag) {
+		const specific = this.#transitionIndex.get(stateTag)?.get(eventTag) ?? [];
+		if (specific.length > 0) return specific;
+		return this.#transitionIndex.get("*")?.get(eventTag) ?? [];
+	}
+	/** @internal */
+	_findSpawnEffects(stateTag) {
+		return this.#spawnIndex.get(stateTag) ?? [];
+	}
+	/** @internal */
+	_backgroundEffectEntries() {
+		return this.#backgroundEffects.values();
+	}
+	/** @internal */
+	_isFinal(stateTag) {
+		return this.#finalStates.has(stateTag);
+	}
+	/** @internal */
+	_shouldPostpone(stateTag, eventTag) {
+		return this.#postponeRules.some((rule) => rule.stateTag === stateTag && rule.eventTag === eventTag);
+	}
+	/** @internal */
+	_hasPostponeRules() {
+		return this.#postponeRules.length > 0;
+	}
+	/** @internal */
+	_replySchema(eventTag) {
+		return this.#replySchemas.get(eventTag);
+	}
+	/** @internal */
+	_withInitial(initial) {
+		const copy = new Machine(initial, this.stateSchema, this.eventSchema);
+		copy.#backgroundEffects.push(...this.#backgroundEffects);
+		for (const stateTag of this.#finalStates) copy.#finalStates.add(stateTag);
+		copy.#postponeRules.push(...this.#postponeRules);
+		for (const [stateTag, events] of this.#transitionIndex) {
+			const eventCopy = /* @__PURE__ */ new Map();
+			for (const [eventTag, transitions] of events) eventCopy.set(eventTag, transitions.slice());
+			copy.#transitionIndex.set(stateTag, eventCopy);
+		}
+		for (const [stateTag, effects] of this.#spawnIndex) copy.#spawnIndex.set(stateTag, effects.slice());
+		return copy;
+	}
+	registerTransition(transition) {
+		const events = this.#transitionIndex.get(transition.stateTag) ?? /* @__PURE__ */ new Map();
+		const transitions = events.get(transition.eventTag) ?? [];
+		transitions.push(transition);
+		events.set(transition.eventTag, transitions);
+		this.#transitionIndex.set(transition.stateTag, events);
+	}
 	task(stateOrStates, run, options) {
 		const handler = Effect.fn("effect-machine.task")(function* (ctx) {
 			yield* emitTaskInspection({
@@ -252,7 +201,8 @@ var Machine = class Machine {
 					taskName: options.name,
 					phase: "success"
 				});
-				const successEvent = options.onSuccess !== void 0 ? options.onSuccess(exit.value, ctx) : exit.value;
+				let successEvent = exit.value;
+				if (options.onSuccess !== void 0) successEvent = options.onSuccess(exit.value, ctx);
 				yield* ctx.self.send(successEvent);
 				yield* Effect.yieldNow;
 				return;
@@ -306,8 +256,16 @@ var Machine = class Machine {
 	*/
 	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;
+		const duration = config.duration;
+		const event = config.event;
+		const resolveDuration = (currentState) => {
+			if (isStateResolver(duration)) return duration(currentState);
+			return duration;
+		};
+		const resolveEvent = (currentState) => {
+			if (isStateResolver(event)) return event(currentState);
+			return event;
+		};
 		return this.task(state, (ctx) => Effect.sleep(resolveDuration(ctx.state)), {
 			onSuccess: (_, ctx) => resolveEvent(ctx.state),
 			name: `$timeout:${stateTag}`
@@ -326,7 +284,7 @@ var Machine = class Machine {
 	* ```
 	*/
 	background(handler) {
-		this._backgroundEffects.push({ handler });
+		this.#backgroundEffects.push({ handler });
 		return this;
 	}
 	/**
@@ -348,10 +306,10 @@ var Machine = class Machine {
 	*/
 	postpone(state, events) {
 		const stateTag = getTag(state);
-		const eventList = Array.isArray(events) ? events : [events];
+		const eventList = toReadonlyArray(events);
 		for (const ev of eventList) {
 			const eventTag = getTag(ev);
-			this._postponeRules.push({
+			this.#postponeRules.push({
 				stateTag,
 				eventTag
 			});
@@ -360,14 +318,16 @@ var Machine = class Machine {
 	}
 	final(state) {
 		const stateTag = getTag(state);
-		this._finalStates.add(stateTag);
+		this.#finalStates.add(stateTag);
 		return this;
 	}
 	static make(config) {
-		return new Machine(config.initial, config.state, config.event, config.slots, config.slotValidation ?? true);
+		return new Machine(config.initial, config.state, config.event);
 	}
 };
 var TransitionScope = class {
+	machine;
+	states;
 	constructor(machine, states) {
 		this.machine = machine;
 		this.states = states;
@@ -385,18 +345,10 @@ 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: {
@@ -407,8 +359,11 @@ const make = Machine.make;
 * ```
 */
 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), {
+	let opts;
+	if (typeof idOrOptions === "string") opts = { id: idOrOptions };
+	else opts = idOrOptions;
+	const actorId = opts?.id ?? `actor-${(yield* Random.next).toString(36).slice(2)}`;
+	const actor = yield* createActor(actorId, machine, {
 		initialState: opts?.hydrate,
 		supervision: opts?.supervision,
 		lifecycle: opts?.lifecycle
@@ -438,50 +393,27 @@ const spawn = Effect.fn("effect-machine.spawn")(function* (machine, idOrOptions)
 */
 const scoped = (effect) => Effect.flatMap(Effect.service(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 machine = input;
+	const advancement = makeEventAdvancement({
+		initial: options?.from ?? machine.initial,
+		isFinal: (state) => machine._isFinal(state._tag),
+		shouldPostpone: (state, event) => shouldPostpone(machine, state._tag, event._tag),
+		postpone: (_state, event) => Effect.succeed({
+			input: event,
+			value: void 0
+		}),
+		process: (state, event) => executeTransition(machine, state, event).pipe(Effect.map((result) => ({
+			state: result.newState,
+			transitioned: result.transitioned,
+			stateChanged: result.transitioned && (result.newState._tag !== state._tag || result.reenter),
+			shouldStop: result.transitioned && machine._isFinal(result.newState._tag),
+			value: void 0
+		})))
+	});
+	for (const event of events) yield* advancement.advance(event);
+	return advancement.state;
 });
 const reply = makeReply;
 const deferReply = makeDeferReply;
 //#endregion
-export { Machine, deferReply, findTransitions, machine_exports, make, materializeMachine, replay, reply, scoped, spawn };
+export { Machine, deferReply, machine_exports, make, replay, reply, scoped, spawn };

package/dist/schema.d.ts

@@ -1,6 +1,5 @@
 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;
@@ -16,7 +15,7 @@ type ReplyFields<F extends Schema.Struct.Fields, RS extends Schema.Schema<unknow
  * 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] };
+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
  */
@@ -24,14 +23,14 @@ type TaggedStructType<Tag extends string, Fields extends Schema.Struct.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]>> };
+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];
+} ? ReplyTypeBrand<R> : unknown); }[keyof D & string];
 /**
  * Check if fields are empty (no required string properties).
  * Symbol keys (like ReplySchemaSymbol) are metadata, not payload fields.
@@ -59,7 +58,7 @@ type VariantConstructors<D extends Record<string, Schema.Struct.Fields>, 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
@@ -69,15 +68,11 @@ type SharedKeys<D extends Record<string, Schema.Struct.Fields>> = keyof D[keyof
 /**
  * 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 };
+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
    */
@@ -111,11 +106,6 @@ interface MachineSchemaBase<D extends Record<string, Schema.Struct.Fields>, Bran
    * ```
    */
   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.Decoder<unknown>>;
 }
 /**
  * Schema-first state definition that provides:
@@ -127,9 +117,7 @@ interface MachineSchemaBase<D extends Record<string, Schema.Struct.Fields>, Bran
  * 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.Codec<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>>;
-};
+type MachineStateSchema<D extends Record<string, Schema.Struct.Fields>> = Schema.Codec<VariantsUnion<D> & FullStateBrand<D>, unknown> & MachineSchemaBase<D, FullStateBrand<D>> & VariantConstructors<D, FullStateBrand<D>>;
 /**
  * Schema-first event definition (same structure as state, different brand)
  *
@@ -146,7 +134,7 @@ type MachineEventSchema<D extends Record<string, Schema.Struct.Fields>> = Schema
  *
  * @example
  * ```ts
- * const OrderState = MachineSchema.State({
+ * const OrderState = State({
  *   Pending: { orderId: Schema.String },
  *   Shipped: { trackingId: Schema.String },
  * })
@@ -167,8 +155,41 @@ type MachineEventSchema<D extends Record<string, Schema.Struct.Fields>> = Schema
  * ```
  */
 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<unknown>>(fields: F, replySchema: RS) => ReplyFields<F, RS>;
+/**
+ * Create a schema-first Event definition.
+ *
+ * The schema's definition type D creates a unique brand, preventing
+ * accidental use of constructors from different event schemas
+ * (unless they have identical definitions).
+ *
+ * Use `Event.reply(fields, replySchema)` to define events that support
+ * typed `ask()` replies.
+ *
+ * @example
+ * ```ts
+ * const OrderEvent = Event({
+ *   Ship: { trackingId: Schema.String },
+ *   Cancel: {},
+ *   GetTotal: Event.reply({}, Schema.Number),
+ * })
+ *
+ * type OrderEvent = typeof OrderEvent.Type
+ *
+ * // Construct
+ * const e = OrderEvent.Ship({ trackingId: "abc" })
+ *
+ * // Typed ask
+ * const total = yield* actor.ask(OrderEvent.GetTotal) // number
+ * ```
+ */
+declare const EventImpl: <const D extends Record<string, Schema.Struct.Fields>>(definition: D) => MachineEventSchema<D>;
+/**
+ * Annotate event fields with a reply schema.
+ * Events defined with `Event.reply(fields, replySchema)` enable typed `ask()`.
+ */
+declare const replyFieldsFn: <F extends Schema.Struct.Fields, RS extends Schema.Schema<unknown>>(fields: F, replySchema: RS) => ReplyFields<F, RS>;
+declare const Event: typeof EventImpl & {
+  reply: typeof replyFieldsFn;
 };
 //#endregion
 export { Event, MachineEventSchema, MachineStateSchema, ReplyFields, ReplySchemaSymbol, State, VariantsUnion };