@solidjs/signals 2.0.0-rc.2 → 2.0.0-rc.3

package/dist/dev.js

@@ -236,7 +236,7 @@ function captureStack() {
   // remaining frames are the user code that performed the write.
   return raw
     .slice(1)
-    .filter(line => !/solid-signals[/\\](src|dist)[/\\]/.test(line))
+    .filter(line => !/(?:^|[/\\])(?:packages[/\\])?signals[/\\](src|dist)[/\\]/.test(line))
     .slice(0, 3)
     .map(line => line.trim());
 }
@@ -4507,7 +4507,16 @@ function optimisticWrite(el, v) {
   const currentValue = hasOverride ? unwrapOverride(el._x?._overrideValue) : el._value;
   if (typeof v === "function") v = v(currentValue);
   const valueChanged =
-    !!(el._statusFlags & STATUS_UNINITIALIZED) || !el._equals || !el._equals(currentValue, v);
+    !!(el._statusFlags & STATUS_UNINITIALIZED) ||
+    // A dirty node's _value is stale (its queued recompute hasn't run — e.g.
+    // a latest() shadow marked by the previous landing's companion snap), so
+    // equality against it must not swallow the write. Without this, a sync
+    // push returning the shadow to that stale value was dropped, the snap
+    // recompute then committed the parent's old value, and the banner showed
+    // the previous transition's target (#3041 follow-up).
+    !!((el._flags ?? 0) & (REACTIVE_DIRTY | REACTIVE_CHECK)) ||
+    !el._equals ||
+    !el._equals(currentValue, v);
   if (!valueChanged) {
     // Same-value write with an active override still entangles the current
     // action's transition — the hold must outlast all overlapping actions.
@@ -4663,18 +4672,33 @@ function laneReadsCommitted(el, owner, c) {
     el._x?._overrideValue !== undefined ||
     !!el._x?._optimisticLane ||
     !!(owner._statusFlags & STATUS_PENDING)
-  )
+  ) {
+    // The committed view hides a staged in-flight value that will promote
+    // silently (commitPendingNode never re-notifies). gatedRead records plain
+    // signals for replay at commit; async memos are excluded from it by the
+    // `_fn` check and reach here instead — a lane-assigned source whose async
+    // already settled (laneAsyncSettled keeps _optimisticLane) served its
+    // committed value to a reader that never re-ran after the landing, so a
+    // pending-gated branch stayed one value behind permanently (#3041
+    // follow-up). Record the reader under the same replay contract.
+    if (el._pendingValue !== NOT_PENDING)
+      (activeTransition ?? globalQueue._batch)._gatedSubs.add(c);
     return true;
+  }
   if (owner === el && stale && c._x?._parentSource !== el) {
-    // The committed view can hide a same-tick ambient write (a lane member —
-    // even just an isPending companion flip — puts the reader "under a lane"
-    // against unrelated plain writes). With no transaction the write commits
-    // at THIS flush's end with no re-delivery, so record the reader for
-    // replay at commit — the same contract gatedRead provides when a
-    // transaction is active (#2963). If a transaction forms mid-flush,
-    // initTransition carries the recording over to it.
-    if (el._pendingValue !== NOT_PENDING && activeTransition === null)
-      globalQueue._batch._gatedSubs.add(c);
+    // The committed view can hide a staged write (a lane member — even just
+    // an isPending companion flip — puts the reader "under a lane"). The
+    // staged value commits with no re-delivery (commitPendingNode never
+    // re-notifies), so record the reader for replay at commit — the same
+    // contract gatedRead provides (#2963). gatedRead itself only covers
+    // signal reads where the reading computed differs from the source; the
+    // owner === el memo/self read lands here instead. With a transaction
+    // active the staged value promotes silently at ITS landing, so record
+    // into the transaction (#3041 follow-up: a pending-gated branch that
+    // first read its async source during the landing flush stayed one value
+    // behind permanently); with none, into the ambient batch.
+    if (el._pendingValue !== NOT_PENDING)
+      (activeTransition ?? globalQueue._batch)._gatedSubs.add(c);
     return true;
   }
   return false;
@@ -5030,6 +5054,13 @@ function snapCompanionsToState(owner) {
 }
 function getLatestValueComputed(el) {
   let lvc = el._x?._latestValueComputed;
+  // A shadow disposed while unobserved (its gated reader unmounted at a
+  // landing) is a corpse: sync writes into it equality-swallow against its
+  // frozen _value, and a later read revives it via recompute — clearing
+  // DISPOSED and re-deriving from the committed view, so the banner showed
+  // the previous transition's target (#3041 follow-up). Treat it as absent;
+  // recreation backfills from the in-flight write below.
+  if (lvc && lvc._flags & REACTIVE_DISPOSED) lvc = undefined;
   if (!lvc) {
     const prevPending = latestReadActive;
     setLatestReadActive(false);
@@ -8463,10 +8494,29 @@ function descend(pv, nv, keyFn, fam, proj = false) {
  * primitives; the generic draft write-traps are reused from the legacy
  * module unchanged.
  */
-function createWriteTraps(isActive, onDraftWrite) {
-  // Save/restore, never hard-reset: the draft can be driven from inside an
-  // enclosing authoritative-write scope (next-store optimistic derives), and
-  // a hard `false` would clobber it mid-derive.
+/**
+ * Wrap a store proxy as a projection DRAFT: every operation carries the write
+ * override (the derive is the author — its ops must not hit the §6c firewall
+ * gate, even in a continuation after an `await`/`yield` where the sync write
+ * scope has closed).
+ *
+ * FAKE TARGET, not the store proxy itself (#3060): after a proxy trap
+ * returns, the engine runs spec invariant validation against the proxy's
+ * TARGET — [[OwnPropertyKeys]] after ownKeys, [[GetOwnProperty]] after
+ * set/getOwnPropertyDescriptor/defineProperty. With the store proxy as
+ * target those checks re-enter the store's traps OUTSIDE the override
+ * bracket (the trap's finally has already run), so `Object.keys(state)` in
+ * a derive continuation fired the firewall gate and re-threw the
+ * projection's own pending NotReadyError into the derive. A dummy of
+ * matching kind (array/object, same trick as the store's own TargetShape)
+ * keeps invariant validation away from the store entirely; the traps
+ * forward to the closed-over inner proxy inside the bracket.
+ *
+ * Save/restore projectionWriteActive, never hard-reset: the draft can be
+ * driven from inside an enclosing authoritative-write scope (next-store
+ * optimistic derives), and a hard `false` would clobber it mid-derive.
+ */
+function wrapDraft(inner, isActive, onDraftWrite) {
   const traps = {
     get(_, prop) {
       let value;
@@ -8474,13 +8524,15 @@ function createWriteTraps(isActive, onDraftWrite) {
       setWriteOverride(true);
       setProjectionWriteActive(true);
       try {
-        value = _[prop];
+        value = inner[prop];
       } finally {
         setWriteOverride(false);
         setProjectionWriteActive(was);
       }
       if (prop === $TARGET) return value;
-      return typeof value === "object" && value !== null ? new Proxy(value, traps) : value;
+      return typeof value === "object" && value !== null
+        ? wrapDraft(value, isActive, onDraftWrite)
+        : value;
     },
     has(_, prop) {
       let value;
@@ -8488,7 +8540,7 @@ function createWriteTraps(isActive, onDraftWrite) {
       setWriteOverride(true);
       setProjectionWriteActive(true);
       try {
-        value = prop in _;
+        value = prop in inner;
       } finally {
         setWriteOverride(false);
         setProjectionWriteActive(was);
@@ -8501,7 +8553,7 @@ function createWriteTraps(isActive, onDraftWrite) {
       setWriteOverride(true);
       setProjectionWriteActive(true);
       try {
-        _[prop] = value;
+        inner[prop] = value;
         onDraftWrite?.();
       } finally {
         setWriteOverride(false);
@@ -8515,7 +8567,49 @@ function createWriteTraps(isActive, onDraftWrite) {
       setWriteOverride(true);
       setProjectionWriteActive(true);
       try {
-        delete _[prop];
+        delete inner[prop];
+        onDraftWrite?.();
+      } finally {
+        setWriteOverride(false);
+        setProjectionWriteActive(was);
+      }
+      return true;
+    },
+    ownKeys() {
+      const was = projectionWriteActive;
+      setWriteOverride(true);
+      setProjectionWriteActive(true);
+      try {
+        return Reflect.ownKeys(inner);
+      } finally {
+        setWriteOverride(false);
+        setProjectionWriteActive(was);
+      }
+    },
+    getOwnPropertyDescriptor(_, prop) {
+      let d;
+      const was = projectionWriteActive;
+      setWriteOverride(true);
+      setProjectionWriteActive(true);
+      try {
+        d = Reflect.getOwnPropertyDescriptor(inner, prop);
+      } finally {
+        setWriteOverride(false);
+        setProjectionWriteActive(was);
+      }
+      // The dummy target doesn't hold the key, so a non-configurable report
+      // would violate the proxy invariant. Store descriptors are already
+      // normalized configurable; enforce it for raw leaves too.
+      if (d) d.configurable = true;
+      return d;
+    },
+    defineProperty(_, prop, desc) {
+      if (isActive && !isActive()) return true;
+      const was = projectionWriteActive;
+      setWriteOverride(true);
+      setProjectionWriteActive(true);
+      try {
+        Reflect.defineProperty(inner, prop, desc);
         onDraftWrite?.();
       } finally {
         setWriteOverride(false);
@@ -8524,7 +8618,8 @@ function createWriteTraps(isActive, onDraftWrite) {
       return true;
     }
   };
-  return traps;
+  // Matching-kind dummy so Array.isArray(draft) answers like the store.
+  return new Proxy(Array.isArray(inner) ? [] : {}, traps);
 }
 function createProjectionNextInternal(fn, seed, options) {
   const fam = {
@@ -8578,9 +8673,10 @@ function runProjectionComputedNext(wrappedStore, fn, key, wrapCommit, onDraftWri
   const shadow = owner._loading
     ? JSON.parse(JSON.stringify(wrappedStore[$TARGET][STORE_VALUE]))
     : null;
-  const draft = new Proxy(
+  const draft = wrapDraft(
     wrappedStore,
-    createWriteTraps(() => !settled || owner._x?._inFlight === result, onDraftWrite)
+    () => !settled || owner._x?._inFlight === result,
+    onDraftWrite
   );
   storeSetterNext(
     draft,