@uistate/core 5.5.2 → 5.6.1

package/README.md

@@ -35,7 +35,7 @@ store.set('count', 1);
 
 ### `createEventState(initialState)`
 
-Returns a store with `get`, `set`, `subscribe`, `setAsync`, `cancel`, `destroy`.
+Returns a store with `get`, `set`, `batch`, `setMany`, `subscribe`, `setAsync`, `cancel`, `destroy`.
 
 ### `store.get(path?)`
 
@@ -65,6 +65,31 @@ const unsub = store.subscribe('count', (value, { oldValue }) => {
 unsub(); // cleanup
 ```
 
+### `store.batch(fn)`
+
+Batch multiple `set()` calls. Subscribers fire once per unique path after the batch completes, not during. Supports nesting.
+
+```javascript
+store.batch(() => {
+  store.set('ui.route.view', 'user');
+  store.set('ui.route.path', '/users/42');
+  store.set('ui.route.params', { id: '42' });
+});
+// Subscribers fire here, once per path, all state consistent
+```
+
+### `store.setMany(entries)`
+
+Set multiple paths atomically. Shorthand for `batch` + a loop of `set` calls. Accepts a plain object, an array of `[path, value]` pairs, or a `Map`.
+
+```javascript
+store.setMany({
+  'ui.route.view': 'user',
+  'ui.route.path': '/users/42',
+  'ui.route.params': { id: '42' },
+});
+```
+
 ### `store.setAsync(path, fetcher)`
 
 Manages async state at `${path}.status`, `${path}.data`, `${path}.error`. Supports abort on re-call.
@@ -106,6 +131,7 @@ qc.invalidate('users');
 | [@uistate/css](https://www.npmjs.com/package/@uistate/css) | CSS-native state via custom properties and data attributes | MIT |
 | [@uistate/event-test](https://www.npmjs.com/package/@uistate/event-test) | Event-sequence testing for UIstate stores | Proprietary |
 | [@uistate/examples](https://www.npmjs.com/package/@uistate/examples) | Example applications and patterns | MIT |
+| [@uistate/renderer](https://www.npmjs.com/package/@uistate/renderer) | Direct-binding reactive renderer: `bind-*`, `set`, `each` attributes. Zero build step | Proprietary |
 | [@uistate/aliases](https://www.npmjs.com/package/@uistate/aliases) | Ergonomic single-character and short-name DOM aliases for vanilla JS | MIT |
 
 📖 **Documentation:** [uistate.com](https://uistate.com)

package/eventState.js

@@ -1,89 +1,289 @@
-const createEventState = (initial = {}) => {
-    const store = JSON.parse(JSON.stringify(initial));
-
-    const bus = new EventTarget();
-    let destroyed = false;
-
-    return {
-        get: (path) => {
-            if (destroyed) throw new Error('Cannot get from destroyed store');
-            if (!path) return store;
-
-            // Parse dot-paths: 'items.0' → ['items', '0']
-            const parts = path.split('.').flatMap(part => {
-                const match = part.match(/([^\[]+)\[(\d+)\]/);
-                return match ? [match[1], match[2]] : part;
-            });
-
-            return parts.reduce(
-                (obj, prop) => (obj && obj[prop] !== undefined ? obj[prop] : undefined),
-                store
-            );
-        },
-        set: (path, value) => {
-            if (destroyed) throw new Error('Cannot set on destroyed store');
-            if (!path) return;
-            const parts = path.split('.');
-            const last = parts.pop();
-            let target = store;
-
-            for (const key of parts) {
-              // create intermediate objects as needed
-              if (typeof target[key] !== 'object' || target[key] === null) {
-                target[key] = {};
-              }
-              target = target[key];
-            }
-
-            target[last] = value;
-
-            if (!destroyed) {
-                // exact path
-                bus.dispatchEvent(new CustomEvent(path, { detail: value }));
-
-                // parent wildcards: a, a.b -> 'a.*', 'a.b.*'
-                for (let i = 1; i <= parts.length; i++) {
-                    const parent = parts.slice(0, i).join('.');
-                    bus.dispatchEvent(new CustomEvent(`${parent}.*`, { detail: { path, value } }));
-                }
-
-                // root wildcard
-                bus.dispatchEvent(new CustomEvent('*', { detail: { path, value } }));
-            }
-
-            return value;
-        },
-        subscribe(path, handler) {
-            if (destroyed) throw new Error('store destroyed');
-            if (!path || typeof handler !== 'function') {
-                throw new TypeError('subscribe(path, handler) requires a string path and function handler');
-            }
-            const onEvent = (evt) => handler(evt.detail, evt);
-            bus.addEventListener(path, onEvent);
-
-            return function unsubscribe() {
-                bus.removeEventListener(path, onEvent);
-            };
-        },
-        addStateListener(path, handler) {
-            return this.subscribe(path, handler);
-        },
-        off(unsubscribe) {
-            if (typeof unsubscribe !== 'function') {
-                throw new TypeError('off(unsubscribe) requires a function returned by subscribe');
-            }
-            return unsubscribe();
-        },
-
-        destroy() {
-            if (!destroyed) {
-                destroyed = true;
-                // EventTarget has no parentNode - just mark as destroyed
-                // Future sets/subscribes will be blocked by destroyed flag
-            }
+/**
+ * EventState v2 - Optimized Path-Based State Management
+ *
+ * A lightweight, performant state management library using path-based subscriptions.
+ * Optimized for selective notifications and granular updates.
+ *
+ * Features:
+ * - Path-based get/set operations (e.g., 'user.profile.name')
+ * - Selective subscriptions (only relevant subscribers fire)
+ * - Wildcard subscriptions (e.g., 'user.*' catches all user changes)
+ * - Global subscriptions (e.g., '*' catches all changes)
+ * - Atomic batching (batch/setMany — subscribers fire after all writes)
+ * - Zero dependencies
+ * - ~2KB minified
+ *
+ * Performance characteristics:
+ * - 2-9x faster than Zustand for selective subscriptions
+ * - Competitive overall performance
+ * - Minimal rendering overhead (1.27x faster paint times)
+ *
+ * @example
+ * const store = createEventState({ count: 0, user: { name: 'Alice' } });
+ *
+ * // Subscribe to specific path
+ * const unsub = store.subscribe('count', (value) => {
+ *   console.log('Count changed:', value);
+ * });
+ *
+ * // Update state
+ * store.set('count', 1);
+ *
+ * // Get state
+ * const count = store.get('count');
+ *
+ * // Wildcard subscription
+ * store.subscribe('user.*', ({ path, value }) => {
+ *   console.log(`User field ${path} changed to:`, value);
+ * });
+ *
+ * // Global subscription
+ * store.subscribe('*', ({ path, value }) => {
+ *   console.log(`State changed at ${path}:`, value);
+ * });
+ *
+ * // Batch multiple writes (subscribers fire once per path, after batch)
+ * store.batch(() => {
+ *   store.set('user.name', 'Charlie');
+ *   store.set('user.email', 'charlie@example.com');
+ * });
+ *
+ * // Or use setMany for the same effect
+ * store.setMany({ 'user.name': 'Charlie', 'user.email': 'charlie@example.com' });
+ *
+ * // Cleanup
+ * unsub();
+ * store.destroy();
+ */
+
+export function createEventState(initial = {}) {
+  const state = JSON.parse(JSON.stringify(initial));
+  const listeners = new Map();
+  const asyncOps = new Map();
+  let destroyed = false;
+
+  // Batching: buffer writes and flush once at the end
+  let batching = false;
+  const batchBuffer = new Map();
+
+  function writeAndNotify(path, value) {
+    const parts = path.split(".");
+    const key = parts.pop();
+    let cur = state;
+
+    for (const p of parts) {
+      if (!cur[p]) cur[p] = {};
+      cur = cur[p];
+    }
+
+    const oldValue = cur[key];
+    cur[key] = value;
+
+    if (!destroyed) {
+      const detail = { path, value, oldValue };
+
+      const exactListeners = listeners.get(path);
+      if (exactListeners) {
+        exactListeners.forEach(cb => cb(value, detail));
+      }
+
+      if (parts.length) {
+        let parent = "";
+        for (const p of parts) {
+          parent = parent ? `${parent}.${p}` : p;
+          const wildcardListeners = listeners.get(`${parent}.*`);
+          if (wildcardListeners) {
+            wildcardListeners.forEach(cb => cb(detail));
+          }
+        }
+      }
+
+      const globalListeners = listeners.get('*');
+      if (globalListeners) {
+        globalListeners.forEach(cb => cb(detail));
+      }
+    }
+
+    return value;
+  }
+
+  function flushBatch() {
+    const entries = Array.from(batchBuffer.entries());
+    batchBuffer.clear();
+    for (const [p, v] of entries) {
+      writeAndNotify(p, v);
+    }
+  }
+
+  return {
+    /**
+     * Get value at path
+     * @param {string} path - Dot-separated path (e.g., 'user.profile.name')
+     * @returns {*} Value at path, or entire state if no path provided
+     */
+    get(path) {
+      if (destroyed) throw new Error('Cannot get from destroyed store');
+      if (!path) return state;
+      const parts = path.split('.');
+      let cur = state;
+      for (const p of parts) {
+        if (cur == null) return undefined;
+        cur = cur[p];
+      }
+      return cur;
+    },
+
+    /**
+     * Set value at path and notify subscribers
+     * @param {string} path - Dot-separated path (e.g., 'user.profile.name')
+     * @param {*} value - New value
+     * @returns {*} The value that was set
+     */
+    set(path, value) {
+      if (destroyed) throw new Error('Cannot set on destroyed store');
+      if (!path) return value;
+
+      if (batching) {
+        batchBuffer.set(path, value);
+        return value;
+      }
+
+      return writeAndNotify(path, value);
+    },
+
+    async setAsync(path, fetcher) {
+      if (destroyed) throw new Error('Cannot setAsync on destroyed store');
+      if (!path) throw new TypeError('setAsync requires a path');
+      if (typeof fetcher !== 'function') {
+        throw new TypeError('setAsync(path, fetcher) requires a function fetcher');
+      }
+
+      if (asyncOps.has(path)) {
+        asyncOps.get(path).controller.abort();
+      }
+
+      const controller = new AbortController();
+      asyncOps.set(path, { controller });
+
+      try {
+        this.batch(() => {
+          this.set(`${path}.status`, 'loading');
+          this.set(`${path}.error`, null);
+        });
+
+        const data = await fetcher(controller.signal);
+
+        if (destroyed) throw new Error('Cannot setAsync on destroyed store');
+
+        this.batch(() => {
+          this.set(`${path}.data`, data);
+          this.set(`${path}.status`, 'success');
+        });
+        return data;
+      } catch (err) {
+        if (err?.name === 'AbortError') {
+          this.set(`${path}.status`, 'cancelled');
+          const cancelErr = new Error('Request cancelled');
+          cancelErr.name = 'AbortError';
+          throw cancelErr;
+        }
+
+        this.batch(() => {
+          this.set(`${path}.status`, 'error');
+          this.set(`${path}.error`, err?.message ?? String(err));
+        });
+        throw err;
+      } finally {
+        const op = asyncOps.get(path);
+        if (op?.controller === controller) {
+          asyncOps.delete(path);
         }
-    };
+      }
+    },
+
+    cancel(path) {
+      if (destroyed) throw new Error('Cannot cancel on destroyed store');
+      if (!path) throw new TypeError('cancel requires a path');
+
+      if (asyncOps.has(path)) {
+        asyncOps.get(path).controller.abort();
+        asyncOps.delete(path);
+        this.set(`${path}.status`, 'cancelled');
+      }
+    },
+
+    /**
+     * Batch multiple set() calls. Subscribers fire once per unique path
+     * after the batch completes, not during. Supports nesting.
+     * @param {Function} fn - Function containing set() calls to batch
+     */
+    batch(fn) {
+      if (destroyed) throw new Error('Cannot batch on destroyed store');
+      if (typeof fn !== 'function') throw new TypeError('batch requires a function');
+      const wasBatching = batching;
+      batching = true;
+      try {
+        fn();
+      } finally {
+        batching = wasBatching;
+        if (!batching) flushBatch();
+      }
+    },
+
+    /**
+     * Set multiple paths atomically. Equivalent to batch(() => { set(a); set(b); ... }).
+     * Accepts a plain object, an array of [path, value] pairs, or a Map.
+     * @param {Object|Array|Map} entries - Paths and values to set
+     */
+    setMany(entries) {
+      if (destroyed) throw new Error('Cannot setMany on destroyed store');
+      if (!entries) return;
+      this.batch(() => {
+        if (Array.isArray(entries)) {
+          for (const [p, v] of entries) this.set(p, v);
+        } else if (entries instanceof Map) {
+          for (const [p, v] of entries.entries()) this.set(p, v);
+        } else if (typeof entries === 'object') {
+          for (const p of Object.keys(entries)) this.set(p, entries[p]);
+        }
+      });
+    },
+
+    /**
+     * Subscribe to changes at path
+     * @param {string} path - Path to subscribe to (supports wildcards: 'user.*', '*')
+     * @param {Function} handler - Callback function.
+     *   - Exact path subscriptions: (value, meta) => void
+     *   - Wildcard/global subscriptions: (meta) => void
+     * @returns {Function} Unsubscribe function
+     */
+    subscribe(path, handler) {
+      if (destroyed) throw new Error('Cannot subscribe to destroyed store');
+      if (!path || typeof handler !== 'function') {
+        throw new TypeError('subscribe requires path and handler');
+      }
+
+      if (!listeners.has(path)) {
+        listeners.set(path, new Set());
+      }
+      listeners.get(path).add(handler);
+
+      return () => listeners.get(path)?.delete(handler);
+    },
+
+    /**
+     * Destroy store and clear all subscriptions
+     */
+    destroy() {
+      if (!destroyed) {
+        destroyed = true;
+        batchBuffer.clear();
+        asyncOps.forEach(({ controller }) => controller.abort());
+        asyncOps.clear();
+        listeners.clear();
+      }
+    }
+  };
 }
 
 export default createEventState;
-export { createEventState };

package/index.js

@@ -6,5 +6,5 @@
  */
 
 // Primary: EventState (recommended for application state)
-export { createEventState } from './eventStateNew.js';
-export { createEventState as default } from './eventStateNew.js';
+export { createEventState } from './eventState.js';
+export { createEventState as default } from './eventState.js';

package/package.json

@@ -1,30 +1,31 @@
 {
   "name": "@uistate/core",
-  "version": "5.5.2",
+  "version": "5.6.1",
   "description": "Lightweight event-driven state management with path-based subscriptions, wildcards, and async support",
   "type": "module",
   "main": "index.js",
+  "scripts": {
+    "postinstall": "node self-test.js",
+    "test": "node tests/core.test.js",
+    "self-test": "node self-test.js"
+  },
   "exports": {
     ".": "./index.js",
     "./eventState": "./eventState.js",
-    "./eventStateNew": "./eventStateNew.js",
     "./query": "./queryClient.js"
   },
   "files": [
     "index.js",
     "eventState.js",
-    "eventStateNew.js",
     "queryClient.js",
+    "self-test.js",
     "LICENSE"
   ],
   "keywords": [
     "state-management",
     "event-driven",
     "reactive",
-    "dom-events",
-    "slot-orchestration",
     "zero-dependency",
-    "framework-free",
     "micro-framework",
     "async-state",
     "query-client"

package/self-test.js

@@ -0,0 +1,216 @@
+/**
+ * @uistate/core — self-test
+ *
+ * Standalone test of core EventState functionality. No dependencies beyond eventState.js.
+ * Runs on `node self-test.js` or as a postinstall hook.
+ */
+
+import { createEventState } from './eventState.js';
+
+let passed = 0;
+let failed = 0;
+
+function assert(name, condition) {
+  if (condition) {
+    passed++;
+    console.log(`  ✓ ${name}`);
+  } else {
+    failed++;
+    console.error(`  ✗ ${name}`);
+  }
+}
+
+console.log('\n1. get / set');
+const s1 = createEventState({ count: 0, user: { name: 'Alice', age: 30 } });
+
+assert('get: primitive', s1.get('count') === 0);
+assert('get: nested', s1.get('user.name') === 'Alice');
+assert('get: object', s1.get('user')?.name === 'Alice');
+assert('get: entire state', s1.get('')?.count === 0);
+assert('get: missing path → undefined', s1.get('nonexistent') === undefined);
+assert('get: deep missing → undefined', s1.get('user.email') === undefined);
+
+s1.set('count', 5);
+assert('set: primitive', s1.get('count') === 5);
+
+s1.set('user.name', 'Bob');
+assert('set: nested', s1.get('user.name') === 'Bob');
+
+s1.set('user.email', 'bob@example.com');
+assert('set: auto-creates path', s1.get('user.email') === 'bob@example.com');
+
+s1.set('deep.nested.path', 'value');
+assert('set: deep auto-create', s1.get('deep.nested.path') === 'value');
+
+s1.destroy();
+
+console.log('\n2. subscribe: exact path');
+const s2 = createEventState({ count: 0 });
+let lastValue = null;
+let fireCount = 0;
+
+const unsub = s2.subscribe('count', (value) => {
+  lastValue = value;
+  fireCount++;
+});
+
+s2.set('count', 1);
+assert('subscribe: fires on change', fireCount === 1);
+assert('subscribe: receives value', lastValue === 1);
+
+s2.set('count', 2);
+assert('subscribe: fires again', fireCount === 2);
+assert('subscribe: receives new value', lastValue === 2);
+
+unsub();
+s2.set('count', 3);
+assert('unsubscribe: stops firing', fireCount === 2);
+assert('unsubscribe: value unchanged in handler', lastValue === 2);
+assert('set still works after unsub', s2.get('count') === 3);
+
+s2.destroy();
+
+console.log('\n3. subscribe: wildcard');
+const s3 = createEventState({ user: { name: 'Alice', age: 30 } });
+let wildcardFires = 0;
+let wildcardDetail = null;
+
+s3.subscribe('user.*', (detail) => {
+  wildcardFires++;
+  wildcardDetail = detail;
+});
+
+s3.set('user.name', 'Bob');
+assert('wildcard: fires on child change', wildcardFires === 1);
+assert('wildcard: detail has path', wildcardDetail?.path === 'user.name');
+assert('wildcard: detail has value', wildcardDetail?.value === 'Bob');
+
+s3.set('user.age', 31);
+assert('wildcard: fires on other child', wildcardFires === 2);
+
+s3.destroy();
+
+console.log('\n4. subscribe: global');
+const s4 = createEventState({ a: 1, b: { c: 2 } });
+let globalFires = 0;
+
+s4.subscribe('*', () => { globalFires++; });
+
+s4.set('a', 10);
+assert('global: fires on root path', globalFires === 1);
+
+s4.set('b.c', 20);
+assert('global: fires on nested path', globalFires === 2);
+
+s4.destroy();
+
+console.log('\n5. batch');
+const s5 = createEventState({ x: 0, y: 0 });
+let batchFires = 0;
+s5.subscribe('*', () => { batchFires++; });
+
+s5.batch(() => {
+  s5.set('x', 1);
+  s5.set('y', 2);
+});
+assert('batch: fires after (not during)', batchFires === 2);
+assert('batch: x set', s5.get('x') === 1);
+assert('batch: y set', s5.get('y') === 2);
+
+// Deduplication
+batchFires = 0;
+s5.batch(() => {
+  s5.set('x', 10);
+  s5.set('x', 20);
+  s5.set('x', 30);
+});
+assert('batch: deduplicates same path (1 fire)', batchFires === 1);
+assert('batch: last write wins', s5.get('x') === 30);
+
+// Nested batch
+batchFires = 0;
+s5.batch(() => {
+  s5.set('x', 100);
+  s5.batch(() => {
+    s5.set('y', 200);
+  });
+});
+assert('nested batch: both fire after outermost', batchFires === 2);
+assert('nested batch: x', s5.get('x') === 100);
+assert('nested batch: y', s5.get('y') === 200);
+
+// No notifications during batch
+const seen = [];
+const s5b = createEventState({ v: 0 });
+s5b.subscribe('v', (val) => seen.push(val));
+s5b.batch(() => {
+  s5b.set('v', 1);
+  s5b.set('v', 2);
+});
+assert('batch: no mid-batch notifications', seen.length === 1);
+assert('batch: final value delivered', seen[0] === 2);
+
+s5.destroy();
+s5b.destroy();
+
+console.log('\n6. setMany');
+const s6 = createEventState({});
+
+// Plain object
+s6.setMany({ 'a.b': 1, 'a.c': 2 });
+assert('setMany object: a.b', s6.get('a.b') === 1);
+assert('setMany object: a.c', s6.get('a.c') === 2);
+
+// Array of pairs
+s6.setMany([['x.y', 'hello'], ['x.z', 'world']]);
+assert('setMany array: x.y', s6.get('x.y') === 'hello');
+assert('setMany array: x.z', s6.get('x.z') === 'world');
+
+// Map
+s6.setMany(new Map([['m.a', true], ['m.b', false]]));
+assert('setMany Map: m.a', s6.get('m.a') === true);
+assert('setMany Map: m.b', s6.get('m.b') === false);
+
+s6.destroy();
+
+console.log('\n7. destroy');
+const s7 = createEventState({ z: 0 });
+s7.destroy();
+
+let threw = false;
+try { s7.get('z'); } catch { threw = true; }
+assert('destroy: get throws', threw);
+
+threw = false;
+try { s7.set('z', 1); } catch { threw = true; }
+assert('destroy: set throws', threw);
+
+threw = false;
+try { s7.batch(() => {}); } catch { threw = true; }
+assert('destroy: batch throws', threw);
+
+threw = false;
+try { s7.setMany({ a: 1 }); } catch { threw = true; }
+assert('destroy: setMany throws', threw);
+
+threw = false;
+try { s7.subscribe('z', () => {}); } catch { threw = true; }
+assert('destroy: subscribe throws', threw);
+
+console.log('\n8. subscribe: detail object');
+const s8 = createEventState({ count: 10 });
+let detail = null;
+s8.subscribe('count', (value, d) => { detail = d; });
+s8.set('count', 20);
+assert('detail: has path', detail?.path === 'count');
+assert('detail: has value', detail?.value === 20);
+assert('detail: has oldValue', detail?.oldValue === 10);
+
+s8.destroy();
+
+// Results
+
+console.log(`\n@uistate/core v5.6.1 — self-test`);
+console.log(`✓ ${passed} assertions passed${failed ? `, ✗ ${failed} failed` : ''}\n`);
+
+if (failed > 0) process.exit(1);

package/eventStateNew.js

@@ -1,218 +0,0 @@
-/**
- * EventState v2 - Optimized Path-Based State Management
- *
- * A lightweight, performant state management library using path-based subscriptions.
- * Optimized for selective notifications and granular updates.
- *
- * Features:
- * - Path-based get/set operations (e.g., 'user.profile.name')
- * - Selective subscriptions (only relevant subscribers fire)
- * - Wildcard subscriptions (e.g., 'user.*' catches all user changes)
- * - Global subscriptions (e.g., '*' catches all changes)
- * - Zero dependencies
- * - ~2KB minified
- *
- * Performance characteristics:
- * - 2-9x faster than Zustand for selective subscriptions
- * - Competitive overall performance
- * - Minimal rendering overhead (1.27x faster paint times)
- *
- * @example
- * const store = createEventState({ count: 0, user: { name: 'Alice' } });
- *
- * // Subscribe to specific path
- * const unsub = store.subscribe('count', (value) => {
- *   console.log('Count changed:', value);
- * });
- *
- * // Update state
- * store.set('count', 1);
- *
- * // Get state
- * const count = store.get('count');
- *
- * // Wildcard subscription
- * store.subscribe('user.*', ({ path, value }) => {
- *   console.log(`User field ${path} changed to:`, value);
- * });
- *
- * // Global subscription
- * store.subscribe('*', ({ path, value }) => {
- *   console.log(`State changed at ${path}:`, value);
- * });
- *
- * // Cleanup
- * unsub();
- * store.destroy();
- */
-
-export function createEventState(initial = {}) {
-  const state = JSON.parse(JSON.stringify(initial));
-  const listeners = new Map();
-  const asyncOps = new Map();
-  let destroyed = false;
-
-  return {
-    /**
-     * Get value at path
-     * @param {string} path - Dot-separated path (e.g., 'user.profile.name')
-     * @returns {*} Value at path, or entire state if no path provided
-     */
-    get(path) {
-      if (destroyed) throw new Error('Cannot get from destroyed store');
-      if (!path) return state;
-      const parts = path.split('.');
-      let cur = state;
-      for (const p of parts) {
-        if (cur == null) return undefined;
-        cur = cur[p];
-      }
-      return cur;
-    },
-
-    /**
-     * Set value at path and notify subscribers
-     * @param {string} path - Dot-separated path (e.g., 'user.profile.name')
-     * @param {*} value - New value
-     * @returns {*} The value that was set
-     */
-    set(path, value) {
-      if (destroyed) throw new Error('Cannot set on destroyed store');
-      if (!path) return value;
-
-      const parts = path.split(".");
-      const key = parts.pop();
-      let cur = state;
-
-      // Navigate to parent object, creating nested objects as needed
-      for (const p of parts) {
-        if (!cur[p]) cur[p] = {};
-        cur = cur[p];
-      }
-
-      const oldValue = cur[key];
-      cur[key] = value;
-
-      if (!destroyed) {
-        const detail = { path, value, oldValue };
-
-        // Notify exact path subscribers
-        const exactListeners = listeners.get(path);
-        if (exactListeners) {
-          exactListeners.forEach(cb => cb(value, detail));
-        }
-
-        // Notify wildcard subscribers for parent paths
-        if (parts.length) {
-          let parent = "";
-          for (const p of parts) {
-            parent = parent ? `${parent}.${p}` : p;
-            const wildcardListeners = listeners.get(`${parent}.*`);
-            if (wildcardListeners) {
-              wildcardListeners.forEach(cb => cb(detail));
-            }
-          }
-        }
-
-        // Notify global subscribers
-        const globalListeners = listeners.get('*');
-        if (globalListeners) {
-          globalListeners.forEach(cb => cb(detail));
-        }
-      }
-
-      return value;
-    },
-
-    async setAsync(path, fetcher) {
-      if (destroyed) throw new Error('Cannot setAsync on destroyed store');
-      if (!path) throw new TypeError('setAsync requires a path');
-      if (typeof fetcher !== 'function') {
-        throw new TypeError('setAsync(path, fetcher) requires a function fetcher');
-      }
-
-      if (asyncOps.has(path)) {
-        asyncOps.get(path).controller.abort();
-      }
-
-      const controller = new AbortController();
-      asyncOps.set(path, { controller });
-
-      try {
-        this.set(`${path}.status`, 'loading');
-        this.set(`${path}.error`, null);
-
-        const data = await fetcher(controller.signal);
-
-        if (destroyed) throw new Error('Cannot setAsync on destroyed store');
-
-        this.set(`${path}.data`, data);
-        this.set(`${path}.status`, 'success');
-        return data;
-      } catch (err) {
-        if (err?.name === 'AbortError') {
-          this.set(`${path}.status`, 'cancelled');
-          const cancelErr = new Error('Request cancelled');
-          cancelErr.name = 'AbortError';
-          throw cancelErr;
-        }
-
-        this.set(`${path}.status`, 'error');
-        this.set(`${path}.error`, err?.message ?? String(err));
-        throw err;
-      } finally {
-        const op = asyncOps.get(path);
-        if (op?.controller === controller) {
-          asyncOps.delete(path);
-        }
-      }
-    },
-
-    cancel(path) {
-      if (destroyed) throw new Error('Cannot cancel on destroyed store');
-      if (!path) throw new TypeError('cancel requires a path');
-
-      if (asyncOps.has(path)) {
-        asyncOps.get(path).controller.abort();
-        asyncOps.delete(path);
-        this.set(`${path}.status`, 'cancelled');
-      }
-    },
-
-    /**
-     * Subscribe to changes at path
-     * @param {string} path - Path to subscribe to (supports wildcards: 'user.*', '*')
-     * @param {Function} handler - Callback function.
-     *   - Exact path subscriptions: (value, meta) => void
-     *   - Wildcard/global subscriptions: (meta) => void
-     * @returns {Function} Unsubscribe function
-     */
-    subscribe(path, handler) {
-      if (destroyed) throw new Error('Cannot subscribe to destroyed store');
-      if (!path || typeof handler !== 'function') {
-        throw new TypeError('subscribe requires path and handler');
-      }
-
-      if (!listeners.has(path)) {
-        listeners.set(path, new Set());
-      }
-      listeners.get(path).add(handler);
-
-      return () => listeners.get(path)?.delete(handler);
-    },
-
-    /**
-     * Destroy store and clear all subscriptions
-     */
-    destroy() {
-      if (!destroyed) {
-        destroyed = true;
-        asyncOps.forEach(({ controller }) => controller.abort());
-        asyncOps.clear();
-        listeners.clear();
-      }
-    }
-  };
-}
-
-export default createEventState;