@xstate/effect 0.1.0-alpha.5 → 0.1.0-alpha.7

package/README.md

@@ -7,14 +7,14 @@ Combine XState's event-driven workflows with Effect services, scopes, clocks and
 - Provide services once for the actor and its child logic.
 - Keep actor lifetime inside your Effect application.
 
-This package is experimental. It targets XState v6 alpha and Effect 4 RC.
+This package is experimental. It targets XState v6 alpha and Effect 4.
 
 ## Installation
 
 <!-- package name and peer dependencies from package.json -->
 
 ```bash
-npm install @xstate/effect@alpha xstate@alpha effect@rc
+npm install @xstate/effect@alpha xstate@alpha effect@^4
 ```
 
 ## XState Effect: Quick start
@@ -256,7 +256,7 @@ 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
 

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

@@ -1,4 +1,4 @@
-import { AsyncResult, Atom } from 'effect/unstable/reactivity';
+import { AsyncResult, Atom } from 'effect/reactivity';
 import type { AnyActorLogic, ErrorFrom, EventFromLogic, SnapshotFrom } from 'xstate';
 import { type EffectActorOptionsArgs } from "./createEffectActor.js";
 import type { EffectActor } from "./effectActor.js";
@@ -8,7 +8,7 @@ import type { RequirementsFrom } from "./types.js";
 export { NotReadyError } from "./errors.js";
 /**
  * Atoms that expose one actor to a reactive UI through
- * `effect/unstable/reactivity`. Read them with the atom bindings for your
+ * `effect/reactivity`. Read them with the atom bindings for your
  * framework, such as `@effect/atom-react`.
  */
 export interface ActorAtoms<TLogic extends AnyActorLogic, ER = never> {

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/{state-14a1fecf.js → state-b3d9b3e2.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. */
@@ -416,6 +416,7 @@ function withActorScope(effect) {
 }
 
 const XSTATE_TIMER = 'xstate.timer';
+const XSTATE_INIT = '@xstate.init';
 
 /** Options for {@link createEffectActor}. */
 
@@ -456,7 +457,11 @@ function createEffectActor(logic, ...[options]) {
     const timerKey = (source, id) => `${source.sessionId}:${id}`;
     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.
@@ -590,10 +595,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,13 +1,13 @@
 import { Cause } from 'effect';
-import { Atom, AsyncResult } from 'effect/unstable/reactivity';
-import { c as createEffectActor, N as NotReadyError, t as taggedState } from './state-14a1fecf.js';
-export { N as NotReadyError } from './state-14a1fecf.js';
+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 'xstate';
 import 'xstate/durable';
 
 /**
  * Atoms that expose one actor to a reactive UI through
- * `effect/unstable/reactivity`. Read them with the atom bindings for your
+ * `effect/reactivity`. Read them with the atom bindings for your
  * framework, such as `@effect/atom-react`.
  */
 

package/dist/xstate-effect.js

@@ -1,7 +1,7 @@
 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 { 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 { dual } from 'effect/Function';
 import 'xstate/durable';
 
@@ -658,6 +658,7 @@ function wrapActions(actions) {
   for (const key of Object.keys(actions)) {
     const action = actions[key];
     wrapped[key] = args => {
+      // machine.provide can replace Effect actions with plain actions.
       const result = action(args);
       return Effect.isEffect(result) ? runHostedEffect(args.self, result, `action.${key}`) : result;
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xstate/effect",
-  "version": "0.1.0-alpha.5",
+  "version": "0.1.0-alpha.7",
   "type": "module",
   "description": "Effect integration for XState",
   "keywords": [
@@ -29,12 +29,13 @@
     "url": "https://github.com/statelyai/xstate/issues"
   },
   "peerDependencies": {
-    "effect": "^4.0.0-rc.115",
-    "xstate": "^6.0.0-alpha.62"
+    "effect": "^4.0.0",
+    "xstate": "^6.0.0-alpha.65"
   },
   "devDependencies": {
-    "effect": "4.0.0-rc.115",
-    "xstate": "^6.0.0-alpha.62"
+    "effect": "4.0.0",
+    "fast-check": "4.10.2",
+    "xstate": "^6.0.0-alpha.65"
   },
   "preconstruct": {
     "entrypoints": [