effect-machine 0.16.0 → 0.17.1

package/dist/schema.d.ts

@@ -49,16 +49,23 @@ type VariantReplyBrand<Fields extends Schema.Struct.Fields> = Fields extends {
  * 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.
+ * Each variant also has a `with` method for constructing from a source object,
+ * copying matching fields and overriding with a partial.
  * The source type uses `object` to accept branded state types without index signature issues.
  * Reply-bearing variants carry ReplyTypeBrand<R> for ask() type inference.
  */
 type VariantConstructors<D extends Record<string, Schema.Struct.Fields>, Brand> = { readonly [K in keyof D & string]: IsEmptyFields<D[K]> extends true ? TaggedStructType<K, D[K]> & Brand & VariantReplyBrand<D[K]> & {
-  readonly derive: (source: object) => TaggedStructType<K, D[K]> & Brand;
+  readonly with: (source: object) => TaggedStructType<K, D[K]> & Brand;
 } : ((args: Schema.Struct.Type<PayloadFields<D[K]>>) => TaggedStructType<K, D[K]> & Brand & VariantReplyBrand<D[K]>) & {
-  readonly derive: (source: object, partial?: Partial<Schema.Struct.Type<PayloadFields<D[K]>>>) => TaggedStructType<K, D[K]> & Brand;
+  readonly with: (source: object, partial?: Partial<Schema.Struct.Type<PayloadFields<D[K]>>>) => TaggedStructType<K, D[K]> & Brand;
   readonly _tag: K;
 } };
+/**
+ * Keys present in ALL variants (intersection of field names).
+ * Used by union-level `with` to accept only fields safe to update
+ * regardless of which variant the source is.
+ */
+type SharedKeys<D extends Record<string, Schema.Struct.Fields>> = keyof D[keyof D & string] & string;
 /**
  * Pattern matching cases type
  */
@@ -87,19 +94,23 @@ interface MachineSchemaBase<D extends Record<string, Schema.Struct.Fields>, Bran
     <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.
+   * Copy fields from `source` into the same variant, overriding with `partial`.
+   * Preserves the specific variant subtype in the return.
    *
-   * Dispatches to the per-variant `derive` based on `source._tag`.
+   * The partial accepts fields common to all variants, so it works safely
+   * when `S` is a generic type parameter (e.g., `<S extends MyState>`).
    *
    * @example
    * ```ts
-   * // 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)
+   * // Per-variant field update — partial accepts that variant's fields
+   * const next = MyState.Streaming.with(state, { draft: newDraft })
+   *
+   * // Cross-variant shared field — works with generic state
+   * const updateQueue = <S extends MyState>(state: S, queue: Queue): S =>
+   *   MyState.with(state, { queue })
    * ```
    */
-  readonly derive: <S extends VariantsUnion<D> & Brand>(source: S, partial?: Partial<Omit<S, "_tag">>) => S;
+  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()`.
@@ -116,8 +127,8 @@ 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, never, never> & MachineSchemaBase<D, FullStateBrand<D>> & VariantConstructors<D, FullStateBrand<D>> & {
-  /** Unbranded schema for persistence — same structure without FullStateBrand. */readonly plain: Schema.Schema<VariantsUnion<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 for persistence, config, and registration. */readonly schema: Schema.Schema<VariantsUnion<D> & FullStateBrand<D>>;
 };
 /**
  * Schema-first event definition (same structure as state, different brand)
@@ -125,7 +136,7 @@ type MachineStateSchema<D extends Record<string, Schema.Struct.Fields>> = Schema
  * 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.Codec<VariantsUnion<D> & FullEventBrand<D>, unknown, never, never> & MachineSchemaBase<D, FullEventBrand<D>> & VariantConstructors<D, FullEventBrand<D>>;
+type MachineEventSchema<D extends Record<string, Schema.Struct.Fields>> = Schema.Codec<VariantsUnion<D> & FullEventBrand<D>, unknown> & MachineSchemaBase<D, FullEventBrand<D>> & VariantConstructors<D, FullEventBrand<D>>;
 /**
  * Create a schema-first State definition.
  *

package/dist/schema.js

@@ -62,7 +62,7 @@ const buildMachineSchema = (definition) => {
 				_tag: tag
 			});
 			constructor._tag = tag;
-			constructor.derive = (source, partial) => {
+			constructor.with = (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)) {
@@ -75,7 +75,7 @@ const buildMachineSchema = (definition) => {
 			constructors[tag] = constructor;
 		} else constructors[tag] = {
 			_tag: tag,
-			derive: () => ({ _tag: tag })
+			with: () => ({ _tag: tag })
 		};
 	}
 	const variantArray = Object.values(variants);
@@ -112,21 +112,21 @@ const buildMachineSchema = (definition) => {
 */
 const createMachineSchema = (definition) => {
 	const { schema, variants, constructors, _definition, replySchemas, $is, $match } = buildMachineSchema(definition);
-	const derive = (source, partial) => {
+	const withFn = (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);
+		const fn = ctor.with;
+		if (fn === void 0) throw new MissingMatchHandlerError({ tag: source._tag });
+		return fn(source, partial);
 	};
 	return Object.assign(Object.create(schema), {
 		variants,
 		_definition,
 		_replySchemas: replySchemas,
-		plain: schema,
+		schema,
 		$is,
 		$match,
-		derive,
+		with: withFn,
 		...constructors
 	});
 };

package/dist/slot.d.ts

@@ -1,4 +1,4 @@
-import { ActorSystem } from "./actor.js";
+import { ActorSystemService } from "./actor.js";
 import { Context, Effect, Schema } from "effect";
 
 //#region src/slot.d.ts
@@ -40,7 +40,7 @@ interface SlotFnDef<F extends Fields = Fields, Return = 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>;
+  <F extends Fields>(fields: F): SlotFnDef<F>;
 };
 /**
  * Record of slot definitions. Keys are slot names, values are SlotFnDef.
@@ -125,14 +125,15 @@ interface MachineContext<State, Event, Self> {
   readonly state: State;
   readonly event: Event;
   readonly self: Self;
-  readonly system: ActorSystem;
+  readonly system: ActorSystemService;
 }
+declare const MachineContextTag_base: Context.ServiceClass<MachineContextTag, "effect-machine/slot/MachineContextTag", MachineContext<any, any, any>>;
 /**
  * Shared Context tag for all machines.
  * Single module-level tag instead of per-machine allocation.
  * @internal
  */
-declare const MachineContextTag: Context.Service<MachineContext<any, any, any>, MachineContext<any, any, any>>;
+declare class MachineContextTag extends MachineContextTag_base {}
 /**
  * Define a set of slots with parameter and return schemas.
  *
@@ -149,9 +150,10 @@ declare const define: <D extends SlotsDef>(definitions: D) => SlotsSchema<D>;
 declare const Slot: {
   readonly fn: {
     <F extends Fields, Return>(fields: F, returnSchema: Schema.Schema<Return>): SlotFnDef<F, Return>;
-    <F extends Fields>(fields: F): SlotFnDef<F, void>;
+    <F extends Fields>(fields: F): SlotFnDef<F>;
   };
   readonly define: <D extends SlotsDef>(definitions: D) => SlotsSchema<D>;
+  readonly of: <D extends SlotsDef>(slotsSchema: SlotsSchema<D>, provided: ProvideSlots<D>) => SlotCalls<D>;
 };
 //#endregion
 export { HasSlotKeys, MachineContext, MachineContextTag, ProvideSlots, Slot, SlotCall, SlotCalls, SlotFnDef, SlotHandler, SlotInvocation, SlotRequest, SlotResult, SlotsDef, SlotsSchema, define, fn };

package/dist/slot.js

@@ -1,4 +1,4 @@
-import { Context, Schema } from "effect";
+import { Context, Effect, Schema } from "effect";
 //#region src/slot.ts
 /**
 * Slot module — unified, schema-based parameterized slots.
@@ -62,7 +62,7 @@ const fn = (fields, returnSchema) => {
 * Single module-level tag instead of per-machine allocation.
 * @internal
 */
-const MachineContextTag = Context.Service("@effect-machine/Context");
+var MachineContextTag = class extends Context.Service()("effect-machine/slot/MachineContextTag") {};
 /**
 * Define a set of slots with parameter and return schemas.
 *
@@ -122,9 +122,44 @@ const define = (definitions) => {
 		}
 	};
 };
+/**
+* Convert raw slot handler implementations into the callable `SlotCalls` form.
+*
+* Handlers that return plain values are wrapped in `Effect.succeed`.
+* Handlers that return Effects are called directly inside `Effect.suspend`.
+*
+* @example
+* ```ts
+* const provided = yield* myExtension.slots(ctx)
+* const slots = Slot.of(slotsSchema, provided)
+* // slots.mySlot({ param: 1 }) returns Effect<ReturnType>
+* ```
+*/
+const of = (slotsSchema, provided) => {
+	const slots = {};
+	for (const name of Object.keys(slotsSchema.definitions)) {
+		const handler = provided[name];
+		if (handler === void 0) continue;
+		const call = (params) => Effect.suspend(() => {
+			const result = handler(params);
+			return Effect.isEffect(result) ? result : Effect.succeed(result);
+		});
+		Object.defineProperty(call, "_tag", {
+			value: "Slot",
+			enumerable: true
+		});
+		Object.defineProperty(call, "name", {
+			value: name,
+			enumerable: true
+		});
+		slots[name] = call;
+	}
+	return slots;
+};
 const Slot = {
 	fn,
-	define
+	define,
+	of
 };
 //#endregion
 export { MachineContextTag, Slot, define, fn };

package/dist/testing.d.ts

@@ -1,6 +1,6 @@
 import { AssertionError } from "./errors.js";
-import { MachineContext, ProvideSlots, SlotsDef } from "./slot.js";
-import { Machine, MachineRef } from "./machine.js";
+import { MachineContextTag, ProvideSlots, SlotsDef } from "./slot.js";
+import { Machine } from "./machine.js";
 import { Effect, SubscriptionRef } from "effect";
 
 //#region src/testing.d.ts
@@ -41,7 +41,7 @@ declare const simulate: <S extends {
 } | undefined) => Effect.Effect<{
   states: S[];
   finalState: S;
-}, never, Exclude<R, MachineContext<S, E, MachineRef<E>>>>;
+}, never, Exclude<R, MachineContextTag>>;
 /**
  * Assert that a machine can reach a specific state given a sequence of events
  */
@@ -51,7 +51,7 @@ declare const assertReaches: <S extends {
   readonly _tag: string;
 }, R, SD extends SlotsDef = Record<string, never>>(input: MachineInput<S, E, R, SD>, events: readonly E[], expectedTag: string, options?: {
   slots?: ProvideSlots<SD, any>;
-} | undefined) => Effect.Effect<S, AssertionError, Exclude<R, MachineContext<S, E, MachineRef<E>>>>;
+} | undefined) => Effect.Effect<S, AssertionError, Exclude<R, MachineContextTag>>;
 /**
  * Assert that a machine follows a specific path of state tags
  *
@@ -73,7 +73,7 @@ declare const assertPath: <S extends {
 } | undefined) => Effect.Effect<{
   states: S[];
   finalState: S;
-}, AssertionError, Exclude<R, MachineContext<S, E, MachineRef<E>>>>;
+}, AssertionError, Exclude<R, MachineContextTag>>;
 /**
  * Assert that a machine never reaches a specific state given a sequence of events
  *
@@ -96,7 +96,7 @@ declare const assertNeverReaches: <S extends {
 } | undefined) => Effect.Effect<{
   states: S[];
   finalState: S;
-}, AssertionError, Exclude<R, MachineContext<S, E, MachineRef<E>>>>;
+}, AssertionError, Exclude<R, MachineContextTag>>;
 /**
  * Create a controllable test harness for a machine
  */
@@ -144,7 +144,7 @@ declare const createTestHarness: <S extends {
   readonly _tag: string;
 }, R, SD extends SlotsDef = Record<string, never>>(input: MachineInput<S, E, R, SD>, options?: TestHarnessOptions<S, E, SD> | undefined) => Effect.Effect<{
   state: SubscriptionRef.SubscriptionRef<S>;
-  send: (event: E) => Effect.Effect<S, never, Exclude<R, MachineContext<S, E, MachineRef<E>>>>;
+  send: (event: E) => Effect.Effect<S, never, Exclude<R, MachineContextTag>>;
   getState: Effect.Effect<S, never, never>;
 }, never, never>;
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-machine",
-  "version": "0.16.0",
+  "version": "0.17.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/cevr/effect-machine.git"
@@ -40,11 +40,9 @@
     "access": "public"
   },
   "scripts": {
-    "typecheck": "tsgo --noEmit",
-    "typecheck:v3": "tsc --noEmit -p v3/tsconfig.json",
-    "lint": "concurrently -n ox,effect -c yellow,blue \"oxlint\" \"bun run lint:effect\"",
-    "lint:ox": "oxlint",
-    "lint:effect": "effect-language-service diagnostics --project tsconfig.json --lspconfig \"$(cat .effect-lsp.json)\"",
+    "typecheck": "concurrently -n v4,v3 -c blue,magenta \"tsgo --noEmit\" \"bun run typecheck:v3\"",
+    "typecheck:v3": "tsgo --noEmit -p v3/tsconfig.json",
+    "lint": "oxlint",
     "lint:fix": "oxlint --fix",
     "fmt": "oxfmt",
     "fmt:check": "oxfmt --check",
@@ -53,38 +51,36 @@
     "test:watch": "bun test --watch",
     "test:all": "bun run test && bun run test:v3",
     "gate": "concurrently -n type,lint,fmt,test,build -c blue,yellow,magenta,green,cyan \"bun run typecheck\" \"bun run lint:fix\" \"bun run fmt\" \"bun run test:all\" \"bun run build\"",
-    "prepare": "lefthook install",
+    "prepare": "lefthook install && effect-tsgo patch",
     "version": "changeset version",
-    "build": "concurrently -n v4,v3 -c cyan,magenta \"tsdown\" \"tsdown --config v3/tsdown.config.ts\"",
+    "build": "concurrently -n v4,v3 -c cyan,magenta \"bun --bun tsdown\" \"bun --bun tsdown --config v3/tsdown.config.ts\"",
     "release": "bun run build && changeset publish"
   },
-  "dependencies": {
-    "effect": "4.0.0-beta.47"
-  },
   "devDependencies": {
     "@changesets/changelog-github": "^0.6.0",
     "@changesets/cli": "^2.30.0",
-    "@effect/language-service": "^0.85.1",
+    "@effect/cluster": "0.58.2",
+    "@effect/rpc": "0.75.1",
+    "@effect/tsgo": "0.5.2",
     "@types/bun": "1.3.12",
-    "@typescript/native-preview": "^7.0.0-dev.20260412.1",
+    "@typescript/native-preview": "7.0.0-dev.20260507.1",
     "concurrently": "^9.2.1",
+    "effect": "4.0.0-beta.64",
     "effect-bun-test": "0.3.0",
-    "effect-v3": "npm:effect@^3.21.0",
+    "effect-v3": "npm:effect@3.21.2",
     "lefthook": "^2.1.5",
     "oxfmt": "^0.44.0",
-    "oxlint": "^1.59.0",
+    "oxlint": "^1.63.0",
+    "oxlint-tsgolint": "^0.22.1",
     "tsdown": "^0.21.7",
     "typescript": "^6.0.2"
   },
   "peerDependencies": {
-    "effect": ">=4.0.0-beta.47"
+    "effect": ">=4.0.0-beta.64"
   },
   "peerDependenciesMeta": {
     "effect": {
       "optional": false
     }
-  },
-  "overrides": {
-    "effect": "4.0.0-beta.47"
   }
 }

package/v3/dist/actor.d.ts

@@ -220,7 +220,7 @@ declare const buildActorRefCore: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R, SD extends SlotsDef>(id: string, machine: Machine<S, E, R, any, any, SD>, stateRef: SubscriptionRef.SubscriptionRef<S>, eventQueueRef: Ref.Ref<Queue.Queue<QueuedEvent<E>>>, stoppedRef: Ref.Ref<boolean>, listeners: Listeners<S>, stop: Effect.Effect<void>, start: Effect.Effect<void>, system: ActorSystem, childrenMap: ReadonlyMap<string, ActorRef<AnyState, unknown>>, pendingReplies: Set<Deferred.Deferred<unknown, unknown>>, transitionsPubSub: PubSub.PubSub<TransitionInfo<S, E>> | undefined, exitDeferred: Deferred.Deferred<ActorExit<S>, never>) => ActorRef<S, E>;
+}, R, SD extends SlotsDef>(id: string, machine: Machine<S, E, R, any, any, SD>, stateRef: SubscriptionRef.SubscriptionRef<S>, eventQueueRef: Ref.Ref<Queue.Queue<QueuedEvent<E>>>, stoppedRef: Ref.Ref<boolean>, listeners: Listeners<S>, stop: Effect.Effect<void>, start: Effect.Effect<void>, system: ActorSystem, childrenMap: ReadonlyMap<string, ActorRef<AnyState, unknown>>, pendingReplies: Set<Deferred.Deferred<unknown, unknown>>, transitionsPubSub: PubSub.PubSub<TransitionInfo<S, E>> | undefined, exitDeferred: Deferred.Deferred<ActorExit<S>>) => ActorRef<S, E>;
 /**
  * Create and start an actor for a machine.
  * Delegates to the shared runtime kernel with actor-specific lifecycle hooks.

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

@@ -43,7 +43,7 @@ interface EntityMachineOptions<S, E> {
    * Retry policy for defects (schedule for restarting after defect).
    * Forwarded to Entity.toLayer.
    */
-  readonly defectRetryPolicy?: Schedule.Schedule<any, unknown>;
+  readonly defectRetryPolicy?: Schedule.Schedule<any>;
   /**
    * Persistence configuration. When set, requires PersistenceAdapter in R.
    */

package/v3/dist/cluster/entity-machine.js

@@ -3,7 +3,7 @@ import { replay } from "../machine.js";
 import { createRuntime } from "../internal/runtime.js";
 import { ActorSystem } from "../actor.js";
 import { PersistenceAdapter } from "./persistence.js";
-import { Effect, Option, Ref } from "effect";
+import { Clock, Effect, Option, Ref } from "effect";
 import { Entity } from "@effect/cluster";
 //#region src/cluster/entity-machine.ts
 /**
@@ -56,10 +56,11 @@ const EntityMachine = { layer: (entity, machine, options) => {
 			yield* Effect.addFinalizer(() => Effect.gen(function* () {
 				const state = yield* runtime.getState;
 				const version = yield* Ref.get(versionRef);
+				const now = yield* Clock.currentTimeMillis;
 				yield* pAdapter.saveSnapshot(key, {
 					state,
 					version,
-					timestamp: Date.now()
+					timestamp: now
 				});
 			}).pipe(Effect.catchAll(() => Effect.void)));
 		}
@@ -153,7 +154,7 @@ const persistEvent = (adapter, key, versionRef, event) => Effect.gen(function* (
 	const persisted = {
 		event,
 		version: newVersion,
-		timestamp: Date.now()
+		timestamp: yield* Clock.currentTimeMillis
 	};
 	yield* adapter.appendEvents(key, [persisted], expectedVersion);
 	yield* Ref.set(versionRef, newVersion);

package/v3/dist/cluster/index.js

@@ -1,6 +1,6 @@
-import { makeEntityActorRef } from "./entity-actor-ref.js";
 import { PersistenceAdapter } from "./persistence.js";
-import { EntityMachine } from "./entity-machine.js";
 import { toEntity } from "./to-entity.js";
+import { EntityMachine } from "./entity-machine.js";
+import { makeEntityActorRef } from "./entity-actor-ref.js";
 import { makeInMemoryPersistenceAdapter } from "./adapters/in-memory.js";
 export { EntityMachine, PersistenceAdapter, makeEntityActorRef, makeInMemoryPersistenceAdapter, toEntity };

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

@@ -1,5 +1,6 @@
 import { Machine } from "../machine.js";
 import { Schema } from "effect";
+import { Entity } from "@effect/cluster";
 import { Rpc } from "@effect/rpc";
 
 //#region src/cluster/to-entity.d.ts
@@ -21,9 +22,9 @@ interface ToEntityOptions {
  */
 type EntityRpcs<StateSchema extends Schema.Schema.Any, EventSchema extends Schema.Schema.Any> = readonly [Rpc.Rpc<"Send", Schema.Struct<{
   readonly event: EventSchema;
-}>, StateSchema, typeof Schema.Never, never>, Rpc.Rpc<"Ask", Schema.Struct<{
+}>, StateSchema, typeof Schema.Never>, Rpc.Rpc<"Ask", Schema.Struct<{
   readonly event: EventSchema;
-}>, typeof Schema.Unknown, typeof Schema.Never, never>, Rpc.Rpc<"GetState", typeof Schema.Void, StateSchema, typeof Schema.Never, never>];
+}>, typeof Schema.Unknown, typeof Schema.Never>, Rpc.Rpc<"GetState", typeof Schema.Void, StateSchema, typeof Schema.Never>];
 /**
  * Generate an Entity definition from a machine.
  *
@@ -59,6 +60,10 @@ declare const toEntity: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R>(machine: Machine<S, E, R, any, any, any>, options: ToEntityOptions) => any;
+}, R>(machine: Machine<S, E, R, any, any, any>, options: ToEntityOptions) => Entity.Entity<string, Rpc.Rpc<"Send", Schema.Struct<{
+  event: Schema.Schema<E, E, never>;
+}>, Schema.Schema<S, S, never>, typeof Schema.Never, never> | Rpc.Rpc<"Ask", Schema.Struct<{
+  event: Schema.Schema<E, E, never>;
+}>, typeof Schema.Unknown, typeof Schema.Never, never> | Rpc.Rpc<"GetState", typeof Schema.Void, Schema.Schema<S, S, never>, typeof Schema.Never, never>>;
 //#endregion
 export { EntityRpcs, ToEntityOptions, toEntity };

package/v3/dist/index.js

@@ -4,6 +4,6 @@ import { Slot } from "./slot.js";
 import { machine_exports } from "./machine.js";
 import { ActorExit, Supervision } from "./supervision.js";
 import { ActorScope, ActorSystem, Default } from "./actor.js";
-import { Event, State } from "./schema.js";
 import { assertNeverReaches, assertPath, assertReaches, createTestHarness, simulate } from "./testing.js";
+import { Event, State } from "./schema.js";
 export { ActorExit, ActorScope, ActorStoppedError, Default as ActorSystemDefault, ActorSystem as ActorSystemService, AssertionError, DuplicateActorError, Event, Inspector as InspectorService, InvalidSchemaError, machine_exports as Machine, MissingMatchHandlerError, MissingSchemaError, NoReplyError, PersistenceError, ProvisionValidationError, Slot, SlotCodecError, SlotProvisionError, State, Supervision, VersionConflictError, assertNeverReaches, assertPath, assertReaches, collectingInspector, combineInspectors, consoleInspector, createTestHarness, makeInspector, makeInspectorEffect, simulate, tracingInspector };

package/v3/dist/inspection.d.ts

@@ -93,7 +93,7 @@ type AnyInspectionEvent = InspectionEvent<{
 /**
  * Inspector interface for observing machine behavior
  */
-type InspectorHandler<S, E> = (event: InspectionEvent<S, E>) => void | Effect.Effect<void, never, never>;
+type InspectorHandler<S, E> = (event: InspectionEvent<S, E>) => void | Effect.Effect<void>;
 interface Inspector<S, E> {
   readonly onInspect: InspectorHandler<S, E>;
 }
@@ -119,7 +119,7 @@ declare const makeInspectorEffect: <S = {
   readonly _tag: string;
 }, E = {
   readonly _tag: string;
-}>(onInspect: (event: InspectionEvent<ResolveType<S>, ResolveType<E>>) => Effect.Effect<void, never, never>) => Inspector<ResolveType<S>, ResolveType<E>>;
+}>(onInspect: (event: InspectionEvent<ResolveType<S>, ResolveType<E>>) => Effect.Effect<void>) => Inspector<ResolveType<S>, ResolveType<E>>;
 declare const combineInspectors: <S, E>(...inspectors: ReadonlyArray<Inspector<S, E>>) => Inspector<S, E>;
 interface TracingInspectorOptions<S, E> {
   readonly spanName?: string | ((event: InspectionEvent<S, E>) => string);

package/v3/dist/inspection.js

@@ -106,30 +106,16 @@ const tracingInspector = (options) => ({ onInspect: (event) => {
 /**
 * Console inspector that logs events in a readable format
 */
-const consoleInspector = () => makeInspector((event) => {
+const consoleInspector = () => makeInspectorEffect((event) => {
 	const prefix = `[${event.actorId}]`;
 	switch (event.type) {
-		case "@machine.spawn":
-			console.log(prefix, "spawned →", event.initialState._tag);
-			break;
-		case "@machine.event":
-			console.log(prefix, "received", event.event._tag, "in", event.state._tag);
-			break;
-		case "@machine.transition":
-			console.log(prefix, event.fromState._tag, "→", event.toState._tag);
-			break;
-		case "@machine.effect":
-			console.log(prefix, event.effectType, "effect in", event.state._tag);
-			break;
-		case "@machine.task":
-			console.log(prefix, "task", event.phase, event.taskName ?? "<unnamed>", "in", event.state._tag);
-			break;
-		case "@machine.error":
-			console.log(prefix, "error in", event.phase, event.state._tag, "-", event.error);
-			break;
-		case "@machine.stop":
-			console.log(prefix, "stopped in", event.finalState._tag);
-			break;
+		case "@machine.spawn": return Effect.log(`${prefix} spawned -> ${event.initialState._tag}`);
+		case "@machine.event": return Effect.log(`${prefix} received ${event.event._tag} in ${event.state._tag}`);
+		case "@machine.transition": return Effect.log(`${prefix} ${event.fromState._tag} -> ${event.toState._tag}`);
+		case "@machine.effect": return Effect.log(`${prefix} ${event.effectType} effect in ${event.state._tag}`);
+		case "@machine.task": return Effect.log(`${prefix} task ${event.phase} ${event.taskName ?? "<unnamed>"} in ${event.state._tag}`);
+		case "@machine.error": return Effect.log(`${prefix} error in ${event.phase} ${event.state._tag} - ${String(event.error)}`);
+		case "@machine.stop": return Effect.log(`${prefix} stopped in ${event.finalState._tag}`);
 	}
 });
 /**

package/v3/dist/internal/runtime.d.ts

@@ -1,8 +1,8 @@
 import { NoReplyError } from "../errors.js";
-import { MachineContext, SlotsDef } from "../slot.js";
+import { SlotsDef } from "../slot.js";
 import { ActorExit } from "../supervision.js";
 import { ProcessEventHooks, ProcessEventResult } from "./transition.js";
-import { Machine, MachineRef } from "../machine.js";
+import { Machine } from "../machine.js";
 import { ActorSystem } from "../actor.js";
 import { Deferred, Effect, Queue, Ref, Scope, SubscriptionRef } from "effect";
 
@@ -27,7 +27,7 @@ type RuntimeQueuedEvent<E> = {
   readonly reply: Deferred.Deferred<unknown, NoReplyError>;
 } | {
   readonly _tag: "drain";
-  readonly done: Deferred.Deferred<void, never>;
+  readonly done: Deferred.Deferred<void>;
 };
 /**
  * Resources owned by the actor cell (stable across generations).
@@ -69,7 +69,7 @@ interface RuntimeHandle<S, E> {
    * Exit deferred — set exactly once with the exit reason when the runtime stops.
    * Final state → ActorExit.Final, explicit stop → ActorExit.Stopped, defect → ActorExit.Defect.
    */
-  readonly exitDeferred: Deferred.Deferred<ActorExit<S>, never>;
+  readonly exitDeferred: Deferred.Deferred<ActorExit<S>>;
   /**
    * Actor scope — owns background fibers for this generation.
    * Closing this scope interrupts all background fibers.
@@ -145,7 +145,7 @@ declare const createRuntime: <S extends {
   readonly _tag: string;
 }, R, SD extends SlotsDef>(machine: Machine<S, E, R, any, any, SD>, system: ActorSystem, config: RuntimeConfig<S, E>) => Effect.Effect<{
   stop: Effect.Effect<void, never, never>;
-  start: Effect.Effect<void, unknown, Exclude<R, MachineContext<S, E, MachineRef<E>>> | Exclude<Exclude<R, MachineContext<S, E, MachineRef<E>>>, Scope.Scope>>;
+  start: Effect.Effect<void, unknown, unknown>;
   send: (event: E) => Effect.Effect<void>;
   sendWait: (event: E) => Effect.Effect<void, unknown>;
   ask: (event: E) => Effect.Effect<unknown, NoReplyError>;

package/v3/dist/internal/runtime.js

@@ -105,15 +105,13 @@ const createRuntime = Effect.fn("effect-machine.runtime.create")(function* (mach
 		}
 		if (lifecycle?.onInitialSpawnEffects !== void 0) yield* lifecycle.onInitialSpawnEffects(machine.initial);
 		const initialSpawnDefectSignal = (cause) => Deferred.succeed(exitDeferred, ActorExit.Defect(cause, "initial-spawn")).pipe(Effect.andThen(Ref.set(stoppedRef, true)), Effect.andThen(Effect.suspend(() => loopFiberRef.current !== void 0 ? Fiber.interrupt(loopFiberRef.current) : Effect.void)), Effect.asVoid);
-		yield* runSpawnEffects(machine, machine.initial, initEvent, self, stateScopeRef.current, system, actorId, hooks?.onError, initialSpawnDefectSignal).pipe(Effect.catchAllCause((cause) => {
-			return Effect.gen(function* () {
-				yield* Ref.set(stoppedRef, true);
-				yield* Scope.close(stateScopeRef.current, Exit.void);
-				yield* Scope.close(actorScope, Exit.void);
-				yield* Deferred.succeed(exitDeferred, ActorExit.Defect(cause, "initial-spawn"));
-				return yield* Effect.failCause(cause);
-			});
-		}));
+		yield* runSpawnEffects(machine, machine.initial, initEvent, self, stateScopeRef.current, system, actorId, hooks?.onError, initialSpawnDefectSignal).pipe(Effect.catchAllCause((cause) => Effect.gen(function* () {
+			yield* Ref.set(stoppedRef, true);
+			yield* Scope.close(stateScopeRef.current, Exit.void);
+			yield* Scope.close(actorScope, Exit.void);
+			yield* Deferred.succeed(exitDeferred, ActorExit.Defect(cause, "initial-spawn"));
+			return yield* Effect.failCause(cause);
+		})));
 		if (machine.finalStates.has(machine.initial._tag)) {
 			if (lifecycle?.onFinal !== void 0) yield* lifecycle.onFinal(machine.initial);
 			yield* Ref.set(stoppedRef, true);
@@ -262,13 +260,10 @@ const runtimeEventLoop = Effect.fn("effect-machine.runtime.eventLoop")(function*
 				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) {
+						const decoded = yield* Schema.decodeUnknown(replySchema)(result.reply).pipe(Effect.catchAll((decodeError) => Effect.gen(function* () {
 							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 if (result.deferReply && deferredReplyRef !== void 0) deferredReplyRef.current = queued.reply;

package/v3/dist/machine.js

@@ -178,7 +178,8 @@ var Machine = class Machine {
 		this._slots = this._slotsSchema !== void 0 ? this._slotsSchema._createSlots(resolve) : {};
 	}
 	from(stateOrStates, build) {
-		build(new TransitionScope(this, Array.isArray(stateOrStates) ? stateOrStates : [stateOrStates]));
+		const states = Array.isArray(stateOrStates) ? stateOrStates : [stateOrStates];
+		build(new TransitionScope(this, states));
 		return this;
 	}
 	/** @internal */