@xstate/effect 1.0.0-alpha.10 → 1.0.0-alpha.12

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

@@ -2,11 +2,23 @@ import { Cause, Duration, Effect, Stream } from 'effect';
 import type { Actor, ActorRef, AnyActorRef, AnyEventObject, EmittedFrom, EventRejection, ErrorFrom, InspectionEvent, OutputFrom, SnapshotFrom } from 'xstate';
 import type { EffectActor } from "./effectActor.js";
 import { ActorStoppedError, type UnwrapEffectFailure } from "./errors.js";
-/** The event type accepted by an actor's `send` method. */
+/**
+ * The event type accepted by an actor's `send` method.
+ *
+ * @experimental
+ */
 export type SendableEventFrom<TActor extends AnyActorRef> = Parameters<TActor['send']>[0];
-/** The event type an actor emits through `actor.on(...)`. */
+/**
+ * The event type an actor emits through `actor.on(...)`.
+ *
+ * @experimental
+ */
 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}. */
+/**
+ * Options for {@link waitFor}.
+ *
+ * @experimental
+ */
 export interface WaitForOptions {
     /**
      * Fails with `Cause.TimeoutError` when no snapshot satisfies the predicate
@@ -19,6 +31,8 @@ export interface WaitForOptions {
  * 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}.
+ *
+ * @experimental
  */
 export declare const send: {
     <TActor extends AnyActorRef>(event: SendableEventFrom<TActor>): (actor: TActor) => Effect.Effect<void>;
@@ -29,12 +43,16 @@ export declare const send: {
  * when the actor completes or stops, and emits the error snapshot before
  * ending when the actor errors. Interrupting the stream unsubscribes from the
  * actor.
+ *
+ * @experimental
  */
 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.
+ *
+ * @experimental
  */
 export declare function emitted<TActor extends AnyActorRef>(actor: TActor): Stream.Stream<EmittedEventFrom<TActor>>;
 /**
@@ -43,6 +61,8 @@ export declare function emitted<TActor extends AnyActorRef>(actor: TActor): Stre
  * `ActorStoppedError` if the actor stops or errors first, and with
  * `Cause.TimeoutError` when `options.timeout` elapses. Interrupting the Effect
  * unsubscribes from the actor.
+ *
+ * @experimental
  */
 export declare const waitFor: {
     <TActor extends AnyActorRef, TNarrowed extends SnapshotFrom<TActor>>(predicate: (snapshot: SnapshotFrom<TActor>) => snapshot is TNarrowed): (actor: TActor) => Effect.Effect<TNarrowed, ActorStoppedError>;
@@ -59,12 +79,16 @@ export declare const waitFor: {
  * when it is done, replays an Effect actor's original Cause when it errors, and fails with
  * `ActorStoppedError` when it stops without output. Waits for a still-active
  * actor to settle. Ordinary XState errors remain typed failures.
+ *
+ * @experimental
  */
 export declare function join<TActor extends AnyActorRef>(actor: TActor): Effect.Effect<OutputFrom<TActor>, UnwrapEffectFailure<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.
+ *
+ * @experimental
  */
 export declare function inspect(actor: AnyActorRef): Stream.Stream<InspectionEvent>;
 /**
@@ -73,5 +97,7 @@ export declare function inspect(actor: AnyActorRef): Stream.Stream<InspectionEve
  * 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.
+ *
+ * @experimental
  */
 export declare function deadLetters(actor: AnyActorRef): Stream.Stream<EventRejection>;

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

@@ -1,11 +1,17 @@
 import { Context, Effect, Scope } from 'effect';
 declare const ActorScope_base: Context.ServiceClass<ActorScope, "@xstate/effect/ActorScope", Scope.Scope>;
-/** The owning Effect actor's scope, supplied by `createEffectActor`. */
+/**
+ * The owning Effect actor's scope, supplied by `createEffectActor`.
+ *
+ * @experimental
+ */
 export declare class ActorScope extends ActorScope_base {
 }
 /**
  * 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.
+ *
+ * @experimental
  */
 export declare function withActorScope<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, Exclude<R, Scope.Scope> | ActorScope>;
 export {};

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

@@ -34,6 +34,7 @@ interface BaseActorAtoms<TLogic extends AnyActorLogic, ER> {
     /** Derives an atom of a value selected from the snapshot. */
     readonly select: <T>(selector: (snapshot: SnapshotFrom<TLogic>) => T) => Atom.Atom<AsyncResult.AsyncResult<T, ER>>;
 }
+/** @experimental */
 export type ActorAtoms<TLogic extends AnyActorLogic, ER = never> = BaseActorAtoms<TLogic, ER> & ([TLogic] extends [AnyStateMachine] ? {
     /** The machine snapshot as a tagged union over its states. */
     readonly state: Atom.Atom<AsyncResult.AsyncResult<TaggedStateFrom<SnapshotFrom<TLogic>>, ER>>;
@@ -52,5 +53,7 @@ interface MissingRequirements<T> {
  * 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.
+ *
+ * @experimental
  */
 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]: EffectActorOptionsArgs<TLogic>): ActorAtoms<TLogic, ER>;

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

@@ -2,7 +2,11 @@ import { Effect, Scope } from 'effect';
 import { type ActorOptions, type AnyActorLogic, type InputFrom, type RequiredActorOptionsFor, type RequiredActorOptionsKeys } from 'xstate';
 import { EffectActor } from "./effectActor.js";
 import type { RequirementsFrom } from "./types.js";
-/** Options for {@link createEffectActor}. */
+/**
+ * Options for {@link createEffectActor}.
+ *
+ * @experimental
+ */
 export type EffectActorOptions<TLogic extends AnyActorLogic> = {
     readonly input?: InputFrom<TLogic>;
     /**
@@ -32,5 +36,7 @@ export type EffectActorOptionsArgs<TLogic extends AnyActorLogic> = [
  * 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`.
+ *
+ * @experimental
  */
 export declare function createEffectActor<TLogic extends AnyActorLogic>(logic: TLogic, ...[options]: EffectActorOptionsArgs<TLogic>): Effect.Effect<EffectActor<TLogic>, never, RequirementsFrom<TLogic> | Scope.Scope>;

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

@@ -23,6 +23,8 @@ export declare function safeCall<T>(fn: ((arg: T) => void) | undefined, arg?: T)
  * 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.
+ *
+ * @experimental
  */
 export declare class EffectActor<TLogic extends AnyActorLogic> implements ActorRef<SnapshotFrom<TLogic>, EventFromLogic<TLogic>, EmittedFrom<TLogic>> {
     readonly logic: TLogic;

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

@@ -10,6 +10,8 @@ declare const effectLogicBrand: unique symbol;
  * failure type and its Effect service requirements, which is how
  * `RequirementsFrom` collects the `R` channel of `createEffectActor` without
  * inspecting the logic at runtime.
+ *
+ * @experimental
  */
 export interface EffectLogicBrand<TError, TRequirements> {
     readonly [effectLogicBrand]: {
@@ -21,6 +23,8 @@ export interface EffectLogicBrand<TError, TRequirements> {
  * Snapshot of a `createEffectLogic` 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 original `Cause` wrapped in `EffectFailure` as `error`.
+ *
+ * @experimental
  */
 export type EffectSnapshot<TOutput, TError, TInput> = Snapshot<TOutput> & {
     readonly context: undefined;
@@ -32,6 +36,8 @@ export type EffectSnapshot<TOutput, TError, TInput> = Snapshot<TOutput> & {
  * source the actor's `input`, its own reference (`self`), the actor `system`,
  * and `emit` for publishing events that `actor.on(...)` and `emitted(actor)`
  * observe.
+ *
+ * @experimental
  */
 export type EffectSourceArgs<TInput> = {
     readonly input: TInput;
@@ -44,6 +50,8 @@ export type EffectSourceArgs<TInput> = {
  * What `createEffectLogic` 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.
+ *
+ * @experimental
  */
 export type EffectSource<TOutput, TError, TInput, TRequirements> = Effect.Effect<TOutput, TError, TRequirements> | ((args: EffectSourceArgs<TInput>) => Effect.Effect<TOutput, TError, TRequirements>);
 type EffectActorSchemas = {
@@ -71,6 +79,8 @@ type EffectSchemaValidationConfig<TSchemas extends EffectActorSchemas> = {
  * ordinary XState actor logic carrying {@link EffectLogicBrand}, so a machine
  * can invoke or spawn it, and `createEffectActor` can collect its
  * requirements.
+ *
+ * @experimental
  */
 export type EffectActorLogic<TOutput, TError, TInput, TRequirements> = ActorLogic<EffectSnapshot<TOutput, TError, TInput>, EventObject, TInput, AnyActorSystem> & {
     readonly id?: string;
@@ -79,6 +89,8 @@ export type EffectActorLogic<TOutput, TError, TInput, TRequirements> = ActorLogi
  * Snapshot of a `createEffectStreamLogic` 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.
+ *
+ * @experimental
  */
 export type EffectStreamSnapshot<TItem, TError, TInput> = Snapshot<undefined> & {
     readonly context: TItem | undefined;
@@ -89,6 +101,8 @@ export type EffectStreamSnapshot<TItem, TError, TInput> = Snapshot<undefined> &
  * Actor logic produced by `createEffectStreamLogic`. Its snapshot is an
  * {@link EffectStreamSnapshot}, so the parent reads the latest item from the
  * child's `context` rather than from events.
+ *
+ * @experimental
  */
 export type EffectStreamActorLogic<TItem, TError, TInput, TRequirements> = ActorLogic<EffectStreamSnapshot<TItem, TError, TInput>, EventObject, TInput, AnyActorSystem> & {
     readonly id?: string;
@@ -102,6 +116,8 @@ export type EffectStreamActorLogic<TItem, TError, TInput, TRequirements> = Actor
  * 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.
+ *
+ * @experimental
  */
 export declare function createEffectLogic<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;
@@ -128,6 +144,8 @@ export declare function createEffectLogic<TOutput, TError = unknown, TInput = un
  * What `createEffectStreamLogic` and `createEffectEventStreamLogic` 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.
+ *
+ * @experimental
  */
 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 {
@@ -150,6 +168,8 @@ type StreamRequirements<T> = T extends Stream.Stream<any, any, infer R> ? R : ne
  * {@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.
+ *
+ * @experimental
  */
 export declare function createEffectStreamLogic<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;
@@ -166,6 +186,8 @@ export declare function createEffectStreamLogic<TItem, TError = unknown, TInput
  * has no output: it reaches `done` when the stream completes and `error` when
  * it fails. Accepts the same forms as `createEffectStreamLogic`. Its resources close
  * when the stream completes, fails or is interrupted.
+ *
+ * @experimental
  */
 export declare function createEffectEventStreamLogic<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;

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

@@ -1,6 +1,10 @@
 import { Cause } from 'effect';
 import type { Snapshot } from 'xstate';
-/** Preserves an Effect failure, defect or interruption through XState error routing. */
+/**
+ * Preserves an Effect failure, defect or interruption through XState error routing.
+ *
+ * @experimental
+ */
 export declare class EffectFailure<E> extends Error {
     #private;
     readonly cause: Cause.Cause<E>;
@@ -11,7 +15,11 @@ export declare class EffectFailure<E> extends Error {
 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>;
-/** @deprecated Inspect `EffectFailure.cause` for interruption instead. */
+/**
+ * @deprecated Inspect `EffectFailure.cause` for interruption instead.
+ *
+ * @experimental
+ */
 export declare class EffectInterruptedError extends EffectInterruptedError_base<{
     readonly cause: Cause.Cause<never>;
 }> {
@@ -24,6 +32,8 @@ declare const ActorStoppedError_base: new <A extends Record<string, any> = {}>(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 outcome instead, preserving an Effect failure's Cause.
+ *
+ * @experimental
  */
 export declare class ActorStoppedError extends ActorStoppedError_base<{
     readonly actorId: string;
@@ -37,6 +47,8 @@ declare const NotReadyError_base: new <A extends Record<string, any> = {}>(args:
 /**
  * Reported by the `send` atom of `createActorAtoms` when an event is sent
  * before the actor's runtime has finished building.
+ *
+ * @experimental
  */
 export declare class NotReadyError extends NotReadyError_base {
     get message(): string;
@@ -45,7 +57,11 @@ export type UnwrapEffectFailure<E> = E extends EffectFailure<infer Failure> ? Fa
 declare const EventRejectedError_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: "EventRejectedError";
 } & Readonly<A>;
-/** An event rejected at the actor's delivery boundary. */
+/**
+ * An event rejected at the actor's delivery boundary.
+ *
+ * @experimental
+ */
 export declare class EventRejectedError extends EventRejectedError_base<{
     readonly actorId: string;
     readonly event: {

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

@@ -1,2 +1,3 @@
+/** @experimental */
 declare const _default: import("@oxlint/plugins").Plugin;
 export default _default;

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

@@ -13,7 +13,11 @@ type SnapshotData<TMachine extends AnyStateMachine> = {
 declare const SnapshotCodecError_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]; }>) => import("effect/Cause").YieldableError & {
     readonly _tag: "SnapshotCodecError";
 } & Readonly<A>;
-/** A malformed transport, unsupported JSON value or missing persistence metadata. */
+/**
+ * A malformed transport, unsupported JSON value or missing persistence metadata.
+ *
+ * @experimental
+ */
 export declare class SnapshotCodecError extends SnapshotCodecError_base<{
     readonly stage: 'encode' | 'decode';
     readonly path: string;
@@ -25,6 +29,8 @@ export declare class SnapshotCodecError extends SnapshotCodecError_base<{
  * Binds a full bidirectional snapshot schema to a versioned machine. The schema
  * owns rich values and supported historical versions. Decoding never migrates;
  * restore or `machineVersions` remains responsible for migration.
+ *
+ * @experimental
  */
 export declare function createSnapshotCodec<TMachine extends AnyStateMachine & {
     readonly version: string;

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

@@ -5,12 +5,16 @@ import type { SetupSchemas, SetupStateSchema, SetupStateSchemas, StandardSchemaV
  * `createEffectStreamLogic` and `createEffectEventStreamLogic` convert it to a Standard
  * Schema, so XState infers the decoded `Schema.Type` without an explicit call
  * to `Schema.toStandardSchemaV1`.
+ *
+ * @experimental
  */
 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.
+ *
+ * @experimental
  */
 export type EffectSchemaLike = StandardSchemaV1 | EffectSchema;
 interface RuntimeValidationDoesNotSupportTransformingSchemas {
@@ -36,6 +40,8 @@ type ToStandardSchemaShape<TValue> = TValue extends EffectSchemaLike ? ToStandar
  * schema position widened to {@link EffectSchemaLike}. Covers `context`,
  * `input`, `output` and the per-key records for `events`, `internalEvents`,
  * `emitted` and `children`.
+ *
+ * @experimental
  */
 export type EffectSetupSchemas = {
     [K in keyof SetupSchemas]?: EffectSchemaShape<NonNullable<SetupSchemas[K]>>;
@@ -48,6 +54,7 @@ export type ValidateEffectSetupSchemas<TSchemas> = {
         [P in keyof TSchemas[K]]: AssertNonTransformingSchema<TSchemas[K][P]>;
     } : K extends 'context' | 'input' | 'output' ? AssertNonTransformingSchema<TSchemas[K]> : TSchemas[K];
 };
+/** @experimental */
 export type ToStandardSetupSchemas<TSchemas> = {
     [K in keyof TSchemas]: ToStandardSchemaShape<TSchemas[K]>;
 } extends infer TStandardSchemas extends SetupSchemas ? TStandardSchemas : never;
@@ -56,6 +63,8 @@ export type ToStandardSetupSchemas<TSchemas> = {
  * that state, and the same shape recursively for its child states. It is
  * XState's `SetupStateSchema` with Effect schemas allowed in every schema
  * position.
+ *
+ * @experimental
  */
 export interface EffectSetupStateSchema {
     schemas?: EffectSchemaShape<SetupStateSchemas>;
@@ -71,6 +80,7 @@ export type ValidateEffectSetupStates<TStates> = {
 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;
+/** @experimental */
 export type ToStandardSetupStates<TStates> = {
     [K in keyof TStates]: ToStandardSetupStateSchema<TStates[K]>;
 };

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

@@ -8,6 +8,8 @@ import { type EffectSetupSchemas, type EffectSetupStateSchema, type ToStandardSe
  * the actor itself and its family (`self`, `parent`, `children`), the
  * registered `actions`, `actors`, `guards` and `delays`, the actor `system`,
  * and the `params` and `output` the transition passed along.
+ *
+ * @experimental
  */
 export type EffectActionArgs<TContext extends MachineContext = MachineContext, TEvent extends EventObject = EventObject> = {
     readonly context: TContext;
@@ -29,6 +31,8 @@ export type EffectActionArgs<TContext extends MachineContext = MachineContext, T
  * enqueued, and returns an Effect that runs afterwards in the actor's Effect
  * context. The Effect is interrupted when the actor stops; its failures and
  * defects route to the state's `onError`.
+ *
+ * @experimental
  */
 export type EffectAction<TContext extends MachineContext = MachineContext, TEvent extends EventObject = EventObject, TError = unknown, TRequirements = never> = (args: EffectActionArgs<TContext, TEvent>) => Effect.Effect<void, TError, TRequirements>;
 type AnyEffectAction = EffectAction<any, any, any, any>;
@@ -110,6 +114,8 @@ type EffectSetupExtensionConfig<TBaseSchemas extends SetupSchemas, TBaseStates e
  * that also accepts Effect schemas and Effect-returning actions. Call
  * `createMachine` on it to build a machine whose registered actions and actors
  * contribute to `RequirementsFrom`.
+ *
+ * @experimental
  */
 export type EffectSetupReturn<TStates extends Record<string, SetupStateSchema> = Record<string, SetupStateSchema>, TSchemas extends SetupSchemas = {}, TSetupActionMap extends Sources['actions'] = {}, TSetupActorMap extends Sources['actors'] = {}, TSetupGuardMap extends Sources['guards'] = {}, TSetupDelayMap extends Sources['delays'] = {}, TSetupDelays extends string = Extract<keyof TSetupDelayMap, string>, TValidator extends ActorLogicValidator | undefined = undefined> = Omit<SetupReturn<TStates, TSchemas, TSetupActionMap, TSetupActorMap, TSetupGuardMap, TSetupDelayMap, TSetupDelays, SystemRegistry, TValidator>, 'extend'> & {
     extend<const TExtensionSchemas extends EffectSetupSchemas = {}, const TExtensionStates extends Record<string, EffectSetupStateSchema> = {}, TExtensionActionMap extends Record<string, EffectActionSource> = {}, TExtensionActorMap extends Sources['actors'] = {}, TExtensionGuardMap extends Sources['guards'] = {}, TExtensionDelayMap extends Sources['delays'] = {}, const TExtensionValidator extends ActorLogicValidator | undefined | InheritedEffectValidator = InheritedEffectValidator>(config: EffectSetupExtensionConfig<TSchemas, TStates, TValidator, TExtensionSchemas, TExtensionStates, TExtensionActionMap, TExtensionActorMap, TExtensionGuardMap, TExtensionDelayMap, TExtensionValidator>): EffectSetupReturn<MergeRecord<TStates, ToStandardSetupStates<TExtensionStates>>, MergeSetupSchemas<TSchemas, ToStandardSetupSchemas<TExtensionSchemas>>, MergeRecord<TSetupActionMap, CoreEffectActionMap<TExtensionActionMap, MergeSetupSchemas<TSchemas, ToStandardSetupSchemas<TExtensionSchemas>>>>, MergeRecord<TSetupActorMap, TExtensionActorMap>, MergeRecord<TSetupGuardMap, TExtensionGuardMap>, MergeRecord<TSetupDelayMap, TExtensionDelayMap>, TSetupDelays | Extract<keyof TExtensionDelayMap, string>, ResolveExtendedValidator<TValidator, TExtensionValidator>>;
@@ -122,6 +128,8 @@ export type EffectSetupReturn<TStates extends Record<string, SetupStateSchema> =
  * runs in the actor's Effect context. Everything else, including `actors`,
  * `guards`, `delays` and `extend`, behaves as in `setup`. Machines built from
  * it must be started with `createEffectActor`.
+ *
+ * @experimental
  */
 export declare function setupEffect(): EffectSetupReturn;
 export declare function setupEffect<const TSchemas extends EffectSetupSchemas = {}, const TStates extends Record<string, EffectSetupStateSchema> = Record<string, EffectSetupStateSchema>, TActionMap extends Record<string, EffectActionSource> = {}, TActorMap extends Sources['actors'] = {}, TGuardMap extends Sources['guards'] = {}, TDelayMap extends Sources['delays'] = {}, const TValidator extends ActorLogicValidator | undefined = undefined>(config: EffectSetupConfig<TSchemas, TStates, TActionMap, TActorMap, TGuardMap, TDelayMap, TValidator>): EffectSetupReturn<ToStandardSetupStates<TStates>, ToStandardSetupSchemas<TSchemas>, CoreEffectActionMap<TActionMap, ToStandardSetupSchemas<TSchemas>>, TActorMap, TGuardMap, TDelayMap, Extract<keyof TDelayMap, string>, TValidator>;

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

@@ -6,6 +6,8 @@ type Join<TPrefix extends string, TKey extends string> = TPrefix extends '' ? TK
  * state has no single path, so its tag stops at the parallel state. When the
  * machine itself is parallel, the tag is `TRootTag`: the machine id, or `''`
  * for a machine without one.
+ *
+ * @experimental
  */
 export type StateTag<TValue, TPrefix extends string = '', TRootTag 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 '' ? TRootTag : TPrefix : {
     [K in keyof TValue & string]: StateTag<TValue[K], Join<TPrefix, K>, TRootTag>;
@@ -22,9 +24,15 @@ type TaggedStateOf<TSnapshot, TValue, TContext extends MachineContext, TSchema e
  * 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.
+ *
+ * @experimental
  */
 export 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. */
+/**
+ * The tagged state union of a machine.
+ *
+ * @experimental
+ */
 export type TaggedState<TMachine extends AnyStateMachine> = TaggedStateFrom<SnapshotFrom<TMachine>>;
 /**
  * Views a machine snapshot as a tagged union member for `Match.tag`,
@@ -40,6 +48,8 @@ export type TaggedState<TMachine extends AnyStateMachine> = TaggedStateFrom<Snap
  * );
  * view(taggedState(snapshot));
  * ```
+ *
+ * @experimental
  */
 export declare function taggedState<TSnapshot extends AnyMachineSnapshot>(snapshot: TSnapshot): TaggedStateFrom<TSnapshot>;
 export {};

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

@@ -7,5 +7,7 @@ import type { ActorStoppedError, EventRejectedError } from "./errors.js";
  * effect scheduling. Ignored events are acknowledged too. Does not await
  * invoked work, background actions or future timers. Interrupting the waiter
  * detaches its receipt without retracting the event.
+ *
+ * @experimental
  */
 export declare function sendAndAwait<TLogic extends AnyActorLogic>(actor: EffectActor<TLogic>, event: EventFromLogic<TLogic>): Effect.Effect<SnapshotFrom<TLogic>, ActorStoppedError | EventRejectedError>;

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

@@ -44,6 +44,8 @@ type RequirementsFromStateSchema<TSchema, TDepth extends Depth> = (TSchema exten
  * 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 {@link MaxDepth} levels of machine nesting).
+ *
+ * @experimental
  */
 export type RequirementsFrom<T, TDepth extends Depth = MaxDepth> = T extends EffectLogicBrand<any, infer R> ? Exclude<R, ActorScope | Scope.Scope> : T extends {
     readonly _actionMap: infer TActionMap;

package/dist/{state-a3f54e06.js → state-a2154dce.js}

@@ -25,7 +25,11 @@ function _classPrivateFieldGet2(s, a) {
 }
 
 var _effectFailure = /*#__PURE__*/new WeakMap();
-/** Preserves an Effect failure, defect or interruption through XState error routing. */
+/**
+ * Preserves an Effect failure, defect or interruption through XState error routing.
+ *
+ * @experimental
+ */
 class EffectFailure extends Error {
   static is(value) {
     return typeof value === 'object' && value !== null && _effectFailure.has(_checkInRHS(value)) && _classPrivateFieldGet2(_effectFailure, value);
@@ -39,7 +43,11 @@ class EffectFailure extends Error {
   }
 }
 
-/** @deprecated Inspect `EffectFailure.cause` for interruption instead. */
+/**
+ * @deprecated Inspect `EffectFailure.cause` for interruption instead.
+ *
+ * @experimental
+ */
 class EffectInterruptedError extends Data.TaggedError('EffectInterruptedError') {
   get message() {
     return 'Effect was interrupted before the actor completed';
@@ -50,6 +58,8 @@ class EffectInterruptedError extends Data.TaggedError('EffectInterruptedError')
  * 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 outcome instead, preserving an Effect failure's Cause.
+ *
+ * @experimental
  */
 class ActorStoppedError extends Data.TaggedError('ActorStoppedError') {
   get message() {
@@ -60,6 +70,8 @@ class ActorStoppedError extends Data.TaggedError('ActorStoppedError') {
 /**
  * Reported by the `send` atom of `createActorAtoms` when an event is sent
  * before the actor's runtime has finished building.
+ *
+ * @experimental
  */
 class NotReadyError extends Data.TaggedError('NotReadyError') {
   get message() {
@@ -71,7 +83,11 @@ class NotReadyError extends Data.TaggedError('NotReadyError') {
 function causeFromError(error) {
   return error instanceof EffectFailure ? error.cause : Cause.fail(error);
 }
-/** An event rejected at the actor's delivery boundary. */
+/**
+ * An event rejected at the actor's delivery boundary.
+ *
+ * @experimental
+ */
 class EventRejectedError extends Data.TaggedError('EventRejectedError') {}
 
 const symbolObservable = (() => typeof Symbol === 'function' && Symbol.observable || '@@observable')();
@@ -105,6 +121,8 @@ function toObserver(nextHandler, errorHandler, completionHandler) {
  * 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.
+ *
+ * @experimental
  */
 class EffectActor {
   constructor(logic, root, snapshot, _mailbox, _stopExecution, _inspectors) {
@@ -533,12 +551,18 @@ function relayToParent(actor, event) {
   }
 }
 
-/** The owning Effect actor's scope, supplied by `createEffectActor`. */
+/**
+ * The owning Effect actor's scope, supplied by `createEffectActor`.
+ *
+ * @experimental
+ */
 class ActorScope extends Context.Service()('@xstate/effect/ActorScope') {}
 
 /**
  * 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.
+ *
+ * @experimental
  */
 function withActorScope(effect) {
   return ActorScope.use(scope => Scope.provide(effect, scope));
@@ -547,7 +571,11 @@ function withActorScope(effect) {
 const XSTATE_TIMER = 'xstate.timer';
 const XSTATE_INIT = 'xstate.init';
 
-/** Options for {@link createEffectActor}. */
+/**
+ * Options for {@link createEffectActor}.
+ *
+ * @experimental
+ */
 
 /**
  * Creates and starts an actor as an Effect interpreter over pure transitions.
@@ -562,6 +590,8 @@ const XSTATE_INIT = 'xstate.init';
  * 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`.
+ *
+ * @experimental
  */
 function createEffectActor(logic, ...[options]) {
   return Effect.acquireRelease(Effect.gen(function* () {
@@ -687,6 +717,8 @@ function createEffectActor(logic, ...[options]) {
         };
       })
     }, {
+      // A live actor needs one FIFO for child events, sends and timers.
+      captureRootEvents: false,
       inspect: event => {
         // The pure step scope re-materializes the root ref per step and
         // announces it again; observers should see the root once.
@@ -845,15 +877,23 @@ function createEffectActor(logic, ...[options]) {
  * state has no single path, so its tag stops at the parallel state. When the
  * machine itself is parallel, the tag is `TRootTag`: the machine id, or `''`
  * for a machine without one.
+ *
+ * @experimental
  */
 
 /**
  * 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.
+ *
+ * @experimental
  */
 
-/** The tagged state union of a machine. */
+/**
+ * The tagged state union of a machine.
+ *
+ * @experimental
+ */
 
 /** Computes the dotted path tag of a state value. */
 function stateTag(value, rootTag, prefix = '') {
@@ -882,6 +922,8 @@ function stateTag(value, rootTag, prefix = '') {
  * );
  * view(taggedState(snapshot));
  * ```
+ *
+ * @experimental
  */
 function taggedState(snapshot) {
   return {

package/dist/xstate-effect-atom.js

@@ -1,8 +1,8 @@
 import { Cause } from 'effect';
 import { Atom, AsyncResult } from 'effect/reactivity';
 import { StateMachine } from 'xstate';
-import { c as createEffectActor, a as causeFromError, N as NotReadyError, t as taggedState } from './state-a3f54e06.js';
-export { N as NotReadyError } from './state-a3f54e06.js';
+import { c as createEffectActor, a as causeFromError, N as NotReadyError, t as taggedState } from './state-a2154dce.js';
+export { N as NotReadyError } from './state-a2154dce.js';
 import 'xstate/durable';
 
 /**
@@ -11,6 +11,8 @@ import 'xstate/durable';
  * framework, such as `@effect/atom-react`.
  */
 
+/** @experimental */
+
 /**
  * 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
@@ -22,6 +24,8 @@ import 'xstate/durable';
  * 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.
+ *
+ * @experimental
  */
 function createActorAtoms(runtime, logic, ...[options]) {
   const host = runtime;

package/dist/xstate-effect-oxlint.js

@@ -112,6 +112,8 @@ const noInlineEffect = defineRule({
     type: 'problem'
   }
 });
+
+/** @experimental */
 var oxlint = definePlugin({
   meta: {
     name: 'xstate-effect'

package/dist/xstate-effect-test.js

@@ -3,6 +3,8 @@
  * effect scheduling. Ignored events are acknowledged too. Does not await
  * invoked work, background actions or future timers. Interrupting the waiter
  * detaches its receipt without retracting the event.
+ *
+ * @experimental
  */
 function sendAndAwait(actor, event) {
   return actor._sendAndAwait(event);

package/dist/xstate-effect.js

@@ -1,7 +1,7 @@
 import { Schema, Effect, Stream, Cause, Exit, Queue, Data } from 'effect';
 import { createStepLogic, setup } from 'xstate';
-import { s as startHostedEffect, r as relayToParent, E as EffectFailure, A as ActorStoppedError, a as causeFromError, b as runHostedEffect } from './state-a3f54e06.js';
-export { e as ActorScope, A as ActorStoppedError, d as EffectActor, E as EffectFailure, g as EffectInterruptedError, f as EventRejectedError, c as createEffectActor, t as taggedState, w as withActorScope } from './state-a3f54e06.js';
+import { s as startHostedEffect, r as relayToParent, E as EffectFailure, A as ActorStoppedError, a as causeFromError, b as runHostedEffect } from './state-a2154dce.js';
+export { e as ActorScope, A as ActorStoppedError, d as EffectActor, E as EffectFailure, g as EffectInterruptedError, f as EventRejectedError, c as createEffectActor, t as taggedState, w as withActorScope } from './state-a2154dce.js';
 import { dual } from 'effect/Function';
 import 'xstate/durable';
 
@@ -10,12 +10,16 @@ import 'xstate/durable';
  * `createEffectStreamLogic` and `createEffectEventStreamLogic` convert it to a Standard
  * Schema, so XState infers the decoded `Schema.Type` without an explicit call
  * to `Schema.toStandardSchemaV1`.
+ *
+ * @experimental
  */
 
 /**
  * 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.
+ *
+ * @experimental
  */
 
 /**
@@ -23,15 +27,23 @@ import 'xstate/durable';
  * schema position widened to {@link EffectSchemaLike}. Covers `context`,
  * `input`, `output` and the per-key records for `events`, `internalEvents`,
  * `emitted` and `children`.
+ *
+ * @experimental
  */
 
+/** @experimental */
+
 /**
  * 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.
+ *
+ * @experimental
  */
 
+/** @experimental */
+
 function isStandardSchema(value) {
   return !!value && (typeof value === 'object' || typeof value === 'function') && '~standard' in value;
 }
@@ -87,12 +99,16 @@ const effectLogicBrand = Symbol.for('@xstate/effect/logic');
  * failure type and its Effect service requirements, which is how
  * `RequirementsFrom` collects the `R` channel of `createEffectActor` without
  * inspecting the logic at runtime.
+ *
+ * @experimental
  */
 
 /**
  * Snapshot of a `createEffectLogic` 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 original `Cause` wrapped in `EffectFailure` as `error`.
+ *
+ * @experimental
  */
 
 /**
@@ -100,12 +116,16 @@ const effectLogicBrand = Symbol.for('@xstate/effect/logic');
  * source the actor's `input`, its own reference (`self`), the actor `system`,
  * and `emit` for publishing events that `actor.on(...)` and `emitted(actor)`
  * observe.
+ *
+ * @experimental
  */
 
 /**
  * What `createEffectLogic` 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.
+ *
+ * @experimental
  */
 
 /**
@@ -113,18 +133,24 @@ const effectLogicBrand = Symbol.for('@xstate/effect/logic');
  * ordinary XState actor logic carrying {@link EffectLogicBrand}, so a machine
  * can invoke or spawn it, and `createEffectActor` can collect its
  * requirements.
+ *
+ * @experimental
  */
 
 /**
  * Snapshot of a `createEffectStreamLogic` 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.
+ *
+ * @experimental
  */
 
 /**
  * Actor logic produced by `createEffectStreamLogic`. Its snapshot is an
  * {@link EffectStreamSnapshot}, so the parent reads the latest item from the
  * child's `context` rather than from events.
+ *
+ * @experimental
  */
 
 function preserveFailure(error) {
@@ -187,6 +213,8 @@ function brandLogic(logic, error, requirements) {
  * 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.
+ *
+ * @experimental
  */
 
 function createEffectLogic(sourceOrConfig) {
@@ -256,6 +284,8 @@ function createEffectLogic(sourceOrConfig) {
  * What `createEffectStreamLogic` and `createEffectEventStreamLogic` 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.
+ *
+ * @experimental
  */
 
 function resolveStreamConfig(sourceOrConfig) {
@@ -276,6 +306,8 @@ function toLogicSchemas(schemas) {
  * {@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.
+ *
+ * @experimental
  */
 
 function createEffectStreamLogic(sourceOrConfig) {
@@ -348,6 +380,8 @@ function createEffectStreamLogic(sourceOrConfig) {
  * has no output: it reaches `done` when the stream completes and `error` when
  * it fails. Accepts the same forms as `createEffectStreamLogic`. Its resources close
  * when the stream completes, fails or is interrupted.
+ *
+ * @experimental
  */
 
 function createEffectEventStreamLogic(sourceOrConfig) {
@@ -402,11 +436,23 @@ function createEffectEventStreamLogic(sourceOrConfig) {
   return brandLogic(logic, undefined, undefined);
 }
 
-/** The event type accepted by an actor's `send` method. */
+/**
+ * The event type accepted by an actor's `send` method.
+ *
+ * @experimental
+ */
 
-/** The event type an actor emits through `actor.on(...)`. */
+/**
+ * The event type an actor emits through `actor.on(...)`.
+ *
+ * @experimental
+ */
 
-/** Options for {@link waitFor}. */
+/**
+ * Options for {@link waitFor}.
+ *
+ * @experimental
+ */
 
 const noopSubscription = {
   unsubscribe: () => {}
@@ -439,6 +485,8 @@ function isActorRef(value) {
  * 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}.
+ *
+ * @experimental
  */
 const send = dual(2, (actor, event) => Effect.sync(() => {
   actor.send(event);
@@ -449,6 +497,8 @@ const send = dual(2, (actor, event) => Effect.sync(() => {
  * when the actor completes or stops, and emits the error snapshot before
  * ending when the actor errors. Interrupting the stream unsubscribes from the
  * actor.
+ *
+ * @experimental
  */
 function snapshots(actor) {
   return Stream.callback(queue => Effect.acquireRelease(Effect.sync(() => {
@@ -480,6 +530,8 @@ function snapshots(actor) {
  * 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.
+ *
+ * @experimental
  */
 function emitted(actor) {
   return Stream.callback(queue => Effect.acquireRelease(Effect.sync(() => {
@@ -511,6 +563,8 @@ function emitted(actor) {
  * `ActorStoppedError` if the actor stops or errors first, and with
  * `Cause.TimeoutError` when `options.timeout` elapses. Interrupting the Effect
  * unsubscribes from the actor.
+ *
+ * @experimental
  */
 const waitFor = dual(args => isActorRef(args[0]), (actor, predicate, options) => {
   const waiting = Effect.callback(resume => {
@@ -567,6 +621,8 @@ const waitFor = dual(args => isActorRef(args[0]), (actor, predicate, options) =>
  * when it is done, replays an Effect actor's original Cause when it errors, and fails with
  * `ActorStoppedError` when it stops without output. Waits for a still-active
  * actor to settle. Ordinary XState errors remain typed failures.
+ *
+ * @experimental
  */
 function join(actor) {
   return Effect.callback(resume => {
@@ -614,6 +670,8 @@ function join(actor) {
  * 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.
+ *
+ * @experimental
  */
 function inspect(actor) {
   return Stream.callback(queue => Effect.acquireRelease(Effect.sync(() => {
@@ -633,6 +691,8 @@ function inspect(actor) {
  * 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.
+ *
+ * @experimental
  */
 function deadLetters(actor) {
   return Stream.callback(queue => Effect.acquireRelease(Effect.sync(() => actor.system.onRejectedEvent(rejection => {
@@ -648,6 +708,8 @@ function deadLetters(actor) {
  * the actor itself and its family (`self`, `parent`, `children`), the
  * registered `actions`, `actors`, `guards` and `delays`, the actor `system`,
  * and the `params` and `output` the transition passed along.
+ *
+ * @experimental
  */
 
 /**
@@ -656,6 +718,8 @@ function deadLetters(actor) {
  * enqueued, and returns an Effect that runs afterwards in the actor's Effect
  * context. The Effect is interrupted when the actor stops; its failures and
  * defects route to the state's `onError`.
+ *
+ * @experimental
  */
 
 /**
@@ -663,6 +727,8 @@ function deadLetters(actor) {
  * that also accepts Effect schemas and Effect-returning actions. Call
  * `createMachine` on it to build a machine whose registered actions and actors
  * contribute to `RequirementsFrom`.
+ *
+ * @experimental
  */
 
 function wrapActions(actions) {
@@ -719,6 +785,8 @@ function decorateEffectSetup(effectSetup) {
  * runs in the actor's Effect context. Everything else, including `actors`,
  * `guards`, `delays` and `extend`, behaves as in `setup`. Machines built from
  * it must be started with `createEffectActor`.
+ *
+ * @experimental
  */
 
 function setupEffect(config = {}) {
@@ -730,7 +798,11 @@ function setupEffect(config = {}) {
   }));
 }
 
-/** A malformed transport, unsupported JSON value or missing persistence metadata. */
+/**
+ * A malformed transport, unsupported JSON value or missing persistence metadata.
+ *
+ * @experimental
+ */
 class SnapshotCodecError extends Data.TaggedError('SnapshotCodecError') {
   get message() {
     return `${this.stage} at ${this.path}: ${this.reason}`;
@@ -845,6 +917,8 @@ function checked(stage, run) {
  * Binds a full bidirectional snapshot schema to a versioned machine. The schema
  * owns rich values and supported historical versions. Decoding never migrates;
  * restore or `machineVersions` remains responsible for migration.
+ *
+ * @experimental
  */
 function createSnapshotCodec(machine, schema) {
   const format = '@xstate/effect/snapshot';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xstate/effect",
-  "version": "1.0.0-alpha.10",
+  "version": "1.0.0-alpha.12",
   "type": "module",
   "description": "Effect integration for XState",
   "keywords": [
@@ -33,14 +33,14 @@
   "peerDependencies": {
     "@oxlint/plugins": "^1.76.0",
     "effect": "^4.0.0",
-    "xstate": "^6.0.0-alpha.71"
+    "xstate": "^6.0.0-alpha.73"
   },
   "devDependencies": {
     "@oxlint/plugins": "^1.76.0",
     "effect": "4.0.6",
     "fast-check": "4.10.2",
     "@xstate/test": "^2.0.0-alpha.4",
-    "xstate": "^6.0.0-alpha.71"
+    "xstate": "^6.0.0-alpha.73"
   },
   "preconstruct": {
     "entrypoints": [