@xstate/codemod 0.1.0-beta.0 → 0.1.0-beta.2

package/dist/xstate-codemod.js

@@ -1,5 +1,11 @@
 import { Node, SyntaxKind, SymbolFlags, ts, Project } from 'ts-morph';
-import process from 'node:process';
+import process$1 from 'node:process';
+import { mkdirSync, writeFileSync, readFileSync } from 'node:fs';
+import { dirname, resolve, join } from 'node:path';
+import { parseArgs as parseArgs$1 } from 'node:util';
+import { spawn } from 'node:child_process';
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
 
 /** Map of v5 xstate exports → v6 replacement names. */
 const RENAMES = {
@@ -73,7 +79,7 @@ const renameImports = {
  * Handles both `createMachine(...)` and `setup(...).createMachine(...)` by
  * returning the trailing property/identifier name (e.g. `createMachine`).
  */
-function getCallName(call) {
+function getCallName$1(call) {
   const expr = call.getExpression();
   if (Node.isIdentifier(expr)) {
     return expr.getText();
@@ -96,7 +102,7 @@ function getCallName(call) {
 function findMachineConfigObjects(sourceFile, callNames = ['createMachine', 'createStateConfig']) {
   const result = [];
   for (const call of sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression)) {
-    const name = getCallName(call);
+    const name = getCallName$1(call);
     if (!name || !callNames.includes(name)) {
       continue;
     }
@@ -283,52 +289,89 @@ const stringTargets = {
 };
 
 /**
- * Extracts the `T` type node from a `{} as T` (AsExpression) initializer of a
- * `types:` property. Returns undefined if the shape isn't recognized.
+ * Flattens an events type into `[eventType, payloadTypeText]` entries. Accepts
+ * inline object literal members with a string-literal `type`, and references
+ * to non-generic type aliases declared in the same file. Returns undefined for
+ * any other member (imported types, interfaces, mapped types, ...).
  */
-function getTypesAsTypeNode(init) {
-  if (!Node.isAsExpression(init)) {
-    return undefined;
+function eventsToEventMap(typeNode, seen = new Set()) {
+  if (Node.isParenthesizedTypeNode(typeNode)) {
+    return eventsToEventMap(typeNode.getTypeNode(), seen);
   }
-  return init.getTypeNode();
-}
-
-/**
- * Given a union type node written as an inline literal union of object types,
- * each with a `type: '...'` discriminant, returns a map entry list of
- * `[eventType, remainingObjectTypeText]`. Returns undefined when the union is
- * not a literal inline union of object types with string-literal `type` props.
- */
-function unionToEventMap(typeNode) {
-  const members = Node.isUnionTypeNode(typeNode) ? typeNode.getTypeNodes() : [typeNode];
-  const entries = [];
-  for (const member of members) {
-    if (!Node.isTypeLiteral(member)) {
-      return undefined; // e.g. a type reference — bail out entirely
+  if (Node.isUnionTypeNode(typeNode)) {
+    const entries = [];
+    for (const member of typeNode.getTypeNodes()) {
+      const memberEntries = eventsToEventMap(member, seen);
+      if (!memberEntries) return undefined;
+      entries.push(...memberEntries);
     }
-    const lit = member;
-    const props = lit.getProperties();
-    const typeProp = props.find(p => p.getName() === 'type');
-    if (!typeProp) {
+    return entries;
+  }
+  if (Node.isTypeReference(typeNode)) {
+    const name = typeNode.getTypeName();
+    if (!Node.isIdentifier(name) || typeNode.getTypeArguments().length) {
       return undefined;
     }
-    const typePropTypeNode = typeProp.getTypeNode();
-    if (!typePropTypeNode || typePropTypeNode.getKind() !== SyntaxKind.LiteralType) {
+    const alias = typeNode.getSourceFile().getTypeAlias(name.getText());
+    const aliased = alias?.getTypeNode();
+    if (!alias || !aliased || alias.getTypeParameters().length) {
       return undefined;
     }
-    const literal = typePropTypeNode.getFirstChild();
-    if (!literal || !Node.isStringLiteral(literal)) return undefined;
-    const eventType = literal.getLiteralValue();
+    if (seen.has(alias.getName())) return undefined;
+    return eventsToEventMap(aliased, new Set(seen).add(alias.getName()));
+  }
+  if (!Node.isTypeLiteral(typeNode)) return undefined;
+  const props = typeNode.getProperties();
+  if (props.length !== typeNode.getMembers().length) return undefined;
+  const typePropTypeNode = props.find(p => p.getName() === 'type')?.getTypeNode();
+  if (!typePropTypeNode || !Node.isLiteralTypeNode(typePropTypeNode)) {
+    return undefined;
+  }
+  const literal = typePropTypeNode.getLiteral();
+  if (!Node.isStringLiteral(literal)) return undefined;
+
+  // Build payload object type text from the remaining props.
+  const payloadProps = props.filter(p => p.getName() !== 'type').map(p => p.getText().replace(/[;,]\s*$/, ''));
+  const payload = payloadProps.length ? `{ ${payloadProps.join('; ')} }` : `{}`;
+  return [{
+    eventType: literal.getLiteralValue(),
+    payload
+  }];
+}
 
-    // Build payload object type text from the remaining props.
-    const payloadProps = props.filter(p => p.getName() !== 'type').map(p => p.getText().replace(/[;,]\s*$/, ''));
-    const payload = payloadProps.length ? `{ ${payloadProps.join('; ')} }` : `{}`;
-    entries.push({
-      eventType,
-      payload
+/**
+ * Reads the members of a `types` initializer, written either as
+ * `{} as { context: C; events: E }` or per key as
+ * `{ context: {} as C, events: {} as E }`. Returns `'opaque'` for `{} as T`
+ * where `T` is not an inline object type, and undefined for any other shape.
+ */
+function getTypesMembers(init) {
+  if (Node.isAsExpression(init)) {
+    const typeNode = init.getTypeNode();
+    if (!typeNode) return undefined;
+    if (!Node.isTypeLiteral(typeNode)) return 'opaque';
+    return typeNode.getProperties().flatMap(member => {
+      const memberType = member.getTypeNode();
+      return memberType ? [{
+        key: member.getName(),
+        typeNode: memberType
+      }] : [];
+    });
+  }
+  if (!Node.isObjectLiteralExpression(init)) return undefined;
+  const members = [];
+  for (const prop of init.getProperties()) {
+    if (!Node.isPropertyAssignment(prop)) return undefined;
+    const key = getKey(prop);
+    const value = prop.getInitializer();
+    const typeNode = value && Node.isAsExpression(value) ? value.getTypeNode() : undefined;
+    if (!key || !typeNode) return undefined;
+    members.push({
+      key,
+      typeNode
     });
   }
-  return entries;
+  return members;
 }
 function getKey(prop) {
   const nameNode = prop.getNameNode();
@@ -340,91 +383,109 @@ function getKey(prop) {
   }
   return undefined;
 }
+const LEFTOVER_TYPES_HINT = '`types` was replaced by `schemas`; declare events as a map `schemas: { events: { TYPE: types<Payload>() } }`, or use `types<EventUnion>()` when the union is not inline.';
+const EVENTS_FALLBACK_HINT = '`events: types<E>()` loads but does not type-check as a v6 event map; expand `E` into `events: { TYPE: types<Payload>(), ... }`.';
+
+/** Records a manual site for a `types` property left at `pos`. */
+function pushLeftoverSite(sourceFile, pos, sites) {
+  const {
+    line,
+    column
+  } = sourceFile.getLineAndColumnAtPos(pos);
+  sites.push({
+    file: sourceFile.getFilePath(),
+    line,
+    column,
+    api: 'types',
+    hint: LEFTOVER_TYPES_HINT
+  });
+}
 
 /**
- * Converts a single `types: {} as { ... }` property into a `schemas: { ... }`
- * property. Mutates the containing config object literal.
+ * Converts a single `types` property into a `schemas: { ... }` property.
+ * Mutates the containing config object literal.
  */
-function convertTypesProperty(configObj, typesProp, notes) {
-  const init = typesProp.getInitializerOrThrow();
-  const typeNode = getTypesAsTypeNode(init);
-  if (!typeNode) {
+function convertTypesProperty(configObj, typesProp, notes, sites, getHelper) {
+  const sourceFile = configObj.getSourceFile();
+  const start = typesProp.getStart();
+  const members = getTypesMembers(typesProp.getInitializerOrThrow());
+  if (!members) {
+    pushLeftoverSite(sourceFile, start, sites);
     return false;
   }
 
   // `types: {} as any` (or non-object) — cannot infer a shape; leave a note.
-  if (!Node.isTypeLiteral(typeNode)) {
-    notes.push(`left 'types' unchanged: initializer is not an inline object type ({} as ${typeNode.getText()})`);
+  if (members === 'opaque') {
+    notes.push(`left 'types' unchanged: initializer is not an inline object type (${typesProp.getInitializerOrThrow().getText()})`);
+    pushLeftoverSite(sourceFile, start, sites);
     typesProp.replaceWithText(`${typesProp.getText()} /* TODO(xstate-codemod): could not migrate 'types' to 'schemas' automatically */`);
     return false;
   }
-  const lit = typeNode;
-  const schemaEntries = [];
-  let usedTypes = false;
-  let eventsLeftBehind = false;
-  for (const member of lit.getProperties()) {
-    const key = member.getName();
-    const valueTypeNode = member.getTypeNode();
-    if (!valueTypeNode) {
-      continue;
-    }
-    if (key === 'events') {
-      const map = unionToEventMap(valueTypeNode);
-      if (!map) {
-        // Not a literal inline union — leave events in `types`, add a TODO.
-        eventsLeftBehind = true;
-        notes.push(`could not migrate 'events' to schemas.events map (not a literal inline union); left in place`);
-        continue;
-      }
-      schemaEntries.push(helper => {
-        const mapEntries = map.map(e => `${JSON.stringify(e.eventType)}: ${helper}<${e.payload}>()`);
-        return `events: {\n    ${mapEntries.join(',\n    ')}\n  }`;
-      });
-      usedTypes = true;
-    } else {
-      // context, input, output, emitted, tags, meta, ... → types<T>()
-      const valueType = valueTypeNode.getText();
-      schemaEntries.push(helper => `${key}: ${helper}<${valueType}>()`);
-      usedTypes = true;
-    }
-  }
-  if (schemaEntries.length === 0) {
-    return false;
-  }
-  const helper = usedTypes ? ensureNamedImport(configObj.getSourceFile(), 'types', configObj) : undefined;
+  if (members.length === 0) return false;
+  const helper = getHelper(configObj);
   if (!helper) {
     notes.push("left 'types' unchanged: no xstate runtime import available");
+    pushLeftoverSite(sourceFile, start, sites);
     return false;
   }
-  const schemasText = `schemas: {\n  ${schemaEntries.map(entry => entry(helper)).join(',\n  ')}\n}`;
-  if (eventsLeftBehind) {
-    // Keep the original `types` property (holding only the un-migratable
-    // events) alongside the new `schemas` property.
-    // Rebuild `types` with only the `events` member preserved.
-    const eventsMember = lit.getProperties().find(p => p.getName() === 'events');
-    const preservedTypes = eventsMember ? `types: {} as { ${eventsMember.getText()} } /* TODO(xstate-codemod): migrate events to schemas.events map */` : typesProp.getText();
-    typesProp.replaceWithText(`${schemasText},\n  ${preservedTypes}`);
-  } else {
-    typesProp.replaceWithText(schemasText);
+  let eventsFallback = false;
+  const schemaEntries = members.map(({
+    key,
+    typeNode
+  }) => {
+    if (key === 'events') {
+      const map = eventsToEventMap(typeNode);
+      if (map) {
+        const mapEntries = map.map(e => `${JSON.stringify(e.eventType)}: ${helper}<${e.payload}>()`);
+        return `events: {\n    ${mapEntries.join(',\n    ')}\n  }`;
+      }
+      notes.push(`'events' is not an inline literal union or a same-file alias of one; wrote it as a single ${helper}<...>() schema`);
+      eventsFallback = true;
+    }
+    // context, input, output, emitted, tags, meta, ... → types<T>()
+    return `${key}: ${helper}<${typeNode.getText()}>()`;
+  });
+  typesProp.replaceWithText(`schemas: {\n  ${schemaEntries.join(',\n  ')}\n}`);
+  if (eventsFallback) {
+    // `events: types<E>()` loads but is not a valid v6 event map type.
+    const schemas = configObj.getProperty('schemas');
+    const events = schemas && Node.isPropertyAssignment(schemas) ? schemas.getInitializerIfKind(SyntaxKind.ObjectLiteralExpression)?.getProperty('events') : undefined;
+    const {
+      line,
+      column
+    } = sourceFile.getLineAndColumnAtPos((events ?? schemas ?? configObj).getStart());
+    sites.push({
+      file: sourceFile.getFilePath(),
+      line,
+      column,
+      api: 'types',
+      hint: EVENTS_FALLBACK_HINT
+    });
   }
-  notes.push(`converted 'types' → 'schemas' (${schemaEntries.length} key(s))${eventsLeftBehind ? "; 'events' left as types (manual)" : ''}`);
+  notes.push(`converted 'types' → 'schemas' (${schemaEntries.length} key(s))`);
   return true;
 }
 
 /**
- * Converts `types: {} as { context; events; input; ... }` inside machine config
- * objects into `schemas: { context: types<...>(), ... }`.
+ * Converts `types: {} as { context; events; input; ... }` (or the per-key
+ * `types: { context: {} as C, ... }` form) inside machine config objects into
+ * `schemas: { context: types<...>(), ... }`.
  */
 const typesToSchemas = {
   name: 'types-to-schemas',
-  description: 'Convert `types: {} as {...}` into `schemas: { context: types<C>(), events: { ... }, input: types<I>() }`. Events are converted to a map only when written as a literal inline union.',
+  description: 'Convert `types: {} as {...}` and `types: { context: {} as C, ... }` into `schemas: { context: types<C>(), events: { ... }, input: types<I>() }`. Events become a map when written as a literal union, inline or in a same-file type alias; otherwise `events: types<E>()`.',
   apply(sourceFile) {
     const notes = [];
+    const sites = [];
     let changed = false;
+    // `ensureNamedImport` reads stale scope after adding an import, so resolve
+    // the helper binding once per file.
+    let helper;
+    const getHelper = location => helper ??= ensureNamedImport(sourceFile, 'types', location);
     for (const configObj of findMachineConfigObjects(sourceFile, ['createMachine', 'createStateConfig', 'setup'])) {
       for (const prop of configObj.getProperties()) {
         if (Node.isPropertyAssignment(prop) && getKey(prop) === 'types') {
-          if (convertTypesProperty(configObj, prop, notes)) {
+          if (convertTypesProperty(configObj, prop, notes, sites, getHelper)) {
             changed = true;
           }
         }
@@ -432,206 +493,2313 @@ const typesToSchemas = {
     }
     return {
       changed,
-      notes
+      notes,
+      sites
     };
   }
 };
 
-/**
- * v5 `'xstate'` exports that require structural rewrites in v6 and are too
- * risky to automate. Value is a one-line hint for the v6 replacement.
- */
-const REMOVED_APIS = {
-  assign: 'return a `{ context }` patch from the transition/action function',
-  raise: 'use `enq.raise(...)` inside an action',
-  sendTo: 'use `enq.sendTo(...)` inside an action',
-  sendParent: 'use `enq.sendTo(...)` with the parent ref inside an action',
-  forwardTo: 'use `enq.sendTo(target, event)` inside an action',
-  emit: 'use `enq.emit(...)` inside an action',
-  log: 'use `enq.log(...)` inside an action',
-  cancel: 'use `enq.cancel(...)` inside an action',
-  spawnChild: 'use `enq.spawn(...)` inside an action',
-  stop: 'use `enq.stop(...)` inside an action',
-  stopChild: 'use `enq.stop(...)` inside an action',
-  enqueueActions: 'action functions now receive an `enq` enqueue object directly',
-  and: 'inline the guard as `(...) => a(...) && b(...)`',
-  or: 'inline the guard as `(...) => a(...) || b(...)`',
-  not: 'inline the guard as `(...) => !a(...)`',
-  stateIn: 'use `self.getSnapshot().matches(...)`',
-  fromPromise: 'use `createAsyncLogic(...)`',
-  fromTransition: 'use `createStepLogic({ context, run })`',
-  toObserver: 'pass an observer object or callback directly',
-  pathToStateValue: 'build the state value object directly',
-  SpecialTargets: 'use `enq.sendTo(self, event)` for internal sends; parent sends use `enq.sendTo(...)` with the parent ref'
+/** Thrown to abandon lowering of one node; the report transforms then flag it. */
+class Skip extends Error {}
+const skip = reason => {
+  throw new Skip(reason);
 };
 
-/**
- * Detects (does NOT transform) usages of v5 `'xstate'` APIs that were removed
- * or restructured in v6. Reports file:line + API + a replacement hint via the
- * returned notes.
- */
-const reportRemovedApis = {
-  name: 'report-removed-apis',
-  description: 'Detect (report only) usages of removed/restructured v5 xstate APIs (assign, raise, sendTo, emit, fromPromise, and/or/not, toObserver, SpecialTargets, etc.) that need manual migration.',
-  apply(sourceFile) {
-    const notes = [];
-    const xstateImports = sourceFile.getImportDeclarations().filter(imp => imp.getModuleSpecifierValue() === 'xstate');
-
-    // Map local binding name → canonical API name (respecting aliases).
-    const tracked = new Map();
-    for (const imp of xstateImports) {
-      for (const spec of imp.getNamedImports()) {
-        const original = spec.getNameNode().getText();
-        if (REMOVED_APIS[original]) {
-          const local = (spec.getAliasNode() ?? spec.getNameNode()).getText();
-          tracked.set(local, original);
-        }
-      }
+/** Local name → imported name, for value imports from `'xstate'`. */
+function getXstateImports(sourceFile) {
+  const map = new Map();
+  for (const imp of sourceFile.getImportDeclarations()) {
+    if (imp.getModuleSpecifierValue() !== 'xstate' || imp.isTypeOnly()) continue;
+    for (const spec of imp.getNamedImports()) {
+      if (spec.isTypeOnly()) continue;
+      const local = (spec.getAliasNode() ?? spec.getNameNode()).getText();
+      map.set(local, spec.getName());
     }
-    if (tracked.size === 0) {
-      return {
-        changed: false,
-        notes
+  }
+  return map;
+}
+
+/** The `'xstate'` export a call invokes, e.g. `assign` for `assign(...)`. */
+function xstateCallee(node, xs) {
+  if (!Node.isCallExpression(node)) return undefined;
+  const expr = node.getExpression();
+  return Node.isIdentifier(expr) ? xs.get(expr.getText()) : undefined;
+}
+function getKeyText$2(node) {
+  if (!Node.isPropertyAssignment(node) && !Node.isMethodDeclaration(node) && !Node.isShorthandPropertyAssignment(node)) return undefined;
+  const name = node.getNameNode();
+  if (Node.isStringLiteral(name) || Node.isNoSubstitutionTemplateLiteral(name)) return name.getLiteralText();
+  if (Node.isIdentifier(name) || Node.isNumericLiteral(name)) return name.getText();
+  return undefined;
+}
+function getProperty$1(object, key) {
+  if (!Node.isObjectLiteralExpression(object)) return undefined;
+  const property = object.getProperties().find(candidate => getKeyText$2(candidate) === key);
+  return Node.isPropertyAssignment(property) ? property.getInitializer() : undefined;
+}
+function isFunctionLike(node) {
+  return !!node && (Node.isArrowFunction(node) || Node.isFunctionExpression(node));
+}
+
+/** `.name` or `['na me']`. */
+function access(name) {
+  return /^[A-Za-z_$][\w$]*$/.test(name) ? `.${name}` : `[${JSON.stringify(name)}]`;
+}
+/** Guard combinators a named guard may be defined as, inlined at call sites. */
+const INLINE_GUARDS = new Set(['and', 'or', 'not', 'stateIn']);
+function classify$1(property, xs, group) {
+  if (Node.isMethodDeclaration(property)) return {
+    kind: 'fn',
+    property
+  };
+  if (Node.isShorthandPropertyAssignment(property)) {
+    if (group === 'actions') {
+      const constAssign = implConstAssign(property.getNameNode(), xs);
+      if (constAssign) return {
+        kind: 'assign',
+        property,
+        ...constAssign
       };
     }
-    const filePath = sourceFile.getFilePath();
-    for (const ident of sourceFile.getDescendantsOfKind(SyntaxKind.Identifier)) {
-      const local = ident.getText();
-      const api = tracked.get(local);
-      if (!api) {
-        continue;
-      }
-      // Skip the import specifier declarations themselves.
-      const parentKind = ident.getParent()?.getKind();
-      if (parentKind === SyntaxKind.ImportSpecifier || parentKind === SyntaxKind.ImportClause) {
-        continue;
-      }
-      const {
-        line,
-        column
-      } = sourceFile.getLineAndColumnAtPos(ident.getPos());
-      notes.push(`${filePath}:${line}:${column} — '${api}' → ${REMOVED_APIS[api]}`);
-    }
-
-    // Never mutates the file.
     return {
-      changed: false,
-      notes
+      kind: resolveIdentifier(property.getNameNode()) === 'fn' ? 'fn' : 'other',
+      property
     };
   }
-};
-
-/** Keys whose string values (or string array elements) are state targets. */
-const TARGET_KEYS = new Set(['target', 'initial', 'on', 'after', 'always', 'onDone', 'onError']);
+  if (!Node.isPropertyAssignment(property)) return {
+    kind: 'other',
+    property
+  };
+  const value = unwrap(property.getInitializer());
+  if (isFunctionLike(value)) return {
+    kind: 'fn',
+    property
+  };
+  if (xstateCallee(value, xs) === 'assign') {
+    const arg = value.getArguments()[0];
+    if (arg) return {
+      kind: 'assign',
+      property,
+      assignArg: arg
+    };
+  }
+  if (Node.isIdentifier(value) && resolveIdentifier(value) === 'fn') {
+    return {
+      kind: 'fn',
+      property
+    };
+  }
+  if (group === 'actions' && Node.isIdentifier(value)) {
+    const constAssign = implConstAssign(value, xs);
+    if (constAssign) return {
+      kind: 'assign',
+      property,
+      ...constAssign
+    };
+  }
+  const callee = xstateCallee(value, xs);
+  if (callee && (group === 'guards' ? INLINE_GUARDS.has(callee) : ACTION_CREATORS.has(callee) || callee === 'enqueueActions')) {
+    return {
+      kind: 'inline',
+      property,
+      expr: value
+    };
+  }
+  return {
+    kind: 'other',
+    property
+  };
+}
 
-/** Calls whose first argument is a state value or `#id` reference. */
-const MATCH_CALLS = new Set(['matches', 'stateIn']);
-function getPropertyName(node) {
-  if (Node.isPropertyAssignment(node)) {
-    const name = node.getNameNode();
-    if (Node.isIdentifier(name) || Node.isStringLiteral(name)) {
-      return Node.isStringLiteral(name) ? name.getLiteralText() : name.getText();
+/** Strips `as` / `satisfies` / parentheses. */
+function unwrap(node) {
+  let current = node;
+  while (Node.isAsExpression(current) || Node.isSatisfiesExpression(current) || Node.isParenthesizedExpression(current)) {
+    current = current.getExpression();
+  }
+  return current;
+}
+function collectFrom(impls, object, xs) {
+  if (!object || !Node.isObjectLiteralExpression(object)) return;
+  for (const group of ['actions', 'guards']) {
+    const map = getProperty$1(object, group);
+    if (!map || !Node.isObjectLiteralExpression(map)) continue;
+    for (const property of map.getProperties()) {
+      const key = implKey(property);
+      if (key === undefined || impls[group].has(key)) continue;
+      impls[group].set(key, classify$1(property, xs, group));
     }
   }
-  return undefined;
 }
-function getStringProperty(object, name) {
-  const property = object.getProperty(name);
-  if (!property || !Node.isPropertyAssignment(property)) return undefined;
-  const initializer = property.getInitializer();
-  return initializer && (Node.isStringLiteral(initializer) || Node.isNoSubstitutionTemplateLiteral(initializer)) ? initializer.getLiteralText() : undefined;
+
+/** Finds the `setup({...})` argument a `createMachine`/`createStateConfig` call is chained to. */
+function findSetupArgument(config) {
+  const call = config.getParent();
+  if (!Node.isCallExpression(call)) return undefined;
+  const expr = call.getExpression();
+  if (!Node.isPropertyAccessExpression(expr)) return undefined;
+  let receiver = expr.getExpression();
+  if (Node.isIdentifier(receiver)) {
+    const decl = receiver.getSymbol()?.getDeclarations().find(Node.isVariableDeclaration);
+    const init = decl?.getInitializer();
+    if (!init) return undefined;
+    receiver = init;
+  }
+  if (!Node.isCallExpression(receiver)) return undefined;
+  const callee = receiver.getExpression();
+  if (!Node.isIdentifier(callee) || callee.getText() !== 'setup') return undefined;
+  return receiver.getArguments()[0];
+}
+
+/** Named implementations visible to a machine config: its own top-level keys, then `setup`. */
+function collectImplementations(config, xs) {
+  const impls = {
+    actions: new Map(),
+    guards: new Map()
+  };
+  collectFrom(impls, config, xs);
+  collectFrom(impls, findSetupArgument(config), xs);
+  return impls;
+}
+
+/** What an identifier's in-file declaration is: a function, a plain value, or unknown. */
+function resolveIdentifier(id) {
+  const parent = id.getParent();
+  const symbol = Node.isShorthandPropertyAssignment(parent) ? parent.getValueSymbol() : id.getSymbol();
+  const decls = symbol?.getDeclarations() ?? [];
+  if (decls.length !== 1) return 'unknown';
+  const decl = decls[0];
+  if (Node.isFunctionDeclaration(decl)) return 'fn';
+  if (!Node.isVariableDeclaration(decl)) return 'unknown';
+  const list = decl.getParent();
+  if (Node.isVariableDeclarationList(list) && !(list.getFlags() & 2) /* NodeFlags.Const */) return 'unknown';
+  const init = decl.getInitializer();
+  if (!init) return 'unknown';
+  const value = unwrap(init);
+  if (isFunctionLike(value)) return 'fn';
+  if (Node.isObjectLiteralExpression(value) || Node.isArrayLiteralExpression(value) || Node.isStringLiteral(value) || Node.isNumericLiteral(value) || Node.isNoSubstitutionTemplateLiteral(value) || Node.isTemplateExpression(value)) return 'value';
+  return 'unknown';
+}
+
+/** Initializer of an identifier's single `const` declaration in this file. */
+function resolveConstInitializer(id) {
+  const decls = id.getSymbol()?.getDeclarations() ?? [];
+  if (decls.length !== 1 || !Node.isVariableDeclaration(decls[0])) return undefined;
+  const init = decls[0].getInitializer();
+  return init && unwrap(init);
 }
+function isReferenceIdentifier(id) {
+  const parent = id.getParent();
+  if (!parent) return false;
+  if ((Node.isPropertyAssignment(parent) || Node.isPropertySignature(parent) || Node.isMethodDeclaration(parent) || Node.isPropertyDeclaration(parent)) && parent.getNameNode() === id) return false;
+  if (Node.isPropertyAccessExpression(parent) && parent.getNameNode() === id) return false;
+  if (Node.isBindingElement(parent) && parent.getPropertyNameNode() === id) return false;
+  if (Node.isQualifiedName(parent) && parent.getRight() === id) return false;
+  if (Node.isTypeReference(parent)) return false;
+  return true;
+}
+
 /**
- * Collects the state ids that one machine config literal declares: explicit
- * state `id`s and, for `createMachine` configs, implicit ids (the path from
- * the root, prefixed by the machine id when one is set). Invoke and actor ids
- * are not state ids and are not collected.
+ * Names in `names` that `node` references while declared outside it (or not
+ * at all, such as globals). Generated bindings with these names would capture
+ * those references.
  */
-function collectStateIds(config, withImplicitIds) {
-  const ids = new Set();
-  function walk(stateConfig, implicitId) {
-    const explicitId = getStringProperty(stateConfig, 'id');
-    if (explicitId !== undefined) ids.add(explicitId);else if (withImplicitIds) ids.add(implicitId);
-    const states = stateConfig.getProperty('states');
-    if (!states || !Node.isPropertyAssignment(states)) return;
-    const statesObject = states.getInitializer();
-    if (!statesObject || !Node.isObjectLiteralExpression(statesObject)) return;
-    for (const state of statesObject.getProperties()) {
-      const key = getPropertyName(state);
-      if (key === undefined || !Node.isPropertyAssignment(state)) continue;
-      const child = state.getInitializer();
-      if (!child || !Node.isObjectLiteralExpression(child)) continue;
-      walk(child, implicitId ? `${implicitId}.${key}` : key);
+function outerReferences(node, names) {
+  const found = new Set();
+  const start = node.getPos();
+  const end = node.getEnd();
+  for (const id of node.getDescendantsOfKind(SyntaxKind.Identifier)) {
+    const text = id.getText();
+    if (!names.has(text) || !isReferenceIdentifier(id)) continue;
+    const parent = id.getParent();
+    const symbol = Node.isShorthandPropertyAssignment(parent) ? id.getProject().getTypeChecker().compilerObject.getShorthandAssignmentValueSymbol(parent.compilerNode) : id.getSymbol()?.compilerSymbol;
+    const decls = symbol?.declarations ?? [];
+    if (!decls.length || decls.some(decl => decl.pos < start || decl.end > end)) {
+      found.add(text);
     }
   }
-  walk(config, getStringProperty(config, 'id') ?? '');
-  return ids;
+  return found;
+}
+
+/** Key of an implementation map entry, resolving `[Enum.X]` computed keys. */
+function implKey(property) {
+  if ((Node.isPropertyAssignment(property) || Node.isMethodDeclaration(property)) && Node.isComputedPropertyName(property.getNameNode())) {
+    const name = property.getNameNode();
+    return Node.isComputedPropertyName(name) ? resolveStringConstant(name.getExpression()) : undefined;
+  }
+  return getKeyText$2(property);
 }
 
 /**
- * Finds the `createMachine(...)` or `createStateConfig(...)` config literal
- * that contains `node`, if any.
+ * The string an expression always evaluates to: a string literal, a `const`
+ * bound to one, a member of a string enum, or a property of a `const` object
+ * literal declared in this file.
  */
-function findEnclosingConfig(node, machineConfigs, stateConfigs) {
-  for (const ancestor of node.getAncestors()) {
-    if (!Node.isObjectLiteralExpression(ancestor)) continue;
-    if (machineConfigs.has(ancestor)) {
-      return {
-        config: ancestor,
-        withImplicitIds: true
-      };
-    }
-    if (stateConfigs.has(ancestor)) {
-      return {
-        config: ancestor,
-        withImplicitIds: false
-      };
-    }
+function resolveStringConstant(node) {
+  const value = unwrap(node);
+  if (Node.isStringLiteral(value) || Node.isNoSubstitutionTemplateLiteral(value)) return value.getLiteralText();
+  if (Node.isIdentifier(value)) {
+    const decls = value.getSymbol()?.getDeclarations() ?? [];
+    if (decls.length !== 1 || !Node.isVariableDeclaration(decls[0])) return;
+    if (!isConst(decls[0])) return;
+    const init = decls[0].getInitializer();
+    const literal = init && unwrap(init);
+    return literal && Node.isStringLiteral(literal) ? literal.getLiteralText() : undefined;
   }
-  return undefined;
+  if (!Node.isPropertyAccessExpression(value)) return undefined;
+  const object = value.getExpression();
+  if (!Node.isIdentifier(object)) return undefined;
+  const member = value.getName();
+  const decls = object.getSymbol()?.getDeclarations() ?? [];
+  if (decls.length !== 1) return undefined;
+  const decl = decls[0];
+  if (Node.isEnumDeclaration(decl)) {
+    const m = decl.getMember(member);
+    const init = m?.getInitializer();
+    return init && Node.isStringLiteral(init) ? init.getLiteralText() : undefined;
+  }
+  if (!Node.isVariableDeclaration(decl) || !isConst(decl)) return undefined;
+  const init = decl.getInitializer();
+  const literal = init && unwrap(init);
+  if (!literal || !Node.isObjectLiteralExpression(literal)) return undefined;
+  const property = literal.getProperties().find(candidate => getKeyText$2(candidate) === member);
+  if (!Node.isPropertyAssignment(property)) return undefined;
+  const v = unwrap(property.getInitializer());
+  return Node.isStringLiteral(v) || Node.isNoSubstitutionTemplateLiteral(v) ? v.getLiteralText() : undefined;
 }
-function isMatchArgument(literal) {
-  const call = literal.getParent();
-  if (!call || !Node.isCallExpression(call)) return false;
-  if (call.getArguments()[0] !== literal) return false;
-  const expression = call.getExpression();
-  const name = Node.isIdentifier(expression) ? expression.getText() : Node.isPropertyAccessExpression(expression) ? expression.getName() : undefined;
-  return !!name && MATCH_CALLS.has(name);
+function isConst(decl) {
+  const list = decl.getParent();
+  return Node.isVariableDeclarationList(list) && !!(list.getFlags() & 2) /* NodeFlags.Const */;
 }
-function isTargetValue(literal) {
-  let node = literal;
-  let parent = node.getParent();
-  if (parent && Node.isArrayLiteralExpression(parent)) {
-    node = parent;
-    parent = node.getParent();
+
+/**
+ * Free identifiers in `node` that are declared inside a function or block
+ * other than the module (so inlining the node elsewhere could not see them).
+ */
+function nonModuleReferences(node) {
+  const found = new Set();
+  const start = node.getPos();
+  const end = node.getEnd();
+  for (const id of node.getDescendantsOfKind(SyntaxKind.Identifier)) {
+    if (!isReferenceIdentifier(id)) continue;
+    const parent = id.getParent();
+    const symbol = Node.isShorthandPropertyAssignment(parent) ? id.getProject().getTypeChecker().compilerObject.getShorthandAssignmentValueSymbol(parent.compilerNode) : id.getSymbol()?.compilerSymbol;
+    for (const decl of symbol?.declarations ?? []) {
+      if (decl.pos >= start && decl.end <= end) continue;
+      if (decl.getSourceFile() !== node.getSourceFile().compilerNode) continue;
+      let scope = decl.parent;
+      while (scope && !ts.isSourceFile(scope)) {
+        if (ts.isFunctionLike(scope) || ts.isBlock(scope) || ts.isClassLike(scope) || ts.isModuleBlock(scope)) {
+          found.add(id.getText());
+          break;
+        }
+        scope = scope.parent;
+      }
+    }
   }
-  if (!parent || !Node.isPropertyAssignment(parent)) return false;
-  const name = getPropertyName(parent);
-  if (name && TARGET_KEYS.has(name)) return true;
-  // A bare string transition inside `on: { EVENT: '#a.b' }` or
-  // `after: { 1000: '#a.b' }`.
-  const container = parent.getParent();
-  const owner = container?.getParent();
-  const ownerName = owner ? getPropertyName(owner) : undefined;
-  return ownerName === 'on' || ownerName === 'after';
+  return [...found];
 }
 
+/** Action creators (besides `assign`) that lower to `enq` statements. */
+const ACTION_CREATORS = new Set(['raise', 'sendTo', 'sendParent', 'forwardTo', 'emit', 'log', 'cancel', 'stopChild', 'stop', 'spawnChild']);
 /**
- * Reports (does NOT transform) `#a.b` targets and `matches('#a.b')`/
- * `stateIn('#a.b')` references that the codemod cannot verify as whole state
- * ids. In v6, the text after `#` is an exact id and is never split into an
- * id followed by a path.
+ * `const x = assign(...)` (or another action creator) declared at module
+ * level and not exported, for an identifier used as an action.
  */
-const reportIdPathTargets = {
-  name: 'report-id-path-targets',
-  description: "Detect (report only) '#id.path' targets and matches('#id.path') references that may combine an id with a relative path, which v6 no longer resolves.",
-  apply(sourceFile) {
-    const notes = [];
-    const filePath = sourceFile.getFilePath();
-    const machineConfigs = new Set(findMachineConfigObjects(sourceFile, ['createMachine']));
-    const stateConfigs = new Set(findMachineConfigObjects(sourceFile, ['createStateConfig']));
-    const idsByConfig = new Map();
-    const literals = [...sourceFile.getDescendantsOfKind(SyntaxKind.StringLiteral), ...sourceFile.getDescendantsOfKind(SyntaxKind.NoSubstitutionTemplateLiteral)].sort((a, b) => a.getStart() - b.getStart());
+function resolveConstAction(id, xs) {
+  const decls = id.getSymbol()?.getDeclarations() ?? [];
+  if (decls.length !== 1) return undefined;
+  const decl = decls[0];
+  if (!Node.isVariableDeclaration(decl) || !isConst(decl)) return undefined;
+  const statement = decl.getVariableStatement();
+  if (!statement || !Node.isSourceFile(statement.getParent()) || statement.isExported() || statement.getDeclarations().length !== 1) return undefined;
+  const init = decl.getInitializer();
+  const call = init && unwrap(init);
+  const callee = call && xstateCallee(call, xs);
+  if (!callee || !(callee === 'assign' || callee === 'enqueueActions' || ACTION_CREATORS.has(callee))) return undefined;
+  return {
+    decl,
+    call: call,
+    callee
+  };
+}
+
+/** Whether a config value is a reference rather than written inline. */
+function isIndirect(node) {
+  const value = unwrap(node);
+  return Node.isIdentifier(value) && value.getText() !== 'undefined' || Node.isPropertyAccessExpression(value) || Node.isElementAccessExpression(value) || Node.isShorthandPropertyAssignment(value) || Node.isSpreadAssignment(value) || Node.isSpreadElement(value);
+}
+/**
+ * Resolves a config reference (identifier, shorthand property or spread) to
+ * the object/array literal or function of a module-level `const` in this file.
+ */
+function derefConfig(node) {
+  let value = unwrap(node);
+  let symbol;
+  if (Node.isShorthandPropertyAssignment(value)) {
+    symbol = value.getValueSymbol();
+  } else {
+    if (Node.isSpreadAssignment(value) || Node.isSpreadElement(value)) {
+      value = unwrap(value.getExpression());
+    }
+    if (!Node.isIdentifier(value)) return undefined;
+    symbol = value.getSymbol();
+  }
+  let decl;
+  for (let depth = 0; depth < 5; depth++) {
+    const decls = symbol?.getDeclarations() ?? [];
+    if (decls.length !== 1) return undefined;
+    const d = decls[0];
+    if (Node.isFunctionDeclaration(d)) return {
+      node: d,
+      decl: decl ?? d
+    };
+    if (!Node.isVariableDeclaration(d) || !isConst(d)) return undefined;
+    const statement = d.getVariableStatement();
+    if (!statement || !Node.isSourceFile(statement.getParent())) return undefined;
+    const init = d.getInitializer();
+    if (!init) return undefined;
+    decl ??= d;
+    value = unwrap(init);
+    if (!Node.isIdentifier(value)) break;
+    symbol = value.getSymbol();
+  }
+  if (Node.isObjectLiteralExpression(value) || Node.isArrayLiteralExpression(value) || isFunctionLike(value)) return {
+    node: value,
+    decl: decl
+  };
+  return undefined;
+}
+
+/**
+ * Whether every reference to a module const sits where a config value or a
+ * spread of one goes, so rewriting its literal in place is safe.
+ */
+function onlyConfigReferences(decl) {
+  if (!Node.isVariableDeclaration(decl)) return false;
+  const name = decl.getNameNode();
+  const symbol = name.getSymbol();
+  return decl.getSourceFile().getDescendantsOfKind(SyntaxKind.Identifier).filter(id => {
+    if (id === name || id.getText() !== name.getText()) return false;
+    const parent = id.getParent();
+    return (Node.isShorthandPropertyAssignment(parent) ? parent.getValueSymbol() : id.getSymbol()) === symbol;
+  }).every(id => {
+    const parent = id.getParent();
+    return Node.isShorthandPropertyAssignment(parent) || Node.isSpreadAssignment(parent) || Node.isPropertyAssignment(parent) && parent.getInitializer() === id || Node.isAsExpression(parent) || Node.isSatisfiesExpression(parent);
+  });
+}
+
+/**
+ * `name` in an actions map bound to a module `const name = assign(...)` whose
+ * only references are entries of implementation maps.
+ */
+function implConstAssign(id, xs) {
+  const parent = id.getParent();
+  const symbol = Node.isShorthandPropertyAssignment(parent) ? parent.getValueSymbol() : id.getSymbol();
+  const decls = symbol?.getDeclarations() ?? [];
+  if (decls.length !== 1) return undefined;
+  const nameId = Node.isVariableDeclaration(decls[0]) ? decls[0].getNameNode() : undefined;
+  if (!nameId) return undefined;
+  const found = resolveConstAction(nameId, xs);
+  if (!found || found.callee !== 'assign') return undefined;
+  const [arg, ...rest] = found.call.getArguments();
+  if (!arg || rest.length) return undefined;
+  const refsOk = id.getSourceFile().getDescendantsOfKind(SyntaxKind.Identifier).filter(r => r !== nameId && r.getText() === nameId.getText()).every(r => {
+    const p = r.getParent();
+    const s = Node.isShorthandPropertyAssignment(p) ? p.getValueSymbol() : r.getSymbol();
+    if (s !== symbol) return true;
+    let value = r;
+    while (Node.isAsExpression(value.getParent()) || Node.isSatisfiesExpression(value.getParent()) || Node.isParenthesizedExpression(value.getParent())) value = value.getParent();
+    const outer = value.getParent();
+    const owner = Node.isShorthandPropertyAssignment(p) ? p : Node.isPropertyAssignment(outer) && outer.getInitializer() === value ? outer : undefined;
+    const map = owner?.getParent()?.getParent();
+    return !!owner && Node.isPropertyAssignment(map) && getKeyText$2(map) === 'actions';
+  });
+  return refsOk ? {
+    assignArg: arg,
+    constDecl: found.decl
+  } : undefined;
+}
+
+/** The `'xstate'` export an identifier is a value import of, if any. */
+function xstateImportOf(id) {
+  if (!Node.isIdentifier(id)) return undefined;
+  for (const decl of id.getSymbol()?.getDeclarations() ?? []) {
+    if (!Node.isImportSpecifier(decl) || decl.isTypeOnly()) continue;
+    const imp = decl.getImportDeclaration();
+    if (imp.getModuleSpecifierValue() === 'xstate' && !imp.isTypeOnly()) {
+      return decl.getName();
+    }
+  }
+  return undefined;
+}
+function isXstateNamespace(id) {
+  if (!Node.isIdentifier(id)) return false;
+  return (id.getSymbol()?.getDeclarations() ?? []).some(decl => Node.isNamespaceImport(decl) && decl.getFirstAncestorByKind(SyntaxKind.ImportDeclaration)?.getModuleSpecifierValue() === 'xstate');
+}
+
+/** `xstate`'s `name` called as `name(...)` or `ns.name(...)`. */
+function callsXstate(call, names) {
+  if (!Node.isCallExpression(call)) return false;
+  const callee = call.getExpression();
+  if (Node.isIdentifier(callee)) {
+    return names.includes(xstateImportOf(callee) ?? '');
+  }
+  return Node.isPropertyAccessExpression(callee) && names.includes(callee.getName()) && isXstateNamespace(callee.getExpression());
+}
+
+/**
+ * Whether a config object is the first argument of xstate's `createMachine` /
+ * `createStateConfig`, directly or chained on xstate's `setup(...)`.
+ */
+function isXstateMachineCall(call) {
+  if (!Node.isCallExpression(call)) return false;
+  if (callsXstate(call, ['createMachine', 'createStateConfig'])) return true;
+  const callee = call.getExpression();
+  if (!Node.isPropertyAccessExpression(callee)) return false;
+  if (!['createMachine', 'createStateConfig'].includes(callee.getName())) return false;
+  let receiver = unwrap(callee.getExpression());
+  if (Node.isIdentifier(receiver)) {
+    const decl = receiver.getSymbol()?.getDeclarations().find(Node.isVariableDeclaration);
+    const init = decl?.getInitializer();
+    if (!init) return false;
+    receiver = unwrap(init);
+  }
+  return callsXstate(receiver, ['setup']);
+}
+
+/** Replaced by the local name of `matchesState` once the import is ensured. */
+const MATCHES_STATE = '__xstate_codemod_matchesState__';
+
+/** What v5's `enqueueActions` callback may destructure. */
+const ENQUEUE_ARGS = new Set(['enqueue', 'check', 'context', 'event', 'self', 'system']);
+const ENQUEUE_METHODS = new Set(['assign', 'raise', 'sendTo', 'sendParent', 'emit', 'log', 'cancel', 'stopChild', 'spawnChild']);
+
+/** Indentation of the line a node starts on. */
+function indentOf(node) {
+  const text = node.getSourceFile().getFullText();
+  const lineStart = text.lastIndexOf('\n', node.getStart() - 1) + 1;
+  return /^[ \t]*/.exec(text.slice(lineStart))[0];
+}
+
+/** The symbol a (possibly shorthand-property) identifier refers to. */
+function valueSymbol(id) {
+  const parent = id.getParent();
+  if (Node.isShorthandPropertyAssignment(parent)) {
+    return id.getProject().getTypeChecker().compilerObject.getShorthandAssignmentValueSymbol(parent.compilerNode);
+  }
+  return id.getSymbol()?.compilerSymbol;
+}
+
+/** `node`'s text with non-overlapping descendant ranges replaced. */
+function spliceText(node, replacements) {
+  const start = node.getStart();
+  let text = node.getText();
+  const inside = replacements.filter(r => r.node.getStart() >= start && r.node.getEnd() <= node.getEnd()).filter((r, _, all) => !all.some(o => o !== r && o.node.getStart() <= r.node.getStart() && o.node.getEnd() >= r.node.getEnd() && o.node !== r.node)).sort((a, b) => b.node.getStart() - a.node.getStart());
+  for (const r of inside) {
+    text = text.slice(0, r.node.getStart() - start) + r.text + text.slice(r.node.getEnd() - start);
+  }
+  return text;
+}
+
+/** Names v5 passed to actions and guards that the v6 `args` object also has. */
+const HOISTABLE = new Set(['context', 'event', 'self', 'system']);
+const RESERVED = new Set(['args', 'enq', 'context', 'patch']);
+const TRANSITION_KEYS = new Set(['target', 'actions', 'guard', 'reenter', 'description', 'meta']);
+/** `({ a, b }) => expr` (or `() => expr`) whose body can be substituted in place. */
+function inlineable(fn) {
+  if (!Node.isArrowFunction(fn) || fn.isAsync()) return undefined;
+  const body = fn.getBody();
+  if (Node.isBlock(body)) return undefined;
+  const params = fn.getParameters();
+  if (params.length === 0) return {
+    names: [],
+    body
+  };
+  if (params.length !== 1) return undefined;
+  const param = params[0];
+  if (param.getInitializer() || param.isRestParameter()) return undefined;
+  const pattern = param.getNameNode();
+  if (!Node.isObjectBindingPattern(pattern)) return undefined;
+  const names = [];
+  for (const element of pattern.getElements()) {
+    const name = element.getNameNode();
+    if (element.getPropertyNameNode() || element.getInitializer() || element.getDotDotDotToken() || !Node.isIdentifier(name) || !HOISTABLE.has(name.getText())) return undefined;
+    names.push(name.getText());
+  }
+  return {
+    names,
+    body
+  };
+}
+function isAtomic(node) {
+  return Node.isIdentifier(node) || Node.isPropertyAccessExpression(node) || Node.isElementAccessExpression(node) || Node.isCallExpression(node) || Node.isParenthesizedExpression(node) || Node.isStringLiteral(node) || Node.isNumericLiteral(node) || Node.isNoSubstitutionTemplateLiteral(node) || Node.isTrueLiteral(node) || Node.isFalseLiteral(node) || Node.isPrefixUnaryExpression(node);
+}
+/** A context patch: object-literal properties, or an expression evaluating to one. */
+
+class Branch {
+  constructor() {
+    this.entries = [];
+    this.assigned = false;
+    this.enqueued = false;
+    /** Patches written from nested control flow: always accumulate in `patch`. */
+    this.forcePatch = false;
+    /** Literal child ids spawned so far → index of the spawning entry. */
+    this.spawns = new Map();
+    /** An assigner received `spawn`, so child ids are unknown statically. */
+    this.spawnAssign = false;
+    /** A `stopChild('id')` was lowered to `args.children[id]`. */
+    this.stringStop = false;
+    /** Arguments text for guards evaluated against an earlier context. */
+    this.argsOverride = void 0;
+  }
+  argsObj() {
+    if (this.argsOverride) return this.argsOverride;
+    return this.assigned ? '{ ...args, context }' : 'args';
+  }
+  push(line, enqueues = true) {
+    this.entries.push(line);
+    if (enqueues) this.enqueued = true;
+  }
+  pushPatch(patch) {
+    this.entries.push(patch);
+    this.assigned = true;
+  }
+  /**
+   * Statement lines plus the `context` return field. Only the patch is
+   * returned, never the whole threaded context: v6 evaluates the transitions
+   * of parallel regions against the same context and merges their patches,
+   * so returning every key would undo a sibling region's update.
+   */
+  finish(fb) {
+    const patches = this.entries.filter(e => typeof e !== 'string');
+    if (!patches.length && !this.forcePatch) {
+      return {
+        lines: this.entries,
+        threaded: false
+      };
+    }
+    if (!this.forcePatch) {
+      // Nothing after the first assign reads `context`: the patches can be
+      // merged straight into the returned object (effects are queued anyway).
+      const first = this.entries.findIndex(e => typeof e !== 'string');
+      const reads = this.entries.slice(first + 1).some(e => /\bcontext\b/.test(typeof e === 'string' ? e : 'props' in e ? e.props : e.expr));
+      if (!reads) {
+        const merged = patches.length === 1 ? 'props' in patches[0] ? `{ ${patches[0].props} }` : patches[0].expr : `{ ${patches.map(p => 'props' in p ? p.props : `...${p.expr}`).join(', ')} }`;
+        return {
+          lines: this.entries.filter(e => typeof e === 'string'),
+          context: `context: ${merged}`,
+          threaded: false
+        };
+      }
+    }
+    fb.threaded = true;
+    return {
+      lines: ['let context = args.context;', 'let patch = {};', ...threadedLines(this.entries)],
+      context: 'context: patch',
+      threaded: true
+    };
+  }
+}
+function threadedLines(entries) {
+  return entries.flatMap(e => typeof e === 'string' ? [e] : ['props' in e ? `patch = { ...patch, ${e.props} };` : `patch = { ...patch, ...${e.expr} };`, 'context = { ...args.context, ...patch };']);
+}
+
+/** Builds one generated `(args, enq) => { ... }` function. */
+class FunctionBuilder {
+  /** Source text of `node`, with active renames applied. */
+  t(node) {
+    return this.renames.length ? spliceText(node, this.renames) : node.getText();
+  }
+  paren(node) {
+    return isAtomic(node) ? this.t(node) : `(${this.t(node)})`;
+  }
+
+  /** `params` of the named action being inlined, passed to its dynamic values. */
+
+  constructor(ctx, node) {
+    this.hoist = new Set();
+    /** Named definitions inlined into this function. */
+    this.inlinedDefs = new Set();
+    /** Module-level action consts called here, with the referencing identifiers. */
+    this.constRefs = new Map();
+    /** True when some branch keeps a running `context` and `patch`. */
+    this.threaded = false;
+    this.inline = void 0;
+    /** Identifier renames applied to source text this builder copies. */
+    this.renames = [];
+    this.paramsText = void 0;
+    this.ctx = void 0;
+    this.ctx = ctx;
+    const reserved = outerReferences(node, RESERVED);
+    if (reserved.size) {
+      skip(`references outer '${[...reserved].join("', '")}', which the generated function would shadow`);
+    }
+    this.inline = outerReferences(node, new Set(['event', 'self', 'system'])).size === 0;
+  }
+  inlined(fn) {
+    if (!this.inline) return undefined;
+    const result = inlineable(fn);
+    if (result) result.names.forEach(name => this.hoist.add(name));
+    return result;
+  }
+
+  /** A value v5 accepted either directly or as a function of the action args. */
+  dynamic(node, br, argsText = br.argsObj()) {
+    const value = unwrap(node);
+    if (isFunctionLike(value)) {
+      const inline = this.inlined(value);
+      const p = this.paramsText ? `, ${this.paramsText}` : '';
+      if (inline) return this.t(inline.body);
+      return `(${this.t(value)})(${argsText}${p})`;
+    }
+    if (Node.isIdentifier(value)) {
+      if (value.getText() === 'undefined') return 'undefined';
+      const kind = resolveIdentifier(value);
+      const p = this.paramsText ? `, ${this.paramsText}` : '';
+      if (kind === 'fn') return `${value.getText()}(${argsText}${p})`;
+      if (kind === 'value') return this.t(node);
+      return skip(`cannot tell whether '${value.getText()}' is a function`);
+    }
+    if (Node.isCallExpression(value) || Node.isNewExpression(value)) {
+      return skip(`'${value.getText()}' may evaluate to a function`);
+    }
+    return this.t(node);
+  }
+  options(node, br, keys) {
+    if (!node) return '';
+    const value = unwrap(node);
+    if (!Node.isObjectLiteralExpression(value)) {
+      return skip('options are not an object literal');
+    }
+    const parts = value.getProperties().map(property => {
+      const key = getKeyText$2(property);
+      if (!key || !keys.includes(key) || !Node.isPropertyAssignment(property)) {
+        return skip(`unsupported option '${property.getText()}'`);
+      }
+      return `${key}: ${this.dynamic(property.getInitializer(), br)}`;
+    });
+    return parts.length ? `, { ${parts.join(', ')} }` : '';
+  }
+
+  // ---- guards ---------------------------------------------------------------
+
+  guard(node, br) {
+    const value = unwrap(node);
+    const ref = Node.isIdentifier(value) ? undefined : nameRef(value);
+    if (ref) return this.namedGuard(ref, undefined, br);
+    if (Node.isObjectLiteralExpression(value)) {
+      const {
+        ref,
+        params
+      } = typeAndParams(value, 'guard');
+      return this.namedGuard(ref, params, br);
+    }
+    if (isFunctionLike(value)) {
+      const inline = this.inlined(value);
+      if (inline) {
+        return {
+          text: this.t(inline.body),
+          atomic: isAtomic(inline.body)
+        };
+      }
+      return {
+        text: `(${this.t(value)})(${br.argsObj()})`,
+        atomic: true
+      };
+    }
+    if (Node.isIdentifier(value)) {
+      if (resolveIdentifier(value) === 'fn') {
+        return {
+          text: `${value.getText()}(${br.argsObj()})`,
+          atomic: true
+        };
+      }
+      const named = resolveStringConstant(value);
+      if (named !== undefined) {
+        return this.namedGuard({
+          name: named,
+          access: access(named)
+        }, undefined, br);
+      }
+      return skip(`unresolved guard '${value.getText()}'`);
+    }
+    const callee = xstateCallee(value, this.ctx.xs);
+    if (callee && Node.isCallExpression(value)) {
+      const [arg, ...rest] = value.getArguments();
+      if (!arg || rest.length) return skip(`unsupported ${callee}(...) call`);
+      switch (callee) {
+        case 'and':
+        case 'or':
+          {
+            const list = unwrap(arg);
+            if (!Node.isArrayLiteralExpression(list)) {
+              return skip(`${callee}(...) argument is not an array literal`);
+            }
+            const guards = list.getElements().map(element => this.guard(element, br));
+            if (!guards.length) {
+              return {
+                text: callee === 'and' ? 'true' : 'false',
+                atomic: true
+              };
+            }
+            if (guards.length === 1) return guards[0];
+            return {
+              text: guards.map(g => g.atomic ? g.text : `(${g.text})`).join(callee === 'and' ? ' && ' : ' || '),
+              atomic: false
+            };
+          }
+        case 'not':
+          {
+            const inner = this.guard(arg, br);
+            return {
+              text: `!${inner.atomic ? inner.text : `(${inner.text})`}`,
+              atomic: true
+            };
+          }
+        case 'stateIn':
+          {
+            const state = unwrap(arg);
+            if (!(Node.isStringLiteral(state) && !state.getLiteralText().startsWith('#') || Node.isObjectLiteralExpression(state))) {
+              return skip('stateIn(...) argument is not a state value literal');
+            }
+            return {
+              text: `${MATCHES_STATE}(${state.getText()}, args.value)`,
+              atomic: true
+            };
+          }
+      }
+    }
+    return skip(`unsupported guard '${value.getText()}'`);
+  }
+
+  /** Throws unless a named definition can be inlined at a call site. */
+  inlineCheck(def, name) {
+    const expr = def.expr;
+    const local = nonModuleReferences(expr);
+    if (local.length) {
+      skip(`'${name}' references '${local.join("', '")}', which are not module-scope`);
+    }
+    const shadowed = outerReferences(expr, new Set([...RESERVED, ...HOISTABLE, 'params']));
+    if (shadowed.size) {
+      skip(`'${name}' references outer '${[...shadowed].join("', '")}', which the generated function would shadow`);
+    }
+  }
+  namedGuard(ref, params, br) {
+    const {
+      name
+    } = ref;
+    const def = this.ctx.impls.guards.get(name);
+    if (def?.kind === 'inline') {
+      if (params) return skip(`guard '${name}' is a combinator given params`);
+      this.inlineCheck(def, name);
+      this.inlinedDefs.add(def);
+      return this.guard(def.expr, br);
+    }
+    if (!def || def.kind !== 'fn') {
+      return skip(`guard '${name}' is not a function defined in this file`);
+    }
+    const p = params ? `, ${this.dynamic(params, br)}` : '';
+    return {
+      text: `args.guards${ref.access}(${br.argsObj()}${p})`,
+      atomic: true
+    };
+  }
+
+  // ---- actions --------------------------------------------------------------
+
+  /** True when the item writes context (an `assign`, inline or named). */
+  isAssign(node) {
+    const value = unwrap(node);
+    if (xstateCallee(value, this.ctx.xs) === 'assign') return true;
+    if (Node.isIdentifier(value)) {
+      const constAction = resolveConstAction(value, this.ctx.xs);
+      if (constAction?.callee === 'assign') {
+        return !this.ctx.disabledConsts.has(constAction.decl);
+      }
+    }
+    const name = Node.isObjectLiteralExpression(value) ? nameRef(getInit(value, 'type'))?.name : Node.isIdentifier(value) ? undefined : nameRef(value)?.name;
+    return !!name && this.ctx.impls.actions.get(name)?.kind === 'assign';
+  }
+  actions(node, br) {
+    if (!node) return;
+    const value = unwrap(node);
+    const items = Node.isArrayLiteralExpression(value) ? value.getElements() : [value];
+    let lastAssign = -1;
+    items.forEach((item, i) => {
+      if (this.isAssign(item)) lastAssign = i;
+    });
+    items.forEach((item, i) => {
+      for (const comment of leadingComments(item)) br.push(comment, false);
+      this.action(item, br, i > lastAssign);
+    });
+  }
+  action(node, br, contextIsFinal) {
+    const value = unwrap(node);
+    const ref = Node.isIdentifier(value) ? undefined : nameRef(value);
+    if (ref) return this.namedAction(ref, undefined, br);
+    if (Node.isObjectLiteralExpression(value)) {
+      const {
+        ref,
+        params
+      } = typeAndParams(value, 'action');
+      return this.namedAction(ref, params, br);
+    }
+    if (Node.isIdentifier(value)) {
+      const named = resolveStringConstant(value);
+      if (named !== undefined) {
+        return this.namedAction({
+          name: named,
+          access: access(named)
+        }, undefined, br);
+      }
+      const constAction = resolveConstAction(value, this.ctx.xs);
+      if (constAction && !this.ctx.disabledConsts.has(constAction.decl)) {
+        const refs = this.constRefs.get(constAction.decl) ?? [];
+        refs.push(value);
+        this.constRefs.set(constAction.decl, refs);
+        if (constAction.callee === 'assign') {
+          const argsText = mentionsSpawn(constAction.call) ? spawnArgs(br) : br.argsObj();
+          return br.pushPatch({
+            expr: `${value.getText()}(${argsText})`
+          });
+        }
+        return br.push(`${value.getText()}(${br.argsObj()}, enq);`);
+      }
+      if (resolveIdentifier(value) !== 'fn') {
+        return skip(`unresolved action '${value.getText()}'`);
+      }
+      return br.push(`enq(${value.getText()}, ${br.argsObj()});`);
+    }
+    if (isFunctionLike(value)) {
+      const candidate = inlineable(value);
+      if (candidate && (contextIsFinal || !candidate.names.includes('context'))) {
+        const inline = this.inlined(value);
+        if (inline) return br.push(`enq(() => ${this.t(inline.body)});`);
+      }
+      return br.push(`enq(${this.t(value)}, ${br.argsObj()});`);
+    }
+    const callee = xstateCallee(value, this.ctx.xs);
+    if (!callee || !Node.isCallExpression(value)) {
+      return skip(`unsupported action '${value.getText()}'`);
+    }
+    return this.creator(callee, value.getArguments(), br);
+  }
+
+  /** Rule C for `callee(...args)`, an action creator call. */
+  creator(callee, args, br) {
+    const arity = (min, max) => {
+      if (args.length < min || args.length > max) {
+        skip(`unsupported ${callee}(...) arity`);
+      }
+    };
+    switch (callee) {
+      case 'assign':
+        arity(1, 1);
+        return this.assign(args[0], br);
+      case 'raise':
+        arity(1, 2);
+        return br.push(`enq.raise(${this.dynamic(args[0], br)}${this.options(args[1], br, ['delay', 'id'])});`);
+      case 'sendTo':
+        arity(2, 3);
+        return br.push(`enq.sendTo(${this.target(args[0], br)}, ${this.dynamic(args[1], br)}${this.options(args[2], br, ['delay', 'id'])});`);
+      case 'sendParent':
+        arity(1, 2);
+        return br.push(`enq.sendTo(args.parent, ${this.dynamic(args[0], br)}${this.options(args[1], br, ['delay', 'id'])});`);
+      case 'forwardTo':
+        arity(1, 2);
+        return br.push(`enq.sendTo(${this.target(args[0], br)}, args.event${this.options(args[1], br, ['delay', 'id'])});`);
+      case 'emit':
+        arity(1, 1);
+        return br.push(`enq.emit(${this.dynamic(args[0], br)});`);
+      case 'log':
+        {
+          arity(0, 2);
+          const logged = args[0] ? this.dynamic(args[0], br) : `{ context: ${br.assigned ? 'context' : 'args.context'}, event: args.event }`;
+          const label = args[1];
+          if (label && !Node.isStringLiteral(unwrap(label))) {
+            return skip('log label is not a string literal');
+          }
+          return br.push(label ? `enq.log(${label.getText()}, ${logged});` : `enq.log(${logged});`);
+        }
+      case 'cancel':
+        arity(1, 1);
+        return br.push(`enq.cancel(${this.dynamic(args[0], br)});`);
+      case 'stop':
+      case 'stopChild':
+        {
+          arity(1, 1);
+          const target = unwrap(args[0]);
+          if (!Node.isStringLiteral(target)) {
+            return br.push(`enq.stop(${this.dynamic(args[0], br)});`);
+          }
+          if (br.spawnAssign) {
+            return skip('stopChild by id after an assign that spawns: the child may not exist in args.children yet');
+          }
+          const at = br.spawns.get(target.getLiteralText());
+          if (at !== undefined) {
+            // v5 adds spawned children immediately; v6 queues the spawn, so
+            // stop the ref it returns instead of reading args.children.
+            const line = br.entries[at];
+            const name = `child${at}`;
+            if (line.startsWith('enq.spawn(')) {
+              br.entries[at] = `const ${name} = ${line}`;
+            }
+            return br.push(`enq.stop(${name});`);
+          }
+          br.stringStop = true;
+          return br.push(`enq.stop(args.children[${target.getText()}]);`);
+        }
+      case 'spawnChild':
+        {
+          arity(1, 2);
+          const src = unwrap(args[0]);
+          if (!Node.isStringLiteral(src) && !Node.isIdentifier(src)) {
+            return skip('spawnChild source is not a name or identifier');
+          }
+          br.push(`enq.spawn(${args[0].getText()}${this.options(args[1], br, ['id', 'input'])});`);
+          const options = args[1] && unwrap(args[1]);
+          const id = options && Node.isObjectLiteralExpression(options) && getInit(options, 'id');
+          const idValue = id && unwrap(id);
+          if (idValue && Node.isStringLiteral(idValue)) {
+            br.spawns.set(idValue.getLiteralText(), br.entries.length - 1);
+          }
+          return;
+        }
+      case 'enqueueActions':
+        arity(1, 1);
+        return this.enqueueActions(args[0], br);
+    }
+    return skip(`'${callee}(...)' cannot be lowered`);
+  }
+
+  /**
+   * `enqueueActions(({ enqueue, check, ... }, params) => BODY)`: BODY is kept
+   * with every `enqueue...(...)` call replaced by its rule-C statements and
+   * every `check(g)` by its rule-B expression. v5's `context` and `check` see
+   * the context from before the callback, even after `enqueue.assign`.
+   */
+  enqueueActions(node, br) {
+    const fn = unwrap(node);
+    if (!Node.isArrowFunction(fn) && !Node.isFunctionExpression(fn)) {
+      return skip('enqueueActions argument is not an inline function');
+    }
+    if (fn.isAsync()) return skip('enqueueActions callback is async');
+    const [first, second, ...more] = fn.getParameters();
+    if (more.length) return skip('enqueueActions callback has extra params');
+    const bound = new Map();
+    if (first) {
+      const pattern = first.getNameNode();
+      if (!Node.isObjectBindingPattern(pattern) || first.getInitializer()) {
+        return skip('enqueueActions callback does not destructure its argument');
+      }
+      for (const element of pattern.getElements()) {
+        const name = element.getNameNode();
+        const key = (element.getPropertyNameNode() ?? name).getText();
+        if (element.getPropertyNameNode() || element.getInitializer() || element.getDotDotDotToken() || !Node.isIdentifier(name) || !ENQUEUE_ARGS.has(key)) {
+          return skip(`unsupported enqueueActions binding '${element.getText()}'`);
+        }
+        bound.set(key, name);
+      }
+    }
+    let paramsName;
+    if (second) {
+      const name = second.getNameNode();
+      if (!Node.isIdentifier(name) || second.getInitializer()) {
+        return skip('enqueueActions params is not a plain identifier');
+      }
+      paramsName = name.getText();
+    }
+    const refsTo = key => {
+      const id = bound.get(key);
+      if (!id) return [];
+      const symbol = valueSymbol(id);
+      return fn.getDescendantsOfKind(SyntaxKind.Identifier).filter(r => r !== id && valueSymbol(r) === symbol);
+    };
+    // Calls to replace: enqueue(...), enqueue.x(...), check(...).
+    const calls = [];
+    for (const ref of refsTo('enqueue')) {
+      const parent = ref.getParentOrThrow();
+      if (Node.isCallExpression(parent) && parent.getExpression() === ref) {
+        calls.push({
+          call: parent,
+          kind: 'enqueue',
+          args: parent.getArguments()
+        });
+        continue;
+      }
+      const call = parent.getParent();
+      if (Node.isPropertyAccessExpression(parent) && Node.isCallExpression(call) && call.getExpression() === parent && ENQUEUE_METHODS.has(parent.getName())) {
+        calls.push({
+          call,
+          kind: parent.getName(),
+          args: call.getArguments()
+        });
+        continue;
+      }
+      return skip('enqueueActions uses `enqueue` other than by calling it');
+    }
+    for (const ref of refsTo('check')) {
+      const parent = ref.getParentOrThrow();
+      if (!Node.isCallExpression(parent) || parent.getExpression() !== ref || parent.getArguments().length !== 1) {
+        return skip('enqueueActions uses `check` other than as check(guard)');
+      }
+      calls.push({
+        call: parent,
+        kind: 'check',
+        args: parent.getArguments()
+      });
+    }
+    const within = (inner, outer) => inner !== outer && inner.getStart() >= outer.getStart() && inner.getEnd() <= outer.getEnd();
+    if (calls.some(a => calls.some(b => within(a.call, b.call)))) {
+      return skip('enqueueActions nests enqueue/check calls');
+    }
+    const body = fn.getBody();
+    if (Node.isBlock(body) && body.getDescendantsOfKind(SyntaxKind.ReturnStatement).some(r => r.getFirstAncestor(a => Node.isArrowFunction(a) || Node.isFunctionExpression(a) || Node.isFunctionDeclaration(a) || Node.isMethodDeclaration(a)) === fn)) {
+      return skip('enqueueActions callback returns early');
+    }
+    const hoistable = ['event', 'self', 'system'].filter(k => refsTo(k).length);
+    if (hoistable.length && !this.inline) {
+      return skip('enqueueActions reads event/self/system shadowed outside');
+    }
+    const assigns = calls.some(c => c.kind === 'assign' || c.kind === 'enqueue' && c.args[0] && this.isAssign(c.args[0]));
+    const contextRefs = refsTo('context');
+    const needSnapshot = contextRefs.length > 0 && (assigns || br.assigned);
+    for (const k of hoistable) this.hoist.add(k);
+    if (contextRefs.length && !needSnapshot) {
+      if (!this.inline) {
+        return skip('enqueueActions reads `context` shadowed outside');
+      }
+      this.hoist.add('context');
+    }
+    const fnText = fn.getText();
+    let snapshot = 'contextBefore';
+    for (let i = 2; new RegExp(`\\b${snapshot}\\b`).test(fnText); i++) {
+      snapshot = `contextBefore${i}`;
+    }
+    const snapshotValue = br.assigned ? 'context' : 'args.context';
+    if (assigns) {
+      br.assigned = true;
+      br.forcePatch = true;
+      this.threaded = true;
+    }
+    const replacements = [];
+    if (needSnapshot) {
+      for (const r of contextRefs) {
+        replacements.push({
+          node: r,
+          text: Node.isShorthandPropertyAssignment(r.getParent()) ? `context: ${snapshot}` : snapshot
+        });
+      }
+    }
+    // Source text copied into enqueue/check lowering sees the renames too.
+    const savedRenames = this.renames;
+    this.renames = [...savedRenames, ...replacements];
+    for (const {
+      call,
+      kind,
+      args
+    } of calls) {
+      if (kind === 'check') {
+        const cb = new Branch();
+        cb.argsOverride = needSnapshot ? `{ ...args, context: ${snapshot} }` : snapshotValue === 'context' ? '{ ...args, context }' : 'args';
+        const saved = this.inline;
+        if (needSnapshot) this.inline = false;
+        try {
+          const g = this.guard(args[0], cb);
+          replacements.push({
+            node: call,
+            text: g.atomic ? g.text : `(${g.text})`
+          });
+        } finally {
+          this.inline = saved;
+        }
+        continue;
+      }
+      const sub = new Branch();
+      sub.assigned = br.assigned;
+      if (kind === 'enqueue') {
+        if (args.length !== 1) return skip('enqueue(...) takes one action');
+        this.action(args[0], sub, false);
+      } else {
+        this.creator(kind, args, sub);
+      }
+      if (sub.enqueued) br.enqueued = true;
+      const lines = threadedLines(sub.entries);
+      const statement = call.getParent();
+      if (Node.isExpressionStatement(statement) || statement === fn) {
+        const target = statement === fn ? call : statement;
+        const indent = indentOf(target);
+        replacements.push({
+          node: target,
+          text: lines.join(`\n${indent}`)
+        });
+      } else if (lines.length === 1 && lines[0].endsWith(';') && typeof sub.entries[0] === 'string') {
+        replacements.push({
+          node: call,
+          text: lines[0].slice(0, -1)
+        });
+      } else {
+        return skip('enqueue call is not a statement');
+      }
+    }
+    this.renames = savedRenames;
+    const pre = [];
+    if (needSnapshot) pre.push(`const ${snapshot} = ${snapshotValue};`);
+    if (paramsName && fn.getDescendantsOfKind(SyntaxKind.Identifier).some(i => i.getText() === paramsName && i !== second.getNameNode())) {
+      pre.push(`const ${paramsName} = ${this.paramsText ?? 'undefined'};`);
+    }
+    const statements = Node.isBlock(body) ? body.getStatements() : [body];
+    const texts = statements.map(st => {
+      const text = spliceText(st, replacements);
+      const indent = indentOf(st);
+      const lines = text.split('\n').map(l => l.startsWith(indent) ? l.slice(indent.length) : l);
+      return Node.isBlock(body) || replacements.some(r => r.node === body) ? lines : [`${lines.join('\n')};`];
+    });
+    const declares = statements.some(st => Node.isVariableStatement(st) || Node.isFunctionDeclaration(st) || Node.isClassDeclaration(st));
+    const flat = texts.flatMap(t => t.flatMap(l => l.split('\n')));
+    if (pre.length || declares) {
+      br.push('{', false);
+      for (const line of [...pre, ...flat]) br.push(`  ${line}`, false);
+      br.push('}', false);
+    } else {
+      for (const line of flat) br.push(line, false);
+    }
+  }
+  target(node, br) {
+    const value = unwrap(node);
+    if (Node.isStringLiteral(value)) {
+      if (value.getLiteralText().startsWith('#')) {
+        return skip(`send target '${value.getLiteralText()}' is a system id`);
+      }
+      return value.getText();
+    }
+    return this.dynamic(node, br);
+  }
+  namedAction(ref, params, br) {
+    const {
+      name
+    } = ref;
+    const def = this.ctx.impls.actions.get(name);
+    if (!def) return skip(`action '${name}' is not defined in this file`);
+    if (def.kind === 'inline') {
+      this.inlineCheck(def, name);
+      this.inlinedDefs.add(def);
+      const saved = this.paramsText;
+      this.paramsText = params ? this.dynamic(params, br) : undefined;
+      try {
+        return this.action(def.expr, br, false);
+      } finally {
+        this.paramsText = saved;
+      }
+    }
+    if (def.kind === 'fn') {
+      const p = params ? `, ${this.dynamic(params, br)}` : '';
+      return br.push(`enq(args.actions${ref.access}, ${br.argsObj()}${p});`);
+    }
+    if (def.kind === 'assign') {
+      const argsText = mentionsSpawn(def.assignArg) ? spawnArgs(br) : br.argsObj();
+      const p = params ? `, ${this.dynamic(params, br, argsText)}` : '';
+      this.ctx.assignDefs.add(def);
+      return br.pushPatch({
+        expr: `args.actions${ref.access}(${argsText}${p})`
+      });
+    }
+    return skip(`action '${name}' is not a plain function or assign`);
+  }
+  assign(node, br) {
+    const value = unwrap(node);
+    const argsText = mentionsSpawn(node) ? spawnArgs(br) : br.argsObj();
+    if (Node.isObjectLiteralExpression(value)) {
+      const props = value.getProperties().map(property => {
+        if (Node.isShorthandPropertyAssignment(property)) {
+          return this.t(property);
+        }
+        const key = getKeyText$2(property);
+        if (!Node.isPropertyAssignment(property) || key === undefined) {
+          return skip(`unsupported assign property '${property.getText()}'`);
+        }
+        return `${property.getNameNode().getText()}: ${this.dynamic(property.getInitializer(), br, argsText)}`;
+      });
+      return br.pushPatch({
+        props: props.join(', ')
+      });
+    }
+    if (isFunctionLike(value)) {
+      const inline = this.inlined(value);
+      const body = inline && unwrap(inline.body);
+      if (body && Node.isObjectLiteralExpression(body)) {
+        return br.pushPatch({
+          props: body.getProperties().map(p => this.t(p)).join(', ')
+        });
+      }
+      if (inline) return br.pushPatch({
+        expr: this.paren(inline.body)
+      });
+      return br.pushPatch({
+        expr: `(${this.t(value)})(${argsText})`
+      });
+    }
+    if (Node.isIdentifier(value) && resolveIdentifier(value) === 'fn') {
+      return br.pushPatch({
+        expr: `${value.getText()}(${argsText})`
+      });
+    }
+    if (Node.isIdentifier(value) && isPlainObjectConst(value)) {
+      return br.pushPatch({
+        expr: value.getText()
+      });
+    }
+    return skip(`unsupported assign argument '${value.getText()}'`);
+  }
+
+  // ---- assembly -------------------------------------------------------------
+
+  /**
+   * Header plus body. Hoisted names used once as `name.x` are written as
+   * `args.name.x` instead. `guard` goes first when it needs no hoisted name.
+   * `dropContext`: a function-scope `let context` exists, so `context` is not
+   * destructured.
+   */
+  assemble(body, dropContext, guard) {
+    const all = guard ? [guard, ...body] : body;
+    const names = [];
+    let lines = all;
+    for (const name of [...this.hoist].sort()) {
+      if (dropContext && name === 'context') continue;
+      // Property keys such as the returned `context:` are not references.
+      const re = new RegExp(`(?<![\\w$])(?<!(?:^|[^.])\\.)(?<![{,]\\s*)${name}(?![\\w$])|(?<![\\w$])(?<!(?:^|[^.])\\.)${name}(?![\\w$])(?!\\s*:)`, 'g');
+      const count = lines.reduce((n, l) => n + (l.match(re)?.length ?? 0), 0);
+      if (count === 0) continue;
+      const single = new RegExp(`(?<![\\w$])(?<!(?:^|[^.])\\.)${name}(?=\\.)`);
+      if (count === 1 && lines.some(l => single.test(l))) {
+        lines = lines.map(l => l.replace(single, `args.${name}`));
+        continue;
+      }
+      names.push(name);
+    }
+    const header = names.length ? [`const { ${names.join(', ')} } = args;`] : [];
+    if (!guard) return [...header, ...lines];
+    const [g, ...rest] = lines;
+    const usesHoisted = names.some(n => new RegExp(`(?<![\\w$])(?<!(?:^|[^.])\\.)${n}(?![\\w$])`).test(g));
+    return usesHoisted ? [...header, g, ...rest] : [g, ...header, ...rest];
+  }
+}
+
+/** A reference to a named implementation: its name and how to access it. */
+
+function nameRef(node) {
+  if (!node) return undefined;
+  const value = unwrap(node);
+  const name = resolveStringConstant(value);
+  if (name === undefined) return undefined;
+  return Node.isStringLiteral(value) || Node.isNoSubstitutionTemplateLiteral(value) ? {
+    name,
+    access: access(name)
+  } : {
+    name,
+    access: `[${value.getText()}]`
+  };
+}
+function getInit(object, key) {
+  const property = object.getProperties().find(p => getKeyText$2(p) === key);
+  return Node.isPropertyAssignment(property) ? property.getInitializer() : undefined;
+}
+function typeAndParams(object, what) {
+  for (const property of object.getProperties()) {
+    const key = getKeyText$2(property);
+    if (!Node.isPropertyAssignment(property) || key !== 'type' && key !== 'params') {
+      return skip(`unsupported ${what} object key '${property.getText()}'`);
+    }
+  }
+  const ref = nameRef(getInit(object, 'type'));
+  if (!ref) return skip(`${what} object has no string 'type'`);
+  return {
+    ref,
+    params: getInit(object, 'params')
+  };
+}
+function mentionsSpawn(node) {
+  return /\bspawn\b/.test(node.getText());
+}
+function spawnArgs(br) {
+  if (br.stringStop) {
+    skip('an assign spawns after stopChild by id; child ids are not static');
+  }
+  br.spawnAssign = true;
+  return br.assigned ? '{ ...args, context, spawn: enq.spawn }' : '{ ...args, spawn: enq.spawn }';
+}
+
+/** `//` and `/* *\/` comments directly before a node, as written. */
+function leadingComments(node) {
+  const text = node.getSourceFile().getFullText();
+  return (ts.getLeadingCommentRanges(text, node.getPos()) ?? []).map(range => text.slice(range.pos, range.end));
+}
+
+// ---- transitions ------------------------------------------------------------
+
+function hasLowerableKeys(object) {
+  return Node.isObjectLiteralExpression(object) && object.getProperties().some(property => {
+    const key = getKeyText$2(property);
+    return key === 'actions' || key === 'guard' || key === 'cond';
+  });
+}
+function lowerBranch(fb, object) {
+  const comments = [];
+  let description;
+  for (const property of object.getProperties()) {
+    const key = getKeyText$2(property);
+    if (key === 'cond') {
+      return skip('`cond` is a v4 key that v5 rejects in development and ignores in production');
+    }
+    if (!key || !TRANSITION_KEYS.has(key) || !Node.isPropertyAssignment(property)) {
+      return skip(`unsupported transition key '${property.getText()}'`);
+    }
+    comments.push(...leadingComments(property));
+    if (key === 'description') {
+      const value = unwrap(property.getInitializer());
+      description = Node.isStringLiteral(value) || Node.isNoSubstitutionTemplateLiteral(value) ? value.getLiteralText() : value.getText();
+    }
+  }
+  const br = new Branch();
+  const guardNode = getInit(object, 'guard');
+  const guard = guardNode ? fb.guard(guardNode, br) : undefined;
+  fb.actions(getInit(object, 'actions'), br);
+  const returnFields = [];
+  for (const key of ['target', 'reenter', 'meta']) {
+    const value = getInit(object, key);
+    if (value) returnFields.push(`${key}: ${value.getText()}`);
+  }
+  const {
+    lines,
+    context,
+    threaded
+  } = br.finish(fb);
+  if (context) returnFields.push(context);
+  return {
+    guard,
+    description,
+    comments,
+    lines,
+    enqueued: br.enqueued,
+    returnFields,
+    threaded
+  };
+}
+const descriptionComments = description => description === undefined ? [] : description.split(/\r?\n/).map(line => `// ${line}`.trimEnd());
+const returnStatement = fields => fields.length ? `return { ${fields.join(', ')} };` : 'return {};';
+const DESCRIPTION_NOTE = 'dropped a transition `description` (kept as a comment); v6 transition functions carry no description';
+/** Rewrites `const x = raise(...)` (or another creator) as `(args, enq) => {...}`. */
+function lowerConstCreator(ctx, call) {
+  try {
+    const fb = new FunctionBuilder(ctx, call);
+    const br = new Branch();
+    fb.actions(call, br);
+    const {
+      lines,
+      context
+    } = br.finish(fb);
+    if (context) return undefined;
+    return ['(args, enq) => {', ...fb.assemble(lines, false).map(l => `  ${l}`), '}'].join('\n');
+  } catch (error) {
+    if (error instanceof Skip) return undefined;
+    throw error;
+  }
+}
+
+/** Lowers a transition object or array to a function body. */
+function lowerTransition(ctx, value) {
+  const fb = new FunctionBuilder(ctx, value);
+  const notes = [];
+  if (Node.isObjectLiteralExpression(value)) {
+    const b = lowerBranch(fb, value);
+    if (b.description !== undefined) notes.push(DESCRIPTION_NOTE);
+    const guardLine = b.guard ? `if (!${b.guard.atomic ? b.guard.text : `(${b.guard.text})`}) return;` : undefined;
+    const body = [...b.lines];
+    if (b.returnFields.length || !b.enqueued) {
+      body.push(returnStatement(b.returnFields));
+    }
+    return {
+      body: [...b.comments, ...fb.assemble(body, b.threaded, guardLine)],
+      above: descriptionComments(b.description),
+      notes,
+      inlined: fb.inlinedDefs,
+      constRefs: fb.constRefs
+    };
+  }
+  if (!Node.isArrayLiteralExpression(value)) {
+    return skip('transition is not an object or array');
+  }
+  const body = [];
+  const elements = value.getElements();
+  for (let i = 0; i < elements.length; i++) {
+    const element = unwrap(elements[i]);
+    if (!Node.isObjectLiteralExpression(element)) {
+      return skip('transition array element is not an object literal');
+    }
+    const b = lowerBranch(fb, element);
+    if (b.description !== undefined) notes.push(DESCRIPTION_NOTE);
+    const inner = [...leadingComments(elements[i]), ...descriptionComments(b.description), ...b.comments, ...b.lines, returnStatement(b.returnFields)];
+    if (!b.guard) {
+      if (b.threaded) {
+        body.push('{', ...inner.map(line => `  ${line}`), '}');
+      } else {
+        body.push(...inner);
+      }
+      if (i < elements.length - 1) {
+        notes.push(`dropped ${elements.length - 1 - i} unreachable transition candidate(s) after an unguarded one`);
+      }
+      break;
+    }
+    body.push(`if (${b.guard.text}) {`, ...inner.map(line => `  ${line}`), '}');
+  }
+  return {
+    body: fb.assemble(body, false),
+    above: [],
+    notes,
+    inlined: fb.inlinedDefs,
+    constRefs: fb.constRefs
+  };
+}
+
+/** Lowers an `entry`/`exit` value to a function body. */
+function lowerEntryExit(ctx, value) {
+  const fb = new FunctionBuilder(ctx, value);
+  const br = new Branch();
+  fb.actions(value, br);
+  const {
+    lines,
+    context,
+    threaded
+  } = br.finish(fb);
+  const body = [...lines];
+  if (context) body.push(`return { ${context} };`);
+  return {
+    body: fb.assemble(body, threaded),
+    above: [],
+    notes: [],
+    inlined: fb.inlinedDefs,
+    constRefs: fb.constRefs
+  };
+}
+
+/** Rewrites a named `assign(...)` definition as a patch-returning function. */
+function lowerAssignDefinition(def) {
+  const arg = unwrap(def.assignArg);
+  if (Node.isIdentifier(arg) && isPlainObjectConst(arg)) {
+    return `() => ${arg.getText()}`;
+  }
+  if (isFunctionLike(arg)) return def.assignArg.getText();
+  if (Node.isIdentifier(arg) && resolveIdentifier(arg) === 'fn') {
+    return arg.getText();
+  }
+  if (!Node.isObjectLiteralExpression(arg)) return undefined;
+  const props = arg.getProperties();
+  if (props.some(p => !Node.isPropertyAssignment(p) && !Node.isShorthandPropertyAssignment(p))) return undefined;
+  const inlineOk = outerReferences(arg, new Set([...HOISTABLE, 'args', 'params'])).size === 0;
+  const names = new Set();
+  const inlined = props.map(p => {
+    if (!Node.isPropertyAssignment(p)) return p.getText();
+    const value = unwrap(p.getInitializer());
+    if (!isFunctionLike(value)) return p.getText();
+    const inline = inlineOk ? inlineable(value) : undefined;
+    if (!inline) return undefined;
+    inline.names.forEach(n => names.add(n));
+    return `${p.getNameNode().getText()}: ${inline.body.getText()}`;
+  });
+  if (inlined.every(p => p !== undefined)) {
+    const param = names.size ? `{ ${[...names].sort().join(', ')} }` : '';
+    return `(${param}) => ({ ${inlined.join(', ')} })`;
+  }
+  if (outerReferences(arg, new Set(['args', 'params'])).size) return undefined;
+  const generic = props.map(p => {
+    if (!Node.isPropertyAssignment(p)) return p.getText();
+    const value = unwrap(p.getInitializer());
+    if (!isFunctionLike(value)) return p.getText();
+    return `${p.getNameNode().getText()}: (${value.getText()})(args, params)`;
+  });
+  return `(args, params) => ({ ${generic.join(', ')} })`;
+}
+
+/**
+ * A module-level `const` object literal with no function, spread or method
+ * members: `assign(x)` then merges exactly `x`.
+ */
+function isPlainObjectConst(id) {
+  const decls = id.getSymbol()?.getDeclarations() ?? [];
+  if (decls.length !== 1 || !Node.isVariableDeclaration(decls[0])) return false;
+  const decl = decls[0];
+  const list = decl.getParent();
+  const statement = decl.getVariableStatement();
+  if (!Node.isVariableDeclarationList(list) || !(list.getFlags() & 2) || !statement || !Node.isSourceFile(statement.getParent())) return false;
+  const init = decl.getInitializer();
+  const value = init && unwrap(init);
+  return !!value && Node.isObjectLiteralExpression(value) && value.getProperties().every(p => Node.isPropertyAssignment(p) && !isFunctionLike(unwrap(p.getInitializer())));
+}
+
+const IMPLEMENTATION_KEYS = new Set(['actions', 'guards', 'actors', 'delays']);
+
+/** Action creators and helpers this transform can leave unreferenced. */
+const REMOVABLE_IMPORTS = new Set(['assign', 'raise', 'sendTo', 'sendParent', 'forwardTo', 'emit', 'log', 'cancel', 'stopChild', 'stop', 'spawnChild', 'enqueueActions', 'and', 'or', 'not', 'stateIn', 'fromPromise']);
+function applyEdits(sourceFile, edits) {
+  if (!edits.length) return false;
+  // Keep outermost edits only; nested ones are part of a replaced range.
+  const sorted = [...edits].sort((a, b) => a.start - b.start || b.end - a.end);
+  const kept = [];
+  for (const edit of sorted) {
+    const last = kept[kept.length - 1];
+    if (last && edit.start < last.end) continue;
+    kept.push(edit);
+  }
+  let text = sourceFile.getFullText();
+  for (const edit of kept.reverse()) {
+    text = text.slice(0, edit.start) + edit.text + text.slice(edit.end);
+  }
+  sourceFile.replaceWithText(text);
+  return true;
+}
+function indentAt(sourceFile, pos) {
+  const text = sourceFile.getFullText();
+  const lineStart = text.lastIndexOf('\n', pos - 1) + 1;
+  return /^[ \t]*/.exec(text.slice(lineStart))[0];
+}
+function where(sourceFile, node) {
+  const {
+    line,
+    column
+  } = sourceFile.getLineAndColumnAtPos(node.getStart());
+  return `${sourceFile.getFilePath()}:${line}:${column}`;
+}
+
+/** Appends property texts to an object literal, keeping its layout. */
+function appendProperties(sourceFile, object, texts) {
+  const last = object.getProperties().at(-1);
+  if (!last) {
+    const indent = indentAt(sourceFile, object.getStart());
+    return {
+      start: object.getStart() + 1,
+      end: object.getEnd() - 1,
+      text: `\n${texts.map(t => `${indent}  ${t}`).join(',\n')}\n${indent}`
+    };
+  }
+  const indent = indentAt(sourceFile, last.getStart());
+  return {
+    start: last.getEnd(),
+    end: last.getEnd(),
+    text: texts.map(t => `,\n${indent}${t}`).join('')
+  };
+}
+
+// ---- F: move createMachine's second argument into the config -----------------
+
+function moveImplementations(sourceFile, notes) {
+  const edits = [];
+  for (const call of sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+    const expr = call.getExpression();
+    const name = Node.isIdentifier(expr) ? expr.getText() : Node.isPropertyAccessExpression(expr) ? expr.getName() : undefined;
+    const args = call.getArguments();
+    if (name !== 'createMachine' || args.length !== 2 || !isXstateMachineCall(call)) continue;
+    const [config, impls] = args.map(unwrap);
+    if (!Node.isObjectLiteralExpression(config) || !Node.isObjectLiteralExpression(impls)) {
+      notes.push(`${where(sourceFile, args[1])} — left the second createMachine argument: not an object literal`);
+      continue;
+    }
+    const plan = [];
+    const newKeys = [];
+    let ok = true;
+    for (const property of impls.getProperties()) {
+      const key = getKeyText$2(property);
+      if (!key || !IMPLEMENTATION_KEYS.has(key) || !(Node.isPropertyAssignment(property) || Node.isShorthandPropertyAssignment(property))) {
+        ok = false;
+        break;
+      }
+      const existing = getProperty$1(config, key);
+      if (!existing) {
+        newKeys.push(property.getText());
+        continue;
+      }
+      const value = Node.isPropertyAssignment(property) ? unwrap(property.getInitializer()) : undefined;
+      const target = unwrap(existing);
+      if (!value || !Node.isObjectLiteralExpression(value) || !Node.isObjectLiteralExpression(target)) {
+        ok = false;
+        break;
+      }
+      const texts = value.getProperties().map(p => p.getText());
+      if (texts.length) plan.push(appendProperties(sourceFile, target, texts));
+    }
+    if (!ok) {
+      notes.push(`${where(sourceFile, args[1])} — left the second createMachine argument: keys other than actions/guards/actors/delays, or a non-literal map`);
+      continue;
+    }
+    if (newKeys.length) plan.push(appendProperties(sourceFile, config, newKeys));
+    plan.push({
+      start: args[0].getEnd(),
+      end: args[1].getEnd(),
+      text: ''
+    });
+    edits.push(...plan);
+    notes.push(`${where(sourceFile, args[1])} — moved the second createMachine argument into the config`);
+  }
+  return applyEdits(sourceFile, edits);
+}
+
+// ---- A–E: transitions and entry/exit --------------------------------------------
+
+function render(sourceFile, property, value, lowered) {
+  const indent = indentAt(sourceFile, property.getStart());
+  const text = lowered.body.join('\n');
+  const usesEnq = /\benq\b/.test(text);
+  const params = usesEnq ? '(args, enq)' : /\bargs\b/.test(text) ? '(args)' : '()';
+  const fn = [`${params} => {`, ...lowered.body.map(line => `${indent}  ${line}`), `${indent}}`].join('\n');
+  if (!lowered.above.length || !Node.isPropertyAssignment(property)) {
+    return {
+      start: value.getStart(),
+      end: value.getEnd(),
+      text: fn
+    };
+  }
+  return {
+    start: property.getStart(),
+    end: value.getEnd(),
+    text: `${lowered.above.join(`\n${indent}`)}\n${indent}${property.getNameNode().getText()}: ${fn}`
+  };
+}
+function lowerMachines(sourceFile, notes) {
+  // A module-level action const is rewritten only when every reference to it
+  // is a call site that got lowered; otherwise plan again without it.
+  const disabledConsts = new Set();
+  for (;;) {
+    const plan = planMachines(sourceFile, disabledConsts);
+    if (plan.edits) {
+      notes.push(...plan.notes);
+      return applyEdits(sourceFile, plan.edits);
+    }
+  }
+}
+function planMachines(sourceFile, disabledConsts) {
+  const notes = [];
+  const xs = getXstateImports(sourceFile);
+  const edits = [];
+  const assignDefs = new Set();
+  const constRefs = new Map();
+  const inlined = new Map();
+  const attempt = (property, value, lower) => {
+    try {
+      const lowered = lower();
+      edits.push(render(sourceFile, property, value, lowered));
+      for (const def of lowered.inlined) {
+        inlined.set(def.property, implName(def));
+      }
+      for (const [decl, ids] of lowered.constRefs) {
+        const set = constRefs.get(decl) ?? new Set();
+        ids.forEach(id => set.add(id));
+        constRefs.set(decl, set);
+      }
+      for (const note of lowered.notes) {
+        notes.push(`${where(sourceFile, value)} — ${note}`);
+      }
+    } catch (error) {
+      if (!(error instanceof Skip)) throw error;
+      notes.push(`${where(sourceFile, value)} — not lowered: ${error.message}`);
+    }
+  };
+  const provided = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).filter(call => {
+    const callee = call.getExpression();
+    return Node.isIdentifier(callee) && callee.getText() === 'provide' || Node.isPropertyAccessExpression(callee) && callee.getName() === 'provide';
+  }).map(call => call.getArguments().map(a => a.getText()).join(','));
+  const mentions = (text, name) => new RegExp(`(^|[^\\w$])${name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}($|[^\\w$])`).test(text);
+  for (const config of findMachineConfigObjects(sourceFile)) {
+    if (!isXstateMachineCall(config.getParentOrThrow())) {
+      notes.push(`${where(sourceFile, config)} — not lowered: the machine call does not resolve to an 'xstate' import`);
+      continue;
+    }
+    const impls = collectImplementations(config, xs);
+    const rewrites = new Map();
+    for (const [name, def] of impls.actions) {
+      if (def.kind !== 'assign') continue;
+      if (provided.some(text => mentions(text, name))) {
+        // `.provide({ actions: { name } })` elsewhere would still pass a v5
+        // assign where call sites expect a patch function.
+        def.kind = 'other';
+        notes.push(`${where(sourceFile, def.property)} — not lowered: '${name}' is overridden through provide(...)`);
+        continue;
+      }
+      const text = lowerAssignDefinition(def);
+      if (text === undefined) def.kind = 'other';else rewrites.set(def, text);
+    }
+    const ctx = {
+      xs,
+      impls,
+      assignDefs,
+      disabledConsts
+    };
+
+    /** Literal behind an in-file const reference, when safe to edit in place. */
+    const resolve = value => {
+      if (!isIndirect(value)) return value;
+      const target = derefConfig(value);
+      if (!target) return value;
+      if (!onlyConfigReferences(target.decl)) return undefined;
+      return target.node;
+    };
+    const transition = (property, value) => {
+      if (!value) return;
+      if (isIndirect(value)) {
+        const target = resolve(value);
+        if (!target || target === value || isFunctionLike(target)) return;
+        // Lowered in place inside the const: replace the literal only.
+        return transition(target, target);
+      }
+      const v = unwrap(value);
+      const candidates = Node.isArrayLiteralExpression(v) ? v.getElements().map(unwrap) : [v];
+      if (!candidates.some(hasLowerableKeys)) {
+        if (Node.isArrayLiteralExpression(v)) collapseArray(v, candidates);
+        return;
+      }
+      attempt(property, value, () => lowerTransition(ctx, v));
+    };
+
+    // v5 takes the first enabled candidate; with no guards that is always the
+    // first one, so the rest are unreachable.
+    const collapseArray = (array, candidates) => {
+      const [first] = candidates;
+      if (!first || !candidates.every(c => Node.isObjectLiteralExpression(c) || Node.isStringLiteral(c) || Node.isNoSubstitutionTemplateLiteral(c))) return;
+      edits.push({
+        start: array.getStart(),
+        end: array.getEnd(),
+        text: first.getText()
+      });
+      if (candidates.length > 1) {
+        notes.push(`${where(sourceFile, array)} — collapsed an unguarded transition array to its first candidate; v5 never reaches the other ${candidates.length - 1}`);
+      }
+    };
+    const transitionMap = map => {
+      const value = map && resolve(map);
+      if (!value || !Node.isObjectLiteralExpression(value)) return;
+      for (const property of value.getProperties()) {
+        if (Node.isPropertyAssignment(property)) {
+          transition(property, property.getInitializer());
+        } else if (Node.isSpreadAssignment(property)) {
+          transitionMap(property);
+        }
+      }
+    };
+    const visitState = node => {
+      const state = node && resolve(node);
+      if (!state || !Node.isObjectLiteralExpression(state)) return;
+      for (const property of state.getProperties()) {
+        if (Node.isSpreadAssignment(property)) {
+          visitState(property);
+          continue;
+        }
+        const key = getKeyText$2(property);
+        if (!key || !Node.isPropertyAssignment(property)) continue;
+        const value = property.getInitializer();
+        if (!value) continue;
+        switch (key) {
+          case 'entry':
+          case 'exit':
+            {
+              const target = resolve(value);
+              if (target && !isFunctionLike(unwrap(target))) {
+                const at = target === value ? property : target;
+                attempt(at, target, () => lowerEntryExit(ctx, target));
+              }
+              break;
+            }
+          case 'on':
+          case 'after':
+            transitionMap(value);
+            break;
+          case 'always':
+          case 'onDone':
+          case 'onError':
+          case 'onSnapshot':
+            transition(property, value);
+            break;
+          case 'invoke':
+            {
+              const list = resolve(value);
+              const invokes = !list ? [] : Node.isArrayLiteralExpression(list) ? list.getElements().map(resolve) : [list];
+              for (const invoke of invokes) {
+                if (!invoke || !Node.isObjectLiteralExpression(invoke)) continue;
+                for (const p of invoke.getProperties()) {
+                  const k = getKeyText$2(p);
+                  if (Node.isPropertyAssignment(p) && (k === 'onDone' || k === 'onError' || k === 'onSnapshot')) {
+                    transition(p, p.getInitializer());
+                  }
+                }
+              }
+              break;
+            }
+          case 'states':
+            visitStates(value);
+            break;
+        }
+      }
+    };
+    const visitStates = node => {
+      const states = resolve(node);
+      if (!states || !Node.isObjectLiteralExpression(states)) return;
+      for (const child of states.getProperties()) {
+        if (Node.isPropertyAssignment(child)) {
+          visitState(child.getInitializer());
+        } else if (Node.isShorthandPropertyAssignment(child)) {
+          visitState(child);
+        } else if (Node.isSpreadAssignment(child)) {
+          visitStates(child);
+        }
+      }
+    };
+    visitState(config);
+    for (const [def, text] of rewrites) {
+      if (def.constDecl && Node.isVariableDeclaration(def.constDecl)) {
+        const init = def.constDecl.getInitializer();
+        edits.push({
+          start: init.getStart(),
+          end: init.getEnd(),
+          text
+        });
+        continue;
+      }
+      if (!Node.isPropertyAssignment(def.property)) continue;
+      const init = def.property.getInitializer();
+      edits.push({
+        start: init.getStart(),
+        end: init.getEnd(),
+        text
+      });
+    }
+  }
+  let retry = false;
+  for (const [decl, ids] of constRefs) {
+    const declaration = decl;
+    const nameNode = declaration.getNameNode();
+    const symbol = nameNode.getSymbol();
+    const unlowered = sourceFile.getDescendantsOfKind(SyntaxKind.Identifier).some(id => id !== nameNode && id.getText() === nameNode.getText() && id.getSymbol() === symbol && !ids.has(id));
+    const call = unwrap(declaration.getInitializer());
+    const text = unlowered ? undefined : xstateCallee(call, xs) === 'assign' ? call.getArguments().length !== 1 ? undefined : lowerAssignDefinition({
+      kind: 'assign',
+      property: decl,
+      assignArg: call.getArguments()[0]
+    }) : lowerConstCreator({
+      xs,
+      impls: {
+        actions: new Map(),
+        guards: new Map()
+      },
+      assignDefs,
+      disabledConsts
+    }, call);
+    if (text === undefined) {
+      disabledConsts.add(decl);
+      retry = true;
+      continue;
+    }
+    const init = declaration.getInitializer();
+    edits.push({
+      start: init.getStart(),
+      end: init.getEnd(),
+      text
+    });
+    notes.push(`${where(sourceFile, decl)} — rewrote '${nameNode.getText()}' as a function its call sites invoke`);
+  }
+  if (retry) return {
+    notes
+  };
+
+  // Definitions only referenced from other removed definitions go too.
+  const removed = [];
+  for (let grew = true; grew;) {
+    grew = false;
+    const ranges = [...edits, ...removed.map(p => ({
+      start: p.getStart(),
+      end: p.getEnd()
+    }))];
+    for (const [property, name] of inlined) {
+      if (removed.includes(property)) continue;
+      if (!hasOtherReferences(sourceFile, name, property, ranges)) {
+        removed.push(property);
+        grew = true;
+      }
+    }
+  }
+  for (const [property, name] of inlined) {
+    if (!removed.includes(property)) {
+      notes.push(`${where(sourceFile, property)} — kept '${name}': referenced where it was not inlined`);
+    }
+  }
+  edits.push(...removeProperties(removed));
+  return {
+    edits,
+    notes
+  };
+}
+function implName(def) {
+  const name = def.property.getNameNode();
+  return Node.isComputedPropertyName(name) ? resolveStringConstant(name.getExpression()) ?? '' : getKeyText$2(def.property) ?? '';
+}
+
+/** Whether `name` still appears outside `def` and the replaced ranges. */
+function hasOtherReferences(sourceFile, name, def, edits) {
+  const replaced = node => node.getStart() >= def.getStart() && node.getEnd() <= def.getEnd() || edits.some(e => node.getStart() >= e.start && node.getEnd() <= e.end);
+  return sourceFile.forEachDescendant(node => {
+    const matches = (Node.isStringLiteral(node) || Node.isNoSubstitutionTemplateLiteral(node)) && node.getLiteralText() === name || Node.isIdentifier(node) && node.getText() === name || Node.isPropertyAccessExpression(node) && resolveStringConstant(node) === name;
+    return matches && !replaced(node) ? true : undefined;
+  }) ?? false;
+}
+
+/** Deletes object literal properties with their separating commas. */
+function removeProperties(properties) {
+  const edits = [];
+  const objects = new Set(properties.map(p => p.getParentOrThrow()));
+  for (const object of objects) {
+    if (!Node.isObjectLiteralExpression(object)) continue;
+    const props = object.getProperties();
+    const gone = props.map(p => properties.includes(p));
+    if (gone.every(Boolean)) {
+      edits.push({
+        start: object.getStart() + 1,
+        end: object.getEnd() - 1,
+        text: ''
+      });
+      continue;
+    }
+    const lastKept = gone.lastIndexOf(false);
+    props.forEach((p, i) => {
+      if (gone[i] && i < lastKept) {
+        edits.push({
+          start: p.getFullStart(),
+          end: props[i + 1].getFullStart(),
+          text: ''
+        });
+      }
+    });
+    if (lastKept < props.length - 1) {
+      edits.push({
+        start: props[lastKept].getEnd(),
+        end: props.at(-1).getEnd(),
+        text: ''
+      });
+    }
+  }
+  return edits;
+}
+
+// ---- F: fromPromise → createAsyncLogic ---------------------------------------
+
+function promiseFunction(arg) {
+  const value = unwrap(arg);
+  if (isFunctionLike(value)) return value;
+  if (Node.isIdentifier(value)) {
+    const init = resolveConstInitializer(value);
+    if (init && isFunctionLike(init)) return init;
+    const decl = value.getSymbol()?.getDeclarations().find(Node.isFunctionDeclaration);
+    return decl;
+  }
+  return undefined;
+}
+function usesSystemOrEmit(fn) {
+  if (!Node.isArrowFunction(fn) && !Node.isFunctionExpression(fn) && !Node.isFunctionDeclaration(fn)) return true;
+  const [param, ...rest] = fn.getParameters();
+  if (rest.length) return true;
+  if (!param) return false;
+  const name = param.getNameNode();
+  if (Node.isObjectBindingPattern(name)) {
+    return name.getElements().some(element => {
+      const key = (element.getPropertyNameNode() ?? element.getNameNode()).getText();
+      return !!element.getDotDotDotToken() || key === 'system' || key === 'emit';
+    });
+  }
+  return /\b(system|emit)\b/.test(fn.getText());
+}
+function lowerFromPromise(sourceFile, notes) {
+  const find = () => {
+    const xs = getXstateImports(sourceFile);
+    return sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).filter(call => {
+      if (xstateCallee(call, xs) !== 'fromPromise') return false;
+      const args = call.getArguments();
+      const fn = args.length === 1 && promiseFunction(args[0]);
+      if (!fn || usesSystemOrEmit(fn)) {
+        notes.push(`${where(sourceFile, call)} — not lowered: fromPromise logic reads \`system\` or \`emit\`, or is not a local function`);
+        return false;
+      }
+      return true;
+    });
+  };
+  if (!find().length) return false;
+  const local = ensureNamedImport(sourceFile, 'createAsyncLogic');
+  if (!local) return false;
+  const calls = find().reverse();
+  for (const call of calls) {
+    call.replaceWithText(`${local}({ run: ${call.getArguments()[0].getText()} })`);
+  }
+  return true;
+}
+
+// ---- G: imports -----------------------------------------------------------------
+
+function cleanupImports(sourceFile) {
+  const references = new Map();
+  for (const id of sourceFile.getDescendantsOfKind(SyntaxKind.Identifier)) {
+    if (id.getFirstAncestorByKind(SyntaxKind.ImportDeclaration)) continue;
+    const parent = id.getParent();
+    if ((Node.isPropertyAssignment(parent) || Node.isPropertyAccessExpression(parent) || Node.isMethodDeclaration(parent) || Node.isPropertySignature(parent)) && parent.getNameNode() === id) continue;
+    references.set(id.getText(), (references.get(id.getText()) ?? 0) + 1);
+  }
+  for (const imp of sourceFile.getImportDeclarations()) {
+    if (imp.getModuleSpecifierValue() !== 'xstate') continue;
+    for (const spec of imp.getNamedImports()) {
+      const local = (spec.getAliasNode() ?? spec.getNameNode()).getText();
+      if (REMOVABLE_IMPORTS.has(spec.getName()) && !references.get(local)) {
+        spec.remove();
+      }
+    }
+    if (!imp.getNamedImports().length && !imp.getDefaultImport() && !imp.getNamespaceImport()) {
+      imp.remove();
+    }
+  }
+}
+
+/**
+ * Lowers v5 action creators, guards and transition objects to v6 transition
+ * and entry/exit functions. Anything it cannot lower is left untouched for the
+ * report transforms.
+ */
+const lowerActions = {
+  name: 'lower-actions',
+  description: 'Rewrite v5 transition `actions`/`guard`, `entry`/`exit` lists, action creators, guard combinators, named `assign` actions, the second `createMachine` argument and `fromPromise` as v6 functions.',
+  apply(sourceFile) {
+    const before = sourceFile.getFullText();
+    const notes = [];
+    let changed = moveImplementations(sourceFile, notes);
+    changed = lowerMachines(sourceFile, notes) || changed;
+    changed = lowerFromPromise(sourceFile, notes) || changed;
+    if (sourceFile.getFullText().includes(MATCHES_STATE)) {
+      const local = ensureNamedImport(sourceFile, 'matchesState') ?? 'matchesState';
+      sourceFile.replaceWithText(sourceFile.getFullText().split(MATCHES_STATE).join(local));
+    }
+    if (changed) cleanupImports(sourceFile);
+    return {
+      changed: sourceFile.getFullText() !== before,
+      notes
+    };
+  }
+};
+
+/**
+ * v5 `'xstate'` exports that require structural rewrites in v6 and are too
+ * risky to automate. Value is a one-line hint for the v6 replacement.
+ */
+const REMOVED_APIS = {
+  assign: 'return a `{ context }` patch from the inline transition function. A named `assign` in `setup({ actions })` becomes a plain function returning the patch; call it from the transition and return its result (`enq(actions.x)` ignores return values).',
+  raise: 'use `enq.raise(...)` inside an action',
+  sendTo: 'use `enq.sendTo(...)` inside an action',
+  sendParent: 'use `enq.sendTo(...)` with the parent ref inside an action',
+  forwardTo: 'use `enq.sendTo(target, event)` inside an action',
+  emit: 'use `enq.emit(...)` inside an action',
+  log: 'use `enq.log(...)` inside an action',
+  cancel: 'use `enq.cancel(...)` inside an action',
+  spawnChild: 'use `enq.spawn(...)` inside an action',
+  stop: 'use `enq.stop(...)` inside an action',
+  stopChild: 'use `enq.stop(...)` inside an action',
+  enqueueActions: 'action functions now receive an `enq` enqueue object directly',
+  and: 'inline the guard as `(...) => a(...) && b(...)`',
+  or: 'inline the guard as `(...) => a(...) || b(...)`',
+  not: 'inline the guard as `(...) => !a(...)`',
+  stateIn: 'use `self.getSnapshot().matches(...)`',
+  fromPromise: 'use `createAsyncLogic(...)`',
+  fromTransition: 'use `createStepLogic({ context, run })`',
+  toObserver: 'pass an observer object or callback directly',
+  pathToStateValue: 'build the state value object directly',
+  SpecialTargets: 'use `enq.sendTo(self, event)` for internal sends; parent sends use `enq.sendTo(...)` with the parent ref'
+};
+
+/**
+ * Detects (does NOT transform) usages of v5 `'xstate'` APIs that were removed
+ * or restructured in v6. Reports file:line + API + a replacement hint via the
+ * returned notes.
+ */
+const reportRemovedApis = {
+  name: 'report-removed-apis',
+  description: 'Detect (report only) usages of removed/restructured v5 xstate APIs (assign, raise, sendTo, emit, fromPromise, and/or/not, toObserver, SpecialTargets, etc.) that need manual migration.',
+  apply(sourceFile) {
+    const notes = [];
+    const sites = [];
+    const xstateImports = sourceFile.getImportDeclarations().filter(imp => imp.getModuleSpecifierValue() === 'xstate');
+
+    // Map local binding name → canonical API name (respecting aliases).
+    const tracked = new Map();
+    for (const imp of xstateImports) {
+      for (const spec of imp.getNamedImports()) {
+        const original = spec.getNameNode().getText();
+        if (REMOVED_APIS[original]) {
+          const local = (spec.getAliasNode() ?? spec.getNameNode()).getText();
+          tracked.set(local, original);
+        }
+      }
+    }
+    if (tracked.size === 0) {
+      return {
+        changed: false,
+        notes,
+        sites
+      };
+    }
+    const filePath = sourceFile.getFilePath();
+    for (const ident of sourceFile.getDescendantsOfKind(SyntaxKind.Identifier)) {
+      const local = ident.getText();
+      const api = tracked.get(local);
+      if (!api) {
+        continue;
+      }
+      // Skip member names such as `enq.emit`; they are not the import.
+      const parent = ident.getParent();
+      if ((Node.isPropertyAccessExpression(parent) || Node.isPropertyAssignment(parent)) && parent.getNameNode() === ident) {
+        continue;
+      }
+      // Skip the import specifier declarations themselves.
+      const parentKind = parent?.getKind();
+      if (parentKind === SyntaxKind.ImportSpecifier || parentKind === SyntaxKind.ImportClause) {
+        continue;
+      }
+      const {
+        line,
+        column
+      } = sourceFile.getLineAndColumnAtPos(ident.getPos());
+      const hint = REMOVED_APIS[api];
+      notes.push(`${filePath}:${line}:${column} — '${api}' → ${hint}`);
+      sites.push({
+        file: filePath,
+        line,
+        column,
+        api,
+        hint
+      });
+    }
+
+    // Never mutates the file.
+    return {
+      changed: false,
+      notes,
+      sites
+    };
+  }
+};
+
+/** Keys whose string values (or string array elements) are state targets. */
+const TARGET_KEYS = new Set(['target', 'initial', 'on', 'after', 'always', 'onDone', 'onError']);
+
+/** Calls whose first argument is a state value or `#id` reference. */
+const MATCH_CALLS = new Set(['matches', 'stateIn']);
+function getPropertyName(node) {
+  if (Node.isPropertyAssignment(node)) {
+    const name = node.getNameNode();
+    if (Node.isIdentifier(name) || Node.isStringLiteral(name)) {
+      return Node.isStringLiteral(name) ? name.getLiteralText() : name.getText();
+    }
+  }
+  return undefined;
+}
+function getStringProperty(object, name) {
+  const property = object.getProperty(name);
+  if (!property || !Node.isPropertyAssignment(property)) return undefined;
+  const initializer = property.getInitializer();
+  return initializer && (Node.isStringLiteral(initializer) || Node.isNoSubstitutionTemplateLiteral(initializer)) ? initializer.getLiteralText() : undefined;
+}
+const ID_PATH_HINT = "'#…' is an exact state id in v6 and is never split into an id and a path; use the target state's own id (its explicit `id` or its full implicit id)";
+/**
+ * Collects the state ids that one machine config literal declares: explicit
+ * state `id`s and, for `createMachine` configs, implicit ids (the path from
+ * the root, prefixed by the machine id when one is set). Invoke and actor ids
+ * are not state ids and are not collected.
+ */
+function collectStateIds(config, withImplicitIds) {
+  const ids = new Set();
+  function walk(stateConfig, implicitId) {
+    const explicitId = getStringProperty(stateConfig, 'id');
+    if (explicitId !== undefined) ids.add(explicitId);else if (withImplicitIds) ids.add(implicitId);
+    const states = stateConfig.getProperty('states');
+    if (!states || !Node.isPropertyAssignment(states)) return;
+    const statesObject = states.getInitializer();
+    if (!statesObject || !Node.isObjectLiteralExpression(statesObject)) return;
+    for (const state of statesObject.getProperties()) {
+      const key = getPropertyName(state);
+      if (key === undefined || !Node.isPropertyAssignment(state)) continue;
+      const child = state.getInitializer();
+      if (!child || !Node.isObjectLiteralExpression(child)) continue;
+      walk(child, implicitId ? `${implicitId}.${key}` : key);
+    }
+  }
+  walk(config, getStringProperty(config, 'id') ?? '');
+  return ids;
+}
+
+/**
+ * Finds the `createMachine(...)` or `createStateConfig(...)` config literal
+ * that contains `node`, if any.
+ */
+function findEnclosingConfig(node, machineConfigs, stateConfigs) {
+  for (const ancestor of node.getAncestors()) {
+    if (!Node.isObjectLiteralExpression(ancestor)) continue;
+    if (machineConfigs.has(ancestor)) {
+      return {
+        config: ancestor,
+        withImplicitIds: true
+      };
+    }
+    if (stateConfigs.has(ancestor)) {
+      return {
+        config: ancestor,
+        withImplicitIds: false
+      };
+    }
+  }
+  return undefined;
+}
+function isMatchArgument(literal) {
+  const call = literal.getParent();
+  if (!call || !Node.isCallExpression(call)) return false;
+  if (call.getArguments()[0] !== literal) return false;
+  const expression = call.getExpression();
+  const name = Node.isIdentifier(expression) ? expression.getText() : Node.isPropertyAccessExpression(expression) ? expression.getName() : undefined;
+  return !!name && MATCH_CALLS.has(name);
+}
+function isTargetValue(literal) {
+  let node = literal;
+  let parent = node.getParent();
+  if (parent && Node.isArrayLiteralExpression(parent)) {
+    node = parent;
+    parent = node.getParent();
+  }
+  if (!parent || !Node.isPropertyAssignment(parent)) return false;
+  const name = getPropertyName(parent);
+  if (name && TARGET_KEYS.has(name)) return true;
+  // A bare string transition inside `on: { EVENT: '#a.b' }` or
+  // `after: { 1000: '#a.b' }`.
+  const container = parent.getParent();
+  const owner = container?.getParent();
+  const ownerName = owner ? getPropertyName(owner) : undefined;
+  return ownerName === 'on' || ownerName === 'after';
+}
+
+/**
+ * Reports (does NOT transform) `#a.b` targets and `matches('#a.b')`/
+ * `stateIn('#a.b')` references that the codemod cannot verify as whole state
+ * ids. In v6, the text after `#` is an exact id and is never split into an
+ * id followed by a path.
+ */
+const reportIdPathTargets = {
+  name: 'report-id-path-targets',
+  description: "Detect (report only) '#id.path' targets and matches('#id.path') references that may combine an id with a relative path, which v6 no longer resolves.",
+  apply(sourceFile) {
+    const notes = [];
+    const sites = [];
+    const filePath = sourceFile.getFilePath();
+    const machineConfigs = new Set(findMachineConfigObjects(sourceFile, ['createMachine']));
+    const stateConfigs = new Set(findMachineConfigObjects(sourceFile, ['createStateConfig']));
+    const idsByConfig = new Map();
+    const literals = [...sourceFile.getDescendantsOfKind(SyntaxKind.StringLiteral), ...sourceFile.getDescendantsOfKind(SyntaxKind.NoSubstitutionTemplateLiteral)].sort((a, b) => a.getStart() - b.getStart());
     for (const literal of literals) {
       const text = literal.getLiteralText();
       if (!text.startsWith('#') || !text.includes('.')) continue;
@@ -651,23 +2819,458 @@ const reportIdPathTargets = {
         line,
         column
       } = sourceFile.getLineAndColumnAtPos(literal.getStart());
-      notes.push(`${filePath}:${line}:${column} — '${text}' → '#…' is an exact state id in v6 and is never split into an id and a path; use the target state's own id (its explicit \`id\` or its full implicit id)`);
+      notes.push(`${filePath}:${line}:${column} — '${text}' → ${ID_PATH_HINT}`);
+      sites.push({
+        file: filePath,
+        line,
+        column,
+        api: text,
+        hint: ID_PATH_HINT
+      });
+    }
+
+    // Never mutates the file.
+    return {
+      changed: false,
+      notes,
+      sites
+    };
+  }
+};
+
+const SUFFIXED_LIFECYCLE = /^xstate\.(done\.state|done\.actor|error\.actor|snapshot|after)\.(.+)$/;
+// v6 category type and the payload field that carries the v5 suffix.
+const REWRITES = {
+  'done.actor': {
+    type: 'xstate.done.actor',
+    field: 'actorId'
+  },
+  'error.actor': {
+    type: 'xstate.error.actor',
+    field: 'actorId'
+  },
+  snapshot: {
+    type: 'xstate.snapshot.actor',
+    field: 'actorId'
+  },
+  'done.state': {
+    type: 'xstate.done.state',
+    field: 'stateId'
+  }
+};
+const AFTER_HINT = 'v6 raises `xstate.after` with `delay` and `stateId`; suffixed keys never match. Use `after: { <delay>: ... }` on the state.';
+function keyHint(category, suffix, reason) {
+  const rewrite = REWRITES[category];
+  if (!rewrite) return AFTER_HINT;
+  return `${reason} Key on '${rewrite.type}' and select the payload with \`matches: { ${rewrite.field}: '${suffix}' }\`.`;
+}
+const LITERAL_HINT = 'v6 lifecycle event types carry the id in a payload field (`actorId`, `stateId`, `delay`), so this string never equals `event.type`. Compare the category type and the payload field instead.';
+
+/** Parses a suffixed lifecycle type; wildcards and `xstate.snapshot.actor` are v6-valid. */
+function parseSuffixed(text) {
+  const match = SUFFIXED_LIFECYCLE.exec(text);
+  if (!match) return undefined;
+  const [, category, suffix] = match;
+  if (suffix === '*' || suffix.endsWith('.*')) return undefined;
+  if (category === 'snapshot' && suffix === 'actor') return undefined;
+  return {
+    category,
+    suffix
+  };
+}
+function getKeyText$1(node) {
+  if (!Node.isPropertyAssignment(node)) return undefined;
+  const name = node.getNameNode();
+  if (Node.isStringLiteral(name)) return name.getLiteralText();
+  if (Node.isIdentifier(name)) return name.getText();
+  return undefined;
+}
+
+/** v5 `done.state` suffixes are state ids, which used the `(machine)` placeholder. */
+function v6StateId(suffix) {
+  return suffix.startsWith('(machine).') ? suffix.slice('(machine).'.length) : suffix;
+}
+
+/**
+ * Builds the v6 transition for a suffixed key, or explains why it cannot.
+ * Object literals get `matches` prepended; functions move under `to`.
+ */
+function rewriteInitializer(entry, field, value) {
+  const init = entry.getInitializerOrThrow();
+  const matches = `matches: { ${field}: ${JSON.stringify(value).replace(/"/g, "'")} }`;
+  if (Node.isObjectLiteralExpression(init)) {
+    if (init.getProperty('matches')) return '';
+    const props = init.getProperties().map(p => p.getText());
+    return `{ ${[matches, ...props].join(', ')} }`;
+  }
+  if (Node.isArrowFunction(init) || Node.isFunctionExpression(init)) {
+    return `{ ${matches}, to: ${init.getText()} }`;
+  }
+  return '';
+}
+
+/**
+ * Rewrites `on` keys that use v5 suffixed lifecycle event types, such as
+ * `'xstate.done.actor.job'`, to the v6 category type with `matches`.
+ * Reports what it cannot rewrite: `xstate.after.<delay>.<id>` keys, keys
+ * whose category type is already present or used twice in the same `on`,
+ * and suffixed type strings outside `on` keys (for example
+ * `event.type === 'xstate.done.actor.job'`).
+ */
+const suffixedLifecycleEvents = {
+  name: 'suffixed-lifecycle-events',
+  description: "Rewrite `on` keys such as 'xstate.done.actor.<id>' to the v6 category type with `matches`; report suffixed types it cannot rewrite.",
+  apply(sourceFile) {
+    const notes = [];
+    const sites = [];
+    const filePath = sourceFile.getFilePath();
+    const handled = new Set();
+    let changed = false;
+    const report = (node, api, hint) => {
+      const {
+        line,
+        column
+      } = sourceFile.getLineAndColumnAtPos(node.getStart());
+      notes.push(`${filePath}:${line}:${column} — '${api}' → ${hint}`);
+      sites.push({
+        file: filePath,
+        line,
+        column,
+        api,
+        hint
+      });
+    };
+    const onObjects = [];
+    for (const config of findMachineConfigObjects(sourceFile)) {
+      for (const property of config.getDescendantsOfKind(SyntaxKind.PropertyAssignment)) {
+        if (getKeyText$1(property) !== 'on') continue;
+        const on = property.getInitializer();
+        if (on && Node.isObjectLiteralExpression(on) && !onObjects.includes(on)) {
+          onObjects.push(on);
+        }
+      }
+    }
+    for (const on of onObjects) {
+      const entries = on.getProperties().flatMap(entry => {
+        const key = getKeyText$1(entry);
+        const parsed = key ? parseSuffixed(key) : undefined;
+        return parsed && Node.isPropertyAssignment(entry) ? [{
+          entry,
+          key: key,
+          ...parsed
+        }] : [];
+      });
+      const existingKeys = new Set(on.getProperties().map(getKeyText$1).filter(Boolean));
+      for (const item of entries) {
+        handled.add(item.entry.getNameNode());
+        const rewrite = REWRITES[item.category];
+        if (!rewrite) {
+          report(item.entry, item.key, AFTER_HINT);
+          continue;
+        }
+        const sameCategory = entries.filter(other => REWRITES[other.category]?.type === rewrite.type);
+        if (existingKeys.has(rewrite.type) || sameCategory.length > 1) {
+          report(item.entry, item.key, keyHint(item.category, item.suffix, `\`on\` already handles '${rewrite.type}' or several suffixed keys share it; merge them into one transition by hand.`));
+          continue;
+        }
+        const value = item.category === 'done.state' ? v6StateId(item.suffix) : item.suffix;
+        const replacement = rewriteInitializer(item.entry, rewrite.field, value);
+        if (!replacement) {
+          report(item.entry, item.key, keyHint(item.category, item.suffix, 'The transition is not an object or function literal, or already has `matches`.'));
+          continue;
+        }
+        item.entry.replaceWithText(`'${rewrite.type}': ${replacement}`);
+        changed = true;
+      }
+    }
+    const importsXState = sourceFile.getImportDeclarations().some(d => /^xstate(\/|$)/.test(d.getModuleSpecifierValue()));
+    if (importsXState) {
+      for (const literal of [...sourceFile.getDescendantsOfKind(SyntaxKind.StringLiteral), ...sourceFile.getDescendantsOfKind(SyntaxKind.NoSubstitutionTemplateLiteral)]) {
+        if (literal.wasForgotten() || handled.has(literal)) continue;
+        if (Node.isImportDeclaration(literal.getParent())) continue;
+        const text = literal.getLiteralText();
+        if (parseSuffixed(text)) report(literal, text, LITERAL_HINT);
+      }
+    }
+    return {
+      changed,
+      notes,
+      sites
+    };
+  }
+};
+
+const ENTRY_EXIT_HINT = 'v6 `entry`/`exit` is a single function `(args, enq) => { ... }`; call named actions with `enq(actions.name, params)`.';
+const TRANSITION_ACTIONS_HINT = 'transition `actions` was removed; use an inline transition function `(args, enq) => { ... }` and queue effects on `enq`; call named actions with `enq(actions.name, params)`.';
+const TRANSITION_GUARD_HINT = 'transition `guard` was removed; return `{ target }` from an inline transition function when the condition holds, or `undefined` to reject the event; named guards are plain predicates called as `guards.name(params)`.';
+const TRANSITION_ARRAY_HINT = 'v6 takes one transition function; combine the candidates into an if-chain: `(args, enq) => { if (cond) return { target }; return { target: other }; }`.';
+const INDIRECT_CONFIG_HINT = 'v6 rejects v5 transition objects, `actions`/`guard` and action lists; this value is not an inline literal or an in-file `const`, so the codemod cannot see into it. Inline it or migrate it by hand.';
+function getKeyText(node) {
+  if (!Node.isPropertyAssignment(node)) return undefined;
+  const name = node.getNameNode();
+  if (Node.isStringLiteral(name)) return name.getLiteralText();
+  if (Node.isIdentifier(name)) return name.getText();
+  return undefined;
+}
+function getProperty(object, key) {
+  if (!Node.isObjectLiteralExpression(object)) return undefined;
+  const property = object.getProperties().find(candidate => getKeyText(candidate) === key);
+  return Node.isPropertyAssignment(property) ? property.getInitializer() : undefined;
+}
+
+/**
+ * Reports (does NOT transform) v5 action shapes that v6 rejects: non-function
+ * `entry` / `exit` values, transition arrays, and `actions`, `guard` or `cond`
+ * on transition objects.
+ */
+const reportActionShapes = {
+  name: 'report-action-shapes',
+  description: 'Detect (report only) non-function `entry`/`exit` values, transition arrays and transition `actions`/`guard`/`cond`, which v6 rejects.',
+  apply(sourceFile) {
+    const notes = [];
+    const sites = [];
+    const filePath = sourceFile.getFilePath();
+    const seen = new Set();
+    const report = (node, api, hint) => {
+      if (seen.has(node)) return;
+      seen.add(node);
+      const {
+        line,
+        column
+      } = sourceFile.getLineAndColumnAtPos(node.getStart());
+      notes.push(`${filePath}:${line}:${column} — '${api}' → ${hint}`);
+      sites.push({
+        file: filePath,
+        line,
+        column,
+        api,
+        hint
+      });
+    };
+
+    /** The literal behind a reference, or undefined (reported) when unknown. */
+    const look = node => {
+      if (!node || !isIndirect(node)) return node;
+      const target = derefConfig(node);
+      if (!target) {
+        report(node, 'indirect-config', INDIRECT_CONFIG_HINT);
+        return undefined;
+      }
+      return target.node;
+    };
+    const visitTransition = node => {
+      const value = look(node);
+      if (!value) return;
+      if (Node.isArrayLiteralExpression(value)) {
+        report(value, 'transition-array', TRANSITION_ARRAY_HINT);
+        value.getElements().forEach(visitTransition);
+        return;
+      }
+      if (!Node.isObjectLiteralExpression(value)) return;
+      for (const property of value.getProperties()) {
+        const key = getKeyText(property);
+        if (key === 'actions') {
+          report(property, 'actions', TRANSITION_ACTIONS_HINT);
+        } else if (key === 'guard' || key === 'cond') {
+          report(property, key, TRANSITION_GUARD_HINT);
+        }
+      }
+    };
+    const visitTransitionMap = node => {
+      const value = look(node);
+      if (!value || !Node.isObjectLiteralExpression(value)) return;
+      for (const property of value.getProperties()) {
+        if (Node.isPropertyAssignment(property)) {
+          visitTransition(property.getInitializer());
+        } else if (Node.isSpreadAssignment(property)) {
+          visitTransitionMap(property);
+        }
+      }
+    };
+    const visitStates = node => {
+      const value = look(node);
+      if (!value || !Node.isObjectLiteralExpression(value)) return;
+      for (const child of value.getProperties()) {
+        if (Node.isPropertyAssignment(child)) {
+          visitState(child.getInitializer());
+        } else if (Node.isShorthandPropertyAssignment(child)) {
+          visitState(child);
+        } else if (Node.isSpreadAssignment(child)) {
+          visitStates(child);
+        }
+      }
+    };
+    const visitState = node => {
+      const state = look(node);
+      if (!state || !Node.isObjectLiteralExpression(state)) return;
+      for (const property of state.getProperties()) {
+        if (Node.isSpreadAssignment(property)) {
+          visitState(property);
+          continue;
+        }
+        const key = getKeyText(property);
+        if (!key || !Node.isPropertyAssignment(property)) continue;
+        const raw = property.getInitializer();
+        const value = raw && ['entry', 'exit', 'invoke'].includes(key) ? look(raw) : raw;
+        switch (key) {
+          case 'entry':
+          case 'exit':
+            if (value && !Node.isArrowFunction(value) && !Node.isFunctionExpression(value) && !Node.isFunctionDeclaration(value)) {
+              report(property, key, ENTRY_EXIT_HINT);
+            }
+            break;
+          case 'on':
+          case 'after':
+            visitTransitionMap(value);
+            break;
+          case 'always':
+          case 'onDone':
+          case 'onError':
+          case 'onSnapshot':
+            visitTransition(value);
+            break;
+          case 'initial':
+            if (value && Node.isObjectLiteralExpression(value)) {
+              visitTransition(value);
+            }
+            break;
+          case 'invoke':
+            {
+              const invokes = value && Node.isArrayLiteralExpression(value) ? value.getElements() : [value];
+              for (const element of invokes) {
+                const invoke = look(element);
+                for (const event of ['onDone', 'onError', 'onSnapshot']) {
+                  visitTransition(invoke && getProperty(invoke, event));
+                }
+              }
+              break;
+            }
+          case 'states':
+            visitStates(value);
+            break;
+        }
+      }
+    };
+    for (const config of findMachineConfigObjects(sourceFile)) {
+      visitState(config);
+    }
+
+    // Never mutates the file.
+    return {
+      changed: false,
+      notes,
+      sites
+    };
+  }
+};
+
+const SECOND_ARGUMENT_HINT = 'v6 `createMachine` takes only a config; the second argument is ignored. Move actions, guards, actors and delays into `setup({ ... }).createMachine(...)`.';
+function getCallName(call) {
+  const expr = call.getExpression();
+  if (Node.isIdentifier(expr)) return expr.getText();
+  if (Node.isPropertyAccessExpression(expr)) return expr.getName();
+  return undefined;
+}
+
+/**
+ * Reports (does NOT transform) a second `createMachine` argument, which v6
+ * ignores. `lower-actions` moves object-literal ones into the config.
+ */
+const reportImplementations = {
+  name: 'report-implementations',
+  description: 'Detect (report only) a second `createMachine` argument, which v6 ignores.',
+  apply(sourceFile) {
+    const notes = [];
+    const sites = [];
+    const filePath = sourceFile.getFilePath();
+    const report = (node, api, hint) => {
+      const {
+        line,
+        column
+      } = sourceFile.getLineAndColumnAtPos(node.getStart());
+      notes.push(`${filePath}:${line}:${column} — '${api}' → ${hint}`);
+      sites.push({
+        file: filePath,
+        line,
+        column,
+        api,
+        hint
+      });
+    };
+    for (const call of sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+      const name = getCallName(call);
+      const args = call.getArguments();
+      if (name === 'createMachine' && args[1]) {
+        report(args[1], 'implementations', SECOND_ARGUMENT_HINT);
+      }
+    }
+
+    // Never mutates the file.
+    return {
+      changed: false,
+      notes,
+      sites
+    };
+  }
+};
+
+const TRANSITION_HINT = 'v6 emits only `@xstate.actor` and `@xstate.transition`; read the event, snapshot, executed `actions` and `microsteps` from `@xstate.transition`.';
+const HINTS = {
+  '@xstate.event': TRANSITION_HINT,
+  '@xstate.snapshot': TRANSITION_HINT,
+  '@xstate.action': TRANSITION_HINT,
+  '@xstate.microstep': TRANSITION_HINT,
+  '@xstate.deadletter': 'v6 has no dead-letter inspection event; observe undelivered events with the `onRejectedEvent` option of `createActor` or `system.onRejectedEvent(listener)`.'
+};
+
+/**
+ * Reports (does NOT transform) string literals naming v5 inspection event
+ * types. Inspection code often types events loosely or lives in plain
+ * JavaScript, where comparing against a removed type compiles and never
+ * matches. Scans every file, with or without an `xstate` import.
+ */
+const reportInspectionEvents = {
+  name: 'report-inspection-events',
+  description: "Detect (report only) v5 inspection event types such as '@xstate.snapshot', which v6 never emits.",
+  apply(sourceFile) {
+    const notes = [];
+    const sites = [];
+    const filePath = sourceFile.getFilePath();
+    const literals = [...sourceFile.getDescendantsOfKind(SyntaxKind.StringLiteral), ...sourceFile.getDescendantsOfKind(SyntaxKind.NoSubstitutionTemplateLiteral)].sort((a, b) => a.getStart() - b.getStart());
+    for (const literal of literals) {
+      if (Node.isImportDeclaration(literal.getParent())) continue;
+      const api = literal.getLiteralText();
+      const hint = HINTS[api];
+      if (!hint) continue;
+      const {
+        line,
+        column
+      } = sourceFile.getLineAndColumnAtPos(literal.getStart());
+      notes.push(`${filePath}:${line}:${column} — '${api}' → ${hint}`);
+      sites.push({
+        file: filePath,
+        line,
+        column,
+        api,
+        hint
+      });
     }
 
     // Never mutates the file.
     return {
       changed: false,
-      notes
+      notes,
+      sites
     };
   }
 };
 
 /** All transforms, in recommended application order. */
-const transforms = [renameImports, stringTargets, typesToSchemas, reportRemovedApis, reportIdPathTargets];
+const transforms = [renameImports, stringTargets, typesToSchemas, lowerActions, reportRemovedApis, reportIdPathTargets, suffixedLifecycleEvents, reportActionShapes, reportImplementations, reportInspectionEvents];
 const transformsByName = Object.fromEntries(transforms.map(t => [t.name, t]));
 
-/** Report-only transforms whose notes list manual migration steps. */
-const REPORT_TRANSFORMS = new Set(['report-removed-apis', 'report-id-path-targets']);
+/** Report-only transforms never rewrite; their notes list manual migration steps. */
+const isReportTransform = name => name.startsWith('report-');
 /** Resolve a list of transform names to Transform objects. */
 function selectTransforms(names) {
   if (!names || names.length === 0) {
@@ -693,7 +3296,8 @@ function applyToSourceFile(sourceFile, transforms) {
     perTransform.push({
       transform: transform.name,
       changed: result.changed,
-      notes: result.notes
+      notes: result.notes,
+      sites: result.sites ?? []
     });
     if (result.changed) {
       changed = true;
@@ -732,14 +3336,22 @@ function run(filePaths, transforms, options = {
   });
   const files = [];
   const manualMigrationNotes = [];
+  const manualSites = [];
   let filesChanged = 0;
   for (const filePath of filePaths) {
     const sourceFile = project.addSourceFileAtPath(filePath);
     const report = applyToSourceFile(sourceFile, transforms);
     for (const pt of report.perTransform) {
-      if (REPORT_TRANSFORMS.has(pt.transform)) {
+      if (isReportTransform(pt.transform)) {
         manualMigrationNotes.push(...pt.notes);
       }
+      // Any transform may leave code it could not migrate.
+      for (const site of pt.sites) {
+        manualSites.push({
+          ...site,
+          transform: pt.transform
+        });
+      }
     }
     if (report.changed) {
       filesChanged++;
@@ -752,7 +3364,8 @@ function run(filePaths, transforms, options = {
   return {
     files,
     filesChanged,
-    manualMigrationNotes
+    manualMigrationNotes,
+    manualSites
   };
 }
 
@@ -765,6 +3378,7 @@ function parseArgs(argv) {
     command: undefined,
     globs: [],
     dry: false,
+    json: false,
     transformNames: undefined,
     help: false
   };
@@ -774,6 +3388,8 @@ function parseArgs(argv) {
       parsed.help = true;
     } else if (arg === '--dry') {
       parsed.dry = true;
+    } else if (arg === '--json') {
+      parsed.json = true;
     } else if (arg === '--transform') {
       const value = argv[++i];
       if (value) {
@@ -791,7 +3407,7 @@ function parseArgs(argv) {
 }
 function printHelp() {
   const names = transforms.map(t => `    ${t.name} — ${t.description}`);
-  process.stdout.write(['xstate-codemod — migrate XState source (v5 → v6)', '', 'Usage:', '  xstate-codemod migrate [globs...] [--dry] [--transform <name,name>]', '', 'Options:', '  --dry                  Print a summary of changes without writing files', '  --transform <names>    Comma-separated transform names (default: all)', '  -h, --help             Show this help', '', `Default glob: ${DEFAULT_GLOB} (excludes node_modules and dist)`, '', 'Transforms:', ...names, ''].join('\n'));
+  process$1.stdout.write(['xstate-codemod — migrate XState source (v5 → v6)', '', 'Usage:', '  xstate-codemod migrate [globs...] [--dry] [--json] [--transform <name,name>]', '  xstate-codemod baseline <v5-file> [--out <path>]', '  xstate-codemod verify --baseline <path> <v6-file>', '  xstate-codemod verify <v5-file> <v6-file>', '', 'Run `xstate-codemod verify --help` for the baseline/verify options.', '', 'Options:', '  --dry                  Print a summary of changes without writing files', '  --json                 Print one JSON report to stdout instead of text', '  --transform <names>    Comma-separated transform names (default: all)', '  -h, --help             Show this help', '', `Default glob: ${DEFAULT_GLOB} (excludes node_modules and dist)`, '', 'Exit codes:', '  0  No manual migration needed', '  1  Usage error or invalid migration output', '  2  Manual migration needed', '', 'Transforms:', ...names, ''].join('\n'));
 }
 
 /**
@@ -818,24 +3434,67 @@ function main(argv) {
     return args.command ? 0 : args.help ? 0 : 1;
   }
   if (args.command !== 'migrate') {
-    process.stderr.write(`Unknown command '${args.command}'. Did you mean 'migrate'?\n`);
+    process$1.stderr.write(`Unknown command '${args.command}'. Expected 'migrate', 'baseline' or 'verify'.\n`);
     return 1;
   }
   let transforms;
   try {
     transforms = selectTransforms(args.transformNames);
   } catch (err) {
-    process.stderr.write(`${err.message}\n`);
+    process$1.stderr.write(`${err.message}\n`);
     return 1;
   }
   const files = resolveFiles(args.globs);
-  if (files.length === 0) {
-    process.stdout.write('No files matched.\n');
+  if (files.length === 0 && !args.json) {
+    process$1.stdout.write('No files matched.\n');
     return 0;
   }
-  const report = run(files, transforms, {
-    write: !args.dry
-  });
+  let report;
+  try {
+    report = run(files, transforms, {
+      write: !args.dry
+    });
+  } catch (err) {
+    const message = err.message;
+    if (!message.startsWith('Refusing to write invalid migration output')) {
+      throw err;
+    }
+    if (args.json) {
+      process$1.stdout.write(`${JSON.stringify({
+        error: {
+          code: 'INVALID_OUTPUT',
+          message
+        }
+      })}\n`);
+    } else {
+      process$1.stderr.write(`${message}\n`);
+    }
+    return 1;
+  }
+  const exitCode = report.manualSites.length > 0 ? 2 : 0;
+  if (args.json) {
+    process$1.stdout.write(`${JSON.stringify({
+      filesChanged: report.filesChanged,
+      files: report.files.map(file => ({
+        filePath: file.filePath,
+        changed: file.changed,
+        transforms: file.perTransform.map(pt => ({
+          name: pt.transform,
+          changed: pt.changed,
+          notes: pt.notes
+        }))
+      })),
+      manualSites: report.manualSites.map(site => ({
+        file: site.file,
+        line: site.line,
+        column: site.column,
+        api: site.api,
+        hint: site.hint,
+        transform: site.transform
+      }))
+    }, null, 2)}\n`);
+    return exitCode;
+  }
 
   // Per-file, per-transform summary.
   for (const file of report.files) {
@@ -843,27 +3502,1236 @@ function main(argv) {
     if (touched.length === 0) {
       continue;
     }
-    process.stdout.write(`\n${file.filePath}${file.changed ? '' : ' (no writes)'}\n`);
+    process$1.stdout.write(`\n${file.filePath}${file.changed ? '' : ' (no writes)'}\n`);
     for (const pt of touched) {
       const mark = pt.changed ? '✔' : '·';
-      process.stdout.write(`  ${mark} ${pt.transform}\n`);
+      process$1.stdout.write(`  ${mark} ${pt.transform}\n`);
       for (const note of pt.notes) {
-        process.stdout.write(`      - ${note}\n`);
+        process$1.stdout.write(`      - ${note}\n`);
       }
     }
   }
 
   // Manual-migration section.
   if (report.manualMigrationNotes.length) {
-    process.stdout.write('\n=== Manual migration needed ===\n');
+    process$1.stdout.write('\n=== Manual migration needed ===\n');
     for (const note of report.manualMigrationNotes) {
-      process.stdout.write(`  ${note}\n`);
+      process$1.stdout.write(`  ${note}\n`);
     }
   }
 
   // Final report.
-  process.stdout.write(`\n${args.dry ? '[dry run] ' : ''}${report.filesChanged} of ${files.length} file(s) ${args.dry ? 'would change' : 'changed'}.\n`);
-  return 0;
+  process$1.stdout.write(`\n${args.dry ? '[dry run] ' : ''}${report.filesChanged} of ${files.length} file(s) ${args.dry ? 'would change' : 'changed'}.\n`);
+  return exitCode;
+}
+
+// v5 spawn (`x:3`), v5 invoke (`0.root.a`), v6 invoke/spawn (`root.a:0`, `child:0`).
+const ANON_ID = /^(x:\d+|\d+\..+|.+:\d+)$/;
+function normalizeId(id) {
+  return ANON_ID.test(id) ? '(anon)' : id;
+}
+
+/**
+ * v5 gives an id-less machine the root id `(machine)` and prefixes every
+ * implicit state id with it; v6 leaves the prefix out.
+ */
+function normalizeStateId(id) {
+  if (id === '(machine)') return '';
+  return id.startsWith('(machine).') ? id.slice('(machine).'.length) : id;
+}
+function isActorRef(value) {
+  return typeof value.send === 'function' && typeof value.getSnapshot === 'function' && typeof value.id === 'string';
+}
+
+/**
+ * JSON round-trip that marks functions/symbols and replaces actor refs.
+ * Objects nested deeper than `maxDepth` become `'[deep]'`.
+ */
+function toJson(value, stats, seen = new Set(), maxDepth = Infinity) {
+  switch (typeof value) {
+    case 'undefined':
+    case 'string':
+    case 'boolean':
+      return value;
+    case 'number':
+      return Number.isFinite(value) ? value : null;
+    case 'bigint':
+      return String(value);
+    case 'function':
+      stats.nonSerializable++;
+      return '[fn]';
+    case 'symbol':
+      stats.nonSerializable++;
+      return '[symbol]';
+  }
+  if (value === null) return null;
+  const obj = value;
+  if (isActorRef(obj)) return {
+    '@actor': normalizeId(obj.id)
+  };
+  if (obj instanceof Error) return String(obj);
+  if (typeof obj.toJSON === 'function') return toJson(obj.toJSON(), stats, seen, maxDepth);
+  if (seen.has(obj)) return '[circular]';
+  if (seen.size >= maxDepth) return '[deep]';
+  seen.add(obj);
+  try {
+    if (Array.isArray(obj)) {
+      return obj.map(item => toJson(item, stats, seen, maxDepth) ?? null);
+    }
+    const out = {};
+    for (const key of Object.keys(obj)) {
+      const item = toJson(obj[key], stats, seen, maxDepth);
+      if (item !== undefined) out[key] = item;
+    }
+    return out;
+  } finally {
+    seen.delete(obj);
+  }
+}
+function withOutput(event, output, stats) {
+  const json = toJson(output, stats);
+  return json === undefined ? event : {
+    ...event,
+    output: json
+  };
+}
+
+/** Maps v5 suffixed and v6 payload-identified lifecycle events to one shape. */
+function normalizeEvent(event, stats) {
+  const {
+    type,
+    sessionId: _sessionId,
+    ...rest
+  } = event;
+  let match;
+  if (type === 'xstate.done.actor' || (match = /^xstate\.done\.actor\.(.+)$/.exec(type))) {
+    const actorId = normalizeId(rest.actorId ?? match[1]);
+    return withOutput({
+      type: 'xstate.done.actor',
+      actorId
+    }, rest.output, stats);
+  }
+  if (type === 'xstate.error.actor' || (match = /^xstate\.error\.actor\.(.+)$/.exec(type))) {
+    return {
+      type: 'xstate.error.actor',
+      actorId: normalizeId(rest.actorId ?? match[1]),
+      error: String(rest.error)
+    };
+  }
+  if (type === 'xstate.done.state' || (match = /^xstate\.done\.state\.(.+)$/.exec(type))) {
+    const stateId = normalizeStateId(rest.stateId ?? match[1]);
+    return withOutput({
+      type: 'xstate.done.state',
+      stateId
+    }, rest.output, stats);
+  }
+  if (type === 'xstate.after') {
+    return {
+      type,
+      delay: rest.delay,
+      stateId: normalizeStateId(rest.stateId)
+    };
+  }
+  if (match = /^xstate\.after\.([^.]+)\.(.+)$/.exec(type)) {
+    const delay = Number(match[1]);
+    return {
+      type: 'xstate.after',
+      delay: Number.isFinite(delay) ? delay : match[1],
+      stateId: normalizeStateId(match[2])
+    };
+  }
+  return {
+    type,
+    ...toJson(rest, stats)
+  };
+}
+
+/** JSON with sorted object keys, for order-insensitive equality. */
+function canonical(value) {
+  return JSON.stringify(value, (_key, item) => item && typeof item === 'object' && !Array.isArray(item) ? Object.fromEntries(Object.keys(item).sort().map(key => [key, item[key]])) : item);
+}
+function isEqual(a, b) {
+  return canonical(a) === canonical(b);
+}
+
+function mapDeep(value, fn) {
+  if (Array.isArray(value)) return value.map(item => mapDeep(item, fn));
+  if (value && typeof value === 'object') {
+    const out = {};
+    for (const [key, item] of Object.entries(value)) {
+      const mapped = fn(key, item);
+      if (mapped !== undefined) out[key] = mapDeep(mapped, fn);
+    }
+    return out;
+  }
+  return value;
+}
+const stripAnonSuffix = value => mapDeep(value, (key, item) => (key === 'id' || key === 'to') && typeof item === 'string' ? item.replace(/(:\d+|\[\d+\])$/, '').replace(/^(x:\d+|\d+\.)/, '') : item);
+const isActorMarker = item => !!item && typeof item === 'object' && '@actor' in item;
+const stripErrorPrefix = message => message.replace(/^(\w*Error:\s*)+/, '').trim();
+const INTENTIONAL_DELTAS = [{
+  rule: 'anonymous-child-id',
+  section: '§12',
+  note: 'anonymous child ids are generated differently',
+  matches: (field, expected, actual) => (field === 'children' || field === 'sent') && isEqual(stripAnonSuffix(expected), stripAnonSuffix(actual))
+}, {
+  rule: 'error-string-shape',
+  section: '§16',
+  note: 'same error message, different error class or prefix',
+  matches: (field, expected, actual) => field === 'error' && typeof expected === 'string' && typeof actual === 'string' && expected !== '' && actual !== '' && stripErrorPrefix(expected) === stripErrorPrefix(actual)
+}, {
+  rule: 'context-reference',
+  section: '§20',
+  note: 'context differs only in stored actor references',
+  matches: (field, expected, actual) => field === 'context' && isEqual(mapDeep(expected, (_key, item) => isActorMarker(item) ? undefined : item), mapDeep(actual, (_key, item) => isActorMarker(item) ? undefined : item))
+}, {
+  rule: 'done-event-session',
+  section: '§12',
+  note: 'done events differ only by sessionId',
+  matches: (field, expected, actual) => field === 'processed' && isEqual(mapDeep(expected, (key, item) => key === 'sessionId' ? undefined : item), mapDeep(actual, (key, item) => key === 'sessionId' ? undefined : item))
+}, {
+  rule: 'final-state-output',
+  section: '§3',
+  note: "v6 promotes a top-level final state's output to snapshot.output when the root has none; v5 left it undefined",
+  matches: (field, expected, actual) => field === 'output' && expected === undefined && actual !== undefined
+}, {
+  rule: 'root-send-parent',
+  section: '§26',
+  note: "v5 errors when a root actor sends to its parent; v6 dead-letters the event with reason 'missingTarget'",
+  matches: (field, _expected, _actual, _step, steps) => field === 'status' && steps.expected.status === 'error' && steps.actual.status !== 'error' && /#_parent|Unable to send event to actor/.test(steps.expected.error ?? '')
+}];
+
+const FIELD_ORDER = ['status', 'value', 'context', 'output', 'error', 'processed', 'children', 'sent', 'emitted', 'actions'];
+const DEFAULT_FIELDS = FIELD_ORDER.filter(f => f !== 'actions');
+function classify(field, expected, actual, step, steps) {
+  const rule = INTENTIONAL_DELTAS.find(delta => delta.matches(field, expected, actual, step, steps));
+  return rule ? {
+    rule: rule.rule,
+    section: rule.section,
+    note: rule.note
+  } : 'unclassified';
+}
+function errorDetail(expected, actual) {
+  const parts = [];
+  if (expected.status === 'error') parts.push(`v5 error: ${expected.error}`);
+  if (actual.status === 'error') parts.push(`v6 error: ${actual.error}`);
+  return parts.join('; ') || undefined;
+}
+
+/**
+ * Compares traces step by step. An unclassified mismatch ends its sequence;
+ * classified (intentional) mismatches are recorded and comparison continues so
+ * they cannot mask a later real divergence.
+ */
+function diffTraces(sequences, expected, actual, fields = DEFAULT_FIELDS) {
+  const diffs = [];
+  let stepsCompared = 0;
+  const compared = FIELD_ORDER.filter(field => fields.includes(field));
+  for (const sequence of sequences) {
+    const exp = expected.find(t => t.sequenceId === sequence.id);
+    const act = actual.find(t => t.sequenceId === sequence.id);
+    if (!exp || !act) continue;
+    const length = Math.min(exp.steps.length, act.steps.length);
+    outer: for (let step = 0; step < length; step++) {
+      stepsCompared++;
+      const expStep = exp.steps[step];
+      const actStep = act.steps[step];
+      // v6 errored snapshots carry no value (v5 keeps the last one), so when
+      // both sides errored only the status and error are meaningful.
+      const bothErrored = expStep.status === 'error' && actStep.status === 'error';
+      for (const field of compared) {
+        if (bothErrored && field !== 'status' && field !== 'error') continue;
+        const e = expStep[field];
+        const a = actStep[field];
+        if (isEqual(e, a)) continue;
+        const classification = classify(field, e, a, step, {
+          expected: expStep,
+          actual: actStep
+        });
+        const detail = field === 'status' ? errorDetail(expStep, actStep) : undefined;
+        diffs.push({
+          sequenceId: sequence.id,
+          origin: sequence.origin,
+          step,
+          witness: sequence.steps.slice(0, step),
+          field,
+          expected: e,
+          actual: a,
+          ...(detail && {
+            detail
+          }),
+          classification
+        });
+        if (classification === 'unclassified') break outer;
+        // An intentional status divergence (one side errored, the other kept
+        // running) makes every later field and step incomparable.
+        if (field === 'status') break outer;
+      }
+    }
+  }
+  diffs.sort((a, b) => Number(a.classification !== 'unclassified') - Number(b.classification !== 'unclassified'));
+  return {
+    diffs,
+    stepsCompared
+  };
+}
+
+/** Generation note for a graph traversal that never closed. */
+const TRAVERSAL_LIMIT_NOTE = 'graph traversal hit its limit (context that changes on every step prevents the graph from closing); random walks still cover these paths';
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = a + 0x6d2b79f5 >>> 0;
+    let t = a;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function eventCandidates(machine, cases) {
+  const events = [];
+  const withoutCases = [];
+  const types = [...new Set(machine.events)].filter(type => !type.startsWith('xstate.') && !type.includes('*'));
+  for (const type of types) {
+    const payloads = cases[type];
+    if (payloads?.length) {
+      for (const payload of payloads) events.push({
+        ...payload,
+        type
+      });
+    } else {
+      withoutCases.push(type);
+      events.push({
+        type
+      });
+    }
+  }
+  return {
+    events,
+    withoutCases
+  };
+}
+
+/**
+ * Advancing exactly to the next deadline fires one timer per step: v5's
+ * SimulatedClock does not fire timers scheduled during an increment while v6's
+ * does, so a longer jump would diverge on clock semantics alone.
+ */
+function untilNextTimer(clock) {
+  // SimulatedClock keeps pending timeouts in a private map.
+  let next = Infinity;
+  for (const {
+    start,
+    timeout
+  } of clock.timeouts.values()) next = Math.min(next, start + timeout);
+  return next === Infinity ? undefined : next - clock.now();
+}
+const flush$1 = async () => {
+  for (let i = 0; i < 3; i++) await new Promise(resolve => setImmediate(resolve));
+};
+
+/** Sequences from the v5 graph (shortest, simple) and seeded random walks. */
+async function generateSequences(xs, graph, machine, events, options, input) {
+  const raw = [];
+  const generationErrors = [];
+  const fromPaths = async (origin, paths) => {
+    let result;
+    try {
+      // The wall clock stays at the epoch during traversal so context that
+      // stores `Date.now()` does not keep the graph from closing.
+      result = await withDeterminism({
+        now: () => 0
+      }, options.seed, paths);
+    } catch (err) {
+      // Unbounded context makes the state space infinite, and a guard that
+      // reads a payload the event cases do not supply throws. Either way the
+      // origin is dropped and reported; random walks still run.
+      const message = err.message ?? String(err);
+      generationErrors.push(`${origin} paths skipped: ${message === 'Traversal limit exceeded' ? TRAVERSAL_LIMIT_NOTE : message}`);
+      return;
+    }
+    for (const path of result) {
+      raw.push({
+        origin,
+        steps: path.steps.filter(step => step.event.type !== 'xstate.init').map(step => ({
+          event: step.event
+        }))
+      });
+    }
+  };
+  const traversal = {
+    events,
+    limit: 1000,
+    input
+  };
+  await fromPaths('shortest', () => graph.getShortestPaths(machine, traversal));
+  if (options.simplePaths === false) generationErrors.push('simple paths skipped (--no-simple-paths)');else await fromPaths('simple', () => graph.getSimplePaths(machine, traversal));
+  const random = mulberry32(options.seed);
+  const randomWalk = async clock => {
+    const actor = xs.createActor(machine, {
+      clock,
+      input
+    });
+    actor.subscribe({
+      error: () => {}
+    });
+    actor.start();
+    await flush$1();
+    const steps = [];
+    while (steps.length < options.steps && actor.getSnapshot().status === 'active') {
+      const snapshot = actor.getSnapshot();
+      const candidates = events.filter(event => {
+        try {
+          return snapshot.can(event);
+        } catch (err) {
+          // A guard threw on this payload; drop the event for this walk.
+          const note = `event '${event.type}' skipped: guard threw: ${err.message ?? String(err)}`;
+          if (!generationErrors.includes(note)) generationErrors.push(note);
+          return false;
+        }
+      }).map(event => ({
+        event
+      }));
+      const ms = untilNextTimer(clock);
+      if (ms !== undefined) candidates.push({
+        advance: ms
+      });
+      if (!candidates.length) break;
+      const next = candidates[Math.floor(random() * candidates.length)];
+      steps.push(next);
+      if ('event' in next) actor.send(next.event);else clock.increment(next.advance);
+      await flush$1();
+    }
+    actor.stop();
+    return steps;
+  };
+  for (let walk = 0; walk < options.walks; walk++) {
+    const clock = new xs.SimulatedClock();
+    const steps = await withDeterminism(clock, options.seed + walk, () => randomWalk(clock));
+    raw.push({
+      origin: 'random',
+      steps
+    });
+  }
+  const seen = new Set();
+  const counts = {
+    shortest: 0,
+    simple: 0,
+    random: 0
+  };
+  const sequences = [];
+  for (const {
+    origin,
+    steps
+  } of raw) {
+    const key = JSON.stringify(steps);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    if (sequences.length >= options.maxSequences) break;
+    sequences.push({
+      id: `${origin}-${counts[origin]++}`,
+      origin,
+      steps
+    });
+  }
+  return {
+    sequences,
+    generationErrors
+  };
+}
+
+/** `Date.now()` at simulated time 0. */
+const EPOCH = 1_700_000_000_000;
+
+/**
+ * Runs `fn` with `Date.now`, `performance.now`, and `Math.random` driven by
+ * the simulated clock and a seeded generator, so both majors read identical
+ * values. The originals are restored afterwards.
+ */
+async function withDeterminism(clock, seed, fn) {
+  const {
+    now
+  } = Date;
+  const perfNow = performance.now;
+  const {
+    random
+  } = Math;
+  Date.now = () => EPOCH + clock.now();
+  performance.now = () => clock.now();
+  Math.random = mulberry32(seed);
+  try {
+    return await fn();
+  } finally {
+    Date.now = now;
+    performance.now = perfNow;
+    Math.random = random;
+  }
+}
+
+/** Action params can hold whole `args` objects; record only their top levels. */
+const ACTION_PARAMS_DEPTH$1 = 4;
+const empty$1 = () => ({
+  processed: [],
+  sent: [],
+  emitted: [],
+  actions: []
+});
+
+/**
+ * v5 inspection: `@xstate.snapshot` (one per processed event), `@xstate.event`
+ * (relays; `sourceRef` → `actorRef`), `@xstate.actor`, `@xstate.action`.
+ */
+function createRecorder5(stats) {
+  let root;
+  let bucket = empty$1();
+  const registry = new Map();
+  return {
+    setRoot: ref => {
+      root = ref;
+    },
+    inspect(e) {
+      switch (e.type) {
+        case '@xstate.actor':
+          registry.set(e.actorRef, typeof e.actorRef.src === 'string' ? e.actorRef.src : '(inline)');
+          break;
+        case '@xstate.snapshot':
+          if (e.actorRef === root && e.event.type !== 'xstate.init') {
+            bucket.processed.push(normalizeEvent(e.event, stats));
+          }
+          break;
+        case '@xstate.event':
+          if (e.sourceRef === root && e.actorRef !== root && e.event.type !== 'xstate.init' && e.event.type !== 'xstate.stop') {
+            bucket.sent.push({
+              to: normalizeId(e.actorRef.id),
+              event: normalizeEvent(e.event, stats)
+            });
+          }
+          break;
+        case '@xstate.action':
+          if (e.actorRef === root && !e.action.type.startsWith('xstate.')) {
+            bucket.actions.push({
+              type: e.action.type,
+              params: toJson(e.action.params, stats, undefined, ACTION_PARAMS_DEPTH$1) ?? null
+            });
+          }
+          break;
+      }
+    },
+    emit(event) {
+      bucket.emitted.push(normalizeEvent(event, stats));
+    },
+    srcOf: ref => registry.get(ref) ?? '(inline)',
+    take() {
+      const taken = bucket;
+      bucket = empty$1();
+      return taken;
+    }
+  };
+}
+
+/** Action params can hold whole `args` objects; record only their top levels. */
+const ACTION_PARAMS_DEPTH = 4;
+const empty = () => ({
+  processed: [],
+  sent: [],
+  emitted: [],
+  actions: []
+});
+
+/**
+ * v6 inspection: `@xstate.actor` (`id`, `src`, `parentRef`) and
+ * `@xstate.transition` (`event`, `snapshot`, `actions[]`, `sent[]`).
+ */
+function createRecorder6(stats) {
+  let root;
+  let rootSnapshot;
+  let bucket = empty();
+  const registry = new Map();
+
+  // Delayed raises arrive as `xstate.timer` keyed by `{ event }`, `{ seq }` or
+  // `{ id }`; resolve them against the timers of the snapshot that scheduled
+  // them so the trace shows the delivered event, as in v5. A delayed send to
+  // another actor shows up in that firing transition's `sent` instead.
+  function onTimer(event) {
+    if (event.event) {
+      bucket.processed.push(normalizeEvent(event.event, stats));
+      return;
+    }
+    const timer = rootSnapshot?.timers?.find(t => event.id !== undefined ? t.id === event.id : t.seq === event.seq);
+    if (timer && (timer.target === 'self' || timer.target === root)) {
+      bucket.processed.push(normalizeEvent(timer.event, stats));
+    }
+  }
+  return {
+    setRoot: ref => {
+      root = ref;
+    },
+    inspect(e) {
+      if (e.type === '@xstate.actor') {
+        registry.set(e.actorRef, typeof e.src === 'string' ? e.src : '(inline)');
+        return;
+      }
+      if (e.type !== '@xstate.transition' || e.actorRef !== root) return;
+      const type = e.event.type;
+      if (type === 'xstate.timer') onTimer(e.event);else if (type !== 'xstate.init') bucket.processed.push(normalizeEvent(e.event, stats));
+      for (const action of e.actions) {
+        if (action.type.startsWith('xstate.') || action.type.startsWith('@xstate.')) continue;
+        bucket.actions.push({
+          type: action.type,
+          params: toJson(action.params, stats, undefined, ACTION_PARAMS_DEPTH) ?? null
+        });
+      }
+      for (const sent of e.sent) {
+        // v5 reports a delayed send when it is delivered; so does the timer's
+        // firing transition here.
+        if (sent.targetRef === root || sent.delay !== undefined) continue;
+        bucket.sent.push({
+          to: normalizeId(sent.targetId),
+          event: normalizeEvent(sent.event, stats)
+        });
+      }
+      rootSnapshot = e.snapshot;
+    },
+    emit(event) {
+      bucket.emitted.push(normalizeEvent(event, stats));
+    },
+    srcOf: ref => registry.get(ref) ?? '(inline)',
+    take() {
+      const taken = bucket;
+      bucket = empty();
+      return taken;
+    }
+  };
+}
+
+function outcome(spec) {
+  if (spec === 'pending') return () => new Promise(() => {});
+  if ('error' in spec) return () => Promise.reject(new Error(spec.error));
+  return () => Promise.resolve(spec.done);
+}
+
+/**
+ * Replaces keyed actors with scripted promise logic. Keyed state machines stay
+ * real: they are deterministic and their behavior is part of the trace.
+ * Everything else defaults to `'pending'` so no real side effect runs.
+ */
+function applyStubs(xs, major, machine, stubs) {
+  const keyed = (major === 5 ? machine.implementations?.actors : machine.sources?.actors) ?? {};
+  const actors = {};
+  for (const [key, logic] of Object.entries(keyed)) {
+    const spec = stubs.actors?.[key];
+    if (!spec && logic instanceof xs.StateMachine) continue;
+    const run = outcome(spec ?? 'pending');
+    actors[key] = major === 5 ? xs.fromPromise(run) : xs.createAsyncLogic({
+      run
+    });
+  }
+  return machine.provide({
+    actors,
+    ...(stubs.delays && {
+      delays: stubs.delays
+    })
+  });
+}
+
+/** Marks the start of the JSON result on stdout; user code may print before it. */
+const RESULT_MARKER = '\n@@xstate-verify-result@@\n';
+class ChildError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = void 0;
+    this.code = code;
+  }
+}
+const isLogic = value => !!value && typeof value.transition === 'function' && typeof value.getInitialSnapshot === 'function';
+async function loadLogic(file, name) {
+  let mod;
+  try {
+    mod = await import(pathToFileURL(file).href);
+  } catch (err) {
+    const error = err;
+    throw Object.assign(new ChildError('LOAD_ERROR', error.message), {
+      stack: error.stack
+    });
+  }
+  const names = Object.keys(mod);
+  const found = name ? isLogic(mod[name]) && name : isLogic(mod.default) && 'default' || names.find(key => isLogic(mod[key]));
+  if (!found) {
+    throw new ChildError('EXPORT_NOT_FOUND', `${name ? `export "${name}" is not actor logic` : 'no actor logic export'} in ${file}; exports: ${names.join(', ') || '(none)'}`);
+  }
+  const notes = [];
+  const logicNames = names.filter(key => isLogic(mod[key]));
+  if (!name && new Set(logicNames.map(key => mod[key])).size > 1) notes.push(`module exports ${logicNames.length} machines: ${logicNames.join(', ')}; using ${found} (pass --export to choose)`);
+  return [found, mod[found], notes];
+}
+const flush = async () => {
+  for (let i = 0; i < 3; i++) await new Promise(resolve => setImmediate(resolve));
+};
+async function recordTrace(xs, logic, sequence, recorder, stats, input, seed) {
+  const clock = new xs.SimulatedClock();
+  return withDeterminism(clock, seed, async () => {
+    const actor = xs.createActor(logic, {
+      clock,
+      inspect: recorder.inspect,
+      input
+    });
+    recorder.setRoot(actor);
+    actor.subscribe({
+      error: () => {}
+    });
+    actor.on('*', recorder.emit);
+    const capture = input => {
+      const snapshot = actor.getSnapshot();
+      const children = Object.values(snapshot.children ?? {}).filter(Boolean).map(ref => ({
+        id: normalizeId(ref.id),
+        src: recorder.srcOf(ref)
+      })).sort((a, b) => (a.id + a.src).localeCompare(b.id + b.src));
+      const output = toJson(snapshot.output, stats);
+      return {
+        input,
+        value: toJson(snapshot.value, stats),
+        context: toJson(snapshot.context, stats) ?? null,
+        status: snapshot.status,
+        ...(output !== undefined && {
+          output
+        }),
+        ...(snapshot.error !== undefined && {
+          error: String(snapshot.error)
+        }),
+        ...recorder.take(),
+        children
+      };
+    };
+    actor.start();
+    await flush();
+    const steps = [capture({
+      start: true
+    })];
+    for (const step of sequence.steps) {
+      if ('event' in step) actor.send(step.event);else clock.increment(step.advance);
+      await flush();
+      steps.push(capture(step));
+    }
+    actor.stop();
+    return {
+      sequenceId: sequence.id,
+      steps
+    };
+  });
+}
+async function runJob(job) {
+  const major = process.env.XSTATE_VERIFY_MAJOR === '5' ? 5 : 6;
+  // The alias hook maps `xstate` to the selected major for these imports too.
+  const xs = await import('xstate');
+  const xstateVersion = createRequire(import.meta.url)('xstate/package.json').version;
+  const [exportName, logic, notes] = await loadLogic(job.file, job.export);
+  const machine = applyStubs(xs, major, logic, job.stubs);
+  const stats = {
+    nonSerializable: 0
+  };
+  let sequences = job.sequences ?? [];
+  let eventsWithoutCases = [];
+  let generationErrors = [];
+  if (job.mode === 'baseline') {
+    const graph = await import('xstate/graph');
+    const candidates = eventCandidates(machine, job.events);
+    eventsWithoutCases = candidates.withoutCases;
+    const generated = await generateSequences(xs, graph, machine, candidates.events, job.options, job.input);
+    sequences = generated.sequences;
+    generationErrors = generated.generationErrors;
+  }
+  const traces = [];
+  const unstubbed = new Set();
+  for (const [index, sequence] of sequences.entries()) {
+    const recorder = major === 5 ? createRecorder5(stats) : createRecorder6(stats);
+    const trace = await recordTrace(xs, machine, sequence, recorder, stats, job.input, job.options.seed + index);
+    for (const step of trace.steps) {
+      for (const child of step.children) if (child.src === '(inline)') unstubbed.add(child.id);
+    }
+    traces.push(trace);
+  }
+  return {
+    ok: true,
+    export: exportName,
+    xstateVersion,
+    sequences,
+    traces,
+    unstubbed: [...unstubbed].sort(),
+    eventsWithoutCases,
+    generationErrors,
+    nonSerializable: stats.nonSerializable,
+    notes
+  };
+}
+async function readStdin() {
+  let data = '';
+  for await (const chunk of process.stdin) data += chunk;
+  return data;
+}
+async function childMain() {
+  let result;
+  try {
+    result = await runJob(JSON.parse(await readStdin()));
+  } catch (err) {
+    result = {
+      ok: false,
+      code: err instanceof ChildError ? err.code : 'RUN_ERROR',
+      message: String(err?.message ?? err),
+      stack: err?.stack
+    };
+  }
+  process.stdout.write(RESULT_MARKER + JSON.stringify(result), () => process.exit(0));
+}
+
+const require = createRequire(import.meta.url);
+// Resolved from this module, not cwd: the same lookup works from src and dist.
+const packageRoot = dirname(require.resolve('@xstate/codemod/package.json'));
+const DEFAULT_OPTIONS = {
+  seed: 1,
+  walks: 25,
+  steps: 12,
+  maxSequences: 200
+};
+const DEFAULT_TIMEOUT = 60_000;
+class VerifyError extends Error {
+  constructor(phase, code, message, stderr, childStack) {
+    super(message);
+    this.phase = void 0;
+    this.code = void 0;
+    this.stderr = void 0;
+    this.childStack = void 0;
+    this.phase = phase;
+    this.code = code;
+    this.stderr = stderr;
+    this.childStack = childStack;
+  }
+}
+async function runChild(major, job, timeout = DEFAULT_TIMEOUT) {
+  const args = [
+  // Select xstate's `development` export condition so v6 config diagnostics
+  // throw at load with a clear message instead of failing later at runtime.
+  '--conditions=development', '--import', pathToFileURL(require.resolve('tsx')).href, '--import', pathToFileURL(join(packageRoot, 'bin/alias-hook.mjs')).href, join(packageRoot, 'bin/verify-child.mjs')];
+  return new Promise(done => {
+    const child = spawn(process.execPath, args, {
+      cwd: dirname(job.file),
+      env: {
+        ...process.env,
+        XSTATE_VERIFY_MAJOR: String(major)
+      },
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+    let stdout = '';
+    let stderr = '';
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill('SIGKILL');
+    }, timeout);
+    child.stdout.setEncoding('utf8').on('data', chunk => stdout += chunk);
+    child.stderr.setEncoding('utf8').on('data', chunk => stderr += chunk);
+    child.on('close', code => {
+      clearTimeout(timer);
+      const at = stdout.lastIndexOf(RESULT_MARKER);
+      let result;
+      if (timedOut) {
+        result = {
+          ok: false,
+          code: 'CHILD_TIMEOUT',
+          message: `child timed out after ${timeout}ms`
+        };
+      } else if (at === -1) {
+        // Node prints the fatal reason (e.g. heap out of memory) before the
+        // native stack, so the first such line is the useful one.
+        const fatal = stderr.split('\n').find(line => /FATAL ERROR|^\w*Error:/.test(line));
+        result = {
+          ok: false,
+          code: 'CHILD_CRASH',
+          message: `child exited with code ${code} without a result${fatal ? `: ${fatal.trim()}` : ''}`
+        };
+      } else {
+        result = JSON.parse(stdout.slice(at + RESULT_MARKER.length));
+      }
+      done({
+        result,
+        stderr
+      });
+    });
+    child.stdin.end(JSON.stringify(job));
+  });
+}
+/** The error of the first trace's start step, when the machine errored there. */
+function startError(baseline) {
+  const start = baseline.traces[0]?.steps[0];
+  return start?.status === 'error' ? start.error ?? 'unknown error' : undefined;
+}
+
+/** Records a golden trace of a v5 module. Throws {@link VerifyError}. */
+async function runBaseline(options) {
+  const file = resolve(options.file);
+  const generate = {
+    seed: options.seed ?? DEFAULT_OPTIONS.seed,
+    walks: options.walks ?? DEFAULT_OPTIONS.walks,
+    steps: options.steps ?? DEFAULT_OPTIONS.steps,
+    maxSequences: options.maxSequences ?? DEFAULT_OPTIONS.maxSequences,
+    ...(options.simplePaths === false && {
+      simplePaths: false
+    })
+  };
+  const events = options.events ?? {};
+  const stubs = options.stubs ?? {};
+  const {
+    result,
+    stderr
+  } = await runChild(5, {
+    mode: 'baseline',
+    file,
+    export: options.export,
+    events,
+    stubs,
+    input: options.input,
+    options: generate
+  }, options.timeout);
+  if (!result.ok) throw new VerifyError('baseline', result.code, result.code === 'CHILD_TIMEOUT' ? `${result.message}; ${generate.simplePaths === false ? '' : 'pass --no-simple-paths or '}pass a smaller --events set` : result.message, stderr, result.stack);
+  return {
+    version: 1,
+    file,
+    export: result.export,
+    xstateVersion: result.xstateVersion,
+    options: generate,
+    events,
+    stubs,
+    input: options.input,
+    sequences: result.sequences,
+    traces: result.traces,
+    unstubbed: result.unstubbed,
+    eventsWithoutCases: result.eventsWithoutCases,
+    generationErrors: result.generationErrors ?? [],
+    nonSerializable: result.nonSerializable,
+    notes: result.notes ?? []
+  };
+}
+/** Replays the baseline's sequences on a v6 module and diffs the traces. */
+async function runVerify(options) {
+  const file = resolve(options.file);
+  const report = {
+    status: 'error',
+    v5: {
+      file: options.v5 ? resolve(options.v5) : '',
+      export: '',
+      xstateVersion: ''
+    },
+    v6: {
+      file,
+      export: '',
+      xstateVersion: ''
+    },
+    sequences: 0,
+    stepsCompared: 0,
+    diffs: [],
+    intentional: 0,
+    unstubbed: [],
+    eventsWithoutCases: [],
+    generationErrors: [],
+    nonSerializable: 0,
+    notes: []
+  };
+  let baseline = options.baseline;
+  if (!baseline) {
+    if (!options.v5) throw new TypeError('runVerify needs `v5` or `baseline`');
+    try {
+      baseline = await runBaseline({
+        ...options,
+        file: options.v5
+      });
+    } catch (err) {
+      if (!(err instanceof VerifyError)) throw err;
+      report.error = {
+        phase: err.phase,
+        code: err.code,
+        message: err.message,
+        stack: err.childStack,
+        stderr: err.stderr
+      };
+      return report;
+    }
+  } else {
+    if (options.events) report.notes.push('--events overrides the cases recorded in the baseline');
+    if (options.stubs) report.notes.push('--stubs overrides the stubs recorded in the baseline');
+    if (options.input !== undefined) report.notes.push('--input overrides the input recorded in the baseline');
+  }
+  report.v5 = {
+    file: baseline.file,
+    export: baseline.export,
+    xstateVersion: baseline.xstateVersion
+  };
+  report.sequences = baseline.sequences.length;
+  report.eventsWithoutCases = baseline.eventsWithoutCases;
+  report.generationErrors = baseline.generationErrors ?? [];
+  report.startError = startError(baseline);
+  const {
+    result,
+    stderr
+  } = await runChild(6, {
+    mode: 'replay',
+    file,
+    export: options.export,
+    events: options.events ?? baseline.events,
+    stubs: options.stubs ?? baseline.stubs,
+    input: options.input ?? baseline.input,
+    options: baseline.options,
+    sequences: baseline.sequences
+  }, options.timeout);
+  if (!result.ok) {
+    report.error = {
+      phase: 'replay',
+      code: result.code,
+      message: result.message,
+      stack: result.stack,
+      stderr
+    };
+    return report;
+  }
+  report.v6 = {
+    file,
+    export: result.export,
+    xstateVersion: result.xstateVersion
+  };
+  report.unstubbed = [...new Set([...baseline.unstubbed, ...result.unstubbed])].sort();
+  report.nonSerializable = baseline.nonSerializable + result.nonSerializable;
+  for (const note of [...(baseline.notes ?? []), ...(result.notes ?? [])]) if (!report.notes.includes(note)) report.notes.push(note);
+  const {
+    diffs,
+    stepsCompared
+  } = diffTraces(baseline.sequences, baseline.traces, result.traces, options.compare ?? DEFAULT_FIELDS);
+  report.diffs = diffs;
+  report.stepsCompared = stepsCompared;
+  report.intentional = diffs.filter(d => d.classification !== 'unclassified').length;
+  report.status = diffs.length > report.intentional ? 'diverged' : 'equivalent';
+  return report;
+}
+
+const USAGE = `Usage:
+  xstate-codemod baseline <v5-file> [--out <path>] [options]
+  xstate-codemod verify <v5-file> <v6-file> [options]
+  xstate-codemod verify --baseline <path> <v6-file> [options]
+
+Options:
+  --export <name>        export to load (default: default, else first actor logic)
+  --events <file>        event payload cases: { "TYPE": [payload, ...] }
+  --stubs <file>         actor/delay stubs: { "actors": {...}, "delays": {...} }
+  --input <file>         JSON passed as createActor(logic, { input })
+  --seed <n>             random walk seed (default 1)
+  --walks <n>            random walks (default 25)
+  --steps <n>            steps per walk (default 12)
+  --max-sequences <n>    sequence cap (default 200)
+  --no-simple-paths      skip the graph's simple paths (use when baseline times out)
+  --compare <fields>     fields to compare, or +field to add (e.g. +actions)
+  --timeout <ms>         per child process (default 60000)
+  --json                 print the JSON report only
+`;
+const startLine = (error, hasInput) => `  start: machine errored at start: ${error} ${hasInput ? '(the baseline exercised nothing past start)' : '(pass --input if the machine reads input)'}`;
+const EVENTS_ADVICE = ' (add payload cases with --events)';
+
+/** The --events advice applies only to a guard that threw on an event sent without a payload. */
+function generationLine(error, eventsWithoutCases) {
+  const type = /^event '(.*)' skipped: guard threw:/.exec(error)?.[1];
+  const advice = type === undefined ? /paths skipped: (?!graph traversal hit its limit)/.test(error) && eventsWithoutCases.length > 0 : eventsWithoutCases.includes(type);
+  return `  generation: ${error}${advice ? EVENTS_ADVICE : ''}`;
+}
+const readJson = file => JSON.parse(readFileSync(file, 'utf8'));
+const show = value => JSON.stringify(value) ?? 'undefined';
+const showStep = step => 'event' in step ? `send ${show(step.event)}` : `advance ${step.advance}ms`;
+function compareFields(value) {
+  if (!value) return undefined;
+  const fields = value.split(',').map(f => f.trim()).filter(Boolean);
+  const added = fields.filter(f => f.startsWith('+')).map(f => f.slice(1));
+  const set = fields.filter(f => !f.startsWith('+'));
+  return [...(set.length ? set : DEFAULT_FIELDS), ...added];
+}
+function formatReport(report, hasInput) {
+  const lines = [`verify: ${report.status}`];
+  lines.push(`  v5: ${report.v5.file} (export ${report.v5.export || '?'}, xstate ${report.v5.xstateVersion || '?'})`);
+  lines.push(`  v6: ${report.v6.file} (export ${report.v6.export || '?'}, xstate ${report.v6.xstateVersion || '?'})`);
+  if (report.error) {
+    lines.push(`  error (${report.error.phase}): ${report.error.code}: ${report.error.message}`);
+    if (report.error.stderr.trim()) lines.push(`  stderr:\n${report.error.stderr.trimEnd()}`);
+    return lines.join('\n') + '\n';
+  }
+  const unclassified = report.diffs.filter(d => d.classification === 'unclassified');
+  lines.push(`  sequences: ${report.sequences}, steps compared: ${report.stepsCompared}, unclassified diffs: ${unclassified.length}, intentional: ${report.intentional}`);
+  if (report.startError) lines.push(startLine(report.startError, hasInput));
+  if (report.unstubbed.length) lines.push(`  unstubbed inline actors: ${report.unstubbed.join(', ')}`);
+  if (report.eventsWithoutCases.length) lines.push(`  events sent without payload (add cases with --events if guards or actions read the payload): ${report.eventsWithoutCases.join(', ')}`);
+  for (const error of report.generationErrors) lines.push(generationLine(error, report.eventsWithoutCases));
+  if (report.nonSerializable) lines.push(`  non-serializable values: ${report.nonSerializable}`);
+  for (const note of report.notes) lines.push(`  note: ${note}`);
+  unclassified.slice(0, 5).forEach((diff, i) => {
+    lines.push('', `Diff ${i + 1}: ${diff.sequenceId} (${diff.origin}) step ${diff.step}, field ${diff.field}`);
+    lines.push('  witness:');
+    if (!diff.witness.length) lines.push('    (start)');
+    diff.witness.forEach((step, j) => lines.push(`    ${j + 1}. ${showStep(step)}`));
+    lines.push(`  expected (v5): ${show(diff.expected)}`);
+    lines.push(`  actual (v6):   ${show(diff.actual)}`);
+    if (diff.detail) lines.push(`  detail: ${diff.detail}`);
+  });
+  return lines.join('\n') + '\n';
+}
+
+/** `baseline` and `verify` commands; `argv[0]` is the command name. */
+async function verifyCli(argv) {
+  const [command, ...rest] = argv;
+  let parsed;
+  try {
+    parsed = parseArgs$1({
+      args: rest,
+      allowPositionals: true,
+      options: {
+        out: {
+          type: 'string'
+        },
+        baseline: {
+          type: 'string'
+        },
+        export: {
+          type: 'string'
+        },
+        events: {
+          type: 'string'
+        },
+        stubs: {
+          type: 'string'
+        },
+        input: {
+          type: 'string'
+        },
+        seed: {
+          type: 'string'
+        },
+        walks: {
+          type: 'string'
+        },
+        steps: {
+          type: 'string'
+        },
+        'max-sequences': {
+          type: 'string'
+        },
+        'no-simple-paths': {
+          type: 'boolean'
+        },
+        compare: {
+          type: 'string'
+        },
+        timeout: {
+          type: 'string'
+        },
+        json: {
+          type: 'boolean'
+        },
+        help: {
+          type: 'boolean',
+          short: 'h'
+        }
+      }
+    });
+  } catch (err) {
+    process.stderr.write(`${err.message}\n${USAGE}`);
+    return 1;
+  }
+  if (parsed.values.help) {
+    process.stdout.write(USAGE);
+    return 0;
+  }
+  const {
+    values,
+    positionals
+  } = parsed;
+  const int = value => value === undefined ? undefined : Number.parseInt(value, 10);
+  const common = {
+    export: values.export,
+    seed: int(values.seed),
+    walks: int(values.walks),
+    steps: int(values.steps),
+    maxSequences: int(values['max-sequences']),
+    ...(values['no-simple-paths'] && {
+      simplePaths: false
+    }),
+    timeout: int(values.timeout)
+  };
+  const numbers = [common.seed, common.walks, common.steps, common.maxSequences, common.timeout];
+  if (numbers.some(n => n !== undefined && !Number.isFinite(n))) {
+    process.stderr.write(`Numeric options must be integers\n${USAGE}`);
+    return 1;
+  }
+  let events, stubs, input;
+  try {
+    events = values.events ? readJson(values.events) : undefined;
+    stubs = values.stubs ? readJson(values.stubs) : undefined;
+    input = values.input ? readJson(values.input) : undefined;
+  } catch (err) {
+    process.stderr.write(`${err.message}\n`);
+    return 1;
+  }
+  if (command === 'baseline') {
+    if (positionals.length !== 1) {
+      process.stderr.write(USAGE);
+      return 1;
+    }
+    let baseline;
+    try {
+      baseline = await runBaseline({
+        ...common,
+        file: positionals[0],
+        events,
+        stubs,
+        input
+      });
+    } catch (err) {
+      if (!(err instanceof VerifyError)) throw err;
+      process.stderr.write(`baseline: ${err.code}: ${err.message}\n${err.stderr}`);
+      return 4;
+    }
+    const out = values.out ?? join('.xstate-migrate', `${baseline.export}.baseline.json`);
+    mkdirSync(dirname(out), {
+      recursive: true
+    });
+    writeFileSync(out, JSON.stringify(baseline, null, 2) + '\n');
+    const error = startError(baseline);
+    if (values.json) process.stdout.write(JSON.stringify({
+      out,
+      sequences: baseline.sequences.length,
+      startError: error
+    }) + '\n');else process.stdout.write(`baseline: ${baseline.sequences.length} sequences from ${baseline.file} (export ${baseline.export}) → ${out}\n` + (error ? startLine(error, input !== undefined) + '\n' : '') + baseline.generationErrors.map(e => generationLine(e, baseline.eventsWithoutCases) + '\n').join('') + (baseline.notes ?? []).map(note => `  note: ${note}\n`).join(''));
+    return 0;
+  }
+  if (command === 'verify') {
+    const expected = values.baseline ? 1 : 2;
+    if (positionals.length !== expected) {
+      process.stderr.write(USAGE);
+      return 1;
+    }
+    let baseline;
+    try {
+      baseline = values.baseline ? readJson(values.baseline) : undefined;
+    } catch (err) {
+      process.stderr.write(`${err.message}\n`);
+      return 1;
+    }
+    const report = await runVerify({
+      ...common,
+      baseline,
+      v5: baseline ? undefined : positionals[0],
+      file: positionals[expected - 1],
+      events,
+      stubs,
+      input,
+      compare: compareFields(values.compare)
+    });
+    process.stdout.write(values.json ? JSON.stringify(report, null, 2) + '\n' : formatReport(report, (input ?? baseline?.input) !== undefined));
+    return report.status === 'equivalent' ? 0 : report.status === 'diverged' ? 3 : 4;
+  }
+  process.stderr.write(USAGE);
+  return 1;
 }
 
-export { applyToSourceFile, main, parseArgs, renameImports, reportIdPathTargets, reportRemovedApis, resolveFiles, run, selectTransforms, stringTargets, transforms, transformsByName, typesToSchemas };
+export { VerifyError, applyToSourceFile, childMain, lowerActions, main, parseArgs, renameImports, reportIdPathTargets, reportRemovedApis, resolveFiles, run, runBaseline, runVerify, selectTransforms, stringTargets, transforms, transformsByName, typesToSchemas, verifyCli };