machina-test 0.2.0

package/LICENSE

@@ -0,0 +1,69 @@
+Copyright (c) 2011-2023 Jim Cowart (MIT License)
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+See http://opensource.org/licenses/MIT for more details.
+
+--------------------------------------------------------------------
+Also available under GPL 2.0
+Copyright (c) 2011-2015 Jim Cowart (GPL-2.0 License)
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or (at
+your option) any later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+See http://opensource.org/licenses/GPL-2.0 for more details
+
+--------------------------------------------------------------------
+
+The extend function included in machina was very heavily borrowed
+from the backbone.js project, which can be found at http://backbonejs.org.
+Due to its origin, the backbone license is included below as well.
+
+Copyright (c) 2010-2012 Jeremy Ashkenas, DocumentCloud
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,110 @@
+# machina-test
+
+Jest/Vitest custom matchers for testing [machina](https://machina-js.org) FSM topology. Assert reachability, catch dead states, and verify structural invariants — all from your existing test suite.
+
+```ts
+import "machina-test";
+
+expect(fsm).toHaveNoUnreachableStates();
+expect(fsm).toAlwaysReach("delivered", { from: "placed" });
+expect(fsm).toNeverReach("shipped", { from: "cancelled" });
+```
+
+Built on [machina-inspect](https://www.npmjs.com/package/machina-inspect). Zero ceremony beyond the import.
+
+## Install
+
+```bash
+npm install --save-dev machina-test
+# or
+pnpm add -D machina-test
+```
+
+`machina` >= 6.1.0 is a peer dependency. Either `jest` or `vitest` must be available as the host test runner.
+
+## Setup
+
+Import `machina-test` in your test files (or in a setup file that runs after the framework's globals are available). The import registers the matchers via `expect.extend()` as a side effect.
+
+```ts
+// in each test file
+import "machina-test";
+
+// or in jest.setup.ts / vitest.setup.ts
+import "machina-test";
+```
+
+That's it. TypeScript users get autocomplete for all three matchers automatically.
+
+## Matchers
+
+### `toHaveNoUnreachableStates()`
+
+Asserts that every state in the FSM is reachable from `initialState`. Delegates to machina-inspect's `inspectGraph()`, which recurses into child FSM graphs.
+
+```ts
+expect(fsm).toHaveNoUnreachableStates();
+```
+
+### `toAlwaysReach(targetState, { from })`
+
+Asserts that a path exists from `from` to `targetState` in the FSM's top-level graph. BFS over all edges (both "definite" and "possible"). Top-level graph only — does not traverse into `_child` FSMs.
+
+```ts
+expect(fsm).toAlwaysReach("delivered", { from: "placed" });
+```
+
+"Always" refers to graph topology — the plumbing exists — not runtime certainty. Whether the path executes at runtime depends on which handlers fire.
+
+### `toNeverReach(targetState, { from })`
+
+Asserts that no path exists from `from` to `targetState`. The logical inverse of `toAlwaysReach`.
+
+```ts
+expect(fsm).toNeverReach("shipped", { from: "cancelled" });
+```
+
+### `.not` variants
+
+Standard Jest/Vitest negation works as expected:
+
+```ts
+expect(fsm).not.toAlwaysReach("shipped", { from: "cancelled" });
+expect(fsm).not.toNeverReach("delivered", { from: "placed" });
+```
+
+### Invalid state names
+
+Typos produce clean test failures (not thrown exceptions) with actionable messages:
+
+```
+State 'shiped' does not exist in FSM 'order-workflow'. Available states: placed, validating, processing, shipped, delivered, cancelled, refunded.
+```
+
+## Testing hierarchical FSMs
+
+`toAlwaysReach` and `toNeverReach` operate on the **top-level graph only**. They do not traverse into `_child` FSMs. This is intentional — it avoids ambiguity around composite state names and keeps assertions explicit about which level you're testing.
+
+To test a child FSM, pass it directly to `expect()`:
+
+```ts
+// Test the parent — sees browsing, checkout, confirmation
+expect(checkout).toAlwaysReach("confirmation", { from: "browsing" });
+
+// Test the child — sees entering-details, processing, authorized, declined
+const payment = createPaymentFsm();
+expect(payment).toAlwaysReach("authorized", { from: "entering-details" });
+expect(payment).toNeverReach("entering-details", { from: "authorized" });
+```
+
+**The one exception**: `toHaveNoUnreachableStates()` _does_ recurse into children via `inspectGraph()`. An orphaned state in a child surfaces as a failure when called on the parent.
+
+## See also
+
+- [machina-inspect](https://www.npmjs.com/package/machina-inspect) — the graph analysis engine these matchers are built on
+- [eslint-plugin-machina](https://www.npmjs.com/package/eslint-plugin-machina) — catch structural issues at lint time in your editor
+- [testing-with-machina-test example](../../examples/testing-with-machina-test/) — full working example with flat and hierarchical FSMs
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,128 @@
+let machina_inspect = require("machina-inspect");
+
+//#region src/reachability.ts
+/**
+* Returns true if `to` is reachable from `from` via BFS over the
+* top-level graph's edges. Returns false if either state is missing
+* from the graph, or if no path exists.
+*
+* Treats `from === to` as trivially reachable (every state reaches itself).
+*/
+const canReach = (graph, from, to) => {
+	if (from === to) return true;
+	if (!(from in graph.nodes)) return false;
+	const visited = /* @__PURE__ */ new Set();
+	const queue = [from];
+	visited.add(from);
+	while (queue.length > 0) {
+		const current = queue.shift();
+		const node = graph.nodes[current];
+		if (!node) continue;
+		for (const edge of node.edges) {
+			if (edge.to === to) return true;
+			if (!visited.has(edge.to) && edge.to in graph.nodes) {
+				visited.add(edge.to);
+				queue.push(edge.to);
+			}
+		}
+	}
+	return false;
+};
+
+//#endregion
+//#region src/matchers.ts
+/**
+* Build the StateGraph for the received FSM instance.
+* `buildStateGraph` accepts both config objects and live instances;
+* here we always receive live instances (users pass `expect(fsm)`).
+*/
+const getGraph = (received) => {
+	return (0, machina_inspect.buildStateGraph)(received);
+};
+/**
+* Produce the "invalid state" failure message. Used when a state name
+* passed to a matcher does not exist in the graph.
+*/
+const invalidStateMessage = (stateName, fsmId, graph) => {
+	return `State '${stateName}' does not exist in FSM '${fsmId}'. Available states: ${Object.keys(graph.nodes).join(", ")}.`;
+};
+/**
+* Passes when the FSM has no states that are unreachable from initialState.
+* Uses inspectGraph() to run all checks and filters for unreachable-state
+* findings, which includes recursive child graph analysis.
+*/
+const toHaveNoUnreachableStates = (received) => {
+	const graph = getGraph(received);
+	const findings = (0, machina_inspect.inspectGraph)(graph).filter((f) => f.type === "unreachable-state");
+	const pass = findings.length === 0;
+	const message = () => {
+		if (pass) return `Expected FSM '${graph.fsmId}' to have unreachable states, but all states are reachable.`;
+		const stateList = findings.map((f) => `'${f.states.join(", ")}'`).join(", ");
+		return `Expected FSM '${graph.fsmId}' to have no unreachable states, but found: ${stateList}.`;
+	};
+	return {
+		pass,
+		message
+	};
+};
+/**
+* Passes when a path exists from `options.from` to `targetState` in the
+* FSM's top-level graph (BFS over all edges, definite and possible).
+*/
+const toAlwaysReach = (received, targetState, options) => {
+	const graph = getGraph(received);
+	const { from } = options;
+	if (!(from in graph.nodes)) return {
+		pass: false,
+		message: () => invalidStateMessage(from, graph.fsmId, graph)
+	};
+	if (!(targetState in graph.nodes)) return {
+		pass: false,
+		message: () => invalidStateMessage(targetState, graph.fsmId, graph)
+	};
+	const pass = canReach(graph, from, targetState);
+	const message = () => {
+		if (pass) return `Expected FSM '${graph.fsmId}' to have no path from '${from}' to '${targetState}', but a path exists.`;
+		return `Expected FSM '${graph.fsmId}' to have a path from '${from}' to '${targetState}', but no path exists.`;
+	};
+	return {
+		pass,
+		message
+	};
+};
+/**
+* Passes when NO path exists from `options.from` to `targetState`.
+* The logical inverse of toAlwaysReach.
+*/
+const toNeverReach = (received, targetState, options) => {
+	const graph = getGraph(received);
+	const { from } = options;
+	if (!(from in graph.nodes)) return {
+		pass: false,
+		message: () => invalidStateMessage(from, graph.fsmId, graph)
+	};
+	if (!(targetState in graph.nodes)) return {
+		pass: false,
+		message: () => invalidStateMessage(targetState, graph.fsmId, graph)
+	};
+	const pass = !canReach(graph, from, targetState);
+	const message = () => {
+		if (pass) return `Expected FSM '${graph.fsmId}' to have a path from '${from}' to '${targetState}', but no path exists.`;
+		return `Expected FSM '${graph.fsmId}' to have no path from '${from}' to '${targetState}', but a path exists.`;
+	};
+	return {
+		pass,
+		message
+	};
+};
+
+//#endregion
+//#region src/index.ts
+expect.extend({
+	toHaveNoUnreachableStates,
+	toAlwaysReach,
+	toNeverReach
+});
+
+//#endregion
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":[],"sources":["../src/reachability.ts","../src/matchers.ts","../src/index.ts"],"sourcesContent":["// =============================================================================\n// reachability.ts — BFS reachability check for StateGraph\n//\n// Top-level graph only. Child graphs are not traversed here — users who want\n// to assert reachability inside a child FSM pass the child instance directly\n// to expect().\n//\n// Both \"definite\" and \"possible\" edges are followed. The question is whether\n// the plumbing exists, not whether runtime conditions will always cause it to\n// execute. See design decisions in the build plan for rationale.\n// =============================================================================\n\nimport type { StateGraph } from \"machina-inspect\";\n\n/**\n * Returns true if `to` is reachable from `from` via BFS over the\n * top-level graph's edges. Returns false if either state is missing\n * from the graph, or if no path exists.\n *\n * Treats `from === to` as trivially reachable (every state reaches itself).\n */\nconst canReach = (graph: StateGraph, from: string, to: string): boolean => {\n    // Trivially reachable — a state always reaches itself\n    if (from === to) {\n        return true;\n    }\n\n    // If the source state isn't in the graph, there's nothing to walk\n    if (!(from in graph.nodes)) {\n        return false;\n    }\n\n    const visited = new Set<string>();\n    const queue: string[] = [from];\n    visited.add(from);\n\n    while (queue.length > 0) {\n        const current = queue.shift()!;\n        const node = graph.nodes[current];\n\n        // Missing node is a safety check — shouldn't happen in a well-formed graph\n        if (!node) {\n            continue;\n        }\n\n        for (const edge of node.edges) {\n            if (edge.to === to) {\n                return true;\n            }\n            if (!visited.has(edge.to) && edge.to in graph.nodes) {\n                visited.add(edge.to);\n                queue.push(edge.to);\n            }\n        }\n    }\n\n    return false;\n};\n\nexport { canReach };\n","// =============================================================================\n// matchers.ts — Custom matcher implementations for machina FSMs\n//\n// Each matcher follows the expect.extend() contract:\n//   - Receives the subject as `received`\n//   - Returns { pass: boolean, message: () => string }\n//   - `message` is always the FAILURE message — jest/vitest call it only\n//     when the assertion fails (accounting for .not inversion)\n//\n// Invalid state names produce matcher failures, not throws, so they appear\n// as clean test failures in the runner rather than unhandled exceptions.\n// =============================================================================\n\nimport { buildStateGraph, inspectGraph, type StateGraph } from \"machina-inspect\";\nimport type { MachinaInstance } from \"machina\";\nimport { canReach } from \"./reachability\";\nimport type { ReachabilityOptions } from \"./types\";\n\n// ---------------------------------------------------------------------------\n// Internal helpers\n// ---------------------------------------------------------------------------\n\n/**\n * Build the StateGraph for the received FSM instance.\n * `buildStateGraph` accepts both config objects and live instances;\n * here we always receive live instances (users pass `expect(fsm)`).\n */\nconst getGraph = (received: MachinaInstance): StateGraph => {\n    return buildStateGraph(received);\n};\n\n/**\n * Produce the \"invalid state\" failure message. Used when a state name\n * passed to a matcher does not exist in the graph.\n */\nconst invalidStateMessage = (stateName: string, fsmId: string, graph: StateGraph): string => {\n    const available = Object.keys(graph.nodes).join(\", \");\n    return `State '${stateName}' does not exist in FSM '${fsmId}'. Available states: ${available}.`;\n};\n\n// ---------------------------------------------------------------------------\n// Matcher: toHaveNoUnreachableStates\n// ---------------------------------------------------------------------------\n\n/**\n * Passes when the FSM has no states that are unreachable from initialState.\n * Uses inspectGraph() to run all checks and filters for unreachable-state\n * findings, which includes recursive child graph analysis.\n */\nconst toHaveNoUnreachableStates = (received: MachinaInstance): jest.CustomMatcherResult => {\n    const graph = getGraph(received);\n    const findings = inspectGraph(graph).filter(f => f.type === \"unreachable-state\");\n\n    const pass = findings.length === 0;\n\n    const message = (): string => {\n        if (pass) {\n            // Negated assertion failed: .not.toHaveNoUnreachableStates() but all states reachable\n            return `Expected FSM '${graph.fsmId}' to have unreachable states, but all states are reachable.`;\n        }\n        const stateList = findings.map(f => `'${f.states.join(\", \")}'`).join(\", \");\n        return `Expected FSM '${graph.fsmId}' to have no unreachable states, but found: ${stateList}.`;\n    };\n\n    return { pass, message };\n};\n\n// ---------------------------------------------------------------------------\n// Matcher: toAlwaysReach\n// ---------------------------------------------------------------------------\n\n/**\n * Passes when a path exists from `options.from` to `targetState` in the\n * FSM's top-level graph (BFS over all edges, definite and possible).\n */\nconst toAlwaysReach = (\n    received: MachinaInstance,\n    targetState: string,\n    options: ReachabilityOptions\n): jest.CustomMatcherResult => {\n    const graph = getGraph(received);\n    const { from } = options;\n\n    // Invalid state names are reported as matcher failures for clean output\n    if (!(from in graph.nodes)) {\n        return {\n            pass: false,\n            message: () => invalidStateMessage(from, graph.fsmId, graph),\n        };\n    }\n\n    if (!(targetState in graph.nodes)) {\n        return {\n            pass: false,\n            message: () => invalidStateMessage(targetState, graph.fsmId, graph),\n        };\n    }\n\n    const pass = canReach(graph, from, targetState);\n\n    const message = (): string => {\n        if (pass) {\n            // Negated assertion failed: .not.toAlwaysReach but path exists\n            return `Expected FSM '${graph.fsmId}' to have no path from '${from}' to '${targetState}', but a path exists.`;\n        }\n        return `Expected FSM '${graph.fsmId}' to have a path from '${from}' to '${targetState}', but no path exists.`;\n    };\n\n    return { pass, message };\n};\n\n// ---------------------------------------------------------------------------\n// Matcher: toNeverReach\n// ---------------------------------------------------------------------------\n\n/**\n * Passes when NO path exists from `options.from` to `targetState`.\n * The logical inverse of toAlwaysReach.\n */\nconst toNeverReach = (\n    received: MachinaInstance,\n    targetState: string,\n    options: ReachabilityOptions\n): jest.CustomMatcherResult => {\n    const graph = getGraph(received);\n    const { from } = options;\n\n    // Invalid state names are reported as matcher failures for clean output\n    if (!(from in graph.nodes)) {\n        return {\n            pass: false,\n            message: () => invalidStateMessage(from, graph.fsmId, graph),\n        };\n    }\n\n    if (!(targetState in graph.nodes)) {\n        return {\n            pass: false,\n            message: () => invalidStateMessage(targetState, graph.fsmId, graph),\n        };\n    }\n\n    // pass: true means \"no path exists\" (the assertion that toNeverReach checks)\n    const pass = !canReach(graph, from, targetState);\n\n    const message = (): string => {\n        if (pass) {\n            // Negated assertion failed: .not.toNeverReach but no path exists\n            return `Expected FSM '${graph.fsmId}' to have a path from '${from}' to '${targetState}', but no path exists.`;\n        }\n        return `Expected FSM '${graph.fsmId}' to have no path from '${from}' to '${targetState}', but a path exists.`;\n    };\n\n    return { pass, message };\n};\n\nexport { toHaveNoUnreachableStates, toAlwaysReach, toNeverReach };\n","// =============================================================================\n// index.ts — Side-effect entry point for machina-test\n//\n// Importing this module registers all three custom matchers with the global\n// `expect` provided by Jest or Vitest. This is the same pattern used by\n// @testing-library/jest-dom — the import IS the side effect.\n//\n// `expect` must be available as a global at the time this module is evaluated.\n// Put the import in a test file or in a setup file that runs after the test\n// framework's globals are injected.\n// =============================================================================\n\nimport { toHaveNoUnreachableStates, toAlwaysReach, toNeverReach } from \"./matchers\";\n\n// Register with the host test runner's global expect\nexpect.extend({ toHaveNoUnreachableStates, toAlwaysReach, toNeverReach });\n\n// Re-export the options type so consumers can import it alongside the package\nexport type { ReachabilityOptions } from \"./types\";\n"],"mappings":";;;;;;;;;;AAqBA,MAAM,YAAY,OAAmB,MAAc,OAAwB;AAEvE,KAAI,SAAS,GACT,QAAO;AAIX,KAAI,EAAE,QAAQ,MAAM,OAChB,QAAO;CAGX,MAAM,0BAAU,IAAI,KAAa;CACjC,MAAM,QAAkB,CAAC,KAAK;AAC9B,SAAQ,IAAI,KAAK;AAEjB,QAAO,MAAM,SAAS,GAAG;EACrB,MAAM,UAAU,MAAM,OAAO;EAC7B,MAAM,OAAO,MAAM,MAAM;AAGzB,MAAI,CAAC,KACD;AAGJ,OAAK,MAAM,QAAQ,KAAK,OAAO;AAC3B,OAAI,KAAK,OAAO,GACZ,QAAO;AAEX,OAAI,CAAC,QAAQ,IAAI,KAAK,GAAG,IAAI,KAAK,MAAM,MAAM,OAAO;AACjD,YAAQ,IAAI,KAAK,GAAG;AACpB,UAAM,KAAK,KAAK,GAAG;;;;AAK/B,QAAO;;;;;;;;;;AC7BX,MAAM,YAAY,aAA0C;AACxD,6CAAuB,SAAS;;;;;;AAOpC,MAAM,uBAAuB,WAAmB,OAAe,UAA8B;AAEzF,QAAO,UAAU,UAAU,2BAA2B,MAAM,uBAD1C,OAAO,KAAK,MAAM,MAAM,CAAC,KAAK,KAAK,CACwC;;;;;;;AAYjG,MAAM,6BAA6B,aAAwD;CACvF,MAAM,QAAQ,SAAS,SAAS;CAChC,MAAM,6CAAwB,MAAM,CAAC,QAAO,MAAK,EAAE,SAAS,oBAAoB;CAEhF,MAAM,OAAO,SAAS,WAAW;CAEjC,MAAM,gBAAwB;AAC1B,MAAI,KAEA,QAAO,iBAAiB,MAAM,MAAM;EAExC,MAAM,YAAY,SAAS,KAAI,MAAK,IAAI,EAAE,OAAO,KAAK,KAAK,CAAC,GAAG,CAAC,KAAK,KAAK;AAC1E,SAAO,iBAAiB,MAAM,MAAM,8CAA8C,UAAU;;AAGhG,QAAO;EAAE;EAAM;EAAS;;;;;;AAW5B,MAAM,iBACF,UACA,aACA,YAC2B;CAC3B,MAAM,QAAQ,SAAS,SAAS;CAChC,MAAM,EAAE,SAAS;AAGjB,KAAI,EAAE,QAAQ,MAAM,OAChB,QAAO;EACH,MAAM;EACN,eAAe,oBAAoB,MAAM,MAAM,OAAO,MAAM;EAC/D;AAGL,KAAI,EAAE,eAAe,MAAM,OACvB,QAAO;EACH,MAAM;EACN,eAAe,oBAAoB,aAAa,MAAM,OAAO,MAAM;EACtE;CAGL,MAAM,OAAO,SAAS,OAAO,MAAM,YAAY;CAE/C,MAAM,gBAAwB;AAC1B,MAAI,KAEA,QAAO,iBAAiB,MAAM,MAAM,0BAA0B,KAAK,QAAQ,YAAY;AAE3F,SAAO,iBAAiB,MAAM,MAAM,yBAAyB,KAAK,QAAQ,YAAY;;AAG1F,QAAO;EAAE;EAAM;EAAS;;;;;;AAW5B,MAAM,gBACF,UACA,aACA,YAC2B;CAC3B,MAAM,QAAQ,SAAS,SAAS;CAChC,MAAM,EAAE,SAAS;AAGjB,KAAI,EAAE,QAAQ,MAAM,OAChB,QAAO;EACH,MAAM;EACN,eAAe,oBAAoB,MAAM,MAAM,OAAO,MAAM;EAC/D;AAGL,KAAI,EAAE,eAAe,MAAM,OACvB,QAAO;EACH,MAAM;EACN,eAAe,oBAAoB,aAAa,MAAM,OAAO,MAAM;EACtE;CAIL,MAAM,OAAO,CAAC,SAAS,OAAO,MAAM,YAAY;CAEhD,MAAM,gBAAwB;AAC1B,MAAI,KAEA,QAAO,iBAAiB,MAAM,MAAM,yBAAyB,KAAK,QAAQ,YAAY;AAE1F,SAAO,iBAAiB,MAAM,MAAM,0BAA0B,KAAK,QAAQ,YAAY;;AAG3F,QAAO;EAAE;EAAM;EAAS;;;;;AC1I5B,OAAO,OAAO;CAAE;CAA2B;CAAe;CAAc,CAAC"}

package/dist/index.d.cts

@@ -0,0 +1,50 @@
+//#region src/types.d.ts
+interface ReachabilityOptions {
+  /** The state to start the BFS from */
+  from: string;
+}
+declare global {
+  namespace jest {
+    interface Matchers<R> {
+      /**
+       * Asserts that every state in the FSM is reachable from its
+       * initialState. Delegates to `inspectGraph` and filters for
+       * unreachable-state findings.
+       */
+      toHaveNoUnreachableStates(): R;
+      /**
+       * Asserts that a path exists (via BFS over graph edges) from
+       * `options.from` to `targetState`.
+       */
+      toAlwaysReach(targetState: string, options: ReachabilityOptions): R;
+      /**
+       * Asserts that NO path exists (via BFS over graph edges) from
+       * `options.from` to `targetState`.
+       */
+      toNeverReach(targetState: string, options: ReachabilityOptions): R;
+    }
+  }
+}
+declare module "vitest" {
+  interface Assertion<T = any> {
+    /**
+     * Asserts that every state in the FSM is reachable from its
+     * initialState. Delegates to `inspectGraph` and filters for
+     * unreachable-state findings.
+     */
+    toHaveNoUnreachableStates(): T;
+    /**
+     * Asserts that a path exists (via BFS over graph edges) from
+     * `options.from` to `targetState`.
+     */
+    toAlwaysReach(targetState: string, options: ReachabilityOptions): T;
+    /**
+     * Asserts that NO path exists (via BFS over graph edges) from
+     * `options.from` to `targetState`.
+     */
+    toNeverReach(targetState: string, options: ReachabilityOptions): T;
+  }
+} //# sourceMappingURL=types.d.ts.map
+//#endregion
+export { type ReachabilityOptions };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/types.ts"],"mappings":";UAWiB,mBAAA;EAAA;EAEb,IAAA;AAAA;AAAA,QAII,MAAA;EAAA,UAEM,IAAA;IAAA,UACI,QAAA;MANjB;;;;;MAYW,yBAAA,IAA6B,CAAA;MAYoC;;;;MANjE,aAAA,CAAc,WAAA,UAAqB,OAAA,EAAS,mBAAA,GAAsB,CAAA;MAZ5D;;;;MAkBN,YAAA,CAAa,WAAA,UAAqB,OAAA,EAAS,mBAAA,GAAsB,CAAA;IAAA;EAAA;AAAA;AAAA;EAAA,UAQ/D,SAAA;IARW;;;;;IAcjB,yBAAA,IAA6B,CAAA;IAdyC;AAAA;;;IAoBtE,aAAA,CAAc,WAAA,UAAqB,OAAA,EAAS,mBAAA,GAAsB,CAAA;IAAtB;;;;IAM5C,YAAA,CAAa,WAAA,UAAqB,OAAA,EAAS,mBAAA,GAAsB,CAAA;EAAA;AAAA"}

package/dist/index.d.mts

@@ -0,0 +1,50 @@
+//#region src/types.d.ts
+interface ReachabilityOptions {
+  /** The state to start the BFS from */
+  from: string;
+}
+declare global {
+  namespace jest {
+    interface Matchers<R> {
+      /**
+       * Asserts that every state in the FSM is reachable from its
+       * initialState. Delegates to `inspectGraph` and filters for
+       * unreachable-state findings.
+       */
+      toHaveNoUnreachableStates(): R;
+      /**
+       * Asserts that a path exists (via BFS over graph edges) from
+       * `options.from` to `targetState`.
+       */
+      toAlwaysReach(targetState: string, options: ReachabilityOptions): R;
+      /**
+       * Asserts that NO path exists (via BFS over graph edges) from
+       * `options.from` to `targetState`.
+       */
+      toNeverReach(targetState: string, options: ReachabilityOptions): R;
+    }
+  }
+}
+declare module "vitest" {
+  interface Assertion<T = any> {
+    /**
+     * Asserts that every state in the FSM is reachable from its
+     * initialState. Delegates to `inspectGraph` and filters for
+     * unreachable-state findings.
+     */
+    toHaveNoUnreachableStates(): T;
+    /**
+     * Asserts that a path exists (via BFS over graph edges) from
+     * `options.from` to `targetState`.
+     */
+    toAlwaysReach(targetState: string, options: ReachabilityOptions): T;
+    /**
+     * Asserts that NO path exists (via BFS over graph edges) from
+     * `options.from` to `targetState`.
+     */
+    toNeverReach(targetState: string, options: ReachabilityOptions): T;
+  }
+} //# sourceMappingURL=types.d.ts.map
+//#endregion
+export { type ReachabilityOptions };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts"],"mappings":";UAWiB,mBAAA;EAAA;EAEb,IAAA;AAAA;AAAA,QAII,MAAA;EAAA,UAEM,IAAA;IAAA,UACI,QAAA;MANjB;;;;;MAYW,yBAAA,IAA6B,CAAA;MAYoC;;;;MANjE,aAAA,CAAc,WAAA,UAAqB,OAAA,EAAS,mBAAA,GAAsB,CAAA;MAZ5D;;;;MAkBN,YAAA,CAAa,WAAA,UAAqB,OAAA,EAAS,mBAAA,GAAsB,CAAA;IAAA;EAAA;AAAA;AAAA;EAAA,UAQ/D,SAAA;IARW;;;;;IAcjB,yBAAA,IAA6B,CAAA;IAdyC;AAAA;;;IAoBtE,aAAA,CAAc,WAAA,UAAqB,OAAA,EAAS,mBAAA,GAAsB,CAAA;IAAtB;;;;IAM5C,YAAA,CAAa,WAAA,UAAqB,OAAA,EAAS,mBAAA,GAAsB,CAAA;EAAA;AAAA"}

package/dist/index.mjs

@@ -0,0 +1,129 @@
+import { buildStateGraph, inspectGraph } from "machina-inspect";
+
+//#region src/reachability.ts
+/**
+* Returns true if `to` is reachable from `from` via BFS over the
+* top-level graph's edges. Returns false if either state is missing
+* from the graph, or if no path exists.
+*
+* Treats `from === to` as trivially reachable (every state reaches itself).
+*/
+const canReach = (graph, from, to) => {
+	if (from === to) return true;
+	if (!(from in graph.nodes)) return false;
+	const visited = /* @__PURE__ */ new Set();
+	const queue = [from];
+	visited.add(from);
+	while (queue.length > 0) {
+		const current = queue.shift();
+		const node = graph.nodes[current];
+		if (!node) continue;
+		for (const edge of node.edges) {
+			if (edge.to === to) return true;
+			if (!visited.has(edge.to) && edge.to in graph.nodes) {
+				visited.add(edge.to);
+				queue.push(edge.to);
+			}
+		}
+	}
+	return false;
+};
+
+//#endregion
+//#region src/matchers.ts
+/**
+* Build the StateGraph for the received FSM instance.
+* `buildStateGraph` accepts both config objects and live instances;
+* here we always receive live instances (users pass `expect(fsm)`).
+*/
+const getGraph = (received) => {
+	return buildStateGraph(received);
+};
+/**
+* Produce the "invalid state" failure message. Used when a state name
+* passed to a matcher does not exist in the graph.
+*/
+const invalidStateMessage = (stateName, fsmId, graph) => {
+	return `State '${stateName}' does not exist in FSM '${fsmId}'. Available states: ${Object.keys(graph.nodes).join(", ")}.`;
+};
+/**
+* Passes when the FSM has no states that are unreachable from initialState.
+* Uses inspectGraph() to run all checks and filters for unreachable-state
+* findings, which includes recursive child graph analysis.
+*/
+const toHaveNoUnreachableStates = (received) => {
+	const graph = getGraph(received);
+	const findings = inspectGraph(graph).filter((f) => f.type === "unreachable-state");
+	const pass = findings.length === 0;
+	const message = () => {
+		if (pass) return `Expected FSM '${graph.fsmId}' to have unreachable states, but all states are reachable.`;
+		const stateList = findings.map((f) => `'${f.states.join(", ")}'`).join(", ");
+		return `Expected FSM '${graph.fsmId}' to have no unreachable states, but found: ${stateList}.`;
+	};
+	return {
+		pass,
+		message
+	};
+};
+/**
+* Passes when a path exists from `options.from` to `targetState` in the
+* FSM's top-level graph (BFS over all edges, definite and possible).
+*/
+const toAlwaysReach = (received, targetState, options) => {
+	const graph = getGraph(received);
+	const { from } = options;
+	if (!(from in graph.nodes)) return {
+		pass: false,
+		message: () => invalidStateMessage(from, graph.fsmId, graph)
+	};
+	if (!(targetState in graph.nodes)) return {
+		pass: false,
+		message: () => invalidStateMessage(targetState, graph.fsmId, graph)
+	};
+	const pass = canReach(graph, from, targetState);
+	const message = () => {
+		if (pass) return `Expected FSM '${graph.fsmId}' to have no path from '${from}' to '${targetState}', but a path exists.`;
+		return `Expected FSM '${graph.fsmId}' to have a path from '${from}' to '${targetState}', but no path exists.`;
+	};
+	return {
+		pass,
+		message
+	};
+};
+/**
+* Passes when NO path exists from `options.from` to `targetState`.
+* The logical inverse of toAlwaysReach.
+*/
+const toNeverReach = (received, targetState, options) => {
+	const graph = getGraph(received);
+	const { from } = options;
+	if (!(from in graph.nodes)) return {
+		pass: false,
+		message: () => invalidStateMessage(from, graph.fsmId, graph)
+	};
+	if (!(targetState in graph.nodes)) return {
+		pass: false,
+		message: () => invalidStateMessage(targetState, graph.fsmId, graph)
+	};
+	const pass = !canReach(graph, from, targetState);
+	const message = () => {
+		if (pass) return `Expected FSM '${graph.fsmId}' to have a path from '${from}' to '${targetState}', but no path exists.`;
+		return `Expected FSM '${graph.fsmId}' to have no path from '${from}' to '${targetState}', but a path exists.`;
+	};
+	return {
+		pass,
+		message
+	};
+};
+
+//#endregion
+//#region src/index.ts
+expect.extend({
+	toHaveNoUnreachableStates,
+	toAlwaysReach,
+	toNeverReach
+});
+
+//#endregion
+export {  };
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/reachability.ts","../src/matchers.ts","../src/index.ts"],"sourcesContent":["// =============================================================================\n// reachability.ts — BFS reachability check for StateGraph\n//\n// Top-level graph only. Child graphs are not traversed here — users who want\n// to assert reachability inside a child FSM pass the child instance directly\n// to expect().\n//\n// Both \"definite\" and \"possible\" edges are followed. The question is whether\n// the plumbing exists, not whether runtime conditions will always cause it to\n// execute. See design decisions in the build plan for rationale.\n// =============================================================================\n\nimport type { StateGraph } from \"machina-inspect\";\n\n/**\n * Returns true if `to` is reachable from `from` via BFS over the\n * top-level graph's edges. Returns false if either state is missing\n * from the graph, or if no path exists.\n *\n * Treats `from === to` as trivially reachable (every state reaches itself).\n */\nconst canReach = (graph: StateGraph, from: string, to: string): boolean => {\n    // Trivially reachable — a state always reaches itself\n    if (from === to) {\n        return true;\n    }\n\n    // If the source state isn't in the graph, there's nothing to walk\n    if (!(from in graph.nodes)) {\n        return false;\n    }\n\n    const visited = new Set<string>();\n    const queue: string[] = [from];\n    visited.add(from);\n\n    while (queue.length > 0) {\n        const current = queue.shift()!;\n        const node = graph.nodes[current];\n\n        // Missing node is a safety check — shouldn't happen in a well-formed graph\n        if (!node) {\n            continue;\n        }\n\n        for (const edge of node.edges) {\n            if (edge.to === to) {\n                return true;\n            }\n            if (!visited.has(edge.to) && edge.to in graph.nodes) {\n                visited.add(edge.to);\n                queue.push(edge.to);\n            }\n        }\n    }\n\n    return false;\n};\n\nexport { canReach };\n","// =============================================================================\n// matchers.ts — Custom matcher implementations for machina FSMs\n//\n// Each matcher follows the expect.extend() contract:\n//   - Receives the subject as `received`\n//   - Returns { pass: boolean, message: () => string }\n//   - `message` is always the FAILURE message — jest/vitest call it only\n//     when the assertion fails (accounting for .not inversion)\n//\n// Invalid state names produce matcher failures, not throws, so they appear\n// as clean test failures in the runner rather than unhandled exceptions.\n// =============================================================================\n\nimport { buildStateGraph, inspectGraph, type StateGraph } from \"machina-inspect\";\nimport type { MachinaInstance } from \"machina\";\nimport { canReach } from \"./reachability\";\nimport type { ReachabilityOptions } from \"./types\";\n\n// ---------------------------------------------------------------------------\n// Internal helpers\n// ---------------------------------------------------------------------------\n\n/**\n * Build the StateGraph for the received FSM instance.\n * `buildStateGraph` accepts both config objects and live instances;\n * here we always receive live instances (users pass `expect(fsm)`).\n */\nconst getGraph = (received: MachinaInstance): StateGraph => {\n    return buildStateGraph(received);\n};\n\n/**\n * Produce the \"invalid state\" failure message. Used when a state name\n * passed to a matcher does not exist in the graph.\n */\nconst invalidStateMessage = (stateName: string, fsmId: string, graph: StateGraph): string => {\n    const available = Object.keys(graph.nodes).join(\", \");\n    return `State '${stateName}' does not exist in FSM '${fsmId}'. Available states: ${available}.`;\n};\n\n// ---------------------------------------------------------------------------\n// Matcher: toHaveNoUnreachableStates\n// ---------------------------------------------------------------------------\n\n/**\n * Passes when the FSM has no states that are unreachable from initialState.\n * Uses inspectGraph() to run all checks and filters for unreachable-state\n * findings, which includes recursive child graph analysis.\n */\nconst toHaveNoUnreachableStates = (received: MachinaInstance): jest.CustomMatcherResult => {\n    const graph = getGraph(received);\n    const findings = inspectGraph(graph).filter(f => f.type === \"unreachable-state\");\n\n    const pass = findings.length === 0;\n\n    const message = (): string => {\n        if (pass) {\n            // Negated assertion failed: .not.toHaveNoUnreachableStates() but all states reachable\n            return `Expected FSM '${graph.fsmId}' to have unreachable states, but all states are reachable.`;\n        }\n        const stateList = findings.map(f => `'${f.states.join(\", \")}'`).join(\", \");\n        return `Expected FSM '${graph.fsmId}' to have no unreachable states, but found: ${stateList}.`;\n    };\n\n    return { pass, message };\n};\n\n// ---------------------------------------------------------------------------\n// Matcher: toAlwaysReach\n// ---------------------------------------------------------------------------\n\n/**\n * Passes when a path exists from `options.from` to `targetState` in the\n * FSM's top-level graph (BFS over all edges, definite and possible).\n */\nconst toAlwaysReach = (\n    received: MachinaInstance,\n    targetState: string,\n    options: ReachabilityOptions\n): jest.CustomMatcherResult => {\n    const graph = getGraph(received);\n    const { from } = options;\n\n    // Invalid state names are reported as matcher failures for clean output\n    if (!(from in graph.nodes)) {\n        return {\n            pass: false,\n            message: () => invalidStateMessage(from, graph.fsmId, graph),\n        };\n    }\n\n    if (!(targetState in graph.nodes)) {\n        return {\n            pass: false,\n            message: () => invalidStateMessage(targetState, graph.fsmId, graph),\n        };\n    }\n\n    const pass = canReach(graph, from, targetState);\n\n    const message = (): string => {\n        if (pass) {\n            // Negated assertion failed: .not.toAlwaysReach but path exists\n            return `Expected FSM '${graph.fsmId}' to have no path from '${from}' to '${targetState}', but a path exists.`;\n        }\n        return `Expected FSM '${graph.fsmId}' to have a path from '${from}' to '${targetState}', but no path exists.`;\n    };\n\n    return { pass, message };\n};\n\n// ---------------------------------------------------------------------------\n// Matcher: toNeverReach\n// ---------------------------------------------------------------------------\n\n/**\n * Passes when NO path exists from `options.from` to `targetState`.\n * The logical inverse of toAlwaysReach.\n */\nconst toNeverReach = (\n    received: MachinaInstance,\n    targetState: string,\n    options: ReachabilityOptions\n): jest.CustomMatcherResult => {\n    const graph = getGraph(received);\n    const { from } = options;\n\n    // Invalid state names are reported as matcher failures for clean output\n    if (!(from in graph.nodes)) {\n        return {\n            pass: false,\n            message: () => invalidStateMessage(from, graph.fsmId, graph),\n        };\n    }\n\n    if (!(targetState in graph.nodes)) {\n        return {\n            pass: false,\n            message: () => invalidStateMessage(targetState, graph.fsmId, graph),\n        };\n    }\n\n    // pass: true means \"no path exists\" (the assertion that toNeverReach checks)\n    const pass = !canReach(graph, from, targetState);\n\n    const message = (): string => {\n        if (pass) {\n            // Negated assertion failed: .not.toNeverReach but no path exists\n            return `Expected FSM '${graph.fsmId}' to have a path from '${from}' to '${targetState}', but no path exists.`;\n        }\n        return `Expected FSM '${graph.fsmId}' to have no path from '${from}' to '${targetState}', but a path exists.`;\n    };\n\n    return { pass, message };\n};\n\nexport { toHaveNoUnreachableStates, toAlwaysReach, toNeverReach };\n","// =============================================================================\n// index.ts — Side-effect entry point for machina-test\n//\n// Importing this module registers all three custom matchers with the global\n// `expect` provided by Jest or Vitest. This is the same pattern used by\n// @testing-library/jest-dom — the import IS the side effect.\n//\n// `expect` must be available as a global at the time this module is evaluated.\n// Put the import in a test file or in a setup file that runs after the test\n// framework's globals are injected.\n// =============================================================================\n\nimport { toHaveNoUnreachableStates, toAlwaysReach, toNeverReach } from \"./matchers\";\n\n// Register with the host test runner's global expect\nexpect.extend({ toHaveNoUnreachableStates, toAlwaysReach, toNeverReach });\n\n// Re-export the options type so consumers can import it alongside the package\nexport type { ReachabilityOptions } from \"./types\";\n"],"mappings":";;;;;;;;;;AAqBA,MAAM,YAAY,OAAmB,MAAc,OAAwB;AAEvE,KAAI,SAAS,GACT,QAAO;AAIX,KAAI,EAAE,QAAQ,MAAM,OAChB,QAAO;CAGX,MAAM,0BAAU,IAAI,KAAa;CACjC,MAAM,QAAkB,CAAC,KAAK;AAC9B,SAAQ,IAAI,KAAK;AAEjB,QAAO,MAAM,SAAS,GAAG;EACrB,MAAM,UAAU,MAAM,OAAO;EAC7B,MAAM,OAAO,MAAM,MAAM;AAGzB,MAAI,CAAC,KACD;AAGJ,OAAK,MAAM,QAAQ,KAAK,OAAO;AAC3B,OAAI,KAAK,OAAO,GACZ,QAAO;AAEX,OAAI,CAAC,QAAQ,IAAI,KAAK,GAAG,IAAI,KAAK,MAAM,MAAM,OAAO;AACjD,YAAQ,IAAI,KAAK,GAAG;AACpB,UAAM,KAAK,KAAK,GAAG;;;;AAK/B,QAAO;;;;;;;;;;AC7BX,MAAM,YAAY,aAA0C;AACxD,QAAO,gBAAgB,SAAS;;;;;;AAOpC,MAAM,uBAAuB,WAAmB,OAAe,UAA8B;AAEzF,QAAO,UAAU,UAAU,2BAA2B,MAAM,uBAD1C,OAAO,KAAK,MAAM,MAAM,CAAC,KAAK,KAAK,CACwC;;;;;;;AAYjG,MAAM,6BAA6B,aAAwD;CACvF,MAAM,QAAQ,SAAS,SAAS;CAChC,MAAM,WAAW,aAAa,MAAM,CAAC,QAAO,MAAK,EAAE,SAAS,oBAAoB;CAEhF,MAAM,OAAO,SAAS,WAAW;CAEjC,MAAM,gBAAwB;AAC1B,MAAI,KAEA,QAAO,iBAAiB,MAAM,MAAM;EAExC,MAAM,YAAY,SAAS,KAAI,MAAK,IAAI,EAAE,OAAO,KAAK,KAAK,CAAC,GAAG,CAAC,KAAK,KAAK;AAC1E,SAAO,iBAAiB,MAAM,MAAM,8CAA8C,UAAU;;AAGhG,QAAO;EAAE;EAAM;EAAS;;;;;;AAW5B,MAAM,iBACF,UACA,aACA,YAC2B;CAC3B,MAAM,QAAQ,SAAS,SAAS;CAChC,MAAM,EAAE,SAAS;AAGjB,KAAI,EAAE,QAAQ,MAAM,OAChB,QAAO;EACH,MAAM;EACN,eAAe,oBAAoB,MAAM,MAAM,OAAO,MAAM;EAC/D;AAGL,KAAI,EAAE,eAAe,MAAM,OACvB,QAAO;EACH,MAAM;EACN,eAAe,oBAAoB,aAAa,MAAM,OAAO,MAAM;EACtE;CAGL,MAAM,OAAO,SAAS,OAAO,MAAM,YAAY;CAE/C,MAAM,gBAAwB;AAC1B,MAAI,KAEA,QAAO,iBAAiB,MAAM,MAAM,0BAA0B,KAAK,QAAQ,YAAY;AAE3F,SAAO,iBAAiB,MAAM,MAAM,yBAAyB,KAAK,QAAQ,YAAY;;AAG1F,QAAO;EAAE;EAAM;EAAS;;;;;;AAW5B,MAAM,gBACF,UACA,aACA,YAC2B;CAC3B,MAAM,QAAQ,SAAS,SAAS;CAChC,MAAM,EAAE,SAAS;AAGjB,KAAI,EAAE,QAAQ,MAAM,OAChB,QAAO;EACH,MAAM;EACN,eAAe,oBAAoB,MAAM,MAAM,OAAO,MAAM;EAC/D;AAGL,KAAI,EAAE,eAAe,MAAM,OACvB,QAAO;EACH,MAAM;EACN,eAAe,oBAAoB,aAAa,MAAM,OAAO,MAAM;EACtE;CAIL,MAAM,OAAO,CAAC,SAAS,OAAO,MAAM,YAAY;CAEhD,MAAM,gBAAwB;AAC1B,MAAI,KAEA,QAAO,iBAAiB,MAAM,MAAM,yBAAyB,KAAK,QAAQ,YAAY;AAE1F,SAAO,iBAAiB,MAAM,MAAM,0BAA0B,KAAK,QAAQ,YAAY;;AAG3F,QAAO;EAAE;EAAM;EAAS;;;;;AC1I5B,OAAO,OAAO;CAAE;CAA2B;CAAe;CAAc,CAAC"}

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "machina-test",
+  "version": "0.2.0",
+  "description": "Jest/Vitest custom matchers for testing machina FSMs.",
+  "author": "Jim Cowart (http://ifandelse.com)",
+  "license": "MIT",
+  "homepage": "https://machina-js.org/",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/ifandelse/machina.js.git"
+  },
+  "bugs": {
+    "url": "http://github.com/ifandelse/machina.js/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "http://opensource.org/licenses/MIT"
+    },
+    {
+      "type": "GPL",
+      "url": "http://opensource.org/licenses/GPL-2.0"
+    }
+  ],
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=22.22"
+  },
+  "sideEffects": true,
+  "dependencies": {
+    "machina-inspect": "1.0.0"
+  },
+  "peerDependencies": {
+    "machina": ">=6.1.0",
+    "jest": ">=29",
+    "vitest": ">=1"
+  },
+  "peerDependenciesMeta": {
+    "jest": {
+      "optional": true
+    },
+    "vitest": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "eslint": "^9.39.2",
+    "jest": "^30.2.0",
+    "ts-jest": "^29.4.6",
+    "tsdown": "^0.20.3",
+    "typescript": "^5.9.3",
+    "machina": "6.1.0"
+  },
+  "scripts": {
+    "dev": "tsdown --watch",
+    "build": "tsdown",
+    "test": "jest --passWithNoTests",
+    "test:watch": "jest --watch",
+    "lint": "ESLINT_USE_FLAT_CONFIG=false eslint --config ../../.eslintrc.js 'src/**/*.{ts,tsx}'"
+  }
+}