@mandujs/core 0.31.0 → 0.33.0

package/src/bundler/types.ts

@@ -164,4 +164,24 @@ export interface BundlerOptions {
    * resolved config flag straight through.
    */
   blockGeneratedImport?: boolean;
+
+  /**
+   * Phase 18.τ — consumer-supplied `BunPlugin`s contributed via plugin
+   * `defineBundlerPlugin()` hook. Composed AFTER Mandu's defaults so
+   * user transforms see already-resolved imports. Omitted / empty
+   * array is a zero-overhead passthrough.
+   *
+   * Resolved by the CLI (`cli/commands/build.ts`, `cli/commands/dev.ts`)
+   * via `runDefineBundlerPlugin()` and fed into every `safeBuild(...)`
+   * call-site; library users may populate it directly.
+   */
+  pluginBundlerPlugins?: readonly import("bun").BunPlugin[];
+
+  /**
+   * Phase 18.τ — fire per-build `onBundleComplete(stats)` hook after
+   * `buildClientBundles()` finishes. Paired with `configHooks` for
+   * config-level hooks. Zero-overhead when both are omitted.
+   */
+  plugins?: readonly import("../plugins/hooks").ManduPlugin[];
+  configHooks?: Partial<import("../plugins/hooks").ManduHooks>;
 }

package/src/config/mandu.ts

@@ -5,6 +5,8 @@ import type { ManduPlugin, ManduHooks } from "../plugins/hooks";
 import type { Middleware } from "../middleware/define";
 import type { RpcDefinition, RpcProcedureRecord } from "../contract/rpc";
 import type { CronDef } from "../scheduler";
+import type { GuardRule as CustomGuardRule } from "../guard/define-rule";
+import type { I18nStrategy, LocaleCode } from "../i18n/types";
 
 export type GuardRuleSeverity = "error" | "warn" | "warning" | "off";
 
@@ -148,7 +150,20 @@ export interface ManduConfig {
     srcDir?: string;
     exclude?: string[];
     realtime?: boolean;
-    rules?: Record<string, GuardRuleSeverity>;
+    /**
+     * Built-in rule severity overrides (map) OR consumer-defined
+     * custom rules (array). The Guard runner dispatches on shape:
+     *
+     *   - `Record<string, GuardRuleSeverity>` → override severity of
+     *     Mandu's built-in rules by id.
+     *   - `GuardRule[]` (Phase 18.ν) → register consumer-defined rules
+     *     alongside the built-in presets. See `@mandujs/core/guard/define-rule`.
+     *
+     * Passing both at once is not supported; pick one shape per config.
+     * Mixed input falls back to "custom rules only" and the built-in
+     * rule severity overrides become unreachable.
+     */
+    rules?: Record<string, GuardRuleSeverity> | CustomGuardRule[];
     contractRequired?: GuardRuleSeverity;
     /**
      * Issue #207 — hard-fail on direct `__generated__/` imports at the
@@ -422,6 +437,48 @@ export interface ManduConfig {
     jobs?: CronDef[];
     disabled?: boolean;
   };
+  /**
+   * Phase 18.μ — first-class internationalization.
+   *
+   * Declaring this block opts the project into the framework's built-in
+   * locale resolution + route synthesis. The CLI (`mandu build` /
+   * `mandu dev`) materializes per-locale route variants when
+   * `strategy === "path-prefix"` so a single `app/docs/page.tsx`
+   * serves `/en/docs`, `/ko/docs`, etc. without file duplication.
+   *
+   * At runtime, the server dispatcher attaches `ctx.locale`
+   * ({@link ResolvedLocale}) + `ctx.t` (typed translator, when a
+   * message registry is wired) to every loader and stamps
+   * `Vary: Accept-Language` on responses so CDNs cache correctly.
+   *
+   * Coexists with the legacy `app/[lang]/...` manual pattern — users
+   * migrate only when ready. See `docs/architect/i18n.md`.
+   *
+   * @example
+   * ```ts
+   * export default {
+   *   i18n: {
+   *     locales: ['en', 'ko'],
+   *     defaultLocale: 'en',
+   *     strategy: 'path-prefix',
+   *   },
+   * } satisfies ManduConfig;
+   * ```
+   */
+  i18n?: {
+    /** Non-empty list of supported locale codes. */
+    locales: LocaleCode[];
+    /** Fallback when no signal matches. MUST be in `locales`. */
+    defaultLocale: LocaleCode;
+    /** Optional fallback chain between request locale and defaultLocale. */
+    fallback?: LocaleCode;
+    /** Locale detection strategy. See {@link I18nStrategy}. */
+    strategy: I18nStrategy;
+    /** Cookie name (default: "mandu_locale"). */
+    cookieName?: string;
+    /** Domain → locale map; required when strategy === "domain". */
+    domains?: Record<string, LocaleCode>;
+  };
 }
 
 export const CONFIG_FILES = [

package/src/config/validate.ts

@@ -7,6 +7,7 @@ import type { ManduAdapter } from "../runtime/adapter";
 import type { ManduPlugin, ManduHooks } from "../plugins/hooks";
 import type { Middleware } from "../middleware/define";
 import type { CronDef } from "../scheduler";
+import { isGuardRuleLike, type GuardRule as CustomGuardRule } from "../guard/define-rule";
 
 /**
  * DNA-003: Strict mode schema helper
@@ -72,8 +73,30 @@ const ServerConfigSchema = z
   })
   .strict();
 
+/**
+ * Phase 18.ν — consumer-defined Guard rule (structural check).
+ *
+ * Rule objects carry closures (`check`) that Zod cannot introspect, so
+ * we validate structurally: must be a non-null object with a non-empty
+ * `id` string and a `check` function. Deeper validation (severity enum,
+ * description type) happens at `defineGuardRule()` time for the clearest
+ * DX error; the Guard runner catches any in-band violations.
+ */
+const CustomGuardRuleSchema = z.custom<CustomGuardRule>(
+  (v) => isGuardRuleLike(v),
+  {
+    message:
+      "Each custom guard rule must be an object with a non-empty `id` string and a `check` function. Use `defineGuardRule({...})` from `@mandujs/core/guard/define-rule` to construct.",
+  }
+);
+
 /**
  * Guard 설정 스키마 (strict)
+ *
+ * `guard.rules` is a discriminated union of two shapes:
+ *   - `Record<string, GuardRuleSeverity>` → built-in rule severity overrides.
+ *   - `GuardRule[]` (Phase 18.ν) → consumer-defined custom rules.
+ * The runner dispatches on `Array.isArray()`.
  */
 const GuardConfigSchema = z
   .object({
@@ -81,7 +104,12 @@ const GuardConfigSchema = z
     srcDir: z.string().default("src"),
     exclude: z.array(z.string()).default([]),
     realtime: z.boolean().default(true),
-    rules: z.record(z.enum(["error", "warn", "warning", "off"])).optional(),
+    rules: z
+      .union([
+        z.record(z.enum(["error", "warn", "warning", "off"])),
+        z.array(CustomGuardRuleSchema),
+      ])
+      .optional(),
     /**
      * Issue #207 — bundler-level hard-fail on direct `__generated__/`
      * imports. Default `true`. Set `false` to opt out of the
@@ -214,10 +242,32 @@ const TestE2EConfigSchema = z
   })
   .strict();
 
+/**
+ * Per-metric threshold sub-block (Phase 18.σ).
+ *
+ * All four metrics (lines / branches / functions / statements) are
+ * independently optional. Omitting the whole sub-block keeps the
+ * legacy behavior — the CLI only enforces thresholds for metrics
+ * that are explicitly set.
+ */
+const TestCoverageThresholdsSchema = z
+  .object({
+    lines: z.number().min(0).max(100).optional(),
+    branches: z.number().min(0).max(100).optional(),
+    functions: z.number().min(0).max(100).optional(),
+    statements: z.number().min(0).max(100).optional(),
+  })
+  .strict();
+
 const TestCoverageConfigSchema = z
   .object({
+    // Legacy top-level shorthand (Phase 12.3). When set, the CLI
+    // mirrors it into `thresholds.lines` so users who already had
+    // `coverage.lines: 80` in their config keep working unchanged.
     lines: z.number().min(0).max(100).optional(),
     branches: z.number().min(0).max(100).optional(),
+    // Phase 18.σ — preferred per-metric threshold block.
+    thresholds: TestCoverageThresholdsSchema.optional(),
   })
   .strict();
 
@@ -377,6 +427,69 @@ const SchedulerConfigSchema = z
   })
   .strict();
 
+/**
+ * Phase 18.μ — i18n config schema (strict).
+ *
+ * Strictly validates shape + cross-field invariants that `defineI18n()`
+ * enforces at runtime (defaultLocale ∈ locales, fallback ∈ locales,
+ * domain map required when strategy === "domain"). Doing this at
+ * config load gives users a clean `mandu validate` error instead of
+ * a runtime boot failure.
+ */
+const I18nConfigSchema = z
+  .object({
+    locales: z.array(z.string().min(1)).min(1),
+    defaultLocale: z.string().min(1),
+    fallback: z.string().min(1).optional(),
+    strategy: z.enum(["path-prefix", "domain", "header", "cookie"]),
+    cookieName: z.string().min(1).optional(),
+    domains: z.record(z.string().min(1)).optional(),
+  })
+  .strict()
+  .superRefine((value, ctx) => {
+    const locales = new Set(value.locales);
+    if (locales.size !== value.locales.length) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["locales"],
+        message: "locales must not contain duplicates",
+      });
+    }
+    if (!locales.has(value.defaultLocale)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["defaultLocale"],
+        message: `defaultLocale "${value.defaultLocale}" must be one of locales`,
+      });
+    }
+    if (value.fallback !== undefined && !locales.has(value.fallback)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["fallback"],
+        message: `fallback "${value.fallback}" must be one of locales`,
+      });
+    }
+    if (value.strategy === "domain") {
+      if (!value.domains || Object.keys(value.domains).length === 0) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ["domains"],
+          message: "strategy 'domain' requires a non-empty domains map",
+        });
+      } else {
+        for (const [host, locale] of Object.entries(value.domains)) {
+          if (!locales.has(locale)) {
+            ctx.addIssue({
+              code: z.ZodIssueCode.custom,
+              path: ["domains", host],
+              message: `domains["${host}"] = "${locale}" is not in locales`,
+            });
+          }
+        }
+      }
+    }
+  });
+
 export const ManduConfigSchema = z
   .object({
     adapter: AdapterConfigSchema.optional(),
@@ -423,6 +536,11 @@ export const ManduConfigSchema = z
      * passthrough).
      */
     scheduler: SchedulerConfigSchema.optional(),
+    /**
+     * Phase 18.μ — first-class i18n config. See {@link I18nConfigSchema}.
+     * Optional; omission leaves i18n disabled with zero runtime overhead.
+     */
+    i18n: I18nConfigSchema.optional(),
   })
   .strict();
 

package/src/diagnose/__tests__/checks.test.ts

@@ -0,0 +1,378 @@
+/**
+ * Tests for the Issue #215 extended diagnose checks.
+ *
+ * Every test uses an isolated `mkdtemp` fixture root so we never touch
+ * the real project tree. Checks are pure I/O functions; seeding the
+ * fixture directly (no build pipeline required) keeps these tests fast
+ * and deterministic.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+import {
+  checkManifestFreshness,
+  checkPrerenderPollution,
+  checkCloneElementWarnings,
+  checkDevArtifactsInProd,
+  checkPackageExportGaps,
+} from "../checks";
+import { runExtendedDiagnose, buildReport } from "../run";
+
+async function mkTmpRoot(): Promise<string> {
+  return fs.mkdtemp(path.join(os.tmpdir(), "mandu-diagnose-"));
+}
+
+async function writeFile(rootDir: string, rel: string, content: string): Promise<void> {
+  const abs = path.join(rootDir, rel);
+  await fs.mkdir(path.dirname(abs), { recursive: true });
+  await fs.writeFile(abs, content, "utf-8");
+}
+
+// ──────────────────────────────────────────────────────────────────
+// manifest_freshness
+// ──────────────────────────────────────────────────────────────────
+
+describe("checkManifestFreshness", () => {
+  let rootDir: string;
+  beforeEach(async () => { rootDir = await mkTmpRoot(); });
+  afterEach(async () => { await fs.rm(rootDir, { recursive: true, force: true }); });
+
+  it("returns error when .mandu/manifest.json is missing", async () => {
+    const result = await checkManifestFreshness(rootDir);
+    expect(result.ok).toBe(false);
+    expect(result.rule).toBe("manifest_freshness");
+    expect(result.severity).toBe("error");
+    expect(result.message).toMatch(/missing/);
+    expect(result.suggestion).toMatch(/mandu build/);
+  });
+
+  it("returns error when env=development (dev manifest shipped to prod)", async () => {
+    await writeFile(rootDir, ".mandu/manifest.json", JSON.stringify({
+      version: 1,
+      buildTime: "2026-01-01T00:00:00.000Z",
+      env: "development",
+      bundles: { "page-home": { js: "/x.js", dependencies: [], priority: "immediate" } },
+      shared: { runtime: "", vendor: "" },
+    }));
+    const result = await checkManifestFreshness(rootDir);
+    expect(result.ok).toBe(false);
+    expect(result.severity).toBe("error");
+    expect(result.message).toMatch(/dev-mode/);
+    expect(result.details?.env).toBe("development");
+  });
+
+  it("returns ok for production manifest with populated bundles", async () => {
+    await writeFile(rootDir, ".mandu/manifest.json", JSON.stringify({
+      version: 1, buildTime: "2026-01-01T00:00:00.000Z", env: "production",
+      bundles: { "page-home": { js: "/x.js", dependencies: [], priority: "immediate" } },
+      shared: { runtime: "/r.js", vendor: "/v.js" },
+    }));
+    const result = await checkManifestFreshness(rootDir);
+    expect(result.ok).toBe(true);
+    expect(result.rule).toBe("manifest_freshness");
+  });
+
+  it("returns warning when production but islands present with no bundles", async () => {
+    await writeFile(rootDir, ".mandu/manifest.json", JSON.stringify({
+      version: 1, buildTime: "x", env: "production",
+      bundles: {},
+      islands: { "Foo": { js: "/f.js", route: "/x", priority: "visible" } },
+      shared: { runtime: "", vendor: "" },
+    }));
+    const result = await checkManifestFreshness(rootDir);
+    expect(result.ok).toBe(false);
+    expect(result.severity).toBe("warning");
+    expect(result.message).toMatch(/0 route bundles/);
+  });
+
+  it("returns ok for production with empty bundles AND empty islands (pure-SSR)", async () => {
+    await writeFile(rootDir, ".mandu/manifest.json", JSON.stringify({
+      version: 1, buildTime: "x", env: "production",
+      bundles: {}, shared: { runtime: "", vendor: "" },
+    }));
+    const result = await checkManifestFreshness(rootDir);
+    expect(result.ok).toBe(true);
+  });
+
+  it("returns error on corrupted JSON", async () => {
+    await writeFile(rootDir, ".mandu/manifest.json", "{ not json }");
+    const result = await checkManifestFreshness(rootDir);
+    expect(result.ok).toBe(false);
+    expect(result.severity).toBe("error");
+    expect(result.message).toMatch(/corrupted/);
+  });
+});
+
+// ──────────────────────────────────────────────────────────────────
+// prerender_pollution
+// ──────────────────────────────────────────────────────────────────
+
+describe("checkPrerenderPollution", () => {
+  let rootDir: string;
+  beforeEach(async () => { rootDir = await mkTmpRoot(); });
+  afterEach(async () => { await fs.rm(rootDir, { recursive: true, force: true }); });
+
+  it("returns ok when no prerendered output exists", async () => {
+    const result = await checkPrerenderPollution(rootDir);
+    expect(result.ok).toBe(true);
+  });
+
+  it("returns ok for clean route shapes", async () => {
+    await writeFile(rootDir, ".mandu/prerendered/index.html", "<html></html>");
+    await writeFile(rootDir, ".mandu/prerendered/blog/hello/index.html", "<html></html>");
+    await writeFile(rootDir, ".mandu/prerendered/docs/getting-started/index.html", "<html></html>");
+    const result = await checkPrerenderPollution(rootDir);
+    expect(result.ok).toBe(true);
+    expect(result.details?.scanned).toBe(3);
+  });
+
+  it("flags a literal 'path' placeholder route (#213)", async () => {
+    await writeFile(rootDir, ".mandu/prerendered/path/index.html", "<html></html>");
+    const result = await checkPrerenderPollution(rootDir);
+    expect(result.ok).toBe(false);
+    expect(result.severity).toBe("warning");
+    expect(result.message).toMatch(/placeholder/);
+  });
+
+  it("flags routes containing '...' inside a segment", async () => {
+    // We can't create a directory literally named "..." on Windows
+    // (trailing dots are stripped), so we use a segment that embeds
+    // "..." in the middle — the classifier still catches it.
+    await writeFile(rootDir, ".mandu/prerendered/blog/a...b/index.html", "<html></html>");
+    const result = await checkPrerenderPollution(rootDir);
+    expect(result.ok).toBe(false);
+    expect(result.severity).toBe("warning");
+  });
+
+  it("flags uppercase-starting segments as suspicious", async () => {
+    await writeFile(rootDir, ".mandu/prerendered/Foo/index.html", "<html></html>");
+    const result = await checkPrerenderPollution(rootDir);
+    expect(result.ok).toBe(false);
+  });
+
+  it("scans legacy .mandu/static/ location too", async () => {
+    await writeFile(rootDir, ".mandu/static/path/index.html", "<html></html>");
+    const result = await checkPrerenderPollution(rootDir);
+    expect(result.ok).toBe(false);
+    expect(result.severity).toBe("warning");
+  });
+});
+
+// ──────────────────────────────────────────────────────────────────
+// cloneelement_warnings
+// ──────────────────────────────────────────────────────────────────
+
+describe("checkCloneElementWarnings", () => {
+  let rootDir: string;
+  beforeEach(async () => { rootDir = await mkTmpRoot(); });
+  afterEach(async () => { await fs.rm(rootDir, { recursive: true, force: true }); });
+
+  it("returns ok when no build log exists", async () => {
+    const result = await checkCloneElementWarnings(rootDir);
+    expect(result.ok).toBe(true);
+  });
+
+  it("returns ok when log has no key warnings", async () => {
+    await writeFile(rootDir, ".mandu/build.log", "Build succeeded\nNo warnings\n");
+    const result = await checkCloneElementWarnings(rootDir);
+    expect(result.ok).toBe(true);
+  });
+
+  it("returns info severity for 1-10 warnings", async () => {
+    const warn = 'Warning: Each child in a list should have a unique "key" prop.\n';
+    await writeFile(rootDir, ".mandu/build.log", warn.repeat(5));
+    const result = await checkCloneElementWarnings(rootDir);
+    expect(result.ok).toBe(false);
+    expect(result.severity).toBe("info");
+    expect(result.details?.count).toBe(5);
+  });
+
+  it("returns warning severity for >10 warnings (#212)", async () => {
+    const warn = 'Warning: Each child in a list should have a unique "key" prop.\n';
+    await writeFile(rootDir, ".mandu/build.log", warn.repeat(25));
+    const result = await checkCloneElementWarnings(rootDir);
+    expect(result.ok).toBe(false);
+    expect(result.severity).toBe("warning");
+    expect(result.details?.count).toBe(25);
+    expect(result.suggestion).toMatch(/0\.32\.0/);
+  });
+
+  it("falls back to dev-server.stderr.log when build.log is absent", async () => {
+    const warn = 'Each child in a list should have a unique "key" prop\n';
+    await writeFile(rootDir, ".mandu/dev-server.stderr.log", warn.repeat(12));
+    const result = await checkCloneElementWarnings(rootDir);
+    expect(result.ok).toBe(false);
+    expect(result.details?.logPath).toMatch(/dev-server\.stderr\.log$/);
+  });
+});
+
+// ──────────────────────────────────────────────────────────────────
+// dev_artifacts_in_prod
+// ──────────────────────────────────────────────────────────────────
+
+describe("checkDevArtifactsInProd", () => {
+  let rootDir: string;
+  beforeEach(async () => { rootDir = await mkTmpRoot(); });
+  afterEach(async () => { await fs.rm(rootDir, { recursive: true, force: true }); });
+
+  it("returns ok when no _devtools.js artifact exists", async () => {
+    const result = await checkDevArtifactsInProd(rootDir);
+    expect(result.ok).toBe(true);
+  });
+
+  it("flags _devtools.js in production manifest", async () => {
+    await writeFile(rootDir, ".mandu/manifest.json", JSON.stringify({
+      version: 1, buildTime: "x", env: "production",
+      bundles: {}, shared: { runtime: "", vendor: "" },
+    }));
+    await writeFile(rootDir, ".mandu/client/_devtools.js", "console.log('devtools');");
+    const result = await checkDevArtifactsInProd(rootDir);
+    expect(result.ok).toBe(false);
+    expect(result.severity).toBe("error");
+    expect(result.message).toMatch(/production/);
+  });
+
+  it("flags _devtools.js when mandu.config sets dev.devtools: false", async () => {
+    await writeFile(rootDir, "mandu.config.ts", `export default { dev: { devtools: false } };`);
+    await writeFile(rootDir, ".mandu/client/_devtools.js", "x");
+    const result = await checkDevArtifactsInProd(rootDir);
+    expect(result.ok).toBe(false);
+    expect(result.severity).toBe("error");
+    expect(result.message).toMatch(/dev\.devtools: false/);
+  });
+
+  it("flags prerendered HTML with a <script src=\".../devtools.js\"> reference", async () => {
+    await writeFile(rootDir, ".mandu/prerendered/index.html",
+      '<html><head><script src="/.mandu/client/_devtools.js"></script></head></html>'
+    );
+    const result = await checkDevArtifactsInProd(rootDir);
+    expect(result.ok).toBe(false);
+    expect(result.message).toMatch(/prerendered HTML/);
+  });
+
+  it("stays ok in dev builds (env=development, devtools expected)", async () => {
+    await writeFile(rootDir, ".mandu/manifest.json", JSON.stringify({
+      version: 1, buildTime: "x", env: "development",
+      bundles: {}, shared: { runtime: "", vendor: "" },
+    }));
+    await writeFile(rootDir, ".mandu/client/_devtools.js", "x");
+    const result = await checkDevArtifactsInProd(rootDir);
+    expect(result.ok).toBe(true);
+  });
+});
+
+// ──────────────────────────────────────────────────────────────────
+// package_export_gaps
+// ──────────────────────────────────────────────────────────────────
+
+describe("checkPackageExportGaps", () => {
+  let rootDir: string;
+  beforeEach(async () => { rootDir = await mkTmpRoot(); });
+  afterEach(async () => { await fs.rm(rootDir, { recursive: true, force: true }); });
+
+  async function seedCore(exports: Record<string, unknown>): Promise<void> {
+    await writeFile(rootDir, "node_modules/@mandujs/core/package.json", JSON.stringify({
+      name: "@mandujs/core", version: "0.32.0", exports,
+    }));
+  }
+
+  it("skips gracefully when @mandujs/core is not installed", async () => {
+    await writeFile(rootDir, "src/foo.ts", `import { x } from "@mandujs/core/unknown";`);
+    const result = await checkPackageExportGaps(rootDir);
+    expect(result.ok).toBe(true);
+    expect(result.details?.skipped).toBe(true);
+  });
+
+  it("returns ok when all user imports match the exports map", async () => {
+    await seedCore({ ".": "./src/index.ts", "./client": "./src/client/index.ts" });
+    await writeFile(rootDir, "src/a.ts", `import { foo } from "@mandujs/core";`);
+    await writeFile(rootDir, "src/b.ts", `import { island } from "@mandujs/core/client";`);
+    const result = await checkPackageExportGaps(rootDir);
+    expect(result.ok).toBe(true);
+    expect(result.details?.uniqueSubpaths).toBe(2);
+  });
+
+  it("flags an import missing from the exports map", async () => {
+    await seedCore({ ".": "./src/index.ts", "./client": "./src/client/index.ts" });
+    await writeFile(rootDir, "src/bad.ts", `import { x } from "@mandujs/core/nonexistent";`);
+    const result = await checkPackageExportGaps(rootDir);
+    expect(result.ok).toBe(false);
+    expect(result.severity).toBe("error");
+    expect(result.message).toMatch(/nonexistent/);
+  });
+
+  it("honors ./* wildcard export as a catch-all", async () => {
+    await seedCore({ ".": "./src/index.ts", "./*": "./src/*" });
+    await writeFile(rootDir, "src/a.ts", `import { x } from "@mandujs/core/anything";`);
+    const result = await checkPackageExportGaps(rootDir);
+    expect(result.ok).toBe(true);
+  });
+
+  it("recognizes require() specifiers in addition to import", async () => {
+    await seedCore({ ".": "./src/index.ts" });
+    await writeFile(rootDir, "src/a.cjs", `const { x } = require("@mandujs/core/ghost");`);
+    const result = await checkPackageExportGaps(rootDir);
+    expect(result.ok).toBe(false);
+    expect(result.severity).toBe("error");
+  });
+});
+
+// ──────────────────────────────────────────────────────────────────
+// aggregator
+// ──────────────────────────────────────────────────────────────────
+
+describe("runExtendedDiagnose", () => {
+  let rootDir: string;
+  beforeEach(async () => { rootDir = await mkTmpRoot(); });
+  afterEach(async () => { await fs.rm(rootDir, { recursive: true, force: true }); });
+
+  it("runs all 5 extended checks and returns a structured report", async () => {
+    const report = await runExtendedDiagnose(rootDir);
+    expect(report.summary.total).toBe(5);
+    // manifest is missing → at least one error
+    expect(report.healthy).toBe(false);
+    expect(report.errorCount).toBeGreaterThanOrEqual(1);
+    const rules = report.checks.map((c) => c.rule);
+    expect(rules).toContain("manifest_freshness");
+    expect(rules).toContain("prerender_pollution");
+    expect(rules).toContain("cloneelement_warnings");
+    expect(rules).toContain("dev_artifacts_in_prod");
+    expect(rules).toContain("package_export_gaps");
+  });
+
+  it("returns healthy=true when all checks pass (production manifest, no gaps)", async () => {
+    await writeFile(rootDir, ".mandu/manifest.json", JSON.stringify({
+      version: 1, buildTime: "x", env: "production",
+      bundles: { h: { js: "/h.js", dependencies: [], priority: "immediate" } },
+      shared: { runtime: "/r.js", vendor: "/v.js" },
+    }));
+    const report = await runExtendedDiagnose(rootDir);
+    expect(report.healthy).toBe(true);
+    expect(report.errorCount).toBe(0);
+  });
+});
+
+describe("buildReport", () => {
+  it("computes healthy=true when no error-severity check fires", () => {
+    const report = buildReport([
+      { ok: true, rule: "a", message: "ok" },
+      { ok: false, rule: "b", severity: "warning", message: "warn" },
+      { ok: false, rule: "c", severity: "info", message: "info" },
+    ]);
+    expect(report.healthy).toBe(true);
+    expect(report.errorCount).toBe(0);
+    expect(report.warningCount).toBe(1);
+    expect(report.summary.failed).toBe(2);
+  });
+
+  it("computes healthy=false when at least one error fires", () => {
+    const report = buildReport([
+      { ok: false, rule: "a", severity: "error", message: "fail" },
+      { ok: true, rule: "b", message: "ok" },
+    ]);
+    expect(report.healthy).toBe(false);
+    expect(report.errorCount).toBe(1);
+  });
+});