@mandujs/core 0.54.12 → 0.54.14

package/src/bundler/build.ts

@@ -100,16 +100,16 @@ function shouldSplitChunks(options: BundlerOptions): boolean {
   return options.splitting ?? (resolveBundlerMode(options) === "production");
 }
 
-function nodeEnvDefine(options: BundlerOptions): string {
-  return JSON.stringify(resolveBundlerMode(options));
-}
-
-const FAST_REFRESH_SELF_ALIAS_PATTERN =
-  /^var\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*=\s*\1;\s*\r?\n(?=\$RefreshReg\$\(\1,\s*["'][^"']*:default["']\);)/gm;
-
-function resolveClientOutDir(rootDir: string, outDir?: string): string {
-  const defaultOutDir = path.join(rootDir, ".mandu/client");
-  if (!outDir) return defaultOutDir;
+function nodeEnvDefine(options: BundlerOptions): string {
+  return JSON.stringify(resolveBundlerMode(options));
+}
+
+const FAST_REFRESH_SELF_ALIAS_PATTERN =
+  /^var\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*=\s*\1;\s*\r?\n(?=\$RefreshReg\$\(\1,\s*["'][^"']*:default["']\);)/gm;
+
+function resolveClientOutDir(rootDir: string, outDir?: string): string {
+  const defaultOutDir = path.join(rootDir, ".mandu/client");
+  if (!outDir) return defaultOutDir;
 
   const resolvedOutDir = path.isAbsolute(outDir) ? outDir : path.resolve(rootDir, outDir);
   if (path.normalize(resolvedOutDir) === path.normalize(path.join(rootDir, ".mandu"))) {
@@ -296,9 +296,9 @@ export async function collectCompilerLintTargets(
 }
 
 /** Build a single per-island bundle. */
-async function buildPerIslandBundle(
-  entry: IslandFileEntry, outDir: string, options: BundlerOptions
-): Promise<{ name: string; js: string; route: string; priority: IslandFileEntry["priority"] }> {
+async function buildPerIslandBundle(
+  entry: IslandFileEntry, outDir: string, options: BundlerOptions
+): Promise<{ name: string; js: string; route: string; priority: IslandFileEntry["priority"] }> {
   const entryPath = path.join(outDir, `_entry_island_${entry.name}.js`);
   const outputName = `${entry.name}.island.js`;
   // Phase 7.1 B-1/B-4: wire Bun's native React Fast Refresh transform +
@@ -320,13 +320,13 @@ async function buildPerIslandBundle(
       define: { "process.env.NODE_ENV": nodeEnvDefine(options), ...options.define },
     });
     await fs.unlink(entryPath).catch(() => {});
-    if (!result.success) {
-      const grouped = result.logs.map((l) => `  - ${l.message}`).join("\n");
-      throw new Error(`Island build failed for '${entry.name}' (source: ${entry.filePath}):\n${grouped}\n  Hint: Check the import paths and TypeScript types in this island file.`);
-    }
-    await sanitizeGeneratedClientBundle(path.join(outDir, outputName), isDev);
-    return { name: entry.name, js: `/.mandu/client/${outputName}`, route: entry.routeId, priority: entry.priority };
-  } catch (error) {
+    if (!result.success) {
+      const grouped = result.logs.map((l) => `  - ${l.message}`).join("\n");
+      throw new Error(`Island build failed for '${entry.name}' (source: ${entry.filePath}):\n${grouped}\n  Hint: Check the import paths and TypeScript types in this island file.`);
+    }
+    await sanitizeGeneratedClientBundle(path.join(outDir, outputName), isDev);
+    return { name: entry.name, js: `/.mandu/client/${outputName}`, route: entry.routeId, priority: entry.priority };
+  } catch (error) {
     await fs.unlink(entryPath).catch(() => {});
     throw error;
   }
@@ -370,11 +370,11 @@ async function buildPartialBundle(
       const grouped = result.logs.map((l) => `  - ${l.message}`).join("\n");
       throw new Error(`Partial build failed for '${entry.name}' (source: ${entry.filePath}):\n${grouped}\n  Hint: Export a Mandu partial from this file with \`partial({ component })\`.`);
     }
-
-    const outputPath = path.join(outDir, outputName);
-    const sanitizedContent = await sanitizeGeneratedClientBundle(outputPath, isDev);
-    const outputFile = Bun.file(outputPath);
-    const gzipped = Bun.gzipSync(Buffer.from(sanitizedContent));
+
+    const outputPath = path.join(outDir, outputName);
+    const sanitizedContent = await sanitizeGeneratedClientBundle(outputPath, isDev);
+    const outputFile = Bun.file(outputPath);
+    const gzipped = Bun.gzipSync(Buffer.from(sanitizedContent));
 
     return {
       name: entry.name,
@@ -1443,18 +1443,61 @@ async function buildRouterRuntime(
  * - Runtime이 dynamic import로 로드
  * - 등록/초기화 코드 없음
  */
-function generateIslandEntry(routeId: string, clientModulePath: string): string {
-  // Windows 경로의 백슬래시를 슬래시로 변환 (JS escape 문제 방지)
-  const normalizedPath = clientModulePath.replace(/\\/g, "/");
-  return `
-/**
- * Mandu Island: ${routeId} (Generated)
- * Pure export - no side effects
- */
-import island from "${normalizedPath}";
-export default island;
-`;
-}
+function generateIslandEntry(routeId: string, clientModulePath: string, exportName?: string): string {
+  // Windows 경로의 백슬래시를 슬래시로 변환 (JS escape 문제 방지)
+  const normalizedPath = clientModulePath.replace(/\\/g, "/");
+  const normalizedExportName = exportName && exportName !== "default" ? exportName : undefined;
+  const candidates = [
+    normalizedExportName,
+    inferClientExportNameFromPath(clientModulePath),
+    inferClientExportNameFromRouteId(routeId),
+  ].filter((candidate, index, values): candidate is string =>
+    !!candidate && values.indexOf(candidate) === index
+  );
+  const importSpecifier = JSON.stringify(normalizedPath);
+  const routeLabel = JSON.stringify(routeId);
+  const commentRouteId = routeId.replace(/\*\//g, "* /");
+  return `
+/**
+ * Mandu Island: ${commentRouteId} (Generated)
+ * Pure export - no side effects
+ */
+import * as islandModule from ${importSpecifier};
+
+const candidateExportNames = ${JSON.stringify(candidates)};
+
+function resolveIslandExport(mod) {
+  if (mod.default) return mod.default;
+  for (const name of candidateExportNames) {
+    if (mod[name]) return mod[name];
+  }
+  const runtimeExports = Object.keys(mod).filter((name) => name !== "__esModule");
+  if (runtimeExports.length === 1) return mod[runtimeExports[0]];
+  throw new Error(
+    "[Mandu Island] " + ${routeLabel} + " must export a default component" +
+      (candidateExportNames.length > 0 ? " or one of: " + candidateExportNames.join(", ") : "")
+  );
+}
+
+const island = resolveIslandExport(islandModule);
+export default island;
+`;
+}
+
+function inferClientExportNameFromPath(clientModulePath: string): string | null {
+  const basename = path.basename(clientModulePath).replace(/\.[cm]?[jt]sx?$/, "");
+  const withoutClientSuffix = basename.replace(/\.(client|island)$/, "");
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(withoutClientSuffix) ? withoutClientSuffix : null;
+}
+
+function inferClientExportNameFromRouteId(routeId: string): string | null {
+  const pascal = routeId
+    .split(/[^A-Za-z0-9]+/)
+    .filter(Boolean)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join("");
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(pascal) ? pascal : null;
+}
 
 function generatePartialEntry(partialId: string, partialModulePath: string): string {
   const normalizedPath = partialModulePath.replace(/\\/g, "/");
@@ -1886,32 +1929,41 @@ async function buildVendorShims(
   };
 }
 
-function vendorShimFailureHint(shimName: string): string {
-  if (shimName.includes("react-refresh")) {
-    return "Hint: install the optional dev peer dependency with `bun add -d react-refresh`.";
-  }
-  return "Hint: check the import paths and ensure the vendor package is installed.";
-}
-
-/**
- * 단일 Island 번들 빌드
- */
+function vendorShimFailureHint(shimName: string): string {
+  if (shimName.includes("react-refresh")) {
+    return "Hint: install the optional dev peer dependency with `bun add -d react-refresh`.";
+  }
+  return "Hint: check the import paths and ensure the vendor package is installed.";
+}
+
+function routeIdToAssetStem(routeId: string): string {
+  const safe = routeId.replace(/[<>:"/\\|?*\x00-\x1F]/g, (ch) =>
+    `_${ch.codePointAt(0)!.toString(16)}_`
+  );
+  return safe.replace(/[. ]+$/g, "") || "route";
+}
+
+/**
+ * 단일 Island 번들 빌드
+ */
 async function buildIsland(
   route: RouteSpec,
   rootDir: string,
   outDir: string,
   options: BundlerOptions
-): Promise<BundleOutput> {
-  const clientModulePath = path.join(rootDir, route.clientModule!);
-  const entryPath = path.join(outDir, `_entry_${route.id}.js`);
-  const outputName = `${route.id}.island.js`;
+): Promise<BundleOutput> {
+  const clientModulePath = path.join(rootDir, route.clientModule!);
+  const assetStem = routeIdToAssetStem(route.id);
+  const entryStem = `_entry_${assetStem}`;
+  const entryPath = path.join(outDir, `${entryStem}.js`);
+  const outputName = `${assetStem}.island.js`;
 
   // Phase 7.1 B-1/B-4: wire native Fast Refresh transform + Mandu's
   // boundary injection plugin. Dev-only; prod bundles remain clean.
   const isDev = isDevelopmentBuild(options);
   try {
     // 엔트리 래퍼 생성
-    await Bun.write(entryPath, generateIslandEntry(route.id, clientModulePath));
+    await Bun.write(entryPath, generateIslandEntry(route.id, clientModulePath, route.clientExportName));
 
     // 빌드
     // splitting 옵션: true면 공통 코드를 별도 청크로 추출
@@ -1945,11 +1997,11 @@ async function buildIsland(
     let actualOutputPath: string;
     let actualOutputName: string;
 
-    if (options.splitting && result.outputs.length > 0) {
-      // splitting 모드: 결과에서 엔트리 파일 찾기
-      const entryOutput = result.outputs.find(
-        (o) => o.kind === "entry-point" || o.path.includes(route.id)
-      );
+    if (options.splitting && result.outputs.length > 0) {
+      // splitting 모드: 결과에서 엔트리 파일 찾기
+      const entryOutput = result.outputs.find(
+        (o) => o.kind === "entry-point" || o.path.includes(entryStem) || o.path.includes(assetStem)
+      );
       if (entryOutput) {
         actualOutputPath = entryOutput.path;
         actualOutputName = path.basename(entryOutput.path);
@@ -1963,9 +2015,9 @@ async function buildIsland(
       actualOutputName = outputName;
     }
 
-    const outputFile = Bun.file(actualOutputPath);
-    const content = await sanitizeGeneratedClientBundle(actualOutputPath, isDev);
-    const gzipped = Bun.gzipSync(Buffer.from(content));
+    const outputFile = Bun.file(actualOutputPath);
+    const content = await sanitizeGeneratedClientBundle(actualOutputPath, isDev);
+    const gzipped = Bun.gzipSync(Buffer.from(content));
 
     return {
       routeId: route.id,
@@ -1977,53 +2029,53 @@ async function buildIsland(
   } catch (error) {
     await fs.unlink(entryPath).catch(() => {});
     throw error;
-  }
-}
-
-async function sanitizeGeneratedClientBundle(outputPath: string, isDev: boolean): Promise<string> {
-  const source = await Bun.file(outputPath).text();
-  if (!isDev) return source;
-
-  const sanitized = removeFastRefreshSelfAliases(source);
-  if (sanitized === source) return source;
-
-  await Bun.write(outputPath, sanitized);
-  await validateGeneratedClientBundle(outputPath);
-  return sanitized;
-}
-
-function removeFastRefreshSelfAliases(source: string): string {
-  return source.replace(FAST_REFRESH_SELF_ALIAS_PATTERN, (line, localName: string, offset: number) => {
-    const priorSource = source.slice(0, offset);
-    const declarationPattern = new RegExp(`(?:const|let|class|function)\\s+${escapeRegExp(localName)}\\b`);
-    return declarationPattern.test(priorSource) ? "" : line;
-  });
-}
-
-async function validateGeneratedClientBundle(outputPath: string): Promise<void> {
-  const tempOutDir = await fs.mkdtemp(path.join(path.dirname(outputPath), ".validate-"));
-  try {
-    const result = await safeBuild({
-      entrypoints: [outputPath],
-      outdir: tempOutDir,
-      target: "browser",
-      external: ["react", "react-dom", "react-dom/client", "react/jsx-runtime", "react/jsx-dev-runtime"],
-    });
-    if (result.success) return;
-
-    const grouped = result.logs.map((log) => `  - ${log.message}`).join("\n");
-    throw new Error(`Generated client bundle failed syntax validation (source: ${outputPath}):\n${grouped}`);
-  } finally {
-    await fs.rm(tempOutDir, { recursive: true, force: true }).catch(() => {});
-  }
-}
-
-function escapeRegExp(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-/**
- * 번들 매니페스트 생성
+  }
+}
+
+async function sanitizeGeneratedClientBundle(outputPath: string, isDev: boolean): Promise<string> {
+  const source = await Bun.file(outputPath).text();
+  if (!isDev) return source;
+
+  const sanitized = removeFastRefreshSelfAliases(source);
+  if (sanitized === source) return source;
+
+  await Bun.write(outputPath, sanitized);
+  await validateGeneratedClientBundle(outputPath);
+  return sanitized;
+}
+
+function removeFastRefreshSelfAliases(source: string): string {
+  return source.replace(FAST_REFRESH_SELF_ALIAS_PATTERN, (line, localName: string, offset: number) => {
+    const priorSource = source.slice(0, offset);
+    const declarationPattern = new RegExp(`(?:const|let|class|function)\\s+${escapeRegExp(localName)}\\b`);
+    return declarationPattern.test(priorSource) ? "" : line;
+  });
+}
+
+async function validateGeneratedClientBundle(outputPath: string): Promise<void> {
+  const tempOutDir = await fs.mkdtemp(path.join(path.dirname(outputPath), ".validate-"));
+  try {
+    const result = await safeBuild({
+      entrypoints: [outputPath],
+      outdir: tempOutDir,
+      target: "browser",
+      external: ["react", "react-dom", "react-dom/client", "react/jsx-runtime", "react/jsx-dev-runtime"],
+    });
+    if (result.success) return;
+
+    const grouped = result.logs.map((log) => `  - ${log.message}`).join("\n");
+    throw new Error(`Generated client bundle failed syntax validation (source: ${outputPath}):\n${grouped}`);
+  } finally {
+    await fs.rm(tempOutDir, { recursive: true, force: true }).catch(() => {});
+  }
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/**
+ * 번들 매니페스트 생성
  */
 function createBundleManifest(
   outputs: BundleOutput[],
@@ -2559,25 +2611,24 @@ export async function buildClientBundles(
       try {
         return { ok: true as const, result: await buildIsland(route, rootDir, outDir, options) };
       } catch (error) {
-        return { ok: false as const, route, error: String(error) };
+        return { ok: false as const, route, error: formatBundlerException(error) };
       }
     }),
   );
   for (const r of fullIslandResults) {
-    if (r.ok) {
-      outputs.push(r.result);
-    } else {
-      const errorStr = r.error;
-      if (errorStr.includes("AggregateError") || errorStr.includes("Could not resolve")) {
-        const clientModule = r.route.clientModule || "";
-        errors.push(
-          `[${r.route.id}] ${errorStr}\n` +
-          `  💡 Hint: If your island imports from "@mandujs/core", change it to "@mandujs/core/client".\n` +
-          `     Client islands cannot use server-side modules. File: ${clientModule}`,
-        );
-      } else {
-        errors.push(`[${r.route.id}] ${errorStr}`);
-      }
+    if (r.ok) {
+      outputs.push(r.result);
+    } else {
+      const errorStr = r.error;
+      if (errorStr.includes("AggregateError") || errorStr.includes("Could not resolve")) {
+        const clientModule = r.route.clientModule || "";
+        errors.push(
+          `[${r.route.id}] ${errorStr}\n` +
+          `  Hint: Check import paths and browser-compatible exports for this island. File: ${clientModule}`,
+        );
+      } else {
+        errors.push(`[${r.route.id}] ${errorStr}`);
+      }
     }
   }
 
@@ -2678,6 +2729,12 @@ export function printBundleStats(result: BundleResult): void {
   const partialCount = Object.keys(result.manifest.partials ?? {}).length;
   if (result.outputs.length === 0 && partialCount === 0) {
     console.log("No islands or partials to bundle (hydration: none or no client entry)");
+    if (result.errors.length > 0) {
+      console.log("\n⚠️ Errors:");
+      for (const error of result.errors) {
+        console.log(`  ${error}`);
+      }
+    }
     return;
   }
 
@@ -2707,3 +2764,17 @@ export function printBundleStats(result: BundleResult): void {
 
   console.log("");
 }
+
+function formatBundlerException(error: unknown): string {
+  if (error instanceof AggregateError) {
+    const parts = [String(error)];
+    for (const nested of error.errors) {
+      parts.push(`  - ${formatBundlerException(nested).replace(/\n/g, "\n    ")}`);
+    }
+    return parts.join("\n");
+  }
+  if (error instanceof Error) {
+    return error.stack ?? error.message;
+  }
+  return String(error);
+}

package/src/bundler/css.ts

@@ -18,38 +18,38 @@ import fs from "fs/promises";
 import { watch as fsWatch, type FSWatcher } from "fs";
 import { withPerf } from "../perf";
 
-/**
- * Tailwind CLI 실행 명령어를 결정한다.
- * Windows에서 Bun.spawn은 PATH 기반 명령어 해석이 불안정하므로 (#152)
- * `bun run mandu` 환경에서는 process.execPath (bun 절대 경로)를 사용한다.
- * Standalone Mandu binary에서는 process.execPath가 mandu.exe를 가리키므로
- * `mandu x @tailwindcss/cli`로 오해석된다. 이 경우 PATH에서 Bun을 찾는다.
- */
-function isBunExecutable(executablePath: string | undefined): boolean {
-  if (!executablePath) return false;
-  const base = path.basename(executablePath).toLowerCase();
-  return base === "bun" || base === "bun.exe";
-}
-
-type WhichExecutable = (command: string) => string | null | undefined;
-
-function resolveBunExecutable(
-  execPath = process.execPath,
-  which: WhichExecutable = (command) => Bun.which(command),
-): string {
-  if (isBunExecutable(execPath)) return execPath;
-  const fromPath = which("bun");
-  if (fromPath) return fromPath;
-  return process.platform === "win32" ? "bun.exe" : "bun";
-}
-
-function getTailwindCommand(
-  args: string[],
-  execPath = process.execPath,
-  which?: WhichExecutable,
-): string[] {
-  return [resolveBunExecutable(execPath, which), "x", ...args];
-}
+/**
+ * Tailwind CLI 실행 명령어를 결정한다.
+ * Windows에서 Bun.spawn은 PATH 기반 명령어 해석이 불안정하므로 (#152)
+ * `bun run mandu` 환경에서는 process.execPath (bun 절대 경로)를 사용한다.
+ * Standalone Mandu binary에서는 process.execPath가 mandu.exe를 가리키므로
+ * `mandu x @tailwindcss/cli`로 오해석된다. 이 경우 PATH에서 Bun을 찾는다.
+ */
+function isBunExecutable(executablePath: string | undefined): boolean {
+  if (!executablePath) return false;
+  const base = path.basename(executablePath).toLowerCase();
+  return base === "bun" || base === "bun.exe";
+}
+
+type WhichExecutable = (command: string) => string | null | undefined;
+
+function resolveBunExecutable(
+  execPath = process.execPath,
+  which: WhichExecutable = (command) => Bun.which(command),
+): string {
+  if (isBunExecutable(execPath)) return execPath;
+  const fromPath = which("bun");
+  if (fromPath) return fromPath;
+  return process.platform === "win32" ? "bun.exe" : "bun";
+}
+
+function getTailwindCommand(
+  args: string[],
+  execPath = process.execPath,
+  which?: WhichExecutable,
+): string[] {
+  return [resolveBunExecutable(execPath, which), "x", ...args];
+}
 
 // ========== Types ==========
 
@@ -344,13 +344,13 @@ export function getCSSServerPath(): string {
 /**
  * CSS 링크 태그 생성
  */
-export function generateCSSLinkTag(isDev: boolean = false): string {
-  const cacheBust = isDev ? `?t=${Date.now()}` : "";
-  return `<link rel="stylesheet" href="${SERVER_CSS_PATH}${cacheBust}">`;
-}
-
-export const __private = {
-  getTailwindCommand,
-  isBunExecutable,
-  resolveBunExecutable,
-};
+export function generateCSSLinkTag(isDev: boolean = false): string {
+  const cacheBust = isDev ? `?t=${Date.now()}` : "";
+  return `<link rel="stylesheet" href="${SERVER_CSS_PATH}${cacheBust}">`;
+}
+
+export const __private = {
+  getTailwindCommand,
+  isBunExecutable,
+  resolveBunExecutable,
+};

package/src/bundler/manifest-schema.ts

@@ -28,8 +28,8 @@
  *
  * URL safety model (applies to `shared.runtime`, `shared.vendor`,
  * `shared.router`, `shared.fastRefresh.glue`, `shared.fastRefresh.runtime`,
- * `bundles[].js`, `bundles[].css`, `islands[].js`, `partials[].js`,
- * `importMap.imports[*]`):
+ * `bundles[].js`, `bundles[].css`, `islands[].js`, `partials[].js`,
+ * `importMap.imports[*]`):
  *
  *   ALLOW:  absolute paths rooted at `/.mandu/client/` ending in `.js` or `.css`.
  *           The bundler itself only ever emits this shape.
@@ -162,20 +162,20 @@ const BundleEntrySchema = z.object({
   priority: PrioritySchema,
 });
 
-const IslandEntrySchema = z.object({
-  js: safeManduUrl("islands[].js"),
-  route: z.string().min(1),
-  priority: PrioritySchema,
-});
-
-const PartialEntrySchema = z.object({
-  js: safeManduUrl("partials[].js"),
-  priority: PrioritySchema,
-});
-
-const FastRefreshSchema = z.object({
-  runtime: safeManduUrl("shared.fastRefresh.runtime"),
-  glue: safeManduUrl("shared.fastRefresh.glue"),
+const IslandEntrySchema = z.object({
+  js: safeManduUrl("islands[].js"),
+  route: z.string().min(1),
+  priority: PrioritySchema,
+});
+
+const PartialEntrySchema = z.object({
+  js: safeManduUrl("partials[].js"),
+  priority: PrioritySchema,
+});
+
+const FastRefreshSchema = z.object({
+  runtime: safeManduUrl("shared.fastRefresh.runtime"),
+  glue: safeManduUrl("shared.fastRefresh.glue"),
 });
 
 const SharedSchema = z.object({
@@ -225,11 +225,11 @@ export const BundleManifestSchema = z
   .object({
     version: z.number().int().min(1),
     buildTime: z.string().min(1),
-    env: z.enum(["development", "production"]),
-    bundles: z.record(z.string(), BundleEntrySchema),
-    islands: z.record(z.string(), IslandEntrySchema).optional(),
-    partials: z.record(z.string(), PartialEntrySchema).optional(),
-    shared: SharedSchema,
+    env: z.enum(["development", "production"]),
+    bundles: z.record(z.string(), BundleEntrySchema),
+    islands: z.record(z.string(), IslandEntrySchema).optional(),
+    partials: z.record(z.string(), PartialEntrySchema).optional(),
+    shared: SharedSchema,
     importMap: ImportMapSchema.optional(),
   })
   .strict();

package/src/bundler/plugins/__tests__/block-generated-imports.test.ts

@@ -80,19 +80,19 @@ describe("defaultAllowImporter", () => {
 });
 
 describe("DEFAULT_BLOCK_FILTER", () => {
-  test("matches __generated__ specifiers", () => {
-    expect("./__generated__/foo").toMatch(DEFAULT_BLOCK_FILTER);
-    expect("../../src/__generated__/routes").toMatch(DEFAULT_BLOCK_FILTER);
-  });
-  test("matches direct .mandu/generated relative specifiers", () => {
-    expect("../.mandu/generated/routes").toMatch(DEFAULT_BLOCK_FILTER);
-    expect("../../../.mandu/generated/server/repos/party.repo").toMatch(DEFAULT_BLOCK_FILTER);
-  });
-  test("does NOT match look-alikes without double underscores", () => {
-    expect("./generated/foo".match(DEFAULT_BLOCK_FILTER)).toBeNull();
-    expect("./src/generate/foo".match(DEFAULT_BLOCK_FILTER)).toBeNull();
-  });
-});
+  test("matches __generated__ specifiers", () => {
+    expect("./__generated__/foo").toMatch(DEFAULT_BLOCK_FILTER);
+    expect("../../src/__generated__/routes").toMatch(DEFAULT_BLOCK_FILTER);
+  });
+  test("matches direct .mandu/generated relative specifiers", () => {
+    expect("../.mandu/generated/routes").toMatch(DEFAULT_BLOCK_FILTER);
+    expect("../../../.mandu/generated/server/repos/party.repo").toMatch(DEFAULT_BLOCK_FILTER);
+  });
+  test("does NOT match look-alikes without double underscores", () => {
+    expect("./generated/foo".match(DEFAULT_BLOCK_FILTER)).toBeNull();
+    expect("./src/generate/foo".match(DEFAULT_BLOCK_FILTER)).toBeNull();
+  });
+});
 
 describe("defaultBundlerPlugins", () => {
   test("installs block-generated-imports by default", () => {

package/src/bundler/plugins/block-generated-imports.ts

@@ -1,5 +1,5 @@
 /**
- * Bun bundler plugin — hard-fail on direct generated-artifact imports.
+ * Bun bundler plugin — hard-fail on direct generated-artifact imports.
  *
  * Background
  * ──────────
@@ -8,15 +8,15 @@
  * but it only runs when the user (or CI) invokes `mandu guard check`.
  * Autonomous coding agents routinely bypass that step. This plugin closes
  * the gap at the bundler level: every `mandu dev` / `mandu build` pass
- * installs it by default, and any import whose specifier targets
- * `__generated__` or `.mandu/generated` fails the build with a structured,
- * actionable error.
+ * installs it by default, and any import whose specifier targets
+ * `__generated__` or `.mandu/generated` fails the build with a structured,
+ * actionable error.
  *
  * Design
  * ──────
- * - `onResolve({ filter: DEFAULT_BLOCK_FILTER })` — Bun hands us every
- *   import whose *specifier* matches the regex, along with the importer's
- *   path (`args.importer`). We never return a result; we always throw.
+ * - `onResolve({ filter: DEFAULT_BLOCK_FILTER })` — Bun hands us every
+ *   import whose *specifier* matches the regex, along with the importer's
+ *   path (`args.importer`). We never return a result; we always throw.
  * - The error is `ForbiddenGeneratedImportError`, a named subclass of
  *   `Error`. Tests can `instanceof`-check; Bun surfaces `error.message` in
  *   its `result.logs` output for CLI display.
@@ -91,8 +91,8 @@ export interface BlockGeneratedImportsOptions {
   allowImporter?: (importerPath: string) => boolean;
   /**
    * Custom filter regex applied to the import specifier. Defaults to
-   * generated-artifact paths. Mandu ships a single default — exposing this
-   * for test harnesses that want to narrow or broaden the filter.
+   * generated-artifact paths. Mandu ships a single default — exposing this
+   * for test harnesses that want to narrow or broaden the filter.
    */
   filter?: RegExp;
 }
@@ -115,7 +115,7 @@ export function defaultAllowImporter(importerPath: string): boolean {
 }
 
 /**
- * Build a `BunPlugin` that blocks direct generated-artifact imports.
+ * Build a `BunPlugin` that blocks direct generated-artifact imports.
  *
  * Usage — call from `defaultBundlerPlugins(config)` (see `./index.ts`).
  * Every `safeBuild` / `Bun.build` invocation in Mandu funnels through
@@ -124,7 +124,7 @@ export function defaultAllowImporter(importerPath: string): boolean {
 export function blockGeneratedImports(
   options: BlockGeneratedImportsOptions = {},
 ): BunPlugin {
-  const filter = options.filter ?? DEFAULT_BLOCK_FILTER;
+  const filter = options.filter ?? DEFAULT_BLOCK_FILTER;
   const allowImporter = options.allowImporter ?? defaultAllowImporter;
 
   return {
@@ -152,5 +152,5 @@ export function blockGeneratedImports(
   };
 }
 
-/** Exported for unit-test convenience — keep the filter text assertable. */
-export const DEFAULT_BLOCK_FILTER = /__generated__|(?:^|[\/\\])\.mandu[\/\\]generated(?:[\/\\]|$)/;
+/** Exported for unit-test convenience — keep the filter text assertable. */
+export const DEFAULT_BLOCK_FILTER = /__generated__|(?:^|[\/\\])\.mandu[\/\\]generated(?:[\/\\]|$)/;