@mandujs/core 0.27.0 → 0.29.0

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

@@ -0,0 +1,155 @@
+/**
+ * Bun bundler plugin — hard-fail on direct `__generated__/` imports.
+ *
+ * Background
+ * ──────────
+ * The Guard rule `INVALID_GENERATED_IMPORT` (see `guard/check.ts`) already
+ * scans source files for literal `import … from '…generated…'` statements,
+ * 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 contains
+ * `__generated__` fails the build with a structured, actionable error.
+ *
+ * Design
+ * ──────
+ * - `onResolve({ filter: /__generated__/ })` — 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.
+ * - The message is built via the shared Guard helper
+ *   (`buildForbiddenGeneratedImportMessage`) so the bundler path and the
+ *   static Guard pass cannot drift out of sync.
+ *
+ * Legitimate escape hatches
+ * ─────────────────────────
+ * 1. `getGenerated()` / `tryGetGenerated()` from `@mandujs/core/runtime`
+ *    read through a global manifest slot (`__MANDU_MANIFEST__`). They do
+ *    NOT trigger an ESM import for the generated artifact, so they never
+ *    hit this plugin. That is the officially supported API.
+ * 2. `import type` statements are allowed by the rule — TS erases them
+ *    before emit, so they never become runtime imports. However, a
+ *    bundler `onResolve` hook cannot distinguish `import type` from a
+ *    value import because Bun strips the `type` keyword before plugin
+ *    dispatch. For this reason the plugin exposes an `allowImporter`
+ *    option (defaulted to recognise `@mandujs/core/runtime` internals)
+ *    but deliberately does NOT try to parse the source for `type`-only
+ *    imports. User type imports go through the type-checker, not the
+ *    bundler, so they remain unaffected in practice.
+ * 3. The per-project opt-out lives in `ManduConfig.guard.blockGeneratedImport
+ *    = false`. The plugin is simply not installed when the flag is off.
+ */
+
+import type { BunPlugin } from "bun";
+import {
+  buildForbiddenGeneratedImportMessage,
+  FORBIDDEN_GENERATED_IMPORT_SUGGESTION,
+  GENERATED_IMPORT_DOCS_URL,
+} from "../../guard/check";
+
+/**
+ * Raised by the plugin's `onResolve` hook. Named so tests can
+ * `instanceof`-check, and so Bun's log output clearly attributes the
+ * failure to the plugin.
+ */
+export class ForbiddenGeneratedImportError extends Error {
+  /** The literal `from "…"` specifier that tripped the guard. */
+  readonly specifier: string;
+  /** Absolute path of the file that issued the import (best-effort). */
+  readonly importer: string;
+  /** Docs URL that explains the official replacement. */
+  readonly docsUrl: string;
+  /** Short, one-line remediation hint. */
+  readonly suggestion: string;
+
+  constructor(specifier: string, importer: string) {
+    const message =
+      `${buildForbiddenGeneratedImportMessage(specifier)}\n` +
+      `  Importer: ${importer || "<unknown>"}\n` +
+      `  Replacement: import { getGenerated } from "@mandujs/core/runtime";\n` +
+      `  Then: const data = getGenerated(<key>);\n` +
+      `  Docs: ${GENERATED_IMPORT_DOCS_URL}`;
+    super(message);
+    this.name = "ForbiddenGeneratedImportError";
+    this.specifier = specifier;
+    this.importer = importer;
+    this.docsUrl = GENERATED_IMPORT_DOCS_URL;
+    this.suggestion = FORBIDDEN_GENERATED_IMPORT_SUGGESTION;
+  }
+}
+
+export interface BlockGeneratedImportsOptions {
+  /**
+   * Predicate that returns `true` when the importer should be exempted
+   * from the rule. Default exempts `@mandujs/core/runtime` (which in
+   * principle never imports `__generated__`, but is listed here so
+   * framework boot code cannot trip over itself during upgrades).
+   */
+  allowImporter?: (importerPath: string) => boolean;
+  /**
+   * Custom filter regex applied to the import specifier. Defaults to
+   * `/__generated__/`. Mandu ships a single default — exposing this for
+   * test harnesses that want to narrow or broaden the filter.
+   */
+  filter?: RegExp;
+}
+
+/**
+ * Default exempt predicate — matches `@mandujs/core/runtime` internals.
+ * The runtime package reads generated artifacts via the global registry,
+ * so in practice it never imports `__generated__/*`. Kept as a belt-and-
+ * suspenders guard against self-inflicted regressions.
+ */
+export function defaultAllowImporter(importerPath: string): boolean {
+  if (!importerPath) return false;
+  // Normalize Windows backslashes so a single check covers both platforms.
+  const norm = importerPath.replace(/\\/g, "/");
+  return (
+    norm.includes("/@mandujs/core/runtime/") ||
+    norm.includes("/packages/core/src/runtime/") ||
+    norm.includes("packages/core/src/runtime/")
+  );
+}
+
+/**
+ * Build a `BunPlugin` that blocks direct `__generated__/` imports.
+ *
+ * Usage — call from `defaultBundlerPlugins(config)` (see `./index.ts`).
+ * Every `safeBuild` / `Bun.build` invocation in Mandu funnels through
+ * that helper, so a single install point enforces the rule everywhere.
+ */
+export function blockGeneratedImports(
+  options: BlockGeneratedImportsOptions = {},
+): BunPlugin {
+  const filter = options.filter ?? /__generated__/;
+  const allowImporter = options.allowImporter ?? defaultAllowImporter;
+
+  return {
+    name: "mandu:block-generated-imports",
+    setup(build) {
+      build.onResolve({ filter }, (args) => {
+        // Normalise the specifier so a Windows-style import (which would
+        // be exotic but technically legal in some toolchains) is still
+        // caught.
+        const specifier = args.path;
+        const importer = args.importer ?? "";
+
+        if (allowImporter(importer)) {
+          // Internal runtime code gets a pass. Return `undefined` so
+          // Bun resolves the path through its normal pipeline.
+          return undefined;
+        }
+
+        // Throw a structured error. Bun surfaces `error.message` in
+        // `BuildResult.logs` (non-success) or re-throws on an exception
+        // path; either way the message reaches the developer.
+        throw new ForbiddenGeneratedImportError(specifier, importer);
+      });
+    },
+  };
+}
+
+/** Exported for unit-test convenience — keep the filter text assertable. */
+export const DEFAULT_BLOCK_FILTER = /__generated__/;

package/src/bundler/plugins/index.ts

@@ -0,0 +1,63 @@
+/**
+ * Bundler-plugin barrel.
+ *
+ * `defaultBundlerPlugins()` is the single choke point for the plugin
+ * set that Mandu installs on every `Bun.build` invocation. Adding a new
+ * default-on plugin means adding it here — every call-site in
+ * `bundler/build.ts` and `cli/src/util/bun.ts` composes the result of
+ * this helper with any build-specific plugins.
+ */
+
+import type { BunPlugin } from "bun";
+import {
+  blockGeneratedImports,
+  type BlockGeneratedImportsOptions,
+} from "./block-generated-imports";
+
+export {
+  blockGeneratedImports,
+  ForbiddenGeneratedImportError,
+  defaultAllowImporter,
+  DEFAULT_BLOCK_FILTER,
+  type BlockGeneratedImportsOptions,
+} from "./block-generated-imports";
+
+/**
+ * Subset of `ManduConfig.guard` consumed by `defaultBundlerPlugins()`.
+ * We deliberately don't import the full `ManduConfig` type to keep the
+ * plugins module cycle-free.
+ */
+export interface DefaultBundlerPluginsConfig {
+  guard?: {
+    blockGeneratedImport?: boolean;
+  };
+}
+
+export interface DefaultBundlerPluginsOptions {
+  /** Mandu config (only `guard.blockGeneratedImport` is consulted). */
+  config?: DefaultBundlerPluginsConfig;
+  /** Override options for the block-generated-imports plugin. */
+  blockGeneratedImports?: BlockGeneratedImportsOptions;
+}
+
+/**
+ * Compose Mandu's default plugin list. Current contents:
+ *
+ *   - `mandu:block-generated-imports` — hard-fail on direct
+ *     `__generated__/` imports. Opt-out via
+ *     `config.guard.blockGeneratedImport = false`.
+ *
+ * Always returns a fresh array; callers are free to concat build-local
+ * plugins (e.g. `fastRefreshPlugin()` in dev) without mutating the
+ * default set.
+ */
+export function defaultBundlerPlugins(
+  options: DefaultBundlerPluginsOptions = {},
+): BunPlugin[] {
+  const plugins: BunPlugin[] = [];
+  const blockEnabled = options.config?.guard?.blockGeneratedImport !== false;
+  if (blockEnabled) {
+    plugins.push(blockGeneratedImports(options.blockGeneratedImports));
+  }
+  return plugins;
+}

package/src/bundler/prerender.ts

@@ -1,32 +1,71 @@
 /**
  * Mandu Prerender Engine
- * 빌드 타임에 정적 HTML 생성 (SSG)
+ *
+ * Build-time static HTML generation (SSG) driven by two signals:
+ *
+ *   1. Static page routes (no dynamic segments) in the routes manifest.
+ *   2. Dynamic page routes whose module exports `generateStaticParams`
+ *      — see `./generate-static-params.ts` for the contract.
+ *
+ * For each resolved URL the engine invokes the build's fetch handler
+ * (a transient server spun up by `mandu build`) and writes the HTML
+ * payload under `.mandu/prerendered/` when callers opt into the new
+ * runtime-aware layout, or `.mandu/static/` for legacy callers.
+ *
+ * When `writeIndex: true` the engine also emits `_manifest.json`
+ * alongside the HTML — the runtime consults that index to serve
+ * prerendered pages directly with `Cache-Control: immutable`, skipping
+ * SSR entirely.
  */
 
 import path from "path";
 import fs from "fs/promises";
-import type { RoutesManifest } from "../spec/schema";
+import type { RoutesManifest, RouteSpec } from "../spec/schema";
+import {
+  collectStaticPaths,
+  isDynamicPattern,
+  type PageModuleWithStaticParams,
+} from "./generate-static-params";
 
 // ========== Types ==========
 
 export interface PrerenderOptions {
-  /** 프로젝트 루트 */
+  /** Project root — all relative paths resolve from here. */
   rootDir: string;
-  /** 출력 디렉토리 (기본: ".mandu/static") */
+  /**
+   * Output directory (absolute, or relative to `rootDir`).
+   * Defaults to `.mandu/static` to preserve behavior for older
+   * callers; `mandu build` opts into `.mandu/prerendered` +
+   * `writeIndex: true` to enable runtime pass-through.
+   */
   outDir?: string;
-  /** 프리렌더할 추가 경로 목록 */
+  /** Extra URL paths to prerender in addition to the manifest. */
   routes?: string[];
-  /** 링크 크롤링으로 자동 발견 (기본: false) */
+  /** Follow internal `<a href>` links in rendered HTML (default: false). */
   crawl?: boolean;
+  /**
+   * When true, also write `<outDir>/_manifest.json` listing every
+   * prerendered pathname. The runtime uses this index to short-circuit
+   * dispatch for matching URLs.
+   */
+  writeIndex?: boolean;
+  /**
+   * Optional injected `import` function. Tests pass a stub so we can
+   * exercise `generateStaticParams` without touching disk; production
+   * callers leave this undefined (the default dynamic import is used).
+   */
+  importModule?: (specifier: string) => Promise<PageModuleWithStaticParams>;
 }
 
 export interface PrerenderResult {
-  /** 생성된 페이지 수 */
+  /** Number of pages rendered successfully. */
   generated: number;
-  /** 생성된 경로별 정보 */
+  /** Per-page telemetry. */
   pages: PrerenderPageResult[];
-  /** 에러 목록 */
+  /** Errors encountered during the run (non-fatal). */
   errors: string[];
+  /** Pathnames that were rendered. */
+  paths: string[];
 }
 
 export interface PrerenderPageResult {
@@ -35,16 +74,39 @@ export interface PrerenderPageResult {
   duration: number;
 }
 
+/** Shape of the index file written to `<outDir>/_manifest.json`. */
+export interface PrerenderIndex {
+  version: 1;
+  generatedAt: string;
+  /** Pathname → relative HTML file path (posix separators). */
+  pages: Record<string, string>;
+}
+
+/** File name used for the runtime index. */
+export const PRERENDER_INDEX_FILE = "_manifest.json";
+
+/** Default output directory (runtime-aware location). */
+export const DEFAULT_PRERENDER_DIR = ".mandu/prerendered";
+
+/** Default output directory (legacy `prerenderRoutes` callers). */
+export const LEGACY_PRERENDER_DIR = ".mandu/static";
+
+/** Default cache policy stamped on runtime prerender responses. */
+export const DEFAULT_PRERENDER_CACHE_CONTROL =
+  "public, max-age=31536000, immutable";
+
 // ========== Implementation ==========
 
 /**
- * 정적 라우트를 HTML로 프리렌더링
+ * Prerender the routes declared in a manifest (plus any extras) to
+ * static HTML. See `PrerenderOptions` for the full contract.
  *
  * @example
  * ```typescript
  * const result = await prerenderRoutes(manifest, fetchHandler, {
  *   rootDir: process.cwd(),
- *   routes: ["/about", "/blog/hello-world"],
+ *   outDir: ".mandu/prerendered",
+ *   writeIndex: true,
  * });
  * ```
  */
@@ -53,49 +115,70 @@ export async function prerenderRoutes(
   fetchHandler: (req: Request) => Promise<Response>,
   options: PrerenderOptions
 ): Promise<PrerenderResult> {
-  const { rootDir, outDir = ".mandu/static", crawl = false } = options;
-  const outputDir = path.isAbsolute(outDir) ? outDir : path.join(rootDir, outDir);
+  const {
+    rootDir,
+    outDir = LEGACY_PRERENDER_DIR,
+    crawl = false,
+    writeIndex = false,
+    importModule,
+  } = options;
 
+  const outputDir = path.isAbsolute(outDir) ? outDir : path.join(rootDir, outDir);
   await fs.mkdir(outputDir, { recursive: true });
 
   const pages: PrerenderPageResult[] = [];
   const errors: string[] = [];
   const renderedPaths = new Set<string>();
+  const pageIndex: Record<string, string> = {};
 
-  // 1. 명시적으로 지정된 경로 수집
+  // 1. Explicit user-supplied routes.
   const pathsToRender = new Set<string>(options.routes ?? []);
 
-  // 2. 매니페스트에서 정적 페이지 라우트 수집 (동적 파라미터 없는 것)
+  // 2. Static page routes (no dynamic segments).
   for (const route of manifest.routes) {
-    if (route.kind === "page" && !route.pattern.includes(":")) {
+    if (route.kind === "page" && !isDynamicPattern(route.pattern)) {
       pathsToRender.add(route.pattern);
     }
   }
 
-  // 3. 동적 라우트의 generateStaticParams 수집
+  // 3. Dynamic routes that export `generateStaticParams`.
+  const resolveModule =
+    importModule ?? ((specifier: string) => import(specifier));
+
   for (const route of manifest.routes) {
-    if (route.kind === "page" && route.pattern.includes(":")) {
-      try {
-        const modulePath = path.join(rootDir, route.module).replace(/\\/g, "/");
-        const mod = await import(modulePath);
-        if (typeof mod.generateStaticParams === "function") {
-          const paramSets = await mod.generateStaticParams();
-          if (Array.isArray(paramSets)) {
-            for (const params of paramSets) {
-              const resolvedPath = resolvePattern(route.pattern, params);
-              pathsToRender.add(resolvedPath);
-            }
-          } else if (paramSets) {
-            console.warn(`[Mandu Prerender] generateStaticParams() for ${route.pattern} returned non-array. Expected an array of param objects.`);
-          }
-        }
-      } catch {
-        // generateStaticParams 없으면 스킵
-      }
+    if (route.kind !== "page" || !isDynamicPattern(route.pattern)) continue;
+
+    let mod: PageModuleWithStaticParams;
+    try {
+      mod = await loadPageModule(rootDir, route, resolveModule);
+    } catch {
+      // Module failed to load entirely. Silent skip — the page may
+      // simply not opt into static params; SSR can still serve it.
+      continue;
+    }
+
+    if (typeof mod.generateStaticParams !== "function") {
+      // Not opted-in for this route — perfectly fine.
+      continue;
+    }
+
+    try {
+      const { paths, errors: paramErrors } = await collectStaticPaths(
+        route.pattern,
+        mod
+      );
+      for (const p of paths) pathsToRender.add(p);
+      for (const e of paramErrors) errors.push(`[${route.pattern}] ${e}`);
+    } catch (error) {
+      // User code threw. Surface the error but keep going — other
+      // routes should not be blocked by one buggy generator.
+      errors.push(
+        `[${route.pattern}] generateStaticParams threw: ${describeError(error)}`
+      );
     }
   }
 
-  // 4. 각 경로를 렌더링
+  // 4. Render every queued path.
   for (const pathname of pathsToRender) {
     if (renderedPaths.has(pathname)) continue;
     renderedPaths.add(pathname);
@@ -118,10 +201,11 @@ export async function prerenderRoutes(
 
       const duration = Date.now() - start;
       pages.push({ path: pathname, size: html.length, duration });
+      pageIndex[pathname] = toPosix(path.relative(outputDir, filePath));
 
-      // 5. 크롤링: 생성된 HTML에서 내부 링크 추출
+      // 5. Optional crawl — harvest internal links for next pass.
       if (crawl) {
-        const links = extractInternalLinks(html, pathname);
+        const links = extractInternalLinks(html);
         for (const link of links) {
           if (!renderedPaths.has(link) && !pathsToRender.has(link)) {
             pathsToRender.add(link);
@@ -129,67 +213,156 @@ export async function prerenderRoutes(
         }
       }
     } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      errors.push(`[${pathname}] ${message}`);
+      errors.push(`[${pathname}] ${describeError(error)}`);
     }
   }
 
-  return { generated: pages.length, pages, errors };
+  // 6. Emit runtime index.
+  if (writeIndex) {
+    const indexContents: PrerenderIndex = {
+      version: 1,
+      generatedAt: new Date().toISOString(),
+      pages: pageIndex,
+    };
+    await fs.writeFile(
+      path.join(outputDir, PRERENDER_INDEX_FILE),
+      JSON.stringify(indexContents, null, 2),
+      "utf-8"
+    );
+  }
+
+  return {
+    generated: pages.length,
+    pages,
+    errors,
+    paths: pages.map((p) => p.path),
+  };
 }
 
-// ========== Helpers ==========
+/**
+ * Load the prerender manifest index emitted under `outDir`. Returns
+ * `null` if it doesn't exist or can't be parsed — callers should
+ * treat that as "no prerendered content" rather than an error.
+ */
+export async function loadPrerenderIndex(
+  rootDir: string,
+  outDir: string = DEFAULT_PRERENDER_DIR
+): Promise<PrerenderIndex | null> {
+  const dir = path.isAbsolute(outDir) ? outDir : path.join(rootDir, outDir);
+  const file = path.join(dir, PRERENDER_INDEX_FILE);
+  try {
+    const contents = await fs.readFile(file, "utf-8");
+    const parsed = JSON.parse(contents) as PrerenderIndex;
+    if (!parsed || typeof parsed !== "object" || parsed.version !== 1 || !parsed.pages) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
 
 /**
- * 라우트 패턴에 파라미터를 대입하여 실제 경로 생성
+ * Resolve a pathname against a loaded index. Returns the absolute
+ * file path of the prerendered HTML, or `null` on miss.
+ *
+ * Tolerates both `/foo` and `/foo/` forms, and an optional `.html`
+ * suffix. Path-traversal in the index value is defensively rejected
+ * so a hand-edited / malicious index cannot escape the output root.
  */
-function resolvePattern(pattern: string, params: Record<string, string>): string {
-  let result = pattern;
-  for (const [key, value] of Object.entries(params)) {
-    // catch-all (:param*) / optional catch-all (:param*?) 지원
-    const paramRegex = new RegExp(`:${key}\\*\\??`);
-    if (paramRegex.test(result)) {
-      // catch-all: 각 세그먼트를 개별 인코딩 (슬래시 보존)
-      const encoded = value.split("/").map(encodeURIComponent).join("/");
-      result = result.replace(paramRegex, encoded);
-    } else {
-      result = result.replace(`:${key}`, encodeURIComponent(value));
+export function resolvePrerenderedFile(
+  index: PrerenderIndex,
+  rootDir: string,
+  outDir: string,
+  pathname: string
+): string | null {
+  const dir = path.isAbsolute(outDir) ? outDir : path.join(rootDir, outDir);
+  const candidates = [pathname];
+  if (pathname.length > 1 && pathname.endsWith("/")) {
+    candidates.push(pathname.slice(0, -1));
+  } else if (pathname !== "/") {
+    candidates.push(pathname + "/");
+  }
+  if (pathname.endsWith(".html")) {
+    candidates.push(pathname.slice(0, -".html".length));
+  }
+  for (const candidate of candidates) {
+    const rel = index.pages[candidate];
+    if (rel) {
+      const resolved = path.resolve(dir, rel);
+      const normalizedDir = path.resolve(dir) + path.sep;
+      if (resolved === path.resolve(dir) || resolved.startsWith(normalizedDir)) {
+        return resolved;
+      }
     }
   }
-  return result;
+  return null;
 }
 
+// ========== Helpers ==========
+
 /**
- * 출력 파일 경로 생성
- * /about → .mandu/static/about/index.html
- * / → .mandu/static/index.html
+ * Dynamic-import a page module given its declared `module` path in
+ * the manifest. Normalizes the path for Windows dynamic-import
+ * (forward slashes + absolute) before delegating.
+ */
+async function loadPageModule(
+  rootDir: string,
+  route: RouteSpec,
+  importFn: (specifier: string) => Promise<PageModuleWithStaticParams>
+): Promise<PageModuleWithStaticParams> {
+  const absolute = path.isAbsolute(route.module)
+    ? route.module
+    : path.join(rootDir, route.module);
+  const specifier = absolute.replace(/\\/g, "/");
+  return importFn(specifier);
+}
+
+/**
+ * URL path → output file path.
+ *   /            → <outDir>/index.html
+ *   /about       → <outDir>/about/index.html (clean URL)
+ *   /blog/a/b    → <outDir>/blog/a/b/index.html
  */
 function getOutputPath(outDir: string, pathname: string): string {
   const trimmed = pathname === "/" ? "/" : pathname.replace(/\/+$/, "");
   if (trimmed === "/") return path.join(outDir, "index.html");
-  // /blog/post → .mandu/static/blog/post/index.html (clean URL)
-  return path.join(outDir, trimmed, "index.html");
+  // Decode percent-encoding so on-disk names are stable across platforms.
+  const decoded = trimmed
+    .split("/")
+    .map((segment) => {
+      try {
+        return decodeURIComponent(segment);
+      } catch {
+        return segment;
+      }
+    })
+    .join("/");
+  return path.join(outDir, decoded, "index.html");
 }
 
-/**
- * HTML에서 내부 링크 추출 (크롤링용)
- */
-function extractInternalLinks(html: string, currentPath: string): string[] {
+/** Extract absolute internal `<a href>` paths (same-origin only). */
+function extractInternalLinks(html: string): string[] {
   const links: string[] = [];
   const hrefRegex = /href=["']([^"']+)["']/g;
   let match: RegExpExecArray | null;
-
   while ((match = hrefRegex.exec(html)) !== null) {
     const href = match[1];
-    // 내부 링크만 (절대 경로이면서 프로토콜 없는 것)
     if (href.startsWith("/") && !href.startsWith("//")) {
-      // 쿼리스트링/해시 제거
       const cleanPath = href.split("?")[0].split("#")[0];
-      // 정적 파일 제외
       if (!cleanPath.match(/\.(js|css|png|jpg|jpeg|gif|svg|ico|woff|woff2|ttf|eot)$/)) {
         links.push(cleanPath);
       }
     }
   }
-
   return [...new Set(links)];
 }
+
+function toPosix(p: string): string {
+  return p.replace(/\\/g, "/");
+}
+
+function describeError(error: unknown): string {
+  if (error instanceof Error) return error.message;
+  return String(error);
+}

package/src/bundler/types.ts

@@ -156,4 +156,12 @@ export interface BundlerOptions {
    * - 안전성: 기존 `.mandu/manifest.json` 이 없으면 자동으로 full build로 fallback.
    */
   skipFrameworkBundles?: boolean;
+  /**
+   * Issue #207 — opt-out for the `mandu:block-generated-imports` bundler
+   * plugin. Default `true` (plugin installed on every build). Set
+   * `false` to skip installation — mirrors
+   * `ManduConfig.guard.blockGeneratedImport`. CLI callers pass the
+   * resolved config flag straight through.
+   */
+  blockGeneratedImport?: boolean;
 }