@agent-native/core 0.101.3 → 0.101.5

package/dist/deploy/build.js

@@ -2101,15 +2101,15 @@ function walkServerJavaScriptFiles(dir, onFile) {
     }
 }
 /**
- * Nitro can preserve Vite's `yjs` external in a split server chunk even when
- * its own server build has emitted `_libs/yjs.mjs`. Netlify does not install
- * that bare package at runtime, so make every emitted server chunk use the
- * bundled copy before its function is packaged.
+ * Nitro receives the React Router SSR build as prebuilt chunks, so its normal
+ * dependency resolver cannot reliably fold the preserved bare `yjs` imports
+ * into the same module instance used by core's server collaboration code.
+ * Keep Yjs external through Nitro, bundle its complete public ESM surface once,
+ * then point every emitted server chunk at that one portable runtime module.
  */
-export function rewriteBareYjsImportsForServerlessOutput(serverDir) {
+export function bundleYjsRuntimeForServerlessOutput(serverDir, projectCwd) {
     const bareImports = [];
     const unsupportedSubpathImports = [];
-    const bundledYjsPath = path.join(serverDir, "_libs", "yjs.mjs");
     walkServerJavaScriptFiles(serverDir, (filePath) => {
         const source = fs.readFileSync(filePath, "utf-8");
         if (!hasBareYjsRuntimeImport(source))
@@ -2125,9 +2125,17 @@ export function rewriteBareYjsImportsForServerlessOutput(serverDir) {
     }
     if (bareImports.length === 0)
         return [];
-    if (!fs.existsSync(bundledYjsPath)) {
-        throw new Error(`[deploy] Serverless output left yjs as a runtime import but did not emit ${bundledYjsPath}`);
-    }
+    const bundledYjsPath = path.join(serverDir, "_libs", "yjs-runtime.mjs");
+    fs.mkdirSync(path.dirname(bundledYjsPath), { recursive: true });
+    execFileSync(findEsbuild(), [
+        resolveNitroBundledYjsEntry(),
+        "--bundle",
+        "--format=esm",
+        "--platform=node",
+        "--target=node22",
+        "--minify",
+        `--outfile=${bundledYjsPath}`,
+    ], { cwd: projectCwd, stdio: "pipe" });
     for (const filePath of bareImports) {
         const bundledImport = path
             .relative(path.dirname(filePath), bundledYjsPath)
@@ -2217,6 +2225,19 @@ export function assertSingleTemplateNetlifyBuildOutput(projectCwd) {
     if (bareYjsImports.length > 0) {
         failures.push(`Netlify server bundle leaves yjs as a runtime import: ${bareYjsImports.join(", ")}`);
     }
+    // Nitro's `_libs/yjs.mjs` is a private tree-shaken chunk, not a package
+    // facade. Repointing a prebuilt SSR chunk at it can request public exports
+    // (notably `Text`) that the private chunk did not retain. The controlled
+    // serverless pass must instead target the complete `yjs-runtime.mjs` bundle.
+    const privateYjsImports = [];
+    walkServerJavaScriptFiles(serverDir, (filePath) => {
+        if (/\b(?:from\s*|import\s*\(\s*|import\s*)(["'])[^"']*_libs\/yjs\.mjs\1/.test(fs.readFileSync(filePath, "utf-8"))) {
+            privateYjsImports.push(path.relative(projectCwd, filePath));
+        }
+    });
+    if (privateYjsImports.length > 0) {
+        failures.push(`Netlify server bundle imports Nitro's internal tree-shaken _libs/yjs.mjs: ${privateYjsImports.join(", ")}`);
+    }
     if (isDurableBackgroundDeployEnabled()) {
         const backgroundDir = path.join(internalDir, AGENT_BACKGROUND_FUNCTION_NAME);
         const backgroundEntryPath = path.join(backgroundDir, `${AGENT_BACKGROUND_FUNCTION_NAME}.mjs`);
@@ -2567,17 +2588,25 @@ const BROWSER_ONLY_SERVER_LIBS = [
     "mermaid",
 ];
 /**
- * Dependencies that must be bundled into every Nitro server output instead of
- * being left as runtime package imports.
- *
- * `yjs` is a direct core dependency, but it is deliberately externalized from
- * the intermediate Vite SSR graph so that Vite and Nitro do not create two
- * incompatible Yjs constructors. On file-traced serverless presets, leaving it
- * external at Nitro's final build can emit `import "yjs"` into a function
- * chunk without placing the package in that function's `node_modules`. Bundle
- * it in Nitro's final output so every template receives the one portable copy.
+ * Dependencies Nitro itself must bundle outside the controlled serverless
+ * output pass. Netlify, Vercel, and Lambda keep Yjs external through Nitro;
+ * `bundleYjsRuntimeForServerlessOutput` then creates their one portable copy.
  */
 export const NITRO_SERVER_RUNTIME_BUNDLED_DEPS = ["yjs"];
+/**
+ * Locate the core-owned ESM entry used by the controlled serverless bundling
+ * pass. Resolving from this module keeps the build independent of whether a
+ * template exposes core's transitive Yjs dependency at its own package root.
+ */
+export function resolveNitroBundledYjsEntry() {
+    const requireFromCore = createRequire(import.meta.url);
+    const packageDir = path.dirname(requireFromCore.resolve("yjs/package.json"));
+    const entry = path.join(packageDir, "dist", "yjs.mjs");
+    if (!fs.existsSync(entry)) {
+        throw new Error(`[build] Could not resolve the Yjs ESM entry at ${entry}`);
+    }
+    return entry;
+}
 /**
  * Edge runtimes have no node_modules, while Node/serverless outputs only need
  * the small set above bundled to keep their package manifests traceable.
@@ -2586,7 +2615,11 @@ export function nitroNoExternalsForPreset(targetPreset) {
     return targetPreset.startsWith("cloudflare") ||
         targetPreset.startsWith("deno")
         ? true
-        : NITRO_SERVER_RUNTIME_BUNDLED_DEPS;
+        : targetPreset === "netlify" ||
+            targetPreset === "vercel" ||
+            targetPreset === "aws-lambda"
+            ? []
+            : NITRO_SERVER_RUNTIME_BUNDLED_DEPS;
 }
 /**
  * Rolldown plugin for the Nitro server bundle that replaces the browser-only
@@ -2722,6 +2755,14 @@ export default bundle;
         // (ReferenceError: window is not defined → every request 502s). Mirrors the
         // Vite `ssrStubPlugin`, which only covers the `build/server` step.
         rollupConfig: {
+            // Nitro treats the intermediate React Router SSR files as prebuilt
+            // chunks, while core's server collaboration files participate in the
+            // final Rolldown graph. Externalize Yjs consistently on serverless so
+            // both graphs retain their public import shapes; the controlled
+            // post-build pass below bundles and rewrites them to one module.
+            ...(preset === "netlify" || preset === "vercel" || preset === "aws-lambda"
+                ? { external: ["yjs"] }
+                : {}),
             plugins: [createBrowserOnlyServerStubPlugin()],
         },
         ...(providedPluginsNitroPlugin
@@ -2729,9 +2770,9 @@ export default bundle;
             : {}),
         routeRules: mcpEmbedStaticAssetRouteRules(appBasePath),
         // Edge presets (cloudflare, deno) bundle all deps because node_modules are
-        // unavailable at runtime. Node/serverless presets also bundle Yjs: Nitro's
-        // file tracer otherwise leaves a bare import that Netlify function bundles
-        // cannot resolve under pnpm.
+        // unavailable at runtime. Ordinary Node presets bundle Yjs through Nitro.
+        // Controlled serverless presets externalize it above, then emit one full
+        // runtime module after Nitro has preserved every consumer's public imports.
         noExternals: nitroNoExternalsForPreset(preset),
     });
     await runNitroBuildPipeline({
@@ -2747,7 +2788,7 @@ export default bundle;
         copyInstalledResvgPackages(nitro.options.output.serverDir);
         copyInstalledFfmpegStaticPackage(nitro.options.output.serverDir);
         sanitizeServerlessFunctionPackageManifest(nitro.options.output.serverDir);
-        rewriteBareYjsImportsForServerlessOutput(nitro.options.output.serverDir);
+        bundleYjsRuntimeForServerlessOutput(nitro.options.output.serverDir, cwd);
     }
     // Durable background agent runs (default-OFF / opt-in; enable with a truthy
     // AGENT_CHAT_DURABLE_BACKGROUND). Additive ONLY: emits a SECOND Netlify