@agent-native/core 0.139.0 → 0.141.0

package/corpus/templates/clips/app/routes/share.$shareId.tsx

@@ -293,6 +293,8 @@ const CLIPS_AGENT_DOCS_URL =
   "https://www.agent-native.com/docs/template-clips#agent-readable-clips";
 const UPLOAD_STUCK_TIMEOUT_MS = 5 * 60 * 1000;
 const PROCESSING_STUCK_TIMEOUT_MS = 12 * 60 * 1000;
+const READY_MEDIA_SETTLE_POLL_MS = 20 * 1000;
+const READY_MEDIA_SETTLE_POLL_INTERVAL_MS = 1000;
 
 type ViewerPlatform = "mac" | "windows" | "linux";
 
@@ -404,6 +406,7 @@ export default function ShareRoute() {
   }, [recordingId, attribution.ref, attribution.via]);
 
   const playerRef = useRef<VideoPlayerHandle | null>(null);
+  const readyMediaPollRef = useRef<{ key: string; until: number } | null>(null);
   const [password, setPassword] = useState<string | null>(() => {
     if (typeof window === "undefined" || !shareId) return null;
     try {
@@ -463,7 +466,26 @@ export default function ShareRoute() {
       // page auto-upgrades from "Processing" to the real player the moment
       // the server flips status to 'ready' and writes videoUrl. Mirrors
       // r.$recordingId.tsx's playerDataQ.refetchInterval.
-      if (rec.status !== "ready" || !rec.videoUrl) return 2000;
+      if (rec.status !== "ready" || !rec.videoUrl) {
+        readyMediaPollRef.current = null;
+        return 2000;
+      }
+      const mediaKey = [
+        rec.id,
+        rec.durationMs ?? "",
+        rec.videoSizeBytes ?? "",
+        rec.videoFormat ?? "",
+      ].join(":");
+      const now = Date.now();
+      if (readyMediaPollRef.current?.key !== mediaKey) {
+        readyMediaPollRef.current = {
+          key: mediaKey,
+          until: now + READY_MEDIA_SETTLE_POLL_MS,
+        };
+      }
+      if (now < readyMediaPollRef.current.until) {
+        return READY_MEDIA_SETTLE_POLL_INTERVAL_MS;
+      }
       // Also keep polling while a transcript is pending so "Transcribing…"
       // auto-flips to the ready transcript (or to the failure card). The
       // public payload has no transcript.cleanup field (that's authenticated
@@ -985,6 +1007,10 @@ export default function ShareRoute() {
               onVideoElementChange={setTrackedVideoEl}
               recordingId={recording.id}
               videoUrl={recording.videoUrl}
+              mediaVersion={[
+                recording.videoSizeBytes ?? "",
+                recording.updatedAt ?? "",
+              ].join(":")}
               videoFormat={recording.videoFormat}
               embedProvider={isLoomEmbedBacked ? "loom" : null}
               durationMs={recording.durationMs}

package/corpus/templates/clips/changelog/2026-08-05-comment-and-video-reaction-pickers-now-include-eyes-and-mind.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-08-05
+---
+
+Comment and video reaction pickers now include eyes and mind-blown reactions consistently.

package/corpus/templates/clips/changelog/2026-08-05-fresh-recordings-now-open-with-the-complete-video.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-08-05
+---
+
+Fresh recordings now open with the complete video

package/corpus/templates/clips/server/lib/transactional-email-templates.ts

@@ -86,29 +86,6 @@ export type ClipsTransactionalEmailInput =
       videoTimestampMs?: number | null;
     });
 
-export const CLIPS_FIRST_VIEW_EMAIL_ID = "clips.first-view";
-export const CLIPS_UNVIEWED_REMINDER_EMAIL_ID = "clips.unviewed-reminder";
-export const CLIPS_FIRST_AGENT_VIEW_EMAIL_ID = "clips.first-agent-view";
-export const CLIPS_FIRST_IMPORT_EMAIL_ID = "clips.first-import";
-export const CLIPS_MONTHLY_RECAP_EMAIL_ID = "clips.monthly-recap";
-export const CLIPS_TWO_CLIPS_EMAIL_ID = "clips.two-clips";
-export const CLIPS_ACTIVITY_COMMENT_EMAIL_ID = "clips.activity-comment";
-export const CLIPS_ACTIVITY_REACTION_EMAIL_ID = "clips.activity-reaction";
-
-export const CLIPS_EMAIL_ID_BY_KIND: Record<
-  ClipsTransactionalEmailInput["kind"],
-  string
-> = {
-  "first-view": CLIPS_FIRST_VIEW_EMAIL_ID,
-  "unviewed-reminder": CLIPS_UNVIEWED_REMINDER_EMAIL_ID,
-  "first-agent-view": CLIPS_FIRST_AGENT_VIEW_EMAIL_ID,
-  "first-import": CLIPS_FIRST_IMPORT_EMAIL_ID,
-  "monthly-recap": CLIPS_MONTHLY_RECAP_EMAIL_ID,
-  "two-clips": CLIPS_TWO_CLIPS_EMAIL_ID,
-  "activity-comment": CLIPS_ACTIVITY_COMMENT_EMAIL_ID,
-  "activity-reaction": CLIPS_ACTIVITY_REACTION_EMAIL_ID,
-};
-
 export interface RecapTopClipInput {
   recordingId: string;
   title?: string | null;
@@ -636,7 +613,6 @@ export async function sendClipsTransactionalEmail(
         ? (validReplyTo(input.senderEmail) ?? FRIENDLY_REPLY_TO)
         : FRIENDLY_REPLY_TO,
     timeoutMs: EMAIL_SEND_TIMEOUT_MS,
-    templateId: CLIPS_EMAIL_ID_BY_KIND[input.kind],
   });
 }
 

package/corpus/templates/clips/server/routes/api/public-recording.get.ts

@@ -453,6 +453,7 @@ export default defineEventHandler(async (event) => {
       editsJson: rec.editsJson,
       videoUrl: playbackVideoUrl,
       videoFormat: rec.videoFormat,
+      videoSizeBytes: rec.videoSizeBytes ?? null,
       width: rec.width,
       height: rec.height,
       hasAudio: Boolean(rec.hasAudio),

package/corpus/templates/content/server/lib/comment-notifications.ts

@@ -21,10 +21,6 @@ import { and, eq } from "drizzle-orm";
 
 import { CONTENT_USER_PREFS_KEY } from "../../shared/content-user-prefs.js";
 import { getDb, schema } from "../db/index.js";
-import {
-  CONTENT_DOCUMENT_COMMENT_EMAIL_ID,
-  CONTENT_DOCUMENT_MENTION_EMAIL_ID,
-} from "./emails.js";
 
 export type DocumentCommentNotificationResult = ActivityNotificationResult;
 
@@ -74,48 +70,6 @@ export interface DocumentCommentNotificationInput {
   isReply: boolean;
 }
 
-export function renderDocumentCommentEmail({
-  actor,
-  title,
-  url,
-  content,
-  isReply,
-  wasMentioned,
-}: {
-  actor: string;
-  title: string;
-  url: string;
-  content: string;
-  isReply: boolean;
-  wasMentioned: boolean;
-}) {
-  const lead = wasMentioned
-    ? `${emailStrong(actor)} mentioned you in a comment on ${emailStrong(title)}.`
-    : isReply
-      ? `${emailStrong(actor)} replied in a comment thread on ${emailStrong(title)}.`
-      : `${emailStrong(actor)} commented on ${emailStrong(title)}.`;
-
-  return {
-    subject: wasMentioned
-      ? `${actor} mentioned you on "${title}"`
-      : isReply
-        ? `${actor} replied to a comment on "${title}"`
-        : `${actor} commented on "${title}"`,
-    ...renderEmail({
-      preheader: `${actor} commented on ${title}.`,
-      heading: wasMentioned
-        ? "You were mentioned"
-        : isReply
-          ? "New reply on your document"
-          : "New comment",
-      paragraphs: [lead, `"${excerpt(content)}"`],
-      cta: { label: "Open document", url },
-      footer:
-        "You received this because you own, were mentioned in, or participated in this thread. Turn these off in Documents settings.",
-    }),
-  };
-}
-
 export async function notifyDocumentComment(
   input: DocumentCommentNotificationInput,
 ): Promise<DocumentCommentNotificationResult> {
@@ -158,19 +112,34 @@ async function deliverDocumentCommentEmails(
     logLabel: LOG_LABEL,
     send: async (to) => {
       const wasMentioned = mentioned.has(to);
+      const lead = wasMentioned
+        ? `${emailStrong(actor)} mentioned you in a comment on ${emailStrong(title)}.`
+        : input.isReply
+          ? `${emailStrong(actor)} replied in a comment thread on ${emailStrong(title)}.`
+          : `${emailStrong(actor)} commented on ${emailStrong(title)}.`;
+
+      const { html, text } = renderEmail({
+        preheader: `${actor} commented on ${title}.`,
+        heading: wasMentioned
+          ? "You were mentioned"
+          : input.isReply
+            ? "New reply on your document"
+            : "New comment",
+        paragraphs: [lead, `"${excerpt(input.content)}"`],
+        cta: { label: "Open document", url },
+        footer:
+          "You received this because you own, were mentioned in, or participated in this thread. Turn these off in Documents settings.",
+      });
+
       await sendEmail({
-        ...renderDocumentCommentEmail({
-          actor,
-          title,
-          url,
-          content: input.content,
-          isReply: input.isReply,
-          wasMentioned,
-        }),
         to,
-        templateId: wasMentioned
-          ? CONTENT_DOCUMENT_MENTION_EMAIL_ID
-          : CONTENT_DOCUMENT_COMMENT_EMAIL_ID,
+        subject: wasMentioned
+          ? `${actor} mentioned you on "${title}"`
+          : input.isReply
+            ? `${actor} replied to a comment on "${title}"`
+            : `${actor} commented on "${title}"`,
+        html,
+        text,
       });
     },
   });

package/corpus/templates/design/app/components/design/edit-panel/stroke-properties.tsx

@@ -162,7 +162,11 @@ function StrokeLayerControl({
         <div className="min-w-0 flex-1">
           <ColorInput
             label=""
-            value={cssColorOrFallback(color, "#000000")}
+            value={cssColorOrFallback(
+              color,
+              /* guard:allow-raw-color - ColorInput needs a concrete swatch fallback. */
+              "#000000",
+            )}
             onChange={(value, meta) =>
               onStyleChange(`${prefix}Color`, value, meta)
             }
@@ -449,7 +453,11 @@ export function StrokeProperties({
             <StrokeLayerControl
               kind="border"
               visible={borderVisible}
-              color={styles.borderColor || "#000000"}
+              color={
+                styles.borderColor ||
+                /* guard:allow-raw-color - a new stroke needs a concrete color. */
+                "#000000"
+              }
               width={styles.borderWidth || "0px"}
               styleValue={styles.borderStyle || "none"}
               onStyleChange={onStyleChange}
@@ -470,7 +478,12 @@ export function StrokeProperties({
             <StrokeLayerControl
               kind="outline"
               visible={outlineVisible}
-              color={styles.outlineColor || styles.borderColor || "#000000"}
+              color={
+                styles.outlineColor ||
+                styles.borderColor ||
+                /* guard:allow-raw-color - a new stroke needs a concrete color. */
+                "#000000"
+              }
               width={styles.outlineWidth || "0px"}
               styleValue={styles.outlineStyle || "solid"}
               outlineOffset={styles.outlineOffset || "0px"}

package/corpus/templates/forms/server/lib/response-email.ts

@@ -1,7 +1,6 @@
 import { emailStrong, renderEmail, sendEmail } from "@agent-native/core/server";
 
 import type { FormField } from "../../shared/types.js";
-import { FORMS_NEW_RESPONSE_EMAIL_ID } from "./emails.js";
 
 export interface NewResponseEmailArgs {
   to: string;
@@ -62,6 +61,5 @@ export async function sendNewResponseEmail(
   await sendEmail({
     to: args.to,
     ...renderNewResponseEmail(args),
-    templateId: FORMS_NEW_RESPONSE_EMAIL_ID,
   });
 }

package/corpus/templates/plan/actions/request-plan-access.ts

@@ -22,8 +22,6 @@ import {
 } from "../server/lib/local-identity.js";
 import { newId, nowIso, planPath, writeEvent } from "../server/plans.js";
 
-export const PLAN_ACCESS_REQUEST_EMAIL_ID = "plan.access-request";
-
 function httpError(message: string, statusCode: number): Error {
   return Object.assign(new Error(message), { statusCode });
 }
@@ -51,28 +49,6 @@ function absolutePlanUrl(planId: string, kind: "plan" | "recap"): string {
   }
 }
 
-export function renderPlanAccessRequestEmail(input: {
-  requesterName: string;
-  requesterEmail: string;
-  planTitle: string;
-  url: string;
-}) {
-  const subject = `${input.requesterName} requested access to "${input.planTitle}"`;
-  return {
-    subject,
-    ...renderEmail({
-      preheader: subject,
-      heading: "Access request",
-      paragraphs: [
-        `${emailStrong(input.requesterName)} (${emailStrong(input.requesterEmail)}) requested access to ${emailStrong(input.planTitle)}.`,
-        "Open the plan and use Share to grant access if this request should be approved.",
-      ],
-      cta: { label: "Open plan", url: input.url },
-      footer: "You received this because you own this Agent-Native Plan.",
-    }),
-  };
-}
-
 async function notifyOwner(input: {
   planId: string;
   planKind: "plan" | "recap";
@@ -86,16 +62,19 @@ async function notifyOwner(input: {
     return false;
   }
 
-  await sendEmail({
-    ...renderPlanAccessRequestEmail({
-      requesterName: input.requesterName,
-      requesterEmail: input.requesterEmail,
-      planTitle: input.planTitle,
-      url: absolutePlanUrl(input.planId, input.planKind),
-    }),
-    to: input.ownerEmail,
-    templateId: PLAN_ACCESS_REQUEST_EMAIL_ID,
+  const url = absolutePlanUrl(input.planId, input.planKind);
+  const subject = `${input.requesterName} requested access to "${input.planTitle}"`;
+  const { html, text } = renderEmail({
+    preheader: subject,
+    heading: "Access request",
+    paragraphs: [
+      `${emailStrong(input.requesterName)} (${emailStrong(input.requesterEmail)}) requested access to ${emailStrong(input.planTitle)}.`,
+      "Open the plan and use Share to grant access if this request should be approved.",
+    ],
+    cta: { label: "Open plan", url },
+    footer: "You received this because you own this Agent-Native Plan.",
   });
+  await sendEmail({ to: input.ownerEmail, subject, html, text });
   return true;
 }
 

package/corpus/templates/plan/server/lib/comment-notifications.ts

@@ -14,8 +14,6 @@ import {
 import type { PlanBundle, PlanComment } from "../../shared/types.js";
 import { getDb, schema } from "../db/index.js";
 
-export const PLAN_COMMENT_EMAIL_ID = "plan.plan-comment";
-
 type CommentNotificationInput = {
   bundle: PlanBundle;
   insertedCommentIds: string[];
@@ -207,64 +205,40 @@ export function planCommentNotificationRecipients(input: {
   return Array.from(recipients.values());
 }
 
-export function renderPlanCommentEmail(input: {
-  actor: string;
-  app: string;
-  planTitle: string;
-  planUrl: string;
-  message: string;
-  isReply: boolean;
-  reason: NotificationRecipient["reason"];
-}) {
-  const actionText =
-    input.reason === "mention"
-      ? "mentioned you in a comment on"
-      : input.reason === "plan-owner"
-        ? "left a comment on your plan"
-        : "replied in a comment thread you participated in";
-  return {
-    subject: input.isReply
-      ? `${input.actor} replied to a comment on "${input.planTitle}"`
-      : `${input.actor} commented on "${input.planTitle}"`,
-    ...renderEmail({
-      preheader: `${input.actor} ${actionText} on ${input.app}.`,
-      heading: input.isReply
-        ? "New reply on your plan"
-        : "New comment on your plan",
-      paragraphs: [
-        `${emailStrong(input.actor)} ${actionText} ${emailStrong(input.planTitle)}.`,
-        `Comment: "${commentExcerpt(input.message)}"`,
-      ],
-      cta: { label: "Open plan", url: input.planUrl },
-      footer:
-        input.reason === "plan-owner"
-          ? "You received this because you own this plan."
-          : input.reason === "mention"
-            ? "You received this because you were mentioned in this comment."
-            : "You received this because you participated in this comment thread.",
-    }),
-  };
-}
-
 async function sendPlanCommentNotification(input: {
   recipient: NotificationRecipient;
   comment: PlanComment;
   planTitle: string;
   planId: string;
 }) {
-  await sendEmail({
-    ...renderPlanCommentEmail({
-      actor: actorName(input.comment),
-      app: appName(),
-      planTitle: input.planTitle,
-      planUrl: planUrl(input.planId),
-      message: input.comment.message,
-      isReply: Boolean(input.comment.parentCommentId),
-      reason: input.recipient.reason,
-    }),
-    to: input.recipient.email,
-    templateId: PLAN_COMMENT_EMAIL_ID,
+  const actor = actorName(input.comment);
+  const app = appName();
+  const isReply = Boolean(input.comment.parentCommentId);
+  const subject = isReply
+    ? `${actor} replied to a comment on "${input.planTitle}"`
+    : `${actor} commented on "${input.planTitle}"`;
+  const actionText =
+    input.recipient.reason === "mention"
+      ? "mentioned you in a comment on"
+      : input.recipient.reason === "plan-owner"
+        ? "left a comment on your plan"
+        : "replied in a comment thread you participated in";
+  const { html, text } = renderEmail({
+    preheader: `${actor} ${actionText} on ${app}.`,
+    heading: isReply ? "New reply on your plan" : "New comment on your plan",
+    paragraphs: [
+      `${emailStrong(actor)} ${actionText} ${emailStrong(input.planTitle)}.`,
+      `Comment: "${commentExcerpt(input.comment.message)}"`,
+    ],
+    cta: { label: "Open plan", url: planUrl(input.planId) },
+    footer:
+      input.recipient.reason === "plan-owner"
+        ? "You received this because you own this plan."
+        : input.recipient.reason === "mention"
+          ? "You received this because you were mentioned in this comment."
+          : "You received this because you participated in this comment thread.",
   });
+  await sendEmail({ to: input.recipient.email, subject, html, text });
 }
 
 export async function notifyPlanCommentRecipients({

package/corpus/templates/slides/server/lib/comment-notifications.ts

@@ -21,7 +21,6 @@ import { and, eq } from "drizzle-orm";
 import { getDeckUrl } from "../../actions/_app-url.js";
 import { SLIDES_USER_PREFS_KEY } from "../../shared/slides-user-prefs.js";
 import { getDb, schema } from "../db/index.js";
-import { SLIDES_DECK_COMMENT_EMAIL_ID } from "./emails.js";
 
 /**
  * `deck-missing` stays distinct from `no-recipients`: one means the deck could
@@ -100,41 +99,6 @@ async function threadParticipants(
   return rows.map((row) => row.authorEmail);
 }
 
-export function renderDeckCommentEmail({
-  actor,
-  title,
-  url,
-  content,
-  isReply,
-}: {
-  actor: string;
-  title: string;
-  url: string;
-  content: string;
-  isReply: boolean;
-}) {
-  return {
-    subject: isReply
-      ? `${actor} replied to a comment on "${title}"`
-      : `${actor} commented on "${title}"`,
-    ...renderEmail({
-      preheader: isReply
-        ? `${actor} replied to a comment on ${title}.`
-        : `${actor} commented on ${title}.`,
-      heading: isReply ? "New reply on your deck" : "New comment",
-      paragraphs: [
-        isReply
-          ? `${emailStrong(actor)} replied in a comment thread on ${emailStrong(title)}.`
-          : `${emailStrong(actor)} commented on ${emailStrong(title)}.`,
-        `"${excerpt(content)}"`,
-      ],
-      cta: { label: "Open deck", url },
-      footer:
-        "You received this because you own or participated in this thread. Turn these off in Slides settings.",
-    }),
-  };
-}
-
 export async function notifyDeckComment(input: {
   deckId: string;
   slideId: string;
@@ -189,16 +153,29 @@ async function deliverDeckCommentEmails(input: {
     preferenceKey: SLIDES_USER_PREFS_KEY,
     logLabel: LOG_LABEL,
     send: async (to) => {
+      const { html, text } = renderEmail({
+        preheader: input.isReply
+          ? `${actor} replied to a comment on ${deck.title}.`
+          : `${actor} commented on ${deck.title}.`,
+        heading: input.isReply ? "New reply on your deck" : "New comment",
+        paragraphs: [
+          input.isReply
+            ? `${emailStrong(actor)} replied in a comment thread on ${emailStrong(deck.title)}.`
+            : `${emailStrong(actor)} commented on ${emailStrong(deck.title)}.`,
+          `"${excerpt(input.content)}"`,
+        ],
+        cta: { label: "Open deck", url },
+        footer:
+          "You received this because you own or participated in this thread. Turn these off in Slides settings.",
+      });
+
       await sendEmail({
-        ...renderDeckCommentEmail({
-          actor,
-          title: deck.title,
-          url,
-          content: input.content,
-          isReply: input.isReply,
-        }),
         to,
-        templateId: SLIDES_DECK_COMMENT_EMAIL_ID,
+        subject: input.isReply
+          ? `${actor} replied to a comment on "${deck.title}"`
+          : `${actor} commented on "${deck.title}"`,
+        html,
+        text,
       });
     },
   });

package/dist/a2a/handlers.js

@@ -583,17 +583,16 @@ async function handleSend(params, config, event) {
     if (!asyncMode)
         idempotencyKey = undefined;
     if (asyncMode) {
-        // Refuse async mode entirely when no auth is configured in production.
-        // The async dispatch path self-fires the `_process-task` route, which
-        // accepts unsigned dispatches when A2A_SECRET is unset — that combined
-        // with the lack of caller identity here would let any unauthenticated
-        // attacker queue and trigger handler runs. In production, require some
-        // form of auth so the verifiedEmail is bound to the task.
-        const hasA2ASecret = hasConfiguredA2ASecret();
-        const hasApiKey = !!(config.apiKeyEnv && process.env[config.apiKeyEnv]);
-        if (isA2AProductionRuntime() && !hasA2ASecret && !hasApiKey) {
+        // Refuse async mode entirely without the shared secret in production.
+        // The async dispatch path self-fires the `_process-task` route, which is
+        // authenticated with an internal HMAC signed by A2A_SECRET. A legacy
+        // apiKeyEnv can authenticate the JSON-RPC request, but it cannot
+        // authenticate that internal handoff. Accepting it here would create a
+        // working task that can never start and leaves the caller polling until
+        // its timeout.
+        if (isA2AProductionRuntime() && !hasConfiguredA2ASecret()) {
             return {
-                ...jsonRpcError(0, -32001, "A2A async mode is not available — A2A_SECRET or apiKeyEnv must be configured."),
+                ...jsonRpcError(0, -32001, "A2A async mode requires A2A_SECRET for internal processor dispatch; apiKeyEnv only supports synchronous A2A."),
                 _id: 0,
             };
         }

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<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/db/client.js

@@ -804,19 +804,19 @@ export function pgPoolOptions(url) {
 export function neonPoolMax() {
     if (!isServerlessRuntime())
         return 20;
-    // The durable background-function worker is a SINGLE process per run (unlike
-    // the many warm request-instances the foreground serverless has), so it can
-    // safely hold a larger pool without risking Neon's connection cap. The agent's
+    // Netlify can run several background workers concurrently; a background
+    // worker is not a global singleton and must not hold a larger pool than the
+    // foreground path. The agent's
     // pre-send setup fires ~6 concurrent DB reads in parallel; with only 2
     // connections that burst exhausts the pool and a single stalled connection
     // freezes the worker before it can claim — observed on analytics' heavier
     // action surface, where the worker froze right after `model_done` and never
-    // recorded `env_config`/`presend`, while the foreground (10-connection pool)
-    // ran the identical code in ~2s. Give the bg worker enough connections for the
-    // burst; keep the foreground serverless pool tiny to avoid "Max client
-    // connections reached" across many warm instances.
+    // recorded `env_config`/`presend`, while the foreground path ran the
+    // identical code in ~2s. Four connections preserve the concurrent
+    // read burst while keeping foreground and background caps aligned, avoiding
+    // "Max client connections reached" across many warm instances.
     if (isBackgroundFunctionPoolContext())
-        return 8;
+        return 4;
     return 4;
 }
 /**