@docubook/flame 2.0.0-beta.1 → 2.0.0-beta.3

package/.docu/node/hydrate.node.ts

@@ -1,7 +1,7 @@
 /**
  * Client bundle builder for Node/Deno runtimes.
  *
- * Wraps esbuild with the plugins needed to produce a browser-ready client
+ * Uses Vite with Rolldown plugins to produce a browser-ready client
  * bundle (JS + CSS) from the same components Bun.build handles natively.
  * Theme helpers (getThemeConfig, buildThemeCss, computeInlineThemeCss)
  * are re-exported from `hydrate.ts` — that module's `buildClientBundle`
@@ -13,8 +13,8 @@ import { builtinModules, createRequire } from "node:module";
 import { basename, dirname, join, resolve } from "node:path";
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { promisify } from "node:util";
-import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
-import { createHash } from "node:crypto";
+import { mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { build as viteBuild } from "vite";
 import {
   ASSETS_DIR,
   FRAMEWORK_ROOT,
@@ -24,6 +24,7 @@ import {
   loadDocuConfig,
 } from "./paths";
 import { buildThemeCss, getThemeConfig } from "./hydrate";
+import { atomicWriteFile, computeTailwindCacheKey, readGlobalsCss } from "./cache-key";
 import { resolveRoutes } from "./fs-scanner";
 import { normalizeImporterPath } from "./security";
 import type { DocuConfig, DocuRoute } from "./types";
@@ -58,10 +59,9 @@ function resolveTailwindBin(): string {
   return join(dirname(pkgPath), binRel);
 }
 
-/** Compute a cache key from globals.css + theme config content. */
+/** Compute a cache key from globals.css + theme + config + toolchain. */
 function tailwindCacheKey(): string {
-  const globalsPath = join(STYLES_DIR, "globals.css");
-  const globalsContent = existsSync(globalsPath) ? readFileSync(globalsPath, "utf-8") : "";
+  const globalsContent = readGlobalsCss();
   let themeSuffix = "";
   try {
     const themeColors = getThemeConfig();
@@ -71,10 +71,7 @@ function tailwindCacheKey(): string {
   } catch {
     // theme config unavailable — proceed without it
   }
-  return createHash("sha256")
-    .update(globalsContent + themeSuffix)
-    .digest("hex")
-    .slice(0, 16);
+  return computeTailwindCacheKey(globalsContent, themeSuffix);
 }
 
 /**
@@ -104,7 +101,7 @@ async function buildTailwindCss(key: string): Promise<{ file: string; content: s
   }
 
   let cssContent = await readFile(tmpCss, "utf-8");
-  await unlink(tmpCss);
+  await unlink(tmpCss).catch(() => {});
 
   try {
     const themeColors = getThemeConfig();
@@ -119,11 +116,12 @@ async function buildTailwindCss(key: string): Promise<{ file: string; content: s
 
   // Use the same input-derived key for lookup and output — if inputs change,
   // the key changes, cache busting works without a separate content hash.
+  // Atomic tmp+rename with pid suffix: parallel builds never clobber each other.
   const cssFile = `client-${key}.css`;
   const outPath = join(ASSETS_DIR, cssFile);
 
   if (!existsSync(outPath)) {
-    await writeFile(outPath, cssContent);
+    await atomicWriteFile(writeFile, rename, unlink, outPath, cssContent);
   }
 
   return { file: cssFile, content: cssContent };
@@ -203,180 +201,129 @@ export async function buildClientBundle(
   await cleanOldBundles(new Set([`client-${twKey}.css`]));
 
   const nodeEnv = process.env.NODE_ENV || "development";
-  const esbuild = await import("esbuild");
-  const { build } = esbuild;
 
   const entryPath = join(LIB_DIR, "client.ts");
-  const workingDir = process.cwd();
-  let result: Awaited<ReturnType<typeof build>>;
-  try {
-    result = await build({
-      entryPoints: [entryPath],
-      bundle: true,
-      outdir: ASSETS_DIR,
-      entryNames: "client-[hash]",
-      platform: "browser",
-      format: "esm",
-      minify: nodeEnv === "production",
-      define: { "process.env.NODE_ENV": JSON.stringify(nodeEnv) },
-      jsx: "automatic",
-      jsxDev: nodeEnv !== "production",
-      metafile: true,
-      logLevel: "silent",
-      plugins: [
-        {
-          name: "node-builtin-stub",
-          setup(build) {
-            build.onResolve({ filter: NODE_BUILTINS_RE }, (args) => ({
-              path: args.path,
-              namespace: "node-stub",
-            }));
-            build.onLoad({ filter: /.*/, namespace: "node-stub" }, () => ({
-              contents: "module.exports = {};",
-              loader: "js",
-            }));
-          },
+  const bundle = await viteBuild({
+    configFile: false,
+    publicDir: false,
+    define: { "process.env.NODE_ENV": JSON.stringify(nodeEnv) },
+    plugins: [
+      {
+        name: "node-builtin-stub",
+        resolveId(id) {
+          if (NODE_BUILTINS_RE.test(id)) return `\0node-stub:${id}`;
+          return null;
         },
-        {
-          name: "lucide-optimize",
-          setup(build) {
-            build.onResolve({ filter: /^lucide-react$/ }, (args) => {
-              // Imports from within our virtual module go to the real package.
-              if (args.namespace === "lucide-virt") {
-                return { path: getLucideRealEntry(), namespace: "file" };
-              }
-              // markdown Icon.tsx uses namespace import for arbitrary
-              // user-provided icon names in MDX — keep full barrel there.
-              if (args.importer) {
-                const normalized = normalizeImporterPath(args.importer);
-                if (normalized.includes("/markdown/dist/")) {
-                  return { path: getLucideRealEntry(), namespace: "file" };
-                }
-              }
-              // All other files get tree-shaken via the virtual module.
-              // Lucide.tsx renders only config-defined icons, which are
-              // collected by extractConfigIcons() + collectAllLucideIcons().
-              return { path: args.path, namespace: "lucide-virt" };
-            });
-            build.onLoad({ filter: /.*/, namespace: "lucide-virt" }, () => {
-              const scanned = collectAllLucideIcons();
-              const configured = extractConfigIcons(loadDocuConfig());
-              const allIcons = [...new Set([...scanned, ...configured])];
-              return {
-                contents: `export { ${allIcons.join(", ")} } from "lucide-react";`,
-                loader: "js",
-              };
-            });
-          },
+        load(id) {
+          if (!id.startsWith("\0node-stub:")) return null;
+          return "export default {}; export {};";
         },
-        {
-          name: "docu-config",
-          setup(build) {
-            // Components import as "../node/client-routes" (no .ts extension),
-            // so filter matches the path tail without requiring the extension.
-            build.onResolve({ filter: /client-routes$/ }, (args) => ({
-              path: args.path,
-              namespace: "client-routes",
-            }));
-            build.onLoad({ filter: /.*/, namespace: "client-routes" }, () => {
-              const config = loadDocuConfig();
-              const resolved = {
-                ...config,
-                routes: resolveRoutes(config.routes as DocuRoute[] | undefined),
-              };
-              return {
-                contents: [
-                  `import type { DocuRoute, DocuConfig } from "./types";`,
-                  `const docuConfig = ${JSON.stringify(resolved)};`,
-                  `export const routes = docuConfig.routes || [];`,
-                  `export const config = docuConfig;`,
-                ].join("\n"),
-                loader: "ts",
-              };
-            });
-          },
+      },
+      {
+        name: "lucide-optimize",
+        resolveId(id, importer) {
+          if (id !== "lucide-react") return null;
+          if (importer) {
+            const normalized = normalizeImporterPath(importer);
+            if (normalized.includes("/markdown/dist/")) return null;
+          }
+          return "\0lucide-virt";
         },
-        {
-          // Serves per-page compiled MDX (program format) as real modules so
-          // the client hydrates the content island without `new Function`.
-          // client.ts imports `{ mdxModules } from "./mdx-manifest"`.
-          name: "mdx-hydrate",
-          setup(build) {
-            // Compiled MDX (program format) imports the JSX runtime and the
-            // MDX provider. Virtual modules have no real directory, so esbuild
-            // cannot resolve bare specifiers from them — map them to the
-            // installed real paths explicitly (same pattern as lucide-optimize).
-            const require = createRequire(import.meta.url);
-            const mdxModuleDeps: Record<string, string> = {
-              "react/jsx-runtime": require.resolve("react/jsx-runtime"),
-              "react/jsx-dev-runtime": require.resolve("react/jsx-dev-runtime"),
-              "@mdx-js/react": require.resolve("@mdx-js/react"),
-            };
-            build.onResolve(
-              { filter: /^(react\/jsx-runtime|react\/jsx-dev-runtime|@mdx-js\/react)$/ },
-              (args) => {
-                if (args.namespace !== "mdx-module") return;
-                return { path: mdxModuleDeps[args.path], namespace: "file" };
-              }
-            );
-            build.onResolve({ filter: /^mdx-module:/ }, (args) => ({
-              path: args.path,
-              namespace: "mdx-module",
-            }));
-            build.onLoad({ filter: /.*/, namespace: "mdx-module" }, (args) => {
-              const slug = args.path.slice("mdx-module:".length);
-              const contents = mdxSources[slug];
-              if (contents == null) {
-                return {
-                  errors: [{ text: `unknown mdx module: ${slug}` }],
-                  contents: "",
-                  loader: "js",
-                };
-              }
-              return { contents, loader: "js" };
-            });
-            build.onResolve({ filter: /mdx-manifest$/ }, (args) => ({
-              path: args.path,
-              namespace: "mdx-manifest",
-            }));
-            build.onLoad({ filter: /.*/, namespace: "mdx-manifest" }, () => {
-              // Sort keys: the prePass fills mdxSources via Promise.all, so
-              // insertion order = resolution order (non-deterministic across
-              // processes). Stable key order keeps the bundle hash stable so
-              // the build cache (`assetsChanged`) actually hits.
-              const slugs = Object.keys(mdxSources).sort();
-              const imports = slugs
-                .map((slug, i) => {
-                  const key = slug.replace(/["\\]/g, "");
-                  return `import * as _mdx${i} from "mdx-module:${key}";`;
-                })
-                .join("\n");
-              const map = slugs.map((slug, i) => `${JSON.stringify(slug)}: _mdx${i}`).join(", ");
-              return {
-                contents: `${imports}\nexport const mdxModules = { ${map} };\n`,
-                loader: "js",
-              };
-            });
-          },
+        load(id) {
+          if (id !== "\0lucide-virt") return null;
+          const scanned = collectAllLucideIcons();
+          const configured = extractConfigIcons(loadDocuConfig());
+          const allIcons = [...new Set([...scanned, ...configured])];
+          return `export { ${allIcons.join(", ")} } from ${JSON.stringify(getLucideRealEntry())};`;
         },
-      ],
-    });
-  } finally {
-    // esbuild's service child process keeps Deno's event loop alive after a
-    // one-shot build (node-compat gap) — stop it so `flame build` exits.
-    await esbuild.stop();
-  }
-
-  // The single entry produces one output. Match resolved source path.
-  const { outputs } = result.metafile!;
-  const jsOutput = Object.keys(outputs).find((p) => {
-    const o = outputs[p];
-    return o.entryPoint && resolve(workingDir, o.entryPoint) === entryPath;
+      },
+      {
+        name: "docu-config",
+        resolveId(id) {
+          if (!/client-routes$/.test(id)) return null;
+          return "\0client-routes";
+        },
+        load(id) {
+          if (id !== "\0client-routes") return null;
+          const config = loadDocuConfig();
+          const resolved = {
+            ...config,
+            routes: resolveRoutes(config.routes as DocuRoute[] | undefined),
+          };
+          return [
+            `const docuConfig = ${JSON.stringify(resolved)};`,
+            `export const routes = docuConfig.routes || [];`,
+            `export const config = docuConfig;`,
+          ].join("\n");
+        },
+      },
+      {
+        name: "mdx-hydrate",
+        resolveId(id) {
+          if (/mdx-manifest$/.test(id)) return "\0mdx-manifest";
+          if (id.startsWith("mdx-module:")) return `\0${id}`;
+          return null;
+        },
+        load(id) {
+          if (id === "\0mdx-manifest") {
+            const slugs = Object.keys(mdxSources).sort();
+            const imports = slugs
+              .map((slug, i) => {
+                const key = slug.replace(/["\\]/g, "");
+                return `import * as _mdx${i} from ${JSON.stringify(`mdx-module:${key}`)};`;
+              })
+              .join("\n");
+            const map = slugs.map((slug, i) => `${JSON.stringify(slug)}: _mdx${i}`).join(", ");
+            return `${imports}\nexport const mdxModules = { ${map} };\n`;
+          }
+          if (!id.startsWith("\0mdx-module:")) return null;
+          const slug = id.slice("\0mdx-module:".length);
+          const contents = mdxSources[slug];
+          if (contents == null) {
+            throw new Error(`unknown mdx module: ${slug}`);
+          }
+          return contents;
+        },
+      },
+    ],
+    build: {
+      outDir: ASSETS_DIR,
+      emptyOutDir: false,
+      sourcemap: true,
+      minify: nodeEnv === "production",
+      target: "es2020",
+      rollupOptions: {
+        input: entryPath,
+        output: {
+          format: "es",
+          entryFileNames: "client-[hash].js",
+          chunkFileNames: "chunks/[name]-[hash].js",
+          assetFileNames: "assets/[name]-[hash][extname]",
+        },
+      },
+    },
   });
-  if (!jsOutput) {
+
+  const outputs = Array.isArray(bundle) ? bundle : [bundle];
+  let jsFile: string | undefined;
+  for (const item of outputs) {
+    if (!("output" in item)) continue;
+    for (const output of item.output) {
+      if (
+        output.type === "chunk" &&
+        output.isEntry &&
+        output.facadeModuleId &&
+        resolve(output.facadeModuleId) === entryPath
+      ) {
+        jsFile = basename(output.fileName);
+        break;
+      }
+    }
+    if (jsFile) break;
+  }
+  if (!jsFile) {
     throw new Error("Client bundle produced no output files");
   }
-  const jsFile = basename(jsOutput);
 
   const { file: cssFile } = await buildTailwindCss(twKey);
 

package/.docu/node/hydrate.ts

@@ -1,9 +1,9 @@
 import { join } from "node:path";
-import { mkdir, unlink } from "node:fs/promises";
-import { existsSync, readFileSync } from "node:fs";
-import { createHash } from "node:crypto";
+import { mkdir, unlink, rename } from "node:fs/promises";
+import { existsSync } from "node:fs";
 import { resolveTheme, generateThemeCss, presetRegistry } from "@docubook/themes-colors";
 import { ASSETS_DIR, cleanOldBundles, LIB_DIR, STYLES_DIR, loadDocuConfig } from "./paths";
+import { atomicWriteFile, computeTailwindCacheKey, readGlobalsCss } from "./cache-key";
 import { resolveRoutes } from "./fs-scanner";
 import type { DocuRoute } from "./types";
 import type { ThemeConfig } from "@docubook/themes-colors";
@@ -57,10 +57,9 @@ export function computeInlineThemeCss(): string | undefined {
   return undefined;
 }
 
-/** Compute Tailwind cache key from globals.css + theme config. */
+/** Compute Tailwind cache key from globals.css + theme + config + toolchain. */
 function twCacheKey(): string {
-  const globalsPath = join(STYLES_DIR, "globals.css");
-  const globals = existsSync(globalsPath) ? readFileSync(globalsPath, "utf-8") : "";
+  const globals = readGlobalsCss();
   let themeSuffix = "";
   try {
     const themeColors = getThemeConfig();
@@ -68,10 +67,7 @@ function twCacheKey(): string {
   } catch {
     // theme config unavailable — proceed without
   }
-  return createHash("sha256")
-    .update(globals + themeSuffix)
-    .digest("hex")
-    .slice(0, 16);
+  return computeTailwindCacheKey(globals, themeSuffix);
 }
 
 /** Run Tailwind CLI, caching by content hash. */
@@ -105,7 +101,7 @@ async function buildTailwindCss(key: string): Promise<{ file: string; content: s
   }
 
   let cssContent = await Bun.file(tmpCss).text();
-  await unlink(tmpCss);
+  await unlink(tmpCss).catch(() => {});
 
   try {
     const themeColors = getThemeConfig();
@@ -116,11 +112,14 @@ async function buildTailwindCss(key: string): Promise<{ file: string; content: s
     );
   }
 
-  // Use the same input-derived key for lookup and output — if inputs change,
-  // the key changes, cache busting works without a separate content hash.
   const cssFile = `client-${key}.css`;
   const outPath = join(ASSETS_DIR, cssFile);
-  if (!existsSync(outPath)) await Bun.write(outPath, cssContent);
+  // Atomic tmp+rename with pid suffix: parallel builds never clobber each
+  // other, and a crash cannot leave a half-written CSS file behind.
+  if (!existsSync(outPath)) {
+    const { writeFile } = await import("node:fs/promises");
+    await atomicWriteFile(writeFile, rename, unlink, outPath, cssContent);
+  }
 
   return { file: cssFile, content: cssContent };
 }

package/.docu/node/mdx.ts

@@ -174,7 +174,10 @@ async function serializeWithDocPlugins(
   // Parse-once: when the prePass already extracted the frontmatter + stripped
   // content, reuse it instead of re-parsing (the SSR phase skips extraction).
   const { strippedContent, frontmatter } =
-    pre ?? extractFrontmatterWithContent<Frontmatter>(rawMdx, opts.frontmatterSchema);
+    pre ??
+    (opts.frontmatterSchema
+      ? extractFrontmatterWithContent<Frontmatter>(rawMdx, opts.frontmatterSchema)
+      : extractFrontmatterWithContent<Frontmatter>(rawMdx));
 
   const defaultRemark = createDefaultRemarkPlugins();
   const defaultRehype = createDefaultRehypePlugins();
@@ -221,7 +224,9 @@ export async function compileMdx(
   const tocs = extractTocsFromRawMdx(rawMdx);
   const frontmatter =
     pre?.frontmatter ??
-    extractFrontmatterWithContent<Frontmatter>(rawMdx, frontmatterSchema).frontmatter;
+    (frontmatterSchema
+      ? extractFrontmatterWithContent<Frontmatter>(rawMdx, frontmatterSchema).frontmatter
+      : extractFrontmatterWithContent<Frontmatter>(rawMdx).frontmatter);
   const serialized = await serializeWithDocPlugins(
     rawMdx,
     { remarkPlugins, rehypePlugins, frontmatterSchema },
@@ -304,6 +309,13 @@ export function getPageContent(href: string): string | undefined {
   return pageContent.get(href);
 }
 
+/** Drop derived page maps under OS memory pressure (Bun 1.4 `memoryPressure`). */
+export function clearDerivedPageCaches(): void {
+  pageContent.clear();
+  pageStripped.clear();
+  pageFrontmatter.clear();
+}
+
 export async function compileMdxModule(
   rawMdx: string,
   remarkPlugins?: Pluggable[],

package/.docu/node/paths.ts

@@ -10,7 +10,28 @@ import type { DocuConfig } from "./types";
 
 // .docu/node/paths.ts → package root is 2 levels up
 export const FRAMEWORK_ROOT = resolve(import.meta.dirname, "../..");
-export const PROJECT_ROOT = process.cwd();
+
+/**
+ * Find the project root by walking up from cwd until docu.json is found.
+ * Falls back to cwd when not found (tests, ad-hoc scripts). Bun 1.4
+ * `run --parallel --filter` may change cwd per workspace task, so a bare
+ * process.cwd() can point at the wrong package.
+ */
+function findProjectRoot(): string {
+  let dir = process.cwd();
+  for (let i = 0; i < 6; i++) {
+    try {
+      if (existsSync(join(dir, "docu.json"))) return dir;
+    } catch {
+      break;
+    }
+    const parent = resolve(dir, "..");
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return process.cwd();
+}
+export const PROJECT_ROOT = findProjectRoot();
 
 // Framework paths (internal)
 export const PAGES_DIR = join(FRAMEWORK_ROOT, ".docu/pages");
@@ -29,6 +50,11 @@ export const DOCS_DIR = join(PROJECT_ROOT, "docs");
 export const DOCS_ASSETS_DIR = join(PROJECT_ROOT, "docs/assets");
 export const DOCU_CONFIG_PATH = join(PROJECT_ROOT, "docu.json");
 
+/** Resolve a project-relative file against the discovered PROJECT_ROOT. */
+export function resolveProjectFile(...segments: string[]): string {
+  return join(PROJECT_ROOT, ...segments);
+}
+
 // Config singleton
 let _config: DocuConfig | null = null;
 

package/.docu/node/types.ts

@@ -93,12 +93,30 @@ export interface DocuConfig {
   plugins?: PluginEntry[];
 }
 
+export interface BuildCacheEntry {
+  hash: string;
+  mtime: number;
+  builtAt: number;
+}
+
+/** Version stamp stored as `__meta__` — extends entry so the index signature stays valid. */
+export interface BuildCacheMeta extends BuildCacheEntry {
+  version: number;
+  runtime: string;
+}
+
 export interface BuildCache {
-  [path: string]: {
-    hash: string;
-    mtime: number;
-    builtAt: number;
-  };
+  [path: string]: BuildCacheEntry;
+  __meta__?: BuildCacheMeta;
+  __assets__?: BuildCacheEntry;
+  __bundle__?: BuildCacheEntry;
+}
+
+/** Narrow a cache slot to a real page/asset entry (guards `__meta__` shape). */
+export function isCacheEntry(value: unknown): value is BuildCacheEntry {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value as Record<string, unknown>;
+  return typeof v.hash === "string" && typeof v.mtime === "number" && typeof v.builtAt === "number";
 }
 
 export interface CliArgs {

package/bin/cli.js

@@ -7,9 +7,35 @@ import { spawnSync } from "node:child_process";
 
 const __dirname = import.meta.dirname;
 
+// Detect the package manager that invoked this binary. npm, pnpm, bun, and
+// yarn set npm_config_user_agent when they run a bin; fall back to lockfiles
+// in the target directory for direct invocations (e.g. `node bin/cli.js`).
+function detectPkgManager(dir) {
+  const userAgent = process.env.npm_config_user_agent || "";
+  // pnpm/yarn UA strings also contain "npm/?" — match specific tools first.
+  if (/bun\//.test(userAgent)) return "bun";
+  if (/pnpm\//.test(userAgent)) return "pnpm";
+  if (/yarn\//.test(userAgent)) return "yarn";
+  if (/npm\//.test(userAgent)) return "npm";
+  if (existsSync(join(dir, "bun.lock"))) return "bun";
+  if (existsSync(join(dir, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync(join(dir, "yarn.lock"))) return "yarn";
+  if (existsSync(join(dir, "package-lock.json"))) return "npm";
+  return "npm";
+}
+
+// Explicit `--bun` on the flame CLI itself (e.g. `flame dev --bun`).
+// Distinct from `bun run --bun dev` (consumed by bun, never reaches here).
+// Stripped so downstream entries don't see an unknown flag.
+const bunFlagIndex = process.argv.indexOf("--bun");
+const wantBun = bunFlagIndex !== -1;
+if (wantBun) process.argv.splice(bunFlagIndex, 1);
+
 // Runtime detection — override with FLAME_RUNTIME=bun|node|deno for testing.
 // Deno's npm compat layer may expose `Bun` via globals, check execPath first.
-const runtime =
+// The shebang (#!/usr/bin/env node) hides `typeof Bun` under `bun run`, so a
+// bun PM also selects the bun runtime; the re-exec below lands on it.
+let runtime =
   process.env.FLAME_RUNTIME ||
   (process.execPath.includes("deno")
     ? "deno"
@@ -18,6 +44,35 @@ const runtime =
       : typeof Deno !== "undefined"
         ? "deno"
         : "node");
+if (wantBun) runtime = "bun";
+else if (
+  !process.env.FLAME_RUNTIME &&
+  runtime === "node" &&
+  detectPkgManager(process.cwd()) === "bun"
+)
+  runtime = "bun";
+
+// Re-exec under `bun` when selected but this process is node. One spawn per
+// command; FLAME_REEXEC guards the loop; silent node fallback when `bun` is
+// missing unless explicitly requested.
+if (
+  runtime === "bun" &&
+  typeof Bun === "undefined" &&
+  !process.execPath.includes("deno") &&
+  !process.env.FLAME_REEXEC
+) {
+  const result = spawnSync("bun", [process.argv[1], ...process.argv.slice(2)], {
+    stdio: "inherit",
+    env: { ...process.env, FLAME_REEXEC: "1" },
+  });
+  if (result.error?.code === "ENOENT") {
+    if (wantBun || process.env.FLAME_RUNTIME)
+      console.error("flame: --bun requested but `bun` not found in PATH, falling back to node.");
+    runtime = "node";
+  } else {
+    process.exit(result.status ?? 0);
+  }
+}
 
 const COMMAND_MAP = {
   bun: {
@@ -50,23 +105,6 @@ if (!COMMAND_MAP) {
 
 const command = process.argv[2];
 
-// Detect the package manager that invoked this binary. npm, pnpm, bun, and
-// yarn set npm_config_user_agent when they run a bin; fall back to lockfiles
-// in the target directory for direct invocations (e.g. `node bin/cli.js`).
-function detectPkgManager(dir) {
-  const userAgent = process.env.npm_config_user_agent || "";
-  // pnpm/yarn UA strings also contain "npm/?" — match specific tools first.
-  if (/bun\//.test(userAgent)) return "bun";
-  if (/pnpm\//.test(userAgent)) return "pnpm";
-  if (/yarn\//.test(userAgent)) return "yarn";
-  if (/npm\//.test(userAgent)) return "npm";
-  if (existsSync(join(dir, "bun.lock"))) return "bun";
-  if (existsSync(join(dir, "pnpm-lock.yaml"))) return "pnpm";
-  if (existsSync(join(dir, "yarn.lock"))) return "yarn";
-  if (existsSync(join(dir, "package-lock.json"))) return "npm";
-  return "npm";
-}
-
 // Parse flags
 const themeIndex = process.argv.indexOf("--theme");
 if (themeIndex !== -1 && themeIndex + 1 < process.argv.length) {