@oxog/state 1.0.0 → 1.2.0

package/dist/index.cjs

@@ -2,6 +2,27 @@
 
 var react = require('react');
 
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+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/utils/deep-clone.ts
 function deepClone(value, seen) {
   if (value === null || typeof value !== "object") {
@@ -37,6 +58,10 @@ function deepClone(value, seen) {
   }
   return value;
 }
+var init_deep_clone = __esm({
+  "src/utils/deep-clone.ts"() {
+  }
+});
 
 // src/utils/deep-equal.ts
 function deepEqual(a, b) {
@@ -73,6 +98,10 @@ function deepEqual(a, b) {
   }
   return true;
 }
+var init_deep_equal = __esm({
+  "src/utils/deep-equal.ts"() {
+  }
+});
 
 // src/utils/shallow-equal.ts
 function shallowEqual(a, b) {
@@ -94,6 +123,10 @@ function shallowEqual(a, b) {
   }
   return true;
 }
+var init_shallow_equal = __esm({
+  "src/utils/shallow-equal.ts"() {
+  }
+});
 
 // src/utils/deep-merge.ts
 function deepMerge(target, source) {
@@ -142,11 +175,20 @@ function cloneValue(value) {
   }
   return value;
 }
+var init_deep_merge = __esm({
+  "src/utils/deep-merge.ts"() {
+    init_deep_clone();
+  }
+});
 
 // src/utils/is-function.ts
 function isFunction(value) {
   return typeof value === "function";
 }
+var init_is_function = __esm({
+  "src/utils/is-function.ts"() {
+  }
+});
 
 // src/utils/pick.ts
 function pick(obj, keys) {
@@ -158,6 +200,10 @@ function pick(obj, keys) {
   }
   return result;
 }
+var init_pick = __esm({
+  "src/utils/pick.ts"() {
+  }
+});
 
 // src/utils/omit.ts
 function omit(obj, keys) {
@@ -167,227 +213,251 @@ function omit(obj, keys) {
   }
   return result;
 }
+var init_omit = __esm({
+  "src/utils/omit.ts"() {
+  }
+});
 
 // src/utils/identity.ts
 function identity(value) {
   return value;
 }
+var init_identity = __esm({
+  "src/utils/identity.ts"() {
+  }
+});
+
+// src/utils/index.ts
+var init_utils = __esm({
+  "src/utils/index.ts"() {
+    init_deep_clone();
+    init_deep_equal();
+    init_shallow_equal();
+    init_deep_merge();
+    init_is_function();
+    init_pick();
+    init_omit();
+    init_identity();
+  }
+});
 
 // src/kernel.ts
-var EventBus = class {
-  listeners = /* @__PURE__ */ new Map();
-  /**
-   * Subscribe to an event.
-   *
-   * @param event - Event name
-   * @param handler - Event handler
-   * @returns Unsubscribe function
-   */
-  on(event, handler) {
-    if (!this.listeners.has(event)) {
-      this.listeners.set(event, /* @__PURE__ */ new Set());
-    }
-    this.listeners.get(event).add(handler);
-    return () => {
-      this.listeners.get(event)?.delete(handler);
-    };
-  }
-  /**
-   * Emit an event to all subscribers.
-   *
-   * @param event - Event name
-   * @param data - Event data
-   */
-  emit(event, data) {
-    const handlers = this.listeners.get(event);
-    if (handlers) {
-      for (const handler of handlers) {
-        try {
-          handler(data);
-        } catch (error) {
-          console.error(`Error in ${event} handler:`, error);
+function createKernel(config) {
+  return new Kernel(config);
+}
+var EventBus, Kernel;
+var init_kernel = __esm({
+  "src/kernel.ts"() {
+    EventBus = class {
+      listeners = /* @__PURE__ */ new Map();
+      /**
+       * Subscribe to an event.
+       *
+       * @param event - Event name
+       * @param handler - Event handler
+       * @returns Unsubscribe function
+       */
+      on(event, handler) {
+        if (!this.listeners.has(event)) {
+          this.listeners.set(event, /* @__PURE__ */ new Set());
         }
+        this.listeners.get(event).add(handler);
+        return () => {
+          this.listeners.get(event)?.delete(handler);
+        };
       }
-    }
-  }
-  /** Clear all listeners. */
-  destroy() {
-    this.listeners.clear();
-  }
-};
-var Kernel = class {
-  plugins = /* @__PURE__ */ new Map();
-  eventBus = new EventBus();
-  config;
-  errorHandlers = /* @__PURE__ */ new Set();
-  initializing = false;
-  constructor(config) {
-    this.config = config || {};
-  }
-  /**
-   * Register a plugin.
-   *
-   * @param plugin - The plugin to register
-   * @param options - Plugin options
-   * @param store - The store instance
-   * @throws {Error} If plugin already registered or dependencies missing
-   */
-  register(plugin, options, store) {
-    if (!plugin.name || !plugin.version || typeof plugin.install !== "function") {
-      throw new Error("Invalid plugin: must have name, version, and install function");
-    }
-    if (this.plugins.has(plugin.name)) {
-      throw new Error(`Plugin '${plugin.name}' is already registered`);
-    }
-    if (plugin.dependencies) {
-      for (const dep of plugin.dependencies) {
-        if (!this.plugins.has(dep)) {
-          throw new Error(
-            `Plugin '${plugin.name}' requires '${dep}' to be registered first`
-          );
+      /**
+       * Emit an event to all subscribers.
+       *
+       * @param event - Event name
+       * @param data - Event data
+       */
+      emit(event, data) {
+        const handlers = this.listeners.get(event);
+        if (handlers) {
+          for (const handler of handlers) {
+            try {
+              handler(data);
+            } catch (error) {
+              console.error(`Error in ${event} handler:`, error);
+            }
+          }
         }
       }
-    }
-    const instance = {
-      plugin,
-      options
-    };
-    try {
-      plugin.install(store, options);
-    } catch (error) {
-      throw new Error(`Failed to install plugin '${plugin.name}': ${error}`);
-    }
-    this.plugins.set(plugin.name, instance);
-    if (!this.initializing && plugin.onInit) {
-      this.runOnInit(plugin, store);
-    }
-  }
-  /**
-   * Initialize all plugins.
-   *
-   * @param store - The store instance
-   */
-  async initializeAll(store) {
-    this.initializing = true;
-    const plugins = Array.from(this.plugins.values());
-    for (const { plugin } of plugins) {
-      if (plugin.onInit) {
-        await this.runOnInit(plugin, store);
+      /** Clear all listeners. */
+      destroy() {
+        this.listeners.clear();
       }
-    }
-    this.initializing = false;
-  }
-  /**
-   * Run plugin's onInit safely.
-   */
-  async runOnInit(plugin, store) {
-    try {
-      await plugin.onInit(store);
-    } catch (error) {
-      console.error(`Error in ${plugin.name} onInit:`, error);
-    }
-  }
-  /**
-   * Unregister a plugin.
-   *
-   * @param name - Plugin name
-   */
-  async unregister(name) {
-    const instance = this.plugins.get(name);
-    if (!instance) {
-      return;
-    }
-    if (instance.plugin.onDestroy) {
-      try {
-        await instance.plugin.onDestroy();
-      } catch (error) {
-        console.error(`Error in ${name} onDestroy:`, error);
+    };
+    Kernel = class {
+      plugins = /* @__PURE__ */ new Map();
+      eventBus = new EventBus();
+      config;
+      errorHandlers = /* @__PURE__ */ new Set();
+      initializing = false;
+      constructor(config) {
+        this.config = config || {};
       }
-    }
-    this.plugins.delete(name);
-  }
-  /**
-   * Emit a state change event.
-   *
-   * @param state - New state
-   * @param prevState - Previous state
-   */
-  emitStateChange(state, prevState) {
-    this.eventBus.emit("stateChange", { state, prevState });
-    for (const { plugin } of this.plugins.values()) {
-      if (plugin.onStateChange) {
+      /**
+       * Register a plugin.
+       *
+       * @param plugin - The plugin to register
+       * @param options - Plugin options
+       * @param store - The store instance
+       * @throws {Error} If plugin already registered or dependencies missing
+       */
+      register(plugin, options, store) {
+        if (!plugin.name || !plugin.version || typeof plugin.install !== "function") {
+          throw new Error("Invalid plugin: must have name, version, and install function");
+        }
+        if (this.plugins.has(plugin.name)) {
+          throw new Error(`Plugin '${plugin.name}' is already registered`);
+        }
+        if (plugin.dependencies) {
+          for (const dep of plugin.dependencies) {
+            if (!this.plugins.has(dep)) {
+              throw new Error(
+                `Plugin '${plugin.name}' requires '${dep}' to be registered first`
+              );
+            }
+          }
+        }
+        const instance = {
+          plugin,
+          options
+        };
         try {
-          plugin.onStateChange(state, prevState);
+          plugin.install(store, options);
         } catch (error) {
-          console.error(`Error in ${plugin.name} onStateChange:`, error);
+          throw new Error(`Failed to install plugin '${plugin.name}': ${error}`);
+        }
+        this.plugins.set(plugin.name, instance);
+        if (!this.initializing && plugin.onInit) {
+          this.runOnInit(plugin, store);
         }
       }
-    }
-  }
-  /**
-   * Emit an error event.
-   *
-   * @param error - The error
-   */
-  emitError(error) {
-    this.eventBus.emit("error", error);
-    for (const { plugin } of this.plugins.values()) {
-      if (plugin.onError) {
+      /**
+       * Initialize all plugins.
+       *
+       * @param store - The store instance
+       */
+      async initializeAll(store) {
+        this.initializing = true;
+        const plugins = Array.from(this.plugins.values());
+        for (const { plugin } of plugins) {
+          if (plugin.onInit) {
+            await this.runOnInit(plugin, store);
+          }
+        }
+        this.initializing = false;
+      }
+      /**
+       * Run plugin's onInit safely.
+       */
+      async runOnInit(plugin, store) {
         try {
-          plugin.onError(error);
-        } catch (err) {
-          console.error(`Error in ${plugin.name} onError:`, err);
+          await plugin.onInit(store);
+        } catch (error) {
+          console.error(`Error in ${plugin.name} onInit:`, error);
         }
       }
-    }
-    for (const handler of this.errorHandlers) {
-      try {
-        handler(error);
-      } catch (err) {
-        console.error("Error in error handler:", err);
+      /**
+       * Unregister a plugin.
+       *
+       * @param name - Plugin name
+       */
+      async unregister(name) {
+        const instance = this.plugins.get(name);
+        if (!instance) {
+          return;
+        }
+        if (instance.plugin.onDestroy) {
+          try {
+            await instance.plugin.onDestroy();
+          } catch (error) {
+            console.error(`Error in ${name} onDestroy:`, error);
+          }
+        }
+        this.plugins.delete(name);
+      }
+      /**
+       * Emit a state change event.
+       *
+       * @param state - New state
+       * @param prevState - Previous state
+       */
+      emitStateChange(state, prevState) {
+        this.eventBus.emit("stateChange", { state, prevState });
+        for (const { plugin } of this.plugins.values()) {
+          if (plugin.onStateChange) {
+            try {
+              plugin.onStateChange(state, prevState);
+            } catch (error) {
+              console.error(`Error in ${plugin.name} onStateChange:`, error);
+            }
+          }
+        }
+      }
+      /**
+       * Emit an error event.
+       *
+       * @param error - The error
+       */
+      emitError(error) {
+        this.eventBus.emit("error", error);
+        for (const { plugin } of this.plugins.values()) {
+          if (plugin.onError) {
+            try {
+              plugin.onError(error);
+            } catch (err) {
+              console.error(`Error in ${plugin.name} onError:`, err);
+            }
+          }
+        }
+        for (const handler of this.errorHandlers) {
+          try {
+            handler(error);
+          } catch (err) {
+            console.error("Error in error handler:", err);
+          }
+        }
+      }
+      /**
+       * Add an error handler.
+       *
+       * @param handler - Error handler function
+       * @returns Unsubscribe function
+       */
+      onError(handler) {
+        this.errorHandlers.add(handler);
+        return () => {
+          this.errorHandlers.delete(handler);
+        };
+      }
+      /**
+       * Subscribe to an event.
+       *
+       * @param event - Event name
+       * @param handler - Event handler
+       * @returns Unsubscribe function
+       */
+      on(event, handler) {
+        return this.eventBus.on(event, handler);
+      }
+      /** Destroy the kernel and cleanup. */
+      async destroy() {
+        const pluginNames = Array.from(this.plugins.keys());
+        for (const name of pluginNames) {
+          await this.unregister(name);
+        }
+        this.eventBus.destroy();
+        this.errorHandlers.clear();
       }
-    }
-  }
-  /**
-   * Add an error handler.
-   *
-   * @param handler - Error handler function
-   * @returns Unsubscribe function
-   */
-  onError(handler) {
-    this.errorHandlers.add(handler);
-    return () => {
-      this.errorHandlers.delete(handler);
     };
   }
-  /**
-   * Subscribe to an event.
-   *
-   * @param event - Event name
-   * @param handler - Event handler
-   * @returns Unsubscribe function
-   */
-  on(event, handler) {
-    return this.eventBus.on(event, handler);
-  }
-  /** Destroy the kernel and cleanup. */
-  async destroy() {
-    const pluginNames = Array.from(this.plugins.keys());
-    for (const name of pluginNames) {
-      await this.unregister(name);
-    }
-    this.eventBus.destroy();
-    this.errorHandlers.clear();
-  }
-};
-function createKernel(config) {
-  return new Kernel(config);
-}
+});
 
 // src/batch-context.ts
-var batchDepth = 0;
-var batchStores = /* @__PURE__ */ new Set();
-var batchManagedStores = /* @__PURE__ */ new Set();
 function isBatching() {
   return batchDepth > 0;
 }
@@ -416,320 +486,94 @@ function addManagedStore(store) {
 function isStoreManaged(store) {
   return batchManagedStores.has(store);
 }
-var sharedBatchContext = {
-  get depth() {
-    return batchDepth;
-  },
-  get stores() {
-    return batchStores;
-  },
-  get managedStores() {
-    return batchManagedStores;
-  },
-  isBatching,
-  batch(store, fn) {
-    const wasAlreadyBatching = isStoreManaged(store);
-    incrementBatchDepth();
-    addBatchStore(store);
-    if (!wasAlreadyBatching && "beginBatch" in store) {
-      store.beginBatch();
-      addManagedStore(store);
-    }
-    try {
-      const result = fn();
-      decrementBatchDepth();
-      if (getBatchDepth() === 0) {
-        for (const s of getBatchManagedStores()) {
-          if ("flushNotifications" in s) {
-            s.flushNotifications();
-          }
-          if ("endBatch" in s) {
-            s.endBatch();
-          }
+var batchDepth, batchStores, batchManagedStores, sharedBatchContext;
+var init_batch_context = __esm({
+  "src/batch-context.ts"() {
+    batchDepth = 0;
+    batchStores = /* @__PURE__ */ new Set();
+    batchManagedStores = /* @__PURE__ */ new Set();
+    sharedBatchContext = {
+      get depth() {
+        return batchDepth;
+      },
+      get stores() {
+        return batchStores;
+      },
+      get managedStores() {
+        return batchManagedStores;
+      },
+      isBatching,
+      batch(store, fn) {
+        const wasAlreadyBatching = isStoreManaged(store);
+        incrementBatchDepth();
+        addBatchStore(store);
+        if (!wasAlreadyBatching && "beginBatch" in store) {
+          store.beginBatch();
+          addManagedStore(store);
         }
-        clearBatchStores();
-      }
-      return result;
-    } catch (error) {
-      decrementBatchDepth();
-      if (getBatchDepth() === 0) {
-        for (const s of getBatchManagedStores()) {
-          if ("endBatch" in s) {
-            s.endBatch();
+        try {
+          const result = fn();
+          decrementBatchDepth();
+          if (getBatchDepth() === 0) {
+            for (const s of getBatchManagedStores()) {
+              if ("flushNotifications" in s) {
+                s.flushNotifications();
+              }
+              if ("endBatch" in s) {
+                s.endBatch();
+              }
+            }
+            clearBatchStores();
+          }
+          return result;
+        } catch (error) {
+          decrementBatchDepth();
+          if (getBatchDepth() === 0) {
+            for (const s of getBatchManagedStores()) {
+              if ("endBatch" in s) {
+                s.endBatch();
+              }
+            }
+            clearBatchStores();
           }
+          throw error;
         }
-        clearBatchStores();
       }
-      throw error;
-    }
+    };
   }
-};
+});
 
 // src/types.ts
-var StoreErrorCode = /* @__PURE__ */ ((StoreErrorCode2) => {
-  StoreErrorCode2["STORE_DESTROYED"] = "STORE_DESTROYED";
-  StoreErrorCode2["PLUGIN_EXISTS"] = "PLUGIN_EXISTS";
-  StoreErrorCode2["PLUGIN_DEPENDENCY_MISSING"] = "PLUGIN_DEPENDENCY_MISSING";
-  StoreErrorCode2["INVALID_STATE_UPDATE"] = "INVALID_STATE_UPDATE";
-  StoreErrorCode2["ACTION_ERROR"] = "ACTION_ERROR";
-  return StoreErrorCode2;
-})(StoreErrorCode || {});
-var StoreError = class extends Error {
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-    this.name = "StoreError";
-  }
-};
-
-// src/store.ts
-var StoreImpl = class {
-  state;
-  initialState;
-  listeners = /* @__PURE__ */ new Set();
-  selectorSubscriptions = /* @__PURE__ */ new Map();
-  kernel;
-  destroyed = false;
-  batchDepth = 0;
-  pendingNotify = false;
-  queuedState = null;
-  queuedPrevState = null;
-  actions = {};
-  constructor(initialState, kernel) {
-    this.state = deepClone(initialState);
-    this.initialState = deepClone(initialState);
-    this.kernel = kernel;
-    this.kernel.onError((error) => {
-      console.error("Store error:", error);
-    });
-  }
-  /** Get current state snapshot. */
-  getState() {
-    this.checkNotDestroyed();
-    return this.state;
-  }
-  /** Update state with partial object or function. */
-  setState(partial) {
-    this.checkNotDestroyed();
-    const prevState = this.state;
-    const update = typeof partial === "function" ? partial(this.state) : partial;
-    this.state = { ...this.state, ...update };
-    this.notifyOrQueue(this.state, prevState);
-  }
-  /** Deep merge state. */
-  merge(partial) {
-    this.checkNotDestroyed();
-    const prevState = this.state;
-    this.state = deepMerge(this.state, partial);
-    this.notifyOrQueue(this.state, prevState);
-  }
-  /** Reset to initial state. */
-  reset() {
-    this.checkNotDestroyed();
-    const prevState = this.state;
-    this.state = deepClone(this.initialState);
-    this.notifyOrQueue(this.state, prevState);
-  }
-  subscribe(arg1, arg2, arg3) {
-    this.checkNotDestroyed();
-    if (arg2 === void 0 && typeof arg1 === "function") {
-      const listener2 = arg1;
-      this.listeners.add(listener2);
-      return () => {
-        this.listeners.delete(listener2);
-      };
-    }
-    const selector2 = arg1;
-    const listener = arg2;
-    const equalityFn = arg3 || shallowEqual;
-    let subscription = this.selectorSubscriptions.get(selector2);
-    if (!subscription) {
-      const initialValue = selector2(this.state);
-      subscription = {
-        value: initialValue,
-        listeners: /* @__PURE__ */ new Set(),
-        selector: selector2,
-        equalityFn
-      };
-      this.selectorSubscriptions.set(selector2, subscription);
-    }
-    subscription.listeners.add(listener);
-    return () => {
-      const sub = this.selectorSubscriptions.get(selector2);
-      if (sub) {
-        sub.listeners.delete(listener);
-        if (sub.listeners.size === 0) {
-          this.selectorSubscriptions.delete(selector2);
-        }
-      }
-    };
-  }
-  /** Register a plugin. */
-  use(plugin, options) {
-    this.checkNotDestroyed();
-    this.kernel.register(plugin, options, this);
-    return this;
-  }
-  /** Destroy store and cleanup. */
-  destroy() {
-    if (this.destroyed) {
-      return;
-    }
-    this.destroyed = true;
-    this.kernel.destroy();
-    this.listeners.clear();
-    this.selectorSubscriptions.clear();
-    this.actions = {};
-  }
-  /** Add an action (for fluent builder pattern). */
-  addAction(name, fn) {
-    this.actions[name] = fn;
-    return this;
-  }
-  /** Get all actions. */
-  getActions() {
-    return this.actions;
-  }
-  /** Check if store is destroyed. */
-  checkNotDestroyed() {
-    if (this.destroyed) {
-      throw new Error("Cannot use destroyed store");
-    }
-  }
-  /** Notify listeners or queue if batching. */
-  notifyOrQueue(state, prevState) {
-    const inGlobalBatch = sharedBatchContext.isBatching();
-    if (inGlobalBatch) {
-      const managedStores = sharedBatchContext.managedStores;
-      if (!managedStores.has(this)) {
-        managedStores.add(this);
-      }
-    }
-    if (this.batchDepth > 0 || inGlobalBatch) {
-      this.queuedState = state;
-      if (!this.pendingNotify) {
-        this.queuedPrevState = prevState;
-      }
-      this.pendingNotify = true;
-    } else {
-      this.notify(state, prevState);
-    }
-  }
-  /** Notify all listeners. */
-  notify(state, prevState) {
-    this.kernel.emitStateChange(state, prevState);
-    for (const listener of this.listeners) {
-      try {
-        listener(state, prevState);
-      } catch (error) {
-        this.kernel.emitError(error);
-      }
-    }
-    for (const subscription of this.selectorSubscriptions.values()) {
-      const newValue = subscription.selector(state);
-      if (!subscription.equalityFn(newValue, subscription.value)) {
-        const prevValue = subscription.value;
-        subscription.value = newValue;
-        for (const listener of subscription.listeners) {
-          try {
-            listener(newValue, prevValue);
-          } catch (error) {
-            this.kernel.emitError(error);
-          }
-        }
-      }
-    }
-  }
-  /** Flush pending notifications (end of batch). */
-  flushNotifications() {
-    if (this.pendingNotify) {
-      this.notify(this.queuedState, this.queuedPrevState);
-      this.pendingNotify = false;
-      this.queuedState = null;
-      this.queuedPrevState = null;
-    }
-  }
-  /** Start batching. */
-  beginBatch() {
-    this.batchDepth++;
-  }
-  /** End batching. */
-  endBatch() {
-    this.batchDepth--;
-    if (this.batchDepth === 0) {
-      this.flushNotifications();
-    }
-  }
-};
-var StoreBuilderImpl = class {
-  store;
-  constructor(initialState, kernel) {
-    this.store = new StoreImpl(initialState, kernel);
-  }
-  getState() {
-    return this.store.getState();
-  }
-  setState(partial) {
-    this.store.setState(partial);
-  }
-  merge(partial) {
-    this.store.merge(partial);
-  }
-  reset() {
-    this.store.reset();
-  }
-  subscribe(arg1, arg2, arg3) {
-    if (arg2 === void 0) {
-      return this.store.subscribe(arg1);
-    } else {
-      return this.store.subscribe(arg1, arg2, arg3);
-    }
-  }
-  use(plugin, options) {
-    this.store.use(plugin, options);
-    return this;
-  }
-  destroy() {
-    this.store.destroy();
-  }
-  action(name, fn) {
-    this.store.addAction(name, fn);
-    this[name] = (...args) => {
-      const currentState = this.getState();
-      const result = fn(currentState, ...args);
-      if (result instanceof Promise) {
-        return result.then((partial) => {
-          this.setState(partial);
-          return partial;
-        });
+exports.StoreErrorCode = void 0; exports.StoreError = void 0;
+var init_types = __esm({
+  "src/types.ts"() {
+    exports.StoreErrorCode = /* @__PURE__ */ ((StoreErrorCode2) => {
+      StoreErrorCode2["STORE_DESTROYED"] = "STORE_DESTROYED";
+      StoreErrorCode2["PLUGIN_EXISTS"] = "PLUGIN_EXISTS";
+      StoreErrorCode2["PLUGIN_DEPENDENCY_MISSING"] = "PLUGIN_DEPENDENCY_MISSING";
+      StoreErrorCode2["INVALID_STATE_UPDATE"] = "INVALID_STATE_UPDATE";
+      StoreErrorCode2["ACTION_ERROR"] = "ACTION_ERROR";
+      return StoreErrorCode2;
+    })(exports.StoreErrorCode || {});
+    exports.StoreError = class extends Error {
+      constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "StoreError";
       }
-      this.setState(result);
-      return result;
     };
-    return this;
-  }
-  /** Add action (internal use). */
-  addAction(name, fn) {
-    this.store.addAction(name, fn);
-    return this;
-  }
-  /** Get actions (internal use). */
-  getActions() {
-    return this.store.getActions();
-  }
-  /** Start batching. */
-  beginBatch() {
-    this.store.beginBatch();
   }
-  /** End batching. */
-  endBatch() {
-    this.store.endBatch();
-  }
-  /** Flush pending notifications. */
-  flushNotifications() {
-    this.store.flushNotifications();
-  }
-};
+});
+
+// src/store.ts
+var store_exports = {};
+__export(store_exports, {
+  StoreError: () => exports.StoreError,
+  StoreErrorCode: () => exports.StoreErrorCode,
+  StoreImpl: () => StoreImpl,
+  batch: () => batch,
+  createStore: () => createStore
+});
 function createStore(initialState, actions) {
   const kernel = createKernel({ name: "store" });
   const state = { ...initialState };
@@ -796,6 +640,270 @@ function createStore(initialState, actions) {
 function batch(fn) {
   return fn();
 }
+var StoreImpl, StoreBuilderImpl;
+var init_store = __esm({
+  "src/store.ts"() {
+    init_utils();
+    init_kernel();
+    init_batch_context();
+    init_types();
+    StoreImpl = class {
+      state;
+      initialState;
+      listeners = /* @__PURE__ */ new Set();
+      selectorSubscriptions = /* @__PURE__ */ new Map();
+      kernel;
+      destroyed = false;
+      batchDepth = 0;
+      pendingNotify = false;
+      queuedState = null;
+      queuedPrevState = null;
+      actions = {};
+      constructor(initialState, kernel) {
+        this.state = deepClone(initialState);
+        this.initialState = deepClone(initialState);
+        this.kernel = kernel;
+        this.kernel.onError((error) => {
+          console.error("Store error:", error);
+        });
+      }
+      /** Get current state snapshot. */
+      getState() {
+        this.checkNotDestroyed();
+        return this.state;
+      }
+      /** Update state with partial object or function. */
+      setState(partial) {
+        this.checkNotDestroyed();
+        const prevState = this.state;
+        const update = typeof partial === "function" ? partial(this.state) : partial;
+        this.state = { ...this.state, ...update };
+        this.notifyOrQueue(this.state, prevState);
+      }
+      /** Deep merge state. */
+      merge(partial) {
+        this.checkNotDestroyed();
+        const prevState = this.state;
+        this.state = deepMerge(this.state, partial);
+        this.notifyOrQueue(this.state, prevState);
+      }
+      /** Reset to initial state. */
+      reset() {
+        this.checkNotDestroyed();
+        const prevState = this.state;
+        this.state = deepClone(this.initialState);
+        this.notifyOrQueue(this.state, prevState);
+      }
+      subscribe(arg1, arg2, arg3) {
+        this.checkNotDestroyed();
+        if (arg2 === void 0 && typeof arg1 === "function") {
+          const listener2 = arg1;
+          this.listeners.add(listener2);
+          return () => {
+            this.listeners.delete(listener2);
+          };
+        }
+        const selector2 = arg1;
+        const listener = arg2;
+        const equalityFn = arg3 || shallowEqual;
+        let subscription = this.selectorSubscriptions.get(selector2);
+        if (!subscription) {
+          const initialValue = selector2(this.state);
+          subscription = {
+            value: initialValue,
+            listeners: /* @__PURE__ */ new Set(),
+            selector: selector2,
+            equalityFn
+          };
+          this.selectorSubscriptions.set(selector2, subscription);
+        }
+        subscription.listeners.add(listener);
+        return () => {
+          const sub = this.selectorSubscriptions.get(selector2);
+          if (sub) {
+            sub.listeners.delete(listener);
+            if (sub.listeners.size === 0) {
+              this.selectorSubscriptions.delete(selector2);
+            }
+          }
+        };
+      }
+      /** Register a plugin. */
+      use(plugin, options) {
+        this.checkNotDestroyed();
+        this.kernel.register(plugin, options, this);
+        return this;
+      }
+      /** Destroy store and cleanup. */
+      destroy() {
+        if (this.destroyed) {
+          return;
+        }
+        this.destroyed = true;
+        this.kernel.destroy();
+        this.listeners.clear();
+        this.selectorSubscriptions.clear();
+        this.actions = {};
+      }
+      /** Add an action (for fluent builder pattern). */
+      addAction(name, fn) {
+        this.actions[name] = fn;
+        return this;
+      }
+      /** Get all actions. */
+      getActions() {
+        return this.actions;
+      }
+      /** Check if store is destroyed. */
+      checkNotDestroyed() {
+        if (this.destroyed) {
+          throw new Error("Cannot use destroyed store");
+        }
+      }
+      /** Notify listeners or queue if batching. */
+      notifyOrQueue(state, prevState) {
+        const inGlobalBatch = sharedBatchContext.isBatching();
+        if (inGlobalBatch) {
+          const managedStores = sharedBatchContext.managedStores;
+          if (!managedStores.has(this)) {
+            managedStores.add(this);
+          }
+        }
+        if (this.batchDepth > 0 || inGlobalBatch) {
+          this.queuedState = state;
+          if (!this.pendingNotify) {
+            this.queuedPrevState = prevState;
+          }
+          this.pendingNotify = true;
+        } else {
+          this.notify(state, prevState);
+        }
+      }
+      /** Notify all listeners. */
+      notify(state, prevState) {
+        this.kernel.emitStateChange(state, prevState);
+        for (const listener of this.listeners) {
+          try {
+            listener(state, prevState);
+          } catch (error) {
+            this.kernel.emitError(error);
+          }
+        }
+        for (const subscription of this.selectorSubscriptions.values()) {
+          const newValue = subscription.selector(state);
+          if (!subscription.equalityFn(newValue, subscription.value)) {
+            const prevValue = subscription.value;
+            subscription.value = newValue;
+            for (const listener of subscription.listeners) {
+              try {
+                listener(newValue, prevValue);
+              } catch (error) {
+                this.kernel.emitError(error);
+              }
+            }
+          }
+        }
+      }
+      /** Flush pending notifications (end of batch). */
+      flushNotifications() {
+        if (this.pendingNotify) {
+          this.notify(this.queuedState, this.queuedPrevState);
+          this.pendingNotify = false;
+          this.queuedState = null;
+          this.queuedPrevState = null;
+        }
+      }
+      /** Start batching. */
+      beginBatch() {
+        this.batchDepth++;
+      }
+      /** End batching. */
+      endBatch() {
+        this.batchDepth--;
+        if (this.batchDepth === 0) {
+          this.flushNotifications();
+        }
+      }
+    };
+    StoreBuilderImpl = class {
+      store;
+      constructor(initialState, kernel) {
+        this.store = new StoreImpl(initialState, kernel);
+      }
+      getState() {
+        return this.store.getState();
+      }
+      setState(partial) {
+        this.store.setState(partial);
+      }
+      merge(partial) {
+        this.store.merge(partial);
+      }
+      reset() {
+        this.store.reset();
+      }
+      subscribe(arg1, arg2, arg3) {
+        if (arg2 === void 0) {
+          return this.store.subscribe(arg1);
+        } else {
+          return this.store.subscribe(arg1, arg2, arg3);
+        }
+      }
+      use(plugin, options) {
+        this.store.use(plugin, options);
+        return this;
+      }
+      destroy() {
+        this.store.destroy();
+      }
+      action(name, fn) {
+        this.store.addAction(name, fn);
+        this[name] = (...args) => {
+          const currentState = this.getState();
+          const result = fn(currentState, ...args);
+          if (result instanceof Promise) {
+            return result.then((partial) => {
+              this.setState(partial);
+              return partial;
+            });
+          }
+          this.setState(result);
+          return result;
+        };
+        return this;
+      }
+      /** Add action (internal use). */
+      addAction(name, fn) {
+        this.store.addAction(name, fn);
+        return this;
+      }
+      /** Get actions (internal use). */
+      getActions() {
+        return this.store.getActions();
+      }
+      /** Start batching. */
+      beginBatch() {
+        this.store.beginBatch();
+      }
+      /** End batching. */
+      endBatch() {
+        this.store.endBatch();
+      }
+      /** Flush pending notifications. */
+      flushNotifications() {
+        this.store.flushNotifications();
+      }
+    };
+  }
+});
+
+// src/index.ts
+init_store();
+
+// src/react.ts
+init_identity();
+init_shallow_equal();
+init_store();
 function useStore(store, selector2 = identity, equalityFn = shallowEqual) {
   const selectorRef = react.useRef(selector2);
   const equalityFnRef = react.useRef(equalityFn);
@@ -857,12 +965,798 @@ function useAction(store, actionName) {
   }
   return actionRef.current;
 }
-
-// src/plugins/persist.ts
-var defaultStorage = {
-  getItem: (key) => {
-    if (typeof window === "undefined") return null;
-    try {
+function useShallow(selector2) {
+  const prev = react.useRef();
+  return (state) => {
+    const next = selector2(state);
+    if (prev.current === void 0) {
+      prev.current = next;
+      return next;
+    }
+    if (shallowCompareObjects(prev.current, next)) {
+      return prev.current;
+    }
+    prev.current = next;
+    return next;
+  };
+}
+function shallowCompareObjects(a, b) {
+  if (a === b) return true;
+  if (typeof a !== "object" || typeof b !== "object") return false;
+  if (a === null || b === null) return false;
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+  for (const key of keysA) {
+    if (a[key] !== b[key]) {
+      return false;
+    }
+  }
+  return true;
+}
+function useStoreActions(store, ...actionNames) {
+  const storeRef = react.useRef(store);
+  const actionsRef = react.useRef({});
+  if (storeRef.current !== store) {
+    storeRef.current = store;
+    actionsRef.current = {};
+  }
+  const result = {};
+  for (const name of actionNames) {
+    if (!actionsRef.current[name]) {
+      actionsRef.current[name] = storeRef.current[name];
+    }
+    result[name] = actionsRef.current[name];
+  }
+  return result;
+}
+function useStoreSelector(store, selectors) {
+  const selectorsRef = react.useRef(selectors);
+  const keysRef = react.useRef(Object.keys(selectors));
+  const prevResultRef = react.useRef(null);
+  if (selectorsRef.current !== selectors) {
+    selectorsRef.current = selectors;
+    keysRef.current = Object.keys(selectors);
+  }
+  const combinedSelector = react.useCallback((state) => {
+    const keys = keysRef.current;
+    const currentSelectors = selectorsRef.current;
+    const result = {};
+    for (const key of keys) {
+      const selector2 = currentSelectors[key];
+      if (selector2) {
+        result[key] = selector2(state);
+      }
+    }
+    if (prevResultRef.current !== null) {
+      let isEqual = true;
+      for (const key of keys) {
+        if (!shallowEqual(prevResultRef.current[key], result[key])) {
+          isEqual = false;
+          break;
+        }
+      }
+      if (isEqual) {
+        return prevResultRef.current;
+      }
+    }
+    prevResultRef.current = result;
+    return result;
+  }, []);
+  return useStore(store, combinedSelector);
+}
+function useTransientSubscribe(store, selector2, callback, equalityFn = shallowEqual) {
+  const callbackRef = react.useRef(callback);
+  callbackRef.current = callback;
+  react.useEffect(() => {
+    const unsubscribe = store.subscribe(
+      selector2,
+      (value, prevValue) => callbackRef.current(value, prevValue),
+      equalityFn
+    );
+    return unsubscribe;
+  }, [store, selector2, equalityFn]);
+}
+function useSetState(store) {
+  const storeRef = react.useRef(store);
+  if (storeRef.current !== store) {
+    storeRef.current = store;
+  }
+  const setStateRef = react.useRef((partial) => {
+    storeRef.current.setState(partial);
+  });
+  return setStateRef.current;
+}
+
+// src/subscribe.ts
+init_utils();
+function createDebounced(fn, delay2) {
+  let timeoutId = null;
+  const debounced = ((...args) => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      fn(...args);
+      timeoutId = null;
+    }, delay2);
+  });
+  debounced.cancel = () => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+  };
+  return debounced;
+}
+function createThrottled(fn, delay2) {
+  let lastCall = 0;
+  let timeoutId = null;
+  let lastArgs = null;
+  const throttled = ((...args) => {
+    const now = Date.now();
+    const remaining = delay2 - (now - lastCall);
+    lastArgs = args;
+    if (remaining <= 0) {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+      lastCall = now;
+      fn(...args);
+    } else if (!timeoutId) {
+      timeoutId = setTimeout(() => {
+        lastCall = Date.now();
+        timeoutId = null;
+        if (lastArgs) {
+          fn(...lastArgs);
+        }
+      }, remaining);
+    }
+  });
+  throttled.cancel = () => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+    lastArgs = null;
+  };
+  return throttled;
+}
+function subscribeWithOptions(store, selector2, listener, options = {}) {
+  const {
+    equalityFn = shallowEqual,
+    fireImmediately = false,
+    debounce,
+    throttle,
+    when
+  } = options;
+  if (debounce !== void 0 && throttle !== void 0) {
+    throw new Error("Cannot use both debounce and throttle options");
+  }
+  let wrappedListener = listener;
+  let cleanup = null;
+  if (debounce !== void 0 && debounce > 0) {
+    const debouncedListener = createDebounced(listener, debounce);
+    wrappedListener = debouncedListener;
+    cleanup = () => debouncedListener.cancel();
+  } else if (throttle !== void 0 && throttle > 0) {
+    const throttledListener = createThrottled(listener, throttle);
+    wrappedListener = throttledListener;
+    cleanup = () => throttledListener.cancel();
+  }
+  let finalListener;
+  let prevState = store.getState();
+  if (when) {
+    finalListener = (value, prevValue) => {
+      const currentState = store.getState();
+      if (when(currentState, prevState)) {
+        wrappedListener(value, prevValue);
+      }
+      prevState = currentState;
+    };
+  } else {
+    finalListener = wrappedListener;
+  }
+  if (fireImmediately) {
+    const currentValue = selector2(store.getState());
+    finalListener(currentValue, currentValue);
+  }
+  const unsubscribe = store.subscribe(selector2, finalListener, equalityFn);
+  return () => {
+    unsubscribe();
+    if (cleanup) {
+      cleanup();
+    }
+  };
+}
+function createSubscriber(defaultOptions = {}) {
+  return (store, selector2, listener, options = {}) => {
+    return subscribeWithOptions(store, selector2, listener, {
+      ...defaultOptions,
+      ...options
+    });
+  };
+}
+function subscribeToMany(store, selectors, listener, options = {}) {
+  const keys = Object.keys(selectors);
+  const state = store.getState();
+  for (const key of keys) {
+    const selector2 = selectors[key];
+    if (selector2) {
+      selector2(state);
+    }
+  }
+  const combinedSelector = (state2) => {
+    const result = {};
+    for (const key of keys) {
+      const selector2 = selectors[key];
+      if (selector2) {
+        result[key] = selector2(state2);
+      }
+    }
+    return result;
+  };
+  const combinedEqualityFn = (a, b) => {
+    for (const key of keys) {
+      if (!shallowEqual(a[key], b[key])) {
+        return false;
+      }
+    }
+    return true;
+  };
+  return subscribeWithOptions(
+    store,
+    combinedSelector,
+    listener,
+    { ...options, equalityFn: combinedEqualityFn }
+  );
+}
+function subscribeOnce(store, selector2, listener, options = {}) {
+  let unsubscribe = null;
+  const onceListener = (value, prevValue) => {
+    listener(value, prevValue);
+    if (unsubscribe) {
+      unsubscribe();
+    }
+  };
+  unsubscribe = subscribeWithOptions(store, selector2, onceListener, options);
+  return unsubscribe;
+}
+
+// src/computed.ts
+init_utils();
+function computed(store, selector2, options = {}) {
+  const { equals = shallowEqual, lazy = false, cacheSize = 1 } = options;
+  const cache = [];
+  let currentValue;
+  let isInitialized = false;
+  let isDestroyed = false;
+  const listeners = /* @__PURE__ */ new Set();
+  let unsubscribe = null;
+  const compute = () => {
+    const state = store.getState();
+    for (const entry of cache) {
+      if (entry.input === state || shallowEqual(entry.input, state)) {
+        return entry.output;
+      }
+    }
+    const newValue = selector2(state);
+    cache.unshift({ input: state, output: newValue });
+    while (cache.length > cacheSize) {
+      cache.pop();
+    }
+    return newValue;
+  };
+  const initialize = () => {
+    if (isInitialized || isDestroyed) return;
+    isInitialized = true;
+    currentValue = compute();
+    unsubscribe = store.subscribe((state, prevState) => {
+      const prevValue = currentValue;
+      const newValue = compute();
+      if (!equals(newValue, prevValue)) {
+        currentValue = newValue;
+        for (const listener of listeners) {
+          try {
+            listener(newValue, prevValue);
+          } catch (error) {
+            console.error("Computed listener error:", error);
+          }
+        }
+      }
+    });
+  };
+  if (!lazy) {
+    initialize();
+  }
+  const get = () => {
+    if (isDestroyed) {
+      throw new Error("Cannot access destroyed computed value");
+    }
+    if (!isInitialized) {
+      initialize();
+    }
+    return currentValue;
+  };
+  const invalidate = () => {
+    if (isDestroyed) return;
+    cache.length = 0;
+    if (isInitialized) {
+      const prevValue = currentValue;
+      currentValue = compute();
+      if (!equals(currentValue, prevValue)) {
+        for (const listener of listeners) {
+          try {
+            listener(currentValue, prevValue);
+          } catch (error) {
+            console.error("Computed listener error:", error);
+          }
+        }
+      }
+    }
+  };
+  const subscribe = (listener) => {
+    if (isDestroyed) {
+      throw new Error("Cannot subscribe to destroyed computed value");
+    }
+    if (!isInitialized) {
+      initialize();
+    }
+    listeners.add(listener);
+    return () => {
+      listeners.delete(listener);
+    };
+  };
+  const getHistory = () => {
+    return cache.map((entry) => entry.output);
+  };
+  const destroy = () => {
+    if (isDestroyed) return;
+    isDestroyed = true;
+    if (unsubscribe) {
+      unsubscribe();
+      unsubscribe = null;
+    }
+    listeners.clear();
+    cache.length = 0;
+    currentValue = void 0;
+  };
+  const computedFn = get;
+  computedFn.get = get;
+  computedFn.invalidate = invalidate;
+  computedFn.subscribe = subscribe;
+  computedFn.getHistory = getHistory;
+  computedFn.destroy = destroy;
+  return computedFn;
+}
+function combineComputed(computeds, combiner, options = {}) {
+  const { equals = shallowEqual, cacheSize = 1 } = options;
+  let currentValue;
+  let isDestroyed = false;
+  const listeners = /* @__PURE__ */ new Set();
+  const unsubscribes = [];
+  const cache = [];
+  const compute = () => {
+    const values = computeds.map((c) => c());
+    return combiner(values);
+  };
+  currentValue = compute();
+  cache.push(currentValue);
+  for (const computed2 of computeds) {
+    const unsub = computed2.subscribe(() => {
+      if (isDestroyed) return;
+      const prevValue = currentValue;
+      const newValue = compute();
+      if (!equals(newValue, prevValue)) {
+        currentValue = newValue;
+        cache.unshift(newValue);
+        while (cache.length > cacheSize) {
+          cache.pop();
+        }
+        for (const listener of listeners) {
+          try {
+            listener(newValue, prevValue);
+          } catch (error) {
+            console.error("Combined computed listener error:", error);
+          }
+        }
+      }
+    });
+    unsubscribes.push(unsub);
+  }
+  const get = () => {
+    if (isDestroyed) {
+      throw new Error("Cannot access destroyed computed value");
+    }
+    return currentValue;
+  };
+  const invalidate = () => {
+    if (isDestroyed) return;
+    for (const computed2 of computeds) {
+      computed2.invalidate();
+    }
+  };
+  const subscribe = (listener) => {
+    if (isDestroyed) {
+      throw new Error("Cannot subscribe to destroyed computed value");
+    }
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+  };
+  const getHistory = () => [...cache];
+  const destroy = () => {
+    if (isDestroyed) return;
+    isDestroyed = true;
+    for (const unsub of unsubscribes) {
+      unsub();
+    }
+    listeners.clear();
+    cache.length = 0;
+  };
+  const combinedFn = get;
+  combinedFn.get = get;
+  combinedFn.invalidate = invalidate;
+  combinedFn.subscribe = subscribe;
+  combinedFn.getHistory = getHistory;
+  combinedFn.destroy = destroy;
+  return combinedFn;
+}
+function memoizeSelector(selector2, equals = shallowEqual) {
+  let lastState;
+  let lastResult;
+  let isInitialized = false;
+  return (state) => {
+    if (!isInitialized || lastState !== state) {
+      const newResult = selector2(state);
+      if (!isInitialized || !equals(newResult, lastResult)) {
+        lastResult = newResult;
+      }
+      lastState = state;
+      isInitialized = true;
+    }
+    return lastResult;
+  };
+}
+
+// src/slices.ts
+init_store();
+function createSlice(name, creator) {
+  return { name, creator };
+}
+function combineSlices(...slices) {
+  const initialState = {};
+  const actions = {};
+  let tempStore = null;
+  const set = (partial) => {
+    if (tempStore) {
+      if (typeof partial === "function") {
+        tempStore.setState(partial);
+      } else {
+        tempStore.setState(partial);
+      }
+    }
+  };
+  const get = () => {
+    return tempStore ? tempStore.getState() : initialState;
+  };
+  const placeholderStore = {
+    getState: () => initialState,
+    setState: () => {
+    },
+    subscribe: () => () => {
+    },
+    merge: () => {
+    },
+    reset: () => {
+    },
+    use: () => placeholderStore,
+    destroy: () => {
+    }
+  };
+  for (const slice of slices) {
+    const sliceResult = slice.creator(set, get, placeholderStore);
+    for (const [key, value] of Object.entries(sliceResult)) {
+      if (typeof value === "function") {
+        actions[key] = value;
+      } else {
+        initialState[key] = value;
+      }
+    }
+  }
+  tempStore = createStore(initialState);
+  for (const slice of slices) {
+    const sliceResult = slice.creator(
+      (partial) => {
+        if (typeof partial === "function") {
+          tempStore.setState(partial);
+        } else {
+          tempStore.setState(partial);
+        }
+      },
+      () => tempStore.getState(),
+      tempStore
+    );
+    for (const [key, value] of Object.entries(sliceResult)) {
+      if (typeof value === "function") {
+        actions[key] = value;
+      }
+    }
+  }
+  const store = tempStore;
+  for (const [name, action] of Object.entries(actions)) {
+    store[name] = action;
+  }
+  return store;
+}
+function createNamespacedSlice(namespace, creator) {
+  return createSlice(namespace, (set, get, store) => {
+    const namespacedSet = (partial) => {
+      const current = get()[namespace] || {};
+      const update = typeof partial === "function" ? partial(current) : partial;
+      set({ [namespace]: { ...current, ...update } });
+    };
+    const namespacedGet = () => {
+      return get()[namespace] || {};
+    };
+    const sliceResult = creator(namespacedSet, namespacedGet);
+    const state = {};
+    const actions = {};
+    for (const [key, value] of Object.entries(sliceResult)) {
+      if (typeof value === "function") {
+        actions[key] = value;
+      } else {
+        state[key] = value;
+      }
+    }
+    return {
+      [namespace]: state,
+      ...actions
+    };
+  });
+}
+function extendStore(store, ...slices) {
+  const actions = {};
+  const set = (partial) => {
+    if (typeof partial === "function") {
+      store.setState(partial);
+    } else {
+      store.setState(partial);
+    }
+  };
+  const get = () => store.getState();
+  for (const slice of slices) {
+    const sliceResult = slice.creator(set, get, store);
+    for (const [key, value] of Object.entries(sliceResult)) {
+      if (typeof value === "function") {
+        actions[key] = value;
+      } else {
+        store.setState({ [key]: value });
+      }
+    }
+  }
+  const extendedStore = store;
+  for (const [name, action] of Object.entries(actions)) {
+    extendedStore[name] = action;
+  }
+  return extendedStore;
+}
+function resetSlices(store, ...sliceNames) {
+  console.warn("resetSlices: Use store.reset() to reset all state");
+  store.reset();
+}
+
+// src/federation.ts
+function createFederation(stores, options = {}) {
+  const { name = "federation", debug = false } = options;
+  const listeners = /* @__PURE__ */ new Set();
+  const unsubscribers = [];
+  let isInTransaction = false;
+  let transactionChanges = [];
+  let previousStates = null;
+  const getState = () => {
+    const state = {};
+    for (const key in stores) {
+      const store = stores[key];
+      if (store) {
+        state[key] = store.getState();
+      }
+    }
+    return state;
+  };
+  const notify = (changedStore) => {
+    if (isInTransaction) {
+      if (!transactionChanges.includes(changedStore)) {
+        transactionChanges.push(changedStore);
+      }
+      return;
+    }
+    const state = getState();
+    const prevState = previousStates || state;
+    for (const listener of listeners) {
+      try {
+        listener(state, prevState, changedStore);
+      } catch (error) {
+        console.error(`Federation listener error:`, error);
+      }
+    }
+    previousStates = state;
+  };
+  for (const key in stores) {
+    const store = stores[key];
+    if (store) {
+      const unsubscribe = store.subscribe(() => {
+        notify(key);
+      });
+      unsubscribers.push(unsubscribe);
+    }
+  }
+  previousStates = getState();
+  const log = (message, ...args) => {
+    if (debug) {
+      console.log(`[${name}] ${message}`, ...args);
+    }
+  };
+  return {
+    stores,
+    getState,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    transaction(fn) {
+      if (isInTransaction) {
+        fn(stores);
+        return;
+      }
+      isInTransaction = true;
+      transactionChanges = [];
+      const snapshotStates = getState();
+      log("Transaction started");
+      try {
+        const result = fn(stores);
+        if (result instanceof Promise) {
+          throw new Error(
+            "Async operations in transaction() are not supported. Use transactionAsync() instead."
+          );
+        }
+        isInTransaction = false;
+        if (transactionChanges.length > 0) {
+          log("Transaction committed, changed stores:", transactionChanges);
+          const state = getState();
+          for (const listener of listeners) {
+            try {
+              listener(state, snapshotStates, transactionChanges[0]);
+            } catch (error) {
+              console.error(`Federation listener error:`, error);
+            }
+          }
+          previousStates = state;
+        }
+      } catch (error) {
+        isInTransaction = false;
+        log("Transaction failed, rolling back");
+        for (const key in stores) {
+          const store = stores[key];
+          if (store) {
+            store.setState(snapshotStates[key]);
+          }
+        }
+        throw error;
+      }
+    },
+    async transactionAsync(fn) {
+      if (isInTransaction) {
+        await fn(stores);
+        return;
+      }
+      isInTransaction = true;
+      transactionChanges = [];
+      const snapshotStates = getState();
+      log("Async transaction started");
+      try {
+        await fn(stores);
+        isInTransaction = false;
+        if (transactionChanges.length > 0) {
+          log("Async transaction committed, changed stores:", transactionChanges);
+          const state = getState();
+          for (const listener of listeners) {
+            try {
+              listener(state, snapshotStates, transactionChanges[0]);
+            } catch (error) {
+              console.error(`Federation listener error:`, error);
+            }
+          }
+          previousStates = state;
+        }
+      } catch (error) {
+        isInTransaction = false;
+        log("Async transaction failed, rolling back");
+        for (const key in stores) {
+          const store = stores[key];
+          if (store) {
+            store.setState(snapshotStates[key]);
+          }
+        }
+        throw error;
+      }
+    },
+    getStore(storeName) {
+      return stores[storeName];
+    },
+    destroy() {
+      log("Destroying federation");
+      for (const unsubscribe of unsubscribers) {
+        unsubscribe();
+      }
+      listeners.clear();
+    }
+  };
+}
+function createFederatedSelector(federation, selector2) {
+  return () => selector2(federation.getState());
+}
+function createFederatedComputed(federation, selector2, equalityFn = Object.is) {
+  let cachedValue = selector2(federation.getState());
+  const listeners = /* @__PURE__ */ new Set();
+  federation.subscribe((state) => {
+    const newValue = selector2(state);
+    if (!equalityFn(newValue, cachedValue)) {
+      const prevValue = cachedValue;
+      cachedValue = newValue;
+      for (const listener of listeners) {
+        listener(newValue, prevValue);
+      }
+    }
+  });
+  return {
+    get() {
+      return cachedValue;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+}
+function waitForFederated(federation, predicate, timeout) {
+  return new Promise((resolve, reject) => {
+    const state = federation.getState();
+    if (predicate(state)) {
+      resolve(state);
+      return;
+    }
+    let timeoutId;
+    let unsubscribe;
+    const cleanup = () => {
+      if (timeoutId) clearTimeout(timeoutId);
+      if (unsubscribe) unsubscribe();
+    };
+    if (timeout) {
+      timeoutId = setTimeout(() => {
+        cleanup();
+        reject(new Error(`waitForFederated timed out after ${timeout}ms`));
+      }, timeout);
+    }
+    unsubscribe = federation.subscribe((state2) => {
+      if (predicate(state2)) {
+        cleanup();
+        resolve(state2);
+      }
+    });
+  });
+}
+
+// src/plugins/persist.ts
+init_utils();
+var defaultStorage = {
+  getItem: (key) => {
+    if (typeof window === "undefined") return null;
+    try {
       return window.localStorage.getItem(key);
     } catch {
       return null;
@@ -903,36 +1797,133 @@ var sessionStorage = {
     }
   }
 };
+function createDebounced2(fn, delay2) {
+  let timeoutId = null;
+  const debounced = ((...args) => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      fn(...args);
+      timeoutId = null;
+    }, delay2);
+  });
+  debounced.cancel = () => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+  };
+  return debounced;
+}
 function persist(options) {
-  const { key, storage = defaultStorage, whitelist, blacklist } = options;
+  const {
+    key,
+    storage = defaultStorage,
+    whitelist,
+    blacklist,
+    partialize,
+    merge: customMerge,
+    version = 0,
+    migrate,
+    serialize = JSON.stringify,
+    deserialize = JSON.parse,
+    encrypt,
+    decrypt,
+    writeDebounce,
+    onRehydrateStorage,
+    onHydrationComplete,
+    onPersistError
+  } = options;
+  let cancelDebounce = null;
   return {
     name: "persist",
     version: "1.0.0",
     install(store) {
       try {
-        const saved = storage.getItem(key);
+        let saved = storage.getItem(key);
+        if (saved && decrypt) {
+          try {
+            saved = decrypt(saved);
+          } catch {
+            saved = null;
+          }
+        }
         if (saved) {
-          const parsed = JSON.parse(saved);
-          store.merge(parsed);
+          let parsed;
+          let persistedVersion = 0;
+          try {
+            const data = deserialize(saved);
+            if (data && typeof data === "object" && "state" in data && "version" in data) {
+              parsed = data.state;
+              persistedVersion = data.version;
+            } else {
+              parsed = data;
+            }
+          } catch {
+            parsed = deserialize(saved);
+          }
+          if (onRehydrateStorage) {
+            onRehydrateStorage(parsed);
+          }
+          if (migrate && persistedVersion < version) {
+            parsed = migrate(parsed, persistedVersion);
+          }
+          if (customMerge) {
+            const currentState = store.getState();
+            const mergedState = customMerge(parsed, currentState);
+            store.setState(mergedState);
+          } else {
+            store.merge(parsed);
+          }
+          if (onHydrationComplete) {
+            onHydrationComplete(store.getState());
+          }
         }
       } catch (error) {
-        console.error(`Failed to hydrate state from '${key}':`, error);
+        if (onPersistError) {
+          onPersistError(error);
+        } else {
+          console.error(`Failed to hydrate state from '${key}':`, error);
+        }
       }
-      store.subscribe((state) => {
+      const persistState = (state) => {
         try {
           let toSave = state;
-          if (whitelist) {
+          if (partialize) {
+            toSave = partialize(state);
+          } else if (whitelist) {
             toSave = pick(state, whitelist);
           } else if (blacklist) {
             toSave = omit(state, blacklist);
           }
-          storage.setItem(key, JSON.stringify(toSave));
+          const dataToStore = {
+            state: toSave,
+            version
+          };
+          let serialized = serialize(dataToStore);
+          if (encrypt) {
+            serialized = encrypt(serialized);
+          }
+          storage.setItem(key, serialized);
         } catch (error) {
-          console.error(`Failed to persist state to '${key}':`, error);
+          if (onPersistError) {
+            onPersistError(error);
+          } else {
+            console.error(`Failed to persist state to '${key}':`, error);
+          }
         }
-      });
+      };
+      const debouncedPersist = writeDebounce && writeDebounce > 0 ? createDebounced2(persistState, writeDebounce) : persistState;
+      if (writeDebounce && writeDebounce > 0) {
+        cancelDebounce = () => debouncedPersist.cancel?.();
+      }
+      store.subscribe(debouncedPersist);
     },
     onDestroy() {
+      if (cancelDebounce) {
+        cancelDebounce();
+      }
     }
   };
 }
@@ -1262,31 +2253,888 @@ function selector(options) {
   };
 }
 
-exports.StoreError = StoreError;
-exports.StoreErrorCode = StoreErrorCode;
+// src/plugins/logger.ts
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var COLORS = {
+  title: "#9E9E9E",
+  prevState: "#9E9E9E",
+  action: "#03A9F4",
+  nextState: "#4CAF50",
+  diff: {
+    changed: "#2196F3"
+  }
+};
+function formatTime(date) {
+  const hours = date.getHours().toString().padStart(2, "0");
+  const minutes = date.getMinutes().toString().padStart(2, "0");
+  const seconds = date.getSeconds().toString().padStart(2, "0");
+  const ms = date.getMilliseconds().toString().padStart(3, "0");
+  return `${hours}:${minutes}:${seconds}.${ms}`;
+}
+function calculateDiff(prevState, nextState) {
+  const diff = {};
+  if (typeof prevState !== "object" || typeof nextState !== "object") {
+    if (prevState !== nextState) {
+      diff["value"] = { prev: prevState, next: nextState };
+    }
+    return diff;
+  }
+  if (prevState === null || nextState === null) {
+    if (prevState !== nextState) {
+      diff["value"] = { prev: prevState, next: nextState };
+    }
+    return diff;
+  }
+  const allKeys = /* @__PURE__ */ new Set([
+    ...Object.keys(prevState),
+    ...Object.keys(nextState)
+  ]);
+  for (const key of allKeys) {
+    const prev = prevState[key];
+    const next = nextState[key];
+    if (prev !== next) {
+      diff[key] = { prev, next };
+    }
+  }
+  return diff;
+}
+function isBrowser() {
+  return typeof window !== "undefined" && typeof window.document !== "undefined";
+}
+function logger(options = {}) {
+  const {
+    level = "debug",
+    logger: customLogger = console,
+    collapsed = true,
+    diff = true,
+    colors = isBrowser(),
+    timestamp = true,
+    filter,
+    stateTransformer,
+    actionName = "STATE_CHANGE",
+    name = "Store",
+    enabled = true
+  } = options;
+  const minLevel = LOG_LEVELS[level];
+  return {
+    name: "logger",
+    version: "1.0.0",
+    install(store) {
+      if (!enabled) return;
+      store.subscribe((state, prevState) => {
+        if (filter && !filter(state, prevState)) {
+          return;
+        }
+        if (LOG_LEVELS.info < minLevel) {
+          return;
+        }
+        const now = /* @__PURE__ */ new Date();
+        const action = typeof actionName === "function" ? actionName(state, prevState) : actionName;
+        const displayPrevState = stateTransformer ? stateTransformer(prevState) : prevState;
+        const displayNextState = stateTransformer ? stateTransformer(state) : state;
+        const timeStr = timestamp ? ` @ ${formatTime(now)}` : "";
+        const title = `${name} ${action}${timeStr}`;
+        if (colors && isBrowser()) {
+          logWithColors(
+            customLogger,
+            title,
+            displayPrevState,
+            displayNextState,
+            collapsed,
+            diff ? calculateDiff(prevState, state) : void 0
+          );
+        } else {
+          logPlain(
+            customLogger,
+            title,
+            displayPrevState,
+            displayNextState,
+            collapsed,
+            diff ? calculateDiff(prevState, state) : void 0
+          );
+        }
+      });
+    }
+  };
+}
+function logWithColors(log, title, prevState, nextState, collapsed, diff) {
+  const titleStyle = `color: ${COLORS.title}; font-weight: lighter;`;
+  const groupMethod = collapsed ? "groupCollapsed" : "group";
+  log[groupMethod](`%c${title}`, titleStyle);
+  log.log("%cprev state", `color: ${COLORS.prevState}; font-weight: bold;`, prevState);
+  log.log("%cnext state", `color: ${COLORS.nextState}; font-weight: bold;`, nextState);
+  if (diff && Object.keys(diff).length > 0) {
+    log.log("%cdiff", `color: ${COLORS.action}; font-weight: bold;`);
+    for (const [key, { prev, next }] of Object.entries(diff)) {
+      log.log(
+        `  %c${key}:`,
+        `color: ${COLORS.diff.changed};`,
+        prev,
+        "\u2192",
+        next
+      );
+    }
+  }
+  log.groupEnd();
+}
+function logPlain(log, title, prevState, nextState, collapsed, diff) {
+  const hasGroupCollapsed = typeof log.groupCollapsed === "function";
+  const groupMethod = collapsed && hasGroupCollapsed ? "groupCollapsed" : "group";
+  const hasGroup = typeof log[groupMethod] === "function";
+  if (hasGroup) {
+    log[groupMethod](title);
+  } else {
+    log.log(`=== ${title} ===`);
+  }
+  log.log("prev state:", prevState);
+  log.log("next state:", nextState);
+  if (diff && Object.keys(diff).length > 0) {
+    log.log("diff:");
+    for (const [key, { prev, next }] of Object.entries(diff)) {
+      log.log(`  ${key}:`, prev, "\u2192", next);
+    }
+  }
+  if (hasGroup) {
+    log.groupEnd();
+  } else {
+    log.log("===");
+  }
+}
+function createLogger(defaultOptions = {}) {
+  return (options = {}) => logger({ ...defaultOptions, ...options });
+}
+
+// src/plugins/effects.ts
+init_utils();
+function createDebounced3(fn, delay2) {
+  let timeoutId = null;
+  const debounced = ((...args) => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      fn(...args);
+      timeoutId = null;
+    }, delay2);
+  });
+  debounced.cancel = () => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+  };
+  return debounced;
+}
+function effects(options) {
+  const { effects: effectDefs, onError } = options;
+  return {
+    name: "effects",
+    version: "1.0.0",
+    install(store) {
+      const cleanups = [];
+      const effectCleanups = /* @__PURE__ */ new Map();
+      for (let i = 0; i < effectDefs.length; i++) {
+        const def = effectDefs[i];
+        if (!def) continue;
+        const {
+          selector: selector2,
+          effect,
+          equalityFn = shallowEqual,
+          fireImmediately = false,
+          debounce,
+          name
+        } = def;
+        let isActive = true;
+        let prevValue = selector2(store.getState());
+        const createUtils = () => ({
+          getState: () => store.getState(),
+          setState: (partial) => store.setState(partial),
+          isActive: () => isActive,
+          cancel: () => {
+            isActive = false;
+          },
+          onlyIfActive: (fn) => {
+            if (isActive) {
+              return fn();
+            }
+            return void 0;
+          }
+        });
+        const runEffect = async (value, prev) => {
+          const prevCleanup = effectCleanups.get(i);
+          if (prevCleanup) {
+            try {
+              prevCleanup();
+            } catch (e) {
+            }
+            effectCleanups.delete(i);
+          }
+          isActive = true;
+          try {
+            const result = effect(value, prev, createUtils());
+            if (result instanceof Promise) {
+              const cleanup = await result;
+              if (cleanup && isActive) {
+                effectCleanups.set(i, cleanup);
+              }
+            } else if (result) {
+              effectCleanups.set(i, result);
+            }
+          } catch (error) {
+            if (onError) {
+              onError(error, name);
+            } else {
+              console.error(`Effect error${name ? ` in '${name}'` : ""}:`, error);
+            }
+          }
+        };
+        const effectFn = debounce && debounce > 0 ? createDebounced3(runEffect, debounce) : runEffect;
+        if (fireImmediately) {
+          effectFn(prevValue, prevValue);
+        }
+        const unsubscribe = store.subscribe(
+          selector2,
+          (value, prev) => {
+            if (!equalityFn(value, prev)) {
+              prevValue = value;
+              effectFn(value, prev);
+            }
+          },
+          equalityFn
+        );
+        cleanups.push(() => {
+          unsubscribe();
+          isActive = false;
+          if ("cancel" in effectFn) {
+            effectFn.cancel();
+          }
+          const cleanup = effectCleanups.get(i);
+          if (cleanup) {
+            try {
+              cleanup();
+            } catch {
+            }
+          }
+        });
+      }
+      store.__effectsCleanup = () => {
+        for (const cleanup of cleanups) {
+          cleanup();
+        }
+        effectCleanups.clear();
+      };
+    }
+  };
+}
+function createEffect(name, selector2, effect, options = {}) {
+  return {
+    name,
+    selector: selector2,
+    effect,
+    ...options
+  };
+}
+function createSimpleEffect(effect, options = {}) {
+  return {
+    selector: (s) => s,
+    effect,
+    equalityFn: () => false,
+    // Always run
+    ...options
+  };
+}
+function combineEffects(...effectDefs) {
+  return {
+    effects: effectDefs
+  };
+}
+function createDebouncedEffect(delay2, selector2, effect, options = {}) {
+  return {
+    selector: selector2,
+    effect,
+    debounce: delay2,
+    ...options
+  };
+}
+
+// src/plugins/validate.ts
+function isZodLike(schema) {
+  return typeof schema === "object" && schema !== null && "safeParse" in schema && typeof schema.safeParse === "function";
+}
+function isYupLike(schema) {
+  return typeof schema === "object" && schema !== null && "validateSync" in schema && typeof schema.validateSync === "function";
+}
+function extractPaths(state, paths) {
+  const result = {};
+  for (const path of paths) {
+    if (path in state) {
+      result[path] = state[path];
+    }
+  }
+  return result;
+}
+function validateState(state, schema, paths) {
+  const stateToValidate = paths ? extractPaths(state, paths) : state;
+  if (typeof schema === "function") {
+    const result = schema(stateToValidate);
+    if (typeof result === "boolean") {
+      return {
+        valid: result,
+        errors: result ? [] : [{ path: [], message: "Validation failed" }]
+      };
+    }
+    if ("valid" in result && "errors" in result) {
+      return result;
+    }
+    if (Array.isArray(result)) {
+      return {
+        valid: result.length === 0,
+        errors: result
+      };
+    }
+    return { valid: true, errors: [] };
+  }
+  if (isZodLike(schema)) {
+    const result = schema.safeParse(stateToValidate);
+    if (result.success) {
+      return { valid: true, errors: [] };
+    }
+    const errors = (result.error?.issues || []).map((issue) => ({
+      path: issue.path.map(String),
+      message: issue.message,
+      rule: issue.code
+    }));
+    return { valid: false, errors };
+  }
+  if (isYupLike(schema)) {
+    try {
+      schema.validateSync(stateToValidate, { abortEarly: false });
+      return { valid: true, errors: [] };
+    } catch (error) {
+      const errors = [];
+      if (error.inner && Array.isArray(error.inner)) {
+        for (const err of error.inner) {
+          errors.push({
+            path: err.path ? err.path.split(".") : [],
+            message: err.message,
+            rule: err.type,
+            value: err.value
+          });
+        }
+      } else {
+        errors.push({
+          path: error.path ? error.path.split(".") : [],
+          message: error.message || "Validation failed",
+          rule: error.type
+        });
+      }
+      return { valid: false, errors };
+    }
+  }
+  return { valid: true, errors: [] };
+}
+function validate(options) {
+  const {
+    schema,
+    on = "change",
+    onError,
+    throwOnError = false,
+    paths,
+    name = "validate"
+  } = options;
+  return {
+    name,
+    version: "1.0.0",
+    install(store) {
+      let currentErrors = [];
+      const doValidate = () => {
+        const state = store.getState();
+        const result = validateState(state, schema, paths);
+        currentErrors = result.errors;
+        if (!result.valid) {
+          if (onError) {
+            onError(result.errors);
+          }
+          if (throwOnError) {
+            const errorMessages = result.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ");
+            throw new Error(`Validation failed: ${errorMessages}`);
+          }
+        }
+        return result;
+      };
+      if (on === "change") {
+        store.subscribe(() => {
+          doValidate();
+        });
+      }
+      const validationAPI = {
+        validate: doValidate,
+        isValid: () => currentErrors.length === 0,
+        getErrors: () => [...currentErrors],
+        clearErrors: () => {
+          currentErrors = [];
+        }
+      };
+      Object.assign(store, validationAPI);
+    }
+  };
+}
+function createValidator(predicate, message) {
+  return (state) => {
+    const valid = predicate(state);
+    return {
+      valid,
+      errors: valid ? [] : [{ path: [], message }]
+    };
+  };
+}
+function combineValidators(...validators) {
+  return (state) => {
+    const allErrors = [];
+    for (const validator of validators) {
+      const result = validator(state);
+      if (typeof result === "boolean") {
+        if (!result) {
+          allErrors.push({ path: [], message: "Validation failed" });
+        }
+      } else if ("valid" in result && "errors" in result) {
+        allErrors.push(...result.errors);
+      } else if (Array.isArray(result)) {
+        allErrors.push(...result);
+      }
+    }
+    return {
+      valid: allErrors.length === 0,
+      errors: allErrors
+    };
+  };
+}
+function createFieldValidator(field, predicate, message) {
+  return (state) => {
+    const valid = predicate(state[field], state);
+    return {
+      valid,
+      errors: valid ? [] : [{ path: [String(field)], message, value: state[field] }]
+    };
+  };
+}
+function createAsyncValidator(validator) {
+  return async (state) => {
+    const errors = await validator(state);
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  };
+}
+
+// src/index.ts
+init_utils();
+
+// src/testing.ts
+init_store();
+init_utils();
+function createMockStorage() {
+  const storage = /* @__PURE__ */ new Map();
+  return {
+    getItem(key) {
+      return storage.get(key) ?? null;
+    },
+    setItem(key, value) {
+      storage.set(key, value);
+    },
+    removeItem(key) {
+      storage.delete(key);
+    },
+    clear() {
+      storage.clear();
+    },
+    getAll() {
+      const result = {};
+      for (const [key, value] of storage) {
+        result[key] = value;
+      }
+      return result;
+    }
+  };
+}
+function spyOnStore(store) {
+  const changes = [];
+  const waiters = [];
+  const unsubscribe = store.subscribe((state, prevState) => {
+    changes.push({
+      state,
+      prevState,
+      timestamp: Date.now()
+    });
+    for (let i = waiters.length - 1; i >= 0; i--) {
+      const waiter = waiters[i];
+      if (waiter && waiter.predicate(state)) {
+        waiter.resolve(state);
+        waiters.splice(i, 1);
+      }
+    }
+  });
+  return {
+    changes,
+    lastChange: () => changes[changes.length - 1],
+    lastState: () => changes[changes.length - 1]?.state,
+    reset: () => {
+      changes.length = 0;
+    },
+    unsubscribe,
+    waitFor: (predicate, timeout = 5e3) => {
+      return new Promise((resolve, reject) => {
+        const current = store.getState();
+        if (predicate(current)) {
+          resolve(current);
+          return;
+        }
+        const waiter = { resolve, predicate };
+        waiters.push(waiter);
+        const timeoutId = setTimeout(() => {
+          const index = waiters.indexOf(waiter);
+          if (index >= 0) {
+            waiters.splice(index, 1);
+            reject(new Error(`waitFor timeout after ${timeout}ms`));
+          }
+        }, timeout);
+        const originalResolve = waiter.resolve;
+        waiter.resolve = (state) => {
+          clearTimeout(timeoutId);
+          originalResolve(state);
+        };
+      });
+    },
+    waitForChanges: (count, timeout = 5e3) => {
+      return new Promise((resolve, reject) => {
+        const startCount = changes.length;
+        const check = () => {
+          if (changes.length >= startCount + count) {
+            return changes.slice(startCount, startCount + count);
+          }
+          return null;
+        };
+        const immediate = check();
+        if (immediate) {
+          resolve(immediate);
+          return;
+        }
+        const intervalId = setInterval(() => {
+          const result = check();
+          if (result) {
+            clearInterval(intervalId);
+            clearTimeout(timeoutId);
+            resolve(result);
+          }
+        }, 10);
+        const timeoutId = setTimeout(() => {
+          clearInterval(intervalId);
+          reject(new Error(`waitForChanges timeout after ${timeout}ms`));
+        }, timeout);
+      });
+    }
+  };
+}
+function assertState(store) {
+  return {
+    toEqual: (expected) => {
+      const state = store.getState();
+      for (const [key, value] of Object.entries(expected)) {
+        if (state[key] !== value) {
+          throw new Error(
+            `Expected state.${key} to be ${JSON.stringify(value)}, but got ${JSON.stringify(state[key])}`
+          );
+        }
+      }
+    },
+    toHaveSelected: (selector2, expected) => {
+      const actual = selector2(store.getState());
+      if (!shallowEqual(actual, expected)) {
+        throw new Error(
+          `Expected selector to return ${JSON.stringify(expected)}, but got ${JSON.stringify(actual)}`
+        );
+      }
+    },
+    toMatch: (predicate) => {
+      const state = store.getState();
+      if (!predicate(state)) {
+        throw new Error(
+          `State did not match predicate: ${JSON.stringify(state)}`
+        );
+      }
+    }
+  };
+}
+function createTestStore(options) {
+  const { initialState, spy: enableSpy = true } = options;
+  const store = createStore(initialState);
+  const spy = enableSpy ? spyOnStore(store) : void 0;
+  const assert = assertState(store);
+  return {
+    store,
+    spy,
+    assert,
+    reset: () => {
+      store.reset();
+      spy?.reset();
+    },
+    destroy: () => {
+      spy?.unsubscribe();
+      store.destroy();
+    }
+  };
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function flushMicrotasks(fn) {
+  if (fn) {
+    fn();
+  }
+  await Promise.resolve();
+}
+function mockAction(fn) {
+  const calls = [];
+  const mocked = ((...args) => {
+    calls.push(args);
+    return fn(...args);
+  });
+  Object.defineProperty(mocked, "callCount", {
+    get: () => calls.length
+  });
+  mocked.calls = calls;
+  mocked.reset = () => {
+    calls.length = 0;
+  };
+  return mocked;
+}
+function snapshot(store) {
+  return JSON.parse(JSON.stringify(store.getState()));
+}
+function stateDiff(before, after) {
+  const diff = {};
+  const allKeys = /* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)]);
+  for (const key of allKeys) {
+    if (!shallowEqual(before[key], after[key])) {
+      diff[key] = { before: before[key], after: after[key] };
+    }
+  }
+  return diff;
+}
+
+// src/compat/middleware.ts
+function toMiddlewareApi(store) {
+  return {
+    setState: (partial, replace) => {
+      if (typeof partial === "function") {
+        const currentState = store.getState();
+        const newPartial = partial(currentState);
+        if (replace) {
+          store.setState(newPartial);
+        } else {
+          store.merge(newPartial);
+        }
+      } else {
+        if (replace) {
+          store.setState(partial);
+        } else {
+          store.merge(partial);
+        }
+      }
+    },
+    getState: () => store.getState(),
+    subscribe: (listener) => store.subscribe(listener),
+    destroy: () => store.destroy()
+  };
+}
+function middlewareCompat(middleware, options) {
+  return {
+    name: "middleware-compat",
+    version: "1.0.0",
+    install(store) {
+      const api = toMiddlewareApi(store);
+      const stateCreator = (set, get) => {
+        return get();
+      };
+      const enhancedCreator = middleware(stateCreator);
+      const enhancedState = enhancedCreator(api.setState, api.getState, api);
+      if (enhancedState && typeof enhancedState === "object") {
+        const currentState = store.getState();
+        const stateOnly = {};
+        for (const key in enhancedState) {
+          const value = enhancedState[key];
+          if (typeof value !== "function") {
+            stateOnly[key] = value;
+          }
+        }
+        if (Object.keys(stateOnly).length > 0) {
+          const hasChanges = Object.keys(stateOnly).some(
+            (key) => currentState[key] !== stateOnly[key]
+          );
+          if (hasChanges) {
+            store.merge(stateOnly);
+          }
+        }
+      }
+    }
+  };
+}
+function createWithMiddleware(creator) {
+  const { createStore: createStore2 } = (init_store(), __toCommonJS(store_exports));
+  let currentState = null;
+  let storeRef = null;
+  const set = (partial, replace) => {
+    if (!storeRef) {
+      throw new Error("Store not initialized");
+    }
+    if (typeof partial === "function") {
+      const newPartial = partial(storeRef.getState());
+      if (replace) {
+        storeRef.setState(newPartial);
+      } else {
+        storeRef.merge(newPartial);
+      }
+    } else {
+      if (replace) {
+        storeRef.setState(partial);
+      } else {
+        storeRef.merge(partial);
+      }
+    }
+  };
+  const get = () => {
+    if (storeRef) {
+      return storeRef.getState();
+    }
+    if (currentState) {
+      return currentState;
+    }
+    throw new Error("Store not initialized");
+  };
+  const placeholderApi = {
+    setState: set,
+    getState: get,
+    subscribe: () => () => {
+    }
+  };
+  currentState = creator(set, get, placeholderApi);
+  storeRef = createStore2(currentState);
+  const api = {
+    setState: (partial, replace) => {
+      if (typeof partial === "function") {
+        const newPartial = partial(storeRef.getState());
+        if (replace) {
+          storeRef.setState(newPartial);
+        } else {
+          storeRef.merge(newPartial);
+        }
+      } else {
+        if (replace) {
+          storeRef.setState(partial);
+        } else {
+          storeRef.merge(partial);
+        }
+      }
+    },
+    getState: () => storeRef.getState(),
+    subscribe: (listener) => storeRef.subscribe(listener),
+    destroy: () => storeRef.destroy(),
+    use: (plugin) => {
+      storeRef.use(plugin);
+      return api;
+    }
+  };
+  return api;
+}
+function createSimpleMiddleware(name, enhancer) {
+  const middleware = enhancer;
+  Object.defineProperty(middleware, "name", { value: name });
+  return middleware;
+}
+function compose(...middlewares) {
+  return (creator) => {
+    return middlewares.reduceRight((acc, middleware) => {
+      return middleware(acc);
+    }, creator);
+  };
+}
+
+exports.assertState = assertState;
 exports.batch = batch;
+exports.combineComputed = combineComputed;
+exports.combineEffects = combineEffects;
+exports.combineSlices = combineSlices;
+exports.combineValidators = combineValidators;
+exports.compose = compose;
+exports.computed = computed;
+exports.createAsyncValidator = createAsyncValidator;
+exports.createDebouncedEffect = createDebouncedEffect;
+exports.createEffect = createEffect;
+exports.createFederatedComputed = createFederatedComputed;
+exports.createFederatedSelector = createFederatedSelector;
+exports.createFederation = createFederation;
+exports.createFieldValidator = createFieldValidator;
+exports.createLogger = createLogger;
+exports.createMockStorage = createMockStorage;
+exports.createNamespacedSlice = createNamespacedSlice;
+exports.createSimpleEffect = createSimpleEffect;
+exports.createSimpleMiddleware = createSimpleMiddleware;
+exports.createSlice = createSlice;
 exports.createStorage = createStorage;
 exports.createStore = createStore;
+exports.createSubscriber = createSubscriber;
+exports.createTestStore = createTestStore;
+exports.createValidator = createValidator;
+exports.createWithMiddleware = createWithMiddleware;
 exports.deepClone = deepClone;
 exports.deepEqual = deepEqual;
 exports.deepMerge = deepMerge;
+exports.delay = delay;
 exports.devtools = devtools;
+exports.effects = effects;
+exports.extendStore = extendStore;
+exports.flushMicrotasks = flushMicrotasks;
 exports.hasHistory = hasHistory;
 exports.history = history;
 exports.identity = identity;
 exports.immer = immer;
 exports.isFunction = isFunction;
+exports.logger = logger;
+exports.memoizeSelector = memoizeSelector;
+exports.middlewareCompat = middlewareCompat;
+exports.mockAction = mockAction;
 exports.omit = omit;
 exports.persist = persist;
 exports.pick = pick;
 exports.produce = produce;
+exports.resetSlices = resetSlices;
 exports.selector = selector;
 exports.sessionStorage = sessionStorage;
 exports.shallowEqual = shallowEqual;
+exports.snapshot = snapshot;
+exports.spyOnStore = spyOnStore;
+exports.stateDiff = stateDiff;
+exports.subscribeOnce = subscribeOnce;
+exports.subscribeToMany = subscribeToMany;
+exports.subscribeWithOptions = subscribeWithOptions;
 exports.sync = sync;
+exports.toMiddlewareApi = toMiddlewareApi;
 exports.triggerSync = triggerSync;
 exports.useAction = useAction;
 exports.useCreateStore = useCreateStore;
+exports.useSetState = useSetState;
+exports.useShallow = useShallow;
 exports.useStore = useStore;
+exports.useStoreActions = useStoreActions;
+exports.useStoreSelector = useStoreSelector;
+exports.useTransientSubscribe = useTransientSubscribe;
+exports.validate = validate;
+exports.waitForFederated = waitForFederated;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map