effect-machine 0.11.0 → 0.12.0

package/dist/schema.d.ts

@@ -1,7 +1,17 @@
-import { FullEventBrand, FullStateBrand } from "./internal/brands.js";
+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<unknown>> = F & {
+  readonly [ReplySchemaSymbol]: RS;
+};
 /**
  * Extract the TypeScript type from a TaggedStruct schema
  */
@@ -12,20 +22,23 @@ type TaggedStructType<Tag extends string, Fields extends Schema.Struct.Fields> =
 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.
+ * 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]> }[keyof D & string];
+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 properties)
+ * 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> = keyof Fields extends never ? true : false;
+type IsEmptyFields<Fields extends Schema.Struct.Fields> = string & 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.
+ * 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`
@@ -33,10 +46,11 @@ type IsEmptyFields<Fields extends Schema.Struct.Fields> = keyof Fields extends n
  *
  * 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.
+ * 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 & {
+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 derive: (source: object) => TaggedStructType<K, D[K]> & Brand;
-} : ((args: Schema.Struct.Type<D[K]>) => TaggedStructType<K, D[K]> & Brand) & {
+} : ((args: Schema.Struct.Type<D[K]>) => TaggedStructType<K, D[K]> & Brand & VariantReplyBrand<D[K]>) & {
   readonly derive: (source: object, partial?: Partial<Schema.Struct.Type<D[K]>>) => TaggedStructType<K, D[K]> & Brand;
   readonly _tag: K;
 } };
@@ -67,6 +81,11 @@ 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;
   };
+  /**
+   * 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:
@@ -116,26 +135,8 @@ 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>;
-/**
- * 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>;
+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>;
+};
 //#endregion
-export { Event, MachineEventSchema, MachineStateSchema, State, VariantsUnion };
+export { Event, MachineEventSchema, MachineStateSchema, ReplyFields, ReplySchemaSymbol, State, VariantsUnion };

package/dist/schema.js

@@ -38,6 +38,7 @@ import { Schema } from "effect";
 *
 * @module
 */
+const ReplySchemaSymbol = Symbol.for("effect-machine/ReplySchema");
 /**
 * Build a schema-first definition from a record of tag -> fields
 */
@@ -45,9 +46,14 @@ const RESERVED_DERIVE_KEYS = new Set(["_tag"]);
 const buildMachineSchema = (definition) => {
 	const variants = {};
 	const constructors = {};
+	const replySchemas = /* @__PURE__ */ new Map();
 	for (const tag of Object.keys(definition)) {
 		const fields = definition[tag];
 		if (fields === void 0) continue;
+		if (ReplySchemaSymbol in fields) {
+			const rs = fields[ReplySchemaSymbol];
+			if (rs !== void 0) replySchemas.set(tag, rs);
+		}
 		variants[tag] = Schema.TaggedStruct(tag, fields);
 		const fieldNames = new Set(Object.keys(fields));
 		if (fieldNames.size > 0) {
@@ -94,6 +100,7 @@ const buildMachineSchema = (definition) => {
 		variants,
 		constructors,
 		_definition: definition,
+		replySchemas,
 		$is,
 		$match
 	};
@@ -103,10 +110,11 @@ const buildMachineSchema = (definition) => {
 * Builds the schema object with variants, constructors, $is, and $match.
 */
 const createMachineSchema = (definition) => {
-	const { schema, variants, constructors, _definition, $is, $match } = buildMachineSchema(definition);
+	const { schema, variants, constructors, _definition, replySchemas, $is, $match } = buildMachineSchema(definition);
 	return Object.assign(Object.create(schema), {
 		variants,
 		_definition,
+		_replySchemas: replySchemas,
 		$is,
 		$match,
 		...constructors
@@ -149,19 +157,40 @@ const State = (definition) => createMachineSchema(definition);
 * 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 = MachineSchema.Event({
+* 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
 * ```
 */
-const Event = (definition) => createMachineSchema(definition);
+const EventImpl = (definition) => createMachineSchema(definition);
+/**
+* Annotate event fields with a reply schema.
+* Events defined with `Event.reply(fields, replySchema)` enable typed `ask()`.
+*/
+const replyFieldsFn = (fields, replySchema) => {
+	const annotated = { ...fields };
+	Object.defineProperty(annotated, ReplySchemaSymbol, {
+		value: replySchema,
+		enumerable: false,
+		writable: false
+	});
+	return annotated;
+};
+const Event = Object.assign(EventImpl, { reply: replyFieldsFn });
 //#endregion
 export { Event, State };

package/dist/testing.js

@@ -30,7 +30,8 @@ const simulate = Effect.fn("effect-machine.simulate")(function* (input, events)
 	const dummySelf = {
 		send: dummySend,
 		cast: dummySend,
-		spawn: () => Effect.die("spawn not supported in simulation")
+		spawn: () => Effect.die("spawn not supported in simulation"),
+		reply: () => Effect.succeed(false)
 	};
 	let currentState = machine.initial;
 	const states = [currentState];
@@ -143,7 +144,8 @@ const createTestHarness = Effect.fn("effect-machine.createTestHarness")(function
 	const dummySelf = {
 		send: dummySend,
 		cast: dummySend,
-		spawn: () => Effect.die("spawn not supported in test harness")
+		spawn: () => Effect.die("spawn not supported in test harness"),
+		reply: () => Effect.succeed(false)
 	};
 	const stateRef = yield* SubscriptionRef.make(machine.initial);
 	const hasPostponeRules = machine.postponeRules.length > 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-machine",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/cevr/effect-machine.git"
@@ -56,7 +56,7 @@
     "release": "bun run build && changeset publish"
   },
   "dependencies": {
-    "effect": "4.0.0-beta.35"
+    "effect": "4.0.0-beta.42"
   },
   "devDependencies": {
     "@changesets/changelog-github": "^0.6.0",
@@ -81,6 +81,6 @@
     }
   },
   "overrides": {
-    "effect": "4.0.0-beta.35"
+    "effect": "4.0.0-beta.42"
   }
 }

package/v3/dist/actor.d.ts

@@ -1,4 +1,5 @@
 import { EffectsDef, GuardsDef, MachineContext } from "./slot.js";
+import { ExtractReply, ReplyTypeBrand } from "./internal/brands.js";
 import { ActorStoppedError, DuplicateActorError, NoReplyError } from "./errors.js";
 import { ProcessEventError, ProcessEventHooks, ProcessEventResult, processEventCore, resolveTransition, runSpawnEffects } from "./internal/transition.js";
 import { BuiltMachine, Machine, MachineRef } from "./machine.js";
@@ -59,11 +60,11 @@ interface ActorRef<State extends {
    */
   readonly call: (event: Event) => Effect.Effect<ProcessEventResult<State>>;
   /**
-   * Typed request-reply. Event is processed through the queue; caller gets
-   * the domain value returned by the handler's `reply` field.
+   * Typed request-reply. Accepts only events with a reply schema
+   * (defined via `Event.reply()`). Return type is inferred from the schema.
    * Fails with NoReplyError if the handler doesn't provide a reply.
    */
-  readonly ask: <R>(event: Event) => Effect.Effect<R, NoReplyError | ActorStoppedError>;
+  readonly ask: <E extends Event & ReplyTypeBrand<unknown>>(event: E) => Effect.Effect<ExtractReply<E>, NoReplyError | ActorStoppedError>;
   /** Observable state. */
   readonly state: SubscriptionRef.SubscriptionRef<State>;
   /** Stop the actor gracefully. */

package/v3/dist/actor.js

@@ -3,7 +3,7 @@ import { INTERNAL_INIT_EVENT } from "./internal/utils.js";
 import { ActorStoppedError, DuplicateActorError, NoReplyError } from "./errors.js";
 import { emitWithTimestamp } from "./internal/inspection.js";
 import { processEventCore, resolveTransition, runSpawnEffects, shouldPostpone } from "./internal/transition.js";
-import { Cause, Context, Deferred, Effect, Exit, Fiber, Layer, MutableHashMap, Option, PubSub, Queue, Ref, Runtime, Scope, Stream, SubscriptionRef } from "effect";
+import { Cause, Context, Deferred, Effect, Exit, Fiber, Layer, MutableHashMap, Option, PubSub, Queue, Ref, Runtime, Schema, Scope, Stream, SubscriptionRef } from "effect";
 //#region src/actor.ts
 /**
 * Actor system: spawning, lifecycle, and event processing.
@@ -276,6 +276,7 @@ const eventLoop = Effect.fn("effect-machine.actor.eventLoop")(function* (machine
 					lifecycleRan: false,
 					isFinal: false,
 					hasReply: false,
+					deferReply: false,
 					reply: void 0,
 					postponed: true
 				};
@@ -296,8 +297,19 @@ const eventLoop = Effect.fn("effect-machine.actor.eventLoop")(function* (machine
 				yield* Deferred.succeed(queued.reply, result);
 				break;
 			case "ask":
-				if (result.hasReply) yield* Deferred.succeed(queued.reply, result.reply);
-				else yield* Deferred.fail(queued.reply, new NoReplyError({
+				if (result.hasReply) {
+					const replySchema = machine._replySchemas?.get(event._tag);
+					if (replySchema !== void 0) {
+						let decoded;
+						try {
+							decoded = Schema.decodeUnknownSync(replySchema)(result.reply);
+						} catch (decodeError) {
+							yield* Deferred.die(queued.reply, decodeError);
+							return yield* Effect.die(decodeError);
+						}
+						yield* Deferred.succeed(queued.reply, decoded);
+					} else yield* Deferred.succeed(queued.reply, result.reply);
+				} else yield* Deferred.fail(queued.reply, new NoReplyError({
 					actorId,
 					eventTag: event._tag
 				}));

package/v3/dist/cluster/adapters/in-memory.d.ts

@@ -0,0 +1,15 @@
+import { PersistedEvent, PersistenceAdapter, Snapshot } from "../persistence.js";
+import { Effect, Layer, Ref } from "effect";
+
+//#region src/cluster/adapters/in-memory.d.ts
+interface EntityStore {
+  snapshot: Snapshot<unknown> | undefined;
+  events: Array<PersistedEvent<unknown>>;
+}
+declare const makeInMemoryPersistenceAdapter: Effect.Effect<{
+  adapter: PersistenceAdapter;
+  storeRef: Ref.Ref<Map<string, EntityStore>>;
+  layer: Layer.Layer<PersistenceAdapter, never, never>;
+}, never, never>;
+//#endregion
+export { makeInMemoryPersistenceAdapter };

package/v3/dist/cluster/adapters/in-memory.js

@@ -0,0 +1,62 @@
+import { VersionConflictError } from "../../errors.js";
+import { PersistenceAdapter } from "../persistence.js";
+import { Effect, Layer, Option, Ref } from "effect";
+//#region src/cluster/adapters/in-memory.ts
+/**
+* In-memory persistence adapter for testing and development (v3).
+*
+* @module
+*/
+const makeKey = (key) => `${key.entityType}/${key.entityId}`;
+const getOrCreate = (store, key) => {
+	let entry = store.get(key);
+	if (entry === void 0) {
+		entry = {
+			snapshot: void 0,
+			events: []
+		};
+		store.set(key, entry);
+	}
+	return entry;
+};
+const makeInMemoryPersistenceAdapter = Effect.gen(function* () {
+	const store = /* @__PURE__ */ new Map();
+	const storeRef = yield* Ref.make(store);
+	const adapter = {
+		saveSnapshot: (key, snapshot) => Effect.gen(function* () {
+			const entry = getOrCreate(yield* Ref.get(storeRef), makeKey(key));
+			if (entry.snapshot !== void 0 && snapshot.version < entry.snapshot.version) return yield* new VersionConflictError({
+				expected: snapshot.version,
+				actual: entry.snapshot.version
+			});
+			entry.snapshot = snapshot;
+		}),
+		loadSnapshot: (key) => Effect.gen(function* () {
+			const entry = (yield* Ref.get(storeRef)).get(makeKey(key));
+			return Option.fromNullable(entry?.snapshot);
+		}),
+		appendEvents: (key, events, expectedVersion) => Effect.gen(function* () {
+			const entry = getOrCreate(yield* Ref.get(storeRef), makeKey(key));
+			const lastEvent = entry.events[entry.events.length - 1];
+			const currentVersion = lastEvent !== void 0 ? lastEvent.version : 0;
+			if (currentVersion !== expectedVersion) return yield* new VersionConflictError({
+				expected: expectedVersion,
+				actual: currentVersion
+			});
+			for (const event of events) entry.events.push(event);
+		}),
+		loadEvents: (key, afterVersion) => Effect.gen(function* () {
+			const entry = (yield* Ref.get(storeRef)).get(makeKey(key));
+			if (entry === void 0) return [];
+			if (afterVersion === void 0) return entry.events;
+			return entry.events.filter((e) => e.version > afterVersion);
+		})
+	};
+	return {
+		adapter,
+		storeRef,
+		layer: Layer.succeed(PersistenceAdapter, adapter)
+	};
+});
+//#endregion
+export { makeInMemoryPersistenceAdapter };

package/v3/dist/cluster/entity-actor-ref.d.ts

@@ -0,0 +1,49 @@
+import { ExtractReply, ReplyTypeBrand } from "../internal/brands.js";
+import { NoReplyError } from "../errors.js";
+import { Effect } from "effect";
+import { RpcClient } from "effect/unstable/rpc";
+
+//#region src/cluster/entity-actor-ref.d.ts
+/**
+ * Typed client wrapper for remote entity machines.
+ *
+ * Unlike local `ActorRef`, this communicates over cluster RPCs.
+ * Only operations that make sense over the network are exposed.
+ *
+ * @example
+ * ```ts
+ * const ref = yield* EntityActorRef.make(OrderEntity, OrderEntityLayer, "order-123")
+ * yield* ref.send(OrderEvent.Ship({ trackingId: "abc" }))
+ * const state = yield* ref.snapshot
+ * ```
+ */
+interface EntityActorRef<State extends {
+  readonly _tag: string;
+}, Event extends {
+  readonly _tag: string;
+}> {
+  readonly entityId: string;
+  /** Send event (fire-and-forget). Returns new state after processing. */
+  readonly send: (event: Event) => Effect.Effect<State>;
+  /** Send event and get typed domain reply (via Event.reply() schema). */
+  readonly ask: <E extends Event & ReplyTypeBrand<unknown>>(event: E) => Effect.Effect<ExtractReply<E>, NoReplyError>;
+  /** Get current state. */
+  readonly snapshot: Effect.Effect<State>;
+}
+/**
+ * Create an EntityActorRef from a test client factory and entity ID.
+ *
+ * @example
+ * ```ts
+ * const makeClient = yield* Entity.makeTestClient(entity, entityLayer)
+ * const ref = yield* makeEntityActorRef(makeClient, "order-123")
+ * yield* ref.send(OrderEvent.Process)
+ * ```
+ */
+declare const makeEntityActorRef: <State extends {
+  readonly _tag: string;
+}, Event extends {
+  readonly _tag: string;
+}>(client: RpcClient.RpcClient<any>, entityId: string) => EntityActorRef<State, Event>;
+//#endregion
+export { EntityActorRef, makeEntityActorRef };

package/v3/dist/cluster/entity-actor-ref.js

@@ -0,0 +1,19 @@
+//#region src/cluster/entity-actor-ref.ts
+/**
+* Create an EntityActorRef from a test client factory and entity ID.
+*
+* @example
+* ```ts
+* const makeClient = yield* Entity.makeTestClient(entity, entityLayer)
+* const ref = yield* makeEntityActorRef(makeClient, "order-123")
+* yield* ref.send(OrderEvent.Process)
+* ```
+*/
+const makeEntityActorRef = (client, entityId) => ({
+	entityId,
+	send: (event) => client.Send({ event }),
+	ask: ((event) => client.Ask({ event })),
+	snapshot: client.GetState()
+});
+//#endregion
+export { makeEntityActorRef };

package/v3/dist/cluster/entity-machine.d.ts

@@ -1,7 +1,7 @@
-import { EffectsDef, GuardsDef } from "../slot.js";
 import { ProcessEventHooks } from "../internal/transition.js";
 import { Machine } from "../machine.js";
-import { Layer } from "effect";
+import { EntityPersistenceConfig } from "./persistence.js";
+import { Duration, Layer, Schedule } from "effect";
 import { Entity } from "@effect/cluster";
 import { Rpc } from "@effect/rpc";
 
@@ -13,77 +13,62 @@ interface EntityMachineOptions<S, E> {
   /**
    * Initialize state from entity ID.
    * Called once when entity is first activated.
-   *
-   * @example
-   * ```ts
-   * EntityMachine.layer(OrderEntity, orderMachine, {
-   *   initializeState: (entityId) => OrderState.Pending({ orderId: entityId }),
-   * })
-   * ```
    */
   readonly initializeState?: (entityId: string) => S;
   /**
    * Optional hooks for inspection/tracing.
-   * Called at specific points during event processing.
-   *
-   * @example
-   * ```ts
-   * EntityMachine.layer(OrderEntity, orderMachine, {
-   *   hooks: {
-   *     onTransition: (from, to, event) =>
-   *       Effect.log(`Transition: ${from._tag} -> ${to._tag}`),
-   *     onSpawnEffect: (state) =>
-   *       Effect.log(`Running spawn effects for ${state._tag}`),
-   *     onError: ({ phase, state }) =>
-   *       Effect.log(`Defect in ${phase} at ${state._tag}`),
-   *   },
-   * })
-   * ```
    */
   readonly hooks?: ProcessEventHooks<S, E>;
+  /**
+   * Maximum idle time before entity deactivation.
+   * Forwarded to Entity.toLayer.
+   */
+  readonly maxIdleTime?: Duration.DurationInput;
+  /**
+   * Concurrency for handler execution.
+   * Forwarded to Entity.toLayer.
+   */
+  readonly concurrency?: number | "unbounded";
+  /**
+   * Mailbox capacity. Default: "unbounded".
+   * Forwarded to Entity.toLayer.
+   */
+  readonly mailboxCapacity?: number | "unbounded";
+  /**
+   * Disable fatal defects (defects won't crash the entity activation).
+   * Forwarded to Entity.toLayer.
+   */
+  readonly disableFatalDefects?: boolean;
+  /**
+   * Retry policy for defects (schedule for restarting after defect).
+   * Forwarded to Entity.toLayer.
+   */
+  readonly defectRetryPolicy?: Schedule.Schedule<any, unknown>;
+  /**
+   * Persistence configuration. When set, requires PersistenceAdapter in R.
+   */
+  readonly persistence?: EntityPersistenceConfig;
 }
 /**
  * Create an Entity layer that wires a machine to handle RPC calls.
  *
- * The layer:
- * - Maintains state via Ref per entity instance
- * - Resolves transitions using the indexed lookup
- * - Evaluates guards in registration order
- * - Runs lifecycle effects (onEnter/spawn)
- * - Processes internal events from spawn effects
+ * v3: Uses `Entity.toLayer` with handler objects backed by the runtime kernel.
  *
  * @example
  * ```ts
- * const OrderEntity = toEntity(orderMachine, {
- *   type: "Order",
- *   stateSchema: OrderState,
- *   eventSchema: OrderEvent,
- * })
+ * const OrderEntity = toEntity(orderMachine, { type: "Order" })
  *
  * const OrderEntityLayer = EntityMachine.layer(OrderEntity, orderMachine, {
  *   initializeState: (entityId) => OrderState.Pending({ orderId: entityId }),
  * })
- *
- * // Use in cluster
- * const program = Effect.gen(function* () {
- *   const client = yield* ShardingClient.client(OrderEntity)
- *   yield* client.Send("order-123", { event: OrderEvent.Ship({ trackingId: "abc" }) })
- * })
  * ```
  */
 declare const EntityMachine: {
-  /**
-   * Create a layer that wires a machine to an Entity.
-   *
-   * @param entity - Entity created via toEntity()
-   * @param machine - Machine with all effects provided
-   * @param options - Optional configuration (state initializer, inspection hooks)
-   */
   layer: <S extends {
     readonly _tag: string;
   }, E extends {
     readonly _tag: string;
-  }, R, GD extends GuardsDef, EFD extends EffectsDef, EntityType extends string, Rpcs extends Rpc.Any>(entity: Entity.Entity<EntityType, Rpcs>, machine: Machine<S, E, R, Record<string, never>, Record<string, never>, GD, EFD>, options?: EntityMachineOptions<S, E>) => Layer.Layer<never, never, R>;
+  }, R, EntityType extends string, Rpcs extends Rpc.Any>(entity: Entity.Entity<EntityType, Rpcs>, machine: Machine<S, E, R, any, any, any, any>, options?: EntityMachineOptions<S, E>) => Layer.Layer<never, never, R>;
 };
 //#endregion
 export { EntityMachine, EntityMachineOptions };