@solidjs/signals 2.0.0-beta.16 → 2.0.0-beta.18

package/dist/dev.js

@@ -12,6 +12,9 @@ class StatusError extends Error {
     this.source = source;
   }
 }
+function unwrapStatusError(error) {
+  return error instanceof StatusError ? error.cause : error;
+}
 class NoOwnerError extends Error {
   constructor() {
     super("Context can only be accessed under a reactive root.");
@@ -36,6 +39,7 @@ const REACTIVE_OPTIMISTIC_DIRTY = 1 << 7;
 const REACTIVE_SNAPSHOT_STALE = 1 << 8;
 const REACTIVE_LAZY = 1 << 9;
 const REACTIVE_MANUAL_WRITE = 1 << 10;
+const REACTIVE_REASK = 1 << 11;
 const CONFIG_OWNED_WRITE = 1 << 0;
 const CONFIG_NO_SNAPSHOT = 1 << 1;
 const CONFIG_TRANSPARENT = 1 << 2;
@@ -253,6 +257,7 @@ function canUseSimpleSyncFlush(queue) {
     activeLanes.size === 0 &&
     queue._children.length === 0 &&
     queue._optimisticNodes.length === 0 &&
+    queue._affectsNodes.length === 0 &&
     queue._optimisticStores.size === 0 &&
     transientStoreNodes.size === 0
   );
@@ -266,6 +271,7 @@ function sweepTransientStoreNodes() {
     }
     if (node._pendingValue !== NOT_PENDING) continue;
     if (node._overrideValue !== undefined && node._overrideValue !== NOT_PENDING) continue;
+    if (node._affectsCount) continue;
     transientStoreNodes.delete(node);
     node._unobserved?.();
   }
@@ -316,6 +322,10 @@ function mergeTransitionState(target, outgoing) {
   target._actions.push(...outgoing._actions);
   for (const lane of activeLanes) if (lane._transition === outgoing) lane._transition = target;
   target._optimisticNodes.push(...outgoing._optimisticNodes);
+  if (outgoing._affectsNodes.length) {
+    target._affectsNodes.push(...outgoing._affectsNodes);
+    outgoing._affectsNodes.length = 0;
+  }
   for (const store of outgoing._optimisticStores) target._optimisticStores.add(store);
   for (const [source, reporters] of outgoing._asyncReporters) {
     let targetReporters = target._asyncReporters.get(source);
@@ -466,11 +476,15 @@ class GlobalQueue extends Queue {
   _pendingNode = null;
   _pendingNodes = [];
   _optimisticNodes = [];
+  _affectsNodes = [];
   _optimisticStores = new Set();
   static _update;
   static _dispose;
   static _runEffect;
   static _clearOptimisticStore = null;
+  static _releaseAffectsScope = null;
+  static _propagateAffects = null;
+  static _settleAffects = null;
   flush() {
     if (this._running) return;
     this._running = true;
@@ -485,6 +499,7 @@ class GlobalQueue extends Queue {
           this._pendingNode = null;
           this._pendingNodes = [];
           this._optimisticNodes = [];
+          this._affectsNodes = [];
           this._optimisticStores = new Set();
           runLaneEffects(EFFECT_RENDER);
           runLaneEffects(EFFECT_USER);
@@ -590,6 +605,7 @@ class GlobalQueue extends Queue {
         _pendingNodes: [],
         _asyncReporters: createAsyncReporters(),
         _optimisticNodes: [],
+        _affectsNodes: [],
         _optimisticStores: new Set(),
         _actions: [],
         _queueStash: { _queues: [[], []], _children: [] },
@@ -625,6 +641,10 @@ class GlobalQueue extends Queue {
       }
       this._optimisticNodes = activeTransition._optimisticNodes;
     }
+    if (this._affectsNodes !== activeTransition._affectsNodes) {
+      activeTransition._affectsNodes.push(...this._affectsNodes);
+      this._affectsNodes = activeTransition._affectsNodes;
+    }
     for (const lane of activeLanes) {
       if (!lane._transition) lane._transition = activeTransition;
     }
@@ -649,10 +669,16 @@ function queuePendingNode(node) {
   }
   globalQueue._pendingNodes.push(node);
 }
+let reaskArmed = false;
+function armReaskClear() {
+  reaskArmed = true;
+}
 function insertSubs(node, optimistic = false) {
   const sourceLane = node._optimisticLane || currentOptimisticLane;
   const hasSnapshot = node._snapshotValue !== undefined;
+  const clearReask = reaskArmed;
   for (let s = node._subs; s !== null; s = s._nextSub) {
+    if (clearReask) s._sub._flags &= ~REACTIVE_REASK;
     if (hasSnapshot && s._sub._config & CONFIG_IN_SNAPSHOT_SCOPE) {
       s._sub._flags |= REACTIVE_SNAPSHOT_STALE;
       continue;
@@ -736,6 +762,9 @@ function finalizePureQueue(completingTransition = null, incomplete = false) {
       }
       completingTransition._gatedSubs.clear();
     }
+    releaseAffectsMarks(
+      completingTransition ? completingTransition._affectsNodes : globalQueue._affectsNodes
+    );
     const optimisticStores = completingTransition
       ? completingTransition._optimisticStores
       : globalQueue._optimisticStores;
@@ -760,6 +789,32 @@ function trackOptimisticStore(store) {
   globalQueue._optimisticStores.add(store);
   schedule();
 }
+let activeAffectsMarks = 0;
+function markAffects(node) {
+  node._affectsCount = (node._affectsCount || 0) + 1;
+  activeAffectsMarks++;
+  if (node._affectsCount === 1) updatePendingSignal(node);
+}
+function registerAffectsMark(node) {
+  markAffects(node);
+  globalQueue._affectsNodes.push(node);
+  GlobalQueue._propagateAffects?.(node);
+  schedule();
+}
+function releaseAffectsMark(node) {
+  activeAffectsMarks--;
+  node._affectsCount--;
+  if (!node._affectsCount) {
+    GlobalQueue._settleAffects?.(node);
+    snapCompanionsToState(node);
+    GlobalQueue._releaseAffectsScope?.(node);
+  }
+}
+function releaseAffectsMarks(nodes) {
+  if (!nodes.length) return;
+  for (let i = 0; i < nodes.length; i++) releaseAffectsMark(nodes[i]);
+  nodes.length = 0;
+}
 function reassignPendingTransition(pendingNodes) {
   for (let i = 0; i < pendingNodes.length; i++) {
     pendingNodes[i]._transition = activeTransition;
@@ -839,7 +894,8 @@ function transitionComplete(transition) {
         hasActiveOverride(node) &&
         "_statusFlags" in node &&
         node._statusFlags & STATUS_PENDING &&
-        node._error instanceof NotReadyError
+        node._error instanceof NotReadyError &&
+        !node._error.source?._affectsFor
       ) {
         done = false;
         break;
@@ -1276,7 +1332,7 @@ function setPendingError(el, source, error) {
 }
 function forEachDependent(el, fn) {
   for (let s = el._subs; s !== null; s = s._nextSub) fn(s._sub, s);
-  for (let child = el._child; child !== null; child = child._nextChild) {
+  for (let child = el._child ?? null; child !== null; child = child._nextChild) {
     for (let s = child._subs; s !== null; s = s._nextSub) fn(s._sub, s);
   }
 }
@@ -1293,21 +1349,22 @@ function enqueueForRerun(node) {
     insertIntoHeap(node, queue);
   }
 }
-function settlePendingSource(el) {
+function settlePendingSource(el, source = el, snap = false) {
   let scheduled = false;
   const visited = new Set();
+  const updateCompanions = snap ? snapCompanionsToState : updatePendingSignal;
   const settle = node => {
-    if (visited.has(node) || !removePendingSource(node, el)) return;
+    if (visited.has(node) || !removePendingSource(node, source)) return;
     visited.add(node);
     node._time = clock;
-    const source = node._pendingSource ?? node._pendingSources?.values().next().value;
-    if (source) {
-      setPendingError(node, source);
-      updatePendingSignal(node);
+    const remaining = node._pendingSource ?? node._pendingSources?.values().next().value;
+    if (remaining) {
+      setPendingError(node, remaining);
+      updateCompanions(node);
     } else {
       node._statusFlags &= ~STATUS_PENDING;
       setPendingError(node);
-      updatePendingSignal(node);
+      updateCompanions(node);
       if (node._blocked) {
         enqueueForRerun(node);
         scheduled = true;
@@ -1433,8 +1490,9 @@ function handleAsync(el, result, setter) {
   }
   if (iterator) {
     const it = result[Symbol.asyncIterator]();
-    let hadSyncValue = false;
+    let hadValue = false;
     let completed = false;
+    let initialRead = true;
     cleanup(() => {
       if (completed) return;
       completed = true;
@@ -1445,7 +1503,9 @@ function handleAsync(el, result, setter) {
     });
     const iterate = () => {
       let syncResult,
+        syncError,
         resolved = false,
+        rejected = false,
         isSync = true;
       it.next().then(
         r => {
@@ -1455,30 +1515,46 @@ function handleAsync(el, result, setter) {
             if (r.done) completed = true;
           } else if (el._inFlight !== result) {
             return;
-          } else if (!r.done) asyncWrite(r.value, iterate);
-          else {
+          } else if (!r.done) {
+            hadValue = true;
+            asyncWrite(r.value, iterate);
+          } else {
             completed = true;
-            schedule();
-            flush();
+            if (hadValue) {
+              schedule();
+              flush();
+            } else {
+              asyncWrite(undefined);
+            }
           }
         },
         e => {
-          if (!isSync && el._inFlight === result) {
+          if (isSync) {
+            syncError = e;
+            rejected = true;
+          } else if (el._inFlight === result) {
             completed = true;
             handleError(e);
           }
         }
       );
       isSync = false;
+      if (rejected) {
+        completed = true;
+        handleError(syncError);
+        if (initialRead) throw syncError;
+        return true;
+      }
       if (resolved && !syncResult.done) {
         syncValue = syncResult.value;
-        hadSyncValue = true;
+        hadValue = true;
         return iterate();
       }
       return resolved && syncResult.done;
     };
     const immediatelyDone = iterate();
-    if (!hadSyncValue && !immediatelyDone) {
+    initialRead = false;
+    if (!hadValue && !immediatelyDone) {
       globalQueue.initTransition(resolveTransition(el));
       throw new NotReadyError(context);
     }
@@ -1488,6 +1564,7 @@ function handleAsync(el, result, setter) {
 function clearStatus(el, clearUninitialized = false) {
   if (el._pendingSource || el._pendingSources) clearPendingSources(el);
   if (el._blocked) el._blocked = false;
+  el._reask = false;
   el._statusFlags = clearUninitialized ? 0 : el._statusFlags & STATUS_UNINITIALIZED;
   if (el._error) setPendingError(el);
   if (el._pendingSignal || el._latestValueComputed) updatePendingSignal(el);
@@ -1557,6 +1634,48 @@ function notifyStatus(el, status, error, blockStatus, lane) {
     }
   });
 }
+function getAffectsSentinel(node) {
+  return (node._affectsSentinel ??= {
+    _name: "affects-sentinel",
+    _affectsFor: node,
+    _flags: 0,
+    _statusFlags: 0,
+    _reask: false,
+    _error: undefined,
+    _subs: null,
+    _deps: null
+  });
+}
+function propagateAffectsMark(node) {
+  if (!node._subs && !node._child) return;
+  const sentinel = getAffectsSentinel(node);
+  const error = new NotReadyError(sentinel);
+  forEachDependent(node, sub => {
+    if (sub._pendingSource !== sentinel && !sub._pendingSources?.has(sentinel)) {
+      if (!sub._transition) queuePendingNode(sub);
+      notifyStatus(sub, STATUS_PENDING, error);
+    }
+  });
+}
+function applyAffectsReads(el, sources) {
+  let applied = false;
+  for (let i = 0; i < sources.length; i++) {
+    const src = sources[i];
+    if (!src._affectsCount) continue;
+    const sentinel = getAffectsSentinel(src);
+    if (addPendingSource(el, sentinel)) {
+      el._statusFlags |= STATUS_PENDING;
+      setPendingError(el, sentinel);
+      applied = true;
+    }
+  }
+  if (applied) updatePendingSignal(el);
+}
+GlobalQueue._propagateAffects = propagateAffectsMark;
+GlobalQueue._settleAffects = node => {
+  const sentinel = node._affectsSentinel;
+  if (sentinel) settlePendingSource(node, sentinel, true);
+};
 let externalSourceConfig = null;
 function enableExternalSource(config) {
   const { factory: factory, untrack: untrackFn = fn => fn() } = config;
@@ -1597,6 +1716,7 @@ let latestReadActive = false;
 let context = null;
 let currentOptimisticLane = null;
 let pendingProbe = null;
+let affectsReads = null;
 let snapshotCaptureActive = false;
 let snapshotSources = null;
 function ownerInSnapshotScope(owner) {
@@ -1669,8 +1789,9 @@ function recompute(el, create = false) {
   }
   let isOptimisticDirty = !!(el._flags & REACTIVE_OPTIMISTIC_DIRTY);
   const hasOverride = el._overrideValue !== undefined && el._overrideValue !== NOT_PENDING;
-  !!(el._statusFlags & STATUS_PENDING);
+  const wasPending = !!(el._statusFlags & STATUS_PENDING);
   const wasUninitialized = !!(el._statusFlags & STATUS_UNINITIALIZED);
+  const isReask = !!(el._flags & REACTIVE_REASK) && !(wasPending && !el._reask);
   const oldcontext = context;
   context = el;
   el._depsTail = null;
@@ -1680,6 +1801,9 @@ function recompute(el, create = false) {
   let value = el._pendingValue === NOT_PENDING ? el._value : el._pendingValue;
   let oldHeight = el._height;
   let prevTracking = tracking;
+  const prevAffectsReads = affectsReads;
+  affectsReads = null;
+  let markedReads = null;
   let prevLane = currentOptimisticLane;
   let prevStrictRead = false;
   {
@@ -1735,7 +1859,12 @@ function recompute(el, create = false) {
         updatePendingSignal(lane._source);
       }
     }
-    if (e instanceof NotReadyError) el._blocked = true;
+    let reaskChanged = false;
+    if (e instanceof NotReadyError) {
+      el._blocked = true;
+      reaskChanged = wasPending && el._reask !== isReask;
+      el._reask = isReask;
+    }
     notifyStatus(
       el,
       e instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR,
@@ -1743,12 +1872,15 @@ function recompute(el, create = false) {
       undefined,
       e instanceof NotReadyError ? el._optimisticLane : undefined
     );
+    if (reaskChanged) repollDownstreamVerdicts(el);
   } finally {
     tracking = prevTracking;
     strictRead = prevStrictRead;
     if (isStaleEffect) stale = prevStale;
     el._flags = REACTIVE_NONE | (create ? el._flags & REACTIVE_SNAPSHOT_STALE : 0);
     context = oldcontext;
+    markedReads = affectsReads;
+    affectsReads = prevAffectsReads;
   }
   if (!el._error) {
     trimStaleDeps(el);
@@ -1794,6 +1926,7 @@ function recompute(el, create = false) {
     }
   }
   currentOptimisticLane = prevLane;
+  if (markedReads) applyAffectsReads(el, markedReads);
   const needsPendingCommit =
     el._pendingValue !== NOT_PENDING ||
     el._pendingFirstChild !== null ||
@@ -1870,7 +2003,8 @@ function computed(fn, options) {
     _pendingDisposal: null,
     _pendingFirstChild: null,
     _inFlight: null,
-    _transition: null
+    _transition: null,
+    _reask: false
   };
   self._name = options?.name ?? "computed";
   setupComputedNode(self, options);
@@ -1916,6 +2050,7 @@ function createEffectNode(fn, effectFn, errorFn, type, notifyStatus, options) {
     _pendingFirstChild: null,
     _inFlight: null,
     _transition: null,
+    _reask: false,
     _modified: false,
     _prevValue: undefined,
     _effectFn: effectFn,
@@ -2105,7 +2240,11 @@ function read(el) {
     !snapshotCaptureActive &&
     !strictRead
   ) {
-    if (c && tracking) link(el, c);
+    if (c && tracking) {
+      link(el, c);
+      if (activeAffectsMarks !== 0 && el._affectsCount && !pendingCheckActive)
+        (affectsReads ??= []).push(el);
+    }
     return !c || el._pendingValue === NOT_PENDING ? el._value : el._pendingValue;
   }
   if (strictRead && owner._statusFlags & STATUS_PENDING) {
@@ -2126,6 +2265,8 @@ function read(el) {
   }
   if (c && tracking) {
     link(el, c, pendingCheckActive);
+    if (activeAffectsMarks !== 0 && el._affectsCount && !pendingCheckActive)
+      (affectsReads ??= []).push(el);
     if (owner._fn) {
       const isZombie = el._flags & REACTIVE_ZOMBIE;
       if (owner._height >= (isZombie ? zombieQueue._min : dirtyQueue._min)) {
@@ -2360,29 +2501,48 @@ function collectPendingSources(el) {
   const owner = el._firewall || el;
   if (owner !== el) pendingProbe.sources.add(owner);
 }
+function witnessAffects(node) {
+  pendingProbe?.sources.add(node);
+}
+function quietPending(el) {
+  if (el._pendingSources) {
+    for (const source of el._pendingSources) if (!source._reask) return false;
+    return true;
+  }
+  if (el._pendingSource) return el._pendingSource._reask;
+  return el._reask;
+}
+function newQuestionInFlight(comp) {
+  return (
+    !!(comp._statusFlags & STATUS_PENDING) &&
+    !(comp._statusFlags & STATUS_UNINITIALIZED) &&
+    !quietPending(comp)
+  );
+}
 function computePendingState(el) {
   const comp = el;
   if (comp._flags & REACTIVE_DISPOSED) return false;
+  if (el._affectsCount) return true;
   const firewall = el._firewall;
-  if ((firewall || comp)._optimisticMask) return false;
   if (el._parentSource) {
     const parentNode = el._parentSource;
-    if (hasActiveOverride(parentNode)) return false;
+    if (parentNode._affectsCount) return true;
     const parent = parentNode._firewall || parentNode;
-    if (parent._optimisticMask) return false;
-    return !!(
-      parent._statusFlags & STATUS_PENDING && !(parent._statusFlags & STATUS_UNINITIALIZED)
-    );
+    return newQuestionInFlight(parent);
   }
-  if (hasActiveOverride(el)) return false;
-  if (firewall && el._pendingValue !== NOT_PENDING) {
+  if (firewall && el._pendingValue !== NOT_PENDING && !hasActiveOverride(el)) {
     return (
       !!(firewall._flags & REACTIVE_MANUAL_WRITE) ||
-      (!firewall._inFlight && !(firewall._statusFlags & STATUS_PENDING))
+      (!firewall._inFlight && !(firewall._statusFlags & STATUS_PENDING)) ||
+      (!!(firewall._statusFlags & STATUS_PENDING) && quietPending(firewall))
     );
   }
-  if (el._pendingValue !== NOT_PENDING && !(comp._statusFlags & STATUS_UNINITIALIZED)) return true;
-  return !!(comp._statusFlags & STATUS_PENDING && !(comp._statusFlags & STATUS_UNINITIALIZED));
+  if (el._pendingValue !== NOT_PENDING && !(comp._statusFlags & STATUS_UNINITIALIZED)) {
+    if (hasActiveOverride(el))
+      return !el._equals || !el._equals(el._pendingValue, el._overrideValue);
+    return true;
+  }
+  return newQuestionInFlight(comp);
 }
 function syncCompanions(el, value) {
   if (el._pendingSignal) updatePendingSignal(el);
@@ -2399,6 +2559,19 @@ function updateChildCompanions(el) {
     if (child._pendingSignal || child._latestValueComputed) updatePendingSignal(child);
   }
 }
+function repollDownstreamVerdicts(el) {
+  const visited = new Set();
+  const visit = node => {
+    if (visited.has(node)) return;
+    visited.add(node);
+    if (node._pendingSignal || node._latestValueComputed) updatePendingSignal(node);
+    for (let s = node._subs; s !== null; s = s._nextSub) visit(s._sub);
+    for (let child = node._child ?? null; child !== null; child = child._nextChild) {
+      visit(child);
+    }
+  };
+  visit(el);
+}
 function snapCompanionsToState(owner) {
   const sig = owner._pendingSignal;
   if (sig && (sig._overrideValue === undefined || sig._overrideValue === NOT_PENDING)) {
@@ -2486,8 +2659,9 @@ function isPending(fn) {
   } catch (e) {
     collectPending();
     if (e instanceof NotReadyError) {
-      if (probe.found && !(e.source?._statusFlags & STATUS_UNINITIALIZED)) return true;
-      if (context) throw e;
+      const uninitialized = !!(e.source?._statusFlags & STATUS_UNINITIALIZED);
+      if (probe.found && !uninitialized) return true;
+      if (context && uninitialized) throw e;
     }
     return probe.found;
   } finally {
@@ -2532,6 +2706,10 @@ function refresh(target) {
     typeof node._fn === "function" &&
     !(node._flags & (REACTIVE_DISPOSED | REACTIVE_MANUAL_WRITE))
   ) {
+    if (!(node._flags & (REACTIVE_DIRTY | REACTIVE_CHECK | REACTIVE_IN_HEAP))) {
+      node._flags |= REACTIVE_REASK;
+      armReaskClear();
+    }
     node._flags = (node._flags & ~REACTIVE_CHECK) | REACTIVE_DIRTY;
     insertIntoHeap(node, node._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
     schedule();
@@ -2632,8 +2810,7 @@ function notifyEffectStatus(status, error) {
 function runEffect(node) {
   if (!node._modified || node._flags & REACTIVE_DISPOSED) return;
   if (node._statusFlags & STATUS_ERROR && node._type === EFFECT_USER) {
-    const err =
-      node._error instanceof StatusError ? (node._error.cause ?? node._error) : node._error;
+    const err = unwrapStatusError(node._error);
     node._prevValue = node._value;
     node._modified = false;
     try {
@@ -2739,6 +2916,9 @@ function trackedEffect(fn, options) {
     console.warn(message);
   }
 }
+const ACTION_CALLED_IN_OWNED_SCOPE_MESSAGE =
+  "[ACTION_CALLED_IN_OWNED_SCOPE] Calling an action inside an owned scope (component, computation) is not allowed. " +
+  "Call it from an event handler or another imperative scope.";
 function restoreTransition(transition, fn) {
   globalQueue.initTransition(transition);
   const result = fn();
@@ -2746,28 +2926,42 @@ function restoreTransition(transition, fn) {
   return result;
 }
 function action(genFn) {
-  return (...args) =>
-    new Promise((resolve, reject) => {
+  return (...args) => {
+    {
+      const owner = getOwner();
+      if (owner && !(owner._config & CONFIG_CHILDREN_FORBIDDEN)) {
+        emitDiagnostic({
+          code: "ACTION_CALLED_IN_OWNED_SCOPE",
+          kind: "write",
+          severity: "error",
+          message: ACTION_CALLED_IN_OWNED_SCOPE_MESSAGE,
+          ownerId: owner.id,
+          ownerName: owner._name
+        });
+        throw new Error(ACTION_CALLED_IN_OWNED_SCOPE_MESSAGE);
+      }
+    }
+    return new Promise((resolve, reject) => {
       const it = genFn(...args);
       globalQueue.initTransition();
       let ctx = activeTransition;
       ctx._actions.push(it);
-      const done = (v, e) => {
+      const done = (v, e, failed = false) => {
         ctx = currentTransition(ctx);
         const i = ctx._actions.indexOf(it);
         if (i >= 0) ctx._actions.splice(i, 1);
         setActiveTransition(ctx);
         schedule();
-        e ? reject(e) : resolve(v);
+        failed ? 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);
+          return done(undefined, e, true);
         }
-        if (isThenable(r)) return void r.then(run, e => done(undefined, e));
+        if (isThenable(r)) return void r.then(run, e => done(undefined, e, true));
         run(r);
       };
       const run = r => {
@@ -2781,6 +2975,7 @@ function action(genFn) {
       };
       step();
     });
+  };
 }
 function onCleanup(fn) {
   {
@@ -2859,11 +3054,17 @@ function createReaction(effectFn, options) {
   let cl = undefined;
   cleanup(() => cl?.());
   const owner = getOwner();
+  let arm;
   return tracking => {
+    if (arm) {
+      dispose(arm);
+      arm = undefined;
+    }
     runWithOwner(owner, () => {
       effect(
-        () => (tracking(), getOwner()),
+        () => (tracking(), (arm = getOwner())),
         node => {
+          arm = undefined;
           cl?.();
           const cleanup = (effectFn.effect || effectFn)?.();
           if (true && cleanup !== undefined && typeof cleanup !== "function") {
@@ -3406,7 +3607,8 @@ function createWriteTraps(isActive, onDraftWrite) {
 const $TRACK = Symbol("STORE_TRACK"),
   $TARGET = Symbol("STORE_TARGET"),
   $PROXY = Symbol("STORE_PROXY"),
-  $DELETED = Symbol("STORE_DELETED");
+  $DELETED = Symbol("STORE_DELETED"),
+  $AFFECTS = Symbol("STORE_AFFECTS");
 const STORE_VALUE = "v",
   STORE_OVERRIDE = "o",
   STORE_OPTIMISTIC_OVERRIDE = "x",
@@ -3416,8 +3618,7 @@ const STORE_VALUE = "v",
   STORE_WRAP = "w",
   STORE_LOOKUP = "l",
   STORE_FIREWALL = "f",
-  STORE_OPTIMISTIC = "p",
-  STORE_MASKED = "m";
+  STORE_OPTIMISTIC = "p";
 const STORE_SELF_PENDING = Symbol("STORE_SELF_PENDING");
 function createStoreProxy(value, traps = storeTraps, extend) {
   let newTarget;
@@ -3513,7 +3714,7 @@ function getNodes(target, type) {
   if (!nodes) target[type] = nodes = Object.create(null);
   return nodes;
 }
-function getNode(nodes, property, value, firewall, equals = isEqual, optimistic, snapshotProps) {
+function getNode(target, nodes, property, value, equals = isEqual, snapshotProps) {
   if (nodes[property]) return nodes[property];
   const s = signal(
     value,
@@ -3525,12 +3726,13 @@ function getNode(nodes, property, value, firewall, equals = isEqual, optimistic,
           if (
             typeof property === "symbol" &&
             property !== $TRACK &&
+            property !== $AFFECTS &&
             symbolKeyedRecords.has(nodes)
           ) {
             const syms = Object.getOwnPropertySymbols(nodes);
             let hasUserSymbol = false;
             for (let i = 0, len = syms.length; i < len; i++) {
-              if (syms[i] !== $TRACK) {
+              if (syms[i] !== $TRACK && syms[i] !== $AFFECTS) {
                 hasUserSymbol = true;
                 break;
               }
@@ -3540,9 +3742,9 @@ function getNode(nodes, property, value, firewall, equals = isEqual, optimistic,
         }
       }
     },
-    firewall
+    target[STORE_FIREWALL]
   );
-  if (optimistic) {
+  if (target[STORE_OPTIMISTIC]) {
     s._overrideValue = NOT_PENDING;
   }
   if (snapshotProps && property in snapshotProps) {
@@ -3550,21 +3752,99 @@ function getNode(nodes, property, value, firewall, equals = isEqual, optimistic,
     s._snapshotValue = sv === undefined ? NO_SNAPSHOT : sv;
     snapshotSources?.add(s);
   }
-  if (typeof property === "symbol" && property !== $TRACK) symbolKeyedRecords.add(nodes);
+  if (typeof property === "symbol" && property !== $TRACK && property !== $AFFECTS)
+    symbolKeyedRecords.add(nodes);
+  if (property !== $AFFECTS && affectsScopes.size) inheritAffectsMarks(s, target[STORE_VALUE]);
   return (nodes[property] = s);
 }
+function inheritAffectsMarks(node, raw) {
+  for (const [carrier, entry] of affectsScopes) {
+    if (carrier._affectsCount && entry.scope.has(raw)) {
+      markAffects(node);
+      entry.inherited.push(node);
+    }
+  }
+}
+const affectsScopes = new Map();
+function walkAffectsScope(value, entry, found, lookup, visited) {
+  if (!isWrappable(value)) return;
+  const target = value[$TARGET] || (lookup ?? storeLookup).get(value)?.[$TARGET];
+  const raw = target ? target[STORE_VALUE] : value;
+  if (visited.has(raw)) return;
+  visited.add(raw);
+  entry.scope.add(raw);
+  let override;
+  if (target) {
+    collectRecordNodes(target[STORE_NODE], found);
+    collectRecordNodes(target[STORE_HAS], found);
+    override = mergedOverlay(target);
+    lookup = target[STORE_LOOKUP] ?? lookup;
+  }
+  if (Array.isArray(raw)) {
+    const len = override?.length ?? raw.length;
+    for (let i = 0; i < len; i++) {
+      const v = override && i in override ? override[i] : raw[i];
+      if (v !== $DELETED) walkAffectsScope(v, entry, found, lookup, visited);
+    }
+  } else {
+    const keys = getKeys(raw, override);
+    for (let i = 0, l = keys.length; i < l; i++) {
+      const desc = getPropertyDescriptor(raw, override, keys[i]);
+      if (!desc || desc.get) continue;
+      walkAffectsScope(desc.value, entry, found, lookup, visited);
+    }
+  }
+}
+function collectRecordNodes(nodes, found) {
+  if (!nodes) return;
+  for (const key of Object.keys(nodes)) found.push(nodes[key]);
+  const syms = Object.getOwnPropertySymbols(nodes);
+  for (let i = 0, l = syms.length; i < l; i++) {
+    if (syms[i] !== $AFFECTS) found.push(nodes[syms[i]]);
+  }
+}
+function witnessAffectsMark(target) {
+  const own = target[STORE_NODE]?.[$AFFECTS];
+  if (own?._affectsCount) witnessAffects(own);
+  if (affectsScopes.size) {
+    const raw = target[STORE_VALUE];
+    for (const [carrier, entry] of affectsScopes) {
+      if (carrier !== own && carrier._affectsCount && entry.scope.has(raw)) witnessAffects(carrier);
+    }
+  }
+}
+function getStoreAffectsNodes(target, key) {
+  const nodes = getNodes(target, STORE_NODE);
+  if (key === undefined) {
+    const carrier = getNode(target, nodes, $AFFECTS, undefined, false);
+    GlobalQueue._releaseAffectsScope ||= node => {
+      const entry = affectsScopes.get(node);
+      if (!entry) return;
+      affectsScopes.delete(node);
+      for (let i = 0; i < entry.inherited.length; i++) releaseAffectsMark(entry.inherited[i]);
+    };
+    let entry = affectsScopes.get(carrier);
+    if (!entry) affectsScopes.set(carrier, (entry = { scope: new Set(), inherited: [] }));
+    const result = [carrier];
+    walkAffectsScope(target[$PROXY], entry, result, target[STORE_LOOKUP], new Set());
+    return result;
+  }
+  if (nodes[key]) return [nodes[key]];
+  const layer = getOverlayLayer(target, key);
+  const raw = layer ? layer[key] : target[STORE_VALUE][key];
+  const prev = raw === $DELETED ? undefined : raw;
+  return [upsertStoreNode(target, nodes, key, prev, target[STORE_SNAPSHOT_PROPS])];
+}
 function trackSelf(target, symbol = $TRACK) {
-  getObserver() &&
-    read(
-      getNode(
-        getNodes(target, STORE_NODE),
-        symbol,
-        undefined,
-        target[STORE_FIREWALL],
-        false,
-        target[STORE_OPTIMISTIC]
-      )
-    );
+  if (!getObserver()) return;
+  read(getNode(target, getNodes(target, STORE_NODE), symbol, undefined, false));
+  if (
+    symbol === $TRACK &&
+    !target[STORE_OVERRIDE] &&
+    !target[STORE_OPTIMISTIC_OVERRIDE] &&
+    target[STORE_VALUE][$TARGET]
+  )
+    target[STORE_VALUE][$TRACK];
 }
 function notifySelf(target) {
   const node = target[STORE_NODE]?.[$TRACK];
@@ -3574,6 +3854,11 @@ function notifySelf(target) {
       target[STORE_OPTIMISTIC] && !projectionWriteActive ? STORE_SELF_PENDING : undefined
     );
 }
+function mergedOverlay(target) {
+  const override = target[STORE_OVERRIDE];
+  const opt = target[STORE_OPTIMISTIC_OVERRIDE];
+  return override && opt ? { ...override, ...opt } : (opt ?? override);
+}
 function getKeys(source, override, enumerable = true) {
   const baseKeys = source[$TARGET]
     ? untrack(() => (enumerable ? Object.keys(source) : Reflect.ownKeys(source)))
@@ -3602,17 +3887,6 @@ function getPropertyDescriptor(source, override, property) {
   }
   return Reflect.getOwnPropertyDescriptor(source, property);
 }
-function maskStoreTarget(target, on) {
-  const firewall = target[STORE_FIREWALL];
-  if (!firewall) return;
-  if (!!target[STORE_MASKED] === on) return;
-  target[STORE_MASKED] = on;
-  const count = (firewall._optimisticMask = (firewall._optimisticMask || 0) + (on ? 1 : -1));
-  if ((on && count === 1) || (!on && count === 0)) {
-    updatePendingSignal(firewall);
-    updateChildCompanions(firewall);
-  }
-}
 function prepareStoreWrite(target, store, property) {
   if (target[STORE_OPTIMISTIC]) {
     const firewall = target[STORE_FIREWALL];
@@ -3642,21 +3916,12 @@ function prepareStoreWrite(target, store, property) {
 function armOptimisticStoreWrite(target, store) {
   if (target[STORE_OPTIMISTIC] && !projectionWriteActive) {
     trackOptimisticStore(store);
-    maskStoreTarget(target, true);
   }
 }
 function upsertStoreNode(target, nodes, property, prev, snapshotProps) {
   if (nodes[property]) return nodes[property];
   const initial = isWrappable(prev) ? wrap(prev, target) : prev;
-  const node = getNode(
-    nodes,
-    property,
-    initial,
-    target[STORE_FIREWALL],
-    isEqual,
-    target[STORE_OPTIMISTIC],
-    snapshotProps
-  );
+  const node = getNode(target, nodes, property, initial, isEqual, snapshotProps);
   registerTransientStoreNode(node);
   return node;
 }
@@ -3699,6 +3964,7 @@ const storeTraps = {
     if (property === $TARGET) return target;
     if (property === $PROXY) return receiver;
     if (property === $REFRESH) return target[STORE_FIREWALL];
+    if (pendingCheckActive) witnessAffectsMark(target);
     if (property === $TRACK) {
       trackSelf(target);
       return receiver;
@@ -3720,7 +3986,7 @@ const storeTraps = {
       !selfRead &&
       !writeOnly(receiver)
     ) {
-      return read(getNode(nodes, property, undefined, target[STORE_FIREWALL]));
+      return read(getNode(target, nodes, property, undefined));
     }
     const overlay = getOverlayLayer(target, property);
     const overridden = !!overlay;
@@ -3768,12 +4034,11 @@ const storeTraps = {
       } else if (getObserver() && !selfRead) {
         return read(
           getNode(
+            target,
             nodes,
             property,
             isWrappable(value) ? wrap(value, target) : value,
-            target[STORE_FIREWALL],
             isEqual,
-            target[STORE_OPTIMISTIC],
             target[STORE_SNAPSHOT_PROPS]
           )
         );
@@ -3797,15 +4062,14 @@ const storeTraps = {
   },
   has(target, property) {
     if (property === $PROXY || property === $TRACK || property === "__proto__") return true;
+    if (pendingCheckActive) witnessAffectsMark(target);
     const hasLayer = getOverlayLayer(target, property);
     const has = hasLayer ? hasLayer[property] !== $DELETED : property in target[STORE_VALUE];
     if (writeOnly(target[$PROXY]) || getObserver() === target[STORE_FIREWALL]) return has;
     const nodes = getNodes(target, STORE_HAS);
     if (nodes[property]) return read(nodes[property]);
     if (getObserver()) {
-      return read(
-        getNode(nodes, property, has, target[STORE_FIREWALL], isEqual, target[STORE_OPTIMISTIC])
-      );
+      return read(getNode(target, nodes, property, has));
     }
     return has;
   },
@@ -3825,9 +4089,14 @@ const storeTraps = {
           ? prevLayer[property] !== $DELETED
           : property in target[STORE_VALUE];
         const value = unwrapStoreValue(rawValue);
+        const index = typeof property === "string" ? Number(property) : -1;
         const isArrayIndexWrite =
-          Array.isArray(state) && property !== "length" && typeof property !== "symbol";
-        const nextIndex = isArrayIndexWrite ? parseInt(property) + 1 : 0;
+          Array.isArray(state) &&
+          Number.isInteger(index) &&
+          index >= 0 &&
+          index < 4294967295 &&
+          String(index) === property;
+        const nextIndex = isArrayIndexWrite ? index + 1 : 0;
         const len = isArrayIndexWrite && (getOverlayLayer(target, "length") ?? state).length;
         const nextLength = isArrayIndexWrite && nextIndex > len ? nextIndex : undefined;
         if (prev === value && nextLength === undefined) return true;
@@ -3930,6 +4199,7 @@ const storeTraps = {
     return true;
   },
   ownKeys(target) {
+    if (pendingCheckActive) witnessAffectsMark(target);
     if (getObserver() !== target[STORE_FIREWALL]) trackSelf(target);
     let keys = getKeys(target[STORE_VALUE], target[STORE_OVERRIDE], false);
     if (target[STORE_OPTIMISTIC_OVERRIDE]) {
@@ -4013,6 +4283,58 @@ function createStore(first, second, options) {
       : fn => storeSetter(wrappedStore, fn)
   ];
 }
+function affects(target, key) {
+  if (arguments.length > 2) {
+    const message =
+      "[INVALID_AFFECTS_TARGET] affects() takes a single optional key — extra keys are " +
+      "not a path. Mark each slot with its own affects(record, key) call, or pass the " +
+      'nested record itself: affects(state.user, "name").';
+    emitDiagnostic({
+      code: "INVALID_AFFECTS_TARGET",
+      kind: "write",
+      severity: "error",
+      message: message
+    });
+    throw new Error(message);
+  }
+  const storeTarget = target?.[$TARGET];
+  if (storeTarget) {
+    const nodes = getStoreAffectsNodes(storeTarget, key);
+    for (let i = 0; i < nodes.length; i++) registerAffectsMark(nodes[i]);
+    return;
+  }
+  const node = target?.[$REFRESH];
+  if (node) {
+    if (key !== undefined) {
+      const message =
+        "[INVALID_AFFECTS_TARGET] affects() keys are only valid on store targets. " +
+        "An accessor is a single slot — pass it alone, or target the store record that owns the property.";
+      emitDiagnostic({
+        code: "INVALID_AFFECTS_TARGET",
+        kind: "write",
+        severity: "error",
+        message: message,
+        nodeName: node._name
+      });
+      throw new Error(message);
+    }
+    registerAffectsMark(node);
+    return;
+  }
+  {
+    const message =
+      "[INVALID_AFFECTS_TARGET] affects() expects a Solid source accessor or a store node. " +
+      "Pass the store proxy (optionally with a property key) or the original accessor, " +
+      "not a wrapper function or an already-read value.";
+    emitDiagnostic({
+      code: "INVALID_AFFECTS_TARGET",
+      kind: "write",
+      severity: "error",
+      message: message
+    });
+    throw new Error(message);
+  }
+}
 function createOptimisticStore(first, second, options) {
   GlobalQueue._clearOptimisticStore ||= clearOptimisticStore;
   const derived = typeof first === "function";
@@ -4023,15 +4345,12 @@ function createOptimisticStore(first, second, options) {
 }
 function clearOptimisticStore(store) {
   const target = store[$TARGET];
-  if (!target) return;
-  maskStoreTarget(target, false);
-  if (!target[STORE_OPTIMISTIC_OVERRIDE]) return;
+  if (!target?.[STORE_OPTIMISTIC_OVERRIDE]) return;
   clearOptimisticOverride(target);
 }
 function clearOptimisticOverride(target) {
   const override = target[STORE_OPTIMISTIC_OVERRIDE];
   if (!override) return;
-  maskStoreTarget(target, false);
   const nodes = target[STORE_NODE];
   delete target[STORE_OPTIMISTIC_OVERRIDE];
   const wasProjectionWriteActive = projectionWriteActive;
@@ -4198,18 +4517,16 @@ const storePath = Object.assign(
   },
   { DELETE: DELETE }
 );
-function mergedOverlay(target) {
-  const override = target[STORE_OVERRIDE];
-  const opt = target[STORE_OPTIMISTIC_OVERRIDE];
-  return override && opt ? { ...override, ...opt } : (opt ?? override);
-}
 function snapshotImpl(item, track, map, lookup) {
   let target, isArray, override, result, unwrapped, v;
   if (!isWrappable(item)) return item;
   if (map && map.has(item)) return map.get(item);
   if (!map) map = new Map();
   if ((target = item[$TARGET] || lookup?.get(item)?.[$TARGET])) {
-    if (track) trackSelf(target, $TRACK);
+    if (track) {
+      trackSelf(target, $TRACK);
+      if (pendingCheckActive) witnessAffectsMark(target);
+    }
     override = mergedOverlay(target);
     isArray = Array.isArray(target[STORE_VALUE]);
     map.set(
@@ -4751,7 +5068,7 @@ class RevealController {
   }
   isMinimallyReady() {
     const order = untrack(this._orderAccessor);
-    if (order === "together") return this.isReady();
+    if (order === "together") return this._forEachOwnedSlot(isSlotMinimallyReady);
     if (order === "natural") {
       let hasSlot = false;
       let anyReady = false;
@@ -4875,9 +5192,6 @@ class CollectionQueue extends Queue {
         this._sources.clear();
       }
     }
-    if (this._collectionType & STATUS_PENDING && flags & STATUS_ERROR) {
-      return super.notify(node, STATUS_ERROR, flags, error);
-    }
     if (this._collectionType & STATUS_PENDING && this._initialized)
       return super.notify(node, type, flags, error);
     if (flags & this._collectionType) {
@@ -4888,7 +5202,7 @@ class CollectionQueue extends Queue {
         this._sources.add(source);
         if (wasEmpty) setSignal(this._disabled, true);
         if (this._collectionType & STATUS_ERROR) {
-          setSignal(this._error, source._error?.cause ?? source._error);
+          setSignal(this._error, unwrapStatusError(source._error));
         }
       }
     }
@@ -5081,6 +5395,7 @@ export {
   NotReadyError,
   SUPPORTS_PROXY,
   action,
+  affects,
   clearSnapshots,
   createContext,
   createEffect,