@solidjs/signals 2.0.0-rc.10 → 2.0.0-rc.13

package/dist/dev-shared.js

@@ -226,20 +226,29 @@ const CONFIG_OVERRIDE_SUPERSEDED = 1 << 19;
  * transaction. A parked node (status propagation stamps `_transition`
  * without recomputing) recomputed when its source lands otherwise disposed
  * its committed children mid-hold, running their cleanups before the
- * transaction's atomic reveal. Cleared by `commitPendingNode`. */
+ * transaction's atomic reveal. Cleared by `commitPendingNode`. Transaction
+ * work only (A15 lane work and transaction work, #3698): zombies are parked
+ * by a pass under a held transaction; a pass over a lane parks a LANE frame
+ * instead (`CONFIG_LANE_FRAME`), whatever the node's kind. */
 const CONFIG_HELD_CHILDREN = 1 << 20;
 /** The frame parked in `_pendingFirstChild` / `_pendingDisposal` is a LANE
- * frame (#3662, A15 lanes corollary): an effect's lane pass direct-commits,
- * so the frame it replaces leaves the screen when the lane's queue applies
- * the run (A30) — not at the action's commit like #3404's transaction
- * zombies, and not at the pass (a held lane defers the run). Drained by the
- * lane's render entry the parking site pushed ahead of the new frame's
- * effects (cleanups before side effects), by `commitPendingNode` if a hold
- * commits the node first, or with the owner's death. While set the parked
- * frame is not a hold (the node is not queued or stamped for it), a
- * superseding pass disposes the never-shown live children on the spot, and a
- * lane-channel dirty on a member is cancelled (`laneZombie`). Effects only: a
- * memo's lane pass publishes an override (A17, #3479). */
+ * frame (#3662, #3698; A15 lane work and transaction work): a lane pass —
+ * on an effect or a memo alike — publishes into the lane's frame (an
+ * effect's run; a memo's derived override, A17), so the frame it replaces
+ * leaves the screen when the lane applies (A30) — not at the action's
+ * commit like #3404's transaction zombies, and not at the pass (a held lane
+ * defers the apply with the frame still displayed). Drained by the lane's
+ * render entry the parking site pushed ahead of the new frame's effects
+ * (cleanups before side effects), by `commitPendingNode` if a hold commits
+ * the node first, or with the owner's death. While set the parked frame is
+ * not a hold (the node is not queued or stamped for it — lane work never
+ * makes its node transaction work), a superseding pass disposes the
+ * never-shown live children on the spot, and a lane-channel dirty on a
+ * member is cancelled (`laneZombie`). Ruled 2026-09-28 (#3698): a pass is
+ * lane work or transaction work by its owner, never by node kind. #3662
+ * flagged effects only, and a memo's lane pass parked a transaction zombie
+ * that queued and stamped the memo as the action's pending node, so its
+ * next mainline recompute re-entered the hold. */
 const CONFIG_LANE_FRAME = 1 << 26;
 /** In-flight async node whose inputs were PUBLISHED while it was pending: a
  * batch or transaction committed with the node still `STATUS_PENDING` (an
@@ -461,22 +470,33 @@ function recordsChannel() {
   const g = globalThis;
   if (g[RECORDS]) return g[RECORDS];
   const listeners = new Map();
+  const bodyListeners = new Map();
   return (g[RECORDS] = {
-    subscribe(type, listener) {
+    subscribe(type, listener, options) {
       const current = listeners.get(type);
-      // Set semantics: one entry per function, however often it is passed.
-      if (current === undefined) listeners.set(type, [listener]);
-      else if (!current.includes(listener)) listeners.set(type, [...current, listener]);
+      // Set semantics: one entry per function, however often it is passed —
+      // the first subscription's options stand for it.
+      if (current === undefined || !current.includes(listener)) {
+        listeners.set(type, current === undefined ? [listener] : [...current, listener]);
+        if (options !== undefined && options.bodies) {
+          let wanting = bodyListeners.get(type);
+          if (wanting === undefined) bodyListeners.set(type, (wanting = new Set()));
+          wanting.add(listener);
+        }
+      }
       return () => {
         const list = listeners.get(type);
-        if (list === undefined) return;
+        if (list === undefined || !list.includes(listener)) return;
         const next = list.filter(l => l !== listener);
         if (next.length > 0) listeners.set(type, next);
         else listeners.delete(type);
+        const wanting = bodyListeners.get(type);
+        if (wanting !== undefined && wanting.delete(listener) && wanting.size === 0)
+          bodyListeners.delete(type);
       };
     },
-    observed(type) {
-      return listeners.has(type);
+    observed(type, facet) {
+      return facet === "bodies" ? bodyListeners.has(type) : listeners.has(type);
     },
     emit(type, event, live) {
       const list = listeners.get(type);
@@ -502,9 +522,14 @@ const OBSERVE = {
   // empty HERE and gains its members by augmentation downstream.
   server: {},
   exclude(owner) {
-    excludedOwners.add(owner);
+    markedOwners.set(owner, true);
     hasExclusions = true;
   },
+  include(owner) {
+    // No flag flip: with nothing excluded there is nothing to re-admit,
+    // and the walk stays short-circuited.
+    markedOwners.set(owner, false);
+  },
   isExcluded,
   ownerPath
 };
@@ -512,16 +537,23 @@ const OBSERVE = {
 //
 // An observer that lives inside the observed app (an adapter's panel,
 // devtools) marks its root; both channels check the subject's owner chain —
-// the same walk `ownerPath` already makes — and stay silent under it. The
-// flag short-circuits the walk for the common case of no exclusions.
-const excludedOwners = new WeakSet();
+// the same walk `ownerPath` already makes — and stay silent under it. An
+// observer that WRAPS the app (a toolbar around it) excludes its own root
+// and includes the app's back: one map, `true` excluded / `false` included,
+// and the nearest marker up the chain decides. The flag short-circuits the
+// walk for the common case of no exclusions (an include with nothing
+// excluded changes no verdict, so it does not flip it).
+const markedOwners = new WeakMap();
 let hasExclusions = false;
 /** Events built for an excluded subject: never delivered, never reported. */
 const suppressedEvents = new WeakSet();
 function isExcluded(subject) {
   if (!hasExclusions || !subject) return false;
   let owner = "_parent" in subject ? subject : (subject._owner ?? null);
-  for (; owner !== null; owner = owner._parent) if (excludedOwners.has(owner)) return true;
+  for (; owner !== null; owner = owner._parent) {
+    const marked = markedOwners.get(owner);
+    if (marked !== undefined) return marked;
+  }
   return false;
 }
 /** For engines that cache the verdict per node: is anything excluded at all? */
@@ -688,8 +720,14 @@ function throwPendingUntrackedRead(strictReadLabel, fields) {
   throw new Error(message);
 }
 function warnStrictReadUntracked(strictReadLabel, fields) {
+  // Name the value when the name says something — a `name` option or a store
+  // key (#3675). The constructors' defaults ("signal", "computed") would only
+  // restate what "reactive value" already says.
+  const nodeName = fields?.nodeName;
+  const named = nodeName !== undefined && nodeName !== "signal" && nodeName !== "computed";
   const message =
-    `[STRICT_READ_UNTRACKED] Reactive value read directly in ${strictReadLabel} will not update. ` +
+    `[STRICT_READ_UNTRACKED] Reactive value${named ? ` "${nodeName}"` : ""} read directly in ` +
+    `${strictReadLabel} will not update. ` +
     `Move it into a tracking scope (JSX, a memo, or an effect's compute function).`;
   reportDiagnostic(
     emitDiagnostic({
@@ -1696,7 +1734,7 @@ function haltReactivity(cause) {
   let message = "[REACTIVITY_HALTED]";
   {
     message +=
-      " An uncaught error halted the reactive system. No further updates will be processed. Handle errors with createErrorBoundary/<Errored> or treat this as a crash.";
+      " An uncaught error halted the reactive system. No further updates will be processed. Handle errors with <Errored> or treat this as a crash.";
     emitDiagnostic({
       code: "REACTIVITY_HALTED",
       kind: "error",
@@ -1932,7 +1970,11 @@ class GlobalQueue extends Queue {
    * commit whatever its relation to the committed value — a landing equal to
    * committed still differs from the override — then _supersedeOverride
    * decides. Installed with the optimistic engine; only reachable on a node
-   * that has an override. */
+   * that has an override — or, from `mapArray` once a lane pass has run over
+   * the map, on a per-slot signal (never CONFIG_OPTIMISTIC): the slot arm
+   * publishes a lane pass's write as the slot's derived override, lands a
+   * plain pass's write over one, and is the plain `setSignal` otherwise (F1,
+   * see optimistic.ts landOnOverride). */
   static _landOnOverride = null;
   static _trackOptimisticStore = null;
   flush() {
@@ -2073,8 +2115,16 @@ class GlobalQueue extends Queue {
       // sweep or recompute wrote a node it owns): effects computed under it
       // since are its to apply, not this flush's — runEffect leaves them queued
       // and the next pass parks them with it (#3319). Everything computed
-      // mainline applies now.
-      scheduled = dirtyQueue._max >= dirtyQueue._min || activeTransition !== null;
+      // mainline applies now. A write the finalize staged in the ambient
+      // batch with no subscriber to dirty (an optimistic store settle's
+      // keyset bump under a reader that never tracks the key set) is work
+      // too — the fast drain and the park exit already count it — so the
+      // next round commits it and the woken re-entry below does not adopt
+      // it into a parked transaction it never belonged to (matrix F6).
+      scheduled =
+        dirtyQueue._max >= dirtyQueue._min ||
+        activeTransition !== null ||
+        this._batch._pendingNodes.length !== 0;
       // Run lane effects first (for ready lanes), then regular effects
       activeLanes.size && GlobalQueue._runLaneEffects(EFFECT_RENDER);
       this.run(EFFECT_RENDER);
@@ -2105,9 +2155,14 @@ class GlobalQueue extends Queue {
       // idle pass: entering adopts the ambient batch, and staged or dirty
       // ambient work would be held behind flights it never read. `scheduled`
       // is that test here — after the park exit as well as the normal one:
-      // it was recomputed from the heap this pass, every write since re-armed
-      // it, and optimistic ambient nodes reverted with the finalize — so a
-      // wake in a pass with work simply falls to the next. Entering re-arms
+      // it was recomputed from the heap and the ambient batch's staged nodes
+      // this pass, every write since re-armed it, and optimistic ambient
+      // nodes reverted with the finalize — so a wake in a pass with work
+      // simply falls to the next. (A staged node with no subscriber — the
+      // finalize's keyset bump under a length-only reader — used to be
+      // missed here: the wake adopted it, stamped it, and a later ambient
+      // write to the same node joined the parked transaction and never
+      // reverted; matrix F6.) Entering re-arms
       // it itself; a dead (completed) wake is a bare return in
       // initTransition, and the loop moves on to the next.
       while (!scheduled && !activeTransition && wokenTransitions.length)
@@ -4688,8 +4743,8 @@ function recompute(el, create = false) {
   let devChanged = false;
   if (attrHooks !== null) attrHooks.recomputeStart(el, create);
   // Lane posture is resolved BEFORE the previous frame is parked below: a
-  // lane pass on an effect direct-commits (#3662, see the parking site), so
-  // the decision must be known there. `lane` is applied to
+  // lane pass parks a lane frame, not a transaction zombie (#3662, #3698;
+  // see the parking site), so the decision must be known there. `lane` is applied to
   // `currentOptimisticLane` further down, once the previous posture is saved.
   let isOptimisticDirty = !!(el._flags & REACTIVE_OPTIMISTIC_DIRTY);
   let lane = null;
@@ -4738,20 +4793,30 @@ function recompute(el, create = false) {
     // Tracked effects run after finalizePureQueue, so dispose immediately
     // instead of deferring. Children built by an uncommitted recompute
     // (CONFIG_HELD_CHILDREN) die immediately too: no frame ever showed them.
-    // Everything else is the committed frame's and is deferred as zombies
-    // until this node's commit — a transaction-owned node included (#3404):
-    // a parked node's children predate the hold, and tearing them down when
-    // the source lands ran cleanups before the transaction's atomic reveal.
-    // A lane pass on an effect parks a LANE frame instead (CONFIG_LANE_FRAME,
-    // #3662; A15 lanes corollary): the frame it replaces leaves the screen
-    // when the lane's queue applies this run (A30) — not at the action's
-    // commit — and a held lane defers that with the frame still displayed.
-    // The drain is the lane's first render entry for this pass, pushed before
-    // the pass builds the new frame: cleanups before side effects — the
-    // retired frame's `onCleanup`s run ahead of every effect callback of the
-    // new frame. While the frame waits, the live children were never shown:
-    // a superseding pass disposes them here like held children, and the
-    // parked frame stays.
+    // Everything else is the committed frame's. Which frame retires it is
+    // decided by who owns the pass, never by the node's kind (A15 lane work
+    // and transaction work, ruled 2026-09-28, #3698). Transaction work — a
+    // pass under a held transaction — defers them as zombies until this
+    // node's commit, a transaction-owned node included (#3404): a parked
+    // node's children predate the hold, and tearing them down when the
+    // source lands ran cleanups before the transaction's atomic reveal.
+    // Lane work — a pass over a lane, effect or memo alike — parks a LANE
+    // frame instead (CONFIG_LANE_FRAME, #3662, #3698): the frame it replaces
+    // leaves the screen when the lane's queue applies this pass (A30) — not
+    // at the action's commit — and a held lane defers that with the frame
+    // still displayed. The drain is the lane's first render entry for this
+    // pass, pushed before the pass builds the new frame: cleanups before
+    // side effects — the retired frame's `onCleanup`s run ahead of every
+    // effect callback of the new frame. While the frame waits, the live
+    // children were never shown: a superseding pass disposes them here like
+    // held children, and the parked frame stays. Zombies exist for
+    // transaction work only: #3662 gated the lane frame on `isEffect`, and a
+    // memo's lane pass (its value a derived override, A17) parked a
+    // transaction zombie that made the memo a pending node of the action,
+    // stamped it, and sent its next mainline recompute through the
+    // stamped-memo arm above — a `Show` whose `when` getter owns a
+    // compiler-emitted memo held an unrelated sync write for the action's
+    // lifetime, against the #3460 ruling that a lane never holds a sync write.
     if (isEffect === EFFECT_TRACKED || el._config & (CONFIG_HELD_CHILDREN | CONFIG_LANE_FRAME))
       disposeChildren(el);
     else if (el._firstChild !== null || el._disposal !== null) {
@@ -4762,7 +4827,7 @@ function recompute(el, create = false) {
       el._disposal = null;
       el._firstChild = null;
       el._childCount = 0;
-      if (isEffect && lane) {
+      if (lane) {
         el._config |= CONFIG_LANE_FRAME;
         findLane(lane)._effectQueues[0].push(() => {
           el._config &= ~CONFIG_LANE_FRAME;
@@ -6441,6 +6506,15 @@ 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)
+    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) {
@@ -6450,12 +6524,6 @@ function read(el) {
       return snapshot;
     }
   }
-  if (strictRead)
-    warnStrictReadUntracked(strictRead, {
-      ownerId: c?.id,
-      ownerName: c?._name,
-      nodeName: owner?._name
-    });
   const value = serve(el, c, owner, el._value);
   if (
     !c &&
@@ -6967,13 +7035,13 @@ export {
   currentTransition as M,
   NoOwnerError as N,
   OVERRIDE_UNDEFINED as O,
-  queuePendingNode as P,
-  latestReadActive as Q,
+  assignOrMergeLane as P,
+  queuePendingNode as Q,
   REACTIVE_DIRTY as R,
   STATUS_UNINITIALIZED as S,
-  REACTIVE_MANUAL_WRITE as T,
-  REACTIVE_OPTIMISTIC_DIRTY as U,
-  assignOrMergeLane as V,
+  latestReadActive as T,
+  REACTIVE_MANUAL_WRITE as U,
+  REACTIVE_OPTIMISTIC_DIRTY as V,
   LANE_RUN as W,
   attrHooks as X,
   EFFECT_USER as Y,

package/dist/dev.attribution.js

@@ -19,12 +19,13 @@ import {
 /** A fallback shown for less than this is a flash: feedback for a wait too short to need it. */
 const FALLBACK_FLASH_MS = 150;
 /**
- * Under an owner the observer marked as its own (`OBSERVE.exclude`), or
- * framework plumbing itself (`CONFIG_PLUMBING` — the HMR memo between a
- * component's root and its body, which is nobody's node): the engine records
- * nothing about the node. Plumbing is a bit read and excludes the node alone,
- * not what it owns; the observer exclusion is cached per node once any
- * exists, before that a flag read.
+ * Under an owner the observer marked as its own (`OBSERVE.exclude`, and not
+ * re-admitted by a nearer `OBSERVE.include`), or framework plumbing itself
+ * (`CONFIG_PLUMBING` — the HMR memo between a component's root and its
+ * body, which is nobody's node): the engine records nothing about the node.
+ * Plumbing is a bit read and excludes the node alone, not what it owns; the
+ * observer exclusion is cached per node once any exists, before that a flag
+ * read.
  */
 function excludedNode(el) {
   if ((el._config & CONFIG_PLUMBING) !== 0) return true;
@@ -333,9 +334,16 @@ function originStart(ref) {
       return;
     }
   }
-  const frame = { kind: ref.kind, at: ref.at ?? now() };
-  if (ref.from !== undefined) frame.from = ref.from;
-  const under = enclosingInteraction();
+  // The initial navigation is the document's: its request is the time origin
+  // unless the router says otherwise, and it left nowhere.
+  const initial = ref.initial === true;
+  const frame = { kind: ref.kind, at: ref.at ?? (initial ? 0 : now()) };
+  if (!initial && ref.from !== undefined) frame.from = ref.from;
+  // Declared beats ambient: a router that awaited before writing hands back
+  // the origin it captured in the request (`undefined` when the request ran
+  // under none — still a declaration); what is on the stack now is whatever
+  // happened to be running.
+  const under = "interaction" in ref ? interactionOf(ref.interaction) : enclosingInteraction();
   if (under !== undefined) frame.interaction = under;
   originFrames.push(frame);
   openNavigation(frame, ref);
@@ -369,7 +377,8 @@ function formatOrigin(origin) {
         notes.push(
           `redirected from ${redirects.map(hop => hop.to ?? hop.name ?? "?").join(" → ")}`
         );
-      return `navigation to ${name}${notes.length > 0 ? ` (${notes.join(", ")})` : ""}`;
+      const initial = navStates.get(origin)?.event.initial === true;
+      return `${initial ? "initial " : ""}navigation to ${name}${notes.length > 0 ? ` (${notes.join(", ")})` : ""}`;
     }
     default:
       return "outside the reactive system";
@@ -1844,8 +1853,10 @@ function checkOptimisticRevert(el, shown, truth, how) {
   // derived override promotes rather than reverts. Same predicate the hold
   // census uses to skip them.
   if (!options.optimisticReverts || isCompanion(el)) return;
+  // Method call, as every commit path does: store slot nodes share one
+  // comparator that reads `this._host` (#3687).
   const equals = el._equals;
-  if (equals && equals(shown, truth)) return;
+  if (equals && equals.call(el, shown, truth)) return;
   const source = nodeName(el);
   // The two values are user data: quoted only under `values: "full"`; the
   // other levels say what happened without saying what was shown.
@@ -2142,6 +2153,7 @@ function syncNavigation(state) {
 }
 function openNavigation(frame, ref) {
   const event = { at: frame.at, writes: 0, origin: frame };
+  if (ref.initial === true) event.initial = true;
   if (frame.from !== undefined) event.from = frame.from;
   if (frame.interaction !== undefined) event.interaction = frame.interaction;
   const state = {
@@ -2354,7 +2366,10 @@ function settleNavigation(state, outcome, hold) {
   event.settledMs = now() - event.at;
   event.outcome = outcome;
   if (hold !== undefined) event.hold = hold;
-  for (const f of folds) f.navigation?.(event);
+  // The initial declaration is not a navigation the person waited on: its
+  // `settledMs` is document start → router built, which would read as the
+  // route's responsiveness in the feedback tables. Consumers get the record.
+  if (event.initial !== true) for (const f of folds) f.navigation?.(event);
   records.emit("navigation", event, undefined);
   trackGraph(event);
   // The interaction that performed it may have been waiting only on this.