@agent-native/core 0.4.5 → 0.6.1

package/dist/deploy/build.js

@@ -16,13 +16,12 @@ import path from "path";
 import fs from "fs";
 import { execFileSync } from "child_process";
 import { createRequire } from "module";
-import { discoverApiRoutes, discoverPlugins, } from "./route-discovery.js";
+import { discoverApiRoutes, discoverPlugins, discoverActionFiles, getMissingDefaultPlugins, DEFAULT_PLUGIN_REGISTRY, } from "./route-discovery.js";
 const cwd = process.cwd();
 const preset = process.env.NITRO_PRESET || "node";
 /** Plugins that require Node.js runtime and cannot run on edge/serverless */
 const NODE_ONLY_PLUGINS = new Set([
     "terminal", // PTY requires child_process
-    "file-sync", // chokidar requires fs watchers
 ]);
 function isNodeOnlyPlugin(filePath) {
     const basename = path.basename(filePath, path.extname(filePath));
@@ -31,15 +30,33 @@ function isNodeOnlyPlugin(filePath) {
 /**
  * Generate the worker entry source code that wires up H3 + React Router SSR.
  */
-function generateWorkerEntry(routes, pluginPaths) {
+function generateWorkerEntry(routes, pluginPaths, defaultPluginStems = [], actions = []) {
     const routeImports = [];
     const routeRegistrations = [];
     for (let i = 0; i < routes.length; i++) {
         const r = routes[i];
         const varName = `route_${i}`;
-        // Use the absolute path for the import
         routeImports.push(`import ${varName} from ${JSON.stringify(r.absPath)};`);
-        routeRegistrations.push(`  router.${r.method}(${JSON.stringify(r.route)}, ${varName});`);
+        routeRegistrations.push(`  app.on(${JSON.stringify(r.method.toUpperCase())}, ${JSON.stringify(r.route)}, ${varName});`);
+    }
+    // Action route imports and registrations
+    const actionImports = [];
+    const actionRegistrations = [];
+    for (let i = 0; i < actions.length; i++) {
+        const a = actions[i];
+        const varName = `action_${i}`;
+        actionImports.push(`import ${varName} from ${JSON.stringify(a.absPath)};`);
+        const routePath = `/_agent-native/actions/${a.name}`;
+        actionRegistrations.push(`  app.on(${JSON.stringify(a.method.toUpperCase())}, ${JSON.stringify(routePath)}, defineEventHandler(async (event) => {
+    const params = ${a.method === "get" ? "Object.fromEntries(event.url.searchParams)" : "(await readBody(event)) ?? {}"};
+    try {
+      const result = await ${varName}.run(params);
+      if (typeof result === "string") { try { return JSON.parse(result); } catch { return result; } }
+      return result;
+    } catch (err) {
+      return new Response(JSON.stringify({ error: err?.message || "Action failed" }), { status: err?.message?.startsWith("Invalid action parameters:") ? 400 : 500, headers: { "Content-Type": "application/json" } });
+    }
+  }));`);
     }
     // Filter out Node-only plugins
     const edgePlugins = pluginPaths.filter((p) => !isNodeOnlyPlugin(p));
@@ -49,18 +66,34 @@ function generateWorkerEntry(routes, pluginPaths) {
         const varName = `plugin_${i}`;
         pluginImports.push(`import ${varName} from ${JSON.stringify(edgePlugins[i])};`);
         pluginCalls.push(`  if (typeof ${varName} === "function") {
-    await ${varName}({ h3App: app });
+    await ${varName}(nitroApp);
+  }`);
+    }
+    // Auto-mounted default plugins (from core, for missing plugin files)
+    const edgeDefaultStems = defaultPluginStems.filter((stem) => !NODE_ONLY_PLUGINS.has(stem));
+    for (let i = 0; i < edgeDefaultStems.length; i++) {
+        const stem = edgeDefaultStems[i];
+        const exportName = DEFAULT_PLUGIN_REGISTRY[stem];
+        if (!exportName)
+            continue;
+        const varName = `defaultPlugin_${i}`;
+        pluginImports.push(`import { ${exportName} as ${varName} } from "@agent-native/core/server";`);
+        pluginCalls.push(`  if (typeof ${varName} === "function") {
+    await ${varName}(nitroApp);
   }`);
     }
     return `
 // Auto-generated worker entry point for ${preset}
-import { createApp, createRouter, toWebHandler, defineEventHandler, toWebRequest } from "h3";
+import { H3, defineEventHandler, readBody } from "h3";
 import { createRequestHandler } from "react-router";
 import * as serverBuild from "./server-build.js";
 
 // API route handlers
 ${routeImports.join("\n")}
 
+// Action handlers (auto-discovered from actions/)
+${actionImports.join("\n")}
+
 // Server plugins
 ${pluginImports.join("\n")}
 
@@ -69,45 +102,55 @@ let _handler;
 async function getHandler() {
   if (_handler) return _handler;
 
-  const app = createApp();
-  const router = createRouter();
+  const app = new H3();
+
+  // Build a fake nitroApp surface so framework plugins (which expect
+  // \`nitroApp.h3["~middleware"]\`) can register routes via getH3App().
+  const noop = () => {};
+  const nitroApp = {
+    h3: app,
+    hooks: { hook: noop, callHook: noop, hookOnce: noop },
+    captureError: noop,
+  };
 
-  // CORS
+  // CORS — applied as global middleware via .use(handler)
   app.use(defineEventHandler((event) => {
-    const headers = event.node?.res || event.res;
-    if (headers?.setHeader) {
-      headers.setHeader("Access-Control-Allow-Origin", "*");
-      headers.setHeader("Access-Control-Allow-Methods", "GET,POST,PUT,PATCH,DELETE,OPTIONS");
-      headers.setHeader("Access-Control-Allow-Headers", "Content-Type,Authorization,X-Requested-With");
-    }
-    if (event.method === "OPTIONS" || event.node?.req?.method === "OPTIONS") {
-      return new Response(null, { status: 204 });
+    if (event.req.method === "OPTIONS") {
+      return new Response(null, {
+        status: 204,
+        headers: {
+          "Access-Control-Allow-Origin": "*",
+          "Access-Control-Allow-Methods": "GET,POST,PUT,PATCH,DELETE,OPTIONS",
+          "Access-Control-Allow-Headers": "Content-Type,Authorization,X-Requested-With",
+        },
+      });
     }
   }));
 
-  // Run plugins BEFORE routes — auth middleware must be mounted first
+  // Run plugins — they call getH3App(nitroApp).use(path, handler) which
+  // pushes path-prefix middleware onto app["~middleware"].
 ${pluginCalls.join("\n")}
 
-  // Mount router AFTER plugins so auth middleware runs first
-  app.use(router);
-
   // Register API routes
 ${routeRegistrations.join("\n")}
 
+  // Register action routes (/_agent-native/actions/*)
+${actionRegistrations.join("\n")}
+
   // SSR catch-all for React Router
   const rrHandler = createRequestHandler(() => serverBuild);
-  router.get("/**", defineEventHandler(async (event) => {
-    const webReq = toWebRequest(event);
-    return rrHandler(webReq);
+  app.all("/**", defineEventHandler(async (event) => {
+    return rrHandler(event.req);
   }));
 
-  _handler = toWebHandler(app);
+  _handler = app.fetch.bind(app);
   return _handler;
 }
 
 export default {
   async fetch(request, env, ctx) {
-    // Expose env bindings globally for compatibility
+    // Expose env and ctx bindings globally for compatibility
+    if (ctx) globalThis.__cf_ctx = ctx;
     if (env) {
       globalThis.process = globalThis.process || { env: {} };
       globalThis.process.env = globalThis.process.env || {};
@@ -120,8 +163,12 @@ export default {
       }
     }
 
-    // Try serving static assets first (CF Pages advanced mode)
-    if (env?.ASSETS) {
+    // Try serving static assets first (CF Pages advanced mode).
+    // Only attempt this for GET/HEAD — the ASSETS binding is a static file
+    // server and returns 405 for any other method, which would short-circuit
+    // API calls (PUT/POST/DELETE to /_agent-native/*) before they reach our
+    // h3 middleware.
+    if (env?.ASSETS && (request.method === "GET" || request.method === "HEAD")) {
       try {
         const assetResponse = await env.ASSETS.fetch(request);
         if (assetResponse.status !== 404) {
@@ -132,7 +179,6 @@ export default {
       }
     }
 
-
     const handler = await getHandler();
     return handler(request);
   }
@@ -169,12 +215,14 @@ async function buildCloudflarePages() {
     const stubsDir = path.join(distDir, "_worker.js", "stubs");
     fs.mkdirSync(stubsDir, { recursive: true });
     fs.writeFileSync(path.join(stubsDir, "empty.js"), "export default {}; export const watch = () => ({ close() {} }); export const Database = class {};\n");
-    // Discover routes and plugins
-    const routes = discoverApiRoutes(cwd);
-    const plugins = discoverPlugins(cwd);
-    console.log(`[deploy] ${routes.length} API routes, ${plugins.length} plugins (${plugins.filter((p) => isNodeOnlyPlugin(p)).length} skipped as Node-only)`);
+    // Discover routes, plugins, and actions
+    const routes = await discoverApiRoutes(cwd);
+    const plugins = await discoverPlugins(cwd);
+    const actions = await discoverActionFiles(cwd);
+    const missingDefaults = await getMissingDefaultPlugins(cwd);
+    console.log(`[deploy] ${routes.length} API routes, ${actions.length} actions, ${plugins.length} plugins (${plugins.filter((p) => isNodeOnlyPlugin(p)).length} skipped as Node-only), ${missingDefaults.length} auto-mounted defaults`);
     // Generate the worker entry
-    const entrySource = generateWorkerEntry(routes, plugins);
+    const entrySource = generateWorkerEntry(routes, plugins, missingDefaults, actions);
     // Create _worker.js output directory
     const workerOutDir = path.join(distDir, "_worker.js");
     fs.mkdirSync(workerOutDir, { recursive: true });
@@ -202,6 +250,7 @@ async function buildCloudflarePages() {
         "chokidar",
         "fsevents",
         "dotenv",
+        "@anthropic-ai/sdk",
     ];
     const stubDir = path.join(tmpDir, "node_modules");
     for (const mod of stubModules) {
@@ -248,11 +297,28 @@ async function buildCloudflarePages() {
         workerCode2 = `/* __unenv_fs_patched__ */\n` + workerCode2;
     }
     fs.writeFileSync(entryFile, workerCode2);
+    // Patch setInterval/setTimeout at module scope — CF Workers disallows timers in global scope.
+    // Some dependencies (e.g. Anthropic SDK rate limiter) call setInterval at module init.
+    // Inject a banner that makes setInterval/setTimeout safe during module evaluation,
+    // then restores them inside the first fetch() call.
+    let workerCode = fs.readFileSync(entryFile, "utf-8");
+    const timerShim = [
+        "var __origSetInterval=globalThis.setInterval;",
+        "globalThis.setInterval=function(){return{unref(){},ref(){},close(){}}};",
+    ].join("");
+    // Restore real setInterval inside the fetch handler
+    const timerRestore = "if(__origSetInterval)globalThis.setInterval=__origSetInterval;";
+    workerCode = timerShim + workerCode;
+    // Inject restore right after "async fetch(request, env, ctx) {"
+    workerCode = workerCode.replace(/async fetch\(request,\s*env,\s*ctx\)\s*\{/, (match) => match + timerRestore);
     // Strip "node:" prefix from all imports/requires — nodejs_compat v1 only provides bare names.
     // Handles minified output (no space before quotes) and subpaths like node:fs/promises.
-    let workerCode = fs.readFileSync(entryFile, "utf-8");
     workerCode = workerCode.replace(/from\s*["']node:([^"']+)["']/g, (_, mod) => `from"${mod}"`);
     workerCode = workerCode.replace(/import\s*["']node:([^"']+)["']/g, (_, mod) => `import"${mod}"`);
+    // Patch createRequire(import.meta.url) — import.meta.url is undefined in CF Workers.
+    // React Router's server build uses createRequire for CJS compat. Replace it with a
+    // stub that returns our require shim (which is already injected via the banner).
+    workerCode = workerCode.replace(/\bimport\s*\{\s*createRequire\s+as\s+([\w$]+)\s*\}\s*from\s*["']module["']\s*;/g, "var $1 = function() { return typeof require !== 'undefined' ? require : function(m) { throw new Error('require not supported: ' + m); }; };");
     fs.writeFileSync(entryFile, workerCode);
     // Report size
     const entrySize = fs.statSync(entryFile).size;
@@ -405,20 +471,548 @@ function copyDir(src, dest) {
         }
     }
 }
+/**
+ * Create stub directories for dangling platform-specific optional dependency
+ * symlinks in the pnpm store.
+ *
+ * pnpm's store at `node_modules/.pnpm/<pkg>@<ver>/node_modules/<pkg>/<dep>`
+ * contains symlinks for ALL optional deps declared by a package, but only
+ * installs the ones matching the current OS/CPU as real packages. The other
+ * symlinks dangle — their targets at `.pnpm/<scope>+<pkg>@<ver>/node_modules/...`
+ * don't exist.
+ *
+ * Nitro's `nitro:externals` plugin (via nf3 / @vercel/nft) walks
+ * optionalDependencies when tracing files and calls `realpath` on them, which
+ * throws ENOENT on dangling targets. This blocks builds with presets like
+ * netlify / vercel / aws-lambda on macOS when packages like `libsql` declare
+ * Linux-only platform variants as optional deps.
+ *
+ * Fix: walk `node_modules/.pnpm/` and for every dangling symlink under
+ * `<pkg>/node_modules/<scope>/<dep>`, create the symlink's target as a tiny
+ * stub directory containing just a valid `package.json`. The tracer can now
+ * `realpath` and read the package.json without throwing — the stub is empty
+ * so no binary is bundled (which is what we want: we're building from macOS,
+ * the target deploy platform will install its own native binary).
+ */
+function createDanglingOptionalDepStubs() {
+    // In pnpm monorepos, the store may live at the workspace root rather than
+    // in the template dir. Walk up from `cwd` to find every `.pnpm` directory.
+    const pnpmRoots = [];
+    let dir = cwd;
+    while (true) {
+        const candidate = path.join(dir, "node_modules", ".pnpm");
+        if (fs.existsSync(candidate))
+            pnpmRoots.push(candidate);
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    if (pnpmRoots.length === 0)
+        return;
+    let stubsCreated = 0;
+    for (const pnpmRoot of pnpmRoots) {
+        let pkgDirs;
+        try {
+            pkgDirs = fs.readdirSync(pnpmRoot);
+        }
+        catch {
+            continue;
+        }
+        for (const pkgDir of pkgDirs) {
+            // e.g. `libsql@0.5.29`, `@libsql+client@0.15.15`
+            const innerNm = path.join(pnpmRoot, pkgDir, "node_modules");
+            if (!fs.existsSync(innerNm))
+                continue;
+            let innerEntries;
+            try {
+                innerEntries = fs.readdirSync(innerNm, { withFileTypes: true });
+            }
+            catch {
+                continue;
+            }
+            for (const entry of innerEntries) {
+                // Top-level entry: either `foo` (unscoped) or `@scope` (scoped)
+                const entryPath = path.join(innerNm, entry.name);
+                const candidates = [];
+                if (entry.name.startsWith("@")) {
+                    // Scoped — iterate children
+                    let scopedChildren;
+                    try {
+                        scopedChildren = fs.readdirSync(entryPath, {
+                            withFileTypes: true,
+                        });
+                    }
+                    catch {
+                        continue;
+                    }
+                    for (const child of scopedChildren) {
+                        candidates.push({
+                            symlinkPath: path.join(entryPath, child.name),
+                            pkgName: `${entry.name}/${child.name}`,
+                        });
+                    }
+                }
+                else {
+                    candidates.push({ symlinkPath: entryPath, pkgName: entry.name });
+                }
+                for (const { symlinkPath, pkgName } of candidates) {
+                    let isSymlink = false;
+                    try {
+                        isSymlink = fs.lstatSync(symlinkPath).isSymbolicLink();
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (!isSymlink)
+                        continue;
+                    // Check if the symlink target exists
+                    try {
+                        fs.statSync(symlinkPath);
+                        continue; // Target exists — nothing to do
+                    }
+                    catch {
+                        // Dangling symlink — create a stub at the target
+                    }
+                    let linkTarget;
+                    try {
+                        linkTarget = fs.readlinkSync(symlinkPath);
+                    }
+                    catch {
+                        continue;
+                    }
+                    const resolvedTarget = path.resolve(path.dirname(symlinkPath), linkTarget);
+                    try {
+                        fs.mkdirSync(resolvedTarget, { recursive: true });
+                        const stubPkgJson = {
+                            name: pkgName,
+                            version: "0.0.0-stub",
+                            description: "Empty stub created by @agent-native/core deploy build to satisfy nitro's file tracer on platforms where this optional dep is not installed.",
+                        };
+                        fs.writeFileSync(path.join(resolvedTarget, "package.json"), JSON.stringify(stubPkgJson, null, 2));
+                        stubsCreated++;
+                    }
+                    catch {
+                        // Best-effort — ignore failures
+                    }
+                }
+            }
+        }
+    }
+    if (stubsCreated > 0) {
+        console.log(`[deploy] Created ${stubsCreated} stub package dir(s) for dangling optional deps (platform-specific binaries not installed on this host).`);
+    }
+}
+/**
+ * Build for any non-Cloudflare preset using Nitro's programmatic build API.
+ * Handles netlify, vercel, deno_deploy, aws-lambda, and all other targets.
+ */
+async function buildWithNitro() {
+    console.log(`[deploy] Building for preset "${preset}" via Nitro...`);
+    // Work around pnpm + nitro:externals (nf3) bug where dangling symlinks for
+    // platform-specific optional deps cause realpath ENOENT during file tracing.
+    createDanglingOptionalDepStubs();
+    const { createNitro, prepare, copyPublicAssets, build: nitroBuild, } = await import("nitro/builder");
+    // Resolve the React Router server build so the SSR catch-all route
+    // can import "virtual:react-router/server-build" in production.
+    const rrServerBuild = path.join(cwd, "build", "server", "index.js");
+    // Inline the template's AGENTS.md + .agents/skills/ content into the Nitro
+    // bundle via the `virtual` config option. Nitro's internal `nitro:virtual`
+    // Rollup plugin picks this up and resolves `virtual:agents-bundle` to the
+    // generated ES module source. Without this, Nitro's Rolldown build (used for
+    // netlify, vercel, aws-lambda, node presets) can't resolve the virtual
+    // module that `server/agents-bundle.ts` imports — it silently falls through
+    // to an empty bundle and the agent gets no instructions/skills at runtime.
+    //
+    // The Vite plugin at `vite/agents-bundle-plugin.ts` handles this for the
+    // React Router client/server build (and cloudflare via esbuild rebundle),
+    // but Nitro runs its OWN build from ./server/ without Vite, so it needs its
+    // own virtual module registration. Both paths reuse `readAgentsBundleFromFs`
+    // from `server/agents-bundle.ts` to guarantee identical content.
+    const { readAgentsBundleFromFs } = await import("../server/agents-bundle.js");
+    const agentsBundleModuleSource = () => {
+        const bundle = readAgentsBundleFromFs(cwd);
+        return `// AUTO-GENERATED by @agent-native/core deploy build (Nitro virtual)
+// Contains the inlined AGENTS.md + .agents/skills/ content from the template.
+const bundle = ${JSON.stringify(bundle)};
+export default bundle;
+`;
+    };
+    const nitro = await createNitro({
+        rootDir: cwd,
+        dev: false,
+        preset,
+        minify: true,
+        serverDir: "./server",
+        alias: fs.existsSync(rrServerBuild)
+            ? { "virtual:react-router/server-build": rrServerBuild }
+            : {},
+        virtual: {
+            "virtual:agents-bundle": agentsBundleModuleSource,
+        },
+        // For edge presets (cloudflare, deno), bundle all deps — node_modules
+        // aren't available at runtime. Netlify/Vercel/Node have node_modules.
+        ...(preset.startsWith("cloudflare") || preset.startsWith("deno")
+            ? { noExternals: true }
+            : {}),
+    });
+    await prepare(nitro);
+    await copyPublicAssets(nitro);
+    await nitroBuild(nitro);
+    // Copy React Router's client build into Nitro's public output dir
+    const clientDir = path.join(cwd, "build", "client");
+    const publicOutputDir = nitro.options.output.publicDir;
+    if (fs.existsSync(clientDir) && publicOutputDir) {
+        copyDir(clientDir, publicOutputDir);
+        console.log(`[deploy] Copied client assets to ${path.relative(cwd, publicOutputDir)}`);
+    }
+    // Resolve remaining bare npm imports by bundling them into _libs/.
+    // Nitro sometimes leaves small packages as externals even with noExternals.
+    if (preset.startsWith("cloudflare") || preset.startsWith("deno")) {
+        const { execFileSync } = await import("child_process");
+        const { createRequire } = await import("module");
+        const esbuildBin = (() => {
+            try {
+                const _req = createRequire(cwd + "/");
+                const pkg = path.dirname(_req.resolve("esbuild/package.json"));
+                const bin = path.join(pkg, "bin", "esbuild");
+                if (fs.existsSync(bin))
+                    return bin;
+            }
+            catch { }
+            return "esbuild";
+        })();
+        // Scan all output files for bare npm imports
+        const outputDir = nitro.options.output.serverDir || path.join(cwd, "dist", "_worker.js");
+        const bareImports = new Set();
+        function scanForBareImports(dir) {
+            if (!fs.existsSync(dir))
+                return;
+            for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+                const p = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    scanForBareImports(p);
+                    continue;
+                }
+                if (!entry.name.endsWith(".mjs") && !entry.name.endsWith(".js"))
+                    continue;
+                const code = fs.readFileSync(p, "utf-8");
+                const matches = code.matchAll(/from\s*["']([a-z@][a-z0-9._\-/]*)["']/g);
+                for (const m of matches) {
+                    const mod = m[1];
+                    if (mod.startsWith("node:"))
+                        continue;
+                    // Skip Node builtins that are available via nodejs_compat
+                    const builtins = new Set([
+                        "fs",
+                        "path",
+                        "os",
+                        "crypto",
+                        "http",
+                        "https",
+                        "stream",
+                        "url",
+                        "util",
+                        "events",
+                        "buffer",
+                        "net",
+                        "tls",
+                        "assert",
+                        "timers",
+                        "child_process",
+                        "module",
+                        "process",
+                        "worker_threads",
+                        "querystring",
+                        "zlib",
+                        "vm",
+                        "string_decoder",
+                        "diagnostics_channel",
+                        "async_hooks",
+                        "perf_hooks",
+                        "inspector",
+                    ]);
+                    if (builtins.has(mod))
+                        continue;
+                    bareImports.add(mod);
+                }
+            }
+        }
+        scanForBareImports(outputDir);
+        // For each bare import, try to bundle it as a standalone module
+        if (bareImports.size > 0) {
+            const libsDir = path.join(outputDir, "_libs");
+            fs.mkdirSync(libsDir, { recursive: true });
+            for (const mod of bareImports) {
+                const outFile = path.join(libsDir, `${mod.replace(/[/@]/g, "_")}.mjs`);
+                try {
+                    // Try resolving from both template dir and workspace root
+                    const nodePaths = [
+                        path.join(cwd, "node_modules"),
+                        path.resolve(cwd, "../../node_modules"),
+                    ].filter((p) => fs.existsSync(p));
+                    // Resolve the module — check workspace node_modules and pnpm store
+                    let resolvedMod = mod;
+                    const _require = createRequire(cwd + "/");
+                    try {
+                        const resolved = _require.resolve(mod);
+                        resolvedMod = resolved;
+                    }
+                    catch {
+                        // Try from workspace root
+                        try {
+                            const wsRequire = createRequire(path.resolve(cwd, "../../package.json"));
+                            resolvedMod = wsRequire.resolve(mod);
+                        }
+                        catch {
+                            // Will fail at esbuild
+                        }
+                    }
+                    // Scan what named imports the consumer expects, then generate
+                    // explicit re-exports to handle CJS modules properly.
+                    const neededExports = new Set();
+                    function findNeededExports(dir) {
+                        if (!fs.existsSync(dir))
+                            return;
+                        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+                            const p = path.join(dir, entry.name);
+                            if (entry.isDirectory()) {
+                                findNeededExports(p);
+                                continue;
+                            }
+                            if (!entry.name.endsWith(".mjs") && !entry.name.endsWith(".js"))
+                                continue;
+                            const code = fs.readFileSync(p, "utf-8");
+                            // Match: import{foo as bar,baz}from"<mod>"
+                            const escaped = mod.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+                            const re = new RegExp(`import\\{([^}]+)\\}from["']${escaped}["']`, "g");
+                            for (const m2 of code.matchAll(re)) {
+                                for (const part of m2[1].split(",")) {
+                                    const name = part
+                                        .trim()
+                                        .split(/\s+as\s+/)[0]
+                                        .trim();
+                                    if (name && /^[a-zA-Z_$]/.test(name))
+                                        neededExports.add(name);
+                                }
+                            }
+                        }
+                    }
+                    findNeededExports(outputDir);
+                    const entryCode = neededExports.size > 0
+                        ? [
+                            `import _mod from "${resolvedMod}";`,
+                            `export default _mod;`,
+                            ...Array.from(neededExports).map((n) => `export const ${n} = _mod.${n} ?? _mod?.default?.${n};`),
+                        ].join("\n")
+                        : `export * from "${resolvedMod}"; export { default } from "${resolvedMod}";`;
+                    execFileSync(esbuildBin, [
+                        "--bundle",
+                        `--outfile=${outFile}`,
+                        "--format=esm",
+                        "--platform=neutral",
+                        "--target=es2022",
+                        "--external:node:*",
+                    ], {
+                        input: entryCode,
+                        cwd,
+                        stdio: ["pipe", "pipe", "pipe"],
+                    });
+                    // Rewrite imports in all files to point to the bundled module
+                    function rewriteImports(dir) {
+                        if (!fs.existsSync(dir))
+                            return;
+                        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+                            const p = path.join(dir, entry.name);
+                            if (entry.isDirectory()) {
+                                rewriteImports(p);
+                                continue;
+                            }
+                            if (!entry.name.endsWith(".mjs") && !entry.name.endsWith(".js"))
+                                continue;
+                            let code = fs.readFileSync(p, "utf-8");
+                            const relPath = path
+                                .relative(path.dirname(p), outFile)
+                                .replace(/\\/g, "/");
+                            const importPath = relPath.startsWith(".")
+                                ? relPath
+                                : "./" + relPath;
+                            const re = new RegExp(`from["']${mod.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["']`, "g");
+                            if (re.test(code)) {
+                                code = code.replace(re, `from"${importPath}"`);
+                                fs.writeFileSync(p, code);
+                            }
+                        }
+                    }
+                    rewriteImports(outputDir);
+                    console.log(`[deploy] Bundled external: ${mod}`);
+                }
+                catch {
+                    console.warn(`[deploy] Could not bundle: ${mod} (may not be needed at runtime)`);
+                }
+            }
+        }
+    }
+    // Cloudflare-specific post-build patches
+    if (preset.startsWith("cloudflare")) {
+        const serverDir2 = nitro.options.output.serverDir;
+        const scanDirs = [serverDir2];
+        if (serverDir2) {
+            const chunksDir = path.join(serverDir2, "_chunks");
+            const libsDir = path.join(serverDir2, "_libs");
+            if (fs.existsSync(chunksDir))
+                scanDirs.push(chunksDir);
+            if (fs.existsSync(libsDir))
+                scanDirs.push(libsDir);
+        }
+        for (const scanDir of scanDirs) {
+            if (!scanDir || !fs.existsSync(scanDir))
+                continue;
+            for (const file of fs.readdirSync(scanDir)) {
+                if (!file.endsWith(".mjs") && !file.endsWith(".js"))
+                    continue;
+                const filePath = path.join(scanDir, file);
+                let code = fs.readFileSync(filePath, "utf-8");
+                let changed = false;
+                // 1. Rewrite bare Node.js imports to node: prefixed.
+                // CF Workers requires the node: prefix for built-in modules.
+                const NODE_BUILTINS = [
+                    "fs",
+                    "path",
+                    "os",
+                    "crypto",
+                    "http",
+                    "https",
+                    "stream",
+                    "url",
+                    "util",
+                    "events",
+                    "buffer",
+                    "querystring",
+                    "zlib",
+                    "net",
+                    "tls",
+                    "assert",
+                    "timers",
+                    "child_process",
+                    "module",
+                    "process",
+                    "worker_threads",
+                    "string_decoder",
+                    "diagnostics_channel",
+                    "async_hooks",
+                    "perf_hooks",
+                    "inspector",
+                    "vm",
+                ];
+                for (const mod of NODE_BUILTINS) {
+                    // Match: from"fs" or from "fs" (but not from"node:fs")
+                    const re = new RegExp(`from\\s*["']${mod}["']`, "g");
+                    if (re.test(code)) {
+                        code = code.replace(re, `from"node:${mod}"`);
+                        changed = true;
+                    }
+                }
+                // 2. Patch import.meta.url for createRequire().
+                // React Router's server build uses createRequire(import.meta.url)
+                // but import.meta.url is undefined on CF Workers.
+                if (code.includes("import.meta.url")) {
+                    code = code.replace(/import\.meta\.url/g, '"file:///worker.mjs"');
+                    changed = true;
+                }
+                // 3. Patch setInterval/setTimeout at global scope.
+                // CF Workers disallows timers in global scope.
+                if (code.includes("setInterval") && !code.includes("__timer_shim__")) {
+                    const shim = "/* __timer_shim__ */" +
+                        "var __origSetInterval=globalThis.setInterval;" +
+                        "globalThis.setInterval=function(){return{unref(){},ref(){},close(){}}};";
+                    const restore = ";(function(){if(typeof __origSetInterval!=='undefined')globalThis.setInterval=__origSetInterval})();";
+                    code = shim + code + "\n" + restore;
+                    changed = true;
+                }
+                if (changed)
+                    fs.writeFileSync(filePath, code);
+            }
+        }
+        // 3. Create stub modules in _libs/ for native deps that Nitro's rolldown
+        // bundler references but can't resolve on CF Workers, and rewrite
+        // bare imports to point to the stub files.
+        const libsDir2 = path.join(serverDir2 || path.join(cwd, "dist", "_worker.js"), "_libs");
+        if (fs.existsSync(libsDir2)) {
+            const NATIVE_STUBS = ["better-sqlite3", "node-pty", "cron-parser"];
+            for (const mod of NATIVE_STUBS) {
+                const libFiles = fs
+                    .readdirSync(libsDir2)
+                    .filter((f) => f.endsWith(".mjs"));
+                const referencingFiles = [];
+                for (const f of libFiles) {
+                    const filePath = path.join(libsDir2, f);
+                    const content = fs.readFileSync(filePath, "utf-8");
+                    if (content.includes(`"${mod}"`) || content.includes(`'${mod}'`)) {
+                        referencingFiles.push(filePath);
+                    }
+                }
+                if (referencingFiles.length === 0)
+                    continue;
+                // Create a stub _libs/<mod>.mjs that exports empty defaults
+                const stubName = mod.replace(/[/@]/g, "__") + ".mjs";
+                const stubPath = path.join(libsDir2, stubName);
+                if (!fs.existsSync(stubPath)) {
+                    fs.writeFileSync(stubPath, `export default {}; export const watch = () => ({ close() {} });\n`);
+                    console.log(`[deploy] Created stub for _libs/${stubName}`);
+                }
+                // Rewrite bare imports in _libs/ and _chunks/ to use the stub
+                const escaped = mod.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+                const importRe = new RegExp(`(from\\s*["'])${escaped}(["'])`, "g");
+                // Scan _libs/ files
+                for (const filePath of referencingFiles) {
+                    let code = fs.readFileSync(filePath, "utf-8");
+                    if (importRe.test(code)) {
+                        code = code.replace(importRe, `$1./${stubName}$2`);
+                        fs.writeFileSync(filePath, code);
+                        console.log(`[deploy] Rewrote ${mod} imports in _libs/${path.basename(filePath)}`);
+                    }
+                }
+                // Also scan _chunks/ files (they import native deps too)
+                const chunksDir2 = path.join(serverDir2 || path.join(cwd, "dist", "_worker.js"), "_chunks");
+                if (fs.existsSync(chunksDir2)) {
+                    for (const f of fs
+                        .readdirSync(chunksDir2)
+                        .filter((f) => f.endsWith(".mjs") || f.endsWith(".js"))) {
+                        const filePath = path.join(chunksDir2, f);
+                        let code = fs.readFileSync(filePath, "utf-8");
+                        if (importRe.test(code)) {
+                            // From _chunks/, the stub is at ../_libs/<stubName>
+                            code = code.replace(importRe, `$1../_libs/${stubName}$2`);
+                            fs.writeFileSync(filePath, code);
+                            console.log(`[deploy] Rewrote ${mod} imports in _chunks/${f}`);
+                        }
+                    }
+                }
+            }
+        }
+        console.log("[deploy] Patched bare Node imports, timer calls, and route finder for CF Workers");
+    }
+    await nitro.close();
+    console.log(`[deploy] Nitro build complete for preset "${preset}".`);
+}
 // Main
-const SUPPORTED_PRESETS = ["cloudflare_pages"];
 if (preset === "node") {
-    // No post-processing needed for Node.js target
     process.exit(0);
 }
-if (!SUPPORTED_PRESETS.includes(preset)) {
-    console.error(`[deploy] Unsupported preset: ${preset}. Supported: ${SUPPORTED_PRESETS.join(", ")}`);
-    process.exit(1);
-}
 console.log(`[deploy] Building for ${preset}...`);
 switch (preset) {
     case "cloudflare_pages":
+    case "cloudflare-pages":
+        // Cloudflare Workers require a single-file bundle that wrangler can deploy.
+        // Nitro's native presets produce split chunks that wrangler can't upload
+        // as multi-module Workers. Use the custom esbuild-based bundler.
         await buildCloudflarePages();
         break;
+    default:
+        // All other presets (netlify, vercel, deno_deploy, aws-lambda, etc.)
+        // are handled natively by Nitro's build API.
+        await buildWithNitro();
+        break;
 }
 //# sourceMappingURL=build.js.map