Forward store options to the server projection so ssrSource works on stores

The server createStore dropped its options argument on the floor, making
ssrSource inert for derived stores: "client" sources ran (and streamed) on
the server (#2972) and "server" lost its serialization path (#2971).

Explicit ssrSource:"server" now also serializes SYNCHRONOUS results — for
stores, memos, signals, and effects alike. Without it nothing rode the
payload, so the client re-ran a source that may not be client-safe and the
in-memory value silently diverged from the claimed DOM. The default (no
ssrSource) is unchanged: sync sources recompute on the client as their own
parity mechanism, keeping payloads lean.

Harness scenarios cover all three shapes: client-sourced async store (server
renders seed, no stream hold), server-sourced async store (awaited,
serialized, isServer probe proves no client re-run), and server-sourced sync
store (probe surfaces the in-memory value to catch silent divergence).

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

Author: ryansolid

.changeset/fix-store-ssr-source-server.md

@@ -0,0 +1,5 @@
+---
+"solid-js": patch
+---
+
+Fix `ssrSource` on derived stores during SSR: the server `createStore` dropped the options argument entirely, so `ssrSource: "client"` sources still ran on the server (#2972) and `ssrSource: "server"` lost its serialization hints (#2971). Explicit `ssrSource: "server"` now also serializes synchronous results (stores, memos, signals, effects) so the client adopts the server value instead of silently re-running a source that may not be client-safe.

packages/solid-web/test/harness/__artifacts__/store-ssr-source-client.json

@@ -0,0 +1,5 @@
+{
+  "name": "store-ssr-source-client",
+  "shell": "<div _hk=1>V: <!--$-->seed<!--/--></div>",
+  "rest": ""
+}

packages/solid-web/test/harness/__artifacts__/store-ssr-source-server-sync.json

@@ -0,0 +1,5 @@
+{
+  "name": "store-ssr-source-server-sync",
+  "shell": "<div _hk=1>V: <!--$-->fromServer<!--/--> P: <!--$-->?<!--/--></div><script>(self.$R=self.$R||{})[\"\"]=[];_$HY.r[\"0\"]=($R[0]={v:\"fromServer\"});</script>",
+  "rest": ""
+}

packages/solid-web/test/harness/__artifacts__/store-ssr-source-server.json

@@ -0,0 +1,5 @@
+{
+  "name": "store-ssr-source-server",
+  "shell": "<div _hk=1>V: <!--$-->fromServer<!--/--></div><script>(self.$R=self.$R||{})[\"\"]=[];_$HY.r[\"0\"]=$R[0]=($R[1]=($R[2]=() => {\n  const resolver = {\n    p: 0,\n    s: 0,\n    f: 0\n  };\n  resolver.p = new Promise((resolve, reject) => {\n    resolver.s = resolve;\n    resolver.f = reject;\n  });\n  return resolver;\n})()).p;($R[4]=(resolver, data) => {\n  resolver.s(data);\n  resolver.p.s = 1;\n  resolver.p.v = data;\n})($R[1],$R[3]={v:\"fromServer\"});</script>",
+  "rest": ""
+}

packages/solid-web/test/harness/scenarios.tsx

@@ -22,7 +22,7 @@
  * - Keep async delays short (5-15ms) — the specs own the settle waits.
  */
 import { createSignal, createMemo, createStore, Show, For, Loading, Errored } from "solid-js";
-import { Portal, httpStatus, httpHeader, clientOnly } from "@solidjs/web";
+import { Portal, httpStatus, httpHeader, clientOnly, isServer } from "@solidjs/web";
 
 const sleep = (ms: number) => new Promise(r => setTimeout(r, ms));
 
@@ -707,6 +707,59 @@ function LateBoundaryAfterDone() {
   );
 }
 
+// ---------------------------------------------------------------------------
+// Derived store with ssrSource:"client" (#2972): the server must never run
+// the source — it renders the seed and serializes nothing — and the client
+// re-derives after hydration. The source is async, so a server-side run would
+// also hold the stream; the serverText probe catches both failure modes.
+function StoreSsrSourceClient() {
+  const [store] = createStore<{ v: string }>(
+    async () => {
+      await sleep(10);
+      return { v: "computed" };
+    },
+    { v: "seed" },
+    { ssrSource: "client" }
+  );
+  return <div>V: {store.v}</div>;
+}
+
+// ---------------------------------------------------------------------------
+// Derived async store with ssrSource:"server" (#2971): the server awaits the
+// source and serializes the settled state; the client adopts it and never
+// re-runs the source (the isServer probe would flip the text if it did).
+function StoreSsrSourceServer() {
+  const [store] = createStore<{ v: string }>(
+    async () => {
+      await sleep(10);
+      return { v: isServer ? "fromServer" : "fromClient" };
+    },
+    { v: "seed" },
+    { ssrSource: "server" }
+  );
+  return <div>V: {store.v}</div>;
+}
+
+// ---------------------------------------------------------------------------
+// SYNC source with ssrSource:"server": serialization is async-only, so
+// nothing rides the payload. The probe surfaces the client store's actual
+// in-memory value post-hydration to detect a silent DOM/store divergence.
+let probeSyncStore!: () => void;
+function StoreSsrSourceServerSync() {
+  const [label, setLabel] = createSignal("?");
+  const [store] = createStore<{ v: string }>(
+    () => ({ v: isServer ? "fromServer" : "fromClient" }),
+    { v: "seed" },
+    { ssrSource: "server" }
+  );
+  probeSyncStore = () => setLabel(store.v);
+  return (
+    <div>
+      V: {store.v} P: {label()}
+    </div>
+  );
+}
+
 export const scenarios: Scenario[] = [
   {
     name: "text-hole",
@@ -966,5 +1019,30 @@ export const scenarios: Scenario[] = [
     expectedText: "lead late content tail",
     serverText: "waiting",
     stableSelector: "div, span"
+  },
+  {
+    name: "store-ssr-source-client",
+    App: StoreSsrSourceClient,
+    async: true,
+    expectedText: "V: computed",
+    serverText: "V: seed",
+    stableSelector: "div"
+  },
+  {
+    name: "store-ssr-source-server",
+    App: StoreSsrSourceServer,
+    async: true,
+    expectedText: "V: fromServer",
+    serverText: "V: fromServer",
+    stableSelector: "div"
+  },
+  {
+    name: "store-ssr-source-server-sync",
+    App: StoreSsrSourceServerSync,
+    expectedText: "V: fromServer P: ?",
+    serverText: "V: fromServer P: ?",
+    update: () => probeSyncStore(),
+    expectedTextAfterUpdate: "V: fromServer P: fromServer",
+    stableSelector: "div"
   }
 ];

packages/solid/src/server/signals.ts

@@ -1040,7 +1040,13 @@ function processResult<T>(
     return;
   }
 
-  // Synchronous value
+  // Synchronous value. Explicit "server" serializes it so the client adopts
+  // instead of re-running (async results already do, via the deferred
+  // promise) — without this, a non-client-safe sync compute re-runs during
+  // hydration and silently diverges from the claimed DOM (#2971, memo/signal/
+  // effect parity with the store fix). Absent ssrSource stays lean.
+  if (ssrSource === "server" && ctx?.async && ctx.serialize && id && !noHydrate)
+    ctx.serialize(id, result, deferStream);
   comp.value = result;
 }
 
@@ -1211,14 +1217,19 @@ export function createStore<T extends object>(
 ): [get: Store<T>, set: StoreSetter<T>];
 export function createStore<T extends object>(
   fn: (store: T) => void | T | Promise<void | T>,
-  store: Partial<T> | Store<T>
+  store: Partial<T> | Store<T>,
+  options?: ServerSsrOptions & { name?: string; shallow?: boolean }
 ): [get: Store<T>, set: StoreSetter<T>];
 export function createStore<T extends object>(
   first: T | Store<T> | ((store: T) => void | T | Promise<void | T>),
-  second?: T | Store<T>
+  second?: T | Store<T>,
+  options?: ServerSsrOptions & { name?: string; shallow?: boolean }
 ): [get: Store<T>, set: StoreSetter<T>] {
   if (typeof first === "function") {
-    const store = createProjection(first as any, second as T);
+    // Forward options: dropping them made ssrSource inert for derived stores —
+    // "client" sources ran on the server (#2972) and "server" ones lost their
+    // deferStream/serialization hints (#2971).
+    const store = createProjection(first as any, second as T, options);
     return [store as Store<T>, ((fn: (state: T) => void) => fn(store as T)) as StoreSetter<T>];
   }
   const state = first as T;
@@ -1480,6 +1491,14 @@ export function createProjection<T extends object>(
   if (result !== undefined && result !== state && result !== draft) {
     replaceState(state, result as T);
   }
+  // Explicit "server" promises the client adopts this value without re-running
+  // the source. Async results keep that promise through the deferred-promise
+  // serialization above; sync results must ride the payload too, or the client
+  // re-runs a source that may not be client-safe and silently diverges from
+  // the claimed DOM (#2971). Default (no ssrSource) stays lean: sync sources
+  // recompute on the client as their own parity mechanism.
+  if (ssrSource === "server" && ctx?.async && !getContext(NoHydrateContext) && owner.id)
+    ctx.serialize(owner.id, state, options?.deferStream);
   return state;
 }