@solidjs/signals 2.0.0-beta.32 → 2.0.0-beta.34

package/dist/dev.js

@@ -980,6 +980,10 @@ function commitPendingNode(n) {
     // Set _modified for effects, but not for tracked effects (they handle their own scheduling)
     if (n._type && n._type !== EFFECT_TRACKED) n._modified = true;
   }
+  // The committed hold is the first observable answer for a loading-window
+  // node — the window closes here, not at compute time (#2990). Unconditional
+  // store to an always-present computed slot.
+  c._loading = false;
   c._flags &= ~REACTIVE_MANUAL_WRITE;
   if (!(c._statusFlags & STATUS_PENDING)) c._statusFlags &= ~STATUS_UNINITIALIZED;
   if (c._pendingFirstChild !== null || c._pendingDisposal !== null)
@@ -1327,6 +1331,10 @@ function markDisposal(el) {
   }
 }
 function dispose(node) {
+  // Leave every scheduler heap on disposal (mirrors `unobserved`): a node
+  // still queued here would be recomputed by the next flush, and recompute()
+  // rewriting `_flags` would clear REACTIVE_DISPOSED — resurrecting it (#2983).
+  deleteFromHeap(node, queueFor(node));
   let toRemove = node._deps;
   while (toRemove !== null) {
     toRemove = unlinkSubs(toRemove);
@@ -1353,9 +1361,14 @@ function disposeChildren(node, self = false, zombie) {
   let child = zombie ? node._pendingFirstChild : node._firstChild;
   while (child) {
     const nextChild = child._nextSibling;
-    if (child._deps) {
-      const n = child;
-      deleteFromHeap(n, queueFor(n));
+    const n = child;
+    // Heap removal must not be gated on `_deps`: a dependency-free
+    // computation queued by refresh() has a null dep list but still sits in
+    // the dirty heap, and left there the post-disposal flush recomputes it —
+    // recompute() rewriting `_flags` clears REACTIVE_DISPOSED and the node
+    // comes back to life (post-unmount runs, leaked cleanups, #2983).
+    if (n._flags & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT)) deleteFromHeap(n, queueFor(n));
+    if (n._deps) {
       let toRemove = n._deps;
       do {
         toRemove = unlinkSubs(toRemove);
@@ -1736,6 +1749,34 @@ function clearPendingSources(el) {
   el._pendingSources?.clear();
   el._pendingSources = undefined;
 }
+// A rejection-pending only resolves through the settle sweep over the
+// SOURCE's subscribers, so it is retryable iff a tracked read created that
+// edge: a dep that IS the source, or one whose own pending chain carries it
+// (pending sources propagate the origin node, so this covers any depth).
+// Dev-only caller — tree-shaken from prod builds.
+function retryReaches(el, source) {
+  for (let d = el._deps; d; d = d._nextDep) {
+    const dep = d._dep._firewall || d._dep;
+    if (dep === source || dep._pendingSources?.has(source)) return true;
+  }
+  return false;
+}
+/**
+ * A loading-window node hit an unready source (sync throw in recompute, or a
+ * NotReadyError-rejected flight): register for the source's settle — the
+ * settlePendingSource walk runs off `_pendingSources` + `_blocked` alone —
+ * with NO read-visible pending status, no downstream propagation, no
+ * transition, no lane registration. Commit #0 keeps serving.
+ */
+function parkLoadingWindow(el, e) {
+  el._blocked = true;
+  if (e.source) addPendingSource(el, e.source);
+  // A settled error is the node's answer ("the error stays the answer until
+  // this retry can actually run") — the park must not replace it: reads
+  // throw `_error` while STATUS_ERROR is set, and overwriting it here leaks
+  // a pending-class NotReadyError from a read-invisible park (#2989).
+  if (!(el._statusFlags & STATUS_ERROR)) setPendingError(el, e.source, e);
+}
 function setPendingError(el, source, error) {
   if (!source) {
     el._error = null;
@@ -1832,12 +1873,18 @@ function settlePendingSource(el) {
     visited.add(node);
     node._time = clock;
     const remaining = node._pendingSources?.values().next().value;
+    // STATUS_ERROR + pending sources only coexist via an errored loading
+    // window's park (notifyStatus(STATUS_ERROR) clears pending sources
+    // otherwise): the settled error stays the answer through the settle —
+    // nulling it here would have reads throw `null` until the re-enqueued
+    // retry lands, or lose it entirely if that retry parks again (#2989).
+    const errored = node._statusFlags & STATUS_ERROR;
     if (remaining) {
-      setPendingError(node, remaining);
+      if (!errored) setPendingError(node, remaining);
       updateCompanions !== null && updateCompanions(node);
     } else {
       node._statusFlags &= ~STATUS_PENDING;
-      setPendingError(node);
+      if (!errored) setPendingError(node);
       updateCompanions !== null && updateCompanions(node);
       if (node._blocked) {
         enqueueSub(node);
@@ -1872,6 +1919,8 @@ function handleAsync(el, result, setter) {
   }
   if (!thenable && !iterator) {
     el._inFlight = null;
+    // A sync landing is the first real answer for a loadingValue node.
+    el._loading = false;
     return result;
   }
   // Dev-only contract enforcement for `sync: true` nodes. In production these
@@ -1924,9 +1973,36 @@ function handleAsync(el, result, setter) {
   };
   const handleError = error => {
     if (el._inFlight !== result) return;
-    settleTransition();
     // NotReadyError from rejected promises should be treated as pending, not error
-    const stillPending = error instanceof NotReadyError;
+    let stillPending = error instanceof NotReadyError;
+    // Dev-only authorship diagnostic (#2987): no edge means a post-`await`
+    // FIRST read — untracked, so the source's settle sweep can never find
+    // this node and "pending" wedges it (and its boundary) forever while
+    // isPending reads false. Fail loud in dev; prod pays no bytes for the
+    // forbidden pattern (the wedge stands there, caught during development).
+    // Runs BEFORE the loading-window parking below: a non-retryable read is
+    // a real error, and the window must not silently park a wedge that can
+    // never settle.
+    if (stillPending && !retryReaches(el, error.source)) {
+      stillPending = false;
+      error = new Error(
+        "Read of an unresolved async source after an `await`. Reads inside async " +
+          "computations only register as dependencies before the first `await`; a source " +
+          "first read after it cannot retry when it settles. Read it before the first " +
+          "`await` (or restructure so the value is an input)."
+      );
+    }
+    if (stillPending && el._loading) {
+      // Loading window: the flight died waiting on an unready source. Keep
+      // serving commit #0 — same parking as recompute's catch for sync
+      // dependency throws. The dead flight is released so the clock-gated
+      // error-retry pull (updateIfNecessary) can also re-ask.
+      el._inFlight = null;
+      parkLoadingWindow(el, error);
+      el._time = clock;
+      return;
+    }
+    settleTransition();
     notifyStatus(el, stillPending ? STATUS_PENDING : STATUS_ERROR, error);
     el._time = clock;
     // A real error settles derivatively-pending dependents (notifyStatus
@@ -2002,6 +2078,13 @@ function handleAsync(el, result, setter) {
         notifyStatus(el, STATUS_ERROR, e);
       }
     }
+    // First real answer landing: the window closes when the answer becomes
+    // OBSERVABLE. A direct commit is observable now; a transition-held write
+    // (`_pendingValue` set above or inside setSignal) is not — the verdict's
+    // held-value branch is window-gated, and commitPendingNode closes the
+    // window when the hold commits, so no one-frame isPending pulse can leak
+    // to live observers between the landing and its commit (#2990).
+    if (el._pendingValue === NOT_PENDING) el._loading = false;
     settlePendingSource(el);
     schedule();
     flush();
@@ -2054,8 +2137,16 @@ function handleAsync(el, result, setter) {
       handleError(syncError);
       throw syncError;
     } else if (!resolved) {
+      // Loading window: serve commit #0 instead of suspending. No transition
+      // is opened — first-flight work on a loadingValue node is loading-class
+      // (invisible to boundaries and transitions); the flight itself is
+      // already registered in _inFlight and lands through asyncWrite.
+      if (el._loading) return el._value;
       globalQueue.initTransition(resolveTransition(el));
       throw new NotReadyError(context);
+    } else {
+      // Synchronously-resolved promise: the first real answer landed.
+      el._loading = false;
     }
   }
   if (iterator) {
@@ -2149,9 +2240,14 @@ function handleAsync(el, result, setter) {
     // Later iterate() calls run from asyncWrite, where rethrowing would be unhandled.
     initialRead = false;
     if (!hadValue && !immediatelyDone) {
+      // Loading window: serve commit #0 (see the promise branch above).
+      if (el._loading) return el._value;
       globalQueue.initTransition(resolveTransition(el));
       throw new NotReadyError(context);
     }
+    // A sync first yield (or immediate empty completion) is the first real
+    // answer; async yields clear inside asyncWrite.
+    el._loading = false;
   }
   return syncValue;
 }
@@ -2352,6 +2448,11 @@ function recompute(el, create = false) {
   // Re-ask classification lives in the verdict module; capture the flag before
   // the recompute wipes _flags below.
   const hadReask = (el._flags & REACTIVE_REASK) !== 0;
+  // Captured before the compute clears it on a sync landing: if that landing
+  // is transition-held below, the window must stay open until the hold
+  // commits (commitPendingNode) — a closed window plus a held value reads as
+  // a pending frame to live observers of the verdict (#2990).
+  const wasLoading = el._loading;
   const oldcontext = context;
   context = el;
   el._depsTail = null;
@@ -2408,7 +2509,14 @@ function recompute(el, create = false) {
       const isAsyncResult = typeof fnResult === "object" && fnResult !== null;
       const inFlightChanged = el._inFlight !== prevInFlight;
       value = inFlightChanged || !isAsyncResult ? fnResult : handleAsync(el, fnResult);
-      if (!inFlightChanged && !isAsyncResult) el._inFlight = null;
+      if (!inFlightChanged && !isAsyncResult) {
+        el._inFlight = null;
+        // A sync (non-object) return is the first real answer; async-shaped
+        // results clear inside handleAsync at their own landing points, and a
+        // self-registered flight (inFlightChanged — projections) clears when
+        // its internal handleAsync lands.
+        el._loading = false;
+      }
     }
     // On a status-free node clearStatus is a guaranteed no-op: every branch
     // in its body is gated on one of these fields, and with _statusFlags === 0
@@ -2428,22 +2536,34 @@ function recompute(el, create = false) {
     // _optimisticLane is only ever assigned by engine paths.
     if (el._optimisticLane) GlobalQueue._laneAsyncSettled(el);
   } catch (e) {
-    // Track pending async in the lane (not the lane's source — it creates the lane
-    // but doesn't belong to it). Set lane BEFORE notifyStatus for downstream propagation.
-    if (e instanceof NotReadyError && currentOptimisticLane) GlobalQueue._laneAsyncPending(el);
-    let reaskChanged = false;
-    if (e instanceof NotReadyError) {
-      el._blocked = true;
-      if (GlobalQueue._applyReask !== null) reaskChanged = GlobalQueue._applyReask(el, hadReask);
-    }
-    notifyStatus(
-      el,
-      e instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR,
-      e,
-      undefined,
-      e instanceof NotReadyError ? el._optimisticLane : undefined
-    );
-    if (reaskChanged) GlobalQueue._repollVerdicts(el);
+    const notReady = e instanceof NotReadyError;
+    if (notReady && el._loading) {
+      // Loading window with an unready sync dependency: register for the
+      // source's settle (the settlePendingSource walk runs off
+      // _pendingSources + _blocked alone) but take NO read-visible pending
+      // status, no downstream propagation, no transition, no lane
+      // registration — the committed loading value keeps serving. If the
+      // node is currently errored the error stays the answer until this
+      // retry can actually run.
+      parkLoadingWindow(el, e);
+    } else {
+      // Track pending async in the lane (not the lane's source — it creates the lane
+      // but doesn't belong to it). Set lane BEFORE notifyStatus for downstream propagation.
+      if (notReady && currentOptimisticLane) GlobalQueue._laneAsyncPending(el);
+      let reaskChanged = false;
+      if (notReady) {
+        el._blocked = true;
+        if (GlobalQueue._applyReask !== null) reaskChanged = GlobalQueue._applyReask(el, hadReask);
+      }
+      notifyStatus(
+        el,
+        notReady ? STATUS_PENDING : STATUS_ERROR,
+        e,
+        undefined,
+        notReady ? el._optimisticLane : undefined
+      );
+      if (reaskChanged) GlobalQueue._repollVerdicts(el);
+    }
   } finally {
     tracking = prevTracking;
     latestReadActive = prevLatestRead;
@@ -2505,6 +2625,9 @@ function recompute(el, create = false) {
         }
       } else {
         el._pendingValue = value;
+        // A window landing that gets held re-opens the window until the hold
+        // commits — the verdict's held-value branch is window-gated (#2990).
+        if (wasLoading) el._loading = true;
         // Transition-held sync recompute is a write path like setSignal/asyncWrite,
         // so sync derivations of held sources stay visible to isPending()/latest()
         // (#2831). Both companion writes are transition-scoped (optimistic) and
@@ -2526,6 +2649,7 @@ function recompute(el, create = false) {
       // for commit on its own transition's schedule — invisibly (A17/A18).
       if (el._pendingValue === NOT_PENDING) queuePendingNode(el);
       el._pendingValue = value;
+      if (wasLoading) el._loading = true; // see the held branch above (#2990)
     } else if (el._height != oldHeight) {
       for (let s = el._subs; s !== null; s = s._nextSub) {
         insertIntoHeapHeight(s._sub, queueFor(s._sub));
@@ -2582,6 +2706,10 @@ function updateIfNecessary(el) {
 }
 function computed(fn, options) {
   const transparent = options?.transparent ?? false;
+  // `in` (not `!== undefined`): an explicit `loadingValue: undefined` on a
+  // `T | undefined` node is a real commit #0. The typeof guard tolerates
+  // non-object option values that older call shapes force through `as any`.
+  const loading = options !== null && typeof options === "object" && "loadingValue" in options;
   const self = {
     id: inheritId(options, transparent, context),
     _config:
@@ -2598,7 +2726,7 @@ function computed(fn, options) {
     _context: context?._context ?? defaultContext,
     _childCount: 0,
     _fn: fn,
-    _value: undefined,
+    _value: loading ? options.loadingValue : undefined,
     _height: 0,
     _child: null,
     _nextHeap: undefined,
@@ -2613,14 +2741,16 @@ function computed(fn, options) {
     _prevSibling: null,
     _firstChild: null,
     _flags: options?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
-    _statusFlags: STATUS_UNINITIALIZED,
+    // A loadingValue node is born committed: commit #0 is already in _value.
+    _statusFlags: loading ? 0 : STATUS_UNINITIALIZED,
     _time: clock,
     _pendingValue: NOT_PENDING,
     _pendingDisposal: null,
     _pendingFirstChild: null,
     _inFlight: null,
     _transition: null,
-    _reask: false
+    _reask: false,
+    _loading: loading
   };
   self._name = options?.name ?? "computed";
   setupComputedNode(self, options);
@@ -2671,6 +2801,7 @@ function createEffectNode(fn, effectFn, errorFn, type, notifyStatus, options) {
     _inFlight: null,
     _transition: null,
     _reask: false,
+    _loading: false,
     _modified: false,
     _prevValue: undefined,
     _effectFn: effectFn,
@@ -3698,6 +3829,13 @@ function quietPending(el) {
   }
   return el._reask;
 }
+// NOTE: a loadingValue node's open loading window (_loading) is verdict-quiet
+// on purpose: commit #0 answers the question by declaration, so the window
+// reads NOT pending — first-load affordances live in the value channel
+// (null / skeleton provenance the author encoded), and isPending stays what
+// it always was: refetch truth for an answered question. This keeps the
+// verdict fully correlated with transition-class machinery and keeps server
+// (always false) and client hydration trivially consistent.
 function newQuestionInFlight(comp) {
   return (
     !!(comp._statusFlags & STATUS_PENDING) &&
@@ -3725,7 +3863,15 @@ function computePendingState(el) {
       (!!(firewall._statusFlags & STATUS_PENDING) && quietPending(firewall))
     );
   }
-  if (el._pendingValue !== NOT_PENDING && !(comp._statusFlags & STATUS_UNINITIALIZED)) {
+  // `!comp._loading`: a hold created while the loading window is still open is
+  // the window's own landing in flight to its commit — verdict-quiet like the
+  // rest of the window (the UNINITIALIZED check suppresses exactly this frame
+  // for windowless first loads; born-committed nodes need their own gate, #2990).
+  if (
+    el._pendingValue !== NOT_PENDING &&
+    !(comp._statusFlags & STATUS_UNINITIALIZED) &&
+    !comp._loading
+  ) {
     if (hasActiveOverride(el))
       return !el._equals || !el._equals(el._pendingValue, unwrapOverride(el._overrideValue));
     return true;
@@ -4409,38 +4555,6 @@ function createSignal(first, second) {
   registerGraph(node, getOwner());
   return [accessor(node), setSignal.bind(null, node)];
 }
-/**
- * Creates a readonly derived reactive memoized signal.
- *
- * ```typescript
- * const value = createMemo<T>(compute, options?: MemoOptions<T>);
- * ```
- * @param compute a function that receives its previous value and returns a new value used to react on a computation
- * @param options `MemoOptions` -- id, name, equals, unobserved, lazy
- *
- * @example
- * ```ts
- * const [first, setFirst] = createSignal("Ada");
- * const [last, setLast] = createSignal("Lovelace");
- *
- * const fullName = createMemo(() => `${first()} ${last()}`);
- *
- * fullName(); // "Ada Lovelace"
- * ```
- *
- * @example
- * ```ts
- * // Async memo — reads surface as pending inside <Loading>
- * const user = createMemo(async () => {
- *   const res = await fetch(`/users/${id()}`);
- *   return res.json();
- * });
- * ```
- *
- * @description https://docs.solidjs.com/reference/basic-reactivity/create-memo
- */
-// NoInfer keeps the previous-value parameter from influencing T inference, so
-// the memo/effect result type is still driven by the compute return type.
 function createMemo(compute, options) {
   return accessor(computed(compute, options));
 }
@@ -4478,7 +4592,7 @@ function createEffect(compute, effectFn, options) {
  * ```
  * @param compute a function that receives its previous value and returns a new value used to react on a computation
  * @param effectFn a function that receives the new value and is used to perform side effects
- * @param options `EffectOptions` -- name, defer, schedule
+ * @param options `EffectOptions` -- name, defer, schedule, transparent
  *
  * @example
  * ```ts
@@ -5545,13 +5659,17 @@ function createProjectionInternal(fn, seed, options) {
     return wrapped;
   };
   const wrappedStore = wrapProjection(seed);
-  node = computed(
-    () => {
-      if (!node) node = getOwner();
-      runProjectionComputed(wrappedStore, fn, options?.key === undefined ? "id" : options.key);
-    },
-    options?.name ? { name: options.name } : undefined
-  );
+  // seedLoadingValue: the firewall is born committed (the seed is commit #0);
+  // the internal handleAsync serves it during the derive's first flight. The
+  // node's own value channel is void, so the loading value itself is
+  // `undefined` — presence of the key is what flips the mode.
+  let nodeOptions;
+  if (options?.seedLoadingValue) nodeOptions = { loadingValue: undefined };
+  if (options?.name) nodeOptions = { ...nodeOptions, name: options.name };
+  node = computed(() => {
+    if (!node) node = getOwner();
+    runProjectionComputed(wrappedStore, fn, options?.key === undefined ? "id" : options.key);
+  }, nodeOptions);
   node._config &= ~CONFIG_AUTO_DISPOSE;
   return { store: wrappedStore, node };
 }
@@ -5623,19 +5741,48 @@ function runProjectionComputed(wrappedStore, fn, key, wrapCommit, onDraftWrite)
   const owner = getOwner();
   let settled = false;
   let result;
+  // Open loading window (seedLoadingValue): the observable store IS commit #0
+  // for the whole first flight, so the derive works a detached shadow of the
+  // seed — draft writes (pre-await, or between yields) land on the shadow and
+  // cannot tear through to readers (#2988; store reads resolve from the live
+  // backing, and the born-committed firewall removed the status gate that hid
+  // windowless drafts). Every commit point — sync return, each yield, the
+  // async landing — reconciles the shadow through the normal commit path, so
+  // a fully-sync derive still lands immediately (commit #0 superseded before
+  // any observer runs, same as a sync answer superseding loadingValue). The
+  // JSON round-trip matches the server's frozen-seed copy (seedLock): a
+  // loading-window seed is renderable data by contract. Optimistic note:
+  // onDraftWrite (override clearing) shifts from write-time to commit-time
+  // for the shadow run — an invisible draft write must not clobber a visible
+  // optimistic override mid-window.
+  const shadow = owner._loading
+    ? JSON.parse(JSON.stringify(wrappedStore[$TARGET][STORE_VALUE]))
+    : null;
   const draft = new Proxy(
     wrappedStore,
     createWriteTraps(() => !settled || owner._inFlight === result, onDraftWrite)
   );
   storeSetter(draft, s => {
-    result = fn(s);
+    result = fn(shadow ?? s);
     settled = true;
     const commit = v => {
+      // Shadow run: a void/self return is the mutation form — the shadow
+      // carries the writes and is what commits. Commit a detached snapshot,
+      // never the shadow itself: reconcile adopts a new root value by
+      // identity, and handing it the live shadow would fuse the draft to the
+      // observable store — later shadow writes would mutate the backing
+      // silently and the next yield would diff the shadow against itself.
+      if (shadow && (v === undefined || v === shadow)) v = JSON.parse(JSON.stringify(shadow));
       if (v === s || v === undefined) return;
       const write = () => storeSetter(wrappedStore, s => reconcileState(v, s, key, true));
       wrapCommit ? wrapCommit(write) : write();
     };
-    commit(handleAsync(owner, result, commit));
+    const sync = handleAsync(owner, result, commit);
+    // A still-open window after handleAsync means the return was the
+    // commit-#0 fall-through, not a landing — real landings arrive through
+    // the setter. A closed one is a genuine sync landing (windowless nodes
+    // were never open); commit it.
+    if (!owner._loading) commit(sync);
   });
   return owner;
 }
@@ -7205,23 +7352,24 @@ function createOptimisticProjectionInternal(fn, initialValue, options) {
         setProjectionWriteActive(wasProjectionWriteActive);
       }
     };
-    node = computed(
-      () => {
-        setProjectionWriteActive(true);
-        try {
-          runProjectionComputed(
-            wrappedStore,
-            fn,
-            options?.key === undefined ? "id" : options.key,
-            wrapCommit,
-            clearProjectionOverride
-          );
-        } finally {
-          setProjectionWriteActive(false);
-        }
-      },
-      options?.name ? { name: options.name } : undefined
-    );
+    // seedLoadingValue: born-committed firewall, same as createProjection.
+    let nodeOptions;
+    if (options?.seedLoadingValue) nodeOptions = { loadingValue: undefined };
+    if (options?.name) nodeOptions = { ...nodeOptions, name: options.name };
+    node = computed(() => {
+      setProjectionWriteActive(true);
+      try {
+        runProjectionComputed(
+          wrappedStore,
+          fn,
+          options?.key === undefined ? "id" : options.key,
+          wrapCommit,
+          clearProjectionOverride
+        );
+      } finally {
+        setProjectionWriteActive(false);
+      }
+    }, nodeOptions);
     node._config &= ~CONFIG_AUTO_DISPOSE;
   }
   return { store: wrappedStore, node };