@deployfoundation/foundation-deploy 0.2.51 → 0.2.52

package/dist/chunk-3614v9rr.js

@@ -0,0 +1,907 @@
+import {
+  wrapUntrusted
+} from "./chunk-96fjaysn.js";
+
+// ../connectors/src/crm.ts
+var CRM_MAX_BATCH_SIZE = 100;
+var CRM_MAX_REQUEST_BYTES = 512 * 1024;
+var CRM_MAX_RESPONSE_BYTES = 512 * 1024;
+var CRM_MAX_ID_CHARS = 256;
+var CRM_MAX_IDEMPOTENCY_KEY_CHARS = 256;
+var CRM_MAX_NAME_CHARS = 512;
+var CRM_MAX_DOMAIN_CHARS = 253;
+var CRM_MAX_WEBSITE_CHARS = 2048;
+var CRM_MAX_SOURCE_CHARS = 128;
+var CRM_MAX_EMAIL_CHARS = 320;
+var CRM_MAX_PERSON_FIELD_CHARS = 256;
+var CRM_MAX_STATUS_CHARS = 128;
+var CRM_MAX_ACTIVITY_TYPE_CHARS = 128;
+var CRM_MAX_SUMMARY_CHARS = 4000;
+var CRM_MAX_CURSOR_CHARS = 8192;
+var CRM_MAX_SEARCH_LIMIT = 100;
+var CRM_MAX_ACTIVITY_PAGE_SIZE = 100;
+var CRM_MAX_CONFIG_VALUES = 100;
+var CRM_MAX_ATTRIBUTE_COUNT = 50;
+var CRM_MAX_ATTRIBUTE_KEY_CHARS = 64;
+var CRM_MAX_ATTRIBUTE_STRING_CHARS = 1024;
+var CRM_MAX_TIMESTAMP_CHARS = 64;
+var CRM_MAX_OUTREACH_QUEUE_ITEMS = 25;
+var CRM_MAX_TIMEZONE_CHARS = 64;
+var CRM_MAX_OUTREACH_CANDIDATES_PAGE = 200;
+var CRM_MAX_VERSION = 1e9;
+var CONTROL_CHARS = /[\u0000-\u001f\u007f]/;
+var SIMPLE_EMAIL = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var ISO_TIMESTAMP = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d{1,3})?(Z|[+-]\d{2}:\d{2})$/;
+var CRM_STATUS_SETTERS = ["agent", "person", "system"];
+var CRM_NOTE_ACTIVITY = "note";
+var CRM_ACTIVITY_AUTHOR_ATTRIBUTE = "by";
+var CRM_OUTREACH_DRAFTED_ACTIVITY = "email_drafted";
+var CRM_OUTREACH_SENT_ACTIVITY = "email_sent";
+var CRM_OUTREACH_REPLY_ACTIVITY = "reply_received";
+var CRM_REFUSAL_REASONS = [
+  "weekly_limit_reached",
+  "follow_up_limit_reached",
+  "already_contacted",
+  "not_contacted",
+  "max_follow_ups_reached",
+  "suppressed",
+  "status_locked",
+  "transition_not_allowed"
+];
+var CRM_PROVIDER_OPERATIONS = [
+  "search",
+  "get_record",
+  "get_activity",
+  "upsert_records",
+  "update_status",
+  "log_activity",
+  "update_note",
+  "outreach_state",
+  "outreach_candidates",
+  "delete_record"
+];
+var CRM_REQUIRED_PROVIDER_OPERATIONS = [
+  "search",
+  "get_record",
+  "upsert_records",
+  "update_status",
+  "log_activity"
+];
+
+class CrmInputError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CrmInputError";
+  }
+}
+
+class CrmResponseError extends Error {
+  constructor() {
+    super("CRM response did not match the bounded contract");
+    this.name = "CrmResponseError";
+  }
+}
+function crmResponseFitsBudget(value) {
+  try {
+    const serialized = JSON.stringify(value);
+    if (Buffer.byteLength(JSON.stringify({ ok: true, result: value }), "utf8") > CRM_MAX_RESPONSE_BYTES) {
+      return false;
+    }
+    return Buffer.byteLength(wrapUntrusted("CRM data", serialized), "utf8") <= CRM_MAX_RESPONSE_BYTES;
+  } catch {
+    return false;
+  }
+}
+function parseCrmUpsertRecordsArgs(value, maxBatchSize = CRM_MAX_BATCH_SIZE) {
+  const input = inputObject(value, "upsert request");
+  assertAllowedFields(input, ["idempotencyKey", "companies", "contacts"], "upsert request");
+  const batchSize = validateBatchSize(maxBatchSize);
+  const idempotencyKey = parseIdempotencyKey(input.idempotencyKey);
+  const companies = input.companies === undefined ? [] : parseRecordArray(input.companies, "companies", parseCompany);
+  const contacts = input.contacts === undefined ? [] : parseRecordArray(input.contacts, "contacts", parseContact);
+  const count = companies.length + contacts.length;
+  if (count === 0)
+    throw new CrmInputError("upsert request must contain at least one record");
+  if (count > batchSize)
+    throw new CrmInputError(`upsert request may contain at most ${batchSize} records`);
+  assertDistinctExternalIds(companies, "companies");
+  assertDistinctExternalIds(contacts, "contacts");
+  const result = {
+    idempotencyKey,
+    ...companies.length === 0 ? {} : { companies },
+    ...contacts.length === 0 ? {} : { contacts }
+  };
+  assertRequestSize(result);
+  return result;
+}
+function parseCrmSearchResponse(value) {
+  try {
+    const input = inputObject(value, "search response");
+    assertAllowedFields(input, ["records", "cursor"], "search response");
+    if (!Array.isArray(input.records) || input.records.length > CRM_MAX_SEARCH_LIMIT) {
+      throw new CrmInputError(`search response records must be an array of at most ${CRM_MAX_SEARCH_LIMIT} records`);
+    }
+    const records = input.records.map(parseSearchRecord);
+    const cursor = optionalText(input.cursor, "search response cursor", CRM_MAX_CURSOR_CHARS);
+    const response = {
+      records,
+      ...cursor === undefined ? {} : { cursor }
+    };
+    if (!crmResponseFitsBudget(response)) {
+      throw new CrmInputError(`CRM response may not exceed ${CRM_MAX_RESPONSE_BYTES} bytes`);
+    }
+    return response;
+  } catch {
+    throw new CrmResponseError;
+  }
+}
+function parseCrmGetRecordResponse(value) {
+  try {
+    const input = inputObject(value, "get record response");
+    assertAllowedFields(input, ["profile", "activities", "cursor"], "get record response");
+    if (!Array.isArray(input.activities) || input.activities.length > CRM_MAX_ACTIVITY_PAGE_SIZE) {
+      throw new CrmInputError(`get record response activities must be an array of at most ${CRM_MAX_ACTIVITY_PAGE_SIZE} activities`);
+    }
+    const profile = parseRecordProfile(input.profile);
+    const activities = input.activities.map(parseActivity);
+    const cursor = optionalText(input.cursor, "get record response cursor", CRM_MAX_CURSOR_CHARS);
+    const response = {
+      profile,
+      activities,
+      ...cursor === undefined ? {} : { cursor }
+    };
+    if (!crmResponseFitsBudget(response)) {
+      throw new CrmInputError(`CRM response may not exceed ${CRM_MAX_RESPONSE_BYTES} bytes`);
+    }
+    return response;
+  } catch {
+    throw new CrmResponseError;
+  }
+}
+function parseCrmOutreachQueueResponse(value) {
+  try {
+    const input = inputObject(value, "outreach queue response");
+    assertAllowedFields(input, [
+      "weekStart",
+      "timezone",
+      "weeklyLimit",
+      "newDraftedThisWeek",
+      "remaining",
+      "followUpLimit",
+      "followUpsDraftedThisWeek",
+      "followUpsRemaining",
+      "followUps",
+      "newLeads",
+      "truncated"
+    ], "outreach queue response");
+    const weekStart = requiredText(input.weekStart, "weekStart", 10);
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(weekStart))
+      throw new CrmInputError("weekStart is invalid");
+    if (!Array.isArray(input.followUps) || input.followUps.length > CRM_MAX_OUTREACH_QUEUE_ITEMS || !Array.isArray(input.newLeads) || input.newLeads.length > CRM_MAX_OUTREACH_QUEUE_ITEMS) {
+      throw new CrmInputError("outreach queue lists are bounded");
+    }
+    if (input.truncated !== undefined && input.truncated !== true) {
+      throw new CrmInputError("truncated must be true when present");
+    }
+    const response = {
+      weekStart,
+      timezone: requiredText(input.timezone, "timezone", CRM_MAX_TIMEZONE_CHARS),
+      weeklyLimit: count(input.weeklyLimit, "weeklyLimit"),
+      newDraftedThisWeek: count(input.newDraftedThisWeek, "newDraftedThisWeek"),
+      remaining: count(input.remaining, "remaining"),
+      followUpLimit: count(input.followUpLimit, "followUpLimit"),
+      followUpsDraftedThisWeek: count(input.followUpsDraftedThisWeek, "followUpsDraftedThisWeek"),
+      followUpsRemaining: count(input.followUpsRemaining, "followUpsRemaining"),
+      followUps: input.followUps.map(parseOutreachFollowUp),
+      newLeads: input.newLeads.map(parseOutreachNewLead),
+      ...input.truncated === true ? { truncated: true } : {}
+    };
+    if (!crmResponseFitsBudget(response)) {
+      throw new CrmInputError(`CRM response may not exceed ${CRM_MAX_RESPONSE_BYTES} bytes`);
+    }
+    return response;
+  } catch {
+    throw new CrmResponseError;
+  }
+}
+var OUTREACH_CONTACT_FIELDS = [
+  "contactId",
+  "email",
+  "status",
+  "firstName",
+  "lastName",
+  "title",
+  "companyExternalId",
+  "companyId",
+  "company"
+];
+function parseOutreachContact(input) {
+  const contact = {
+    contactId: requiredText(input.contactId, "contactId", CRM_MAX_ID_CHARS),
+    email: email(input.email),
+    status: requiredText(input.status, "status", CRM_MAX_STATUS_CHARS)
+  };
+  for (const [field, maximum] of [
+    ["firstName", CRM_MAX_PERSON_FIELD_CHARS],
+    ["lastName", CRM_MAX_PERSON_FIELD_CHARS],
+    ["title", CRM_MAX_PERSON_FIELD_CHARS],
+    ["companyExternalId", CRM_MAX_ID_CHARS],
+    ["companyId", CRM_MAX_ID_CHARS],
+    ["company", CRM_MAX_NAME_CHARS]
+  ]) {
+    const text = optionalText(input[field], field, maximum);
+    if (text !== undefined)
+      contact[field] = text;
+  }
+  return contact;
+}
+function parseOutreachFollowUp(value) {
+  const input = inputObject(value, "outreach follow-up");
+  assertAllowedFields(input, [...OUTREACH_CONTACT_FIELDS, "lastTouchAt", "followUpNumber", "threadId"], "outreach follow-up");
+  const threadId = optionalText(input.threadId, "threadId", CRM_MAX_ATTRIBUTE_STRING_CHARS);
+  return {
+    ...parseOutreachContact(input),
+    lastTouchAt: parseCrmTimestamp(input.lastTouchAt, "lastTouchAt"),
+    followUpNumber: positiveInteger(input.followUpNumber, "followUpNumber", 10),
+    ...threadId === undefined ? {} : { threadId }
+  };
+}
+function parseOutreachNewLead(value) {
+  const input = inputObject(value, "outreach new lead");
+  assertAllowedFields(input, [...OUTREACH_CONTACT_FIELDS, "rank"], "outreach new lead");
+  const rank = input.rank;
+  if (rank !== undefined && (typeof rank !== "number" || !Number.isFinite(rank))) {
+    throw new CrmInputError("rank must be a finite number");
+  }
+  return {
+    ...parseOutreachContact(input),
+    ...rank === undefined ? {} : { rank }
+  };
+}
+function count(value, field) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0 || value > 1e6) {
+    throw new CrmInputError(`${field} must be a non-negative integer`);
+  }
+  return value;
+}
+function parseCrmOperationAck(value) {
+  try {
+    const input = inputObject(value, "operation acknowledgement");
+    if (input.accepted !== true)
+      throw new CrmInputError("operation acknowledgement must be accepted");
+    switch (operation(input.operation)) {
+      case "upsert_records": {
+        assertAllowedFields(input, ["accepted", "operation", "records"], "operation acknowledgement");
+        return {
+          accepted: true,
+          operation: "upsert_records",
+          records: positiveInteger(input.records, "records", CRM_MAX_BATCH_SIZE)
+        };
+      }
+      case "update_status": {
+        assertAllowedFields(input, ["accepted", "operation", "recordType", "recordId", "status"], "operation acknowledgement");
+        return {
+          accepted: true,
+          operation: "update_status",
+          recordType: recordType(input.recordType),
+          recordId: requiredText(input.recordId, "recordId", CRM_MAX_ID_CHARS),
+          status: requiredText(input.status, "status", CRM_MAX_STATUS_CHARS)
+        };
+      }
+      case "log_activity": {
+        assertAllowedFields(input, ["accepted", "operation", "recordType", "recordId", "activityType"], "operation acknowledgement");
+        return {
+          accepted: true,
+          operation: "log_activity",
+          recordType: recordType(input.recordType),
+          recordId: requiredText(input.recordId, "recordId", CRM_MAX_ID_CHARS),
+          activityType: requiredText(input.activityType, "activityType", CRM_MAX_ACTIVITY_TYPE_CHARS)
+        };
+      }
+      case "update_note": {
+        assertAllowedFields(input, ["accepted", "operation", "recordType", "recordId", "activityId", "version"], "operation acknowledgement");
+        return {
+          accepted: true,
+          operation: "update_note",
+          recordType: recordType(input.recordType),
+          recordId: requiredText(input.recordId, "recordId", CRM_MAX_ID_CHARS),
+          activityId: requiredText(input.activityId, "activityId", CRM_MAX_ID_CHARS),
+          version: positiveInteger(input.version, "version", CRM_MAX_VERSION)
+        };
+      }
+      case "delete_record": {
+        assertAllowedFields(input, ["accepted", "operation", "recordType", "recordId"], "operation acknowledgement");
+        return {
+          accepted: true,
+          operation: "delete_record",
+          recordType: recordType(input.recordType),
+          recordId: requiredText(input.recordId, "recordId", CRM_MAX_ID_CHARS)
+        };
+      }
+    }
+  } catch {
+    throw new CrmResponseError;
+  }
+}
+function parseCrmUpdateStatusArgs(value) {
+  const input = inputObject(value, "status update request");
+  assertAllowedFields(input, ["recordType", "recordId", "status", "idempotencyKey"], "status update request");
+  return {
+    recordType: recordType(input.recordType),
+    recordId: requiredText(input.recordId, "recordId", CRM_MAX_ID_CHARS),
+    status: requiredText(input.status, "status", CRM_MAX_STATUS_CHARS),
+    idempotencyKey: parseIdempotencyKey(input.idempotencyKey)
+  };
+}
+function parseCrmLogActivityArgs(value) {
+  const input = inputObject(value, "activity request");
+  assertAllowedFields(input, [
+    "recordType",
+    "recordId",
+    "activityType",
+    "summary",
+    "occurredAt",
+    "attributes",
+    "idempotencyKey"
+  ], "activity request");
+  const result = {
+    recordType: recordType(input.recordType),
+    recordId: requiredText(input.recordId, "recordId", CRM_MAX_ID_CHARS),
+    activityType: requiredText(input.activityType, "activityType", CRM_MAX_ACTIVITY_TYPE_CHARS),
+    summary: requiredText(input.summary, "summary", CRM_MAX_SUMMARY_CHARS),
+    idempotencyKey: parseIdempotencyKey(input.idempotencyKey)
+  };
+  if (input.occurredAt !== undefined)
+    result.occurredAt = parseCrmTimestamp(input.occurredAt, "occurredAt");
+  const attributes = parseAttributes(input.attributes);
+  if (attributes !== undefined && Object.hasOwn(attributes, CRM_ACTIVITY_AUTHOR_ATTRIBUTE)) {
+    throw new CrmInputError("attributes.by is set by the CRM, not the caller");
+  }
+  if (attributes !== undefined)
+    result.attributes = attributes;
+  return result;
+}
+function parseCrmGetActivityResponse(value) {
+  try {
+    const input = inputObject(value, "get activity response");
+    assertAllowedFields(input, ["activity"], "get activity response");
+    return parseActivity(input.activity);
+  } catch {
+    throw new CrmResponseError;
+  }
+}
+function parseCrmOutreachState(value) {
+  try {
+    const input = inputObject(value, "outreach state");
+    assertAllowedFields(input, [
+      "contactId",
+      "status",
+      "statusSetBy",
+      "doNotContact",
+      "companyId",
+      "companyStatus",
+      "companyLastTouchAt",
+      "touch"
+    ], "outreach state");
+    if (typeof input.doNotContact !== "boolean") {
+      throw new CrmInputError("doNotContact must be a boolean");
+    }
+    const state = {
+      contactId: requiredText(input.contactId, "contactId", CRM_MAX_ID_CHARS),
+      status: requiredText(input.status, "status", CRM_MAX_STATUS_CHARS),
+      doNotContact: input.doNotContact,
+      touch: parseTouchSummary(input.touch)
+    };
+    if (input.statusSetBy !== undefined)
+      state.statusSetBy = statusSetter(input.statusSetBy);
+    const companyId = optionalText(input.companyId, "companyId", CRM_MAX_ID_CHARS);
+    if (companyId !== undefined)
+      state.companyId = companyId;
+    const companyStatus = optionalText(input.companyStatus, "companyStatus", CRM_MAX_STATUS_CHARS);
+    if (companyStatus !== undefined)
+      state.companyStatus = companyStatus;
+    if (input.companyLastTouchAt !== undefined) {
+      state.companyLastTouchAt = parseCrmTimestamp(input.companyLastTouchAt, "companyLastTouchAt");
+    }
+    return state;
+  } catch {
+    throw new CrmResponseError;
+  }
+}
+function parseCrmOutreachCandidatesResponse(value) {
+  try {
+    const input = inputObject(value, "outreach candidates response");
+    assertAllowedFields(input, ["candidates", "companies", "cursor"], "outreach candidates response");
+    if (!Array.isArray(input.candidates) || input.candidates.length > CRM_MAX_OUTREACH_CANDIDATES_PAGE || !Array.isArray(input.companies) || input.companies.length > CRM_MAX_OUTREACH_CANDIDATES_PAGE) {
+      throw new CrmInputError("outreach candidate lists are bounded");
+    }
+    const cursor = optionalText(input.cursor, "cursor", CRM_MAX_CURSOR_CHARS);
+    return {
+      candidates: input.candidates.map(parseOutreachCandidate),
+      companies: input.companies.map((entry) => {
+        const company = inputObject(entry, "candidate company");
+        assertAllowedFields(company, ["companyId", "lastTouchAt"], "candidate company");
+        return {
+          companyId: requiredText(company.companyId, "companyId", CRM_MAX_ID_CHARS),
+          ...company.lastTouchAt === undefined ? {} : { lastTouchAt: parseCrmTimestamp(company.lastTouchAt, "lastTouchAt") }
+        };
+      }),
+      ...cursor === undefined ? {} : { cursor }
+    };
+  } catch {
+    throw new CrmResponseError;
+  }
+}
+function parseCrmProviderMeta(value) {
+  try {
+    const input = inputObject(value, "provider meta");
+    assertAllowedFields(input, [
+      "contract",
+      "tenant",
+      "principal",
+      "statuses",
+      "activityTypes",
+      "operations",
+      "maxBatchSize",
+      "policy"
+    ], "provider meta");
+    const contract = requiredText(input.contract, "contract", 32);
+    if (!/^crm\/\d{1,4}$/.test(contract))
+      throw new CrmInputError("contract is invalid");
+    const tenantInput = inputObject(input.tenant, "tenant");
+    assertAllowedFields(tenantInput, ["id", "name"], "tenant");
+    const tenantName = optionalText(tenantInput.name, "tenant name", CRM_MAX_NAME_CHARS);
+    const statusesInput = inputObject(input.statuses, "statuses");
+    assertAllowedFields(statusesInput, ["company", "contact"], "statuses");
+    const operations = parseStringArray(input.operations, "operations", CRM_PROVIDER_OPERATIONS.length, 32);
+    for (const name of operations) {
+      if (!CRM_PROVIDER_OPERATIONS.includes(name)) {
+        throw new CrmInputError("operations names an unknown operation");
+      }
+    }
+    const principal = optionalText(input.principal, "principal", CRM_MAX_NAME_CHARS);
+    const meta = {
+      contract,
+      tenant: {
+        id: requiredText(tenantInput.id, "tenant id", CRM_MAX_ID_CHARS),
+        ...tenantName === undefined ? {} : { name: tenantName }
+      },
+      ...principal === undefined ? {} : { principal },
+      statuses: {
+        company: parseStringArray(statusesInput.company, "company statuses", CRM_MAX_CONFIG_VALUES, CRM_MAX_STATUS_CHARS),
+        contact: parseStringArray(statusesInput.contact, "contact statuses", CRM_MAX_CONFIG_VALUES, CRM_MAX_STATUS_CHARS)
+      },
+      activityTypes: parseStringArray(input.activityTypes, "activityTypes", CRM_MAX_CONFIG_VALUES, CRM_MAX_ACTIVITY_TYPE_CHARS),
+      operations,
+      maxBatchSize: positiveInteger(input.maxBatchSize, "maxBatchSize", 1e4)
+    };
+    if (input.policy !== undefined)
+      meta.policy = parseProviderPolicy(input.policy);
+    return meta;
+  } catch {
+    throw new CrmResponseError;
+  }
+}
+function parseProviderPolicy(value) {
+  const input = inputObject(value, "provider policy");
+  assertAllowedFields(input, ["firstTouchWeeklyLimit", "followUpWeeklyLimit", "maxFollowUps", "timezone", "personSet"], "provider policy");
+  const policy = {};
+  for (const field of ["firstTouchWeeklyLimit", "followUpWeeklyLimit", "maxFollowUps"]) {
+    if (input[field] !== undefined)
+      policy[field] = count(input[field], field);
+  }
+  const timezone = optionalText(input.timezone, "timezone", CRM_MAX_TIMEZONE_CHARS);
+  if (timezone !== undefined)
+    policy.timezone = timezone;
+  if (input.personSet !== undefined) {
+    if (input.personSet !== "lock" && input.personSet !== "advance") {
+      throw new CrmInputError("personSet must be lock or advance");
+    }
+    policy.personSet = input.personSet;
+  }
+  return policy;
+}
+function parseTouchSummary(value) {
+  const input = inputObject(value, "touch");
+  assertAllowedFields(input, ["firstTouchAt", "lastTouchAt", "lastReplyAt", "followUps", "lastThreadId", "lastDraftId"], "touch");
+  const touch = { followUps: count(input.followUps, "followUps") };
+  for (const field of ["firstTouchAt", "lastTouchAt", "lastReplyAt"]) {
+    if (input[field] !== undefined)
+      touch[field] = parseCrmTimestamp(input[field], field);
+  }
+  for (const field of ["lastThreadId", "lastDraftId"]) {
+    const text = optionalText(input[field], field, CRM_MAX_ATTRIBUTE_STRING_CHARS);
+    if (text !== undefined)
+      touch[field] = text;
+  }
+  return touch;
+}
+function parseOutreachCandidate(value) {
+  const input = inputObject(value, "outreach candidate");
+  assertAllowedFields(input, [
+    "contactId",
+    "email",
+    "status",
+    "doNotContact",
+    "firstName",
+    "lastName",
+    "title",
+    "companyId",
+    "companyExternalId",
+    "company",
+    "companyStatus",
+    "rank",
+    "createdAt",
+    "touch"
+  ], "outreach candidate");
+  if (typeof input.doNotContact !== "boolean") {
+    throw new CrmInputError("doNotContact must be a boolean");
+  }
+  const candidate = {
+    contactId: requiredText(input.contactId, "contactId", CRM_MAX_ID_CHARS),
+    email: email(input.email),
+    status: requiredText(input.status, "status", CRM_MAX_STATUS_CHARS),
+    doNotContact: input.doNotContact,
+    touch: parseTouchSummary(input.touch)
+  };
+  for (const [field, maximum] of [
+    ["firstName", CRM_MAX_PERSON_FIELD_CHARS],
+    ["lastName", CRM_MAX_PERSON_FIELD_CHARS],
+    ["title", CRM_MAX_PERSON_FIELD_CHARS],
+    ["companyId", CRM_MAX_ID_CHARS],
+    ["companyExternalId", CRM_MAX_ID_CHARS],
+    ["company", CRM_MAX_NAME_CHARS],
+    ["companyStatus", CRM_MAX_STATUS_CHARS]
+  ]) {
+    const text = optionalText(input[field], field, maximum);
+    if (text !== undefined)
+      candidate[field] = text;
+  }
+  if (input.rank !== undefined) {
+    if (typeof input.rank !== "number" || !Number.isFinite(input.rank)) {
+      throw new CrmInputError("rank must be a finite number");
+    }
+    candidate.rank = input.rank;
+  }
+  if (input.createdAt !== undefined) {
+    candidate.createdAt = parseCrmTimestamp(input.createdAt, "createdAt");
+  }
+  return candidate;
+}
+function statusSetter(value) {
+  if (!CRM_STATUS_SETTERS.includes(value)) {
+    throw new CrmInputError("statusSetBy must be agent, person or system");
+  }
+  return value;
+}
+function isCrmIdempotencyKey(value) {
+  return typeof value === "string" && value.length <= CRM_MAX_IDEMPOTENCY_KEY_CHARS && /^[\x21-\x7e](?:[\x20-\x7e]*[\x21-\x7e])?$/.test(value);
+}
+function parseIdempotencyKey(value) {
+  if (!isCrmIdempotencyKey(value)) {
+    throw new CrmInputError(`idempotencyKey must be printable ASCII (letters, digits, punctuation; no accents), at most ${CRM_MAX_IDEMPOTENCY_KEY_CHARS} characters`);
+  }
+  return value;
+}
+function inputObject(value, label) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new CrmInputError(`${label} must be an object`);
+  }
+  return Object.fromEntries(Object.entries(value));
+}
+function assertAllowedFields(input, fields, label) {
+  for (const key of Object.keys(input)) {
+    if (!fields.includes(key))
+      throw new CrmInputError(`${label} contains an unsupported field`);
+  }
+}
+function requiredText(value, field, max) {
+  if (typeof value !== "string" || value.length === 0 || value.length > max || value.trim() === "" || CONTROL_CHARS.test(value)) {
+    throw new CrmInputError(`${field} must be a non-empty string of at most ${max} characters`);
+  }
+  return value;
+}
+function optionalText(value, field, max) {
+  if (value === undefined)
+    return;
+  return requiredText(value, field, max);
+}
+function positiveInteger(value, field, max) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 1 || value > max) {
+    throw new CrmInputError(`${field} must be an integer between 1 and ${max}`);
+  }
+  return value;
+}
+function parseRecordArray(value, field, parse) {
+  if (!Array.isArray(value))
+    throw new CrmInputError(`${field} must be an array`);
+  if (value.length > CRM_MAX_BATCH_SIZE)
+    throw new CrmInputError(`${field} may contain at most ${CRM_MAX_BATCH_SIZE} records`);
+  return value.map(parse);
+}
+function parseCompany(value) {
+  const input = inputObject(value, "company");
+  assertAllowedFields(input, ["externalId", "name", "domain", "website", "source", "attributes"], "company");
+  const company = {
+    externalId: requiredText(input.externalId, "company externalId", CRM_MAX_ID_CHARS),
+    name: requiredText(input.name, "company name", CRM_MAX_NAME_CHARS)
+  };
+  const domain = optionalText(input.domain, "company domain", CRM_MAX_DOMAIN_CHARS);
+  if (domain !== undefined)
+    company.domain = domain;
+  const website = optionalText(input.website, "company website", CRM_MAX_WEBSITE_CHARS);
+  if (website !== undefined)
+    company.website = website;
+  const source = optionalText(input.source, "company source", CRM_MAX_SOURCE_CHARS);
+  if (source !== undefined)
+    company.source = source;
+  const attributes = parseAttributes(input.attributes);
+  if (attributes !== undefined)
+    company.attributes = attributes;
+  return company;
+}
+function parseContact(value) {
+  const input = inputObject(value, "contact");
+  assertAllowedFields(input, [
+    "externalId",
+    "email",
+    "firstName",
+    "lastName",
+    "title",
+    "companyExternalId",
+    "source",
+    "attributes"
+  ], "contact");
+  const contact = {
+    externalId: requiredText(input.externalId, "contact externalId", CRM_MAX_ID_CHARS)
+  };
+  if (input.email !== undefined)
+    contact.email = email(input.email);
+  const firstName = optionalText(input.firstName, "contact firstName", CRM_MAX_PERSON_FIELD_CHARS);
+  if (firstName !== undefined)
+    contact.firstName = firstName;
+  const lastName = optionalText(input.lastName, "contact lastName", CRM_MAX_PERSON_FIELD_CHARS);
+  if (lastName !== undefined)
+    contact.lastName = lastName;
+  const title = optionalText(input.title, "contact title", CRM_MAX_PERSON_FIELD_CHARS);
+  if (title !== undefined)
+    contact.title = title;
+  const companyExternalId = optionalText(input.companyExternalId, "contact companyExternalId", CRM_MAX_ID_CHARS);
+  if (companyExternalId !== undefined)
+    contact.companyExternalId = companyExternalId;
+  const source = optionalText(input.source, "contact source", CRM_MAX_SOURCE_CHARS);
+  if (source !== undefined)
+    contact.source = source;
+  const attributes = parseAttributes(input.attributes);
+  if (attributes !== undefined)
+    contact.attributes = attributes;
+  return contact;
+}
+function parseSearchRecord(value) {
+  const input = inputObject(value, "search record");
+  assertAllowedFields(input, [
+    "recordType",
+    "id",
+    "externalId",
+    "status",
+    "name",
+    "domain",
+    "website",
+    "source",
+    "email",
+    "firstName",
+    "lastName",
+    "title",
+    "companyExternalId"
+  ], "search record");
+  return parseRecordSummary(input, "search record");
+}
+function parseRecordProfile(value) {
+  const input = inputObject(value, "record profile");
+  assertAllowedFields(input, [
+    "recordType",
+    "id",
+    "externalId",
+    "status",
+    "name",
+    "domain",
+    "website",
+    "source",
+    "email",
+    "firstName",
+    "lastName",
+    "title",
+    "companyExternalId",
+    "attributes",
+    "createdAt",
+    "updatedAt",
+    "statusSetBy",
+    "statusSetAt",
+    "statusVersion",
+    "doNotContact"
+  ], "record profile");
+  const attributes = parseAttributes(input.attributes);
+  const profile = {
+    ...parseRecordSummary(input, "record profile"),
+    externalId: requiredText(input.externalId, "record profile externalId", CRM_MAX_ID_CHARS),
+    status: requiredText(input.status, "record profile status", CRM_MAX_STATUS_CHARS),
+    ...attributes === undefined ? {} : { attributes },
+    createdAt: parseCrmTimestamp(input.createdAt, "record profile createdAt"),
+    updatedAt: parseCrmTimestamp(input.updatedAt, "record profile updatedAt")
+  };
+  if (input.statusSetBy !== undefined)
+    profile.statusSetBy = statusSetter(input.statusSetBy);
+  if (input.statusSetAt !== undefined) {
+    profile.statusSetAt = parseCrmTimestamp(input.statusSetAt, "record profile statusSetAt");
+  }
+  if (input.statusVersion !== undefined) {
+    profile.statusVersion = count(input.statusVersion, "statusVersion");
+  }
+  if (input.doNotContact !== undefined) {
+    if (typeof input.doNotContact !== "boolean") {
+      throw new CrmInputError("doNotContact must be a boolean");
+    }
+    profile.doNotContact = input.doNotContact;
+  }
+  return profile;
+}
+function parseRecordSummary(input, label) {
+  const record = {
+    recordType: recordType(input.recordType),
+    id: requiredText(input.id, `${label} id`, CRM_MAX_ID_CHARS)
+  };
+  for (const [field, maximum] of [
+    ["externalId", CRM_MAX_ID_CHARS],
+    ["status", CRM_MAX_STATUS_CHARS],
+    ["name", CRM_MAX_NAME_CHARS],
+    ["domain", CRM_MAX_DOMAIN_CHARS],
+    ["website", CRM_MAX_WEBSITE_CHARS],
+    ["source", CRM_MAX_SOURCE_CHARS],
+    ["firstName", CRM_MAX_PERSON_FIELD_CHARS],
+    ["lastName", CRM_MAX_PERSON_FIELD_CHARS],
+    ["title", CRM_MAX_PERSON_FIELD_CHARS],
+    ["companyExternalId", CRM_MAX_ID_CHARS]
+  ]) {
+    const text = optionalText(input[field], `${label} ${field}`, maximum);
+    if (text !== undefined)
+      record[field] = text;
+  }
+  if (input.email !== undefined)
+    record.email = email(input.email);
+  return record;
+}
+function parseActivity(value) {
+  const input = inputObject(value, "activity");
+  assertAllowedFields(input, ["id", "activityType", "summary", "occurredAt", "createdAt", "attributes", "version"], "activity");
+  const attributes = parseAttributes(input.attributes);
+  return {
+    id: requiredText(input.id, "activity id", CRM_MAX_ID_CHARS),
+    activityType: requiredText(input.activityType, "activityType", CRM_MAX_ACTIVITY_TYPE_CHARS),
+    summary: requiredText(input.summary, "activity summary", CRM_MAX_SUMMARY_CHARS),
+    occurredAt: parseCrmTimestamp(input.occurredAt, "activity occurredAt"),
+    createdAt: parseCrmTimestamp(input.createdAt, "activity createdAt"),
+    ...attributes === undefined ? {} : { attributes },
+    ...input.version === undefined ? {} : { version: positiveInteger(input.version, "activity version", CRM_MAX_VERSION) }
+  };
+}
+function parseAttributes(value) {
+  if (value === undefined)
+    return;
+  const input = inputObject(value, "attributes");
+  const keys = Object.keys(input);
+  if (keys.length > CRM_MAX_ATTRIBUTE_COUNT) {
+    throw new CrmInputError(`attributes may contain at most ${CRM_MAX_ATTRIBUTE_COUNT} keys`);
+  }
+  const attributes = {};
+  for (const key of keys) {
+    if (key.length === 0 || key.length > CRM_MAX_ATTRIBUTE_KEY_CHARS || key.trim() === "" || CONTROL_CHARS.test(key) || key === "__proto__" || key === "constructor" || key === "prototype") {
+      throw new CrmInputError(`attribute keys must be non-empty strings of at most ${CRM_MAX_ATTRIBUTE_KEY_CHARS} characters`);
+    }
+    const scalar = attributeValue(input[key]);
+    Object.defineProperty(attributes, key, {
+      value: scalar,
+      enumerable: true,
+      configurable: false,
+      writable: false
+    });
+  }
+  return attributes;
+}
+function attributeValue(value) {
+  if (value === null || typeof value === "boolean")
+    return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value))
+      throw new CrmInputError("attribute values must be JSON scalars");
+    return value;
+  }
+  if (typeof value === "string") {
+    if (value.length > CRM_MAX_ATTRIBUTE_STRING_CHARS || CONTROL_CHARS.test(value)) {
+      throw new CrmInputError(`attribute strings may contain at most ${CRM_MAX_ATTRIBUTE_STRING_CHARS} characters`);
+    }
+    return value;
+  }
+  throw new CrmInputError("attribute values must be JSON scalars");
+}
+function assertDistinctExternalIds(records, field) {
+  const ids = new Set;
+  for (const record of records) {
+    if (ids.has(record.externalId))
+      throw new CrmInputError(`${field} may not repeat externalId`);
+    ids.add(record.externalId);
+  }
+}
+function assertRequestSize(value) {
+  if (Buffer.byteLength(JSON.stringify(value), "utf8") > CRM_MAX_REQUEST_BYTES) {
+    throw new CrmInputError(`CRM request may not exceed ${CRM_MAX_REQUEST_BYTES} bytes`);
+  }
+}
+function parseStringArray(value, field, maxItems, maxItemChars) {
+  if (!Array.isArray(value))
+    throw new CrmInputError(`${field} must be an array`);
+  if (value.length > maxItems)
+    throw new CrmInputError(`${field} may contain at most ${maxItems} values`);
+  const seen = new Set;
+  const output = [];
+  for (const item of value) {
+    const parsed = requiredText(item, field, maxItemChars);
+    if (seen.has(parsed))
+      throw new CrmInputError(`${field} may not contain duplicates`);
+    seen.add(parsed);
+    output.push(parsed);
+  }
+  return output;
+}
+function email(value) {
+  const parsed = requiredText(value, "contact email", CRM_MAX_EMAIL_CHARS);
+  if (!SIMPLE_EMAIL.test(parsed))
+    throw new CrmInputError("contact email must be a valid address");
+  return parsed;
+}
+function recordType(value) {
+  if (value !== "company" && value !== "contact")
+    throw new CrmInputError("recordType must be company or contact");
+  return value;
+}
+function operation(value) {
+  if (value !== "upsert_records" && value !== "update_status" && value !== "log_activity" && value !== "update_note" && value !== "delete_record") {
+    throw new CrmInputError("operation is unsupported");
+  }
+  return value;
+}
+function parseCrmTimestamp(value, field) {
+  const parsed = requiredText(value, field, CRM_MAX_TIMESTAMP_CHARS);
+  const match = ISO_TIMESTAMP.exec(parsed);
+  if (match === null)
+    throw new CrmInputError(`${field} must be an ISO-8601 timestamp`);
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  const hour = Number(match[4]);
+  const minute = Number(match[5]);
+  const second = Number(match[6]);
+  const zone = match[7] ?? "";
+  const maxDay = daysInMonth(year, month);
+  const validZone = zone === "Z" || /^[+-]\d{2}:\d{2}$/.test(zone) && Number(zone.slice(1, 3)) <= 23 && Number(zone.slice(4, 6)) <= 59;
+  if (month < 1 || month > 12 || day < 1 || day > maxDay || hour > 23 || minute > 59 || second > 59 || !validZone) {
+    throw new CrmInputError(`${field} must be an ISO-8601 timestamp`);
+  }
+  const normalized = new Date(parsed);
+  if (!Number.isFinite(normalized.getTime()) || !/^\d{4}-\d{2}-\d{2}T/.test(normalized.toISOString())) {
+    throw new CrmInputError(`${field} must normalize to a four-digit UTC year`);
+  }
+  return parsed;
+}
+function daysInMonth(year, month) {
+  if (month === 2)
+    return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0) ? 29 : 28;
+  return month === 4 || month === 6 || month === 9 || month === 11 ? 30 : 31;
+}
+function validateBatchSize(value) {
+  if (!Number.isInteger(value) || value < 1 || value > CRM_MAX_BATCH_SIZE) {
+    throw new CrmInputError(`maxBatchSize must be an integer between 1 and ${CRM_MAX_BATCH_SIZE}`);
+  }
+  return value;
+}
+
+export { CRM_MAX_REQUEST_BYTES, CRM_MAX_RESPONSE_BYTES, CRM_MAX_ID_CHARS, CRM_MAX_CURSOR_CHARS, CRM_MAX_SEARCH_LIMIT, CRM_MAX_ACTIVITY_PAGE_SIZE, CRM_MAX_ATTRIBUTE_STRING_CHARS, CRM_MAX_OUTREACH_QUEUE_ITEMS, CRM_MAX_OUTREACH_CANDIDATES_PAGE, CRM_NOTE_ACTIVITY, CRM_OUTREACH_DRAFTED_ACTIVITY, CRM_OUTREACH_SENT_ACTIVITY, CRM_OUTREACH_REPLY_ACTIVITY, CRM_REFUSAL_REASONS, CRM_REQUIRED_PROVIDER_OPERATIONS, CrmInputError, crmResponseFitsBudget, parseCrmUpsertRecordsArgs, parseCrmSearchResponse, parseCrmGetRecordResponse, parseCrmOutreachQueueResponse, parseCrmOperationAck, parseCrmUpdateStatusArgs, parseCrmLogActivityArgs, parseCrmGetActivityResponse, parseCrmOutreachState, parseCrmOutreachCandidatesResponse, parseCrmProviderMeta, isCrmIdempotencyKey, parseCrmTimestamp };