@xstate/effect 0.1.0-alpha.6 → 1.0.0-alpha.8

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.
@@ -256,10 +262,10 @@ See [atoms and React](docs/atoms-and-react.md) for complete examples with import
 - Timed waits fail with Effect's `Cause.TimeoutError`.
 - `join` preserves a task's typed failure. Unexpected machine errors have type `unknown`.
 
-See [testing and errors](docs/testing-and-errors.md) for executable deadline, retry and failure examples. Persisted snapshots record actor state; restoration into a new Effect interpreter is not supported yet.
+See [testing and errors](docs/testing-and-errors.md) for executable deadline, retry and failure examples. Persisted snapshots record actor state; pass one to `createEffectActor(logic, { snapshot })` to resume the actor. See [persisting and restoring](docs/actors.md#persisting-and-restoring).
 
 ## 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/createEffectActor.d.ts

@@ -1,14 +1,24 @@
 import { Effect, Scope } from 'effect';
-import { type AnyActorLogic, type InputFrom } from 'xstate';
+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}. */
-export type EffectActorOptions<TLogic extends AnyActorLogic> = undefined extends InputFrom<TLogic> ? {
+export type EffectActorOptions<TLogic extends AnyActorLogic> = {
     readonly input?: InputFrom<TLogic>;
-} : {
-    readonly input: InputFrom<TLogic>;
-};
-export type EffectActorOptionsArgs<TLogic extends AnyActorLogic> = undefined extends InputFrom<TLogic> ? [options?: EffectActorOptions<TLogic>] : [options: EffectActorOptions<TLogic>];
+    /**
+     * A snapshot from `actor.getPersistedSnapshot()`. The actor resumes in that
+     * state without re-running entry actions, and pending timers keep their
+     * original deadlines, as with XState's `createActor(logic, { snapshot })`.
+     * State-machine children resume their persisted state and completed
+     * children stay done. Effect tasks and streams that were running, at the
+     * root or as children, start again from the beginning. A restored actor
+     * does not need `input`.
+     */
+    readonly snapshot?: ActorOptions<TLogic>['snapshot'];
+} & RequiredActorOptionsFor<TLogic>;
+export type EffectActorOptionsArgs<TLogic extends AnyActorLogic> = [
+    RequiredActorOptionsKeys<TLogic>
+] extends [never] ? [options?: EffectActorOptions<TLogic>] : [options: EffectActorOptions<TLogic>];
 /**
  * Creates and starts an actor as an Effect interpreter over pure transitions.
  *

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/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-14a1fecf.js → state-ea62b88e.js}

@@ -1,5 +1,5 @@
-import { Queue, Effect, Fiber, Scope, Exit, Cause, Context, Duration, Data } from 'effect';
-import { stopActor, terminateActor, deliverEvent } from 'xstate';
+import { Queue, Effect, Fiber, Scope, Exit, Cause, Context, Clock, Duration, Data } from 'effect';
+import { stopActor, terminateActor, deliverEvent, isMachineSnapshot } from 'xstate';
 import { createDurable } from 'xstate/durable';
 
 /** A mailbox item that reports a failed fire-and-forget action. */
@@ -146,8 +146,7 @@ class EffectActor {
   }
   toJSON() {
     return {
-      xstate$$type: 1,
-      id: this.id
+      $actor: this.address
     };
   }
 
@@ -416,6 +415,7 @@ function withActorScope(effect) {
 }
 
 const XSTATE_TIMER = 'xstate.timer';
+const XSTATE_INIT = 'xstate.init';
 
 /** Options for {@link createEffectActor}. */
 
@@ -453,10 +453,14 @@ 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);
     const durable = createDurable(logic, {
+      // Timer deadlines are measured on the same clock the timers sleep
+      // on, so a restored timer resumes with its remaining delay.
+      now: () => clock.currentTimeMillisUnsafe(),
       executeAction: (action, _metadata, runtime) => {
         // Fire-and-forget: the action starts now and the loop continues.
         // A rejection reaches the machine as an execution error.
@@ -508,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);
@@ -525,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);
       },
@@ -590,10 +594,29 @@ function createEffectActor(logic, ...[options]) {
       closeEffectHost(host);
     };
 
-    // The first transition runs here so the handle is ready when this
-    // Effect succeeds, and the initial actions start before any send.
-    let [snapshot, effects] = durable.initialTransition(options?.input);
+    // The first transition (or the restore) runs here so the handle is
+    // ready when this Effect succeeds, and the initial actions start before
+    // any send. Restoring runs no entry actions; its effects resume
+    // machine children, restart running Effect children and re-arm pending
+    // timers.
+    let [snapshot, effects] = options?.snapshot ? durable.restore(options.snapshot) : durable.initialTransition(options?.input);
+    const initial = snapshot;
+    if (options?.snapshot && !isMachineSnapshot(initial) && initial.status === 'active') {
+      // A restored machine resumes through the effects above. Other logic
+      // (an Effect task or stream at the root) reattaches its active work by
+      // replaying its init event, as its restored `start` does under
+      // `createActor`.
+      const [started, startEffects] = durable.transition(snapshot, {
+        type: XSTATE_INIT,
+        input: 'input' in initial ? initial.input : undefined
+      });
+      snapshot = started;
+      effects = [...effects, ...startEffects];
+    }
     const root = durable.getActorRef(snapshot);
+    // Restored children are created by the snapshot, not spawned through
+    // the adapter; they find this host through their parent chain.
+    bindEffectHost(root, host);
     // The root exists from here on; later announcements are step
     // re-materializations, not new actors.
     rootAnnounced = true;

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-14a1fecf.js';
-export { N as NotReadyError } from './state-14a1fecf.js';
+import { c as createEffectActor, N as NotReadyError, t as taggedState } from './state-ea62b88e.js';
+export { N as NotReadyError } from './state-ea62b88e.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-14a1fecf.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-14a1fecf.js';
+import { createStepLogic, setup } from 'xstate';
+import { s as startHostedEffect, r as relayToParent, E as EffectInterruptedError, A as ActorStoppedError, a as runHostedEffect } from './state-ea62b88e.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-ea62b88e.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.6",
+  "version": "1.0.0-alpha.8",
   "type": "module",
   "description": "Effect integration for XState",
   "keywords": [
@@ -30,11 +30,12 @@
   },
   "peerDependencies": {
     "effect": "^4.0.0",
-    "xstate": "^6.0.0-alpha.63"
+    "xstate": "^6.0.0-alpha.68"
   },
   "devDependencies": {
     "effect": "4.0.0",
-    "xstate": "^6.0.0-alpha.63"
+    "fast-check": "4.10.2",
+    "xstate": "^6.0.0-alpha.68"
   },
   "preconstruct": {
     "entrypoints": [