@mandujs/core 0.54.5 → 0.54.7

package/src/router/fs-scanner.ts

@@ -30,7 +30,11 @@ import {
 } from "./fs-patterns";
 import { mark, measure } from "../perf";
 import { METADATA_ROUTES } from "../routes/types";
-import { hasUseClientDirective } from "./client-entry";
+import {
+  findRouteLevelClientComponentImport,
+  hasUseClientDirective,
+  resolveClientImportModulePath,
+} from "./client-entry";
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Scanner Class
@@ -229,7 +233,7 @@ export class FSScanner {
    */
   private async createRouteConfigs(
     files: ScannedFile[],
-    _rootDir: string
+    rootDir: string
   ): Promise<{ routes: FSRouteConfig[]; routeErrors: ScanError[] }> {
     const routes: FSRouteConfig[] = [];
     const routeErrors: ScanError[] = [];
@@ -389,13 +393,22 @@ export class FSScanner {
             conflictsWith: islands[0].absolutePath,
           });
         }
-      } else if (file.type === "page" && pageFileContent) {
-        // page 파일 자체에서 "use client" 확인
+      } else if (file.type === "page" && pageFileContent) {
+        // page 파일 자체에서 "use client" 확인
         const hasUseClient = hasUseClientDirective(pageFileContent);
-        if (hasUseClient) {
-          clientModule = modulePath;
-        }
-      }
+        if (hasUseClient) {
+          clientModule = modulePath;
+        } else {
+          const routeLevelClientImport = findRouteLevelClientComponentImport(pageFileContent);
+          if (routeLevelClientImport) {
+            clientModule = await resolveClientImportModulePath(
+              rootDir,
+              modulePath,
+              routeLevelClientImport.module,
+            ) ?? undefined;
+          }
+        }
+      }
 
       // 로딩/에러/404 모듈 찾기 — nearest-ancestor resolution.
       // Phase 18.β: `not-found.tsx` joins `loading.tsx`/`error.tsx` in

package/src/runtime/server.ts

@@ -2232,18 +2232,26 @@ async function renderPageSSR(
 
     // Island 래핑: 레이아웃 적용 전에 페이지 콘텐츠만 island div로 감쌈
     // 이렇게 하면 레이아웃은 island 바깥에 위치하여 하이드레이션 시 레이아웃이 유지됨
-    const needsIslandWrap = !!(
+    const needsIslandHydration = !!(
       route.hydration &&
       route.hydration.strategy !== "none" &&
       settings.bundleManifest
     );
-
-    if (needsIslandWrap) {
-      const bundle = settings.bundleManifest?.bundles[route.id];
-      const bundleSrc = bundle?.js ? `${bundle.js}?t=${Date.now()}` : "";
-      const priority = route.hydration!.priority || "visible";
-      app = React.createElement("div", {
-        "data-mandu-island": route.id,
+    const routeBundle = settings.bundleManifest?.bundles[route.id];
+    const bundleSrc = routeBundle?.js ? `${routeBundle.js}?t=${Date.now()}` : "";
+    const needsIslandWrap = needsIslandHydration && bundleSrc.length > 0;
+
+    if (needsIslandHydration && !needsIslandWrap && settings.isDev) {
+      console.warn(
+        `[Mandu] Hydration requested for route "${route.id}" but no client bundle was found. ` +
+        `Run mandu build/generate and ensure the route has a clientModule.`,
+      );
+    }
+
+    if (needsIslandWrap) {
+      const priority = route.hydration!.priority || "visible";
+      app = React.createElement("div", {
+        "data-mandu-island": route.id,
         "data-mandu-src": bundleSrc,
         "data-mandu-priority": priority,
         style: { display: "contents" },

package/src/watcher/__tests__/watcher.test.ts

@@ -0,0 +1,59 @@
+import { afterEach, expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { hasRecentGenerateStamp } from "../watcher";
+
+const tmpRoots: string[] = [];
+
+function makeRoot(): string {
+  const root = mkdtempSync(join(tmpdir(), "mandu-watch-"));
+  tmpRoots.push(root);
+  return root;
+}
+
+afterEach(() => {
+  for (const root of tmpRoots.splice(0)) {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("hasRecentGenerateStamp suppresses generated events using the root stamp", () => {
+  const root = makeRoot();
+  const now = 1_700_000_000_000;
+  mkdirSync(join(root, ".mandu"), { recursive: true });
+  writeFileSync(join(root, ".mandu", "generate.stamp"), String(now - 500));
+
+  const generatedFile = join(
+    root,
+    ".mandu",
+    "generated",
+    "server",
+    "repos",
+    "notification.repo.ts",
+  );
+
+  expect(hasRecentGenerateStamp(root, generatedFile, now)).toBe(true);
+});
+
+test("hasRecentGenerateStamp does not suppress stale generated events", () => {
+  const root = makeRoot();
+  const now = 1_700_000_000_000;
+  mkdirSync(join(root, ".mandu"), { recursive: true });
+  writeFileSync(join(root, ".mandu", "generate.stamp"), String(now - 30_000));
+
+  const generatedFile = join(root, ".mandu", "generated", "server", "old.route.ts");
+
+  expect(hasRecentGenerateStamp(root, generatedFile, now)).toBe(false);
+});
+
+test("hasRecentGenerateStamp does not suppress source files after generation", () => {
+  const root = makeRoot();
+  const now = 1_700_000_000_000;
+  mkdirSync(join(root, ".mandu"), { recursive: true });
+  writeFileSync(join(root, ".mandu", "generate.stamp"), String(now - 500));
+
+  const sourceFile = join(root, "app", "page.tsx");
+
+  expect(hasRecentGenerateStamp(root, sourceFile, now)).toBe(false);
+});

package/src/watcher/watcher.ts

@@ -61,13 +61,63 @@ const DEFAULT_CONFIG: Partial<WatcherConfig> = {
  * These cause EISDIR/ENOENT errors when file watchers try to access them.
  * See: https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file
  */
-const WINDOWS_RESERVED_NAMES = new Set([
-  "CON", "PRN", "AUX", "NUL",
-  "COM0", "COM1", "COM2", "COM3", "COM4", "COM5", "COM6", "COM7", "COM8", "COM9",
-  "LPT0", "LPT1", "LPT2", "LPT3", "LPT4", "LPT5", "LPT6", "LPT7", "LPT8", "LPT9",
-]);
-
-export class FileWatcher {
+const WINDOWS_RESERVED_NAMES = new Set([
+  "CON", "PRN", "AUX", "NUL",
+  "COM0", "COM1", "COM2", "COM3", "COM4", "COM5", "COM6", "COM7", "COM8", "COM9",
+  "LPT0", "LPT1", "LPT2", "LPT3", "LPT4", "LPT5", "LPT6", "LPT7", "LPT8", "LPT9",
+]);
+
+const GENERATE_STAMP_SUPPRESS_MS = 10_000;
+
+function readGenerateStamp(stampFile: string): number | null {
+  try {
+    const stamp = Number.parseInt(fs.readFileSync(stampFile, "utf-8"), 10);
+    return Number.isFinite(stamp) ? stamp : null;
+  } catch {
+    return null;
+  }
+}
+
+function isManduGeneratedPath(rootDir: string, filePath: string): boolean {
+  const relativePath = path.relative(rootDir, filePath).replace(/\\/g, "/");
+  return relativePath === ".mandu/generated" || relativePath.startsWith(".mandu/generated/");
+}
+
+export function hasRecentGenerateStamp(
+  rootDir: string,
+  filePath: string,
+  now: number = Date.now()
+): boolean {
+  if (!isManduGeneratedPath(rootDir, filePath)) {
+    return false;
+  }
+
+  const candidates = new Set<string>([
+    path.join(rootDir, ".mandu", "generate.stamp"),
+  ]);
+  const resolvedRoot = path.resolve(rootDir);
+  let stampDir = path.dirname(path.resolve(filePath));
+
+  while (stampDir !== path.dirname(stampDir)) {
+    candidates.add(path.join(stampDir, ".mandu", "generate.stamp"));
+    if (stampDir === resolvedRoot) break;
+    stampDir = path.dirname(stampDir);
+  }
+
+  for (const stampFile of candidates) {
+    const stamp = readGenerateStamp(stampFile);
+    if (stamp === null) continue;
+
+    const ageMs = now - stamp;
+    if (ageMs >= 0 && ageMs < GENERATE_STAMP_SUPPRESS_MS) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+export class FileWatcher {
   private config: WatcherConfig;
   private chokidarWatcher: FSWatcher | null = null;
   private handlers: Set<WatchEventHandler> = new Set();
@@ -311,21 +361,10 @@ export class FileWatcher {
 
     const { rootDir } = this.config;
 
-    // Cross-process: skip if generate finished within last 2 seconds
-    // Walk up from the changed file to find nearest .mandu/generate.stamp
-    let stampDir = path.dirname(filePath);
-    while (stampDir !== path.dirname(stampDir)) {
-      const stampFile = path.join(stampDir, ".mandu", "generate.stamp");
-      try {
-        const stamp = parseInt(fs.readFileSync(stampFile, "utf-8"), 10);
-        if (Date.now() - stamp < 2000) return;
-        break;
-      } catch {}
-      stampDir = path.dirname(stampDir);
-    }
-
-
-    // Validate file against rules
+    // Cross-process: skip generated-file churn from a recent mandu generate.
+    if (hasRecentGenerateStamp(rootDir, filePath)) return;
+
+    // Validate file against rules
     try {
       const warnings = await validateFile(filePath, event, rootDir);