Describe the bug

If a derivation that receives prev — createSignal(fn) or createMemo(fn) — reads latest() (or isPending()) of a signal that an in-flight async memo is holding, it can be re-run with an empty object {} as prev instead of its previous value:

prev = []
prev = []
prev = {}
[REACTIVITY_HALTED] An uncaught error halted the reactive system. … TypeError: prev is not iterable

rc.13 passes the previous value every time, so this is a regression in rc.14. It still reproduces on next at 43570f8, in development and production builds.

We hit it in an app where a list's filter rows are a writable derived signal (createSignal((names = []) => [...names, …])) that reads latest() of the list's filters. A second filter click while the list is still loading throws, and the page stops updating; with a slow API that happens on every run. The repro reduces it to one async memo, one derivation and two writes, and fails every time.

Your Example Website or App

Solid 2.0 playground (rc.14, dev build)

Steps to Reproduce the Bug or Issue

1. Open the playground link above (pinned to Solid 2.0.0-rc.14, dev build) and wait for data: 0.
2. Click Write filter twice within a second.
3. The console logs prev = {} and Uncaught TypeError: prev is not iterable, then REACTIVITY_HALTED; data stays at 0, and further clicks change nothing.

The same playground on rc.13 logs prev = [] on every click and moves data on. In the Node version below, each of these makes it pass, so they are all needed:

• the async memo reading filter being observed (dropping its render effect, or making it synchronous, means nothing is held)
• reading filter through latest() (or isPending()) rather than filter()
• the derivation's first pass during the hold being equals to its previous result (returning a new array that equals rejects passes)
• the second write landing while the first fetch is still in flight

// node --conditions=browser --conditions=development repro.mjs
// -> prev = [], prev = [], prev = {}, then TypeError: prev is not iterable
import {createRoot, createSignal, createMemo, createRenderEffect, latest, flush} from "solid-js";

const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

const setFilter = createRoot(() => {
  const [filter, setFilter] = createSignal("a");

  // An async memo observed by an effect: a write to `filter` is held until it lands.
  const data = createMemo(async () => { const f = filter(); await sleep(50); return f; });
  createRenderEffect(data, () => {});

  const [names] = createSignal((prev = []) => {
    latest(filter);
    console.log("prev =", JSON.stringify(prev));
    return [...prev];
  }, {equals: (a, b) => a.length === b.length});
  createRenderEffect(names, () => {});

  return setFilter;
});

await sleep(100);
setFilter("b"); // held: `data` is in flight; `names` re-runs in the verdict lane, equal result
flush();
await sleep(10);
setFilter("c"); // still in flight: `names` re-runs with prev = {}
try { flush(); } catch (e) { console.log("flush threw:", e.message); }
await sleep(100);

Expected behavior

prev is the derivation's previous value (here []) on every run.

Screenshots or Videos

N/A — the console output above is the whole symptom.

Platform

• OS: Linux (Arch, kernel 7.2.2)
• Browser: Chromium 151 (the playground link, and our app under Vite 8 dev); the Node repro on Node 24.21.0
• Version: solid-js / @solidjs/signals 2.0.0-rc.14 and next at 43570f8 (dev and production builds)

Additional context

The cause seems to be this line in recompute (dist/dev-shared.js; the same in prod/core/core.js and observe/core/core.js, and in packages/signals/src/core/core.ts on next):

let value =
  el._pendingValue !== NOT_PENDING
    ? el._pendingValue
    : el._config & CONFIG_OVERRIDE
      ? el._x._lane
      : el._value;

The node enters the verdict lane with _x._lane still NOT_PENDING, and an equal first pass never writes it, so the next pass gets NOT_PENDING as prev. The compareValue a few lines further down already guards this case (el._config & CONFIG_OVERRIDE && el._x._lane !== NOT_PENDING). Adding the same check here makes the repro pass, and it fixes our app.