refactor(signals): remove the Loading notify-through remap

After #2856 narrowed the remap to fire only while the ERROR dimension
was still live in the notification mask, the rule collapsed into the
generic consume-and-forward path: each boundary consumes only its own
status dimension from the mask and forwards the remainder, so an error
inside a Loading reaches its Errored natively. The only residual
behavior — suppressing pending collection on a node that is
simultaneously pending and errored — is unreachable: status propagation
(notifyStatus) assigns a single dimension per node, and the effect-phase
error path notifies with literal ERROR-only flags.

Pins the two paths the remap used to intercept (sync error in the
mounting flush and reactive error after a healthy commit, both
Errored > Loading > content). Full signals, solid, and solid-web
(client/SSR/hydration) suites pass.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: ryansolid

.changeset/remove-loading-notify-through-remap.md

@@ -0,0 +1,5 @@
+---
+"@solidjs/signals": patch
+---
+
+Removed the `Loading` queue's notify-through remap. After #2856 narrowed it to fire only while the ERROR dimension was still live in the notification mask, the rule collapsed into the generic consume-and-forward path: each boundary consumes only its own status dimension and forwards the remainder, so an error inside a `Loading` reaches its `Errored` natively. The only residual behavior — suppressing pending collection on a node that is simultaneously pending and errored — is unreachable, as status propagation never sets both dimensions on one node. Added pins for the two paths the remap used to intercept (sync error in the mounting flush and reactive error after commit, both `Errored > Loading > content`).

packages/solid-signals/src/boundaries.ts

@@ -301,24 +301,16 @@ export class CollectionQueue extends Queue {
       }
     }
 
-    // Notify-through: a real error inside a `Loading` is not this boundary's to
-    // handle — remap it to ERROR and forward toward the `Errored` that catches it.
-    // This must run before the initialized passthrough below so the error still
-    // reaches its catcher after this boundary has committed. Guarded on the ERROR
-    // dimension still being live in `type`: an `Errored` nested below this
-    // `Loading` consumes ERROR from the mask when it catches, and remapping off
-    // the node's raw `flags` alone would resurrect that consumed error and route
-    // it past the boundary that already handled it (the Loading > Errored >
-    // content composition escape).
-    // The mirror case (pending inside an `Errored`) needs no explicit rule: the
-    // PENDING dimension survives `type &= ~collectionType` below and reaches the
-    // outer `Loading` natively, while a pending already caught by an inner
-    // `Loading` arrives here as a bare ERROR-dimension remainder and is correctly
-    // swallowed.
-    if (this._collectionType & STATUS_PENDING && type & STATUS_ERROR && flags & STATUS_ERROR) {
-      return super.notify(node, STATUS_ERROR, flags, error);
-    }
-
+    // Routing is dimension-independent: each boundary consumes only its own
+    // status dimension from the mask (`type &= ~collectionType` below) and
+    // forwards the remainder up the queue chain. An error inside a `Loading`
+    // needs no special rule — the ERROR dimension survives consumption here and
+    // reaches the `Errored` that catches it natively, and `flags & collectionType`
+    // keeps this boundary from collecting a node that isn't actually pending.
+    // Symmetrically, a pending inside an `Errored` forwards on the PENDING
+    // dimension, while a status already caught by an inner boundary arrives with
+    // its dimension consumed from the mask and is correctly not re-routed
+    // (the Loading > Errored > content composition escape, #2856).
     if (this._collectionType & STATUS_PENDING && this._initialized)
       return super.notify(node, type, flags, error);
 

packages/solid-signals/tests/createErrorBoundary.test.ts

@@ -923,6 +923,69 @@ it("catches an async rejection at the inner Errored (Errored > Loading > Errored
   dispose();
 });
 
+/**
+ * Dimension-independent routing pins (remap removal follow-up to #2856): a sync
+ * error inside a `Loading` with NO inner `Errored` must forward on the ERROR
+ * dimension past the `Loading` to the outer `Errored` natively — the queue
+ * chain consumes only each boundary's own dimension, so no explicit
+ * notify-through rule is needed. Pinned for both the uninitialized boundary
+ * (throw in the mounting flush) and the committed one (reactive throw), the two
+ * paths the old remap intercepted.
+ */
+it("routes a sync mount error past a Loading to the outer Errored (Errored > Loading > content)", () => {
+  let rendered: unknown;
+  const dispose = createRoot(dispose => {
+    const outer = createErrorBoundary(
+      () =>
+        createLoadingBoundary(
+          () => {
+            throw new Error("boom on mount");
+          },
+          () => "loading"
+        )(),
+      () => "outer caught"
+    );
+    createRenderEffect(
+      () => (rendered = outer()),
+      () => {}
+    );
+    return dispose;
+  });
+  flush();
+  expect(rendered).toBe("outer caught");
+  dispose();
+});
+
+it("routes a reactive sync error past a committed Loading to the outer Errored (Errored > Loading > content)", () => {
+  const [$boom, setBoom] = createSignal(false);
+  let rendered: unknown;
+  const dispose = createRoot(dispose => {
+    const outer = createErrorBoundary(
+      () =>
+        createLoadingBoundary(
+          () => {
+            if ($boom()) throw new Error("boom");
+            return "ok";
+          },
+          () => "loading"
+        )(),
+      () => "outer caught"
+    );
+    createRenderEffect(
+      () => (rendered = outer()),
+      () => {}
+    );
+    return dispose;
+  });
+  flush();
+  expect(rendered).toBe("ok");
+
+  setBoom(true);
+  flush();
+  expect(rendered).toBe("outer caught");
+  dispose();
+});
+
 /**
  * #2809 hydration interaction: with snapshot capture active (as during
  * `hydrate()`), boundary computeds must not become snapshot sources. The tree no