@cosmicdrift/kumiko-dev-server 0.193.1 → 0.195.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-dev-server",
-  "version": "0.193.1",
+  "version": "0.195.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.193.1",
-    "@cosmicdrift/kumiko-framework": "0.193.1",
-    "@cosmicdrift/kumiko-server-runtime": "0.193.1",
+    "@cosmicdrift/kumiko-bundled-features": "0.195.0",
+    "@cosmicdrift/kumiko-framework": "0.195.0",
+    "@cosmicdrift/kumiko-server-runtime": "0.195.0",
     "ts-morph": "^28.0.0"
   },
   "publishConfig": {

package/src/codegen/__tests__/watch.test.ts

@@ -47,21 +47,40 @@ afterAll(() => {
  * implicitly assume "this many ms is enough", which is brittle on
  * loaded CI runners. The polling form converges as fast as the system
  * allows AND fails loudly with a useful message if the event never lands.
+ *
+ * `retry`/`retryIntervalMs`: for predicates gated on a native `fs.watch`
+ * event, a single write only gets one chance at delivery — under macOS
+ * FSEvents backlog (hundreds of concurrent recursive watches in a full
+ * `bun test` run), events aren't just delayed, they're sometimes dropped
+ * entirely, and Node doesn't surface a rescan signal. `retry` re-fires the
+ * triggering action on a cadence so a dropped event costs one interval,
+ * not the whole timeout. `retryIntervalMs` must stay well above the
+ * watcher's `debounceMs` — a retry that lands mid-debounce just resets
+ * the timer and can starve `fire()` forever.
  */
 async function waitFor(
   predicate: () => boolean,
-  opts: { timeout?: number; interval?: number; label?: string } = {},
+  opts: {
+    timeout?: number;
+    interval?: number;
+    label?: string;
+    retry?: () => void;
+    retryIntervalMs?: number;
+  } = {},
 ): Promise<void> {
-  // Default 5000ms — fchokidar-FS-watch events take >2s under CI load on
-  // the cdgs-runner (Memory feedback_watch_test_flaky, observed 3× in
-  // a row on PR #80). 5s gives headroom without slowing the happy-path.
   const timeout = opts.timeout ?? 5000;
   const interval = opts.interval ?? 25;
+  const retryIntervalMs = opts.retryIntervalMs ?? 250;
   const deadline = Date.now() + timeout;
+  let nextRetryAt = Date.now() + retryIntervalMs;
   while (!predicate()) {
     if (Date.now() > deadline) {
       throw new Error(`waitFor: ${opts.label ?? "predicate"} not satisfied within ${timeout}ms`);
     }
+    if (opts.retry && Date.now() >= nextRetryAt) {
+      opts.retry();
+      nextRetryAt = Date.now() + retryIntervalMs;
+    }
     await new Promise((r) => setTimeout(r, interval));
   }
 }
@@ -105,11 +124,11 @@ describe("watchAndRegenerate", () => {
     expect(results).toHaveLength(1);
     expect(results[0]?.eventCount).toBe(1);
 
-    // Add a second event-definition by rewriting the feature.
-    writeFile(
-      appRoot,
-      "src/feature.ts",
-      `
+    const rewrite = () =>
+      writeFile(
+        appRoot,
+        "src/feature.ts",
+        `
 import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
 import { z } from "zod";
 
@@ -118,20 +137,29 @@ export default defineFeature("orders", (r) => {
   r.defineEvent("second", z.object({ tag: z.string() }));
 });
 `,
-    );
-
-    // Poll until the watcher's debounced re-run has landed. fs.watch
-    // events on macOS arrive in 1-5ms; CI runners can stretch that —
-    // polling adapts to the actual schedule instead of guessing a fixed
-    // sleep.
-    await waitFor(() => results.length >= 2, {
-      timeout: 5000,
-      label: "second codegen result",
-    });
+      );
 
-    expect(results.at(-1)?.eventCount).toBe(2);
-    handle.close();
-  });
+    // Add a second event-definition by rewriting the feature.
+    rewrite();
+
+    // Poll until the watcher's debounced re-run has landed, re-touching
+    // the file every 250ms in case the triggering fs.watch event was
+    // dropped rather than merely delayed (see waitFor's `retry` doc).
+    // Waits on the expected *state* (eventCount 2), not just a length
+    // bump — writeFileSync truncates then writes, so an event fired
+    // mid-write would satisfy a length-only predicate with a stale
+    // (0 or 1) eventCount, especially with retries widening that window.
+    try {
+      await waitFor(() => results.some((r) => r.eventCount === 2), {
+        timeout: 12000,
+        label: "second codegen result",
+        retry: rewrite,
+      });
+      expect(results.at(-1)?.eventCount).toBe(2);
+    } finally {
+      handle.close();
+    }
+  }, 15000);
 
   test("close() is idempotent", () => {
     const appRoot = makeAppDir();
@@ -174,15 +202,20 @@ export default defineFeature("orders", (r) => {
 
     // Positive control: a .ts change MUST trigger. waitFor exits as
     // soon as the new result lands, confirming the watcher is alive.
-    writeFile(appRoot, "src/feature.ts", FEATURE_TEMPLATE("ignore-css", "after"));
+    // Re-touched on retry in case the triggering event is dropped
+    // rather than merely delayed under a loaded fs.watch backlog.
+    const triggerRewrite = () =>
+      writeFile(appRoot, "src/feature.ts", FEATURE_TEMPLATE("ignore-css", "after"));
+    triggerRewrite();
     await waitFor(() => results.length > afterNonTs, {
-      timeout: 5000,
+      timeout: 12000,
       label: "ts-change result after non-ts noise",
+      retry: triggerRewrite,
     });
 
     // The non-ts writes should not have advanced the count past the
     // baseline. If they did, the watcher's filter is broken.
     expect(afterNonTs).toBe(baseline);
     handle.close();
-  });
+  }, 15000);
 });

package/src/create-kumiko-server.ts

@@ -153,9 +153,9 @@ export type CreateKumikoServerOptions = {
    *  `stylesheet: false` → CSS-Pipeline explizit deaktivieren. */
   readonly stylesheet?: string | false;
   /** Optional HTML template served at `GET /`. The dev-server injects
-   *  a `<script src="/client.js">` and a reload-listener snippet into
-   *  `</body>` if those aren't already there. Defaults to a minimal
-   *  empty-body document — enough to boot the client. */
+   *  a `<script type="module" src="/client.js">` and a reload-listener
+   *  snippet into `</body>` if those aren't already there. Defaults to a
+   *  minimal empty-body document — enough to boot the client. */
   readonly htmlPath?: string;
   /** Port to listen on. Default 4173. Overridable via `PORT` env. */
   readonly port?: number;