@xstate/effect 1.0.0-alpha.8 → 1.0.0-beta.0

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

@@ -1,6 +1,5 @@
 import { Effect } from 'effect';
-import { type ActorLogicValidator, type AnyActorRef, type EventObject, type MachineContext, type SetupConfig, type SetupReturn, type SetupSchemas, type SetupStateSchema, type Sources, type SystemRegistry, type SystemRuntime } from 'xstate';
-import { effectActionBrand } from "./brands.js";
+import { type ActorLogicValidator, type AnyActorRef, type EventObject, type MachineContext, type InferEvents, type StandardSchemaV1, type SetupConfig, type SetupReturn, type SetupSchemas, type SetupStateSchema, type Sources, type SystemRegistry, type SystemRuntime } from 'xstate';
 import type { EffectRequirements } from "./types.js";
 import { type EffectSetupSchemas, type EffectSetupStateSchema, type ToStandardSetupSchemas, type ToStandardSetupStates, type ValidateEffectSetupSchemas, type ValidateEffectSetupStates } from "./schema.js";
 /**
@@ -9,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;
@@ -30,22 +31,58 @@ 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>;
+type EffectActionSource = (...args: never[]) => Effect.Effect<void, any, any>;
+type ActionContext<TSchemas> = TSchemas extends {
+    context: infer TContext extends StandardSchemaV1;
+} ? Extract<StandardSchemaV1.InferOutput<TContext>, MachineContext> : Record<string, unknown>;
+type ActionEvents<TSchemas> = (TSchemas extends {
+    events: infer TEvents extends Record<string, StandardSchemaV1>;
+} ? InferEvents<TEvents> : EventObject) | (TSchemas extends {
+    internalEvents: infer TEvents extends Record<string, StandardSchemaV1>;
+} ? string extends keyof TEvents ? never : InferEvents<TEvents> : never);
+type ActionInput<TSchemas, TKey extends PropertyKey> = TSchemas extends {
+    actions: {
+        [K in TKey]: {
+            params: infer TParams extends StandardSchemaV1;
+        };
+    };
+} ? StandardSchemaV1.InferOutput<TParams> & Pick<EffectActionArgs, 'self'> : EffectActionArgs<ActionContext<TSchemas>, ActionEvents<TSchemas>>;
+type ActionSources<TSchemas, TActionMap> = {
+    [K in keyof TActionMap]: (args: ActionInput<TSchemas, K>) => Effect.Effect<void, any, any>;
+};
+type AnnotatedActionSources<TSchemas, TActionMap> = TActionMap extends {
+    [K in keyof TActionMap]: TSchemas extends {
+        actions: {
+            [P in K]: {
+                params: StandardSchemaV1;
+            };
+        };
+    } ? ActionSources<TSchemas, TActionMap>[K] : AnyEffectAction;
+} ? unknown : never;
 type EffectActionRequirements<TAction> = TAction extends (...args: any[]) => infer TResult ? EffectRequirements<TResult> : never;
-type CoreEffectAction<TAction> = TAction extends (...args: infer TArgs) => any ? ((...args: TArgs) => void) & {
-    readonly [effectActionBrand]?: EffectActionRequirements<TAction>;
+type CoreEffectAction<TAction, TInput = never> = TAction extends (...args: infer TArgs) => any ? ((...args: [TInput] extends [never] ? TArgs : [args: TInput]) => void) & {
+    readonly '~effectRequirements'?: EffectActionRequirements<TAction>;
 } : never;
-type CoreEffectActionMap<TActionMap> = {
-    [K in keyof TActionMap]: CoreEffectAction<TActionMap[K]>;
+type CoreEffectActionMap<TActionMap, TSchemas> = {
+    [K in keyof TActionMap]: CoreEffectAction<TActionMap[K], TSchemas extends {
+        actions: {
+            [P in K]: {
+                params: StandardSchemaV1;
+            };
+        };
+    } ? ActionInput<TSchemas, K> : never>;
 };
-type EffectSetupConfig<TSchemas extends EffectSetupSchemas, TStates extends Record<string, EffectSetupStateSchema>, TActionMap extends Record<string, AnyEffectAction>, TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TValidator extends ActorLogicValidator | undefined, TSourceSchemas extends SetupSchemas = ToStandardSetupSchemas<TSchemas>> = {
+type EffectSetupConfig<TSchemas extends EffectSetupSchemas, TStates extends Record<string, EffectSetupStateSchema>, TActionMap extends Record<string, EffectActionSource>, TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TValidator extends ActorLogicValidator | undefined, TSourceSchemas extends SetupSchemas = ToStandardSetupSchemas<TSchemas>, TContextualActions extends boolean = true> = {
     validator?: TValidator;
-    actions?: TActionMap & Record<string, AnyEffectAction>;
+    actions?: TActionMap & (TContextualActions extends true ? ActionSources<NoInfer<TSourceSchemas>, TActionMap> : AnnotatedActionSources<NoInfer<TSourceSchemas>, TActionMap>);
     actors?: TActorMap;
-    guards?: NonNullable<SetupConfig<TSourceSchemas, ToStandardSetupStates<TStates>, CoreEffectActionMap<TActionMap>, TActorMap, TGuardMap, TDelayMap, TValidator>['guards']>;
-    delays?: NonNullable<SetupConfig<TSourceSchemas, ToStandardSetupStates<TStates>, CoreEffectActionMap<TActionMap>, TActorMap, TGuardMap, TDelayMap, TValidator>['delays']>;
+    guards?: NonNullable<SetupConfig<TSourceSchemas, ToStandardSetupStates<TStates>, CoreEffectActionMap<TActionMap, TSourceSchemas>, TActorMap, TGuardMap, TDelayMap, TValidator>['guards']>;
+    delays?: NonNullable<SetupConfig<TSourceSchemas, ToStandardSetupStates<TStates>, CoreEffectActionMap<TActionMap, TSourceSchemas>, TActorMap, TGuardMap, TDelayMap, TValidator>['delays']>;
     schemas?: TSchemas & ([TValidator] extends [ActorLogicValidator] ? ValidateEffectSetupSchemas<TSchemas> : unknown);
     states?: TStates & ([TValidator] extends [ActorLogicValidator] ? ValidateEffectSetupStates<TStates> : unknown);
 };
@@ -71,15 +108,18 @@ type ExtendValidatorConfig<TExtension> = [TExtension] extends [
 } : {
     validator: TExtension;
 };
-type EffectSetupExtensionConfig<TBaseSchemas extends SetupSchemas, TBaseStates extends Record<string, SetupStateSchema>, TBaseValidator extends ActorLogicValidator | undefined, TExtensionSchemas extends EffectSetupSchemas, TExtensionStates extends Record<string, EffectSetupStateSchema>, TExtensionActionMap extends Record<string, AnyEffectAction>, TExtensionActorMap extends Sources['actors'], TExtensionGuardMap extends Sources['guards'], TExtensionDelayMap extends Sources['delays'], TExtensionValidator extends ActorLogicValidator | undefined | InheritedEffectValidator> = EffectSetupConfig<TExtensionSchemas, TExtensionStates, TExtensionActionMap, TExtensionActorMap, TExtensionGuardMap, TExtensionDelayMap, ResolveExtendedValidator<TBaseValidator, TExtensionValidator>, MergeSetupSchemas<TBaseSchemas, ToStandardSetupSchemas<TExtensionSchemas>>> & ExtendValidatorConfig<TExtensionValidator> & RuntimeValidationCompatibility<NoInfer<TBaseSchemas>, NoInfer<TBaseStates>, ResolveExtendedValidator<TBaseValidator, TExtensionValidator>>;
+type EffectSetupExtensionConfig<TBaseSchemas extends SetupSchemas, TBaseStates extends Record<string, SetupStateSchema>, TBaseValidator extends ActorLogicValidator | undefined, TExtensionSchemas extends EffectSetupSchemas, TExtensionStates extends Record<string, EffectSetupStateSchema>, TExtensionActionMap extends Record<string, EffectActionSource>, TExtensionActorMap extends Sources['actors'], TExtensionGuardMap extends Sources['guards'], TExtensionDelayMap extends Sources['delays'], TExtensionValidator extends ActorLogicValidator | undefined | InheritedEffectValidator, TContextualActions extends boolean = true> = EffectSetupConfig<TExtensionSchemas, TExtensionStates, TExtensionActionMap, TExtensionActorMap, TExtensionGuardMap, TExtensionDelayMap, ResolveExtendedValidator<TBaseValidator, TExtensionValidator>, MergeSetupSchemas<TBaseSchemas, ToStandardSetupSchemas<TExtensionSchemas>>, TContextualActions> & ExtendValidatorConfig<TExtensionValidator> & RuntimeValidationCompatibility<NoInfer<TBaseSchemas>, NoInfer<TBaseStates>, ResolveExtendedValidator<TBaseValidator, TExtensionValidator>>;
 /**
  * What `setupEffect` returns: the XState `SetupReturn` with an `extend` method
  * 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, AnyEffectAction> = {}, 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>>, MergeRecord<TSetupActorMap, TExtensionActorMap>, MergeRecord<TSetupGuardMap, TExtensionGuardMap>, MergeRecord<TSetupDelayMap, TExtensionDelayMap>, TSetupDelays | Extract<keyof TExtensionDelayMap, string>, ResolveExtendedValidator<TValidator, TExtensionValidator>>;
+    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>>;
+    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, false>): 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>>;
 };
 /**
  * The Effect-aware form of XState's `setup`. It accepts Effect `Schema` values
@@ -88,7 +128,10 @@ 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, AnyEffectAction> = {}, 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>, TActorMap, TGuardMap, TDelayMap, Extract<keyof TDelayMap, string>, TValidator>;
+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>;
+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, ToStandardSetupSchemas<TSchemas>, false>): EffectSetupReturn<ToStandardSetupStates<TStates>, ToStandardSetupSchemas<TSchemas>, CoreEffectActionMap<TActionMap, ToStandardSetupSchemas<TSchemas>>, TActorMap, TGuardMap, TDelayMap, Extract<keyof TDelayMap, string>, TValidator>;
 export {};

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

@@ -1,18 +1,21 @@
 import type { AnyMachineSnapshot, AnyStateMachine, MachineContext, MachineSnapshot, SnapshotFrom, StateContextFromStateValue, StateSchema, StateValueFromStateSchema } from 'xstate';
 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.
+ * 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 = ''> = 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>>;
+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>;
 }[keyof TValue & string] : never;
 type TaggedStateOf<TSnapshot, TValue, TContext extends MachineContext, TSchema extends StateSchema> = TValue extends unknown ? {
-    readonly _tag: StateTag<TValue>;
+    readonly _tag: StateTag<TValue, '', TSchema extends {
+        id: infer TId extends string;
+    } ? TId : ''>;
     readonly value: TValue;
     readonly context: StateContextFromStateValue<TSchema, TContext, TValue>;
     readonly snapshot: TSnapshot;
@@ -21,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`,
@@ -39,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

@@ -0,0 +1,13 @@
+import type { Effect } from 'effect';
+import type { AnyActorLogic, EventFromLogic, SnapshotFrom } from 'xstate';
+import type { EffectActor } from "./effectActor.js";
+import type { ActorStoppedError, EventRejectedError } from "./errors.js";
+/**
+ * Sends one mailbox item and awaits its macrostep publication and immediate
+ * 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

@@ -1,11 +1,10 @@
 import type { Effect, Scope } from 'effect';
 import type { EffectLogicBrand } from "./effectLogic.js";
-import { effectActionBrand } from "./brands.js";
 import type { ActorScope } from "./actorScope.js";
 /** The `R` channel of an Effect type, or `never` for anything else. */
 export 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;
+    readonly '~effectRequirements'?: 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
@@ -45,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;