@agent-native/core 0.133.1 → 0.133.3

package/corpus/README.md

@@ -30,4 +30,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 
 - core files: 1646
 - toolkit files: 168
-- template files: 7413
+- template files: 7421

package/corpus/core/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @agent-native/core
 
+## 0.133.3
+
+### Patch Changes
+
+- 9258da4: Preserve nested object parameters when browser clients call GET actions.
+
+## 0.133.2
+
+### Patch Changes
+
+- 3fac05d: Ensure Netlify-hosted integration calls hand off slow cross-app work to durable delivery when only runtime markers are available.
+
 ## 0.133.1
 
 ### Patch Changes

package/corpus/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.133.1",
+  "version": "0.133.3",
   "description": "Framework for agent-native application development — where AI agents and UI share SQL state, actions, and context",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {

package/corpus/core/src/a2a/client.ts

@@ -536,8 +536,14 @@ export class A2AClient {
       metadata?: Record<string, unknown>;
       idempotencyKey?: string;
       approvedActions?: A2AApprovedAction[];
-      /** Total time to wait for completion. Default 5 min. */
+      /** Time to wait after submission for completion. Default 5 min. */
       timeoutMs?: number;
+      /**
+       * Optional separate budget for agent-card discovery and the initial
+       * async message submission. When omitted, timeoutMs remains the shared
+       * end-to-end deadline for backwards compatibility.
+       */
+      submissionTimeoutMs?: number;
       /** Poll interval. Default 2s. */
       pollIntervalMs?: number;
       /** Called with each polled task — useful for surfacing progress. */
@@ -545,7 +551,8 @@ export class A2AClient {
     },
   ): Promise<Task> {
     const timeoutMs = opts?.timeoutMs ?? 5 * 60_000;
-    const deadlineMs = Date.now() + timeoutMs;
+    const submissionDeadlineMs =
+      Date.now() + (opts?.submissionTimeoutMs ?? timeoutMs);
     const submitted = await this.send(message, {
       contextId: opts?.contextId,
       metadata: opts?.metadata,
@@ -556,12 +563,19 @@ export class A2AClient {
       async: true,
       requestTimeoutMs: Math.min(
         this.requestTimeoutMs ?? DEFAULT_A2A_POLL_REQUEST_TIMEOUT_MS,
-        Math.max(1, deadlineMs - Date.now()),
+        Math.max(1, submissionDeadlineMs - Date.now()),
       ),
-      deadlineMs,
+      deadlineMs: submissionDeadlineMs,
     });
 
-    return this.pollTask(submitted, { ...opts, timeoutMs, deadlineMs });
+    const pollingDeadlineMs = opts?.submissionTimeoutMs
+      ? Date.now() + timeoutMs
+      : submissionDeadlineMs;
+    return this.pollTask(submitted, {
+      ...opts,
+      timeoutMs,
+      deadlineMs: pollingDeadlineMs,
+    });
   }
 
   /**
@@ -1017,6 +1031,8 @@ export async function callAgent(
     async?: boolean;
     /** Total time to wait for the polled task (default 5 min). */
     timeoutMs?: number;
+    /** Separate budget for discovery and initial async submission. */
+    submissionTimeoutMs?: number;
     /**
      * Existing async task to keep polling. When set, no new message is sent.
      * This prevents a caller-side timeout from duplicating downstream work.
@@ -1092,6 +1108,7 @@ export async function callAgent(
                 ? { approvedActions: opts.approvedActions }
                 : {}),
               timeoutMs: opts?.timeoutMs,
+              submissionTimeoutMs: opts?.submissionTimeoutMs,
               pollIntervalMs: opts?.pollIntervalMs,
               onUpdate: opts?.onUpdate,
             });

package/corpus/core/src/client/use-action.ts

@@ -207,6 +207,12 @@ function appendActionQueryParam(
     }
     return;
   }
+  if (typeof value === "object") {
+    // defineAction restores JSON strings when the schema expects an object.
+    // Preserve nested GET params instead of collapsing them to "[object Object]".
+    qs.append(key, JSON.stringify(value));
+    return;
+  }
   qs.append(key, String(value));
 }
 

package/corpus/core/src/integrations/webhook-handler.ts

@@ -2274,6 +2274,13 @@ function isQueuedA2AContinuationDeferral(text: string): boolean {
   if (!normalized) return true;
   if (hasSubstantiveA2APartialAnswer(text)) return false;
   if (normalized.includes(A2A_CONTINUATION_QUEUED_MARKER)) return true;
+  if (
+    /\bwill\b[^.!?]{0,160}\bpost\b[^.!?]{0,160}\b(?:thread|result|link|content id)\b/i.test(
+      normalized,
+    )
+  ) {
+    return true;
+  }
   return /\b(?:still (?:working|processing)|is working on|taking longer than expected|will (?:post|update|surface|show up)|(?:it'?ll|it will|the result will|the final result will) (?:post|be posted|update|be updated|surface|show up)|will be (?:posted|updated|sent|shared)|final result when it finishes|while you wait|as soon as (?:it|it'?s|it is|the result|the artifact) (?:comes back|is ready|ready)|hang tight|relay from the .* agent)\b/i.test(
     normalized,
   );

package/corpus/core/src/scripts/call-agent.ts

@@ -38,6 +38,7 @@ import { track } from "../tracking/registry.js";
 
 const DEFAULT_SERVERLESS_INTEGRATION_A2A_TIMEOUT_MS = 18_000;
 const NETLIFY_INTEGRATION_A2A_TIMEOUT_MS = 2_000;
+const NETLIFY_INTEGRATION_A2A_SUBMISSION_TIMEOUT_MS = 15_000;
 const INTEGRATION_A2A_TOKEN_TTL = "30m";
 const A2A_INVOCATION_EVENT = "$a2a_invocation";
 
@@ -167,13 +168,32 @@ function parseTimeoutMs(value: string | undefined): number | undefined {
   return Math.floor(parsed);
 }
 
+function hasExplicitNonHostedNetlifyOverride(): boolean {
+  return (
+    process.env.NETLIFY_LOCAL === "true" || process.env.NETLIFY === "false"
+  );
+}
+
+function isNetlifyHostedRuntimeForIntegrationCall(): boolean {
+  if (hasExplicitNonHostedNetlifyOverride()) return false;
+  if (process.env.NETLIFY && process.env.NETLIFY !== "false") return true;
+
+  // NETLIFY is a build-time marker, while deployed Netlify Functions expose
+  // SITE_ID at runtime. Recognize the same runtime-only marker used by the
+  // durable background and run-manager gates so the integration caller hands
+  // slow A2A work to durable delivery before its foreground budget expires.
+  return Boolean(process.env.SITE_ID); // guard:allow-env-credential -- Netlify's read-only public site identifier is a runtime host marker, not a user credential.
+}
+
 function isServerlessHost(): boolean {
+  if (hasExplicitNonHostedNetlifyOverride()) return false;
+
   // Detection mirrors db/migrations.ts:297-301. On Cloudflare Workers/Pages,
   // `process.env` is shimmed and CF_PAGES isn't reliably populated at runtime —
   // the canonical signal is the `__cf_env`/`__env__` global injected by the
   // Cloudflare runtime adapter.
   return (
-    !!process.env.NETLIFY ||
+    isNetlifyHostedRuntimeForIntegrationCall() ||
     !!process.env.AWS_LAMBDA_FUNCTION_NAME ||
     !!process.env.VERCEL ||
     "__cf_env" in globalThis ||
@@ -193,7 +213,9 @@ function getIntegrationCallTimeoutMs(): number | undefined {
   // calls very short so multi-agent integration requests queue downstream
   // continuations quickly instead of spending the parent Slack/email processor
   // budget waiting on separately deployed apps one-by-one.
-  if (process.env.NETLIFY) return NETLIFY_INTEGRATION_A2A_TIMEOUT_MS;
+  if (isNetlifyHostedRuntimeForIntegrationCall()) {
+    return NETLIFY_INTEGRATION_A2A_TIMEOUT_MS;
+  }
 
   return DEFAULT_SERVERLESS_INTEGRATION_A2A_TIMEOUT_MS;
 }
@@ -676,6 +698,10 @@ export async function run(
         // Docker can wait for slow-but-valid answers; integration processors
         // still need to finish before their current function execution dies.
         const callTimeoutMs = getIntegrationCallTimeoutMs();
+        const submissionTimeoutMs =
+          callTimeoutMs && isNetlifyHostedRuntimeForIntegrationCall()
+            ? NETLIFY_INTEGRATION_A2A_SUBMISSION_TIMEOUT_MS
+            : undefined;
         responseText = await callAgent(agent.url, messageWithHint, {
           apiKey,
           userEmail: callerEmail,
@@ -692,6 +718,7 @@ export async function run(
           ...(callTimeoutMs
             ? {
                 timeoutMs: callTimeoutMs,
+                ...(submissionTimeoutMs ? { submissionTimeoutMs } : {}),
               }
             : {}),
         });

package/corpus/templates/content/actions/_batch-utils.ts

@@ -1,3 +1,5 @@
+import { getDialect, type Dialect } from "@agent-native/core/db";
+
 export function chunks<T>(items: T[], size: number): T[][] {
   if (items.length === 0) return [];
   const out: T[][] = [];
@@ -6,3 +8,34 @@ export function chunks<T>(items: T[], size: number): T[][] {
   }
   return out;
 }
+
+export function bulkChunkSizeForColumnCount(
+  columnCount: number,
+  dialect: Dialect = getDialect(),
+) {
+  // D1 rejects statements with more than 100 bound params, so derive every
+  // bulk chunk from the statement's column count instead of a fixed row count.
+  const budget = dialect === "d1" ? 90 : 900;
+  return Math.max(1, Math.floor(budget / Math.max(1, columnCount)));
+}
+
+export async function processWithConcurrency<T>(
+  items: readonly T[],
+  concurrency: number,
+  worker: (item: T) => Promise<void>,
+) {
+  let nextIndex = 0;
+  const workerCount = Math.min(
+    items.length,
+    Math.max(1, Math.floor(concurrency)),
+  );
+  await Promise.all(
+    Array.from({ length: workerCount }, async () => {
+      while (nextIndex < items.length) {
+        const item = items[nextIndex];
+        nextIndex += 1;
+        if (item !== undefined) await worker(item);
+      }
+    }),
+  );
+}

package/corpus/templates/content/actions/_builder-cms-read-client.ts

@@ -163,6 +163,7 @@ type BuilderMcpToolResult = {
 const BUILDER_CMS_DEFAULT_READ_LIMIT = 500;
 const BUILDER_CMS_MAX_READ_LIMIT = 10_000;
 const BUILDER_CMS_PAGE_SIZE = 100;
+const BUILDER_CMS_PROJECTED_READ_CONCURRENCY = 8;
 const BUILDER_CMS_READ_RETRIES = 2;
 const BUILDER_CMS_METADATA_ENTRY_FIELD_PATHS = [
   "id",
@@ -192,6 +193,10 @@ const BUILDER_CMS_HEAVY_BODY_FIELD_PATHS = [
 const BUILDER_CMS_FIELD_PATH_PATTERN =
   /^[A-Za-z0-9_$-]+(?:\.[A-Za-z0-9_$-]+)*$/;
 
+type BuilderCmsContentPageResult =
+  | { pageLimit: number; pageEntries: BuilderCmsSourceEntry[] }
+  | { pageLimit: number; error: string };
+
 function normalizeBuilderCmsListFieldPath(fieldPath: string) {
   const trimmed = fieldPath.trim();
   if (!trimmed || !BUILDER_CMS_FIELD_PATH_PATTERN.test(trimmed)) return null;
@@ -218,6 +223,36 @@ function normalizeBuilderCmsListFieldPath(fieldPath: string) {
   return normalized;
 }
 
+function preserveProjectedBuilderFieldAbsence(
+  read: BuilderCmsReadResult,
+  fieldPaths: readonly string[] | undefined,
+  rawData: boolean | undefined,
+): BuilderCmsReadResult {
+  if (read.state !== "live" || rawData === true || !fieldPaths?.length) {
+    return read;
+  }
+  const projectedFieldPaths = [
+    ...new Set(
+      fieldPaths
+        .map(normalizeBuilderCmsListFieldPath)
+        .filter((fieldPath): fieldPath is string => fieldPath !== null),
+    ),
+  ];
+  if (projectedFieldPaths.length === 0) return read;
+  return {
+    ...read,
+    entries: read.entries.map((entry) => {
+      const sourceValues = { ...entry.sourceValues };
+      for (const fieldPath of projectedFieldPaths) {
+        if (!Object.prototype.hasOwnProperty.call(sourceValues, fieldPath)) {
+          sourceValues[fieldPath] = null;
+        }
+      }
+      return { ...entry, sourceValues };
+    }),
+  };
+}
+
 export function builderCmsListEntryFields(fieldPaths: readonly string[] = []) {
   const fields = new Map<string, string>();
   for (const fieldPath of [
@@ -752,6 +787,7 @@ async function initializeBuilderMcp(args: {
 async function readBuilderCmsContentEntriesViaMcp(args: {
   model: string;
   fieldPaths?: readonly string[];
+  includeBodies?: boolean;
   rawData?: boolean;
   limit?: number;
   maxPages?: number;
@@ -775,7 +811,9 @@ async function readBuilderCmsContentEntriesViaMcp(args: {
   const contentEntries: BuilderCmsSourceEntry[] = [];
   const fields = args.rawData
     ? undefined
-    : builderCmsListEntryFields(args.fieldPaths);
+    : args.includeBodies
+      ? `${builderCmsListEntryFields(args.fieldPaths)},${BUILDER_CMS_HEAVY_BODY_FIELD_PATHS.join(",")}`
+      : builderCmsListEntryFields(args.fieldPaths);
   const seenContentIds = new Set<string>();
   let pagesRead = 0;
   let hasMore = false;
@@ -941,6 +979,8 @@ async function readBuilderCmsContentEntriesViaMcp(args: {
 async function readBuilderCmsContentEntriesViaContentApi(args: {
   model: string;
   fieldPaths?: readonly string[];
+  includeBodies?: boolean;
+  allowCached?: boolean;
   rawData?: boolean;
   limit?: number;
   maxPages?: number;
@@ -959,14 +999,21 @@ async function readBuilderCmsContentEntriesViaContentApi(args: {
   // Fidelity reads intentionally do neither: Builder's raw data object is the
   // clone contract, including unresolved references and every nested field.
   url.searchParams.set("enrich", args.rawData === true ? "false" : "true");
-  url.searchParams.set("noCache", "true");
-  url.searchParams.set(
-    "cachebust",
-    args.rawData === true ? String(Date.now()) : "true",
-  );
+  if (args.allowCached !== true || args.rawData === true) {
+    url.searchParams.set("noCache", "true");
+    url.searchParams.set(
+      "cachebust",
+      args.rawData === true ? String(Date.now()) : "true",
+    );
+  }
   url.searchParams.set("includeUnpublished", "true");
   if (args.rawData !== true) {
-    url.searchParams.set("fields", builderCmsListEntryFields(args.fieldPaths));
+    url.searchParams.set(
+      "fields",
+      args.includeBodies
+        ? `${builderCmsListEntryFields(args.fieldPaths)},${BUILDER_CMS_HEAVY_BODY_FIELD_PATHS.join(",")}`
+        : builderCmsListEntryFields(args.fieldPaths),
+    );
   }
 
   const limit = readLimit(args.limit);
@@ -978,73 +1025,103 @@ async function readBuilderCmsContentEntriesViaContentApi(args: {
   const seenIds = new Set<string>();
   let pagesRead = 0;
   let hasMore = false;
-  for (
-    let offset = startOffset;
-    entries.length < limit;
-    offset += BUILDER_CMS_PAGE_SIZE
-  ) {
-    const pageUrl = new URL(url);
-    const pageLimit = readPageLimit(limit - entries.length);
-    pageUrl.searchParams.set("limit", String(pageLimit));
-    pageUrl.searchParams.set("offset", String(offset));
+  const concurrency =
+    args.rawData === true ? 1 : BUILDER_CMS_PROJECTED_READ_CONCURRENCY;
+  const errorResult = (message: string): BuilderCmsReadResult => ({
+    state: "error",
+    entries: [],
+    fetchedAt,
+    message,
+    progress: {
+      requestedLimit: limit,
+      pageSize: BUILDER_CMS_PAGE_SIZE,
+      startOffset,
+      nextOffset: startOffset + entries.length,
+      fetchedEntryCount: startOffset + entries.length,
+      hasMore,
+      partial: Boolean(args.maxPages) && hasMore,
+      readMode: "builder-api",
+    },
+  });
 
-    let response: Response;
-    try {
-      response = await fetchBuilderContentPage({
-        fetchImpl: args.fetchImpl,
-        url: pageUrl,
-        privateKey: args.privateKey,
-      });
-    } catch (error) {
-      return {
-        state: "error",
-        entries: [],
-        fetchedAt,
-        message:
-          error instanceof Error
-            ? `Builder CMS read failed: ${error.message}`
-            : "Builder CMS read failed.",
-        progress: {
-          requestedLimit: limit,
-          pageSize: BUILDER_CMS_PAGE_SIZE,
-          startOffset,
-          nextOffset: startOffset + entries.length,
-          fetchedEntryCount: startOffset + entries.length,
-          hasMore,
-          partial: Boolean(args.maxPages) && hasMore,
-          readMode: "builder-api",
+  while (entries.length < limit) {
+    const pagesRemaining = args.maxPages
+      ? args.maxPages - pagesRead
+      : Number.POSITIVE_INFINITY;
+    if (pagesRemaining <= 0) break;
+    const pageCount = Math.min(
+      pagesRead === 0 ? 1 : concurrency,
+      pagesRemaining,
+      Math.ceil((limit - entries.length) / BUILDER_CMS_PAGE_SIZE),
+    );
+    const pageRequests = Array.from({ length: pageCount }, (_, index) => {
+      const pageUrl = new URL(url);
+      const pageLimit = readPageLimit(
+        limit - entries.length - index * BUILDER_CMS_PAGE_SIZE,
+      );
+      pageUrl.searchParams.set("limit", String(pageLimit));
+      pageUrl.searchParams.set(
+        "offset",
+        String(startOffset + (pagesRead + index) * BUILDER_CMS_PAGE_SIZE),
+      );
+      return { pageLimit, pageUrl };
+    });
+    const pageResults = await Promise.all(
+      pageRequests.map(
+        async ({
+          pageLimit,
+          pageUrl,
+        }): Promise<BuilderCmsContentPageResult> => {
+          try {
+            const response = await fetchBuilderContentPage({
+              fetchImpl: args.fetchImpl,
+              url: pageUrl,
+              privateKey: args.privateKey,
+            });
+            if (!response.ok) {
+              return {
+                pageLimit,
+                error: `Builder CMS read failed with HTTP ${response.status}.`,
+              };
+            }
+            const json = (await response.json()) as unknown;
+            const pageEntries = entryArrayFromResponse(json)
+              .map((entry) => normalizeBuilderCmsApiEntry(entry, args.model))
+              .filter((entry): entry is BuilderCmsSourceEntry =>
+                Boolean(entry),
+              );
+            return { pageLimit, pageEntries };
+          } catch (error) {
+            return {
+              pageLimit,
+              error:
+                error instanceof Error
+                  ? `Builder CMS read failed: ${error.message}`
+                  : "Builder CMS read failed.",
+            };
+          }
         },
-      };
-    }
+      ),
+    );
 
-    if (!response.ok) {
-      return {
-        state: "error",
-        entries: [],
-        fetchedAt,
-        message: `Builder CMS read failed with HTTP ${response.status}.`,
-        progress: {
-          requestedLimit: limit,
-          pageSize: BUILDER_CMS_PAGE_SIZE,
-          startOffset,
-          nextOffset: startOffset + entries.length,
-          fetchedEntryCount: startOffset + entries.length,
-          hasMore,
-          partial: Boolean(args.maxPages) && hasMore,
-          readMode: "builder-api",
-        },
-      };
+    let stoppedOnShortPage = false;
+    for (const pageResult of pageResults) {
+      if ("error" in pageResult) return errorResult(pageResult.error);
+      const appended = appendUniqueBuilderEntries(
+        entries,
+        seenIds,
+        pageResult.pageEntries,
+      );
+      pagesRead += 1;
+      hasMore =
+        pageResult.pageEntries.length >= pageResult.pageLimit && appended > 0;
+      if (args.maxPages && pagesRead >= args.maxPages) break;
+      if (!hasMore) {
+        stoppedOnShortPage = true;
+        break;
+      }
     }
-
-    const json = (await response.json()) as unknown;
-    const pageEntries = entryArrayFromResponse(json)
-      .map((entry) => normalizeBuilderCmsApiEntry(entry, args.model))
-      .filter((entry): entry is BuilderCmsSourceEntry => Boolean(entry));
-    const appended = appendUniqueBuilderEntries(entries, seenIds, pageEntries);
-    pagesRead += 1;
-    hasMore = pageEntries.length >= pageLimit && appended > 0;
-    if (args.maxPages && pagesRead >= args.maxPages) break;
-    if (!hasMore) break;
+    if (stoppedOnShortPage || !hasMore) break;
   }
 
   return {
@@ -1231,6 +1308,8 @@ export async function readBuilderCmsModelFields(args: {
 export async function readBuilderCmsContentEntries(args: {
   model: string;
   fieldPaths?: readonly string[];
+  includeBodies?: boolean;
+  allowCached?: boolean;
   rawData?: boolean;
   requirePrivateKey?: boolean;
   limit?: number;
@@ -1265,6 +1344,8 @@ export async function readBuilderCmsContentEntries(args: {
     const contentApiRead = await readBuilderCmsContentEntriesViaContentApi({
       model: args.model,
       fieldPaths: args.fieldPaths,
+      includeBodies: args.includeBodies,
+      allowCached: args.allowCached,
       rawData: args.rawData,
       limit: args.limit,
       maxPages: args.maxPages,
@@ -1273,22 +1354,33 @@ export async function readBuilderCmsContentEntries(args: {
       publicKey,
       privateKey: privateKey ?? undefined,
     });
-    if (contentApiRead.state === "live") return contentApiRead;
+    if (contentApiRead.state === "live") {
+      return preserveProjectedBuilderFieldAbsence(
+        contentApiRead,
+        args.fieldPaths,
+        args.rawData,
+      );
+    }
     if (!privateKey) return contentApiRead;
   }
 
   if (privateKey) {
     try {
-      return await readBuilderCmsContentEntriesViaMcp({
-        model: args.model,
-        fieldPaths: args.fieldPaths,
-        rawData: args.rawData,
-        limit: args.limit,
-        maxPages: args.maxPages,
-        offset: args.offset,
-        fetchImpl,
-        privateKey,
-      });
+      return preserveProjectedBuilderFieldAbsence(
+        await readBuilderCmsContentEntriesViaMcp({
+          model: args.model,
+          fieldPaths: args.fieldPaths,
+          includeBodies: args.includeBodies,
+          rawData: args.rawData,
+          limit: args.limit,
+          maxPages: args.maxPages,
+          offset: args.offset,
+          fetchImpl,
+          privateKey,
+        }),
+        args.fieldPaths,
+        args.rawData,
+      );
     } catch (error) {
       return {
         state: "error",

package/corpus/templates/content/actions/_content-files.ts

@@ -4,6 +4,7 @@ import { accessFilter } from "@agent-native/core/sharing";
 import { and, eq, inArray, isNotNull, isNull, or, sql } from "drizzle-orm";
 
 import { schema } from "../server/db/index.js";
+import { bulkChunkSizeForColumnCount, chunks } from "./_batch-utils.js";
 import {
   listContentOrganizationMemberships,
   normalizeContentSpaceEmail,
@@ -32,23 +33,29 @@ export function contentFilesItemId(databaseId: string, documentId: string) {
 
 async function remapItemReferences(db: Db, replacements: Map<string, string>) {
   if (!replacements.size) return;
-  const duplicateIds = [...replacements.keys()];
-  const remap = (column: any) => {
-    let expression = sql`CASE ${column}`;
-    for (const [duplicateId, canonicalId] of replacements)
-      expression = sql`${expression} WHEN ${duplicateId} THEN ${canonicalId}`;
-    return sql`${expression} ELSE ${column} END`;
-  };
-  for (const table of [
-    schema.contentSpaceCatalogItems,
-    schema.contentDatabaseBodyHydrationQueue,
-    schema.contentDatabaseSourceRows,
-    schema.contentDatabaseSourceChangeSets,
-  ]) {
-    await db
-      .update(table)
-      .set({ databaseItemId: remap(table.databaseItemId) })
-      .where(inArray(table.databaseItemId, duplicateIds));
+  for (const replacementBatch of chunks(
+    [...replacements.entries()],
+    bulkChunkSizeForColumnCount(3),
+  )) {
+    const batchReplacements = new Map(replacementBatch);
+    const duplicateIds = [...batchReplacements.keys()];
+    const remap = (column: any) => {
+      let expression = sql`CASE ${column}`;
+      for (const [duplicateId, canonicalId] of batchReplacements)
+        expression = sql`${expression} WHEN ${duplicateId} THEN ${canonicalId}`;
+      return sql`${expression} ELSE ${column} END`;
+    };
+    for (const table of [
+      schema.contentSpaceCatalogItems,
+      schema.contentDatabaseBodyHydrationQueue,
+      schema.contentDatabaseSourceRows,
+      schema.contentDatabaseSourceChangeSets,
+    ]) {
+      await db
+        .update(table)
+        .set({ databaseItemId: remap(table.databaseItemId) })
+        .where(inArray(table.databaseItemId, duplicateIds));
+    }
   }
 }
 
@@ -170,15 +177,18 @@ async function reconcileDocuments(args: {
     }
   }
   await remapItemReferences(args.db, replacements);
-  if (deleteIds.size) {
+  for (const deleteBatch of chunks(
+    [...deleteIds],
+    bulkChunkSizeForColumnCount(1),
+  )) {
     await args.db
       .delete(schema.contentDatabaseItems)
-      .where(inArray(schema.contentDatabaseItems.id, [...deleteIds]));
+      .where(inArray(schema.contentDatabaseItems.id, deleteBatch));
   }
-  if (inserts.length) {
+  for (const insertBatch of chunks(inserts, bulkChunkSizeForColumnCount(8))) {
     await args.db
       .insert(schema.contentDatabaseItems)
-      .values(inserts)
+      .values(insertBatch)
       .onConflictDoNothing();
   }
   return { inserted: inserts.length, removed: deleteIds.size };