@xstate/effect 0.1.0-alpha.2

package/dist/declarations/src/actor.d.ts

@@ -0,0 +1,76 @@
+import { Cause, Duration, Effect, Stream } from 'effect';
+import type { Actor, ActorRef, AnyActorRef, AnyEventObject, DeadLetterInspectionEvent, EmittedFrom, ErrorFrom, InspectionEvent, OutputFrom, SnapshotFrom } from 'xstate';
+import type { EffectActor } from "./effectActor.js";
+import { ActorStoppedError } from "./errors.js";
+/** The event type accepted by an actor's `send` method. */
+export type SendableEventFrom<TActor extends AnyActorRef> = Parameters<TActor['send']>[0];
+/** The event type an actor emits through `actor.on(...)`. */
+export type EmittedEventFrom<TActor> = TActor extends EffectActor<infer TLogic> ? EmittedFrom<TLogic> : TActor extends Actor<infer TLogic> ? EmittedFrom<TLogic> : TActor extends ActorRef<any, any, infer TEmitted, any> ? TEmitted : AnyEventObject;
+/** Options for {@link waitFor}. */
+export interface WaitForOptions {
+    /**
+     * Fails with `Cause.TimeoutError` when no snapshot satisfies the predicate
+     * within this duration.
+     */
+    readonly timeout: Duration.Input;
+}
+/**
+ * Sends an event to an actor. The returned Effect always succeeds: the event
+ * is enqueued, like `actor.send(event)`, and processed on the actor's own
+ * fiber. An event that cannot be delivered (for example to a stopped actor)
+ * is reported as a dead letter, observable with {@link deadLetters}.
+ */
+export declare const send: {
+    <TActor extends AnyActorRef>(event: SendableEventFrom<TActor>): (actor: TActor) => Effect.Effect<void>;
+    <TActor extends AnyActorRef>(actor: TActor, event: SendableEventFrom<TActor>): Effect.Effect<void>;
+};
+/**
+ * Streams an actor's snapshots, starting with the current one. The stream ends
+ * when the actor completes or stops, and emits the error snapshot before
+ * ending when the actor errors. Interrupting the stream unsubscribes from the
+ * actor.
+ */
+export declare function snapshots<TActor extends AnyActorRef>(actor: TActor): Stream.Stream<SnapshotFrom<TActor>>;
+/**
+ * Streams every event an actor emits, as delivered to `actor.on('*', …)`. The
+ * stream ends when the actor completes, errors or stops. Interrupting the
+ * stream removes the listener.
+ */
+export declare function emitted<TActor extends AnyActorRef>(actor: TActor): Stream.Stream<EmittedEventFrom<TActor>>;
+/**
+ * Waits for the first actor snapshot that satisfies `predicate`, succeeding
+ * immediately when the current snapshot already does. Fails with
+ * `ActorStoppedError` if the actor stops or errors first, and with
+ * `Cause.TimeoutError` when `options.timeout` elapses. Interrupting the Effect
+ * unsubscribes from the actor.
+ */
+export declare const waitFor: {
+    <TActor extends AnyActorRef, TNarrowed extends SnapshotFrom<TActor>>(predicate: (snapshot: SnapshotFrom<TActor>) => snapshot is TNarrowed): (actor: TActor) => Effect.Effect<TNarrowed, ActorStoppedError>;
+    <TActor extends AnyActorRef>(predicate: (snapshot: SnapshotFrom<TActor>) => boolean): (actor: TActor) => Effect.Effect<SnapshotFrom<TActor>, ActorStoppedError>;
+    <TActor extends AnyActorRef, TNarrowed extends SnapshotFrom<TActor>>(predicate: (snapshot: SnapshotFrom<TActor>) => snapshot is TNarrowed, options: WaitForOptions): (actor: TActor) => Effect.Effect<TNarrowed, ActorStoppedError | Cause.TimeoutError>;
+    <TActor extends AnyActorRef>(predicate: (snapshot: SnapshotFrom<TActor>) => boolean, options: WaitForOptions): (actor: TActor) => Effect.Effect<SnapshotFrom<TActor>, ActorStoppedError | Cause.TimeoutError>;
+    <TActor extends AnyActorRef, TNarrowed extends SnapshotFrom<TActor>>(actor: TActor, predicate: (snapshot: SnapshotFrom<TActor>) => snapshot is TNarrowed): Effect.Effect<TNarrowed, ActorStoppedError>;
+    <TActor extends AnyActorRef>(actor: TActor, predicate: (snapshot: SnapshotFrom<TActor>) => boolean): Effect.Effect<SnapshotFrom<TActor>, ActorStoppedError>;
+    <TActor extends AnyActorRef, TNarrowed extends SnapshotFrom<TActor>>(actor: TActor, predicate: (snapshot: SnapshotFrom<TActor>) => snapshot is TNarrowed, options: WaitForOptions): Effect.Effect<TNarrowed, ActorStoppedError | Cause.TimeoutError>;
+    <TActor extends AnyActorRef>(actor: TActor, predicate: (snapshot: SnapshotFrom<TActor>) => boolean, options: WaitForOptions): Effect.Effect<SnapshotFrom<TActor>, ActorStoppedError | Cause.TimeoutError>;
+};
+/**
+ * Joins an actor's final result, like `Fiber.join`: succeeds with its `output`
+ * when it is done, fails with `snapshot.error` when it errors, and fails with
+ * `ActorStoppedError` when it stops without output. Waits for a still-active
+ * actor to settle.
+ */
+export declare function join<TActor extends AnyActorRef>(actor: TActor): Effect.Effect<OutputFrom<TActor>, ErrorFrom<TActor> | ActorStoppedError>;
+/**
+ * Streams the inspection events of the actor's system, as delivered to
+ * `system.inspect(…)`. The stream runs until it is interrupted or its scope
+ * closes.
+ */
+export declare function inspect(actor: AnyActorRef): Stream.Stream<InspectionEvent>;
+/**
+ * Streams the events the actor's system could not deliver: sends to a
+ * stopped actor, invalid external events and internal events sent from
+ * outside their owner. A dead letter is not an actor error. The stream runs
+ * until it is interrupted or its scope closes.
+ */
+export declare function deadLetters(actor: AnyActorRef): Stream.Stream<DeadLetterInspectionEvent>;

package/dist/declarations/src/atom.d.ts

@@ -0,0 +1,56 @@
+import { AsyncResult, Atom } from 'effect/unstable/reactivity';
+import type { AnyActorLogic, ErrorFrom, EventFromLogic, SnapshotFrom } from 'xstate';
+import { type EffectActorOptions } from "./createEffectActor.js";
+import type { EffectActor } from "./effectActor.js";
+import { NotReadyError } from "./errors.js";
+import { type TaggedStateFrom } from "./state.js";
+import type { RequirementsFrom } from "./types.js";
+export { NotReadyError } from "./errors.js";
+/**
+ * Atoms that expose one actor to a reactive UI through
+ * `effect/unstable/reactivity`. Read them with the atom bindings for your
+ * framework, such as `@effect/atom-react`.
+ */
+export interface ActorAtoms<TLogic extends AnyActorLogic, ER = never> {
+    /**
+     * The running actor. It starts when the atom is first read and stops when
+     * the atom is released, that is, when nothing reads or mounts it anymore.
+     */
+    readonly actor: Atom.Atom<AsyncResult.AsyncResult<EffectActor<TLogic>, ER>>;
+    /** The actor's current snapshot, updated on every transition. */
+    readonly snapshot: Atom.Atom<AsyncResult.AsyncResult<SnapshotFrom<TLogic>, ER>>;
+    /**
+     * The snapshot as a result: a `Failure` carrying the actor's error once
+     * the actor's status is `error`, so an error boundary can handle it.
+     */
+    readonly result: Atom.Atom<AsyncResult.AsyncResult<SnapshotFrom<TLogic>, ER | ErrorFrom<TLogic>>>;
+    /**
+     * Sends an event to the actor synchronously. Set it with the event, for
+     * example through `useAtomSet` in React. Its value reports the last send:
+     * a `NotReadyError` failure when the runtime is still building, otherwise
+     * success.
+     */
+    readonly send: Atom.Writable<AsyncResult.AsyncResult<void, ER | NotReadyError>, EventFromLogic<TLogic>>;
+    /** Derives an atom of a value selected from the snapshot. */
+    readonly select: <T>(selector: (snapshot: SnapshotFrom<TLogic>) => T) => Atom.Atom<AsyncResult.AsyncResult<T, ER>>;
+    /**
+     * The snapshot as a tagged union over the machine's states, for
+     * `Match.tag` or a `switch` on `_tag`. See `taggedState`.
+     */
+    readonly state: Atom.Atom<AsyncResult.AsyncResult<TaggedStateFrom<SnapshotFrom<TLogic>>, ER>>;
+}
+interface MissingRequirements<T> {
+    readonly 'The runtime does not provide services the logic requires': T;
+}
+/**
+ * Creates atoms for an actor that runs in an `Atom.runtime`. The runtime's
+ * Layer must provide every service the logic requires; a missing service is
+ * a type error on the `runtime` argument.
+ *
+ * The actor is created with `createEffectActor` inside the `actor` atom's
+ * scope, so its lifetime follows the atom: it starts on first read and stops
+ * when the atom is released. Wrap the atoms with `Atom.keepAlive` to pin the
+ * actor for the registry's lifetime, or with `Atom.family` to create one
+ * actor per input.
+ */
+export declare function createActorAtoms<TLogic extends AnyActorLogic, R, ER = never>(runtime: Atom.AtomRuntime<R, ER> & ([RequirementsFrom<TLogic>] extends [R] ? unknown : MissingRequirements<Exclude<RequirementsFrom<TLogic>, R>>), logic: TLogic, options?: EffectActorOptions<TLogic>): ActorAtoms<TLogic, ER>;

package/dist/declarations/src/brands.d.ts

@@ -0,0 +1 @@
+export declare const effectActionBrand: unique symbol;

package/dist/declarations/src/createEffectActor.d.ts

@@ -0,0 +1,30 @@
+import { Effect, Scope } from 'effect';
+import { type AnyActorLogic, type InputFrom } from 'xstate';
+import { EffectActor } from "./effectActor.js";
+import type { RequirementsFrom } from "./types.js";
+/** Options for {@link createEffectActor}. */
+export interface EffectActorOptions<TLogic extends AnyActorLogic> {
+    /** The actor's input. */
+    readonly input?: InputFrom<TLogic>;
+}
+type RequiredInput<TLogic extends AnyActorLogic> = undefined extends InputFrom<TLogic> ? {
+    input?: InputFrom<TLogic>;
+} : {
+    input: InputFrom<TLogic>;
+};
+/**
+ * Creates and starts an actor as an Effect interpreter over pure transitions.
+ *
+ * Each step is `transition(snapshot, event)`, a pure function that returns
+ * the next snapshot and the actions to run. An Effect fiber owns the loop:
+ * the mailbox is a `Queue`, timers are `Effect.sleep` fibers on the Effect
+ * `Clock`, and declared Effect actions run as forked Effects in the actor's
+ * `Scope` with the services captured here. Child actors are started as live
+ * XState actors whose Effects run in the same host.
+ *
+ * The actor is a scoped resource: it stops, and every Effect it hosts is
+ * interrupted, when the enclosing `Scope` closes. The returned Effect never
+ * fails; the actor's own outcome is its snapshot status, read with `join`.
+ */
+export declare function createEffectActor<TLogic extends AnyActorLogic>(logic: TLogic, ...[options]: undefined extends InputFrom<TLogic> ? [options?: EffectActorOptions<TLogic>] : [options: EffectActorOptions<TLogic> & RequiredInput<TLogic>]): Effect.Effect<EffectActor<TLogic>, never, RequirementsFrom<TLogic> | Scope.Scope>;
+export {};

package/dist/declarations/src/effectActor.d.ts

@@ -0,0 +1,60 @@
+import { Queue } from 'effect';
+import type { ActorRef, AnyActor, AnyActorLogic, EmittedFrom, EventFromLogic, InspectionEvent, Observer, Snapshot, SnapshotFrom, Subscription } from 'xstate';
+/** A mailbox item that reports a failed fire-and-forget action. */
+export interface ActionFailure {
+    readonly [actionFailure]: true;
+    readonly error: unknown;
+}
+export declare const actionFailure: unique symbol;
+export declare function isActionFailure(value: unknown): value is ActionFailure;
+export type MailboxItem<TEvent> = TEvent | ActionFailure;
+declare const symbolObservable: typeof Symbol.observable;
+/**
+ * Calls a listener and reports an exception it throws without letting it
+ * escape into the interpreter, matching core's `safeCall`.
+ */
+export declare function safeCall<T>(fn: ((arg: T) => void) | undefined, arg?: T): void;
+/**
+ * The handle `createEffectActor` returns. It implements XState's `ActorRef`
+ * contract (`send`, `getSnapshot`, `subscribe`, `on`), so it works with
+ * `useSelector`, this package's actor functions and the inspection APIs, while
+ * the actor itself is driven by an Effect fiber over pure transitions.
+ */
+export declare class EffectActor<TLogic extends AnyActorLogic> implements ActorRef<SnapshotFrom<TLogic>, EventFromLogic<TLogic>, EmittedFrom<TLogic>> {
+    readonly logic: TLogic;
+    private readonly _mailbox;
+    private readonly _stopExecution;
+    private readonly _inspectors;
+    readonly id: string;
+    readonly address: string;
+    readonly sessionId: string | undefined;
+    /** The actor system that hosts this actor and its children. */
+    readonly system: AnyActor['system'];
+    private _snapshot;
+    private readonly _observers;
+    private readonly _listeners;
+    private _settled;
+    constructor(logic: TLogic, root: AnyActor, snapshot: SnapshotFrom<TLogic>, _mailbox: Queue.Queue<MailboxItem<EventFromLogic<TLogic>>>, _stopExecution: () => void, _inspectors: Set<(event: InspectionEvent) => void>);
+    getSnapshot(): SnapshotFrom<TLogic>;
+    getPersistedSnapshot(): Snapshot<unknown>;
+    /** Sends an event; the actor processes it on its own fiber. */
+    send(event: EventFromLogic<TLogic>): void;
+    /** Stops the actor, its children and every Effect it hosts. */
+    stop(): this;
+    subscribe(observer: Observer<SnapshotFrom<TLogic>>): Subscription;
+    subscribe(nextListener?: (snapshot: SnapshotFrom<TLogic>) => void, errorListener?: (error: any) => void, completeListener?: () => void): Subscription;
+    on<TType extends EmittedFrom<TLogic>['type'] | '*'>(type: TType, handler: (emitted: EmittedFrom<TLogic> & (TType extends '*' ? unknown : {
+        type: TType;
+    })) => void): Subscription;
+    /**
+     * Observes the inspection events of this actor and its children: every
+     * transition, event delivery and dead letter of the execution.
+     */
+    inspect(observer: Observer<InspectionEvent> | ((event: InspectionEvent) => void)): Subscription;
+    [symbolObservable](): this;
+    toJSON(): {
+        xstate$$type: number;
+        id: string;
+    };
+}
+export {};

package/dist/declarations/src/errors.d.ts

@@ -0,0 +1,40 @@
+import { Cause } from 'effect';
+import type { Snapshot } from 'xstate';
+declare const EffectInterruptedError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & {
+    readonly _tag: "EffectInterruptedError";
+} & Readonly<A>;
+/**
+ * The failure an Effect-backed actor reports when its Effect was interrupted
+ * by something other than the actor being stopped, such as `Effect.interrupt`,
+ * losing an `Effect.race`, or an `Effect.timeout` that interrupts.
+ */
+export declare class EffectInterruptedError extends EffectInterruptedError_base<{
+    readonly cause: Cause.Cause<never>;
+}> {
+    get message(): string;
+}
+declare const ActorStoppedError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & {
+    readonly _tag: "ActorStoppedError";
+} & Readonly<A>;
+/**
+ * Reported by `waitFor` when the actor stops or errors before a snapshot
+ * matches, and by `join` when the actor stops without output. `join` reports
+ * an errored actor's own `snapshot.error` instead.
+ */
+export declare class ActorStoppedError extends ActorStoppedError_base<{
+    readonly actorId: string;
+    readonly snapshot: Snapshot<unknown>;
+}> {
+    get message(): string;
+}
+declare const NotReadyError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & {
+    readonly _tag: "NotReadyError";
+} & Readonly<A>;
+/**
+ * Reported by the `send` atom of `createActorAtoms` when an event is sent
+ * before the actor's runtime has finished building.
+ */
+export declare class NotReadyError extends NotReadyError_base {
+    get message(): string;
+}
+export {};

package/dist/declarations/src/fromEffect.d.ts

@@ -0,0 +1,176 @@
+import { Effect, Stream } from 'effect';
+import { type ActorLogicValidator, type ActorLogic, type AnyActorRef, type AnyActorSystem, type AnyEventObject, type EventObject, type Snapshot, type StandardSchemaV1 } from 'xstate';
+import type { EffectRequirements } from "./types.js";
+import { type EffectSchemaLike, type ToStandardSchema, type ValidateEffectActorSchemas } from "./schema.js";
+declare const effectLogicBrand: unique symbol;
+/**
+ * Type-level marker attached to logic created by `fromEffect`,
+ * `fromEffectStream` and `fromEffectEventStream`. It carries the logic's
+ * failure type and its Effect service requirements, which is how
+ * `RequirementsFrom` collects the `R` channel of `createEffectActor` without
+ * inspecting the logic at runtime.
+ */
+export interface EffectLogicBrand<TError, TRequirements> {
+    readonly [effectLogicBrand]: {
+        readonly error: TError;
+        readonly requirements: TRequirements;
+    };
+}
+/**
+ * Snapshot of a `fromEffect` actor. The actor holds no context of its own: it
+ * is `active` while the Effect runs, `done` with the Effect's success value as
+ * `output`, or `error` with the Effect's failure, defect or
+ * `EffectInterruptedError` as `error`.
+ */
+export type EffectSnapshot<TOutput, TError, TInput> = Snapshot<TOutput> & {
+    readonly context: undefined;
+    readonly input: TInput | undefined;
+    readonly error: TError | undefined;
+};
+/**
+ * Argument passed to the function form of an Effect source. It gives the
+ * source the actor's `input`, its own reference (`self`), the actor `system`,
+ * and `emit` for publishing events that `actor.on(...)` and `emitted(actor)`
+ * observe.
+ */
+export type EffectSourceArgs<TInput> = {
+    readonly input: TInput;
+    readonly self: AnyActorRef;
+    readonly system: AnyActorSystem;
+    /** Emits an event that can be observed with `actor.on(...)` or `emitted(actor)`. */
+    readonly emit: (event: AnyEventObject) => void;
+};
+/**
+ * What `fromEffect` accepts as its Effect: either an Effect value, or a
+ * function of {@link EffectSourceArgs} returning one. The function form is
+ * called once per actor start, so it sees that actor's input.
+ */
+export type EffectSource<TOutput, TError, TInput, TRequirements> = Effect.Effect<TOutput, TError, TRequirements> | ((args: EffectSourceArgs<TInput>) => Effect.Effect<TOutput, TError, TRequirements>);
+type EffectActorSchemas = {
+    readonly input?: EffectSchemaLike;
+    readonly output?: EffectSchemaLike;
+};
+type EffectSourceConfig<TOutput, TError, TInput, TRequirements, TSchemas extends EffectActorSchemas = EffectActorSchemas, TValidator extends ActorLogicValidator | undefined = ActorLogicValidator | undefined> = {
+    readonly id?: string;
+    readonly validator?: TValidator;
+    readonly schemas?: TSchemas & ([TValidator] extends [ActorLogicValidator] ? ValidateEffectActorSchemas<TSchemas> : unknown);
+    readonly effect: EffectSource<TOutput, TError, TInput, TRequirements>;
+};
+type SchemaOutput<TSchema extends EffectSchemaLike> = StandardSchemaV1.InferOutput<ToStandardSchema<TSchema>>;
+type EffectSuccess<T> = T extends Effect.Effect<infer A, any, any> ? A : never;
+type EffectFailure<T> = T extends Effect.Effect<any, infer E, any> ? E : never;
+type EffectSchemaValidationConfig<TSchemas extends EffectActorSchemas> = {
+    readonly validator: ActorLogicValidator;
+    readonly schemas: TSchemas & ValidateEffectActorSchemas<TSchemas>;
+} | {
+    readonly validator?: undefined;
+    readonly schemas: TSchemas;
+};
+/**
+ * Actor logic produced by `fromEffect` and `fromEffectEventStream`. It is
+ * ordinary XState actor logic carrying {@link EffectLogicBrand}, so a machine
+ * can invoke or spawn it, and `createEffectActor` can collect its
+ * requirements.
+ */
+export type EffectActorLogic<TOutput, TError, TInput, TRequirements> = ActorLogic<EffectSnapshot<TOutput, TError, TInput>, EventObject, TInput, AnyActorSystem> & {
+    readonly id?: string;
+} & EffectLogicBrand<TError, TRequirements>;
+/**
+ * Snapshot of a `fromEffectStream` actor. `context` holds the most recent
+ * stream item, or `undefined` before the first one. The actor reaches `done`
+ * with no output when the stream completes, and `error` when it fails.
+ */
+export type EffectStreamSnapshot<TItem, TError, TInput> = Snapshot<undefined> & {
+    readonly context: TItem | undefined;
+    readonly input: TInput | undefined;
+    readonly error: TError | undefined;
+};
+/**
+ * Actor logic produced by `fromEffectStream`. Its snapshot is an
+ * {@link EffectStreamSnapshot}, so the parent reads the latest item from the
+ * child's `context` rather than from events.
+ */
+export type EffectStreamActorLogic<TItem, TError, TInput, TRequirements> = ActorLogic<EffectStreamSnapshot<TItem, TError, TInput>, EventObject, TInput, AnyActorSystem> & {
+    readonly id?: string;
+} & EffectLogicBrand<TError, TRequirements>;
+/**
+ * Creates actor logic that runs an Effect. The actor completes with the
+ * Effect's success value as its output and fails with the Effect's error, its
+ * squashed defect, or an `EffectInterruptedError` when the Effect interrupts
+ * itself. Stopping the actor interrupts the Effect without an error. Accepts
+ * an Effect, a function of {@link EffectSourceArgs} returning one, or a config
+ * object with `id`, `schemas`, `validator` and `effect`. The logic must be run
+ * under `createEffectActor`, which provides the Effect services it declares.
+ */
+export declare function fromEffect<const TInputSchema extends EffectSchemaLike, const TOutputSchema extends EffectSchemaLike, TError = unknown, TRequirements = never>(config: Omit<EffectSourceConfig<SchemaOutput<TOutputSchema>, TError, SchemaOutput<TInputSchema>, TRequirements>, 'schemas' | 'validator'> & EffectSchemaValidationConfig<{
+    input: TInputSchema;
+    output: TOutputSchema;
+}>): EffectActorLogic<SchemaOutput<TOutputSchema>, TError, SchemaOutput<TInputSchema>, TRequirements>;
+export declare function fromEffect<const TInputSchema extends EffectSchemaLike, TEffect extends Effect.Effect<any, any, any>>(config: Omit<EffectSourceConfig<EffectSuccess<TEffect>, EffectFailure<TEffect>, SchemaOutput<TInputSchema>, EffectRequirements<TEffect>, {
+    input: TInputSchema;
+}>, 'effect' | 'schemas' | 'validator'> & EffectSchemaValidationConfig<{
+    input: TInputSchema;
+    output?: never;
+}> & {
+    effect: TEffect | ((args: EffectSourceArgs<SchemaOutput<TInputSchema>>) => TEffect);
+}): EffectActorLogic<EffectSuccess<TEffect>, EffectFailure<TEffect>, SchemaOutput<TInputSchema>, EffectRequirements<TEffect>>;
+export declare function fromEffect<const TOutputSchema extends EffectSchemaLike, TError = unknown, TInput = undefined, TRequirements = never>(config: Omit<EffectSourceConfig<SchemaOutput<TOutputSchema>, TError, TInput, TRequirements>, 'schemas' | 'validator'> & EffectSchemaValidationConfig<{
+    input?: never;
+    output: TOutputSchema;
+}>): EffectActorLogic<SchemaOutput<TOutputSchema>, TError, TInput, TRequirements>;
+export declare function fromEffect<TOutput, TError = unknown, TInput = undefined, TRequirements = never>(config: EffectSourceConfig<TOutput, TError, TInput, TRequirements> & {
+    schemas?: undefined;
+}): EffectActorLogic<TOutput, TError, TInput, TRequirements>;
+export declare function fromEffect<TOutput, TError = unknown, TRequirements = never>(effect: Effect.Effect<TOutput, TError, TRequirements>): EffectActorLogic<TOutput, TError, undefined, TRequirements>;
+export declare function fromEffect<TOutput, TError = unknown, TInput = undefined, TRequirements = never>(effect: (args: EffectSourceArgs<TInput>) => Effect.Effect<TOutput, TError, TRequirements>): EffectActorLogic<TOutput, TError, TInput, TRequirements>;
+/**
+ * What `fromEffectStream` and `fromEffectEventStream` accept as their stream:
+ * either a Stream value, or a function of {@link EffectSourceArgs} returning
+ * one. The function form is called once per actor start.
+ */
+export type EffectStreamSource<TItem, TError, TInput, TRequirements> = Stream.Stream<TItem, TError, TRequirements> | ((args: EffectSourceArgs<TInput>) => Stream.Stream<TItem, TError, TRequirements>);
+type EffectStreamConfig<TItem, TError, TInput, TRequirements, TSchemas extends {
+    readonly input?: EffectSchemaLike;
+} = {
+    readonly input?: EffectSchemaLike;
+}, TValidator extends ActorLogicValidator | undefined = ActorLogicValidator | undefined> = {
+    readonly id?: string;
+    readonly validator?: TValidator;
+    readonly schemas?: TSchemas & ([TValidator] extends [ActorLogicValidator] ? ValidateEffectActorSchemas<TSchemas> : unknown);
+    readonly stream: EffectStreamSource<TItem, TError, TInput, TRequirements>;
+};
+type StreamItem<T> = T extends Stream.Stream<infer A, any, any> ? A : never;
+type StreamError<T> = T extends Stream.Stream<any, infer E, any> ? E : never;
+type StreamRequirements<T> = T extends Stream.Stream<any, any, infer R> ? R : never;
+/**
+ * Creates actor logic that runs a Stream and exposes its most recent item as
+ * the actor's `context`. The actor reaches `done` when the stream completes
+ * and `error` when it fails. Accepts a Stream, a function of
+ * {@link EffectSourceArgs} returning one, or a config object with `id`,
+ * `schemas`, `validator` and `stream`.
+ */
+export declare function fromEffectStream<const TInputSchema extends EffectSchemaLike, TStream extends Stream.Stream<any, any, any>>(config: Omit<EffectStreamConfig<StreamItem<TStream>, StreamError<TStream>, SchemaOutput<TInputSchema>, StreamRequirements<TStream>>, 'stream' | 'schemas' | 'validator'> & EffectSchemaValidationConfig<{
+    input: TInputSchema;
+}> & {
+    stream: TStream | ((args: EffectSourceArgs<SchemaOutput<TInputSchema>>) => TStream);
+}): EffectStreamActorLogic<StreamItem<TStream>, StreamError<TStream>, SchemaOutput<TInputSchema>, StreamRequirements<TStream>>;
+export declare function fromEffectStream<TItem, TError = unknown, TInput = undefined, TRequirements = never>(config: EffectStreamConfig<TItem, TError, TInput, TRequirements> & {
+    schemas?: undefined;
+}): EffectStreamActorLogic<TItem, TError, TInput, TRequirements>;
+export declare function fromEffectStream<TItem, TError = unknown, TInput = undefined, TRequirements = never>(stream: EffectStreamSource<TItem, TError, TInput, TRequirements>): EffectStreamActorLogic<TItem, TError, TInput, TRequirements>;
+/**
+ * Creates actor logic that runs a Stream of events and relays each item to the
+ * parent machine as an event, the way `fromEventObservable` does. The actor
+ * has no output: it reaches `done` when the stream completes and `error` when
+ * it fails. Accepts the same forms as `fromEffectStream`.
+ */
+export declare function fromEffectEventStream<const TInputSchema extends EffectSchemaLike, TStream extends Stream.Stream<EventObject, any, any>>(config: Omit<EffectStreamConfig<StreamItem<TStream>, StreamError<TStream>, SchemaOutput<TInputSchema>, StreamRequirements<TStream>>, 'stream' | 'schemas' | 'validator'> & EffectSchemaValidationConfig<{
+    input: TInputSchema;
+}> & {
+    stream: TStream | ((args: EffectSourceArgs<SchemaOutput<TInputSchema>>) => TStream);
+}): EffectActorLogic<undefined, StreamError<TStream>, SchemaOutput<TInputSchema>, StreamRequirements<TStream>>;
+export declare function fromEffectEventStream<TEvent extends EventObject, TError = unknown, TInput = undefined, TRequirements = never>(config: EffectStreamConfig<TEvent, TError, TInput, TRequirements> & {
+    schemas?: undefined;
+}): EffectActorLogic<undefined, TError, TInput, TRequirements>;
+export declare function fromEffectEventStream<TEvent extends EventObject, TError = unknown, TInput = undefined, TRequirements = never>(stream: EffectStreamSource<TEvent, TError, TInput, TRequirements>): EffectActorLogic<undefined, TError, TInput, TRequirements>;
+export {};

package/dist/declarations/src/index.d.ts

@@ -0,0 +1,10 @@
+export { fromEffect, fromEffectEventStream, fromEffectStream, type EffectActorLogic, type EffectLogicBrand, type EffectSnapshot, type EffectSource, type EffectSourceArgs, type EffectStreamSource, type EffectStreamActorLogic, type EffectStreamSnapshot } from "./fromEffect.js";
+export { createEffectActor, type EffectActorOptions } from "./createEffectActor.js";
+export { EffectActor } from "./effectActor.js";
+export { deadLetters, emitted, inspect, join, send, snapshots, waitFor, type EmittedEventFrom, type SendableEventFrom, type WaitForOptions } from "./actor.js";
+export { ActorStoppedError, EffectInterruptedError } from "./errors.js";
+export { setupEffect, type EffectAction, type EffectActionArgs, type EffectSetupReturn } from "./setupEffect.js";
+export { type RequirementsFrom } from "./types.js";
+export { taggedState, type StateTag, type TaggedState, type TaggedStateFrom } from "./state.js";
+export { type ErrorFrom } from 'xstate';
+export { type EffectSchema, type EffectSchemaLike, type EffectSetupSchemas, type EffectSetupStateSchema } from "./schema.js";

package/dist/declarations/src/schema.d.ts

@@ -0,0 +1,80 @@
+import { Schema } from 'effect';
+import type { SetupSchemas, SetupStateSchema, SetupStateSchemas, StandardSchemaV1 } from 'xstate';
+/**
+ * An Effect `Schema` accepted by this package. `setupEffect`, `fromEffect`,
+ * `fromEffectStream` and `fromEffectEventStream` convert it to a Standard
+ * Schema, so XState infers the decoded `Schema.Type` without an explicit call
+ * to `Schema.toStandardSchemaV1`.
+ */
+export type EffectSchema = Schema.ConstraintDecoder<unknown>;
+/**
+ * Either an Effect {@link EffectSchema} or a Standard Schema. Every schema
+ * position in this package accepts both, so Effect schemas and schemas from
+ * other libraries can be mixed in one machine.
+ */
+export type EffectSchemaLike = StandardSchemaV1 | EffectSchema;
+interface RuntimeValidationDoesNotSupportTransformingSchemas {
+    readonly __xstate_effect_error: 'Runtime validation does not support schemas with different encoded and decoded types';
+}
+type IsAny<T> = 0 extends 1 & T ? true : false;
+export type ToStandardSchema<TSchema> = TSchema extends StandardSchemaV1 ? TSchema : TSchema extends EffectSchema ? StandardSchemaV1<TSchema['Encoded'], TSchema['Type']> & TSchema : never;
+type AssertNonTransformingSchema<TSchema> = TSchema extends EffectSchemaLike ? IsAny<StandardSchemaV1.InferInput<ToStandardSchema<TSchema>>> extends true ? TSchema : IsAny<StandardSchemaV1.InferOutput<ToStandardSchema<TSchema>>> extends true ? TSchema : [
+    StandardSchemaV1.InferInput<ToStandardSchema<TSchema>>,
+    StandardSchemaV1.InferOutput<ToStandardSchema<TSchema>>
+] extends [
+    StandardSchemaV1.InferOutput<ToStandardSchema<TSchema>>,
+    StandardSchemaV1.InferInput<ToStandardSchema<TSchema>>
+] ? TSchema : RuntimeValidationDoesNotSupportTransformingSchemas : TSchema;
+type EffectSchemaShape<TValue> = TValue extends StandardSchemaV1 ? EffectSchemaLike : TValue extends Record<string, unknown> ? {
+    [K in keyof TValue]: EffectSchemaShape<TValue[K]>;
+} : TValue;
+type ToStandardSchemaShape<TValue> = TValue extends EffectSchemaLike ? ToStandardSchema<TValue> : TValue extends Record<string, unknown> ? {
+    [K in keyof TValue]: ToStandardSchemaShape<TValue[K]>;
+} : TValue;
+/**
+ * The `schemas` option of `setupEffect`: XState's `SetupSchemas` with every
+ * schema position widened to {@link EffectSchemaLike}. Covers `context`,
+ * `input`, `output` and the per-key records for `events`, `internalEvents`,
+ * `emitted` and `children`.
+ */
+export type EffectSetupSchemas = {
+    [K in keyof SetupSchemas]?: EffectSchemaShape<NonNullable<SetupSchemas[K]>>;
+};
+export type ValidateEffectActorSchemas<TSchemas> = {
+    [K in keyof TSchemas]: AssertNonTransformingSchema<TSchemas[K]>;
+};
+export type ValidateEffectSetupSchemas<TSchemas> = {
+    [K in keyof TSchemas]: K extends 'events' | 'internalEvents' | 'emitted' | 'children' ? {
+        [P in keyof TSchemas[K]]: AssertNonTransformingSchema<TSchemas[K][P]>;
+    } : K extends 'context' | 'input' | 'output' ? AssertNonTransformingSchema<TSchemas[K]> : TSchemas[K];
+};
+export type ToStandardSetupSchemas<TSchemas> = {
+    [K in keyof TSchemas]: ToStandardSchemaShape<TSchemas[K]>;
+} extends infer TStandardSchemas extends SetupSchemas ? TStandardSchemas : never;
+/**
+ * One node of the `states` option of `setupEffect`: the schemas declared for
+ * that state, and the same shape recursively for its child states. It is
+ * XState's `SetupStateSchema` with Effect schemas allowed in every schema
+ * position.
+ */
+export interface EffectSetupStateSchema {
+    schemas?: EffectSchemaShape<SetupStateSchemas>;
+    states?: Record<string, EffectSetupStateSchema>;
+}
+export type ValidateEffectSetupStates<TStates> = {
+    [K in keyof TStates]: TStates[K] extends EffectSetupStateSchema ? {
+        [P in keyof TStates[K]]: P extends 'schemas' ? TStates[K][P] extends Record<string, unknown> ? {
+            [S in keyof TStates[K][P]]: AssertNonTransformingSchema<TStates[K][P][S]>;
+        } : TStates[K][P] : P extends 'states' ? TStates[K][P] extends Record<string, EffectSetupStateSchema> ? ValidateEffectSetupStates<TStates[K][P]> : TStates[K][P] : TStates[K][P];
+    } : TStates[K];
+};
+type ToStandardSetupStateSchema<TStateSchema> = TStateSchema extends EffectSetupStateSchema ? {
+    [K in keyof TStateSchema]: K extends 'schemas' ? ToStandardSchemaShape<TStateSchema[K]> : K extends 'states' ? TStateSchema[K] extends Record<string, EffectSetupStateSchema> ? ToStandardSetupStates<TStateSchema[K]> : TStateSchema[K] : TStateSchema[K];
+} extends infer TStandardStateSchema extends SetupStateSchema ? TStandardStateSchema : never : never;
+export type ToStandardSetupStates<TStates> = {
+    [K in keyof TStates]: ToStandardSetupStateSchema<TStates[K]>;
+};
+export declare function toStandardSchema(schema: EffectSchemaLike): StandardSchemaV1;
+export declare function toStandardSetupSchemas(schemas: EffectSetupSchemas | undefined): SetupSchemas | undefined;
+export declare function toStandardSetupStates(states: Record<string, EffectSetupStateSchema> | undefined): Record<string, SetupStateSchema> | undefined;
+export {};