xstate 6.0.0-beta.2 → 6.0.0-beta.3

package/docs/faq.md

@@ -25,7 +25,7 @@ No typegen step is needed. Types come from `schemas`: declare `context`, `events
 
 ## What happened to `@xstate/immer` and `@xstate/inspect`?
 
-Both packages were removed. Instead of `@xstate/immer`, return an updated `context` patch directly from the transition function; if you want Immer drafts, call Immer's `produce` yourself inside that function. Instead of `@xstate/inspect`, use `actor.subscribe(...)` or the `inspect` option on `createActor(...)`, and use [`@statelyai/inspect`](https://github.com/statelyai/inspect) for a visual inspector. See [inspection](inspection.md) and [inspect actor systems](inspect-actor-systems.md).
+Both packages were removed. Instead of `@xstate/immer`, return an updated `context` patch directly from the transition function; if you want Immer drafts, call Immer's `produce` yourself inside that function. Instead of `@xstate/inspect`, use `actor.subscribe(...)` or the `inspect` option on `createActor(...)`, and use [`@statelyai/sdk/inspect`](migrate-inspector.md) for a visual inspector. See [inspection](inspection.md) and [inspect actor systems](inspect-actor-systems.md).
 
 ## Can I run v5 and v6 side by side?
 

package/docs/fsm.md

@@ -17,8 +17,8 @@ import { createFSM } from 'xstate/fsm';
 const machine = createFSM({
   initial: 'inactive',
   states: {
-    inactive: { on: { toggle: 'active' } },
-    active: { on: { toggle: 'inactive' } }
+    inactive: { on: { toggle: { target: 'active' } } },
+    active: { on: { toggle: { target: 'inactive' } } }
   }
 });
 
@@ -121,8 +121,8 @@ import { createFSM } from 'xstate/fsm';
 const machine = createFSM({
   initial: 'inactive',
   states: {
-    inactive: { on: { toggle: 'active' } },
-    active: { on: { toggle: 'inactive' } }
+    inactive: { on: { toggle: { target: 'active' } } },
+    active: { on: { toggle: { target: 'inactive' } } }
   }
 });
 
@@ -143,23 +143,66 @@ from `xstate` adds the runtime to your bundle.
 
 `createFSM` is pure. It does not create or run actors:
 
-- `machine.initialState` is the initial `{ status: 'active', value, context }`.
-  FSM snapshots are always `'active'`. The `output` and `error` fields of the
-  snapshot type are always `undefined` and are not set on the object.
+- `machine.initialState` is the settled initial
+  `{ status: 'active', value, context }` snapshot. FSM snapshots are always
+  `'active'`. The `output` and `error` fields are always `undefined`.
 - `machine.getInitialSnapshot()` returns `machine.initialState`.
 - `machine.transition(state, event)` returns `[nextState, effects]`. `effects`
   is always empty.
 - Missing transitions return the current state unchanged.
-- A transition can be a state name, `{ target, context }`, or a function that
+- A transition can be `{ target, context }` or a function that
   receives `{ context, event }` and returns `{ target, context }`. Return
   `undefined` from a function for no transition.
-- Only own entries in `states` and `on` define transitions. A state inherited from the `states` prototype has no outgoing transitions, like an undeclared state. Transition targets are not validated.
+- Only own entries in `states` and `on` define transitions. A state inherited from the `states` prototype has no outgoing transitions, like an undeclared state. Target state names are not validated at runtime. Bare string transitions are rejected.
 - Context updates are shallow patches. A patch adds its own enumerable string and symbol keys even when a new value is `undefined` or matches an inherited value. If the target is unchanged, a patch whose keys already exist with `Object.is`-equal values keeps the current snapshot.
 - `types<T>()` adds types without runtime validation. Setup schema values are
   ignored by the FSM runtime; state `schemas.input` is accepted for upgrade
   compatibility but no input is consumed by this pure API.
 
+## Eventless transitions
+
+A state can declare `always` with the same object or function form as
+an event transition. Return `undefined` from a function when no transition
+is enabled:
+
+```ts
+const machine = createFSM<{ attempts: number }>({
+  initial: 'checking',
+  context: { attempts: 0 },
+  states: {
+    checking: {
+      always: ({ context }) =>
+        context.attempts < 3
+          ? { context: { attempts: context.attempts + 1 } }
+          : { target: 'ready' }
+    },
+    ready: {}
+  }
+});
+
+machine.initialState.value; // 'ready'
+```
+
+The presence of `always` transitions is detected once during construction.
+Define all `always` transitions before calling `createFSM`.
+
+The machine follows enabled `always` transitions during construction and after
+each handled event until none is enabled. Ignored events and callbacks that
+return `undefined` do not start another eventless chain. Subscribers receive
+only the settled snapshot. During construction, callbacks receive
+`{ type: 'xstate.init' }`; afterward, they receive the triggering event.
+
+There is no transition-count limit. An unconditional cycle does not terminate.
+Each state supports one `always` transition. Transition arrays and a separate
+guard API are not supported.
+
 The package intentionally has no actions, guards, effects, timers, child
-actors, hierarchical or parallel states, or eventless transitions. Use
+actors, hierarchical or parallel states. Use
 `createMachine` and `createActor` from `xstate` when the state machine needs
 those statechart or runtime features.
+
+## Transition target migration
+
+`on` and `always` require transition objects or functions returning transition objects. Replace `on: { GO: 'ready' }` with `on: { GO: { target: 'ready' } }` and `always: 'ready'` with `always: { target: 'ready' }`. `initial: 'idle'` stays a string. Invalid string transitions throw a `TypeError`.
+
+The `@xstate/codemod` `string-targets` transform updates inline `createFSM` and `setup(...).createFSM` configurations, including aliased `createFSM` imports. Review configurations stored separately and functions returning strings manually.

package/docs/index.md

@@ -1,4 +1,4 @@
-# XState 6.0.0-beta.2
+# XState 6.0.0-beta.3
 
 These docs match the installed xstate package. Start with the [quick start](quick-start.md) or the [agent guide](agents.md).
 For differences from v5, read the [migration guide](xstate-v5-to-v6.md).
@@ -29,6 +29,7 @@ The [export stability manifest](api-stability.json) classifies the installed sou
 - [Test XState logic](testing.md)
 - [Model-based testing](model-based-testing.md)
 - [Inspect actor systems](inspect-actor-systems.md)
+- [Migrate to SDK inspection](migrate-inspector.md)
 - [Troubleshooting](troubleshooting.md)
 - [Error codes](errors.md)
 - [Machine configuration](configuration.md)

package/docs/inspect-actor-systems.md

@@ -103,13 +103,30 @@ Redact before sending. Events and context often carry addresses, card details an
 
 ## 5. Use the visual inspector
 
-[`@statelyai/inspect`](https://github.com/statelyai/inspect) consumes the same inspection events and draws the running system as a statechart instead of a log.
+Use `createInspector` from `@statelyai/sdk/inspect` to visualize the running actor system.
 
 ```bash
-npm install @statelyai/inspect
+npm install @statelyai/sdk
 ```
 
-Create its inspector and pass it to the same `inspect` option, in development only.
+```ts
+import { createActor } from 'xstate';
+import { createInspector } from '@statelyai/sdk/inspect';
+import { checkoutMachine } from './checkoutMachine';
+
+const inspector = createInspector();
+const actor = createActor(checkoutMachine, { inspect: inspector.inspect });
+actor.start();
+
+await inspector.ready;
+console.log(inspector.inspectorUrl);
+```
+
+Open the logged URL to view the system. The SDK connects to the hosted relay without an API key and does not open a browser by default. In Node, pass `launch: 'browser'` to open the viewer automatically. In a browser, expose the URL as a link after `inspector.ready` resolves and let the user open it.
+
+Snapshot context is omitted by default. Use `serializeSnapshot` to include selected context fields. Call `inspector.destroy()` when inspection ends; this disconnects inspection without stopping your actors. Configure inspection in development only.
+
+If you use `@statelyai/inspect`, follow [Migrate to SDK inspection](migrate-inspector.md). The SDK has a different API and transport protocol.
 
 ## What next?
 

package/docs/inspection.md

@@ -44,7 +44,9 @@ Both event types carry `rootId`, the session ID of the root actor, and `actorRef
 | `snapshot` | The resulting snapshot. |
 | `microsteps` | The microstep transition definitions taken. |
 | `actions` | The executed actions, as `{ type, params }`. |
-| `sent` | Events relayed to other actors, as `{ targetRef, targetId, event, delay, id }`. |
+| `sent` | Events sent by the actor, including events sent to itself, as `{ targetRef, targetId, event, delay, id }`. |
+
+Callback `sendBack`, event observable values, and events mapped by `enq.listen()` or `enq.subscribeTo()` enter the source actor's mailbox before reaching the parent. The source reports a transition with the parent event in `sent`. A `createEffectEventStreamLogic` actor reports its stream items the same way.
 
 Each transition retains the source of its own event, including events queued before the actor starts or while another transition runs. Events sent through the public `actor.send(...)` method have an `undefined` source. Child initialization transitions identify the parent as their source.
 
@@ -73,3 +75,5 @@ event.microsteps, event.actions, event.sent; // '@xstate.transition'
 ```
 
 Microstep transition records contain the targets selected by function transitions. Inspection and `getMicrosteps()` expose resolved copies with a `definition` reference to the shared transition; the machine's shared transition definitions remain reusable.
+
+For visual inspection, use [`@statelyai/sdk/inspect`](inspect-actor-systems.md#5-use-the-visual-inspector). See [Migrate to SDK inspection](migrate-inspector.md) if you use the legacy `@statelyai/inspect` package.

package/docs/invoke.md

@@ -154,9 +154,9 @@ Invoked actors belong to the state that starts them:
 - leaving the state stops it
 - re-entering the state stops the old actor and starts a new one
 
-A state is re-entered by an external transition back to itself, or by a transition with `reenter: true`. A transition that stays inside the invoking state does not restart the child.
+A state is re-entered by an external transition back to itself, or by a targeted transition with `reenter: true`. A transition that stays inside the invoking state does not restart the child. Targetless transitions do not restart the child, even with `reenter: true`.
 
-Invoke on the machine root runs for the whole lifetime of the actor. Root invocations survive ordinary transitions between top-level states, and restart only on a root [transition](transitions.md) with `reenter: true`.
+Invoke on the machine root runs for the whole lifetime of the actor. Root invocations survive ordinary transitions between top-level states, and restart only on a root [transition](transitions.md) with an explicit target and `reenter: true`.
 
 ```ts
 const machine = createMachine({

package/docs/migrate-inspector.md

@@ -0,0 +1,141 @@
+---
+title: Migrate to SDK inspection
+description: Replace legacy Stately Inspect integrations with the Stately SDK.
+---
+
+Use `@statelyai/sdk/inspect` for visual inspection with XState v6. The SDK accepts XState v5 and v6 inspection events. The legacy `@statelyai/inspect` package remains available for existing XState v5 integrations.
+
+The SDK is not a drop-in replacement. Check the options and transport changes below before removing the legacy package. This guide describes `@statelyai/sdk` 0.48.0.
+
+## Install and connect
+
+```bash
+npm install @statelyai/sdk
+```
+
+Replace the browser factory with the SDK factory:
+
+```ts
+// Before: XState v5
+import { createBrowserInspector } from '@statelyai/inspect';
+
+const inspector = createBrowserInspector();
+```
+
+```ts
+// After: XState v6
+import { createActor } from 'xstate';
+import { createInspector } from '@statelyai/sdk/inspect';
+import { machine } from './machine';
+
+const inspector = createInspector();
+const actor = createActor(machine, { inspect: inspector.inspect });
+actor.start();
+
+await inspector.ready;
+console.log(inspector.inspectorUrl);
+```
+
+The SDK connects to the hosted relay without an API key. `inspector.ready` resolves after relay registration and the initial-state flush. Open `inspector.inspectorUrl` after it resolves. If you supply a custom transport, the URL is `null` and your transport controls the viewer connection.
+
+The SDK's `inspect` property is a callback. Pass it directly to `createActor` instead of calling the legacy observer's `inspect.next(...)` method. To inspect an actor that already exists, call `inspector.attach(actor)`.
+
+The SDK has no XState peer dependency restriction, but currently depends on XState v5 internally. An application using XState v6 can have both versions installed.
+
+## Open the viewer
+
+The SDK does not open a popup automatically. In a browser, expose `inspector.inspectorUrl` as a link after `inspector.ready` resolves. Let the user open it from a click or another user gesture.
+
+In Node, request automatic browser launch:
+
+```ts
+import { createInspector } from '@statelyai/sdk/inspect';
+
+const inspector = createInspector({ launch: 'browser' });
+```
+
+`launch: 'browser'` is supported from Node, not from a browser runtime.
+
+## Include selected context
+
+The default snapshot serializer sends `value`, `status`, and available tags. It omits context. Use `serializeSnapshot` to include fields that your viewer needs:
+
+```ts
+import { createInspector } from '@statelyai/sdk/inspect';
+
+const inspector = createInspector({
+  serializeSnapshot: (snapshot) => {
+    const context = snapshot.context;
+    const orderId =
+      context !== null &&
+      typeof context === 'object' &&
+      'orderId' in context &&
+      typeof context.orderId === 'string'
+        ? context.orderId
+        : undefined;
+
+    return {
+      value: snapshot.value,
+      status: snapshot.status,
+      tags: snapshot.tags ? Array.from(snapshot.tags) : [],
+      context: { orderId }
+    };
+  }
+});
+```
+
+Return JSON-serializable data. Avoid sending actor references, DOM nodes, credentials, or personal data. This serializer controls snapshots only; it does not redact event payloads or machine definitions.
+
+## Disconnect inspection
+
+Replace the legacy `inspector.stop()` teardown call with:
+
+```ts
+inspector.destroy();
+```
+
+This closes inspection and its subscriptions. It does not stop the application actors. The SDK's `stop(actorId)` method marks a manually inspected actor as stopped; it is not a teardown method. The SDK has no equivalent of the legacy `autoStart: false` and `start()` lifecycle.
+
+## Migrate manual inspection
+
+Both packages support manual actors, events, and snapshots, but actor registration has a different shape:
+
+```ts
+// Before
+inspector.actor('request', { status: 'active' }, { parentId: 'server' });
+```
+
+```ts
+// After
+inspector.actor('request', {
+  snapshot: { status: 'active' },
+  parent: 'server'
+});
+```
+
+Pass actor IDs as strings. Replace actor-reference arguments with their corresponding manual IDs. Map a legacy `definition` to the SDK's `machine` option, and provide a machine config or source string rather than assuming the old serialized definition is accepted.
+
+`inspector.snapshot(id, snapshot, event)` takes the triggering event directly as its third argument. The legacy API takes `{ event }` there. `inspector.event(id, event, { source })` continues to accept a source, but the SDK expects the source actor's ID as a string.
+
+## Check unsupported options and transports
+
+| Legacy API                                                | SDK migration                                                                                                                                                                          |
+| --------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `createInspector(adapter, options)`                       | `createInspector(options)` has a different signature. A custom SDK `transport` must implement the SDK transport interface.                                                             |
+| `createWebSocketInspector({ url })`                       | Use `createInspector({ url })` with a compatible SDK relay. The SDK `url` is a relay URL, not a viewer URL.                                                                            |
+| `createInspectorServer` from `@statelyai/inspect/server`  | For local inspection, use `createNodeInspectionRelay` from `@statelyai/sdk/node-relay`. Install its `ws` peer dependency and start the relay before connecting.                        |
+| `createBrowserReceiver`, `createWebSocketReceiver`        | There are no matching SDK exports. Keep the legacy receiver until its integration supports the SDK protocol.                                                                           |
+| `iframe`, custom `window`, browser `send` override        | There is no equivalent option on the SDK inspector factory. Keep the legacy integration until the viewer integration is migrated.                                                      |
+| `filter`, `serialize`, `sanitizeEvent`, `sanitizeContext` | There are no matching SDK options. `serializeSnapshot` only controls snapshots. Keep the legacy integration if it requires event filtering or sanitization that has not been replaced. |
+| `maxDeferredEvents`, `serializationDepthLimit`            | There are no matching SDK options. Do not pass them and assume they take effect.                                                                                                       |
+| `createSkyInspector({ apiKey })`                          | The SDK has an `apiKey` option for hosted session ownership, but it uses a different session and transport protocol. Migrate the hosted integration explicitly.                        |
+
+The legacy popup, WebSocket receiver, and local bridge exchange legacy inspection messages. SDK relays exchange room and producer messages. Changing the package name or server URL does not make these protocols compatible.
+
+After migrating and verifying your integration, remove `@statelyai/inspect` if no other code uses it:
+
+```bash
+npm uninstall @statelyai/inspect
+```
+
+See [Inspect actor systems](inspect-actor-systems.md) for the v6 inspection workflow and [Inspection](inspection.md) for XState's event types.

package/docs/system-transitions.md

@@ -79,6 +79,8 @@ such as `actor.send`, `actor.start`, `actor.on` and `actor.subscribe` throw.
 For `enq.listen`/`enq.subscribeTo`, register named pure mapper functions in
 `systemLogic.mappers`; mapped communication and attachment lifetimes belong
 to the snapshot too.
+Mapped events transition through their listener or subscription actor before
+reaching the owner.
 Subscription `done`/`error` mappings enter the owner's message queue before
 the native child completion/error notification, matching live actor ordering.
 

package/docs/transitions.md

@@ -35,7 +35,7 @@ schemas: {
 
 There is no `guard` property. Conditions live inside the transition function, which returns `undefined` to reject the event. Check the condition before calling `enq`: a function that calls `enq` is taken even if it returns `undefined`. See [guards](guards.md).
 
-A targetless transition can update context and run effects without leaving the current state. Set `reenter: true` when a self-transition should run exit and entry behavior again.
+A targetless transition can update context and run effects without leaving the current state. It does not run exit or entry behavior, even with `reenter: true`. Specify a target and set `reenter: true` when a self-transition should run exit and entry behavior again.
 
 ```ts
 on: {
@@ -101,6 +101,10 @@ Transition functions must be synchronous. A transition function that returns a p
 
 `always` runs without an external event. `after` runs after a delay. `onDone`, `onError` and `onTimeout` handle actor outcomes.
 
+When an `after` timer, state timeout, or delayed `enq.raise(...)` becomes due, the delayed event is processed before `always` is reevaluated. Eventless transitions then settle before immediately raised events are processed. Timer bookkeeping does not itself run `always`: a delayed `enq.sendTo(...)` delivers its event without reevaluating eventless transitions in the sender. If the sender is also the recipient, it processes the delivered event and then reevaluates `always`.
+
+If an `always` condition depends only on context updated through transitions, it is reevaluated during those updates and cannot become enabled silently while the machine waits. This also applies to observable values whose updates reach the machine as events and update context. The timer ordering issue concerns conditions that read outside mutable values or depend on the current event. `always` does not poll outside values for changes.
+
 Use targetless transitions for edits that keep a form on the same step. Use re-entering transitions to restart a timer, subscription or invoked request.
 
 Put shared transitions on a parent state. A child can set an event to `undefined` to forbid that parent transition. Wildcards such as `pointer.*` match an event family when no exact transition matches.

package/docs/xstate-v5-to-v6.md

@@ -34,7 +34,7 @@ This guide is organized by area. Skim the **Quick reference** below and read [§
 | `types: {} as { context: ..., events: ...}`             | `schemas: { context, events, ... }` (Zod / Standard Schema, or `types<T>()` for type-only)                                          |
 | `actor.send({ type: 'INC' })`                           | `actor.send(...)` keeps working; new typed `actor.trigger.INC()`                                                                    |
 | `@xstate/immer`                                         | removed - return updated `context` patches directly                                                                                 |
-| `@xstate/inspect`                                       | removed - use `inspect` option on `createActor`, `actor.subscribe`, or [`@statelyai/inspect`](https://github.com/statelyai/inspect) |
+| `@xstate/inspect`                                       | removed - use `inspect` option on `createActor`, `actor.subscribe`, or [`@statelyai/sdk/inspect`](migrate-inspector.md) |
 | `sendTo('child', ev)` with no running `child`           | dead letter with reason `'missingTarget'`; the sender stays `active` (§26)                                                          |
 | `tsTypes` (typegen)                                     | removed; declare types with `schemas` (§3)                                                                                          |
 | `machine.implementations`                               | `machine.sources`                                                                                                                   |
@@ -1146,7 +1146,7 @@ See [compact finite state machines](fsm.md) for its exact supported surface.
 - The executable action types are now executable effect types: `ExecutableActionObject` is `ExecutableEffect`, `ExecutableActionsFrom` is `ExecutableEffectFrom`, `SpecialExecutableAction` is `SpecialExecutableEffect`, `ExecutableSpawnAction` is `SpawnExecutableEffect`, and `ToExecutableAction` is `ToExecutableEffect`. The new v6 types and helpers use the same naming, for example `BuiltInExecutableEffect` and `isBuiltInExecutableEffect`.
 - `snapshot._nodes` is now `snapshot.nodes`. It lists the active state nodes.
 - Implicit state ids no longer use the `(machine)` placeholder. A state's implicit id is its path from the root joined by `.`, prefixed by the machine `id` when the machine has one: `shop.checkout` for `id: 'shop'`, and `checkout` without an id (v5: `(machine).checkout`). `machine.id` and the root's id are `''` for a machine without an `id`, so `#` cannot reference that root; give the machine an `id` to target it. An explicit state `id` that equals another state's id throws.
-- Bare string transition values (`on: { GO: 'next' }`, `after: { 1000: 'idle' }`, `always: 'ready'`, `onDone: 'done'`) throw when the machine is created: `Transition for "GO" in state "idle" is the string "next". Use { target: 'next' }.` Write `{ target: 'next' }`; the `string-targets` codemod transform rewrites them. `initial` keeps its string form, and `xstate/fsm` still accepts string targets.
+- Bare string transition values (`on: { GO: 'next' }`, `after: { 1000: 'idle' }`, `always: 'ready'`, `onDone: 'done'`) throw when the machine is created: `Transition for "GO" in state "idle" is the string "next". Use { target: 'next' }.` Write `{ target: 'next' }`; the `string-targets` codemod transform rewrites them. `initial` keeps its string form. `xstate/fsm` also requires object targets for `on` and `always`.
 - `#` targets and `matches('#…')` resolve by exact id. v5 split the text after `#` at the first `.` and resolved the rest as a path below that id, so `#flow.review` meant "child `review` of the state with id `flow`". In v6, the whole string after `#` is the id: use the target state's own explicit `id`, or its full implicit id. This also applies to `@xstate.stateIn` guards in JSON. Dots in an explicit id are matched literally (`#checkout.v2` for `id: 'checkout.v2'`); v5 required `#checkout\\.v2`. An unresolvable target throws when the machine is created, and suggests the target's id when the old form resolves:
 
   ```ts
@@ -1204,6 +1204,8 @@ If you want Immer-style drafts, call Immer's `produce` yourself inside the inlin
 
 ### `@xstate/inspect` - removed
 
+For a visual inspector, use `createInspector` from `@statelyai/sdk/inspect`. See [Migrate to SDK inspection](migrate-inspector.md) for installation and changes from `@statelyai/inspect`.
+
 The standalone inspector package and its `inspect()` entry point are gone. Inspection now flows through:
 
 - `actor.subscribe(observer)` - the snapshot stream
@@ -1630,7 +1632,7 @@ It runs these transforms in order. `--transform name,name` selects a subset.
 | Transform             | Effect                                                                                                                                                                                                                                                                      |
 | --------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `rename-imports`      | Renames `interpret` to `createActor`, `Interpreter` to `Actor`, and `fromCallback`, `fromObservable`, and `fromEventObservable` to their `create*Logic` names, and the executable action types to their executable effect names, including usages. Import aliases are kept.                                                                  |
-| `string-targets`      | Wraps bare string transition values under `on`, `after`, `onDone`, `onError`, and `always` in `{ target: '...' }` inside `createMachine` and `createStateConfig` configs.                                                                                                   |
+| `string-targets`      | Wraps bare string transition values under `on`, `after`, `onDone`, `onError`, and `always` in `{ target: '...' }` inside `createMachine`, `createStateConfig`, and `createFSM` configs.                                                                                                   |
 | `types-to-schemas`    | Converts `types: {} as { ... }` and the per-key form `types: { context: {} as C, events: {} as E }` to `schemas` with `types<T>()` entries. Events become a map when they are written as a union of object literals with a string-literal `type`, inline or through type aliases declared in the same file. Other event types become `events: types<E>()`, which loads but does not type-check as a v6 event map, so the entry is reported as a manual site to rewrite as a map by hand. A `types` value in any other shape, such as a variable, is reported as a manual site. |
 | `lower-actions`       | Rewrites transition objects that have `actions` or `guard`, and transition arrays, as one transition function `(args, enq) => { ... }`; non-function `entry` and `exit` values as one function; and the action creators and guard combinators inside them (`assign`, `enqueueActions`, `raise`, `sendTo`, `sendParent`, `forwardTo`, `emit`, `log`, `cancel`, `stopChild`, `spawnChild`, `and`, `or`, `not`, `stateIn`) as `enq` calls, context patches and boolean expressions, following named implementations and module-level constants defined in the same file. Named actions and guards keep their v5 signatures; the generated code calls them as `enq(args.actions.name, args, params)` and `args.guards.name(args, params)`. A named `assign` action becomes a function that returns a context patch. Moves an object-literal second `createMachine` argument into the config, and rewrites `fromPromise(fn)` as `createAsyncLogic({ run: fn })` when `fn` does not read `system` or `emit`. Removes the `'xstate'` imports it leaves unused. A transition, `entry`, or `exit` value that contains anything it cannot rewrite, such as an `enqueueActions` callback that passes `enqueue` as a value or returns early, a guard or action defined in another file, or a named `assign` that `provide()` overrides, is left unchanged and reported by the transforms below. |
 | `report-removed-apis` | Reports, without rewriting, uses of `assign`, `raise`, `sendTo`, `sendParent`, `forwardTo`, `emit`, `log`, `cancel`, `spawnChild`, `stop`, `stopChild`, `enqueueActions`, `and`, `or`, `not`, `stateIn`, `fromPromise`, `fromTransition`, `toObserver`, `pathToStateValue`, and `SpecialTargets`, with a suggested replacement. |
@@ -1994,7 +1996,7 @@ In v5, an undeclared delay name resolved to `undefined`, and the delayed transit
 - [ ] If you used `events` as a **union**, restructure to a **map keyed by type**
 - [ ] Move implementations passed as the second argument of `createMachine(config, implementations)` (deprecated in v5) into `setup({ ... })`, the `createMachine({ ... })` config, or `machine.provide({ ... })` (§4). v6's `createMachine` takes one argument and throws when it receives a second one
 - [ ] Audit `invoke.src` references - `src` may be a logic object, a registered name, or a resolver function
-- [ ] Drop dependencies on `@xstate/immer` and `@xstate/inspect`; update inspection to `actor.subscribe`, the `inspect` option, or `@statelyai/inspect`
+- [ ] Drop dependencies on `@xstate/immer` and `@xstate/inspect`; update inspection to `actor.subscribe`, the `inspect` option, or `@statelyai/sdk/inspect`
 - [ ] Remove imports of `GuardArgs`, `GuardPredicate`, `Inspected*Event`, `PromiseActorLogic`, and `fromPromise` (use `createAsyncLogic`), and update the type arguments of any `SetupReturn<...>` annotation (§16)
 - [ ] Drain/migrate any v5 persisted snapshots - the v6 snapshot shape is not binary-compatible
 - [ ] Check that persisted `context` holds only JSON values; development builds warn on functions, symbols, `BigInt`, `Map`, `Set`, cycles, `NaN`, and `Infinity`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xstate",
-  "version": "6.0.0-beta.2",
+  "version": "6.0.0-beta.3",
   "description": "Finite State Machines and Statecharts for the Modern Web.",
   "main": "dist/xstate.cjs.js",
   "bin": {