fullstackgtm 0.46.0 → 0.47.0

package/CHANGELOG.md

@@ -7,6 +7,12 @@ The path to 1.0 is planned in the roadmap doc in the repository.
 
 ## [Unreleased]
 
+## [0.47.0] — 2026-07-06
+
+### Added
+
+- **Batched CRM apply for updates and deletes.** `applyPatchPlan` can now dispatch consecutive homogeneous `set_field` / `clear_field` / `archive_record` runs through an optional connector `applyBatch` capability with connector-declared `applyBatchLimit`. Salesforce implements this with batched CAS SOQL reads and Composite sObject Collections update/delete (`allOrNone:false`, 200/call); HubSpot implements batched CAS reads plus `/batch/update` and `/batch/archive` (100/call). Both preserve per-operation `applied | skipped | conflict | failed` results and connectors without the capability stay on sequential apply.
+
 ## [0.46.0] — 2026-07-06
 
 ### Fixed — launch hardening

package/dist/connector.js

@@ -71,6 +71,13 @@ function normalizeForComparison(value) {
         return null;
     return String(value);
 }
+function isApplyBatchCandidate(operation) {
+    return (((operation.operation === "set_field" || operation.operation === "clear_field") && Boolean(operation.field)) ||
+        operation.operation === "archive_record");
+}
+function sameApplyBatchKind(a, b) {
+    return a.operation === b.operation && a.objectType === b.objectType;
+}
 /**
  * Apply an approved subset of a patch plan through a connector.
  *
@@ -194,6 +201,11 @@ export async function applyPatchPlan(connector, plan, options) {
         for (const operation of plan.operations) {
             if (!approved.has(operation.id) || conflicts.has(operation.id))
                 continue;
+            // Generic batch connectors (Salesforce) do their own batched CAS read for
+            // eligible field writes, so don't pre-read those one-by-one here.
+            if (connector.applyBatch && isApplyBatchCandidate(operation) && !operation.groupId && !operation.preconditions?.length) {
+                continue;
+            }
             let conflict = null;
             if (operation.field && FIELD_WRITE_OPERATIONS.has(operation.operation)) {
                 const current = await connector.readField(operation.objectType, operation.objectId, operation.field);
@@ -266,35 +278,38 @@ export async function applyPatchPlan(connector, plan, options) {
     const notifyProgress = () => {
         if ((!options.onOperation && !options.progress) || results.length === lastNotified)
             return;
-        lastNotified = results.length;
-        const last = results[results.length - 1];
-        if (last.status === "applied")
-            progressCounts.applied += 1;
-        else if (last.status === "failed")
-            progressCounts.failed += 1;
-        else if (last.status === "conflict")
-            progressCounts.conflicts += 1;
-        else
-            progressCounts.skipped += 1;
-        // Shared vocabulary: operation id + status only — a conflict/failure
-        // detail can echo field values, which never leave the machine.
-        options.progress?.opResult(last.operationId, last.status);
-        options.progress?.items(results.length - resultsBefore, plan.operations.length);
-        if (options.onOperation) {
-            try {
-                options.onOperation({
-                    completed: results.length - resultsBefore,
-                    total: plan.operations.length,
-                    ...progressCounts,
-                });
-            }
-            catch {
-                // progress is presentation-only
+        while (lastNotified < results.length) {
+            const last = results[lastNotified];
+            lastNotified += 1;
+            if (last.status === "applied")
+                progressCounts.applied += 1;
+            else if (last.status === "failed")
+                progressCounts.failed += 1;
+            else if (last.status === "conflict")
+                progressCounts.conflicts += 1;
+            else
+                progressCounts.skipped += 1;
+            // Shared vocabulary: operation id + status only — a conflict/failure
+            // detail can echo field values, which never leave the machine.
+            options.progress?.opResult(last.operationId, last.status);
+            options.progress?.items(results.length - resultsBefore, plan.operations.length);
+            if (options.onOperation) {
+                try {
+                    options.onOperation({
+                        completed: lastNotified - resultsBefore,
+                        total: plan.operations.length,
+                        ...progressCounts,
+                    });
+                }
+                catch {
+                    // progress is presentation-only
+                }
             }
         }
     };
     emitStage("operations");
-    for (const operation of plan.operations) {
+    for (let opIndex = 0; opIndex < plan.operations.length; opIndex++) {
+        const operation = plan.operations[opIndex];
         // Report the previous iteration's result (guarded: no-op if it pushed
         // nothing). One-iteration lag keeps this a two-line hook instead of a
         // notify after all ten push sites; the loop-exit call below flushes the last.
@@ -362,6 +377,62 @@ export async function applyPatchPlan(connector, plan, options) {
             });
             continue;
         }
+        if (connector.applyBatch && isApplyBatchCandidate(operation) && (checkConflicts || operation.operation === "archive_record") && !operation.groupId && !operation.preconditions?.length) {
+            const chunk = [];
+            const applyBatchLimit = Math.max(1, connector.applyBatchLimit ?? 200);
+            for (let scan = opIndex; scan < plan.operations.length && chunk.length < applyBatchLimit; scan++) {
+                const candidate = plan.operations[scan];
+                if (!sameApplyBatchKind(operation, candidate) || !isApplyBatchCandidate(candidate))
+                    break;
+                const candidateOverride = options.valueOverrides?.[candidate.id];
+                if (!approved.has(candidate.id) ||
+                    (requiresHumanInput(candidate.afterValue) && candidateOverride === undefined) ||
+                    conflicts.has(candidate.id) ||
+                    Boolean(candidate.groupId) ||
+                    Boolean(candidate.preconditions?.length) ||
+                    (staleByFilter && staleByFilter.has(candidate.objectId)) ||
+                    irreversibleStale.has(candidate.id)) {
+                    break;
+                }
+                chunk.push(candidateOverride === undefined ? candidate : { ...candidate, afterValue: candidateOverride });
+            }
+            if (chunk.length > 1) {
+                try {
+                    const batchResults = await connector.applyBatch(chunk);
+                    const byOperationId = new Map(batchResults.map((result) => [result.operationId, result]));
+                    for (const batchOperation of chunk) {
+                        const result = byOperationId.get(batchOperation.id) ?? {
+                            operationId: batchOperation.id,
+                            status: "failed",
+                            detail: "Batch connector did not return a result for this operation.",
+                        };
+                        results.push(result);
+                        if (result.status === "applied" || result.status === "failed")
+                            attempted += 1;
+                        if (result.status === "applied")
+                            applied += 1;
+                    }
+                    const appliedInBatch = batchResults.filter((result) => result.status === "applied").length;
+                    appliedSinceRecheck += appliedInBatch;
+                    if (appliedInBatch > 0 && (applied === appliedInBatch || appliedSinceRecheck >= recheckEvery)) {
+                        appliedSinceRecheck = 0;
+                        await refreshSnapshotChecks();
+                    }
+                }
+                catch (error) {
+                    for (const batchOperation of chunk) {
+                        results.push({
+                            operationId: batchOperation.id,
+                            status: "failed",
+                            detail: error instanceof Error ? error.message : String(error),
+                        });
+                        attempted += 1;
+                    }
+                }
+                opIndex += chunk.length - 1;
+                continue;
+            }
+        }
         const resolved = override === undefined ? operation : { ...operation, afterValue: override };
         attempted += 1;
         try {

package/dist/connectors/hubspot.d.ts

@@ -26,4 +26,4 @@ export type HubspotConnectorOptions = {
  * amountless deals — so audit rules can surface the gaps instead of hiding
  * them.
  */
-export declare function createHubspotConnector(options: HubspotConnectorOptions): Required<GtmConnector>;
+export declare function createHubspotConnector(options: HubspotConnectorOptions): GtmConnector;

package/dist/connectors/hubspot.js

@@ -1057,6 +1057,173 @@ export function createHubspotConnector(options) {
             detail: `Archived ${objectPath}/${operation.objectId}.`,
         };
     }
+    function fieldMapping(operation) {
+        const objectPath = OBJECT_PATHS[operation.objectType];
+        const mappingType = MAPPING_OBJECT_TYPES[operation.objectType];
+        if (!objectPath || !mappingType || !operation.field)
+            return null;
+        const defaults = HUBSPOT_DEFAULT_FIELD_MAPPINGS[mappingType] ?? {};
+        return { objectPath, property: mappedField(mappings, mappingType, operation.field, defaults[operation.field] ?? operation.field) };
+    }
+    function normalizeHubspotReadValue(field, value) {
+        if (field === "closeDate" && typeof value === "string")
+            return value.split("T")[0];
+        return value ?? null;
+    }
+    function normalizeForComparison(value) {
+        if (value === undefined || value === null || value === "")
+            return null;
+        return String(value);
+    }
+    function batchErrorIds(error) {
+        const context = error?.context ?? {};
+        const ids = context.ids ?? context.id ?? error?.id ?? error?.objectId;
+        if (Array.isArray(ids))
+            return ids.map(String);
+        if (ids !== undefined && ids !== null)
+            return [String(ids)];
+        return [];
+    }
+    function batchErrorDetail(error) {
+        const category = error?.category ? `${String(error.category)}: ` : "";
+        return `${category}${String(error?.message ?? "HubSpot batch row failed.")}`;
+    }
+    async function applySetFieldBatch(operations) {
+        const out = new Map();
+        const mapped = operations.map((operation) => ({ operation, mapping: fieldMapping(operation) }));
+        for (const item of mapped) {
+            if (!item.mapping) {
+                out.set(item.operation.id, {
+                    operationId: item.operation.id,
+                    status: "skipped",
+                    detail: "Field writes are only supported for accounts, contacts, and deals with an explicit field.",
+                });
+            }
+        }
+        const clean = mapped.filter((item) => Boolean(item.mapping));
+        if (clean.length === 0)
+            return operations.map((operation) => out.get(operation.id));
+        const objectPath = clean[0].mapping.objectPath;
+        const properties = [...new Set(clean.map((item) => item.mapping.property))];
+        const liveById = new Map();
+        const ids = [...new Set(clean.map((item) => item.operation.objectId))];
+        for (let i = 0; i < ids.length; i += 100) {
+            const chunkIds = ids.slice(i, i + 100);
+            const data = await request(`/crm/v3/objects/${objectPath}/batch/read`, {
+                method: "POST",
+                body: JSON.stringify({ properties, inputs: chunkIds.map((id) => ({ id })) }),
+            });
+            for (const row of data?.results ?? []) {
+                if (row?.id)
+                    liveById.set(String(row.id), row.properties ?? {});
+            }
+        }
+        const toWrite = [];
+        for (const { operation, mapping } of clean) {
+            const props = liveById.get(operation.objectId);
+            const current = normalizeHubspotReadValue(operation.field, props?.[mapping.property] ?? null);
+            const expected = normalizeForComparison(operation.beforeValue);
+            const found = normalizeForComparison(current);
+            if (!props || expected !== found) {
+                out.set(operation.id, {
+                    operationId: operation.id,
+                    status: "conflict",
+                    detail: `Value drifted since the plan was proposed: expected ${expected ?? "∅"}, found ${found ?? "∅"}. Re-run the audit.`,
+                    providerData: { currentValue: current ?? null },
+                });
+                continue;
+            }
+            toWrite.push({ operation, property: mapping.property });
+        }
+        for (let i = 0; i < toWrite.length; i += 100) {
+            const chunk = toWrite.slice(i, i + 100);
+            let data;
+            try {
+                data = await request(`/crm/v3/objects/${objectPath}/batch/update`, {
+                    method: "POST",
+                    body: JSON.stringify({
+                        inputs: chunk.map(({ operation, property }) => ({
+                            id: operation.objectId,
+                            properties: { [property]: operation.operation === "clear_field" ? "" : String(operation.afterValue ?? "") },
+                        })),
+                    }),
+                });
+            }
+            catch (error) {
+                for (const { operation } of chunk)
+                    out.set(operation.id, { operationId: operation.id, status: "failed", detail: error instanceof Error ? error.message : String(error) });
+                continue;
+            }
+            const opByObjectId = new Map(chunk.map(({ operation }) => [operation.objectId, operation]));
+            for (const error of data?.errors ?? []) {
+                for (const id of batchErrorIds(error)) {
+                    const operation = opByObjectId.get(id);
+                    if (operation)
+                        out.set(operation.id, { operationId: operation.id, status: "failed", detail: batchErrorDetail(error) });
+                }
+            }
+            for (const result of data?.results ?? []) {
+                const operation = opByObjectId.get(String(result?.id));
+                if (operation && !out.has(operation.id))
+                    out.set(operation.id, { operationId: operation.id, status: "applied", detail: `Set ${chunk.find((item) => item.operation.id === operation.id)?.property ?? "field"} on ${objectPath}/${operation.objectId}.`, providerData: { id: result?.id } });
+            }
+            for (const { operation, property } of chunk) {
+                if (!out.has(operation.id))
+                    out.set(operation.id, { operationId: operation.id, status: "applied", detail: `Set ${property} on ${objectPath}/${operation.objectId}.` });
+            }
+        }
+        return operations.map((operation) => out.get(operation.id) ?? { operationId: operation.id, status: "failed", detail: "Batch update did not process this operation." });
+    }
+    async function applyArchiveBatch(operations) {
+        const objectPath = OBJECT_PATHS[operations[0]?.objectType];
+        if (!objectPath)
+            return operations.map((operation) => ({ operationId: operation.id, status: "skipped", detail: "archive_record is supported for accounts, contacts, and deals." }));
+        const out = new Map();
+        for (let i = 0; i < operations.length; i += 100) {
+            const chunk = operations.slice(i, i + 100);
+            let data;
+            try {
+                data = await request(`/crm/v3/objects/${objectPath}/batch/archive`, {
+                    method: "POST",
+                    body: JSON.stringify({ inputs: chunk.map((operation) => ({ id: operation.objectId })) }),
+                });
+            }
+            catch (error) {
+                for (const operation of chunk)
+                    out.set(operation.id, { operationId: operation.id, status: "failed", detail: error instanceof Error ? error.message : String(error) });
+                continue;
+            }
+            const opByObjectId = new Map(chunk.map((operation) => [operation.objectId, operation]));
+            for (const error of data?.errors ?? []) {
+                for (const id of batchErrorIds(error)) {
+                    const operation = opByObjectId.get(id);
+                    if (operation)
+                        out.set(operation.id, { operationId: operation.id, status: "failed", detail: batchErrorDetail(error) });
+                }
+            }
+            for (const result of data?.results ?? []) {
+                const operation = opByObjectId.get(String(result?.id));
+                if (operation && !out.has(operation.id))
+                    out.set(operation.id, { operationId: operation.id, status: "applied", detail: `Archived ${objectPath}/${operation.objectId}.` });
+            }
+            for (const operation of chunk) {
+                if (!out.has(operation.id))
+                    out.set(operation.id, { operationId: operation.id, status: "applied", detail: `Archived ${objectPath}/${operation.objectId}.` });
+            }
+        }
+        return operations.map((operation) => out.get(operation.id) ?? { operationId: operation.id, status: "failed", detail: "Batch archive did not process this operation." });
+    }
+    async function applyBatch(operations) {
+        if (operations.length === 0)
+            return [];
+        if (operations.every((operation) => (operation.operation === "set_field" || operation.operation === "clear_field") && operation.objectType === operations[0].objectType)) {
+            return applySetFieldBatch(operations);
+        }
+        if (operations.every((operation) => operation.operation === "archive_record" && operation.objectType === operations[0].objectType)) {
+            return applyArchiveBatch(operations);
+        }
+        return operations.map((operation) => ({ operationId: operation.id, status: "skipped", detail: "This mixed operation batch is not supported." }));
+    }
     /**
      * Merge a duplicate group into the approved survivor via HubSpot's v3
      * merge API (supported for contacts, companies, deals, and tickets).
@@ -1182,10 +1349,7 @@ export function createHubspotConnector(options) {
         // single-object read here returns HubSpot's raw "2026-03-07T00:00:00Z", which
         // made compare-and-set see a spurious drift and refuse every date-field write.
         // Mirror the snapshot's normalization so the comparison is apples-to-apples.
-        if (field === "closeDate" && typeof value === "string") {
-            return value.split("T")[0];
-        }
-        return value;
+        return normalizeHubspotReadValue(field, value);
     }
     return {
         provider: "hubspot",
@@ -1193,6 +1357,8 @@ export function createHubspotConnector(options) {
         fetchChanges,
         applyOperation,
         applyCreateContactsBatch,
+        applyBatch,
+        applyBatchLimit: 100,
         readField,
     };
 }

package/dist/connectors/salesforce.d.ts

@@ -32,4 +32,4 @@ export type SalesforceConnectorOptions = {
  * surface the gaps). Probabilities are normalized to 0..1 to match the
  * canonical model.
  */
-export declare function createSalesforceConnector(options: SalesforceConnectorOptions): Required<GtmConnector>;
+export declare function createSalesforceConnector(options: SalesforceConnectorOptions): GtmConnector;

package/dist/connectors/salesforce.js

@@ -376,6 +376,139 @@ export function createSalesforceConnector(options) {
             detail: `Deleted ${sobjectType}/${operation.objectId}.`,
         };
     }
+    function normalizeSalesforceValue(value) {
+        if (value === undefined || value === null || value === "")
+            return null;
+        return String(value).split("T")[0];
+    }
+    function fieldMappingFor(operation) {
+        const sobjectType = SOBJECT_TYPES[operation.objectType];
+        const mappingType = MAPPING_OBJECT_TYPES[operation.objectType];
+        if (!sobjectType || !mappingType || !operation.field)
+            return null;
+        const defaults = SALESFORCE_DEFAULT_FIELD_MAPPINGS[mappingType] ?? {};
+        return {
+            sobjectType,
+            field: mappedField(mappings, mappingType, operation.field, defaults[operation.field] ?? operation.field),
+        };
+    }
+    function compositeErrorDetail(result) {
+        const errors = Array.isArray(result?.errors) ? result.errors : [];
+        const message = errors
+            .map((error) => [error?.statusCode, error?.message].filter(Boolean).join(": "))
+            .filter(Boolean)
+            .join("; ");
+        return message ? `Salesforce rejected this record: ${message.slice(0, 300)}.` : "Salesforce rejected this record.";
+    }
+    async function applySetFieldBatch(operations) {
+        const out = new Map();
+        const mapped = operations.map((operation) => ({ operation, mapping: fieldMappingFor(operation) }));
+        for (const item of mapped) {
+            if (!item.mapping) {
+                out.set(item.operation.id, {
+                    operationId: item.operation.id,
+                    status: "skipped",
+                    detail: "Field writes are only supported for accounts, contacts, and deals with an explicit field.",
+                });
+            }
+        }
+        const clean = mapped.filter((item) => Boolean(item.mapping));
+        if (clean.length === 0)
+            return operations.map((operation) => out.get(operation.id));
+        const sobjectType = clean[0].mapping.sobjectType;
+        const fields = [...new Set(clean.map((item) => item.mapping.field))];
+        const liveById = new Map();
+        const ids = [...new Set(clean.map((item) => item.operation.objectId))];
+        for (let i = 0; i < ids.length; i += 200) {
+            const idList = ids.slice(i, i + 200).map((id) => `'${id.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`).join(",");
+            const rows = await query(`SELECT Id, ${fields.join(", ")} FROM ${sobjectType} WHERE Id IN (${idList})`);
+            for (const row of rows)
+                liveById.set(String(row.Id), row);
+        }
+        const toWrite = [];
+        for (const { operation, mapping } of clean) {
+            const row = liveById.get(operation.objectId);
+            const current = row?.[mapping.field] ?? null;
+            const expected = normalizeSalesforceValue(operation.beforeValue);
+            const found = normalizeSalesforceValue(current);
+            if (!row || expected !== found) {
+                out.set(operation.id, {
+                    operationId: operation.id,
+                    status: "conflict",
+                    detail: `Value drifted since the plan was proposed: expected ${expected ?? "∅"}, found ${found ?? "∅"}. Re-run the audit.`,
+                    providerData: { currentValue: current ?? null },
+                });
+                continue;
+            }
+            toWrite.push({ operation, field: mapping.field });
+        }
+        for (let i = 0; i < toWrite.length; i += 200) {
+            const chunk = toWrite.slice(i, i + 200);
+            const records = chunk.map(({ operation, field }) => ({
+                attributes: { type: sobjectType },
+                Id: operation.objectId,
+                [field]: operation.operation === "clear_field" ? null : String(operation.afterValue ?? ""),
+            }));
+            let response;
+            try {
+                response = (await request(`/services/data/${apiVersion}/composite/sobjects`, {
+                    method: "PATCH",
+                    body: JSON.stringify({ allOrNone: false, records }),
+                }));
+            }
+            catch (error) {
+                for (const { operation } of chunk)
+                    out.set(operation.id, { operationId: operation.id, status: "failed", detail: error instanceof Error ? error.message : String(error) });
+                continue;
+            }
+            for (let j = 0; j < chunk.length; j++) {
+                const { operation, field } = chunk[j];
+                const result = Array.isArray(response) ? response[j] : undefined;
+                out.set(operation.id, result?.success
+                    ? { operationId: operation.id, status: "applied", detail: `Set ${field} on ${sobjectType}/${operation.objectId}.`, providerData: { sobjectType, field } }
+                    : { operationId: operation.id, status: "failed", detail: compositeErrorDetail(result) });
+            }
+        }
+        return operations.map((operation) => out.get(operation.id) ?? { operationId: operation.id, status: "failed", detail: "Batch update did not process this operation." });
+    }
+    async function applyArchiveBatch(operations) {
+        const sobjectType = SOBJECT_TYPES[operations[0]?.objectType];
+        if (!sobjectType)
+            return operations.map((operation) => ({ operationId: operation.id, status: "skipped", detail: "archive_record is supported for accounts, contacts, and deals." }));
+        const out = new Map();
+        for (let i = 0; i < operations.length; i += 200) {
+            const chunk = operations.slice(i, i + 200);
+            const ids = chunk.map((operation) => encodeURIComponent(operation.objectId)).join(",");
+            let response;
+            try {
+                response = (await request(`/services/data/${apiVersion}/composite/sobjects?ids=${ids}&allOrNone=false`, { method: "DELETE" }));
+            }
+            catch (error) {
+                for (const operation of chunk)
+                    out.set(operation.id, { operationId: operation.id, status: "failed", detail: error instanceof Error ? error.message : String(error) });
+                continue;
+            }
+            for (let j = 0; j < chunk.length; j++) {
+                const operation = chunk[j];
+                const result = Array.isArray(response) ? response[j] : undefined;
+                out.set(operation.id, result?.success
+                    ? { operationId: operation.id, status: "applied", detail: `Deleted ${sobjectType}/${operation.objectId}.` }
+                    : { operationId: operation.id, status: "failed", detail: compositeErrorDetail(result) });
+            }
+        }
+        return operations.map((operation) => out.get(operation.id) ?? { operationId: operation.id, status: "failed", detail: "Batch delete did not process this operation." });
+    }
+    async function applyBatch(operations) {
+        if (operations.length === 0)
+            return [];
+        if (operations.every((operation) => (operation.operation === "set_field" || operation.operation === "clear_field") && operation.objectType === operations[0].objectType)) {
+            return applySetFieldBatch(operations);
+        }
+        if (operations.every((operation) => operation.operation === "archive_record" && operation.objectType === operations[0].objectType)) {
+            return applyArchiveBatch(operations);
+        }
+        return operations.map((operation) => ({ operationId: operation.id, status: "skipped", detail: "This mixed operation batch is not supported." }));
+    }
     function escapeXml(value) {
         return value
             .replace(/&/g, "&amp;")
@@ -738,6 +871,8 @@ export function createSalesforceConnector(options) {
         fetchChanges,
         applyOperation,
         applyCreateContactsBatch,
+        applyBatch,
+        applyBatchLimit: 200,
         readField,
     };
 }

package/dist/types.d.ts

@@ -435,6 +435,21 @@ export type GtmConnector = {
      * result per input op. Optional: connectors without it use `applyOperation`.
      */
     applyCreateContactsBatch?: (operations: PatchOperation[]) => Promise<PatchOperationResult[]>;
+    /**
+     * Optional bulk apply path for homogeneous operation runs selected by
+     * `applyPatchPlan` (currently consecutive `set_field` ops on one object type
+     * and consecutive `archive_record` ops on one object type). Implementations
+     * MUST return exactly one result per input operation, preserve per-operation
+     * CAS/conflict semantics for field writes, and must not write operations that
+     * would have conflicted under the serial `readField` + `applyOperation` path.
+     * Connectors without it use `applyOperation` per operation.
+     */
+    applyBatch?: (operations: PatchOperation[]) => Promise<PatchOperationResult[]>;
+    /**
+     * Maximum number of operations `applyPatchPlan` should pass to one
+     * `applyBatch` call. Defaults to 200 when unspecified.
+     */
+    applyBatchLimit?: number;
     /**
      * Read the live value of one canonical field, used for compare-and-set:
      * apply orchestration refuses to write over values that drifted since the

package/docs/api.md

@@ -37,9 +37,10 @@ release.
 
 ## Connectors
 
-- `GtmConnector` — `{ provider, fetchSnapshot(), applyOperation?, applyCreateContactsBatch?, readField?, fetchChanges? }`.
+- `GtmConnector` — `{ provider, fetchSnapshot(), applyOperation?, applyCreateContactsBatch?, applyBatch?, applyBatchLimit?, readField?, fetchChanges? }`.
   - Connectors never silently drop unresolvable records; audits surface them.
   - `fetchChanges(sinceIso)` returns a partial snapshot; change feeds may omit associations.
+  - `applyBatch?(operations)` — optional bulk apply path for consecutive homogeneous `set_field`, `clear_field`, or `archive_record` runs selected by `applyPatchPlan`. It must return one result per input operation; field-write implementations preserve CAS by batch-reading live target values first and writing only clean records. Connectors without it stay on the sequential `applyOperation` path. `applyBatchLimit?` declares max operations per `applyBatch` call (default 200; Salesforce 200, HubSpot 100). Salesforce uses SOQL `IN` CAS reads plus Composite sObject Collections update/delete (`allOrNone:false`); HubSpot uses batch/read + batch/update/archive.
   - `applyCreateContactsBatch?(operations)` — optional bulk fast-path for
     independent `create_record` contact ops. `applyPatchPlan` routes safe-to-batch
     creates here (batched resolve-first + batched create — ~N/100 calls instead of

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fullstackgtm",
-  "version": "0.46.0",
+  "version": "0.47.0",
   "description": "Open-source agentic GTM ops framework: canonical GTM data model, pluggable deterministic audits, reviewable dry-run patch plans, approval-gated write-back with conflict detection, and cross-system entity resolution. HubSpot, Salesforce, and Stripe connectors included.",
   "license": "Apache-2.0",
   "author": "Full Stack GTM LLC <ryan@fullstackgtm.com> (https://fullstackgtm.com)",

package/src/connector.ts

@@ -138,6 +138,17 @@ function normalizeForComparison(value: unknown): string | null {
   return String(value);
 }
 
+function isApplyBatchCandidate(operation: PatchOperation): boolean {
+  return (
+    ((operation.operation === "set_field" || operation.operation === "clear_field") && Boolean(operation.field)) ||
+    operation.operation === "archive_record"
+  );
+}
+
+function sameApplyBatchKind(a: PatchOperation, b: PatchOperation): boolean {
+  return a.operation === b.operation && a.objectType === b.objectType;
+}
+
 /**
  * Apply an approved subset of a patch plan through a connector.
  *
@@ -267,6 +278,11 @@ export async function applyPatchPlan(
   if (checkConflicts && connector.readField) {
     for (const operation of plan.operations) {
       if (!approved.has(operation.id) || conflicts.has(operation.id)) continue;
+      // Generic batch connectors (Salesforce) do their own batched CAS read for
+      // eligible field writes, so don't pre-read those one-by-one here.
+      if (connector.applyBatch && isApplyBatchCandidate(operation) && !operation.groupId && !operation.preconditions?.length) {
+        continue;
+      }
       let conflict: PatchOperationResult | null = null;
       if (operation.field && FIELD_WRITE_OPERATIONS.has(operation.operation)) {
         const current = await connector.readField(
@@ -349,31 +365,34 @@ export async function applyPatchPlan(
   let lastNotified = results.length;
   const notifyProgress = () => {
     if ((!options.onOperation && !options.progress) || results.length === lastNotified) return;
-    lastNotified = results.length;
-    const last = results[results.length - 1];
-    if (last.status === "applied") progressCounts.applied += 1;
-    else if (last.status === "failed") progressCounts.failed += 1;
-    else if (last.status === "conflict") progressCounts.conflicts += 1;
-    else progressCounts.skipped += 1;
-    // Shared vocabulary: operation id + status only — a conflict/failure
-    // detail can echo field values, which never leave the machine.
-    options.progress?.opResult(last.operationId, last.status);
-    options.progress?.items(results.length - resultsBefore, plan.operations.length);
-    if (options.onOperation) {
-      try {
-        options.onOperation({
-          completed: results.length - resultsBefore,
-          total: plan.operations.length,
-          ...progressCounts,
-        });
-      } catch {
-        // progress is presentation-only
+    while (lastNotified < results.length) {
+      const last = results[lastNotified];
+      lastNotified += 1;
+      if (last.status === "applied") progressCounts.applied += 1;
+      else if (last.status === "failed") progressCounts.failed += 1;
+      else if (last.status === "conflict") progressCounts.conflicts += 1;
+      else progressCounts.skipped += 1;
+      // Shared vocabulary: operation id + status only — a conflict/failure
+      // detail can echo field values, which never leave the machine.
+      options.progress?.opResult(last.operationId, last.status);
+      options.progress?.items(results.length - resultsBefore, plan.operations.length);
+      if (options.onOperation) {
+        try {
+          options.onOperation({
+            completed: lastNotified - resultsBefore,
+            total: plan.operations.length,
+            ...progressCounts,
+          });
+        } catch {
+          // progress is presentation-only
+        }
       }
     }
   };
 
   emitStage("operations");
-  for (const operation of plan.operations) {
+  for (let opIndex = 0; opIndex < plan.operations.length; opIndex++) {
+    const operation = plan.operations[opIndex];
     // Report the previous iteration's result (guarded: no-op if it pushed
     // nothing). One-iteration lag keeps this a two-line hook instead of a
     // notify after all ten push sites; the loop-exit call below flushes the last.
@@ -441,6 +460,61 @@ export async function applyPatchPlan(
       continue;
     }
 
+    if (connector.applyBatch && isApplyBatchCandidate(operation) && (checkConflicts || operation.operation === "archive_record") && !operation.groupId && !operation.preconditions?.length) {
+      const chunk: PatchOperation[] = [];
+      const applyBatchLimit = Math.max(1, connector.applyBatchLimit ?? 200);
+      for (let scan = opIndex; scan < plan.operations.length && chunk.length < applyBatchLimit; scan++) {
+        const candidate = plan.operations[scan];
+        if (!sameApplyBatchKind(operation, candidate) || !isApplyBatchCandidate(candidate)) break;
+        const candidateOverride = options.valueOverrides?.[candidate.id];
+        if (
+          !approved.has(candidate.id) ||
+          (requiresHumanInput(candidate.afterValue) && candidateOverride === undefined) ||
+          conflicts.has(candidate.id) ||
+          Boolean(candidate.groupId) ||
+          Boolean(candidate.preconditions?.length) ||
+          (staleByFilter && staleByFilter.has(candidate.objectId)) ||
+          irreversibleStale.has(candidate.id)
+        ) {
+          break;
+        }
+        chunk.push(candidateOverride === undefined ? candidate : { ...candidate, afterValue: candidateOverride });
+      }
+      if (chunk.length > 1) {
+        try {
+          const batchResults = await connector.applyBatch(chunk);
+          const byOperationId = new Map(batchResults.map((result) => [result.operationId, result]));
+          for (const batchOperation of chunk) {
+            const result = byOperationId.get(batchOperation.id) ?? {
+              operationId: batchOperation.id,
+              status: "failed" as const,
+              detail: "Batch connector did not return a result for this operation.",
+            };
+            results.push(result);
+            if (result.status === "applied" || result.status === "failed") attempted += 1;
+            if (result.status === "applied") applied += 1;
+          }
+          const appliedInBatch = batchResults.filter((result) => result.status === "applied").length;
+          appliedSinceRecheck += appliedInBatch;
+          if (appliedInBatch > 0 && (applied === appliedInBatch || appliedSinceRecheck >= recheckEvery)) {
+            appliedSinceRecheck = 0;
+            await refreshSnapshotChecks();
+          }
+        } catch (error) {
+          for (const batchOperation of chunk) {
+            results.push({
+              operationId: batchOperation.id,
+              status: "failed",
+              detail: error instanceof Error ? error.message : String(error),
+            });
+            attempted += 1;
+          }
+        }
+        opIndex += chunk.length - 1;
+        continue;
+      }
+    }
+
     const resolved: PatchOperation =
       override === undefined ? operation : { ...operation, afterValue: override };
 

package/src/connectors/hubspot.ts

@@ -71,7 +71,7 @@ const PULL_STAGE_BY_TYPE: Record<SnapshotProgress["objectType"], (typeof SNAPSHO
  * amountless deals — so audit rules can surface the gaps instead of hiding
  * them.
  */
-export function createHubspotConnector(options: HubspotConnectorOptions): Required<GtmConnector> {
+export function createHubspotConnector(options: HubspotConnectorOptions): GtmConnector {
   const baseUrl = (options.apiBaseUrl ?? DEFAULT_API_BASE_URL).replace(/\/$/, "");
   const fetchImpl = options.fetchImpl ?? fetch;
   const mappings = options.fieldMappings;
@@ -1195,6 +1195,164 @@ export function createHubspotConnector(options: HubspotConnectorOptions): Requir
     };
   }
 
+  function fieldMapping(operation: PatchOperation): { objectPath: string; property: string } | null {
+    const objectPath = OBJECT_PATHS[operation.objectType];
+    const mappingType = MAPPING_OBJECT_TYPES[operation.objectType];
+    if (!objectPath || !mappingType || !operation.field) return null;
+    const defaults = HUBSPOT_DEFAULT_FIELD_MAPPINGS[mappingType] ?? {};
+    return { objectPath, property: mappedField(mappings, mappingType, operation.field, defaults[operation.field] ?? operation.field) };
+  }
+
+  function normalizeHubspotReadValue(field: string | undefined, value: unknown): unknown {
+    if (field === "closeDate" && typeof value === "string") return value.split("T")[0];
+    return value ?? null;
+  }
+
+  function normalizeForComparison(value: unknown): string | null {
+    if (value === undefined || value === null || value === "") return null;
+    return String(value);
+  }
+
+  function batchErrorIds(error: any): string[] {
+    const context = error?.context ?? {};
+    const ids = context.ids ?? context.id ?? error?.id ?? error?.objectId;
+    if (Array.isArray(ids)) return ids.map(String);
+    if (ids !== undefined && ids !== null) return [String(ids)];
+    return [];
+  }
+
+  function batchErrorDetail(error: any): string {
+    const category = error?.category ? `${String(error.category)}: ` : "";
+    return `${category}${String(error?.message ?? "HubSpot batch row failed.")}`;
+  }
+
+  async function applySetFieldBatch(operations: PatchOperation[]): Promise<PatchOperationResult[]> {
+    const out = new Map<string, PatchOperationResult>();
+    const mapped = operations.map((operation) => ({ operation, mapping: fieldMapping(operation) }));
+    for (const item of mapped) {
+      if (!item.mapping) {
+        out.set(item.operation.id, {
+          operationId: item.operation.id,
+          status: "skipped",
+          detail: "Field writes are only supported for accounts, contacts, and deals with an explicit field.",
+        });
+      }
+    }
+    const clean = mapped.filter((item): item is { operation: PatchOperation; mapping: { objectPath: string; property: string } } => Boolean(item.mapping));
+    if (clean.length === 0) return operations.map((operation) => out.get(operation.id)!);
+    const objectPath = clean[0].mapping.objectPath;
+    const properties = [...new Set(clean.map((item) => item.mapping.property))];
+    const liveById = new Map<string, Record<string, unknown>>();
+    const ids = [...new Set(clean.map((item) => item.operation.objectId))];
+    for (let i = 0; i < ids.length; i += 100) {
+      const chunkIds = ids.slice(i, i + 100);
+      const data = await request(`/crm/v3/objects/${objectPath}/batch/read`, {
+        method: "POST",
+        body: JSON.stringify({ properties, inputs: chunkIds.map((id) => ({ id })) }),
+      });
+      for (const row of data?.results ?? []) {
+        if (row?.id) liveById.set(String(row.id), row.properties ?? {});
+      }
+    }
+
+    const toWrite: Array<{ operation: PatchOperation; property: string }> = [];
+    for (const { operation, mapping } of clean) {
+      const props = liveById.get(operation.objectId);
+      const current = normalizeHubspotReadValue(operation.field, props?.[mapping.property] ?? null);
+      const expected = normalizeForComparison(operation.beforeValue);
+      const found = normalizeForComparison(current);
+      if (!props || expected !== found) {
+        out.set(operation.id, {
+          operationId: operation.id,
+          status: "conflict",
+          detail: `Value drifted since the plan was proposed: expected ${expected ?? "∅"}, found ${found ?? "∅"}. Re-run the audit.`,
+          providerData: { currentValue: current ?? null },
+        });
+        continue;
+      }
+      toWrite.push({ operation, property: mapping.property });
+    }
+
+    for (let i = 0; i < toWrite.length; i += 100) {
+      const chunk = toWrite.slice(i, i + 100);
+      let data: any;
+      try {
+        data = await request(`/crm/v3/objects/${objectPath}/batch/update`, {
+          method: "POST",
+          body: JSON.stringify({
+            inputs: chunk.map(({ operation, property }) => ({
+              id: operation.objectId,
+              properties: { [property]: operation.operation === "clear_field" ? "" : String(operation.afterValue ?? "") },
+            })),
+          }),
+        });
+      } catch (error) {
+        for (const { operation } of chunk) out.set(operation.id, { operationId: operation.id, status: "failed", detail: error instanceof Error ? error.message : String(error) });
+        continue;
+      }
+      const opByObjectId = new Map(chunk.map(({ operation }) => [operation.objectId, operation]));
+      for (const error of data?.errors ?? []) {
+        for (const id of batchErrorIds(error)) {
+          const operation = opByObjectId.get(id);
+          if (operation) out.set(operation.id, { operationId: operation.id, status: "failed", detail: batchErrorDetail(error) });
+        }
+      }
+      for (const result of data?.results ?? []) {
+        const operation = opByObjectId.get(String(result?.id));
+        if (operation && !out.has(operation.id)) out.set(operation.id, { operationId: operation.id, status: "applied", detail: `Set ${chunk.find((item) => item.operation.id === operation.id)?.property ?? "field"} on ${objectPath}/${operation.objectId}.`, providerData: { id: result?.id } });
+      }
+      for (const { operation, property } of chunk) {
+        if (!out.has(operation.id)) out.set(operation.id, { operationId: operation.id, status: "applied", detail: `Set ${property} on ${objectPath}/${operation.objectId}.` });
+      }
+    }
+    return operations.map((operation) => out.get(operation.id) ?? { operationId: operation.id, status: "failed", detail: "Batch update did not process this operation." });
+  }
+
+  async function applyArchiveBatch(operations: PatchOperation[]): Promise<PatchOperationResult[]> {
+    const objectPath = OBJECT_PATHS[operations[0]?.objectType];
+    if (!objectPath) return operations.map((operation) => ({ operationId: operation.id, status: "skipped", detail: "archive_record is supported for accounts, contacts, and deals." }));
+    const out = new Map<string, PatchOperationResult>();
+    for (let i = 0; i < operations.length; i += 100) {
+      const chunk = operations.slice(i, i + 100);
+      let data: any;
+      try {
+        data = await request(`/crm/v3/objects/${objectPath}/batch/archive`, {
+          method: "POST",
+          body: JSON.stringify({ inputs: chunk.map((operation) => ({ id: operation.objectId })) }),
+        });
+      } catch (error) {
+        for (const operation of chunk) out.set(operation.id, { operationId: operation.id, status: "failed", detail: error instanceof Error ? error.message : String(error) });
+        continue;
+      }
+      const opByObjectId = new Map(chunk.map((operation) => [operation.objectId, operation]));
+      for (const error of data?.errors ?? []) {
+        for (const id of batchErrorIds(error)) {
+          const operation = opByObjectId.get(id);
+          if (operation) out.set(operation.id, { operationId: operation.id, status: "failed", detail: batchErrorDetail(error) });
+        }
+      }
+      for (const result of data?.results ?? []) {
+        const operation = opByObjectId.get(String(result?.id));
+        if (operation && !out.has(operation.id)) out.set(operation.id, { operationId: operation.id, status: "applied", detail: `Archived ${objectPath}/${operation.objectId}.` });
+      }
+      for (const operation of chunk) {
+        if (!out.has(operation.id)) out.set(operation.id, { operationId: operation.id, status: "applied", detail: `Archived ${objectPath}/${operation.objectId}.` });
+      }
+    }
+    return operations.map((operation) => out.get(operation.id) ?? { operationId: operation.id, status: "failed", detail: "Batch archive did not process this operation." });
+  }
+
+  async function applyBatch(operations: PatchOperation[]): Promise<PatchOperationResult[]> {
+    if (operations.length === 0) return [];
+    if (operations.every((operation) => (operation.operation === "set_field" || operation.operation === "clear_field") && operation.objectType === operations[0].objectType)) {
+      return applySetFieldBatch(operations);
+    }
+    if (operations.every((operation) => operation.operation === "archive_record" && operation.objectType === operations[0].objectType)) {
+      return applyArchiveBatch(operations);
+    }
+    return operations.map((operation) => ({ operationId: operation.id, status: "skipped", detail: "This mixed operation batch is not supported." }));
+  }
+
   /**
    * Merge a duplicate group into the approved survivor via HubSpot's v3
    * merge API (supported for contacts, companies, deals, and tickets).
@@ -1335,10 +1493,7 @@ export function createHubspotConnector(options: HubspotConnectorOptions): Requir
     // single-object read here returns HubSpot's raw "2026-03-07T00:00:00Z", which
     // made compare-and-set see a spurious drift and refuse every date-field write.
     // Mirror the snapshot's normalization so the comparison is apples-to-apples.
-    if (field === "closeDate" && typeof value === "string") {
-      return value.split("T")[0];
-    }
-    return value;
+    return normalizeHubspotReadValue(field, value);
   }
 
   return {
@@ -1347,6 +1502,8 @@ export function createHubspotConnector(options: HubspotConnectorOptions): Requir
     fetchChanges,
     applyOperation,
     applyCreateContactsBatch,
+    applyBatch,
+    applyBatchLimit: 100,
     readField,
   };
 }

package/src/connectors/salesforce.ts

@@ -86,7 +86,7 @@ const PULL_STAGE_BY_TYPE: Record<SnapshotProgress["objectType"], (typeof SNAPSHO
  */
 export function createSalesforceConnector(
   options: SalesforceConnectorOptions,
-): Required<GtmConnector> {
+): GtmConnector {
   const apiVersion = options.apiVersion ?? DEFAULT_API_VERSION;
   const fetchImpl = options.fetchImpl ?? fetch;
   const mappings = options.fieldMappings;
@@ -489,6 +489,137 @@ export function createSalesforceConnector(
     };
   }
 
+  function normalizeSalesforceValue(value: unknown): string | null {
+    if (value === undefined || value === null || value === "") return null;
+    return String(value).split("T")[0];
+  }
+
+  function fieldMappingFor(operation: PatchOperation): { sobjectType: string; field: string } | null {
+    const sobjectType = SOBJECT_TYPES[operation.objectType];
+    const mappingType = MAPPING_OBJECT_TYPES[operation.objectType];
+    if (!sobjectType || !mappingType || !operation.field) return null;
+    const defaults = SALESFORCE_DEFAULT_FIELD_MAPPINGS[mappingType] ?? {};
+    return {
+      sobjectType,
+      field: mappedField(mappings, mappingType, operation.field, defaults[operation.field] ?? operation.field),
+    };
+  }
+
+  function compositeErrorDetail(result: any): string {
+    const errors = Array.isArray(result?.errors) ? result.errors : [];
+    const message = errors
+      .map((error: any) => [error?.statusCode, error?.message].filter(Boolean).join(": "))
+      .filter(Boolean)
+      .join("; ");
+    return message ? `Salesforce rejected this record: ${message.slice(0, 300)}.` : "Salesforce rejected this record.";
+  }
+
+  async function applySetFieldBatch(operations: PatchOperation[]): Promise<PatchOperationResult[]> {
+    const out = new Map<string, PatchOperationResult>();
+    const mapped = operations.map((operation) => ({ operation, mapping: fieldMappingFor(operation) }));
+    for (const item of mapped) {
+      if (!item.mapping) {
+        out.set(item.operation.id, {
+          operationId: item.operation.id,
+          status: "skipped",
+          detail: "Field writes are only supported for accounts, contacts, and deals with an explicit field.",
+        });
+      }
+    }
+    const clean = mapped.filter((item): item is { operation: PatchOperation; mapping: { sobjectType: string; field: string } } => Boolean(item.mapping));
+    if (clean.length === 0) return operations.map((operation) => out.get(operation.id)!);
+    const sobjectType = clean[0].mapping.sobjectType;
+    const fields = [...new Set(clean.map((item) => item.mapping.field))];
+    const liveById = new Map<string, Record<string, unknown>>();
+    const ids = [...new Set(clean.map((item) => item.operation.objectId))];
+    for (let i = 0; i < ids.length; i += 200) {
+      const idList = ids.slice(i, i + 200).map((id) => `'${id.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`).join(",");
+      const rows = await query(`SELECT Id, ${fields.join(", ")} FROM ${sobjectType} WHERE Id IN (${idList})`);
+      for (const row of rows) liveById.set(String(row.Id), row);
+    }
+
+    const toWrite: Array<{ operation: PatchOperation; field: string }> = [];
+    for (const { operation, mapping } of clean) {
+      const row = liveById.get(operation.objectId);
+      const current = row?.[mapping.field] ?? null;
+      const expected = normalizeSalesforceValue(operation.beforeValue);
+      const found = normalizeSalesforceValue(current);
+      if (!row || expected !== found) {
+        out.set(operation.id, {
+          operationId: operation.id,
+          status: "conflict",
+          detail: `Value drifted since the plan was proposed: expected ${expected ?? "∅"}, found ${found ?? "∅"}. Re-run the audit.`,
+          providerData: { currentValue: current ?? null },
+        });
+        continue;
+      }
+      toWrite.push({ operation, field: mapping.field });
+    }
+
+    for (let i = 0; i < toWrite.length; i += 200) {
+      const chunk = toWrite.slice(i, i + 200);
+      const records = chunk.map(({ operation, field }) => ({
+        attributes: { type: sobjectType },
+        Id: operation.objectId,
+        [field]: operation.operation === "clear_field" ? null : String(operation.afterValue ?? ""),
+      }));
+      let response: any[];
+      try {
+        response = (await request(`/services/data/${apiVersion}/composite/sobjects`, {
+          method: "PATCH",
+          body: JSON.stringify({ allOrNone: false, records }),
+        })) as any[];
+      } catch (error) {
+        for (const { operation } of chunk) out.set(operation.id, { operationId: operation.id, status: "failed", detail: error instanceof Error ? error.message : String(error) });
+        continue;
+      }
+      for (let j = 0; j < chunk.length; j++) {
+        const { operation, field } = chunk[j];
+        const result = Array.isArray(response) ? response[j] : undefined;
+        out.set(operation.id, result?.success
+          ? { operationId: operation.id, status: "applied", detail: `Set ${field} on ${sobjectType}/${operation.objectId}.`, providerData: { sobjectType, field } }
+          : { operationId: operation.id, status: "failed", detail: compositeErrorDetail(result) });
+      }
+    }
+    return operations.map((operation) => out.get(operation.id) ?? { operationId: operation.id, status: "failed", detail: "Batch update did not process this operation." });
+  }
+
+  async function applyArchiveBatch(operations: PatchOperation[]): Promise<PatchOperationResult[]> {
+    const sobjectType = SOBJECT_TYPES[operations[0]?.objectType];
+    if (!sobjectType) return operations.map((operation) => ({ operationId: operation.id, status: "skipped", detail: "archive_record is supported for accounts, contacts, and deals." }));
+    const out = new Map<string, PatchOperationResult>();
+    for (let i = 0; i < operations.length; i += 200) {
+      const chunk = operations.slice(i, i + 200);
+      const ids = chunk.map((operation) => encodeURIComponent(operation.objectId)).join(",");
+      let response: any[];
+      try {
+        response = (await request(`/services/data/${apiVersion}/composite/sobjects?ids=${ids}&allOrNone=false`, { method: "DELETE" })) as any[];
+      } catch (error) {
+        for (const operation of chunk) out.set(operation.id, { operationId: operation.id, status: "failed", detail: error instanceof Error ? error.message : String(error) });
+        continue;
+      }
+      for (let j = 0; j < chunk.length; j++) {
+        const operation = chunk[j];
+        const result = Array.isArray(response) ? response[j] : undefined;
+        out.set(operation.id, result?.success
+          ? { operationId: operation.id, status: "applied", detail: `Deleted ${sobjectType}/${operation.objectId}.` }
+          : { operationId: operation.id, status: "failed", detail: compositeErrorDetail(result) });
+      }
+    }
+    return operations.map((operation) => out.get(operation.id) ?? { operationId: operation.id, status: "failed", detail: "Batch delete did not process this operation." });
+  }
+
+  async function applyBatch(operations: PatchOperation[]): Promise<PatchOperationResult[]> {
+    if (operations.length === 0) return [];
+    if (operations.every((operation) => (operation.operation === "set_field" || operation.operation === "clear_field") && operation.objectType === operations[0].objectType)) {
+      return applySetFieldBatch(operations);
+    }
+    if (operations.every((operation) => operation.operation === "archive_record" && operation.objectType === operations[0].objectType)) {
+      return applyArchiveBatch(operations);
+    }
+    return operations.map((operation) => ({ operationId: operation.id, status: "skipped", detail: "This mixed operation batch is not supported." }));
+  }
+
   function escapeXml(value: string): string {
     return value
       .replace(/&/g, "&amp;")
@@ -869,6 +1000,8 @@ export function createSalesforceConnector(
     fetchChanges,
     applyOperation,
     applyCreateContactsBatch,
+    applyBatch,
+    applyBatchLimit: 200,
     readField,
   };
 }

package/src/types.ts

@@ -523,6 +523,21 @@ export type GtmConnector = {
    * result per input op. Optional: connectors without it use `applyOperation`.
    */
   applyCreateContactsBatch?: (operations: PatchOperation[]) => Promise<PatchOperationResult[]>;
+  /**
+   * Optional bulk apply path for homogeneous operation runs selected by
+   * `applyPatchPlan` (currently consecutive `set_field` ops on one object type
+   * and consecutive `archive_record` ops on one object type). Implementations
+   * MUST return exactly one result per input operation, preserve per-operation
+   * CAS/conflict semantics for field writes, and must not write operations that
+   * would have conflicted under the serial `readField` + `applyOperation` path.
+   * Connectors without it use `applyOperation` per operation.
+   */
+  applyBatch?: (operations: PatchOperation[]) => Promise<PatchOperationResult[]>;
+  /**
+   * Maximum number of operations `applyPatchPlan` should pass to one
+   * `applyBatch` call. Defaults to 200 when unspecified.
+   */
+  applyBatchLimit?: number;
   /**
    * Read the live value of one canonical field, used for compare-and-set:
    * apply orchestration refuses to write over values that drifted since the