aifsmjs 0.5.8 → 0.6.0

package/dist/index.d.ts

@@ -1,6 +1,13 @@
-import { f as MachineDef, I as Implementations, m as RuntimeOptions, j as Runtime, M as MachineConfig, S as Snapshot, o as StateDef, p as StepResult, A as Action, e as GuardRef, G as Guard, T as TransitionConfig, r as TransitionDef } from './types-DIM7QTtf.js';
-export { a as ActionRef, E as Effect, b as EffectHandler, c as Enqueuer, d as GuardArgs, g as Middleware, h as MiddlewareContext, R as RESET_EVENT_TYPE, i as ResetEvent, k as RuntimeErrorEvent, l as RuntimeEventMap, n as RuntimeTransitionEvent, q as SubMachineDef } from './types-DIM7QTtf.js';
+import { f as MachineDef, I as Implementations, m as RuntimeOptions, j as Runtime, M as MachineConfig, S as Snapshot, o as StateDef, p as StepResult, A as Action, e as GuardRef, G as Guard, T as TransitionConfig, r as TransitionDef } from './types-CrDxFfBx.js';
+export { a as ActionRef, E as Effect, b as EffectHandler, c as Enqueuer, d as GuardArgs, g as Middleware, h as MiddlewareContext, R as RESET_EVENT_TYPE, i as ResetEvent, k as RuntimeErrorEvent, l as RuntimeEventMap, n as RuntimeTransitionEvent, q as SubMachineDef } from './types-CrDxFfBx.js';
 
+/**
+ * Thrown for an invalid machine definition and, since 0.6.0, for argument
+ * misuse at the definition/runtime boundary (`defineMachine`,
+ * `setup().defineMachine`, `createMachine`, `createRuntime`, and the
+ * `send` / `reset` / `subscribe` / `on` / `onTransition` runtime methods).
+ * Messages read `aifsmjs: <subject> must be <constraint>`.
+ */
 declare class InvalidDefinitionError extends Error {
     constructor(message: string);
 }
@@ -26,8 +33,9 @@ declare function defineMachine<Ctx = Record<string, never>, Evt extends {
 }, States extends string = string>(def: MachineConfig<Ctx, Evt, States>): MachineDef<Ctx, Evt, States>;
 /**
  * Curried builder so `States` can be inferred from `keyof states` without
- * `initial` collapsing it to a single literal. Pass `Ctx` and `Evt` as the
- * type arguments; pass the def to the returned `defineMachine`.
+ * `initial` or a transition `target` collapsing it to a single literal. Pass
+ * `Ctx` and `Evt` as the type arguments; pass the def to the returned
+ * `defineMachine`.
  *
  *   const machine = setup<MyCtx, MyEvt>().defineMachine({
  *     id: "m",
@@ -44,7 +52,9 @@ declare function setup<Ctx = Record<string, never>, Evt extends {
     defineMachine: <const States extends string>(def: Readonly<{
         id: string;
         initial: NoInfer<States>;
-        states: Readonly<Record<States, StateDef<Ctx, Evt, States>>>;
+        states: Readonly<{
+            [K in States]: StateDef<Ctx, Evt, NoInfer<States>>;
+        }>;
     }> & (Record<string, never> extends Ctx ? {
         readonly context?: Ctx;
     } : {
@@ -75,6 +85,21 @@ declare class UnknownActionError extends Error {
     readonly actionName: string;
     constructor(actionName: string);
 }
+/**
+ * Thrown (from `step()`, and so from `send()` before anything is committed)
+ * when an action returns a non-nullish primitive (`false`, `0`, `""`, ...) as
+ * the patch for an object context. An object context accepts only a
+ * plain-object patch or `undefined`/`null` (no change).
+ *
+ * `actionName` is the string ref, the inline function's name, or `"<inline>"`
+ * for an anonymous inline action (mirrors guard naming).
+ *
+ * @since 0.6.0
+ */
+declare class InvalidActionResultError extends Error {
+    readonly actionName: string;
+    constructor(actionName: string, patch: unknown);
+}
 /**
  * Compute the next snapshot and collected effects from a single event.
  *
@@ -87,6 +112,7 @@ declare class UnknownActionError extends Error {
  *   6. return { snapshot, effects, changed }
  *
  * The function is pure: it never dispatches effects and never mutates inputs.
+ * Each guard on the path is evaluated at most once.
  */
 declare function step<Ctx, Evt extends {
     type: string;
@@ -98,11 +124,15 @@ declare class RuntimeDisposedError extends Error {
 /**
  * Thrown by `send()` / `reset()` when a sub-machine init or dispose throws.
  *
- * Invariants:
- * - `phase: "init"` — child constructor threw. Parent snapshot was rolled
- *   back to `prev`; no middleware ran; no `'transition'` emitted; no effects.
- * - `phase: "dispose"` — previous child's `dispose()` threw during transition.
- *   Parent snapshot was rolled back to `prev`; child reference is cleared.
+ * Prepare-then-commit: the new child is constructed before the previous one
+ * is disposed. Invariants:
+ * - `phase: "init"` — the new child's constructor threw. The parent snapshot
+ *   is not committed and the previous child (if any) is untouched: still live
+ *   and still returned by `subRuntime()`. No middleware ran, no `'transition'`
+ *   was emitted, no effects were dispatched.
+ * - `phase: "dispose"` — the previous child's `dispose()` threw. The new
+ *   child (if any) was discarded, the parent snapshot is not committed, and
+ *   `subRuntime()` returns `undefined` until the sub state is re-entered.
  * - Never thrown from `runtime.dispose()` cascade (never-throws contract).
  *
  * @since 0.3.0
@@ -115,9 +145,18 @@ declare class SubMachineError extends Error {
 }
 /**
  * Build a thin stateful runtime around a machine. `send()` calls `step()`,
- * runs the read-only middleware pipeline, dispatches effects, and notifies
- * subscribers. The runtime owns an `AbortController`; `dispose()` aborts it
- * and clears all state.
+ * commits, runs the read-only middleware pipeline, dispatches effects, and
+ * notifies subscribers then `'transition'` listeners. `send()`/`reset()` are
+ * run-to-completion: a call made while the runtime is already dispatching
+ * (from middleware, an effect handler, a listener, or a child runtime) is
+ * queued FIFO and processed after the current event's last notification.
+ * The runtime owns an `AbortController`; `dispose()` aborts it and clears all
+ * state.
+ *
+ * Arguments are validated before anything is created: a non-object `def`,
+ * `def.states`, `impl` or `opts`, or a `middleware` option that is not an
+ * array of functions, throws `InvalidDefinitionError`. The rest of `def` is
+ * trusted (build it with `defineMachine` / `setup().defineMachine`).
  */
 declare function createRuntime<Ctx, Evt extends {
     type: string;
@@ -132,12 +171,21 @@ declare function assign<Ctx, Evt>(updater: (args: {
     event: Evt;
 }) => Partial<Ctx>): Action<Ctx, Evt>;
 /**
- * Merge a partial context update into the current context. Plain-object
- * contexts get a shallow merge; non-object contexts get replaced wholesale.
+ * Merge an action's result into the current context. The function never
+ * mutates either argument.
  *
- * The function never mutates either argument.
+ * - `undefined` / `null` patch: `current` is returned unchanged.
+ * - Object context (not an array or `ArrayBuffer` view) + plain-object patch:
+ *   shallow merge into a new object that keeps `current`'s prototype, so a
+ *   class-instance context keeps its methods and untouched fields. Only own
+ *   enumerable (string and symbol) properties are carried; `#private` and
+ *   non-enumerable members are not, so prefer plain-object contexts.
+ * - Object context + non-nullish primitive patch (`false`, `0`, `""`, ...):
+ *   throws {@link InvalidActionResultError} (`actionName` names the action).
+ * - Anything else (a primitive or array context, or a non-plain-object patch
+ *   such as an array or class instance): the patch replaces `current`.
  */
-declare function mergeContext<Ctx>(current: Ctx, patch: Partial<Ctx> | void): Ctx;
+declare function mergeContext<Ctx>(current: Ctx, patch: Partial<Ctx> | void, actionName?: string): Ctx;
 
 declare class UnknownGuardError extends Error {
     readonly guardName: string;
@@ -220,4 +268,4 @@ declare function createSnapshot<C, S extends string>(args: {
     status?: "active" | "final";
 }): Snapshot<C, S>;
 
-export { Action, AsyncGuardError, Guard, GuardRef, Implementations, InvalidDefinitionError, MachineDef, Runtime, RuntimeDisposedError, RuntimeOptions, Snapshot, StateDef, StepResult, SubMachineError, TransitionConfig, TransitionDef, UnknownActionError, UnknownGuardError, assign, createMachine, createRuntime, createSnapshot, deepFreeze, defineMachine, evalGuard, freezeSnapshot, initialSnapshot, isAsyncGuardFn, mergeContext, normalizeTransition, normalizeTransitions, resolveGuard, resolveTransitions, setup, step };
+export { Action, AsyncGuardError, Guard, GuardRef, Implementations, InvalidActionResultError, InvalidDefinitionError, MachineConfig, MachineDef, Runtime, RuntimeDisposedError, RuntimeOptions, Snapshot, StateDef, StepResult, SubMachineError, TransitionConfig, TransitionDef, UnknownActionError, UnknownGuardError, assign, createMachine, createRuntime, createSnapshot, deepFreeze, defineMachine, evalGuard, freezeSnapshot, initialSnapshot, isAsyncGuardFn, mergeContext, normalizeTransition, normalizeTransitions, resolveGuard, resolveTransitions, setup, step };

package/dist/index.js

@@ -1,7 +1,6 @@
-export { InvalidDefinitionError, RESET_EVENT_TYPE, RuntimeDisposedError, SubMachineError, createMachine, createRuntime, defineMachine, initialSnapshot, setup } from './chunk-VZCSHTOI.js';
-export { UnknownActionError, assign, createSnapshot, deepFreeze, freezeSnapshot, mergeContext, normalizeTransition, normalizeTransitions, resolveTransitions, step } from './chunk-ZLQ7HZCE.js';
+export { InvalidDefinitionError, RESET_EVENT_TYPE, RuntimeDisposedError, SubMachineError, createMachine, createRuntime, defineMachine, initialSnapshot, setup } from './chunk-XA24A7VP.js';
+export { InvalidActionResultError, UnknownActionError, assign, createSnapshot, deepFreeze, freezeSnapshot, mergeContext, normalizeTransition, normalizeTransitions, resolveTransitions, step } from './chunk-D6H64FSI.js';
 import './chunk-JKZAOPQC.js';
-export { AsyncGuardError, UnknownGuardError, evalGuard, isAsyncGuardFn, resolveGuard } from './chunk-A7U7QQL5.js';
-import './chunk-PZ5AY32C.js';
+export { AsyncGuardError, UnknownGuardError, evalGuard, isAsyncGuardFn, resolveGuard } from './chunk-SSNKGEVB.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/inspect/index.cjs

@@ -1,7 +1,5 @@
 'use strict';
 
-require('../chunk-Q7SFCCGT.cjs');
-
 // src/inspect/index.ts
 function logger(out = (l) => console.log(l)) {
   return (mw, next) => {

package/dist/inspect/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/inspect/index.ts"],"names":[],"mappings":";;;;;AAUO,SAAS,OACd,GAAA,GAAwE,CAAC,MAAM,OAAA,CAAQ,GAAA,CAAI,CAAC,CAAA,EAC9D;AAC9B,EAAA,OAAO,CAAC,IAAI,IAAA,KAAS;AACnB,IAAA,IAAA,EAAK;AACL,IAAA,IAAI,GAAG,OAAA,EAAS;AACd,MAAA,GAAA,CAAI,CAAA,CAAA,EAAI,EAAA,CAAG,KAAA,CAAM,IAAI,CAAA,EAAA,EAAK,EAAA,CAAG,IAAA,CAAK,KAAK,CAAA,QAAA,EAAM,EAAA,CAAG,IAAA,CAAK,KAAK,IAAI,EAAE,CAAA;AAAA,IAClE;AAAA,EACF,CAAA;AACF;AAaO,SAAS,QAAkE,IAAA,EAGjD;AAC/B,EAAA,OAAO,CAAC,IAAI,IAAA,KAAS;AACnB,IAAA,IAAA,EAAK;AACL,IAAA,IAAI,GAAG,OAAA,EAAS;AACd,MAAA,IAAA,CAAK,OAAA,CAAQ,QAAQ,IAAA,CAAK,GAAA,EAAK,KAAK,SAAA,CAAU,EAAA,CAAG,IAAI,CAAC,CAAA;AAAA,IACxD;AAAA,EACF,CAAA;AACF;AAcO,SAAS,SACd,IAAA,EAC8B;AAC9B,EAAA,OAAO,CAAC,IAAI,IAAA,KAAS;AACnB,IAAA,IAAA,EAAK;AACL,IAAA,IAAA,CAAK,IAAA,CAAK;AAAA,MACR,OAAO,EAAA,CAAG,KAAA;AAAA,MACV,MAAM,EAAA,CAAG,IAAA;AAAA,MACT,MAAM,EAAA,CAAG,IAAA;AAAA,MACT,SAAS,EAAA,CAAG;AAAA,KACb,CAAA;AAAA,EACH,CAAA;AACF","file":"index.cjs","sourcesContent":["import type { Middleware, MiddlewareContext } from \"../fsm/types.js\";\n\nexport type { Middleware, MiddlewareContext } from \"../fsm/types.js\";\n\n/**\n * Log every transition that changed the snapshot. Default formatter:\n *   \"[EVENT_TYPE] oldState → newState\"\n *\n * Pass a custom `out` callback to integrate with structured logging.\n */\nexport function logger<Ctx, Evt extends { type: string }, States extends string>(\n  out: (line: string, ctx: MiddlewareContext<Ctx, Evt, States>) => void = (l) => console.log(l),\n): Middleware<Ctx, Evt, States> {\n  return (mw, next) => {\n    next();\n    if (mw.changed) {\n      out(`[${mw.event.type}] ${mw.prev.value} → ${mw.next.value}`, mw);\n    }\n  };\n}\n\nexport type StorageLike = {\n  setItem(key: string, value: string): void;\n};\n\n/**\n * Persist the latest snapshot to a storage-like sink on every change. The\n * snapshot is JSON-serialised; non-serializable context fields will throw.\n *\n * For replay, pair this with `aifsmjs/replay` and an event log of your own\n * choosing — this middleware only persists the latest snapshot.\n */\nexport function persist<Ctx, Evt extends { type: string }, States extends string>(opts: {\n  key: string;\n  storage: StorageLike;\n}): Middleware<Ctx, Evt, States> {\n  return (mw, next) => {\n    next();\n    if (mw.changed) {\n      opts.storage.setItem(opts.key, JSON.stringify(mw.next));\n    }\n  };\n}\n\n/**\n * Collect every event-snapshot pair into the supplied array. Useful for\n * test assertions, time-travel debugging, or building event logs to feed\n * back into `replay()`.\n */\nexport type RecordedEntry<Ctx, Evt, States extends string> = Readonly<{\n  event: MiddlewareContext<Ctx, Evt, States>[\"event\"];\n  prev: MiddlewareContext<Ctx, Evt, States>[\"prev\"];\n  next: MiddlewareContext<Ctx, Evt, States>[\"next\"];\n  changed: boolean;\n}>;\n\nexport function recorder<Ctx, Evt extends { type: string }, States extends string>(\n  sink: RecordedEntry<Ctx, Evt, States>[],\n): Middleware<Ctx, Evt, States> {\n  return (mw, next) => {\n    next();\n    sink.push({\n      event: mw.event,\n      prev: mw.prev,\n      next: mw.next,\n      changed: mw.changed,\n    });\n  };\n}\n"]}
+{"version":3,"sources":["../../src/inspect/index.ts"],"names":[],"mappings":";;;AAUO,SAAS,OACd,GAAA,GAAwE,CAAC,MAAM,OAAA,CAAQ,GAAA,CAAI,CAAC,CAAA,EAC9D;AAC9B,EAAA,OAAO,CAAC,IAAI,IAAA,KAAS;AACnB,IAAA,IAAA,EAAK;AACL,IAAA,IAAI,GAAG,OAAA,EAAS;AACd,MAAA,GAAA,CAAI,CAAA,CAAA,EAAI,EAAA,CAAG,KAAA,CAAM,IAAI,CAAA,EAAA,EAAK,EAAA,CAAG,IAAA,CAAK,KAAK,CAAA,QAAA,EAAM,EAAA,CAAG,IAAA,CAAK,KAAK,IAAI,EAAE,CAAA;AAAA,IAClE;AAAA,EACF,CAAA;AACF;AAaO,SAAS,QAAkE,IAAA,EAGjD;AAC/B,EAAA,OAAO,CAAC,IAAI,IAAA,KAAS;AACnB,IAAA,IAAA,EAAK;AACL,IAAA,IAAI,GAAG,OAAA,EAAS;AACd,MAAA,IAAA,CAAK,OAAA,CAAQ,QAAQ,IAAA,CAAK,GAAA,EAAK,KAAK,SAAA,CAAU,EAAA,CAAG,IAAI,CAAC,CAAA;AAAA,IACxD;AAAA,EACF,CAAA;AACF;AAcO,SAAS,SACd,IAAA,EAC8B;AAC9B,EAAA,OAAO,CAAC,IAAI,IAAA,KAAS;AACnB,IAAA,IAAA,EAAK;AACL,IAAA,IAAA,CAAK,IAAA,CAAK;AAAA,MACR,OAAO,EAAA,CAAG,KAAA;AAAA,MACV,MAAM,EAAA,CAAG,IAAA;AAAA,MACT,MAAM,EAAA,CAAG,IAAA;AAAA,MACT,SAAS,EAAA,CAAG;AAAA,KACb,CAAA;AAAA,EACH,CAAA;AACF","file":"index.cjs","sourcesContent":["import type { Middleware, MiddlewareContext } from \"../fsm/types.js\";\n\nexport type { Middleware, MiddlewareContext } from \"../fsm/types.js\";\n\n/**\n * Log every transition that changed the snapshot. Default formatter:\n *   \"[EVENT_TYPE] oldState → newState\"\n *\n * Pass a custom `out` callback to integrate with structured logging.\n */\nexport function logger<Ctx, Evt extends { type: string }, States extends string>(\n  out: (line: string, ctx: MiddlewareContext<Ctx, Evt, States>) => void = (l) => console.log(l),\n): Middleware<Ctx, Evt, States> {\n  return (mw, next) => {\n    next();\n    if (mw.changed) {\n      out(`[${mw.event.type}] ${mw.prev.value} → ${mw.next.value}`, mw);\n    }\n  };\n}\n\nexport type StorageLike = {\n  setItem(key: string, value: string): void;\n};\n\n/**\n * Persist the latest snapshot to a storage-like sink on every change. The\n * snapshot is JSON-serialised; non-serializable context fields will throw.\n *\n * For replay, pair this with `aifsmjs/replay` and an event log of your own\n * choosing — this middleware only persists the latest snapshot.\n */\nexport function persist<Ctx, Evt extends { type: string }, States extends string>(opts: {\n  key: string;\n  storage: StorageLike;\n}): Middleware<Ctx, Evt, States> {\n  return (mw, next) => {\n    next();\n    if (mw.changed) {\n      opts.storage.setItem(opts.key, JSON.stringify(mw.next));\n    }\n  };\n}\n\n/**\n * Collect every event-snapshot pair into the supplied array. Useful for\n * test assertions, time-travel debugging, or building event logs to feed\n * back into `replay()`.\n */\nexport type RecordedEntry<Ctx, Evt, States extends string> = Readonly<{\n  event: MiddlewareContext<Ctx, Evt, States>[\"event\"];\n  prev: MiddlewareContext<Ctx, Evt, States>[\"prev\"];\n  next: MiddlewareContext<Ctx, Evt, States>[\"next\"];\n  changed: boolean;\n}>;\n\nexport function recorder<Ctx, Evt extends { type: string }, States extends string>(\n  sink: RecordedEntry<Ctx, Evt, States>[],\n): Middleware<Ctx, Evt, States> {\n  return (mw, next) => {\n    next();\n    sink.push({\n      event: mw.event,\n      prev: mw.prev,\n      next: mw.next,\n      changed: mw.changed,\n    });\n  };\n}\n"]}

package/dist/inspect/index.d.cts

@@ -1,4 +1,4 @@
-import { h as MiddlewareContext, g as Middleware } from '../types-DIM7QTtf.cjs';
+import { h as MiddlewareContext, g as Middleware } from '../types-CrDxFfBx.cjs';
 
 /**
  * Log every transition that changed the snapshot. Default formatter:

package/dist/inspect/index.d.ts

@@ -1,4 +1,4 @@
-import { h as MiddlewareContext, g as Middleware } from '../types-DIM7QTtf.js';
+import { h as MiddlewareContext, g as Middleware } from '../types-CrDxFfBx.js';
 
 /**
  * Log every transition that changed the snapshot. Default formatter:

package/dist/inspect/index.js

@@ -1,5 +1,3 @@
-import '../chunk-PZ5AY32C.js';
-
 // src/inspect/index.ts
 function logger(out = (l) => console.log(l)) {
   return (mw, next) => {

package/dist/inspect/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/inspect/index.ts"],"names":[],"mappings":";;;AAUO,SAAS,OACd,GAAA,GAAwE,CAAC,MAAM,OAAA,CAAQ,GAAA,CAAI,CAAC,CAAA,EAC9D;AAC9B,EAAA,OAAO,CAAC,IAAI,IAAA,KAAS;AACnB,IAAA,IAAA,EAAK;AACL,IAAA,IAAI,GAAG,OAAA,EAAS;AACd,MAAA,GAAA,CAAI,CAAA,CAAA,EAAI,EAAA,CAAG,KAAA,CAAM,IAAI,CAAA,EAAA,EAAK,EAAA,CAAG,IAAA,CAAK,KAAK,CAAA,QAAA,EAAM,EAAA,CAAG,IAAA,CAAK,KAAK,IAAI,EAAE,CAAA;AAAA,IAClE;AAAA,EACF,CAAA;AACF;AAaO,SAAS,QAAkE,IAAA,EAGjD;AAC/B,EAAA,OAAO,CAAC,IAAI,IAAA,KAAS;AACnB,IAAA,IAAA,EAAK;AACL,IAAA,IAAI,GAAG,OAAA,EAAS;AACd,MAAA,IAAA,CAAK,OAAA,CAAQ,QAAQ,IAAA,CAAK,GAAA,EAAK,KAAK,SAAA,CAAU,EAAA,CAAG,IAAI,CAAC,CAAA;AAAA,IACxD;AAAA,EACF,CAAA;AACF;AAcO,SAAS,SACd,IAAA,EAC8B;AAC9B,EAAA,OAAO,CAAC,IAAI,IAAA,KAAS;AACnB,IAAA,IAAA,EAAK;AACL,IAAA,IAAA,CAAK,IAAA,CAAK;AAAA,MACR,OAAO,EAAA,CAAG,KAAA;AAAA,MACV,MAAM,EAAA,CAAG,IAAA;AAAA,MACT,MAAM,EAAA,CAAG,IAAA;AAAA,MACT,SAAS,EAAA,CAAG;AAAA,KACb,CAAA;AAAA,EACH,CAAA;AACF","file":"index.js","sourcesContent":["import type { Middleware, MiddlewareContext } from \"../fsm/types.js\";\n\nexport type { Middleware, MiddlewareContext } from \"../fsm/types.js\";\n\n/**\n * Log every transition that changed the snapshot. Default formatter:\n *   \"[EVENT_TYPE] oldState → newState\"\n *\n * Pass a custom `out` callback to integrate with structured logging.\n */\nexport function logger<Ctx, Evt extends { type: string }, States extends string>(\n  out: (line: string, ctx: MiddlewareContext<Ctx, Evt, States>) => void = (l) => console.log(l),\n): Middleware<Ctx, Evt, States> {\n  return (mw, next) => {\n    next();\n    if (mw.changed) {\n      out(`[${mw.event.type}] ${mw.prev.value} → ${mw.next.value}`, mw);\n    }\n  };\n}\n\nexport type StorageLike = {\n  setItem(key: string, value: string): void;\n};\n\n/**\n * Persist the latest snapshot to a storage-like sink on every change. The\n * snapshot is JSON-serialised; non-serializable context fields will throw.\n *\n * For replay, pair this with `aifsmjs/replay` and an event log of your own\n * choosing — this middleware only persists the latest snapshot.\n */\nexport function persist<Ctx, Evt extends { type: string }, States extends string>(opts: {\n  key: string;\n  storage: StorageLike;\n}): Middleware<Ctx, Evt, States> {\n  return (mw, next) => {\n    next();\n    if (mw.changed) {\n      opts.storage.setItem(opts.key, JSON.stringify(mw.next));\n    }\n  };\n}\n\n/**\n * Collect every event-snapshot pair into the supplied array. Useful for\n * test assertions, time-travel debugging, or building event logs to feed\n * back into `replay()`.\n */\nexport type RecordedEntry<Ctx, Evt, States extends string> = Readonly<{\n  event: MiddlewareContext<Ctx, Evt, States>[\"event\"];\n  prev: MiddlewareContext<Ctx, Evt, States>[\"prev\"];\n  next: MiddlewareContext<Ctx, Evt, States>[\"next\"];\n  changed: boolean;\n}>;\n\nexport function recorder<Ctx, Evt extends { type: string }, States extends string>(\n  sink: RecordedEntry<Ctx, Evt, States>[],\n): Middleware<Ctx, Evt, States> {\n  return (mw, next) => {\n    next();\n    sink.push({\n      event: mw.event,\n      prev: mw.prev,\n      next: mw.next,\n      changed: mw.changed,\n    });\n  };\n}\n"]}
+{"version":3,"sources":["../../src/inspect/index.ts"],"names":[],"mappings":";AAUO,SAAS,OACd,GAAA,GAAwE,CAAC,MAAM,OAAA,CAAQ,GAAA,CAAI,CAAC,CAAA,EAC9D;AAC9B,EAAA,OAAO,CAAC,IAAI,IAAA,KAAS;AACnB,IAAA,IAAA,EAAK;AACL,IAAA,IAAI,GAAG,OAAA,EAAS;AACd,MAAA,GAAA,CAAI,CAAA,CAAA,EAAI,EAAA,CAAG,KAAA,CAAM,IAAI,CAAA,EAAA,EAAK,EAAA,CAAG,IAAA,CAAK,KAAK,CAAA,QAAA,EAAM,EAAA,CAAG,IAAA,CAAK,KAAK,IAAI,EAAE,CAAA;AAAA,IAClE;AAAA,EACF,CAAA;AACF;AAaO,SAAS,QAAkE,IAAA,EAGjD;AAC/B,EAAA,OAAO,CAAC,IAAI,IAAA,KAAS;AACnB,IAAA,IAAA,EAAK;AACL,IAAA,IAAI,GAAG,OAAA,EAAS;AACd,MAAA,IAAA,CAAK,OAAA,CAAQ,QAAQ,IAAA,CAAK,GAAA,EAAK,KAAK,SAAA,CAAU,EAAA,CAAG,IAAI,CAAC,CAAA;AAAA,IACxD;AAAA,EACF,CAAA;AACF;AAcO,SAAS,SACd,IAAA,EAC8B;AAC9B,EAAA,OAAO,CAAC,IAAI,IAAA,KAAS;AACnB,IAAA,IAAA,EAAK;AACL,IAAA,IAAA,CAAK,IAAA,CAAK;AAAA,MACR,OAAO,EAAA,CAAG,KAAA;AAAA,MACV,MAAM,EAAA,CAAG,IAAA;AAAA,MACT,MAAM,EAAA,CAAG,IAAA;AAAA,MACT,SAAS,EAAA,CAAG;AAAA,KACb,CAAA;AAAA,EACH,CAAA;AACF","file":"index.js","sourcesContent":["import type { Middleware, MiddlewareContext } from \"../fsm/types.js\";\n\nexport type { Middleware, MiddlewareContext } from \"../fsm/types.js\";\n\n/**\n * Log every transition that changed the snapshot. Default formatter:\n *   \"[EVENT_TYPE] oldState → newState\"\n *\n * Pass a custom `out` callback to integrate with structured logging.\n */\nexport function logger<Ctx, Evt extends { type: string }, States extends string>(\n  out: (line: string, ctx: MiddlewareContext<Ctx, Evt, States>) => void = (l) => console.log(l),\n): Middleware<Ctx, Evt, States> {\n  return (mw, next) => {\n    next();\n    if (mw.changed) {\n      out(`[${mw.event.type}] ${mw.prev.value} → ${mw.next.value}`, mw);\n    }\n  };\n}\n\nexport type StorageLike = {\n  setItem(key: string, value: string): void;\n};\n\n/**\n * Persist the latest snapshot to a storage-like sink on every change. The\n * snapshot is JSON-serialised; non-serializable context fields will throw.\n *\n * For replay, pair this with `aifsmjs/replay` and an event log of your own\n * choosing — this middleware only persists the latest snapshot.\n */\nexport function persist<Ctx, Evt extends { type: string }, States extends string>(opts: {\n  key: string;\n  storage: StorageLike;\n}): Middleware<Ctx, Evt, States> {\n  return (mw, next) => {\n    next();\n    if (mw.changed) {\n      opts.storage.setItem(opts.key, JSON.stringify(mw.next));\n    }\n  };\n}\n\n/**\n * Collect every event-snapshot pair into the supplied array. Useful for\n * test assertions, time-travel debugging, or building event logs to feed\n * back into `replay()`.\n */\nexport type RecordedEntry<Ctx, Evt, States extends string> = Readonly<{\n  event: MiddlewareContext<Ctx, Evt, States>[\"event\"];\n  prev: MiddlewareContext<Ctx, Evt, States>[\"prev\"];\n  next: MiddlewareContext<Ctx, Evt, States>[\"next\"];\n  changed: boolean;\n}>;\n\nexport function recorder<Ctx, Evt extends { type: string }, States extends string>(\n  sink: RecordedEntry<Ctx, Evt, States>[],\n): Middleware<Ctx, Evt, States> {\n  return (mw, next) => {\n    next();\n    sink.push({\n      event: mw.event,\n      prev: mw.prev,\n      next: mw.next,\n      changed: mw.changed,\n    });\n  };\n}\n"]}

package/dist/pbt/index.cjs

@@ -1,12 +1,12 @@
 'use strict';
 
-var chunk2MME5V4F_cjs = require('../chunk-2MME5V4F.cjs');
-var chunkFHTQ7LSQ_cjs = require('../chunk-FHTQ7LSQ.cjs');
-var chunkI354FONA_cjs = require('../chunk-I354FONA.cjs');
+var chunkYK25NVFC_cjs = require('../chunk-YK25NVFC.cjs');
+var chunkVV5TKFQO_cjs = require('../chunk-VV5TKFQO.cjs');
+var chunkVGLF5NQH_cjs = require('../chunk-VGLF5NQH.cjs');
 require('../chunk-3B2USJ3H.cjs');
-require('../chunk-CDK25FTD.cjs');
-var chunkQ7SFCCGT_cjs = require('../chunk-Q7SFCCGT.cjs');
+var chunkQCTA2X4J_cjs = require('../chunk-QCTA2X4J.cjs');
 var fc2 = require('fast-check');
+var util = require('util');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -52,7 +52,7 @@ var SendCommand = class {
     const before = r.getSnapshot();
     r.send(this.event);
     const after = r.getSnapshot();
-    const predicted = chunkI354FONA_cjs.step(this.def, before, this.event, this.impl);
+    const predicted = chunkVGLF5NQH_cjs.step(this.def, before, this.event, this.impl);
     if (predicted.snapshot.value !== after.value) {
       throw new Error(
         `aifsmjs/pbt: determinism violation \u2014 predicted "${String(predicted.snapshot.value)}" but runtime returned "${String(after.value)}" after ${this.toString()}`
@@ -74,18 +74,6 @@ function commandsFromMachine(def, impl, eventArbitraries) {
   }
   return fc2__namespace.commands(arbs, { size: "+1" });
 }
-
-// src/pbt/properties.ts
-var properties_exports = {};
-chunkQ7SFCCGT_cjs.__export(properties_exports, {
-  assertAll: () => assertAll,
-  assignDoesNotMutate: () => assignDoesNotMutate,
-  guardsFalseNoTransition: () => guardsFalseNoTransition,
-  reachableStatesSubsetDeclared: () => reachableStatesSubsetDeclared,
-  replayEqualsFold: () => replayEqualsFold,
-  snapshotAlwaysFrozen: () => snapshotAlwaysFrozen,
-  unknownEventNoOp: () => unknownEventNoOp
-});
 function buildAssertOpts(opts) {
   const out = {};
   if (opts?.numRuns !== void 0) out.numRuns = opts.numRuns;
@@ -93,13 +81,20 @@ function buildAssertOpts(opts) {
   if (opts?.verbose) out.verbose = true;
   return out;
 }
+function contextEquals(a, b) {
+  return util.isDeepStrictEqual(a, b);
+}
 function snapshotAlwaysFrozen(def, impl, eventArbitraries, opts) {
   fc2__namespace.assert(
     fc2__namespace.property(commandsFromMachine(def, impl, eventArbitraries), (cmds) => {
-      const real = chunk2MME5V4F_cjs.createRuntime(def, impl);
-      const model = initialModel(def);
-      fc2__namespace.modelRun(() => ({ model, real }), cmds);
-      return Object.isFrozen(real.getSnapshot());
+      const real = chunkYK25NVFC_cjs.createRuntime(def, impl, { dispatchEffects: false });
+      try {
+        const model = initialModel(def);
+        fc2__namespace.modelRun(() => ({ model, real }), cmds);
+        return Object.isFrozen(real.getSnapshot());
+      } finally {
+        real.dispose();
+      }
     }),
     buildAssertOpts(opts)
   );
@@ -107,8 +102,8 @@ function snapshotAlwaysFrozen(def, impl, eventArbitraries, opts) {
 function unknownEventNoOp(def, impl, unknownType, opts) {
   fc2__namespace.assert(
     fc2__namespace.property(fc2__namespace.constant(unknownType), (t) => {
-      const initial = chunk2MME5V4F_cjs.initialSnapshot(def);
-      const result = chunkI354FONA_cjs.step(def, initial, { type: t }, impl);
+      const initial = chunkYK25NVFC_cjs.initialSnapshot(def);
+      const result = chunkVGLF5NQH_cjs.step(def, initial, { type: t }, impl);
       return result.changed === false && result.snapshot === initial && result.effects.length === 0;
     }),
     buildAssertOpts(opts)
@@ -118,13 +113,17 @@ function reachableStatesSubsetDeclared(def, impl, eventArbitraries, opts) {
   const declared = new Set(Object.keys(def.states));
   fc2__namespace.assert(
     fc2__namespace.property(commandsFromMachine(def, impl, eventArbitraries), (cmds) => {
-      const real = chunk2MME5V4F_cjs.createRuntime(def, impl);
-      const model = initialModel(def);
-      fc2__namespace.modelRun(() => ({ model, real }), cmds);
-      for (const s of model.reached) {
-        if (!declared.has(s)) return false;
+      const real = chunkYK25NVFC_cjs.createRuntime(def, impl, { dispatchEffects: false });
+      try {
+        const model = initialModel(def);
+        fc2__namespace.modelRun(() => ({ model, real }), cmds);
+        for (const s of model.reached) {
+          if (!declared.has(s)) return false;
+        }
+        return declared.has(real.getSnapshot().value);
+      } finally {
+        real.dispose();
       }
-      return declared.has(real.getSnapshot().value);
     }),
     buildAssertOpts(opts)
   );
@@ -133,11 +132,15 @@ function replayEqualsFold(def, impl, eventArbitraries, opts) {
   const eventArb = fc2__namespace.oneof(...Object.values(eventArbitraries));
   fc2__namespace.assert(
     fc2__namespace.property(fc2__namespace.array(eventArb, { maxLength: 32 }), (events) => {
-      const real = chunk2MME5V4F_cjs.createRuntime(def, impl, { dispatchEffects: false });
-      for (const e of events) real.send(e);
-      const live = real.getSnapshot();
-      const replayed = chunkFHTQ7LSQ_cjs.replay(chunk2MME5V4F_cjs.initialSnapshot(def), events, def, impl).snapshot;
-      return live.value === replayed.value && JSON.stringify(live.context) === JSON.stringify(replayed.context);
+      const real = chunkYK25NVFC_cjs.createRuntime(def, impl, { dispatchEffects: false });
+      try {
+        for (const e of events) real.send(e);
+        const live = real.getSnapshot();
+        const replayed = chunkVV5TKFQO_cjs.replay(chunkYK25NVFC_cjs.initialSnapshot(def), events, def, impl).snapshot;
+        return live.value === replayed.value && contextEquals(live.context, replayed.context);
+      } finally {
+        real.dispose();
+      }
     }),
     buildAssertOpts(opts)
   );
@@ -146,7 +149,8 @@ function guardsFalseNoTransition(def, impl, eventArbitraries, opts) {
   const blockedGuards = new Proxy(
     {},
     {
-      get: () => () => false
+      get: () => () => false,
+      getOwnPropertyDescriptor: () => ({ configurable: true })
     }
   );
   const blockedImpl = {
@@ -154,17 +158,17 @@ function guardsFalseNoTransition(def, impl, eventArbitraries, opts) {
     guards: blockedGuards
   };
   const isFullyGuarded = (value, eventType) => {
-    const candidates = chunkI354FONA_cjs.normalizeTransitions(def.states[value]?.on?.[eventType]);
+    const candidates = chunkVGLF5NQH_cjs.normalizeTransitions(chunkQCTA2X4J_cjs.ownValue(def.states[value]?.on, eventType));
     return candidates.length > 0 && candidates.every((t) => t.guard !== void 0);
   };
   fc2__namespace.assert(
     fc2__namespace.property(
       fc2__namespace.array(fc2__namespace.oneof(...Object.values(eventArbitraries)), { maxLength: 16 }),
       (events) => {
-        let snap = chunk2MME5V4F_cjs.initialSnapshot(def);
+        let snap = chunkYK25NVFC_cjs.initialSnapshot(def);
         for (const e of events) {
           const fullyGuarded = isFullyGuarded(snap.value, e.type);
-          const r = chunkI354FONA_cjs.step(def, snap, e, blockedImpl);
+          const r = chunkVGLF5NQH_cjs.step(def, snap, e, blockedImpl);
           if (fullyGuarded && r.changed !== false) return false;
           snap = r.snapshot;
         }
@@ -174,20 +178,28 @@ function guardsFalseNoTransition(def, impl, eventArbitraries, opts) {
     buildAssertOpts(opts)
   );
 }
+var ownState = (v) => [
+  ...Reflect.ownKeys(v).flatMap((k) => [k, v[k]]),
+  ...v instanceof Map || v instanceof Set ? [...v.entries()].flat() : [],
+  v instanceof Date && v.getTime()
+];
 function assignDoesNotMutate(def, impl, eventArbitraries, opts) {
-  const dummy = { a: 1, b: 2 };
-  const merged = chunkI354FONA_cjs.mergeContext(dummy, { b: 3 });
-  if (merged === dummy) throw new Error("aifsmjs/pbt: mergeContext returned the same reference");
   fc2__namespace.assert(
     fc2__namespace.property(
       fc2__namespace.array(fc2__namespace.oneof(...Object.values(eventArbitraries)), { maxLength: 16 }),
       (events) => {
-        let snap = chunk2MME5V4F_cjs.initialSnapshot(def);
+        let snap = chunkYK25NVFC_cjs.initialSnapshot(def);
         for (const e of events) {
-          const beforeCtxSerialised = JSON.stringify(snap.context);
-          chunkI354FONA_cjs.step(def, snap, e, impl);
-          if (JSON.stringify(snap.context) !== beforeCtxSerialised) return false;
-          snap = chunkI354FONA_cjs.step(def, snap, e, impl).snapshot;
+          const before = /* @__PURE__ */ new Map();
+          const walk = (v) => {
+            if (!v || typeof v !== "object" || before.has(v)) return;
+            const own = ownState(v);
+            before.set(v, own);
+            own.forEach(walk);
+          };
+          walk(snap.context);
+          snap = chunkVGLF5NQH_cjs.step(def, snap, e, impl).snapshot;
+          for (const [obj, own] of before) if (!contextEquals(ownState(obj), own)) return false;
         }
         return true;
       }
@@ -205,7 +217,16 @@ function assertAll(def, impl, eventArbitraries, opts) {
 }
 
 // src/pbt/index.ts
-var properties = properties_exports;
+var properties = Object.freeze({
+  assertAll,
+  assignDoesNotMutate,
+  contextEquals,
+  guardsFalseNoTransition,
+  reachableStatesSubsetDeclared,
+  replayEqualsFold,
+  snapshotAlwaysFrozen,
+  unknownEventNoOp
+});
 
 exports.assertAll = assertAll;
 exports.assignDoesNotMutate = assignDoesNotMutate;

package/dist/pbt/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/pbt/commands.ts","../../src/pbt/properties.ts","../../src/pbt/index.ts"],"names":["step","fc","__export","fc2","createRuntime","initialSnapshot","replay","normalizeTransitions","mergeContext"],"mappings":"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","file":"index.cjs","sourcesContent":["import * as fc from \"fast-check\";\nimport { step } from \"../fsm/lifecycle.js\";\nimport type { Implementations, MachineDef, Runtime, Snapshot } from \"../fsm/types.js\";\n\n/**\n * Pure-model representation of an FSM run, used by `fc.commands`.\n * `reached` tracks every state visited so generic properties can check\n * containment without re-running.\n */\nexport type FsmModel<Ctx, States extends string> = {\n  value: States;\n  context: Ctx;\n  status: \"active\" | \"final\";\n  reached: Set<States>;\n};\n\nexport type EventArbitraries<Evt extends { type: string }> = Readonly<\n  Record<string, fc.Arbitrary<Evt>>\n>;\n\nexport type FsmCommand<Ctx, Evt extends { type: string }, States extends string> = fc.Command<\n  FsmModel<Ctx, States>,\n  Runtime<Ctx, Evt, States>\n>;\n\nexport function initialModel<Ctx, Evt extends { type: string }, States extends string>(\n  def: MachineDef<Ctx, Evt, States>,\n): FsmModel<Ctx, States> {\n  return {\n    value: def.initial,\n    context: def.context,\n    status: def.states[def.initial]?.final ? \"final\" : \"active\",\n    reached: new Set([def.initial]),\n  };\n}\n\nclass SendCommand<Ctx, Evt extends { type: string }, States extends string>\n  implements FsmCommand<Ctx, Evt, States>\n{\n  constructor(\n    private readonly event: Evt,\n    private readonly def: MachineDef<Ctx, Evt, States>,\n    private readonly impl: Implementations<Ctx, Evt>,\n  ) {}\n\n  check(_m: Readonly<FsmModel<Ctx, States>>): boolean {\n    // Every event is always applicable; invariants are asserted in run().\n    return true;\n  }\n\n  run(m: FsmModel<Ctx, States>, r: Runtime<Ctx, Evt, States>): void {\n    const before: Snapshot<Ctx, States> = r.getSnapshot();\n    r.send(this.event);\n    const after = r.getSnapshot();\n\n    const predicted = step(this.def, before, this.event, this.impl);\n\n    /* v8 ignore start — invariant guard: fires only when the live runtime\n       diverges from the pure step() prediction, i.e. an internal bug. */\n    if (predicted.snapshot.value !== after.value) {\n      throw new Error(\n        `aifsmjs/pbt: determinism violation — predicted \"${String(predicted.snapshot.value)}\" but runtime returned \"${String(after.value)}\" after ${this.toString()}`,\n      );\n    }\n    /* v8 ignore stop */\n\n    m.value = after.value;\n    m.context = after.context as Ctx;\n    m.status = after.status;\n    m.reached.add(after.value);\n  }\n\n  toString(): string {\n    return `send(${JSON.stringify(this.event)})`;\n  }\n}\n\n/**\n * Build an `fc.Arbitrary` of FSM command sequences. Each command pulls one\n * event from the user-supplied arbitrary map and, when run, asserts that the\n * pure `step()` prediction matches the runtime's observable outcome.\n *\n * Pair this arbitrary with `fc.property(...)` inside a `fc.assert(...)` call,\n * or use the helpers in `aifsmjs/pbt` properties to get the six generic\n * invariants for free.\n */\nexport function commandsFromMachine<Ctx, Evt extends { type: string }, States extends string>(\n  def: MachineDef<Ctx, Evt, States>,\n  impl: Implementations<Ctx, Evt>,\n  eventArbitraries: EventArbitraries<Evt>,\n): fc.Arbitrary<Iterable<FsmCommand<Ctx, Evt, States>>> {\n  const arbs: fc.Arbitrary<FsmCommand<Ctx, Evt, States>>[] = [];\n  for (const arb of Object.values(eventArbitraries)) {\n    arbs.push(arb.map((event) => new SendCommand(event, def, impl)));\n  }\n  return fc.commands(arbs, { size: \"+1\" });\n}\n","import * as fc from \"fast-check\";\nimport { initialSnapshot } from \"../fsm/definition.js\";\nimport { step } from \"../fsm/lifecycle.js\";\nimport { normalizeTransitions } from \"../fsm/resolver.js\";\nimport { createRuntime } from \"../fsm/runtime.js\";\nimport type { Guard, Implementations, MachineDef } from \"../fsm/types.js\";\nimport { mergeContext } from \"../fsm/updater.js\";\nimport { replay } from \"../replay/index.js\";\nimport {\n  type EventArbitraries,\n  type FsmModel,\n  commandsFromMachine,\n  initialModel,\n} from \"./commands.js\";\n\nexport type AssertOpts = Readonly<{\n  numRuns?: number;\n  seed?: number;\n  verbose?: boolean;\n}>;\n\nfunction buildAssertOpts(opts: AssertOpts | undefined): fc.Parameters<unknown> {\n  const out: fc.Parameters<unknown> = {};\n  if (opts?.numRuns !== undefined) out.numRuns = opts.numRuns;\n  if (opts?.seed !== undefined) out.seed = opts.seed;\n  if (opts?.verbose) out.verbose = true;\n  return out;\n}\n\n/**\n * #1 snapshotAlwaysFrozen — after any event sequence the live snapshot remains\n * frozen at the top level.\n */\nexport function snapshotAlwaysFrozen<Ctx, Evt extends { type: string }, States extends string>(\n  def: MachineDef<Ctx, Evt, States>,\n  impl: Implementations<Ctx, Evt>,\n  eventArbitraries: EventArbitraries<Evt>,\n  opts?: AssertOpts,\n): void {\n  fc.assert(\n    fc.property(commandsFromMachine(def, impl, eventArbitraries), (cmds) => {\n      const real = createRuntime(def, impl);\n      const model: FsmModel<Ctx, States> = initialModel(def);\n      fc.modelRun(() => ({ model, real }), cmds);\n      return Object.isFrozen(real.getSnapshot());\n    }),\n    buildAssertOpts(opts),\n  );\n}\n\n/**\n * #2 unknownEventNoOp — sending an event whose `type` is not declared in any\n * state's `on` map never changes the snapshot.\n */\nexport function unknownEventNoOp<Ctx, Evt extends { type: string }, States extends string>(\n  def: MachineDef<Ctx, Evt, States>,\n  impl: Implementations<Ctx, Evt>,\n  unknownType: string,\n  opts?: AssertOpts,\n): void {\n  fc.assert(\n    fc.property(fc.constant(unknownType), (t) => {\n      const initial = initialSnapshot(def);\n      const result = step(def, initial, { type: t } as unknown as Evt, impl);\n      return result.changed === false && result.snapshot === initial && result.effects.length === 0;\n    }),\n    buildAssertOpts(opts),\n  );\n}\n\n/**\n * #3 reachableStatesSubsetDeclared — every state visited during a run belongs\n * to `def.states`.\n */\nexport function reachableStatesSubsetDeclared<\n  Ctx,\n  Evt extends { type: string },\n  States extends string,\n>(\n  def: MachineDef<Ctx, Evt, States>,\n  impl: Implementations<Ctx, Evt>,\n  eventArbitraries: EventArbitraries<Evt>,\n  opts?: AssertOpts,\n): void {\n  const declared = new Set<string>(Object.keys(def.states));\n  fc.assert(\n    fc.property(commandsFromMachine(def, impl, eventArbitraries), (cmds) => {\n      const real = createRuntime(def, impl);\n      const model: FsmModel<Ctx, States> = initialModel(def);\n      fc.modelRun(() => ({ model, real }), cmds);\n      for (const s of model.reached as Set<string>) {\n        /* v8 ignore next — property failure branch; an unreachable state would indicate a bug. */\n        if (!declared.has(s)) return false;\n      }\n      return declared.has(real.getSnapshot().value);\n    }),\n    buildAssertOpts(opts),\n  );\n}\n\n/**\n * #4 replayEqualsFold — `replay(initial, log)` produces the same final state\n * as a live runtime fed the same events. Effects dispatched by the runtime are\n * ignored; the comparison is on `{ value, context }`.\n */\nexport function replayEqualsFold<Ctx, Evt extends { type: string }, States extends string>(\n  def: MachineDef<Ctx, Evt, States>,\n  impl: Implementations<Ctx, Evt>,\n  eventArbitraries: EventArbitraries<Evt>,\n  opts?: AssertOpts,\n): void {\n  const eventArb = fc.oneof(...Object.values(eventArbitraries));\n  fc.assert(\n    fc.property(fc.array(eventArb, { maxLength: 32 }), (events) => {\n      const real = createRuntime(def, impl, { dispatchEffects: false });\n      for (const e of events) real.send(e);\n      const live = real.getSnapshot();\n      const replayed = replay(initialSnapshot(def), events, def, impl).snapshot;\n      return (\n        live.value === replayed.value &&\n        JSON.stringify(live.context) === JSON.stringify(replayed.context)\n      );\n    }),\n    buildAssertOpts(opts),\n  );\n}\n\n/**\n * #5 guardsFalseNoTransition — when every candidate transition for the current\n * (state, event) pair carries a guard and every guard returns `false`, the\n * snapshot is unchanged (`changed === false`).\n *\n * Implementation: synthesise an impl that forces every guard to `false`, then\n * for each step whose candidate list is fully guarded, assert the step did not\n * change state. Steps with an unguarded fallback candidate (which fires even\n * when all guards are false) are skipped — the README claim is specifically\n * about the all-guards-false case.\n */\nexport function guardsFalseNoTransition<Ctx, Evt extends { type: string }, States extends string>(\n  def: MachineDef<Ctx, Evt, States>,\n  impl: Implementations<Ctx, Evt>,\n  eventArbitraries: EventArbitraries<Evt>,\n  opts?: AssertOpts,\n): void {\n  const blockedGuards = new Proxy(\n    {},\n    {\n      get: () => () => false,\n    },\n  ) as Readonly<Record<string, Guard<Ctx, Evt>>>;\n  const blockedImpl: Implementations<Ctx, Evt> = {\n    ...impl,\n    guards: blockedGuards,\n  };\n  // True when every candidate transition for (value, eventType) carries a\n  // guard — i.e. blocking all guards leaves no unconditional fallback, so a\n  // correct step() must report changed === false.\n  const isFullyGuarded = (value: States, eventType: string): boolean => {\n    const candidates = normalizeTransitions(def.states[value]?.on?.[eventType]);\n    return candidates.length > 0 && candidates.every((t) => t.guard !== undefined);\n  };\n  fc.assert(\n    fc.property(\n      fc.array(fc.oneof(...Object.values(eventArbitraries)), { maxLength: 16 }),\n      (events) => {\n        let snap = initialSnapshot(def);\n        for (const e of events) {\n          const fullyGuarded = isFullyGuarded(snap.value, e.type);\n          const r = step(def, snap, e, blockedImpl);\n          // The named invariant: all guards false + no unconditional fallback\n          // ⇒ no transition. Without this assertion the property was vacuous\n          // (it only failed if step() threw).\n          if (fullyGuarded && r.changed !== false) return false;\n          snap = r.snapshot;\n        }\n        return true;\n      },\n    ),\n    buildAssertOpts(opts),\n  );\n}\n\n/**\n * #6 assignDoesNotMutate — running an `assign`-style action never mutates the\n * previous context object. Verified by deep-equality check on a snapshot taken\n * before each event.\n */\nexport function assignDoesNotMutate<Ctx, Evt extends { type: string }, States extends string>(\n  def: MachineDef<Ctx, Evt, States>,\n  impl: Implementations<Ctx, Evt>,\n  eventArbitraries: EventArbitraries<Evt>,\n  opts?: AssertOpts,\n): void {\n  // Quick sanity guard: mergeContext is the only context mutator used by step.\n  const dummy = { a: 1, b: 2 };\n  const merged = mergeContext(dummy, { b: 3 });\n  /* v8 ignore next — invariant guard; mergeContext returning the same ref would mean unit tests have already broken. */\n  if (merged === dummy) throw new Error(\"aifsmjs/pbt: mergeContext returned the same reference\");\n\n  fc.assert(\n    fc.property(\n      fc.array(fc.oneof(...Object.values(eventArbitraries)), { maxLength: 16 }),\n      (events) => {\n        let snap = initialSnapshot(def);\n        for (const e of events) {\n          const beforeCtxSerialised = JSON.stringify(snap.context);\n          step(def, snap, e, impl);\n          /* v8 ignore next — property failure branch; step() mutating snap.context would indicate a bug. */\n          if (JSON.stringify(snap.context) !== beforeCtxSerialised) return false;\n          // Continue with the actual result for subsequent events\n          snap = step(def, snap, e, impl).snapshot;\n        }\n        return true;\n      },\n    ),\n    buildAssertOpts(opts),\n  );\n}\n\n/**\n * Assert every generic property in one call. Use this when you don't need\n * fine-grained control over per-property options.\n */\nexport function assertAll<Ctx, Evt extends { type: string }, States extends string>(\n  def: MachineDef<Ctx, Evt, States>,\n  impl: Implementations<Ctx, Evt>,\n  eventArbitraries: EventArbitraries<Evt>,\n  opts?: AssertOpts & { unknownEventType?: string },\n): void {\n  snapshotAlwaysFrozen(def, impl, eventArbitraries, opts);\n  unknownEventNoOp(def, impl, opts?.unknownEventType ?? \"__AIFSMJS_UNKNOWN__\", opts);\n  reachableStatesSubsetDeclared(def, impl, eventArbitraries, opts);\n  replayEqualsFold(def, impl, eventArbitraries, opts);\n  guardsFalseNoTransition(def, impl, eventArbitraries, opts);\n  assignDoesNotMutate(def, impl, eventArbitraries, opts);\n}\n","export {\n  commandsFromMachine,\n  initialModel,\n  type EventArbitraries,\n  type FsmCommand,\n  type FsmModel,\n} from \"./commands.js\";\n\nexport {\n  assertAll,\n  assignDoesNotMutate,\n  guardsFalseNoTransition,\n  reachableStatesSubsetDeclared,\n  replayEqualsFold,\n  snapshotAlwaysFrozen,\n  unknownEventNoOp,\n  type AssertOpts,\n} from \"./properties.js\";\n\n// Convenience namespace mirroring the README:\n//   import { properties } from \"aifsmjs/pbt\"\n//   properties.snapshotAlwaysFrozen(...)\nimport * as propertiesModule from \"./properties.js\";\nexport const properties = propertiesModule;\n"]}
+{"version":3,"sources":["../../src/pbt/commands.ts","../../src/pbt/properties.ts","../../src/pbt/index.ts"],"names":["step","fc","isDeepStrictEqual","fc2","createRuntime","initialSnapshot","replay","normalizeTransitions","ownValue"],"mappings":"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","file":"index.cjs","sourcesContent":["import * as fc from \"fast-check\";\nimport { step } from \"../fsm/lifecycle.js\";\nimport type { Implementations, MachineDef, Runtime, Snapshot } from \"../fsm/types.js\";\n\n/**\n * Pure-model representation of an FSM run, used by `fc.commands`.\n * `reached` tracks every state visited so generic properties can check\n * containment without re-running.\n */\nexport type FsmModel<Ctx, States extends string> = {\n  value: States;\n  context: Ctx;\n  status: \"active\" | \"final\";\n  reached: Set<States>;\n};\n\nexport type EventArbitraries<Evt extends { type: string }> = Readonly<\n  Record<string, fc.Arbitrary<Evt>>\n>;\n\nexport type FsmCommand<Ctx, Evt extends { type: string }, States extends string> = fc.Command<\n  FsmModel<Ctx, States>,\n  Runtime<Ctx, Evt, States>\n>;\n\nexport function initialModel<Ctx, Evt extends { type: string }, States extends string>(\n  def: MachineDef<Ctx, Evt, States>,\n): FsmModel<Ctx, States> {\n  return {\n    value: def.initial,\n    context: def.context,\n    status: def.states[def.initial]?.final ? \"final\" : \"active\",\n    reached: new Set([def.initial]),\n  };\n}\n\nclass SendCommand<Ctx, Evt extends { type: string }, States extends string>\n  implements FsmCommand<Ctx, Evt, States>\n{\n  constructor(\n    private readonly event: Evt,\n    private readonly def: MachineDef<Ctx, Evt, States>,\n    private readonly impl: Implementations<Ctx, Evt>,\n  ) {}\n\n  check(_m: Readonly<FsmModel<Ctx, States>>): boolean {\n    // Every event is always applicable; invariants are asserted in run().\n    return true;\n  }\n\n  run(m: FsmModel<Ctx, States>, r: Runtime<Ctx, Evt, States>): void {\n    const before: Snapshot<Ctx, States> = r.getSnapshot();\n    r.send(this.event);\n    const after = r.getSnapshot();\n\n    const predicted = step(this.def, before, this.event, this.impl);\n\n    /* v8 ignore start — invariant guard: fires only when the live runtime\n       diverges from the pure step() prediction, i.e. an internal bug. */\n    if (predicted.snapshot.value !== after.value) {\n      throw new Error(\n        `aifsmjs/pbt: determinism violation — predicted \"${String(predicted.snapshot.value)}\" but runtime returned \"${String(after.value)}\" after ${this.toString()}`,\n      );\n    }\n    /* v8 ignore stop */\n\n    m.value = after.value;\n    m.context = after.context as Ctx;\n    m.status = after.status;\n    m.reached.add(after.value);\n  }\n\n  toString(): string {\n    return `send(${JSON.stringify(this.event)})`;\n  }\n}\n\n/**\n * Build an `fc.Arbitrary` of FSM command sequences. Each command pulls one\n * event from the user-supplied arbitrary map and, when run, asserts that the\n * pure `step()` prediction matches the runtime's observable outcome.\n *\n * Pair this arbitrary with `fc.property(...)` inside a `fc.assert(...)` call,\n * or use the helpers in `aifsmjs/pbt` properties to get the six generic\n * invariants for free.\n */\nexport function commandsFromMachine<Ctx, Evt extends { type: string }, States extends string>(\n  def: MachineDef<Ctx, Evt, States>,\n  impl: Implementations<Ctx, Evt>,\n  eventArbitraries: EventArbitraries<Evt>,\n): fc.Arbitrary<Iterable<FsmCommand<Ctx, Evt, States>>> {\n  const arbs: fc.Arbitrary<FsmCommand<Ctx, Evt, States>>[] = [];\n  for (const arb of Object.values(eventArbitraries)) {\n    arbs.push(arb.map((event) => new SendCommand(event, def, impl)));\n  }\n  return fc.commands(arbs, { size: \"+1\" });\n}\n","import { isDeepStrictEqual } from \"node:util\";\nimport * as fc from \"fast-check\";\nimport { initialSnapshot } from \"../fsm/definition.js\";\nimport { ownValue } from \"../fsm/evaluator.js\";\nimport { step } from \"../fsm/lifecycle.js\";\nimport { normalizeTransitions } from \"../fsm/resolver.js\";\nimport { createRuntime } from \"../fsm/runtime.js\";\nimport type { Guard, Implementations, MachineDef } from \"../fsm/types.js\";\nimport { replay } from \"../replay/index.js\";\nimport {\n  type EventArbitraries,\n  type FsmModel,\n  commandsFromMachine,\n  initialModel,\n} from \"./commands.js\";\n\nexport type AssertOpts = Readonly<{\n  numRuns?: number;\n  seed?: number;\n  verbose?: boolean;\n}>;\n\nfunction buildAssertOpts(opts: AssertOpts | undefined): fc.Parameters<unknown> {\n  const out: fc.Parameters<unknown> = {};\n  if (opts?.numRuns !== undefined) out.numRuns = opts.numRuns;\n  if (opts?.seed !== undefined) out.seed = opts.seed;\n  if (opts?.verbose) out.verbose = true;\n  return out;\n}\n\n/**\n * Structural deep-equality for two context values (C3). Backed by `node:util`\n * `isDeepStrictEqual`, replacing the previous `JSON.stringify(a) === JSON.stringify(b)`\n * oracle which was unsound:\n *\n *   - key-order-sensitive  → false-FAIL on `{a:1,b:2}` vs `{b:2,a:1}`;\n *   - drops undefined keys  → false-PASS on `{v:undefined,w:1}` vs `{w:1}`;\n *   - lossy for `Map`/`Set`/`Date` (all serialise to `{}` or an ISO string);\n *   - throws on `BigInt`.\n *\n * `isDeepStrictEqual` distinguishes present-but-undefined from absent keys,\n * compares `Map`/`Set`/`Date` by contents, and tolerates `BigInt` — exactly\n * the verdicts a context-equality oracle for PBT requires. No new dependency\n * (Node built-in; the package already targets Node >=18).\n */\nexport function contextEquals(a: unknown, b: unknown): boolean {\n  return isDeepStrictEqual(a, b);\n}\n\n/**\n * #1 snapshotAlwaysFrozen — after any event sequence the live snapshot remains\n * frozen at the top level.\n */\nexport function snapshotAlwaysFrozen<Ctx, Evt extends { type: string }, States extends string>(\n  def: MachineDef<Ctx, Evt, States>,\n  impl: Implementations<Ctx, Evt>,\n  eventArbitraries: EventArbitraries<Evt>,\n  opts?: AssertOpts,\n): void {\n  fc.assert(\n    fc.property(commandsFromMachine(def, impl, eventArbitraries), (cmds) => {\n      const real = createRuntime(def, impl, { dispatchEffects: false });\n      // Dispose every generated run's runtime (its signal aborts, its child\n      // runtimes are torn down); the asserted value is computed first.\n      try {\n        const model: FsmModel<Ctx, States> = initialModel(def);\n        fc.modelRun(() => ({ model, real }), cmds);\n        return Object.isFrozen(real.getSnapshot());\n      } finally {\n        real.dispose();\n      }\n    }),\n    buildAssertOpts(opts),\n  );\n}\n\n/**\n * #2 unknownEventNoOp — sending an event whose `type` is not declared in any\n * state's `on` map never changes the snapshot.\n */\nexport function unknownEventNoOp<Ctx, Evt extends { type: string }, States extends string>(\n  def: MachineDef<Ctx, Evt, States>,\n  impl: Implementations<Ctx, Evt>,\n  unknownType: string,\n  opts?: AssertOpts,\n): void {\n  fc.assert(\n    fc.property(fc.constant(unknownType), (t) => {\n      const initial = initialSnapshot(def);\n      const result = step(def, initial, { type: t } as unknown as Evt, impl);\n      return result.changed === false && result.snapshot === initial && result.effects.length === 0;\n    }),\n    buildAssertOpts(opts),\n  );\n}\n\n/**\n * #3 reachableStatesSubsetDeclared — every state visited during a run belongs\n * to `def.states`.\n */\nexport function reachableStatesSubsetDeclared<\n  Ctx,\n  Evt extends { type: string },\n  States extends string,\n>(\n  def: MachineDef<Ctx, Evt, States>,\n  impl: Implementations<Ctx, Evt>,\n  eventArbitraries: EventArbitraries<Evt>,\n  opts?: AssertOpts,\n): void {\n  const declared = new Set<string>(Object.keys(def.states));\n  fc.assert(\n    fc.property(commandsFromMachine(def, impl, eventArbitraries), (cmds) => {\n      const real = createRuntime(def, impl, { dispatchEffects: false });\n      try {\n        const model: FsmModel<Ctx, States> = initialModel(def);\n        fc.modelRun(() => ({ model, real }), cmds);\n        for (const s of model.reached as Set<string>) {\n          /* v8 ignore next — property failure branch; an unreachable state would indicate a bug. */\n          if (!declared.has(s)) return false;\n        }\n        return declared.has(real.getSnapshot().value);\n      } finally {\n        real.dispose();\n      }\n    }),\n    buildAssertOpts(opts),\n  );\n}\n\n/**\n * #4 replayEqualsFold — `replay(initial, log)` produces the same final state\n * as a live runtime fed the same events. Effects dispatched by the runtime are\n * ignored; the comparison is on `{ value, context }`.\n */\nexport function replayEqualsFold<Ctx, Evt extends { type: string }, States extends string>(\n  def: MachineDef<Ctx, Evt, States>,\n  impl: Implementations<Ctx, Evt>,\n  eventArbitraries: EventArbitraries<Evt>,\n  opts?: AssertOpts,\n): void {\n  const eventArb = fc.oneof(...Object.values(eventArbitraries));\n  fc.assert(\n    fc.property(fc.array(eventArb, { maxLength: 32 }), (events) => {\n      const real = createRuntime(def, impl, { dispatchEffects: false });\n      try {\n        for (const e of events) real.send(e);\n        const live = real.getSnapshot();\n        const replayed = replay(initialSnapshot(def), events, def, impl).snapshot;\n        return live.value === replayed.value && contextEquals(live.context, replayed.context);\n      } finally {\n        real.dispose();\n      }\n    }),\n    buildAssertOpts(opts),\n  );\n}\n\n/**\n * #5 guardsFalseNoTransition — when every candidate transition for the current\n * (state, event) pair carries a guard and every guard returns `false`, the\n * snapshot is unchanged (`changed === false`).\n *\n * Implementation: synthesise an impl that forces every guard to `false`, then\n * for each step whose candidate list is fully guarded, assert the step did not\n * change state. Steps with an unguarded fallback candidate (which fires even\n * when all guards are false) are skipped — the README claim is specifically\n * about the all-guards-false case.\n */\nexport function guardsFalseNoTransition<Ctx, Evt extends { type: string }, States extends string>(\n  def: MachineDef<Ctx, Evt, States>,\n  impl: Implementations<Ctx, Evt>,\n  eventArbitraries: EventArbitraries<Evt>,\n  opts?: AssertOpts,\n): void {\n  // Every key reads as an own property: step() resolves guard refs with an\n  // own-key lookup (the value itself still comes from `get`), so a `get` trap\n  // alone would surface as UnknownGuardError.\n  const blockedGuards = new Proxy(\n    {},\n    {\n      get: () => () => false,\n      getOwnPropertyDescriptor: () => ({ configurable: true }),\n    },\n  ) as Readonly<Record<string, Guard<Ctx, Evt>>>;\n  const blockedImpl: Implementations<Ctx, Evt> = {\n    ...impl,\n    guards: blockedGuards,\n  };\n  // True when every candidate transition for (value, eventType) carries a\n  // guard — i.e. blocking all guards leaves no unconditional fallback, so a\n  // correct step() must report changed === false.\n  const isFullyGuarded = (value: States, eventType: string): boolean => {\n    const candidates = normalizeTransitions(ownValue(def.states[value]?.on, eventType));\n    return candidates.length > 0 && candidates.every((t) => t.guard !== undefined);\n  };\n  fc.assert(\n    fc.property(\n      fc.array(fc.oneof(...Object.values(eventArbitraries)), { maxLength: 16 }),\n      (events) => {\n        let snap = initialSnapshot(def);\n        for (const e of events) {\n          const fullyGuarded = isFullyGuarded(snap.value, e.type);\n          const r = step(def, snap, e, blockedImpl);\n          // The named invariant: all guards false + no unconditional fallback\n          // ⇒ no transition. Without this assertion the property was vacuous\n          // (it only failed if step() threw).\n          if (fullyGuarded && r.changed !== false) return false;\n          snap = r.snapshot;\n        }\n        return true;\n      },\n    ),\n    buildAssertOpts(opts),\n  );\n}\n\n// Own keys/values of one object, plus Map/Set entries and Date time.\nconst ownState = (v: object): unknown[] => [\n  ...Reflect.ownKeys(v).flatMap((k) => [k, (v as Record<PropertyKey, unknown>)[k]]),\n  ...(v instanceof Map || v instanceof Set ? [...v.entries()].flat() : []),\n  v instanceof Date && v.getTime(),\n];\n\n/**\n * #6 assignDoesNotMutate — running an `assign`-style action never mutates the\n * previous context object. Verified by re-checking the own state of every\n * object reachable from the pre-step context.\n */\nexport function assignDoesNotMutate<Ctx, Evt extends { type: string }, States extends string>(\n  def: MachineDef<Ctx, Evt, States>,\n  impl: Implementations<Ctx, Evt>,\n  eventArbitraries: EventArbitraries<Evt>,\n  opts?: AssertOpts,\n): void {\n  fc.assert(\n    fc.property(\n      fc.array(fc.oneof(...Object.values(eventArbitraries)), { maxLength: 16 }),\n      (events) => {\n        let snap = initialSnapshot(def);\n        for (const e of events) {\n          // Record, not clone (clones drop prototypes, throw on functions).\n          const before = new Map<object, unknown[]>();\n          const walk = (v: unknown): void => {\n            if (!v || typeof v !== \"object\" || before.has(v)) return;\n            const own = ownState(v);\n            before.set(v, own);\n            own.forEach(walk);\n          };\n          walk(snap.context);\n          // `before` keeps the pre-step objects, so advancing `snap` first is safe.\n          snap = step(def, snap, e, impl).snapshot;\n          for (const [obj, own] of before) if (!contextEquals(ownState(obj), own)) return false;\n        }\n        return true;\n      },\n    ),\n    buildAssertOpts(opts),\n  );\n}\n\n/**\n * Assert every generic property in one call. Use this when you don't need\n * fine-grained control over per-property options.\n */\nexport function assertAll<Ctx, Evt extends { type: string }, States extends string>(\n  def: MachineDef<Ctx, Evt, States>,\n  impl: Implementations<Ctx, Evt>,\n  eventArbitraries: EventArbitraries<Evt>,\n  opts?: AssertOpts & { unknownEventType?: string },\n): void {\n  snapshotAlwaysFrozen(def, impl, eventArbitraries, opts);\n  unknownEventNoOp(def, impl, opts?.unknownEventType ?? \"__AIFSMJS_UNKNOWN__\", opts);\n  reachableStatesSubsetDeclared(def, impl, eventArbitraries, opts);\n  replayEqualsFold(def, impl, eventArbitraries, opts);\n  guardsFalseNoTransition(def, impl, eventArbitraries, opts);\n  assignDoesNotMutate(def, impl, eventArbitraries, opts);\n}\n","export {\n  commandsFromMachine,\n  initialModel,\n  type EventArbitraries,\n  type FsmCommand,\n  type FsmModel,\n} from \"./commands.js\";\n\nexport {\n  assertAll,\n  assignDoesNotMutate,\n  guardsFalseNoTransition,\n  reachableStatesSubsetDeclared,\n  replayEqualsFold,\n  snapshotAlwaysFrozen,\n  unknownEventNoOp,\n  type AssertOpts,\n} from \"./properties.js\";\n\n// Convenience namespace mirroring the README:\n//   import { properties } from \"aifsmjs/pbt\"\n//   properties.snapshotAlwaysFrozen(...)\n// A frozen object literal rather than `import * as`: a namespace re-export\n// makes tsup emit a shared `__export` helper chunk that every subpath entry\n// (root, guards, timer, ...) then imports and pays for.\nimport {\n  assertAll,\n  assignDoesNotMutate,\n  contextEquals,\n  guardsFalseNoTransition,\n  reachableStatesSubsetDeclared,\n  replayEqualsFold,\n  snapshotAlwaysFrozen,\n  unknownEventNoOp,\n} from \"./properties.js\";\nexport const properties = Object.freeze({\n  assertAll,\n  assignDoesNotMutate,\n  contextEquals,\n  guardsFalseNoTransition,\n  reachableStatesSubsetDeclared,\n  replayEqualsFold,\n  snapshotAlwaysFrozen,\n  unknownEventNoOp,\n});\n"]}

package/dist/pbt/index.d.cts

@@ -1,5 +1,5 @@
 import * as fc from 'fast-check';
-import { j as Runtime, f as MachineDef, I as Implementations } from '../types-DIM7QTtf.cjs';
+import { j as Runtime, f as MachineDef, I as Implementations } from '../types-CrDxFfBx.cjs';
 
 /**
  * Pure-model representation of an FSM run, used by `fc.commands`.
@@ -39,6 +39,22 @@ type AssertOpts = Readonly<{
     seed?: number;
     verbose?: boolean;
 }>;
+/**
+ * Structural deep-equality for two context values (C3). Backed by `node:util`
+ * `isDeepStrictEqual`, replacing the previous `JSON.stringify(a) === JSON.stringify(b)`
+ * oracle which was unsound:
+ *
+ *   - key-order-sensitive  → false-FAIL on `{a:1,b:2}` vs `{b:2,a:1}`;
+ *   - drops undefined keys  → false-PASS on `{v:undefined,w:1}` vs `{w:1}`;
+ *   - lossy for `Map`/`Set`/`Date` (all serialise to `{}` or an ISO string);
+ *   - throws on `BigInt`.
+ *
+ * `isDeepStrictEqual` distinguishes present-but-undefined from absent keys,
+ * compares `Map`/`Set`/`Date` by contents, and tolerates `BigInt` — exactly
+ * the verdicts a context-equality oracle for PBT requires. No new dependency
+ * (Node built-in; the package already targets Node >=18).
+ */
+declare function contextEquals(a: unknown, b: unknown): boolean;
 /**
  * #1 snapshotAlwaysFrozen — after any event sequence the live snapshot remains
  * frozen at the top level.
@@ -84,8 +100,8 @@ declare function guardsFalseNoTransition<Ctx, Evt extends {
 }, States extends string>(def: MachineDef<Ctx, Evt, States>, impl: Implementations<Ctx, Evt>, eventArbitraries: EventArbitraries<Evt>, opts?: AssertOpts): void;
 /**
  * #6 assignDoesNotMutate — running an `assign`-style action never mutates the
- * previous context object. Verified by deep-equality check on a snapshot taken
- * before each event.
+ * previous context object. Verified by re-checking the own state of every
+ * object reachable from the pre-step context.
  */
 declare function assignDoesNotMutate<Ctx, Evt extends {
     type: string;
@@ -100,18 +116,15 @@ declare function assertAll<Ctx, Evt extends {
     unknownEventType?: string;
 }): void;
 
-type propertiesModule_AssertOpts = AssertOpts;
-declare const propertiesModule_assertAll: typeof assertAll;
-declare const propertiesModule_assignDoesNotMutate: typeof assignDoesNotMutate;
-declare const propertiesModule_guardsFalseNoTransition: typeof guardsFalseNoTransition;
-declare const propertiesModule_reachableStatesSubsetDeclared: typeof reachableStatesSubsetDeclared;
-declare const propertiesModule_replayEqualsFold: typeof replayEqualsFold;
-declare const propertiesModule_snapshotAlwaysFrozen: typeof snapshotAlwaysFrozen;
-declare const propertiesModule_unknownEventNoOp: typeof unknownEventNoOp;
-declare namespace propertiesModule {
-  export { type propertiesModule_AssertOpts as AssertOpts, propertiesModule_assertAll as assertAll, propertiesModule_assignDoesNotMutate as assignDoesNotMutate, propertiesModule_guardsFalseNoTransition as guardsFalseNoTransition, propertiesModule_reachableStatesSubsetDeclared as reachableStatesSubsetDeclared, propertiesModule_replayEqualsFold as replayEqualsFold, propertiesModule_snapshotAlwaysFrozen as snapshotAlwaysFrozen, propertiesModule_unknownEventNoOp as unknownEventNoOp };
-}
-
-declare const properties: typeof propertiesModule;
+declare const properties: Readonly<{
+    assertAll: typeof assertAll;
+    assignDoesNotMutate: typeof assignDoesNotMutate;
+    contextEquals: typeof contextEquals;
+    guardsFalseNoTransition: typeof guardsFalseNoTransition;
+    reachableStatesSubsetDeclared: typeof reachableStatesSubsetDeclared;
+    replayEqualsFold: typeof replayEqualsFold;
+    snapshotAlwaysFrozen: typeof snapshotAlwaysFrozen;
+    unknownEventNoOp: typeof unknownEventNoOp;
+}>;
 
 export { type AssertOpts, type EventArbitraries, type FsmCommand, type FsmModel, assertAll, assignDoesNotMutate, commandsFromMachine, guardsFalseNoTransition, initialModel, properties, reachableStatesSubsetDeclared, replayEqualsFold, snapshotAlwaysFrozen, unknownEventNoOp };