@agent-native/core 0.169.1 → 0.171.0

package/dist/deploy/build.js

@@ -32,7 +32,7 @@ import { isTruthyRuntimeValue } from "../shared/runtime-config.js";
 import { AGENT_NATIVE_SOCIAL_IMAGE_ALT, AGENT_NATIVE_SOCIAL_IMAGE_CACHE_BUSTER, AGENT_NATIVE_SOCIAL_IMAGE_HEIGHT, AGENT_NATIVE_SOCIAL_IMAGE_PATH, AGENT_NATIVE_SOCIAL_IMAGE_TYPE, AGENT_NATIVE_SOCIAL_IMAGE_WIDTH, } from "../shared/social-meta.js";
 import { generateActionRegistryForProject } from "../vite/action-types-plugin.js";
 import { createAgentNativeConfigContext, loadResolvedAgentNativeConfig, } from "../vite/agent-native-config-loader.js";
-import { cloneServerBundleForFunction, copyDir } from "./function-bundle.js";
+import { cloneServerBundleForFunction, copyDir, pruneSsrIslandFromRewritingClone, readPackageManifest, SERVERLESS_BROWSER_RUNTIME_PACKAGES, } from "./function-bundle.js";
 import { collectImmutableAssetPaths, IMMUTABLE_ASSET_CACHE_CONTROL, IMMUTABLE_ASSET_CACHE_HEADERS, prefixAssetPath, } from "./immutable-assets.js";
 import { writeNetlifyStaticHeaders } from "./netlify-static-headers.js";
 import { discoverApiRoutes, discoverPlugins, discoverActionFiles, getMissingDefaultPlugins, DEFAULT_PLUGIN_REGISTRY, } from "./route-discovery.js";
@@ -766,10 +766,17 @@ ${["post", "put", "delete"]
                 continue;
             pluginImports.push(`import { ${defaultExportName} as ${varName} } from "${EDGE_SERVER_ENTRYPOINT}";`);
         }
-        pluginCalls.push(`  if (typeof ${varName} === "function") {
+        // The worker entry mounts defaults statically, so the `plugins.disabled`
+        // check that `bootstrapDefaultPlugins` runs has to happen here too —
+        // otherwise the same config withholds a plugin on Node hosts and mounts it
+        // on the edge.
+        pluginCalls.push(`  if (typeof ${varName} === "function" && !isDefaultPluginDisabled(${JSON.stringify(stem)})) {
     await ${varName}(nitroApp);
   }`);
     }
+    if (edgeDefaultStems.length > 0) {
+        pluginImports.unshift(`import { isDefaultPluginDisabled } from "${EDGE_SERVER_ENTRYPOINT}";`);
+    }
     const generatedPluginMarks = providedPluginStems.size > 0
         ? [
             ...new Set([
@@ -2065,10 +2072,6 @@ const LIBSQL_NATIVE_PACKAGE_NAMES = [
 const FFMPEG_STATIC_PACKAGE_NAME = "ffmpeg-static";
 const RESVG_SCOPE = "@resvg";
 const RESVG_PACKAGE_PREFIX = "resvg-js";
-const SERVERLESS_BROWSER_RUNTIME_PACKAGES = [
-    "@sparticuz/chromium",
-    "playwright-core",
-];
 const SERVERLESS_BROWSER_RUNTIME_CONSUMER = "@agent-native/creative-context";
 const PACKAGE_DEPENDENCY_FIELDS = [
     "dependencies",
@@ -2112,6 +2115,28 @@ const SERVERLESS_FUNCTION_PACKAGE_DENYLIST = new Set([
     "fsevents",
     "node-pty",
     "playwright",
+    // Nitro traces these from officeparser's PDF-output branch, which nothing in
+    // this repo reaches — the creative-context browser path uses playwright-core,
+    // not puppeteer. `pdf` output from officeparser now fails loudly instead of
+    // launching a second, unused browser stack in every function.
+    "puppeteer",
+    "puppeteer-core",
+    "chromium-bidi",
+]);
+/**
+ * Declared dependencies of the browser tree that only the Bare runtime can
+ * load. tar-stream hard-depends on bare-fs and events-universal on bare-events,
+ * but on Node both exports maps resolve to the plain builtins instead, so these
+ * are never required — and most of their bytes are android/darwin/win32
+ * prebuilds a Linux function could not execute anyway.
+ */
+const BARE_RUNTIME_ONLY_PACKAGES = new Set([
+    "bare-events",
+    "bare-fs",
+    "bare-path",
+    "bare-stream",
+    "bare-url",
+    "teex",
 ]);
 function serverlessFfmpegStaticTargetArchFromEnv() {
     const value = process.env.AGENT_NATIVE_SERVERLESS_FFMPEG_ARCH;
@@ -2139,16 +2164,6 @@ function nodeModulesAncestors(startDir) {
     }
     return dirs;
 }
-function readPackageManifest(packageDir) {
-    const packageJsonPath = path.join(packageDir, "package.json");
-    if (!fs.existsSync(packageJsonPath))
-        return null;
-    const manifest = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
-    if (!manifest || typeof manifest !== "object" || Array.isArray(manifest)) {
-        return null;
-    }
-    return manifest;
-}
 function manifestDeclaresDependency(manifest, packageName) {
     if (!manifest)
         return false;
@@ -2237,6 +2252,13 @@ function copyRuntimePackageTree(packageName, packageDir, serverDir, nodeModulesR
         return 1;
     let copiedCount = 1;
     for (const dependencyName of Object.keys(dependencies)) {
+        // Declared by tar-stream and events-universal but unreachable on Node: both
+        // exports maps send Node to a plain fs/path implementation, and only the
+        // Bare runtime sets the condition that selects these. Skipped inside the
+        // loop, before resolution, so an unresolvable REAL dependency still fails
+        // loudly below.
+        if (BARE_RUNTIME_ONLY_PACKAGES.has(dependencyName))
+            continue;
         const dependencyDir = findInstalledPackageRoot(dependencyName, nodeModulesRoots, packageDir);
         if (!dependencyDir) {
             throw new Error(`[deploy] Could not resolve ${dependencyName}, required by ${packageName}, for the serverless browser runtime.`);
@@ -2267,6 +2289,15 @@ export function copyInstalledBrowserRuntimePackages(serverDir, projectCwd = cwd)
             continue;
         copiedCount += copyRuntimePackageTree(packageName, packageDir, serverDir, nodeModulesRoots, copiedPackages);
     }
+    // playwright-core ships its own developer tooling: lib/vite is the trace
+    // viewer, HTML reporter, codegen recorder and CLI dashboard UI, and lib/tools
+    // plus bin/ and cli.js are the command line. A function reaches none of them —
+    // they are only entered from startTraceViewerServer, startDashboardServer and
+    // the recorder route — and every byte is paid once per emitted function.
+    // force:true because a fixture (or a future playwright-core) may not have them.
+    for (const dead of ["lib/vite", "lib/tools", "bin", "cli.js"]) {
+        fs.rmSync(path.join(serverDir, "node_modules", "playwright-core", ...dead.split("/")), { recursive: true, force: true });
+    }
     if (copiedCount === 0) {
         // Not the same as the skip above: the app asked for the browser runtime and
         // the build could not find it, so anything that opens a browser will fail
@@ -2871,6 +2902,15 @@ export const config = {
 };
 `;
     fs.writeFileSync(path.join(dest, `${backgroundName}.mjs`), entry);
+    {
+        // The clone rewrites url.pathname unconditionally, so it can never
+        // route to the SSR page/asset handlers it inherited. Netlify zips and
+        // uploads every function separately, so that island is paid for twice.
+        const freed = pruneSsrIslandFromRewritingClone(dest, entry);
+        if (freed > 0) {
+            console.log(`[deploy] Pruned ${(freed / 1024 / 1024).toFixed(1)}MB of unroutable SSR modules from ${path.basename(dest)}.`);
+        }
+    }
     assertEmittedBackgroundFunctionOnDisk(dest, backgroundName);
     console.log(`[build] Emitted durable-background function "${backgroundName}" into the ` +
         `scanned dir .netlify/functions-internal with config { background:true } ` +
@@ -2961,6 +3001,15 @@ export const config = {
 };
 `;
     fs.writeFileSync(path.join(dest, `${functionName}.mjs`), entry);
+    {
+        // The clone rewrites url.pathname unconditionally, so it can never route to
+        // the SSR page/asset handlers it inherited. Netlify zips and uploads every
+        // function separately, so that island is paid for on every deploy.
+        const freed = pruneSsrIslandFromRewritingClone(dest, entry);
+        if (freed > 0) {
+            console.log(`[deploy] Pruned ${(freed / 1024 / 1024).toFixed(1)}MB of unroutable SSR modules from ${path.basename(dest)}.`);
+        }
+    }
 }
 /**
  * Nitro's Netlify preset can emit a harmful fallback rewrite to
@@ -3135,9 +3184,81 @@ function hasBundledFfmpegStaticRuntime(functionDir) {
     const binaryName = FFMPEG_STATIC_BINARY_NAMES[0];
     return fs.existsSync(path.join(functionDir, "node_modules", FFMPEG_STATIC_PACKAGE_NAME, binaryName));
 }
+/**
+ * Whether this function embeds the browser binary itself, which earns the size
+ * budget's browser allowance. `chromium-min` fetches the pack at launch and
+ * ships no `bin/`, so a min-based function no longer claims the allowance — the
+ * budget tightens automatically once the binary stops being bundled.
+ */
 function hasBundledServerlessBrowserRuntime(functionDir) {
     return fs.existsSync(path.join(functionDir, "node_modules", "@sparticuz", "chromium", "bin", "chromium.br"));
 }
+/**
+ * Replace the bundled `better-sqlite3` with a throwing stub in serverless
+ * output.
+ *
+ * The package is 27MB — a 9.1MB `sqlite3.c`, its object files, and a static
+ * archive, none of which a function can use: every consumer is gated on a
+ * `file:` or schemeless `DATABASE_URL`, and a serverless container holding a
+ * file-backed SQLite database is already broken, since the filesystem is
+ * ephemeral and each container gets its own copy.
+ *
+ * It cannot simply be deleted. Drizzle's bundled `_libs/drizzle-orm+postgres`
+ * chunk imports it at module scope, so removing the package turns every cold
+ * start into `ERR_MODULE_NOT_FOUND` — which is how this was first written, and
+ * what the SSR cold-start smoke caught. The stub keeps the specifier
+ * resolvable and moves the failure to the only place it can be acted on: a
+ * deploy that actually tries to open a file-backed database, which now throws
+ * with the reason instead of quietly serving an empty one.
+ */
+export function stubLocalOnlySqliteDriverForServerless(serverDir) {
+    const packageDir = path.join(serverDir, "node_modules", "better-sqlite3");
+    if (!fs.existsSync(packageDir))
+        return 0;
+    const manifestPath = path.join(packageDir, "package.json");
+    if (!fs.existsSync(manifestPath)) {
+        throw new Error(`[deploy] ${path.relative(serverDir, packageDir)} has no package.json; ` +
+            "refusing to stub a package tree this build does not understand.");
+    }
+    const version = JSON.parse(fs.readFileSync(manifestPath, "utf8")).version;
+    if (!version) {
+        throw new Error(`[deploy] ${path.relative(serverDir, manifestPath)} declares no version; ` +
+            "refusing to stub a package tree this build does not understand.");
+    }
+    const saved = getDirSize(packageDir);
+    fs.rmSync(packageDir, { recursive: true, force: true });
+    fs.mkdirSync(packageDir, { recursive: true });
+    fs.writeFileSync(manifestPath, `${JSON.stringify({
+        name: "better-sqlite3",
+        version,
+        main: "index.js",
+        // Read by the CLI's native-dependency preflight, which would otherwise
+        // probe the stub, see its deliberate throw, and try to rebuild it.
+        agentNativeServerlessStub: true,
+    }, null, 2)}\n`);
+    // CommonJS, matching the real package: Drizzle default-imports it from ESM
+    // and relies on the interop default being the constructor.
+    fs.writeFileSync(path.join(packageDir, "index.js"), [
+        "// Replaced at build time by @agent-native/core: better-sqlite3 is a",
+        "// local-development driver and cannot back a serverless deployment,",
+        "// whose filesystem is ephemeral and per-container.",
+        "module.exports = class BetterSqlite3NotAvailableInServerless {",
+        "  constructor() {",
+        "    throw new Error(",
+        '      "better-sqlite3 is not available in a serverless deployment. " +',
+        '        "DATABASE_URL resolved to a file-backed SQLite database, whose " +',
+        '        "filesystem is ephemeral and not shared between containers. " +',
+        '        "Point DATABASE_URL at Postgres or libSQL/Turso."',
+        "    );",
+        "  }",
+        "};",
+        "",
+    ].join("\n"));
+    const freed = saved - getDirSize(packageDir);
+    console.log(`[deploy] Stubbed better-sqlite3 in ${path.basename(serverDir)}: ` +
+        `${(freed / 1024 / 1024).toFixed(1)}MB of local-only SQLite driver removed.`);
+    return freed;
+}
 function netlifyFunctionSizeBudget(functionDir) {
     const allowance = (hasBundledServerlessBrowserRuntime(functionDir)
         ? NETLIFY_BROWSER_RUNTIME_SIZE_ALLOWANCE_BYTES
@@ -3147,6 +3268,33 @@ function netlifyFunctionSizeBudget(functionDir) {
             : 0);
     return Math.min(NETLIFY_FUNCTION_SIZE_BUDGET_BYTES + allowance, NETLIFY_FUNCTION_HARD_LIMIT_BYTES);
 }
+/**
+ * App-owned pruning of the emitted serverless functions, run before the
+ * framework measures them.
+ *
+ * An app can know things about its own payload the framework cannot — docs, for
+ * instance, emits a locale chunk per translated page and can tell which ones no
+ * prerendered route will ever import. That pruning used to be chained after
+ * `agent-native build` with `&&`, which put it after this file had already
+ * printed the size report and applied the budget: the numbers described a
+ * directory that no longer existed by the time the deploy uploaded it, 19MB
+ * high for docs. Running the app's script here instead is the only ordering in
+ * which the report is measuring what ships.
+ *
+ * A script that exists and fails aborts the build. Silently continuing would
+ * publish an unpruned payload while reporting the size the app expected.
+ */
+function runAppServerlessFunctionPruning(cwd) {
+    const script = path.join(cwd, "scripts", "prune-serverless-functions.ts");
+    if (!fs.existsSync(script))
+        return;
+    console.log(`[deploy] Running app serverless pruning: ${path.relative(cwd, script)}`);
+    // Resolve tsx's own entry rather than shelling out to `npx`: npm's Windows
+    // shim is `npx.cmd`, which execFileSync cannot resolve, and running the
+    // resolved script under the current interpreter avoids the question.
+    const tsxCli = createRequire(path.join(cwd, "package.json")).resolve("tsx/cli");
+    execFileSync(process.execPath, [tsxCli, script], { cwd, stdio: "inherit" });
+}
 function reportNetlifyFunctionSizes(internalDir, failures) {
     if (!fs.existsSync(internalDir))
         return;
@@ -3602,6 +3750,30 @@ export function pruneServerlessFunctionDeadWeight(functionDir) {
         removedNames.push("data");
         fs.rmSync(dataDir, { recursive: true, force: true });
     }
+    // Only the `types` export condition points at declaration files, and no
+    // runtime resolver honours it — nothing inside a deployed function ever
+    // type-checks. Scoped to node_modules on purpose: there are no .d.ts outside
+    // it today, and scoping keeps a future emitted asset out of range.
+    if (fs.existsSync(nodeModulesDir)) {
+        let removedDeclarations = 0;
+        for (const declaration of fs.globSync("**/*.d.ts", {
+            cwd: nodeModulesDir,
+        })) {
+            const declarationPath = path.join(nodeModulesDir, declaration);
+            try {
+                removedBytes += fs.statSync(declarationPath).size;
+                fs.rmSync(declarationPath);
+                removedDeclarations += 1;
+            }
+            catch {
+                // coercion-ok: a file already gone contributes nothing, and its bytes
+                // were counted before the unlink, so the total stays honest.
+            }
+        }
+        if (removedDeclarations > 0) {
+            removedNames.push(`${removedDeclarations} .d.ts file(s)`);
+        }
+    }
     if (removedNames.length > 0) {
         console.log(`[deploy] Pruned ${removedNames.length} unrunnable path(s) (${(removedBytes /
             1024 /
@@ -4104,6 +4276,7 @@ export default bundle;
         copyInstalledFfmpegStaticPackage(nitro.options.output.serverDir);
         copyInstalledBrowserRuntimePackages(nitro.options.output.serverDir);
         sanitizeServerlessFunctionPackageManifest(nitro.options.output.serverDir);
+        stubLocalOnlySqliteDriverForServerless(nitro.options.output.serverDir);
         // Before the Netlify block below clones this dir into the extra functions,
         // so they inherit the pruned bundle instead of a second full copy.
         pruneServerlessFunctionDeadWeight(nitro.options.output.serverDir);
@@ -4144,6 +4317,7 @@ export default bundle;
         // directly from Netlify's static backing store. Keep that artifact on the
         // same public SWR policy as runtime SSR and .data responses.
         writeNetlifyStaticHeaders(path.join(cwd, "dist"));
+        runAppServerlessFunctionPruning(cwd);
         assertSingleTemplateNetlifyBuildOutput(cwd);
     }
     // Resolve remaining bare npm imports by bundling them into _libs/.

package/dist/deploy/function-bundle.d.ts

@@ -19,3 +19,48 @@ export declare function copyDir(src: string, dest: string, ancestorRealPaths?: S
  * regular file — see the note in `copyTree`.
  */
 export declare function cloneServerBundleForFunction(src: string, dest: string): void;
+/**
+ * Drop the SSR page/asset island from a clone that can never route to it.
+ *
+ * The background and integration-recovery entries overwrite `url.pathname`
+ * unconditionally before delegating to `main.mjs`, so those clones cannot reach
+ * the page or asset handlers — yet each shipped a full copy of that island, and
+ * Netlify zips and uploads every function separately. Deleting from the clone is
+ * safe under hard links: only an in-place WRITE would reach the source bundle.
+ */
+export declare function pruneSsrIslandFromRewritingClone(dest: string, entryText: string): number;
+/**
+ * Read a package's manifest, or null when it has none. Shared with build.ts's
+ * copyRuntimePackageTree, which is why this lives here rather than there:
+ * build.ts already imports from this file, and the reverse import would be
+ * circular.
+ */
+export declare function readPackageManifest(packageDir: string): Record<string, unknown> | null;
+/**
+ * The browser runtime copied into serverless functions, by exact package name.
+ *
+ * Exact names, never the `@sparticuz` scope: another dependency can install an
+ * unrelated package into the same scope, and a scope-wide delete takes it with
+ * no way for the closure walk to prove it is still needed. build.ts imports
+ * this rather than declaring its own copy, so the list that is copied in and
+ * the list that is pruned out cannot drift apart.
+ */
+export declare const SERVERLESS_BROWSER_RUNTIME_PACKAGES: readonly ["@sparticuz/chromium-min", "playwright-core"];
+/**
+ * Drop the serverless browser runtime — and everything installed only because
+ * the runtime needed it — from a clone that can never run an agent turn.
+ *
+ * Playwright and @sparticuz/chromium are reached only through NON-LITERAL
+ * dynamic imports in creative-context's rendered-page connector, so no static
+ * walk can prove them dead. The caller asserts it instead, and this refuses the
+ * prune when the entry rewrites to a route that could reach an agent — a
+ * scheduled report sweep can drop the runtime, an agent worker cannot.
+ *
+ * Deleting just the two known directories used to leave their whole
+ * dependency closure behind — packages like tar-fs and pump that exist in
+ * `node_modules` for no other reason than @sparticuz/chromium-min or
+ * playwright-core needing them. Those are orphaned the instant the runtime is
+ * gone, so this walks the closure and removes it too, keeping only what a
+ * still-present, unrelated package also depends on.
+ */
+export declare function pruneBrowserRuntimeFromNonAgentClone(dest: string, entryText: string): number;