essor 0.0.17-beta.7 → 0.0.18-beta.1

package/dist/essor.browser.dev.js

@@ -1,12 +1,12 @@
 /**
-* essor v0.0.17-beta.7
-* build time 2026-06-27T06:24:37.846Z
+* essor v0.0.18-beta.1
+* build time 2026-07-08T09:46:23.036Z
 * (c) 2023-Present jiangxd <jiangxd2016@gmail.com>
 * @license MIT
 **/
 
 // src/version.ts
-var __version = "0.0.17-beta.7";
+var __version = "0.0.18-beta.1";
 
 // ../shared/dist/shared.dev.js
 var isObject = (val) => val !== null && typeof val === "object";
@@ -20,6 +20,9 @@ function isString(val) {
 function isNumber(val) {
   return typeof val === "number";
 }
+function isNull(val) {
+  return val === null;
+}
 function isSymbol(val) {
   return typeof val === "symbol";
 }
@@ -36,7 +39,11 @@ function isMap(val) {
   return _toString.call(val) === "[object Map]";
 }
 var isFunction = (val) => typeof val === "function";
-var isPlainObject = (val) => _toString.call(val) === "[object Object]";
+var isPlainObject = (val) => {
+  if (_toString.call(val) !== "[object Object]") return false;
+  const proto = Object.getPrototypeOf(val);
+  return proto === null || proto === Object.prototype;
+};
 function isStringNumber(val) {
   if (!isString(val) || val === "") {
     return false;
@@ -46,6 +53,12 @@ function isStringNumber(val) {
 function isUndefined(val) {
   return typeof val === "undefined";
 }
+function isDate(val) {
+  return _toString.call(val) === "[object Date]";
+}
+function isRegExp(val) {
+  return _toString.call(val) === "[object RegExp]";
+}
 var _toString = Object.prototype.toString;
 var hasOwnProperty = Object.prototype.hasOwnProperty;
 var hasOwn = (val, key) => hasOwnProperty.call(val, key);
@@ -432,6 +445,17 @@ function isValidLink(checkLink, sub) {
 }
 var targetMap = /* @__PURE__ */ new WeakMap();
 var triggerVersion = 0;
+var triggerEffects = [];
+var triggerDepth = 0;
+function startTriggerEffects() {
+  const effects = triggerDepth === 0 ? triggerEffects : [];
+  triggerDepth++;
+  return effects;
+}
+function endTriggerEffects(effects) {
+  effects.length = 0;
+  triggerDepth--;
+}
 function collectTriggeredEffects(dep, effects, version) {
   if (!dep) {
     return;
@@ -462,46 +486,127 @@ function track(target, key) {
   linkReactiveNode(dep, activeSub);
 }
 function trigger(target, type, key, newValue) {
-  var _a52;
+  var _a62;
   const depsMap = targetMap.get(target);
   if (!depsMap) {
     return;
   }
-  const effects = [];
+  const effects = startTriggerEffects();
   const version = ++triggerVersion;
-  if (key !== void 0) {
-    if (Array.isArray(key)) {
-      for (const element of key) {
-        collectTriggeredEffects(depsMap.get(element), effects, version);
+  try {
+    if (key !== void 0) {
+      if (isArray(key)) {
+        for (const element of key) {
+          collectTriggeredEffects(depsMap.get(element), effects, version);
+        }
+      } else {
+        collectTriggeredEffects(depsMap.get(key), effects, version);
       }
-    } else {
-      collectTriggeredEffects(depsMap.get(key), effects, version);
     }
+    if (type === "ADD" || type === "DELETE" || type === "CLEAR") {
+      const iterationKey = isArray(target) ? ARRAY_ITERATE_KEY : ITERATE_KEY;
+      collectTriggeredEffects(depsMap.get(iterationKey), effects, version);
+    }
+    for (const effect2 of effects) {
+      if (isFunction(effect2.onTrigger)) {
+        effect2.onTrigger({
+          effect: effect2,
+          target,
+          type,
+          key,
+          newValue
+        });
+      }
+      if (effect2.flag & 2) {
+        (_a62 = effect2.notify) == null ? void 0 : _a62.call(effect2);
+      } else if (effect2.flag & 1) {
+        effect2.flag |= 16;
+        if (effect2.subLink) {
+          propagate(effect2.subLink);
+        }
+      }
+    }
+  } finally {
+    endTriggerEffects(effects);
   }
-  if (type === "ADD" || type === "DELETE" || type === "CLEAR") {
-    const iterationKey = Array.isArray(target) ? ARRAY_ITERATE_KEY : ITERATE_KEY;
-    collectTriggeredEffects(depsMap.get(iterationKey), effects, version);
-  }
-  for (const effect2 of effects) {
-    if (isFunction(effect2.onTrigger)) {
-      effect2.onTrigger({
-        effect: effect2,
-        target,
-        type,
-        key,
-        newValue
-      });
+}
+function trackNode(node) {
+  if (!activeSub || isUntracking) return;
+  linkReactiveNode(node, activeSub);
+}
+function triggerNode(node) {
+  var _a62;
+  const link = node.subLink;
+  if (!link) return;
+  const effects = startTriggerEffects();
+  const version = ++triggerVersion;
+  try {
+    for (let current = link; current; current = current.nextSubLink) {
+      const effect2 = current.subNode;
+      if (effect2._triggerVersion === version) {
+        continue;
+      }
+      effect2._triggerVersion = version;
+      effects.push(effect2);
     }
-    if (effect2.flag & 2) {
-      (_a52 = effect2.notify) == null ? void 0 : _a52.call(effect2);
-    } else if (effect2.flag & 1) {
-      effect2.flag |= 16;
-      if (effect2.subLink) {
-        propagate(effect2.subLink);
+    for (const effect2 of effects) {
+      if (effect2.flag & 2) {
+        (_a62 = effect2.notify) == null ? void 0 : _a62.call(effect2);
+      } else if (effect2.flag & 1) {
+        effect2.flag |= 16;
+        if (effect2.subLink) {
+          propagate(effect2.subLink);
+        }
       }
     }
+  } finally {
+    endTriggerEffects(effects);
   }
 }
+var ReactiveProperty = class {
+  constructor(_target, _key) {
+    this._target = _target;
+    this._key = _key;
+    this.flag = 1;
+  }
+  /**
+   * Read the property value and track the dependency.
+   *
+   * Uses trackNode(this) — bypasses targetMap/Dep. The ReactiveProperty itself
+   * IS the depNode, so linkReactiveNode connects the active subscriber directly
+   * to this node's subLink chain.
+   *
+   * Nested proxy wrapping and signal auto-unwrapping are handled by the caller
+   * (the reactive proxy get trap), keeping this method self-contained and free
+   * of a circular dependency on the rest of reactive.ts.
+   */
+  getValue() {
+    trackNode(this);
+    return this._target[this._key];
+  }
+  /**
+   * Update the property value and notify subscribers.
+   *
+   * Uses triggerNode(this) — directly walks the subLink chain, bypassing
+   * targetMap + collectTriggeredEffects.
+   *
+   * @param rawValue - The new (already unrawed) value.
+   * @param oldValue - The previous value, read BEFORE Reflect.set.
+   */
+  setValue(rawValue, oldValue) {
+    if (Object.is(oldValue, rawValue)) {
+      return;
+    }
+    triggerNode(this);
+  }
+  /**
+   * Invalidate this property (called on delete).
+   * Notifies subscribers that the value is gone.
+   */
+  invalidate() {
+    triggerNode(this);
+  }
+};
 var reactiveCaches = /* @__PURE__ */ new WeakMap();
 var shallowReactiveCaches = /* @__PURE__ */ new WeakMap();
 function toRaw(value) {
@@ -563,7 +668,7 @@ function createArrayInstrumentations() {
       const isShallowMode = isShallow(this);
       track(arr, ARRAY_ITERATE_KEY);
       const res = Array.prototype[key].apply(arr, args);
-      if (!Array.isArray(res)) {
+      if (!isArray(res)) {
         return res;
       }
       return res.map((item) => isObject(item) ? reactiveImpl(item, isShallowMode) : item);
@@ -598,7 +703,7 @@ function createArrayInstrumentations() {
           if (done) {
             return { value, done };
           }
-          if (Array.isArray(value)) {
+          if (isArray(value)) {
             return {
               value: value.map((v) => isObject(v) ? reactiveImpl(v, isShallowMode) : v),
               done
@@ -660,6 +765,32 @@ var arrayHandlers = (shallow) => ({
       }
     }
     return result;
+  },
+  has: (target, key) => {
+    const result = Reflect.has(target, key);
+    if (typeof key !== "symbol") {
+      if (isStringNumber(key)) {
+        track(target, key);
+      }
+      track(target, ARRAY_KEY);
+    }
+    return result;
+  },
+  deleteProperty: (target, key) => {
+    const hadKey = hasOwn(target, key);
+    const result = Reflect.deleteProperty(target, key);
+    if (hadKey && result) {
+      if (isStringNumber(key)) {
+        trigger(target, TriggerOpTypes.DELETE, [key, ARRAY_ITERATE_KEY, ARRAY_KEY]);
+      } else {
+        trigger(target, TriggerOpTypes.DELETE, key);
+      }
+    }
+    return result;
+  },
+  ownKeys: (target) => {
+    track(target, ARRAY_ITERATE_KEY);
+    return Reflect.ownKeys(target);
   }
 });
 var shallowArrayHandlers = arrayHandlers(true);
@@ -826,7 +957,7 @@ var collectionInstrumentations = {
         if (isShallowMode) {
           return { value, done };
         }
-        if (Array.isArray(value)) {
+        if (isArray(value)) {
           return {
             value: value.map((v) => isObject(v) ? reactiveImpl(v) : v),
             done
@@ -1017,9 +1148,46 @@ var weakInstrumentations = {
     return result;
   }
 };
+var targetPropertyMaps = /* @__PURE__ */ new WeakMap();
+function getTargetDepSize(target, key) {
+  var _a62, _b2;
+  const rawTarget = (_a62 = target[
+    "_RAW"
+    /* RAW */
+  ]) != null ? _a62 : target;
+  const prop = (_b2 = targetPropertyMaps.get(rawTarget)) == null ? void 0 : _b2.get(key);
+  if (!(prop == null ? void 0 : prop.subLink)) return 0;
+  let size = 0;
+  for (let link = prop.subLink; link; link = link.nextSubLink) size++;
+  return size;
+}
+function getPropertyMap(target) {
+  let map = targetPropertyMaps.get(target);
+  if (!map) {
+    map = /* @__PURE__ */ new Map();
+    targetPropertyMaps.set(target, map);
+  }
+  return map;
+}
+function trackProperty(target, key) {
+  if (!activeSub) {
+    return target[key];
+  }
+  const pm = getPropertyMap(target);
+  let prop = pm.get(key);
+  if (!prop) {
+    prop = new ReactiveProperty(target, key);
+    pm.set(key, prop);
+  }
+  return prop.getValue();
+}
 var objectHandlers = (shallow) => ({
   /**
    * Reads an object property, unwraps signals, and tracks the access.
+   *
+   * Own properties use the per-property signal fast path (trackNode),
+   * which bypasses the targetMap → Map → Dep indirection.
+   * Prototype-chain properties fall back to the standard track() path.
    */
   get(target, key, receiver) {
     if (key === "_RAW") {
@@ -1031,6 +1199,14 @@ var objectHandlers = (shallow) => ({
     if (key === "_IS_SHALLOW") {
       return shallow;
     }
+    if (activeSub && hasOwn(target, key)) {
+      const result = trackProperty(target, key);
+      const unwrapped = isSignal(result) ? result.value : result;
+      if (isObject(unwrapped) && !shallow) {
+        return reactiveImpl(unwrapped);
+      }
+      return unwrapped;
+    }
     const value = Reflect.get(target, key, receiver);
     const valueUnwrapped = isSignal(value) ? value.value : value;
     track(target, key);
@@ -1044,6 +1220,14 @@ var objectHandlers = (shallow) => ({
     const oldValue = Reflect.get(target, key, receiver);
     const rawValue = toRaw(value);
     const result = Reflect.set(target, key, rawValue, receiver);
+    if (hadKey) {
+      const pm = targetPropertyMaps.get(target);
+      const prop = pm == null ? void 0 : pm.get(key);
+      if (prop) {
+        prop.setValue(rawValue, oldValue);
+        return result;
+      }
+    }
     if (hasStoredValueChanged(rawValue, oldValue)) {
       trigger(target, hadKey ? TriggerOpTypes.SET : TriggerOpTypes.ADD, key, rawValue);
     }
@@ -1053,6 +1237,12 @@ var objectHandlers = (shallow) => ({
     const hadKey = hasOwn(target, key);
     const result = Reflect.deleteProperty(target, key);
     if (hadKey && result) {
+      const pm = targetPropertyMaps.get(target);
+      const prop = pm == null ? void 0 : pm.get(key);
+      if (prop) {
+        pm.delete(key);
+        prop.invalidate();
+      }
       trigger(target, TriggerOpTypes.DELETE, key, void 0);
     }
     return result;
@@ -1295,6 +1485,7 @@ function isSignal(value) {
 }
 var queue = /* @__PURE__ */ new Set();
 var activePreFlushCbs = /* @__PURE__ */ new Set();
+var activePostFlushCbs = /* @__PURE__ */ new Set();
 var p = Promise.resolve();
 var isFlushPending = false;
 var RECURSION_LIMIT = 100;
@@ -1315,6 +1506,10 @@ function queuePreFlushCb(cb) {
   activePreFlushCbs.add(cb);
   queueFlush();
 }
+function queuePostFlushJob(cb) {
+  activePostFlushCbs.add(cb);
+  queueFlush();
+}
 function flushJobs() {
   isFlushPending = false;
   flushPreFlushCbs();
@@ -1327,7 +1522,7 @@ function flushJobs() {
           `[Scheduler] Maximum recursive flush count (${RECURSION_LIMIT}) exceeded. This usually means an effect or watch callback is mutating a reactive dependency it also reads, causing an infinite update loop. The remaining queued jobs have been dropped to keep the app responsive.`
         );
       }
-      return;
+      break;
     }
     const jobs = [...queue];
     queue.clear();
@@ -1341,6 +1536,7 @@ function flushJobs() {
       }
     }
   }
+  flushPostFlushCbs();
 }
 function flushPreFlushCbs() {
   const callbacks = Array.from(activePreFlushCbs);
@@ -1355,6 +1551,20 @@ function flushPreFlushCbs() {
     }
   }
 }
+function flushPostFlushCbs() {
+  if (activePostFlushCbs.size === 0) return;
+  const callbacks = Array.from(activePostFlushCbs);
+  activePostFlushCbs.clear();
+  for (const callback of callbacks) {
+    try {
+      callback();
+    } catch (_error) {
+      {
+        error("Error executing post-flush callback:", _error);
+      }
+    }
+  }
+}
 function createScheduler(effect2, flush) {
   switch (flush) {
     case "sync":
@@ -1405,7 +1615,7 @@ var EffectScope = class {
   constructor(detached = false, parent = void 0) {
     this.detached = detached;
     this.parent = parent;
-    this._active = true;
+    this._state = 0;
     this.effects = /* @__PURE__ */ new Set();
     this.scopes = /* @__PURE__ */ new Set();
     this.cleanups = [];
@@ -1415,36 +1625,46 @@ var EffectScope = class {
     }
   }
   get active() {
-    return this._active;
+    return this._state !== 2;
+  }
+  /** Whether the scope is paused. */
+  get isPaused() {
+    return this._state === 1;
+  }
+  /** Whether the scope has been stopped / disposed. */
+  get isDisposed() {
+    return this._state === 2;
   }
   pause() {
-    var _a52;
-    if (!this._active) {
+    var _a62;
+    if (this._state !== 0) {
       return;
     }
+    this._state = 1;
     for (const scope of this.scopes) {
       scope.pause();
     }
     for (const effect2 of this.effects) {
-      (_a52 = effect2.pause) == null ? void 0 : _a52.call(effect2);
+      (_a62 = effect2.pause) == null ? void 0 : _a62.call(effect2);
     }
   }
   resume() {
-    var _a52;
-    if (!this._active) {
+    var _a62;
+    if (this._state !== 1) {
       return;
     }
+    this._state = 0;
     for (const scope of this.scopes) {
       scope.resume();
     }
     for (const effect2 of this.effects) {
-      (_a52 = effect2.resume) == null ? void 0 : _a52.call(effect2);
+      (_a62 = effect2.resume) == null ? void 0 : _a62.call(effect2);
     }
   }
   run(fn) {
-    if (!this._active) {
+    if (this._state === 2) {
       {
-        warn("cannot run an inactive effect scope.");
+        warn("cannot run a disposed effect scope.");
       }
       return;
     }
@@ -1457,27 +1677,42 @@ var EffectScope = class {
     }
   }
   stop(fromParent = false) {
-    if (!this._active) {
+    if (this._state === 2) {
       return;
     }
-    this._active = false;
-    for (const scope of this.scopes) {
-      scope.stop(true);
-    }
-    this.scopes.clear();
-    const effects = Array.from(this.effects);
-    this.effects.clear();
-    for (const effect2 of effects) {
-      effect2.stop();
-    }
-    for (let i = 0; i < this.cleanups.length; i++) {
-      this.cleanups[i]();
-    }
-    this.cleanups.length = 0;
-    if (!fromParent && this.parent) {
-      this.parent.scopes.delete(this);
+    this._state = 2;
+    try {
+      for (const scope of this.scopes) {
+        try {
+          scope.stop(true);
+        } catch (error_) {
+          if (true) error("[EffectScope] child scope disposal threw:", error_);
+        }
+      }
+      this.scopes.clear();
+      const effects = Array.from(this.effects);
+      this.effects.clear();
+      for (const effect2 of effects) {
+        try {
+          effect2.stop();
+        } catch (error_) {
+          if (true) error("[EffectScope] effect disposal threw:", error_);
+        }
+      }
+      for (let i = 0; i < this.cleanups.length; i++) {
+        try {
+          this.cleanups[i]();
+        } catch (error_) {
+          if (true) error("[EffectScope] cleanup threw:", error_);
+        }
+      }
+      this.cleanups.length = 0;
+    } finally {
+      if (!fromParent && this.parent) {
+        this.parent.scopes.delete(this);
+      }
+      this.parent = void 0;
     }
-    this.parent = void 0;
   }
   _record(effect2) {
     this.effects.add(effect2);
@@ -1641,9 +1876,9 @@ var EffectImpl = class {
     const prevSub = startTracking(this);
     try {
       return this.fn();
-    } catch (error5) {
+    } catch (error6) {
       this.flag |= 16;
-      throw error5;
+      throw error6;
     } finally {
       this.flag &= -513;
       endTracking(this, prevSub);
@@ -1669,13 +1904,13 @@ var EffectImpl = class {
    * @returns {void}
    */
   notify() {
-    var _a52, _b2, _c, _d;
+    var _a62, _b2, _c, _d;
     const flags = this.flag;
     if (!this._active || flags & (256 | 512 | 16)) {
       return;
     }
     this.flag = flags | 16;
-    if ((_a52 = this.options) == null ? void 0 : _a52.onTrigger) {
+    if ((_a62 = this.options) == null ? void 0 : _a62.onTrigger) {
       this.options.onTrigger({
         effect: this,
         target: {},
@@ -1708,7 +1943,7 @@ var EffectImpl = class {
    * @returns {void}
    */
   stop() {
-    var _a52;
+    var _a62;
     if (!this._active) {
       return;
     }
@@ -1738,7 +1973,7 @@ var EffectImpl = class {
         );
       }
     }
-    if ((_a52 = this.options) == null ? void 0 : _a52.onStop) {
+    if ((_a62 = this.options) == null ? void 0 : _a62.onStop) {
       this.options.onStop();
     }
   }
@@ -1885,7 +2120,7 @@ var ComputedImpl = class {
     const hadValue = oldValue !== NO_VALUE;
     const prevSub = startTracking(this);
     try {
-      const newValue = this.getter();
+      const newValue = this.getter(hadValue ? oldValue : void 0);
       const flags = this.flag;
       const subs = this.subLink;
       const clearMask = ~(16 | 32);
@@ -2008,13 +2243,13 @@ function cloneInitialState(value, seen = /* @__PURE__ */ new WeakMap()) {
   if (seen.has(value)) {
     return seen.get(value);
   }
-  if (value instanceof Date) {
+  if (isDate(value)) {
     return new Date(value.getTime());
   }
-  if (value instanceof RegExp) {
+  if (isRegExp(value)) {
     return new RegExp(value.source, value.flags);
   }
-  if (value instanceof Map) {
+  if (isMap(value)) {
     const clone2 = /* @__PURE__ */ new Map();
     seen.set(value, clone2);
     value.forEach((mapValue, mapKey) => {
@@ -2022,7 +2257,7 @@ function cloneInitialState(value, seen = /* @__PURE__ */ new WeakMap()) {
     });
     return clone2;
   }
-  if (value instanceof Set) {
+  if (isSet(value)) {
     const clone2 = /* @__PURE__ */ new Set();
     seen.set(value, clone2);
     value.forEach((setValue) => {
@@ -2030,7 +2265,7 @@ function cloneInitialState(value, seen = /* @__PURE__ */ new WeakMap()) {
     });
     return clone2;
   }
-  if (Array.isArray(value)) {
+  if (isArray(value)) {
     const clone2 = [];
     seen.set(value, clone2);
     value.forEach((item, index) => {
@@ -2039,7 +2274,7 @@ function cloneInitialState(value, seen = /* @__PURE__ */ new WeakMap()) {
     return clone2;
   }
   const prototype = Object.getPrototypeOf(value);
-  if (prototype !== Object.prototype && prototype !== null) {
+  if (prototype !== Object.prototype && !isNull(prototype)) {
     return value;
   }
   const clone = Object.create(prototype);
@@ -2070,11 +2305,58 @@ function createOptionsStore(options) {
       };
     }
     set.add(callback);
-    return () => set.delete(callback);
+    const unsubscribe = () => set.delete(callback);
+    onScopeDispose(
+      unsubscribe,
+      /* failSilently */
+      true
+    );
+    return unsubscribe;
+  };
+  let activeTransaction = null;
+  const flushTransaction = (transaction) => {
+    if (transaction.depth === 0 && transaction.pending === 0 && !transaction.notified) {
+      transaction.notified = true;
+      notify(reactiveState);
+    }
   };
   const commit = (mutate) => {
-    batch(mutate);
-    notify(reactiveState);
+    const transaction = activeTransaction != null ? activeTransaction : {
+      depth: 0,
+      pending: 0,
+      notified: false
+    };
+    const previousTransaction = activeTransaction;
+    transaction.depth++;
+    let result;
+    try {
+      activeTransaction = transaction;
+      result = batch(mutate);
+    } catch (error6) {
+      transaction.depth--;
+      activeTransaction = previousTransaction;
+      throw error6;
+    }
+    activeTransaction = previousTransaction;
+    if (isPromise(result)) {
+      transaction.pending++;
+      transaction.depth--;
+      return result.then(
+        (value) => {
+          transaction.pending--;
+          flushTransaction(transaction);
+          return value;
+        },
+        (error6) => {
+          transaction.pending--;
+          flushTransaction(transaction);
+          throw error6;
+        }
+      );
+    }
+    transaction.depth--;
+    flushTransaction(transaction);
+    return result;
   };
   const defaultActions = {
     $patch(payload) {
@@ -2097,7 +2379,15 @@ function createOptionsStore(options) {
       actionCallbacks.delete(callback);
     },
     $reset() {
-      commit(() => Object.assign(reactiveState, initState));
+      commit(() => {
+        const fresh = cloneInitialState(initState);
+        for (const key of Object.keys(reactiveState)) {
+          if (!Object.prototype.hasOwnProperty.call(fresh, key)) {
+            delete reactiveState[key];
+          }
+        }
+        Object.assign(reactiveState, fresh);
+      });
     }
   };
   const store = {};
@@ -2115,7 +2405,7 @@ function createOptionsStore(options) {
     value: reactiveState,
     enumerable: true,
     configurable: true,
-    writable: true
+    writable: false
   });
   Object.assign(store, defaultActions);
   if (getters) {
@@ -2135,9 +2425,7 @@ function createOptionsStore(options) {
       const action = actions[key];
       if (action) {
         store[key] = (...args) => {
-          const result = action.apply(store, args);
-          actionCallbacks.forEach((callback) => callback(reactiveState));
-          return result;
+          return commit(() => action.apply(store, args));
         };
       }
     }
@@ -2209,6 +2497,12 @@ var RefImpl = class extends (_b = SignalImpl, _a4 = "_IS_REF", _b) {
     if (sub) {
       linkReactiveNode(this, sub);
     }
+    if (this.flag & 16 && this.shouldUpdate()) {
+      const subs = this.subLink;
+      if (subs) {
+        shallowPropagate(subs);
+      }
+    }
     return this._value;
   }
   /**
@@ -2224,6 +2518,7 @@ var RefImpl = class extends (_b = SignalImpl, _a4 = "_IS_REF", _b) {
       newValue = newValue.value;
     }
     if (hasChanged(this._value, newValue)) {
+      this._oldValue = this._rawValue;
       this._rawValue = newValue;
       this._value = newValue;
       this.flag |= 16;
@@ -2248,6 +2543,45 @@ function isRef(value) {
     /* IS_REF */
   ];
 }
+var _a5;
+_a5 = "_IS_COMPUTED";
+var ObjectPropertyRef = class {
+  constructor(obj, key, defaultValue) {
+    this.obj = obj;
+    this.key = key;
+    this.defaultValue = defaultValue;
+    this[_a5] = true;
+  }
+  get value() {
+    const value = this.obj[this.key];
+    return value !== void 0 ? value : this.defaultValue;
+  }
+  set value(value) {
+    this.obj[this.key] = value;
+  }
+  peek() {
+    return untrack(() => this.value);
+  }
+};
+function unref(value) {
+  if (isSignal(value) || isRef(value) || isComputed(value)) {
+    return value.value;
+  }
+  if (isFunction(value)) {
+    return value();
+  }
+  return value;
+}
+function toRef(obj, key, defaultValue) {
+  return new ObjectPropertyRef(obj, key, defaultValue);
+}
+function toRefs(obj) {
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    result[key] = toRef(obj, key);
+  }
+  return result;
+}
 var INITIAL_WATCHER_VALUE = {};
 var _traverseSeen = /* @__PURE__ */ new Set();
 var _traverseBusy = false;
@@ -2258,7 +2592,7 @@ function traverseValue(value, seen) {
   seen.add(value);
   if (isSignal(value) || isComputed(value)) {
     traverseValue(value.value, seen);
-  } else if (Array.isArray(value)) {
+  } else if (isArray(value)) {
     for (const element of value) {
       traverseValue(element, seen);
     }
@@ -2308,7 +2642,7 @@ function resolveSingleSource(source) {
   return () => source;
 }
 function resolveSource(source) {
-  if (Array.isArray(source)) {
+  if (isArray(source)) {
     const getters = source.map((s) => resolveSingleSource(s));
     return () => getters.map((g) => g());
   }
@@ -2319,7 +2653,7 @@ function watch(source, callback, options = {}) {
   let oldValue = INITIAL_WATCHER_VALUE;
   let lastValue;
   let active = true;
-  const isSingleReactive = !Array.isArray(source) && isReactive(source);
+  const isSingleReactive = !isArray(source) && isReactive(source);
   const needTraverse = deep && !isSingleReactive;
   const getter = resolveSource(source);
   let cleanup;
@@ -2328,8 +2662,8 @@ function watch(source, callback, options = {}) {
       cleanup = void 0;
       try {
         fn();
-      } catch (error5) {
-        warn("[watch] cleanup handler threw:", error5);
+      } catch (error6) {
+        warn("[watch] cleanup handler threw:", error6);
       }
     };
   };
@@ -2462,12 +2796,12 @@ function runWithScope(scope, fn) {
   }
 }
 function disposeScope(scope) {
-  var _a6;
+  var _a7;
   if (!scope || scope.isDestroyed) {
     return;
   }
   scope.isDestroyed = true;
-  if ((_a6 = scope.parent) == null ? void 0 : _a6.children) {
+  if ((_a7 = scope.parent) == null ? void 0 : _a7.children) {
     scope.parent.children.delete(scope);
   }
   scope.parent = null;
@@ -2539,6 +2873,24 @@ var FOR_COMPONENT = /* @__PURE__ */ Symbol("For Component");
 var TRANSITION_COMPONENT = /* @__PURE__ */ Symbol("Transition Component");
 var TRANSITION_GROUP_COMPONENT = /* @__PURE__ */ Symbol("TransitionGroup Component");
 var DANGEROUS_DATA_MIME_RE = /^data:\s*(?:text\/html|text\/xml|application\/xhtml\+xml|image\/svg\+xml|application\/xml)/;
+var BOOLEAN_PROPERTY_ALIASES = {
+  allowfullscreen: "allowFullscreen",
+  formnovalidate: "formNoValidate",
+  ismap: "isMap",
+  nomodule: "noModule",
+  novalidate: "noValidate",
+  readonly: "readOnly"
+};
+function syncBooleanProperty(el, key, value) {
+  var _a22;
+  if (el.namespaceURI === SVG_NAMESPACE) return;
+  const prop = (_a22 = BOOLEAN_PROPERTY_ALIASES[key.toLowerCase()]) != null ? _a22 : key;
+  if (!(prop in el) || typeof el[prop] !== "boolean") return;
+  try {
+    el[prop] = value;
+  } catch (e) {
+  }
+}
 function isUnsafeUrl(value) {
   const v = value.replaceAll(/[\u0000-\u0020]+/g, "").toLowerCase();
   if (startsWith(v, "javascript:") || startsWith(v, "vbscript:")) {
@@ -2615,14 +2967,19 @@ function patchAttr(el, key, prev, next2) {
     } else {
       el.removeAttribute(key);
     }
+    if (isBoolean || lowerKey === "indeterminate") {
+      syncBooleanProperty(el, key, false);
+    }
     return;
   }
   if (isBoolean) {
-    if (includeBooleanAttr(next2)) {
+    const included = includeBooleanAttr(next2);
+    if (included) {
       el.setAttribute(key, "");
     } else {
       el.removeAttribute(key);
     }
+    syncBooleanProperty(el, key, included);
     return;
   }
   const attrValue = isSymbol(next2) ? String(next2) : next2;
@@ -2849,19 +3206,31 @@ function endHydration() {
   _teleportTargetStarts.clear();
 }
 function claimHydratedNodes(parent, expected, before) {
-  var _a22, _b2;
+  var _a22, _b2, _c;
   if (!_isHydrating || before && before.parentNode !== parent) return null;
   if (expected.length === 0) return [];
   const claimed = new Array(expected.length);
   let cursor = before ? before.previousSibling : parent.lastChild;
   for (let i = expected.length - 1; i >= 0; i--) {
-    if (!cursor) return null;
     const expectedNode = expected[i];
     const expectedType = expectedNode.nodeType;
     if (expectedType === Node.TEXT_NODE) {
       const expectedText = (_a22 = expectedNode.textContent) != null ? _a22 : "";
-      if (!expectedText || cursor.nodeType !== Node.TEXT_NODE) return null;
-      const existingText = (_b2 = cursor.textContent) != null ? _b2 : "";
+      if (expectedText === "") {
+        if ((cursor == null ? void 0 : cursor.nodeType) === Node.TEXT_NODE && ((_b2 = cursor.textContent) != null ? _b2 : "") === "") {
+          claimed[i] = cursor;
+          cursor = cursor.previousSibling;
+        } else {
+          const emptyNode = document.createTextNode("");
+          const anchor = i + 1 < expected.length ? claimed[i + 1] : before != null ? before : null;
+          parent.insertBefore(emptyNode, anchor);
+          claimed[i] = emptyNode;
+        }
+        continue;
+      }
+      if (!cursor) return null;
+      if (cursor.nodeType !== Node.TEXT_NODE) return null;
+      const existingText = (_c = cursor.textContent) != null ? _c : "";
       if (existingText === expectedText) {
         claimed[i] = cursor;
         cursor = cursor.previousSibling;
@@ -2877,6 +3246,7 @@ function claimHydratedNodes(parent, expected, before) {
       cursor = prefixNode;
       continue;
     }
+    if (!cursor) return null;
     if (cursor.nodeType !== expectedType) return null;
     if (expectedType === Node.ELEMENT_NODE) {
       if (cursor.tagName !== expectedNode.tagName) return null;
@@ -3180,6 +3550,8 @@ function insert(parent, nodeFactory, before) {
   const effectRunner = effect(() => {
     const executeUpdate = () => {
       const rawNodes = isFunction(nodeFactory) ? nodeFactory() : nodeFactory;
+      const rawType = typeof rawNodes;
+      const canPatchText = rawNodes == null || rawType === "string" || rawType === "number" || rawType === "boolean" || rawType === "symbol";
       const nodes = resolveNodes(rawNodes);
       if (isFirstRun && isHydrating() && nodes.every((node) => node instanceof Node && node.parentNode === parent)) {
         renderedNodes = nodes;
@@ -3194,6 +3566,13 @@ function insert(parent, nodeFactory, before) {
           return;
         }
       }
+      if (canPatchText && renderedNodes.length === 1 && nodes.length === 1 && renderedNodes[0].nodeType === Node.TEXT_NODE && nodes[0].nodeType === Node.TEXT_NODE) {
+        const current = renderedNodes[0];
+        const nextText = nodes[0].textContent;
+        if (current.textContent !== nextText) current.textContent = nextText;
+        isFirstRun = false;
+        return;
+      }
       renderedNodes = reconcileArrays(parent, renderedNodes, nodes, before);
       isFirstRun = false;
     };
@@ -3238,7 +3617,7 @@ function addEvent(el, event, handler, options) {
   const selector = options.delegate;
   const wrappedHandler = (e) => {
     const target = e.target;
-    if (target.matches(selector) || target.closest(selector)) {
+    if (target.closest(selector)) {
       handler.call(el, e);
     }
   };
@@ -3352,13 +3731,13 @@ function readDescriptorValue(source, key) {
   const descriptor = Object.getOwnPropertyDescriptor(source, key);
   return descriptor.get ? descriptor.get.call(source) : descriptor.value;
 }
-var _a5;
-_a5 = "normal";
+var _a6;
+_a6 = "normal";
 var Component = class {
   constructor(component, props = {}) {
     this.component = component;
     this.props = props;
-    this[_a5] = true;
+    this[_a6] = true;
     this.scope = null;
     this.state = 0;
     this.beforeNode = void 0;
@@ -3469,28 +3848,34 @@ var Component = class {
    */
   syncSpecialProps(props) {
     if (!props) return;
-    const root = this.firstChild;
-    if (!root || !(root instanceof Element)) return;
+    const roots = this.getRootElements();
+    if (roots.length === 0) return;
+    const refRoot = roots[0];
     this.releaseSpecialProps();
     for (const key of Reflect.ownKeys(props)) {
       if (!isString(key)) continue;
       if (key === REF_KEY) {
         const value = readDescriptorValue(props, key);
-        this.rootRefCleanup = this.bindRootRef(value, root);
+        this.rootRefCleanup = this.bindRootRef(value, refRoot);
         continue;
       }
       if (isOn(key)) {
         const value = readDescriptorValue(props, key);
         if (!isFunction(value)) continue;
         const eventName = key.slice(2).toLowerCase();
-        this.bindRootEvent(
-          root,
-          eventName,
-          value
-        );
+        for (const root of roots) {
+          this.bindRootEvent(root, eventName, value);
+        }
       }
     }
   }
+  getRootElements() {
+    const roots = [];
+    for (const node of this.renderedNodes) {
+      if (node instanceof Element) roots.push(node);
+    }
+    return roots;
+  }
   bindRootEvent(target, eventName, handler) {
     const slot = `_$${eventName}`;
     const prev = target[slot];
@@ -3699,7 +4084,9 @@ function eventHandler(e) {
     return true;
   };
   const walkUpTree = () => {
-    while (handleNode() && (node = node._$host || node.parentNode || node.host)) ;
+    while (handleNode() && (node = node._$host || node.parentNode || node.host)) {
+      if (node === oriCurrentTarget) break;
+    }
   };
   Object.defineProperty(e, "currentTarget", {
     configurable: true,
@@ -3710,23 +4097,26 @@ function eventHandler(e) {
       return node || document;
     }
   });
-  if (e.composedPath) {
-    const path = e.composedPath();
-    reTargetEvent(e, path[0]);
-    for (let i = 0; i < path.length - 2; i++) {
-      node = path[i];
-      if (!handleNode()) break;
-      if (node._$host) {
-        node = node._$host;
-        walkUpTree();
-        break;
-      }
-      if (node.parentNode === oriCurrentTarget) {
-        break;
+  try {
+    if (e.composedPath) {
+      const path = e.composedPath();
+      reTargetEvent(e, path[0]);
+      for (let i = 0; i < path.length - 2; i++) {
+        node = path[i];
+        if (!handleNode()) break;
+        if (node._$host) {
+          node = node._$host;
+          walkUpTree();
+          break;
+        }
+        if (node.parentNode === oriCurrentTarget) {
+          break;
+        }
       }
-    }
-  } else walkUpTree();
-  reTargetEvent(e, oriTarget);
+    } else walkUpTree();
+  } finally {
+    reTargetEvent(e, oriTarget);
+  }
 }
 var $EVENTS = /* @__PURE__ */ Symbol("_$EVENTS");
 function delegateEvents(eventNames, document2 = globalThis.document) {
@@ -3762,6 +4152,7 @@ var EMPTY_FILES = (() => {
   if (typeof DataTransfer !== "undefined") return new DataTransfer().files;
   return [];
 })();
+var checkboxArraySnapshots = /* @__PURE__ */ new WeakMap();
 function writeValue(el, v) {
   const target = el;
   const next2 = v == null ? "" : String(v);
@@ -3878,11 +4269,16 @@ function bindElement(node, prop, getter, setter, modifiers = {}) {
   const getModel = isFunction(getter) ? getter : () => getter;
   const cast = shouldCast ? (v) => applyModifiers(v, trim, toNum) : IDENTITY;
   const computeNext = checkboxArray ? (raw) => {
+    var _a22;
     const current = getModel();
-    if (!isArray(current)) return cast(raw);
+    if (!isArray(current)) {
+      return cast(raw);
+    }
     const own = node.value;
-    const next2 = current.filter((item) => String(item) !== own);
+    const source = (_a22 = checkboxArraySnapshots.get(current)) != null ? _a22 : current;
+    const next2 = source.filter((item) => String(item) !== own);
     if (raw) next2.push(own);
+    checkboxArraySnapshots.set(current, next2);
     return next2;
   } : cast;
   let composing = false;
@@ -3909,6 +4305,9 @@ function bindElement(node, prop, getter, setter, modifiers = {}) {
   }
   const runner = effect(() => {
     const value = getModel();
+    if (checkboxArray) {
+      if (isArray(value)) checkboxArraySnapshots.set(value, [...value]);
+    }
     if (ime && composing) return;
     if (ime && !lazy && isFocused(node) && Object.is(cast(read(node)), value)) return;
     write(node, value);
@@ -3919,7 +4318,7 @@ function bindElement(node, prop, getter, setter, modifiers = {}) {
 }
 function unwrapSlotValue(raw) {
   let v = raw;
-  if (Array.isArray(v) && v.length === 1) v = v[0];
+  if (isArray(v) && v.length === 1) v = v[0];
   return isFunction(v) ? v() : v;
 }
 function useChildren(props) {
@@ -4000,7 +4399,9 @@ function Portal(props) {
   if (children == null) return placeholder;
   const parentScope = getActiveScope();
   let innerScope = null;
+  let disposed = false;
   const mountAt = (parent, before) => {
+    if (disposed || (parentScope == null ? void 0 : parentScope.isDestroyed)) return;
     innerScope = createScope(parentScope);
     runWithScope(innerScope, () => {
       insert(parent, () => children, before);
@@ -4013,6 +4414,7 @@ function Portal(props) {
     }
   };
   const apply = (disabled, target) => {
+    if (disposed) return;
     teardown();
     if (disabled) {
       const parent = placeholder.parentNode;
@@ -4045,11 +4447,13 @@ function Portal(props) {
       return;
     }
     queueMicrotask(() => {
+      if (disposed) return;
       if (!placeholder.parentNode) return;
       apply(evalDisabled(props), resolveTarget(props));
     });
   });
   onCleanup(() => {
+    disposed = true;
     effectRunner.stop();
     teardown();
   });
@@ -4095,12 +4499,15 @@ function resolveNodeValue(value) {
   if (isSignal(current) || isComputed(current)) {
     return resolveNodeValue(current.value);
   }
-  if (Array.isArray(current)) {
+  if (isArray(current)) {
     return current.map((item) => resolveNodeValue(item));
   }
   return current;
 }
 var SuspenseContext = /* @__PURE__ */ Symbol("SuspenseContext");
+function isAbortError(error4) {
+  return !!error4 && typeof error4 === "object" && error4.name === "AbortError";
+}
 function Suspense(props) {
   var _a22;
   if (!isBrowser()) {
@@ -4114,10 +4521,14 @@ function Suspense(props) {
   let mounted = true;
   let pending = 0;
   let mounting = false;
+  let boundaryVersion = 0;
+  let currentChildren = null;
   let contentScope = null;
   let parked = null;
   let fallbackScope = null;
   let resolved = null;
+  let hasResolved = false;
+  let manualReleases = [];
   const parkContent = () => {
     const off = document.createDocumentFragment();
     while (end.previousSibling && end.previousSibling !== start) {
@@ -4147,14 +4558,35 @@ function Suspense(props) {
     disposeScope(fallbackScope);
     fallbackScope = null;
   };
-  const mountContent = (children2) => {
+  const disposeContent = () => {
+    if (contentScope) {
+      disposeScope(contentScope);
+      contentScope = null;
+    }
+    if (parked) {
+      while (parked.firstChild) parked.firstChild.remove();
+      parked = null;
+    }
+  };
+  const mountContent = (children) => {
+    const scope = createScope(owner);
     mounting = true;
-    contentScope = createScope(owner);
-    runWithScope(contentScope, () => {
-      var _a32;
-      insert((_a32 = end.parentNode) != null ? _a32 : frag, () => resolveNodeValue(children2), end);
-    });
-    mounting = false;
+    contentScope = scope;
+    try {
+      runWithScope(scope, () => {
+        var _a32;
+        insert((_a32 = end.parentNode) != null ? _a32 : frag, () => resolveNodeValue(children), end);
+      });
+    } catch (error4) {
+      if (contentScope === scope) contentScope = null;
+      disposeScope(scope);
+      pending = 0;
+      manualReleases = [];
+      boundaryVersion++;
+      throw error4;
+    } finally {
+      mounting = false;
+    }
     if (pending && !parked) {
       parkContent();
       mountFallback();
@@ -4168,53 +4600,89 @@ function Suspense(props) {
   };
   const showContent = () => {
     if (!parked) return;
-    const hasSyncChildren = props.children != null && !isPromise(props.children);
-    if (contentScope == null && resolved == null && !hasSyncChildren) return;
+    const hasSyncChildren = currentChildren != null && !isPromise(currentChildren);
+    if (contentScope == null && !hasResolved && !hasSyncChildren) return;
     disposeFallback();
     restoreContent();
     if (!contentScope) {
-      if (resolved) {
+      if (hasResolved) {
         mountContent(resolved);
       } else if (hasSyncChildren) {
-        mountContent(props.children);
+        mountContent(currentChildren);
       }
     }
   };
-  const settle = () => {
+  const addPending = (version = boundaryVersion) => {
+    pending++;
+    showFallback();
+    const release = (() => {
+      if (!release.active) return;
+      release.active = false;
+      if (!mounted || version !== boundaryVersion) return;
+      if (--pending === 0) showContent();
+    });
+    release.active = true;
+    return release;
+  };
+  const settle = (release) => {
     if (!mounted) return;
-    if (--pending === 0) showContent();
+    release();
+  };
+  const dequeueManualRelease = () => {
+    while (manualReleases.length > 0) {
+      const release = manualReleases.shift();
+      if (release.active) return release;
+    }
+    return void 0;
   };
   const ctx = {
     register: (promise) => {
-      pending++;
-      showFallback();
-      promise.then(settle).catch((error4) => {
-        warn("[Suspense] Resource failed:", error4);
-        settle();
-      });
+      const release = addPending();
+      promise.then(
+        () => settle(release),
+        (error4) => {
+          if (!isAbortError(error4)) warn("[Suspense] Resource failed:", error4);
+          settle(release);
+        }
+      );
+      return release;
     },
     increment: () => {
-      pending++;
-      showFallback();
+      const release = addPending();
+      manualReleases.push(release);
+      return release;
     },
     decrement: () => {
-      pending = Math.max(0, pending - 1);
-      if (pending === 0) showContent();
+      const release = dequeueManualRelease();
+      if (release) settle(release);
     }
   };
   provide(SuspenseContext, ctx);
-  const children = props.children;
-  if (isPromise(children)) {
-    children.then((value) => {
-      resolved = value;
-    }).catch(() => {
-    });
-    ctx.register(children);
-  } else if (children != null) {
-    mountContent(children);
-  } else if (props.fallback != null) {
-    showFallback();
-  }
+  const renderChildren = (children) => {
+    const version = ++boundaryVersion;
+    currentChildren = children != null ? children : null;
+    pending = 0;
+    resolved = null;
+    hasResolved = false;
+    manualReleases = [];
+    disposeContent();
+    disposeFallback();
+    if (isPromise(children)) {
+      children.then((value) => {
+        if (!mounted || version !== boundaryVersion) return;
+        resolved = value;
+        hasResolved = true;
+      }).catch(() => {
+      });
+      ctx.register(children);
+    } else if (children != null) {
+      mountContent(children);
+    } else if (props.fallback != null) {
+      showFallback();
+    }
+  };
+  renderChildren(props.children);
+  onUpdate(() => renderChildren(props.children));
   onCleanup(() => {
     mounted = false;
     pending = 0;
@@ -4232,6 +4700,9 @@ Suspense[SUSPENSE_COMPONENT] = true;
 function isSuspense(node) {
   return !!node && !!node[SUSPENSE_COMPONENT];
 }
+function isAbortError2(error4) {
+  return !!error4 && typeof error4 === "object" && error4.name === "AbortError";
+}
 function createResource(fetcher, options) {
   const value = signal(options == null ? void 0 : options.initialValue);
   const loading = signal(true);
@@ -4266,7 +4737,7 @@ function createResource(fetcher, options) {
       }
     } catch (error_) {
       if (id !== fetchId) return;
-      if (error_ instanceof DOMException && error_.name === "AbortError") {
+      if (isAbortError2(error_)) {
         loading.value = false;
         return;
       }
@@ -4321,17 +4792,26 @@ function defineServerAsyncComponent(loader, ssr) {
 function defineClientAsyncComponent(loader, options) {
   const { loading, error: errorComp, delay = 200, timeout, onError } = options;
   let component = null;
-  let error4 = null;
+  let loadError = null;
   let status = "pending";
   let loadPromise = null;
-  const load = () => loadPromise != null ? loadPromise : loadPromise = loader().then((mod) => {
-    component = resolveModule(mod);
-    status = "resolved";
-  }).catch((error_) => {
-    error4 = error_ instanceof Error ? error_ : new Error(String(error_));
-    status = "errored";
-    loadPromise = null;
-  });
+  let loadId = 0;
+  const currentLoad = (id) => id !== loadId ? loadPromise != null ? loadPromise : void 0 : void 0;
+  const load = (forceId) => {
+    if (loadPromise && forceId === void 0) return loadPromise;
+    const id = forceId != null ? forceId : ++loadId;
+    loadPromise = loader().then((mod) => {
+      if (id !== loadId) return currentLoad(id);
+      component = resolveModule(mod);
+      status = "resolved";
+    }).catch((error_) => {
+      if (id !== loadId) return currentLoad(id);
+      loadError = error_ instanceof Error ? error_ : new Error(String(error_));
+      status = "errored";
+      loadPromise = null;
+    });
+    return loadPromise;
+  };
   load();
   function AsyncWrapper(props) {
     var _a22;
@@ -4343,6 +4823,7 @@ function defineClientAsyncComponent(loader, options) {
     let viewScope = null;
     let delayTimer = null;
     let timeoutTimer = null;
+    let instanceRetryId = 0;
     const clearTimers = () => {
       if (delayTimer != null) clearTimeout(delayTimer);
       if (timeoutTimer != null) clearTimeout(timeoutTimer);
@@ -4372,28 +4853,34 @@ function defineClientAsyncComponent(loader, options) {
       end.remove();
     });
     const retryWith = (retryProps) => () => {
+      if (!alive) return;
+      const retryLoadId = ++loadId;
       loadPromise = null;
       status = "pending";
-      error4 = null;
+      loadError = null;
+      instanceRetryId++;
+      const capturedRetry = instanceRetryId;
       if (loading) render(loading);
-      load().then(() => settle(retryProps));
+      load(retryLoadId).then(() => {
+        if (alive && capturedRetry === instanceRetryId) settle(retryProps);
+      });
     };
     const settle = (renderProps) => {
       if (!alive) return;
       clearTimers();
       if (status === "resolved" && component) {
         render(component, renderProps);
-      } else if (status === "errored" && error4) {
-        if (errorComp) render(errorComp, { error: error4, retry: retryWith(renderProps) });
-        if (onError) onError(error4, retryWith(renderProps));
+      } else if (status === "errored" && loadError) {
+        if (errorComp) render(errorComp, { error: loadError, retry: retryWith(renderProps) });
+        if (onError) onError(loadError, retryWith(renderProps));
       }
     };
     if (status === "resolved" && component) {
       render(component, props);
       return frag;
     }
-    if (status === "errored" && error4) {
-      if (errorComp) render(errorComp, { error: error4, retry: retryWith(props) });
+    if (status === "errored" && loadError) {
+      if (errorComp) render(errorComp, { error: loadError, retry: retryWith(props) });
       return frag;
     }
     const pending = load().then(() => settle(props));
@@ -4408,10 +4895,9 @@ function defineClientAsyncComponent(loader, options) {
     if (timeout != null) {
       timeoutTimer = setTimeout(() => {
         if (!alive || status !== "pending") return;
-        error4 = new Error(`[defineAsyncComponent] Timeout after ${timeout}ms`);
-        status = "errored";
-        if (errorComp) render(errorComp, { error: error4, retry: retryWith(props) });
-        if (onError) onError(error4, retryWith(props));
+        const err = new Error(`[defineAsyncComponent] Timeout after ${timeout}ms`);
+        if (errorComp) render(errorComp, { error: err, retry: retryWith(props) });
+        if (onError) onError(err, retryWith(props));
       }, timeout);
     }
     return frag;
@@ -4430,9 +4916,11 @@ function For(props) {
   fragment.appendChild(marker);
   let entries = [];
   let fallbackNodes = [];
+  let fallbackScope = null;
+  const ownerScope = getActiveScope();
   const keyFn = props.key;
   const raw = props.children;
-  const renderFn = Array.isArray(raw) && raw.length === 1 && isFunction(raw[0]) ? raw[0] : props.children;
+  const renderFn = isArray(raw) && raw.length === 1 && isFunction(raw[0]) ? raw[0] : props.children;
   if (!isFunction(renderFn)) {
     throw new TypeError("<For> requires `children` to be a function (item, index) => Node");
   }
@@ -4444,9 +4932,31 @@ function For(props) {
     return input != null ? input : [];
   };
   const getKey = (item, index) => keyFn ? keyFn(item, index) : item;
+  const formatKeyForWarning = (key) => {
+    if (typeof key === "string") return JSON.stringify(key);
+    return String(key);
+  };
+  const getKeys = (items) => {
+    const keys = new Array(items.length);
+    {
+      const seen = /* @__PURE__ */ new Set();
+      for (const [i, item] of items.entries()) {
+        const key = getKey(item, i);
+        keys[i] = key;
+        if (seen.has(key)) {
+          warn(
+            `[For] duplicate key ${formatKeyForWarning(key)} detected. Duplicate keys may cause rows to remount or lose state.`
+          );
+        } else {
+          seen.add(key);
+        }
+      }
+      return keys;
+    }
+  };
   const mountValue = (value, parent, before) => {
     if (value == null || value === false) return [];
-    if (Array.isArray(value)) {
+    if (isArray(value)) {
       const nodes = [];
       for (const child2 of value) nodes.push(...mountValue(child2, parent, before));
       return nodes;
@@ -4460,17 +4970,30 @@ function For(props) {
     return [node];
   };
   const mountFallback = (parent, before) => {
+    var _a22;
     if (!props.fallback) return;
-    const nodes = mountValue(props.fallback(), parent, before);
-    fallbackNodes = nodes;
+    fallbackScope = createScope((_a22 = getActiveScope()) != null ? _a22 : ownerScope);
+    try {
+      runWithScope(fallbackScope, () => {
+        fallbackNodes = mountValue(props.fallback(), parent, before);
+      });
+    } catch (error4) {
+      disposeScope(fallbackScope);
+      fallbackScope = null;
+      fallbackNodes = [];
+      throw error4;
+    }
   };
   const clearFallback = () => {
+    if (fallbackScope) {
+      disposeScope(fallbackScope);
+      fallbackScope = null;
+    }
     for (const node of fallbackNodes) {
       removeNode(node);
     }
     fallbackNodes = [];
   };
-  const ownerScope = getActiveScope();
   const renderItem = (item, index, parent, before, key = getKey(item, index)) => {
     var _a22;
     const parentScope = (_a22 = getActiveScope()) != null ? _a22 : ownerScope;
@@ -4502,10 +5025,9 @@ function For(props) {
         mountFallback(fragment, marker);
       } else {
         entries = new Array(newItems.length);
-        let idx = 0;
-        for (const newItem of newItems) {
-          entries[idx] = renderItem(newItem, idx, fragment, marker);
-          idx++;
+        const newKeys = getKeys(newItems);
+        for (const [i, newItem] of newItems.entries()) {
+          entries[i] = renderItem(newItem, i, fragment, marker, newKeys[i]);
         }
       }
       return;
@@ -4531,10 +5053,13 @@ function For(props) {
       }
       entries = new Array(newLen);
       const batchFragment2 = document.createDocumentFragment();
+      const newKeys2 = getKeys(newItems);
       for (let i = 0; i < newLen; i++) {
-        entries[i] = renderItem(newItems[i], i, batchFragment2, null);
+        entries[i] = renderItem(newItems[i], i, batchFragment2, null, newKeys2[i]);
       }
-      parent.insertBefore(batchFragment2, marker);
+      untrack(() => {
+        parent.insertBefore(batchFragment2, marker);
+      });
       return;
     }
     const oldKeyMap = /* @__PURE__ */ new Map();
@@ -4551,10 +5076,7 @@ function For(props) {
     const newIndexToOldIndex = new Int32Array(newLen);
     let moved = false;
     let maxOldSeen = 0;
-    const newKeys = new Array(newLen);
-    for (let i = 0; i < newLen; i++) {
-      newKeys[i] = getKey(newItems[i], i);
-    }
+    const newKeys = getKeys(newItems);
     for (let i = 0; i < newLen; i++) {
       const item = newItems[i];
       const key = newKeys[i];
@@ -4569,7 +5091,7 @@ function For(props) {
           else maxOldSeen = oldIndex;
         } else {
           if (!batchFragment) batchFragment = document.createDocumentFragment();
-          disposeItem(reused);
+          untrack(() => disposeItem(reused));
           newEntries[i] = renderItem(item, i, batchFragment, null, key);
         }
       } else {
@@ -4580,28 +5102,30 @@ function For(props) {
     for (const list of oldKeyMap.values()) {
       for (const [entry] of list) toRemove.push(entry);
     }
-    for (const entry of toRemove) disposeItem(entry);
-    const lis = moved ? getSequence(newIndexToOldIndex) : [];
-    let lisCursor = lis.length - 1;
-    let nextNode = marker;
-    for (let i = newLen - 1; i >= 0; i--) {
-      const entry = newEntries[i];
-      const nodes = entry.nodes;
-      const isFresh = newIndexToOldIndex[i] === 0;
-      const inLis = !isFresh && moved && lisCursor >= 0 && i === lis[lisCursor];
-      if (inLis) {
-        lisCursor--;
-        for (let j = nodes.length - 1; j >= 0; j--) nextNode = nodes[j];
-        continue;
-      }
-      for (let j = nodes.length - 1; j >= 0; j--) {
-        const node = nodes[j];
-        if (node.nextSibling !== nextNode) {
-          parent.insertBefore(node, nextNode);
+    for (const entry of toRemove) untrack(() => disposeItem(entry));
+    untrack(() => {
+      const lis = moved ? getSequence(newIndexToOldIndex) : [];
+      let lisCursor = lis.length - 1;
+      let nextNode = marker;
+      for (let i = newLen - 1; i >= 0; i--) {
+        const entry = newEntries[i];
+        const nodes = entry.nodes;
+        const isFresh = newIndexToOldIndex[i] === 0;
+        const inLis = !isFresh && moved && lisCursor >= 0 && i === lis[lisCursor];
+        if (inLis) {
+          lisCursor--;
+          for (let j = nodes.length - 1; j >= 0; j--) nextNode = nodes[j];
+          continue;
+        }
+        for (let j = nodes.length - 1; j >= 0; j--) {
+          const node = nodes[j];
+          if (node.nextSibling !== nextNode) {
+            parent.insertBefore(node, nextNode);
+          }
+          nextNode = node;
         }
-        nextNode = node;
       }
-    }
+    });
     entries = newEntries;
   }
   onCleanup(() => {
@@ -4664,21 +5188,40 @@ function addClass(el, cls) {
 function removeClass(el, cls) {
   for (const c of cls.split(/\s+/)) if (c) el.classList.remove(c);
 }
-function nextFrame(cb) {
-  requestAnimationFrame(() => requestAnimationFrame(cb));
+function nextFrameCancellable(cb) {
+  let cancelled = false;
+  let innerId = null;
+  const outerId = requestAnimationFrame(() => {
+    if (cancelled) return;
+    innerId = requestAnimationFrame(cb);
+  });
+  return () => {
+    cancelled = true;
+    cancelAnimationFrame(outerId);
+    if (innerId != null) cancelAnimationFrame(innerId);
+  };
 }
 function forceReflow(el) {
   void el.offsetHeight;
 }
 function whenTransitionEnds(el, type, explicit, resolve2) {
   if (explicit != null) {
-    setTimeout(resolve2, explicit);
-    return;
+    let done2 = false;
+    const timer2 = setTimeout(() => {
+      if (done2) return;
+      done2 = true;
+      resolve2();
+    }, explicit);
+    return () => {
+      done2 = true;
+      clearTimeout(timer2);
+    };
   }
   const info = getTransitionInfo(el, type);
   if (!info) {
     resolve2();
-    return;
+    return () => {
+    };
   }
   let done = false;
   const finish = () => {
@@ -4688,9 +5231,18 @@ function whenTransitionEnds(el, type, explicit, resolve2) {
     el.removeEventListener(info.event, onEnd);
     resolve2();
   };
-  const onEnd = () => finish();
+  const onEnd = (event) => {
+    if (event.target !== el) return;
+    finish();
+  };
   el.addEventListener(info.event, onEnd);
   const timer = setTimeout(finish, info.timeout + 1);
+  return () => {
+    if (done) return;
+    done = true;
+    clearTimeout(timer);
+    el.removeEventListener(info.event, onEnd);
+  };
 }
 function resolveDuration(d, dir) {
   if (d == null) return null;
@@ -4699,7 +5251,7 @@ function resolveDuration(d, dir) {
 }
 function validateSlot(value) {
   if (value == null || value === false) return null;
-  if (Array.isArray(value)) {
+  if (isArray(value)) {
     {
       throw new Error(
         "[essor] <Transition> expects a single root child. Use <TransitionGroup> for multiple children."
@@ -4745,8 +5297,26 @@ function Transition(props) {
   let hasPending = false;
   let scheduled = false;
   let disposed = false;
+  let cancelEnterWait = null;
+  let cancelLeaveWait = null;
+  const stopEnterWait = () => {
+    cancelEnterWait == null ? void 0 : cancelEnterWait();
+    cancelEnterWait = null;
+  };
+  const stopLeaveWait = () => {
+    cancelLeaveWait == null ? void 0 : cancelLeaveWait();
+    cancelLeaveWait = null;
+  };
   const enter = (el, phase) => {
     var _a22;
+    stopEnterWait();
+    let cancelWait = null;
+    const stopWait = () => {
+      cancelWait == null ? void 0 : cancelWait();
+      cancelWait = null;
+      if (cancelEnterWait === stopWait) cancelEnterWait = null;
+    };
+    cancelEnterWait = stopWait;
     const prevLeave = el[LEAVE_CB];
     if (prevLeave) prevLeave(true);
     state = "entering";
@@ -4763,6 +5333,7 @@ function Transition(props) {
       var _a32, _b2;
       if (called) return;
       called = true;
+      stopWait();
       el[ENTER_CB] = void 0;
       if (useCss) {
         removeClass(el, fromCls);
@@ -4777,7 +5348,8 @@ function Transition(props) {
       }
     };
     el[ENTER_CB] = done;
-    nextFrame(() => {
+    cancelWait = nextFrameCancellable(() => {
+      cancelWait = null;
       if (called) return;
       if (useCss) {
         removeClass(el, fromCls);
@@ -4787,7 +5359,10 @@ function Transition(props) {
         props.onEnter(el, () => done(false));
       } else if (useCss) {
         const explicit = resolveDuration(props.duration, "enter");
-        whenTransitionEnds(el, props.type, explicit, () => done(false));
+        cancelWait = whenTransitionEnds(el, props.type, explicit, () => {
+          cancelWait = null;
+          done(false);
+        });
       } else {
         done(false);
       }
@@ -4795,6 +5370,14 @@ function Transition(props) {
   };
   const leave = (el, after) => {
     var _a22;
+    stopLeaveWait();
+    let cancelWait = null;
+    const stopWait = () => {
+      cancelWait == null ? void 0 : cancelWait();
+      cancelWait = null;
+      if (cancelLeaveWait === stopWait) cancelLeaveWait = null;
+    };
+    cancelLeaveWait = stopWait;
     const prevEnter = el[ENTER_CB];
     if (prevEnter) {
       prevEnter(true);
@@ -4811,6 +5394,7 @@ function Transition(props) {
       var _a32, _b2;
       if (called) return;
       called = true;
+      stopWait();
       el[LEAVE_CB] = void 0;
       if (useCss) {
         removeClass(el, classes.leaveFrom);
@@ -4832,7 +5416,8 @@ function Transition(props) {
       done(false);
       return;
     }
-    nextFrame(() => {
+    cancelWait = nextFrameCancellable(() => {
+      cancelWait = null;
       if (called) return;
       if (useCss) {
         removeClass(el, classes.leaveFrom);
@@ -4841,7 +5426,10 @@ function Transition(props) {
       if (props.onLeave) {
         props.onLeave(el, () => done(false));
       } else if (useCss) {
-        whenTransitionEnds(el, props.type, explicit, () => done(false));
+        cancelWait = whenTransitionEnds(el, props.type, explicit, () => {
+          cancelWait = null;
+          done(false);
+        });
       } else {
         done(false);
       }
@@ -4916,6 +5504,8 @@ function Transition(props) {
   });
   onCleanup(() => {
     disposed = true;
+    stopEnterWait();
+    stopLeaveWait();
     effectRunner.stop();
     for (const el of [currentEl, leavingEl]) {
       if (!el) continue;
@@ -4937,7 +5527,7 @@ function isTransition(node) {
 }
 function resolveItemElement(raw, parent) {
   if (raw == null || raw === false) return { el: null, comp: null };
-  if (Array.isArray(raw) && raw.length === 1) {
+  if (isArray(raw) && raw.length === 1) {
     return resolveItemElement(raw[0], parent);
   }
   if (isFunction(raw)) {
@@ -4992,7 +5582,7 @@ function TransitionGroup(props) {
   const moveClass = (_c = props.moveClass) != null ? _c : `${(_b2 = props.name) != null ? _b2 : "v"}-move`;
   const keyFn = props.key;
   const rawChildren = props.children;
-  const childrenFn = Array.isArray(rawChildren) && rawChildren.length === 1 && isFunction(rawChildren[0]) ? rawChildren[0] : props.children;
+  const childrenFn = isArray(rawChildren) && rawChildren.length === 1 && isFunction(rawChildren[0]) ? rawChildren[0] : props.children;
   if (!isFunction(childrenFn) || !isFunction(keyFn)) {
     throw new TypeError(
       "<TransitionGroup> requires `children: (item, index) => Node` and `key: (item, index) => unknown`"
@@ -5043,9 +5633,12 @@ function TransitionGroup(props) {
     if (entry.el.parentNode === wrapper) wrapper.removeChild(entry.el);
   };
   const disposeEntry = (entry) => {
-    var _a32, _b22;
+    var _a32, _b22, _c2, _d, _e;
     (_a32 = entry.cancelEnter) == null ? void 0 : _a32.call(entry, true);
     (_b22 = entry.cancelLeave) == null ? void 0 : _b22.call(entry, true);
+    (_c2 = entry.cancelEnterWait) == null ? void 0 : _c2.call(entry);
+    (_d = entry.cancelLeaveWait) == null ? void 0 : _d.call(entry);
+    (_e = entry.cancelMoveWait) == null ? void 0 : _e.call(entry);
     if (entry.comp) entry.comp.destroy();
     detachEntryDom(entry);
     disposeScope(entry.scope);
@@ -5064,23 +5657,26 @@ function TransitionGroup(props) {
     addClass(el, classes.enterActive);
     let called = false;
     const done = (cancelled) => {
-      var _a42, _b3;
+      var _a42, _b3, _c3;
       if (called) return;
       called = true;
       entry.cancelEnter = void 0;
+      (_a42 = entry.cancelEnterWait) == null ? void 0 : _a42.call(entry);
+      entry.cancelEnterWait = void 0;
       removeClass(el, classes.enterFrom);
       removeClass(el, classes.enterActive);
       removeClass(el, classes.enterTo);
       if (cancelled) {
-        (_a42 = props.onEnterCancelled) == null ? void 0 : _a42.call(props, el);
+        (_b3 = props.onEnterCancelled) == null ? void 0 : _b3.call(props, el);
       } else {
         entry.state = "present";
-        (_b3 = props.onAfterEnter) == null ? void 0 : _b3.call(props, el);
+        (_c3 = props.onAfterEnter) == null ? void 0 : _c3.call(props, el);
       }
     };
     entry.cancelEnter = done;
     entry.state = "entering";
-    nextFrame(() => {
+    entry.cancelEnterWait = nextFrameCancellable(() => {
+      entry.cancelEnterWait = void 0;
       if (called) return;
       removeClass(el, classes.enterFrom);
       addClass(el, classes.enterTo);
@@ -5088,7 +5684,10 @@ function TransitionGroup(props) {
         props.onEnter(el, () => done(false));
       } else {
         const explicit = resolveDuration(props.duration, "enter");
-        whenTransitionEnds(el, props.type, explicit, () => done(false));
+        entry.cancelEnterWait = whenTransitionEnds(el, props.type, explicit, () => {
+          entry.cancelEnterWait = void 0;
+          done(false);
+        });
       }
     });
   };
@@ -5120,17 +5719,19 @@ function TransitionGroup(props) {
     addClass(el, classes.leaveActive);
     let called = false;
     const done = (cancelled) => {
-      var _a42, _b3;
+      var _a42, _b3, _c2;
       if (called) return;
       called = true;
       entry.cancelLeave = void 0;
+      (_a42 = entry.cancelLeaveWait) == null ? void 0 : _a42.call(entry);
+      entry.cancelLeaveWait = void 0;
       removeClass(el, classes.leaveFrom);
       removeClass(el, classes.leaveActive);
       removeClass(el, classes.leaveTo);
       if (cancelled) {
         if (entry.savedStyles) restoreStyles(el, entry.savedStyles);
         entry.savedStyles = void 0;
-        (_a42 = props.onLeaveCancelled) == null ? void 0 : _a42.call(props, el);
+        (_b3 = props.onLeaveCancelled) == null ? void 0 : _b3.call(props, el);
         return;
       }
       if (entry.savedStyles) restoreStyles(el, entry.savedStyles);
@@ -5138,10 +5739,11 @@ function TransitionGroup(props) {
       detachEntryDom(entry);
       disposeScope(entry.scope);
       if (entry.comp) entry.comp.destroy();
-      (_b3 = props.onAfterLeave) == null ? void 0 : _b3.call(props, el);
+      (_c2 = props.onAfterLeave) == null ? void 0 : _c2.call(props, el);
     };
     entry.cancelLeave = done;
-    nextFrame(() => {
+    entry.cancelLeaveWait = nextFrameCancellable(() => {
+      entry.cancelLeaveWait = void 0;
       if (called) return;
       removeClass(el, classes.leaveFrom);
       addClass(el, classes.leaveTo);
@@ -5149,11 +5751,15 @@ function TransitionGroup(props) {
         props.onLeave(el, () => done(false));
       } else {
         const explicit = resolveDuration(props.duration, "leave");
-        whenTransitionEnds(el, props.type, explicit, () => done(false));
+        entry.cancelLeaveWait = whenTransitionEnds(el, props.type, explicit, () => {
+          entry.cancelLeaveWait = void 0;
+          done(false);
+        });
       }
     });
   };
   const runMove = (entry, prevRect) => {
+    var _a32;
     if (!useCss || entry.state !== "present") return;
     const el = entry.el;
     const newRect = el.getBoundingClientRect();
@@ -5169,7 +5775,9 @@ function TransitionGroup(props) {
     el.style.transform = savedTransform;
     el.style.transitionDuration = savedTransition;
     const explicit = resolveDuration(props.duration, "enter");
-    whenTransitionEnds(el, props.type, explicit, () => {
+    (_a32 = entry.cancelMoveWait) == null ? void 0 : _a32.call(entry);
+    entry.cancelMoveWait = whenTransitionEnds(el, props.type, explicit, () => {
+      entry.cancelMoveWait = void 0;
       removeClass(el, moveClass);
     });
   };
@@ -5278,6 +5886,6 @@ if (globalThis) {
   globalThis.__essor_version__ = __version;
 }
 
-export { Component, EffectScope, For, Fragment, Portal, Suspense, Transition, TransitionGroup, TriggerOpTypes, __version, addEvent, addEventListener, batch, beginHydration, bindElement, child, clearDelegatedEvents, computed, consumeTeleportAnchor, consumeTeleportBlock, createApp, createComponent, createResource, createStore, defineAsyncComponent, delegateEvents, effect, effectScope, endBatch, endHydration, getBatchDepth, getCurrentScope, getHydrationKey, getRenderedElement, hydrate, hydrationAnchor, hydrationMarker, inject, insert, isBatching, isComponent, isComputed, isEffect, isFragment, isHydrating, isPortal, isReactive, isRef, isShallow, isSignal, isSuspense, isTransition, isTransitionGroup, memoEffect, next, nextTick, normalizeClass, nthChild, omitProps, onDestroy, onMount, onScopeDispose, onUpdate, patchAttr, patchAttrHydrate, patchClass, patchClassHydrate, patchStyle, patchStyleHydrate, provide, queueJob, queuePreFlushCb, reactive, ref, resetHydrationKey, setCurrentScope, setStyle, shallowReactive, shallowSignal, signal, startBatch, stop, template, toRaw, toReactive, trigger, untrack, watch };
+export { Component, EffectScope, For, Fragment, Portal, Suspense, Transition, TransitionGroup, TriggerOpTypes, __version, addEvent, addEventListener, batch, beginHydration, bindElement, child, clearDelegatedEvents, computed, consumeTeleportAnchor, consumeTeleportBlock, createApp, createComponent, createResource, createStore, defineAsyncComponent, delegateEvents, effect, effectScope, endBatch, endHydration, getBatchDepth, getCurrentScope, getHydrationKey, getRenderedElement, getTargetDepSize, hydrate, hydrationAnchor, hydrationMarker, inject, insert, isBatching, isComponent, isComputed, isEffect, isFragment, isHydrating, isPortal, isReactive, isRef, isShallow, isSignal, isSuspense, isTransition, isTransitionGroup, memoEffect, next, nextTick, normalizeClass, nthChild, omitProps, onDestroy, onMount, onScopeDispose, onUpdate, patchAttr, patchAttrHydrate, patchClass, patchClassHydrate, patchStyle, patchStyleHydrate, provide, queueJob, queuePostFlushJob, queuePreFlushCb, reactive, ref, resetHydrationKey, setCurrentScope, setStyle, shallowReactive, shallowSignal, signal, startBatch, stop, template, toRaw, toReactive, toRef, toRefs, trigger, unref, untrack, watch };
 //# sourceMappingURL=essor.browser.dev.js.map
 //# sourceMappingURL=essor.browser.dev.js.map