state-invariant 0.1.0

package/README.md

@@ -0,0 +1,147 @@
+# state-invariant
+
+Catch illegal **state transitions** at runtime, in any state management library.
+
+Most validation libraries (Zod, Yup, io-ts) check the *shape* of one object at one
+moment in time. `state-invariant` checks something different: given the state
+**before**, the state **after**, and the **action** that caused the change — was
+that transition actually legal?
+
+```
+prev state  +  action  →  next state
+     ↑                          ↑
+     └──── is this legal? ──────┘
+```
+
+## Install
+
+```bash
+npm install state-invariant
+```
+
+## Core usage (works anywhere)
+
+```ts
+import { createInvariantChecker } from 'state-invariant';
+
+const check = createInvariantChecker([
+  {
+    name: 'balance-never-negative',
+    check: (prev, next) => next.balance >= 0,
+    message: (prev, next, action) =>
+      `action ${action.type} would make balance negative: ${next.balance}`,
+  },
+  {
+    name: 'logout-clears-user',
+    when: (action) => action.type === 'LOGOUT',
+    check: (prev, next) => next.user === null,
+  },
+]);
+
+check(prevState, nextState, action); // throws InvariantViolationError if a rule fails
+```
+
+## With Redux
+
+```ts
+import { configureStore } from '@reduxjs/toolkit';
+import { createInvariantMiddleware } from 'state-invariant/redux';
+
+const middleware = createInvariantMiddleware([
+  { name: 'balance-never-negative', check: (p, n) => n.balance >= 0 },
+]);
+
+const store = configureStore({
+  reducer,
+  middleware: (getDefault) => getDefault().concat(middleware),
+});
+```
+
+## With Zustand
+
+```ts
+import { create } from 'zustand';
+import { invariant } from 'state-invariant/zustand';
+
+const useStore = create(
+  invariant([{ name: 'count-never-negative', check: (p, n) => n.count >= 0 }])(
+    (set) => ({ count: 0, decrement: () => set((s) => ({ count: s.count - 1 })) })
+  )
+);
+```
+
+## With anything else (plain reducer)
+
+```ts
+import { wrapReducer } from 'state-invariant/generic';
+
+const checkedReducer = wrapReducer(myReducer, [
+  { name: 'total-conserved', check: (p, n) => p.total === n.total },
+]);
+```
+
+Or bracket any mutation manually, for stores with no middleware hooks at all:
+
+```ts
+import { wrapManual } from 'state-invariant/generic';
+
+const checker = wrapManual(myVanillaStore, rules);
+checker.before();
+myVanillaStore.doSomething();
+checker.after('doSomething');
+```
+
+## With APIs & Backends (Database Mutations)
+
+This pattern is incredibly powerful for backend APIs and distributed systems where you want to guarantee that a database mutation doesn't violate core business rules. 
+
+```ts
+import { createInvariantTransaction } from 'state-invariant/backend';
+
+const safeTransfer = createInvariantTransaction([
+  {
+    name: 'balance-never-negative',
+    check: (prev, next) => next.balance >= 0 || 'Insufficient funds'
+  }
+]);
+
+// Inside your Express/Next.js route handler
+app.post('/transfer', async (req, res) => {
+  try {
+    const result = await safeTransfer(req.body, {
+      read: () => db.accounts.findById(req.body.accountId),
+      compute: (prev) => ({
+        ...prev,
+        balance: prev.balance - req.body.amount
+      }),
+      write: (next) => db.accounts.save(next)
+    });
+    res.json(result);
+  } catch (error) {
+    res.status(400).json({ error: error.message });
+  }
+});
+```
+The invariant check runs *after* `compute` but *before* `write`. If the invariant fails, it throws, meaning your database is never corrupted.
+
+## Error handling modes
+
+```ts
+createInvariantChecker(rules, { mode: 'throw' });   // default: throw immediately
+createInvariantChecker(rules, { mode: 'warn' });    // console.warn, keep running
+createInvariantChecker(rules, { mode: 'collect' }); // gather violations silently
+```
+
+In `collect` mode, read them back with `check.getViolations()`.
+
+## Why not just Zod?
+
+Zod validates one object's shape. It can't tell you whether `next.balance`
+is a *legal consequence* of `prev.balance` and the action that ran. That
+requires seeing both states plus the action together — which is what this
+package is for. Use Zod for shape, `state-invariant` for transitions. They
+compose fine together.
+
+## License
+
+MIT

package/dist/backend.cjs

@@ -0,0 +1,90 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/backend.ts
+var backend_exports = {};
+__export(backend_exports, {
+  createInvariantTransaction: () => createInvariantTransaction
+});
+module.exports = __toCommonJS(backend_exports);
+
+// src/core.ts
+var InvariantViolationError = class extends Error {
+  constructor(message, details) {
+    super(message);
+    this.name = "InvariantViolationError";
+    this.ruleName = details.ruleName;
+    this.prev = details.prev;
+    this.next = details.next;
+    this.action = details.action;
+  }
+};
+function createInvariantChecker(rules, options = {}) {
+  var _a;
+  const mode = (_a = options.mode) != null ? _a : "throw";
+  const violations = [];
+  function check(prev, next, action) {
+    for (const rule of rules) {
+      if (rule.when && !rule.when(action)) continue;
+      let ok;
+      try {
+        ok = rule.check(prev, next, action);
+      } catch (err) {
+        ok = false;
+      }
+      if (ok === false || typeof ok === "string") {
+        const message = typeof ok === "string" ? ok : rule.message ? rule.message(prev, next, action) : `Invariant "${rule.name}" violated`;
+        const error = new InvariantViolationError(message, {
+          ruleName: rule.name,
+          prev,
+          next,
+          action
+        });
+        if (mode === "throw") {
+          throw error;
+        } else if (mode === "warn") {
+          console.warn(`[state-invariant] ${message}`, { prev, next, action });
+        } else {
+          violations.push(error);
+        }
+      }
+    }
+  }
+  check.getViolations = () => violations.slice();
+  check.clearViolations = () => {
+    violations.length = 0;
+  };
+  return check;
+}
+
+// src/backend.ts
+function createInvariantTransaction(rules, options = {}) {
+  const check = createInvariantChecker(rules, options);
+  return async (action, handlers) => {
+    const prev = await handlers.read();
+    const next = await handlers.compute(prev);
+    check(prev, next, action);
+    return await handlers.write(next);
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createInvariantTransaction
+});
+//# sourceMappingURL=backend.cjs.map

package/dist/backend.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/backend.ts","../src/core.ts"],"sourcesContent":["import { createInvariantChecker, InvariantRule, CheckerOptions } from './core';\n\n/**\n * Orchestrates a backend data transaction (read, compute, write).\n * Ensures that the transition from `prev` to `next` state is validated\n * against the provided invariant rules BEFORE the `write` handler is executed.\n * \n * Perfect for API routes, database operations, and event processors.\n */\nexport function createInvariantTransaction<State = any, Action = any, Result = any>(\n  rules: InvariantRule<State, Action>[],\n  options: CheckerOptions = {}\n) {\n  const check = createInvariantChecker<State, Action>(rules, options);\n\n  return async (\n    action: Action,\n    handlers: {\n      /** Fetch the current state from your database/source */\n      read: () => Promise<State> | State;\n      /** Compute the proposed new state based on the current state */\n      compute: (prev: State) => Promise<State> | State;\n      /** Save the new state. This will NOT be called if the invariant check fails. */\n      write: (next: State) => Promise<Result> | Result;\n    }\n  ): Promise<Result> => {\n    const prev = await handlers.read();\n    const next = await handlers.compute(prev);\n    \n    // Check if the transition is legal before saving\n    check(prev, next, action);\n    \n    return await handlers.write(next);\n  };\n}\n","/**\n * state-invariant/core\n *\n * Framework-agnostic engine. Doesn't know about Redux, Zustand, or anyone else.\n * You give it rules; it tells you whether a state TRANSITION (prev -> next, caused\n * by some action) was legal. This is different from Zod/Yup: those check the shape\n * of ONE object. This checks the relationship between two states and the action\n * that connected them.\n */\n\nexport interface InvariantRule<State = any, Action = any> {\n  /** Human-readable name, shown in error messages and stack traces. */\n  name: string;\n  /**\n   * Optional filter. If provided, the rule only runs when this returns true.\n   * Lets you scope a rule to one action type, e.g. action => action.type === 'WITHDRAW'\n   */\n  when?: (action: Action) => boolean;\n  /**\n   * The actual check. Return true if the transition is valid, false if it violates\n   * the invariant. Alternatively, return a string to indicate a violation and use\n   * that string as the error message.\n   */\n  check: (prev: State, next: State, action: Action) => boolean | string;\n  /**\n   * Optional custom error message builder. Falls back to a generic message.\n   * Ignored if `check` returns a string.\n   */\n  message?: (prev: State, next: State, action: Action) => string;\n}\n\nexport class InvariantViolationError extends Error {\n  ruleName: string;\n  prev: unknown;\n  next: unknown;\n  action: unknown;\n\n  constructor(\n    message: string,\n    details: { ruleName: string; prev: unknown; next: unknown; action: unknown }\n  ) {\n    super(message);\n    this.name = 'InvariantViolationError';\n    this.ruleName = details.ruleName;\n    this.prev = details.prev;\n    this.next = details.next;\n    this.action = details.action;\n  }\n}\n\nexport interface CheckerOptions {\n  /**\n   * 'throw' (default) - throw InvariantViolationError immediately, stopping execution.\n   * 'warn' - console.warn and continue. Useful in production if you don't want to crash.\n   * 'collect' - don't throw or warn, just gather violations; call .getViolations() yourself.\n   */\n  mode?: 'throw' | 'warn' | 'collect';\n}\n\nexport function createInvariantChecker<State = any, Action = any>(\n  rules: InvariantRule<State, Action>[],\n  options: CheckerOptions = {}\n) {\n  const mode = options.mode ?? 'throw';\n  const violations: InvariantViolationError[] = [];\n\n  function check(prev: State, next: State, action: Action): void {\n    for (const rule of rules) {\n      if (rule.when && !rule.when(action)) continue;\n\n      let ok: boolean | string;\n      try {\n        ok = rule.check(prev, next, action);\n      } catch (err) {\n        // A rule that throws internally (e.g. undefined property access) is itself\n        // a bug in the rule, but we surface it as a violation so it's not silently\n        // swallowed by the store.\n        ok = false;\n      }\n\n      if (ok === false || typeof ok === 'string') {\n        const message =\n          typeof ok === 'string'\n            ? ok\n            : rule.message\n            ? rule.message(prev, next, action)\n            : `Invariant \"${rule.name}\" violated`;\n\n        const error = new InvariantViolationError(message, {\n          ruleName: rule.name,\n          prev,\n          next,\n          action,\n        });\n\n        if (mode === 'throw') {\n          throw error;\n        } else if (mode === 'warn') {\n          // eslint-disable-next-line no-console\n          console.warn(`[state-invariant] ${message}`, { prev, next, action });\n        } else {\n          violations.push(error);\n        }\n      }\n    }\n  }\n\n  check.getViolations = () => violations.slice();\n  check.clearViolations = () => {\n    violations.length = 0;\n  };\n\n  return check;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;AC+BO,IAAM,0BAAN,cAAsC,MAAM;AAAA,EAMjD,YACE,SACA,SACA;AACA,UAAM,OAAO;AACb,SAAK,OAAO;AACZ,SAAK,WAAW,QAAQ;AACxB,SAAK,OAAO,QAAQ;AACpB,SAAK,OAAO,QAAQ;AACpB,SAAK,SAAS,QAAQ;AAAA,EACxB;AACF;AAWO,SAAS,uBACd,OACA,UAA0B,CAAC,GAC3B;AA9DF;AA+DE,QAAM,QAAO,aAAQ,SAAR,YAAgB;AAC7B,QAAM,aAAwC,CAAC;AAE/C,WAAS,MAAM,MAAa,MAAa,QAAsB;AAC7D,eAAW,QAAQ,OAAO;AACxB,UAAI,KAAK,QAAQ,CAAC,KAAK,KAAK,MAAM,EAAG;AAErC,UAAI;AACJ,UAAI;AACF,aAAK,KAAK,MAAM,MAAM,MAAM,MAAM;AAAA,MACpC,SAAS,KAAK;AAIZ,aAAK;AAAA,MACP;AAEA,UAAI,OAAO,SAAS,OAAO,OAAO,UAAU;AAC1C,cAAM,UACJ,OAAO,OAAO,WACV,KACA,KAAK,UACL,KAAK,QAAQ,MAAM,MAAM,MAAM,IAC/B,cAAc,KAAK,IAAI;AAE7B,cAAM,QAAQ,IAAI,wBAAwB,SAAS;AAAA,UACjD,UAAU,KAAK;AAAA,UACf;AAAA,UACA;AAAA,UACA;AAAA,QACF,CAAC;AAED,YAAI,SAAS,SAAS;AACpB,gBAAM;AAAA,QACR,WAAW,SAAS,QAAQ;AAE1B,kBAAQ,KAAK,qBAAqB,OAAO,IAAI,EAAE,MAAM,MAAM,OAAO,CAAC;AAAA,QACrE,OAAO;AACL,qBAAW,KAAK,KAAK;AAAA,QACvB;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,QAAM,gBAAgB,MAAM,WAAW,MAAM;AAC7C,QAAM,kBAAkB,MAAM;AAC5B,eAAW,SAAS;AAAA,EACtB;AAEA,SAAO;AACT;;;ADxGO,SAAS,2BACd,OACA,UAA0B,CAAC,GAC3B;AACA,QAAM,QAAQ,uBAAsC,OAAO,OAAO;AAElE,SAAO,OACL,QACA,aAQoB;AACpB,UAAM,OAAO,MAAM,SAAS,KAAK;AACjC,UAAM,OAAO,MAAM,SAAS,QAAQ,IAAI;AAGxC,UAAM,MAAM,MAAM,MAAM;AAExB,WAAO,MAAM,SAAS,MAAM,IAAI;AAAA,EAClC;AACF;","names":[]}

package/dist/backend.d.ts

@@ -0,0 +1,16 @@
+import { InvariantRule, CheckerOptions } from './core';
+/**
+ * Orchestrates a backend data transaction (read, compute, write).
+ * Ensures that the transition from `prev` to `next` state is validated
+ * against the provided invariant rules BEFORE the `write` handler is executed.
+ *
+ * Perfect for API routes, database operations, and event processors.
+ */
+export declare function createInvariantTransaction<State = any, Action = any, Result = any>(rules: InvariantRule<State, Action>[], options?: CheckerOptions): (action: Action, handlers: {
+    /** Fetch the current state from your database/source */
+    read: () => Promise<State> | State;
+    /** Compute the proposed new state based on the current state */
+    compute: (prev: State) => Promise<State> | State;
+    /** Save the new state. This will NOT be called if the invariant check fails. */
+    write: (next: State) => Promise<Result> | Result;
+}) => Promise<Result>;

package/dist/backend.js

@@ -0,0 +1,18 @@
+import {
+  createInvariantChecker
+} from "./chunk-DRSBKG3Y.js";
+
+// src/backend.ts
+function createInvariantTransaction(rules, options = {}) {
+  const check = createInvariantChecker(rules, options);
+  return async (action, handlers) => {
+    const prev = await handlers.read();
+    const next = await handlers.compute(prev);
+    check(prev, next, action);
+    return await handlers.write(next);
+  };
+}
+export {
+  createInvariantTransaction
+};
+//# sourceMappingURL=backend.js.map

package/dist/backend.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/backend.ts"],"sourcesContent":["import { createInvariantChecker, InvariantRule, CheckerOptions } from './core';\n\n/**\n * Orchestrates a backend data transaction (read, compute, write).\n * Ensures that the transition from `prev` to `next` state is validated\n * against the provided invariant rules BEFORE the `write` handler is executed.\n * \n * Perfect for API routes, database operations, and event processors.\n */\nexport function createInvariantTransaction<State = any, Action = any, Result = any>(\n  rules: InvariantRule<State, Action>[],\n  options: CheckerOptions = {}\n) {\n  const check = createInvariantChecker<State, Action>(rules, options);\n\n  return async (\n    action: Action,\n    handlers: {\n      /** Fetch the current state from your database/source */\n      read: () => Promise<State> | State;\n      /** Compute the proposed new state based on the current state */\n      compute: (prev: State) => Promise<State> | State;\n      /** Save the new state. This will NOT be called if the invariant check fails. */\n      write: (next: State) => Promise<Result> | Result;\n    }\n  ): Promise<Result> => {\n    const prev = await handlers.read();\n    const next = await handlers.compute(prev);\n    \n    // Check if the transition is legal before saving\n    check(prev, next, action);\n    \n    return await handlers.write(next);\n  };\n}\n"],"mappings":";;;;;AASO,SAAS,2BACd,OACA,UAA0B,CAAC,GAC3B;AACA,QAAM,QAAQ,uBAAsC,OAAO,OAAO;AAElE,SAAO,OACL,QACA,aAQoB;AACpB,UAAM,OAAO,MAAM,SAAS,KAAK;AACjC,UAAM,OAAO,MAAM,SAAS,QAAQ,IAAI;AAGxC,UAAM,MAAM,MAAM,MAAM;AAExB,WAAO,MAAM,SAAS,MAAM,IAAI;AAAA,EAClC;AACF;","names":[]}

package/dist/chunk-DRSBKG3Y.js

@@ -0,0 +1,54 @@
+// src/core.ts
+var InvariantViolationError = class extends Error {
+  constructor(message, details) {
+    super(message);
+    this.name = "InvariantViolationError";
+    this.ruleName = details.ruleName;
+    this.prev = details.prev;
+    this.next = details.next;
+    this.action = details.action;
+  }
+};
+function createInvariantChecker(rules, options = {}) {
+  var _a;
+  const mode = (_a = options.mode) != null ? _a : "throw";
+  const violations = [];
+  function check(prev, next, action) {
+    for (const rule of rules) {
+      if (rule.when && !rule.when(action)) continue;
+      let ok;
+      try {
+        ok = rule.check(prev, next, action);
+      } catch (err) {
+        ok = false;
+      }
+      if (ok === false || typeof ok === "string") {
+        const message = typeof ok === "string" ? ok : rule.message ? rule.message(prev, next, action) : `Invariant "${rule.name}" violated`;
+        const error = new InvariantViolationError(message, {
+          ruleName: rule.name,
+          prev,
+          next,
+          action
+        });
+        if (mode === "throw") {
+          throw error;
+        } else if (mode === "warn") {
+          console.warn(`[state-invariant] ${message}`, { prev, next, action });
+        } else {
+          violations.push(error);
+        }
+      }
+    }
+  }
+  check.getViolations = () => violations.slice();
+  check.clearViolations = () => {
+    violations.length = 0;
+  };
+  return check;
+}
+
+export {
+  InvariantViolationError,
+  createInvariantChecker
+};
+//# sourceMappingURL=chunk-DRSBKG3Y.js.map

package/dist/chunk-DRSBKG3Y.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core.ts"],"sourcesContent":["/**\n * state-invariant/core\n *\n * Framework-agnostic engine. Doesn't know about Redux, Zustand, or anyone else.\n * You give it rules; it tells you whether a state TRANSITION (prev -> next, caused\n * by some action) was legal. This is different from Zod/Yup: those check the shape\n * of ONE object. This checks the relationship between two states and the action\n * that connected them.\n */\n\nexport interface InvariantRule<State = any, Action = any> {\n  /** Human-readable name, shown in error messages and stack traces. */\n  name: string;\n  /**\n   * Optional filter. If provided, the rule only runs when this returns true.\n   * Lets you scope a rule to one action type, e.g. action => action.type === 'WITHDRAW'\n   */\n  when?: (action: Action) => boolean;\n  /**\n   * The actual check. Return true if the transition is valid, false if it violates\n   * the invariant. Alternatively, return a string to indicate a violation and use\n   * that string as the error message.\n   */\n  check: (prev: State, next: State, action: Action) => boolean | string;\n  /**\n   * Optional custom error message builder. Falls back to a generic message.\n   * Ignored if `check` returns a string.\n   */\n  message?: (prev: State, next: State, action: Action) => string;\n}\n\nexport class InvariantViolationError extends Error {\n  ruleName: string;\n  prev: unknown;\n  next: unknown;\n  action: unknown;\n\n  constructor(\n    message: string,\n    details: { ruleName: string; prev: unknown; next: unknown; action: unknown }\n  ) {\n    super(message);\n    this.name = 'InvariantViolationError';\n    this.ruleName = details.ruleName;\n    this.prev = details.prev;\n    this.next = details.next;\n    this.action = details.action;\n  }\n}\n\nexport interface CheckerOptions {\n  /**\n   * 'throw' (default) - throw InvariantViolationError immediately, stopping execution.\n   * 'warn' - console.warn and continue. Useful in production if you don't want to crash.\n   * 'collect' - don't throw or warn, just gather violations; call .getViolations() yourself.\n   */\n  mode?: 'throw' | 'warn' | 'collect';\n}\n\nexport function createInvariantChecker<State = any, Action = any>(\n  rules: InvariantRule<State, Action>[],\n  options: CheckerOptions = {}\n) {\n  const mode = options.mode ?? 'throw';\n  const violations: InvariantViolationError[] = [];\n\n  function check(prev: State, next: State, action: Action): void {\n    for (const rule of rules) {\n      if (rule.when && !rule.when(action)) continue;\n\n      let ok: boolean | string;\n      try {\n        ok = rule.check(prev, next, action);\n      } catch (err) {\n        // A rule that throws internally (e.g. undefined property access) is itself\n        // a bug in the rule, but we surface it as a violation so it's not silently\n        // swallowed by the store.\n        ok = false;\n      }\n\n      if (ok === false || typeof ok === 'string') {\n        const message =\n          typeof ok === 'string'\n            ? ok\n            : rule.message\n            ? rule.message(prev, next, action)\n            : `Invariant \"${rule.name}\" violated`;\n\n        const error = new InvariantViolationError(message, {\n          ruleName: rule.name,\n          prev,\n          next,\n          action,\n        });\n\n        if (mode === 'throw') {\n          throw error;\n        } else if (mode === 'warn') {\n          // eslint-disable-next-line no-console\n          console.warn(`[state-invariant] ${message}`, { prev, next, action });\n        } else {\n          violations.push(error);\n        }\n      }\n    }\n  }\n\n  check.getViolations = () => violations.slice();\n  check.clearViolations = () => {\n    violations.length = 0;\n  };\n\n  return check;\n}\n"],"mappings":";AA+BO,IAAM,0BAAN,cAAsC,MAAM;AAAA,EAMjD,YACE,SACA,SACA;AACA,UAAM,OAAO;AACb,SAAK,OAAO;AACZ,SAAK,WAAW,QAAQ;AACxB,SAAK,OAAO,QAAQ;AACpB,SAAK,OAAO,QAAQ;AACpB,SAAK,SAAS,QAAQ;AAAA,EACxB;AACF;AAWO,SAAS,uBACd,OACA,UAA0B,CAAC,GAC3B;AA9DF;AA+DE,QAAM,QAAO,aAAQ,SAAR,YAAgB;AAC7B,QAAM,aAAwC,CAAC;AAE/C,WAAS,MAAM,MAAa,MAAa,QAAsB;AAC7D,eAAW,QAAQ,OAAO;AACxB,UAAI,KAAK,QAAQ,CAAC,KAAK,KAAK,MAAM,EAAG;AAErC,UAAI;AACJ,UAAI;AACF,aAAK,KAAK,MAAM,MAAM,MAAM,MAAM;AAAA,MACpC,SAAS,KAAK;AAIZ,aAAK;AAAA,MACP;AAEA,UAAI,OAAO,SAAS,OAAO,OAAO,UAAU;AAC1C,cAAM,UACJ,OAAO,OAAO,WACV,KACA,KAAK,UACL,KAAK,QAAQ,MAAM,MAAM,MAAM,IAC/B,cAAc,KAAK,IAAI;AAE7B,cAAM,QAAQ,IAAI,wBAAwB,SAAS;AAAA,UACjD,UAAU,KAAK;AAAA,UACf;AAAA,UACA;AAAA,UACA;AAAA,QACF,CAAC;AAED,YAAI,SAAS,SAAS;AACpB,gBAAM;AAAA,QACR,WAAW,SAAS,QAAQ;AAE1B,kBAAQ,KAAK,qBAAqB,OAAO,IAAI,EAAE,MAAM,MAAM,OAAO,CAAC;AAAA,QACrE,OAAO;AACL,qBAAW,KAAK,KAAK;AAAA,QACvB;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,QAAM,gBAAgB,MAAM,WAAW,MAAM;AAC7C,QAAM,kBAAkB,MAAM;AAC5B,eAAW,SAAS;AAAA,EACtB;AAEA,SAAO;AACT;","names":[]}

package/dist/core.d.ts

@@ -0,0 +1,54 @@
+/**
+ * state-invariant/core
+ *
+ * Framework-agnostic engine. Doesn't know about Redux, Zustand, or anyone else.
+ * You give it rules; it tells you whether a state TRANSITION (prev -> next, caused
+ * by some action) was legal. This is different from Zod/Yup: those check the shape
+ * of ONE object. This checks the relationship between two states and the action
+ * that connected them.
+ */
+export interface InvariantRule<State = any, Action = any> {
+    /** Human-readable name, shown in error messages and stack traces. */
+    name: string;
+    /**
+     * Optional filter. If provided, the rule only runs when this returns true.
+     * Lets you scope a rule to one action type, e.g. action => action.type === 'WITHDRAW'
+     */
+    when?: (action: Action) => boolean;
+    /**
+     * The actual check. Return true if the transition is valid, false if it violates
+     * the invariant. Alternatively, return a string to indicate a violation and use
+     * that string as the error message.
+     */
+    check: (prev: State, next: State, action: Action) => boolean | string;
+    /**
+     * Optional custom error message builder. Falls back to a generic message.
+     * Ignored if `check` returns a string.
+     */
+    message?: (prev: State, next: State, action: Action) => string;
+}
+export declare class InvariantViolationError extends Error {
+    ruleName: string;
+    prev: unknown;
+    next: unknown;
+    action: unknown;
+    constructor(message: string, details: {
+        ruleName: string;
+        prev: unknown;
+        next: unknown;
+        action: unknown;
+    });
+}
+export interface CheckerOptions {
+    /**
+     * 'throw' (default) - throw InvariantViolationError immediately, stopping execution.
+     * 'warn' - console.warn and continue. Useful in production if you don't want to crash.
+     * 'collect' - don't throw or warn, just gather violations; call .getViolations() yourself.
+     */
+    mode?: 'throw' | 'warn' | 'collect';
+}
+export declare function createInvariantChecker<State = any, Action = any>(rules: InvariantRule<State, Action>[], options?: CheckerOptions): {
+    (prev: State, next: State, action: Action): void;
+    getViolations(): InvariantViolationError[];
+    clearViolations(): void;
+};

package/dist/generic.cjs

@@ -0,0 +1,108 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/generic.ts
+var generic_exports = {};
+__export(generic_exports, {
+  wrapManual: () => wrapManual,
+  wrapReducer: () => wrapReducer
+});
+module.exports = __toCommonJS(generic_exports);
+
+// src/core.ts
+var InvariantViolationError = class extends Error {
+  constructor(message, details) {
+    super(message);
+    this.name = "InvariantViolationError";
+    this.ruleName = details.ruleName;
+    this.prev = details.prev;
+    this.next = details.next;
+    this.action = details.action;
+  }
+};
+function createInvariantChecker(rules, options = {}) {
+  var _a;
+  const mode = (_a = options.mode) != null ? _a : "throw";
+  const violations = [];
+  function check(prev, next, action) {
+    for (const rule of rules) {
+      if (rule.when && !rule.when(action)) continue;
+      let ok;
+      try {
+        ok = rule.check(prev, next, action);
+      } catch (err) {
+        ok = false;
+      }
+      if (ok === false || typeof ok === "string") {
+        const message = typeof ok === "string" ? ok : rule.message ? rule.message(prev, next, action) : `Invariant "${rule.name}" violated`;
+        const error = new InvariantViolationError(message, {
+          ruleName: rule.name,
+          prev,
+          next,
+          action
+        });
+        if (mode === "throw") {
+          throw error;
+        } else if (mode === "warn") {
+          console.warn(`[state-invariant] ${message}`, { prev, next, action });
+        } else {
+          violations.push(error);
+        }
+      }
+    }
+  }
+  check.getViolations = () => violations.slice();
+  check.clearViolations = () => {
+    violations.length = 0;
+  };
+  return check;
+}
+
+// src/generic.ts
+function wrapReducer(reducer, rules, options = {}) {
+  const check = createInvariantChecker(rules, options);
+  return (state, action) => {
+    const nextState = reducer(state, action);
+    check(state, nextState, action);
+    return nextState;
+  };
+}
+function wrapManual(store, rules, options = {}) {
+  const check = createInvariantChecker(rules, options);
+  let snapshot;
+  return {
+    before() {
+      snapshot = store.getState();
+    },
+    after(action) {
+      if (snapshot === void 0) {
+        throw new Error("wrapManual: after() called without before()");
+      }
+      const next = store.getState();
+      check(snapshot, next, action);
+      snapshot = void 0;
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  wrapManual,
+  wrapReducer
+});
+//# sourceMappingURL=generic.cjs.map

package/dist/generic.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/generic.ts","../src/core.ts"],"sourcesContent":["import { createInvariantChecker, InvariantRule, CheckerOptions } from './core';\n\n/**\n * Works with ANY reducer-shaped function: (state, action) => newState.\n * This is the \"plugs into anything\" escape hatch — if a library doesn't have\n * a dedicated adapter, and it exposes a plain reducer somewhere, wrap it with this.\n *\n * Usage:\n *   const checkedReducer = wrapReducer(myReducer, [\n *     { name: 'total-conserved', check: (p, n) => p.total === n.total }\n *   ]);\n */\nexport function wrapReducer<State = any, Action = any>(\n  reducer: (state: State, action: Action) => State,\n  rules: InvariantRule<State, Action>[],\n  options: CheckerOptions = {}\n) {\n  const check = createInvariantChecker<State, Action>(rules, options);\n\n  return (state: State, action: Action): State => {\n    const nextState = reducer(state, action);\n    check(state, nextState, action);\n    return nextState;\n  };\n}\n\n/**\n * Works with any object that has getState()/setState()-style access, by letting\n * you manually bracket a mutation. Useful for libraries with no middleware hooks\n * at all (vanilla stores, custom pub-sub state, etc).\n *\n * Usage:\n *   const checker = wrapManual(myStore, rules);\n *   checker.before();\n *   myStore.doSomething();\n *   checker.after(actionLabel);\n */\nexport function wrapManual<State = any, Action = any>(\n  store: { getState: () => State },\n  rules: InvariantRule<State, Action>[],\n  options: CheckerOptions = {}\n) {\n  const check = createInvariantChecker<State, Action>(rules, options);\n  let snapshot: State | undefined;\n\n  return {\n    before() {\n      snapshot = store.getState();\n    },\n    after(action: Action) {\n      if (snapshot === undefined) {\n        throw new Error('wrapManual: after() called without before()');\n      }\n      const next = store.getState();\n      check(snapshot, next, action);\n      snapshot = undefined;\n    },\n  };\n}\n","/**\n * state-invariant/core\n *\n * Framework-agnostic engine. Doesn't know about Redux, Zustand, or anyone else.\n * You give it rules; it tells you whether a state TRANSITION (prev -> next, caused\n * by some action) was legal. This is different from Zod/Yup: those check the shape\n * of ONE object. This checks the relationship between two states and the action\n * that connected them.\n */\n\nexport interface InvariantRule<State = any, Action = any> {\n  /** Human-readable name, shown in error messages and stack traces. */\n  name: string;\n  /**\n   * Optional filter. If provided, the rule only runs when this returns true.\n   * Lets you scope a rule to one action type, e.g. action => action.type === 'WITHDRAW'\n   */\n  when?: (action: Action) => boolean;\n  /**\n   * The actual check. Return true if the transition is valid, false if it violates\n   * the invariant. Alternatively, return a string to indicate a violation and use\n   * that string as the error message.\n   */\n  check: (prev: State, next: State, action: Action) => boolean | string;\n  /**\n   * Optional custom error message builder. Falls back to a generic message.\n   * Ignored if `check` returns a string.\n   */\n  message?: (prev: State, next: State, action: Action) => string;\n}\n\nexport class InvariantViolationError extends Error {\n  ruleName: string;\n  prev: unknown;\n  next: unknown;\n  action: unknown;\n\n  constructor(\n    message: string,\n    details: { ruleName: string; prev: unknown; next: unknown; action: unknown }\n  ) {\n    super(message);\n    this.name = 'InvariantViolationError';\n    this.ruleName = details.ruleName;\n    this.prev = details.prev;\n    this.next = details.next;\n    this.action = details.action;\n  }\n}\n\nexport interface CheckerOptions {\n  /**\n   * 'throw' (default) - throw InvariantViolationError immediately, stopping execution.\n   * 'warn' - console.warn and continue. Useful in production if you don't want to crash.\n   * 'collect' - don't throw or warn, just gather violations; call .getViolations() yourself.\n   */\n  mode?: 'throw' | 'warn' | 'collect';\n}\n\nexport function createInvariantChecker<State = any, Action = any>(\n  rules: InvariantRule<State, Action>[],\n  options: CheckerOptions = {}\n) {\n  const mode = options.mode ?? 'throw';\n  const violations: InvariantViolationError[] = [];\n\n  function check(prev: State, next: State, action: Action): void {\n    for (const rule of rules) {\n      if (rule.when && !rule.when(action)) continue;\n\n      let ok: boolean | string;\n      try {\n        ok = rule.check(prev, next, action);\n      } catch (err) {\n        // A rule that throws internally (e.g. undefined property access) is itself\n        // a bug in the rule, but we surface it as a violation so it's not silently\n        // swallowed by the store.\n        ok = false;\n      }\n\n      if (ok === false || typeof ok === 'string') {\n        const message =\n          typeof ok === 'string'\n            ? ok\n            : rule.message\n            ? rule.message(prev, next, action)\n            : `Invariant \"${rule.name}\" violated`;\n\n        const error = new InvariantViolationError(message, {\n          ruleName: rule.name,\n          prev,\n          next,\n          action,\n        });\n\n        if (mode === 'throw') {\n          throw error;\n        } else if (mode === 'warn') {\n          // eslint-disable-next-line no-console\n          console.warn(`[state-invariant] ${message}`, { prev, next, action });\n        } else {\n          violations.push(error);\n        }\n      }\n    }\n  }\n\n  check.getViolations = () => violations.slice();\n  check.clearViolations = () => {\n    violations.length = 0;\n  };\n\n  return check;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;AC+BO,IAAM,0BAAN,cAAsC,MAAM;AAAA,EAMjD,YACE,SACA,SACA;AACA,UAAM,OAAO;AACb,SAAK,OAAO;AACZ,SAAK,WAAW,QAAQ;AACxB,SAAK,OAAO,QAAQ;AACpB,SAAK,OAAO,QAAQ;AACpB,SAAK,SAAS,QAAQ;AAAA,EACxB;AACF;AAWO,SAAS,uBACd,OACA,UAA0B,CAAC,GAC3B;AA9DF;AA+DE,QAAM,QAAO,aAAQ,SAAR,YAAgB;AAC7B,QAAM,aAAwC,CAAC;AAE/C,WAAS,MAAM,MAAa,MAAa,QAAsB;AAC7D,eAAW,QAAQ,OAAO;AACxB,UAAI,KAAK,QAAQ,CAAC,KAAK,KAAK,MAAM,EAAG;AAErC,UAAI;AACJ,UAAI;AACF,aAAK,KAAK,MAAM,MAAM,MAAM,MAAM;AAAA,MACpC,SAAS,KAAK;AAIZ,aAAK;AAAA,MACP;AAEA,UAAI,OAAO,SAAS,OAAO,OAAO,UAAU;AAC1C,cAAM,UACJ,OAAO,OAAO,WACV,KACA,KAAK,UACL,KAAK,QAAQ,MAAM,MAAM,MAAM,IAC/B,cAAc,KAAK,IAAI;AAE7B,cAAM,QAAQ,IAAI,wBAAwB,SAAS;AAAA,UACjD,UAAU,KAAK;AAAA,UACf;AAAA,UACA;AAAA,UACA;AAAA,QACF,CAAC;AAED,YAAI,SAAS,SAAS;AACpB,gBAAM;AAAA,QACR,WAAW,SAAS,QAAQ;AAE1B,kBAAQ,KAAK,qBAAqB,OAAO,IAAI,EAAE,MAAM,MAAM,OAAO,CAAC;AAAA,QACrE,OAAO;AACL,qBAAW,KAAK,KAAK;AAAA,QACvB;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,QAAM,gBAAgB,MAAM,WAAW,MAAM;AAC7C,QAAM,kBAAkB,MAAM;AAC5B,eAAW,SAAS;AAAA,EACtB;AAEA,SAAO;AACT;;;ADrGO,SAAS,YACd,SACA,OACA,UAA0B,CAAC,GAC3B;AACA,QAAM,QAAQ,uBAAsC,OAAO,OAAO;AAElE,SAAO,CAAC,OAAc,WAA0B;AAC9C,UAAM,YAAY,QAAQ,OAAO,MAAM;AACvC,UAAM,OAAO,WAAW,MAAM;AAC9B,WAAO;AAAA,EACT;AACF;AAaO,SAAS,WACd,OACA,OACA,UAA0B,CAAC,GAC3B;AACA,QAAM,QAAQ,uBAAsC,OAAO,OAAO;AAClE,MAAI;AAEJ,SAAO;AAAA,IACL,SAAS;AACP,iBAAW,MAAM,SAAS;AAAA,IAC5B;AAAA,IACA,MAAM,QAAgB;AACpB,UAAI,aAAa,QAAW;AAC1B,cAAM,IAAI,MAAM,6CAA6C;AAAA,MAC/D;AACA,YAAM,OAAO,MAAM,SAAS;AAC5B,YAAM,UAAU,MAAM,MAAM;AAC5B,iBAAW;AAAA,IACb;AAAA,EACF;AACF;","names":[]}

package/dist/generic.d.ts

@@ -0,0 +1,29 @@
+import { InvariantRule, CheckerOptions } from './core';
+/**
+ * Works with ANY reducer-shaped function: (state, action) => newState.
+ * This is the "plugs into anything" escape hatch — if a library doesn't have
+ * a dedicated adapter, and it exposes a plain reducer somewhere, wrap it with this.
+ *
+ * Usage:
+ *   const checkedReducer = wrapReducer(myReducer, [
+ *     { name: 'total-conserved', check: (p, n) => p.total === n.total }
+ *   ]);
+ */
+export declare function wrapReducer<State = any, Action = any>(reducer: (state: State, action: Action) => State, rules: InvariantRule<State, Action>[], options?: CheckerOptions): (state: State, action: Action) => State;
+/**
+ * Works with any object that has getState()/setState()-style access, by letting
+ * you manually bracket a mutation. Useful for libraries with no middleware hooks
+ * at all (vanilla stores, custom pub-sub state, etc).
+ *
+ * Usage:
+ *   const checker = wrapManual(myStore, rules);
+ *   checker.before();
+ *   myStore.doSomething();
+ *   checker.after(actionLabel);
+ */
+export declare function wrapManual<State = any, Action = any>(store: {
+    getState: () => State;
+}, rules: InvariantRule<State, Action>[], options?: CheckerOptions): {
+    before(): void;
+    after(action: Action): void;
+};

package/dist/generic.js

@@ -0,0 +1,35 @@
+import {
+  createInvariantChecker
+} from "./chunk-DRSBKG3Y.js";
+
+// src/generic.ts
+function wrapReducer(reducer, rules, options = {}) {
+  const check = createInvariantChecker(rules, options);
+  return (state, action) => {
+    const nextState = reducer(state, action);
+    check(state, nextState, action);
+    return nextState;
+  };
+}
+function wrapManual(store, rules, options = {}) {
+  const check = createInvariantChecker(rules, options);
+  let snapshot;
+  return {
+    before() {
+      snapshot = store.getState();
+    },
+    after(action) {
+      if (snapshot === void 0) {
+        throw new Error("wrapManual: after() called without before()");
+      }
+      const next = store.getState();
+      check(snapshot, next, action);
+      snapshot = void 0;
+    }
+  };
+}
+export {
+  wrapManual,
+  wrapReducer
+};
+//# sourceMappingURL=generic.js.map

package/dist/generic.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/generic.ts"],"sourcesContent":["import { createInvariantChecker, InvariantRule, CheckerOptions } from './core';\n\n/**\n * Works with ANY reducer-shaped function: (state, action) => newState.\n * This is the \"plugs into anything\" escape hatch — if a library doesn't have\n * a dedicated adapter, and it exposes a plain reducer somewhere, wrap it with this.\n *\n * Usage:\n *   const checkedReducer = wrapReducer(myReducer, [\n *     { name: 'total-conserved', check: (p, n) => p.total === n.total }\n *   ]);\n */\nexport function wrapReducer<State = any, Action = any>(\n  reducer: (state: State, action: Action) => State,\n  rules: InvariantRule<State, Action>[],\n  options: CheckerOptions = {}\n) {\n  const check = createInvariantChecker<State, Action>(rules, options);\n\n  return (state: State, action: Action): State => {\n    const nextState = reducer(state, action);\n    check(state, nextState, action);\n    return nextState;\n  };\n}\n\n/**\n * Works with any object that has getState()/setState()-style access, by letting\n * you manually bracket a mutation. Useful for libraries with no middleware hooks\n * at all (vanilla stores, custom pub-sub state, etc).\n *\n * Usage:\n *   const checker = wrapManual(myStore, rules);\n *   checker.before();\n *   myStore.doSomething();\n *   checker.after(actionLabel);\n */\nexport function wrapManual<State = any, Action = any>(\n  store: { getState: () => State },\n  rules: InvariantRule<State, Action>[],\n  options: CheckerOptions = {}\n) {\n  const check = createInvariantChecker<State, Action>(rules, options);\n  let snapshot: State | undefined;\n\n  return {\n    before() {\n      snapshot = store.getState();\n    },\n    after(action: Action) {\n      if (snapshot === undefined) {\n        throw new Error('wrapManual: after() called without before()');\n      }\n      const next = store.getState();\n      check(snapshot, next, action);\n      snapshot = undefined;\n    },\n  };\n}\n"],"mappings":";;;;;AAYO,SAAS,YACd,SACA,OACA,UAA0B,CAAC,GAC3B;AACA,QAAM,QAAQ,uBAAsC,OAAO,OAAO;AAElE,SAAO,CAAC,OAAc,WAA0B;AAC9C,UAAM,YAAY,QAAQ,OAAO,MAAM;AACvC,UAAM,OAAO,WAAW,MAAM;AAC9B,WAAO;AAAA,EACT;AACF;AAaO,SAAS,WACd,OACA,OACA,UAA0B,CAAC,GAC3B;AACA,QAAM,QAAQ,uBAAsC,OAAO,OAAO;AAClE,MAAI;AAEJ,SAAO;AAAA,IACL,SAAS;AACP,iBAAW,MAAM,SAAS;AAAA,IAC5B;AAAA,IACA,MAAM,QAAgB;AACpB,UAAI,aAAa,QAAW;AAC1B,cAAM,IAAI,MAAM,6CAA6C;AAAA,MAC/D;AACA,YAAM,OAAO,MAAM,SAAS;AAC5B,YAAM,UAAU,MAAM,MAAM;AAC5B,iBAAW;AAAA,IACb;AAAA,EACF;AACF;","names":[]}

package/dist/index.cjs

@@ -0,0 +1,81 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  InvariantViolationError: () => InvariantViolationError,
+  createInvariantChecker: () => createInvariantChecker
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/core.ts
+var InvariantViolationError = class extends Error {
+  constructor(message, details) {
+    super(message);
+    this.name = "InvariantViolationError";
+    this.ruleName = details.ruleName;
+    this.prev = details.prev;
+    this.next = details.next;
+    this.action = details.action;
+  }
+};
+function createInvariantChecker(rules, options = {}) {
+  var _a;
+  const mode = (_a = options.mode) != null ? _a : "throw";
+  const violations = [];
+  function check(prev, next, action) {
+    for (const rule of rules) {
+      if (rule.when && !rule.when(action)) continue;
+      let ok;
+      try {
+        ok = rule.check(prev, next, action);
+      } catch (err) {
+        ok = false;
+      }
+      if (ok === false || typeof ok === "string") {
+        const message = typeof ok === "string" ? ok : rule.message ? rule.message(prev, next, action) : `Invariant "${rule.name}" violated`;
+        const error = new InvariantViolationError(message, {
+          ruleName: rule.name,
+          prev,
+          next,
+          action
+        });
+        if (mode === "throw") {
+          throw error;
+        } else if (mode === "warn") {
+          console.warn(`[state-invariant] ${message}`, { prev, next, action });
+        } else {
+          violations.push(error);
+        }
+      }
+    }
+  }
+  check.getViolations = () => violations.slice();
+  check.clearViolations = () => {
+    violations.length = 0;
+  };
+  return check;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InvariantViolationError,
+  createInvariantChecker
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/core.ts"],"sourcesContent":["export * from './core';\n","/**\n * state-invariant/core\n *\n * Framework-agnostic engine. Doesn't know about Redux, Zustand, or anyone else.\n * You give it rules; it tells you whether a state TRANSITION (prev -> next, caused\n * by some action) was legal. This is different from Zod/Yup: those check the shape\n * of ONE object. This checks the relationship between two states and the action\n * that connected them.\n */\n\nexport interface InvariantRule<State = any, Action = any> {\n  /** Human-readable name, shown in error messages and stack traces. */\n  name: string;\n  /**\n   * Optional filter. If provided, the rule only runs when this returns true.\n   * Lets you scope a rule to one action type, e.g. action => action.type === 'WITHDRAW'\n   */\n  when?: (action: Action) => boolean;\n  /**\n   * The actual check. Return true if the transition is valid, false if it violates\n   * the invariant. Alternatively, return a string to indicate a violation and use\n   * that string as the error message.\n   */\n  check: (prev: State, next: State, action: Action) => boolean | string;\n  /**\n   * Optional custom error message builder. Falls back to a generic message.\n   * Ignored if `check` returns a string.\n   */\n  message?: (prev: State, next: State, action: Action) => string;\n}\n\nexport class InvariantViolationError extends Error {\n  ruleName: string;\n  prev: unknown;\n  next: unknown;\n  action: unknown;\n\n  constructor(\n    message: string,\n    details: { ruleName: string; prev: unknown; next: unknown; action: unknown }\n  ) {\n    super(message);\n    this.name = 'InvariantViolationError';\n    this.ruleName = details.ruleName;\n    this.prev = details.prev;\n    this.next = details.next;\n    this.action = details.action;\n  }\n}\n\nexport interface CheckerOptions {\n  /**\n   * 'throw' (default) - throw InvariantViolationError immediately, stopping execution.\n   * 'warn' - console.warn and continue. Useful in production if you don't want to crash.\n   * 'collect' - don't throw or warn, just gather violations; call .getViolations() yourself.\n   */\n  mode?: 'throw' | 'warn' | 'collect';\n}\n\nexport function createInvariantChecker<State = any, Action = any>(\n  rules: InvariantRule<State, Action>[],\n  options: CheckerOptions = {}\n) {\n  const mode = options.mode ?? 'throw';\n  const violations: InvariantViolationError[] = [];\n\n  function check(prev: State, next: State, action: Action): void {\n    for (const rule of rules) {\n      if (rule.when && !rule.when(action)) continue;\n\n      let ok: boolean | string;\n      try {\n        ok = rule.check(prev, next, action);\n      } catch (err) {\n        // A rule that throws internally (e.g. undefined property access) is itself\n        // a bug in the rule, but we surface it as a violation so it's not silently\n        // swallowed by the store.\n        ok = false;\n      }\n\n      if (ok === false || typeof ok === 'string') {\n        const message =\n          typeof ok === 'string'\n            ? ok\n            : rule.message\n            ? rule.message(prev, next, action)\n            : `Invariant \"${rule.name}\" violated`;\n\n        const error = new InvariantViolationError(message, {\n          ruleName: rule.name,\n          prev,\n          next,\n          action,\n        });\n\n        if (mode === 'throw') {\n          throw error;\n        } else if (mode === 'warn') {\n          // eslint-disable-next-line no-console\n          console.warn(`[state-invariant] ${message}`, { prev, next, action });\n        } else {\n          violations.push(error);\n        }\n      }\n    }\n  }\n\n  check.getViolations = () => violations.slice();\n  check.clearViolations = () => {\n    violations.length = 0;\n  };\n\n  return check;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;AC+BO,IAAM,0BAAN,cAAsC,MAAM;AAAA,EAMjD,YACE,SACA,SACA;AACA,UAAM,OAAO;AACb,SAAK,OAAO;AACZ,SAAK,WAAW,QAAQ;AACxB,SAAK,OAAO,QAAQ;AACpB,SAAK,OAAO,QAAQ;AACpB,SAAK,SAAS,QAAQ;AAAA,EACxB;AACF;AAWO,SAAS,uBACd,OACA,UAA0B,CAAC,GAC3B;AA9DF;AA+DE,QAAM,QAAO,aAAQ,SAAR,YAAgB;AAC7B,QAAM,aAAwC,CAAC;AAE/C,WAAS,MAAM,MAAa,MAAa,QAAsB;AAC7D,eAAW,QAAQ,OAAO;AACxB,UAAI,KAAK,QAAQ,CAAC,KAAK,KAAK,MAAM,EAAG;AAErC,UAAI;AACJ,UAAI;AACF,aAAK,KAAK,MAAM,MAAM,MAAM,MAAM;AAAA,MACpC,SAAS,KAAK;AAIZ,aAAK;AAAA,MACP;AAEA,UAAI,OAAO,SAAS,OAAO,OAAO,UAAU;AAC1C,cAAM,UACJ,OAAO,OAAO,WACV,KACA,KAAK,UACL,KAAK,QAAQ,MAAM,MAAM,MAAM,IAC/B,cAAc,KAAK,IAAI;AAE7B,cAAM,QAAQ,IAAI,wBAAwB,SAAS;AAAA,UACjD,UAAU,KAAK;AAAA,UACf;AAAA,UACA;AAAA,UACA;AAAA,QACF,CAAC;AAED,YAAI,SAAS,SAAS;AACpB,gBAAM;AAAA,QACR,WAAW,SAAS,QAAQ;AAE1B,kBAAQ,KAAK,qBAAqB,OAAO,IAAI,EAAE,MAAM,MAAM,OAAO,CAAC;AAAA,QACrE,OAAO;AACL,qBAAW,KAAK,KAAK;AAAA,QACvB;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,QAAM,gBAAgB,MAAM,WAAW,MAAM;AAC7C,QAAM,kBAAkB,MAAM;AAC5B,eAAW,SAAS;AAAA,EACtB;AAEA,SAAO;AACT;","names":[]}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './core';

package/dist/index.js

@@ -0,0 +1,9 @@
+import {
+  InvariantViolationError,
+  createInvariantChecker
+} from "./chunk-DRSBKG3Y.js";
+export {
+  InvariantViolationError,
+  createInvariantChecker
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/redux.cjs

@@ -0,0 +1,91 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/redux.ts
+var redux_exports = {};
+__export(redux_exports, {
+  createInvariantMiddleware: () => createInvariantMiddleware
+});
+module.exports = __toCommonJS(redux_exports);
+
+// src/core.ts
+var InvariantViolationError = class extends Error {
+  constructor(message, details) {
+    super(message);
+    this.name = "InvariantViolationError";
+    this.ruleName = details.ruleName;
+    this.prev = details.prev;
+    this.next = details.next;
+    this.action = details.action;
+  }
+};
+function createInvariantChecker(rules, options = {}) {
+  var _a;
+  const mode = (_a = options.mode) != null ? _a : "throw";
+  const violations = [];
+  function check(prev, next, action) {
+    for (const rule of rules) {
+      if (rule.when && !rule.when(action)) continue;
+      let ok;
+      try {
+        ok = rule.check(prev, next, action);
+      } catch (err) {
+        ok = false;
+      }
+      if (ok === false || typeof ok === "string") {
+        const message = typeof ok === "string" ? ok : rule.message ? rule.message(prev, next, action) : `Invariant "${rule.name}" violated`;
+        const error = new InvariantViolationError(message, {
+          ruleName: rule.name,
+          prev,
+          next,
+          action
+        });
+        if (mode === "throw") {
+          throw error;
+        } else if (mode === "warn") {
+          console.warn(`[state-invariant] ${message}`, { prev, next, action });
+        } else {
+          violations.push(error);
+        }
+      }
+    }
+  }
+  check.getViolations = () => violations.slice();
+  check.clearViolations = () => {
+    violations.length = 0;
+  };
+  return check;
+}
+
+// src/redux.ts
+function createInvariantMiddleware(rules, options = {}) {
+  const check = createInvariantChecker(rules, options);
+  return (storeApi) => (next) => (action) => {
+    const prev = storeApi.getState();
+    const result = next(action);
+    const nextState = storeApi.getState();
+    check(prev, nextState, action);
+    return result;
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createInvariantMiddleware
+});
+//# sourceMappingURL=redux.cjs.map

package/dist/redux.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/redux.ts","../src/core.ts"],"sourcesContent":["import { createInvariantChecker, InvariantRule, CheckerOptions } from './core';\n\n/**\n * Redux middleware. Runs your invariant rules after every dispatch, comparing\n * state before and after.\n *\n * Usage:\n *   import { createInvariantMiddleware } from 'state-invariant/redux';\n *\n *   const middleware = createInvariantMiddleware([\n *     {\n *       name: 'balance-never-negative',\n *       check: (prev, next) => next.balance >= 0,\n *       message: (prev, next) => `balance went negative: ${next.balance}`,\n *     },\n *   ]);\n *\n *   const store = configureStore({\n *     reducer,\n *     middleware: (getDefault) => getDefault().concat(middleware),\n *   });\n */\nexport function createInvariantMiddleware<State = any, Action = any>(\n  rules: InvariantRule<State, Action>[],\n  options: CheckerOptions = {}\n) {\n  const check = createInvariantChecker<State, Action>(rules, options);\n\n  return (storeApi: { getState: () => State }) =>\n    (next: (action: Action) => unknown) =>\n    (action: Action) => {\n      const prev = storeApi.getState();\n      const result = next(action);\n      const nextState = storeApi.getState();\n      check(prev, nextState, action);\n      return result;\n    };\n}\n","/**\n * state-invariant/core\n *\n * Framework-agnostic engine. Doesn't know about Redux, Zustand, or anyone else.\n * You give it rules; it tells you whether a state TRANSITION (prev -> next, caused\n * by some action) was legal. This is different from Zod/Yup: those check the shape\n * of ONE object. This checks the relationship between two states and the action\n * that connected them.\n */\n\nexport interface InvariantRule<State = any, Action = any> {\n  /** Human-readable name, shown in error messages and stack traces. */\n  name: string;\n  /**\n   * Optional filter. If provided, the rule only runs when this returns true.\n   * Lets you scope a rule to one action type, e.g. action => action.type === 'WITHDRAW'\n   */\n  when?: (action: Action) => boolean;\n  /**\n   * The actual check. Return true if the transition is valid, false if it violates\n   * the invariant. Alternatively, return a string to indicate a violation and use\n   * that string as the error message.\n   */\n  check: (prev: State, next: State, action: Action) => boolean | string;\n  /**\n   * Optional custom error message builder. Falls back to a generic message.\n   * Ignored if `check` returns a string.\n   */\n  message?: (prev: State, next: State, action: Action) => string;\n}\n\nexport class InvariantViolationError extends Error {\n  ruleName: string;\n  prev: unknown;\n  next: unknown;\n  action: unknown;\n\n  constructor(\n    message: string,\n    details: { ruleName: string; prev: unknown; next: unknown; action: unknown }\n  ) {\n    super(message);\n    this.name = 'InvariantViolationError';\n    this.ruleName = details.ruleName;\n    this.prev = details.prev;\n    this.next = details.next;\n    this.action = details.action;\n  }\n}\n\nexport interface CheckerOptions {\n  /**\n   * 'throw' (default) - throw InvariantViolationError immediately, stopping execution.\n   * 'warn' - console.warn and continue. Useful in production if you don't want to crash.\n   * 'collect' - don't throw or warn, just gather violations; call .getViolations() yourself.\n   */\n  mode?: 'throw' | 'warn' | 'collect';\n}\n\nexport function createInvariantChecker<State = any, Action = any>(\n  rules: InvariantRule<State, Action>[],\n  options: CheckerOptions = {}\n) {\n  const mode = options.mode ?? 'throw';\n  const violations: InvariantViolationError[] = [];\n\n  function check(prev: State, next: State, action: Action): void {\n    for (const rule of rules) {\n      if (rule.when && !rule.when(action)) continue;\n\n      let ok: boolean | string;\n      try {\n        ok = rule.check(prev, next, action);\n      } catch (err) {\n        // A rule that throws internally (e.g. undefined property access) is itself\n        // a bug in the rule, but we surface it as a violation so it's not silently\n        // swallowed by the store.\n        ok = false;\n      }\n\n      if (ok === false || typeof ok === 'string') {\n        const message =\n          typeof ok === 'string'\n            ? ok\n            : rule.message\n            ? rule.message(prev, next, action)\n            : `Invariant \"${rule.name}\" violated`;\n\n        const error = new InvariantViolationError(message, {\n          ruleName: rule.name,\n          prev,\n          next,\n          action,\n        });\n\n        if (mode === 'throw') {\n          throw error;\n        } else if (mode === 'warn') {\n          // eslint-disable-next-line no-console\n          console.warn(`[state-invariant] ${message}`, { prev, next, action });\n        } else {\n          violations.push(error);\n        }\n      }\n    }\n  }\n\n  check.getViolations = () => violations.slice();\n  check.clearViolations = () => {\n    violations.length = 0;\n  };\n\n  return check;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;AC+BO,IAAM,0BAAN,cAAsC,MAAM;AAAA,EAMjD,YACE,SACA,SACA;AACA,UAAM,OAAO;AACb,SAAK,OAAO;AACZ,SAAK,WAAW,QAAQ;AACxB,SAAK,OAAO,QAAQ;AACpB,SAAK,OAAO,QAAQ;AACpB,SAAK,SAAS,QAAQ;AAAA,EACxB;AACF;AAWO,SAAS,uBACd,OACA,UAA0B,CAAC,GAC3B;AA9DF;AA+DE,QAAM,QAAO,aAAQ,SAAR,YAAgB;AAC7B,QAAM,aAAwC,CAAC;AAE/C,WAAS,MAAM,MAAa,MAAa,QAAsB;AAC7D,eAAW,QAAQ,OAAO;AACxB,UAAI,KAAK,QAAQ,CAAC,KAAK,KAAK,MAAM,EAAG;AAErC,UAAI;AACJ,UAAI;AACF,aAAK,KAAK,MAAM,MAAM,MAAM,MAAM;AAAA,MACpC,SAAS,KAAK;AAIZ,aAAK;AAAA,MACP;AAEA,UAAI,OAAO,SAAS,OAAO,OAAO,UAAU;AAC1C,cAAM,UACJ,OAAO,OAAO,WACV,KACA,KAAK,UACL,KAAK,QAAQ,MAAM,MAAM,MAAM,IAC/B,cAAc,KAAK,IAAI;AAE7B,cAAM,QAAQ,IAAI,wBAAwB,SAAS;AAAA,UACjD,UAAU,KAAK;AAAA,UACf;AAAA,UACA;AAAA,UACA;AAAA,QACF,CAAC;AAED,YAAI,SAAS,SAAS;AACpB,gBAAM;AAAA,QACR,WAAW,SAAS,QAAQ;AAE1B,kBAAQ,KAAK,qBAAqB,OAAO,IAAI,EAAE,MAAM,MAAM,OAAO,CAAC;AAAA,QACrE,OAAO;AACL,qBAAW,KAAK,KAAK;AAAA,QACvB;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,QAAM,gBAAgB,MAAM,WAAW,MAAM;AAC7C,QAAM,kBAAkB,MAAM;AAC5B,eAAW,SAAS;AAAA,EACtB;AAEA,SAAO;AACT;;;AD3FO,SAAS,0BACd,OACA,UAA0B,CAAC,GAC3B;AACA,QAAM,QAAQ,uBAAsC,OAAO,OAAO;AAElE,SAAO,CAAC,aACN,CAAC,SACD,CAAC,WAAmB;AAClB,UAAM,OAAO,SAAS,SAAS;AAC/B,UAAM,SAAS,KAAK,MAAM;AAC1B,UAAM,YAAY,SAAS,SAAS;AACpC,UAAM,MAAM,WAAW,MAAM;AAC7B,WAAO;AAAA,EACT;AACJ;","names":[]}

package/dist/redux.d.ts

@@ -0,0 +1,24 @@
+import { InvariantRule, CheckerOptions } from './core';
+/**
+ * Redux middleware. Runs your invariant rules after every dispatch, comparing
+ * state before and after.
+ *
+ * Usage:
+ *   import { createInvariantMiddleware } from 'state-invariant/redux';
+ *
+ *   const middleware = createInvariantMiddleware([
+ *     {
+ *       name: 'balance-never-negative',
+ *       check: (prev, next) => next.balance >= 0,
+ *       message: (prev, next) => `balance went negative: ${next.balance}`,
+ *     },
+ *   ]);
+ *
+ *   const store = configureStore({
+ *     reducer,
+ *     middleware: (getDefault) => getDefault().concat(middleware),
+ *   });
+ */
+export declare function createInvariantMiddleware<State = any, Action = any>(rules: InvariantRule<State, Action>[], options?: CheckerOptions): (storeApi: {
+    getState: () => State;
+}) => (next: (action: Action) => unknown) => (action: Action) => unknown;

package/dist/redux.js

@@ -0,0 +1,19 @@
+import {
+  createInvariantChecker
+} from "./chunk-DRSBKG3Y.js";
+
+// src/redux.ts
+function createInvariantMiddleware(rules, options = {}) {
+  const check = createInvariantChecker(rules, options);
+  return (storeApi) => (next) => (action) => {
+    const prev = storeApi.getState();
+    const result = next(action);
+    const nextState = storeApi.getState();
+    check(prev, nextState, action);
+    return result;
+  };
+}
+export {
+  createInvariantMiddleware
+};
+//# sourceMappingURL=redux.js.map

package/dist/redux.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/redux.ts"],"sourcesContent":["import { createInvariantChecker, InvariantRule, CheckerOptions } from './core';\n\n/**\n * Redux middleware. Runs your invariant rules after every dispatch, comparing\n * state before and after.\n *\n * Usage:\n *   import { createInvariantMiddleware } from 'state-invariant/redux';\n *\n *   const middleware = createInvariantMiddleware([\n *     {\n *       name: 'balance-never-negative',\n *       check: (prev, next) => next.balance >= 0,\n *       message: (prev, next) => `balance went negative: ${next.balance}`,\n *     },\n *   ]);\n *\n *   const store = configureStore({\n *     reducer,\n *     middleware: (getDefault) => getDefault().concat(middleware),\n *   });\n */\nexport function createInvariantMiddleware<State = any, Action = any>(\n  rules: InvariantRule<State, Action>[],\n  options: CheckerOptions = {}\n) {\n  const check = createInvariantChecker<State, Action>(rules, options);\n\n  return (storeApi: { getState: () => State }) =>\n    (next: (action: Action) => unknown) =>\n    (action: Action) => {\n      const prev = storeApi.getState();\n      const result = next(action);\n      const nextState = storeApi.getState();\n      check(prev, nextState, action);\n      return result;\n    };\n}\n"],"mappings":";;;;;AAsBO,SAAS,0BACd,OACA,UAA0B,CAAC,GAC3B;AACA,QAAM,QAAQ,uBAAsC,OAAO,OAAO;AAElE,SAAO,CAAC,aACN,CAAC,SACD,CAAC,WAAmB;AAClB,UAAM,OAAO,SAAS,SAAS;AAC/B,UAAM,SAAS,KAAK,MAAM;AAC1B,UAAM,YAAY,SAAS,SAAS;AACpC,UAAM,MAAM,WAAW,MAAM;AAC7B,WAAO;AAAA,EACT;AACJ;","names":[]}

package/dist/zustand.cjs

@@ -0,0 +1,94 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/zustand.ts
+var zustand_exports = {};
+__export(zustand_exports, {
+  invariant: () => invariant
+});
+module.exports = __toCommonJS(zustand_exports);
+
+// src/core.ts
+var InvariantViolationError = class extends Error {
+  constructor(message, details) {
+    super(message);
+    this.name = "InvariantViolationError";
+    this.ruleName = details.ruleName;
+    this.prev = details.prev;
+    this.next = details.next;
+    this.action = details.action;
+  }
+};
+function createInvariantChecker(rules, options = {}) {
+  var _a;
+  const mode = (_a = options.mode) != null ? _a : "throw";
+  const violations = [];
+  function check(prev, next, action) {
+    for (const rule of rules) {
+      if (rule.when && !rule.when(action)) continue;
+      let ok;
+      try {
+        ok = rule.check(prev, next, action);
+      } catch (err) {
+        ok = false;
+      }
+      if (ok === false || typeof ok === "string") {
+        const message = typeof ok === "string" ? ok : rule.message ? rule.message(prev, next, action) : `Invariant "${rule.name}" violated`;
+        const error = new InvariantViolationError(message, {
+          ruleName: rule.name,
+          prev,
+          next,
+          action
+        });
+        if (mode === "throw") {
+          throw error;
+        } else if (mode === "warn") {
+          console.warn(`[state-invariant] ${message}`, { prev, next, action });
+        } else {
+          violations.push(error);
+        }
+      }
+    }
+  }
+  check.getViolations = () => violations.slice();
+  check.clearViolations = () => {
+    violations.length = 0;
+  };
+  return check;
+}
+
+// src/zustand.ts
+function invariant(rules, options = {}) {
+  const check = createInvariantChecker(rules, options);
+  return (config) => (set, get, api) => {
+    const wrappedSet = (...args) => {
+      const prev = get();
+      set(...args);
+      const next = get();
+      const action = args.length > 2 ? args[2] : void 0;
+      check(prev, next, action);
+    };
+    return config(wrappedSet, get, api);
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  invariant
+});
+//# sourceMappingURL=zustand.cjs.map

package/dist/zustand.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/zustand.ts","../src/core.ts"],"sourcesContent":["import { createInvariantChecker, InvariantRule, CheckerOptions } from './core';\n\n/**\n * Zustand middleware. Wraps `set` so every state update is checked before\n * and after.\n *\n * Note: plain Zustand doesn't have a first-class \"action\" object like Redux does,\n * so `action` will be undefined unless you're using Zustand's `redux` middleware\n * on top (in which case compose this OUTSIDE that one, closer to `create`).\n *\n * Usage:\n *   import { create } from 'zustand';\n *   import { invariant } from 'state-invariant/zustand';\n *\n *   const useStore = create(\n *     invariant([\n *       { name: 'count-never-negative', check: (p, n) => n.count >= 0 }\n *     ])(\n *       (set) => ({ count: 0, decrement: () => set((s) => ({ count: s.count - 1 })) })\n *     )\n *   );\n */\nexport function invariant<State = any, Action = any>(\n  rules: InvariantRule<State, Action>[],\n  options: CheckerOptions = {}\n) {\n  const check = createInvariantChecker<State, Action>(rules, options);\n\n  return (config: (set: any, get: any, api: any) => State) =>\n    (set: any, get: any, api: any) => {\n      const wrappedSet = (...args: any[]) => {\n        const prev = get();\n        set(...args);\n        const next = get();\n        // Zustand `set` signature: set(partial, replace, actionType)\n        const action = (args.length > 2 ? args[2] : undefined) as Action;\n        check(prev, next, action);\n      };\n      return config(wrappedSet, get, api);\n    };\n}\n","/**\n * state-invariant/core\n *\n * Framework-agnostic engine. Doesn't know about Redux, Zustand, or anyone else.\n * You give it rules; it tells you whether a state TRANSITION (prev -> next, caused\n * by some action) was legal. This is different from Zod/Yup: those check the shape\n * of ONE object. This checks the relationship between two states and the action\n * that connected them.\n */\n\nexport interface InvariantRule<State = any, Action = any> {\n  /** Human-readable name, shown in error messages and stack traces. */\n  name: string;\n  /**\n   * Optional filter. If provided, the rule only runs when this returns true.\n   * Lets you scope a rule to one action type, e.g. action => action.type === 'WITHDRAW'\n   */\n  when?: (action: Action) => boolean;\n  /**\n   * The actual check. Return true if the transition is valid, false if it violates\n   * the invariant. Alternatively, return a string to indicate a violation and use\n   * that string as the error message.\n   */\n  check: (prev: State, next: State, action: Action) => boolean | string;\n  /**\n   * Optional custom error message builder. Falls back to a generic message.\n   * Ignored if `check` returns a string.\n   */\n  message?: (prev: State, next: State, action: Action) => string;\n}\n\nexport class InvariantViolationError extends Error {\n  ruleName: string;\n  prev: unknown;\n  next: unknown;\n  action: unknown;\n\n  constructor(\n    message: string,\n    details: { ruleName: string; prev: unknown; next: unknown; action: unknown }\n  ) {\n    super(message);\n    this.name = 'InvariantViolationError';\n    this.ruleName = details.ruleName;\n    this.prev = details.prev;\n    this.next = details.next;\n    this.action = details.action;\n  }\n}\n\nexport interface CheckerOptions {\n  /**\n   * 'throw' (default) - throw InvariantViolationError immediately, stopping execution.\n   * 'warn' - console.warn and continue. Useful in production if you don't want to crash.\n   * 'collect' - don't throw or warn, just gather violations; call .getViolations() yourself.\n   */\n  mode?: 'throw' | 'warn' | 'collect';\n}\n\nexport function createInvariantChecker<State = any, Action = any>(\n  rules: InvariantRule<State, Action>[],\n  options: CheckerOptions = {}\n) {\n  const mode = options.mode ?? 'throw';\n  const violations: InvariantViolationError[] = [];\n\n  function check(prev: State, next: State, action: Action): void {\n    for (const rule of rules) {\n      if (rule.when && !rule.when(action)) continue;\n\n      let ok: boolean | string;\n      try {\n        ok = rule.check(prev, next, action);\n      } catch (err) {\n        // A rule that throws internally (e.g. undefined property access) is itself\n        // a bug in the rule, but we surface it as a violation so it's not silently\n        // swallowed by the store.\n        ok = false;\n      }\n\n      if (ok === false || typeof ok === 'string') {\n        const message =\n          typeof ok === 'string'\n            ? ok\n            : rule.message\n            ? rule.message(prev, next, action)\n            : `Invariant \"${rule.name}\" violated`;\n\n        const error = new InvariantViolationError(message, {\n          ruleName: rule.name,\n          prev,\n          next,\n          action,\n        });\n\n        if (mode === 'throw') {\n          throw error;\n        } else if (mode === 'warn') {\n          // eslint-disable-next-line no-console\n          console.warn(`[state-invariant] ${message}`, { prev, next, action });\n        } else {\n          violations.push(error);\n        }\n      }\n    }\n  }\n\n  check.getViolations = () => violations.slice();\n  check.clearViolations = () => {\n    violations.length = 0;\n  };\n\n  return check;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;AC+BO,IAAM,0BAAN,cAAsC,MAAM;AAAA,EAMjD,YACE,SACA,SACA;AACA,UAAM,OAAO;AACb,SAAK,OAAO;AACZ,SAAK,WAAW,QAAQ;AACxB,SAAK,OAAO,QAAQ;AACpB,SAAK,OAAO,QAAQ;AACpB,SAAK,SAAS,QAAQ;AAAA,EACxB;AACF;AAWO,SAAS,uBACd,OACA,UAA0B,CAAC,GAC3B;AA9DF;AA+DE,QAAM,QAAO,aAAQ,SAAR,YAAgB;AAC7B,QAAM,aAAwC,CAAC;AAE/C,WAAS,MAAM,MAAa,MAAa,QAAsB;AAC7D,eAAW,QAAQ,OAAO;AACxB,UAAI,KAAK,QAAQ,CAAC,KAAK,KAAK,MAAM,EAAG;AAErC,UAAI;AACJ,UAAI;AACF,aAAK,KAAK,MAAM,MAAM,MAAM,MAAM;AAAA,MACpC,SAAS,KAAK;AAIZ,aAAK;AAAA,MACP;AAEA,UAAI,OAAO,SAAS,OAAO,OAAO,UAAU;AAC1C,cAAM,UACJ,OAAO,OAAO,WACV,KACA,KAAK,UACL,KAAK,QAAQ,MAAM,MAAM,MAAM,IAC/B,cAAc,KAAK,IAAI;AAE7B,cAAM,QAAQ,IAAI,wBAAwB,SAAS;AAAA,UACjD,UAAU,KAAK;AAAA,UACf;AAAA,UACA;AAAA,UACA;AAAA,QACF,CAAC;AAED,YAAI,SAAS,SAAS;AACpB,gBAAM;AAAA,QACR,WAAW,SAAS,QAAQ;AAE1B,kBAAQ,KAAK,qBAAqB,OAAO,IAAI,EAAE,MAAM,MAAM,OAAO,CAAC;AAAA,QACrE,OAAO;AACL,qBAAW,KAAK,KAAK;AAAA,QACvB;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,QAAM,gBAAgB,MAAM,WAAW,MAAM;AAC7C,QAAM,kBAAkB,MAAM;AAC5B,eAAW,SAAS;AAAA,EACtB;AAEA,SAAO;AACT;;;AD3FO,SAAS,UACd,OACA,UAA0B,CAAC,GAC3B;AACA,QAAM,QAAQ,uBAAsC,OAAO,OAAO;AAElE,SAAO,CAAC,WACN,CAAC,KAAU,KAAU,QAAa;AAChC,UAAM,aAAa,IAAI,SAAgB;AACrC,YAAM,OAAO,IAAI;AACjB,UAAI,GAAG,IAAI;AACX,YAAM,OAAO,IAAI;AAEjB,YAAM,SAAU,KAAK,SAAS,IAAI,KAAK,CAAC,IAAI;AAC5C,YAAM,MAAM,MAAM,MAAM;AAAA,IAC1B;AACA,WAAO,OAAO,YAAY,KAAK,GAAG;AAAA,EACpC;AACJ;","names":[]}

package/dist/zustand.d.ts

@@ -0,0 +1,22 @@
+import { InvariantRule, CheckerOptions } from './core';
+/**
+ * Zustand middleware. Wraps `set` so every state update is checked before
+ * and after.
+ *
+ * Note: plain Zustand doesn't have a first-class "action" object like Redux does,
+ * so `action` will be undefined unless you're using Zustand's `redux` middleware
+ * on top (in which case compose this OUTSIDE that one, closer to `create`).
+ *
+ * Usage:
+ *   import { create } from 'zustand';
+ *   import { invariant } from 'state-invariant/zustand';
+ *
+ *   const useStore = create(
+ *     invariant([
+ *       { name: 'count-never-negative', check: (p, n) => n.count >= 0 }
+ *     ])(
+ *       (set) => ({ count: 0, decrement: () => set((s) => ({ count: s.count - 1 })) })
+ *     )
+ *   );
+ */
+export declare function invariant<State = any, Action = any>(rules: InvariantRule<State, Action>[], options?: CheckerOptions): (config: (set: any, get: any, api: any) => State) => (set: any, get: any, api: any) => State;

package/dist/zustand.js

@@ -0,0 +1,22 @@
+import {
+  createInvariantChecker
+} from "./chunk-DRSBKG3Y.js";
+
+// src/zustand.ts
+function invariant(rules, options = {}) {
+  const check = createInvariantChecker(rules, options);
+  return (config) => (set, get, api) => {
+    const wrappedSet = (...args) => {
+      const prev = get();
+      set(...args);
+      const next = get();
+      const action = args.length > 2 ? args[2] : void 0;
+      check(prev, next, action);
+    };
+    return config(wrappedSet, get, api);
+  };
+}
+export {
+  invariant
+};
+//# sourceMappingURL=zustand.js.map

package/dist/zustand.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/zustand.ts"],"sourcesContent":["import { createInvariantChecker, InvariantRule, CheckerOptions } from './core';\n\n/**\n * Zustand middleware. Wraps `set` so every state update is checked before\n * and after.\n *\n * Note: plain Zustand doesn't have a first-class \"action\" object like Redux does,\n * so `action` will be undefined unless you're using Zustand's `redux` middleware\n * on top (in which case compose this OUTSIDE that one, closer to `create`).\n *\n * Usage:\n *   import { create } from 'zustand';\n *   import { invariant } from 'state-invariant/zustand';\n *\n *   const useStore = create(\n *     invariant([\n *       { name: 'count-never-negative', check: (p, n) => n.count >= 0 }\n *     ])(\n *       (set) => ({ count: 0, decrement: () => set((s) => ({ count: s.count - 1 })) })\n *     )\n *   );\n */\nexport function invariant<State = any, Action = any>(\n  rules: InvariantRule<State, Action>[],\n  options: CheckerOptions = {}\n) {\n  const check = createInvariantChecker<State, Action>(rules, options);\n\n  return (config: (set: any, get: any, api: any) => State) =>\n    (set: any, get: any, api: any) => {\n      const wrappedSet = (...args: any[]) => {\n        const prev = get();\n        set(...args);\n        const next = get();\n        // Zustand `set` signature: set(partial, replace, actionType)\n        const action = (args.length > 2 ? args[2] : undefined) as Action;\n        check(prev, next, action);\n      };\n      return config(wrappedSet, get, api);\n    };\n}\n"],"mappings":";;;;;AAsBO,SAAS,UACd,OACA,UAA0B,CAAC,GAC3B;AACA,QAAM,QAAQ,uBAAsC,OAAO,OAAO;AAElE,SAAO,CAAC,WACN,CAAC,KAAU,KAAU,QAAa;AAChC,UAAM,aAAa,IAAI,SAAgB;AACrC,YAAM,OAAO,IAAI;AACjB,UAAI,GAAG,IAAI;AACX,YAAM,OAAO,IAAI;AAEjB,YAAM,SAAU,KAAK,SAAS,IAAI,KAAK,CAAC,IAAI;AAC5C,YAAM,MAAM,MAAM,MAAM;AAAA,IAC1B;AACA,WAAO,OAAO,YAAY,KAAK,GAAG;AAAA,EACpC;AACJ;","names":[]}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "state-invariant",
+  "version": "0.1.0",
+  "description": "Cross-verify state transitions against declared invariants, in any state management library (Redux, Zustand, or plain reducers). Not shape validation like Zod - transition validation: given prev state, next state, and the action that connected them, was it legal?",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./redux": {
+      "types": "./dist/redux.d.ts",
+      "import": "./dist/redux.js",
+      "require": "./dist/redux.cjs"
+    },
+    "./zustand": {
+      "types": "./dist/zustand.d.ts",
+      "import": "./dist/zustand.js",
+      "require": "./dist/zustand.cjs"
+    },
+    "./generic": {
+      "types": "./dist/generic.d.ts",
+      "import": "./dist/generic.js",
+      "require": "./dist/generic.cjs"
+    },
+    "./backend": {
+      "types": "./dist/backend.d.ts",
+      "import": "./dist/backend.js",
+      "require": "./dist/backend.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup && tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "state management",
+    "redux",
+    "zustand",
+    "validation",
+    "invariant",
+    "runtime checking"
+  ],
+  "author": "Amal Vijayakumar",
+  "license": "MIT",
+  "devDependencies": {
+    "typescript": "^5.9.3",
+    "tsup": "^8.5.0"
+  }
+}