effect-machine 0.13.0 → 0.14.0

package/dist/machine.js

@@ -1,12 +1,12 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
-import { Inspector } from "./inspection.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 { ProvisionValidationError, SlotProvisionError } from "./errors.js";
-import { createActor } from "./actor.js";
+import { Inspector } from "./inspection.js";
 import { MachineContextTag } from "./slot.js";
-import { Cause, Effect, Exit, Option, Random, Scope } from "effect";
+import { 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,
@@ -36,22 +36,14 @@ const emitTaskInspection = (input) => Effect.flatMap(Effect.serviceOption(Inspec
 */
 const materializeMachine = (machine, handlers) => {
 	if (handlers === void 0) {
-		const hasGuards = machine._guardsSchema !== void 0 && Object.keys(machine._guardsSchema.definitions).length > 0;
-		const hasEffects = machine._effectsSchema !== void 0 && Object.keys(machine._effectsSchema.definitions).length > 0;
-		if (hasGuards || hasEffects) {
-			const missing = [];
-			if (machine._guardsSchema !== void 0) missing.push(...Object.keys(machine._guardsSchema.definitions));
-			if (machine._effectsSchema !== void 0) missing.push(...Object.keys(machine._effectsSchema.definitions));
-			throw new ProvisionValidationError({
-				missing,
-				extra: []
-			});
-		}
+		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._guardsSchema !== void 0) for (const name of Object.keys(machine._guardsSchema.definitions)) requiredSlots.add(name);
-	if (machine._effectsSchema !== void 0) for (const name of Object.keys(machine._effectsSchema.definitions)) requiredSlots.add(name);
+	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 = [];
@@ -61,15 +53,14 @@ const materializeMachine = (machine, handlers) => {
 		missing,
 		extra
 	});
-	const result = new Machine(machine.initial, machine.stateSchema, machine.eventSchema, machine._guardsSchema, machine._effectsSchema);
+	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._guardsSchema !== void 0) for (const name of Object.keys(machine._guardsSchema.definitions)) result._guardHandlers.set(name, handlers[name]);
-	if (machine._effectsSchema !== void 0) for (const name of Object.keys(machine._effectsSchema.definitions)) result._effectHandlers.set(name, handlers[name]);
+	if (machine._slotsSchema !== void 0) for (const name of Object.keys(machine._slotsSchema.definitions)) result._slotHandlers.set(name, handlers[name]);
 	return result;
 };
 /**
@@ -81,8 +72,7 @@ const materializeMachine = (machine, handlers) => {
 * - `R`: Effect requirements
 * - `_SD`: State schema definition (for compile-time validation)
 * - `_ED`: Event schema definition (for compile-time validation)
-* - `GD`: Guard definitions
-* - `EFD`: Effect definitions
+* - `SD`: Slot definitions
 */
 var Machine = class Machine {
 	initial;
@@ -91,11 +81,10 @@ var Machine = class Machine {
 	/** @internal */ _backgroundEffects;
 	/** @internal */ _finalStates;
 	/** @internal */ _postponeRules;
-	/** @internal */ _guardsSchema;
-	/** @internal */ _effectsSchema;
-	/** @internal */ _guardHandlers;
-	/** @internal */ _effectHandlers;
+	/** @internal */ _slotsSchema;
+	/** @internal */ _slotHandlers;
 	/** @internal */ _slots;
+	/** @internal */ _slotValidation;
 	stateSchema;
 	eventSchema;
 	/** @internal */ _replySchemas;
@@ -119,53 +108,73 @@ var Machine = class Machine {
 	get postponeRules() {
 		return this._postponeRules;
 	}
-	get guardsSchema() {
-		return this._guardsSchema;
-	}
-	get effectsSchema() {
-		return this._effectsSchema;
+	get slotsSchema() {
+		return this._slotsSchema;
 	}
 	get replySchemas() {
 		return this._replySchemas;
 	}
 	/** @internal */
-	constructor(initial, stateSchema, eventSchema, guardsSchema, effectsSchema) {
+	constructor(initial, stateSchema, eventSchema, slotsSchema, slotValidation = true) {
 		this.initial = initial;
 		this._transitions = [];
 		this._spawnEffects = [];
 		this._backgroundEffects = [];
 		this._finalStates = /* @__PURE__ */ new Set();
 		this._postponeRules = [];
-		this._guardsSchema = guardsSchema;
-		this._effectsSchema = effectsSchema;
+		this._slotsSchema = slotsSchema;
 		this._replySchemas = eventSchema?._replySchemas ?? /* @__PURE__ */ new Map();
-		this._guardHandlers = /* @__PURE__ */ new Map();
-		this._effectHandlers = /* @__PURE__ */ new Map();
+		this._slotHandlers = /* @__PURE__ */ new Map();
+		this._slotValidation = slotValidation;
 		this.stateSchema = stateSchema;
 		this.eventSchema = eventSchema;
-		this._slots = {
-			guards: this._guardsSchema !== void 0 ? this._guardsSchema._createSlots((name, params) => Effect.flatMap(Effect.serviceOption(this.Context), (maybeCtx) => {
-				if (Option.isNone(maybeCtx)) return Effect.die("MachineContext not available");
-				const ctx = maybeCtx.value;
-				const handler = this._guardHandlers.get(name);
-				if (handler === void 0) return Effect.die(new SlotProvisionError({
-					slotName: name,
-					slotType: "guard"
-				}));
-				const result = handler(params, ctx);
-				return typeof result === "boolean" ? Effect.succeed(result) : result;
-			})) : {},
-			effects: this._effectsSchema !== void 0 ? this._effectsSchema._createSlots((name, params) => Effect.flatMap(Effect.serviceOption(this.Context), (maybeCtx) => {
-				if (Option.isNone(maybeCtx)) return Effect.die("MachineContext not available");
-				const ctx = maybeCtx.value;
-				const handler = this._effectHandlers.get(name);
-				if (handler === void 0) return Effect.die(new SlotProvisionError({
-					slotName: name,
-					slotType: "effect"
-				}));
-				return handler(params, ctx);
-			})) : {}
-		};
+		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) {
 		build(new TransitionScope(this, Array.isArray(stateOrStates) ? stateOrStates : [stateOrStates]));
@@ -213,42 +222,19 @@ var Machine = class Machine {
 		invalidateIndex(this);
 		return this;
 	}
-	/**
-	* State-scoped effect that is forked on state entry and automatically cancelled on state exit.
-	* Use effect slots defined via `Slot.Effects` for the actual work.
-	*
-	* @example
-	* ```ts
-	* const MyEffects = Slot.Effects({
-	*   fetchData: { url: Schema.String },
-	* });
-	*
-	* machine
-	*   .spawn(State.Loading, ({ effects, state }) => effects.fetchData({ url: state.url }))
-	*   .build({
-	*     fetchData: ({ url }, { self }) =>
-	*       Effect.gen(function* () {
-	*         yield* Effect.addFinalizer(() => Effect.log("Leaving Loading"));
-	*         const data = yield* Http.get(url);
-	*         yield* self.send(Event.Loaded({ data }));
-	*       }),
-	*   });
-	* ```
-	*/
-	spawn(state, handler) {
-		const stateTag = getTag(state);
-		this._spawnEffects.push({
-			stateTag,
-			handler
-		});
+	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;
 	}
-	/**
-	* State-scoped task that runs on entry and sends success/failure events.
-	* Interrupts do not emit failure events.
-	*/
-	task(state, run, options) {
+	task(stateOrStates, run, options) {
 		const handler = Effect.fn("effect-machine.task")(function* (ctx) {
 			yield* emitTaskInspection({
 				actorId: ctx.actorId,
@@ -264,7 +250,8 @@ var Machine = class Machine {
 					taskName: options.name,
 					phase: "success"
 				});
-				yield* ctx.self.send(options.onSuccess(exit.value, ctx));
+				const successEvent = options.onSuccess !== void 0 ? options.onSuccess(exit.value, ctx) : exit.value;
+				yield* ctx.self.send(successEvent);
 				yield* Effect.yieldNow;
 				return;
 			}
@@ -292,7 +279,7 @@ var Machine = class Machine {
 			}
 			return yield* Effect.failCause(cause).pipe(Effect.orDie);
 		});
-		return this.spawn(state, handler);
+		return this.spawn(stateOrStates, handler);
 	}
 	/**
 	* State timeout — gen_statem's `state_timeout`.
@@ -326,22 +313,14 @@ var Machine = class Machine {
 	}
 	/**
 	* Machine-lifetime effect that is forked on actor spawn and runs until the actor stops.
-	* Use effect slots defined via `Slot.Effects` for the actual work.
 	*
 	* @example
 	* ```ts
-	* const MyEffects = Slot.Effects({
-	*   heartbeat: {},
-	* });
-	*
-	* machine
-	*   .background(({ effects }) => effects.heartbeat())
-	*   .build({
-	*     heartbeat: (_, { self }) =>
-	*       Effect.forever(
-	*         Effect.sleep("30 seconds").pipe(Effect.andThen(self.send(Event.Ping)))
-	*       ),
-	*   });
+	* machine.background(({ self }) =>
+	*   Effect.forever(
+	*     Effect.sleep("30 seconds").pipe(Effect.andThen(self.send(Event.Ping))),
+	*   ),
+	* );
 	* ```
 	*/
 	background(handler) {
@@ -383,7 +362,7 @@ var Machine = class Machine {
 		return this;
 	}
 	static make(config) {
-		return new Machine(config.initial, config.state, config.event, config.guards, config.effects);
+		return new Machine(config.initial, config.state, config.event, config.slots, config.slotValidation ?? true);
 	}
 };
 var TransitionScope = class {
@@ -413,18 +392,24 @@ const make = Machine.make;
 *
 * // With slots
 * const actor = yield* Machine.spawn(machine, {
-*   slots: { canRetry: ({ max }, { state }) => state.attempts < max },
+*   slots: { canRetry: ({ max }) => attempts < max },
 * });
 *
-* // With hydration
-* const actor = yield* Machine.spawn(machine, { hydrate: savedState });
+* // With persistence
+* const actor = yield* Machine.spawn(machine, {
+*   persist: {
+*     load: () => storage.get("actor-state"),
+*     save: (state) => storage.set("actor-state", state),
+*   },
+* });
 * ```
 */
 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
+		supervision: opts?.supervision,
+		persist: opts?.persist
 	});
 	const maybeScope = yield* Effect.serviceOption(Scope.Scope);
 	if (Option.isSome(maybeScope)) yield* Scope.addFinalizer(maybeScope.value, actor.stop);

package/dist/schema.d.ts

@@ -81,6 +81,20 @@ interface MachineSchemaBase<D extends Record<string, Schema.Struct.Fields>, Bran
     <R>(cases: MatchCases<D, R>): (value: VariantsUnion<D> & Brand) => R;
     <R>(value: VariantsUnion<D> & Brand, cases: MatchCases<D, R>): R;
   };
+  /**
+   * Union-level derive: copies fields from `source` into the same variant,
+   * overriding with `partial`. Preserves the specific variant subtype.
+   *
+   * Dispatches to the per-variant `derive` based on `source._tag`.
+   *
+   * @example
+   * ```ts
+   * // Instead of switching on _tag to call per-variant derive:
+   * const updated = AgentLoopState.derive(state, { queue: newQueue })
+   * // If state is StreamingState, returns StreamingState (not LoopState)
+   * ```
+   */
+  readonly derive: <S extends VariantsUnion<D> & Brand>(source: S, partial?: Partial<Omit<S, "_tag">>) => S;
   /**
    * Reply schemas per variant tag. Only populated for event schemas
    * with variants defined via `Event.reply()`.

package/dist/schema.js

@@ -67,6 +67,7 @@ const buildMachineSchema = (definition) => {
 				for (const key of fieldNames) if (key in source) result[key] = source[key];
 				if (partial !== void 0) for (const [key, value] of Object.entries(partial)) {
 					if (RESERVED_DERIVE_KEYS.has(key)) continue;
+					if (!fieldNames.has(key)) continue;
 					result[key] = value;
 				}
 				return result;
@@ -111,12 +112,20 @@ const buildMachineSchema = (definition) => {
 */
 const createMachineSchema = (definition) => {
 	const { schema, variants, constructors, _definition, replySchemas, $is, $match } = buildMachineSchema(definition);
+	const derive = (source, partial) => {
+		const ctor = constructors[source._tag];
+		if (ctor === void 0) throw new MissingMatchHandlerError({ tag: source._tag });
+		const deriveFn = ctor.derive;
+		if (deriveFn === void 0) throw new MissingMatchHandlerError({ tag: source._tag });
+		return deriveFn(source, partial);
+	};
 	return Object.assign(Object.create(schema), {
 		variants,
 		_definition,
 		_replySchemas: replySchemas,
 		$is,
 		$match,
+		derive,
 		...constructors
 	});
 };

package/dist/slot.d.ts

@@ -4,42 +4,120 @@ import { Effect, Schema, ServiceMap } from "effect";
 //#region src/slot.d.ts
 /** Schema fields definition (like Schema.Struct.Fields) */
 type Fields = Record<string, Schema.Top>;
-/** Extract the encoded type from schema fields (used for parameters) */
+/** Extract the type from schema fields (used for parameters) */
 type FieldsToParams<F extends Fields> = keyof F extends never ? void : Schema.Schema.Type<Schema.Struct<F>>;
 /**
- * A guard slot - callable function that returns Effect<boolean>.
- */
-interface GuardSlot<Name extends string, Params> {
-  readonly _tag: "GuardSlot";
-  readonly name: Name;
-  (params: Params): Effect.Effect<boolean>;
+ * Definition of a single slot function.
+ * Created via `Slot.fn(params, returnSchema?)`.
+ *
+ * Carries both type-level information and materialized schemas
+ * for runtime validation and serialization.
+ */
+interface SlotFnDef<F extends Fields = Fields, Return = void> {
+  readonly _tag: "SlotFnDef";
+  readonly fields: F;
+  /** Return schema — undefined means void */
+  readonly returnSchema: Schema.Schema<Return> | undefined;
+  /** Materialized input schema (Schema.Struct of fields, or Schema.Void for empty) */
+  readonly inputSchema: Schema.Codec<FieldsToParams<F>>;
+  /** Materialized output schema (returnSchema or Schema.Void) */
+  readonly outputSchema: Schema.Codec<Return>;
 }
 /**
- * An effect slot - callable function that returns Effect<void>.
+ * Define a single slot function with parameter schema and optional return schema.
+ *
+ * @example
+ * ```ts
+ * // Guard-like: returns boolean
+ * Slot.fn({ max: Schema.Number }, Schema.Boolean)
+ *
+ * // Effect-like: returns void (default)
+ * Slot.fn({ url: Schema.String })
+ *
+ * // No params, returns boolean
+ * Slot.fn({}, Schema.Boolean)
+ * ```
  */
-interface EffectSlot<Name extends string, Params> {
-  readonly _tag: "EffectSlot";
-  readonly name: Name;
-  (params: Params): Effect.Effect<void>;
-}
+declare const fn: {
+  <F extends Fields, Return>(fields: F, returnSchema: Schema.Schema<Return>): SlotFnDef<F, Return>;
+  <F extends Fields>(fields: F): SlotFnDef<F, void>;
+};
+/**
+ * Record of slot definitions. Keys are slot names, values are SlotFnDef.
+ */
+type SlotsDef = Record<string, SlotFnDef<Fields, unknown>>;
 /**
- * Guard definition - name to schema fields mapping
+ * Slots schema — returned by `Slot.define()`. Passed to `Machine.make({ slots })`.
  */
-type GuardsDef = Record<string, Fields>;
+interface SlotsSchema<D extends SlotsDef> {
+  readonly _tag: "SlotsSchema";
+  readonly definitions: D;
+  /** Schema for slot requests `{ _tag: "SlotRequest", name, params }`. For RPC request payloads. */
+  readonly requestSchema: Schema.Codec<SlotRequest<D>>;
+  /** Schema for slot results `{ _tag: "SlotResult", name, result }`. For RPC response payloads. */
+  readonly resultSchema: Schema.Codec<SlotResult<D>>;
+  /** Schema for slot invocations `{ _tag: "SlotInvocation", name, params, result }`. For persistence/logging. */
+  readonly invocationSchema: Schema.Codec<SlotInvocation<D>>;
+  /** Create callable slot proxies (used by Machine internally) */
+  readonly _createSlots: (resolve: <N extends keyof D & string>(name: N, params: SlotParams<D[N]>) => Effect.Effect<SlotReturn<D[N]>>) => SlotCalls<D>;
+}
 /**
- * Effect definition - name to schema fields mapping
+ * A serialized slot request — captures name and params (no result).
+ * Used for RPC request payloads.
+ */
+type SlotRequest<D extends SlotsDef> = { readonly [K in keyof D & string]: {
+  readonly _tag: "SlotRequest";
+  readonly name: K;
+  readonly params: SlotParams<D[K]>;
+} }[keyof D & string];
+/**
+ * A serialized slot result — captures name and result (no params).
+ * Used for RPC response payloads.
+ */
+type SlotResult<D extends SlotsDef> = { readonly [K in keyof D & string]: {
+  readonly _tag: "SlotResult";
+  readonly name: K;
+  readonly result: SlotReturn<D[K]>;
+} }[keyof D & string];
+/**
+ * A serialized slot invocation — captures name, params, and result.
+ * Used for persistence, logging, and audit trails.
+ */
+type SlotInvocation<D extends SlotsDef> = { readonly [K in keyof D & string]: {
+  readonly _tag: "SlotInvocation";
+  readonly name: K;
+  readonly params: SlotParams<D[K]>;
+  readonly result: SlotReturn<D[K]>;
+} }[keyof D & string];
+/** Extract params type from a SlotFnDef */
+type SlotParams<D extends SlotFnDef<Fields, unknown>> = D extends SlotFnDef<infer F, unknown> ? FieldsToParams<F> : never;
+/** Extract return type from a SlotFnDef */
+type SlotReturn<D extends SlotFnDef<Fields, unknown>> = D extends SlotFnDef<Fields, infer R> ? R : never;
+/**
+ * A callable slot — function that takes params and returns Effect<Return>.
+ */
+interface SlotCall<Name extends string, Params, Return> {
+  readonly _tag: "Slot";
+  readonly name: Name;
+  (params: Params): Effect.Effect<Return>;
+}
+/**
+ * Convert slot definitions to callable slot proxies.
  */
-type EffectsDef = Record<string, Fields>;
+type SlotCalls<D extends SlotsDef> = { readonly [K in keyof D & string]: SlotCall<K, SlotParams<D[K]>, SlotReturn<D[K]>> };
 /**
- * Convert guard definitions to callable guard slots
+ * Slot handler implementation.
+ * Receives only params — use `yield* machine.Context` for machine context.
  */
-type GuardSlots<D extends GuardsDef> = { readonly [K in keyof D & string]: GuardSlot<K, FieldsToParams<D[K]>> };
+type SlotHandler<Params, Return, R = never> = (params: Params) => Return | Effect.Effect<Return, never, R>;
 /**
- * Convert effect definitions to callable effect slots
+ * Handler implementations for all slots in a definition.
  */
-type EffectSlots<D extends EffectsDef> = { readonly [K in keyof D & string]: EffectSlot<K, FieldsToParams<D[K]>> };
+type ProvideSlots<D extends SlotsDef, R = never> = { readonly [K in keyof D & string]: SlotHandler<SlotParams<D[K]>, SlotReturn<D[K]>, R> };
+/** Check if a SlotsDef has any actual keys */
+type HasSlotKeys<SD extends SlotsDef> = [keyof SD] extends [never] ? false : SD extends Record<string, never> ? false : true;
 /**
- * Type for machine context - state, event, and self reference.
+ * Type for machine context — state, event, and self reference.
  * Shared across all machines via MachineContextTag.
  */
 interface MachineContext<State, Event, Self> {
@@ -56,76 +134,24 @@ interface MachineContext<State, Event, Self> {
  */
 declare const MachineContextTag: ServiceMap.Service<MachineContext<any, any, any>, MachineContext<any, any, any>>;
 /**
- * Guard handler implementation.
- * Receives params and context, returns Effect<boolean>.
- */
-type GuardHandler<Params, Ctx, R = never> = (params: Params, ctx: Ctx) => boolean | Effect.Effect<boolean, never, R>;
-/**
- * Effect handler implementation.
- * Receives params and context, returns Effect<void>.
- */
-type EffectHandler<Params, Ctx, R = never> = (params: Params, ctx: Ctx) => Effect.Effect<void, never, R>;
-/**
- * Handler types for all guards in a definition
- */
-type GuardHandlers<D extends GuardsDef, MachineCtx, R = never> = { readonly [K in keyof D & string]: GuardHandler<FieldsToParams<D[K]>, MachineCtx, R> };
-/**
- * Handler types for all effects in a definition
- */
-type EffectHandlers<D extends EffectsDef, MachineCtx, R = never> = { readonly [K in keyof D & string]: EffectHandler<FieldsToParams<D[K]>, MachineCtx, R> };
-/**
- * Guards schema - returned by Slot.Guards()
- */
-interface GuardsSchema<D extends GuardsDef> {
-  readonly _tag: "GuardsSchema";
-  readonly definitions: D;
-  /** Create callable guard slots (used by Machine internally) */
-  readonly _createSlots: (resolve: <N extends keyof D & string>(name: N, params: FieldsToParams<D[N]>) => Effect.Effect<boolean>) => GuardSlots<D>;
-}
-/**
- * Effects schema - returned by Slot.Effects()
- */
-interface EffectsSchema<D extends EffectsDef> {
-  readonly _tag: "EffectsSchema";
-  readonly definitions: D;
-  /** Create callable effect slots (used by Machine internally) */
-  readonly _createSlots: (resolve: <N extends keyof D & string>(name: N, params: FieldsToParams<D[N]>) => Effect.Effect<void>) => EffectSlots<D>;
-}
-/**
- * Create a guards schema with parameterized guard definitions.
- *
- * @example
- * ```ts
- * const MyGuards = Slot.Guards({
- *   canRetry: { max: Schema.Number },
- *   isValid: {},
- * })
- * ```
- */
-declare const Guards: <D extends GuardsDef>(definitions: D) => GuardsSchema<D>;
-/**
- * Create an effects schema with parameterized effect definitions.
+ * Define a set of slots with parameter and return schemas.
  *
  * @example
  * ```ts
- * const MyEffects = Slot.Effects({
- *   fetchData: { url: Schema.String },
- *   notify: { message: Schema.String },
+ * const MySlots = Slot.define({
+ *   canRetry: Slot.fn({ max: Schema.Number }, Schema.Boolean),
+ *   fetchData: Slot.fn({ url: Schema.String }),
+ *   notify: Slot.fn({ message: Schema.String }),
  * })
  * ```
  */
-declare const Effects: <D extends EffectsDef>(definitions: D) => EffectsSchema<D>;
-/** Extract guard definition type from GuardsSchema */
-type GuardsDefOf<G> = G extends GuardsSchema<infer D> ? D : never;
-/** Extract effect definition type from EffectsSchema */
-type EffectsDefOf<E> = E extends EffectsSchema<infer D> ? D : never;
-/** Extract guard slots type from GuardsSchema */
-type GuardSlotsOf<G> = G extends GuardsSchema<infer D> ? GuardSlots<D> : never;
-/** Extract effect slots type from EffectsSchema */
-type EffectSlotsOf<E> = E extends EffectsSchema<infer D> ? EffectSlots<D> : never;
+declare const define: <D extends SlotsDef>(definitions: D) => SlotsSchema<D>;
 declare const Slot: {
-  readonly Guards: <D extends GuardsDef>(definitions: D) => GuardsSchema<D>;
-  readonly Effects: <D extends EffectsDef>(definitions: D) => EffectsSchema<D>;
+  readonly fn: {
+    <F extends Fields, Return>(fields: F, returnSchema: Schema.Schema<Return>): SlotFnDef<F, Return>;
+    <F extends Fields>(fields: F): SlotFnDef<F, void>;
+  };
+  readonly define: <D extends SlotsDef>(definitions: D) => SlotsSchema<D>;
 };
 //#endregion
-export { EffectHandler, EffectHandlers, EffectSlot, EffectSlots, EffectSlotsOf, Effects, EffectsDef, EffectsDefOf, EffectsSchema, GuardHandler, GuardHandlers, GuardSlot, GuardSlots, GuardSlotsOf, Guards, GuardsDef, GuardsDefOf, GuardsSchema, MachineContext, MachineContextTag, Slot };
+export { HasSlotKeys, MachineContext, MachineContextTag, ProvideSlots, Slot, SlotCall, SlotCalls, SlotFnDef, SlotHandler, SlotInvocation, SlotRequest, SlotResult, SlotsDef, SlotsSchema, define, fn };