effect-machine 0.17.1 → 0.18.0

package/v3/dist/schema.js

@@ -1,206 +0,0 @@
-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
-*/
-const ReplySchemaSymbol = Symbol.for("effect-machine/ReplySchema");
-/**
-* Build a schema-first definition from a record of tag -> fields
-*/
-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) {
-			const constructor = (args) => ({
-				...args,
-				_tag: tag
-			});
-			constructor._tag = tag;
-			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)) {
-					if (RESERVED_DERIVE_KEYS.has(key)) continue;
-					if (!fieldNames.has(key)) continue;
-					result[key] = value;
-				}
-				return result;
-			};
-			constructors[tag] = constructor;
-		} else constructors[tag] = {
-			_tag: tag,
-			with: () => ({ _tag: tag })
-		};
-	}
-	const variantArray = Object.values(variants);
-	if (variantArray.length === 0) throw new InvalidSchemaError({ message: "Schema must have at least one variant" });
-	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,
-		replySchemas,
-		$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, replySchemas, $is, $match } = buildMachineSchema(definition);
-	const withFn = (source, partial) => {
-		const ctor = constructors[source._tag];
-		if (ctor === void 0) throw new MissingMatchHandlerError({ tag: source._tag });
-		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,
-		schema,
-		$is,
-		$match,
-		with: withFn,
-		...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).
-*
-* Use `Event.reply(fields, replySchema)` to define events that support
-* typed `ask()` replies.
-*
-* @example
-* ```ts
-* 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 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/v3/dist/slot.d.ts

@@ -1,158 +0,0 @@
-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 type from schema fields (used for parameters) */
-type FieldsToParams<F extends Fields> = keyof F extends never ? void : Schema.Schema.Type<Schema.Struct<F>>;
-/**
- * Definition of a single slot function.
- * Created via `Slot.fn(params, returnSchema?)`.
- *
- * Carries both type-level information and materialized schemas
- * for runtime validation and serialization.
- */
-interface SlotFnDef<F extends Fields = Fields, _Return = void> {
-  readonly _tag: "SlotFnDef";
-  readonly fields: F;
-  /** Return schema — undefined means void */
-  readonly returnSchema: Schema.Schema.Any | undefined;
-  /** Materialized input schema (Schema.Struct of fields, or Schema.Void for empty) */
-  readonly inputSchema: Schema.Schema.Any;
-  /** Materialized output schema (returnSchema or Schema.Void) */
-  readonly outputSchema: Schema.Schema.Any;
-}
-/**
- * Define a single slot function with parameter schema and optional return schema.
- *
- * @example
- * ```ts
- * // Guard-like: returns boolean
- * Slot.fn({ max: Schema.Number }, Schema.Boolean)
- *
- * // Effect-like: returns void (default)
- * Slot.fn({ url: Schema.String })
- *
- * // No params, returns boolean
- * Slot.fn({}, Schema.Boolean)
- * ```
- */
-declare const fn: {
-  <F extends Fields, S extends Schema.Schema.Any>(fields: F, returnSchema: S): SlotFnDef<F, Schema.Schema.Type<S>>;
-  <F extends Fields>(fields: F): SlotFnDef<F>;
-};
-/**
- * Record of slot definitions. Keys are slot names, values are SlotFnDef.
- */
-type SlotsDef = Record<string, SlotFnDef<Fields, unknown>>;
-/**
- * Slots schema — returned by `Slot.define()`. Passed to `Machine.make({ slots })`.
- */
-interface SlotsSchema<D extends SlotsDef> {
-  readonly _tag: "SlotsSchema";
-  readonly definitions: D;
-  /** Schema for slot requests `{ _tag: "SlotRequest", name, params }`. For RPC request payloads. */
-  readonly requestSchema: Schema.Schema<SlotRequest<D>>;
-  /** Schema for slot results `{ _tag: "SlotResult", name, result }`. For RPC response payloads. */
-  readonly resultSchema: Schema.Schema<SlotResult<D>>;
-  /** Schema for slot invocations `{ _tag: "SlotInvocation", name, params, result }`. For persistence/logging. */
-  readonly invocationSchema: Schema.Schema<SlotInvocation<D>>;
-  /** Create callable slot proxies (used by Machine internally) */
-  readonly _createSlots: (resolve: <N extends keyof D & string>(name: N, params: SlotParams<D[N]>) => Effect.Effect<SlotReturn<D[N]>>) => SlotCalls<D>;
-}
-/**
- * A serialized slot request — captures name and params (no result).
- * Used for RPC request payloads.
- */
-type SlotRequest<D extends SlotsDef> = { readonly [K in keyof D & string]: {
-  readonly _tag: "SlotRequest";
-  readonly name: K;
-  readonly params: SlotParams<D[K]>;
-} }[keyof D & string];
-/**
- * A serialized slot result — captures name and result (no params).
- * Used for RPC response payloads.
- */
-type SlotResult<D extends SlotsDef> = { readonly [K in keyof D & string]: {
-  readonly _tag: "SlotResult";
-  readonly name: K;
-  readonly result: SlotReturn<D[K]>;
-} }[keyof D & string];
-/**
- * A serialized slot invocation — captures name, params, and result.
- * Used for persistence, logging, and audit trails.
- */
-type SlotInvocation<D extends SlotsDef> = { readonly [K in keyof D & string]: {
-  readonly _tag: "SlotInvocation";
-  readonly name: K;
-  readonly params: SlotParams<D[K]>;
-  readonly result: SlotReturn<D[K]>;
-} }[keyof D & string];
-/** Extract params type from a SlotFnDef */
-type SlotParams<D extends SlotFnDef<Fields, unknown>> = D extends SlotFnDef<infer F, unknown> ? FieldsToParams<F> : never;
-/** Extract return type from a SlotFnDef */
-type SlotReturn<D extends SlotFnDef<Fields, unknown>> = D extends SlotFnDef<Fields, infer R> ? R : never;
-/**
- * A callable slot — function that takes params and returns Effect<Return>.
- */
-interface SlotCall<Name extends string, Params, Return> {
-  readonly _tag: "Slot";
-  readonly name: Name;
-  (params: Params): Effect.Effect<Return>;
-}
-/**
- * Convert slot definitions to callable slot proxies.
- */
-type SlotCalls<D extends SlotsDef> = { readonly [K in keyof D & string]: SlotCall<K, SlotParams<D[K]>, SlotReturn<D[K]>> };
-/**
- * Slot handler implementation.
- * Receives only params — use `yield* machine.Context` for machine context.
- */
-type SlotHandler<Params, Return, R = never> = (params: Params) => Return | Effect.Effect<Return, never, R>;
-/**
- * Handler implementations for all slots in a definition.
- */
-type ProvideSlots<D extends SlotsDef, R = never> = { readonly [K in keyof D & string]: SlotHandler<SlotParams<D[K]>, SlotReturn<D[K]>, R> };
-/** Check if a SlotsDef has any actual keys */
-type HasSlotKeys<SD extends SlotsDef> = [keyof SD] extends [never] ? false : SD extends Record<string, never> ? false : true;
-/**
- * Type for machine context — state, event, and self reference.
- * Shared across all machines via MachineContextTag.
- */
-interface MachineContext<State, Event, Self> {
-  readonly actorId: string;
-  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>>;
-/**
- * Define a set of slots with parameter and return schemas.
- *
- * @example
- * ```ts
- * const MySlots = Slot.define({
- *   canRetry: Slot.fn({ max: Schema.Number }, Schema.Boolean),
- *   fetchData: Slot.fn({ url: Schema.String }),
- *   notify: Slot.fn({ message: Schema.String }),
- * })
- * ```
- */
-declare const define: <D extends SlotsDef>(definitions: D) => SlotsSchema<D>;
-declare const Slot: {
-  readonly fn: {
-    <F extends Fields, S extends Schema.Schema.Any>(fields: F, returnSchema: S): SlotFnDef<F, Schema.Schema.Type<S>>;
-    <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/v3/dist/slot.js

@@ -1,165 +0,0 @@
-import { Context, Effect, Schema } from "effect";
-//#region src/slot.ts
-/**
-* Slot module — unified, schema-based parameterized slots.
-*
-* Replaces the split Guards/Effects API with a single `Slot.define` + `Slot.fn`.
-* Each slot declares its parameter schema and (optional) return schema.
-* Handlers receive only params — machine context is accessed via `yield* machine.Context`.
-*
-* @example
-* ```ts
-* import { Slot } from "effect-machine"
-* import { Schema } from "effect"
-*
-* const MySlots = Slot.define({
-*   canRetry: Slot.fn({ max: Schema.Number }, Schema.Boolean),
-*   isValid: Slot.fn({}, Schema.Boolean),
-*   fetchData: Slot.fn({ url: Schema.String }),
-*   notify: Slot.fn({ message: Schema.String }),
-* })
-*
-* // Used in handlers:
-* .on(State.X, Event.Y, ({ slots }) =>
-*   Effect.gen(function* () {
-*     if (yield* slots.canRetry({ max: 3 })) {
-*       yield* slots.fetchData({ url: "/api" })
-*       return State.Next
-*     }
-*     return state
-*   })
-* )
-* ```
-*
-* @module
-*/
-/**
-* Define a single slot function with parameter schema and optional return schema.
-*
-* @example
-* ```ts
-* // Guard-like: returns boolean
-* Slot.fn({ max: Schema.Number }, Schema.Boolean)
-*
-* // Effect-like: returns void (default)
-* Slot.fn({ url: Schema.String })
-*
-* // No params, returns boolean
-* Slot.fn({}, Schema.Boolean)
-* ```
-*/
-const fn = (fields, returnSchema) => {
-	return {
-		_tag: "SlotFnDef",
-		fields,
-		returnSchema,
-		inputSchema: Object.keys(fields).length > 0 ? Schema.Struct(fields) : Schema.Void,
-		outputSchema: returnSchema ?? Schema.Void
-	};
-};
-/**
-* Shared Context tag for all machines.
-* Single module-level tag instead of per-machine allocation.
-* @internal
-*/
-const MachineContextTag = Context.GenericTag("@effect-machine/Context");
-/**
-* Define a set of slots with parameter and return schemas.
-*
-* @example
-* ```ts
-* const MySlots = Slot.define({
-*   canRetry: Slot.fn({ max: Schema.Number }, Schema.Boolean),
-*   fetchData: Slot.fn({ url: Schema.String }),
-*   notify: Slot.fn({ message: Schema.String }),
-* })
-* ```
-*/
-const define = (definitions) => {
-	const names = Object.keys(definitions);
-	const requestSchemas = [];
-	const resultSchemas = [];
-	const invocationSchemas = [];
-	for (const name of names) {
-		const def = definitions[name];
-		if (def === void 0) continue;
-		requestSchemas.push(Schema.TaggedStruct("SlotRequest", {
-			name: Schema.Literal(name),
-			params: def.inputSchema
-		}));
-		resultSchemas.push(Schema.TaggedStruct("SlotResult", {
-			name: Schema.Literal(name),
-			result: def.outputSchema
-		}));
-		invocationSchemas.push(Schema.TaggedStruct("SlotInvocation", {
-			name: Schema.Literal(name),
-			params: def.inputSchema,
-			result: def.outputSchema
-		}));
-	}
-	const buildUnion = (schemas) => schemas.length === 0 ? Schema.Never : Schema.Union(...schemas);
-	return {
-		_tag: "SlotsSchema",
-		definitions,
-		requestSchema: buildUnion(requestSchemas),
-		resultSchema: buildUnion(resultSchemas),
-		invocationSchema: buildUnion(invocationSchemas),
-		_createSlots: (resolve) => {
-			const slots = {};
-			for (const name of names) {
-				const slot = (params) => resolve(name, params);
-				Object.defineProperty(slot, "_tag", {
-					value: "Slot",
-					enumerable: true
-				});
-				Object.defineProperty(slot, "name", {
-					value: name,
-					enumerable: true
-				});
-				slots[name] = slot;
-			}
-			return slots;
-		}
-	};
-};
-/**
-* 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,
-	of
-};
-//#endregion
-export { MachineContextTag, Slot, define, fn };

package/v3/dist/supervision.d.ts

@@ -1,97 +0,0 @@
-import { Cause, Duration, Schedule } from "effect";
-
-//#region src/supervision.d.ts
-/**
- * Where in the actor lifecycle a defect occurred.
- *
- * - `transition` — during event handler execution
- * - `spawn` — during state spawn effect execution
- * - `background` — in a background effect fiber
- * - `initial-spawn` — during initial state spawn effects (before event loop)
- */
-type DefectPhase = "transition" | "spawn" | "background" | "initial-spawn";
-/**
- * Terminal exit reason for an actor generation.
- *
- * - `Final` — machine reached a final state normally
- * - `Stopped` — explicit `actor.stop` or `actor.drain`
- * - `Defect` — unhandled error in the runtime
- */
-type ActorExit<S> = {
-  readonly _tag: "Final";
-  readonly state: S;
-} | {
-  readonly _tag: "Stopped";
-} | {
-  readonly _tag: "Defect";
-  readonly cause: Cause.Cause<unknown>;
-  readonly phase: DefectPhase;
-};
-/** Constructors for ActorExit */
-declare const ActorExit: {
-  readonly Final: <S>(state: S) => ActorExit<S>;
-  readonly Stopped: ActorExit<never>;
-  readonly Defect: <S = never>(cause: Cause.Cause<unknown>, phase: DefectPhase) => ActorExit<S>;
-};
-/**
- * Phase state for supervised actors. Serializes concurrent stop/restart/drain.
- *
- * Transitions:
- * - `Running` → crash → `Restarting` → new runtime → `Running`
- * - `Running` → explicit stop/drain → `Stopping` → `Terminated`
- * - `Restarting` → explicit stop → `Stopping` → `Terminated`
- *
- * @internal
- */
-type CellPhase<S> = {
-  readonly _tag: "Running";
-  readonly generation: number;
-} | {
-  readonly _tag: "Restarting";
-  readonly generation: number;
-} | {
-  readonly _tag: "Stopping";
-} | {
-  readonly _tag: "Terminated";
-  readonly exit: ActorExit<S>;
-};
-declare namespace Supervision {
-  /**
-   * Supervision policy for actor restart behavior.
-   *
-   * `schedule` controls restart timing and budget — schedule exhaustion means terminal stop.
-   * `shouldRestart` optionally classifies defects — return `false` to stop immediately
-   * without consuming the schedule.
-   */
-  interface Policy {
-    /** Schedule that controls restart timing. Exhaustion = terminal stop. */
-    readonly schedule: Schedule.Schedule<unknown>;
-    /**
-     * Optional classifier: given a defect exit, decide whether to restart or stop immediately.
-     * Default: always restart (let schedule handle budget).
-     */
-    readonly shouldRestart?: (exit: Extract<ActorExit<unknown>, {
-      readonly _tag: "Defect";
-    }>) => boolean;
-  }
-  /** No supervision — crashes are terminal. */
-  const none: Policy;
-  /**
-   * Restart on defect with max restarts within a window, optional backoff.
-   *
-   * @example
-   * ```ts
-   * Supervision.restart() // unlimited restarts, no backoff
-   * Supervision.restart({ maxRestarts: 3 }) // 3 restarts then terminal
-   * Supervision.restart({ maxRestarts: 3, within: "1 minute" }) // 3 within 1 min
-   * Supervision.restart({ backoff: Schedule.exponential("100 millis") })
-   * ```
-   */
-  const restart: (options?: {
-    readonly maxRestarts?: number;
-    readonly within?: Duration.DurationInput;
-    readonly backoff?: Schedule.Schedule<unknown>;
-  }) => Policy;
-}
-//#endregion
-export { ActorExit, CellPhase, DefectPhase, Supervision };

package/v3/dist/supervision.js

@@ -1,42 +0,0 @@
-import { Schedule } from "effect";
-//#region src/supervision.ts
-/**
-* Supervision types for actor lifecycle management.
-*
-* Core concepts:
-* - `ActorExit<S>` — why an actor stopped (final, explicit stop, or defect)
-* - `DefectPhase` — where in the lifecycle a defect occurred
-* - `Supervision.Policy` — Schedule-based restart policy
-* - `CellPhase<S>` — internal phase machine for serializing stop/restart/drain
-*
-* @module
-*/
-/** Constructors for ActorExit */
-const ActorExit = {
-	Final: (state) => ({
-		_tag: "Final",
-		state
-	}),
-	Stopped: { _tag: "Stopped" },
-	Defect: (cause, phase) => ({
-		_tag: "Defect",
-		cause,
-		phase
-	})
-};
-let Supervision;
-(function(_Supervision) {
-	_Supervision.none = { schedule: Schedule.recurs(0) };
-	_Supervision.restart = (options) => {
-		let schedule = Schedule.forever;
-		if (options?.maxRestarts !== void 0) {
-			const recurs = Schedule.recurs(options.maxRestarts);
-			if (options.within !== void 0) schedule = Schedule.intersect(recurs, Schedule.windowed(options.within));
-			else schedule = recurs;
-		}
-		if (options?.backoff !== void 0) schedule = Schedule.intersect(schedule, options.backoff);
-		return { schedule };
-	};
-})(Supervision || (Supervision = {}));
-//#endregion
-export { ActorExit, Supervision };