effect-machine 0.3.1 → 0.4.0

package/{src/persistence/persistent-machine.ts → dist/persistence/persistent-machine.d.ts}

@@ -1,13 +1,14 @@
-import type { Schema, Schedule } from "effect";
-
-import type { Machine } from "../machine.js";
-import type { StateBrand, EventBrand } from "../internal/brands.js";
-import { MissingSchemaError } from "../errors.js";
-
-// Branded type constraints
-type BrandedState = { readonly _tag: string } & StateBrand;
-type BrandedEvent = { readonly _tag: string } & EventBrand;
+import { EventBrand, StateBrand } from "../internal/brands.js";
+import { Machine } from "../machine.js";
+import { Schedule, Schema } from "effect";
 
+//#region src/persistence/persistent-machine.d.ts
+type BrandedState = {
+  readonly _tag: string;
+} & StateBrand;
+type BrandedEvent = {
+  readonly _tag: string;
+} & EventBrand;
 /**
  * Configuration for persistence behavior (after resolution).
  * Schemas are required at runtime - the persist function ensures this.
@@ -15,7 +16,7 @@ type BrandedEvent = { readonly _tag: string } & EventBrand;
  * Note: Schema types S and E should match the structural shape of the machine's
  * state and event types (without brands). The schemas don't know about brands.
  */
-export interface PersistenceConfig<S, E, SSI = unknown, ESI = unknown> {
+interface PersistenceConfig<S, E, SSI = unknown, ESI = unknown> {
   /**
    * Schedule controlling when snapshots are taken.
    * Input is the new state after each transition.
@@ -26,25 +27,21 @@ export interface PersistenceConfig<S, E, SSI = unknown, ESI = unknown> {
    * - Schedule.recurs(100) — every N transitions
    */
   readonly snapshotSchedule: Schedule.Schedule<unknown, S>;
-
   /**
    * Whether to journal events for replay capability.
    * When true, all events are appended to the event log.
    */
   readonly journalEvents: boolean;
-
   /**
    * Schema for serializing/deserializing state.
    * Always present at runtime (resolved from config or machine).
    */
   readonly stateSchema: Schema.Schema<S, SSI, never>;
-
   /**
    * Schema for serializing/deserializing events.
    * Always present at runtime (resolved from config or machine).
    */
   readonly eventSchema: Schema.Schema<E, ESI, never>;
-
   /**
    * User-provided identifier for the machine type.
    * Used for filtering actors in restoreAll.
@@ -52,32 +49,27 @@ export interface PersistenceConfig<S, E, SSI = unknown, ESI = unknown> {
    */
   readonly machineType?: string;
 }
-
 /**
  * Machine with persistence configuration attached.
  * Spawn auto-detects this and returns PersistentActorRef.
  */
-export interface PersistentMachine<
-  S extends { readonly _tag: string },
-  E extends { readonly _tag: string },
-  R = never,
-> {
+interface PersistentMachine<S extends {
+  readonly _tag: string;
+}, E extends {
+  readonly _tag: string;
+}, R = never> {
   readonly _tag: "PersistentMachine";
   readonly machine: Machine<S, E, R>;
   readonly persistence: PersistenceConfig<S, E>;
 }
-
 /**
  * Type guard to check if a value is a PersistentMachine
  */
-export const isPersistentMachine = (
-  value: unknown,
-): value is PersistentMachine<{ readonly _tag: string }, { readonly _tag: string }, unknown> =>
-  typeof value === "object" &&
-  value !== null &&
-  "_tag" in value &&
-  (value as { _tag: unknown })._tag === "PersistentMachine";
-
+declare const isPersistentMachine: (value: unknown) => value is PersistentMachine<{
+  readonly _tag: string;
+}, {
+  readonly _tag: string;
+}, unknown>;
 /**
  * Attach persistence configuration to a machine.
  *
@@ -101,31 +93,13 @@ export const isPersistentMachine = (
  * );
  * ```
  */
-export interface WithPersistenceConfig {
-  readonly snapshotSchedule: Schedule.Schedule<unknown, { readonly _tag: string }>;
+interface WithPersistenceConfig {
+  readonly snapshotSchedule: Schedule.Schedule<unknown, {
+    readonly _tag: string;
+  }>;
   readonly journalEvents: boolean;
   readonly machineType?: string;
 }
-
-export const persist =
-  (config: WithPersistenceConfig) =>
-  <S extends BrandedState, E extends BrandedEvent, R>(
-    machine: Machine<S, E, R>,
-  ): PersistentMachine<S, E, R> => {
-    const stateSchema = machine.stateSchema;
-    const eventSchema = machine.eventSchema;
-
-    if (stateSchema === undefined || eventSchema === undefined) {
-      throw new MissingSchemaError({ operation: "persist" });
-    }
-
-    return {
-      _tag: "PersistentMachine",
-      machine,
-      persistence: {
-        ...config,
-        stateSchema,
-        eventSchema,
-      } as unknown as PersistenceConfig<S, E>,
-    };
-  };
+declare const persist: (config: WithPersistenceConfig) => <S extends BrandedState, E extends BrandedEvent, R>(machine: Machine<S, E, R>) => PersistentMachine<S, E, R>;
+//#endregion
+export { PersistenceConfig, PersistentMachine, WithPersistenceConfig, isPersistentMachine, persist };

package/dist/persistence/persistent-machine.js

@@ -0,0 +1,24 @@
+import { MissingSchemaError } from "../errors.js";
+
+//#region src/persistence/persistent-machine.ts
+/**
+* Type guard to check if a value is a PersistentMachine
+*/
+const isPersistentMachine = (value) => typeof value === "object" && value !== null && "_tag" in value && value._tag === "PersistentMachine";
+const persist = (config) => (machine) => {
+	const stateSchema = machine.stateSchema;
+	const eventSchema = machine.eventSchema;
+	if (stateSchema === void 0 || eventSchema === void 0) throw new MissingSchemaError({ operation: "persist" });
+	return {
+		_tag: "PersistentMachine",
+		machine,
+		persistence: {
+			...config,
+			stateSchema,
+			eventSchema
+		}
+	};
+};
+
+//#endregion
+export { isPersistentMachine, persist };

package/dist/schema.d.ts

@@ -0,0 +1,141 @@
+import { FullEventBrand, FullStateBrand } from "./internal/brands.js";
+import { Schema } from "effect";
+
+//#region src/schema.d.ts
+/**
+ * Extract the TypeScript type from a TaggedStruct schema
+ */
+type TaggedStructType<Tag extends string, Fields extends Schema.Struct.Fields> = Schema.Schema.Type<Schema.TaggedStruct<Tag, 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, D[K]> };
+/**
+ * Build union type from variant schemas.
+ * Used for constraining fluent method type params.
+ */
+type VariantsUnion<D extends Record<string, Schema.Struct.Fields>> = { [K in keyof D & string]: TaggedStructType<K, D[K]> }[keyof D & string];
+/**
+ * Check if fields are empty (no required properties)
+ */
+type IsEmptyFields<Fields extends Schema.Struct.Fields> = keyof Fields extends never ? true : false;
+/**
+ * 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 `derive` method for constructing from a source object.
+ */
+/**
+ * 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 `derive` method for constructing from a source object.
+ * The source type uses `object` to accept branded state types without index signature issues.
+ */
+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 & {
+  readonly derive: (source: object) => TaggedStructType<K, D[K]> & Brand;
+} : ((args: Schema.Struct.Constructor<D[K]>) => TaggedStructType<K, D[K]> & Brand) & {
+  readonly derive: (source: object, partial?: Partial<Schema.Struct.Constructor<D[K]>>) => TaggedStructType<K, D[K]> & Brand;
+  readonly _tag: K;
+} };
+/**
+ * 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;
+  };
+}
+/**
+ * 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>, VariantsUnion<D>, never> & MachineSchemaBase<D, FullStateBrand<D>> & VariantConstructors<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>, VariantsUnion<D>, never> & 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>;
+/**
+ * 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).
+ *
+ * @example
+ * ```ts
+ * const OrderEvent = MachineSchema.Event({
+ *   Ship: { trackingId: Schema.String },
+ *   Cancel: {},
+ * })
+ *
+ * type OrderEvent = typeof OrderEvent.Type
+ *
+ * // Construct
+ * const e = OrderEvent.Ship({ trackingId: "abc" })
+ * ```
+ */
+declare const Event: <const D extends Record<string, Schema.Struct.Fields>>(definition: D) => MachineEventSchema<D>;
+//#endregion
+export { Event, MachineEventSchema, MachineStateSchema, State, VariantsUnion };

package/dist/schema.js

@@ -0,0 +1,165 @@
+import { InvalidSchemaError, MissingMatchHandlerError } from "./errors.js";
+import { Schema } from "effect";
+
+//#region src/schema.ts
+/**
+* Schema-first State/Event definitions for effect-machine.
+*
+* MachineSchema provides a single source of truth that combines:
+* - Schema for validation/serialization
+* - Variant constructors (like Data.taggedEnum)
+* - $is and $match helpers for pattern matching
+* - Brand integration for compile-time safety
+*
+* @example
+* ```ts
+* import { State, Event, Machine } from "effect-machine"
+*
+* // Define schema-first state
+* const OrderState = State({
+*   Pending: { orderId: Schema.String },
+*   Shipped: { trackingId: Schema.String },
+* })
+*
+* // Infer type from schema
+* type OrderState = typeof OrderState.Type
+*
+* // Use constructors
+* const pending = OrderState.Pending({ orderId: "123" })
+*
+* // Pattern match
+* OrderState.$match(state, {
+*   Pending: (s) => `Order ${s.orderId} pending`,
+*   Shipped: (s) => `Shipped: ${s.trackingId}`,
+* })
+*
+* // Use as Schema for persistence/cluster
+* machine.pipe(Machine.persist({ stateSchema: OrderState, ... }))
+* ```
+*
+* @module
+*/
+/**
+* Build a schema-first definition from a record of tag -> fields
+*/
+const buildMachineSchema = (definition) => {
+	const variants = {};
+	const constructors = {};
+	for (const tag of Object.keys(definition)) {
+		const fields = definition[tag];
+		if (fields === void 0) continue;
+		variants[tag] = Schema.TaggedStruct(tag, fields);
+		const fieldNames = new Set(Object.keys(fields));
+		if (fieldNames.size > 0) {
+			const constructor = (args) => ({
+				...args,
+				_tag: tag
+			});
+			constructor._tag = tag;
+			constructor.derive = (source, partial) => {
+				const result = { _tag: tag };
+				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)) result[key] = value;
+				return result;
+			};
+			constructors[tag] = constructor;
+		} else constructors[tag] = {
+			_tag: tag,
+			derive: () => ({ _tag: tag })
+		};
+	}
+	const variantArray = Object.values(variants);
+	if (variantArray.length === 0) throw new InvalidSchemaError();
+	const unionSchema = variantArray.length === 1 ? variantArray[0] : Schema.Union(...variantArray);
+	const $is = (tag) => (u) => typeof u === "object" && u !== null && "_tag" in u && u._tag === tag;
+	const $match = (valueOrCases, maybeCases) => {
+		if (maybeCases !== void 0) {
+			const value = valueOrCases;
+			const handler = maybeCases[value._tag];
+			if (handler === void 0) throw new MissingMatchHandlerError({ tag: value._tag });
+			return handler(value);
+		}
+		const cases = valueOrCases;
+		return (value) => {
+			const handler = cases[value._tag];
+			if (handler === void 0) throw new MissingMatchHandlerError({ tag: value._tag });
+			return handler(value);
+		};
+	};
+	return {
+		schema: unionSchema,
+		variants,
+		constructors,
+		_definition: definition,
+		$is,
+		$match
+	};
+};
+/**
+* Internal helper to create a machine schema (shared by State and Event).
+* Builds the schema object with variants, constructors, $is, and $match.
+*/
+const createMachineSchema = (definition) => {
+	const { schema, variants, constructors, _definition, $is, $match } = buildMachineSchema(definition);
+	return Object.assign(Object.create(schema), {
+		variants,
+		_definition,
+		$is,
+		$match,
+		...constructors
+	});
+};
+/**
+* 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)
+* ```
+*/
+const State = (definition) => createMachineSchema(definition);
+/**
+* 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).
+*
+* @example
+* ```ts
+* const OrderEvent = MachineSchema.Event({
+*   Ship: { trackingId: Schema.String },
+*   Cancel: {},
+* })
+*
+* type OrderEvent = typeof OrderEvent.Type
+*
+* // Construct
+* const e = OrderEvent.Ship({ trackingId: "abc" })
+* ```
+*/
+const Event = (definition) => createMachineSchema(definition);
+
+//#endregion
+export { Event, State };

package/dist/slot.d.ts

@@ -0,0 +1,130 @@
+import { ActorSystem } from "./actor.js";
+import { Context, Effect, Schema } from "effect";
+
+//#region src/slot.d.ts
+/** Schema fields definition (like Schema.Struct.Fields) */
+type Fields = Record<string, Schema.Schema.All>;
+/** Extract the encoded 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>;
+}
+/**
+ * An effect slot - callable function that returns Effect<void>.
+ */
+interface EffectSlot<Name extends string, Params> {
+  readonly _tag: "EffectSlot";
+  readonly name: Name;
+  (params: Params): Effect.Effect<void>;
+}
+/**
+ * Guard definition - name to schema fields mapping
+ */
+type GuardsDef = Record<string, Fields>;
+/**
+ * Effect definition - name to schema fields mapping
+ */
+type EffectsDef = Record<string, Fields>;
+/**
+ * Convert guard definitions to callable guard slots
+ */
+type GuardSlots<D extends GuardsDef> = { readonly [K in keyof D & string]: GuardSlot<K, FieldsToParams<D[K]>> };
+/**
+ * Convert effect definitions to callable effect slots
+ */
+type EffectSlots<D extends EffectsDef> = { readonly [K in keyof D & string]: EffectSlot<K, FieldsToParams<D[K]>> };
+/**
+ * Type for machine context - state, event, and self reference.
+ * Shared across all machines via MachineContextTag.
+ */
+interface MachineContext<State, Event, Self> {
+  readonly state: State;
+  readonly event: Event;
+  readonly self: Self;
+  readonly system: ActorSystem;
+}
+/**
+ * Shared Context tag for all machines.
+ * Single module-level tag instead of per-machine allocation.
+ * @internal
+ */
+declare const MachineContextTag: Context.Tag<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.
+ *
+ * @example
+ * ```ts
+ * const MyEffects = Slot.Effects({
+ *   fetchData: { url: Schema.String },
+ *   notify: { 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 Slot: {
+  readonly Guards: <D extends GuardsDef>(definitions: D) => GuardsSchema<D>;
+  readonly Effects: <D extends EffectsDef>(definitions: D) => EffectsSchema<D>;
+};
+//#endregion
+export { EffectHandler, EffectHandlers, EffectSlot, EffectSlots, EffectSlotsOf, Effects, EffectsDef, EffectsDefOf, EffectsSchema, GuardHandler, GuardHandlers, GuardSlot, GuardSlots, GuardSlotsOf, Guards, GuardsDef, GuardsDefOf, GuardsSchema, MachineContext, MachineContextTag, Slot };

package/dist/slot.js

@@ -0,0 +1,99 @@
+import { Context } from "effect";
+
+//#region src/slot.ts
+/**
+* Slot module - schema-based, parameterized guards and effects.
+*
+* Guards and Effects are defined with schemas for their parameters,
+* and provided implementations receive typed parameters plus machine context.
+*
+* @example
+* ```ts
+* import { Slot } from "effect-machine"
+* import { Schema } from "effect"
+*
+* const MyGuards = Slot.Guards({
+*   canRetry: { max: Schema.Number },
+*   isValid: {},  // no params
+* })
+*
+* const MyEffects = Slot.Effects({
+*   fetchData: { url: Schema.String },
+*   notify: { message: Schema.String },
+* })
+*
+* // Used in handlers:
+* .on(State.X, Event.Y, ({ guards, effects }) =>
+*   Effect.gen(function* () {
+*     if (yield* guards.canRetry({ max: 3 })) {
+*       yield* effects.fetchData({ url: "/api" })
+*       return State.Next
+*     }
+*     return state
+*   })
+* )
+* ```
+*
+* @module
+*/
+/**
+* Shared Context tag for all machines.
+* Single module-level tag instead of per-machine allocation.
+* @internal
+*/
+const MachineContextTag = Context.GenericTag("@effect-machine/Context");
+/**
+* Generic slot schema factory. Used internally by Guards() and Effects().
+* @internal
+*/
+const createSlotSchema = (tag, slotTag, definitions) => ({
+	_tag: tag,
+	definitions,
+	_createSlots: (resolve) => {
+		const slots = {};
+		for (const name of Object.keys(definitions)) {
+			const slot = (params) => resolve(name, params);
+			Object.defineProperty(slot, "_tag", {
+				value: slotTag,
+				enumerable: true
+			});
+			Object.defineProperty(slot, "name", {
+				value: name,
+				enumerable: true
+			});
+			slots[name] = slot;
+		}
+		return slots;
+	}
+});
+/**
+* Create a guards schema with parameterized guard definitions.
+*
+* @example
+* ```ts
+* const MyGuards = Slot.Guards({
+*   canRetry: { max: Schema.Number },
+*   isValid: {},
+* })
+* ```
+*/
+const Guards = (definitions) => createSlotSchema("GuardsSchema", "GuardSlot", definitions);
+/**
+* Create an effects schema with parameterized effect definitions.
+*
+* @example
+* ```ts
+* const MyEffects = Slot.Effects({
+*   fetchData: { url: Schema.String },
+*   notify: { message: Schema.String },
+* })
+* ```
+*/
+const Effects = (definitions) => createSlotSchema("EffectsSchema", "EffectSlot", definitions);
+const Slot = {
+	Guards,
+	Effects
+};
+
+//#endregion
+export { Effects, Guards, MachineContextTag, Slot };