@deployfoundation/foundation-deploy 0.2.50 → 0.2.52

package/dist/chunk-mh1206ne.js

@@ -0,0 +1,1764 @@
+import {
+  CrmIdempotencyConflictError,
+  CrmOutreachUnconfiguredError,
+  CrmRecordNotFoundError,
+  CrmStaleWriteError,
+  CrmStorageError
+} from "./chunk-tey0gh86.js";
+import {
+  CrmPolicyRefusedError,
+  checkDraft,
+  checkDraftedStatus,
+  checkNoteEdit,
+  checkStatusChange,
+  checkSuppressed,
+  classifyOutreach,
+  movesToDraftedStatus,
+  outreachWeekStart
+} from "./chunk-p7zkm4pp.js";
+import {
+  CRM_MAX_ACTIVITY_PAGE_SIZE,
+  CRM_MAX_CURSOR_CHARS,
+  CRM_MAX_OUTREACH_QUEUE_ITEMS,
+  CRM_MAX_SEARCH_LIMIT,
+  CRM_NOTE_ACTIVITY,
+  CrmInputError,
+  crmResponseFitsBudget,
+  parseCrmGetRecordResponse,
+  parseCrmOperationAck,
+  parseCrmOutreachQueueResponse,
+  parseCrmSearchResponse,
+  parseCrmTimestamp
+} from "./chunk-3614v9rr.js";
+import"./chunk-96fjaysn.js";
+import"./chunk-5wgwscd0.js";
+
+// ../capability-crm/src/proxy/repository.ts
+import {
+  BatchGetCommand,
+  BatchWriteCommand,
+  GetCommand as GetCommand2,
+  PutCommand as PutCommand2,
+  QueryCommand,
+  TransactWriteCommand as TransactWriteCommand2
+} from "@aws-sdk/lib-dynamodb";
+
+// ../capability-crm/src/proxy/hash.ts
+import { createHash } from "node:crypto";
+function hashPayload(operation, payload) {
+  return hashText(stableJson({ operation, payload }));
+}
+function hashText(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function stableJson(value) {
+  if (value === null || typeof value === "boolean" || typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value))
+      throw new CrmInputError("idempotency payload must be JSON");
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value))
+    return `[${value.map(stableJson).join(",")}]`;
+  if (typeof value !== "object")
+    throw new CrmInputError("idempotency payload must be JSON");
+  const entries = Object.entries(value).filter(([, entryValue]) => entryValue !== undefined).sort(([left], [right]) => left.localeCompare(right));
+  return `{${entries.map(([key, entryValue]) => `${JSON.stringify(key)}:${stableJson(entryValue)}`).join(",")}}`;
+}
+
+// ../capability-crm/src/proxy/ledger.ts
+import { GetCommand, PutCommand, TransactWriteCommand } from "@aws-sdk/lib-dynamodb";
+var RESERVATION_TTL_SECONDS = 35 * 86400;
+function outreachLedgerPartition(tenantId) {
+  return `TENANT#${tenantId}#OUTREACH`;
+}
+function outreachWeekSk(weekStart) {
+  return `WEEK#${weekStart}`;
+}
+
+// ../capability-crm/src/proxy/outreach-queue.ts
+var SPARE_NEW_LEADS = 10;
+var ORGANIZATION_COOLDOWN_DAYS = 60;
+var DAY_MS = 86400000;
+async function buildOutreachQueue(input) {
+  const { policy, now, counters } = input;
+  const remaining = Math.max(0, policy.weeklyLimit - counters.firstTouch);
+  const followUpsRemaining = Math.max(0, policy.followUpLimit - counters.followUp);
+  const dueBefore = now.getTime() - policy.followUpAfterDays * DAY_MS;
+  const cooldownSince = now.getTime() - ORGANIZATION_COOLDOWN_DAYS * DAY_MS;
+  const recentlyTouched = new Set;
+  const touched = (organization, at) => {
+    if (organization !== undefined && at !== undefined && Date.parse(at) >= cooldownSince) {
+      recentlyTouched.add(organization);
+    }
+  };
+  for (const candidate of input.candidates) {
+    touched(candidate.organization, candidate.touch?.lastTouchAt);
+  }
+  for (const { organization, lastTouchAt } of input.organizationTouches ?? []) {
+    touched(organization, lastTouchAt);
+  }
+  const isNewLead = (candidate) => candidate.touch === undefined && newLeadStatus(policy, candidate.status) && !suppressed(policy, candidate);
+  const isFollowUp = (candidate) => followUpDue(policy, candidate, dueBefore) && !suppressed(policy, candidate);
+  const followUpCandidates = [];
+  const newCandidates = [];
+  for (const candidate of input.candidates) {
+    if (candidate.touch === undefined) {
+      if (candidate.organization !== undefined && recentlyTouched.has(candidate.organization)) {
+        continue;
+      }
+      if (isNewLead(candidate))
+        newCandidates.push(candidate);
+      continue;
+    }
+    if (isFollowUp(candidate))
+      followUpCandidates.push(candidate);
+  }
+  followUpCandidates.sort((left, right) => (left.touch?.lastTouchAt ?? "").localeCompare(right.touch?.lastTouchAt ?? "") || left.contactId.localeCompare(right.contactId));
+  newCandidates.sort((left, right) => (right.rank ?? Number.NEGATIVE_INFINITY) - (left.rank ?? Number.NEGATIVE_INFINITY) || (left.createdAt ?? "").localeCompare(right.createdAt ?? "") || left.contactId.localeCompare(right.contactId));
+  const followUps = [];
+  for (const candidate of await chosen(followUpCandidates, Math.min(followUpsRemaining, CRM_MAX_OUTREACH_QUEUE_ITEMS), isFollowUp, input.recheck)) {
+    const touch = candidate.touch;
+    followUps.push({
+      ...outreachContact(candidate),
+      lastTouchAt: touch.lastTouchAt,
+      followUpNumber: touch.followUps + 1,
+      ...touch.lastThreadId === undefined ? {} : { threadId: touch.lastThreadId }
+    });
+  }
+  const offered = new Set;
+  const distinct = newCandidates.filter((candidate) => {
+    if (candidate.organization === undefined)
+      return true;
+    if (offered.has(candidate.organization))
+      return false;
+    offered.add(candidate.organization);
+    return true;
+  });
+  const newLeads = [];
+  for (const candidate of await chosen(distinct, remaining === 0 ? 0 : Math.min(remaining + SPARE_NEW_LEADS, CRM_MAX_OUTREACH_QUEUE_ITEMS), isNewLead, input.recheck)) {
+    newLeads.push({
+      ...outreachContact(candidate),
+      ...candidate.rank === undefined ? {} : { rank: candidate.rank }
+    });
+  }
+  return parseCrmOutreachQueueResponse({
+    weekStart: outreachWeekStart(now, policy.timezone),
+    timezone: policy.timezone,
+    weeklyLimit: policy.weeklyLimit,
+    newDraftedThisWeek: counters.firstTouch,
+    remaining,
+    followUpLimit: policy.followUpLimit,
+    followUpsDraftedThisWeek: counters.followUp,
+    followUpsRemaining,
+    followUps,
+    newLeads,
+    ...input.truncated === true ? { truncated: true } : {}
+  });
+}
+async function chosen(candidates, cap, qualifies, recheck) {
+  const accepted = [];
+  for (const candidate of candidates) {
+    if (accepted.length >= cap)
+      break;
+    const current = recheck === undefined ? candidate : await recheck(candidate);
+    if (current === null || !qualifies(current))
+      continue;
+    accepted.push(current);
+  }
+  return accepted;
+}
+function newLeadStatus(policy, status) {
+  return policy.eligibleStatuses.includes(status) && !policy.blockedStatuses.includes(status);
+}
+function suppressed(policy, candidate) {
+  return checkSuppressed(policy.suppressedStatuses, {
+    status: candidate.status,
+    ...candidate.doNotContact === undefined ? {} : { doNotContact: candidate.doNotContact }
+  }, candidate.companyStatus === undefined ? undefined : { status: candidate.companyStatus }) !== undefined;
+}
+function followUpDue(policy, candidate, dueBefore) {
+  const touch = candidate.touch;
+  if (touch?.lastTouchAt === undefined || !policy.followUpStatuses.includes(candidate.status)) {
+    return false;
+  }
+  if (touch.followUps >= policy.maxFollowUps)
+    return false;
+  const lastTouch = Date.parse(touch.lastTouchAt);
+  if (!Number.isFinite(lastTouch) || lastTouch > dueBefore)
+    return false;
+  if (touch.lastReplyAt !== undefined && Date.parse(touch.lastReplyAt) >= lastTouch)
+    return false;
+  return true;
+}
+function outreachContact(candidate) {
+  return {
+    contactId: candidate.contactId,
+    email: candidate.email,
+    status: candidate.status,
+    ...candidate.firstName === undefined ? {} : { firstName: candidate.firstName },
+    ...candidate.lastName === undefined ? {} : { lastName: candidate.lastName },
+    ...candidate.title === undefined ? {} : { title: candidate.title },
+    ...candidate.companyExternalId === undefined ? {} : { companyExternalId: candidate.companyExternalId },
+    ...candidate.companyId === undefined ? {} : { companyId: candidate.companyId },
+    ...candidate.company === undefined ? {} : { company: candidate.company }
+  };
+}
+
+// ../capability-crm/src/proxy/repository.ts
+var RECORDS_INDEX = "RecordsIndex";
+var PROFILE_SK = "PROFILE";
+var LIFECYCLE_SK = "LIFECYCLE";
+var ACTIVITY_SK_PREFIX = "ACTIVITY#";
+var DEFAULT_ACTIVITY_LIMIT = 20;
+var MAX_WRITE_RETRIES = 4;
+var MAX_BATCH_WRITE_RETRIES = 4;
+var BATCH_WRITE_LIMIT = 25;
+var ACTIVITY_DELETE_PAGE_SIZE = 100;
+var MAX_ACTIVITY_DELETE_PAGES = 10;
+var OUTREACH_SK_PREFIX = "OUTREACH#";
+var MAX_QUEUE_SCAN_PAGES = 30;
+var QUEUE_SCAN_PAGE_SIZE = 100;
+var BATCH_GET_LIMIT = 100;
+var MAX_BATCH_GET_RETRIES = 4;
+var MAX_ACTIVITY_FIND_PAGES = 10;
+var MAX_NOTE_HISTORY = 10;
+class DynamoCrmClient {
+  documentClient;
+  tableName;
+  tenantId;
+  defaultStatuses;
+  maxBatchSize;
+  actor;
+  statusPolicy;
+  outreach;
+  countsOutreach;
+  now;
+  constructor(options) {
+    this.documentClient = options.documentClient;
+    this.tableName = options.tableName;
+    this.tenantId = options.tenantId;
+    this.defaultStatuses = {
+      company: options.defaultStatuses.company,
+      contact: options.defaultStatuses.contact
+    };
+    this.maxBatchSize = options.maxBatchSize;
+    this.actor = copyActor(options.actor);
+    this.statusPolicy = options.statusPolicy ?? {};
+    this.outreach = options.outreach;
+    this.countsOutreach = options.countsOutreach ?? true;
+    this.now = options.now ?? (() => new Date);
+  }
+  async upsertRecords(args) {
+    const count = (args.companies?.length ?? 0) + (args.contacts?.length ?? 0);
+    if (count === 0 || count > this.maxBatchSize) {
+      throw new CrmInputError(`upsert request may contain at most ${this.maxBatchSize} records`);
+    }
+    const companies = args.companies ?? [];
+    const contacts = args.contacts ?? [];
+    let claim = await this.resolveClaim("upsert_records", args.idempotencyKey, args);
+    claim ??= await this.claimWrite("upsert_records", args.idempotencyKey, args, await this.upsertTargets(companies, contacts));
+    if (claim.replay !== undefined)
+      return claim.replay;
+    for (const company of companies) {
+      const partition = this.recordPartition("company", deterministicRecordId("company", company.externalId));
+      await this.mergeProfile("company", company, claim.claimedAt, requiredTarget(claim, partition));
+    }
+    for (const contact of contacts) {
+      const partition = this.recordPartition("contact", deterministicRecordId("contact", contact.externalId));
+      await this.mergeProfile("contact", contact, claim.claimedAt, requiredTarget(claim, partition));
+    }
+    const result = { accepted: true, operation: "upsert_records", records: count };
+    await this.completeClaim(claim, result);
+    return result;
+  }
+  async search(args = {}) {
+    const limit = boundedLimit(args.limit, CRM_MAX_SEARCH_LIMIT, "limit");
+    const searchText = args.query === undefined ? undefined : normalizedText([args.query]);
+    const exclusiveStartKey = args.cursor === undefined ? undefined : decodeRecordsCursor(args.cursor, this.recordsPartition());
+    const output = await this.documentClient.send(new QueryCommand({
+      TableName: this.tableName,
+      IndexName: RECORDS_INDEX,
+      KeyConditionExpression: "#gsi1pk = :gsi1pk",
+      ExpressionAttributeNames: { "#gsi1pk": "gsi1pk" },
+      ExpressionAttributeValues: { ":gsi1pk": this.recordsPartition() },
+      Limit: limit,
+      ...exclusiveStartKey === undefined ? {} : { ExclusiveStartKey: exclusiveStartKey }
+    }));
+    const items = output.Items ?? [];
+    const candidates = await Promise.all(items.map(async (item) => {
+      const identity = indexCandidate(item, this.recordsPartition());
+      const profile = await this.readActiveProfile(identity.recordType, identity.recordId);
+      if (profile === null || !profileMatchesSearch(profile, args, searchText))
+        return null;
+      return { item, profile };
+    }));
+    const accepted = candidates.filter((candidate) => candidate !== null);
+    const records = accepted.map(({ profile }) => searchRecord(profile));
+    const finalCursor = output.LastEvaluatedKey === undefined ? undefined : encodeRecordsCursor(output.LastEvaluatedKey, this.recordsPartition());
+    return boundedSearchResponse(accepted.map(({ item }) => item), records, finalCursor, this.recordsPartition());
+  }
+  async getRecord(args) {
+    const profile = await this.readActiveProfile(args.recordType, args.recordId);
+    if (profile === null)
+      throw new CrmRecordNotFoundError;
+    const activityLimit = boundedLimit(args.activityLimit, CRM_MAX_ACTIVITY_PAGE_SIZE, "activityLimit", DEFAULT_ACTIVITY_LIMIT);
+    const partition = this.recordPartition(args.recordType, args.recordId);
+    const prefix = activityPrefix(profile.generation);
+    const exclusiveStartKey = args.cursor === undefined ? undefined : decodeActivityCursor(args.cursor, partition, prefix);
+    const output = await this.documentClient.send(new QueryCommand({
+      TableName: this.tableName,
+      KeyConditionExpression: "#pk = :pk AND begins_with(#sk, :activityPrefix)",
+      ExpressionAttributeNames: { "#pk": "pk", "#sk": "sk" },
+      ExpressionAttributeValues: { ":pk": partition, ":activityPrefix": prefix },
+      Limit: activityLimit,
+      ScanIndexForward: false,
+      ConsistentRead: true,
+      ...exclusiveStartKey === undefined ? {} : { ExclusiveStartKey: exclusiveStartKey }
+    }));
+    const items = output.Items ?? [];
+    const activities = items.map(activityFromItem);
+    const finalCursor = output.LastEvaluatedKey === undefined ? undefined : encodeActivityCursor(output.LastEvaluatedKey, partition, prefix);
+    return boundedGetResponse(profileRecord(profile), items, activities, finalCursor, partition, prefix);
+  }
+  async updateStatus(args) {
+    const partition = this.recordPartition(args.recordType, args.recordId);
+    let claim = await this.resolveClaim("update_status", args.idempotencyKey, args);
+    if (claim === null) {
+      const profile = await this.readActiveProfile(args.recordType, args.recordId);
+      if (profile === null)
+        throw new CrmRecordNotFoundError;
+      this.assertStatusChangeAllowed(args, profile.status);
+      await this.assertDraftedStatusAllowed(args, partition, profile);
+      claim = await this.claimWrite("update_status", args.idempotencyKey, args, {
+        [partition]: profile.generation
+      });
+    }
+    if (claim.replay !== undefined)
+      return claim.replay;
+    const targetGeneration = requiredTarget(claim, partition);
+    await this.changeProfile(args.recordType, args.recordId, claim.claimedAt, targetGeneration, (profile) => {
+      this.assertStatusChangeAllowed(args, profile.status);
+      return { ...profile, status: args.status };
+    });
+    const result = {
+      accepted: true,
+      operation: "update_status",
+      recordType: args.recordType,
+      recordId: args.recordId,
+      status: args.status
+    };
+    await this.completeClaim(claim, result);
+    return result;
+  }
+  async logActivity(args) {
+    const partition = this.recordPartition(args.recordType, args.recordId);
+    const outreachEvent = classifyOutreach(args, this.outreach !== undefined);
+    let claim = await this.resolveClaim("log_activity", args.idempotencyKey, args);
+    if (claim === null) {
+      const initial = await this.readActiveProfile(args.recordType, args.recordId);
+      if (initial === null)
+        throw new CrmRecordNotFoundError;
+      if (outreachEvent?.type === "drafted") {
+        await this.assertNotSuppressed(initial);
+        await this.assertDraftAllowed(partition, initial.generation, outreachEvent.kind);
+      }
+      claim = await this.claimWrite("log_activity", args.idempotencyKey, args, {
+        [partition]: initial.generation
+      });
+    }
+    if (claim.replay !== undefined)
+      return claim.replay;
+    const targetGeneration = requiredTarget(claim, partition);
+    const profile = await this.readActiveProfile(args.recordType, args.recordId);
+    if (profile === null)
+      throw new CrmRecordNotFoundError;
+    if (profile.generation !== targetGeneration)
+      throw new CrmStorageError;
+    const occurredAt = new Date(parseCrmTimestamp(args.occurredAt ?? claim.claimedAt, "occurredAt")).toISOString();
+    const activityId = deterministicActivityId(partition, claim.key.sk);
+    const item = {
+      pk: partition,
+      sk: `${activityPrefix(targetGeneration)}${occurredAt}#${activityId}`,
+      recordType: args.recordType,
+      recordId: args.recordId,
+      generation: targetGeneration,
+      activityId,
+      activityType: args.activityType,
+      summary: args.summary,
+      occurredAt,
+      createdAt: claim.claimedAt,
+      actor: this.actor,
+      ...args.attributes === undefined ? {} : { attributes: copyAttributes(args.attributes) }
+    };
+    try {
+      await this.documentClient.send(new TransactWriteCommand2({
+        TransactItems: [
+          {
+            ConditionCheck: {
+              TableName: this.tableName,
+              Key: { pk: partition, sk: LIFECYCLE_SK },
+              ConditionExpression: "#state = :active AND #generation = :generation",
+              ExpressionAttributeNames: { "#state": "state", "#generation": "generation" },
+              ExpressionAttributeValues: {
+                ":active": "active",
+                ":generation": targetGeneration
+              }
+            }
+          },
+          { Put: { TableName: this.tableName, Item: item } },
+          ...outreachEvent === undefined ? [] : this.outreachWrites(partition, targetGeneration, outreachEvent, occurredAt)
+        ]
+      }));
+    } catch (error) {
+      if (!isConditionalFailure(error))
+        throw error;
+      if (outreachEvent?.type === "drafted") {
+        await this.assertDraftAllowed(partition, targetGeneration, outreachEvent.kind);
+      }
+      throw new CrmStorageError;
+    }
+    const result = {
+      accepted: true,
+      operation: "log_activity",
+      recordType: args.recordType,
+      recordId: args.recordId,
+      activityType: args.activityType
+    };
+    await this.completeClaim(claim, result);
+    return result;
+  }
+  async updateNote(args) {
+    const partition = this.recordPartition(args.recordType, args.recordId);
+    let claim = await this.resolveClaim("update_note", args.idempotencyKey, args);
+    if (claim === null) {
+      const profile = await this.readActiveProfile(args.recordType, args.recordId);
+      if (profile === null)
+        throw new CrmRecordNotFoundError;
+      const item2 = await this.findActivity(partition, profile.generation, args.activityId);
+      assertNoteEditable(item2, args.version);
+      claim = await this.claimWrite("update_note", args.idempotencyKey, args, {
+        [partition]: profile.generation
+      });
+    }
+    if (claim.replay !== undefined)
+      return claim.replay;
+    const generation = requiredTarget(claim, partition);
+    const item = await this.findActivity(partition, generation, args.activityId);
+    const result = {
+      accepted: true,
+      operation: "update_note",
+      recordType: args.recordType,
+      recordId: args.recordId,
+      activityId: args.activityId,
+      version: args.version + 1
+    };
+    if (item?.editedByClaim === claim.key.sk && activityVersion(item) === args.version + 1) {
+      await this.completeClaim(claim, result);
+      return result;
+    }
+    assertNoteEditable(item, args.version);
+    const current = item;
+    const replaced = {
+      summary: current.summary,
+      version: args.version,
+      replacedAt: claim.claimedAt
+    };
+    const history = [...storedNoteHistory(current.history), replaced].slice(-MAX_NOTE_HISTORY);
+    const versioned = typeof current.version === "number";
+    try {
+      await this.documentClient.send(new TransactWriteCommand2({
+        TransactItems: [
+          {
+            ConditionCheck: {
+              TableName: this.tableName,
+              Key: { pk: partition, sk: LIFECYCLE_SK },
+              ConditionExpression: "#state = :active AND #generation = :generation",
+              ExpressionAttributeNames: { "#state": "state", "#generation": "generation" },
+              ExpressionAttributeValues: { ":active": "active", ":generation": generation }
+            }
+          },
+          {
+            Update: {
+              TableName: this.tableName,
+              Key: { pk: current.pk, sk: current.sk },
+              UpdateExpression: "SET #summary = :summary, #version = :next, #editedAt = :at, #editedBy = :by, #editedByClaim = :claim, #history = :history",
+              ConditionExpression: versioned ? "#activityType = :note AND #version = :version" : "#activityType = :note AND attribute_not_exists(#version)",
+              ExpressionAttributeNames: {
+                "#summary": "summary",
+                "#version": "version",
+                "#editedAt": "editedAt",
+                "#editedBy": "editedBy",
+                "#editedByClaim": "editedByClaim",
+                "#history": "history",
+                "#activityType": "activityType"
+              },
+              ExpressionAttributeValues: {
+                ":summary": args.summary,
+                ":next": args.version + 1,
+                ":at": claim.claimedAt,
+                ":by": this.actor,
+                ":claim": claim.key.sk,
+                ":history": history,
+                ":note": CRM_NOTE_ACTIVITY,
+                ...versioned ? { ":version": args.version } : {}
+              }
+            }
+          }
+        ]
+      }));
+    } catch (error) {
+      if (!isConditionalFailure(error))
+        throw error;
+      throw new CrmStaleWriteError("stale_version");
+    }
+    await this.completeClaim(claim, result);
+    return result;
+  }
+  async findActivity(partition, generation, activityId) {
+    let exclusiveStartKey;
+    for (let page = 0;page < MAX_ACTIVITY_FIND_PAGES; page += 1) {
+      const output = await this.documentClient.send(new QueryCommand({
+        TableName: this.tableName,
+        KeyConditionExpression: "#pk = :pk AND begins_with(#sk, :activityPrefix)",
+        FilterExpression: "#activityId = :activityId",
+        ExpressionAttributeNames: { "#pk": "pk", "#sk": "sk", "#activityId": "activityId" },
+        ExpressionAttributeValues: {
+          ":pk": partition,
+          ":activityPrefix": activityPrefix(generation),
+          ":activityId": activityId
+        },
+        ConsistentRead: true,
+        Limit: ACTIVITY_DELETE_PAGE_SIZE,
+        ...exclusiveStartKey === undefined ? {} : { ExclusiveStartKey: exclusiveStartKey }
+      }));
+      const found = (output.Items ?? []).find((item) => item.activityId === activityId);
+      if (found !== undefined)
+        return found;
+      exclusiveStartKey = output.LastEvaluatedKey;
+      if (exclusiveStartKey === undefined)
+        return null;
+    }
+    return null;
+  }
+  async deleteRecord(args) {
+    const partition = this.recordPartition(args.recordType, args.recordId);
+    let claim = await this.resolveClaim("delete_record", args.idempotencyKey, args);
+    if (claim === null) {
+      const lifecycle = await this.readLifecycle(partition);
+      const targets = lifecycle === null ? {} : { [partition]: lifecycle.generation };
+      claim = await this.claimWrite("delete_record", args.idempotencyKey, args, targets);
+    }
+    const result = {
+      accepted: true,
+      operation: "delete_record",
+      recordType: args.recordType,
+      recordId: args.recordId
+    };
+    const targetGeneration = claim.targets[partition];
+    if (claim.replay === undefined) {
+      await this.fenceDelete(partition, claim, result, targetGeneration);
+    }
+    if (targetGeneration !== undefined) {
+      await this.deleteActivityGeneration(partition, targetGeneration);
+    }
+    return claim.replay ?? result;
+  }
+  async outreachQueue() {
+    const policy = this.outreach;
+    if (policy === undefined)
+      throw new CrmOutreachUnconfiguredError;
+    const now = this.now();
+    const [counters, scan] = await Promise.all([
+      this.readWeekCounter(outreachWeekStart(now, policy.timezone)),
+      this.scanProfiles()
+    ]);
+    const companies = new Map;
+    const contacts = [];
+    for (const profile of scan.profiles) {
+      if (profile.recordType === "company")
+        companies.set(profile.externalId, profile);
+      else if (profile.email !== undefined)
+        contacts.push(profile);
+    }
+    const touches = await this.readOutreachStates(contacts);
+    const candidate = (profile) => outreachCandidate(profile, companies, touches.get(profile.recordId), policy.rankAttribute);
+    return buildOutreachQueue({
+      policy,
+      now,
+      counters,
+      candidates: contacts.map(candidate),
+      ...scan.truncated ? { truncated: true } : {},
+      recheck: async ({ contactId }) => {
+        const current = await this.readActiveProfile("contact", contactId);
+        return current === null || current.email === undefined ? null : candidate(current);
+      }
+    });
+  }
+  async scanProfiles() {
+    const identities = [];
+    let exclusiveStartKey;
+    let truncated = false;
+    for (let page = 0;page < MAX_QUEUE_SCAN_PAGES; page += 1) {
+      const output = await this.documentClient.send(new QueryCommand({
+        TableName: this.tableName,
+        IndexName: RECORDS_INDEX,
+        KeyConditionExpression: "#gsi1pk = :gsi1pk",
+        ExpressionAttributeNames: { "#gsi1pk": "gsi1pk" },
+        ExpressionAttributeValues: { ":gsi1pk": this.recordsPartition() },
+        Limit: QUEUE_SCAN_PAGE_SIZE,
+        ...exclusiveStartKey === undefined ? {} : { ExclusiveStartKey: exclusiveStartKey }
+      }));
+      for (const item of output.Items ?? []) {
+        identities.push(indexCandidate(item, this.recordsPartition()));
+      }
+      exclusiveStartKey = output.LastEvaluatedKey;
+      if (exclusiveStartKey === undefined)
+        break;
+      if (page === MAX_QUEUE_SCAN_PAGES - 1)
+        truncated = true;
+    }
+    const keys = [];
+    for (const { recordType, recordId } of identities) {
+      const pk = this.recordPartition(recordType, recordId);
+      keys.push({ pk, sk: PROFILE_SK }, { pk, sk: LIFECYCLE_SK });
+    }
+    const items = await this.batchGet(keys);
+    const profiles = [];
+    for (const { recordType, recordId } of identities) {
+      const pk = this.recordPartition(recordType, recordId);
+      const profileItem = items.get(itemKey(pk, PROFILE_SK));
+      const lifecycleItem = items.get(itemKey(pk, LIFECYCLE_SK));
+      if (profileItem === undefined || lifecycleItem === undefined)
+        continue;
+      const profile = profileFromItem(profileItem);
+      this.assertProfileStorageKey(profileItem, profile);
+      if (lifecycleItem.state !== "active" || lifecycleItem.generation !== profile.generation || profile.recordType !== recordType || profile.recordId !== recordId) {
+        continue;
+      }
+      profiles.push(profile);
+    }
+    return { profiles, truncated };
+  }
+  async readOutreachStates(contacts) {
+    const items = await this.batchGet(contacts.map((profile) => ({
+      pk: this.recordPartition("contact", profile.recordId),
+      sk: outreachSk(profile.generation)
+    })));
+    const states = new Map;
+    for (const profile of contacts) {
+      const item = items.get(itemKey(this.recordPartition("contact", profile.recordId), outreachSk(profile.generation)));
+      if (item !== undefined)
+        states.set(profile.recordId, outreachStateFromItem(item));
+    }
+    return states;
+  }
+  async batchGet(keys) {
+    const found = new Map;
+    const chunks = [];
+    for (let offset = 0;offset < keys.length; offset += BATCH_GET_LIMIT) {
+      chunks.push(keys.slice(offset, offset + BATCH_GET_LIMIT));
+    }
+    for (const chunk of chunks) {
+      let pending = chunk;
+      for (let attempt = 0;pending.length > 0 && attempt < MAX_BATCH_GET_RETRIES; attempt += 1) {
+        const output = await this.documentClient.send(new BatchGetCommand({
+          RequestItems: { [this.tableName]: { Keys: pending, ConsistentRead: true } }
+        }));
+        for (const item of output.Responses?.[this.tableName] ?? []) {
+          if (typeof item.pk === "string" && typeof item.sk === "string") {
+            found.set(itemKey(item.pk, item.sk), item);
+          }
+        }
+        pending = output.UnprocessedKeys?.[this.tableName]?.Keys ?? [];
+      }
+      if (pending.length > 0)
+        throw new CrmStorageError;
+    }
+    return found;
+  }
+  assertStatusChangeAllowed(args, currentStatus) {
+    const refusal = checkStatusChange(this.statusPolicy, args.recordType, { status: currentStatus, setBy: "agent" }, args.status);
+    if (refusal !== undefined)
+      throw new CrmPolicyRefusedError(refusal);
+  }
+  async assertNotSuppressed(contact) {
+    const policy = this.outreach;
+    if (policy === undefined)
+      return;
+    const company = contact.companyExternalId === undefined ? null : await this.readActiveProfile("company", deterministicRecordId("company", contact.companyExternalId));
+    const refusal = checkSuppressed(policy.suppressedStatuses, { status: contact.status }, company === null ? undefined : { status: company.status });
+    if (refusal !== undefined)
+      throw new CrmPolicyRefusedError(refusal);
+  }
+  async assertDraftAllowed(partition, generation, kind) {
+    const policy = this.outreach;
+    if (policy === undefined)
+      return;
+    if (!this.countsOutreach) {
+      const touch2 = await this.readOutreachState(partition, generation);
+      const uncapped = {
+        ...policy,
+        weeklyLimit: Number.POSITIVE_INFINITY,
+        followUpLimit: Number.POSITIVE_INFINITY
+      };
+      const refusal2 = checkDraft(uncapped, touch2, { firstTouch: 0, followUp: 0 }, kind);
+      if (refusal2 !== undefined)
+        throw new CrmPolicyRefusedError(refusal2);
+      return;
+    }
+    const [touch, counters] = await Promise.all([
+      this.readOutreachState(partition, generation),
+      this.readWeekCounter(outreachWeekStart(this.now(), policy.timezone))
+    ]);
+    const refusal = checkDraft(policy, touch, counters, kind);
+    if (refusal !== undefined)
+      throw new CrmPolicyRefusedError(refusal);
+  }
+  async assertDraftedStatusAllowed(args, partition, profile) {
+    const policy = this.outreach;
+    if (policy === undefined || !this.countsOutreach || !movesToDraftedStatus(policy, args.recordType, profile.status, args.status)) {
+      return;
+    }
+    const touched = await this.readOutreachState(partition, profile.generation) !== null;
+    if (touched)
+      return;
+    const counters = await this.readWeekCounter(outreachWeekStart(this.now(), policy.timezone));
+    const refusal = checkDraftedStatus(policy, args.recordType, profile.status, args.status, touched, counters);
+    if (refusal !== undefined)
+      throw new CrmPolicyRefusedError(refusal);
+  }
+  outreachWrites(partition, generation, event, occurredAt) {
+    const policy = this.outreach;
+    if (policy === undefined)
+      return [];
+    const key = { pk: partition, sk: outreachSk(generation) };
+    if (event.type === "sent") {
+      const withThread = event.threadId !== undefined;
+      return [
+        {
+          Update: {
+            TableName: this.tableName,
+            Key: key,
+            UpdateExpression: `SET #lastTouchAt = :at, #firstTouchAt = if_not_exists(#firstTouchAt, :at), #followUps = if_not_exists(#followUps, :zero)${withThread ? ", #lastThreadId = :thread" : ""}`,
+            ExpressionAttributeNames: {
+              "#lastTouchAt": "lastTouchAt",
+              "#firstTouchAt": "firstTouchAt",
+              "#followUps": "followUps",
+              ...withThread ? { "#lastThreadId": "lastThreadId" } : {}
+            },
+            ExpressionAttributeValues: {
+              ":at": occurredAt,
+              ":zero": 0,
+              ...withThread ? { ":thread": event.threadId } : {}
+            }
+          }
+        }
+      ];
+    }
+    if (event.type === "reply") {
+      return [
+        {
+          Update: {
+            TableName: this.tableName,
+            Key: key,
+            UpdateExpression: "SET #lastReplyAt = :at, #followUps = if_not_exists(#followUps, :zero)",
+            ExpressionAttributeNames: { "#lastReplyAt": "lastReplyAt", "#followUps": "followUps" },
+            ExpressionAttributeValues: { ":at": occurredAt, ":zero": 0 }
+          }
+        }
+      ];
+    }
+    const firstTouch = event.kind === "first_touch";
+    const counterField = firstTouch ? "firstTouch" : "followUp";
+    const counterWrite = {
+      Update: {
+        TableName: this.tableName,
+        Key: {
+          pk: this.outreachPartition(),
+          sk: outreachWeekSk(outreachWeekStart(this.now(), policy.timezone))
+        },
+        UpdateExpression: "ADD #count :one",
+        ConditionExpression: "attribute_not_exists(#count) OR #count < :limit",
+        ExpressionAttributeNames: { "#count": counterField },
+        ExpressionAttributeValues: {
+          ":one": 1,
+          ":limit": firstTouch ? policy.weeklyLimit : policy.followUpLimit
+        }
+      }
+    };
+    const counted = this.countsOutreach ? [counterWrite] : [];
+    if (firstTouch) {
+      return [
+        ...counted,
+        {
+          Put: {
+            TableName: this.tableName,
+            Item: {
+              ...key,
+              firstTouchAt: occurredAt,
+              lastTouchAt: occurredAt,
+              followUps: 0,
+              ...event.threadId === undefined ? {} : { lastThreadId: event.threadId },
+              ...event.draftId === undefined ? {} : { lastDraftId: event.draftId }
+            },
+            ConditionExpression: "attribute_not_exists(#pk)",
+            ExpressionAttributeNames: { "#pk": "pk" }
+          }
+        }
+      ];
+    }
+    const names = {
+      "#pk": "pk",
+      "#lastTouchAt": "lastTouchAt",
+      "#followUps": "followUps"
+    };
+    const values = {
+      ":at": occurredAt,
+      ":one": 1,
+      ":max": policy.maxFollowUps
+    };
+    const sets = ["#lastTouchAt = :at", "#followUps = #followUps + :one"];
+    if (event.threadId !== undefined) {
+      names["#lastThreadId"] = "lastThreadId";
+      values[":thread"] = event.threadId;
+      sets.push("#lastThreadId = :thread");
+    }
+    if (event.draftId !== undefined) {
+      names["#lastDraftId"] = "lastDraftId";
+      values[":draft"] = event.draftId;
+      sets.push("#lastDraftId = :draft");
+    }
+    return [
+      ...counted,
+      {
+        Update: {
+          TableName: this.tableName,
+          Key: key,
+          UpdateExpression: `SET ${sets.join(", ")}`,
+          ConditionExpression: "attribute_exists(#pk) AND #followUps < :max",
+          ExpressionAttributeNames: names,
+          ExpressionAttributeValues: values
+        }
+      }
+    ];
+  }
+  async readOutreachState(partition, generation) {
+    const output = await this.documentClient.send(new GetCommand2({
+      TableName: this.tableName,
+      Key: { pk: partition, sk: outreachSk(generation) },
+      ConsistentRead: true
+    }));
+    return output.Item === undefined ? null : outreachStateFromItem(output.Item);
+  }
+  async readWeekCounter(weekStart) {
+    const output = await this.documentClient.send(new GetCommand2({
+      TableName: this.tableName,
+      Key: { pk: this.outreachPartition(), sk: outreachWeekSk(weekStart) },
+      ConsistentRead: true
+    }));
+    return {
+      firstTouch: storedCount(output.Item?.firstTouch),
+      followUp: storedCount(output.Item?.followUp)
+    };
+  }
+  async mergeProfile(recordType, input, timestamp, targetGeneration) {
+    const recordId = deterministicRecordId(recordType, input.externalId);
+    const partition = this.recordPartition(recordType, recordId);
+    await this.ensureLifecycleGeneration(partition, targetGeneration);
+    for (let attempt = 0;attempt < MAX_WRITE_RETRIES; attempt += 1) {
+      const stored = await this.readProfile(recordType, recordId);
+      const current = stored?.generation === targetGeneration ? stored : null;
+      const next = {
+        ...mergeProfile(current, recordType, recordId, input, timestamp, this.defaultStatuses[recordType], this.actor),
+        generation: targetGeneration,
+        version: (current?.version ?? 0) + 1
+      };
+      try {
+        await this.writeProfile(next, current);
+        return;
+      } catch (error) {
+        if (!isConditionalFailure(error) || attempt === MAX_WRITE_RETRIES - 1)
+          throw error;
+        await this.assertActiveGeneration(partition, targetGeneration);
+      }
+    }
+    throw new CrmStorageError;
+  }
+  async changeProfile(recordType, recordId, timestamp, targetGeneration, change) {
+    for (let attempt = 0;attempt < MAX_WRITE_RETRIES; attempt += 1) {
+      const current = await this.readActiveProfile(recordType, recordId);
+      if (current === null)
+        throw new CrmRecordNotFoundError;
+      if (current.generation !== targetGeneration)
+        throw new CrmStorageError;
+      const next = {
+        ...change(current),
+        recordType,
+        recordId,
+        createdAt: current.createdAt,
+        updatedAt: timestamp,
+        generation: targetGeneration,
+        version: current.version + 1
+      };
+      try {
+        await this.writeProfile(next, current);
+        return;
+      } catch (error) {
+        if (!isConditionalFailure(error) || attempt === MAX_WRITE_RETRIES - 1)
+          throw error;
+        await this.assertActiveGeneration(this.recordPartition(recordType, recordId), targetGeneration);
+      }
+    }
+    throw new CrmStorageError;
+  }
+  async readProfile(recordType, recordId) {
+    const output = await this.documentClient.send(new GetCommand2({
+      TableName: this.tableName,
+      Key: { pk: this.recordPartition(recordType, recordId), sk: PROFILE_SK },
+      ConsistentRead: true
+    }));
+    if (output.Item === undefined)
+      return null;
+    const profile = profileFromItem(output.Item);
+    this.assertProfileStorageKey(output.Item, profile);
+    if (profile.recordType !== recordType || profile.recordId !== recordId)
+      throw new CrmStorageError;
+    return profile;
+  }
+  async readActiveProfile(recordType, recordId) {
+    const partition = this.recordPartition(recordType, recordId);
+    const [profile, lifecycle] = await Promise.all([
+      this.readProfile(recordType, recordId),
+      this.readLifecycle(partition)
+    ]);
+    if (profile === null || lifecycle?.state !== "active" || lifecycle.generation !== profile.generation) {
+      return null;
+    }
+    return profile;
+  }
+  assertProfileStorageKey(item, profile) {
+    if (item.pk !== this.recordPartition(profile.recordType, profile.recordId) || item.sk !== PROFILE_SK || item.gsi1pk !== this.recordsPartition() || item.gsi1sk !== `PROFILE#${profile.recordType}#${profile.recordId}`) {
+      throw new CrmStorageError;
+    }
+  }
+  profileItem(profile) {
+    return {
+      pk: this.recordPartition(profile.recordType, profile.recordId),
+      sk: PROFILE_SK,
+      gsi1pk: this.recordsPartition(),
+      gsi1sk: `PROFILE#${profile.recordType}#${profile.recordId}`,
+      ...profile,
+      searchText: normalizedText(profileSearchFields(profile)),
+      createdBy: profile.createdBy,
+      updatedBy: this.actor
+    };
+  }
+  async writeProfile(next, previous) {
+    const partition = this.recordPartition(next.recordType, next.recordId);
+    await this.documentClient.send(new TransactWriteCommand2({
+      TransactItems: [
+        {
+          ConditionCheck: {
+            TableName: this.tableName,
+            Key: { pk: partition, sk: LIFECYCLE_SK },
+            ConditionExpression: "#state = :active AND #generation = :generation",
+            ExpressionAttributeNames: { "#state": "state", "#generation": "generation" },
+            ExpressionAttributeValues: {
+              ":active": "active",
+              ":generation": next.generation
+            }
+          }
+        },
+        {
+          Put: {
+            TableName: this.tableName,
+            Item: this.profileItem(next),
+            ...previous === null ? {
+              ConditionExpression: "attribute_not_exists(#pk) AND attribute_not_exists(#sk)",
+              ExpressionAttributeNames: { "#pk": "pk", "#sk": "sk" }
+            } : {
+              ConditionExpression: "#version = :version",
+              ExpressionAttributeNames: { "#version": "version" },
+              ExpressionAttributeValues: { ":version": previous.version }
+            }
+          }
+        }
+      ]
+    }));
+  }
+  async resolveClaim(operation, idempotencyKey, payload) {
+    const key = {
+      pk: this.idempotencyPartition(),
+      sk: `${operation}#${hashText(idempotencyKey)}`
+    };
+    const payloadHash = hashPayload(operation, payload);
+    const output = await this.documentClient.send(new GetCommand2({ TableName: this.tableName, Key: key, ConsistentRead: true }));
+    if (output.Item === undefined)
+      return null;
+    if (output.Item.payloadHash !== payloadHash)
+      throw new CrmIdempotencyConflictError;
+    const claimedAt = output.Item.claimedAt;
+    if (typeof claimedAt !== "string")
+      throw new CrmStorageError;
+    const actor = storedActor(output.Item.actor);
+    if (!sameActor(actor, this.actor))
+      throw new CrmIdempotencyConflictError;
+    const targets = storedTargets(output.Item.targets);
+    if (output.Item.state === "completed") {
+      return {
+        key,
+        payloadHash,
+        claimedAt,
+        actor,
+        targets,
+        replay: completedResult(output.Item, operation)
+      };
+    }
+    if (output.Item.state === "claimed") {
+      return { key, payloadHash, claimedAt, actor, targets };
+    }
+    throw new CrmStorageError;
+  }
+  async claimWrite(operation, idempotencyKey, payload, targets) {
+    const key = {
+      pk: this.idempotencyPartition(),
+      sk: `${operation}#${hashText(idempotencyKey)}`
+    };
+    const payloadHash = hashPayload(operation, payload);
+    for (let attempt = 0;attempt < MAX_WRITE_RETRIES; attempt += 1) {
+      const existing = await this.resolveClaim(operation, idempotencyKey, payload);
+      if (existing !== null)
+        return existing;
+      const claimedAt = this.nowIso();
+      try {
+        await this.documentClient.send(new PutCommand2({
+          TableName: this.tableName,
+          Item: {
+            ...key,
+            payloadHash,
+            state: "claimed",
+            claimedAt,
+            actor: this.actor,
+            targets
+          },
+          ConditionExpression: "attribute_not_exists(#pk) AND attribute_not_exists(#sk)",
+          ExpressionAttributeNames: { "#pk": "pk", "#sk": "sk" }
+        }));
+        return {
+          key,
+          payloadHash,
+          claimedAt,
+          actor: copyActor(this.actor),
+          targets: { ...targets }
+        };
+      } catch (error) {
+        if (!isConditionalFailure(error) || attempt === MAX_WRITE_RETRIES - 1)
+          throw error;
+      }
+    }
+    throw new CrmStorageError;
+  }
+  completedClaimItem(claim, result) {
+    return {
+      ...claim.key,
+      payloadHash: claim.payloadHash,
+      state: "completed",
+      claimedAt: claim.claimedAt,
+      completedAt: this.nowIso(),
+      actor: claim.actor,
+      targets: { ...claim.targets },
+      result
+    };
+  }
+  async completeClaim(claim, result) {
+    await this.documentClient.send(new PutCommand2({
+      TableName: this.tableName,
+      Item: this.completedClaimItem(claim, result),
+      ConditionExpression: "#payloadHash = :payloadHash AND #state = :claimed",
+      ExpressionAttributeNames: { "#payloadHash": "payloadHash", "#state": "state" },
+      ExpressionAttributeValues: { ":payloadHash": claim.payloadHash, ":claimed": "claimed" }
+    }));
+  }
+  async readLifecycle(partition) {
+    const output = await this.documentClient.send(new GetCommand2({
+      TableName: this.tableName,
+      Key: { pk: partition, sk: LIFECYCLE_SK },
+      ConsistentRead: true
+    }));
+    if (output.Item === undefined)
+      return null;
+    const { generation, state, deletedByClaim } = output.Item;
+    if (typeof generation !== "number" || !Number.isSafeInteger(generation) || generation < 1 || state !== "active" && state !== "deleted" || deletedByClaim !== undefined && typeof deletedByClaim !== "string") {
+      throw new CrmStorageError;
+    }
+    return {
+      generation,
+      state,
+      ...deletedByClaim === undefined ? {} : { deletedByClaim }
+    };
+  }
+  async upsertTargets(companies, contacts) {
+    const partitions = new Set;
+    for (const company of companies) {
+      partitions.add(this.recordPartition("company", deterministicRecordId("company", company.externalId)));
+    }
+    for (const contact of contacts) {
+      partitions.add(this.recordPartition("contact", deterministicRecordId("contact", contact.externalId)));
+    }
+    const targets = {};
+    await Promise.all([...partitions].map(async (partition) => {
+      const lifecycle = await this.readLifecycle(partition);
+      targets[partition] = lifecycle?.state === "active" ? lifecycle.generation : (lifecycle?.generation ?? 0) + 1;
+    }));
+    return targets;
+  }
+  async assertActiveGeneration(partition, generation) {
+    const lifecycle = await this.readLifecycle(partition);
+    if (lifecycle?.state !== "active" || lifecycle.generation !== generation) {
+      throw new CrmStorageError;
+    }
+  }
+  async ensureLifecycleGeneration(partition, targetGeneration) {
+    for (let attempt = 0;attempt < MAX_WRITE_RETRIES; attempt += 1) {
+      const current = await this.readLifecycle(partition);
+      if (current?.state === "active" && current.generation === targetGeneration)
+        return;
+      const mayActivate = current === null && targetGeneration === 1 || current?.state === "deleted" && current.generation + 1 === targetGeneration;
+      if (!mayActivate)
+        throw new CrmStorageError;
+      try {
+        await this.documentClient.send(new PutCommand2({
+          TableName: this.tableName,
+          Item: {
+            pk: partition,
+            sk: LIFECYCLE_SK,
+            state: "active",
+            generation: targetGeneration
+          },
+          ...current === null ? {
+            ConditionExpression: "attribute_not_exists(#pk) AND attribute_not_exists(#sk)",
+            ExpressionAttributeNames: { "#pk": "pk", "#sk": "sk" }
+          } : {
+            ConditionExpression: "#state = :deleted AND #generation = :previous",
+            ExpressionAttributeNames: { "#state": "state", "#generation": "generation" },
+            ExpressionAttributeValues: {
+              ":deleted": "deleted",
+              ":previous": current.generation
+            }
+          }
+        }));
+        return;
+      } catch (error) {
+        if (!isConditionalFailure(error) || attempt === MAX_WRITE_RETRIES - 1)
+          throw error;
+      }
+    }
+    throw new CrmStorageError;
+  }
+  async fenceDelete(partition, claim, result, targetGeneration) {
+    for (let attempt = 0;attempt < MAX_WRITE_RETRIES; attempt += 1) {
+      const lifecycle = await this.readLifecycle(partition);
+      if (targetGeneration === undefined) {
+        await this.completeClaim(claim, result);
+        return;
+      }
+      if (lifecycle?.state === "deleted" && lifecycle.generation === targetGeneration) {
+        await this.completeClaim(claim, result);
+        return;
+      }
+      if (lifecycle?.state !== "active" || lifecycle.generation !== targetGeneration) {
+        throw new CrmStorageError;
+      }
+      try {
+        await this.documentClient.send(new TransactWriteCommand2({
+          TransactItems: [
+            {
+              Put: {
+                TableName: this.tableName,
+                Item: {
+                  pk: partition,
+                  sk: LIFECYCLE_SK,
+                  state: "deleted",
+                  generation: targetGeneration,
+                  deletedByClaim: claim.key.sk
+                },
+                ConditionExpression: "#state = :active AND #generation = :generation",
+                ExpressionAttributeNames: { "#state": "state", "#generation": "generation" },
+                ExpressionAttributeValues: {
+                  ":active": "active",
+                  ":generation": targetGeneration
+                }
+              }
+            },
+            {
+              Delete: {
+                TableName: this.tableName,
+                Key: { pk: partition, sk: PROFILE_SK }
+              }
+            },
+            {
+              Delete: {
+                TableName: this.tableName,
+                Key: { pk: partition, sk: outreachSk(targetGeneration) }
+              }
+            },
+            {
+              Put: {
+                TableName: this.tableName,
+                Item: this.completedClaimItem(claim, result),
+                ConditionExpression: "#payloadHash = :payloadHash AND #state = :claimed",
+                ExpressionAttributeNames: { "#payloadHash": "payloadHash", "#state": "state" },
+                ExpressionAttributeValues: {
+                  ":payloadHash": claim.payloadHash,
+                  ":claimed": "claimed"
+                }
+              }
+            }
+          ]
+        }));
+        return;
+      } catch (error) {
+        if (!isConditionalFailure(error) || attempt === MAX_WRITE_RETRIES - 1)
+          throw error;
+      }
+    }
+    throw new CrmStorageError;
+  }
+  async deleteActivityGeneration(partition, generation) {
+    let exclusiveStartKey;
+    for (let page = 0;page < MAX_ACTIVITY_DELETE_PAGES; page += 1) {
+      const output = await this.documentClient.send(new QueryCommand({
+        TableName: this.tableName,
+        KeyConditionExpression: "#pk = :pk AND begins_with(#sk, :activityPrefix)",
+        ExpressionAttributeNames: { "#pk": "pk", "#sk": "sk" },
+        ExpressionAttributeValues: {
+          ":pk": partition,
+          ":activityPrefix": activityPrefix(generation)
+        },
+        ConsistentRead: true,
+        Limit: ACTIVITY_DELETE_PAGE_SIZE,
+        ...exclusiveStartKey === undefined ? {} : { ExclusiveStartKey: exclusiveStartKey }
+      }));
+      await this.batchDelete(output.Items ?? []);
+      exclusiveStartKey = output.LastEvaluatedKey;
+      if (exclusiveStartKey === undefined)
+        return;
+    }
+    throw new CrmStorageError;
+  }
+  async batchDelete(items) {
+    for (let offset = 0;offset < items.length; offset += BATCH_WRITE_LIMIT) {
+      let requests = items.slice(offset, offset + BATCH_WRITE_LIMIT).map((item) => ({
+        DeleteRequest: { Key: { pk: item.pk, sk: item.sk } }
+      }));
+      for (let attempt = 0;requests.length > 0 && attempt < MAX_BATCH_WRITE_RETRIES; attempt += 1) {
+        const output = await this.documentClient.send(new BatchWriteCommand({ RequestItems: { [this.tableName]: requests } }));
+        requests = output.UnprocessedItems?.[this.tableName] ?? [];
+      }
+      if (requests.length > 0)
+        throw new CrmStorageError;
+    }
+  }
+  recordsPartition() {
+    return `TENANT#${this.tenantId}#RECORDS`;
+  }
+  recordPartition(recordType, recordId) {
+    return `TENANT#${this.tenantId}#RECORD#${recordType}#${recordId}`;
+  }
+  idempotencyPartition() {
+    return `TENANT#${this.tenantId}#IDEMPOTENCY`;
+  }
+  outreachPartition() {
+    return outreachLedgerPartition(this.tenantId);
+  }
+  nowIso() {
+    const value = this.now();
+    if (!(value instanceof Date) || !Number.isFinite(value.getTime()))
+      throw new CrmStorageError;
+    return value.toISOString();
+  }
+}
+function createDynamoCrmClient(options) {
+  return new DynamoCrmClient(options);
+}
+function outreachSk(generation) {
+  return `${OUTREACH_SK_PREFIX}${String(generation).padStart(12, "0")}`;
+}
+function itemKey(pk, sk) {
+  return `${pk}\x00${sk}`;
+}
+function outreachStateFromItem(item) {
+  const state = { followUps: storedCount(item.followUps) };
+  for (const field of [
+    "firstTouchAt",
+    "lastTouchAt",
+    "lastReplyAt",
+    "lastThreadId",
+    "lastDraftId"
+  ]) {
+    const value = item[field];
+    if (value === undefined)
+      continue;
+    if (typeof value !== "string")
+      throw new CrmStorageError;
+    state[field] = value;
+  }
+  return state;
+}
+function storedCount(value) {
+  if (value === undefined)
+    return 0;
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+    throw new CrmStorageError;
+  }
+  return value;
+}
+function rankOf(profile, companies, attribute) {
+  const own = profile.attributes?.[attribute];
+  if (typeof own === "number" && Number.isFinite(own))
+    return own;
+  const company = profile.companyExternalId === undefined ? undefined : companies.get(profile.companyExternalId)?.attributes?.[attribute];
+  return typeof company === "number" && Number.isFinite(company) ? company : undefined;
+}
+function outreachCandidate(profile, companies, touch, rankAttribute) {
+  const companyProfile = profile.companyExternalId === undefined ? undefined : companies.get(profile.companyExternalId);
+  const rank = rankOf(profile, companies, rankAttribute);
+  return {
+    contactId: profile.recordId,
+    email: profile.email,
+    status: profile.status,
+    createdAt: profile.createdAt,
+    ...profile.firstName === undefined ? {} : { firstName: profile.firstName },
+    ...profile.lastName === undefined ? {} : { lastName: profile.lastName },
+    ...profile.title === undefined ? {} : { title: profile.title },
+    ...profile.companyExternalId === undefined ? {} : { companyExternalId: profile.companyExternalId, organization: profile.companyExternalId },
+    ...companyProfile === undefined ? {} : {
+      companyId: companyProfile.recordId,
+      companyStatus: companyProfile.status,
+      ...companyProfile.name === undefined ? {} : { company: companyProfile.name }
+    },
+    ...rank === undefined ? {} : { rank },
+    ...touch === undefined ? {} : { touch }
+  };
+}
+function storedTargets(value) {
+  if (value === undefined)
+    return {};
+  if (!isObject(value) || Object.keys(value).length > 100)
+    throw new CrmStorageError;
+  const targets = {};
+  for (const [partition, generation] of Object.entries(value)) {
+    targets[partition] = storedPositiveInteger(generation);
+  }
+  return targets;
+}
+function requiredTarget(claim, partition) {
+  const generation = claim.targets[partition];
+  if (generation === undefined)
+    throw new CrmStorageError;
+  return generation;
+}
+function deterministicRecordId(recordType, externalId) {
+  return `${recordType}_${hashText(`${recordType}\x00${externalId}`)}`;
+}
+function deterministicActivityId(partition, idempotencySk) {
+  return `activity_${hashText(`${partition}\x00${idempotencySk}`)}`;
+}
+function activityPrefix(generation) {
+  return `${ACTIVITY_SK_PREFIX}${String(generation).padStart(12, "0")}#`;
+}
+function mergeProfile(current, recordType, recordId, incoming, timestamp, defaultStatus, actor) {
+  const fields = recordType === "company" ? ["name", "domain", "website", "source"] : ["email", "firstName", "lastName", "title", "companyExternalId", "source"];
+  const result = {
+    recordType,
+    recordId,
+    externalId: incoming.externalId,
+    status: current?.status ?? defaultStatus,
+    createdAt: current?.createdAt ?? timestamp,
+    updatedAt: timestamp,
+    createdBy: current?.createdBy ?? copyActor(actor),
+    generation: current?.generation ?? 1,
+    version: (current?.version ?? 0) + 1
+  };
+  for (const field of fields) {
+    const previous = current?.[field];
+    const next = incoming[field];
+    if (typeof next === "string") {
+      result[field] = next;
+    } else if (typeof previous === "string") {
+      result[field] = previous;
+    }
+  }
+  const incomingAttributes = incoming.attributes;
+  if (incomingAttributes !== undefined) {
+    result.attributes = copyAttributes(incomingAttributes);
+  } else if (current?.attributes !== undefined) {
+    result.attributes = copyAttributes(current.attributes);
+  }
+  return result;
+}
+function storedPositiveInteger(value) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1) {
+    throw new CrmStorageError;
+  }
+  return value;
+}
+function profileFromItem(item) {
+  const recordType = item.recordType;
+  if (recordType !== "company" && recordType !== "contact")
+    throw new CrmStorageError;
+  const required = ["recordId", "externalId", "status", "createdAt", "updatedAt"];
+  for (const key of required) {
+    if (typeof item[key] !== "string")
+      throw new CrmStorageError;
+  }
+  const version = storedPositiveInteger(item.version);
+  const generation = storedPositiveInteger(item.generation);
+  const profile = {
+    recordType,
+    recordId: item.recordId,
+    externalId: item.externalId,
+    status: item.status,
+    createdAt: item.createdAt,
+    updatedAt: item.updatedAt,
+    createdBy: storedActor(item.createdBy),
+    generation,
+    version
+  };
+  for (const field of [
+    "name",
+    "domain",
+    "website",
+    "source",
+    "email",
+    "firstName",
+    "lastName",
+    "title",
+    "companyExternalId"
+  ]) {
+    if (typeof item[field] === "string")
+      profile[field] = item[field];
+  }
+  const attributes = storedAttributes(item.attributes);
+  if (attributes !== undefined)
+    profile.attributes = attributes;
+  return profile;
+}
+function searchRecord(profile) {
+  const {
+    attributes: _attributes,
+    createdAt: _createdAt,
+    updatedAt: _updatedAt,
+    ...result
+  } = profileRecord(profile);
+  return result;
+}
+function profileRecord(profile) {
+  const result = {
+    recordType: profile.recordType,
+    id: profile.recordId,
+    externalId: profile.externalId,
+    status: profile.status,
+    createdAt: profile.createdAt,
+    updatedAt: profile.updatedAt
+  };
+  for (const field of [
+    "name",
+    "domain",
+    "website",
+    "source",
+    "email",
+    "firstName",
+    "lastName",
+    "title",
+    "companyExternalId"
+  ]) {
+    const value = profile[field];
+    if (value !== undefined)
+      result[field] = value;
+  }
+  if (profile.attributes !== undefined)
+    result.attributes = copyAttributes(profile.attributes);
+  return result;
+}
+function activityFromItem(item) {
+  const required = ["activityId", "activityType", "summary", "occurredAt", "createdAt"];
+  for (const key of required) {
+    if (typeof item[key] !== "string")
+      throw new CrmStorageError;
+  }
+  const activity = {
+    id: item.activityId,
+    activityType: item.activityType,
+    summary: item.summary,
+    occurredAt: item.occurredAt,
+    createdAt: item.createdAt
+  };
+  const attributes = storedAttributes(item.attributes);
+  if (attributes !== undefined)
+    activity.attributes = attributes;
+  if (item.version !== undefined)
+    activity.version = storedPositiveInteger(item.version);
+  return activity;
+}
+function activityVersion(item) {
+  return item.version === undefined ? 1 : storedPositiveInteger(item.version);
+}
+function assertNoteEditable(item, version) {
+  if (item === null)
+    throw new CrmRecordNotFoundError;
+  const refusal = checkNoteEdit(activityFromItem(item), "agent");
+  if (refusal !== undefined)
+    throw new CrmPolicyRefusedError(refusal);
+  if (activityVersion(item) !== version)
+    throw new CrmStaleWriteError("stale_version");
+}
+function storedNoteHistory(value) {
+  if (value === undefined)
+    return [];
+  if (!Array.isArray(value) || !value.every(isObject))
+    throw new CrmStorageError;
+  return value;
+}
+function profileSearchFields(profile) {
+  const values = [
+    profile.recordType,
+    profile.externalId,
+    profile.status,
+    profile.name,
+    profile.domain,
+    profile.website,
+    profile.source,
+    profile.email,
+    profile.firstName,
+    profile.lastName,
+    profile.title,
+    profile.companyExternalId
+  ];
+  return values.filter((value) => typeof value === "string");
+}
+function indexCandidate(item, partition) {
+  const key = recordCursorKey(recordsCursorProjection(item), partition);
+  if (typeof key.gsi1sk !== "string")
+    throw new CrmStorageError;
+  const match = /^PROFILE#(company|contact)#(.+)$/.exec(key.gsi1sk);
+  const recordType = item.recordType;
+  const recordId = item.recordId;
+  if (match === null || recordType !== "company" && recordType !== "contact" || typeof recordId !== "string" || match[1] !== recordType || match[2] !== recordId) {
+    throw new CrmStorageError;
+  }
+  return { recordType, recordId };
+}
+function profileMatchesSearch(profile, args, searchText) {
+  if (searchText !== undefined && searchText !== "" && !normalizedText(profileSearchFields(profile)).includes(searchText)) {
+    return false;
+  }
+  if (args.statuses !== undefined && !args.statuses.includes(profile.status))
+    return false;
+  if (args.hasEmail !== undefined && args.hasEmail !== (profile.email !== undefined))
+    return false;
+  return true;
+}
+function normalizedText(values) {
+  return values.join(" ").normalize("NFKD").replace(/\p{M}/gu, "").toLowerCase().replace(/\s+/g, " ").trim();
+}
+function boundedSearchResponse(items, records, finalCursor, partition) {
+  const minimum = records.length === 0 ? 0 : 1;
+  for (let count = records.length;count >= minimum; count -= 1) {
+    const cursor = count < records.length ? encodeRecordsCursor(recordsCursorProjection(items[count - 1]), partition) : finalCursor;
+    const candidate = {
+      records: records.slice(0, count),
+      ...cursor === undefined ? {} : { cursor }
+    };
+    if (crmResponseFitsBudget(candidate)) {
+      return parseCrmSearchResponse(candidate);
+    }
+  }
+  throw new CrmStorageError;
+}
+function boundedGetResponse(profile, items, activities, finalCursor, partition, prefix) {
+  const minimum = activities.length === 0 ? 0 : 1;
+  for (let count = activities.length;count >= minimum; count -= 1) {
+    const cursor = count < activities.length ? encodeActivityCursor(activityCursorProjection(items[count - 1]), partition, prefix) : finalCursor;
+    const candidate = {
+      profile,
+      activities: activities.slice(0, count),
+      ...cursor === undefined ? {} : { cursor }
+    };
+    if (crmResponseFitsBudget(candidate)) {
+      return parseCrmGetRecordResponse(candidate);
+    }
+  }
+  throw new CrmStorageError;
+}
+function boundedLimit(value, maximum, field, defaultValue = maximum) {
+  const result = value ?? defaultValue;
+  if (!Number.isInteger(result) || result < 1 || result > maximum) {
+    throw new CrmInputError(`${field} must be an integer between 1 and ${maximum}`);
+  }
+  return result;
+}
+function sameActor(left, right) {
+  return left.teamId === right.teamId && left.userId === right.userId && left.channelId === right.channelId && left.sessionKey === right.sessionKey;
+}
+function copyActor(actor) {
+  return {
+    teamId: actor.teamId,
+    userId: actor.userId,
+    channelId: actor.channelId,
+    sessionKey: actor.sessionKey
+  };
+}
+function storedActor(value) {
+  if (!isObject(value))
+    throw new CrmStorageError;
+  for (const field of ["teamId", "userId", "channelId", "sessionKey"]) {
+    if (typeof value[field] !== "string" || value[field].length === 0) {
+      throw new CrmStorageError;
+    }
+  }
+  return {
+    teamId: value.teamId,
+    userId: value.userId,
+    channelId: value.channelId,
+    sessionKey: value.sessionKey
+  };
+}
+function copyAttributes(attributes) {
+  const output = {};
+  for (const [key, value] of Object.entries(attributes)) {
+    Object.defineProperty(output, key, {
+      value,
+      enumerable: true,
+      configurable: false,
+      writable: false
+    });
+  }
+  return output;
+}
+function storedAttributes(value) {
+  if (!isObject(value))
+    return;
+  const output = {};
+  for (const [key, candidate] of Object.entries(value)) {
+    if (candidate !== null && typeof candidate !== "string" && typeof candidate !== "number" && typeof candidate !== "boolean") {
+      throw new CrmStorageError;
+    }
+    Object.defineProperty(output, key, {
+      value: candidate,
+      enumerable: true,
+      configurable: false,
+      writable: false
+    });
+  }
+  return output;
+}
+function completedResult(item, operation) {
+  const result = parseCrmOperationAck(item.result);
+  if (result.operation !== operation)
+    throw new CrmStorageError;
+  return result;
+}
+function recordsCursorProjection(item) {
+  return { pk: item.pk, sk: item.sk, gsi1pk: item.gsi1pk, gsi1sk: item.gsi1sk };
+}
+function activityCursorProjection(item) {
+  return { pk: item.pk, sk: item.sk };
+}
+function encodeRecordsCursor(key, partition) {
+  const valid = recordCursorKey(key, partition);
+  return encodeCursor("records", valid);
+}
+function decodeRecordsCursor(cursor, partition) {
+  return recordCursorKey(decodeCursor(cursor, "records"), partition);
+}
+function recordCursorKey(key, partition) {
+  if (!hasExactKeys(key, ["pk", "sk", "gsi1pk", "gsi1sk"]))
+    throw new CrmInputError("cursor is invalid");
+  if (typeof key.pk !== "string" || typeof key.sk !== "string" || typeof key.gsi1pk !== "string" || typeof key.gsi1sk !== "string" || key.gsi1pk !== partition || key.sk !== PROFILE_SK) {
+    throw new CrmInputError("cursor is invalid");
+  }
+  const match = /^PROFILE#(company|contact)#(.+)$/.exec(key.gsi1sk);
+  if (match === null || match[1] === undefined || match[2] === undefined) {
+    throw new CrmInputError("cursor is invalid");
+  }
+  if (key.pk !== `${partition.replace(/#RECORDS$/, "")}#RECORD#${match[1]}#${match[2]}`) {
+    throw new CrmInputError("cursor is invalid");
+  }
+  return { pk: key.pk, sk: key.sk, gsi1pk: key.gsi1pk, gsi1sk: key.gsi1sk };
+}
+function encodeActivityCursor(key, partition, prefix) {
+  const valid = activityCursorKey(key, partition, prefix);
+  return encodeCursor("activities", valid);
+}
+function decodeActivityCursor(cursor, partition, prefix) {
+  return activityCursorKey(decodeCursor(cursor, "activities"), partition, prefix);
+}
+function activityCursorKey(key, partition, prefix) {
+  if (!hasExactKeys(key, ["pk", "sk"]))
+    throw new CrmInputError("cursor is invalid");
+  if (typeof key.pk !== "string" || typeof key.sk !== "string" || key.pk !== partition || !key.sk.startsWith(prefix)) {
+    throw new CrmInputError("cursor is invalid");
+  }
+  return { pk: key.pk, sk: key.sk };
+}
+function encodeCursor(scope, key) {
+  const encoded = Buffer.from(JSON.stringify({ v: 1, scope, key })).toString("base64url");
+  if (encoded.length > CRM_MAX_CURSOR_CHARS)
+    throw new CrmStorageError;
+  return encoded;
+}
+function decodeCursor(cursor, scope) {
+  if (typeof cursor !== "string" || cursor.length === 0 || cursor.length > CRM_MAX_CURSOR_CHARS || !/^[A-Za-z0-9_-]+$/.test(cursor)) {
+    throw new CrmInputError("cursor is invalid");
+  }
+  let parsed;
+  try {
+    const decoded = Buffer.from(cursor, "base64url");
+    if (decoded.length === 0 || decoded.length > CRM_MAX_CURSOR_CHARS) {
+      throw new CrmInputError("cursor is invalid");
+    }
+    if (decoded.toString("base64url") !== cursor)
+      throw new CrmInputError("cursor is invalid");
+    parsed = JSON.parse(decoded.toString("utf8"));
+  } catch (error) {
+    if (error instanceof CrmInputError)
+      throw error;
+    throw new CrmInputError("cursor is invalid");
+  }
+  if (!isObject(parsed) || !hasExactKeys(parsed, ["v", "scope", "key"])) {
+    throw new CrmInputError("cursor is invalid");
+  }
+  if (parsed.v !== 1 || parsed.scope !== scope || !isObject(parsed.key)) {
+    throw new CrmInputError("cursor is invalid");
+  }
+  return Object.fromEntries(Object.entries(parsed.key));
+}
+function hasExactKeys(value, expected) {
+  const keys = Object.keys(value).sort();
+  if (keys.length !== expected.length)
+    return false;
+  const sortedExpected = [...expected].sort();
+  return keys.every((key, index) => key === sortedExpected[index]);
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isConditionalFailure(error) {
+  if (typeof error !== "object" || error === null || !("name" in error))
+    return false;
+  const name = error.name;
+  return name === "ConditionalCheckFailedException" || name === "TransactionCanceledException";
+}
+export {
+  CrmIdempotencyConflictError,
+  CrmOutreachUnconfiguredError,
+  CrmRecordNotFoundError,
+  CrmStorageError,
+  DynamoCrmClient,
+  createDynamoCrmClient,
+  deterministicRecordId
+};