@systemfsoftware/xstate-effect 0.0.0-bootstrap.0 → 0.1.0-beta.8

package/dist/state-Ch1-WxXd.d.ts

@@ -0,0 +1,447 @@
+import { Cause, Context, Effect, Queue, Schema, Scope, Stream } from "effect";
+import { ActorLogic, ActorLogicValidator, ActorOptions, ActorRef, AnyActor, AnyActorLogic, AnyActorRef, AnyActorSystem, AnyEventObject, AnyMachineSnapshot, AnyStateMachine, EmittedFrom, EventFromLogic, EventObject, InputFrom, InspectionEvent, MachineContext, MachineSnapshot, Observer, RequiredActorOptionsFor, RequiredActorOptionsKeys, SetupSchemas, SetupStateSchema, SetupStateSchemas, Snapshot, SnapshotFrom, StandardSchemaV1, StateContextFromStateValue, StateSchema, StateValueFromStateSchema, Subscription } from "@systemfsoftware/xstate";
+/** A mailbox item that reports a failed fire-and-forget action. */
+interface ActionFailure {
+  readonly [actionFailure]: true;
+  readonly error: unknown;
+}
+declare const actionFailure: unique symbol;
+type MailboxItem<TEvent> = TEvent | ActionFailure;
+declare const symbolObservable: typeof Symbol.observable;
+/**
+ * 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.
+ */
+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
+   * actor creation and transition of the execution.
+   */
+  inspect(observer: Observer<InspectionEvent> | ((event: InspectionEvent) => void)): Subscription;
+  [symbolObservable](): this;
+  toJSON(): {
+    xstate$$type: number;
+    id: string;
+  };
+}
+declare const ActorScopeService: Context.ServiceClass<ActorScope, "@systemfsoftware/xstate-effect/actorScope", Scope.Scope>;
+/** The owning Effect actor's scope, supplied by `createEffectActor`. */
+declare class ActorScope extends ActorScopeService {}
+/**
+ * Acquires resources in the owning actor's scope. Their finalizers run when
+ * that actor stops, even if the invoking task finishes or is cancelled first.
+ */
+declare function withActorScope<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, Exclude<R, Scope.Scope> | ActorScope>;
+declare const effectActionBrand: unique symbol;
+/**
+ * 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`.
+ */
+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.
+ */
+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;
+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`.
+ */
+type EffectSetupSchemas = { [K in keyof SetupSchemas]?: EffectSchemaShape<NonNullable<SetupSchemas[K]>>; };
+type ValidateEffectActorSchemas<TSchemas> = { [K in keyof TSchemas]: AssertNonTransformingSchema<TSchemas[K]>; };
+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]; };
+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.
+ */
+interface EffectSetupStateSchema {
+  schemas?: EffectSchemaShape<SetupStateSchemas>;
+  states?: Record<string, EffectSetupStateSchema>;
+}
+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;
+type ToStandardSetupStates<TStates> = { [K in keyof TStates]: ToStandardSetupStateSchema<TStates[K]>; };
+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.
+ */
+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`.
+ */
+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.
+ */
+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.
+ */
+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.
+ */
+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.
+ */
+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.
+ */
+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.
+ * Resources belong to this task's scope and close on completion, failure or
+ * interruption. Use `withActorScope` to retain a resource until the owning
+ * Effect actor stops.
+ */
+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>;
+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>>;
+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>;
+declare function fromEffect<TOutput, TError = unknown, TInput = undefined, TRequirements = never>(config: EffectSourceConfig<TOutput, TError, TInput, TRequirements> & {
+  schemas?: undefined;
+}): EffectActorLogic<TOutput, TError, TInput, TRequirements>;
+declare function fromEffect<TOutput, TError = unknown, TRequirements = never>(effect: Effect.Effect<TOutput, TError, TRequirements>): EffectActorLogic<TOutput, TError, undefined, TRequirements>;
+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.
+ */
+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`. Its resources close when the stream
+ * completes, fails or is interrupted.
+ */
+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>>;
+declare function fromEffectStream<TItem, TError = unknown, TInput = undefined, TRequirements = never>(config: EffectStreamConfig<TItem, TError, TInput, TRequirements> & {
+  schemas?: undefined;
+}): EffectStreamActorLogic<TItem, TError, TInput, TRequirements>;
+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`. Its resources close
+ * when the stream completes, fails or is interrupted.
+ */
+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>>;
+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>;
+declare function fromEffectEventStream<TEvent extends EventObject, TError = unknown, TInput = undefined, TRequirements = never>(stream: EffectStreamSource<TEvent, TError, TInput, TRequirements>): EffectActorLogic<undefined, TError, TInput, TRequirements>;
+/** The `R` channel of an Effect type, or `never` for anything else. */
+type EffectRequirements<T> = T extends Effect.Effect<any, any, infer R> ? R : never;
+type RequirementsFromActions<T> = T extends Record<string, (...args: any[]) => any> ? T[keyof T] extends (infer TAction) ? TAction extends {
+  readonly [effectActionBrand]?: infer R;
+} ? unknown extends R ? EffectRequirements<TAction extends ((...args: any[]) => infer TResult) ? TResult : never> : Exclude<R, undefined> : EffectRequirements<TAction extends ((...args: any[]) => infer TResult) ? TResult : never> : never : never;
+/**
+ * Recursion budget for walking registered child machines. A machine cannot
+ * contain itself as a registered actor type, but deeply nested machine trees
+ * are capped at this depth to keep the conditional type finite.
+ */
+type MaxDepth = 10;
+type PrevDepth = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+type Depth = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10;
+type RequirementsFromActors<T, TDepth extends Depth> = T extends Record<string, any> ? RequirementsFrom<T[keyof T], TDepth> : never;
+/** `invoke` accepts a single config or an array of them. */
+type InvokeEntry<TInvoke> = TInvoke extends readonly (infer U)[] ? U : TInvoke;
+/**
+ * Requirements of the logic passed inline as `invoke.src`. A string `src`
+ * names an actor registered in `setup({ actors })`, whose requirements are
+ * already collected from the actor map, so it contributes nothing here.
+ */
+type RequirementsFromInvoke<TInvoke, TDepth extends Depth> = InvokeEntry<TInvoke> extends (infer TEntry) ? TEntry extends {
+  src: infer TSrc;
+} ? TSrc extends string ? never : RequirementsFrom<TSrc, TDepth> : never : never;
+/**
+ * Walks the machine's literal config tree (the state schema) collecting
+ * requirements from inline `invoke.src` logic at the root and in every
+ * descendant state node.
+ */
+type RequirementsFromStateSchema<TSchema, TDepth extends Depth> = (TSchema extends {
+  invoke: infer TInvoke;
+} ? RequirementsFromInvoke<TInvoke, TDepth> : never) | (TSchema extends {
+  states: infer TStates;
+} ? TStates extends Record<string, any> ? RequirementsFromStateSchema<TStates[keyof TStates], TDepth> : never : never);
+/**
+ * Collects the Effect service requirements of an actor logic.
+ *
+ * Actor and invocation scopes are supplied by the host and excluded here.
+ * For Effect logic this is the remaining `R`. For a state machine it is the
+ * union of the requirements of its registered Effect actions, its registered
+ * Effect actors, the Effect logic passed inline as `invoke.src` anywhere in
+ * its state tree, and — recursively — the requirements of any child machine
+ * reached either way (capped at `MaxDepth` levels of machine nesting).
+ */
+type RequirementsFrom<T, TDepth extends Depth = MaxDepth> = T extends EffectLogicBrand<any, infer R> ? Exclude<R, ActorScope | Scope.Scope> : T extends {
+  readonly _actionMap: infer TActionMap;
+  readonly _actorMap: infer TActorMap;
+  readonly _stateSchema: infer TStateSchema;
+} ? Exclude<RequirementsFromActions<TActionMap>, ActorScope | Scope.Scope> | ([TDepth] extends [0] ? never : RequirementsFromActors<TActorMap, PrevDepth[TDepth]> | RequirementsFromStateSchema<TStateSchema, PrevDepth[TDepth]>) : never;
+/** Options for {@link createEffectActor}. */
+type EffectActorOptions<TLogic extends AnyActorLogic> = {
+  readonly input?: InputFrom<TLogic>;
+  /**
+   * A snapshot from `actor.getPersistedSnapshot()`. The actor resumes in that
+   * state without re-running entry actions, and pending timers keep their
+   * original deadlines, as with XState's `createActor(logic, { snapshot })`.
+   * State-machine children resume their persisted state and completed
+   * children stay done. Effect tasks and streams that were running, at the
+   * root or as children, start again from the beginning. A restored actor
+   * does not need `input`.
+   */
+  readonly snapshot?: ActorOptions<TLogic>['snapshot'];
+} & RequiredActorOptionsFor<TLogic>;
+type EffectActorOptionsArgs<TLogic extends AnyActorLogic> = [RequiredActorOptionsKeys<TLogic>] extends [never] ? [options?: EffectActorOptions<TLogic>] : [options: EffectActorOptions<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`.
+ */
+declare function createEffectActor<TLogic extends AnyActorLogic>(logic: TLogic, ...[options]: EffectActorOptionsArgs<TLogic>): Effect.Effect<EffectActor<TLogic>, never, RequirementsFrom<TLogic> | Scope.Scope>;
+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.
+ */
+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.
+ */
+declare class ActorStoppedError extends ActorStoppedError_base<{
+  readonly actorId: string;
+  readonly snapshot: Snapshot<unknown>;
+}> {
+  get message(): string;
+}
+declare const ActorFailedError_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: "@systemfsoftware/xstate-effect/errors/ActorFailedError";
+} & Readonly<A>;
+declare class ActorFailedError<E = unknown> extends ActorFailedError_base<{
+  readonly cause: E;
+}> {
+  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.
+ */
+declare class NotReadyError extends NotReadyError_base {
+  get message(): string;
+}
+type IsUnion<T, U = T> = T extends unknown ? [U] extends [T] ? false : true : never;
+type Join<TPrefix extends string, TKey extends string> = TPrefix extends '' ? TKey : `${TPrefix}.${TKey}`;
+/** The tag of the machine itself, used when the root state is parallel. */
+declare const MACHINE_TAG = "(machine)";
+/**
+ * The dotted path of a state value: `'idle'`, `'form.editing'`. A parallel
+ * state has no single path, so its tag stops at the parallel state, or is
+ * `'(machine)'` when the machine itself is parallel.
+ */
+type StateTag<TValue, TPrefix extends string = ''> = string extends TValue ? string : TValue extends string ? Join<TPrefix, TValue> : TValue extends object ? string extends keyof TValue ? string : IsUnion<keyof TValue & string> extends true ? TPrefix extends '' ? typeof MACHINE_TAG : TPrefix : { [K in keyof TValue & string]: StateTag<TValue[K], Join<TPrefix, K>>; }[keyof TValue & string] : never;
+type TaggedStateOf<TSnapshot, TValue, TContext extends MachineContext, TSchema extends StateSchema> = TValue extends unknown ? {
+  readonly _tag: StateTag<TValue>;
+  readonly value: TValue;
+  readonly context: StateContextFromStateValue<TSchema, TContext, TValue>;
+  readonly snapshot: TSnapshot;
+} : never;
+/**
+ * A machine snapshot as a tagged union over its states. `_tag` is the state's
+ * dotted path and `context` is the context of that state, including any
+ * per-state context schema, so `Match.tag` narrows both.
+ */
+type TaggedStateFrom<TSnapshot> = TSnapshot extends MachineSnapshot<infer TContext, infer _TEvent, infer _TChildren, infer _TStateValue, infer _TTag, infer _TOutput, infer _TMeta, infer TSchema> ? TaggedStateOf<TSnapshot, StateValueFromStateSchema<TSchema>, TContext, TSchema> : never;
+/** The tagged state union of a machine. */
+type TaggedState<TMachine extends AnyStateMachine> = TaggedStateFrom<SnapshotFrom<TMachine>>;
+/**
+ * Views a machine snapshot as a tagged union member for `Match.tag`,
+ * `Match.tags` or a `switch` on `_tag`.
+ *
+ * @example
+ *
+ * ```ts
+ * const view = Match.type<TaggedStateFrom<typeof snapshot>>().pipe(
+ *   Match.tag('loading', ({ context }) => `Loading ${context.id}`),
+ *   Match.tag('done', () => 'Done'),
+ *   Match.exhaustive
+ * );
+ * view(taggedState(snapshot));
+ * ```
+ */
+declare function taggedState<TSnapshot extends AnyMachineSnapshot>(snapshot: TSnapshot): TaggedStateFrom<TSnapshot>;
+export { ToStandardSetupStates as A, fromEffectEventStream as C, EffectSetupSchemas as D, EffectSchemaLike as E, withActorScope as F, EffectActor as I, ValidateEffectSetupStates as M, effectActionBrand as N, EffectSetupStateSchema as O, ActorScope as P, fromEffect as S, EffectSchema as T, EffectSource as _, ActorFailedError as a, EffectStreamSnapshot as b, NotReadyError as c, createEffectActor as d, EffectRequirements as f, EffectSnapshot as g, EffectLogicBrand as h, taggedState as i, ValidateEffectSetupSchemas as j, ToStandardSetupSchemas as k, EffectActorOptions as l, EffectActorLogic as m, TaggedState as n, ActorStoppedError as o, RequirementsFrom as p, TaggedStateFrom as r, EffectInterruptedError as s, StateTag as t, EffectActorOptionsArgs as u, EffectSourceArgs as v, fromEffectStream as w, EffectStreamSource as x, EffectStreamActorLogic as y };

package/package.json

@@ -1,10 +1,63 @@
 {
   "name": "@systemfsoftware/xstate-effect",
-  "version": "0.0.0-bootstrap.0",
-  "description": "Reserved for trusted publishing from github.com/systemfsoftware/xstate.",
+  "license": "MIT",
+  "version": "0.1.0-beta.8",
+  "author": "Ryan Lee <drdgvhbh@gmail.com>",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/systemfsoftware/xstate.git"
+    "url": "git+https://github.com/systemfsoftware/xstate.git",
+    "directory": "packages/xstate-effect"
   },
-  "license": "Apache-2.0"
-}
+  "homepage": "https://github.com/systemfsoftware/xstate/tree/main/packages/xstate-effect#readme",
+  "bugs": "https://github.com/systemfsoftware/xstate/issues",
+  "description": "Effect 4 actors for XState machines: services, scopes, clocks and tracing from Effect — forked under systemfsoftware from statelyai/xstate (@xstate/effect at 2146ae26).",
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "@systemfsoftware/xstate": "^6.0.0-beta.65",
+    "effect": "^4.1.0"
+  },
+  "devDependencies": {
+    "@effect/tsgo": "0.64.1",
+    "@microsoft/api-extractor": "7.59.1",
+    "@systemfsoftware/arethetypeswrong-cli": "file:../../.deps/arethetypeswrong-cli.tgz",
+    "@systemfsoftware/tsconfig": "file:../../.deps/tsconfig.tgz",
+    "@systemfsoftware/vitest": "file:../../.deps/vitest.tgz",
+    "@systemfsoftware/xstate": "^6.0.0-beta.65",
+    "@types/node": "24.19.1",
+    "effect": "4.1.2",
+    "fast-check": "4.9.0",
+    "rimraf": "6.1.3",
+    "tsdown": "0.23.0",
+    "typescript": "7.0.2",
+    "vitest": "5.0.3"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.mjs"
+    },
+    "./atom": {
+      "types": "./dist/atom.d.ts",
+      "default": "./dist/atom.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "clean": "rimraf dist",
+    "build": "tsdown -l warn && pnpm api:check",
+    "typecheck": "tsc -b",
+    "test": "vitest run",
+    "lint:tsgo": "effect-tsgo diagnostics --project tsconfig.app.json --format ${TSGO_FORMAT:-text} && ../../scripts/tsgo-test-diagnostics.ts",
+    "attw": "attw --pack .",
+    "api:check": "api-extractor run && api-extractor run --config api-extractor.atom.json",
+    "api:update": "api-extractor run --local && api-extractor run --local --config api-extractor.atom.json"
+  }
+}