@xstate/effect 0.1.0-alpha.7 → 1.0.0-alpha.9

package/README.md

@@ -9,6 +9,8 @@ Combine XState's event-driven workflows with Effect services, scopes, clocks and
 
 This package is experimental. It targets XState v6 alpha and Effect 4.
 
+In these docs, "transition effects" are the executable effect descriptors (`ExecutableEffect`) that an XState transition returns. "Effect" means an Effect.ts program.
+
 ## Installation
 
 <!-- package name and peer dependencies from package.json -->
@@ -29,7 +31,7 @@ A release waits for approval, expires after 30 seconds, and allows cancellation
 import { Context, Effect, Schema } from 'effect';
 import {
   createEffectActor,
-  fromEffect,
+  createEffectLogic,
   send,
   setupEffect,
   waitFor
@@ -40,7 +42,7 @@ export class Deployments extends Context.Service<
   { readonly deploy: (release: string) => Effect.Effect<string, Error> }
 >()('@app/Deployments') {}
 
-const deploy = fromEffect({
+const deploy = createEffectLogic({
   schemas: { input: Schema.Struct({ release: Schema.String }) },
   effect: ({ input }) => Deployments.use((api) => api.deploy(input.release))
 });
@@ -134,7 +136,7 @@ Start Effect-backed logic with `createEffectActor` inside an Effect scope.
 | [Atoms and React](docs/atoms-and-react.md) | Registry ownership, approval controls and useSelector. |
 | [Testing and errors](docs/testing-and-errors.md) | TestClock, task retries, supervision and typed failures. |
 
-Runnable copies live in [examples/effect-workflows](../../examples/effect-workflows). Their tests verify the docs use the same code.
+Try the runnable examples in [examples/effect-workflows](../../examples/effect-workflows).
 
 ## Actors
 
@@ -183,13 +185,13 @@ The actor's later errors are observed through `join` or snapshots. Invalid input
 
 ## Effect actor logic
 
-<!-- fromEffect, fromEffectStream, fromEffectEventStream from src/fromEffect.ts -->
+<!-- createEffectLogic, createEffectStreamLogic, createEffectEventStreamLogic from src/createEffectLogic.ts -->
 
 | Function | Behavior |
 | --- | --- |
-| `fromEffect` | Run a task; its success value is the actor's output. |
-| `fromEffectStream` | Expose the latest stream item as snapshot context. |
-| `fromEffectEventStream` | Relay stream items to the parent as events. |
+| `createEffectLogic` | Run a task; its success value is the actor's output. |
+| `createEffectStreamLogic` | Expose the latest stream item as snapshot context. |
+| `createEffectEventStreamLogic` | Relay stream items to the parent as events. |
 
 For example, a progress stream can feed an upload UI:
 
@@ -197,10 +199,14 @@ For example, a progress stream can feed an upload UI:
 
 ```ts
 import { Effect, Option, Stream } from 'effect';
-import { createEffectActor, fromEffectStream, snapshots } from '@xstate/effect';
+import {
+  createEffectActor,
+  createEffectStreamLogic,
+  snapshots
+} from '@xstate/effect';
 
 // Demo upload progress. Replace with your upload SDK's progress stream.
-const uploadProgress = fromEffectStream(Stream.make(0, 25, 60, 100));
+const uploadProgress = createEffectStreamLogic(Stream.make(0, 25, 60, 100));
 
 const program = Effect.gen(function* () {
   const actor = yield* createEffectActor(uploadProgress);
@@ -229,7 +235,7 @@ See [Effect actor logic](docs/effect-logic.md) for tasks and a stream that drive
 <!-- effect action contract from src/setupEffect.ts; spawn guard from src/internal.ts -->
 
 - Register background Effect actions in `setupEffect({ actions })`; enqueue them with explicit arguments.
-- Invoke `fromEffect` logic when the machine needs to wait for a result.
+- Invoke `createEffectLogic` logic when the machine needs to wait for a result.
 - Register spawned Effect logic in `actors`, then use `enq.spawn(args.actors.worker)`.
 
 See [schemas and actions](docs/schemas-and-actions.md) for a complete audit example, runtime schema constraints and inline-source pitfalls.
@@ -260,6 +266,6 @@ See [testing and errors](docs/testing-and-errors.md) for executable deadline, re
 
 ## Tracing
 
-<!-- span names and attributes from src/internal.ts and src/fromEffect.ts -->
+<!-- span names and attributes from src/internal.ts and src/createEffectLogic.ts -->
 
-Hosted work uses spans named `fromEffect`, `fromEffectStream`, `fromEffectEventStream` and `action.<name>`. Each carries `xstate.actor.id` and `xstate.actor.address`. Provide a `Tracer` to record and export them.
+Hosted work uses spans named `createEffectLogic`, `createEffectStreamLogic`, `createEffectEventStreamLogic` and `action.<name>`. Each carries `xstate.actor.id` and `xstate.actor.address`. Provide a `Tracer` to record and export them.

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

@@ -53,8 +53,7 @@ export declare class EffectActor<TLogic extends AnyActorLogic> implements ActorR
     inspect(observer: Observer<InspectionEvent> | ((event: InspectionEvent) => void)): Subscription;
     [symbolObservable](): this;
     toJSON(): {
-        xstate$$type: number;
-        id: string;
+        $actor: string;
     };
 }
 export {};

package/dist/declarations/src/{fromEffect.d.ts → effectLogic.d.ts}

@@ -4,8 +4,8 @@ import type { EffectRequirements } from "./types.js";
 import { type EffectSchemaLike, type ToStandardSchema, type ValidateEffectActorSchemas } from "./schema.js";
 declare const effectLogicBrand: unique symbol;
 /**
- * Type-level marker attached to logic created by `fromEffect`,
- * `fromEffectStream` and `fromEffectEventStream`. It carries the logic's
+ * Type-level marker attached to logic created by `createEffectLogic`,
+ * `createEffectStreamLogic` and `createEffectEventStreamLogic`. 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.
@@ -17,7 +17,7 @@ export interface EffectLogicBrand<TError, TRequirements> {
     };
 }
 /**
- * Snapshot of a `fromEffect` actor. The actor holds no context of its own: it
+ * 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 Effect's failure, defect or
  * `EffectInterruptedError` as `error`.
@@ -41,7 +41,7 @@ export type EffectSourceArgs<TInput> = {
     readonly emit: (event: AnyEventObject) => void;
 };
 /**
- * What `fromEffect` accepts as its Effect: either an Effect value, or a
+ * 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.
  */
@@ -67,7 +67,7 @@ type EffectSchemaValidationConfig<TSchemas extends EffectActorSchemas> = {
     readonly schemas: TSchemas;
 };
 /**
- * Actor logic produced by `fromEffect` and `fromEffectEventStream`. It is
+ * Actor logic produced by `createEffectLogic` and `createEffectEventStreamLogic`. It is
  * ordinary XState actor logic carrying {@link EffectLogicBrand}, so a machine
  * can invoke or spawn it, and `createEffectActor` can collect its
  * requirements.
@@ -76,7 +76,7 @@ export type EffectActorLogic<TOutput, TError, TInput, TRequirements> = ActorLogi
     readonly id?: string;
 } & EffectLogicBrand<TError, TRequirements>;
 /**
- * Snapshot of a `fromEffectStream` actor. `context` holds the most recent
+ * 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.
  */
@@ -86,7 +86,7 @@ export type EffectStreamSnapshot<TItem, TError, TInput> = Snapshot<undefined> &
     readonly error: TError | undefined;
 };
 /**
- * Actor logic produced by `fromEffectStream`. Its snapshot is an
+ * 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.
  */
@@ -105,11 +105,11 @@ export type EffectStreamActorLogic<TItem, TError, TInput, TRequirements> = Actor
  * interruption. Use `withActorScope` to retain a resource until the owning
  * Effect actor stops.
  */
-export declare function fromEffect<const TInputSchema extends EffectSchemaLike, const TOutputSchema extends EffectSchemaLike, TError = unknown, TRequirements = never>(config: Omit<EffectSourceConfig<SchemaOutput<TOutputSchema>, TError, SchemaOutput<TInputSchema>, TRequirements>, 'schemas' | 'validator'> & EffectSchemaValidationConfig<{
+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;
     output: TOutputSchema;
 }>): EffectActorLogic<SchemaOutput<TOutputSchema>, TError, SchemaOutput<TInputSchema>, TRequirements>;
-export declare function fromEffect<const TInputSchema extends EffectSchemaLike, TEffect extends Effect.Effect<any, any, any>>(config: Omit<EffectSourceConfig<EffectSuccess<TEffect>, EffectFailure<TEffect>, SchemaOutput<TInputSchema>, EffectRequirements<TEffect>, {
+export declare function createEffectLogic<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;
@@ -117,17 +117,17 @@ export declare function fromEffect<const TInputSchema extends EffectSchemaLike,
 }> & {
     effect: TEffect | ((args: EffectSourceArgs<SchemaOutput<TInputSchema>>) => TEffect);
 }): EffectActorLogic<EffectSuccess<TEffect>, EffectFailure<TEffect>, SchemaOutput<TInputSchema>, EffectRequirements<TEffect>>;
-export declare function fromEffect<const TOutputSchema extends EffectSchemaLike, TError = unknown, TInput = undefined, TRequirements = never>(config: Omit<EffectSourceConfig<SchemaOutput<TOutputSchema>, TError, TInput, TRequirements>, 'schemas' | 'validator'> & EffectSchemaValidationConfig<{
+export declare function createEffectLogic<const TOutputSchema extends EffectSchemaLike, TError = unknown, TInput = undefined, TRequirements = never>(config: Omit<EffectSourceConfig<SchemaOutput<TOutputSchema>, TError, TInput, TRequirements>, 'schemas' | 'validator'> & EffectSchemaValidationConfig<{
     input?: never;
     output: TOutputSchema;
 }>): EffectActorLogic<SchemaOutput<TOutputSchema>, TError, TInput, TRequirements>;
-export declare function fromEffect<TOutput, TError = unknown, TInput = undefined, TRequirements = never>(config: EffectSourceConfig<TOutput, TError, TInput, TRequirements> & {
+export declare function createEffectLogic<TOutput, TError = unknown, TInput = undefined, TRequirements = never>(config: EffectSourceConfig<TOutput, TError, TInput, TRequirements> & {
     schemas?: undefined;
 }): EffectActorLogic<TOutput, TError, TInput, TRequirements>;
-export declare function fromEffect<TOutput, TError = unknown, TRequirements = never>(effect: Effect.Effect<TOutput, TError, TRequirements>): EffectActorLogic<TOutput, TError, undefined, TRequirements>;
-export declare function fromEffect<TOutput, TError = unknown, TInput = undefined, TRequirements = never>(effect: (args: EffectSourceArgs<TInput>) => Effect.Effect<TOutput, TError, TRequirements>): EffectActorLogic<TOutput, TError, TInput, TRequirements>;
+export declare function createEffectLogic<TOutput, TError = unknown, TRequirements = never>(effect: Effect.Effect<TOutput, TError, TRequirements>): EffectActorLogic<TOutput, TError, undefined, TRequirements>;
+export declare function createEffectLogic<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:
+ * 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.
  */
@@ -153,29 +153,29 @@ type StreamRequirements<T> = T extends Stream.Stream<any, any, infer R> ? R : ne
  * `schemas`, `validator` and `stream`. Its resources close when the stream
  * completes, fails or is interrupted.
  */
-export declare function fromEffectStream<const TInputSchema extends EffectSchemaLike, TStream extends Stream.Stream<any, any, any>>(config: Omit<EffectStreamConfig<StreamItem<TStream>, StreamError<TStream>, SchemaOutput<TInputSchema>, StreamRequirements<TStream>>, 'stream' | 'schemas' | 'validator'> & EffectSchemaValidationConfig<{
+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;
 }> & {
     stream: TStream | ((args: EffectSourceArgs<SchemaOutput<TInputSchema>>) => TStream);
 }): EffectStreamActorLogic<StreamItem<TStream>, StreamError<TStream>, SchemaOutput<TInputSchema>, StreamRequirements<TStream>>;
-export declare function fromEffectStream<TItem, TError = unknown, TInput = undefined, TRequirements = never>(config: EffectStreamConfig<TItem, TError, TInput, TRequirements> & {
+export declare function createEffectStreamLogic<TItem, TError = unknown, TInput = undefined, TRequirements = never>(config: EffectStreamConfig<TItem, TError, TInput, TRequirements> & {
     schemas?: undefined;
 }): EffectStreamActorLogic<TItem, TError, TInput, TRequirements>;
-export declare function fromEffectStream<TItem, TError = unknown, TInput = undefined, TRequirements = never>(stream: EffectStreamSource<TItem, TError, TInput, TRequirements>): EffectStreamActorLogic<TItem, TError, TInput, TRequirements>;
+export declare function createEffectStreamLogic<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
+ * it fails. Accepts the same forms as `createEffectStreamLogic`. Its resources close
  * when the stream completes, fails or is interrupted.
  */
-export declare function fromEffectEventStream<const TInputSchema extends EffectSchemaLike, TStream extends Stream.Stream<EventObject, any, any>>(config: Omit<EffectStreamConfig<StreamItem<TStream>, StreamError<TStream>, SchemaOutput<TInputSchema>, StreamRequirements<TStream>>, 'stream' | 'schemas' | 'validator'> & EffectSchemaValidationConfig<{
+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;
 }> & {
     stream: TStream | ((args: EffectSourceArgs<SchemaOutput<TInputSchema>>) => TStream);
 }): EffectActorLogic<undefined, StreamError<TStream>, SchemaOutput<TInputSchema>, StreamRequirements<TStream>>;
-export declare function fromEffectEventStream<TEvent extends EventObject, TError = unknown, TInput = undefined, TRequirements = never>(config: EffectStreamConfig<TEvent, TError, TInput, TRequirements> & {
+export declare function createEffectEventStreamLogic<TEvent extends EventObject, TError = unknown, TInput = undefined, TRequirements = never>(config: EffectStreamConfig<TEvent, TError, TInput, TRequirements> & {
     schemas?: undefined;
 }): EffectActorLogic<undefined, TError, TInput, TRequirements>;
-export declare function fromEffectEventStream<TEvent extends EventObject, TError = unknown, TInput = undefined, TRequirements = never>(stream: EffectStreamSource<TEvent, TError, TInput, TRequirements>): EffectActorLogic<undefined, TError, TInput, TRequirements>;
+export declare function createEffectEventStreamLogic<TEvent extends EventObject, TError = unknown, TInput = undefined, TRequirements = never>(stream: EffectStreamSource<TEvent, TError, TInput, TRequirements>): EffectActorLogic<undefined, TError, TInput, TRequirements>;
 export {};

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

@@ -1,4 +1,4 @@
-export { fromEffect, fromEffectEventStream, fromEffectStream, type EffectActorLogic, type EffectLogicBrand, type EffectSnapshot, type EffectSource, type EffectSourceArgs, type EffectStreamSource, type EffectStreamActorLogic, type EffectStreamSnapshot } from "./fromEffect.js";
+export { createEffectLogic, createEffectEventStreamLogic, createEffectStreamLogic, type EffectActorLogic, type EffectLogicBrand, type EffectSnapshot, type EffectSource, type EffectSourceArgs, type EffectStreamSource, type EffectStreamActorLogic, type EffectStreamSnapshot } from "./effectLogic.js";
 export { createEffectActor, type EffectActorOptions } from "./createEffectActor.js";
 export { EffectActor } from "./effectActor.js";
 export { ActorScope, withActorScope } from "./actorScope.js";

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

@@ -1,8 +1,8 @@
 import { Schema } from 'effect';
 import type { SetupSchemas, SetupStateSchema, SetupStateSchemas, StandardSchemaV1 } from 'xstate';
 /**
- * An Effect `Schema` accepted by this package. `setupEffect`, `fromEffect`,
- * `fromEffectStream` and `fromEffectEventStream` convert it to a Standard
+ * An Effect `Schema` accepted by this package. `setupEffect`, `createEffectLogic`,
+ * `createEffectStreamLogic` and `createEffectEventStreamLogic` convert it to a Standard
  * Schema, so XState infers the decoded `Schema.Type` without an explicit call
  * to `Schema.toStandardSchemaV1`.
  */

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

@@ -1,18 +1,19 @@
 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.
  */
-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;

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

@@ -1,5 +1,5 @@
 import type { Effect, Scope } from 'effect';
-import type { EffectLogicBrand } from "./fromEffect.js";
+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. */

package/dist/{state-b3d9b3e2.js → state-a2e5cb31.js}

@@ -146,8 +146,7 @@ class EffectActor {
   }
   toJSON() {
     return {
-      xstate$$type: 1,
-      id: this.id
+      $actor: this.address
     };
   }
 
@@ -416,7 +415,7 @@ function withActorScope(effect) {
 }
 
 const XSTATE_TIMER = 'xstate.timer';
-const XSTATE_INIT = '@xstate.init';
+const XSTATE_INIT = 'xstate.init';
 
 /** Options for {@link createEffectActor}. */
 
@@ -454,7 +453,7 @@ function createEffectActor(logic, ...[options]) {
         Queue.offerUnsafe(mailbox, item);
       }
     };
-    const timerKey = (source, id) => `${source.sessionId}:${id}`;
+    const timerKey = (source, timer) => `${source.sessionId}:${JSON.stringify(timer)}`;
     const inspectors = new Set();
     let rootAnnounced = false;
     const clock = Context.get(context, Clock.Clock);
@@ -513,14 +512,14 @@ function createEffectActor(logic, ...[options]) {
         }
         source._emit(event);
       },
-      scheduleTimer: (source, id, delay) => {
-        const key = timerKey(source, id);
+      scheduleTimer: (source, timer, delay) => {
+        const key = timerKey(source, timer);
         timers.get(key)?.interruptUnsafe();
         const fiber = Fiber.runIn(runFork(Effect.andThen(Effect.sleep(Duration.millis(delay)), Effect.sync(() => {
           timers.delete(key);
           const timerEvent = {
             type: XSTATE_TIMER,
-            id
+            ...timer
           };
           if (isRoot(source)) {
             offer(timerEvent);
@@ -530,8 +529,8 @@ function createEffectActor(logic, ...[options]) {
         }))), actorScope);
         timers.set(key, fiber);
       },
-      cancelTimer: (source, id) => {
-        const key = timerKey(source, id);
+      cancelTimer: (source, timer) => {
+        const key = timerKey(source, timer);
         timers.get(key)?.interruptUnsafe();
         timers.delete(key);
       },
@@ -716,13 +715,11 @@ class NotReadyError extends Data.TaggedError('NotReadyError') {
   }
 }
 
-/** The tag of the machine itself, used when the root state is parallel. */
-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.
  */
 
 /**
@@ -734,16 +731,16 @@ const MACHINE_TAG = '(machine)';
 /** The tagged state union of a machine. */
 
 /** Computes the dotted path tag of a state value. */
-function stateTag(value, prefix = '') {
+function stateTag(value, rootTag, prefix = '') {
   if (typeof value === 'string') {
     return prefix ? `${prefix}.${value}` : value;
   }
   const keys = Object.keys(value);
   if (keys.length !== 1) {
-    return prefix || MACHINE_TAG;
+    return prefix || rootTag;
   }
   const key = keys[0];
-  return stateTag(value[key], prefix ? `${prefix}.${key}` : key);
+  return stateTag(value[key], rootTag, prefix ? `${prefix}.${key}` : key);
 }
 
 /**
@@ -763,7 +760,7 @@ function stateTag(value, prefix = '') {
  */
 function taggedState(snapshot) {
   return {
-    _tag: stateTag(snapshot.value),
+    _tag: stateTag(snapshot.value, snapshot.machine.id),
     value: snapshot.value,
     context: snapshot.context,
     snapshot

package/dist/xstate-effect-atom.js

@@ -1,7 +1,7 @@
 import { Cause } from 'effect';
 import { Atom, AsyncResult } from 'effect/reactivity';
-import { c as createEffectActor, N as NotReadyError, t as taggedState } from './state-b3d9b3e2.js';
-export { N as NotReadyError } from './state-b3d9b3e2.js';
+import { c as createEffectActor, N as NotReadyError, t as taggedState } from './state-a2e5cb31.js';
+export { N as NotReadyError } from './state-a2e5cb31.js';
 import 'xstate';
 import 'xstate/durable';
 

package/dist/xstate-effect.js

@@ -1,13 +1,13 @@
 import { Schema, Effect, Stream, Exit, Cause, Queue } from 'effect';
-import { createLogic, setup } from 'xstate';
-import { s as startHostedEffect, r as relayToParent, E as EffectInterruptedError, A as ActorStoppedError, a as runHostedEffect } from './state-b3d9b3e2.js';
-export { d as ActorScope, A as ActorStoppedError, b as EffectActor, E as EffectInterruptedError, c as createEffectActor, t as taggedState, w as withActorScope } from './state-b3d9b3e2.js';
+import { createStepLogic, setup } from 'xstate';
+import { s as startHostedEffect, r as relayToParent, E as EffectInterruptedError, A as ActorStoppedError, a as runHostedEffect } from './state-a2e5cb31.js';
+export { d as ActorScope, A as ActorStoppedError, b as EffectActor, E as EffectInterruptedError, c as createEffectActor, t as taggedState, w as withActorScope } from './state-a2e5cb31.js';
 import { dual } from 'effect/Function';
 import 'xstate/durable';
 
 /**
- * An Effect `Schema` accepted by this package. `setupEffect`, `fromEffect`,
- * `fromEffectStream` and `fromEffectEventStream` convert it to a Standard
+ * An Effect `Schema` accepted by this package. `setupEffect`, `createEffectLogic`,
+ * `createEffectStreamLogic` and `createEffectEventStreamLogic` convert it to a Standard
  * Schema, so XState infers the decoded `Schema.Type` without an explicit call
  * to `Schema.toStandardSchemaV1`.
  */
@@ -74,7 +74,7 @@ function toStandardSetupStates(states) {
   }));
 }
 
-const EFFECT_INIT = '@xstate.init';
+const EFFECT_INIT = 'xstate.init';
 const EFFECT_RESOLVE = 'xstate.effect.resolve';
 const EFFECT_REJECT = 'xstate.effect.reject';
 const EFFECT_NEXT = 'xstate.effect.next';
@@ -82,15 +82,15 @@ const EFFECT_COMPLETE = 'xstate.effect.complete';
 const effectLogicBrand = Symbol.for('@xstate/effect/logic');
 
 /**
- * Type-level marker attached to logic created by `fromEffect`,
- * `fromEffectStream` and `fromEffectEventStream`. It carries the logic's
+ * Type-level marker attached to logic created by `createEffectLogic`,
+ * `createEffectStreamLogic` and `createEffectEventStreamLogic`. 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.
  */
 
 /**
- * Snapshot of a `fromEffect` actor. The actor holds no context of its own: it
+ * 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 Effect's failure, defect or
  * `EffectInterruptedError` as `error`.
@@ -104,26 +104,26 @@ const effectLogicBrand = Symbol.for('@xstate/effect/logic');
  */
 
 /**
- * What `fromEffect` accepts as its Effect: either an Effect value, or a
+ * 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.
  */
 
 /**
- * Actor logic produced by `fromEffect` and `fromEffectEventStream`. It is
+ * Actor logic produced by `createEffectLogic` and `createEffectEventStreamLogic`. It is
  * ordinary XState actor logic carrying {@link EffectLogicBrand}, so a machine
  * can invoke or spawn it, and `createEffectActor` can collect its
  * requirements.
  */
 
 /**
- * Snapshot of a `fromEffectStream` actor. `context` holds the most recent
+ * 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.
  */
 
 /**
- * Actor logic produced by `fromEffectStream`. Its snapshot is an
+ * 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.
  */
@@ -174,7 +174,7 @@ function brandLogic(logic, error, requirements) {
  * Effect actor stops.
  */
 
-function fromEffect(sourceOrConfig) {
+function createEffectLogic(sourceOrConfig) {
   const config = typeof sourceOrConfig === 'function' || Effect.isEffect(sourceOrConfig) ? {
     effect: sourceOrConfig
   } : sourceOrConfig;
@@ -187,7 +187,7 @@ function fromEffect(sourceOrConfig) {
       output: toStandardSchema(config.schemas.output)
     } : {})
   } : undefined;
-  const logic = createLogic({
+  const logic = createStepLogic({
     id: config.id,
     validator: config.validator,
     schemas,
@@ -216,7 +216,7 @@ function fromEffect(sourceOrConfig) {
         return;
       }
       const effect = typeof source === 'function' ? source(createSourceArgs(input, self, system)) : source;
-      enq.effect(() => startHostedEffect(self, Effect.scoped(effect), 'fromEffect', exit => {
+      enq.effect(() => startHostedEffect(self, Effect.scoped(effect), 'createEffectLogic', exit => {
         if (self.getSnapshot().status !== 'active') {
           return;
         }
@@ -238,7 +238,7 @@ function fromEffect(sourceOrConfig) {
 }
 
 /**
- * What `fromEffectStream` and `fromEffectEventStream` accept as their stream:
+ * 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.
  */
@@ -263,10 +263,10 @@ function toLogicSchemas(schemas) {
  * completes, fails or is interrupted.
  */
 
-function fromEffectStream(sourceOrConfig) {
+function createEffectStreamLogic(sourceOrConfig) {
   const config = resolveStreamConfig(sourceOrConfig);
   const stream = config.stream;
-  const logic = createLogic({
+  const logic = createStepLogic({
     id: config.id,
     validator: config.validator,
     schemas: toLogicSchemas(config.schemas),
@@ -307,7 +307,7 @@ function fromEffectStream(sourceOrConfig) {
           });
         }
       }));
-      enq.effect(() => startHostedEffect(self, Effect.scoped(consume), 'fromEffectStream', exit => {
+      enq.effect(() => startHostedEffect(self, Effect.scoped(consume), 'createEffectStreamLogic', exit => {
         if (self.getSnapshot().status !== 'active') {
           return;
         }
@@ -331,14 +331,14 @@ function fromEffectStream(sourceOrConfig) {
  * 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
+ * it fails. Accepts the same forms as `createEffectStreamLogic`. Its resources close
  * when the stream completes, fails or is interrupted.
  */
 
-function fromEffectEventStream(sourceOrConfig) {
+function createEffectEventStreamLogic(sourceOrConfig) {
   const config = resolveStreamConfig(sourceOrConfig);
   const stream = config.stream;
-  const logic = createLogic({
+  const logic = createStepLogic({
     id: config.id,
     validator: config.validator,
     schemas: toLogicSchemas(config.schemas),
@@ -367,7 +367,7 @@ function fromEffectEventStream(sourceOrConfig) {
       }
       const streamValue = typeof stream === 'function' ? stream(createSourceArgs(input, self, system)) : stream;
       const consume = Stream.runForEach(streamValue, value => Effect.sync(() => relayToParent(self, value)));
-      enq.effect(() => startHostedEffect(self, Effect.scoped(consume), 'fromEffectEventStream', exit => {
+      enq.effect(() => startHostedEffect(self, Effect.scoped(consume), 'createEffectEventStreamLogic', exit => {
         if (self.getSnapshot().status !== 'active') {
           return;
         }
@@ -710,4 +710,4 @@ function setupEffect(config = {}) {
   }));
 }
 
-export { deadLetters, emitted, fromEffect, fromEffectEventStream, fromEffectStream, inspect, join, send, setupEffect, snapshots, waitFor };
+export { createEffectEventStreamLogic, createEffectLogic, createEffectStreamLogic, deadLetters, emitted, inspect, join, send, setupEffect, snapshots, waitFor };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xstate/effect",
-  "version": "0.1.0-alpha.7",
+  "version": "1.0.0-alpha.9",
   "type": "module",
   "description": "Effect integration for XState",
   "keywords": [
@@ -30,12 +30,12 @@
   },
   "peerDependencies": {
     "effect": "^4.0.0",
-    "xstate": "^6.0.0-alpha.65"
+    "xstate": "^6.0.0-alpha.70"
   },
   "devDependencies": {
     "effect": "4.0.0",
     "fast-check": "4.10.2",
-    "xstate": "^6.0.0-alpha.65"
+    "xstate": "^6.0.0-alpha.70"
   },
   "preconstruct": {
     "entrypoints": [