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

package/dist/xstate-effect.js

@@ -1,7 +1,7 @@
-import { Schema, Effect, Stream, Exit, Cause, Queue } from 'effect';
+import { Schema, Effect, Stream, Cause, Exit, Queue, Data } from 'effect';
 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 { s as startHostedEffect, r as relayToParent, E as EffectFailure, A as ActorStoppedError, a as causeFromError, b as runHostedEffect } from './state-a2154dce.js';
+export { e as ActorScope, A as ActorStoppedError, d as EffectActor, E as EffectFailure, g as EffectInterruptedError, f as EventRejectedError, c as createEffectActor, t as taggedState, w as withActorScope } from './state-a2154dce.js';
 import { dual } from 'effect/Function';
 import 'xstate/durable';
 
@@ -10,12 +10,16 @@ import 'xstate/durable';
  * `createEffectStreamLogic` and `createEffectEventStreamLogic` convert it to a Standard
  * Schema, so XState infers the decoded `Schema.Type` without an explicit call
  * to `Schema.toStandardSchemaV1`.
+ *
+ * @experimental
  */
 
 /**
  * Either an Effect {@link EffectSchema} or a Standard Schema. Every schema
  * position in this package accepts both, so Effect schemas and schemas from
  * other libraries can be mixed in one machine.
+ *
+ * @experimental
  */
 
 /**
@@ -23,15 +27,23 @@ import 'xstate/durable';
  * schema position widened to {@link EffectSchemaLike}. Covers `context`,
  * `input`, `output` and the per-key records for `events`, `internalEvents`,
  * `emitted` and `children`.
+ *
+ * @experimental
  */
 
+/** @experimental */
+
 /**
  * One node of the `states` option of `setupEffect`: the schemas declared for
  * that state, and the same shape recursively for its child states. It is
  * XState's `SetupStateSchema` with Effect schemas allowed in every schema
  * position.
+ *
+ * @experimental
  */
 
+/** @experimental */
+
 function isStandardSchema(value) {
   return !!value && (typeof value === 'object' || typeof value === 'function') && '~standard' in value;
 }
@@ -87,13 +99,16 @@ const effectLogicBrand = Symbol.for('@xstate/effect/logic');
  * failure type and its Effect service requirements, which is how
  * `RequirementsFrom` collects the `R` channel of `createEffectActor` without
  * inspecting the logic at runtime.
+ *
+ * @experimental
  */
 
 /**
  * Snapshot of a `createEffectLogic` actor. The actor holds no context of its own: it
  * is `active` while the Effect runs, `done` with the Effect's success value as
- * `output`, or `error` with the Effect's failure, defect or
- * `EffectInterruptedError` as `error`.
+ * `output`, or `error` with the original `Cause` wrapped in `EffectFailure` as `error`.
+ *
+ * @experimental
  */
 
 /**
@@ -101,12 +116,16 @@ const effectLogicBrand = Symbol.for('@xstate/effect/logic');
  * source the actor's `input`, its own reference (`self`), the actor `system`,
  * and `emit` for publishing events that `actor.on(...)` and `emitted(actor)`
  * observe.
+ *
+ * @experimental
  */
 
 /**
  * What `createEffectLogic` accepts as its Effect: either an Effect value, or a
  * function of {@link EffectSourceArgs} returning one. The function form is
  * called once per actor start, so it sees that actor's input.
+ *
+ * @experimental
  */
 
 /**
@@ -114,30 +133,28 @@ const effectLogicBrand = Symbol.for('@xstate/effect/logic');
  * ordinary XState actor logic carrying {@link EffectLogicBrand}, so a machine
  * can invoke or spawn it, and `createEffectActor` can collect its
  * requirements.
+ *
+ * @experimental
  */
 
 /**
  * Snapshot of a `createEffectStreamLogic` actor. `context` holds the most recent
  * stream item, or `undefined` before the first one. The actor reaches `done`
  * with no output when the stream completes, and `error` when it fails.
+ *
+ * @experimental
  */
 
 /**
  * Actor logic produced by `createEffectStreamLogic`. Its snapshot is an
  * {@link EffectStreamSnapshot}, so the parent reads the latest item from the
  * child's `context` rather than from events.
+ *
+ * @experimental
  */
 
-function toError(exit) {
-  if (Exit.isSuccess(exit)) {
-    return undefined;
-  }
-  if (Cause.hasInterruptsOnly(exit.cause)) {
-    return new EffectInterruptedError({
-      cause: exit.cause
-    });
-  }
-  return Cause.squash(exit.cause);
+function preserveFailure(error) {
+  return EffectFailure.is(error) ? error : new EffectFailure(Cause.die(error));
 }
 function createSourceArgs(input, self, system) {
   return {
@@ -150,6 +167,32 @@ function createSourceArgs(input, self, system) {
   };
 }
 function brandLogic(logic, error, requirements) {
+  const transition = logic.transition.bind(logic);
+  logic.transition = (snapshot, event, scope) => {
+    try {
+      return transition(snapshot, event, scope);
+    } catch (error) {
+      throw preserveFailure(error);
+    }
+  };
+  const initialTransition = logic.initialTransition.bind(logic);
+  logic.initialTransition = (input, scope) => {
+    try {
+      return initialTransition(input, scope);
+    } catch (error) {
+      throw preserveFailure(error);
+    }
+  };
+  const restoreSnapshot = logic.restoreSnapshot?.bind(logic);
+  if (restoreSnapshot) {
+    logic.restoreSnapshot = (persisted, scope) => {
+      const snapshot = restoreSnapshot(persisted, scope);
+      if (snapshot.status === 'error' && !EffectFailure.is(snapshot.error)) {
+        throw new Error('Cannot restore a serialized Effect failure. Recover the error before persisting the actor.');
+      }
+      return snapshot;
+    };
+  }
   Object.defineProperty(logic, effectLogicBrand, {
     configurable: false,
     enumerable: false,
@@ -163,15 +206,15 @@ function brandLogic(logic, error, requirements) {
 
 /**
  * Creates actor logic that runs an Effect. The actor completes with the
- * Effect's success value as its output and fails with the Effect's error, its
- * squashed defect, or an `EffectInterruptedError` when the Effect interrupts
- * itself. Stopping the actor interrupts the Effect without an error. Accepts
+ * Effect's success value as its output and fails with the original `Cause` wrapped in `EffectFailure`. Stopping the actor interrupts the Effect without an error. Accepts
  * an Effect, a function of {@link EffectSourceArgs} returning one, or a config
  * object with `id`, `schemas`, `validator` and `effect`. The logic must be run
  * under `createEffectActor`, which provides the Effect services it declares.
  * Resources belong to this task's scope and close on completion, failure or
  * interruption. Use `withActorScope` to retain a resource until the owning
  * Effect actor stops.
+ *
+ * @experimental
  */
 
 function createEffectLogic(sourceOrConfig) {
@@ -208,14 +251,14 @@ function createEffectLogic(sourceOrConfig) {
       if (event.type === EFFECT_REJECT) {
         return {
           status: 'error',
-          error: event.error,
+          error: preserveFailure(event.error),
           input: undefined
         };
       }
       if (event.type !== EFFECT_INIT) {
         return;
       }
-      const effect = typeof source === 'function' ? source(createSourceArgs(input, self, system)) : source;
+      const effect = Effect.suspend(() => typeof source === 'function' ? source(createSourceArgs(input, self, system)) : source);
       enq.effect(() => startHostedEffect(self, Effect.scoped(effect), 'createEffectLogic', exit => {
         if (self.getSnapshot().status !== 'active') {
           return;
@@ -228,7 +271,7 @@ function createEffectLogic(sourceOrConfig) {
         } else {
           self.send({
             type: EFFECT_REJECT,
-            error: toError(exit)
+            error: new EffectFailure(exit.cause)
           });
         }
       }));
@@ -241,6 +284,8 @@ function createEffectLogic(sourceOrConfig) {
  * What `createEffectStreamLogic` and `createEffectEventStreamLogic` accept as their stream:
  * either a Stream value, or a function of {@link EffectSourceArgs} returning
  * one. The function form is called once per actor start.
+ *
+ * @experimental
  */
 
 function resolveStreamConfig(sourceOrConfig) {
@@ -261,6 +306,8 @@ function toLogicSchemas(schemas) {
  * {@link EffectSourceArgs} returning one, or a config object with `id`,
  * `schemas`, `validator` and `stream`. Its resources close when the stream
  * completes, fails or is interrupted.
+ *
+ * @experimental
  */
 
 function createEffectStreamLogic(sourceOrConfig) {
@@ -291,14 +338,14 @@ function createEffectStreamLogic(sourceOrConfig) {
       if (event.type === EFFECT_REJECT) {
         return {
           status: 'error',
-          error: event.error,
+          error: preserveFailure(event.error),
           input: undefined
         };
       }
       if (event.type !== EFFECT_INIT) {
         return;
       }
-      const streamValue = typeof stream === 'function' ? stream(createSourceArgs(input, self, system)) : stream;
+      const streamValue = Stream.suspend(() => typeof stream === 'function' ? stream(createSourceArgs(input, self, system)) : stream);
       const consume = Stream.runForEach(streamValue, value => Effect.sync(() => {
         if (self.getSnapshot().status === 'active') {
           self.send({
@@ -318,7 +365,7 @@ function createEffectStreamLogic(sourceOrConfig) {
         } else {
           self.send({
             type: EFFECT_REJECT,
-            error: toError(exit)
+            error: new EffectFailure(exit.cause)
           });
         }
       }));
@@ -333,6 +380,8 @@ function createEffectStreamLogic(sourceOrConfig) {
  * has no output: it reaches `done` when the stream completes and `error` when
  * it fails. Accepts the same forms as `createEffectStreamLogic`. Its resources close
  * when the stream completes, fails or is interrupted.
+ *
+ * @experimental
  */
 
 function createEffectEventStreamLogic(sourceOrConfig) {
@@ -358,14 +407,14 @@ function createEffectEventStreamLogic(sourceOrConfig) {
       if (event.type === EFFECT_REJECT) {
         return {
           status: 'error',
-          error: event.error,
+          error: preserveFailure(event.error),
           input: undefined
         };
       }
       if (event.type !== EFFECT_INIT) {
         return;
       }
-      const streamValue = typeof stream === 'function' ? stream(createSourceArgs(input, self, system)) : stream;
+      const streamValue = Stream.suspend(() => 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), 'createEffectEventStreamLogic', exit => {
         if (self.getSnapshot().status !== 'active') {
@@ -378,7 +427,7 @@ function createEffectEventStreamLogic(sourceOrConfig) {
         } else {
           self.send({
             type: EFFECT_REJECT,
-            error: toError(exit)
+            error: new EffectFailure(exit.cause)
           });
         }
       }));
@@ -387,11 +436,23 @@ function createEffectEventStreamLogic(sourceOrConfig) {
   return brandLogic(logic, undefined, undefined);
 }
 
-/** The event type accepted by an actor's `send` method. */
+/**
+ * The event type accepted by an actor's `send` method.
+ *
+ * @experimental
+ */
 
-/** The event type an actor emits through `actor.on(...)`. */
+/**
+ * The event type an actor emits through `actor.on(...)`.
+ *
+ * @experimental
+ */
 
-/** Options for {@link waitFor}. */
+/**
+ * Options for {@link waitFor}.
+ *
+ * @experimental
+ */
 
 const noopSubscription = {
   unsubscribe: () => {}
@@ -424,6 +485,8 @@ function isActorRef(value) {
  * is enqueued, like `actor.send(event)`, and processed on the actor's own
  * fiber. An event that cannot be delivered (for example to a stopped actor)
  * is reported as a dead letter, observable with {@link deadLetters}.
+ *
+ * @experimental
  */
 const send = dual(2, (actor, event) => Effect.sync(() => {
   actor.send(event);
@@ -434,6 +497,8 @@ const send = dual(2, (actor, event) => Effect.sync(() => {
  * when the actor completes or stops, and emits the error snapshot before
  * ending when the actor errors. Interrupting the stream unsubscribes from the
  * actor.
+ *
+ * @experimental
  */
 function snapshots(actor) {
   return Stream.callback(queue => Effect.acquireRelease(Effect.sync(() => {
@@ -465,6 +530,8 @@ function snapshots(actor) {
  * Streams every event an actor emits, as delivered to `actor.on('*', …)`. The
  * stream ends when the actor completes, errors or stops. Interrupting the
  * stream removes the listener.
+ *
+ * @experimental
  */
 function emitted(actor) {
   return Stream.callback(queue => Effect.acquireRelease(Effect.sync(() => {
@@ -496,6 +563,8 @@ function emitted(actor) {
  * `ActorStoppedError` if the actor stops or errors first, and with
  * `Cause.TimeoutError` when `options.timeout` elapses. Interrupting the Effect
  * unsubscribes from the actor.
+ *
+ * @experimental
  */
 const waitFor = dual(args => isActorRef(args[0]), (actor, predicate, options) => {
   const waiting = Effect.callback(resume => {
@@ -549,9 +618,11 @@ const waitFor = dual(args => isActorRef(args[0]), (actor, predicate, options) =>
 
 /**
  * Joins an actor's final result, like `Fiber.join`: succeeds with its `output`
- * when it is done, fails with `snapshot.error` when it errors, and fails with
+ * when it is done, replays an Effect actor's original Cause when it errors, and fails with
  * `ActorStoppedError` when it stops without output. Waits for a still-active
- * actor to settle.
+ * actor to settle. Ordinary XState errors remain typed failures.
+ *
+ * @experimental
  */
 function join(actor) {
   return Effect.callback(resume => {
@@ -560,7 +631,7 @@ function join(actor) {
       if (snapshot.status === 'done') {
         resume(Effect.succeed(snapshot.output));
       } else if (snapshot.status === 'error') {
-        resume(Effect.fail(snapshot.error));
+        resume(Effect.failCause(causeFromError(snapshot.error)));
       } else {
         resume(Effect.fail(stoppedError(actor)));
       }
@@ -599,6 +670,8 @@ function join(actor) {
  * Streams the inspection events of the actor's system, as delivered to
  * `system.inspect(…)`. The stream runs until it is interrupted or its scope
  * closes.
+ *
+ * @experimental
  */
 function inspect(actor) {
   return Stream.callback(queue => Effect.acquireRelease(Effect.sync(() => {
@@ -618,6 +691,8 @@ function inspect(actor) {
  * events and internal events sent from outside their owner. A dead letter is
  * not an actor error. The stream runs until it is interrupted or its scope
  * closes.
+ *
+ * @experimental
  */
 function deadLetters(actor) {
   return Stream.callback(queue => Effect.acquireRelease(Effect.sync(() => actor.system.onRejectedEvent(rejection => {
@@ -633,6 +708,8 @@ function deadLetters(actor) {
  * the actor itself and its family (`self`, `parent`, `children`), the
  * registered `actions`, `actors`, `guards` and `delays`, the actor `system`,
  * and the `params` and `output` the transition passed along.
+ *
+ * @experimental
  */
 
 /**
@@ -641,6 +718,8 @@ function deadLetters(actor) {
  * enqueued, and returns an Effect that runs afterwards in the actor's Effect
  * context. The Effect is interrupted when the actor stops; its failures and
  * defects route to the state's `onError`.
+ *
+ * @experimental
  */
 
 /**
@@ -648,6 +727,8 @@ function deadLetters(actor) {
  * that also accepts Effect schemas and Effect-returning actions. Call
  * `createMachine` on it to build a machine whose registered actions and actors
  * contribute to `RequirementsFrom`.
+ *
+ * @experimental
  */
 
 function wrapActions(actions) {
@@ -659,7 +740,12 @@ function wrapActions(actions) {
     const action = actions[key];
     wrapped[key] = args => {
       // machine.provide can replace Effect actions with plain actions.
-      const result = action(args);
+      let result;
+      try {
+        result = action(args);
+      } catch (error) {
+        result = Effect.die(error);
+      }
       return Effect.isEffect(result) ? runHostedEffect(args.self, result, `action.${key}`) : result;
     };
   }
@@ -699,6 +785,8 @@ function decorateEffectSetup(effectSetup) {
  * runs in the actor's Effect context. Everything else, including `actors`,
  * `guards`, `delays` and `extend`, behaves as in `setup`. Machines built from
  * it must be started with `createEffectActor`.
+ *
+ * @experimental
  */
 
 function setupEffect(config = {}) {
@@ -710,4 +798,167 @@ function setupEffect(config = {}) {
   }));
 }
 
-export { createEffectEventStreamLogic, createEffectLogic, createEffectStreamLogic, deadLetters, emitted, inspect, join, send, setupEffect, snapshots, waitFor };
+/**
+ * A malformed transport, unsupported JSON value or missing persistence metadata.
+ *
+ * @experimental
+ */
+class SnapshotCodecError extends Data.TaggedError('SnapshotCodecError') {
+  get message() {
+    return `${this.stage} at ${this.path}: ${this.reason}`;
+  }
+}
+function record(value) {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function invalid(stage, path, reason) {
+  throw new SnapshotCodecError({
+    stage,
+    path,
+    reason
+  });
+}
+function checkJson(value, stage, path = '$', ancestors = new Set()) {
+  if (value === null || typeof value === 'string' || typeof value === 'boolean') return;
+  if (typeof value === 'number' && Number.isFinite(value) && !Object.is(value, -0)) return;
+  if (typeof value !== 'object') invalid(stage, path, 'Expected lossless JSON; encode this value with a schema');
+  if (ancestors.has(value)) invalid(stage, path, 'Cyclic value');
+  if (Array.isArray(value) && Object.getPrototypeOf(value) !== Array.prototype) invalid(stage, path, 'Unsupported array prototype');
+  if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) {
+    invalid(stage, path, 'Unsupported object prototype; supply a reversible schema');
+  }
+  if (Object.getOwnPropertySymbols(value).length) invalid(stage, path, 'Symbol properties are not JSON');
+  ancestors.add(value);
+  if (Array.isArray(value)) {
+    if (Object.keys(value).length !== value.length) invalid(stage, path, 'Array holes or extra properties are not JSON');
+    for (let index = 0; index < value.length; index++) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+      if (!descriptor?.enumerable || !('value' in descriptor)) invalid(stage, `${path}[${index}]`, 'Array accessor or hole is not JSON');
+      checkJson(descriptor.value, stage, `${path}[${index}]`, ancestors);
+    }
+    if (Object.getOwnPropertyNames(value).length !== value.length + 1) invalid(stage, path, 'Extra array properties are not JSON');
+  } else {
+    for (const key of Object.getOwnPropertyNames(value)) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (!descriptor.enumerable || !('value' in descriptor)) invalid(stage, `${path}.${key}`, 'Non-enumerable or accessor property is not JSON');
+      checkJson(descriptor.value, stage, `${path}.${key}`, ancestors);
+    }
+  }
+  ancestors.delete(value);
+}
+function checkSnapshot(value, stage, path = '$.snapshot', machineId) {
+  if (!record(value)) invalid(stage, path, 'Expected a persisted snapshot');
+  if (!['active', 'done', 'stopped', 'error'].includes(String(value.status))) invalid(stage, path, 'Invalid snapshot status');
+  if (value.status === 'error') invalid(stage, path, 'Errored snapshots require an explicit error recovery policy before persistence');
+  if (machineId !== undefined || 'machine' in value) {
+    if (!record(value.machine) || typeof value.machine.id !== 'string' || typeof value.machine.version !== 'string' || !value.machine.version) invalid(stage, `${path}.machine`, 'Expected a versioned machine identity');
+    if (machineId !== undefined && value.machine.id !== machineId) invalid(stage, `${path}.machine.id`, 'Machine identity mismatch');
+  }
+  if ('value' in value || 'machine' in value) {
+    for (const key of ['context', 'value', 'children', 'historyValue', 'timers']) {
+      if (!(key in value)) invalid(stage, `${path}.${key}`, 'Missing machine persistence metadata');
+    }
+    if (!record(value.children) || !record(value.historyValue) || !Array.isArray(value.timers)) invalid(stage, path, 'Invalid machine persistence metadata');
+  }
+  if (record(value.children)) {
+    for (const [id, child] of Object.entries(value.children)) {
+      if (!record(child) || child.src !== undefined && typeof child.src !== 'string') invalid(stage, `${path}.children.${id}`, 'Invalid persisted child');
+      if (child.remote === true) {
+        if (child.snapshot !== undefined) invalid(stage, `${path}.children.${id}`, 'Remote children cannot contain snapshots');
+        continue;
+      }
+      checkSnapshot(child.snapshot, stage, `${path}.children.${id}.snapshot`);
+    }
+  }
+}
+function sameData(left, right) {
+  if (Object.is(left, right)) return true;
+  if (Array.isArray(left) && Array.isArray(right)) return left.length === right.length && left.every((item, index) => sameData(item, right[index]));
+  if (record(left) && record(right)) {
+    const keys = Object.keys(left);
+    return keys.length === Object.keys(right).length && keys.every(key => Object.hasOwn(right, key) && sameData(left[key], right[key]));
+  }
+  return false;
+}
+function checkMetadata(before, after, stage, path = '$.snapshot') {
+  for (const [key, value] of Object.entries(before)) {
+    if (['context', 'input', 'output', 'error', 'stateInputs'].includes(key) || value === undefined) continue;
+    if (key === 'children' && record(value) && record(after.children)) {
+      if (!sameData(Object.keys(value).sort(), Object.keys(after.children).sort())) invalid(stage, `${path}.children`, 'Schema changed persisted children');
+      for (const [id, child] of Object.entries(value)) {
+        const next = after.children[id];
+        if (!record(child) || !record(next)) invalid(stage, `${path}.children.${id}`, 'Schema changed child metadata');
+        for (const childKey of Object.keys(child)) {
+          if (childKey !== 'snapshot' && child[childKey] !== undefined && !sameData(child[childKey], next[childKey])) invalid(stage, `${path}.children.${id}.${childKey}`, 'Schema changed child metadata');
+        }
+        if (record(child.snapshot) && record(next.snapshot)) checkMetadata(child.snapshot, next.snapshot, stage, `${path}.children.${id}.snapshot`);
+      }
+    } else if (!sameData(value, after[key])) {
+      invalid(stage, `${path}.${key}`, 'Schema changed machine persistence metadata');
+    }
+  }
+  if (before.input !== undefined && !('input' in after)) invalid(stage, `${path}.input`, 'Schema removed input');
+  if (before.output !== undefined && !('output' in after)) invalid(stage, `${path}.output`, 'Schema removed output');
+  if (record(before.stateInputs) && (!record(after.stateInputs) || !sameData(Object.keys(before.stateInputs).sort(), Object.keys(after.stateInputs).sort()))) invalid(stage, `${path}.stateInputs`, 'Schema changed state input owners');
+  if ('stateInputs' in before && !('stateInputs' in after)) invalid(stage, `${path}.stateInputs`, 'Schema removed state inputs');
+}
+function checked(stage, run) {
+  return Effect.try({
+    try: run,
+    catch: error => error instanceof SnapshotCodecError ? error : new SnapshotCodecError({
+      stage,
+      path: '$',
+      reason: error instanceof Error ? error.message : String(error)
+    })
+  });
+}
+
+/**
+ * Binds a full bidirectional snapshot schema to a versioned machine. The schema
+ * owns rich values and supported historical versions. Decoding never migrates;
+ * restore or `machineVersions` remains responsible for migration.
+ *
+ * @experimental
+ */
+function createSnapshotCodec(machine, schema) {
+  const format = '@xstate/effect/snapshot';
+  return {
+    encode(snapshot) {
+      return Effect.gen(function* () {
+        yield* checked('encode', () => checkSnapshot(snapshot, 'encode', '$.snapshot', machine.id));
+        const encoded = yield* Schema.encodeUnknownEffect(schema)(snapshot);
+        return yield* checked('encode', () => {
+          checkJson(encoded, 'encode');
+          checkSnapshot(encoded, 'encode', '$.snapshot', machine.id);
+          checkMetadata(snapshot, encoded, 'encode');
+          return JSON.stringify({
+            format,
+            version: 1,
+            logicId: machine.id,
+            snapshot: encoded
+          });
+        });
+      });
+    },
+    decode(json) {
+      return Effect.gen(function* () {
+        const encoded = yield* checked('decode', () => {
+          const envelope = JSON.parse(json);
+          checkJson(envelope, 'decode');
+          if (!record(envelope) || envelope.format !== format || envelope.version !== 1) invalid('decode', '$', 'Unsupported snapshot format or version');
+          if (envelope.logicId !== machine.id) invalid('decode', '$.logicId', 'Machine identity mismatch');
+          checkSnapshot(envelope.snapshot, 'decode', '$.snapshot', machine.id);
+          return envelope.snapshot;
+        });
+        const snapshot = yield* Schema.decodeUnknownEffect(schema)(encoded);
+        yield* checked('decode', () => {
+          checkSnapshot(snapshot, 'decode', '$.snapshot', machine.id);
+          checkMetadata(encoded, snapshot, 'decode');
+        });
+        return snapshot;
+      });
+    }
+  };
+}
+
+export { SnapshotCodecError, createEffectEventStreamLogic, createEffectLogic, createEffectStreamLogic, createSnapshotCodec, deadLetters, emitted, inspect, join, send, setupEffect, snapshots, waitFor };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xstate/effect",
-  "version": "1.0.0-alpha.8",
+  "version": "1.0.0-beta.0",
   "type": "module",
   "description": "Effect integration for XState",
   "keywords": [
@@ -14,7 +14,9 @@
   "license": "MIT",
   "exports": {
     "./atom": "./dist/xstate-effect-atom.js",
+    "./test": "./dist/xstate-effect-test.js",
     ".": "./dist/xstate-effect.js",
+    "./oxlint": "./dist/xstate-effect-oxlint.js",
     "./package.json": "./package.json"
   },
   "sideEffects": false,
@@ -29,19 +31,29 @@
     "url": "https://github.com/statelyai/xstate/issues"
   },
   "peerDependencies": {
+    "@oxlint/plugins": "^1.76.0",
     "effect": "^4.0.0",
-    "xstate": "^6.0.0-alpha.68"
+    "xstate": "^6.0.0-beta.0"
   },
   "devDependencies": {
-    "effect": "4.0.0",
+    "@oxlint/plugins": "^1.76.0",
+    "effect": "4.0.6",
     "fast-check": "4.10.2",
-    "xstate": "^6.0.0-alpha.68"
+    "@xstate/test": "^2.0.0-beta.0",
+    "xstate": "^6.0.0-beta.0"
   },
   "preconstruct": {
     "entrypoints": [
       "./index.ts",
-      "./atom.ts"
+      "./atom.ts",
+      "./oxlint.ts",
+      "./test.ts"
     ]
   },
+  "peerDependenciesMeta": {
+    "@oxlint/plugins": {
+      "optional": true
+    }
+  },
   "scripts": {}
 }

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

@@ -1 +0,0 @@
-export declare const effectActionBrand: unique symbol;