@cosmicdrift/kumiko-dev-server 0.159.1 → 0.160.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-dev-server",
-  "version": "0.159.1",
+  "version": "0.160.0",
   "description": "Dev-tooling for Kumiko apps: local dev-server bootstrap (runDevApp), scaffolding, codegen. Not shipped into production node_modules — see @cosmicdrift/kumiko-server-runtime for the prod boot path.",
   "license": "BUSL-1.1",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",
@@ -54,9 +54,9 @@
     "kumiko-schema-check": "./bin/kumiko-schema-check.ts"
   },
   "dependencies": {
-    "@cosmicdrift/kumiko-bundled-features": "0.159.1",
-    "@cosmicdrift/kumiko-framework": "0.159.1",
-    "@cosmicdrift/kumiko-server-runtime": "0.159.1",
+    "@cosmicdrift/kumiko-bundled-features": "0.160.0",
+    "@cosmicdrift/kumiko-framework": "0.160.0",
+    "@cosmicdrift/kumiko-server-runtime": "0.160.0",
     "ts-morph": "^28.0.0"
   },
   "publishConfig": {

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

@@ -0,0 +1,63 @@
+// createKumikoServer error / graceful-degradation paths — boot rejects,
+// stylesheet pipeline failures, missing CSS route.
+
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
+import { createKumikoServer, type KumikoServerHandle } from "../create-kumiko-server";
+
+const emptyFeature = defineFeature("dev-server-errors-probe", () => {});
+
+let handle: KumikoServerHandle | undefined;
+
+afterEach(async () => {
+  if (handle) {
+    await handle.stop();
+    handle = undefined;
+  }
+});
+
+describe("createKumikoServer — client bundle failure", () => {
+  test("broken clientEntry rejects at boot with client bundle failed", async () => {
+    const tmpDir = mkdtempSync(join(tmpdir(), "kumiko-bundle-fail-"));
+    const entry = join(tmpDir, "client.tsx");
+    writeFileSync(entry, "const x = {{{\n");
+    try {
+      await expect(
+        createKumikoServer({
+          features: [emptyFeature],
+          port: 0,
+          installSignalHandlers: false,
+          clientEntry: entry,
+          stylesheet: false,
+        }),
+      ).rejects.toThrow(/client bundle failed|Bundle failed/);
+    } finally {
+      rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  test("_buildBundle throw propagates at boot", async () => {
+    const tmpDir = mkdtempSync(join(tmpdir(), "kumiko-stub-fail-"));
+    const entry = join(tmpDir, "client.tsx");
+    writeFileSync(entry, "// noop\n");
+    try {
+      await expect(
+        createKumikoServer({
+          features: [emptyFeature],
+          port: 0,
+          installSignalHandlers: false,
+          clientEntry: entry,
+          stylesheet: false,
+          _buildBundle: async () => {
+            throw new Error("stub build blew up");
+          },
+        }),
+      ).rejects.toThrow(/stub build blew up/);
+    } finally {
+      rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+});

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

@@ -1,5 +1,5 @@
 import { afterEach, describe, expect, test } from "bun:test";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { asRawClient } from "@cosmicdrift/kumiko-framework/bun-db";
@@ -336,3 +336,123 @@ describe("createKumikoServer extraRoutes-deps", () => {
     expect(body.data?.roles).toContain("SystemAdmin");
   });
 });
+
+describe("createKumikoServer — stylesheet tailwind failure (graceful)", () => {
+  test("missing stylesheet entry boots without CSS — GET /styles.css → 404", async () => {
+    const tmpDir = mkdtempSync(join(tmpdir(), "kumiko-css-fail-"));
+    const entry = join(tmpDir, "client.tsx");
+    writeFileSync(entry, "export const x = 1;\n");
+    try {
+      handle = await createKumikoServer({
+        features: [probeFeature],
+        port: 0,
+        installSignalHandlers: false,
+        clientEntry: entry,
+        stylesheet: join(tmpDir, "does-not-exist.css"),
+        _buildBundle: async () => ({ js: "// stub", map: "" }),
+      });
+      const cssRes = await handle.fetch(new Request("http://localhost/styles.css"));
+      expect(cssRes.status).toBe(404);
+      expect(await cssRes.text()).toBe("no stylesheet");
+    } finally {
+      rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("createKumikoServer — real Bun.build (buildClient)", () => {
+  test("clientEntry without _buildBundle produces a JS bundle via Bun.build", async () => {
+    const tmpDir = mkdtempSync(join(tmpdir(), "kumiko-real-build-"));
+    const entry = join(tmpDir, "client.tsx");
+    // Minimal entry Bun.build can emit — no JSX, no imports.
+    writeFileSync(entry, "export const ping = 1;\n");
+    // Empty dirs matching a glob — exercises expandWatchPatterns without
+    // writing files (avoids process.exit(75) from bare .tsx events).
+    mkdirSync(join(tmpDir, "pkg-a"));
+    mkdirSync(join(tmpDir, "pkg-b"));
+    try {
+      handle = await createKumikoServer({
+        features: [probeFeature],
+        port: 0,
+        installSignalHandlers: false,
+        clientEntry: entry,
+        stylesheet: false,
+        watchDirs: [join(tmpDir, "pkg-*")],
+      });
+      const res = await handle.fetch(new Request("http://localhost/client.js"));
+      expect(res.status).toBe(200);
+      expect(res.headers.get("content-type")).toMatch(/application\/javascript/);
+      const body = await res.text();
+      expect(body.length).toBeGreaterThan(0);
+      expect(body).toMatch(/ping/);
+    } finally {
+      rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("createKumikoServer — hot-reload broadcast", () => {
+  test("file change under web/ rebuilds and broadcasts SSE reload", async () => {
+    const tmpDir = mkdtempSync(join(tmpdir(), "kumiko-watch-"));
+    const entry = join(tmpDir, "client.tsx");
+    const webDir = join(tmpDir, "web");
+    mkdirSync(webDir);
+    writeFileSync(entry, "export const ping = 1;\n");
+
+    let builds = 0;
+    try {
+      handle = await createKumikoServer({
+        features: [probeFeature],
+        port: 0,
+        installSignalHandlers: false,
+        clientEntry: entry,
+        stylesheet: false,
+        // Only the entry dir is watched (no extra watchDirs) — a nested
+        // web/page.tsx event arrives as "web/page.tsx" → hot-reload.
+        // Watching web/ separately would fire bare "page.tsx" → restart
+        // → process.exit(75) and kill the test runner.
+        _buildBundle: async () => {
+          builds += 1;
+          return { js: `// build-${builds}`, map: "" };
+        },
+      });
+
+      const sseRes = await handle.fetch(new Request("http://localhost/_reload"));
+      expect(sseRes.status).toBe(200);
+      const reader = sseRes.body?.getReader();
+      expect(reader).toBeDefined();
+      if (!reader) return;
+
+      await reader.read(); // drain connected comment
+
+      const initialBuilds = builds;
+      writeFileSync(join(webDir, "page.tsx"), "export const x = 1;\n");
+
+      const deadline = Date.now() + 3000;
+      let sawReload = false;
+      while (Date.now() < deadline && !sawReload) {
+        const readPromise = reader.read();
+        const timeout = new Promise<{ done: true; value: undefined }>((resolve) =>
+          setTimeout(() => resolve({ done: true, value: undefined }), 200),
+        );
+        const { value, done } = await Promise.race([readPromise, timeout]);
+        if (done || value === undefined) continue;
+        const chunk = new TextDecoder().decode(value);
+        if (chunk.includes("event: reload")) sawReload = true;
+      }
+      await reader.cancel();
+
+      expect(builds).toBeGreaterThan(initialBuilds);
+      expect(sawReload).toBe(true);
+
+      const js = await handle.fetch(new Request("http://localhost/client.js"));
+      expect(await js.text()).toMatch(/build-/);
+
+      // Abort watchers before teardown rmSync can fire a restart event.
+      await handle.stop();
+      handle = undefined;
+    } finally {
+      rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+});

package/src/__tests__/resolve-stylesheet.test.ts

@@ -64,6 +64,22 @@ describe("resolveStylesheet", () => {
     }
   });
 
+  test("Bun.resolveSync failure → undefined (catch path, no throw)", () => {
+    const tmpDir = realpathSync(mkdtempSync(join(tmpdir(), "kumiko-resolve-catch-")));
+    const cwdBefore = process.cwd();
+    process.chdir(tmpDir);
+    try {
+      const out = resolveStylesheet({
+        features: [],
+        clientEntry: "./entry.tsx",
+      });
+      expect(out).toBeUndefined();
+    } finally {
+      process.chdir(cwdBefore);
+      rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
   test("undefined + clientEntry + src/styles.css existiert → returns App-Theme-Override", () => {
     // Auto-Detection greift VOR dem renderer-web-Fallback: Wenn die App
     // ein eigenes src/styles.css hat (App-Theme-Pattern), wird das

package/src/scaffold-app.ts

@@ -42,6 +42,8 @@ export type ScaffoldFeatureEntry = {
   readonly importPath: string;
   readonly exportName: string;
   readonly callExpression: string;
+  /** Runtime args for factory-style exports that need config the codegen text can't parse back out (e.g. `{ scopes: {} }`). Omit for zero-arg factories and object-style exports. */
+  readonly callArgs?: readonly unknown[];
 };
 
 export type ScaffoldAppOptions = {
@@ -850,11 +852,8 @@ async function instantiateScaffoldFeatures(
         `scaffoldApp: ${entry.importPath} missing export ${entry.exportName} for ${entry.callExpression}`,
       );
     }
-    if (entry.callExpression.endsWith("()")) {
-      if (typeof exp !== "function") {
-        throw new Error(`scaffoldApp: ${entry.exportName} is not callable (${entry.importPath})`);
-      }
-      instances.push((exp as () => FeatureDefinition)());
+    if (typeof exp === "function") {
+      instances.push((exp as (...args: unknown[]) => FeatureDefinition)(...(entry.callArgs ?? [])));
     } else {
       instances.push(exp as FeatureDefinition);
     }