@solidjs/signals 0.9.4 → 0.9.6

package/dist/dev.js

@@ -25,12 +25,14 @@ const REACTIVE_IN_HEAP = 1 << 3;
 const REACTIVE_IN_HEAP_HEIGHT = 1 << 4;
 const REACTIVE_ZOMBIE = 1 << 5;
 const REACTIVE_DISPOSED = 1 << 6;
+const REACTIVE_OPTIMISTIC_DIRTY = 1 << 7;
 const STATUS_NONE = 0;
 const STATUS_PENDING = 1 << 0;
 const STATUS_ERROR = 1 << 1;
 const STATUS_UNINITIALIZED = 1 << 2;
 const EFFECT_RENDER = 1;
 const EFFECT_USER = 2;
+const EFFECT_TRACKED = 3;
 const NOT_PENDING = {};
 const SUPPORTS_PROXY = typeof Proxy === "function";
 const defaultContext = {};
@@ -133,20 +135,28 @@ function adjustHeight(el, heap) {
   }
 }
 const transitions = new Set();
-let optimisticRun = false;
 const dirtyQueue = { _heap: new Array(2e3).fill(undefined), _marked: false, _min: 0, _max: 0 };
 const zombieQueue = { _heap: new Array(2e3).fill(undefined), _marked: false, _min: 0, _max: 0 };
 let clock = 0;
 let activeTransition = null;
 let scheduled = false;
+let optimisticReadActive = false;
+let projectionWriteActive = false;
+function setOptimisticReadActive(value) {
+  optimisticReadActive = value;
+}
+function setProjectionWriteActive(value) {
+  projectionWriteActive = value;
+}
 function schedule() {
   if (scheduled) return;
   scheduled = true;
-  if (!globalQueue._running) Promise.resolve().then(() => queueMicrotask(flush));
+  if (!globalQueue._running) queueMicrotask(flush);
 }
 class Queue {
   _parent = null;
   _queues = [[], []];
+  _optimisticQueues = [[], []];
   _children = [];
   created = clock;
   addChild(child) {
@@ -164,18 +174,27 @@ class Queue {
     if (this._parent) return this._parent.notify(node, mask, flags);
     return false;
   }
-  run(type) {
-    if (this._queues[type - 1].length) {
-      const effects = this._queues[type - 1];
-      this._queues[type - 1] = [];
+  _runQueue(type, queues, method) {
+    if (queues[type - 1].length) {
+      const effects = queues[type - 1];
+      queues[type - 1] = [];
       runQueue(effects, type);
     }
     for (let i = 0; i < this._children.length; i++) {
-      this._children[i].run(type);
+      this._children[i][method]?.(type);
     }
   }
+  run(type) {
+    this._runQueue(type, this._queues, "run");
+  }
+  runOptimistic(type) {
+    this._runQueue(type, this._optimisticQueues, "runOptimistic");
+  }
   enqueue(type, fn) {
-    if (type) this._queues[type - 1].push(fn);
+    if (type) {
+      const queue = optimisticReadActive ? this._optimisticQueues : this._queues;
+      queue[type - 1].push(fn);
+    }
     schedule();
   }
   stashQueues(stub) {
@@ -206,38 +225,50 @@ class GlobalQueue extends Queue {
   _running = false;
   _pendingNodes = [];
   _optimisticNodes = [];
+  _optimisticStores = new Set();
   static _update;
   static _dispose;
+  static _clearOptimisticStore = null;
   flush() {
     if (this._running) return;
     this._running = true;
     try {
       runHeap(dirtyQueue, GlobalQueue._update);
       if (activeTransition) {
-        if (!transitionComplete(activeTransition)) {
+        const isComplete = transitionComplete(activeTransition);
+        if (!isComplete) {
           let t = activeTransition;
           runHeap(zombieQueue, GlobalQueue._update);
           this._pendingNodes = [];
+          this._optimisticNodes = [];
+          this._optimisticStores = new Set();
+          this.runOptimistic(EFFECT_RENDER);
+          this.runOptimistic(EFFECT_USER);
           this.stashQueues(activeTransition.queueStash);
           clock++;
           scheduled = false;
-          runTransitionPending(activeTransition.pendingNodes, true);
+          runTransitionPending(activeTransition.pendingNodes);
           activeTransition = null;
-          runOptimistic(t);
+          finalizePureQueue(null, true);
           return;
         }
-        this._pendingNodes.push(...activeTransition.pendingNodes);
-        this._optimisticNodes !== activeTransition.optimisticNodes &&
-          this._optimisticNodes.push(...activeTransition.optimisticNodes);
+        this._pendingNodes !== activeTransition.pendingNodes &&
+          this._pendingNodes.push(...activeTransition.pendingNodes);
         this.restoreQueues(activeTransition.queueStash);
         transitions.delete(activeTransition);
+        const completingTransition = activeTransition;
         activeTransition = null;
-        runTransitionPending(this._pendingNodes, false);
-      } else if (transitions.size) runHeap(zombieQueue, GlobalQueue._update);
-      runOptimistic();
+        runTransitionPending(this._pendingNodes);
+        finalizePureQueue(completingTransition);
+      } else {
+        if (transitions.size) runHeap(zombieQueue, GlobalQueue._update);
+        finalizePureQueue();
+      }
       clock++;
-      scheduled = false;
+      scheduled = dirtyQueue._max >= dirtyQueue._min;
+      this.runOptimistic(EFFECT_RENDER);
       this.run(EFFECT_RENDER);
+      this.runOptimistic(EFFECT_USER);
       this.run(EFFECT_USER);
     } finally {
       this._running = false;
@@ -246,7 +277,11 @@ class GlobalQueue extends Queue {
   notify(node, mask, flags) {
     if (mask & STATUS_PENDING) {
       if (flags & STATUS_PENDING) {
-        if (activeTransition && !activeTransition.asyncNodes.includes(node._error.cause)) {
+        if (
+          activeTransition &&
+          node._error &&
+          !activeTransition.asyncNodes.includes(node._error.cause)
+        ) {
           activeTransition.asyncNodes.push(node._error.cause);
           schedule();
         }
@@ -255,18 +290,26 @@ class GlobalQueue extends Queue {
     }
     return false;
   }
-  initTransition(node) {
-    if (activeTransition && activeTransition.time === clock) return;
+  initTransition(transition) {
+    if (transition) transition = currentTransition(transition);
+    if (transition && transition === activeTransition) return;
+    if (!transition && activeTransition && activeTransition.time === clock) return;
     if (!activeTransition) {
-      activeTransition = node?._transition ?? {
+      activeTransition = transition ?? {
         time: clock,
         pendingNodes: [],
         asyncNodes: [],
         optimisticNodes: [],
+        optimisticStores: new Set(),
         actions: [],
         queueStash: { _queues: [[], []], _children: [] },
         done: false
       };
+    } else if (transition) {
+      activeTransition.done = transition;
+      transition.actions.push(...activeTransition.actions);
+      transitions.delete(activeTransition);
+      activeTransition = transition;
     }
     transitions.add(activeTransition);
     activeTransition.time = clock;
@@ -275,65 +318,86 @@ class GlobalQueue extends Queue {
       n._transition = activeTransition;
       activeTransition.pendingNodes.push(n);
     }
+    this._pendingNodes = activeTransition.pendingNodes;
     for (let i = 0; i < this._optimisticNodes.length; i++) {
-      const n = this._optimisticNodes[i];
-      n._transition = activeTransition;
-      activeTransition.optimisticNodes.push(n);
+      const node = this._optimisticNodes[i];
+      node._transition = activeTransition;
+      activeTransition.optimisticNodes.push(node);
     }
-    this._pendingNodes = activeTransition.pendingNodes;
     this._optimisticNodes = activeTransition.optimisticNodes;
+    for (const store of this._optimisticStores) {
+      activeTransition.optimisticStores.add(store);
+    }
+    this._optimisticStores = activeTransition.optimisticStores;
   }
 }
-function notifySubs(node) {
+function insertSubs(node, optimistic = false) {
   for (let s = node._subs; s !== null; s = s._nextSub) {
+    if (optimistic) s._sub._flags |= REACTIVE_OPTIMISTIC_DIRTY;
+    const sub = s._sub;
+    if (sub._type === EFFECT_TRACKED) {
+      if (!sub._modified) {
+        sub._modified = true;
+        sub._queue.enqueue(EFFECT_USER, sub._run);
+      }
+      continue;
+    }
     const queue = s._sub._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
     if (queue._min > s._sub._height) queue._min = s._sub._height;
     insertIntoHeap(s._sub, queue);
   }
 }
-function runOptimistic(activeTransition = null) {
-  let resolvePending = !activeTransition;
-  const optimisticNodes = globalQueue._optimisticNodes;
-  optimisticRun = true;
-  for (let i = 0; i < optimisticNodes.length; i++) {
-    const n = optimisticNodes[i];
-    if (
-      !activeTransition &&
-      (!n._transition || n._transition.done) &&
-      n._pendingValue !== NOT_PENDING
-    ) {
-      n._value = n._pendingValue;
-      n._pendingValue = NOT_PENDING;
-    }
-    n._transition = activeTransition;
-    notifySubs(n);
-  }
-  globalQueue._optimisticNodes = [];
+function finalizePureQueue(completingTransition = null, incomplete = false) {
+  let resolvePending = !incomplete;
   if (dirtyQueue._max >= dirtyQueue._min) {
     resolvePending = true;
     runHeap(dirtyQueue, GlobalQueue._update);
   }
-  optimisticRun = false;
-  resolvePending && runPending(globalQueue._pendingNodes);
-}
-function runPending(pendingNodes) {
-  for (let i = 0; i < pendingNodes.length; i++) {
-    const n = pendingNodes[i];
-    if (n._pendingValue !== NOT_PENDING) {
-      n._value = n._pendingValue;
+  if (resolvePending) {
+    const pendingNodes = globalQueue._pendingNodes;
+    for (let i = 0; i < pendingNodes.length; i++) {
+      const n = pendingNodes[i];
+      if (n._pendingValue !== NOT_PENDING) {
+        n._value = n._pendingValue;
+        n._pendingValue = NOT_PENDING;
+        if (n._type && n._type !== EFFECT_TRACKED) n._modified = true;
+      }
+      if (n._fn) GlobalQueue._dispose(n, false, true);
+    }
+    pendingNodes.length = 0;
+    const optimisticNodes = completingTransition
+      ? completingTransition.optimisticNodes
+      : globalQueue._optimisticNodes;
+    for (let i = 0; i < optimisticNodes.length; i++) {
+      const n = optimisticNodes[i];
+      const original = n._pendingValue;
+      if (original !== NOT_PENDING && n._value !== original) {
+        n._value = original;
+        insertSubs(n, true);
+      }
       n._pendingValue = NOT_PENDING;
-      if (n._type) n._modified = true;
+      n._transition = null;
+    }
+    optimisticNodes.length = 0;
+    const optimisticStores = completingTransition
+      ? completingTransition.optimisticStores
+      : globalQueue._optimisticStores;
+    if (GlobalQueue._clearOptimisticStore && optimisticStores.size) {
+      for (const store of optimisticStores) {
+        GlobalQueue._clearOptimisticStore(store);
+      }
+      optimisticStores.clear();
+      schedule();
     }
-    if (n._fn) GlobalQueue._dispose(n, false, true);
   }
-  pendingNodes.length = 0;
 }
-function runTransitionPending(pendingNodes, value) {
-  const p = pendingNodes.slice();
-  for (let i = 0; i < p.length; i++) {
-    const n = p[i];
-    n._transition = activeTransition;
-    if (n._pendingCheck) n._pendingCheck._set(value);
+function trackOptimisticStore(store) {
+  globalQueue._optimisticStores.add(store);
+  schedule();
+}
+function runTransitionPending(pendingNodes) {
+  for (let i = 0; i < pendingNodes.length; i++) {
+    pendingNodes[i]._transition = activeTransition;
   }
 }
 const globalQueue = new GlobalQueue();
@@ -360,54 +424,81 @@ function transitionComplete(transition) {
   done && (transition.done = true);
   return done;
 }
+function currentTransition(transition) {
+  while (transition.done && typeof transition.done === "object") transition = transition.done;
+  return transition;
+}
 function runInTransition(transition, fn) {
   const prevTransition = activeTransition;
   try {
-    activeTransition = transition;
+    activeTransition = currentTransition(transition);
     return fn();
   } finally {
     activeTransition = prevTransition;
   }
 }
+function restoreTransition(transition, fn) {
+  globalQueue.initTransition(transition);
+  const result = fn();
+  flush();
+  return result;
+}
 function action(genFn) {
-  return (...args) => {
-    const iterator = genFn(...args);
-    globalQueue.initTransition();
-    let ctx = activeTransition;
-    ctx.actions.push(iterator);
-    const step = input => {
-      let nextValue = iterator.next(input);
-      if (nextValue instanceof Promise) return nextValue.then(process);
-      process(nextValue);
-    };
-    const process = result => {
-      if (result.done) {
-        ctx.actions.splice(ctx.actions.indexOf(iterator), 1);
+  return (...args) =>
+    new Promise((resolve, reject) => {
+      const it = genFn(...args);
+      globalQueue.initTransition();
+      let ctx = activeTransition;
+      ctx.actions.push(it);
+      const done = (v, e) => {
+        ctx = currentTransition(ctx);
+        const i = ctx.actions.indexOf(it);
+        if (i >= 0) ctx.actions.splice(i, 1);
         activeTransition = ctx;
         schedule();
-        flush();
-        return;
-      }
-      const yielded = result.value;
-      if (yielded instanceof Promise) return yielded.then(step);
-      runInTransition(ctx, () => step(yielded));
-    };
-    runInTransition(ctx, () => step());
-  };
+        e ? reject(e) : resolve(v);
+      };
+      const step = (v, err) => {
+        let r;
+        try {
+          r = err ? it.throw(v) : it.next(v);
+        } catch (e) {
+          return done(undefined, e);
+        }
+        if (r instanceof Promise)
+          return void r.then(run, e => restoreTransition(ctx, () => step(e, true)));
+        run(r);
+      };
+      const run = r => {
+        if (r.done) return done(r.value);
+        if (r.value instanceof Promise)
+          return void r.value.then(
+            v => restoreTransition(ctx, () => step(v)),
+            e => restoreTransition(ctx, () => step(e, true))
+          );
+        restoreTransition(ctx, () => step(r.value));
+      };
+      step();
+    });
 }
 GlobalQueue._update = recompute;
 GlobalQueue._dispose = disposeChildren;
 let tracking = false;
 let stale = false;
-let pendingValueCheck = false;
-let pendingCheck = null;
 let refreshing = false;
+let pendingCheckActive = false;
+let foundPending = false;
+let pendingReadActive = false;
 let context = null;
+let leafEffectActive = false;
+function setLeafEffectActive(v) {
+  leafEffectActive = v;
+}
 function recompute(el, create = false) {
-  const honoraryOptimistic = el._type && el._transition != activeTransition;
+  const isEffect = el._type;
   if (!create) {
-    if (el._transition && activeTransition !== el._transition && !honoraryOptimistic)
-      globalQueue.initTransition(el);
+    if (el._transition && (!isEffect || activeTransition) && activeTransition !== el._transition)
+      globalQueue.initTransition(el._transition);
     deleteFromHeap(el, el._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
     if (el._transition) disposeChildren(el);
     else {
@@ -418,35 +509,33 @@ function recompute(el, create = false) {
       el._firstChild = null;
     }
   }
+  const isOptimisticDirty = !!(el._flags & REACTIVE_OPTIMISTIC_DIRTY);
+  const hasOptimisticOverride = el._optimistic && el._pendingValue !== NOT_PENDING;
   const oldcontext = context;
   context = el;
   el._depsTail = null;
   el._flags = REACTIVE_RECOMPUTING_DEPS;
   el._time = clock;
-  let value =
-    el._pendingValue === NOT_PENDING || (el._optimistic && el._transition)
-      ? el._value
-      : el._pendingValue;
+  let value = el._pendingValue === NOT_PENDING ? el._value : el._pendingValue;
   let oldHeight = el._height;
-  let prevStatusFlags = el._statusFlags;
-  let prevError = el._error;
   let prevTracking = tracking;
-  setStatusFlags(el, STATUS_NONE | (prevStatusFlags & STATUS_UNINITIALIZED));
+  let prevOptimisticRead = optimisticReadActive;
   tracking = true;
+  if (isOptimisticDirty) setOptimisticReadActive(true);
   try {
     value = handleAsync(el, el._fn(value));
-    el._statusFlags &= ~STATUS_UNINITIALIZED;
+    clearStatus(el);
   } catch (e) {
     if (e instanceof NotReadyError) {
       if (e.cause !== el) link(e.cause, el);
-      setStatusFlags(el, (prevStatusFlags & ~STATUS_ERROR) | STATUS_PENDING, e);
-    } else setStatusFlags(el, STATUS_ERROR, e);
+      notifyStatus(el, STATUS_PENDING, e);
+    } else notifyStatus(el, STATUS_ERROR, e);
   } finally {
     tracking = prevTracking;
+    el._flags = REACTIVE_NONE;
+    context = oldcontext;
   }
-  el._flags = REACTIVE_NONE;
-  context = oldcontext;
-  if (!(el._statusFlags & STATUS_PENDING)) {
+  if (!el._error) {
     const depsTail = el._depsTail;
     let toRemove = depsTail !== null ? depsTail._nextDep : el._deps;
     if (toRemove !== null) {
@@ -456,83 +545,158 @@ function recompute(el, create = false) {
       if (depsTail !== null) depsTail._nextDep = null;
       else el._deps = null;
     }
-  }
-  const valueChanged =
-    !el._equals ||
-    !el._equals(
-      el._pendingValue === NOT_PENDING || (el._optimistic && el._transition) || honoraryOptimistic
-        ? el._value
-        : el._pendingValue,
-      value
-    );
-  const statusFlagsChanged = el._statusFlags !== prevStatusFlags || el._error !== prevError;
-  el._notifyQueue?.(statusFlagsChanged, prevStatusFlags);
-  if (valueChanged || statusFlagsChanged) {
+    const valueChanged =
+      !el._equals ||
+      !el._equals(el._pendingValue === NOT_PENDING ? el._value : el._pendingValue, value);
     if (valueChanged) {
-      if (create || el._optimistic || honoraryOptimistic) el._value = value;
+      if (create || (isEffect && activeTransition !== el._transition) || isOptimisticDirty)
+        el._value = value;
       else el._pendingValue = value;
-      if (el._pendingSignal) setSignal(el._pendingSignal, value);
-    }
-    (!el._optimistic || optimisticRun) && notifySubs(el);
-  } else if (el._height != oldHeight) {
-    for (let s = el._subs; s !== null; s = s._nextSub) {
-      insertIntoHeapHeight(s._sub, s._sub._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+      insertSubs(el, isOptimisticDirty || hasOptimisticOverride);
+    } else if (el._height != oldHeight) {
+      for (let s = el._subs; s !== null; s = s._nextSub) {
+        insertIntoHeapHeight(s._sub, s._sub._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+      }
     }
   }
-  el._optimistic && !optimisticRun && globalQueue._optimisticNodes.push(el);
+  setOptimisticReadActive(prevOptimisticRead);
   (!create || el._statusFlags & STATUS_PENDING) &&
     !el._transition &&
     globalQueue._pendingNodes.push(el);
-  el._transition && honoraryOptimistic && runInTransition(el._transition, () => recompute(el));
+  el._transition &&
+    isEffect &&
+    activeTransition !== el._transition &&
+    runInTransition(el._transition, () => recompute(el));
 }
 function handleAsync(el, result, setter) {
   const isObject = typeof result === "object" && result !== null;
-  const isPromise = isObject && result instanceof Promise;
   const iterator = isObject && untrack(() => result[Symbol.asyncIterator]);
-  if (!isPromise && !iterator) {
+  const isThenable = !iterator && isObject && untrack(() => typeof result.then === "function");
+  if (!isThenable && !iterator) {
     el._inFlight = null;
     return result;
   }
   el._inFlight = result;
-  if (isPromise) {
-    result
-      .then(value => {
-        if (el._inFlight !== result) return;
-        globalQueue.initTransition(el);
-        setter?.(value) ?? setSignal(el, () => value);
-        flush();
-      })
-      .catch(e => {
-        if (el._inFlight !== result) return;
-        globalQueue.initTransition(el);
-        setStatusFlags(el, STATUS_ERROR, e);
-        el._time = clock;
-        notifySubs(el);
-        schedule();
-        flush();
-      });
+  let syncValue;
+  const handleError = error => {
+    if (el._inFlight !== result) return;
+    globalQueue.initTransition(el._transition);
+    if (error instanceof NotReadyError) {
+      if (error.cause !== el) link(error.cause, el);
+      notifyStatus(el, STATUS_PENDING, error);
+    } else notifyStatus(el, STATUS_ERROR, error);
+    el._time = clock;
+  };
+  const asyncWrite = (value, then) => {
+    if (el._inFlight !== result) return;
+    globalQueue.initTransition(el._transition);
+    clearStatus(el);
+    if (setter) setter(value);
+    else if (el._optimistic) {
+      const hasOverride = el._pendingValue !== NOT_PENDING;
+      if (el._fn) el._pendingValue = value;
+      if (!hasOverride) {
+        el._value = value;
+        insertSubs(el);
+      }
+      el._time = clock;
+      schedule();
+    } else setSignal(el, () => value);
+    flush();
+    then?.();
+  };
+  if (isThenable) {
+    let resolved = false,
+      isSync = true;
+    result.then(
+      v => {
+        if (isSync) {
+          syncValue = v;
+          resolved = true;
+        } else asyncWrite(v);
+      },
+      e => {
+        if (!isSync) handleError(e);
+      }
+    );
+    isSync = false;
+    if (!resolved) {
+      globalQueue.initTransition(el._transition);
+      throw new NotReadyError(context);
+    }
+  }
+  if (iterator) {
+    const it = result[Symbol.asyncIterator]();
+    let hadSyncValue = false;
+    const iterate = () => {
+      let syncResult,
+        resolved = false,
+        isSync = true;
+      it.next().then(
+        r => {
+          if (isSync) {
+            syncResult = r;
+            resolved = true;
+          } else if (!r.done) asyncWrite(r.value, iterate);
+        },
+        e => {
+          if (!isSync) handleError(e);
+        }
+      );
+      isSync = false;
+      if (resolved && !syncResult.done) {
+        syncValue = syncResult.value;
+        hadSyncValue = true;
+        return iterate();
+      }
+      return resolved && syncResult.done;
+    };
+    const immediatelyDone = iterate();
+    if (!hadSyncValue && !immediatelyDone) {
+      globalQueue.initTransition(el._transition);
+      throw new NotReadyError(context);
+    }
+  }
+  return syncValue;
+}
+function clearStatus(el) {
+  el._statusFlags = STATUS_NONE;
+  el._error = null;
+  updatePendingSignal(el);
+  if (el._notifyStatus) {
+    el._notifyStatus();
   } else {
-    (async () => {
-      try {
-        for await (let value of result) {
-          if (el._inFlight !== result) return;
-          globalQueue.initTransition(el);
-          setter?.(value) ?? setSignal(el, () => value);
-          flush();
+    if (!el._transition) {
+      for (let s = el._subs; s !== null; s = s._nextSub) {
+        if (s._sub._statusFlags & STATUS_PENDING) {
+          insertIntoHeap(s._sub, s._sub._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
         }
-      } catch (error) {
-        if (el._inFlight !== result) return;
-        globalQueue.initTransition(el);
-        setStatusFlags(el, STATUS_ERROR, error);
-        el._time = clock;
-        notifySubs(el);
-        schedule();
-        flush();
       }
-    })();
+    }
+    schedule();
+  }
+}
+function notifyStatus(el, status, error) {
+  el._statusFlags = status | (el._statusFlags & STATUS_UNINITIALIZED);
+  el._error = error;
+  updatePendingSignal(el);
+  if (el._notifyStatus) return el._notifyStatus();
+  for (let s = el._subs; s !== null; s = s._nextSub) {
+    s._sub._time = clock;
+    if (s._sub._error !== error) {
+      !s._sub._transition && globalQueue._pendingNodes.push(s._sub);
+      notifyStatus(s._sub, status, error);
+    }
+  }
+  for (let child = el._child; child !== null; child = child._nextChild) {
+    for (let s = child._subs; s !== null; s = s._nextSub) {
+      s._sub._time = clock;
+      if (s._sub._error !== error) {
+        !s._sub._transition && globalQueue._pendingNodes.push(s._sub);
+        notifyStatus(s._sub, status, error);
+      }
+    }
   }
-  globalQueue.initTransition(el);
-  throw new NotReadyError(context);
 }
 function updateIfNecessary(el) {
   if (el._flags & REACTIVE_CHECK) {
@@ -614,10 +778,6 @@ function isValidLink(checkLink, sub) {
   }
   return false;
 }
-function setStatusFlags(signal, flags, error = null) {
-  signal._statusFlags = flags;
-  signal._error = error;
-}
 function markDisposal(el) {
   let child = el._firstChild;
   while (child) {
@@ -720,10 +880,12 @@ function computed(fn, initialValue, options) {
     _inFlight: null,
     _transition: null
   };
-  if (options?._internal) Object.assign(self, options._internal);
   self._name = options?.name ?? "computed";
   self._prevHeap = self;
   const parent = context?._root ? context._parentComputed : context;
+  if (leafEffectActive && context) {
+    throw new Error("Cannot create reactive primitives inside createTrackedEffect");
+  }
   if (context) {
     const lastChild = context._firstChild;
     if (lastChild === null) {
@@ -739,14 +901,12 @@ function computed(fn, initialValue, options) {
 }
 function signal(v, options, firewall = null) {
   const s = {
-    id: options?.id ?? (context?.id != null ? getNextChildId(context) : undefined),
     _equals: options?.equals != null ? options.equals : isEqual,
     _pureWrite: !!options?.pureWrite,
     _unobserved: options?.unobserved,
     _value: v,
     _subs: null,
     _subsTail: null,
-    _statusFlags: STATUS_NONE,
     _time: clock,
     _firewall: firewall,
     _nextChild: firewall?._child || null,
@@ -756,6 +916,40 @@ function signal(v, options, firewall = null) {
   firewall && (firewall._child = s);
   return s;
 }
+function optimisticSignal(v, options) {
+  const s = signal(v, options);
+  s._optimistic = true;
+  return s;
+}
+function optimisticComputed(fn, initialValue, options) {
+  const c = computed(fn, initialValue, options);
+  c._optimistic = true;
+  return c;
+}
+function getPendingSignal(el) {
+  if (!el._pendingSignal) {
+    el._pendingSignal = optimisticSignal(false, { pureWrite: true });
+    if (computePendingState(el)) setSignal(el._pendingSignal, true);
+  }
+  return el._pendingSignal;
+}
+function computePendingState(el) {
+  if (el._pendingValue !== NOT_PENDING) return true;
+  const comp = el;
+  return !!(comp._statusFlags & STATUS_PENDING && !(comp._statusFlags & STATUS_UNINITIALIZED));
+}
+function getPendingValueComputed(el) {
+  if (!el._pendingValueComputed) {
+    const prevPending = pendingReadActive;
+    pendingReadActive = false;
+    el._pendingValueComputed = optimisticComputed(() => read(el));
+    pendingReadActive = prevPending;
+  }
+  return el._pendingValueComputed;
+}
+function updatePendingSignal(el) {
+  if (el._pendingSignal) setSignal(el._pendingSignal, computePendingState(el));
+}
 function isEqual(a, b) {
   return a === b;
 }
@@ -769,10 +963,30 @@ function untrack(fn) {
   }
 }
 function read(el) {
+  if (pendingCheckActive) {
+    const target = el._firewall || el;
+    const pendingSig = getPendingSignal(target);
+    const prevCheck = pendingCheckActive;
+    pendingCheckActive = false;
+    if (read(pendingSig)) {
+      foundPending = true;
+    }
+    pendingCheckActive = prevCheck;
+    return el._value;
+  }
+  if (pendingReadActive) {
+    const pendingComputed = getPendingValueComputed(el);
+    const prevPending = pendingReadActive;
+    pendingReadActive = false;
+    const value = read(pendingComputed);
+    pendingReadActive = prevPending;
+    if (pendingComputed._statusFlags & STATUS_PENDING) return el._value;
+    return value;
+  }
   let c = context;
   if (c?._root) c = c._parentComputed;
   if (refreshing && el._fn) recompute(el);
-  if (c && tracking && !pendingCheck && !pendingValueCheck) {
+  if (c && tracking) {
     if (el._fn && el._flags & REACTIVE_DISPOSED) recompute(el);
     link(el, c);
     const owner = el._firewall || el;
@@ -789,88 +1003,67 @@ function read(el) {
       }
     }
   }
-  if (pendingValueCheck) {
-    if (!el._pendingSignal) {
-      el._pendingSignal = signal(el._value);
-      el._pendingSignal._optimistic = true;
-    }
-    pendingValueCheck = false;
-    try {
-      return read(el._pendingSignal);
-    } finally {
-      pendingValueCheck = true;
-    }
-  }
   const asyncCompute = el._firewall || el;
-  if (pendingCheck) {
-    if (!asyncCompute._pendingCheck) {
-      asyncCompute._pendingCheck = signal(false);
-      asyncCompute._pendingCheck._optimistic = true;
-      asyncCompute._pendingCheck._set = v => setSignal(asyncCompute._pendingCheck, v);
-    }
-    const prev = pendingCheck;
-    pendingCheck = null;
-    prev._value = read(asyncCompute._pendingCheck) || prev._value;
-    pendingCheck = prev;
-  }
-  if (!pendingCheck && asyncCompute._statusFlags & STATUS_PENDING) {
-    if ((c && !stale) || asyncCompute._statusFlags & STATUS_UNINITIALIZED || el._firewall)
-      throw asyncCompute._error;
-    else if (c && stale) {
-      setStatusFlags(c, c._statusFlags | STATUS_PENDING, asyncCompute._error);
-    }
-  }
-  if (el._statusFlags & STATUS_ERROR) {
+  if (
+    c &&
+    !optimisticReadActive &&
+    asyncCompute._statusFlags & STATUS_PENDING &&
+    !(stale && asyncCompute._transition && activeTransition !== asyncCompute._transition)
+  )
+    throw asyncCompute._error;
+  if (el._fn && el._statusFlags & STATUS_ERROR) {
     if (el._time < clock) {
       recompute(el, true);
       return read(el);
-    } else {
-      throw el._error;
-    }
+    } else throw el._error;
   }
   return !c ||
-    el._optimistic ||
+    optimisticReadActive ||
     el._pendingValue === NOT_PENDING ||
-    (stale &&
-      !pendingCheck &&
-      (c._optimistic || (el._transition && activeTransition !== el._transition)))
+    (stale && el._transition && activeTransition !== el._transition)
     ? el._value
     : el._pendingValue;
 }
 function setSignal(el, v) {
   if (!el._pureWrite && context && el._firewall !== context)
     console.warn("A Signal was written to in an owned scope.");
-  if (typeof v === "function") {
-    v = v(
-      el._pendingValue === NOT_PENDING || (el._optimistic && el._transition)
-        ? el._value
-        : el._pendingValue
-    );
+  if (el._transition && activeTransition !== el._transition)
+    globalQueue.initTransition(el._transition);
+  const isOptimistic = el._optimistic && !projectionWriteActive;
+  const currentValue = isOptimistic
+    ? el._value
+    : el._pendingValue === NOT_PENDING
+      ? el._value
+      : el._pendingValue;
+  if (typeof v === "function") v = v(currentValue);
+  const valueChanged = !el._equals || !el._equals(currentValue, v);
+  if (!valueChanged) return v;
+  if (isOptimistic) {
+    const isFirstWrite = el._pendingValue === NOT_PENDING;
+    if (el._transition && !isFirstWrite) {
+      globalQueue.initTransition(el._transition);
+    }
+    if (isFirstWrite) {
+      el._pendingValue = el._value;
+      globalQueue._optimisticNodes.push(el);
+    }
+    el._value = v;
+  } else {
+    if (el._pendingValue === NOT_PENDING) globalQueue._pendingNodes.push(el);
+    el._pendingValue = v;
   }
-  const valueChanged =
-    !el._equals ||
-    !el._equals(
-      el._pendingValue === NOT_PENDING || (el._optimistic && el._transition)
-        ? el._value
-        : el._pendingValue,
-      v
-    );
-  if (!valueChanged && !el._statusFlags) return v;
-  if (valueChanged) {
-    if (el._optimistic) el._value = v;
-    else {
-      if (el._pendingValue === NOT_PENDING) globalQueue._pendingNodes.push(el);
-      el._pendingValue = v;
-    }
-    if (el._pendingSignal) setSignal(el._pendingSignal, v);
+  updatePendingSignal(el);
+  if (el._pendingValueComputed) {
+    setSignal(el._pendingValueComputed, v);
   }
-  setStatusFlags(el, STATUS_NONE);
   el._time = clock;
-  el._optimistic && !optimisticRun ? globalQueue._optimisticNodes.push(el) : notifySubs(el);
+  insertSubs(el, isOptimistic);
   schedule();
   return v;
 }
+const PENDING_OWNER = {};
 function getObserver() {
+  if (pendingCheckActive || pendingReadActive) return PENDING_OWNER;
   return tracking ? context : null;
 }
 function getOwner() {
@@ -878,25 +1071,20 @@ function getOwner() {
 }
 function onCleanup(fn) {
   if (!context) return fn;
-  const node = context;
-  if (!node._disposal) {
-    node._disposal = fn;
-  } else if (Array.isArray(node._disposal)) {
-    node._disposal.push(fn);
-  } else {
-    node._disposal = [node._disposal, fn];
-  }
+  if (!context._disposal) context._disposal = fn;
+  else if (Array.isArray(context._disposal)) context._disposal.push(fn);
+  else context._disposal = [context._disposal, fn];
   return fn;
 }
 function createOwner(options) {
   const parent = context;
   const owner = {
+    id: options?.id ?? (parent?.id != null ? getNextChildId(parent) : undefined),
     _root: true,
     _parentComputed: parent?._root ? parent._parentComputed : parent,
     _firstChild: null,
     _nextSibling: null,
     _disposal: null,
-    id: options?.id ?? (parent?.id != null ? getNextChildId(parent) : undefined),
     _queue: parent?._queue ?? globalQueue,
     _context: parent?._context || defaultContext,
     _childCount: 0,
@@ -907,6 +1095,9 @@ function createOwner(options) {
       disposeChildren(owner, self);
     }
   };
+  if (leafEffectActive && parent) {
+    throw new Error("Cannot create reactive primitives inside createTrackedEffect");
+  }
   if (parent) {
     const lastChild = parent._firstChild;
     if (lastChild === null) {
@@ -924,11 +1115,14 @@ function createRoot(init, options) {
 }
 function runWithOwner(owner, fn) {
   const oldContext = context;
+  const prevTracking = tracking;
   context = owner;
+  tracking = false;
   try {
     return fn();
   } finally {
     context = oldContext;
+    tracking = prevTracking;
   }
 }
 function staleValues(fn, set = true) {
@@ -941,25 +1135,25 @@ function staleValues(fn, set = true) {
   }
 }
 function pending(fn) {
-  const prevLatest = pendingValueCheck;
-  pendingValueCheck = true;
+  const prevPending = pendingReadActive;
+  pendingReadActive = true;
   try {
-    return staleValues(fn, false);
+    return fn();
   } finally {
-    pendingValueCheck = prevLatest;
+    pendingReadActive = prevPending;
   }
 }
 function isPending(fn) {
-  const current = pendingCheck;
-  pendingCheck = { _value: false };
+  const prevPendingCheck = pendingCheckActive;
+  const prevFoundPending = foundPending;
+  pendingCheckActive = true;
+  foundPending = false;
   try {
-    staleValues(fn);
-    return pendingCheck._value;
-  } catch (err) {
-    if (!(err instanceof NotReadyError)) return false;
-    throw err;
+    fn();
+    return foundPending;
   } finally {
-    pendingCheck = current;
+    pendingCheckActive = prevPendingCheck;
+    foundPending = prevFoundPending;
   }
 }
 function refresh(fn) {
@@ -975,7 +1169,6 @@ function refresh(fn) {
     refreshing = prevRefreshing;
     if (!prevRefreshing) {
       schedule();
-      flush();
     }
   }
 }
@@ -1012,54 +1205,50 @@ function isUndefined(value) {
 }
 function effect(compute, effect, error, initialValue, options) {
   let initialized = false;
-  const node = computed(compute, initialValue, {
-    ...options,
-    _internal: {
-      _modified: true,
-      _prevValue: initialValue,
-      _effectFn: effect,
-      _errorFn: error,
-      _cleanup: undefined,
-      _type: options?.render ? EFFECT_RENDER : EFFECT_USER,
-      _notifyQueue(statusFlagsChanged, prevStatusFlags) {
-        if (initialized) {
-          const errorChanged =
-            this._statusFlags && this._statusFlags === prevStatusFlags && statusFlagsChanged;
-          this._modified =
-            !(this._statusFlags & STATUS_ERROR) &&
-            !(this._statusFlags & STATUS_PENDING & ~prevStatusFlags) &&
-            !errorChanged;
-          if (this._modified) this._queue.enqueue(this._type, runEffect.bind(this));
-        }
-        if (this._statusFlags & STATUS_ERROR) {
-          let error = this._error;
-          this._queue.notify(this, STATUS_PENDING, 0);
-          if (this._type === EFFECT_USER) {
-            try {
-              return this._errorFn
-                ? this._errorFn(error, () => {
-                    this._cleanup?.();
-                    this._cleanup = undefined;
-                  })
-                : console.error(error);
-            } catch (e) {
-              error = e;
-            }
-          }
-          if (!this._queue.notify(this, STATUS_ERROR, STATUS_ERROR)) throw error;
-        } else if (this._type === EFFECT_RENDER) {
-          this._queue.notify(this, STATUS_PENDING | STATUS_ERROR, this._statusFlags);
+  const node = computed(
+    options?.render ? p => staleValues(() => compute(p)) : compute,
+    initialValue,
+    {
+      ...options,
+      equals: () => {
+        node._modified = !node._error;
+        if (initialized) node._queue.enqueue(node._type, runEffect.bind(node));
+        return false;
+      },
+      lazy: true
+    }
+  );
+  node._prevValue = initialValue;
+  node._effectFn = effect;
+  node._errorFn = error;
+  node._cleanup = undefined;
+  node._type = options?.render ? EFFECT_RENDER : EFFECT_USER;
+  node._notifyStatus = () => {
+    if (node._statusFlags & STATUS_ERROR) {
+      let error = node._error;
+      node._queue.notify(node, STATUS_PENDING, 0);
+      if (node._type === EFFECT_USER) {
+        try {
+          return node._errorFn
+            ? node._errorFn(error, () => {
+                node._cleanup?.();
+                node._cleanup = undefined;
+              })
+            : console.error(error);
+        } catch (e) {
+          error = e;
         }
       }
-    }
-  });
-  initialized = true;
-  if (node._type === EFFECT_RENDER) node._fn = p => staleValues(() => compute(p));
+      if (!node._queue.notify(node, STATUS_ERROR, STATUS_ERROR)) throw error;
+    } else if (node._type === EFFECT_RENDER)
+      node._queue.notify(node, STATUS_PENDING | STATUS_ERROR, node._statusFlags);
+  };
+  recompute(node, true);
   !options?.defer &&
-    !(node._statusFlags & (STATUS_ERROR | STATUS_PENDING)) &&
     (node._type === EFFECT_USER
       ? node._queue.enqueue(node._type, runEffect.bind(node))
       : runEffect.call(node));
+  initialized = true;
   onCleanup(() => node._cleanup?.());
   if (!node._parent)
     console.warn("Effects created outside a reactive context will never be disposed");
@@ -1077,6 +1266,35 @@ function runEffect() {
     this._modified = false;
   }
 }
+function trackedEffect(fn, options) {
+  const run = () => {
+    if (!node._modified || node._flags & REACTIVE_DISPOSED) return;
+    node._modified = false;
+    recompute(node);
+  };
+  const node = computed(
+    () => {
+      setLeafEffectActive(true);
+      try {
+        node._cleanup?.();
+        node._cleanup = undefined;
+        node._cleanup = staleValues(fn) || undefined;
+      } finally {
+        setLeafEffectActive(false);
+      }
+    },
+    undefined,
+    { ...options, lazy: true, pureWrite: true }
+  );
+  node._cleanup = undefined;
+  node._modified = true;
+  node._type = EFFECT_TRACKED;
+  node._run = run;
+  node._queue.enqueue(EFFECT_USER, run);
+  onCleanup(() => node._cleanup?.());
+  if (!node._parent)
+    console.warn("Effects created outside a reactive context will never be disposed");
+}
 function createSignal(first, second, third) {
   if (typeof first === "function") {
     const node = computed(first, second, third);
@@ -1090,18 +1308,20 @@ function createMemo(compute, value, options) {
   return read.bind(null, node);
 }
 function createEffect(compute, effectFn, value, options) {
-  void effect(compute, effectFn.effect || effectFn, effectFn.error, value, {
+  effect(compute, effectFn.effect || effectFn, effectFn.error, value, {
     ...options,
     name: options?.name ?? "effect"
   });
 }
 function createRenderEffect(compute, effectFn, value, options) {
-  void effect(compute, effectFn, undefined, value, {
+  effect(compute, effectFn, undefined, value, {
     render: true,
     ...{ ...options, name: options?.name ?? "effect" }
   });
 }
-function createTrackedEffect(compute, options) {}
+function createTrackedEffect(compute, options) {
+  trackedEffect(compute, { ...options, name: options?.name ?? "trackedEffect" });
+}
 function createReaction(effectFn, options) {
   let cleanup = undefined;
   onCleanup(() => cleanup?.());
@@ -1138,39 +1358,19 @@ function resolve(fn) {
   });
 }
 function createOptimistic(first, second, third) {
-  if (typeof first === "function") {
-    const node = computed(
-      prev => {
-        const n = getOwner();
-        const value = first(prev);
-        if (n._statusFlags & STATUS_UNINITIALIZED) return value;
-        n._pendingValue = value;
-        return prev;
-      },
-      second,
-      third
-    );
-    node._optimistic = true;
-    return [read.bind(null, node), setSignal.bind(null, node)];
-  }
-  const node = signal(first, second);
-  node._optimistic = true;
-  return [
-    read.bind(null, node),
-    v => {
-      node._pendingValue = first;
-      return setSignal(node, v);
-    }
-  ];
+  const node =
+    typeof first === "function"
+      ? optimisticComputed(first, second, third)
+      : optimisticSignal(first, second);
+  return [read.bind(null, node), setSignal.bind(null, node)];
 }
 function onSettled(callback) {
-  let cleanup;
-  const o = getOwner();
-  if (o) onCleanup(() => cleanup?.());
-  globalQueue.enqueue(EFFECT_USER, () => {
-    cleanup = callback();
-    !o && cleanup?.();
-  });
+  getOwner()
+    ? createTrackedEffect(() => untrack(callback))
+    : globalQueue.enqueue(EFFECT_USER, () => {
+        const cleanup = callback();
+        cleanup?.();
+      });
 }
 function unwrap(value) {
   return value?.[$TARGET]?.[STORE_NODE] ?? value;
@@ -1339,12 +1539,12 @@ function createProjectionInternal(fn, initialValue = {}, options) {
     const owner = getOwner();
     storeSetter(new Proxy(wrappedStore, writeTraps), s => {
       const value = handleAsync(owner, fn(s), value => {
-        value !== wrappedStore &&
+        value !== s &&
           value !== undefined &&
           storeSetter(wrappedStore, reconcile(value, options?.key || "id", options?.all));
         setSignal(owner, undefined);
       });
-      value !== wrappedStore &&
+      value !== s &&
         value !== undefined &&
         reconcile(value, options?.key || "id", options?.all)(wrappedStore);
     });
@@ -1359,28 +1559,34 @@ const writeTraps = {
   get(_, prop) {
     let value;
     setWriteOverride(true);
+    setProjectionWriteActive(true);
     try {
       value = _[prop];
     } finally {
       setWriteOverride(false);
+      setProjectionWriteActive(false);
     }
     return typeof value === "object" && value !== null ? new Proxy(value, writeTraps) : value;
   },
   set(_, prop, value) {
     setWriteOverride(true);
+    setProjectionWriteActive(true);
     try {
       _[prop] = value;
     } finally {
       setWriteOverride(false);
+      setProjectionWriteActive(false);
     }
     return true;
   },
   deleteProperty(_, prop) {
     setWriteOverride(true);
+    setProjectionWriteActive(true);
     try {
       delete _[prop];
     } finally {
       setWriteOverride(false);
+      setProjectionWriteActive(false);
     }
     return true;
   }
@@ -1393,11 +1599,13 @@ const $TRACK = Symbol("STORE_TRACK"),
 const PARENTS = new WeakMap();
 const STORE_VALUE = "v",
   STORE_OVERRIDE = "o",
+  STORE_OPTIMISTIC_OVERRIDE = "x",
   STORE_NODE = "n",
   STORE_HAS = "h",
   STORE_WRAP = "w",
   STORE_LOOKUP = "l",
-  STORE_FIREWALL = "f";
+  STORE_FIREWALL = "f",
+  STORE_OPTIMISTIC = "p";
 function createStoreProxy(value, traps = storeTraps, extend) {
   let newTarget;
   if (Array.isArray(value)) {
@@ -1429,9 +1637,9 @@ function getNodes(target, type) {
   if (!nodes) target[type] = nodes = Object.create(null);
   return nodes;
 }
-function getNode(nodes, property, value, firewall, equals = isEqual) {
+function getNode(nodes, property, value, firewall, equals = isEqual, optimistic) {
   if (nodes[property]) return nodes[property];
-  return (nodes[property] = signal(
+  const s = signal(
     value,
     {
       equals: equals,
@@ -1440,11 +1648,22 @@ function getNode(nodes, property, value, firewall, equals = isEqual) {
       }
     },
     firewall
-  ));
+  );
+  if (optimistic) s._optimistic = true;
+  return (nodes[property] = s);
 }
 function trackSelf(target, symbol = $TRACK) {
   getObserver() &&
-    read(getNode(getNodes(target, STORE_NODE), symbol, undefined, target[STORE_FIREWALL], false));
+    read(
+      getNode(
+        getNodes(target, STORE_NODE),
+        symbol,
+        undefined,
+        target[STORE_FIREWALL],
+        false,
+        target[STORE_OPTIMISTIC]
+      )
+    );
 }
 function getKeys(source, override, enumerable = true) {
   const baseKeys = untrack(() => (enumerable ? Object.keys(source) : Reflect.ownKeys(source)));
@@ -1477,9 +1696,16 @@ const storeTraps = {
     }
     const nodes = getNodes(target, STORE_NODE);
     const tracked = nodes[property];
-    const overridden = target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE];
+    const optOverridden =
+      target[STORE_OPTIMISTIC_OVERRIDE] && property in target[STORE_OPTIMISTIC_OVERRIDE];
+    const overridden =
+      optOverridden || (target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE]);
     const proxySource = !!target[STORE_VALUE][$TARGET];
-    const storeValue = overridden ? target[STORE_OVERRIDE] : target[STORE_VALUE];
+    const storeValue = optOverridden
+      ? target[STORE_OPTIMISTIC_OVERRIDE]
+      : target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE]
+        ? target[STORE_OVERRIDE]
+        : target[STORE_VALUE];
     if (!tracked) {
       const desc = Object.getOwnPropertyDescriptor(storeValue, property);
       if (desc && desc.get) return desc.get.call(receiver);
@@ -1488,7 +1714,9 @@ const storeTraps = {
       let value =
         tracked && (overridden || !proxySource)
           ? tracked._pendingValue !== NOT_PENDING
-            ? tracked._pendingValue
+            ? tracked._optimistic
+              ? tracked._value
+              : tracked._pendingValue
             : tracked._value
           : storeValue[property];
       value === $DELETED && (value = undefined);
@@ -1517,7 +1745,9 @@ const storeTraps = {
             nodes,
             property,
             isWrappable(value) ? wrap(value, target) : value,
-            target[STORE_FIREWALL]
+            target[STORE_FIREWALL],
+            isEqual,
+            target[STORE_OPTIMISTIC]
           )
         );
       }
@@ -1527,30 +1757,53 @@ const storeTraps = {
   has(target, property) {
     if (property === $PROXY || property === $TRACK || property === "__proto__") return true;
     const has =
-      target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE]
-        ? target[STORE_OVERRIDE][property] !== $DELETED
-        : property in target[STORE_VALUE];
+      target[STORE_OPTIMISTIC_OVERRIDE] && property in target[STORE_OPTIMISTIC_OVERRIDE]
+        ? target[STORE_OPTIMISTIC_OVERRIDE][property] !== $DELETED
+        : target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE]
+          ? target[STORE_OVERRIDE][property] !== $DELETED
+          : property in target[STORE_VALUE];
     getObserver() &&
-      read(getNode(getNodes(target, STORE_HAS), property, has, target[STORE_FIREWALL]));
+      read(
+        getNode(
+          getNodes(target, STORE_HAS),
+          property,
+          has,
+          target[STORE_FIREWALL],
+          isEqual,
+          target[STORE_OPTIMISTIC]
+        )
+      );
     return has;
   },
   set(target, property, rawValue) {
     const store = target[$PROXY];
     if (writeOnly(store)) {
+      if (target[STORE_OPTIMISTIC]) {
+        const firewall = target[STORE_FIREWALL];
+        if (firewall?._transition) {
+          globalQueue.initTransition(firewall._transition);
+        }
+      }
       untrack(() => {
         const state = target[STORE_VALUE];
         const base = state[property];
+        const useOptimistic = target[STORE_OPTIMISTIC] && !projectionWriteActive;
+        const overrideKey = useOptimistic ? STORE_OPTIMISTIC_OVERRIDE : STORE_OVERRIDE;
+        if (useOptimistic) trackOptimisticStore(store);
         const prev =
-          target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE]
-            ? target[STORE_OVERRIDE][property]
-            : base;
+          target[STORE_OPTIMISTIC_OVERRIDE] && property in target[STORE_OPTIMISTIC_OVERRIDE]
+            ? target[STORE_OPTIMISTIC_OVERRIDE][property]
+            : target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE]
+              ? target[STORE_OVERRIDE][property]
+              : base;
         const value = rawValue?.[$TARGET]?.[STORE_VALUE] ?? rawValue;
         if (prev === value) return true;
-        const len = target[STORE_OVERRIDE]?.length || state.length;
-        if (value !== undefined && value === base) delete target[STORE_OVERRIDE][property];
-        else
-          (target[STORE_OVERRIDE] || (target[STORE_OVERRIDE] = Object.create(null)))[property] =
-            value;
+        const len =
+          target[STORE_OPTIMISTIC_OVERRIDE]?.length ||
+          target[STORE_OVERRIDE]?.length ||
+          state.length;
+        if (value !== undefined && value === base) delete target[overrideKey][property];
+        else (target[overrideKey] || (target[overrideKey] = Object.create(null)))[property] = value;
         const wrappable = isWrappable(value);
         if (isWrappable(prev)) {
           const parents = PARENTS.get(prev);
@@ -1562,8 +1815,12 @@ const storeTraps = {
         nodes[property] &&
           setSignal(nodes[property], () => (wrappable ? wrap(value, target) : value));
         if (Array.isArray(state)) {
-          const index = parseInt(property) + 1;
-          if (index > len) nodes.length && setSignal(nodes.length, index);
+          if (property === "length") {
+            nodes.length && setSignal(nodes.length, value);
+          } else {
+            const index = parseInt(property) + 1;
+            if (index > len) nodes.length && setSignal(nodes.length, index);
+          }
         }
         nodes[$TRACK] && setSignal(nodes[$TRACK], undefined);
       });
@@ -1571,17 +1828,26 @@ const storeTraps = {
     return true;
   },
   deleteProperty(target, property) {
-    if (writeOnly(target[$PROXY]) && target[STORE_OVERRIDE]?.[property] !== $DELETED) {
+    const optDeleted = target[STORE_OPTIMISTIC_OVERRIDE]?.[property] === $DELETED;
+    const regDeleted = target[STORE_OVERRIDE]?.[property] === $DELETED;
+    if (writeOnly(target[$PROXY]) && !optDeleted && !regDeleted) {
       untrack(() => {
+        const useOptimistic = target[STORE_OPTIMISTIC] && !projectionWriteActive;
+        const overrideKey = useOptimistic ? STORE_OPTIMISTIC_OVERRIDE : STORE_OVERRIDE;
+        if (useOptimistic) trackOptimisticStore(target[$PROXY]);
         const prev =
-          target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE]
-            ? target[STORE_OVERRIDE][property]
-            : target[STORE_VALUE][property];
-        if (property in target[STORE_VALUE]) {
-          (target[STORE_OVERRIDE] || (target[STORE_OVERRIDE] = Object.create(null)))[property] =
-            $DELETED;
-        } else if (target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE]) {
-          delete target[STORE_OVERRIDE][property];
+          target[STORE_OPTIMISTIC_OVERRIDE] && property in target[STORE_OPTIMISTIC_OVERRIDE]
+            ? target[STORE_OPTIMISTIC_OVERRIDE][property]
+            : target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE]
+              ? target[STORE_OVERRIDE][property]
+              : target[STORE_VALUE][property];
+        if (
+          property in target[STORE_VALUE] ||
+          (target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE])
+        ) {
+          (target[overrideKey] || (target[overrideKey] = Object.create(null)))[property] = $DELETED;
+        } else if (target[overrideKey] && property in target[overrideKey]) {
+          delete target[overrideKey][property];
         } else return true;
         if (isWrappable(prev)) {
           const parents = PARENTS.get(prev);
@@ -1597,10 +1863,32 @@ const storeTraps = {
   },
   ownKeys(target) {
     trackSelf(target);
-    return getKeys(target[STORE_VALUE], target[STORE_OVERRIDE], false);
+    let keys = getKeys(target[STORE_VALUE], target[STORE_OVERRIDE], false);
+    if (target[STORE_OPTIMISTIC_OVERRIDE]) {
+      const keySet = new Set(keys);
+      for (const key of Reflect.ownKeys(target[STORE_OPTIMISTIC_OVERRIDE])) {
+        if (target[STORE_OPTIMISTIC_OVERRIDE][key] !== $DELETED) keySet.add(key);
+        else keySet.delete(key);
+      }
+      keys = Array.from(keySet);
+    }
+    return keys;
   },
   getOwnPropertyDescriptor(target, property) {
     if (property === $PROXY) return { value: target[$PROXY], writable: true, configurable: true };
+    if (target[STORE_OPTIMISTIC_OVERRIDE] && property in target[STORE_OPTIMISTIC_OVERRIDE]) {
+      if (target[STORE_OPTIMISTIC_OVERRIDE][property] === $DELETED) return undefined;
+      const baseDesc = getPropertyDescriptor(target[STORE_VALUE], target[STORE_OVERRIDE], property);
+      if (baseDesc) {
+        return { ...baseDesc, value: target[STORE_OPTIMISTIC_OVERRIDE][property] };
+      }
+      return {
+        value: target[STORE_OPTIMISTIC_OVERRIDE][property],
+        writable: true,
+        enumerable: true,
+        configurable: true
+      };
+    }
     return getPropertyDescriptor(target[STORE_VALUE], target[STORE_OVERRIDE], property);
   },
   getPrototypeOf(target) {
@@ -1689,7 +1977,82 @@ function deep(store) {
   return store[$DEEP];
 }
 function createOptimisticStore(first, second, options) {
-  return [];
+  GlobalQueue._clearOptimisticStore ||= clearOptimisticStore;
+  const derived = typeof first === "function";
+  const initialValue = (derived ? second : first) ?? {};
+  const fn = derived ? first : undefined;
+  const { store: wrappedStore } = createOptimisticProjectionInternal(fn, initialValue, options);
+  return [wrappedStore, fn => storeSetter(wrappedStore, fn)];
+}
+function clearOptimisticStore(store) {
+  const target = store[$TARGET];
+  if (!target || !target[STORE_OPTIMISTIC_OVERRIDE]) return;
+  const override = target[STORE_OPTIMISTIC_OVERRIDE];
+  const nodes = target[STORE_NODE];
+  if (nodes) {
+    for (const key of Reflect.ownKeys(override)) {
+      if (nodes[key]) {
+        const baseValue =
+          target[STORE_OVERRIDE] && key in target[STORE_OVERRIDE]
+            ? target[STORE_OVERRIDE][key]
+            : target[STORE_VALUE][key];
+        const value = baseValue === $DELETED ? undefined : baseValue;
+        setSignal(nodes[key], isWrappable(value) ? wrap(value, target) : value);
+      }
+    }
+    nodes[$TRACK] && setSignal(nodes[$TRACK], undefined);
+  }
+  delete target[STORE_OPTIMISTIC_OVERRIDE];
+}
+function createOptimisticProjectionInternal(fn, initialValue = {}, options) {
+  let node;
+  const wrappedMap = new WeakMap();
+  const wrapper = s => {
+    s[STORE_WRAP] = wrapProjection;
+    s[STORE_LOOKUP] = wrappedMap;
+    s[STORE_OPTIMISTIC] = true;
+    Object.defineProperty(s, STORE_FIREWALL, {
+      get() {
+        return node;
+      },
+      configurable: true
+    });
+  };
+  const wrapProjection = source => {
+    if (wrappedMap.has(source)) return wrappedMap.get(source);
+    if (source[$TARGET]?.[STORE_WRAP] === wrapProjection) return source;
+    const wrapped = createStoreProxy(source, storeTraps, wrapper);
+    wrappedMap.set(source, wrapped);
+    return wrapped;
+  };
+  const wrappedStore = wrapProjection(initialValue);
+  if (fn) {
+    node = computed(() => {
+      const owner = getOwner();
+      setProjectionWriteActive(true);
+      try {
+        storeSetter(new Proxy(wrappedStore, writeTraps), s => {
+          const value = handleAsync(owner, fn(s), value => {
+            setProjectionWriteActive(true);
+            try {
+              value !== s &&
+                value !== undefined &&
+                storeSetter(wrappedStore, reconcile(value, options?.key || "id", options?.all));
+            } finally {
+              setProjectionWriteActive(false);
+            }
+          });
+          value !== s &&
+            value !== undefined &&
+            reconcile(value, options?.key || "id", options?.all)(wrappedStore);
+        });
+      } finally {
+        setProjectionWriteActive(false);
+      }
+    });
+    node._preventAutoDisposal = true;
+  }
+  return { store: wrappedStore, node: node };
 }
 function snapshot(item, map, lookup) {
   let target, isArray, override, result, unwrapped, v;
@@ -2084,21 +2447,15 @@ function compare(key, a, b) {
   return key ? key(a) === key(b) : true;
 }
 function boundaryComputed(fn, propagationMask) {
-  const node = computed(fn, undefined, {
-    _internal: {
-      _notifyQueue() {
-        let flags = this._statusFlags;
-        this._statusFlags &= ~this._propagationMask;
-        if (this._propagationMask & STATUS_PENDING && !(this._statusFlags & STATUS_UNINITIALIZED)) {
-          flags &= ~STATUS_PENDING;
-        }
-        this._queue.notify(this, this._propagationMask, flags);
-      },
-      _propagationMask: propagationMask
-    }
-  });
+  const node = computed(fn, undefined, { lazy: true });
+  node._notifyStatus = () => {
+    const flags = node._statusFlags;
+    node._statusFlags &= ~node._propagationMask;
+    node._queue.notify(node, node._propagationMask, flags);
+  };
   node._propagationMask = propagationMask;
   node._preventAutoDisposal = true;
+  recompute(node, true);
   return node;
 }
 function createBoundChildren(owner, fn, queue, mask) {
@@ -2198,8 +2555,10 @@ function createCollectionBoundary(type, fn, fallback) {
   const decision = computed(() => {
     if (!read(queue._disabled)) {
       const resolved = read(tree);
-      if (!untrack(() => read(queue._disabled))) queue._initialized = true;
-      return resolved;
+      if (!untrack(() => read(queue._disabled))) {
+        queue._initialized = true;
+        return resolved;
+      }
     }
     return fallback(queue);
   });