effect-machine 0.17.0 → 0.18.0

package/dist/slot.d.ts

@@ -1,159 +0,0 @@
-import { ActorSystemService } 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.Top>;
-/** 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<Return> | undefined;
-  /** Materialized input schema (Schema.Struct of fields, or Schema.Void for empty) */
-  readonly inputSchema: Schema.Codec<FieldsToParams<F>>;
-  /** Materialized output schema (returnSchema or Schema.Void) */
-  readonly outputSchema: Schema.Codec<Return>;
-}
-/**
- * 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, Return>(fields: F, returnSchema: Schema.Schema<Return>): SlotFnDef<F, Return>;
-  <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.Codec<SlotRequest<D>>;
-  /** Schema for slot results `{ _tag: "SlotResult", name, result }`. For RPC response payloads. */
-  readonly resultSchema: Schema.Codec<SlotResult<D>>;
-  /** Schema for slot invocations `{ _tag: "SlotInvocation", name, params, result }`. For persistence/logging. */
-  readonly invocationSchema: Schema.Codec<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: 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 class MachineContextTag extends MachineContextTag_base {}
-/**
- * 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, Return>(fields: F, returnSchema: Schema.Schema<Return>): SlotFnDef<F, Return>;
-    <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,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
-*/
-var MachineContextTag = class extends Context.Service()("effect-machine/slot/MachineContextTag") {};
-/**
-* 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/_virtual/_rolldown/runtime.js

@@ -1,13 +0,0 @@
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
-};
-//#endregion
-export { __exportAll };

package/v3/dist/actor.d.ts

@@ -1,250 +0,0 @@
-import { ExtractReply, ReplyTypeBrand } from "./internal/brands.js";
-import { ActorStoppedError, DuplicateActorError, NoReplyError } from "./errors.js";
-import { ProvideSlots, SlotsDef } from "./slot.js";
-import { ActorExit, Supervision } from "./supervision.js";
-import { ProcessEventError, ProcessEventHooks, ProcessEventResult, processEventCore, resolveTransition, runSpawnEffects } from "./internal/transition.js";
-import { Lifecycle, Machine } from "./machine.js";
-import { RuntimeQueuedEvent } from "./internal/runtime.js";
-import { Context, Deferred, Effect, Layer, Option, PubSub, Queue, Ref, Scope, Stream, SubscriptionRef } from "effect";
-
-//#region src/actor.d.ts
-/** Discriminated mailbox request — alias for RuntimeQueuedEvent */
-type QueuedEvent<E> = RuntimeQueuedEvent<E>;
-/**
- * Sync projection of ActorRef for non-Effect boundaries (React hooks, framework callbacks).
- */
-interface ActorRefSync<State extends {
-  readonly _tag: string;
-}, Event> {
-  readonly send: (event: Event) => void;
-  readonly stop: () => void;
-  readonly snapshot: () => State;
-  readonly matches: (tag: State["_tag"]) => boolean;
-  readonly can: (event: Event) => boolean;
-}
-/**
- * Information about a successful transition.
- * Emitted on the `transitions` stream after each accepted event.
- */
-interface TransitionInfo<State, Event> {
-  readonly fromState: State;
-  readonly toState: State;
-  readonly event: Event;
-}
-interface ActorRef<State extends {
-  readonly _tag: string;
-}, Event> {
-  readonly id: string;
-  /** Send an event (fire-and-forget). */
-  readonly send: (event: Event) => Effect.Effect<void>;
-  /** Fire-and-forget alias for send (OTP gen_server:cast). */
-  readonly cast: (event: Event) => Effect.Effect<void>;
-  /**
-   * Serialized request-reply (OTP gen_server:call).
-   * Event is processed through the queue; caller gets ProcessEventResult back.
-   */
-  readonly call: (event: Event) => Effect.Effect<ProcessEventResult<State>>;
-  /**
-   * 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: <E extends Event & ReplyTypeBrand<unknown>>(event: E) => Effect.Effect<ExtractReply<E>, NoReplyError | ActorStoppedError>;
-  /** Observable state. */
-  readonly state: SubscriptionRef.SubscriptionRef<State>;
-  /** Stop the actor gracefully. */
-  readonly stop: Effect.Effect<void>;
-  /**
-   * Start the actor — fork event loop, background effects, spawn effects.
-   * Called automatically by `system.spawn`. For `Machine.spawn`, the caller
-   * must call `start` explicitly. Events sent before start() are queued.
-   */
-  readonly start: Effect.Effect<void>;
-  /** Get current state snapshot. */
-  readonly snapshot: Effect.Effect<State>;
-  /** Check if current state matches tag. */
-  readonly matches: (tag: State["_tag"]) => Effect.Effect<boolean>;
-  /** Check if event can be handled in current state. */
-  readonly can: (event: Event) => Effect.Effect<boolean>;
-  /** Stream of state changes. */
-  readonly changes: Stream.Stream<State>;
-  /**
-   * Stream of accepted transitions (edge stream).
-   *
-   * Emits `{ fromState, toState, event }` on every successful transition,
-   * including same-state reenters. PubSub-backed — late subscribers miss
-   * past edges. This is observational, not a durability guarantee.
-   */
-  readonly transitions: Stream.Stream<TransitionInfo<State, Event>>;
-  /** Wait for a state matching predicate or variant (includes current snapshot). */
-  readonly waitFor: {
-    (predicate: (state: State) => boolean): Effect.Effect<State>;
-    (state: {
-      readonly _tag: State["_tag"];
-    }): Effect.Effect<State>;
-  };
-  /** Wait for a final state (includes current snapshot). */
-  readonly awaitFinal: Effect.Effect<State>;
-  /** Send event and wait for predicate, state variant, or final state. */
-  readonly sendAndWait: {
-    (event: Event, predicate: (state: State) => boolean): Effect.Effect<State>;
-    (event: Event, state: {
-      readonly _tag: State["_tag"];
-    }): Effect.Effect<State>;
-    (event: Event): Effect.Effect<State>;
-  };
-  /** Subscribe to state changes (sync callback). Returns unsubscribe function. */
-  readonly subscribe: (fn: (state: State) => void) => () => void;
-  /**
-   * Wait for this actor's terminal exit. Resolves with the exit reason.
-   * Set exactly once when the actor terminates (final, stop, drain, or defect).
-   */
-  readonly awaitExit: Effect.Effect<ActorExit<State>>;
-  /**
-   * Watch another actor. Returns an Effect that resolves with the exit reason
-   * when the watched actor terminally stops. Ignores restarts (Step 3).
-   * Built on the other actor's exitDeferred — authoritative, not system events.
-   */
-  readonly watch: (other: {
-    readonly id: string;
-    readonly awaitExit: Effect.Effect<ActorExit<unknown>>;
-  }) => Effect.Effect<ActorExit<unknown>>;
-  /**
-   * Drain: process all remaining events in the queue, then stop.
-   * Unlike `stop` (which interrupts immediately), `drain` lets the actor finish its work.
-   */
-  readonly drain: Effect.Effect<void>;
-  /** Sync helpers for non-Effect boundaries. */
-  readonly sync: ActorRefSync<State, Event>;
-  /** The actor system this actor belongs to. */
-  readonly system: ActorSystem;
-  /** Child actors spawned via `self.spawn` in this actor's handlers. */
-  readonly children: ReadonlyMap<string, ActorRef<AnyState, unknown>>;
-}
-/** Base type for stored actors (internal) */
-type AnyState = {
-  readonly _tag: string;
-};
-/**
- * Events emitted by the ActorSystem when actors are spawned or stopped.
- */
-type SystemEvent = {
-  readonly _tag: "ActorSpawned";
-  readonly id: string;
-  readonly actor: ActorRef<AnyState, unknown>;
-} | {
-  readonly _tag: "ActorRestarted";
-  readonly id: string;
-  readonly actor: ActorRef<AnyState, unknown>;
-  readonly generation: number;
-  readonly exit: ActorExit<unknown>;
-} | {
-  readonly _tag: "ActorStopped";
-  readonly id: string;
-  readonly actor: ActorRef<AnyState, unknown>;
-  readonly exit: ActorExit<unknown>;
-};
-/**
- * Listener callback for system events.
- */
-type SystemEventListener = (event: SystemEvent) => void;
-/**
- * Actor system for managing actor lifecycles
- */
-interface ActorSystem {
-  /**
-   * Spawn a new actor with the given machine.
-   *
-   * @example
-   * ```ts
-   * const actor = yield* system.spawn("my-actor", machine);
-   * ```
-   */
-  readonly spawn: <S extends {
-    readonly _tag: string;
-  }, E extends {
-    readonly _tag: string;
-  }, R, SD extends SlotsDef = Record<string, never>>(id: string, machine: Machine<S, E, R, any, any, SD>, options?: {
-    readonly supervision?: Supervision.Policy;
-    readonly slots?: ProvideSlots<SD, any>;
-    readonly lifecycle?: Lifecycle<S, E>;
-  }) => Effect.Effect<ActorRef<S, E>, DuplicateActorError, R>;
-  /**
-   * Get an existing actor by ID
-   */
-  readonly get: (id: string) => Effect.Effect<Option.Option<ActorRef<AnyState, unknown>>>;
-  /**
-   * Stop an actor by ID
-   */
-  readonly stop: (id: string) => Effect.Effect<boolean>;
-  /**
-   * Async stream of system events (actor spawned/stopped).
-   * Each subscriber gets their own queue — late subscribers miss prior events.
-   */
-  readonly events: Stream.Stream<SystemEvent>;
-  /**
-   * Sync snapshot of all currently registered actors.
-   * Returns a new Map on each access (not live).
-   */
-  readonly actors: ReadonlyMap<string, ActorRef<AnyState, unknown>>;
-  /**
-   * Subscribe to system events synchronously.
-   * Returns an unsubscribe function.
-   */
-  readonly subscribe: (fn: SystemEventListener) => () => void;
-}
-/**
- * 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>;
-/**
- * Notify all listeners of state change.
- */
-declare const notifyListeners: <S>(listeners: Listeners<S>, state: S) => void;
-/**
- * Build core ActorRef methods.
- */
-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>>) => ActorRef<S, E>;
-/**
- * Create and start an actor for a machine.
- * Delegates to the shared runtime kernel with actor-specific lifecycle hooks.
- */
-declare const createActor: <S extends {
-  readonly _tag: string;
-}, E extends {
-  readonly _tag: string;
-}, R, SD extends SlotsDef>(id: string, machine: Machine<S, E, R, any, any, SD>, options?: {
-  initialState?: S;
-  supervision?: Supervision.Policy;
-  lifecycle?: Lifecycle<S, E>; /** @internal Called by system after each restart — emits ActorRestarted system event */
-  onRestart?: (generation: number, exit: ActorExit<unknown>) => Effect.Effect<void>;
-} | undefined) => Effect.Effect<ActorRef<S, E>, never, never>;
-/** Fail all pending call/ask Deferreds with ActorStoppedError. Safe to call multiple times. */
-declare const settlePendingReplies: (pendingReplies: Set<Deferred.Deferred<unknown, unknown>>, actorId: string) => Effect.Effect<void, never, never>;
-/**
- * Create an ActorSystem instance. Must be run in a Scope.
- * @internal — use Default layer for normal usage
- */
-declare const makeSystem: () => Effect.Effect<ActorSystem, never, Scope.Scope>;
-/**
- * Default ActorSystem layer
- */
-declare const Default: Layer.Layer<ActorSystem, never, never>;
-//#endregion
-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 };