createMachine({ invoke: { src: "load", onError: {} } }); // ❌ fires: empty onError
createMachine({ invoke: { src: "load", onError: "failed" }, entry: spawnChild("sync", { id: "sync" }) }); // ❌ fires: spawn, no xstate.error
createMachine({ invoke: { src: load, onError: "error" } }); // ✅ silent

Fires per invoke without a real onError (reviewed per invocation; v6 createInvoke({...}) is unwrapped, and an enclosing state's onError covers it), and per spawnChild(...) / enq.spawn(...) / spawn(...) with no actor-error handling: a root onError (v6), an xstate.error.actor transition, or subscribeTo(ref, { error }). v6 logic creators (createAsyncLogic, createCallbackLogic, …) and fromEffect* count as failure sources. The guidance differs per version: v6 onError recovers action and spawned-child errors, v5 doesn't. Whole-machine fallback remains for promise/callback logic with neither. onSnapshot is not a failure path; pure machines don't need a fabricated error state.

Options: machineDefinitionPattern, invokeMarkerPattern, errorHandlingMarkerPattern, spawnCallPattern, spawnErrorMarkerPattern.

Fires on createActor(...) and system.createActor(...); createEffectActor(...) (owned by its Effect Scope) and createActorAtoms(...) (owned by its atom registry) get their own message. Injected or parent-owned actors need not stop themselves.

• exit actions don't run on an external stop() (v5 and v6); cleanup lives in fromCallback / createCallbackLogic or the async abort signal
• React ownership goes through useActorRef / useMachine / createActorContext
• unsubscribe: relaxed once stop() is proven

Options: actorStartPattern.

createMachine({ on: { ADD: { actions: assign({ ref: ({ spawn }) => spawn(todoMachine) }) } } }); // ❌ fires
setup({}).createMachine({ entry: spawnChild("sync", { id: "sync" }) }); // ❌ fires, once
const child = spawn("git", ["status"]);
assign({ ref: child }); // ✅ silent: not a machine

Fires once per machine definition (createMachine, setup(...) / setupEffect(...) / system.setup(...) .createMachine, a stored setup, createStateConfig) containing spawnChild(...) / enqueue.spawnChild(...), v6 enq.spawn(...), or a destructured spawn(...) (v5 assign, v5/v6 context factory). The judge pairs every spawn with a reachable stopChild / enq.stop(ref) and ref removal from context (v6: a returned context patch), or handled self-completion, list-removal transitions included. Bounded parent-lifetime actors pass with the bound stated. Review prompt only: pairing across transitions is not syntactic.

Options: machineCalleePattern, spawnChildCallPattern.

createActor(machine, { snapshot: JSON.parse(raw) }); // ❌ fires
useMachine(machine, { snapshot }); // ❌ fires
createActor(machine, { input: { id } }); // ✅ silent
render(view, { snapshot: actor.getSnapshot() }); // ✅ silent: not an actor call

Fires on getPersistedSnapshot() and on createActor / useActor / useMachine / useActorRef with a snapshot key. Review prompt only: storage code and context types span files. The judge checks:

• versioned storage (v6: machine version + machineVersions() migration; v5 snapshots don't restore in v6)
• restore falls back to a fresh actor: an incompatible snapshot yields status 'error', it doesn't throw, so try/catch alone catches nothing
• persists getPersistedSnapshot(), never getSnapshot(); @xstate/effect actors can't be restored yet
• context is JSON-serialisable
• no reliance on replayed entry actions
• actor src is named

Options: persistCalleePattern, restoreCalleePattern (both tested against the callee text).

createMachine({});
assign({ canSubmit: true }); // ❌ fires
setup({ types: { context: {} as { status: "idle" | "loading" } } }).createMachine({}); // ❌ fires
createMachine({});
assign({ count: 1 }); // ✅ silent
createMachine({ context: { status: initialStatus, items: [] } }); // ✅ silent: not a literal

Fires on assign(...), enqueue.assign(...), setup-bound <x>.assign(...), v6 context patches (a context returned by a handler or set on a static transition object), the initial context of a createMachine config, and types.context / v6 schemas.context (once when both declare the same field), for can|is|has* flags and status|state|step|phase|mode fields holding a string literal or string union. A review prompt, not a verdict: naming alone can't establish derivability.

Options: contextFlagPattern, stateMirrorPattern, machineFilePattern (tested against the file source; gates the rule to machine files).

createMachine({
  on: {
    ADD: (_, enq) => {
      enq.spawn("todo", { id: "todo" });
    },
  },
}); // ❌ fires
createMachine({
  on: {
    ADD: ({ event }, enq) => {
      enq.spawn("todo", { id: `todo-${event.id}` });
    },
  },
}); // ✅ silent

Fires on enq.spawn, spawnChild / enqueue.spawnChild, or destructured spawn with a fixed string id inside an on.<EVENT> handler. Spawns in entry, after, or the context factory stay silent. A second event spawns a second child under the same id: v6 errors the parent, v5 orphans the first child. The judge accepts per-child ids, a stop of the old child in the same transition, or proof the event can't repeat while the child lives.

Options: spawnChildCallPattern.

const actor = yield * createEffectActor(machine); // ❌ fires: never joined, waited on, or returned
const actor = yield * createEffectActor(machine);
return yield * waitFor(actor, (s) => s.matches("done"), { timeout: "5 seconds" }); // ✅ silent

Fires on createEffectActor(...) bound to a variable the file never passes to join, waitFor, or snapshots (also through pipe), never subscribes to, and never returns. emitted doesn't count: it just ends when the actor errors. Unbound creations such as Layer.effect(...) stay silent.

Options: effectActorCalleePattern, observerNames.