@coherent.js/state 1.1.2 → 2.0.0

package/dist/index.js

@@ -14,11 +14,107 @@ var globalErrorHandler = {
     console.error("State Error:", error.message, context);
   }
 };
-var Observable = class _Observable {
+var MAX_FLUSH_ITERATIONS = 100;
+var activeComputed = null;
+var batchDepth = 0;
+var flushing = false;
+var pendingObservables = /* @__PURE__ */ new Map();
+var pendingComputeds = /* @__PURE__ */ new Set();
+var globalVersion = 0;
+function reportError(source, error, type, context = {}) {
+  const onError = source?._options?.onError;
+  if (typeof onError === "function") {
+    try {
+      onError(error, { type, ...context });
+      return;
+    } catch (handlerError) {
+      error = handlerError;
+    }
+  }
+  globalErrorHandler.handle(error, { type, context });
+}
+function runObserver(source, observer, newValue, oldValue) {
+  try {
+    observer.callback(newValue, oldValue, observer.unwatch);
+  } catch (error) {
+    reportError(source, error, "watcher-error", { newValue, oldValue });
+  }
+}
+function flush() {
+  flushing = true;
+  let iterations = 0;
+  try {
+    while (pendingObservables.size > 0 || pendingComputeds.size > 0) {
+      if (++iterations > MAX_FLUSH_ITERATIONS) {
+        const culprits = [...pendingObservables.keys(), ...pendingComputeds];
+        pendingObservables.clear();
+        pendingComputeds.clear();
+        reportError(
+          culprits[0],
+          new StateError(
+            `Watchers kept changing state after ${MAX_FLUSH_ITERATIONS} rounds; a watcher probably writes a new value to a state it (indirectly) watches.`,
+            { type: "update-depth" }
+          ),
+          "update-depth"
+        );
+        return;
+      }
+      const observables = [...pendingObservables];
+      pendingObservables.clear();
+      for (const [source, oldValue] of observables) {
+        const newValue = source._value;
+        if (!source._changed(oldValue, newValue)) continue;
+        for (const observer of [...source._observers]) {
+          if (source._observers.has(observer)) {
+            runObserver(source, observer, newValue, oldValue);
+          }
+        }
+      }
+      const computeds = [...pendingComputeds];
+      pendingComputeds.clear();
+      for (const source of computeds) {
+        if (source._observers.size === 0) continue;
+        try {
+          source._refresh();
+        } catch (error) {
+          reportError(source, error, "computed-error");
+          continue;
+        }
+        const newValue = source._value;
+        const oldValue = source._lastNotified;
+        if (Object.is(newValue, oldValue)) continue;
+        source._lastNotified = newValue;
+        for (const observer of [...source._observers]) {
+          if (source._observers.has(observer)) {
+            runObserver(source, observer, newValue, oldValue);
+          }
+        }
+      }
+    }
+  } finally {
+    flushing = false;
+  }
+}
+function scheduleFlush() {
+  if (batchDepth === 0 && !flushing) {
+    flush();
+  }
+}
+function batch(fn) {
+  batchDepth++;
+  try {
+    return fn();
+  } finally {
+    batchDepth--;
+    scheduleFlush();
+  }
+}
+var Observable = class {
   constructor(value, options = {}) {
     this._value = value;
+    this._version = 0;
     this._observers = /* @__PURE__ */ new Set();
-    this._computedDependents = /* @__PURE__ */ new Set();
+    this._subscribers = /* @__PURE__ */ new Set();
     this._options = {
       deep: options.deep !== false,
       immediate: options.immediate !== false,
@@ -26,107 +122,281 @@ var Observable = class _Observable {
     };
   }
   get value() {
-    if (_Observable._currentComputed) {
-      this._computedDependents.add(_Observable._currentComputed);
-    }
+    activeComputed?._track(this);
     return this._value;
   }
   set value(newValue) {
-    if (this._value === newValue && !this._options.deep) {
+    this._write(newValue);
+  }
+  /** Read without registering a dependency. */
+  peek() {
+    return this._value;
+  }
+  /**
+   * Whether a write from `oldValue` to `newValue` is a change. Identical
+   * primitives never are; with `deep` (the default) re-assigning the same
+   * object is, since it may have been mutated in place.
+   * @private
+   */
+  _changed(oldValue, newValue) {
+    if (!Object.is(oldValue, newValue)) return true;
+    return this._options.deep && newValue !== null && typeof newValue === "object";
+  }
+  /** @private */
+  _write(newValue) {
+    const oldValue = this._value;
+    if (!this._changed(oldValue, newValue)) {
       return;
     }
-    const oldValue = this._value;
     this._value = newValue;
-    this._observers.forEach((observer) => {
-      try {
-        observer(newValue, oldValue);
-      } catch (_error) {
-        globalErrorHandler.handle(_error, {
-          type: "watcher-_error",
-          context: { newValue, oldValue }
-        });
-      }
-    });
-    this._computedDependents.forEach((computed2) => {
-      computed2._invalidate();
-    });
+    this._version++;
+    globalVersion++;
+    for (const subscriber of [...this._subscribers]) {
+      subscriber._markDirty();
+    }
+    if (this._observers.size > 0 && !pendingObservables.has(this)) {
+      pendingObservables.set(this, oldValue);
+    }
+    scheduleFlush();
+  }
+  /** @private */
+  _addSubscriber(computed2) {
+    this._subscribers.add(computed2);
+  }
+  /** @private */
+  _removeSubscriber(computed2) {
+    this._subscribers.delete(computed2);
+  }
+  /** @private */
+  _addObserver(observer) {
+    this._observers.add(observer);
+  }
+  /** @private */
+  _removeObserver(observer) {
+    this._observers.delete(observer);
   }
   watch(callback, options = {}) {
     if (typeof callback !== "function") {
       throw new StateError("Watch callback must be a function");
     }
-    const observer = (newValue, oldValue) => {
-      callback(newValue, oldValue, () => this.unwatch(observer));
-    };
-    this._observers.add(observer);
+    const observer = { callback, unwatch: null };
+    observer.unwatch = () => this._removeObserver(observer);
+    this._addObserver(observer);
     if (options.immediate !== false) {
-      observer(this._value, void 0);
+      runObserver(this, observer, this._value, void 0);
     }
-    return () => this.unwatch(observer);
+    return observer.unwatch;
   }
-  unwatch(observer) {
-    this._observers.delete(observer);
+  /**
+   * Remove a watcher, by the callback passed to watch()
+   * @param {Function} callback
+   */
+  unwatch(callback) {
+    for (const observer of [...this._observers]) {
+      if (observer.callback === callback || observer.unwatch === callback) {
+        this._removeObserver(observer);
+      }
+    }
   }
+  /** Remove every watcher. */
   unwatchAll() {
-    this._observers.clear();
-    this._computedDependents.clear();
+    for (const observer of [...this._observers]) {
+      this._removeObserver(observer);
+    }
   }
 };
-var Computed = class extends Observable {
+var Computed = class _Computed extends Observable {
   constructor(getter, options = {}) {
-    super(void 0, options);
-    this._getter = getter;
-    this._cached = false;
-    this._dirty = true;
     if (typeof getter !== "function") {
       throw new StateError("Computed getter must be a function");
     }
+    super(void 0, options);
+    this._getter = getter;
+    this._deps = /* @__PURE__ */ new Map();
+    this._dirty = true;
+    this._computing = false;
+    this._globalVersionSeen = -1;
+    this._lastNotified = void 0;
   }
   get value() {
-    if (this._dirty || !this._cached) {
-      this._compute();
-    }
+    this._refresh();
+    activeComputed?._track(this);
     return this._value;
   }
-  set value(newValue) {
+  set value(_newValue) {
     throw new StateError("Cannot set value on computed property");
   }
-  _compute() {
-    const prevComputed = Observable._currentComputed;
-    Observable._currentComputed = this;
-    try {
-      const newValue = this._getter();
-      if (newValue !== this._value) {
-        const oldValue = this._value;
-        this._value = newValue;
-        this._observers.forEach((observer) => {
-          observer(newValue, oldValue);
-        });
-      }
-      this._cached = true;
-      this._dirty = false;
-    } catch (_error) {
-      globalErrorHandler.handle(_error, {
-        type: "computed-_error",
-        context: { getter: this._getter.toString() }
+  peek() {
+    this._refresh();
+    return this._value;
+  }
+  /** Watched, or a dependency of a live computed. @private */
+  get _live() {
+    return this._observers.size > 0 || this._subscribers.size > 0;
+  }
+  /** @private */
+  _track(source) {
+    if (!this._deps.has(source)) {
+      this._deps.set(source, source._version);
+    }
+  }
+  /** Bring the cached value up to date. @private */
+  _refresh() {
+    if (this._computing) {
+      throw new StateError("Circular dependency between computed properties", {
+        type: "computed-cycle",
+        context: { getter: this._getter.name || "anonymous" }
       });
+    }
+    if (!this._dirty) {
+      if (this._live || this._globalVersionSeen === globalVersion) return;
+      if (!this._dependenciesChanged()) {
+        this._globalVersionSeen = globalVersion;
+        return;
+      }
+    }
+    this._recompute();
+  }
+  /** @private */
+  _dependenciesChanged() {
+    for (const [source, version] of this._deps) {
+      if (source instanceof _Computed) {
+        source._refresh();
+      }
+      if (source._version !== version) return true;
+    }
+    return false;
+  }
+  /** @private */
+  _recompute() {
+    const previousDeps = this._deps;
+    const previousActive = activeComputed;
+    this._deps = /* @__PURE__ */ new Map();
+    this._computing = true;
+    activeComputed = this;
+    let newValue;
+    try {
+      newValue = this._getter();
+    } catch (error) {
+      this._deps = previousDeps;
+      this._dirty = true;
+      throw error;
     } finally {
-      Observable._currentComputed = prevComputed;
+      this._computing = false;
+      activeComputed = previousActive;
+    }
+    if (this._live) {
+      for (const source of previousDeps.keys()) {
+        if (!this._deps.has(source)) source._removeSubscriber(this);
+      }
+      for (const source of this._deps.keys()) {
+        if (!previousDeps.has(source)) source._addSubscriber(this);
+      }
+    }
+    this._dirty = false;
+    this._globalVersionSeen = globalVersion;
+    if (!Object.is(newValue, this._value)) {
+      this._value = newValue;
+      this._version++;
     }
   }
-  _invalidate() {
+  /** A dependency changed. @private */
+  _markDirty() {
+    if (this._dirty) return;
     this._dirty = true;
-    this._computedDependents.forEach((computed2) => {
-      computed2._invalidate();
-    });
+    if (this._observers.size > 0) {
+      pendingComputeds.add(this);
+    }
+    for (const subscriber of [...this._subscribers]) {
+      subscriber._markDirty();
+    }
+  }
+  /** Subscribe to dependencies. @private */
+  _goLive() {
+    this._refresh();
+    for (const source of this._deps.keys()) {
+      source._addSubscriber(this);
+    }
+  }
+  /** Unsubscribe from dependencies. @private */
+  _goLazy() {
+    for (const source of this._deps.keys()) {
+      source._removeSubscriber(this);
+    }
+  }
+  /** @private */
+  _addSubscriber(computed2) {
+    const wasLive = this._live;
+    this._subscribers.add(computed2);
+    if (!wasLive) this._goLive();
+  }
+  /** @private */
+  _removeSubscriber(computed2) {
+    this._subscribers.delete(computed2);
+    if (!this._live) this._goLazy();
+  }
+  /** @private */
+  _addObserver(observer) {
+    const hadObservers = this._observers.size > 0;
+    const wasLive = this._live;
+    this._observers.add(observer);
+    try {
+      if (wasLive) {
+        this._refresh();
+      } else {
+        this._goLive();
+      }
+    } catch (error) {
+      this._observers.delete(observer);
+      throw error;
+    }
+    if (!hadObservers) {
+      this._lastNotified = this._value;
+    }
+  }
+  /** @private */
+  _removeObserver(observer) {
+    if (!this._observers.delete(observer)) return;
+    if (!this._live) this._goLazy();
   }
 };
-Observable._currentComputed = null;
+var ABSENT = /* @__PURE__ */ Symbol("absent");
+function isPath(key) {
+  return typeof key === "string" && key.includes(".");
+}
+function readPath(value, segments) {
+  let current = value;
+  for (const segment of segments) {
+    if (current === null || current === void 0) return void 0;
+    current = current[segment];
+  }
+  return current;
+}
+function writePath(target, segments, value) {
+  const [head, ...rest] = segments;
+  const base = target !== null && typeof target === "object" ? Array.isArray(target) ? [...target] : { ...target } : {};
+  const next = rest.length === 0 ? value : writePath(base[head], rest, value);
+  Object.defineProperty(base, head, { value: next, enumerable: true, writable: true, configurable: true });
+  return base;
+}
+function deletePath(target, segments) {
+  if (target === null || typeof target !== "object") return target;
+  const [head, ...rest] = segments;
+  if (!Object.prototype.hasOwnProperty.call(target, head)) return target;
+  const base = Array.isArray(target) ? [...target] : { ...target };
+  if (rest.length === 0) {
+    delete base[head];
+  } else {
+    base[head] = deletePath(base[head], rest);
+  }
+  return base;
+}
 var ReactiveState = class {
   constructor(initialState = {}, options = {}) {
     this._state = /* @__PURE__ */ new Map();
     this._computed = /* @__PURE__ */ new Map();
     this._watchers = /* @__PURE__ */ new Map();
+    this._expressionWatchers = /* @__PURE__ */ new Set();
     this._middleware = [];
     this._history = [];
     this._options = {
@@ -140,57 +410,115 @@ var ReactiveState = class {
       this.set(key, value);
     });
   }
+  /** Observable for a key, created as an absent placeholder if needed. @private */
+  _observable(key) {
+    let observable2 = this._state.get(key);
+    if (!observable2) {
+      observable2 = new Observable(ABSENT, this._options);
+      this._state.set(key, observable2);
+    }
+    return observable2;
+  }
+  /** Whether a key is stored under its full name. @private */
+  _hasOwnKey(key) {
+    const observable2 = this._state.get(key);
+    return Boolean(observable2) && observable2._value !== ABSENT;
+  }
+  /** [rootKey, pathSegments] for a dot path, or null for a plain key. @private */
+  _splitPath(key) {
+    if (!isPath(key)) return null;
+    const [root, ...segments] = key.split(".");
+    return [root, segments];
+  }
   /**
    * Get reactive state value
    */
   get(key) {
-    const observable2 = this._state.get(key);
-    return observable2 ? observable2.value : void 0;
+    const path = this._splitPath(key);
+    if (path) {
+      return readPath(this.get(path[0]), path[1]);
+    }
+    const observable2 = activeComputed ? this._observable(key) : this._state.get(key);
+    if (!observable2) return void 0;
+    const value = observable2.value;
+    return value === ABSENT ? void 0 : value;
   }
   /**
    * Set reactive state value
    */
   set(key, value, options = {}) {
     const config = { ...this._options, ...options };
+    const oldValue = this.get(key);
     if (config.enableMiddleware) {
-      const middlewareResult = this._runMiddleware("set", { key, value, oldValue: this.get(key) });
+      const middlewareResult = this._runMiddleware("set", { key, value, oldValue });
       if (middlewareResult.cancelled) {
         return false;
       }
       value = middlewareResult.value !== void 0 ? middlewareResult.value : value;
     }
-    let observable2 = this._state.get(key);
-    if (!observable2) {
-      observable2 = new Observable(value, config);
-      this._state.set(key, observable2);
-    } else {
+    const path = this._splitPath(key);
+    if (path) {
+      const [root, segments] = path;
       if (config.enableHistory) {
-        this._addToHistory("set", key, observable2.value, value);
+        this._addToHistory("set", key, oldValue, value);
       }
-      observable2.value = value;
+      this._writeKey(root, writePath(this.get(root), segments, value));
+      return true;
+    }
+    if (config.enableHistory && this._hasOwnKey(key)) {
+      this._addToHistory("set", key, oldValue, value);
     }
+    this._writeKey(key, value);
     return true;
   }
+  /** @private */
+  _writeKey(key, value) {
+    this._observable(key)._write(value);
+  }
   /**
    * Check if state has a key
    */
   has(key) {
-    return this._state.has(key);
+    const path = this._splitPath(key);
+    if (path) {
+      const parent = readPath(this.get(path[0]), path[1].slice(0, -1));
+      return parent !== null && typeof parent === "object" && Object.prototype.hasOwnProperty.call(parent, path[1][path[1].length - 1]);
+    }
+    return this._hasOwnKey(key);
   }
   /**
-   * Delete state key
+   * Delete state key. Its watchers are removed; computed properties that
+   * read it update.
    */
   delete(key) {
-    const observable2 = this._state.get(key);
-    if (observable2) {
+    const path = this._splitPath(key);
+    if (path) {
+      if (!this.has(key)) return false;
       if (this._options.enableHistory) {
-        this._addToHistory("delete", key, observable2.value, void 0);
+        this._addToHistory("delete", key, this.get(key), void 0);
       }
-      observable2.unwatchAll();
-      this._state.delete(key);
+      this._writeKey(path[0], deletePath(this.get(path[0]), path[1]));
       return true;
     }
-    return false;
+    if (!this._hasOwnKey(key)) {
+      return false;
+    }
+    const observable2 = this._state.get(key);
+    if (this._options.enableHistory) {
+      this._addToHistory("delete", key, observable2._value, void 0);
+    }
+    observable2.unwatchAll();
+    this._releaseKeyWatchers(key);
+    observable2._write(ABSENT);
+    return true;
+  }
+  /** @private */
+  _releaseKeyWatchers(key) {
+    const unwatchers = this._watchers.get(key);
+    if (unwatchers) {
+      for (const unwatch of unwatchers) unwatch();
+      this._watchers.delete(key);
+    }
   }
   /**
    * Clear all state
@@ -199,10 +527,13 @@ var ReactiveState = class {
     if (this._options.enableHistory) {
       this._addToHistory("clear", null, this.toObject(), {});
     }
-    for (const observable2 of this._state.values()) {
-      observable2.unwatchAll();
-    }
-    this._state.clear();
+    batch(() => {
+      for (const [key, observable2] of this._state) {
+        observable2.unwatchAll();
+        this._releaseKeyWatchers(key);
+        observable2._write(ABSENT);
+      }
+    });
     this._computed.clear();
     this._watchers.clear();
   }
@@ -225,40 +556,62 @@ var ReactiveState = class {
     return computed2 ? computed2.value : void 0;
   }
   /**
-   * Watch state changes
+   * Watch state changes: a key, a dot path into a key, or a getter
+   * expression (re-evaluated whenever what it reads changes).
    */
   watch(key, callback, options = {}) {
     if (typeof key === "function") {
       return this._watchComputed(key, callback, options);
     }
-    const observable2 = this._state.get(key);
-    if (!observable2) {
+    const path = this._splitPath(key);
+    if (path) {
+      if (!this._hasOwnKey(path[0])) {
+        throw new StateError(`Cannot watch undefined state key: ${path[0]}`);
+      }
+      const computed2 = new Computed(() => this.get(key), { ...this._options, ...options });
+      return this._track(key, computed2.watch(callback, options));
+    }
+    if (!this._hasOwnKey(key)) {
       throw new StateError(`Cannot watch undefined state key: ${key}`);
     }
-    const unwatch = observable2.watch(callback, options);
+    return this._track(key, this._state.get(key).watch(callback, options));
+  }
+  /** Remember an unwatch function for cleanup. @private */
+  _track(key, unwatch) {
     if (!this._watchers.has(key)) {
       this._watchers.set(key, /* @__PURE__ */ new Set());
     }
-    this._watchers.get(key).add(unwatch);
-    return unwatch;
+    const unwatchers = this._watchers.get(key);
+    const release = () => {
+      unwatch();
+      unwatchers.delete(release);
+    };
+    unwatchers.add(release);
+    return release;
   }
   /**
    * Watch computed expression
    */
   _watchComputed(expression, callback, options = {}) {
-    const computed2 = new Computed(expression, options);
+    const computed2 = new Computed(expression, { ...this._options, ...options });
     const unwatch = computed2.watch(callback, options);
-    return unwatch;
+    const release = () => {
+      unwatch();
+      this._expressionWatchers.delete(release);
+    };
+    this._expressionWatchers.add(release);
+    return release;
   }
   /**
-   * Batch state updates
+   * Batch state updates: watchers run once, after every update, with the
+   * final values.
    */
   batch(updates) {
     if (typeof updates === "function") {
       const oldEnableHistory = this._options.enableHistory;
       this._options.enableHistory = false;
       try {
-        const result = updates(this);
+        const result = batch(() => updates(this));
         if (oldEnableHistory) {
           this._addToHistory("batch", null, null, this.toObject());
         }
@@ -318,11 +671,8 @@ var ReactiveState = class {
             break;
           }
         }
-      } catch (_error) {
-        globalErrorHandler.handle(_error, {
-          type: "middleware-_error",
-          context: { action, middleware: middleware.toString() }
-        });
+      } catch (error) {
+        reportError(this, error, "middleware-error", { action });
       }
     }
     return result;
@@ -386,28 +736,28 @@ var ReactiveState = class {
    * Convert state to plain object
    */
   toObject() {
-    const result = {};
-    for (const [key, observable2] of this._state.entries()) {
-      result[key] = observable2.value;
-    }
-    return result;
+    return Object.fromEntries(
+      [...this._state].filter(([, observable2]) => observable2._value !== ABSENT).map(([key, observable2]) => [key, observable2._value])
+    );
   }
   /**
    * Convert computed properties to object
    */
   getComputedValues() {
-    const result = {};
-    for (const [key, computed2] of this._computed.entries()) {
-      result[key] = computed2.value;
-    }
-    return result;
+    return Object.fromEntries(
+      [...this._computed].map(([key, computed2]) => [key, computed2.value])
+    );
   }
   /**
    * Get state statistics
    */
   getStats() {
+    let stateKeys = 0;
+    for (const observable2 of this._state.values()) {
+      if (observable2._value !== ABSENT) stateKeys++;
+    }
     return {
-      stateKeys: this._state.size,
+      stateKeys,
       computedKeys: this._computed.size,
       watcherKeys: this._watchers.size,
       historyLength: this._history.length,
@@ -418,6 +768,12 @@ var ReactiveState = class {
    * Cleanup and destroy
    */
   destroy() {
+    for (const key of [...this._watchers.keys()]) {
+      this._releaseKeyWatchers(key);
+    }
+    for (const release of [...this._expressionWatchers]) {
+      release();
+    }
     for (const observable2 of this._state.values()) {
       observable2.unwatchAll();
     }
@@ -545,147 +901,199 @@ var globalStateManager = {
     return createState();
   }
 };
-var contextStacks = /* @__PURE__ */ new Map();
-function provideContext(key, value) {
-  if (!contextStacks.has(key)) {
-    contextStacks.set(key, []);
+var EMPTY_SCOPE = /* @__PURE__ */ new Map();
+function createAsyncStorage() {
+  try {
+    const asyncHooks = globalThis.process?.getBuiltinModule?.("node:async_hooks");
+    const AsyncLocalStorage = asyncHooks?.AsyncLocalStorage;
+    return typeof AsyncLocalStorage === "function" ? new AsyncLocalStorage() : null;
+  } catch {
+    return null;
   }
-  const stack = contextStacks.get(key);
-  const previousValue = globalState.get(key);
-  stack.push(previousValue);
-  globalState.set(key, value);
+}
+var asyncStorage = createAsyncStorage();
+var syncHolder = { scope: EMPTY_SCOPE, owned: true };
+function currentHolder() {
+  return asyncStorage ? asyncStorage.getStore() : syncHolder;
+}
+function currentScope() {
+  return currentHolder()?.scope ?? EMPTY_SCOPE;
+}
+function setScope(scope, holder = currentHolder()) {
+  if (!holder?.owned) {
+    throw new Error(
+      "Context can only be provided inside runWithContext() on the server: outside it the value would leak into other requests. Wrap each request or render: runWithContext(() => ...)."
+    );
+  }
+  holder.scope = scope;
+}
+function runInScope(scope, fn, args) {
+  if (asyncStorage) {
+    return asyncStorage.run({ scope, owned: true }, fn, ...args);
+  }
+  const previous = syncHolder.scope;
+  syncHolder.scope = scope;
+  try {
+    return fn(...args);
+  } finally {
+    syncHolder.scope = previous;
+  }
+}
+function withValue(scope, key, value) {
+  const next = new Map(scope);
+  next.set(key, { value, previous: scope.get(key) });
+  return next;
+}
+function runWithContext(fn, values) {
+  if (typeof fn !== "function") {
+    throw new TypeError(`runWithContext() requires a function, received: ${typeof fn}`);
+  }
+  let scope = EMPTY_SCOPE;
+  if (values && typeof values === "object") {
+    for (const [key, value] of Object.entries(values)) {
+      scope = withValue(scope, key, value);
+    }
+  }
+  return runInScope(scope, fn, []);
+}
+function provideContext(key, value) {
+  setScope(withValue(currentScope(), key, value));
 }
 function createContextProvider(key, value, children) {
-  return (renderFunction) => {
-    try {
-      provideContext(key, value);
-      if (renderFunction && typeof renderFunction === "function") {
-        return renderFunction(children);
-      } else {
-        return children;
-      }
-    } finally {
-      restoreContext(key);
+  function contextProvider(...args) {
+    const renderFunction = args[0];
+    const scope = withValue(currentScope(), key, value);
+    if (typeof renderFunction === "function") {
+      return runInScope(scope, renderFunction, [children]);
     }
+    return runInScope(scope, resolveComponents, [children]);
+  }
+  return contextProvider;
+}
+var TAG_NAME = /^[a-zA-Z][a-zA-Z0-9-]*$/;
+function resolveComponents(node, depth = 0) {
+  if (depth > 1e3) return node;
+  if (typeof node === "function") {
+    return resolveComponents(node(), depth + 1);
+  }
+  if (Array.isArray(node)) {
+    let changed2 = false;
+    const resolved2 = node.map((child) => {
+      const next = resolveComponents(child, depth + 1);
+      if (next !== child) changed2 = true;
+      return next;
+    });
+    return changed2 ? resolved2 : node;
+  }
+  if (!node || typeof node !== "object") return node;
+  if (node.__isLazy === true && typeof node.evaluate === "function") {
+    return resolveComponents(node.evaluate(), depth + 1);
+  }
+  const tags = Object.keys(node);
+  if (tags.length === 0 || !tags.every((tag) => TAG_NAME.test(tag))) return node;
+  let changed = false;
+  const resolved = {};
+  for (const tag of tags) {
+    let content = node[tag];
+    if (typeof content === "function") {
+      content = resolveComponents(content(), depth + 1);
+    }
+    if (content && typeof content === "object" && !Array.isArray(content) && !isTrusted(content)) {
+      content = resolveProps(content, depth);
+    }
+    if (content !== node[tag]) changed = true;
+    resolved[tag] = content;
+  }
+  return changed ? resolved : node;
+}
+function isTrusted(value) {
+  return value[/* @__PURE__ */ Symbol.for("coherent.js.trustedContent")] === true;
+}
+function resolveProps(props, depth) {
+  let next = props;
+  const set = (key, value) => {
+    if (next === props) next = { ...props };
+    next[key] = value;
   };
+  for (const key of Object.keys(props)) {
+    const value = props[key];
+    if (key === "children") {
+      if (value !== void 0 && value !== null) {
+        const children = resolveComponents(value, depth + 1);
+        if (children !== value) set(key, children);
+      }
+    } else if (typeof value === "function" && key !== "key") {
+      if (key === "text" || key === "html") {
+        set(key, value());
+      } else if (!key.startsWith("on")) {
+        try {
+          set(key, value());
+        } catch {
+        }
+      }
+    }
+  }
+  return next;
 }
 function restoreContext(key) {
-  if (!contextStacks.has(key)) return;
-  const stack = contextStacks.get(key);
-  const previousValue = stack.pop();
-  if (stack.length === 0) {
-    if (previousValue === void 0) {
-      globalState.delete(key);
-    } else {
-      globalState.set(key, previousValue);
-    }
-    contextStacks.delete(key);
+  const scope = currentScope();
+  const entry = scope.get(key);
+  if (!entry) return;
+  const next = new Map(scope);
+  if (entry.previous) {
+    next.set(key, entry.previous);
   } else {
-    globalState.set(key, previousValue);
+    next.delete(key);
   }
+  setScope(next);
 }
 function clearAllContexts() {
-  for (const [key, stack] of contextStacks) {
-    const beforeFirstProvide = stack[0];
-    if (beforeFirstProvide === void 0) {
-      globalState.delete(key);
-    } else {
-      globalState.set(key, beforeFirstProvide);
-    }
+  if (currentScope().size > 0) {
+    setScope(EMPTY_SCOPE);
   }
-  contextStacks.clear();
 }
 function useContext(key) {
-  return globalState.get(key);
+  const entry = currentScope().get(key);
+  return entry ? entry.value : globalState.get(key);
 }
 
 // src/state-persistence.js
-var LocalStorageAdapter = class {
-  constructor() {
-    this.available = typeof localStorage !== "undefined";
+var WebStorageAdapter = class {
+  constructor(storageName) {
+    this.storageName = storageName;
+    this.available = typeof globalThis[storageName] !== "undefined" && globalThis[storageName] !== null;
+  }
+  get storage() {
+    return globalThis[this.storageName];
   }
   async get(key) {
     if (!this.available) return null;
-    try {
-      return localStorage.getItem(key);
-    } catch (error) {
-      console.error("LocalStorage get error:", error);
-      return null;
-    }
+    return this.storage.getItem(key);
   }
   async set(key, value) {
     if (!this.available) return false;
-    try {
-      localStorage.setItem(key, value);
-      return true;
-    } catch (error) {
-      console.error("LocalStorage set error:", error);
-      return false;
-    }
+    this.storage.setItem(key, value);
+    return true;
   }
   async remove(key) {
     if (!this.available) return false;
-    try {
-      localStorage.removeItem(key);
-      return true;
-    } catch (error) {
-      console.error("LocalStorage remove error:", error);
-      return false;
-    }
+    this.storage.removeItem(key);
+    return true;
   }
   async clear() {
     if (!this.available) return false;
-    try {
-      localStorage.clear();
-      return true;
-    } catch (error) {
-      console.error("LocalStorage clear error:", error);
-      return false;
-    }
+    this.storage.clear();
+    return true;
   }
 };
-var SessionStorageAdapter = class {
+var LocalStorageAdapter = class extends WebStorageAdapter {
   constructor() {
-    this.available = typeof sessionStorage !== "undefined";
-  }
-  async get(key) {
-    if (!this.available) return null;
-    try {
-      return sessionStorage.getItem(key);
-    } catch (error) {
-      console.error("SessionStorage get error:", error);
-      return null;
-    }
-  }
-  async set(key, value) {
-    if (!this.available) return false;
-    try {
-      sessionStorage.setItem(key, value);
-      return true;
-    } catch (error) {
-      console.error("SessionStorage set error:", error);
-      return false;
-    }
-  }
-  async remove(key) {
-    if (!this.available) return false;
-    try {
-      sessionStorage.removeItem(key);
-      return true;
-    } catch (error) {
-      console.error("SessionStorage remove error:", error);
-      return false;
-    }
+    super("localStorage");
   }
-  async clear() {
-    if (!this.available) return false;
-    try {
-      sessionStorage.clear();
-      return true;
-    } catch (error) {
-      console.error("SessionStorage clear error:", error);
-      return false;
-    }
+};
+var SessionStorageAdapter = class extends WebStorageAdapter {
+  constructor() {
+    super("sessionStorage");
   }
 };
 var IndexedDBAdapter = class {
@@ -694,19 +1102,21 @@ var IndexedDBAdapter = class {
     this.storeName = storeName;
     this.available = typeof indexedDB !== "undefined";
     this.db = null;
+    this.opening = null;
   }
-  async init() {
-    if (!this.available) return false;
-    if (this.db) return true;
+  /**
+   * Open the database, creating the store in an upgrade. Without `version`,
+   * opens the current version (creating version 1 for a new database).
+   */
+  open(version) {
     return new Promise((resolve, reject) => {
-      const request = indexedDB.open(this.dbName, 1);
+      const request = version === void 0 ? indexedDB.open(this.dbName) : indexedDB.open(this.dbName, version);
       request.onerror = () => {
         console.error("IndexedDB open error:", request.error);
         reject(request.error);
       };
       request.onsuccess = () => {
-        this.db = request.result;
-        resolve(true);
+        resolve(request.result);
       };
       request.onupgradeneeded = (event) => {
         const db = event.target.result;
@@ -716,6 +1126,27 @@ var IndexedDBAdapter = class {
       };
     });
   }
+  async init() {
+    if (!this.available) return false;
+    if (this.db) return true;
+    this.opening ??= (async () => {
+      let db = await this.open();
+      if (!db.objectStoreNames.contains(this.storeName)) {
+        const version = db.version + 1;
+        db.close();
+        db = await this.open(version);
+      }
+      db.onversionchange = () => {
+        db.close();
+        if (this.db === db) this.db = null;
+      };
+      this.db = db;
+      return true;
+    })().finally(() => {
+      this.opening = null;
+    });
+    return this.opening;
+  }
   async get(key) {
     if (!this.available) return null;
     await this.init();
@@ -801,47 +1232,85 @@ var MemoryAdapter = class {
     return true;
   }
 };
-var SimpleEncryption = class {
-  constructor(key) {
-    this.key = key || "default-key";
+var ServerAdapter = class {
+  constructor() {
+    this.available = false;
+  }
+  async get() {
+    return null;
   }
-  encrypt(text) {
-    let result = "";
-    for (let i = 0; i < text.length; i++) {
-      result += String.fromCharCode(
-        text.charCodeAt(i) ^ this.key.charCodeAt(i % this.key.length)
+  async set() {
+    return false;
+  }
+  async remove() {
+    return false;
+  }
+  async clear() {
+    return false;
+  }
+};
+function toBase64(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i += 32768) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + 32768));
+  }
+  return btoa(binary);
+}
+function fromBase64(encoded) {
+  const binary = atob(encoded);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+var XorObfuscation = class {
+  constructor(key) {
+    if (typeof key !== "string" || key.length === 0) {
+      throw new TypeError(
+        "createPersistentState: `encrypt: true` requires a non-empty `encryptionKey`. It is XOR obfuscation, not encryption; there is no default key."
       );
     }
-    return btoa(result);
+    this.keyBytes = new globalThis.TextEncoder().encode(key);
   }
-  decrypt(encrypted) {
-    const text = atob(encrypted);
-    let result = "";
-    for (let i = 0; i < text.length; i++) {
-      result += String.fromCharCode(
-        text.charCodeAt(i) ^ this.key.charCodeAt(i % this.key.length)
-      );
+  xor(bytes) {
+    for (let i = 0; i < bytes.length; i++) {
+      bytes[i] ^= this.keyBytes[i % this.keyBytes.length];
     }
-    return result;
+    return bytes;
+  }
+  encode(text) {
+    return toBase64(this.xor(new globalThis.TextEncoder().encode(text)));
+  }
+  decode(encoded) {
+    return new globalThis.TextDecoder().decode(this.xor(fromBase64(encoded)));
   }
 };
-function createStorageAdapter(type) {
+function createStorageAdapter(type, options = {}) {
   switch (type) {
     case "localStorage":
       return new LocalStorageAdapter();
     case "sessionStorage":
       return new SessionStorageAdapter();
     case "indexedDB":
-      return new IndexedDBAdapter();
+      return new IndexedDBAdapter(options.dbName ?? void 0, options.storeName ?? void 0);
     case "memory":
       return new MemoryAdapter();
     default:
       return new LocalStorageAdapter();
   }
 }
+function createInstanceId() {
+  const cryptoApi = globalThis.crypto;
+  if (cryptoApi && typeof cryptoApi.randomUUID === "function") {
+    return cryptoApi.randomUUID();
+  }
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
 function createPersistentState(initialState = {}, options = {}) {
   const opts = {
     storage: "localStorage",
+    adapter: null,
     key: "coherent-state",
     debounce: true,
     debounceDelay: 300,
@@ -861,11 +1330,30 @@ function createPersistentState(initialState = {}, options = {}) {
     crossTab: false,
     ...options
   };
-  const adapter = createStorageAdapter(opts.storage);
-  const encryption = opts.encrypt ? new SimpleEncryption(opts.encryptionKey) : null;
+  const onServer = typeof window === "undefined";
+  const obfuscation = opts.encrypt ? new XorObfuscation(opts.encryptionKey) : null;
+  let adapter;
+  if (opts.adapter) {
+    adapter = opts.adapter;
+  } else if (onServer && opts.storage !== "memory") {
+    adapter = new ServerAdapter();
+  } else {
+    adapter = createStorageAdapter(opts.storage, opts);
+  }
+  const instanceId = createInstanceId();
   let state = { ...initialState };
   let saveTimeout = null;
+  let destroyed = false;
   const listeners = /* @__PURE__ */ new Set();
+  let initialRestorePending = false;
+  const touchedKeys = /* @__PURE__ */ new Set();
+  function reportError2(error) {
+    if (opts.onError) {
+      opts.onError(error);
+    } else {
+      console.error("State persistence error:", error);
+    }
+  }
   function filterKeys(obj) {
     if (!obj || typeof obj !== "object") return obj;
     if (opts.include && Array.isArray(opts.include)) {
@@ -886,11 +1374,31 @@ function createPersistentState(initialState = {}, options = {}) {
     }
     return obj;
   }
-  async function save(immediate = false) {
-    if (opts.debounce && !immediate) {
-      clearTimeout(saveTimeout);
-      saveTimeout = setTimeout(() => save(true), opts.debounceDelay);
-      return;
+  let channel = null;
+  if (opts.crossTab && !onServer && typeof BroadcastChannel !== "undefined") {
+    channel = new BroadcastChannel(`coherent-state-sync:${opts.key}`);
+    channel.onmessage = (event) => {
+      const message = event.data;
+      if (destroyed || !message || message.type !== "state-update" || message.source === instanceId) {
+        return;
+      }
+      const oldState = { ...state };
+      state = { ...state, ...message.state };
+      notifyListeners(oldState, state);
+    };
+    channel.unref?.();
+  }
+  function broadcast(filteredState) {
+    if (!channel) return;
+    try {
+      channel.postMessage({ type: "state-update", source: instanceId, state: filteredState });
+    } catch (error) {
+      reportError2(error);
+    }
+  }
+  async function write() {
+    if (adapter.available === false) {
+      return false;
     }
     try {
       const filteredState = filterKeys(state);
@@ -902,31 +1410,45 @@ function createPersistentState(initialState = {}, options = {}) {
         ttl: opts.ttl
       };
       let dataString = JSON.stringify(data);
-      if (encryption) {
-        dataString = encryption.encrypt(dataString);
+      if (obfuscation) {
+        dataString = obfuscation.encode(dataString);
+      }
+      const stored = await adapter.set(opts.key, dataString);
+      if (stored === false) {
+        throw new Error(`State "${opts.key}" could not be written to storage`);
       }
-      await adapter.set(opts.key, dataString);
       if (opts.onSave) {
         opts.onSave(filteredState);
       }
-      if (opts.crossTab && typeof BroadcastChannel !== "undefined") {
-        const channel = new BroadcastChannel("coherent-state-sync");
-        channel.postMessage({ type: "state-update", state: filteredState });
-        channel.close();
-      }
+      broadcast(filteredState);
+      return true;
     } catch (error) {
-      console.error("State save error:", error);
-      if (opts.onError) {
-        opts.onError(error);
-      }
+      reportError2(error);
+      return false;
     }
   }
+  function save(immediate = false) {
+    if (destroyed) {
+      return Promise.resolve(false);
+    }
+    if (opts.debounce && !immediate) {
+      clearTimeout(saveTimeout);
+      saveTimeout = setTimeout(() => {
+        saveTimeout = null;
+        write();
+      }, opts.debounceDelay);
+      return void 0;
+    }
+    clearTimeout(saveTimeout);
+    saveTimeout = null;
+    return write();
+  }
   async function load() {
     try {
       let dataString = await adapter.get(opts.key);
       if (!dataString) return null;
-      if (encryption) {
-        dataString = encryption.decrypt(dataString);
+      if (obfuscation) {
+        dataString = obfuscation.decode(dataString);
       }
       const data = JSON.parse(dataString);
       if (data.ttl && data.timestamp) {
@@ -949,10 +1471,7 @@ function createPersistentState(initialState = {}, options = {}) {
       }
       return loadedState;
     } catch (error) {
-      console.error("State load error:", error);
-      if (opts.onError) {
-        opts.onError(error);
-      }
+      reportError2(error);
       return null;
     }
   }
@@ -969,6 +1488,20 @@ function createPersistentState(initialState = {}, options = {}) {
       }
     });
   }
+  function applyLoaded(loaded, skipTouched) {
+    if (!loaded || typeof loaded !== "object") {
+      return false;
+    }
+    const updates = Object.fromEntries(
+      Object.entries(loaded).filter(([key]) => !skipTouched || !touchedKeys.has(key))
+    );
+    if (Object.keys(updates).length > 0) {
+      const oldState = { ...state };
+      state = { ...state, ...updates };
+      notifyListeners(oldState, state);
+    }
+    return true;
+  }
   function getState(key) {
     return key ? state[key] : { ...state };
   }
@@ -977,6 +1510,9 @@ function createPersistentState(initialState = {}, options = {}) {
     if (typeof updates === "function") {
       updates = updates(oldState);
     }
+    if (initialRestorePending && updates && typeof updates === "object") {
+      for (const key of Object.keys(updates)) touchedKeys.add(key);
+    }
     state = { ...state, ...updates };
     notifyListeners(oldState, state);
     if (persist2) {
@@ -985,6 +1521,10 @@ function createPersistentState(initialState = {}, options = {}) {
   }
   function resetState(persist2 = true) {
     const oldState = { ...state };
+    if (initialRestorePending) {
+      for (const key of Object.keys(oldState)) touchedKeys.add(key);
+      for (const key of Object.keys(initialState)) touchedKeys.add(key);
+    }
     state = { ...initialState };
     notifyListeners(oldState, state);
     if (persist2) {
@@ -992,33 +1532,44 @@ function createPersistentState(initialState = {}, options = {}) {
     }
   }
   async function clearStorage() {
-    await adapter.remove(opts.key);
+    try {
+      await adapter.remove(opts.key);
+    } catch (error) {
+      reportError2(error);
+    }
   }
   async function persist() {
-    await save(true);
+    return save(true);
   }
   async function restore() {
-    const loaded = await load();
-    if (loaded) {
-      const oldState = { ...state };
-      state = { ...state, ...loaded };
-      notifyListeners(oldState, state);
-      return true;
-    }
-    return false;
-  }
-  if (opts.crossTab && typeof BroadcastChannel !== "undefined") {
-    const channel = new BroadcastChannel("coherent-state-sync");
-    channel.onmessage = (event) => {
-      if (event.data.type === "state-update") {
-        const oldState = { ...state };
-        state = { ...state, ...event.data.state };
-        notifyListeners(oldState, state);
-      }
-    };
-  }
-  if (opts.storage !== "memory") {
-    restore();
+    return applyLoaded(await load(), false);
+  }
+  async function destroy() {
+    if (destroyed) return;
+    const pending = saveTimeout !== null;
+    clearTimeout(saveTimeout);
+    saveTimeout = null;
+    if (pending) {
+      await write();
+    }
+    destroyed = true;
+    channel?.close();
+    channel = null;
+    listeners.clear();
+  }
+  let ready;
+  if (opts.storage !== "memory" || opts.adapter) {
+    initialRestorePending = true;
+    ready = load().then((loaded) => {
+      initialRestorePending = false;
+      if (destroyed) return false;
+      const restored = applyLoaded(loaded, true);
+      if (restored && touchedKeys.size > 0) save();
+      touchedKeys.clear();
+      return restored;
+    });
+  } else {
+    ready = Promise.resolve(false);
   }
   return {
     getState,
@@ -1030,6 +1581,9 @@ function createPersistentState(initialState = {}, options = {}) {
     clearStorage,
     load,
     save: () => save(true),
+    destroy,
+    /** Settles once the automatic restore on creation is done */
+    ready,
     get adapter() {
       return adapter;
     }
@@ -1063,6 +1617,61 @@ var EMAIL_MAX_LENGTH = 254;
 function isEmailShaped(value) {
   return typeof value === "string" && value.length <= EMAIL_MAX_LENGTH && EMAIL_PATTERN.test(value);
 }
+function matchesType(value, type) {
+  switch (type) {
+    case "array":
+      return Array.isArray(value);
+    case "null":
+      return value === null;
+    case "object":
+      return value !== null && typeof value === "object" && !Array.isArray(value);
+    case "integer":
+      return typeof value === "number" && Number.isInteger(value);
+    case "number":
+      return typeof value === "number" && !Number.isNaN(value);
+    default:
+      return typeof value === type;
+  }
+}
+function describeValue(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  if (typeof value === "string") return JSON.stringify(value);
+  return typeof value === "object" ? "object" : String(value);
+}
+function coerceTo(value, type) {
+  switch (type) {
+    case "string":
+      if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+        return { ok: !Number.isNaN(value), value: String(value) };
+      }
+      return { ok: false };
+    case "number":
+    case "integer": {
+      let number;
+      if (typeof value === "string" && value.trim() !== "") {
+        number = Number(value);
+      } else if (typeof value === "boolean") {
+        number = value ? 1 : 0;
+      } else {
+        return { ok: false };
+      }
+      const valid = type === "integer" ? Number.isInteger(number) : !Number.isNaN(number);
+      return valid ? { ok: true, value: number } : { ok: false };
+    }
+    case "boolean":
+      if (typeof value === "string") {
+        const normalized = value.trim().toLowerCase();
+        if (normalized === "true" || normalized === "1") return { ok: true, value: true };
+        if (normalized === "false" || normalized === "0" || normalized === "") return { ok: true, value: false };
+        return { ok: false };
+      }
+      if (value === 1 || value === 0) return { ok: true, value: value === 1 };
+      return { ok: false };
+    default:
+      return { ok: false };
+  }
+}
 var SchemaValidator = class {
   constructor(schema, options = {}) {
     this.schema = schema;
@@ -1085,10 +1694,7 @@ var SchemaValidator = class {
     if (schema.type) {
       const typeResult = this.validateType(value, schema.type, path);
       if (!typeResult.valid) {
-        errors.push(...typeResult.errors);
-        if (!this.options.coerce) {
-          return { valid: false, errors, value };
-        }
+        return { valid: false, errors: typeResult.errors, value };
       }
       coercedValue = typeResult.value;
     }
@@ -1146,47 +1752,17 @@ var SchemaValidator = class {
     const errors = [];
     let coercedValue = value;
     const types = Array.isArray(type) ? type : [type];
-    const isValid = types.some((t) => {
-      if (t === "array") return Array.isArray(value);
-      if (t === "null") return value === null;
-      if (t === "integer") return typeof value === "number" && Number.isInteger(value);
-      return typeof value === t;
-    });
+    const isValid = types.some((t) => matchesType(value, t));
     if (!isValid) {
       if (this.options.coerce) {
         const primaryType = types[0];
-        try {
-          if (primaryType === "string") {
-            coercedValue = String(value);
-          } else if (primaryType === "number") {
-            coercedValue = Number(value);
-            if (isNaN(coercedValue)) {
-              errors.push({
-                path,
-                message: `Cannot coerce "${value}" to number`,
-                type: "type",
-                value,
-                expected: primaryType
-              });
-            }
-          } else if (primaryType === "boolean") {
-            coercedValue = Boolean(value);
-          } else if (primaryType === "integer") {
-            coercedValue = parseInt(value, 10);
-            if (isNaN(coercedValue)) {
-              errors.push({
-                path,
-                message: `Cannot coerce "${value}" to integer`,
-                type: "type",
-                value,
-                expected: primaryType
-              });
-            }
-          }
-        } catch {
+        const coerced = coerceTo(value, primaryType);
+        if (coerced.ok) {
+          coercedValue = coerced.value;
+        } else {
           errors.push({
             path,
-            message: `Cannot coerce value to ${primaryType}`,
+            message: `Cannot coerce ${describeValue(value)} to ${primaryType}`,
             type: "type",
             value,
             expected: primaryType
@@ -1407,7 +1983,7 @@ var SchemaValidator = class {
         }
       });
     }
-    if (schema.additionalProperties === false && !this.options.allowUnknown) {
+    if (schema.additionalProperties === false || !this.options.allowUnknown && schema.properties) {
       const allowedProps = new Set(Object.keys(schema.properties || {}));
       Object.keys(value).forEach((prop) => {
         if (!allowedProps.has(prop)) {
@@ -1889,7 +2465,16 @@ var ModalState = class {
     this._currentId = 0;
   }
   // OOP methods for modal control
+  /**
+   * Open the modal with `data`. Resolves with the value passed to close().
+   * Opening again while open replaces the modal: the earlier promise
+   * resolves with `null`, as if it had been closed without a result.
+   */
   async open(data) {
+    for (const [id, resolver] of this._resolvers) {
+      resolver(null);
+      this._resolvers.delete(id);
+    }
     return new Promise((resolve) => {
       const id = ++this._currentId;
       this._resolvers.set(id, resolve);
@@ -1991,6 +2576,7 @@ var index_default = {
   createReactiveState,
   observable,
   computed,
+  batch,
   // SSR-compatible state management
   createState,
   globalStateManager,
@@ -1999,6 +2585,7 @@ var index_default = {
   restoreContext,
   clearAllContexts,
   useContext,
+  runWithContext,
   // Persistence utilities
   createPersistentState,
   withLocalStorage,
@@ -2023,6 +2610,7 @@ export {
   ReactiveState,
   RouterState,
   StateError,
+  batch,
   clearAllContexts,
   computed,
   createContextProvider,
@@ -2040,6 +2628,7 @@ export {
   observable,
   provideContext,
   restoreContext,
+  runWithContext,
   stateUtils,
   useContext,
   validators,