fix(signals): defer skips a held mount's first effect run (#4543) (#4547)

* fix(signals): defer skips a held mount's first effect run (#4543)

An effect created by a held pass is born held (A29): its first run is
the commit's replay, not its creation's. effect() skipped only the
synchronous first run for defer: true, so the replay called the effect
with its initial value. The replay of a deferred effect born held (or
a lane's node) now applies the value without calling back; later runs
call it as before.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2

* fix(signals): a deferred born-held effect drops its staging instead of stubbing

Rework for size and creation cost: the one-shot callback stub cost +53 B
minified on every core row and touched effect creation. A deferred effect
now drops the staging of a first pass born held, so the commit has nothing
to replay; the plain path keeps its shape (one ternary instead of the
leading !defer). A source change during the hold still runs the effect
once, at the commit; the spec covers it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: ryansolid

.changeset/defer-effect-held-mount.md

@@ -0,0 +1,5 @@
+---
+"@solidjs/signals": patch
+---
+
+fix(signals): `defer: true` skips an effect's first run when a held update mounts it (#4543)

packages/signals/src/core/effect.ts

@@ -79,13 +79,16 @@ export function effect<T>(
   // staged); the flush's commit replays this effect. Its first run is not this
   // creation's (A29). A lane's node likewise: its run is the lane's, queued
   // by the pass and released at the reveal (lanes.ts).
-  !options?.defer &&
-    node._pendingValue === NOT_PENDING &&
-    !node._x?._transaction?._lane &&
-    (node._type === EFFECT_USER || options?.schedule
-      ? globalQueue.enqueue(node._type, runEffect.bind(null, node))
-      : // Type 0: the synchronous first render, not a queued run (D-19).
-        runEffect(node, 0));
+  // `defer` skips the first run, the commit's replay of a node born staged
+  // included (#4543): it drops the staging, so the commit replays nothing.
+  options?.defer
+    ? (node._pendingValue = NOT_PENDING)
+    : node._pendingValue === NOT_PENDING &&
+      !node._x?._transaction?._lane &&
+      (node._type === EFFECT_USER || options?.schedule
+        ? globalQueue.enqueue(node._type, runEffect.bind(null, node))
+        : // Type 0: the synchronous first render, not a queued run (D-19).
+          runEffect(node, 0));
   if (__DEV__ && !node._parent) {
     const message =
       "[NO_OWNER_EFFECT] Effects created outside a reactive context will never be disposed";

packages/web/test/defer-effect-held-mount-4543.spec.tsx

@@ -0,0 +1,133 @@
+/**
+ * @jsxImportSource @solidjs/web
+ * @vitest-environment jsdom
+ */
+import { expect, it } from "vitest";
+import {
+  createEffect,
+  createMemo,
+  createRenderEffect,
+  createSignal,
+  flush,
+  Loading,
+  Show
+} from "solid-js";
+import { render } from "@solidjs/web";
+
+// #4543: `defer: true` skips the effect's first run. An effect created in a
+// subtree that a held update mounts is still in its first run when the hold
+// commits; its source never changed, so the commit must not run it.
+const wait = (ms: number) => new Promise(r => setTimeout(r, ms));
+
+async function mountChild(held: boolean) {
+  const runs: unknown[] = [];
+  const renders: unknown[] = [];
+  const [path, setPath] = createSignal("a");
+  const matched = createMemo(() => {
+    const p = path();
+    return p === "a" || !held ? p : wait(10).then(() => p);
+  });
+  function Child() {
+    const [local, setLocal] = createSignal(1);
+    const keys = createMemo(() => [local()]);
+    createEffect(
+      () => keys(),
+      k => void runs.push(k),
+      { defer: true }
+    );
+    createRenderEffect(
+      () => keys(),
+      k => void renders.push(k),
+      { defer: true }
+    );
+    bump = setLocal;
+    return <p>B</p>;
+  }
+  let bump!: (v: number) => void;
+  const el = document.createElement("div");
+  const dispose = render(
+    () => (
+      <Loading fallback="root">
+        <Show when={matched() === "b"} fallback={<p>A</p>}>
+          <Child />
+        </Show>
+      </Loading>
+    ),
+    el
+  );
+  setPath("b");
+  flush();
+  await wait(80);
+  flush();
+  const text = el.textContent ?? "";
+  const before = [...runs, ...renders];
+  bump(2);
+  flush();
+  dispose();
+  return { text, runs: before, after: [...runs, ...renders] };
+}
+
+it("control: defer skips the first run when the mount is not held", async () => {
+  expect(await mountChild(false)).toEqual({ text: "B", runs: [], after: [[2], [2]] });
+});
+
+it("defer skips the first run when the mount is held by an async memo (#4543)", async () => {
+  expect(await mountChild(true)).toEqual({ text: "B", runs: [], after: [[2], [2]] });
+});
+
+it("a change during the hold runs a deferred effect once, at the commit (#4543)", async () => {
+  const runs: unknown[] = [];
+  const renders: unknown[] = [];
+  let answerPath!: () => void;
+  let answerData!: () => void;
+  const [path, setPath] = createSignal("a");
+  const matched = createMemo(() => {
+    const p = path();
+    return p === "a" ? p : new Promise<string>(r => (answerPath = () => r(p)));
+  });
+  let bump: ((v: number) => void) | undefined;
+  function Child() {
+    const [local, setLocal] = createSignal(1);
+    const keys = createMemo(() => [local()]);
+    createEffect(
+      () => keys(),
+      k => void runs.push(k),
+      { defer: true }
+    );
+    createRenderEffect(
+      () => keys(),
+      k => void renders.push(k),
+      { defer: true }
+    );
+    bump = setLocal;
+    // A second async read keeps the mount held after `matched` answers.
+    const data = createMemo(() => new Promise<string>(r => (answerData = () => r("d"))));
+    return <p>B{data()}</p>;
+  }
+  const el = document.createElement("div");
+  const dispose = render(
+    () => (
+      <Loading fallback="root">
+        <Show when={matched() === "b"} fallback={<p>A</p>}>
+          <Child />
+        </Show>
+      </Loading>
+    ),
+    el
+  );
+  setPath("b");
+  flush();
+  answerPath();
+  await wait(0);
+  flush();
+  expect([el.textContent, !!bump]).toEqual(["A", true]);
+  bump!(3);
+  flush();
+  expect([runs, renders]).toEqual([[], []]);
+  answerData();
+  await wait(0);
+  flush();
+  expect(el.textContent).toBe("Bd");
+  expect([runs, renders]).toEqual([[[3]], [[3]]]);
+  dispose();
+});