@@ -0,0 +1,5 @@
+---
+"@solidjs/signals": patch
+---
+
+Add a development CJS build, `dist/node.dev.cjs`, selected by the `development` condition on the `require` branch of `exports`. Previously `require` always resolved to the production `dist/node.cjs` (`__DEV__` false), so a CJS host that resolved `solid-js`'s dev server artifact would get `DEV === undefined` from its `@solidjs/signals` dependency — a dev server runtime whose diagnostics channel was silently absent. Dev CJS is the unmangled twin of `dist/dev.js`; the production CJS is unchanged.
@@ -141,10 +141,17 @@ false`), `exports-server-conditions.spec.tsx`; solid
   `solid.dev.*`, `web.dev.*`, `universal.dev.*`. Signals keeps `dev.js` vs
   `prod/` (chunked dir for the mangle pass; a restructure, not a rename).
   The resolution test now pins the client pairing under `browser` too.
-- Known gap, not P0: `@solidjs/signals`' `require` branch has no
-  `development` condition (`dist/node.cjs` is `__DEV__: false` only), so CJS
-  hosts loading `server.dev.cjs` still get signals' prod object and `DEV`
-  comes back `undefined`. Needs a dev CJS build of signals; file separately.
+- `@solidjs/signals`' `require` branch had no `development` condition
+  (`dist/node.cjs` is `__DEV__: false` only), so CJS hosts loading
+  `server.dev.cjs` got signals' prod object and `DEV` came back `undefined` —
+  a dev artifact lying about the one export P1 will emit through. Fixed in
+  the same PR: `dist/node.dev.cjs` (unmangled twin of `dev.js`), selected by
+  `require.development`. The resolution test walks the CJS hops
+  (`@solidjs/web` → `solid-js` → `@solidjs/signals`) and pins all three
+  flipping together; a signals dist test pins `DEV` per CJS artifact.
+- `solid-js#test` now depends on `solid-js#build` in `turbo.json` — it had
+  no dist-based tests until this work, so it was the one package whose test
+  task didn't wait for its own build.
 
 ### P1 — A server diagnostics channel
 
 
@@ -34,14 +34,15 @@
       },
       "require": {
         "types": "./dist/types-cjs/index.d.cts",
+        "development": "./dist/node.dev.cjs",
         "default": "./dist/node.cjs"
       }
     },
     "./package.json": "./package.json"
   },
   "scripts": {
     "build": "npm-run-all -nl build:* && pnpm types",
-    "build:clean": "rimraf dist/dev dist/prod dist/node dist/dev.js dist/prod.js dist/node.cjs",
+    "build:clean": "rimraf dist/dev dist/prod dist/node dist/dev.js dist/prod.js dist/node.cjs dist/node.dev.cjs",
     "build:js": "rollup -c && node ./scripts/mangle-props.mjs dist/prod dist/node.cjs && node ./scripts/check-pure.mjs dist/prod",
     "types": "tsc -p tsconfig.build.json && node ../../scripts/sync-dual-types.mjs ./dist/types ./dist/types-cjs",
     "test": "vitest run",
 
@@ -6,7 +6,7 @@ import prettier from "rollup-plugin-prettier";
 // consumed exclusively by bundlers, which can drop whole feature modules —
 // including their top-level GlobalQueue hook installs, which statement-level
 // shaking of a flat file can never remove (#2883) — and scope-hoist the rest
-// back into one module. Dev and node stay flat single files: dev bundle size
+// back into one module. Dev and node (prod + dev CJS) stay flat single files: dev bundle size
 // doesn't matter (and vitest's per-module SSR transform makes a chunked tree
 // ~2x slower in the flush hot path, poisoning CI benches), and CJS `require`
 // can't tree-shake, so a tree would charge unbundled SSR the per-module-
@@ -95,5 +95,38 @@ export default [
         parser: "typescript"
       })
     ]
+  },
+  {
+    // Dev CJS — the `require` twin of dist/dev.js, selected by the
+    // `development` condition on the `require` branch. Without it a CJS host
+    // that resolved solid-js's `dist/server.dev.cjs` would `require` the prod
+    // `dist/node.cjs` (`__DEV__` false) and get `DEV === undefined` from a dev
+    // artifact — a lie that goes unnoticed until something emits into
+    // `DEV.diagnostics`. Flat single file like node.cjs; not mangled (dev
+    // outputs never are — see build:js).
+    input: "src/index.ts",
+    output: {
+      file: "dist/node.dev.cjs",
+      format: "cjs",
+      exports: "named"
+    },
+    plugins: [
+      replace({
+        __DEV__: "true",
+        __TEST__: "false",
+        preventAssignment: true
+      }),
+      typescript({
+        declaration: false,
+        outDir: "dist",
+        module: "esnext",
+        target: "esnext",
+        moduleResolution: "bundler",
+        verbatimModuleSyntax: true
+      }),
+      prettier({
+        parser: "typescript"
+      })
+    ]
   }
 ];
@@ -0,0 +1,35 @@
+/**
+ * Direct coverage of the built CJS artifacts — dist/node.cjs (prod, the
+ * `require` default) and dist/node.dev.cjs (the `development` condition on
+ * the `require` branch). The suite otherwise imports source under vitest's
+ * `__DEV__: true` define, so it cannot see whether each artifact's replace
+ * ran. `DEV` is the observable: defined in dev, `undefined` in prod. The dev
+ * CJS exists so a CJS host that resolves solid-js's `dist/server.dev.cjs`
+ * also gets a signals with a live `DEV.diagnostics` — one dev flag per
+ * process, not one per module format. Requires a prior build (the turbo
+ * `test` task depends on `build`).
+ */
+import { createRequire } from "node:module";
+import { describe, expect, test } from "vitest";
+
+const require = createRequire(import.meta.url);
+
+describe("@solidjs/signals CJS artifacts", () => {
+  test("dist/node.cjs (prod) exports DEV as undefined", () => {
+    const prod = require("../dist/node.cjs");
+    expect(prod.DEV).toBeUndefined();
+  });
+
+  test("dist/node.dev.cjs exports a live DEV with the diagnostics channel", () => {
+    const dev = require("../dist/node.dev.cjs");
+    expect(dev.DEV).toBeDefined();
+    expect(typeof dev.DEV.diagnostics.subscribe).toBe("function");
+    expect(typeof dev.DEV.diagnostics.capture).toBe("function");
+  });
+
+  test("the two artifacts export the same surface", () => {
+    const prod = require("../dist/node.cjs");
+    const dev = require("../dist/node.dev.cjs");
+    expect(Object.keys(dev).sort()).toEqual(Object.keys(prod).sort());
+  });
+});
@@ -89,6 +89,40 @@ describe("export conditions: dev/prod artifact pairing", () => {
     });
   });
 
+  test("CJS `require` pairs solid-js's server.dev.cjs with signals' node.dev.cjs", () => {
+    // The web server bundle externalizes solid-js, and solid-js's server
+    // bundle externalizes @solidjs/signals, so a CJS host resolves each in
+    // turn. The dev server artifact is only honest if the signals it requires
+    // is dev too — its `DEV` export is signals' object — so the `require`
+    // branch of signals needs its own `development` entry, and this pins
+    // both hops flipping together.
+    const script =
+      `const { createRequire } = require("node:module"); ` +
+      `const r = createRequire(process.cwd() + "/"); ` +
+      `const solid = r.resolve("solid-js"); ` +
+      `const signals = createRequire(solid).resolve("@solidjs/signals"); ` +
+      `const web = r.resolve("@solidjs/web"); ` +
+      `process.stdout.write(JSON.stringify([web, solid, signals].map(p => p.replace(/^.*\\/packages\\//, ""))));`;
+    const run = (conditions: string[]) =>
+      JSON.parse(
+        execFileSync(
+          process.execPath,
+          [...conditions.map(c => `--conditions=${c}`), "-e", script],
+          { cwd: process.cwd(), encoding: "utf8" }
+        )
+      );
+    expect(run([])).toEqual([
+      "web/dist/server.cjs",
+      "solid/dist/server.cjs",
+      "signals/dist/node.cjs"
+    ]);
+    expect(run(["development"])).toEqual([
+      "web/dist/server.dev.cjs",
+      "solid/dist/server.dev.cjs",
+      "signals/dist/node.dev.cjs"
+    ]);
+  });
+
   test("worker and deno conditions carry the same dev/prod pairing as node", () => {
     // Node always adds its own `node` condition; passing `worker`/`deno` on top
     // exercises those keys' nesting (they precede `node` in every exports map
 
@@ -80,7 +80,7 @@
       "outputs": []
     },
     "solid-js#test": {
-      "dependsOn": ["@solidjs/signals#build"],
+      "dependsOn": ["@solidjs/signals#build", "solid-js#build"],
       "outputs": []
     },
     "@solidjs/web#test": {
-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +---
 +"@solidjs/signals": patch
 +---
++
 +Add a development CJS build, `dist/node.dev.cjs`, selected by the `development` condition on the `require` branch of `exports`. Previously `require` always resolved to the production `dist/node.cjs` (`__DEV__` false), so a CJS host that resolved `solid-js`'s dev server artifact would get `DEV === undefined` from its `@solidjs/signals` dependency — a dev server runtime whose diagnostics channel was silently absent. Dev CJS is the unmangled twin of `dist/dev.js`; the production CJS is unchanged.