@uistate/core 5.0.3 → 5.1.1

package/eventStateNew.js

@@ -0,0 +1,212 @@
+/**
+ * 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;
+      return path.split(".").reduce((obj, key) => obj?.[key], state);
+    },
+
+    /**
+     * 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);
+        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;

package/eventTest.js

@@ -24,7 +24,7 @@
  * Provides TDD-style testing with type extraction capabilities
  */
 
-import { createEventState } from './eventState.js';
+import { createEventState } from './eventStateNew.js';
 
 export function createEventTest(initialState = {}) {
   const store = createEventState(initialState);

package/examples/028-counter-improved-eventTest/app/store.js

@@ -1,5 +1,5 @@
 // store.js — singleton eventState store for counter app
-import { createEventState } from '../runtime/core/eventState.js';
+import { createEventState } from '../runtime/core/eventStateNew.js';
 
 const initial = {
   count: 0

package/examples/028-counter-improved-eventTest/runtime/core/eventStateNew.js

@@ -0,0 +1,149 @@
+/**
+ * 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 (receives value directly)
+ * 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();
+  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;
+      return path.split(".").reduce((obj, key) => obj?.[key], state);
+    },
+
+    /**
+     * 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 (pass value directly for backwards compatibility)
+        const exactListeners = listeners.get(path);
+        if (exactListeners) {
+          exactListeners.forEach(cb => cb(value));
+        }
+
+        // Notify wildcard subscribers for all parent paths (pass detail object)
+        for (let i = 0; i < parts.length; i++) {
+          const parentPath = parts.slice(0, i + 1).join('.');
+          const wildcardListeners = listeners.get(`${parentPath}.*`);
+          if (wildcardListeners) {
+            wildcardListeners.forEach(cb => cb(detail));
+          }
+        }
+
+        // Notify global subscribers (pass detail object)
+        const globalListeners = listeners.get('*');
+        if (globalListeners) {
+          globalListeners.forEach(cb => cb(detail));
+        }
+      }
+
+      return value;
+    },
+
+    /**
+     * Subscribe to changes at path
+     * @param {string} path - Path to subscribe to (supports wildcards: 'user.*', '*')
+     * @param {Function} handler - Callback function receiving { path, value, oldValue }
+     * @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;
+        listeners.clear();
+      }
+    }
+  };
+}
+
+export default createEventState;

package/examples/028-counter-improved-eventTest/tests/eventTest.js

@@ -4,7 +4,7 @@
  * Provides TDD-style testing with type extraction capabilities
  */
 
-import { createEventState } from '../runtime/core/eventState.js';
+import { createEventState } from '../runtime/core/eventStateNew.js';
 
 export function createEventTest(initialState = {}) {
   const store = createEventState(initialState);

package/examples/030-todo-app-with-eventTest/app/store.js

@@ -1,5 +1,5 @@
 // store.js — singleton eventState store for the SPA
-import { createEventState } from '../runtime/core/eventState.js';
+import { createEventState } from '../runtime/core/eventStateNew.js';
 
 const initial = {
   ui: {

package/examples/030-todo-app-with-eventTest/runtime/core/eventStateNew.js

@@ -0,0 +1,149 @@
+/**
+ * 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 (receives value directly)
+ * 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();
+  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;
+      return path.split(".").reduce((obj, key) => obj?.[key], state);
+    },
+
+    /**
+     * 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 (pass value directly for backwards compatibility)
+        const exactListeners = listeners.get(path);
+        if (exactListeners) {
+          exactListeners.forEach(cb => cb(value));
+        }
+
+        // Notify wildcard subscribers for all parent paths (pass detail object)
+        for (let i = 0; i < parts.length; i++) {
+          const parentPath = parts.slice(0, i + 1).join('.');
+          const wildcardListeners = listeners.get(`${parentPath}.*`);
+          if (wildcardListeners) {
+            wildcardListeners.forEach(cb => cb(detail));
+          }
+        }
+
+        // Notify global subscribers (pass detail object)
+        const globalListeners = listeners.get('*');
+        if (globalListeners) {
+          globalListeners.forEach(cb => cb(detail));
+        }
+      }
+
+      return value;
+    },
+
+    /**
+     * Subscribe to changes at path
+     * @param {string} path - Path to subscribe to (supports wildcards: 'user.*', '*')
+     * @param {Function} handler - Callback function receiving { path, value, oldValue }
+     * @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;
+        listeners.clear();
+      }
+    }
+  };
+}
+
+export default createEventState;

package/examples/030-todo-app-with-eventTest/tests/eventTest.js

@@ -4,7 +4,7 @@
  * Provides TDD-style testing with type extraction capabilities
  */
 
-import { createEventState } from '../runtime/core/eventState.js';
+import { createEventState } from '../runtime/core/eventStateNew.js';
 
 export function createEventTest(initialState = {}) {
   const store = createEventState(initialState);

package/examples/031-todo-app-with-eventTest/app/store.js

@@ -1,5 +1,5 @@
 // store.js — singleton eventState store for the SPA
-import { createEventState } from '../runtime/core/eventState.js';
+import { createEventState } from '../runtime/core/eventStateNew.js';
 
 const initial = {
   ui: {

package/examples/031-todo-app-with-eventTest/runtime/core/eventStateNew.js

@@ -0,0 +1,149 @@
+/**
+ * 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 (receives value directly)
+ * 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();
+  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;
+      return path.split(".").reduce((obj, key) => obj?.[key], state);
+    },
+
+    /**
+     * 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 (pass value directly for backwards compatibility)
+        const exactListeners = listeners.get(path);
+        if (exactListeners) {
+          exactListeners.forEach(cb => cb(value));
+        }
+
+        // Notify wildcard subscribers for all parent paths (pass detail object)
+        for (let i = 0; i < parts.length; i++) {
+          const parentPath = parts.slice(0, i + 1).join('.');
+          const wildcardListeners = listeners.get(`${parentPath}.*`);
+          if (wildcardListeners) {
+            wildcardListeners.forEach(cb => cb(detail));
+          }
+        }
+
+        // Notify global subscribers (pass detail object)
+        const globalListeners = listeners.get('*');
+        if (globalListeners) {
+          globalListeners.forEach(cb => cb(detail));
+        }
+      }
+
+      return value;
+    },
+
+    /**
+     * Subscribe to changes at path
+     * @param {string} path - Path to subscribe to (supports wildcards: 'user.*', '*')
+     * @param {Function} handler - Callback function receiving { path, value, oldValue }
+     * @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;
+        listeners.clear();
+      }
+    }
+  };
+}
+
+export default createEventState;

package/examples/031-todo-app-with-eventTest/runtime/extensions/eventState.plus.js

@@ -3,7 +3,7 @@
 // NOTE: This module composes the existing './eventState.js' implementation and returns
 // an enhanced facade. The original fine-grained semantics (per-path events) remain intact.
 
-import createEventStateBase from '../core/eventState.js';
+import createEventStateBase from '../core/eventStateNew.js';
 
 /**
  * Create an enhanced EventState store while preserving the original semantics.

package/examples/031-todo-app-with-eventTest/tests/eventTest.js

@@ -4,7 +4,7 @@
  * Provides TDD-style testing with type extraction capabilities
  */
 
-import { createEventState } from '../runtime/core/eventState.js';
+import { createEventState } from '../runtime/core/eventStateNew.js';
 
 export function createEventTest(initialState = {}) {
   const store = createEventState(initialState);

package/examples/032-todo-app-with-eventTest/app/store.js

@@ -1,5 +1,5 @@
 // store.js — singleton eventState store for the SPA
-import { createEventState } from '../runtime/core/eventState.js';
+import { createEventState } from '../runtime/core/eventStateNew.js';
 
 const initial = {
   ui: {

package/examples/032-todo-app-with-eventTest/runtime/core/eventStateNew.js

@@ -0,0 +1,149 @@
+/**
+ * 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 (receives value directly)
+ * 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();
+  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;
+      return path.split(".").reduce((obj, key) => obj?.[key], state);
+    },
+
+    /**
+     * 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 (pass value directly for backwards compatibility)
+        const exactListeners = listeners.get(path);
+        if (exactListeners) {
+          exactListeners.forEach(cb => cb(value));
+        }
+
+        // Notify wildcard subscribers for all parent paths (pass detail object)
+        for (let i = 0; i < parts.length; i++) {
+          const parentPath = parts.slice(0, i + 1).join('.');
+          const wildcardListeners = listeners.get(`${parentPath}.*`);
+          if (wildcardListeners) {
+            wildcardListeners.forEach(cb => cb(detail));
+          }
+        }
+
+        // Notify global subscribers (pass detail object)
+        const globalListeners = listeners.get('*');
+        if (globalListeners) {
+          globalListeners.forEach(cb => cb(detail));
+        }
+      }
+
+      return value;
+    },
+
+    /**
+     * Subscribe to changes at path
+     * @param {string} path - Path to subscribe to (supports wildcards: 'user.*', '*')
+     * @param {Function} handler - Callback function receiving { path, value, oldValue }
+     * @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;
+        listeners.clear();
+      }
+    }
+  };
+}
+
+export default createEventState;

package/examples/032-todo-app-with-eventTest/runtime/extensions/eventState.plus.js

@@ -3,7 +3,7 @@
 // NOTE: This module composes the existing './eventState.js' implementation and returns
 // an enhanced facade. The original fine-grained semantics (per-path events) remain intact.
 
-import createEventStateBase from '../core/eventState.js';
+import createEventStateBase from '../core/eventStateNew.js';
 
 /**
  * Create an enhanced EventState store while preserving the original semantics.

package/examples/032-todo-app-with-eventTest/tests/eventTest.js

@@ -4,7 +4,7 @@
  * Provides TDD-style testing with type extraction capabilities
  */
 
-import { createEventState } from '../runtime/core/eventState.js';
+import { createEventState } from '../runtime/core/eventStateNew.js';
 
 export function createEventTest(initialState = {}) {
   const store = createEventState(initialState);

package/index.js

@@ -6,8 +6,8 @@
  */
 
 // Primary: EventState (recommended for application state)
-export { createEventState } from './eventState.js';
-export { createEventState as default } from './eventState.js';
+export { createEventState } from './eventStateNew.js';
+export { createEventState as default } from './eventStateNew.js';
 
 // Specialized: CSS State (for CSS variables and theme management)
 export { createCssState } from './cssState.js';

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@uistate/core",
-  "version": "5.0.3",
+  "version": "5.1.1",
   "description": "Lightweight event-driven state management with slot orchestration and experimental event-sequence testing (eventTest.js available under dual license)",
   "type": "module",
   "main": "index.js",
   "exports": {
     ".": "./index.js",
     "./eventState": "./eventState.js",
+    "./eventStateNew": "./eventStateNew.js",
     "./cssState": "./cssState.js",
     "./stateSerializer": "./stateSerializer.js",
     "./templateManager": "./templateManager.js"
@@ -14,6 +15,7 @@
   "files": [
     "index.js",
     "eventState.js",
+    "eventStateNew.js",
     "cssState.js",
     "stateSerializer.js",
     "templateManager.js",