@cosmicdrift/kumiko-dev-server 0.306.0 → 0.308.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-dev-server",
-  "version": "0.306.0",
+  "version": "0.308.0",
   "description": "Dev-tooling for Kumiko apps: local dev-server bootstrap (runDevApp), scaffolding, codegen. Its compose-stacks/env-schema subpaths are consumed at prod boot too — see @cosmicdrift/kumiko-server-runtime for the prod runner itself.",
   "license": "BUSL-1.1",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",
@@ -59,10 +59,10 @@
     "kumiko-upgrade": "./bin/kumiko-upgrade.ts"
   },
   "dependencies": {
-    "@cosmicdrift/kumiko-bundled-features": "0.306.0",
-    "@cosmicdrift/kumiko-framework": "0.306.0",
-    "@cosmicdrift/kumiko-headless": "0.306.0",
-    "@cosmicdrift/kumiko-server-runtime": "0.306.0",
+    "@cosmicdrift/kumiko-bundled-features": "0.308.0",
+    "@cosmicdrift/kumiko-framework": "0.308.0",
+    "@cosmicdrift/kumiko-headless": "0.308.0",
+    "@cosmicdrift/kumiko-server-runtime": "0.308.0",
     "ts-morph": "^28.0.0"
   },
   "publishConfig": {

package/src/__tests__/config-resolver-default.integration.test.ts

@@ -17,7 +17,7 @@ import {
   TestUsers,
   unsafePushTables,
 } from "@cosmicdrift/kumiko-framework/stack";
-import { z } from "zod";
+import * as z from "zod";
 import { mergeConfigResolverDefault } from "../run-dev-app";
 
 // Pins runDevApp's ENV→config-app-override wiring: mergeConfigResolverDefault

package/src/__tests__/create-kumiko-server.integration.test.ts

@@ -16,10 +16,11 @@ import {
   type TenantId,
 } from "@cosmicdrift/kumiko-framework/engine";
 import { TestUsers } from "@cosmicdrift/kumiko-framework/stack";
-import { z } from "zod";
+import * as z from "zod";
 import {
   createKumikoServer,
   type KumikoServerHandle,
+  PROD_BUNDLES_ENV,
   STYLESHEET_WATCH_ENV,
 } from "../create-kumiko-server";
 
@@ -540,6 +541,10 @@ describe("createKumikoServer — real Bun.build (buildClient)", () => {
       expect(body.length).toBeGreaterThan(0);
       expect(body).toMatch(/ping/);
 
+      const mapRes = await handle.fetch(new Request("http://localhost/client.js.map"));
+      expect(mapRes.status).toBe(200);
+      expect(await mapRes.text()).toMatch(/"sources"/);
+
       // Stop the watcher before teardown rmSync deletes clientEntry out from
       // under it — a bare "client.tsx" delete event classifies as "restart"
       // (classifyChange only special-cases endsWith("/client.tsx")) and
@@ -550,6 +555,62 @@ describe("createKumikoServer — real Bun.build (buildClient)", () => {
       rmSync(tmpDir, { recursive: true, force: true });
     }
   });
+
+  test("PROD_BUNDLES_ENV builds a prod-shaped bundle: split chunk served, no sourcemap, NODE_ENV replaced", async () => {
+    const tmpDir = mkdtempSync(join(tmpdir(), "kumiko-real-build-prod-"));
+    const entry = join(tmpDir, "client.tsx");
+    writeFileSync(
+      entry,
+      `export async function loadLazy() {
+  const m = await import("./lazy.ts");
+  return m.hello();
+}
+`,
+    );
+    writeFileSync(
+      join(tmpDir, "lazy.ts"),
+      `export function hello() {
+  return "env=" + process.env.NODE_ENV;
+}
+`,
+    );
+    const previousProdBundles = process.env[PROD_BUNDLES_ENV];
+    process.env[PROD_BUNDLES_ENV] = "1";
+    try {
+      handle = await createKumikoServer({
+        features: [probeFeature],
+        port: 0,
+        installSignalHandlers: false,
+        clientEntry: entry,
+        stylesheet: false,
+      });
+      const res = await handle.fetch(new Request("http://localhost/client.js"));
+      expect(res.status).toBe(200);
+      const body = await res.text();
+
+      // Only the dynamic import() call points at the lazy chunk — the
+      // entry also statically imports a shared async-loader chunk.
+      const chunkMatch = body.match(/import\("(?:\.\/)?(chunk-[\w-]+\.js)"\)/);
+      expect(chunkMatch).not.toBeNull();
+      const normalizedChunkPath = `/${chunkMatch ? (chunkMatch[1] ?? "") : ""}`;
+
+      const chunkRes = await handle.fetch(new Request(`http://localhost${normalizedChunkPath}`));
+      expect(chunkRes.status).toBe(200);
+      expect(chunkRes.headers.get("content-type")).toMatch(/application\/javascript/);
+      const chunkBody = await chunkRes.text();
+      expect(chunkBody).toContain("env=production");
+
+      const mapRes = await handle.fetch(new Request("http://localhost/client.js.map"));
+      expect(mapRes.status).toBe(404);
+
+      await handle.stop();
+      handle = undefined;
+    } finally {
+      if (previousProdBundles === undefined) delete process.env[PROD_BUNDLES_ENV];
+      else process.env[PROD_BUNDLES_ENV] = previousProdBundles;
+      rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
 });
 
 describe("createKumikoServer — hot-reload broadcast", () => {

package/src/__tests__/env-schema.integration.test.ts

@@ -8,7 +8,7 @@ import { describe, expect, it } from "bun:test";
 import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
 import { composeEnvSchema, KumikoBootError } from "@cosmicdrift/kumiko-framework/env";
 import { runProdApp } from "@cosmicdrift/kumiko-server-runtime/run-prod-app";
-import { z } from "zod";
+import * as z from "zod";
 import { frameworkCoreEnvSchema } from "../env-schema";
 import * as devServerPublicApi from "../index";
 

package/src/__tests__/env-schema.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "bun:test";
 import { composeEnvSchema, KumikoBootError, parseEnv } from "@cosmicdrift/kumiko-framework/env";
-import { z } from "zod";
+import * as z from "zod";
 import { type FrameworkCoreEnv, frameworkCoreEnvSchema } from "../env-schema";
 
 // Statt Sentinel-throw IM try (ein nicht-werfender parseEnv ließe den

package/src/__tests__/run-dev-app.integration.test.ts

@@ -23,7 +23,7 @@ import {
 } from "@cosmicdrift/kumiko-framework/engine";
 import { TestUsers } from "@cosmicdrift/kumiko-framework/stack";
 import * as jose from "jose";
-import { z } from "zod";
+import * as z from "zod";
 import type { KumikoServerHandle } from "../create-kumiko-server";
 import { runDevApp } from "../run-dev-app";
 

package/src/changes.json

@@ -1,4 +1,14 @@
 [
+  {
+    "version": "0.308.0",
+    "type": "improvement",
+    "title": "Dev server can build prod-shaped client bundles, E2E uses them"
+  },
+  {
+    "version": "0.307.0",
+    "type": "fix",
+    "title": "Dev-server job queues no longer collide across parallel boots"
+  },
   {
     "version": "0.305.0",
     "type": "improvement",

package/src/create-kumiko-server.ts

@@ -269,6 +269,10 @@ const AUTH_COOKIE = "kumiko_auth";
 // runs under Node and cannot import this module.
 export const STYLESHEET_WATCH_ENV = "KUMIKO_DEV_STYLESHEET_WATCH";
 
+// Duplicated in packages/testing/src/e2e/constants.ts: the Playwright config
+// runs under Node and cannot import this module.
+export const PROD_BUNDLES_ENV = "KUMIKO_DEV_PROD_BUNDLES";
+
 // Reload snippet injected into every page-load so the browser
 // subscribes to /_reload without the HTML needing to hard-code it.
 //
@@ -325,7 +329,13 @@ const DEFAULT_HTML = `<!doctype html>
 </html>
 `;
 
-type ClientBundle = { readonly js: string; readonly map: string };
+type ClientBundle = {
+  readonly js: string;
+  readonly map: string;
+  // Only set when PROD_BUNDLES_ENV builds with splitting. Path -> content,
+  // e.g. "/chunk-abc123.js" -> "...".
+  readonly chunks?: ReadonlyMap<string, string>;
+};
 
 async function buildClient(entry: string): Promise<ClientBundle> {
   if (!hasBun) {
@@ -334,23 +344,35 @@ async function buildClient(entry: string): Promise<ClientBundle> {
     );
   }
   const unminified = process.env["KUMIKO_DEV_UNMINIFIED"] === "1";
+  // Same splitting/sourcemap/NODE_ENV as build-prod-bundle.ts, opt-in via
+  // env so `bun dev` stays unchanged.
+  const prodShaped = process.env[PROD_BUNDLES_ENV] === "1";
   const built = await Bun.build({
     entrypoints: [entry],
     target: "browser",
     minify: !unminified,
-    sourcemap: "linked",
+    sourcemap: prodShaped ? "none" : "linked",
+    splitting: prodShaped,
+    ...(prodShaped ? { define: { "process.env.NODE_ENV": JSON.stringify("production") } } : {}),
   });
   if (!built.success) {
     logError("[kumiko-server] client bundle failed:");
     for (const log of built.logs) logError(log);
     throw new Error("client bundle failed");
   }
-  const jsOutput = built.outputs.find((o) => o.path.endsWith(".js"));
+  const jsOutput = built.outputs.find((o) => o.kind === "entry-point");
   const mapOutput = built.outputs.find((o) => o.path.endsWith(".js.map"));
   if (!jsOutput) throw new Error("[kumiko-server] client bundle produced no .js output");
+  const chunks = new Map<string, string>();
+  for (const output of built.outputs) {
+    if (output.kind !== "chunk") continue;
+    const chunkPath = `/${output.path.replace(/^\.\//, "")}`;
+    chunks.set(chunkPath, await output.text());
+  }
   return {
     js: await jsOutput.text(),
     map: mapOutput ? await mapOutput.text() : "",
+    chunks,
   };
 }
 
@@ -849,6 +871,16 @@ export async function createKumikoServer(
   const devDbName = process.env["KUMIKO_DEV_DB_NAME"];
   const persistentDb = devDbName !== undefined && devDbName !== "";
 
+  // Redis is shared across boots AND across apps (unlike the per-boot test
+  // DB, which is ephemeral or persistent per KUMIKO_DEV_DB_NAME), so every
+  // boot needs its own queue-name prefix — otherwise two dev/e2e servers
+  // running in parallel drain each other's queues ("Unknown job: ..."). A
+  // persistent DB implies a stable prefix so jobs survive a restart; an
+  // ephemeral DB gets a fresh prefix per boot, matching the fresh DB.
+  const jobQueueNamePrefix = persistentDb
+    ? `kumiko-dev-${devDbName}`
+    : `kumiko-dev-${crypto.randomUUID()}`;
+
   logInfo(
     `[kumiko-server] booting Kumiko stack${
       persistentDb ? ` — persistent DB "${devDbName}"` : " — ephemeral test DB"
@@ -866,9 +898,11 @@ export async function createKumikoServer(
       effectiveFeatures: options.effectiveFeatures,
     }),
     ...(options.extraRoutes !== undefined && { extraRoutes: options.extraRoutes }),
-    // jobs: {} = enqueuer-only; startDevJobRunners below is the sole
-    // consumer/cron-scheduler per lane, so runOnBoot/cron jobs don't double-fire.
-    jobs: {},
+    // jobs.consumerLane unset = enqueuer-only; startDevJobRunners below is
+    // the sole consumer/cron-scheduler per lane, so runOnBoot/cron jobs
+    // don't double-fire. queueNamePrefix keeps this boot's queues isolated
+    // from every other dev/e2e server sharing the same Redis.
+    jobs: { queueNamePrefix: jobQueueNamePrefix },
   });
   await createEventsTable(stack.db);
   await pushEntityProjectionTables(stack, stack.registry);
@@ -921,6 +955,10 @@ export async function createKumikoServer(
     // ctx.write/ctx.writeAs/ctx.queryAs inside a dev-run job throw on their
     // first call (kumiko-framework#2553).
     dispatcher: stack.dispatcher,
+    // Same isolation reasoning as setupTestStack's jobs.queueNamePrefix
+    // above — both must use the same prefix so enqueuer and consumer agree
+    // on queue names.
+    queueNamePrefix: jobQueueNamePrefix,
   });
 
   // Dev user = TestUsers.admin. Demo features are openToAll but the
@@ -1039,6 +1077,17 @@ export async function createKumikoServer(
           headers: { "Content-Type": "application/javascript; charset=utf-8" },
         });
       }
+      // Looked up in the live bundles instead of a separate index, which a
+      // hot-reload rebuild would leave stale.
+      for (const bundle of clientBundles.values()) {
+        const chunk = bundle.chunks?.get(url.pathname);
+        if (chunk !== undefined) {
+          return new Response(chunk, {
+            headers: { "Content-Type": "application/javascript; charset=utf-8" },
+          });
+        }
+      }
+
       // .js.map-Variante: gleicher Lookup mit /.map abgeschnitten.
       if (url.pathname.endsWith(".js.map")) {
         const jsPath = url.pathname.slice(0, -".map".length);

package/src/env-schema.ts

@@ -15,7 +15,7 @@
 // Feature-specific vars (JWT_SECRET, KUMIKO_SECRETS_MASTER_KEY_*) live
 // in their owning feature's envSchema — Phase 2 (bundled-features).
 
-import { z } from "zod";
+import * as z from "zod";
 
 /** Env-vars read by framework-core (api/server, db/connection,
  *  dev-server/run-prod-app). NOT including feature-specific vars.

package/src/index.ts

@@ -54,6 +54,7 @@ export {
   type CreateKumikoServerOptions,
   createKumikoServer,
   type KumikoServerHandle,
+  PROD_BUNDLES_ENV,
   resolveStylesheet,
   STYLESHEET_WATCH_ENV,
 } from "./create-kumiko-server";