@getforma/core 1.0.10 → 1.2.0

package/dist/formajs.global.js

@@ -348,6 +348,9 @@ var FormaJS = (() => {
       }
     }
   });
+  function getActiveSub() {
+    return activeSub;
+  }
   function setActiveSub(sub) {
     const prevSub = activeSub;
     activeSub = sub;
@@ -593,16 +596,50 @@ var FormaJS = (() => {
     }
   }
 
+  // src/reactive/dev.ts
+  function isDev() {
+    if (typeof process !== "undefined") {
+      return process.env?.NODE_ENV !== "production";
+    }
+    return typeof __FORMA_DEV__ !== "undefined" ? !!__FORMA_DEV__ : false;
+  }
+  var __DEV__ = isDev();
+  var _errorHandlers = /* @__PURE__ */ new Set();
+  function onError(handler) {
+    _errorHandlers.add(handler);
+    return () => {
+      _errorHandlers.delete(handler);
+    };
+  }
+  function reportError(error, source) {
+    for (const handler of _errorHandlers) {
+      try {
+        handler(error, source ? { source } : {});
+      } catch {
+      }
+    }
+    if (isDev()) {
+      console.error(`[forma] ${source ?? "Unknown"} error:`, error);
+    }
+  }
+
   // src/reactive/signal.ts
+  var signalNames = /* @__PURE__ */ new WeakMap();
+  function value(v) {
+    return () => v;
+  }
   function applySignalSet(s, v, equals) {
     if (typeof v !== "function") {
-      if (equals) {
-        const prevSub2 = setActiveSub(void 0);
-        const prev2 = s();
-        setActiveSub(prevSub2);
-        if (equals(prev2, v)) return;
+      if (!equals) {
+        s(v);
+        return;
       }
+      const prevSub2 = setActiveSub(void 0);
+      const prev2 = s();
+      setActiveSub(prevSub2);
+      if (equals(prev2, v)) return;
       s(v);
+      if (Object.is(prev2, v)) forceNotify(s);
       return;
     }
     const prevSub = setActiveSub(void 0);
@@ -611,10 +648,19 @@ var FormaJS = (() => {
     const next = v(prev);
     if (equals && equals(prev, next)) return;
     s(next);
+    if (equals && Object.is(prev, next)) forceNotify(s);
+  }
+  function forceNotify(s) {
+    trigger(() => {
+      s();
+    });
   }
   function createSignal(initialValue, options) {
     const s = signal(initialValue);
     const getter = s;
+    if (__DEV__ && options?.name) {
+      signalNames.set(getter, options.name);
+    }
     const eq = options?.equals;
     const setter = (v) => applySignalSet(s, v, eq);
     return [getter, setter];
@@ -623,29 +669,73 @@ var FormaJS = (() => {
   // src/reactive/root.ts
   var currentRoot = null;
   var rootStack = [];
+  var currentOwner = null;
+  function getOwner() {
+    return currentOwner;
+  }
+  function runWithOwner(owner, fn) {
+    const prev = currentOwner;
+    currentOwner = owner;
+    try {
+      return fn();
+    } finally {
+      currentOwner = prev;
+    }
+  }
+  function registerOwnerDisposer(owner, dispose) {
+    owner.disposers.push(dispose);
+  }
+  function createChildOwner() {
+    return { disposers: [] };
+  }
+  function disposeOwner(owner) {
+    const ds = owner.disposers;
+    for (const d of ds) {
+      try {
+        d();
+      } catch {
+      }
+    }
+    ds.length = 0;
+  }
   function createRootImpl(fn, owned) {
     const scope = { disposers: [], scopeDispose: null };
     const parentRoot = owned ? currentRoot : null;
     rootStack.push(currentRoot);
     currentRoot = scope;
+    const prevOwner = currentOwner;
+    currentOwner = scope;
     let disposed = false;
-    const dispose = () => {
-      if (disposed) return;
-      disposed = true;
-      if (scope.scopeDispose) {
+    let setupComplete = false;
+    let disposeRequestedDuringSetup = false;
+    const runDisposers = () => {
+      for (const d of scope.disposers) {
         try {
-          scope.scopeDispose();
+          d();
         } catch {
         }
-        scope.scopeDispose = null;
       }
-      for (const d of scope.disposers) {
+      scope.disposers.length = 0;
+    };
+    const runTeardown = () => {
+      if (scope.scopeDispose) {
         try {
-          d();
+          scope.scopeDispose();
         } catch {
         }
+        scope.scopeDispose = null;
       }
-      scope.disposers.length = 0;
+      runDisposers();
+    };
+    const dispose = () => {
+      if (disposed) return;
+      disposed = true;
+      if (!setupComplete) {
+        disposeRequestedDuringSetup = true;
+        runDisposers();
+        return;
+      }
+      runTeardown();
     };
     if (parentRoot) {
       parentRoot.disposers.push(dispose);
@@ -666,8 +756,13 @@ var FormaJS = (() => {
           setActiveSub(prevSub);
         }
       }
+      setupComplete = true;
+      if (disposeRequestedDuringSetup) {
+        runTeardown();
+      }
     } finally {
       currentRoot = rootStack.pop() ?? null;
+      currentOwner = prevOwner;
     }
     return result;
   }
@@ -678,12 +773,12 @@ var FormaJS = (() => {
     return createRootImpl(fn, false);
   }
   function registerDisposer(dispose) {
-    if (currentRoot) {
-      currentRoot.disposers.push(dispose);
+    if (currentOwner) {
+      currentOwner.disposers.push(dispose);
     }
   }
   function hasActiveRoot() {
-    return currentRoot !== null;
+    return currentOwner !== null;
   }
 
   // src/reactive/cleanup.ts
@@ -697,30 +792,13 @@ var FormaJS = (() => {
     return prev;
   }
 
-  // src/reactive/dev.ts
-  var __DEV__ = typeof process !== "undefined" ? process.env?.NODE_ENV !== "production" : true;
-  var _errorHandler = null;
-  function onError(handler) {
-    _errorHandler = handler;
-  }
-  function reportError(error, source) {
-    if (_errorHandler) {
-      try {
-        _errorHandler(error, source ? { source } : {});
-      } catch {
-      }
-    }
-    if (__DEV__) {
-      console.error(`[forma] ${source ?? "Unknown"} error:`, error);
-    }
-  }
-
   // src/reactive/effect.ts
   var POOL_SIZE = 32;
   var MAX_REENTRANT_RUNS = 100;
   var pool = [];
   for (let i = 0; i < POOL_SIZE; i++) pool.push([]);
   var poolIdx = POOL_SIZE;
+  var PENDING = 32;
   function acquireArray() {
     if (poolIdx > 0) {
       const arr = pool[--poolIdx];
@@ -761,7 +839,8 @@ var FormaJS = (() => {
     return dispose;
   }
   function createEffect(fn) {
-    const shouldRegister = hasActiveRoot();
+    const ownerAtCreate = getOwner();
+    const childOwner = createChildOwner();
     let cleanup2;
     let cleanupBag;
     let nextCleanup;
@@ -780,11 +859,8 @@ var FormaJS = (() => {
       }
       nextCleanup = cb;
     };
-    let skipCleanupInfra = false;
-    let firstRun = true;
-    let running = false;
-    let rerunRequested = false;
     const runOnce = () => {
+      disposeOwner(childOwner);
       if (cleanup2 !== void 0) {
         runCleanup(cleanup2);
         cleanup2 = void 0;
@@ -794,68 +870,46 @@ var FormaJS = (() => {
         releaseArray(cleanupBag);
         cleanupBag = void 0;
       }
-      if (skipCleanupInfra) {
-        try {
-          fn();
-        } catch (e) {
-          reportError(e, "effect");
-        }
-        return;
-      }
       nextCleanup = void 0;
       nextCleanupBag = void 0;
       const prevCollector = setCleanupCollector(addCleanup);
       try {
-        const result = fn();
+        const result = runWithOwner(childOwner, fn);
         if (typeof result === "function") {
           addCleanup(result);
         }
-        if (nextCleanup === void 0 && nextCleanupBag === void 0) {
-          if (firstRun) skipCleanupInfra = true;
-          return;
-        }
         if (nextCleanupBag !== void 0) {
           cleanupBag = nextCleanupBag;
-        } else {
+        } else if (nextCleanup !== void 0) {
           cleanup2 = nextCleanup;
         }
       } catch (e) {
         reportError(e, "effect");
         if (nextCleanupBag !== void 0) {
           cleanupBag = nextCleanupBag;
-        } else {
+        } else if (nextCleanup !== void 0) {
           cleanup2 = nextCleanup;
         }
       } finally {
         setCleanupCollector(prevCollector);
-        firstRun = false;
       }
     };
     const safeFn = () => {
-      if (running) {
-        rerunRequested = true;
-        return;
-      }
-      running = true;
-      try {
-        let reentrantRuns = 0;
-        do {
-          rerunRequested = false;
-          runOnce();
-          if (rerunRequested) {
-            reentrantRuns++;
-            if (reentrantRuns >= MAX_REENTRANT_RUNS) {
-              reportError(
-                new Error(`createEffect exceeded ${MAX_REENTRANT_RUNS} re-entrant runs`),
-                "effect"
-              );
-              rerunRequested = false;
-            }
-          }
-        } while (rerunRequested);
-      } finally {
-        running = false;
-      }
+      const node = getActiveSub();
+      let reentrantRuns = 0;
+      do {
+        if (node) node.flags &= ~PENDING;
+        runOnce();
+        if (node === void 0 || (node.flags & PENDING) === 0) break;
+        if (++reentrantRuns >= MAX_REENTRANT_RUNS) {
+          node.flags &= ~PENDING;
+          reportError(
+            new Error(`createEffect exceeded ${MAX_REENTRANT_RUNS} self-triggered re-runs (cycle?)`),
+            "effect"
+          );
+          break;
+        }
+      } while (true);
     };
     const dispose = effect(safeFn);
     let disposed = false;
@@ -863,6 +917,7 @@ var FormaJS = (() => {
       if (disposed) return;
       disposed = true;
       dispose();
+      disposeOwner(childOwner);
       if (cleanup2 !== void 0) {
         runCleanup(cleanup2);
         cleanup2 = void 0;
@@ -873,15 +928,42 @@ var FormaJS = (() => {
         cleanupBag = void 0;
       }
     };
-    if (shouldRegister) {
-      registerDisposer(wrappedDispose);
+    if (ownerAtCreate) {
+      registerOwnerDisposer(ownerAtCreate, wrappedDispose);
     }
     return wrappedDispose;
   }
 
   // src/reactive/computed.ts
+  var ERR = /* @__PURE__ */ Symbol("formaComputedError");
+  function isErrBox(v) {
+    return typeof v === "object" && v !== null && ERR in v;
+  }
   function createComputed(fn) {
-    return computed(fn);
+    let errored = false;
+    let error;
+    let lastGood;
+    const raw = computed(() => {
+      try {
+        const v = fn(lastGood);
+        errored = false;
+        error = void 0;
+        lastGood = v;
+        return v;
+      } catch (e) {
+        errored = true;
+        error = e;
+        reportError(e, "computed");
+        return { [ERR]: e };
+      }
+    });
+    const reader = () => {
+      const v = raw();
+      if (errored || isErrBox(v)) throw error;
+      return v;
+    };
+    Object.defineProperty(reader, "name", { value: raw.name, configurable: true });
+    return reader;
   }
 
   // src/reactive/memo.ts
@@ -974,25 +1056,34 @@ var FormaJS = (() => {
         suspenseCtx.increment();
         suspensePending = true;
       }
-      setLoading(true);
-      setError(void 0);
-      Promise.resolve(fetcher(sourceValue)).then((result) => {
+      batch(() => {
+        setLoading(true);
+        setError(void 0);
+      });
+      let promise;
+      try {
+        promise = Promise.resolve(fetcher(sourceValue, { signal: controller.signal }));
+      } catch (err) {
+        promise = Promise.reject(err);
+      }
+      promise.then((result) => {
         if (isLatest() && !controller.signal.aborted) {
-          setData(() => result);
+          batch(() => {
+            setData(() => result);
+            setLoading(false);
+          });
         }
       }).catch((err) => {
-        if (isLatest() && !controller.signal.aborted) {
-          if (err?.name !== "AbortError") {
+        if (isLatest() && !controller.signal.aborted && err?.name !== "AbortError") {
+          batch(() => {
             setError(err);
-          }
+            setLoading(false);
+          });
         }
       }).finally(() => {
         if (suspensePending) suspenseCtx?.decrement();
-        if (isLatest()) {
-          setLoading(false);
-          if (abortController === controller) {
-            abortController = null;
-          }
+        if (isLatest() && abortController === controller) {
+          abortController = null;
         }
       });
     };
@@ -1000,6 +1091,15 @@ var FormaJS = (() => {
       source();
       doFetch();
     });
+    if (hasActiveRoot()) {
+      registerDisposer(() => {
+        fetchVersion++;
+        if (abortController) {
+          abortController.abort();
+          abortController = null;
+        }
+      });
+    }
     const resource = (() => data());
     resource.loading = loading;
     resource.error = error;
@@ -3059,6 +3159,19 @@ var FormaJS = (() => {
   function createStore(initial) {
     const signals = /* @__PURE__ */ new Map();
     const children2 = /* @__PURE__ */ new Map();
+    const arrayVersions = /* @__PURE__ */ new Map();
+    function getArrayVersion(path) {
+      let p = arrayVersions.get(path);
+      if (!p) {
+        p = createSignal(0);
+        arrayVersions.set(path, p);
+      }
+      return p;
+    }
+    function bumpArrayVersion(path) {
+      const p = arrayVersions.get(path);
+      if (p) p[1]((n) => n + 1);
+    }
     function registerChild(path) {
       const lastDot = path.lastIndexOf(".");
       if (lastDot === -1) return;
@@ -3090,14 +3203,37 @@ var FormaJS = (() => {
       }
       childSet.clear();
     }
+    function lastSegment(path) {
+      const d = path.lastIndexOf(".");
+      return d === -1 ? path : path.substring(d + 1);
+    }
+    function setLiteral(pair, v) {
+      pair[1](typeof v === "function" ? value(v) : v);
+    }
+    function reconcileChildren(parentPath, rawParent) {
+      const set = children2.get(parentPath);
+      if (!set) return;
+      for (const childPath of set) {
+        const key = lastSegment(childPath);
+        const nv = rawParent[key];
+        const pair = signals.get(childPath);
+        if (pair) setLiteral(pair, nv);
+        if (nv != null && typeof nv === "object") {
+          reconcileChildren(childPath, nv);
+        } else {
+          invalidateChildren(childPath);
+        }
+      }
+    }
     function wrap(raw, basePath) {
       if (!shouldWrap(raw)) return raw;
-      const cached = proxyCache.get(raw);
-      if (cached) return cached;
+      let byPath = proxyCache.get(raw);
+      if (byPath) {
+        const hit = byPath.get(basePath);
+        if (hit) return hit;
+      }
       const isArr = Array.isArray(raw);
       const basePrefix = basePath ? basePath + "." : "";
-      let lastKey = "";
-      let lastSignal;
       const proxy = new Proxy(raw, {
         // -------------------------------------------------------------------
         // GET
@@ -3118,12 +3254,10 @@ var FormaJS = (() => {
                   (a) => a != null && typeof a === "object" && a[RAW] ? a[RAW] : a
                 );
                 result = target[key].apply(target, rawArgs);
-                invalidateChildren(basePath);
-                const [, setLen] = getSignal(
-                  basePrefix + "length",
-                  target.length
-                );
-                setLen(target.length);
+                reconcileChildren(basePath, target);
+                const lenPair = signals.get(basePrefix + "length");
+                if (lenPair) lenPair[1](target.length);
+                if (basePath) bumpArrayVersion(basePath);
               });
               return result;
             };
@@ -3134,15 +3268,11 @@ var FormaJS = (() => {
             return target.length;
           }
           const value2 = Reflect.get(target, prop);
-          let pair;
-          if (key === lastKey && lastSignal) {
-            pair = lastSignal;
-          } else {
-            pair = getSignal(childPath, value2);
-            lastKey = key;
-            lastSignal = pair;
-          }
+          const pair = getSignal(childPath, value2);
           pair[0]();
+          if (Array.isArray(value2)) {
+            getArrayVersion(childPath)[0]();
+          }
           if (shouldWrap(value2)) {
             return wrap(value2, childPath);
           }
@@ -3158,9 +3288,11 @@ var FormaJS = (() => {
           const key = String(prop);
           const childPath = basePrefix + key;
           const rawValue = value2 != null && typeof value2 === "object" && value2[RAW] ? value2[RAW] : value2;
+          const oldRaw = Reflect.get(target, prop);
           Reflect.set(target, prop, rawValue);
-          if (rawValue != null && typeof rawValue === "object") {
+          if (rawValue != null && typeof rawValue === "object" && oldRaw !== rawValue) {
             invalidateChildren(childPath);
+            evictProxy(oldRaw, childPath);
           }
           if (isArr && key !== "length") {
             const lengthPath = basePrefix + "length";
@@ -3169,6 +3301,12 @@ var FormaJS = (() => {
               lenPair[1](target.length);
             }
           }
+          if (isArr && key === "length") {
+            batch(() => {
+              reconcileChildren(basePath, target);
+              if (basePath) bumpArrayVersion(basePath);
+            });
+          }
           const [, setter2] = getSignal(childPath, rawValue);
           setter2(rawValue);
           return true;
@@ -3207,24 +3345,30 @@ var FormaJS = (() => {
           }
           const key = String(prop);
           const childPath = basePrefix + key;
+          const oldRaw = Reflect.get(target, prop);
           const result = Reflect.deleteProperty(target, prop);
+          const delPair = signals.get(childPath);
+          if (delPair) delPair[1](void 0);
+          evictProxy(oldRaw, childPath);
           invalidateChildren(childPath);
-          signals.delete(childPath);
-          const parentPath = basePath;
-          if (parentPath !== void 0) {
-            const parentSet = children2.get(parentPath);
-            if (parentSet) {
-              parentSet.delete(childPath);
-              if (parentSet.size === 0) children2.delete(parentPath);
-            }
-          }
-          children2.delete(childPath);
           return result;
         }
       });
-      proxyCache.set(raw, proxy);
+      if (!byPath) {
+        byPath = /* @__PURE__ */ new Map();
+        proxyCache.set(raw, byPath);
+      }
+      byPath.set(basePath, proxy);
       return proxy;
     }
+    function evictProxy(oldRaw, path) {
+      if (oldRaw == null || typeof oldRaw !== "object") return;
+      const om = proxyCache.get(oldRaw);
+      if (om) {
+        om.delete(path);
+        if (om.size === 0) proxyCache.delete(oldRaw);
+      }
+    }
     const rootProxy = wrap(initial, "");
     function getCurrentSnapshot() {
       return untrack(() => deepClone(initial));
@@ -3241,10 +3385,24 @@ var FormaJS = (() => {
   }
 
   // src/state/history.ts
+  function cloneEntry(v, seen) {
+    if (v === null || typeof v !== "object") return v;
+    const proto = Object.getPrototypeOf(v);
+    if (!Array.isArray(v) && proto !== Object.prototype && proto !== null) return v;
+    if (!seen) seen = /* @__PURE__ */ new WeakSet();
+    if (seen.has(v)) return v;
+    seen.add(v);
+    if (Array.isArray(v)) return v.map((i) => cloneEntry(i, seen));
+    const out = {};
+    for (const k of Object.keys(v)) {
+      out[k] = cloneEntry(v[k], seen);
+    }
+    return out;
+  }
   function createHistory(source, options) {
     const [sourceGet, sourceSet] = source;
-    const maxLength = options?.maxLength ?? 100;
-    let _stack = [sourceGet()];
+    const maxLength = Math.max(1, options?.maxLength ?? 100);
+    let _stack = [cloneEntry(sourceGet())];
     let _cursor = 0;
     const [stackSignal, setStackSignal] = createSignal([..._stack]);
     const [cursorSignal, setCursorSignal] = createSignal(_cursor);
@@ -3256,45 +3414,52 @@ var FormaJS = (() => {
         setStackLenSignal(_stack.length);
       });
     }
-    let ignoreNext = false;
+    const NONE = /* @__PURE__ */ Symbol("none");
+    let _expected = NONE;
     let isFirstRun = true;
-    internalEffect(() => {
+    const disposeEffect = internalEffect(() => {
       const value2 = sourceGet();
       if (isFirstRun) {
         isFirstRun = false;
         return;
       }
-      if (ignoreNext) {
-        ignoreNext = false;
+      if (_expected !== NONE && Object.is(value2, _expected)) {
+        _expected = NONE;
         return;
       }
+      _expected = NONE;
       _stack = _stack.slice(0, _cursor + 1);
-      _stack.push(value2);
+      _stack.push(cloneEntry(value2));
       if (_stack.length > maxLength) {
         _stack.splice(0, _stack.length - maxLength);
       }
       _cursor = _stack.length - 1;
       syncSignals();
     });
+    const destroy = () => {
+      disposeEffect();
+    };
     const canUndo = () => cursorSignal() > 0;
     const canRedo = () => cursorSignal() < stackLenSignal() - 1;
     const undo = () => {
       if (_cursor <= 0) return;
       _cursor--;
-      ignoreNext = true;
-      sourceSet(_stack[_cursor]);
+      const restored = cloneEntry(_stack[_cursor]);
+      _expected = restored;
+      sourceSet(restored);
       syncSignals();
     };
     const redo = () => {
       if (_cursor >= _stack.length - 1) return;
       _cursor++;
-      ignoreNext = true;
-      sourceSet(_stack[_cursor]);
+      const restored = cloneEntry(_stack[_cursor]);
+      _expected = restored;
+      sourceSet(restored);
       syncSignals();
     };
     const clear = () => {
       const currentValue = sourceGet();
-      _stack = [currentValue];
+      _stack = [cloneEntry(currentValue)];
       _cursor = 0;
       syncSignals();
     };
@@ -3305,35 +3470,91 @@ var FormaJS = (() => {
       canRedo,
       history: () => stackSignal(),
       cursor: () => cursorSignal(),
-      clear
+      clear,
+      destroy
     };
   }
 
   // src/state/persist.ts
+  var ENVELOPE_TAG = "$forma:v";
   function persist(source, key, options) {
     const [sourceGet, sourceSet] = source;
     const storage = options?.storage ?? globalThis.localStorage;
     const serialize = options?.serialize ?? JSON.stringify;
     const deserialize = options?.deserialize ?? JSON.parse;
     const validate = options?.validate;
-    try {
-      const stored = storage.getItem(key);
-      if (stored !== null) {
-        const value2 = deserialize(stored);
+    const version = options?.version;
+    const migrate = options?.migrate;
+    const onError2 = options?.onError;
+    let writing = false;
+    function unwrap(stored) {
+      const parsed = deserialize(stored);
+      if (parsed != null && typeof parsed === "object" && Object.prototype.hasOwnProperty.call(parsed, ENVELOPE_TAG)) {
+        const env = parsed;
+        return { value: env.value, version: Number(env[ENVELOPE_TAG]) };
+      }
+      return { value: parsed, version: 0 };
+    }
+    function hydrate() {
+      let stored;
+      try {
+        stored = storage.getItem(key);
+      } catch (err) {
+        onError2?.(err, "hydrate");
+        return;
+      }
+      if (stored === null) return;
+      try {
+        const { value: raw, version: storedVersion } = unwrap(stored);
+        let value2 = raw;
+        if (version !== void 0 && storedVersion < version) {
+          if (!migrate) return;
+          try {
+            value2 = migrate(raw, storedVersion);
+          } catch (err) {
+            onError2?.(err, "migrate");
+            return;
+          }
+        }
         if (!validate || validate(value2)) {
-          sourceSet(value2);
+          writing = true;
+          try {
+            sourceSet(value2);
+          } finally {
+            writing = false;
+          }
         }
+      } catch (err) {
+        onError2?.(err, "hydrate");
       }
-    } catch {
     }
-    internalEffect(() => {
+    hydrate();
+    const stopEffect = internalEffect(() => {
       const value2 = sourceGet();
+      if (writing) return;
       try {
-        const serialized = serialize(value2);
+        const serialized = version !== void 0 ? serialize({ [ENVELOPE_TAG]: version, value: value2 }) : serialize(value2);
         storage.setItem(key, serialized);
-      } catch {
+      } catch (err) {
+        onError2?.(err, err?.name === "QuotaExceededError" ? "write" : "serialize");
       }
     });
+    const enableSync = options?.syncTabs ?? (typeof window !== "undefined" && storage === globalThis.localStorage);
+    let onStorage;
+    if (enableSync && typeof window !== "undefined") {
+      onStorage = (e) => {
+        if (e.storageArea !== storage) return;
+        if (e.key !== null && e.key !== key) return;
+        hydrate();
+      };
+      window.addEventListener("storage", onStorage);
+    }
+    return () => {
+      stopEffect();
+      if (onStorage && typeof window !== "undefined") {
+        window.removeEventListener("storage", onStorage);
+      }
+    };
   }
 
   // src/events/bus.ts