fix: keep scheduler state consistent when an effect throws

Two scheduler-hygiene fixes that stop a thrown effect from corrupting
shared scheduler state (the error still propagates):

- flush(fn) now decrements syncDepth in a finally, so a throwing drain
  can no longer leak the counter and leave schedule() permanently unable
  to queue a microtask.
- adjustHeight routes each height-adjusted subscriber to the queue that
  matches its own zombie flag, mirroring the post-recompute path. This
  avoids parking a zombie in dirtyQueue (or a live node in zombieQueue),
  the same flag/queue invariant violation behind the #2759 livelock.

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

Author: ryansolid

.changeset/fix-adjustheight-zombie-queue-routing.md

@@ -0,0 +1,5 @@
+---
+"@solidjs/signals": patch
+---
+
+Route height-adjusted subscribers to the queue that matches their own zombie flag in `adjustHeight`, mirroring the post-recompute height-adjust path. Inserting into the currently running heap unconditionally could park a zombie node in `dirtyQueue` (or a live node in `zombieQueue`), breaking the flag/queue invariant `deleteFromHeap` relies on — the same corruption class behind the #2759 livelock, reachable through a different trigger.

.changeset/fix-flush-syncdepth-leak-on-throw.md

@@ -0,0 +1,5 @@
+---
+"@solidjs/signals": patch
+---
+
+`flush(fn)` now restores its sync-depth counter when the drain throws. An effect that throws inside a synchronous flush scope previously leaked the counter, which left `schedule()` permanently unable to queue a microtask and silently froze all later reactivity. Balancing it in a `finally` keeps the scheduler usable after the error propagates.

packages/solid-signals/src/core/heap.ts

@@ -4,8 +4,10 @@ import {
   REACTIVE_IN_HEAP,
   REACTIVE_IN_HEAP_HEIGHT,
   REACTIVE_MANUAL_WRITE,
-  REACTIVE_RECOMPUTING_DEPS
+  REACTIVE_RECOMPUTING_DEPS,
+  REACTIVE_ZOMBIE
 } from "./constants.js";
+import { dirtyQueue, zombieQueue } from "./scheduler.js";
 import type { Computed, FirewallSignal, Root } from "./types.js";
 
 export interface Heap {
@@ -130,7 +132,12 @@ function adjustHeight(el: Computed<unknown>, heap: Heap) {
   if (el._height !== newHeight) {
     el._height = newHeight;
     for (let s = el._subs; s !== null; s = s._nextSub) {
-      insertIntoHeapHeight(s._sub, heap);
+      // Route each subscriber by its own zombie flag, mirroring the
+      // post-recompute height-adjust path. Inserting into the running `heap`
+      // unconditionally can park a zombie in `dirtyQueue` (or a live node in
+      // `zombieQueue`), breaking the flag/queue invariant `deleteFromHeap`
+      // relies on — the same corruption class as #2759.
+      insertIntoHeapHeight(s._sub, s._sub._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
     }
   }
 }

packages/solid-signals/src/core/scheduler.ts

@@ -658,8 +658,13 @@ export function flush<T>(fn?: () => T): T | void {
     try {
       return fn();
     } finally {
-      flush();
-      syncDepth--;
+      // Decrement even if the drain throws (a throwing effect): a leaked
+      // syncDepth would stop `schedule()` from ever queuing a microtask again.
+      try {
+        flush();
+      } finally {
+        syncDepth--;
+      }
     }
   }
   if (globalQueue._running) {

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

@@ -2,6 +2,39 @@ import { createEffect, createRoot, createSignal, flush } from "../src/index.js";
 
 afterEach(() => flush());
 
+describe("scheduler hygiene around throwing effects", () => {
+  it("balances syncDepth when an effect throws inside flush(fn)", async () => {
+    const [a, setA] = createSignal(0);
+    const [c, setC] = createSignal(0);
+    const seenC: number[] = [];
+
+    createRoot(() => {
+      // Throws without writing a signal, so the drain leaves no pending work —
+      // this isolates the syncDepth leak from any stuck-`scheduled` symptom.
+      createEffect(a, v => {
+        if (v === 1) throw new Error("boom");
+      });
+      createEffect(c, v => {
+        seenC.push(v);
+      });
+    });
+    flush();
+    // Drain the microtask queued by effect creation; a leftover microtask would
+    // otherwise mask a leaked syncDepth by draining the work for us.
+    await Promise.resolve();
+    seenC.length = 0;
+
+    expect(() => flush(() => setA(1))).toThrow("boom");
+
+    // A clean write must still schedule a microtask. If the throw above leaked
+    // syncDepth, `schedule()` would never queue one again and this would stall.
+    setC(3);
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(seenC).toEqual([3]);
+  });
+});
+
 it("should batch updates", () => {
   const [$x, setX] = createSignal(10);
   const effect = vi.fn();