@agent-native/core 0.146.5 → 0.146.7

package/corpus/templates/analytics/server/jobs/analytics-bigquery-backfill.ts

@@ -201,21 +201,13 @@ export async function queueFirstPartyAnalyticsBigQueryBackfill(
   const id = jobId(scope.orgId ?? "");
   if (!scope.orgId)
     throw new Error("BigQuery backfill requires an organization");
-  const conflictClause =
-    requestedBatchSize === undefined
-      ? "ON CONFLICT (id) DO NOTHING"
-      : `ON CONFLICT (id) DO UPDATE SET batch_size = CASE
-           WHEN batch_size < excluded.batch_size
-             THEN excluded.batch_size
-           ELSE batch_size
-         END`;
   await executor().execute({
     sql: `INSERT INTO ${JOB_TABLE} (
             id, org_id, owner_email, table_ref, batch_size, backfill_cursor,
               status, copied_count, lease_token, lease_expires_at, next_run_at,
               last_error, completed_at, updated_at
             ) VALUES (?, ?, ?, ?, ?, ?, 'pending', 0, NULL, NULL, ?, NULL, NULL, ?)
-            ${conflictClause}`,
+            ON CONFLICT (id) DO NOTHING`,
     args: [
       id,
       scope.orgId,
@@ -229,6 +221,18 @@ export async function queueFirstPartyAnalyticsBigQueryBackfill(
     timeoutMs: 5_000,
     maxAttempts: 1,
   });
+  if (requestedBatchSize !== undefined) {
+    const batchSize = boundedBatchSize(requestedBatchSize);
+    await executor().execute({
+      sql: `UPDATE ${JOB_TABLE}
+               SET batch_size = ?
+             WHERE id = ?
+               AND batch_size < ?`,
+      args: [batchSize, id, batchSize],
+      timeoutMs: 5_000,
+      maxAttempts: 1,
+    });
+  }
   const job = await getFirstPartyAnalyticsBigQueryBackfillJob(scope);
   if (!job) throw new Error("BigQuery backfill job was not persisted");
   if (job.table !== table) {

package/corpus/templates/analytics/server/lib/first-party-analytics-backend.ts

@@ -1031,7 +1031,7 @@ function backfillBranchSql(
     ? [cursor.receivedAt, cursor.receivedAt, cursor.id]
     : [];
   return {
-    sql: `SELECT ${FIRST_PARTY_ANALYTICS_BACKFILL_COLUMNS.join(", ")}
+    sql: `SELECT id, received_at
       FROM analytics_events
       WHERE ${predicate}${cursorSql ? ` AND ${cursorSql}` : ""}
       ORDER BY received_at ASC, id ASC LIMIT ?`,
@@ -1039,32 +1039,20 @@ function backfillBranchSql(
   };
 }
 
-function backfillScopedRowsSql(
-  branches: Array<{ predicate: string; args: string[] }>,
-  cursor: FirstPartyAnalyticsBackfillCursor,
-  limit: number,
-): { sql: string; args: Array<string | number> } {
-  const branchQueries = branches.map((branch) =>
-    backfillBranchSql(branch.predicate, branch.args, cursor),
-  );
-  const columns = FIRST_PARTY_ANALYTICS_BACKFILL_COLUMNS.join(", ");
+function backfillRowsByIdsSql(ids: string[]): {
+  sql: string;
+  args: string[];
+} {
   return {
-    sql: `WITH ${branchQueries
-      .map(
-        (_branch, index) =>
-          `backfill_branch_${index} AS (${branchQueries[index]!.sql})`,
-      )
-      .join(", ")}
-      SELECT ${columns}
-      FROM (${branchQueries.map((_branch, index) => `SELECT ${columns} FROM backfill_branch_${index}`).join(" UNION ALL ")}) AS selected_events
-      ORDER BY received_at ASC, id ASC LIMIT ?`,
-    args: [
-      ...branchQueries.flatMap((branch) => [...branch.args, limit]),
-      limit,
-    ],
+    sql: `SELECT ${FIRST_PARTY_ANALYTICS_BACKFILL_COLUMNS.join(", ")}
+      FROM analytics_events
+      WHERE id IN (${ids.map(() => "?").join(", ")})`,
+    args: ids,
   };
 }
 
+const MAX_SQLITE_BIND_VARIABLES = 900;
+
 function backfillRowCursor(
   row: Record<string, unknown>,
 ): FirstPartyAnalyticsBackfillCursor {
@@ -1081,6 +1069,18 @@ function backfillRowCursor(
   return { receivedAt, id };
 }
 
+function compareBackfillRows(
+  left: Record<string, unknown>,
+  right: Record<string, unknown>,
+): number {
+  const leftCursor = backfillRowCursor(left);
+  const rightCursor = backfillRowCursor(right);
+  return (
+    leftCursor.receivedAt.localeCompare(rightCursor.receivedAt) ||
+    leftCursor.id.localeCompare(rightCursor.id)
+  );
+}
+
 export async function backfillFirstPartyAnalyticsBatch(
   scope: FirstPartyAnalyticsScope,
   cursor: string | null,
@@ -1108,15 +1108,22 @@ export async function backfillFirstPartyAnalyticsBatch(
         },
       ];
   const rows: Record<string, unknown>[] = [];
-  const scoped = backfillScopedRowsSql(branches, parsedCursor, boundedLimit);
-  const result = await db.execute({
-    sql: scoped.sql,
-    args: scoped.args,
-    timeoutMs: 20_000,
-    maxAttempts: 1,
-  });
-  rows.push(...(result.rows as Record<string, unknown>[]));
-  const selectedRows = rows;
+  for (const branch of branches) {
+    const scoped = backfillBranchSql(
+      branch.predicate,
+      branch.args,
+      parsedCursor,
+    );
+    const result = await db.execute({
+      sql: scoped.sql,
+      args: [...scoped.args, boundedLimit],
+      timeoutMs: 20_000,
+      maxAttempts: 1,
+    });
+    rows.push(...(result.rows as Record<string, unknown>[]));
+  }
+  rows.sort(compareBackfillRows);
+  const selectedRows = rows.slice(0, boundedLimit);
   if (!selectedRows.length) {
     return {
       nextCursor: serializeBackfillCursor(parsedCursor),
@@ -1125,7 +1132,36 @@ export async function backfillFirstPartyAnalyticsBatch(
     };
   }
 
-  const selectedEvents = selectedRows;
+  const selectedIds = selectedRows.map((row) => backfillRowCursor(row).id);
+  const hydratedRows: Record<string, unknown>[] = [];
+  for (
+    let offset = 0;
+    offset < selectedIds.length;
+    offset += MAX_SQLITE_BIND_VARIABLES
+  ) {
+    const hydratedQuery = backfillRowsByIdsSql(
+      selectedIds.slice(offset, offset + MAX_SQLITE_BIND_VARIABLES),
+    );
+    const hydratedResult = await db.execute({
+      sql: hydratedQuery.sql,
+      args: hydratedQuery.args,
+      timeoutMs: 20_000,
+      maxAttempts: 1,
+    });
+    hydratedRows.push(...(hydratedResult.rows as Record<string, unknown>[]));
+  }
+  const hydratedById = new Map(
+    hydratedRows.map((row) => [backfillRowCursor(row).id, row]),
+  );
+  const selectedEvents = selectedIds.map((id) => {
+    const row = hydratedById.get(id);
+    if (!row) {
+      throw new Error(
+        `First-party analytics backfill row ${id} disappeared before hydration`,
+      );
+    }
+    return row;
+  });
   await insertFirstPartyAnalyticsRows(selectedEvents, configuredTable);
   const lastCursor = backfillRowCursor(selectedRows[selectedRows.length - 1]!);
   return {

package/corpus/templates/calendar/app/root.tsx

@@ -95,7 +95,6 @@ export function Layout({ children }: { children: React.ReactNode }) {
   const localeInitScript = getLocaleInitScript({
     locale: loaderData.locale,
     preference: loaderData.preference,
-    messages: loaderData.messages,
   });
 
   return (

package/corpus/templates/clips/app/root.tsx

@@ -130,7 +130,6 @@ export function Layout({ children }: { children: React.ReactNode }) {
   const localeInitScript = getHydrationStableLocaleInitScript({
     locale: loaderData.locale,
     preference: loaderData.preference,
-    messages: loaderData.messages,
   });
 
   return (

package/corpus/templates/content/app/root.tsx

@@ -188,7 +188,6 @@ export function Layout({ children }: { children: React.ReactNode }) {
   const localeInitScript = getLocaleInitScript({
     locale: loaderData.locale,
     preference: loaderData.preference,
-    messages: loaderData.messages,
   });
 
   return (

package/dist/collab/routes.d.ts

@@ -26,8 +26,8 @@ export declare const getCollabState: import("h3").EventHandlerWithFetch<import("
  * Body: { update: string (base64), requestSource?: string }
  */
 export declare const postCollabUpdate: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/collab/struct-routes.d.ts

@@ -13,8 +13,8 @@
  * Body: { json: any, fieldName?: string, type?: "map"|"array", requestSource?: string }
  */
 export declare const postCollabJson: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/deploy/build.d.ts

@@ -74,6 +74,14 @@ export { copyDir };
 export declare function isServerlessNativePlatformPackage(packageName: string): boolean;
 type ServerlessFfmpegStaticArch = "arm64" | "x64";
 export declare function shouldBundleFfmpegStaticForServerless(hostPlatform?: NodeJS.Platform, hostArch?: NodeJS.Architecture, targetArch?: ServerlessFfmpegStaticArch | null): boolean;
+/**
+ * Which dependency gives this app a path to the serverless browser runtime, or
+ * null when it has none. Resolution cannot answer this: findInstalledPackageRoot
+ * falls back to an ancestor + .pnpm store walk, so in a workspace every app
+ * "resolves" the sibling package that actually declares Chromium and ships its
+ * ~80MB into every emitted function.
+ */
+export declare function findServerlessBrowserRuntimeConsumer(projectCwd?: string): string | null;
 export declare function findInstalledPackageRoot(packageName: string, nodeModulesRoots: string[], fromPackageDir?: string): string | null;
 export declare function copyInstalledBrowserRuntimePackages(serverDir: string | undefined, projectCwd?: string): number;
 export declare function findInstalledFfmpegStaticPackage(nodeModulesRoots: string[]): string | null;
@@ -238,6 +246,19 @@ export declare function writeSingleTemplateNetlifyRedirects(projectCwd: string):
  * though the server bundle never imports Electron at runtime.
  */
 export declare function sanitizeServerlessFunctionPackageManifest(functionDir: string | undefined): void;
+/**
+ * Nitro's dependency tracer is not subject to the copy-time filters above, so
+ * it ships every prebuild of a multi-platform native package plus whatever the
+ * local dev server left in `data/`. Prune both from the function dir before it
+ * is cloned for the extra functions, since each clone is zipped and uploaded in
+ * full.
+ *
+ * Only prunes inside a directory that still holds a runnable prebuild under the
+ * `isServerlessNativePlatformPackage` naming (`@libsql`, `@resvg`). Packages
+ * that name prebuilds differently — `@img/sharp-linux-x64` has no gnu/musl
+ * suffix — read as entirely dead and must be left alone.
+ */
+export declare function pruneServerlessFunctionDeadWeight(functionDir: string | undefined): number;
 /**
  * Build for any non-Cloudflare preset using Nitro's programmatic build API.
  * Handles netlify, vercel, deno_deploy, aws-lambda, and all other targets.

package/dist/deploy/build.js

@@ -1925,6 +1925,13 @@ const SERVERLESS_BROWSER_RUNTIME_PACKAGES = [
     "@sparticuz/chromium",
     "playwright-core",
 ];
+const SERVERLESS_BROWSER_RUNTIME_CONSUMER = "@agent-native/creative-context";
+const PACKAGE_DEPENDENCY_FIELDS = [
+    "dependencies",
+    "optionalDependencies",
+    "devDependencies",
+    "peerDependencies",
+];
 // Serverless functions only ever run on 64-bit Linux. The darwin/win32/android
 // and 32-bit-arm prebuilds of these native packages are ~100MB that can never
 // execute there, and Netlify copies the whole server dir again for every extra
@@ -1941,6 +1948,11 @@ const SERVERLESS_NATIVE_PACKAGE_SUFFIXES = [
 export function isServerlessNativePlatformPackage(packageName) {
     return SERVERLESS_NATIVE_PACKAGE_SUFFIXES.some((suffix) => packageName.endsWith(suffix));
 }
+// Names a prebuild package by the platform it targets: `darwin-arm64`,
+// `resvg-js-win32-ia32-msvc`, `linux-x64-gnu`. Matching only says "this is a
+// per-platform prebuild"; isServerlessNativePlatformPackage decides whether it
+// can run in the function.
+const SERVERLESS_PLATFORM_PACKAGE_NAME = /(?:^|-)(?:darwin|win32|linux|android|freebsd)-[a-z0-9]+(?:-[a-z0-9]+)?$/;
 const FFMPEG_STATIC_BINARY_NAMES = process.platform === "win32" ? ["ffmpeg.exe", "ffmpeg"] : ["ffmpeg"];
 const SERVERLESS_FFMPEG_STATIC_PLATFORM = "linux";
 const SERVERLESS_FFMPEG_STATIC_ARCHES = new Set([
@@ -1993,6 +2005,37 @@ function readPackageManifest(packageDir) {
     }
     return manifest;
 }
+function manifestDeclaresDependency(manifest, packageName) {
+    if (!manifest)
+        return false;
+    return PACKAGE_DEPENDENCY_FIELDS.some((field) => {
+        const deps = manifest[field];
+        if (!deps || typeof deps !== "object" || Array.isArray(deps))
+            return false;
+        return Object.prototype.hasOwnProperty.call(deps, packageName);
+    });
+}
+/**
+ * Which dependency gives this app a path to the serverless browser runtime, or
+ * null when it has none. Resolution cannot answer this: findInstalledPackageRoot
+ * falls back to an ancestor + .pnpm store walk, so in a workspace every app
+ * "resolves" the sibling package that actually declares Chromium and ships its
+ * ~80MB into every emitted function.
+ */
+export function findServerlessBrowserRuntimeConsumer(projectCwd = cwd) {
+    const manifest = readPackageManifest(projectCwd);
+    for (const packageName of [
+        ...SERVERLESS_BROWSER_RUNTIME_PACKAGES,
+        SERVERLESS_BROWSER_RUNTIME_CONSUMER,
+    ]) {
+        if (manifestDeclaresDependency(manifest, packageName))
+            return packageName;
+        const linked = path.join(projectCwd, "node_modules", ...packageName.split("/"));
+        if (fs.existsSync(linked))
+            return packageName;
+    }
+    return null;
+}
 function packageRootFromResolvedPath(packageName, resolvedPath) {
     let current = path.dirname(resolvedPath);
     while (true) {
@@ -2062,6 +2105,16 @@ export function copyInstalledBrowserRuntimePackages(serverDir, projectCwd = cwd)
     if (!serverDir || !fs.existsSync(serverDir))
         return 0;
     const nodeModulesRoots = nodeModulesAncestors(projectCwd);
+    const consumer = findServerlessBrowserRuntimeConsumer(projectCwd);
+    if (!consumer) {
+        const skippedBytes = SERVERLESS_BROWSER_RUNTIME_PACKAGES.reduce((total, packageName) => {
+            const packageDir = findInstalledPackageRoot(packageName, nodeModulesRoots);
+            return packageDir ? total + getDirSize(packageDir) : total;
+        }, 0);
+        console.log(`[deploy] Skipped the serverless browser runtime (${SERVERLESS_BROWSER_RUNTIME_PACKAGES.join(", ")}): this app depends on neither ${SERVERLESS_BROWSER_RUNTIME_CONSUMER} ` +
+            `nor a browser package. Kept ${(skippedBytes / 1024 / 1024).toFixed(1)}MB out of every emitted function.`);
+        return 0;
+    }
     const copiedPackages = new Set();
     let copiedCount = 0;
     for (const packageName of SERVERLESS_BROWSER_RUNTIME_PACKAGES) {
@@ -2070,9 +2123,15 @@ export function copyInstalledBrowserRuntimePackages(serverDir, projectCwd = cwd)
             continue;
         copiedCount += copyRuntimePackageTree(packageName, packageDir, serverDir, nodeModulesRoots, copiedPackages);
     }
-    if (copiedCount > 0) {
-        console.log(`[deploy] Copied ${copiedCount} serverless browser runtime package(s) into the server bundle.`);
+    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
+        // at runtime instead of at build time.
+        console.warn(`[deploy] ${consumer} needs the serverless browser runtime but none of ` +
+            `${SERVERLESS_BROWSER_RUNTIME_PACKAGES.join(", ")} is installed; the function ships without it.`);
+        return 0;
     }
+    console.log(`[deploy] Copied ${copiedCount} serverless browser runtime package(s) into the server bundle (required by ${consumer}).`);
     return copiedCount;
 }
 function findInstalledLibsqlNativePackage(nodeModulesRoots, packageName) {
@@ -2847,6 +2906,60 @@ export function bundleYjsRuntimeForServerlessOutput(serverDir, projectCwd) {
     });
     return bareImports;
 }
+// Netlify's hard limit is 250MB unzipped per function; a bundle this far under
+// it still leaves room for growth, and today's server functions land near 70MB
+// once the dead weight is out. Apps that legitimately ship the browser runtime
+// get its ~85MB on top, so the budget stays a regression signal rather than a
+// tax on Chromium-backed templates.
+const NETLIFY_FUNCTION_SIZE_BUDGET_BYTES = 120 * 1024 * 1024;
+const NETLIFY_BROWSER_RUNTIME_SIZE_ALLOWANCE_BYTES = 100 * 1024 * 1024;
+function reportNetlifyFunctionSizes(projectCwd, internalDir, failures) {
+    if (!fs.existsSync(internalDir))
+        return;
+    const functions = fs
+        .readdirSync(internalDir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => ({
+        name: entry.name,
+        dir: path.join(internalDir, entry.name),
+        size: getDirSize(path.join(internalDir, entry.name)),
+    }))
+        .sort((a, b) => b.size - a.size);
+    if (functions.length === 0)
+        return;
+    const toMb = (bytes) => (bytes / 1024 / 1024).toFixed(1);
+    const total = functions.reduce((sum, fn) => sum + fn.size, 0);
+    // Every extra function is a full second copy of the bundle: the clone is
+    // hard-linked on disk, but zip-it-and-ship-it sees regular files and uploads
+    // each one whole, so the total is what the deploy actually pays.
+    console.log(`[deploy] Netlify functions: ${functions.length} (${functions
+        .map((fn) => `${fn.name} ${toMb(fn.size)}MB`)
+        .join(", ")}) — ${toMb(total)}MB uploaded in total.`);
+    const budget = NETLIFY_FUNCTION_SIZE_BUDGET_BYTES +
+        (findServerlessBrowserRuntimeConsumer(projectCwd)
+            ? NETLIFY_BROWSER_RUNTIME_SIZE_ALLOWANCE_BYTES
+            : 0);
+    for (const fn of functions) {
+        if (fn.size <= budget)
+            continue;
+        // node_modules is always the biggest child and names nothing useful; the
+        // packages inside it are what a regression actually adds.
+        const nodeModulesDir = path.join(fn.dir, "node_modules");
+        const inspectDir = fs.existsSync(nodeModulesDir) ? nodeModulesDir : fn.dir;
+        const largest = fs
+            .readdirSync(inspectDir, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => ({
+            name: entry.name,
+            size: getDirSize(path.join(inspectDir, entry.name)),
+        }))
+            .sort((a, b) => b.size - a.size)
+            .slice(0, 3)
+            .map((child) => `${child.name} ${toMb(child.size)}MB`)
+            .join(", ");
+        failures.push(`function ${fn.name} is ${toMb(fn.size)}MB, over the ${toMb(budget)}MB budget — largest: ${largest}`);
+    }
+}
 export function assertSingleTemplateNetlifyBuildOutput(projectCwd) {
     const failures = [];
     const publishDir = path.join(projectCwd, "dist");
@@ -2988,9 +3101,10 @@ export function assertSingleTemplateNetlifyBuildOutput(projectCwd) {
             }
         }
     }
+    reportNetlifyFunctionSizes(projectCwd, internalDir, failures);
     if (failures.length > 0) {
         throw new Error("[deploy] Netlify deploy guard failed; refusing to publish an output " +
-            "that would likely serve Netlify 404s:\n" +
+            "that would likely serve Netlify 404s or blow the function size limit:\n" +
             failures.map((failure) => `- ${failure}`).join("\n"));
     }
     console.log("[deploy] Netlify deploy guard passed: publish dir and catch-all server function are present.");
@@ -3111,13 +3225,7 @@ export function sanitizeServerlessFunctionPackageManifest(functionDir) {
         return;
     }
     let removed = 0;
-    const depFields = [
-        "dependencies",
-        "optionalDependencies",
-        "devDependencies",
-        "peerDependencies",
-    ];
-    for (const field of depFields) {
+    for (const field of PACKAGE_DEPENDENCY_FIELDS) {
         const deps = packageJson[field];
         if (!deps || typeof deps !== "object" || Array.isArray(deps))
             continue;
@@ -3145,6 +3253,70 @@ export function sanitizeServerlessFunctionPackageManifest(functionDir) {
         console.log(`[deploy] Removed ${removed} desktop-only package reference(s) from ${path.relative(cwd, functionDir)}.`);
     }
 }
+/**
+ * Nitro's dependency tracer is not subject to the copy-time filters above, so
+ * it ships every prebuild of a multi-platform native package plus whatever the
+ * local dev server left in `data/`. Prune both from the function dir before it
+ * is cloned for the extra functions, since each clone is zipped and uploaded in
+ * full.
+ *
+ * Only prunes inside a directory that still holds a runnable prebuild under the
+ * `isServerlessNativePlatformPackage` naming (`@libsql`, `@resvg`). Packages
+ * that name prebuilds differently — `@img/sharp-linux-x64` has no gnu/musl
+ * suffix — read as entirely dead and must be left alone.
+ */
+export function pruneServerlessFunctionDeadWeight(functionDir) {
+    if (!functionDir || !fs.existsSync(functionDir))
+        return 0;
+    let removedBytes = 0;
+    const removedNames = [];
+    const nodeModulesDir = path.join(functionDir, "node_modules");
+    const packageDirs = [];
+    if (fs.existsSync(nodeModulesDir)) {
+        packageDirs.push(nodeModulesDir);
+        for (const entry of fs.readdirSync(nodeModulesDir, {
+            withFileTypes: true,
+        })) {
+            if (entry.isDirectory() && entry.name.startsWith("@")) {
+                packageDirs.push(path.join(nodeModulesDir, entry.name));
+            }
+        }
+    }
+    for (const packageDir of packageDirs) {
+        const prebuilds = fs
+            .readdirSync(packageDir, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory() &&
+            SERVERLESS_PLATFORM_PACKAGE_NAME.test(entry.name))
+            .map((entry) => entry.name);
+        const runnable = prebuilds.filter(isServerlessNativePlatformPackage);
+        if (runnable.length === 0)
+            continue;
+        for (const name of prebuilds) {
+            if (isServerlessNativePlatformPackage(name))
+                continue;
+            const deadDir = path.join(packageDir, name);
+            removedBytes += getDirSize(deadDir);
+            removedNames.push(path.relative(functionDir, deadDir));
+            fs.rmSync(deadDir, { recursive: true, force: true });
+        }
+        const survivors = runnable.filter((name) => fs.existsSync(path.join(packageDir, name)));
+        if (survivors.length === 0) {
+            throw new Error(`[deploy] Pruning dead-platform prebuilds from ${path.relative(cwd, packageDir)} removed every runnable Linux prebuild (had: ${runnable.join(", ")}).`);
+        }
+    }
+    const dataDir = path.join(functionDir, "data");
+    if (fs.existsSync(dataDir)) {
+        removedBytes += getDirSize(dataDir);
+        removedNames.push("data");
+        fs.rmSync(dataDir, { recursive: true, force: true });
+    }
+    if (removedNames.length > 0) {
+        console.log(`[deploy] Pruned ${removedNames.length} unrunnable path(s) (${(removedBytes /
+            1024 /
+            1024).toFixed(1)}MB) from ${path.relative(cwd, functionDir)}: ${removedNames.join(", ")}.`);
+    }
+    return removedBytes;
+}
 /**
  * Create stub directories for dangling platform-specific optional dependency
  * symlinks in the pnpm store.
@@ -3612,6 +3784,9 @@ export default bundle;
         copyInstalledFfmpegStaticPackage(nitro.options.output.serverDir);
         copyInstalledBrowserRuntimePackages(nitro.options.output.serverDir);
         sanitizeServerlessFunctionPackageManifest(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);
         bundleYjsRuntimeForServerlessOutput(nitro.options.output.serverDir, cwd);
     }
     if (isCloudflareModulePreset(preset)) {

package/dist/jobs/background-automation-runner.d.ts

@@ -12,7 +12,7 @@ export interface BackgroundAutomationContext {
     resource: Resource;
 }
 export interface BackgroundAutomationDeps {
-    getActions: (automation?: BackgroundAutomationContext) => Record<string, ActionEntry>;
+    getActions: (automation?: BackgroundAutomationContext) => Record<string, ActionEntry> | Promise<Record<string, ActionEntry>>;
     getSystemPrompt: (owner: string) => Promise<string>;
     getInitialToolNames?: (automation?: BackgroundAutomationContext) => string[] | undefined;
     engine?: AgentEngine;

package/dist/jobs/background-automation-runner.js

@@ -221,7 +221,7 @@ async function executeBackgroundAutomation(options, deps, historyId) {
         userEmail: ownerEmail,
         orgId,
     }, async () => {
-        const baseActions = deps.getActions(automation);
+        const baseActions = await deps.getActions(automation);
         assertRequestedMcpToolsAvailable(automation, baseActions);
         const configuredInitialTools = deps.getInitialToolNames?.(automation);
         const initialToolNames = configuredInitialTools

package/dist/jobs/scheduler-health.d.ts

@@ -1,3 +1,7 @@
+import { type MigrationEntry } from "../db/migrations.js";
+/** Authoritative release-time schema for recurring scheduler health. */
+export declare const AUTOMATION_SCHEDULER_HEALTH_MIGRATIONS: MigrationEntry[];
+export declare function runAutomationSchedulerHealthMigrations(nitroApp: unknown): Promise<void>;
 export interface AutomationSchedulerHealth {
     appId: string;
     orgId: string | null;

package/dist/jobs/scheduler-health.js

@@ -1,8 +1,41 @@
 import { getDbExec, intType, isPostgres } from "../db/client.js";
 import { ensureColumnExists, ensureIndexExists, ensureTableExists, } from "../db/ddl-guard.js";
+import { runMigrations } from "../db/migrations.js";
 const TABLE = "automation_scheduler_health";
 const DEFAULT_APP_ID = "default";
 const MAX_ERROR_LENGTH = 500;
+/** Authoritative release-time schema for recurring scheduler health. */
+export const AUTOMATION_SCHEDULER_HEALTH_MIGRATIONS = [
+    {
+        version: 1,
+        name: "automation-scheduler-health-table",
+        sql: `
+      CREATE TABLE IF NOT EXISTS ${TABLE} (
+        id TEXT PRIMARY KEY,
+        app_id TEXT NOT NULL DEFAULT 'default',
+        org_id TEXT,
+        last_checked_at INTEGER,
+        last_dispatched_at INTEGER,
+        last_error TEXT,
+        runtime TEXT,
+        updated_at INTEGER NOT NULL DEFAULT 0
+      );
+      ALTER TABLE ${TABLE} ADD COLUMN IF NOT EXISTS app_id TEXT NOT NULL DEFAULT 'default';
+      ALTER TABLE ${TABLE} ADD COLUMN IF NOT EXISTS org_id TEXT;
+      ALTER TABLE ${TABLE} ADD COLUMN IF NOT EXISTS last_checked_at INTEGER;
+      ALTER TABLE ${TABLE} ADD COLUMN IF NOT EXISTS last_dispatched_at INTEGER;
+      ALTER TABLE ${TABLE} ADD COLUMN IF NOT EXISTS last_error TEXT;
+      ALTER TABLE ${TABLE} ADD COLUMN IF NOT EXISTS runtime TEXT;
+      ALTER TABLE ${TABLE} ADD COLUMN IF NOT EXISTS updated_at INTEGER NOT NULL DEFAULT 0;
+      CREATE INDEX IF NOT EXISTS idx_${TABLE}_updated ON ${TABLE} (updated_at)
+    `,
+    },
+];
+export async function runAutomationSchedulerHealthMigrations(nitroApp) {
+    await runMigrations(AUTOMATION_SCHEDULER_HEALTH_MIGRATIONS, {
+        table: "_automation_scheduler_health_migrations",
+    })(nitroApp);
+}
 function normalizeAppId(appId) {
     const normalized = appId?.trim();
     return normalized || DEFAULT_APP_ID;

package/dist/localization/server.d.ts

@@ -16,7 +16,6 @@ export interface ResolveLocaleFromRequestOptions {
 export interface LocaleInitScriptOptions {
     locale?: LocaleCode;
     preference?: LocalizationPreference | LocalePreference;
-    messages?: Record<string, unknown> | null;
 }
 export declare function parseAcceptLanguage(header: string | null | undefined): string[];
 export declare function resolveLocaleFromRequest(options?: ResolveLocaleFromRequestOptions): ResolvedRequestLocale;

package/dist/localization/server.js

@@ -58,11 +58,13 @@ export function getLocaleInitScript(options = {}) {
     const safeLocale = normalizeLocaleCode(options.locale) ?? DEFAULT_LOCALE;
     const shouldStorePreference = options.preference !== undefined;
     const safePreference = normalizeLocalizationPreference(options.preference ?? { locale: "system" });
+    // Translations are deliberately absent here: this script is render-blocking in
+    // <head>, and the provider already receives the same catalog through loader
+    // data as `initialMessages`. Adding them back doubles every localized payload.
     const payload = {
         locale: safeLocale,
         preference: safePreference,
         dir: localeDirection(safeLocale),
-        messages: options.messages ?? undefined,
     };
     return `(function(){try{var supported=${JSON.stringify(SUPPORTED_LOCALES)};var payload=${JSON.stringify(payload)};var shouldStorePreference=${JSON.stringify(shouldStorePreference)};function valid(x){return supported.indexOf(x)>=0}function canon(x){if(typeof x!=='string'||!x)return null;try{var c=Intl.getCanonicalLocales(x)[0];if(valid(c))return c;var lang=c&&c.split('-')[0].toLowerCase();for(var i=0;i<supported.length;i++){if(supported[i].split('-')[0].toLowerCase()===lang)return supported[i]}}catch(e){}return null}function storageGet(k){try{return window.localStorage.getItem(k)}catch(e){return null}}function storageSet(k,v){try{window.localStorage.setItem(k,v)}catch(e){}}var stored=storageGet(${JSON.stringify(LOCALE_STORAGE_KEY)});var pref=payload.preference&&payload.preference.locale;var locale=payload.locale;if(!valid(locale)){locale=null}if(!locale&&stored&&stored!=='system'){locale=canon(stored)}if(!locale&&pref&&pref!=='system'){locale=canon(pref)}if(!locale){var langs=navigator.languages&&navigator.languages.length?navigator.languages:[navigator.language];for(var j=0;j<langs.length&&!locale;j++){locale=canon(langs[j])}}if(!locale)locale=${JSON.stringify(DEFAULT_LOCALE)};var root=document.documentElement;root.setAttribute('lang',locale);root.setAttribute('dir',locale==='ar-SA'?'rtl':'ltr');root.setAttribute('data-locale',locale);payload.locale=locale;payload.dir=locale==='ar-SA'?'rtl':'ltr';window[${JSON.stringify(LOCALE_HYDRATION_GLOBAL)}]=payload;if(shouldStorePreference&&pref){storageSet(${JSON.stringify(LOCALE_STORAGE_KEY)},pref)}}catch(e){}})();`;
 }

package/dist/mcp-client/index.d.ts

@@ -10,7 +10,7 @@ export { listRemoteServers, addRemoteServer, addOAuthRemoteServer, addFirstParty
 export { finishMcpOAuthAuthorization, getMcpOAuthAccessToken, readMcpOAuthCredentials, saveMcpOAuthCredentials, startMcpOAuthAuthorization, type McpOAuthCallbackResult, type McpOAuthCredentialBundle, type McpOAuthDiscoveryState, type McpOAuthProviderOptions, type McpOAuthStartResult, } from "./oauth-client.js";
 export { areBuiltinMcpCapabilitiesSupported, BUILTIN_MCP_CAPABILITIES, getBuiltinMcpCapability, isBuiltinMcpCapabilityAvailable, listSupportedBuiltinMcpCapabilities, normalizeBuiltinMcpCapabilityIds, toBuiltinMcpServerConfig, type BuiltinMcpCapability, type BuiltinMcpCapabilityId, } from "./builtin-capabilities.js";
 export { builtinMcpCapabilitiesSettingsKey, listEnabledBuiltinMcpCapabilities, setEnabledBuiltinMcpCapabilities, setBuiltinMcpCapabilityEnabled, type StoredBuiltinMcpCapabilities, } from "./builtin-store.js";
-export { mountMcpServersRoutes, buildMergedConfig, builtinMergedConfigKey, startMcpConfigRefresh, type ClientBuiltinCapability, } from "./routes.js";
+export { mountMcpServersRoutes, buildMergedConfig, builtinMergedConfigKey, startMcpConfigRefresh, McpConfigUnreadableError, type ClientBuiltinCapability, } from "./routes.js";
 export { mountMcpHubRoutes, listHubServers, getHubStatus, isHubServeEnabled, isHubConsumeEnabled, type HubServerRecord, type HubServersResponse, } from "./hub-routes.js";
 export { fetchHubServers } from "./hub-client.js";
 export { isMcpToolAllowedForRequest } from "./visibility.js";

package/dist/mcp-client/index.js

@@ -10,7 +10,7 @@ export { listRemoteServers, addRemoteServer, addOAuthRemoteServer, addFirstParty
 export { finishMcpOAuthAuthorization, getMcpOAuthAccessToken, readMcpOAuthCredentials, saveMcpOAuthCredentials, startMcpOAuthAuthorization, } from "./oauth-client.js";
 export { areBuiltinMcpCapabilitiesSupported, BUILTIN_MCP_CAPABILITIES, getBuiltinMcpCapability, isBuiltinMcpCapabilityAvailable, listSupportedBuiltinMcpCapabilities, normalizeBuiltinMcpCapabilityIds, toBuiltinMcpServerConfig, } from "./builtin-capabilities.js";
 export { builtinMcpCapabilitiesSettingsKey, listEnabledBuiltinMcpCapabilities, setEnabledBuiltinMcpCapabilities, setBuiltinMcpCapabilityEnabled, } from "./builtin-store.js";
-export { mountMcpServersRoutes, buildMergedConfig, builtinMergedConfigKey, startMcpConfigRefresh, } from "./routes.js";
+export { mountMcpServersRoutes, buildMergedConfig, builtinMergedConfigKey, startMcpConfigRefresh, McpConfigUnreadableError, } from "./routes.js";
 export { mountMcpHubRoutes, listHubServers, getHubStatus, isHubServeEnabled, isHubConsumeEnabled, } from "./hub-routes.js";
 export { fetchHubServers } from "./hub-client.js";
 export { isMcpToolAllowedForRequest } from "./visibility.js";