@mandujs/core 0.54.10 → 0.54.11

package/src/router/fs-routes.ts

@@ -14,11 +14,11 @@ import { DEFAULT_SCANNER_CONFIG } from "./fs-types";
 import { scanRoutes } from "./fs-scanner";
 import { loadManduConfig } from "../config";
 import type { ManduPlugin, ManduHooks } from "../plugins/hooks";
-import {
-  runOnRouteRegistered,
-  runOnManifestBuilt,
-} from "../plugins/runner";
-import { shouldPreserveExistingClientModule } from "./client-entry";
+import {
+  runOnRouteRegistered,
+  runOnManifestBuilt,
+} from "../plugins/runner";
+import { shouldPreserveExistingClientModule } from "./client-entry";
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Types
@@ -309,17 +309,17 @@ export async function generateManifest(
       for (const route of manifest.routes) {
         const prev = existingMap.get(route.id);
         if (!prev) continue;
-        // 사용자가 설정한 clientModule/hydration 보존.
-        // If app/page.tsx used to be a client page and later becomes a server
-        // page, preserving the old clientModule would leak the server graph into
-        // the browser bundle.
-        if (
-          prev.clientModule &&
-          !route.clientModule &&
-          await shouldPreserveExistingClientModule(route, prev.clientModule, rootDir)
-        ) {
-          route.clientModule = prev.clientModule;
-        }
+        // 사용자가 설정한 clientModule/hydration 보존.
+        // If app/page.tsx used to be a client page and later becomes a server
+        // page, preserving the old clientModule would leak the server graph into
+        // the browser bundle.
+        if (
+          prev.clientModule &&
+          !route.clientModule &&
+          await shouldPreserveExistingClientModule(route, prev.clientModule, rootDir)
+        ) {
+          route.clientModule = prev.clientModule;
+        }
         if (prev.hydration && !route.hydration) {
           route.hydration = prev.hydration;
         }

package/src/router/fs-scanner.ts

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

package/src/runtime/__tests__/devtools-adapter.test.ts

@@ -1,68 +1,68 @@
-import { afterEach, describe, expect, it } from "bun:test";
-import type { RoutesManifest } from "../../spec/schema";
-import {
-  createRuntimeDevtoolsAdapter,
-  shouldRecordRuntimeRequest,
-  type RuntimeDevtoolsAdapter,
-} from "../devtools-adapter";
-
-const manifest: RoutesManifest = {
-  version: 1,
-  routes: [],
-};
-
-describe("runtime devtools adapter", () => {
-  let adapter: RuntimeDevtoolsAdapter | null = null;
-
-  afterEach(() => {
-    adapter?.stop();
-    adapter = null;
-  });
-
-  it("stays disabled outside dev mode", async () => {
-    adapter = createRuntimeDevtoolsAdapter({
-      isDev: false,
-      rootDir: process.cwd(),
-      manifest,
-      guardConfig: null,
-    });
-
-    expect(adapter.kitchen).toBeNull();
-    expect(adapter.dashboardPath).toBeNull();
-    const response = await adapter.handleRequest(
-      new Request("http://localhost:3000/__kitchen"),
-      "/__kitchen"
-    );
-    expect(response).toBeNull();
-  });
-
-  it("dispatches Kitchen requests in dev mode", async () => {
-    adapter = createRuntimeDevtoolsAdapter({
-      isDev: true,
-      rootDir: process.cwd(),
-      manifest,
-      guardConfig: null,
-    });
-
-    expect(adapter.kitchen).not.toBeNull();
-    expect(adapter.dashboardPath).toBe("/__kitchen");
-    await expect(
-      adapter.handleRequest(new Request("http://localhost:3000/api/ping"), "/api/ping")
-    ).resolves.toBeNull();
-
-    const response = await adapter.handleRequest(
-      new Request("http://localhost:3000/__kitchen"),
-      "/__kitchen"
-    );
-    expect(response?.status).toBe(200);
-    expect(await response?.text()).toContain("Mandu Kitchen");
-  });
-
-  it("keeps framework-internal request paths out of the Kitchen request log", () => {
-    expect(shouldRecordRuntimeRequest("/api/ping")).toBe(true);
-    expect(shouldRecordRuntimeRequest("/_mandu/heap")).toBe(true);
-    expect(shouldRecordRuntimeRequest("/.mandu/client/runtime.js")).toBe(false);
-    expect(shouldRecordRuntimeRequest("/__kitchen/api/events")).toBe(false);
-    expect(shouldRecordRuntimeRequest("/__mandu/events/recent")).toBe(false);
-  });
-});
+import { afterEach, describe, expect, it } from "bun:test";
+import type { RoutesManifest } from "../../spec/schema";
+import {
+  createRuntimeDevtoolsAdapter,
+  shouldRecordRuntimeRequest,
+  type RuntimeDevtoolsAdapter,
+} from "../devtools-adapter";
+
+const manifest: RoutesManifest = {
+  version: 1,
+  routes: [],
+};
+
+describe("runtime devtools adapter", () => {
+  let adapter: RuntimeDevtoolsAdapter | null = null;
+
+  afterEach(() => {
+    adapter?.stop();
+    adapter = null;
+  });
+
+  it("stays disabled outside dev mode", async () => {
+    adapter = createRuntimeDevtoolsAdapter({
+      isDev: false,
+      rootDir: process.cwd(),
+      manifest,
+      guardConfig: null,
+    });
+
+    expect(adapter.kitchen).toBeNull();
+    expect(adapter.dashboardPath).toBeNull();
+    const response = await adapter.handleRequest(
+      new Request("http://localhost:3000/__kitchen"),
+      "/__kitchen"
+    );
+    expect(response).toBeNull();
+  });
+
+  it("dispatches Kitchen requests in dev mode", async () => {
+    adapter = createRuntimeDevtoolsAdapter({
+      isDev: true,
+      rootDir: process.cwd(),
+      manifest,
+      guardConfig: null,
+    });
+
+    expect(adapter.kitchen).not.toBeNull();
+    expect(adapter.dashboardPath).toBe("/__kitchen");
+    await expect(
+      adapter.handleRequest(new Request("http://localhost:3000/api/ping"), "/api/ping")
+    ).resolves.toBeNull();
+
+    const response = await adapter.handleRequest(
+      new Request("http://localhost:3000/__kitchen"),
+      "/__kitchen"
+    );
+    expect(response?.status).toBe(200);
+    expect(await response?.text()).toContain("Mandu Kitchen");
+  });
+
+  it("keeps framework-internal request paths out of the Kitchen request log", () => {
+    expect(shouldRecordRuntimeRequest("/api/ping")).toBe(true);
+    expect(shouldRecordRuntimeRequest("/_mandu/heap")).toBe(true);
+    expect(shouldRecordRuntimeRequest("/.mandu/client/runtime.js")).toBe(false);
+    expect(shouldRecordRuntimeRequest("/__kitchen/api/events")).toBe(false);
+    expect(shouldRecordRuntimeRequest("/__mandu/events/recent")).toBe(false);
+  });
+});

package/src/runtime/__tests__/observability-lifecycle.test.ts

@@ -1,103 +1,103 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import {
-  INTERNAL_EVENTS_ENDPOINT,
-  createRuntimeObservabilityLifecycle,
-} from "../observability-lifecycle";
-import { eventBus } from "../../observability/event-bus";
-import {
-  resetTracer,
-  type Span,
-  type SpanExporter,
-} from "../../observability/tracing";
-
-class CaptureExporter implements SpanExporter {
-  readonly spans: Span[] = [];
-  export(spans: Span[]): void {
-    this.spans.push(...spans);
-  }
-}
-
-afterEach(() => {
-  resetTracer();
-});
-
-describe("runtime observability lifecycle", () => {
-  test("serves heap snapshots with perf data when exposed", async () => {
-    const lifecycle = createRuntimeObservabilityLifecycle({ isDev: true });
-    const response = lifecycle.handleEndpoint(
-      new Request("http://localhost/_mandu/heap"),
-      "/_mandu/heap"
-    );
-
-    expect(response?.status).toBe(200);
-    const body = await response!.json() as {
-      process: { heapUsed: number };
-      perf: unknown;
-    };
-    expect(body.process.heapUsed).toBeGreaterThan(0);
-    expect(body.perf).toBeDefined();
-  });
-
-  test("keeps metrics hidden in production unless explicitly enabled", () => {
-    const hidden = createRuntimeObservabilityLifecycle({ isDev: false });
-    const shown = createRuntimeObservabilityLifecycle({
-      isDev: false,
-      metricsEndpoint: true,
-    });
-
-    expect(hidden.handleEndpoint(new Request("http://localhost/_mandu/metrics"), "/_mandu/metrics")).toBeNull();
-    expect(shown.handleEndpoint(new Request("http://localhost/_mandu/metrics"), "/_mandu/metrics")?.status).toBe(200);
-  });
-
-  test("serves recent EventBus snapshots from the lifecycle endpoint", async () => {
-    const lifecycle = createRuntimeObservabilityLifecycle({ isDev: true });
-    const source = `observability-lifecycle-${Date.now()}`;
-    eventBus.emit({
-      type: "http",
-      severity: "info",
-      source,
-      message: "GET /observed 200",
-    });
-
-    const response = lifecycle.handleEndpoint(
-      new Request(`http://localhost${INTERNAL_EVENTS_ENDPOINT}/recent?source=${source}`),
-      `${INTERNAL_EVENTS_ENDPOINT}/recent`
-    );
-
-    expect(response?.status).toBe(200);
-    const body = await response!.json() as {
-      events: Array<{ source: string; message: string }>;
-    };
-    expect(body.events.some((event) => event.source === source)).toBe(true);
-  });
-
-  test("wraps requests in a root tracing span", async () => {
-    const exporter = new CaptureExporter();
-    const lifecycle = createRuntimeObservabilityLifecycle({
-      isDev: false,
-      tracing: {
-        enabled: true,
-        customExporter: exporter,
-      },
-    });
-    const incomingTraceId = "4bf92f3577b34da6a3ce929d0e0e4736";
-    const incomingSpanId = "00f067aa0ba902b7";
-    const response = await lifecycle.runRequest(
-      new Request("https://example.test/users", {
-        headers: {
-          traceparent: `00-${incomingTraceId}-${incomingSpanId}-01`,
-        },
-      }),
-      Date.now(),
-      "corr-1",
-      async () => new Response("created", { status: 201 })
-    );
-
-    expect(response.status).toBe(201);
-    expect(exporter.spans).toHaveLength(1);
-    expect(exporter.spans[0].traceId).toBe(incomingTraceId);
-    expect(exporter.spans[0].parentSpanId).toBe(incomingSpanId);
-    expect(exporter.spans[0].attributes["http.status_code"]).toBe(201);
-    expect(exporter.spans[0].status).toBe("ok");
-  });
-});
+import { afterEach, describe, expect, test } from "bun:test";
+import {
+  INTERNAL_EVENTS_ENDPOINT,
+  createRuntimeObservabilityLifecycle,
+} from "../observability-lifecycle";
+import { eventBus } from "../../observability/event-bus";
+import {
+  resetTracer,
+  type Span,
+  type SpanExporter,
+} from "../../observability/tracing";
+
+class CaptureExporter implements SpanExporter {
+  readonly spans: Span[] = [];
+  export(spans: Span[]): void {
+    this.spans.push(...spans);
+  }
+}
+
+afterEach(() => {
+  resetTracer();
+});
+
+describe("runtime observability lifecycle", () => {
+  test("serves heap snapshots with perf data when exposed", async () => {
+    const lifecycle = createRuntimeObservabilityLifecycle({ isDev: true });
+    const response = lifecycle.handleEndpoint(
+      new Request("http://localhost/_mandu/heap"),
+      "/_mandu/heap"
+    );
+
+    expect(response?.status).toBe(200);
+    const body = await response!.json() as {
+      process: { heapUsed: number };
+      perf: unknown;
+    };
+    expect(body.process.heapUsed).toBeGreaterThan(0);
+    expect(body.perf).toBeDefined();
+  });
+
+  test("keeps metrics hidden in production unless explicitly enabled", () => {
+    const hidden = createRuntimeObservabilityLifecycle({ isDev: false });
+    const shown = createRuntimeObservabilityLifecycle({
+      isDev: false,
+      metricsEndpoint: true,
+    });
+
+    expect(hidden.handleEndpoint(new Request("http://localhost/_mandu/metrics"), "/_mandu/metrics")).toBeNull();
+    expect(shown.handleEndpoint(new Request("http://localhost/_mandu/metrics"), "/_mandu/metrics")?.status).toBe(200);
+  });
+
+  test("serves recent EventBus snapshots from the lifecycle endpoint", async () => {
+    const lifecycle = createRuntimeObservabilityLifecycle({ isDev: true });
+    const source = `observability-lifecycle-${Date.now()}`;
+    eventBus.emit({
+      type: "http",
+      severity: "info",
+      source,
+      message: "GET /observed 200",
+    });
+
+    const response = lifecycle.handleEndpoint(
+      new Request(`http://localhost${INTERNAL_EVENTS_ENDPOINT}/recent?source=${source}`),
+      `${INTERNAL_EVENTS_ENDPOINT}/recent`
+    );
+
+    expect(response?.status).toBe(200);
+    const body = await response!.json() as {
+      events: Array<{ source: string; message: string }>;
+    };
+    expect(body.events.some((event) => event.source === source)).toBe(true);
+  });
+
+  test("wraps requests in a root tracing span", async () => {
+    const exporter = new CaptureExporter();
+    const lifecycle = createRuntimeObservabilityLifecycle({
+      isDev: false,
+      tracing: {
+        enabled: true,
+        customExporter: exporter,
+      },
+    });
+    const incomingTraceId = "4bf92f3577b34da6a3ce929d0e0e4736";
+    const incomingSpanId = "00f067aa0ba902b7";
+    const response = await lifecycle.runRequest(
+      new Request("https://example.test/users", {
+        headers: {
+          traceparent: `00-${incomingTraceId}-${incomingSpanId}-01`,
+        },
+      }),
+      Date.now(),
+      "corr-1",
+      async () => new Response("created", { status: 201 })
+    );
+
+    expect(response.status).toBe(201);
+    expect(exporter.spans).toHaveLength(1);
+    expect(exporter.spans[0].traceId).toBe(incomingTraceId);
+    expect(exporter.spans[0].parentSpanId).toBe(incomingSpanId);
+    expect(exporter.spans[0].attributes["http.status_code"]).toBe(201);
+    expect(exporter.spans[0].status).toBe("ok");
+  });
+});

package/src/runtime/__tests__/page-render-response.test.ts

@@ -1,103 +1,103 @@
-import { describe, expect, it } from "bun:test";
-import React from "react";
-import { renderPageResponse } from "../page-render-response";
-import type { BundleManifest } from "../../bundler/types";
-
-const HYDRATED_MANIFEST: BundleManifest = {
-  version: 1,
-  buildTime: "2026-05-19T00:00:00.000Z",
-  env: "production",
-  bundles: {
-    home: {
-      js: "/.mandu/client/home.island.js",
-      dependencies: ["_runtime", "_react"],
-      priority: "visible",
-    },
-  },
-  shared: {
-    runtime: "/.mandu/client/_runtime.js",
-    vendor: "/.mandu/client/_react.js",
-    router: "/.mandu/client/_router.js",
-  },
-  importMap: {
-    imports: {
-      react: "/.mandu/client/_react.js",
-      "react-dom": "/.mandu/client/_react-dom.js",
-      "react-dom/client": "/.mandu/client/_react-dom-client.js",
-    },
-  },
-};
-
-describe("runtime page render response orchestration", () => {
-  it("pre-resolves async components on the non-streaming path", async () => {
-    async function AsyncPage() {
-      return React.createElement("main", null, "resolved-page");
-    }
-
-    const response = await renderPageResponse({
-      app: React.createElement(AsyncPage),
-      useStreaming: false,
-      title: "Async Page",
-      headTags: "",
-      isDev: false,
-      routeId: "page/async",
-      routePattern: "/async",
-      loaderData: { ok: true },
-      transitions: false,
-      prefetch: false,
-      spa: false,
-      devtools: false,
-    });
-
-    expect(response.status).toBe(200);
-    const html = await response.text();
-    expect(html).toContain("resolved-page");
-    expect(html).toContain("Async Page");
-  });
-
-  it("uses the streaming renderer when requested", async () => {
-    const response = await renderPageResponse({
-      app: React.createElement("main", null, "stream-page"),
-      useStreaming: true,
-      title: "Stream Page",
-      headTags: "",
-      isDev: false,
-      routeId: "page/stream",
-      routePattern: "/stream",
-      loaderData: { ok: true },
-      transitions: false,
-      prefetch: false,
-      spa: false,
-      devtools: false,
-    });
-
-    expect(response.status).toBe(200);
-    expect(response.headers.get("X-Accel-Buffering")).toBe("no");
-    const html = await response.text();
-    expect(html).toContain("stream-page");
-    expect(html).toContain("Stream Page");
-  });
-
-  it("serializes non-streaming loaderData as the route server data exactly once", async () => {
-    const response = await renderPageResponse({
-      app: React.createElement("main", null, "hydrated-page"),
-      useStreaming: false,
-      title: "Hydrated Page",
-      headTags: "",
-      isDev: false,
-      routeId: "home",
-      routePattern: "/",
-      loaderData: { items: ["a", "b"] },
-      hydration: { strategy: "island", priority: "visible", preload: false },
-      bundleManifest: HYDRATED_MANIFEST,
-      transitions: false,
-      prefetch: false,
-      spa: false,
-      devtools: false,
-    });
-
-    const html = await response.text();
-    expect(html).toContain('"home":{"serverData":{"items":["a","b"]}');
-    expect(html).not.toContain('"serverData":{"home"');
-  });
-});
+import { describe, expect, it } from "bun:test";
+import React from "react";
+import { renderPageResponse } from "../page-render-response";
+import type { BundleManifest } from "../../bundler/types";
+
+const HYDRATED_MANIFEST: BundleManifest = {
+  version: 1,
+  buildTime: "2026-05-19T00:00:00.000Z",
+  env: "production",
+  bundles: {
+    home: {
+      js: "/.mandu/client/home.island.js",
+      dependencies: ["_runtime", "_react"],
+      priority: "visible",
+    },
+  },
+  shared: {
+    runtime: "/.mandu/client/_runtime.js",
+    vendor: "/.mandu/client/_react.js",
+    router: "/.mandu/client/_router.js",
+  },
+  importMap: {
+    imports: {
+      react: "/.mandu/client/_react.js",
+      "react-dom": "/.mandu/client/_react-dom.js",
+      "react-dom/client": "/.mandu/client/_react-dom-client.js",
+    },
+  },
+};
+
+describe("runtime page render response orchestration", () => {
+  it("pre-resolves async components on the non-streaming path", async () => {
+    async function AsyncPage() {
+      return React.createElement("main", null, "resolved-page");
+    }
+
+    const response = await renderPageResponse({
+      app: React.createElement(AsyncPage),
+      useStreaming: false,
+      title: "Async Page",
+      headTags: "",
+      isDev: false,
+      routeId: "page/async",
+      routePattern: "/async",
+      loaderData: { ok: true },
+      transitions: false,
+      prefetch: false,
+      spa: false,
+      devtools: false,
+    });
+
+    expect(response.status).toBe(200);
+    const html = await response.text();
+    expect(html).toContain("resolved-page");
+    expect(html).toContain("Async Page");
+  });
+
+  it("uses the streaming renderer when requested", async () => {
+    const response = await renderPageResponse({
+      app: React.createElement("main", null, "stream-page"),
+      useStreaming: true,
+      title: "Stream Page",
+      headTags: "",
+      isDev: false,
+      routeId: "page/stream",
+      routePattern: "/stream",
+      loaderData: { ok: true },
+      transitions: false,
+      prefetch: false,
+      spa: false,
+      devtools: false,
+    });
+
+    expect(response.status).toBe(200);
+    expect(response.headers.get("X-Accel-Buffering")).toBe("no");
+    const html = await response.text();
+    expect(html).toContain("stream-page");
+    expect(html).toContain("Stream Page");
+  });
+
+  it("serializes non-streaming loaderData as the route server data exactly once", async () => {
+    const response = await renderPageResponse({
+      app: React.createElement("main", null, "hydrated-page"),
+      useStreaming: false,
+      title: "Hydrated Page",
+      headTags: "",
+      isDev: false,
+      routeId: "home",
+      routePattern: "/",
+      loaderData: { items: ["a", "b"] },
+      hydration: { strategy: "island", priority: "visible", preload: false },
+      bundleManifest: HYDRATED_MANIFEST,
+      transitions: false,
+      prefetch: false,
+      spa: false,
+      devtools: false,
+    });
+
+    const html = await response.text();
+    expect(html).toContain('"home":{"serverData":{"items":["a","b"]}');
+    expect(html).not.toContain('"serverData":{"home"');
+  });
+});