@solidjs/signals 2.0.0-rc.18 → 2.0.0-rc.19

package/dist/dev-shared.js

@@ -283,10 +283,30 @@ const CONFIG_WIDE = 1 << 26;
  * creation by dev builds only (the observe artifact mangles the option name,
  * as it does `_wide`). */
 const CONFIG_SUPERSEDES = 1 << 27;
+/** Observe tiers only: the memo `merge()` creates for a function source — a
+ * key bag readers consume key by key, built by the framework (a compiled
+ * component spread) with options no user can reach. The attribution engine's
+ * UNSTABLE_MEMO_OUTPUT skips it: a fresh-but-equal bag is the idiom
+ * (`{...(on() ? { a } : {})}`), and the advice (`equals`) cannot be applied
+ * (#4256). Set through `_extraConfig` by observe builds only. */
+const CONFIG_KEY_BAG = 1 << 28;
+/** The frame (rule 3, D-3): a render effect (set at creation, as
+ * `EFFECT_RENDER << 23` — keep the two in step), and a boundary's tree and
+ * output (boundaries.ts) — structure between the content and the render
+ * effect that shows it, not a user derivation of the content. Outside a
+ * hold's own flush it reads that hold's values as committed and is
+ * re-derived at its landing, and a re-pass of it publishes mainline: it
+ * joins nothing, so two mounts under one boundary made in separate flushes
+ * keep their holds apart (D-4, S-5 rows 1′–3′, #4283). */
+const CONFIG_FRAME = 1 << 23;
 const STATUS_NONE = 0;
 const STATUS_PENDING = 1 << 0;
 const STATUS_ERROR = 1 << 1;
 const STATUS_UNINITIALIZED = 1 << 2;
+/** An error that answered a node's first read (no value has ever landed):
+ * the error, not UNINITIALIZED, is its status while shown, but a re-ask
+ * makes it uninitialized-pending again — it still has no value (#4244). */
+const STATUS_NO_VALUE = 1 << 3;
 /** `catchHook`'s answer when the catcher is a boundary re-armed by
  * `on` (truthy, as any catch): what it collects is its own, not the hold's. */
 const CAUGHT_REARMED = 2;
@@ -1214,10 +1234,12 @@ function disposeChildren(node, self = false, zombie) {
     // A death that can unblock the future (L2, `futureBlocked`): a held
     // flight's — a transaction's or a lane's (its `_x._transaction`) — or a
     // stale reader's (REACTIVE_FRAME_READ — a frame that derived from one).
+    // An idle pending queue would also pin it until an unrelated flush.
     // Nothing else re-examines a dead node, so make sure a seam comes.
     if (
       (node._statusFlags & STATUS_PENDING && node._x?._transaction != null) ||
-      flags & REACTIVE_FRAME_READ
+      flags & REACTIVE_FRAME_READ ||
+      pendingNodes.length
     )
       schedule();
   }
@@ -2071,12 +2093,13 @@ function schedule() {
  * hook machinery (pay-for-use).
  */
 const ROOT_ERROR_HOOK = Symbol.for("solid-js/root-error-hook");
+const HALTED = "[REACTIVITY_HALTED]";
 function haltReactivity(cause) {
   if (halted) return;
   halted = true;
   // A cleanup error collected before the halt is dropped (owner.ts).
   rethrowCleanupError(true);
-  let message = "[REACTIVITY_HALTED]";
+  let message = HALTED;
   {
     message +=
       " An uncaught error halted the reactive system. No further updates will be processed. Handle errors with <Errored> or treat this as a crash.";
@@ -2302,11 +2325,12 @@ class GlobalQueue {
     // This flush's own runs, the lanes' reveals, and the landings' held runs
     // are collected apart and ordered below.
     const own = this._queues;
-    const lanes = (this._queues = [[], []]);
+    const lanes = [[], []];
     // The passes that read this frame's stagings as the screen read held
     // writes if it parked: the lane seam re-derives them on the committed
     // world (a lane's runs wait this round).
     if (laneSeamsHook) {
+      this._queues = lanes;
       laneSeamsHook(t !== null ? stagedReaders : null);
       if (stagedReaders.length) stagedReaders.length = 0;
     }
@@ -2462,7 +2486,7 @@ function land(u) {
   // (`_nodes` still lists them).
   if (attrHooks !== null) attrHooks.transitionSettled(u);
   const frame = reruns(u);
-  if (u._marks !== null) releaseMarksHook(u._marks);
+  if (releaseMarksHook && u._marks !== null) releaseMarksHook(u._marks);
   // Old children die in the commits (cleanups first), then the stashed
   // effects run ahead of this flush's own. A node a lane took over since
   // (a guess written over the staged truth) is the lane's to land.
@@ -3515,8 +3539,14 @@ function handleAsync(
         return;
       }
       // A store derive's landing commits through its setter: unheld, the
-      // shown error leaves now; held, at the derive's commit.
-      if (!(el._config & CONFIG_HELD)) el._x._shownError = undefined;
+      // shown error leaves now, and so does a commit-beneath-a-flight's
+      // CONFIG_INPUTS_PUBLISHED (its first flight's, #4269) — left standing,
+      // a verdict reader of the next flight would suspend instead of being
+      // served the screen; held, both at the derive's commit.
+      if (!(el._config & CONFIG_HELD)) {
+        el._x._shownError = undefined;
+        el._config &= ~CONFIG_INPUTS_PUBLISHED;
+      }
       if (wasUninitialized) landStatus(el, true);
       // Attribution hook: this path landed through the setter (derived
       // stores, projections), which does not go through setSignal, so the
@@ -3849,14 +3879,28 @@ function notifyStatus(el, status, error) {
     // D-41: a re-ask of a shown error keeps it the display (`_shownError`).
     if (el._statusFlags & STATUS_ERROR) el._x._shownError = el._x._error;
     addPendingSource(el, pendingSource);
-    el._statusFlags = STATUS_PENDING | (el._statusFlags & STATUS_UNINITIALIZED);
+    // A re-ask of an error that answered the first read: still no value.
+    el._statusFlags =
+      STATUS_PENDING |
+      (el._statusFlags & STATUS_NO_VALUE
+        ? STATUS_UNINITIALIZED
+        : el._statusFlags & STATUS_UNINITIALIZED);
     // Preserve the current source on this propagation so readers park on
     // the distinct pending source.
     setPendingError(el, pendingSource, error);
   } else {
     clearPendingSources(el);
+    // An error answering a node with no value marks it so; a re-ask of it
+    // (pending) is uninitialized again; a write (STATUS_NONE) gives it one.
     el._statusFlags =
-      status | (status !== STATUS_ERROR ? el._statusFlags & STATUS_UNINITIALIZED : 0);
+      status |
+      (status === STATUS_ERROR
+        ? el._statusFlags & (STATUS_UNINITIALIZED | STATUS_NO_VALUE)
+          ? STATUS_NO_VALUE
+          : 0
+        : status === STATUS_PENDING && el._statusFlags & STATUS_NO_VALUE
+          ? STATUS_UNINITIALIZED
+          : el._statusFlags & STATUS_UNINITIALIZED);
     ext(el)._error = error;
   }
   // Lanes: a written guess is an optimistic boundary (A17 — "the optimistic
@@ -3955,6 +3999,9 @@ function propagateStatus(el, status, error) {
           joinFuture(txOf(sub));
       }
       notifyStatus(sub, status, error);
+      // A derived store's derive (store/projection.ts): marked, not re-run —
+      // its leaves' readers are not its dependents, so the family walks them.
+      sub.fam?.st(status);
     }
   });
 }
@@ -4057,8 +4104,23 @@ function setSnapshotCapture(active) {
   snapshotCaptureActive = active;
   if (active && !snapshotSources) snapshotSources = new NewSet();
 }
-function markSnapshotScope(owner) {
-  owner._snapshotScope = true;
+/**
+ * Marks `owner` a snapshot scope: while capture is on, the readers created
+ * under it serve each source's snapshot (the value it had when hydration
+ * began) and replay at `releaseSnapshotScope`.
+ *
+ * With `served` (hydration), `owner` is instead a hydrated computed and
+ * `served` its server answer — what the server rendered every reader of the
+ * node with — landing after the node was created pending (so the creation
+ * arm skipped it). It becomes the node's snapshot when it has none, whether
+ * the node committed the answer or a client write had already taken its
+ * compute over. A claim made later reads the value its markup shows, and
+ * replays the node's own value at its release, as for a written signal.
+ */
+function markSnapshotScope(owner, served) {
+  if (arguments.length < 2) owner._snapshotScope = true;
+  else if (snapshotCaptureActive && owner._x?._snapshotValue === undefined)
+    takeSnapshot(owner, served);
 }
 function releaseSnapshotScope(owner) {
   owner._snapshotScope = false;
@@ -4171,6 +4233,8 @@ function recompute(el, create = false) {
     // A29, or mounted by a pass of it still awaiting its commit, #4010) keeps
     // staging: live writes keep it current, it effects at the swap (ruling
     // A).
+    // A boundary's structure (CONFIG_FRAME) is the frame like a render
+    // effect: it publishes mainline outside its transaction's flush (#4283).
     // A pending flight is the transition's own work (#3884). A probe on an
     // earlier pass left CONFIG_VERDICT, and a frame read here would serve the
     // committed screen, settle the flight and drop the hold — a superseding
@@ -4184,8 +4248,10 @@ function recompute(el, create = false) {
       // world (`read`), and has left it otherwise.
       // An answered deferred node's re-pass is a lagging question (D-40):
       // it joins nothing, so the write that reached it commits mainline.
+      // `EFFECT_RENDER << 23` is CONFIG_FRAME (a render effect, a boundary's
+      // tree and output), spelled from the effect type as at creation.
       if (tx._lane || el._config & CONFIG_LAGS);
-      else if (isEffect !== EFFECT_RENDER && !(el._config & CONFIG_VERDICT))
+      else if (!(el._config & (CONFIG_VERDICT | (EFFECT_RENDER << 23))))
         joinPassTx(tx, freshHook?.(el, el._statusFlags & STATUS_UNINITIALIZED));
       else if (
         tx !== flushTransaction &&
@@ -4197,8 +4263,10 @@ function recompute(el, create = false) {
         // after the new frame's first runs, and the held pass's own
         // children die below (`disposeChildren`). The landing re-derives a
         // fresh held frame for the reveal (`_reruns`).
+        // Not held any more, whichever frame reader it is: its readers read
+        // the value this pass publishes.
         el._pendingValue = NOT_PENDING;
-        if (isEffect === EFFECT_RENDER) el._config &= ~CONFIG_HELD;
+        el._config &= ~CONFIG_HELD;
       }
     }
     // The previous pass's frame. If that pass is still awaiting its commit
@@ -4482,7 +4550,9 @@ function recompute(el, create = false) {
     // confirm is a landing too — the lane's end commits it) and notifies
     // only a correction: an equal truth re-runs nothing (lanes.ts). (As the
     // lane's own work the lane judged it — `laneStage`.)
+    // (The hook first: a build without lanes folds the arm away.)
     if (
+      laneOutcomeHook &&
       !create &&
       lane === null &&
       el._config & CONFIG_GUESS &&
@@ -4853,13 +4923,18 @@ function frameRead(c, el) {
   // read the screen. Lane work with no committed value yet reads a flight
   // as a mount's memo does: it enters, and the boundary it mounts catches
   // the pending (#3540).
+  // A boundary's tree and output (CONFIG_FRAME) read as a render effect
+  // does: structure, not a derivation of what it shows (#4283). A mount
+  // under a hold still enters it: the content memo it reads is born held,
+  // with no committed value to serve.
   // (Verdict readers and lanes exist only with their engines installed.)
   const verdict = observeFlightHook && c._config & CONFIG_VERDICT;
   const lane = laneStageHook && passLane !== null;
   if (
     (!lane || (c._statusFlags & STATUS_UNINITIALIZED && el._statusFlags & STATUS_PENDING)) &&
     !verdict &&
-    (c._type !== EFFECT_RENDER || el._config & CONFIG_INPUTS_PUBLISHED)
+    // CONFIG_FRAME, spelled as at the effect's creation.
+    (!(c._config & (EFFECT_RENDER << 23)) || el._config & CONFIG_INPUTS_PUBLISHED)
   )
     return false;
   const t = txOf(el);
@@ -4916,6 +4991,9 @@ function createEffectNode(fn, effectFn, errorFn, type, options) {
   const self = {
     id: inheritId(options, transparent, context),
     _config:
+      // CONFIG_FRAME for a render effect (EFFECT_RENDER = 1; a user
+      // effect's 1 << 24 is unused).
+      (type << 23) |
       (transparent ? CONFIG_TRANSPARENT : 0) |
       (options?.ownedWrite ? CONFIG_OWNED_WRITE : 0) |
       (options?.sync ? CONFIG_SYNC : 0) |
@@ -5008,11 +5086,8 @@ function setupComputedNode(self, options) {
   wireExternalSourceHook?.(self);
   !options?.lazy && recompute(self, true);
   if (snapshotCaptureActive && !options?.lazy) {
-    if (!(self._statusFlags & STATUS_PENDING) && !(self._config & CONFIG_NO_SNAPSHOT)) {
-      ext(self)._snapshotValue = self._value === undefined ? NO_SNAPSHOT : self._value;
-      self._config |= CONFIG_HAS_SNAPSHOT;
-      snapshotSources.add(self);
-    }
+    if (!(self._statusFlags & STATUS_PENDING) && !(self._config & CONFIG_NO_SNAPSHOT))
+      takeSnapshot(self, self._value);
   }
 }
 function signal(v, options) {
@@ -5038,11 +5113,7 @@ function signal(v, options) {
   };
   s._internal = false;
   if (options?.unobserved) ext(s)._unobserved = options.unobserved;
-  if (snapshotCaptureActive && !(s._config & CONFIG_NO_SNAPSHOT)) {
-    ext(s)._snapshotValue = v === undefined ? NO_SNAPSHOT : v;
-    s._config |= CONFIG_HAS_SNAPSHOT;
-    snapshotSources.add(s);
-  }
+  if (snapshotCaptureActive && !(s._config & CONFIG_NO_SNAPSHOT)) takeSnapshot(s, v);
   return s;
 }
 function isEqual(a, b) {
@@ -5459,6 +5530,28 @@ function read(el) {
     const v = laneReadHook(c, el);
     if (v !== NOT_PENDING) return v;
   }
+  // Ahead of the snapshot serve below: a component body's direct read is
+  // wrong in the same way whether the pass is hydrating or not, and the
+  // hydration pass is the console nobody is watching (#3675).
+  if (strictRead && strictReadActive())
+    warnStrictReadUntracked(strictRead, {
+      ownerId: c?.id,
+      ownerName: c?._name,
+      nodeName: owner?._name
+    });
+  // A reader in a snapshot scope (a hydration claim) is served the value the
+  // server rendered with: a client write's recompute still in flight does
+  // not pull the claim off the markup it adopts — the reader replays at the
+  // scope's release. An errored node throws below as for any reader.
+  if (snapshotCaptureActive && c && c._config & CONFIG_IN_SNAPSHOT_SCOPE) {
+    const sv = el._x?._snapshotValue;
+    if (sv !== undefined && !(owner._statusFlags & STATUS_ERROR)) {
+      const snapshot = sv === NO_SNAPSHOT ? undefined : sv;
+      const current = el._pendingValue !== NOT_PENDING ? el._pendingValue : el._value;
+      if (current !== snapshot) c._flags |= REACTIVE_SNAPSHOT_STALE;
+      return snapshot;
+    }
+  }
   // A stale reader of a held flight (rule 3, A15's reveal corollary) is served
   // the committed value — coherent with the frame, whose inputs are the
   // committed ones too — and does not go pending on it. So is lane work
@@ -5535,24 +5628,6 @@ function read(el) {
       return read(el);
     } else throw owner._x?._error;
   }
-  // Ahead of the snapshot serve below: a component body's direct read is
-  // wrong in the same way whether the pass is hydrating or not, and the
-  // hydration pass is the console nobody is watching (#3675).
-  if (strictRead && strictReadActive())
-    warnStrictReadUntracked(strictRead, {
-      ownerId: c?.id,
-      ownerName: c?._name,
-      nodeName: owner?._name
-    });
-  if (snapshotCaptureActive && c && c._config & CONFIG_IN_SNAPSHOT_SCOPE) {
-    const sv = el._x?._snapshotValue;
-    if (sv !== undefined) {
-      const snapshot = sv === NO_SNAPSHOT ? undefined : sv;
-      const current = el._pendingValue !== NOT_PENDING ? el._pendingValue : el._value;
-      if (current !== snapshot) c._flags |= REACTIVE_SNAPSHOT_STALE;
-      return snapshot;
-    }
-  }
   if (committed) return el._value;
   // D-41: an untracked read reads the screen, and a shown error is on it
   // until the answer that replaces it commits.
@@ -5679,7 +5754,10 @@ function captureWriteSnapshot(el, current) {
     el._x?._snapshotValue !== undefined
   )
     return;
-  ext(el)._snapshotValue = current === undefined ? NO_SNAPSHOT : current;
+  takeSnapshot(el, current);
+}
+function takeSnapshot(el, value) {
+  ext(el)._snapshotValue = value === undefined ? NO_SNAPSHOT : value;
   el._config |= CONFIG_HAS_SNAPSHOT;
   snapshotSources.add(el);
 }
@@ -5936,13 +6014,13 @@ function markRefresh(node) {
 }
 
 export {
-  setPassLane as $,
+  merge as $,
   tracking as A,
   CONFIG_CHILDREN_FORBIDDEN as B,
   CONFIG_GUESS as C,
   passLane as D,
-  STATUS_PENDING as E,
-  EFFECT_RENDER as F,
+  EFFECT_RENDER as E,
+  setPassLane as F,
   GlobalQueue as G,
   sameLane as H,
   flushTransaction as I,
@@ -5956,14 +6034,14 @@ export {
   REACTIVE_CHECK as Q,
   REACTIVE_DISPOSED as R,
   STATUS_UNINITIALIZED as S,
-  CONFIG_INPUTS_PUBLISHED as T,
-  releaseQueues as U,
-  CONFIG_SLOT_NODE as V,
-  holdNode as W,
-  joinFuture as X,
-  reruns as Y,
-  CONFIG_STAGED as Z,
-  merge as _,
+  STATUS_PENDING as T,
+  CONFIG_INPUTS_PUBLISHED as U,
+  releaseQueues as V,
+  CONFIG_SLOT_NODE as W,
+  holdNode as X,
+  joinFuture as Y,
+  reruns as Z,
+  CONFIG_STAGED as _,
   NotReadyError as a,
   resetUnhandledAsync as a$,
   REACTIVE_JOINED as a0,
@@ -6030,7 +6108,7 @@ export {
   effectCallbackEvent as ay,
   setExternalHooks as az,
   CONFIG_AUTHORITATIVE as b,
-  resetErrorHalt as b$,
+  peekNextChildId as b$,
   ROOT_ERROR_HOOK as b0,
   registerGraph as b1,
   runWithOwner as b2,
@@ -6049,25 +6127,25 @@ export {
   joinPassAt as bF,
   notifyEpoch as bG,
   SUPPORTS_PROXY as bH,
-  releaseMarksHook as bI,
-  installMarkHooks as bJ,
-  CONFIG_LAGS as bK,
-  REACTIVE_REASK as bL,
-  onSupersede as bM,
-  haltReactivity as bN,
-  heldUnder as bO,
-  unhold as bP,
-  laneStageHook as bQ,
-  REACTIVE_ZOMBIE as bR,
-  installBoundaryHooks as bS,
-  CAUGHT_REARMED as bT,
-  OBSERVE as bU,
-  clearSnapshots as bV,
-  enforceLoadingBoundary as bW,
-  getNextChildId as bX,
-  markSnapshotScope as bY,
-  peekNextChildId as bZ,
-  releaseSnapshotScope as b_,
+  CONFIG_KEY_BAG as bI,
+  releaseMarksHook as bJ,
+  installMarkHooks as bK,
+  CONFIG_LAGS as bL,
+  REACTIVE_REASK as bM,
+  onSupersede as bN,
+  haltReactivity as bO,
+  CONFIG_FRAME as bP,
+  heldUnder as bQ,
+  unhold as bR,
+  laneStageHook as bS,
+  REACTIVE_ZOMBIE as bT,
+  installBoundaryHooks as bU,
+  CAUGHT_REARMED as bV,
+  OBSERVE as bW,
+  clearSnapshots as bX,
+  enforceLoadingBoundary as bY,
+  getNextChildId as bZ,
+  markSnapshotScope as b_,
   untrack as ba,
   dirtyQueue as bb,
   CONFIG_REDERIVE as bc,
@@ -6095,21 +6173,23 @@ export {
   insertIntoHeap as by,
   isDisposed as bz,
   CONFIG_OVERRIDE as c,
-  setConsoleFooter as c0,
-  setSnapshotCapture as c1,
-  setWriteHook as c2,
-  setAttributionHooks as c3,
-  liveRootOwners as c4,
-  ownerPath as c5,
-  isSuppressed as c6,
-  blockersOf as c7,
-  CONFIG_PLUMBING as c8,
-  anyExcluded as c9,
-  isExcluded as ca,
-  CONFIG_WIDE as cb,
-  GRAPH_SIZE_WARN_AT as cc,
-  noteFanOut as cd,
-  CONFIG_SUPERSEDES as ce,
+  releaseSnapshotScope as c0,
+  resetErrorHalt as c1,
+  setConsoleFooter as c2,
+  setSnapshotCapture as c3,
+  setWriteHook as c4,
+  setAttributionHooks as c5,
+  liveRootOwners as c6,
+  ownerPath as c7,
+  isSuppressed as c8,
+  blockersOf as c9,
+  CONFIG_PLUMBING as ca,
+  anyExcluded as cb,
+  isExcluded as cc,
+  CONFIG_WIDE as cd,
+  GRAPH_SIZE_WARN_AT as ce,
+  noteFanOut as cf,
+  CONFIG_SUPERSEDES as cg,
   newTransaction as d,
   enqueueSub as e,
   CONFIG_VERDICT as f,

package/dist/dev.attribution.js

@@ -1,24 +1,25 @@
 import {
-  bU as OBSERVE,
-  c3 as setAttributionHooks,
-  c4 as liveRootOwners,
+  bW as OBSERVE,
+  c5 as setAttributionHooks,
+  c6 as liveRootOwners,
   N as NOT_PENDING,
   at as emitDiagnostic,
-  c5 as ownerPath,
+  c7 as ownerPath,
   aL as reportDiagnostic,
-  c6 as isSuppressed,
-  c7 as blockersOf,
-  c8 as CONFIG_PLUMBING,
-  c9 as anyExcluded,
-  ca as isExcluded,
-  cb as CONFIG_WIDE,
+  c8 as isSuppressed,
+  c9 as blockersOf,
+  ca as CONFIG_PLUMBING,
+  cb as anyExcluded,
+  cc as isExcluded,
+  bI as CONFIG_KEY_BAG,
+  cd as CONFIG_WIDE,
   c as CONFIG_OVERRIDE,
   C as CONFIG_GUESS,
   G as GlobalQueue,
   f as CONFIG_VERDICT,
-  cc as GRAPH_SIZE_WARN_AT,
-  cd as noteFanOut,
-  ce as CONFIG_SUPERSEDES,
+  ce as GRAPH_SIZE_WARN_AT,
+  cf as noteFanOut,
+  cg as CONFIG_SUPERSEDES,
   b4 as $REFRESH
 } from "./dev-shared.js";
 
@@ -897,6 +898,8 @@ function checkUnstableOutput(el, prevValue, newValue) {
   // typeof guard: an explicit `unstableMemos: undefined` in enable() options
   // clobbers the default through the spread — treat any non-number as off.
   if (typeof limit !== "number") return;
+  // merge()'s function-source memo: a key bag no user configures (#4256).
+  if (el._config & CONFIG_KEY_BAG) return;
   const node = el;
   if (
     prevValue === newValue || // paranoia: changed runs should never hit this