effect-machine 0.15.2 → 0.17.0

package/dist/internal/transition.d.ts

@@ -1,6 +1,6 @@
-import { MachineContext, SlotsDef } from "../slot.js";
+import { MachineContextTag, SlotsDef } from "../slot.js";
 import { Machine, MachineRef, SpawnEffect, Transition } from "../machine.js";
-import { ActorSystem } from "../actor.js";
+import { ActorSystemService } from "../actor.js";
 import { Cause, Effect, Scope } from "effect";
 
 //#region src/internal/transition.d.ts
@@ -29,12 +29,12 @@ declare const runTransitionHandler: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R, SD extends SlotsDef>(machine: Machine<S, E, R, any, any, SD>, transition: Transition<S, E, SD, R>, state: S, event: E, self: MachineRef<E>, system: ActorSystem, actorId: string) => Effect.Effect<{
+}, R, SD extends SlotsDef>(machine: Machine<S, E, R, any, any, SD>, transition: Transition<S, E, SD, R>, state: S, event: E, self: MachineRef<E>, system: ActorSystemService, actorId: string) => Effect.Effect<{
   newState: S;
   hasReply: boolean;
   deferReply: boolean;
   reply: unknown;
-}, never, Exclude<R, MachineContext<S, E, MachineRef<E>>>>;
+}, never, Exclude<R, MachineContextTag>>;
 /**
  * Execute a transition for a given state and event.
  * Handles transition resolution, handler invocation, and guard/effect slot creation.
@@ -50,14 +50,14 @@ declare const executeTransition: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R, SD extends SlotsDef>(machine: Machine<S, E, R, any, any, SD>, currentState: S, event: E, self: MachineRef<E>, system: ActorSystem, actorId: string) => Effect.Effect<{
+}, R, SD extends SlotsDef>(machine: Machine<S, E, R, any, any, SD>, currentState: S, event: E, self: MachineRef<E>, system: ActorSystemService, actorId: string) => Effect.Effect<{
   newState: S;
   transitioned: boolean;
   reenter: boolean;
   hasReply: boolean;
   deferReply: boolean;
   reply: unknown;
-}, never, Exclude<R, MachineContext<S, E, MachineRef<E>>>>;
+}, never, Exclude<R, MachineContextTag>>;
 /**
  * Optional hooks for event processing inspection/tracing.
  */
@@ -130,7 +130,7 @@ declare const processEventCore: <S extends {
   readonly _tag: string;
 }, R, SD extends SlotsDef>(machine: Machine<S, E, R, any, any, SD>, currentState: S, event: E, self: MachineRef<E>, stateScopeRef: {
   current: Scope.Closeable;
-}, system: ActorSystem, actorId: string, hooks?: ProcessEventHooks<S, E> | undefined) => Effect.Effect<{
+}, system: ActorSystemService, actorId: string, hooks?: ProcessEventHooks<S, E> | undefined) => Effect.Effect<{
   newState: S;
   previousState: S;
   transitioned: boolean;
@@ -140,7 +140,7 @@ declare const processEventCore: <S extends {
   deferReply: boolean;
   reply: unknown;
   postponed: boolean;
-}, never, Exclude<R, MachineContext<S, E, MachineRef<E>>> | Exclude<Exclude<R, MachineContext<S, E, MachineRef<E>>>, Scope.Scope>>;
+}, never, Exclude<R, MachineContextTag> | Exclude<Exclude<R, MachineContextTag>, Scope.Scope>>;
 /**
  * Run spawn effects for a state (forked into state scope, auto-cancelled on state exit).
  *
@@ -150,7 +150,7 @@ declare const runSpawnEffects: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R, SD extends SlotsDef>(machine: Machine<S, E, R, any, any, SD>, state: S, event: E, self: MachineRef<E>, stateScope: Scope.Closeable, system: ActorSystem, actorId: string, onError?: ((info: ProcessEventError<S, E>) => Effect.Effect<void>) | undefined, onSpawnDefect?: ((cause: Cause.Cause<unknown>) => Effect.Effect<void>) | undefined) => Effect.Effect<void, never, Exclude<Exclude<R, MachineContext<S, E, MachineRef<E>>>, Scope.Scope>>;
+}, R, SD extends SlotsDef>(machine: Machine<S, E, R, any, any, SD>, state: S, event: E, self: MachineRef<E>, stateScope: Scope.Closeable, system: ActorSystemService, actorId: string, onError?: ((info: ProcessEventError<S, E>) => Effect.Effect<void>) | undefined, onSpawnDefect?: ((cause: Cause.Cause<unknown>) => Effect.Effect<void>) | undefined) => Effect.Effect<void, never, Exclude<Exclude<R, MachineContextTag>, Scope.Scope>>;
 /**
  * Resolve which transition should fire for a given state and event.
  * Uses indexed O(1) lookup. First matching transition wins.

package/dist/internal/utils.d.ts

@@ -1,4 +1,4 @@
-import { ActorSystem } from "../actor.js";
+import { ActorSystemService } from "../actor.js";
 import { Effect } from "effect";
 
 //#region src/internal/utils.d.ts
@@ -91,11 +91,11 @@ declare const getTag: (constructorOrValue: {
 /** Check if a value is an Effect */
 declare const isEffect: (value: unknown) => value is Effect.Effect<unknown, unknown, unknown>;
 /**
- * Stub ActorSystem that dies on any method call.
+ * Stub ActorSystemService that dies on any method call.
  * Used in contexts where spawning/system access isn't supported
  * (testing simulation, persistent actor replay).
  * @internal
  */
-declare const stubSystem: ActorSystem;
+declare const stubSystem: ActorSystemService;
 //#endregion
 export { ArgsOf, DeferReplyResult, DeferReplySymbol, INTERNAL_ENTER_EVENT, INTERNAL_INIT_EVENT, InstanceOf, ReplyResult, ReplyResultSymbol, TagOf, TaggedConstructor, TransitionResult, getTag, isDeferReplyResult, isEffect, isReplyResult, makeDeferReply, makeReply, stubSystem };

package/dist/internal/utils.js

@@ -56,7 +56,7 @@ const getTag = (constructorOrValue) => {
 /** Check if a value is an Effect */
 const isEffect = Effect.isEffect;
 /**
-* Stub ActorSystem that dies on any method call.
+* Stub ActorSystemService that dies on any method call.
 * Used in contexts where spawning/system access isn't supported
 * (testing simulation, persistent actor replay).
 * @internal

package/dist/machine.d.ts

@@ -2,15 +2,15 @@ import { DeferReplyResult, ReplyResult, TransitionResult } from "./internal/util
 import { BrandedEvent, BrandedState, ExtractReply, TaggedOrConstructor } from "./internal/brands.js";
 import { MachineEventSchema, MachineStateSchema, VariantsUnion } from "./schema.js";
 import { DuplicateActorError } from "./errors.js";
-import { MachineContext, ProvideSlots, SlotCalls, SlotsDef, SlotsSchema } from "./slot.js";
+import { MachineContext, MachineContextTag, ProvideSlots, SlotCalls, SlotsDef, SlotsSchema } from "./slot.js";
 import { Supervision } from "./supervision.js";
 import { findTransitions } from "./internal/transition.js";
-import { ActorRef, ActorSystem } from "./actor.js";
-import { Cause, Duration, Effect, Option, Schema, Scope, ServiceMap } from "effect";
+import { ActorRef, ActorSystemService } from "./actor.js";
+import { Cause, Context, Duration, Effect, Option, Schema, Scope } from "effect";
 
 //#region src/machine.d.ts
 declare namespace machine_d_exports {
-  export { BackgroundEffect, DeferReplyResult, Durability, DurabilityCommit, HandlerContext, Lifecycle, Machine, MachineRef, MakeConfig, Recovery, RecoveryContext, ReplyResult, SpawnEffect, StateEffectHandler, StateHandlerContext, TaskOptions, TimeoutConfig, Transition, TransitionHandler, deferReply, findTransitions, make, materializeMachine, replay, reply, spawn };
+  export { BackgroundEffect, DeferReplyResult, Durability, DurabilityCommit, HandlerContext, Lifecycle, Machine, MachineRef, MakeConfig, Recovery, RecoveryContext, ReplyResult, SpawnEffect, StateEffectHandler, StateHandlerContext, TaskOptions, TimeoutConfig, Transition, TransitionHandler, deferReply, findTransitions, make, materializeMachine, replay, reply, scoped, spawn };
 }
 /**
  * Self reference for sending events back to the machine
@@ -48,7 +48,7 @@ interface StateHandlerContext<State, Event, SD extends SlotsDef = Record<string,
   readonly event: Event;
   readonly self: MachineRef<Event>;
   readonly slots: SlotCalls<SD>;
-  readonly system: ActorSystem;
+  readonly system: ActorSystemService;
 }
 /**
  * Transition handler function.
@@ -196,7 +196,7 @@ declare class Machine<State, Event, R = never, _SD extends Record<string, Schema
    * Context tag for accessing machine state/event/self in slot handlers.
    * Uses shared module-level tag for all machines.
    */
-  readonly Context: ServiceMap.Service<MachineContext<State, Event, MachineRef<Event>>, MachineContext<State, Event, MachineRef<Event>>>;
+  readonly Context: Context.Service<MachineContextTag, MachineContext<State, Event, MachineRef<Event>>>;
   get transitions(): ReadonlyArray<Transition<State, Event, SD, R>>;
   get spawnEffects(): ReadonlyArray<SpawnEffect<State, Event, SD, R>>;
   get backgroundEffects(): ReadonlyArray<BackgroundEffect<State, Event, SD, R>>;
@@ -362,6 +362,26 @@ declare const spawn: <S extends {
   supervision?: Supervision.Policy;
   lifecycle?: Lifecycle<S, E>;
 }) => Effect.Effect<ActorRef<S, E>, never, R>;
+/**
+ * Wrap an effect to provide an `ActorScope` from the current `Scope`.
+ *
+ * Actors spawned inside will attach cleanup finalizers to this scope,
+ * so they are automatically stopped when the scope closes.
+ *
+ * @example
+ * ```ts
+ * yield* Effect.scoped(
+ *   Machine.scoped(
+ *     Effect.gen(function* () {
+ *       const actor = yield* Machine.spawn(machine);
+ *       yield* actor.start;
+ *       // actor auto-stopped when scope closes
+ *     }),
+ *   ),
+ * );
+ * ```
+ */
+declare const scoped: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R | Scope.Scope>;
 declare const replay: {
   <S extends {
     readonly _tag: string;
@@ -375,4 +395,4 @@ declare const replay: {
 declare const reply: <State, Reply>(state: State, reply: Reply) => ReplyResult<State, Reply>;
 declare const deferReply: <State>(state: State) => DeferReplyResult<State>;
 //#endregion
-export { BackgroundEffect, type DeferReplyResult, Durability, DurabilityCommit, HandlerContext, Lifecycle, Machine, MachineRef, MakeConfig, Recovery, RecoveryContext, type ReplyResult, SpawnEffect, StateEffectHandler, StateHandlerContext, TaskOptions, TimeoutConfig, Transition, TransitionHandler, deferReply, findTransitions, machine_d_exports, make, materializeMachine, replay, reply, spawn };
+export { BackgroundEffect, type DeferReplyResult, Durability, DurabilityCommit, HandlerContext, Lifecycle, Machine, MachineRef, MakeConfig, Recovery, RecoveryContext, type ReplyResult, SpawnEffect, StateEffectHandler, StateHandlerContext, TaskOptions, TimeoutConfig, Transition, TransitionHandler, deferReply, findTransitions, machine_d_exports, make, materializeMachine, replay, reply, scoped, spawn };

package/dist/machine.js

@@ -5,7 +5,7 @@ import { findTransitions, invalidateIndex, resolveTransition, runTransitionHandl
 import { emitWithTimestamp } from "./internal/inspection.js";
 import { Inspector } from "./inspection.js";
 import { MachineContextTag } from "./slot.js";
-import { createActor } from "./actor.js";
+import { ActorScope, createActor } from "./actor.js";
 import { Cause, Effect, Exit, Option, Random, Schema, Scope } from "effect";
 //#region src/machine.ts
 var machine_exports = /* @__PURE__ */ __exportAll({
@@ -16,6 +16,7 @@ var machine_exports = /* @__PURE__ */ __exportAll({
 	materializeMachine: () => materializeMachine,
 	replay: () => replay,
 	reply: () => reply,
+	scoped: () => scoped,
 	spawn: () => spawn
 });
 const emitTaskInspection = (input) => Effect.flatMap(Effect.serviceOption(Inspector), (inspector) => Option.isNone(inspector) ? Effect.void : emitWithTimestamp(inspector.value, (timestamp) => ({
@@ -177,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 */
@@ -411,10 +413,30 @@ const spawn = Effect.fn("effect-machine.spawn")(function* (machine, idOrOptions)
 		supervision: opts?.supervision,
 		lifecycle: opts?.lifecycle
 	});
-	const maybeScope = yield* Effect.serviceOption(Scope.Scope);
+	const maybeScope = yield* Effect.serviceOption(ActorScope);
 	if (Option.isSome(maybeScope)) yield* Scope.addFinalizer(maybeScope.value, actor.stop);
 	return actor;
 });
+/**
+* Wrap an effect to provide an `ActorScope` from the current `Scope`.
+*
+* Actors spawned inside will attach cleanup finalizers to this scope,
+* so they are automatically stopped when the scope closes.
+*
+* @example
+* ```ts
+* yield* Effect.scoped(
+*   Machine.scoped(
+*     Effect.gen(function* () {
+*       const actor = yield* Machine.spawn(machine);
+*       yield* actor.start;
+*       // actor auto-stopped when scope closes
+*     }),
+*   ),
+* );
+* ```
+*/
+const scoped = (effect) => Effect.flatMap(Effect.service(Scope.Scope), (scope) => Effect.provideService(effect, ActorScope, scope));
 const replay = Effect.fn("effect-machine.replay")(function* (input, events, options) {
 	const machine = materializeMachine(input, options?.slots);
 	let state = options?.from ?? machine.initial;
@@ -462,4 +484,4 @@ const replay = Effect.fn("effect-machine.replay")(function* (input, events, opti
 const reply = makeReply;
 const deferReply = makeDeferReply;
 //#endregion
-export { Machine, deferReply, findTransitions, machine_exports, make, materializeMachine, replay, reply, spawn };
+export { Machine, deferReply, findTransitions, machine_exports, make, materializeMachine, replay, reply, scoped, spawn };

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,5 +1,5 @@
-import { ActorSystem } from "./actor.js";
-import { Effect, Schema, ServiceMap } from "effect";
+import { ActorSystemService } from "./actor.js";
+import { Context, Effect, Schema } from "effect";
 
 //#region src/slot.d.ts
 /** Schema fields definition (like Schema.Struct.Fields) */
@@ -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: ServiceMap.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 { Schema, ServiceMap } 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 = ServiceMap.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.15.2",
+  "version": "0.17.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/cevr/effect-machine.git"
@@ -40,47 +40,47 @@
     "access": "public"
   },
   "scripts": {
-    "typecheck": "tsc --noEmit",
-    "typecheck:v3": "tsc --noEmit -p v3/tsconfig.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",
-    "test": "bun test",
-    "test:v3": "bun test --tsconfig-override=v3/tsconfig.json v3/test/",
+    "test": "bun test --tsconfig-override=tsconfig.json",
+    "test:v3": "cd v3 && bun test --tsconfig-override=tsconfig.json ./test/",
     "test:watch": "bun test --watch",
-    "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\" \"bun run build\"",
-    "prepare": "lefthook install || true && effect-language-service patch",
+    "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 && effect-tsgo patch",
     "version": "changeset version",
-    "build": "tsdown && tsdown --config v3/tsdown.config.ts",
+    "build": "concurrently -n v4,v3 -c cyan,magenta \"tsdown\" \"tsdown --config v3/tsdown.config.ts\"",
     "release": "bun run build && changeset publish"
   },
-  "dependencies": {
-    "effect": "4.0.0-beta.43"
-  },
   "devDependencies": {
     "@changesets/changelog-github": "^0.6.0",
     "@changesets/cli": "^2.30.0",
-    "@effect/language-service": "^0.84.2",
-    "@types/bun": "1.3.11",
+    "@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.20260507.1",
     "concurrently": "^9.2.1",
+    "effect": "4.0.0-beta.63",
     "effect-bun-test": "0.3.0",
-    "effect-v3": "npm:effect@^3.21.0",
-    "lefthook": "^2.1.4",
-    "oxfmt": "^0.42.0",
-    "oxlint": "^1.57.0",
+    "effect-v3": "npm:effect@3.21.2",
+    "lefthook": "^2.1.5",
+    "oxfmt": "^0.44.0",
+    "oxlint": "^1.63.0",
+    "oxlint-tsgolint": "^0.22.1",
     "tsdown": "^0.21.7",
-    "typescript": "^5.9.3"
+    "typescript": "^6.0.2"
   },
   "peerDependencies": {
-    "effect": ">=3.19.16"
+    "effect": ">=4.0.0-beta.63"
   },
   "peerDependenciesMeta": {
     "effect": {
       "optional": false
     }
-  },
-  "overrides": {
-    "effect": "4.0.0-beta.43"
   }
 }

package/v3/dist/actor.d.ts

@@ -197,6 +197,16 @@ interface ActorSystem {
  * ActorSystem service tag
  */
 declare const ActorSystem: Context.Tag<ActorSystem, ActorSystem>;
+/**
+ * Explicit scope for actor lifecycle management.
+ *
+ * When present in context, actors attach cleanup finalizers to this scope.
+ * This replaces ambient `Scope.Scope` detection which caused bugs where
+ * unrelated scopes would tear down actors unexpectedly.
+ *
+ * Provide via `Machine.scoped` or `Effect.provideService(ActorScope, scope)`.
+ */
+declare const ActorScope: Context.Tag<Scope.Scope, Scope.Scope>;
 /** Listener set for sync subscriptions */
 type Listeners<S> = Set<(state: S) => void>;
 /**
@@ -210,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.
@@ -237,4 +247,4 @@ declare const makeSystem: () => Effect.Effect<ActorSystem, never, Scope.Scope>;
  */
 declare const Default: Layer.Layer<ActorSystem, never, never>;
 //#endregion
-export { ActorRef, ActorRefSync, ActorSystem, Default, Listeners, type ProcessEventError, type ProcessEventHooks, type ProcessEventResult, QueuedEvent, SystemEvent, SystemEventListener, TransitionInfo, buildActorRefCore, createActor, makeSystem, notifyListeners, processEventCore, resolveTransition, runSpawnEffects, settlePendingReplies };
+export { ActorRef, ActorRefSync, ActorScope, ActorSystem, Default, Listeners, type ProcessEventError, type ProcessEventHooks, type ProcessEventResult, QueuedEvent, SystemEvent, SystemEventListener, TransitionInfo, buildActorRefCore, createActor, makeSystem, notifyListeners, processEventCore, resolveTransition, runSpawnEffects, settlePendingReplies };