twenty-app-intake 0.3.0 → 0.4.0

package/src/logic-functions/retry.mjs

@@ -21,10 +21,6 @@ var __anyHandler = {
 var __anyStub = new Proxy(() => void 0, __anyHandler);
 var defineLogicFunction = __defineFactoryStub;
 
-// src/logic-functions/retry.ts
-import { CoreApiClient } from "twenty-client-sdk/core";
-import { MetadataApiClient } from "twenty-client-sdk/metadata";
-
 // src/constants/universal-identifiers.ts
 var IDS = {
   APPLICATION: "96a389dd-384a-43a1-a376-9d3cf01b6ab7",
@@ -63,6 +59,7 @@ var IDS = {
   INTAKE_FIELD_RULE_FIELD_TYPE: "72d1f6d8-d63e-419e-a244-8127d7b4705f",
   INTAKE_FIELD_RULE_PRIORITY: "911df299-940b-44f9-92f7-3fd01fde01a7",
   INTAKE_FIELD_RULE_IS_ACTIVE: "6f9cd96d-aecd-437f-a7b5-d45548782771",
+  INTAKE_FIELD_RULE_TARGET_OBJECT: "7b8411a7-5e1d-40f2-a20c-683c07f67926",
   // Logic Functions
   WEBHOOK_LOGIC_FUNCTION: "8323c257-48fe-4bb6-b1dd-166844f575c0",
   HEALTH_LOGIC_FUNCTION: "4ece4e39-286b-4820-81f4-b7beee71d092",
@@ -88,9 +85,76 @@ var IDS = {
   // Views & Navigation
   SOURCES_VIEW: "4435cd43-5c13-472f-b4f9-b686c0f46285",
   LOGS_VIEW: "a2cd0a93-9778-4ba5-99d9-b8b89c4fb39d",
-  INTAKE_NAV_ITEM: "e81bf288-5686-4713-86ae-e2947b124cab"
+  INTAKE_NAV_ITEM: "e81bf288-5686-4713-86ae-e2947b124cab",
+  // ── v0.4.0 ────────────────────────────────────────────────────────────────
+  // IntakeLog fields — quarantine, idempotency, replay lineage
+  INTAKE_LOG_IDEMPOTENCY_KEY: "bf91e4c0-6477-41f2-a9bd-fb159d3091d4",
+  INTAKE_LOG_SPAM_SCORE: "4e250af2-925f-4724-85f6-f353a6bb4cfd",
+  INTAKE_LOG_QUARANTINE_REASON: "323b3c3e-a111-45d1-a211-cf70efa6cd9e",
+  INTAKE_LOG_REPLAY_OF: "b68876b1-0045-4eaa-a4e7-f0634e110ef1",
+  // IntakeSource fields — silence detection, spam, merge policy
+  INTAKE_SOURCE_EXPECTED_CADENCE: "a97c3906-5555-4e60-a6d6-84155a4e00a6",
+  INTAKE_SOURCE_HEALTH_STATUS: "2ad13b20-5bd7-450a-b52d-bcf208373cf5",
+  INTAKE_SOURCE_SILENT_SINCE: "d3395601-f29f-4e57-98eb-561ab011cc72",
+  INTAKE_SOURCE_ALERT_WEBHOOK: "5a066d62-0426-41c1-b34c-1a7e881ce854",
+  INTAKE_SOURCE_LAST_ALERT_AT: "fc64a598-ccbe-44e3-bd42-716e32d626a2",
+  INTAKE_SOURCE_HONEYPOT_FIELD: "5c145686-50de-496c-bb45-a30c8b39034c",
+  INTAKE_SOURCE_MERGE_POLICY: "5a946f85-b1c2-493e-92c6-31c50e637a7e",
+  // IntakeFieldRule fields
+  INTAKE_FIELD_RULE_MERGE_STRATEGY: "40c6fdcb-527a-4691-8518-c40a3d3e34c6",
+  // Logic Functions
+  CONTRACT_LOGIC_FUNCTION: "2eea4152-1b08-4b8c-903c-f4c7ee7275d0",
+  REPLAY_LOG_LOGIC_FUNCTION: "8ff98390-7358-4a91-84f3-435f758182a3",
+  REPLAY_BULK_LOGIC_FUNCTION: "b82ed4c4-07bc-4095-8ee5-611200626dc0",
+  QUARANTINE_LIST_LOGIC_FUNCTION: "0203643c-2a97-4e7c-b4a5-b76d721cf23a",
+  QUARANTINE_RELEASE_LOGIC_FUNCTION: "5a10d4fe-c807-45c6-9e61-c191d4e37b4e",
+  QUARANTINE_DISCARD_LOGIC_FUNCTION: "1454a56e-6197-4dfd-9b41-5cc3b1436af7",
+  CHECK_SILENCE_LOGIC_FUNCTION: "e88cd5f2-ab96-4f89-ac55-78db66b32d66",
+  // Application variables
+  VAR_MERGE_POLICY: "a84fe9fd-3d7c-41d9-b0e8-dfdc1a87f348",
+  VAR_SPAM_FILTER_ENABLED: "570d3ba8-1904-4bad-a5ce-27e208e6414a",
+  VAR_SPAM_SCORE_THRESHOLD: "4395574d-24b4-4e0e-afa3-1e90fcd4f470",
+  VAR_HONEYPOT_FIELD: "2cf56c56-f5cb-47c5-aa43-84f301060a95",
+  VAR_RAW_PAYLOAD_RETENTION: "f3314ad6-05b9-4127-bb88-cea5f2018dc9",
+  VAR_RAW_PAYLOAD_MAX_BYTES: "b002ca76-df3d-47b4-8ac5-d3f562239c48",
+  VAR_REPLAY_MAX_BATCH: "cf55956f-177e-4afd-8d9f-7f42c614209c"
 };
 
+// src/lib/rest-client.ts
+var apiUrl = () => process.env["TWENTY_API_URL"] ?? "";
+var token = () => process.env["TWENTY_APP_ACCESS_TOKEN"] ?? "";
+async function request(base, method, path, body) {
+  const res = await fetch(`${base}${path}`, {
+    method,
+    headers: {
+      Authorization: `Bearer ${token()}`,
+      "Content-Type": "application/json"
+    },
+    body: body !== void 0 ? JSON.stringify(body) : void 0
+  });
+  const text = await res.text();
+  if (!res.ok) {
+    throw new Error(`${method} ${path} \u2192 ${res.status}: ${text}`);
+  }
+  return JSON.parse(text);
+}
+var coreApi = {
+  get: (path) => request(`${apiUrl()}/rest`, "GET", path),
+  post: (path, body) => request(`${apiUrl()}/rest`, "POST", path, body),
+  patch: (path, body) => request(`${apiUrl()}/rest`, "PATCH", path, body)
+};
+var metaApi = {
+  get: (path) => request(`${apiUrl()}/rest/metadata`, "GET", path),
+  post: (path, body) => request(`${apiUrl()}/rest/metadata`, "POST", path, body)
+};
+async function gql(query, variables) {
+  return request(`${apiUrl()}`, "POST", "/graphql", { query, variables });
+}
+
+// src/lib/ingest.ts
+import { CoreApiClient } from "twenty-client-sdk/core";
+import { MetadataApiClient } from "twenty-client-sdk/metadata";
+
 // src/lib/pipeline.ts
 var Pipeline = class {
   stages = [];
@@ -122,6 +186,10 @@ var ErrorCode = {
   SOURCE_NOT_FOUND: "SOURCE_NOT_FOUND",
   SOURCE_PAUSED: "SOURCE_PAUSED",
   DUPLICATE_PAYLOAD: "DUPLICATE_PAYLOAD",
+  /** Held by the spam filter — recorded, not written, and releasable. */
+  QUARANTINED: "QUARANTINED",
+  /** Retention is off or the payload was too large, so there is nothing to replay. */
+  NO_STORED_PAYLOAD: "NO_STORED_PAYLOAD",
   FIELD_CREATE_FAILED: "FIELD_CREATE_FAILED",
   RECORD_UPSERT_FAILED: "RECORD_UPSERT_FAILED",
   NOTE_CREATE_FAILED: "NOTE_CREATE_FAILED",
@@ -132,6 +200,21 @@ var ok = (value) => ({ ok: true, value });
 var err = (code, message, details) => ({ ok: false, error: { code, message, details } });
 
 // src/lib/stages/load-source.stage.ts
+var BASE_FIELDS = {
+  id: true,
+  name: true,
+  slug: true,
+  targetObject: true,
+  webhookSecret: true,
+  status: true,
+  createOpportunity: true,
+  opportunityNameTemplate: true
+};
+var V4_FIELDS = {
+  ...BASE_FIELDS,
+  honeypotField: true,
+  mergePolicy: true
+};
 var LoadSourceStage = class {
   constructor(client) {
     this.client = client;
@@ -139,24 +222,7 @@ var LoadSourceStage = class {
   client;
   name = "load-source";
   async execute(ctx) {
-    const result = await this.client.query({
-      intakeSources: {
-        __args: { filter: { slug: { eq: ctx.sourceSlug } } },
-        edges: {
-          node: {
-            id: true,
-            name: true,
-            slug: true,
-            targetObject: true,
-            webhookSecret: true,
-            status: true,
-            createOpportunity: true,
-            opportunityNameTemplate: true
-          }
-        }
-      }
-    });
-    const node = result.intakeSources?.edges?.[0]?.node;
+    const node = await this.fetch(ctx.sourceSlug);
     if (!node) {
       return err(ErrorCode.SOURCE_NOT_FOUND, `No Intake source found with slug "${ctx.sourceSlug}"`);
     }
@@ -173,11 +239,48 @@ var LoadSourceStage = class {
         webhookSecret: node.webhookSecret ?? null,
         status: node.status,
         createOpportunity: node.createOpportunity ?? true,
-        opportunityNameTemplate: node.opportunityNameTemplate ?? "{{source}} \u2014 {{firstName}} {{lastName}}"
+        opportunityNameTemplate: node.opportunityNameTemplate ?? "{{source}} \u2014 {{firstName}} {{lastName}}",
+        honeypotField: node.honeypotField ?? null,
+        mergePolicy: parseMergePolicy(node.mergePolicy)
       }
     });
   }
+  /**
+   * Ask for the 0.4.0 columns, and fall back to the original set if they are not
+   * there yet. A workspace that upgraded the package but has not re-synced its
+   * schema would otherwise fail the query and reject every request as an unknown
+   * source — an upgrade that takes the webhook offline, which is not acceptable
+   * for something sitting in front of someone's contact form.
+   */
+  async fetch(slug) {
+    const args = { filter: { slug: { eq: slug } } };
+    try {
+      const result = await this.client.query({
+        intakeSources: { __args: args, edges: { node: V4_FIELDS } }
+      });
+      return result.intakeSources?.edges?.[0]?.node ?? null;
+    } catch {
+      try {
+        const result = await this.client.query({
+          intakeSources: { __args: args, edges: { node: BASE_FIELDS } }
+        });
+        return result.intakeSources?.edges?.[0]?.node ?? null;
+      } catch {
+        return null;
+      }
+    }
+  }
 };
+function parseMergePolicy(raw) {
+  switch ((raw ?? "").toUpperCase()) {
+    case "PRESERVE":
+      return "PRESERVE";
+    case "NEWEST_WINS":
+      return "NEWEST_WINS";
+    default:
+      return null;
+  }
+}
 
 // src/lib/stages/verify-signature.stage.ts
 import { createHmac, timingSafeEqual } from "node:crypto";
@@ -228,6 +331,48 @@ function withinWindow(processedAt, windowMs = 5 * 60 * 1e3) {
   return Date.now() - processedAt.getTime() < windowMs;
 }
 
+// src/lib/settings.ts
+function str(key, fallback) {
+  const v = process.env[key];
+  return v === void 0 || v === "" ? fallback : v;
+}
+function int(key, fallback) {
+  const parsed = parseInt(process.env[key] ?? "", 10);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+function bool(key, fallback) {
+  const v = process.env[key];
+  if (v === void 0 || v === "") return fallback;
+  return v.toLowerCase() === "true";
+}
+function appLabel() {
+  return str("INTAKE_APP_LABEL", "Intake");
+}
+function defaultOpportunityStage() {
+  return str("INTAKE_DEFAULT_OPP_STAGE", "NEW");
+}
+function dedupWindowMinutes() {
+  return int("INTAKE_DEDUP_WINDOW_MINUTES", 5);
+}
+function mergePolicy() {
+  return str("INTAKE_MERGE_POLICY", "PRESERVE").toUpperCase() === "NEWEST_WINS" ? "NEWEST_WINS" : "PRESERVE";
+}
+function spamFilterEnabled() {
+  return bool("INTAKE_SPAM_FILTER_ENABLED", false);
+}
+function spamScoreThreshold() {
+  return int("INTAKE_SPAM_SCORE_THRESHOLD", 5);
+}
+function honeypotField() {
+  return str("INTAKE_HONEYPOT_FIELD", "");
+}
+function rawPayloadRetention() {
+  return str("INTAKE_RAW_PAYLOAD_RETENTION", "FULL").toUpperCase() === "NONE" ? "NONE" : "FULL";
+}
+function rawPayloadMaxBytes() {
+  return int("INTAKE_RAW_PAYLOAD_MAX_BYTES", 65e3);
+}
+
 // src/lib/stages/idempotency.stage.ts
 var IdempotencyStage = class {
   constructor(client) {
@@ -237,34 +382,65 @@ var IdempotencyStage = class {
   name = "idempotency";
   async execute(ctx) {
     const hash = computePayloadHash(ctx.rawPayload);
-    if (ctx.skipDedup) return ok({ ...ctx, payloadHash: hash });
-    const existing = await this.client.query({
-      intakeLogs: {
-        __args: {
-          filter: { payloadHash: { eq: hash } },
-          orderBy: { processedAt: "DescNullsLast" },
-          first: 1
-        },
-        edges: {
-          node: {
-            id: true,
-            status: true,
-            recordId: true,
-            processedAt: true
-          }
-        }
+    const next = { ...ctx, payloadHash: hash };
+    if (ctx.skipDedup) return ok(next);
+    if (ctx.idempotencyKey) {
+      const prior2 = await this.findByKey(ctx.idempotencyKey);
+      if (prior2) {
+        return err(
+          ErrorCode.DUPLICATE_PAYLOAD,
+          `Idempotency key already processed (log ${prior2.id})`,
+          { priorLogId: prior2.id, priorRecordId: prior2.recordId, idempotencyKey: ctx.idempotencyKey }
+        );
       }
-    });
-    const prior = existing.intakeLogs?.edges?.[0]?.node;
-    const windowMins = parseInt(process.env["INTAKE_DEDUP_WINDOW_MINUTES"] ?? "5", 10);
-    if (prior && withinWindow(new Date(prior.processedAt), windowMins * 60 * 1e3)) {
+    }
+    const windowMins = dedupWindowMinutes();
+    if (windowMins <= 0) return ok(next);
+    const prior = await this.findByHash(hash);
+    if (prior?.processedAt && withinWindow(new Date(prior.processedAt), windowMins * 60 * 1e3)) {
       return err(
         ErrorCode.DUPLICATE_PAYLOAD,
-        `Duplicate payload \u2014 already processed ${prior.status.toLowerCase()} (log ${prior.id})`,
+        `Duplicate payload \u2014 already processed ${String(prior.status).toLowerCase()} (log ${prior.id})`,
         { priorLogId: prior.id, priorRecordId: prior.recordId }
       );
     }
-    return ok({ ...ctx, payloadHash: hash });
+    return ok(next);
+  }
+  async findByKey(key) {
+    try {
+      const res = await this.client.query({
+        intakeLogs: {
+          __args: {
+            filter: { idempotencyKey: { eq: key } },
+            orderBy: { processedAt: "DescNullsLast" },
+            first: 1
+          },
+          edges: { node: { id: true, status: true, recordId: true, processedAt: true } }
+        }
+      });
+      const node = res.intakeLogs?.edges?.[0]?.node ?? null;
+      if (node && (node.status === "QUARANTINED" || node.status === "DISCARDED")) return null;
+      return node;
+    } catch {
+      return null;
+    }
+  }
+  async findByHash(hash) {
+    try {
+      const res = await this.client.query({
+        intakeLogs: {
+          __args: {
+            filter: { payloadHash: { eq: hash } },
+            orderBy: { processedAt: "DescNullsLast" },
+            first: 1
+          },
+          edges: { node: { id: true, status: true, recordId: true, processedAt: true } }
+        }
+      });
+      return res.intakeLogs?.edges?.[0]?.node ?? null;
+    } catch {
+      return null;
+    }
   }
 };
 
@@ -542,7 +718,113 @@ function classify(key, value) {
   return "field";
 }
 
+// src/lib/merge.ts
+function decideMerge(existing, incoming, policy, strategy = "INHERIT") {
+  if (isEmpty(incoming)) return { write: false, status: "preserved" };
+  if (isEmpty(existing)) return { write: true, status: "filled-empty" };
+  if (sameValue(existing, incoming)) return { write: false, status: "unchanged" };
+  const effective = strategy === "INHERIT" ? policy : strategy;
+  return effective === "NEWEST_WINS" ? { write: true, status: "set" } : { write: false, status: "preserved" };
+}
+function mergePatch(existing, incoming, policy, strategyFor = () => "INHERIT") {
+  const patch = {};
+  const decisions = {};
+  for (const [key, value] of Object.entries(incoming)) {
+    const decision = decideMerge(existing[key], value, policy, strategyFor(key));
+    decisions[key] = decision;
+    if (decision.write) patch[key] = value;
+  }
+  return { patch, decisions };
+}
+function parseFieldMergeStrategy(raw) {
+  switch ((raw ?? "").toUpperCase()) {
+    case "PRESERVE":
+      return "PRESERVE";
+    case "NEWEST_WINS":
+      return "NEWEST_WINS";
+    default:
+      return "INHERIT";
+  }
+}
+function isEmpty(value) {
+  if (value === null || value === void 0) return true;
+  if (typeof value === "string") return value.trim() === "";
+  if (Array.isArray(value)) return value.length === 0;
+  if (typeof value === "object") {
+    const entries = Object.entries(value);
+    if (entries.length === 0) return true;
+    const meaningful = entries.filter(([k]) => !IGNORED_COMPOSITE_KEYS.has(k));
+    if (meaningful.length === 0) return true;
+    return meaningful.every(([, v]) => isEmpty(v));
+  }
+  return false;
+}
+var IGNORED_COMPOSITE_KEYS = /* @__PURE__ */ new Set([
+  "currencyCode",
+  "primaryLinkLabel",
+  "primaryPhoneCountryCode",
+  "primaryPhoneCallingCode",
+  "additionalLinks",
+  "additionalEmails",
+  "additionalPhones"
+]);
+function sameValue(a, b) {
+  if (a === b) return true;
+  if (typeof a === "object" && typeof b === "object" && a !== null && b !== null) {
+    try {
+      return JSON.stringify(sortKeys(a)) === JSON.stringify(sortKeys(b));
+    } catch {
+      return false;
+    }
+  }
+  return String(a) === String(b);
+}
+function sortKeys(value) {
+  if (value === null || typeof value !== "object") return value;
+  if (Array.isArray(value)) return value.map(sortKeys);
+  const obj = value;
+  const out = {};
+  for (const key of Object.keys(obj).sort()) out[key] = sortKeys(obj[key]);
+  return out;
+}
+
 // src/lib/normalizer.ts
+function actionForRule(rule) {
+  if (rule.action) return rule.action;
+  switch ((rule.fieldType ?? "").toUpperCase()) {
+    case "SKIP":
+      return "skip";
+    case "NOTE":
+      return "note";
+    default:
+      return "field";
+  }
+}
+function typeForRule(rule) {
+  switch ((rule.fieldType ?? "").toUpperCase()) {
+    case "NOTE":
+      return "RICH_TEXT";
+    case "SKIP":
+      return "TEXT";
+    case "":
+      return "TEXT";
+    default:
+      return rule.fieldType;
+  }
+}
+var OPPORTUNITY_KEY_PREFIXES = ["opportunity_", "opp_", "deal_"];
+function parseTargetObject(raw) {
+  switch ((raw ?? "").toUpperCase()) {
+    case "PERSON":
+      return "person";
+    case "COMPANY":
+      return "company";
+    case "OPPORTUNITY":
+      return "opportunity";
+    default:
+      return "auto";
+  }
+}
 function normalizeFields(flat, rules = []) {
   const sorted = [...rules].sort((a, b) => b.priority - a.priority);
   return Object.entries(flat).map(
@@ -559,7 +841,8 @@ function normalizeField(key, value, rules) {
       twentyType: builtIn.twentyType,
       action: builtIn.action,
       value,
-      source: "builtin"
+      source: "builtin",
+      targetObject: "auto"
     };
   }
   for (const rule of rules) {
@@ -573,23 +856,29 @@ function normalizeField(key, value, rules) {
       return {
         originalKey: key,
         canonicalName: rule.canonicalName,
-        twentyType: rule.fieldType,
-        action: rule.action,
+        twentyType: typeForRule(rule),
+        action: actionForRule(rule),
         value,
-        source: "rule"
+        source: "rule",
+        targetObject: parseTargetObject(rule.targetObject),
+        mergeStrategy: parseFieldMergeStrategy(rule.mergeStrategy)
       };
     }
   }
   const detectedType = detectType(value);
   const classification = classify(key, value);
-  const canonicalName = classification === "field" ? toExtFieldName(key) : lookupKey;
+  const prefix = OPPORTUNITY_KEY_PREFIXES.find((p) => lookupKey.startsWith(p));
+  const targetObject = prefix ? "opportunity" : "auto";
+  const bareKey = prefix ? lookupKey.slice(prefix.length) : key;
+  const canonicalName = classification === "field" ? toExtFieldName(bareKey) : lookupKey;
   return {
     originalKey: key,
     canonicalName,
     twentyType: detectedType,
     action: classification === "field" ? "field" : classification,
     value,
-    source: "passthrough"
+    source: "passthrough",
+    targetObject
   };
 }
 function toExtFieldName(key) {
@@ -700,6 +989,32 @@ var NormalizeStage = class {
     });
   }
   async loadRules(sourceId) {
+    try {
+      const filter = sourceId ? { or: [{ intakeSource: { id: { eq: sourceId } } }, { intakeSource: { id: { is: "NULL" } } }] } : { intakeSource: { id: { is: "NULL" } } };
+      const result = await this.client.query({
+        intakeFieldRules: {
+          __args: {
+            filter: { and: [filter, { isActive: { eq: true } }] },
+            orderBy: { priority: "DescNullsLast" }
+          },
+          edges: {
+            node: {
+              inputPattern: true,
+              canonicalName: true,
+              fieldType: true,
+              priority: true,
+              targetObject: true,
+              mergeStrategy: true
+            }
+          }
+        }
+      });
+      return (result.intakeFieldRules?.edges ?? []).map((e) => e.node);
+    } catch {
+      return this.loadRulesLegacy(sourceId);
+    }
+  }
+  async loadRulesLegacy(sourceId) {
     try {
       const filter = sourceId ? { or: [{ intakeSource: { id: { eq: sourceId } } }, { intakeSource: { id: { is: "NULL" } } }] } : { intakeSource: { id: { is: "NULL" } } };
       const result = await this.client.query({
@@ -725,36 +1040,203 @@ var NormalizeStage = class {
   }
 };
 
-// src/lib/rest-client.ts
-var apiUrl = () => process.env["TWENTY_API_URL"] ?? "";
-var token = () => process.env["TWENTY_APP_ACCESS_TOKEN"] ?? "";
-async function request(base, method, path, body) {
-  const res = await fetch(`${base}${path}`, {
-    method,
-    headers: {
-      Authorization: `Bearer ${token()}`,
-      "Content-Type": "application/json"
-    },
-    body: body !== void 0 ? JSON.stringify(body) : void 0
-  });
-  const text = await res.text();
-  if (!res.ok) {
-    throw new Error(`${method} ${path} \u2192 ${res.status}: ${text}`);
+// src/lib/spam.ts
+var HONEYPOT_SCORE = 100;
+var DISPOSABLE_EMAIL_DOMAINS = /* @__PURE__ */ new Set([
+  "mailinator.com",
+  "guerrillamail.com",
+  "guerrillamail.net",
+  "sharklasers.com",
+  "10minutemail.com",
+  "10minutemail.net",
+  "tempmail.com",
+  "temp-mail.org",
+  "throwawaymail.com",
+  "yopmail.com",
+  "yopmail.net",
+  "trashmail.com",
+  "dispostable.com",
+  "getnada.com",
+  "nada.email",
+  "fakeinbox.com",
+  "maildrop.cc",
+  "mintemail.com",
+  "spamgourmet.com",
+  "mailnesia.com",
+  "tempinbox.com",
+  "emailondeck.com",
+  "moakt.com",
+  "mohmal.com",
+  "inboxkitten.com",
+  "mailcatch.com",
+  "mytemp.email",
+  "discard.email"
+]);
+var PLACEHOLDER_EMAIL_DOMAINS = /* @__PURE__ */ new Set([
+  "example.com",
+  "example.org",
+  "example.net",
+  "test.com",
+  "localhost",
+  "domain.com",
+  "email.com",
+  "yourdomain.com"
+]);
+var URL_RE2 = /https?:\/\/|www\./i;
+var GLOBAL_URL_RE = /https?:\/\/[^\s<>"']+/gi;
+var MARKUP_RE = /<\s*a\s|<\s*script|\[url[=\]]|\[link[=\]]|\]\(https?:/i;
+var EMAIL_RE2 = /^[^\s@]+@[^\s@]+\.[^\s@]{2,}$/;
+var NAME_KEYS = /* @__PURE__ */ new Set([
+  "name",
+  "fullName",
+  "firstName",
+  "lastName",
+  "contact_name",
+  "your_name"
+]);
+var MESSAGE_KEYS = /* @__PURE__ */ new Set([
+  "message",
+  "description",
+  "comments",
+  "notes",
+  "body",
+  "details",
+  "content",
+  "text",
+  "inquiry",
+  "summary",
+  "feedback"
+]);
+function scoreSpam(flat, honeypotKey) {
+  const signals = [];
+  if (honeypotKey) {
+    const hit = Object.entries(flat).find(
+      ([k, v]) => k.toLowerCase() === honeypotKey.toLowerCase() && isFilled(v)
+    );
+    if (hit) {
+      return {
+        score: HONEYPOT_SCORE,
+        signals: [{ reason: `Honeypot field "${hit[0]}" was filled`, points: HONEYPOT_SCORE }],
+        honeypot: true
+      };
+    }
   }
-  return JSON.parse(text);
+  const add = (reason, points) => signals.push({ reason, points });
+  for (const [key, value] of Object.entries(flat)) {
+    if (typeof value !== "string" || value === "") continue;
+    const bare = key.replace(/^(opportunity_|opp_|deal_)/i, "");
+    if (NAME_KEYS.has(bare) || NAME_KEYS.has(key)) {
+      if (URL_RE2.test(value)) add(`Name field "${key}" contains a URL`, 4);
+      if (MARKUP_RE.test(value)) add(`Name field "${key}" contains markup or a link tag`, 4);
+    }
+    if (MESSAGE_KEYS.has(bare) || MESSAGE_KEYS.has(key)) {
+      const urls = value.match(GLOBAL_URL_RE) ?? [];
+      const distinct = new Set(urls.map((u) => u.toLowerCase()));
+      if (distinct.size >= 5) add(`Message field "${key}" contains ${distinct.size} links`, 3);
+      if (MARKUP_RE.test(value)) add(`Message field "${key}" contains anchor or BBCode markup`, 2);
+    }
+  }
+  const email = firstEmail(flat);
+  if (email !== null) {
+    if (!EMAIL_RE2.test(email)) {
+      add(`Email "${truncate(email)}" is not a valid address`, 3);
+    } else {
+      const domain = email.slice(email.lastIndexOf("@") + 1).toLowerCase();
+      if (DISPOSABLE_EMAIL_DOMAINS.has(domain)) {
+        add(`Email domain "${domain}" is a disposable inbox`, 4);
+      } else if (PLACEHOLDER_EMAIL_DOMAINS.has(domain)) {
+        add(`Email domain "${domain}" is a placeholder domain`, 3);
+      }
+    }
+  }
+  const repeated = mostRepeatedValue(flat);
+  if (repeated && repeated.count >= 4) {
+    add(`The same value appears in ${repeated.count} different fields`, 2);
+  }
+  const phone = firstPhone(flat);
+  if (phone && isImplausiblePhone(phone)) {
+    add(`Phone "${truncate(phone)}" is a placeholder number`, 2);
+  }
+  const score = signals.reduce((sum, s) => sum + s.points, 0);
+  return { score, signals, honeypot: false };
 }
-var coreApi = {
-  get: (path) => request(`${apiUrl()}/rest`, "GET", path),
-  post: (path, body) => request(`${apiUrl()}/rest`, "POST", path, body),
-  patch: (path, body) => request(`${apiUrl()}/rest`, "PATCH", path, body)
-};
-var metaApi = {
-  get: (path) => request(`${apiUrl()}/rest/metadata`, "GET", path),
-  post: (path, body) => request(`${apiUrl()}/rest/metadata`, "POST", path, body)
-};
-async function gql(query, variables) {
-  return request(`${apiUrl()}`, "POST", "/graphql", { query, variables });
+function describeVerdict(verdict) {
+  return verdict.signals.map((s) => s.reason).join("; ").slice(0, 500);
+}
+function isFilled(value) {
+  if (value === null || value === void 0) return false;
+  if (typeof value === "string") return value.trim() !== "";
+  if (typeof value === "boolean") return value;
+  return true;
+}
+function firstEmail(flat) {
+  for (const [key, value] of Object.entries(flat)) {
+    if (typeof value !== "string" || value === "") continue;
+    if (/mail/i.test(key)) return value.trim();
+  }
+  return null;
+}
+function firstPhone(flat) {
+  for (const [key, value] of Object.entries(flat)) {
+    if (typeof value !== "string" || value === "") continue;
+    if (/phone|mobile|tel|cell/i.test(key)) return value.trim();
+  }
+  return null;
 }
+function isImplausiblePhone(raw) {
+  const digits = raw.replace(/\D/g, "");
+  if (digits.length < 7) return false;
+  if (/^(\d)\1+$/.test(digits)) return true;
+  const ascending = digits.split("").every((d, i, arr) => i === 0 || Number(d) === (Number(arr[i - 1]) + 1) % 10);
+  return ascending;
+}
+function mostRepeatedValue(flat) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const value of Object.values(flat)) {
+    if (typeof value !== "string") continue;
+    const v = value.trim();
+    if (v.length < 8) continue;
+    counts.set(v, (counts.get(v) ?? 0) + 1);
+  }
+  let best = null;
+  for (const [value, count] of counts) {
+    if (!best || count > best.count) best = { value, count };
+  }
+  return best;
+}
+function truncate(s) {
+  return s.length > 60 ? `${s.slice(0, 60)}\u2026` : s;
+}
+
+// src/lib/stages/quarantine.stage.ts
+var QuarantineStage = class {
+  name = "quarantine";
+  async execute(ctx) {
+    const honeypot = ctx.source?.honeypotField || honeypotField();
+    const filterOn = spamFilterEnabled();
+    if (!honeypot && !filterOn) return ok(ctx);
+    const verdict = scoreSpam(ctx.flat ?? {}, honeypot);
+    const next = { ...ctx, spam: verdict };
+    if (ctx.skipSpamFilter) {
+      if (verdict.score > 0) {
+        next.warnings.push(`Spam filter overruled by release \u2014 score was ${verdict.score}: ${describeVerdict(verdict)}`);
+      }
+      return ok(next);
+    }
+    const quarantine = verdict.honeypot || filterOn && verdict.score >= spamScoreThreshold();
+    if (quarantine) {
+      return err(
+        ErrorCode.QUARANTINED,
+        verdict.honeypot ? "Honeypot field was filled \u2014 payload quarantined" : `Spam score ${verdict.score} met the threshold of ${spamScoreThreshold()} \u2014 payload quarantined`,
+        { spamScore: verdict.score, reason: describeVerdict(verdict), signals: verdict.signals }
+      );
+    }
+    if (verdict.score > 0) {
+      next.warnings.push(`Spam score ${verdict.score} (below threshold): ${describeVerdict(verdict)}`);
+    }
+    return ok(next);
+  }
+};
 
 // src/lib/stages/sync-schema.stage.ts
 var STANDARD_FIELDS = /* @__PURE__ */ new Set([
@@ -773,66 +1255,122 @@ var STANDARD_FIELDS = /* @__PURE__ */ new Set([
   "city",
   "employees",
   "annualRecurringRevenue",
-  "idealCustomerProfile"
+  "idealCustomerProfile",
+  ...Object.values(FIELD_MAP).map((e) => e.canonicalName)
 ]);
+var STANDARD_OPPORTUNITY_FIELDS = /* @__PURE__ */ new Set(["name", "stage", "amount", "closeDate"]);
+var EXT_RE = /^ext[A-Z]/;
 var SyncSchemaStage = class {
   name = "sync-schema";
   objectCache = /* @__PURE__ */ new Map();
   TTL = 5 * 60 * 1e3;
   async execute(ctx) {
     if (!ctx.crmFields || ctx.crmFields.length === 0) return ok(ctx);
-    if (process.env["INTAKE_FIELD_CREATION_ENABLED"] === "false") {
+    const primary = this.primaryTarget(ctx);
+    const creationEnabled = process.env["INTAKE_FIELD_CREATION_ENABLED"] !== "false";
+    if (!creationEnabled) {
       ctx.warnings.push("Field creation disabled by INTAKE_FIELD_CREATION_ENABLED setting \u2014 ext fields skipped");
-      return ok(ctx);
     }
-    const targets = this.targetObjects(ctx);
+    const resolved = ctx.crmFields.map((f) => ({
+      ...f,
+      targetObject: this.resolveTarget(f.targetObject, primary, ctx)
+    }));
     let fieldsCreated = 0;
     let fieldsMatched = 0;
-    for (const objectName of targets) {
+    const demoted = [];
+    for (const objectName of this.targetObjects(resolved)) {
+      const fields = resolved.filter((f) => f.targetObject === objectName);
+      if (fields.length === 0) continue;
+      const standardForObject = objectName === "opportunity" ? STANDARD_OPPORTUNITY_FIELDS : STANDARD_FIELDS;
       const meta = await this.getObjectMeta(objectName);
-      if (!meta) continue;
+      if (!meta) {
+        for (const f of fields) {
+          if (standardForObject.has(f.canonicalName)) {
+            f.writable = true;
+            fieldsMatched++;
+            continue;
+          }
+          ctx.warnings.push(`Could not read schema for ${objectName} \u2014 "${f.canonicalName}" goes to note`);
+          demoted.push(f);
+        }
+        continue;
+      }
       const maxExt = parseInt(process.env["INTAKE_MAX_EXT_FIELDS"] ?? "50", 10);
-      const currentExtCount = [...meta.fields].filter((f) => /^ext[A-Z]/.test(f)).length;
-      for (const field of ctx.crmFields) {
-        if (STANDARD_FIELDS.has(field.canonicalName)) {
+      let extCount = [...meta.fields].filter((f) => EXT_RE.test(f)).length;
+      for (const field of fields) {
+        const name = field.canonicalName;
+        if (standardForObject.has(name)) {
+          field.writable = true;
           fieldsMatched++;
           continue;
         }
-        if (!/^ext[A-Z]/.test(field.canonicalName)) {
+        if (meta.fields.has(name)) {
+          field.writable = true;
           fieldsMatched++;
           continue;
         }
-        if (meta.fields.has(field.canonicalName)) {
-          fieldsMatched++;
+        if (!EXT_RE.test(name)) {
+          ctx.warnings.push(
+            `Field "${name}" does not exist on ${objectName} and is not ext-prefixed \u2014 value routed to note. Create the field in Twenty first, or rename the rule's canonical name to ext${name.charAt(0).toUpperCase()}${name.slice(1)}.`
+          );
+          demoted.push(field);
+          continue;
+        }
+        if (!creationEnabled) {
+          demoted.push(field);
           continue;
         }
-        if (currentExtCount >= maxExt) {
-          ctx.warnings.push(`ext field limit (${maxExt}) reached for ${objectName} \u2014 "${field.canonicalName}" goes to note`);
+        if (extCount >= maxExt) {
+          ctx.warnings.push(`ext field limit (${maxExt}) reached for ${objectName} \u2014 "${name}" goes to note`);
+          demoted.push(field);
           continue;
         }
-        const created = await this.createField(meta.id, field.canonicalName, field.twentyType);
+        const created = await this.createField(meta.id, name, field.twentyType);
         if (created) {
-          meta.fields.add(field.canonicalName);
-          this.objectCache.get(objectName)?.fields.add(field.canonicalName);
+          meta.fields.add(name);
+          this.objectCache.get(objectName)?.fields.add(name);
+          extCount++;
           fieldsCreated++;
+          field.writable = true;
         } else {
-          ctx.warnings.push(`Could not create field "${field.canonicalName}" on ${objectName} \u2014 will go to note`);
+          ctx.warnings.push(`Could not create field "${name}" on ${objectName} \u2014 will go to note`);
+          demoted.push(field);
         }
       }
     }
-    return ok({ ...ctx, fieldsCreated, fieldsMatched });
+    const demotedSet = new Set(demoted);
+    return ok({
+      ...ctx,
+      crmFields: resolved.filter((f) => !demotedSet.has(f)),
+      noteFields: [...ctx.noteFields ?? [], ...demoted],
+      fieldsCreated,
+      fieldsMatched
+    });
   }
-  targetObjects(ctx) {
+  /** Where an `auto` field lands: the person, or the company for company-only payloads. */
+  primaryTarget(ctx) {
     const t = ctx.source?.targetObject ?? "AUTO";
-    if (t === "PERSON") return ["person"];
-    if (t === "COMPANY") return ["company"];
-    if (ctx.structuredCompany) return ["company"];
+    if (t === "PERSON") return "person";
+    if (t === "COMPANY") return "company";
+    if (ctx.structuredCompany) return "company";
     const hasPersonData = ctx.crmFields?.some((f) => ["firstName", "lastName", "email", "phone", "fullName", "emails", "phones", "name"].includes(f.canonicalName));
     const hasCompanyData = ctx.crmFields?.some((f) => ["companyName", "domainName"].includes(f.canonicalName));
-    const out = [];
-    if (hasPersonData) out.push("person");
-    else if (hasCompanyData) out.push("company");
-    return out.length > 0 ? out : ["person"];
+    if (hasPersonData) return "person";
+    if (hasCompanyData) return "company";
+    return "person";
+  }
+  resolveTarget(target, primary, ctx) {
+    if (target === "auto") return primary;
+    if (target === "opportunity" && !ctx.source?.createOpportunity) {
+      ctx.warnings.push("Field routed to opportunity but this source does not create opportunities \u2014 written to the primary record instead");
+      return primary;
+    }
+    return target;
+  }
+  targetObjects(fields) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const f of fields) if (f.targetObject !== "auto") seen.add(f.targetObject);
+    return [...seen];
   }
   async getObjectMeta(objectName) {
     const cached = this.objectCache.get(objectName);
@@ -905,7 +1443,69 @@ function formatValue(value) {
   return String(value);
 }
 
+// src/lib/lookup.ts
+async function firstMatch(collection, query) {
+  try {
+    const res = await coreApi.get(`/${collection}?${query}&first=1`);
+    return res.data?.[collection]?.edges?.[0]?.node ?? null;
+  } catch {
+    return null;
+  }
+}
+async function findPersonByEmail(email) {
+  if (!email) return null;
+  return firstMatch("people", `filter=emails.primaryEmail[eq]:${encodeURIComponent(email)}`);
+}
+async function findCompanyByDomain(domain) {
+  if (!domain) return null;
+  const host = extractHost(domain);
+  if (!host) return null;
+  return firstMatch(
+    "companies",
+    `filter=domainName.primaryLinkUrl[like]:%25${encodeURIComponent(host)}%25`
+  );
+}
+function extractHost(url) {
+  try {
+    return new URL(url).hostname.replace(/^www\./, "");
+  } catch {
+    return url;
+  }
+}
+
 // src/lib/stages/upsert-record.stage.ts
+var STANDARD_BY_OBJECT = {
+  person: /* @__PURE__ */ new Set([
+    "name",
+    "emails",
+    "phones",
+    "firstName",
+    "lastName",
+    "fullName",
+    "email",
+    "phone",
+    "linkedInLink",
+    "xLink",
+    "jobTitle",
+    "city",
+    "companyName",
+    "domainName",
+    "address"
+  ]),
+  company: /* @__PURE__ */ new Set([
+    "name",
+    "domainName",
+    "address",
+    "companyName",
+    "linkedInLink",
+    "xLink",
+    "employees",
+    "annualRecurringRevenue",
+    "idealCustomerProfile",
+    "city"
+  ]),
+  opportunity: /* @__PURE__ */ new Set(["name", "stage", "amount", "closeDate"])
+};
 var UpsertRecordStage = class {
   name = "upsert-record";
   async execute(ctx) {
@@ -916,25 +1516,50 @@ var UpsertRecordStage = class {
     const structuredCompany = ctx.structuredCompany;
     const structuredPerson = ctx.structuredPerson;
     const rawCompanyName = structuredCompany?.["name"] ?? assembled["companyName"];
-    const extFieldTypes = /* @__PURE__ */ new Map();
+    const customFor = (object) => {
+      const out = {};
+      for (const f of ctx.crmFields ?? []) {
+        if (f.targetObject !== object || f.writable === false || f.writable === void 0) continue;
+        if (STANDARD_BY_OBJECT[object].has(f.canonicalName)) continue;
+        out[f.canonicalName] = formatExtValue(f.value, f.twentyType);
+      }
+      return out;
+    };
+    const policy = ctx.source?.mergePolicy ?? mergePolicy();
+    const strategyByField = /* @__PURE__ */ new Map();
     for (const f of ctx.crmFields ?? []) {
-      if (/^ext[A-Z]/.test(f.canonicalName)) extFieldTypes.set(f.canonicalName, f.twentyType);
+      if (f.mergeStrategy && f.mergeStrategy !== "INHERIT") {
+        strategyByField.set(f.canonicalName, f.mergeStrategy);
+      }
     }
+    const strategyFor = (field) => strategyByField.get(field) ?? "INHERIT";
+    const patchExisting = async (collection, object, existing, incoming) => {
+      const { patch, decisions } = mergePatch(existing, incoming, policy, strategyFor);
+      ctx.mergeDecisions = { ...ctx.mergeDecisions ?? {}, [object]: decisions };
+      const preserved = Object.entries(decisions).filter(([, d]) => d.status === "preserved" && d.write === false).map(([field]) => field);
+      if (preserved.length > 0 && policy === "PRESERVE") {
+        ctx.warnings.push(
+          `Kept the existing ${object} values for ${preserved.join(", ")} \u2014 INTAKE_MERGE_POLICY is PRESERVE`
+        );
+      }
+      if (Object.keys(patch).length === 0) return;
+      await coreApi.patch(`/${collection}/${existing.id}`, patch);
+    };
     try {
       let companyId;
       let personId;
       const needsCompany = rawCompanyName || ctx.source?.targetObject === "COMPANY";
       if (needsCompany) {
-        companyId = await this.upsertCompany(assembled, structuredCompany ?? {}, rawCompanyName, extFieldTypes, ctx);
+        companyId = await this.upsertCompany(assembled, structuredCompany ?? {}, rawCompanyName, customFor("company"), ctx, patchExisting);
       }
       const personData = structuredPerson ?? assembled;
       const hasPersonData = personData["emails"] || personData["name"] || assembled["emails"] || assembled["name"];
       if (hasPersonData || ctx.source?.targetObject === "PERSON") {
-        personId = await this.upsertPerson(assembled, structuredPerson, companyId, extFieldTypes, ctx);
+        personId = await this.upsertPerson(assembled, structuredPerson, companyId, customFor("person"), ctx, patchExisting);
       }
       let opportunityId;
       if (ctx.source?.createOpportunity && (personId || companyId)) {
-        opportunityId = await this.createOpportunity(assembled, personId, companyId, ctx);
+        opportunityId = await this.createOpportunity(assembled, personId, companyId, ctx.crmFields ?? [], customFor("opportunity"), ctx);
       }
       let noteId;
       const noteFields = ctx.noteFields ?? [];
@@ -955,7 +1580,7 @@ var UpsertRecordStage = class {
       return err(ErrorCode.RECORD_UPSERT_FAILED, `Failed to upsert record: ${String(e)}`);
     }
   }
-  async upsertCompany(assembled, structuredCompany, companyName, extFieldTypes, ctx) {
+  async upsertCompany(assembled, structuredCompany, companyName, customData, ctx, patchExisting) {
     const standard = { ...structuredCompany };
     if (companyName && !standard["name"]) standard["name"] = companyName;
     if (!standard["domainName"] && assembled["domainName"]) standard["domainName"] = assembled["domainName"];
@@ -963,17 +1588,10 @@ var UpsertRecordStage = class {
     const domain = standard["domainName"]?.["primaryLinkUrl"];
     let companyId;
     if (domain) {
-      const host = extractHost(domain);
-      try {
-        const found = await coreApi.get(
-          `/companies?filter=domainName.primaryLinkUrl[like]:%25${encodeURIComponent(host)}%25&first=1`
-        );
-        const existing = found.data?.companies?.edges?.[0]?.node;
-        if (existing) {
-          await coreApi.patch(`/companies/${existing.id}`, standard);
-          companyId = existing.id;
-        }
-      } catch {
+      const existing = await findCompanyByDomain(domain);
+      if (existing) {
+        await patchExisting("companies", "company", existing, { ...standard, ...customData });
+        return existing.id;
       }
     }
     if (!companyId) {
@@ -994,20 +1612,14 @@ var UpsertRecordStage = class {
         if (!companyId) throw e;
       }
     }
-    if (Object.keys(structuredCompany).length > 0) {
-      const extData = {};
-      for (const [k, v] of Object.entries(assembled)) {
-        if (/^ext[A-Z]/.test(k)) extData[k] = formatExtValue(v, extFieldTypes.get(k));
-      }
-      if (Object.keys(extData).length > 0) {
-        await coreApi.patch(`/companies/${companyId}`, extData).catch((e) => {
-          ctx.warnings.push(`Could not set ext fields on company: ${e.message.slice(0, 120)}`);
-        });
-      }
+    if (Object.keys(customData).length > 0) {
+      await coreApi.patch(`/companies/${companyId}`, customData).catch((e) => {
+        ctx.warnings.push(`Could not set custom fields on company: ${e.message.slice(0, 120)}`);
+      });
     }
     return companyId;
   }
-  async upsertPerson(assembled, structuredPerson, companyId, extFieldTypes, ctx) {
+  async upsertPerson(assembled, structuredPerson, companyId, customData, ctx, patchExisting) {
     const standard = structuredPerson ? { ...structuredPerson } : {};
     if (!standard["name"] && assembled["name"]) standard["name"] = assembled["name"];
     if (!standard["emails"] && assembled["emails"]) standard["emails"] = assembled["emails"];
@@ -1017,55 +1629,56 @@ var UpsertRecordStage = class {
     const email = emails?.["primaryEmail"];
     let personId;
     if (email) {
-      try {
-        const found = await coreApi.get(
-          `/people?filter=emails.primaryEmail[eq]:${encodeURIComponent(email)}&first=1`
-        );
-        const existing = found.data?.people?.edges?.[0]?.node;
-        if (existing) {
-          await coreApi.patch(`/people/${existing.id}`, standard);
-          personId = existing.id;
-        }
-      } catch {
+      const existing = await findPersonByEmail(email);
+      if (existing) {
+        await patchExisting("people", "person", existing, { ...standard, ...customData });
+        return existing.id;
       }
     }
     if (!personId) {
       const created = await coreApi.post("/people", standard);
       personId = created.data.createPerson.id;
     }
-    if (!structuredPerson) {
-      const extData = {};
-      for (const [k, v] of Object.entries(assembled)) {
-        if (/^ext[A-Z]/.test(k)) extData[k] = formatExtValue(v, extFieldTypes.get(k));
-      }
-      if (Object.keys(extData).length > 0) {
-        await coreApi.patch(`/people/${personId}`, extData).catch((e) => {
-          ctx.warnings.push(`Could not set ext fields on person: ${e.message.slice(0, 120)}`);
-        });
-      }
+    if (Object.keys(customData).length > 0) {
+      await coreApi.patch(`/people/${personId}`, customData).catch((e) => {
+        ctx.warnings.push(`Could not set custom fields on person: ${e.message.slice(0, 120)}`);
+      });
     }
     return personId;
   }
-  async createOpportunity(assembled, personId, companyId, ctx) {
+  async createOpportunity(assembled, personId, companyId, crmFields, customData, ctx) {
+    let opportunityId;
     try {
       const name = buildOpportunityName(ctx, assembled);
-      const stage = process.env["INTAKE_DEFAULT_OPP_STAGE"] ?? "NEW";
+      const stage = defaultOpportunityStage();
       const data = { name, stage };
       if (personId) data["pointOfContactId"] = personId;
       if (companyId) data["companyId"] = companyId;
+      for (const f of crmFields) {
+        if (f.targetObject !== "opportunity" || !f.writable) continue;
+        if (f.canonicalName === "amount" || f.canonicalName === "closeDate") {
+          data[f.canonicalName] = formatExtValue(f.value, f.twentyType);
+        }
+      }
       const created = await coreApi.post("/opportunities", data);
-      return created.data.createOpportunity.id;
+      opportunityId = created.data.createOpportunity.id;
     } catch {
       ctx.warnings.push("Opportunity creation failed \u2014 record was still created");
       return void 0;
     }
+    if (Object.keys(customData).length > 0) {
+      await coreApi.patch(`/opportunities/${opportunityId}`, customData).catch((e) => {
+        ctx.warnings.push(`Could not set custom fields on opportunity: ${e.message.slice(0, 120)}`);
+      });
+    }
+    return opportunityId;
   }
   async createNote(overflow, personId, companyId, ctx) {
     try {
       const markdown = formatNote(ctx.source?.name ?? ctx.sourceSlug, overflow);
-      const appLabel = process.env["INTAKE_APP_LABEL"] ?? "Intake";
+      const label = appLabel();
       const created = await coreApi.post("/notes", {
-        title: `${ctx.source?.name ?? appLabel} \u2014 Lead`,
+        title: `${ctx.source?.name ?? label} \u2014 Lead`,
         bodyV2: { markdown }
       });
       const noteId = created.data.createNote.id;
@@ -1083,92 +1696,257 @@ var UpsertRecordStage = class {
   }
 };
 function buildOpportunityName(ctx, assembled) {
-  const appLabel = process.env["INTAKE_APP_LABEL"] ?? "Intake";
+  const label = appLabel();
   const defaultTemplate = `{{source}} \u2014 {{firstName}} {{lastName}}`;
   const template = ctx.source?.opportunityNameTemplate ?? defaultTemplate;
   const name = assembled["name"];
-  return template.replace("{{source}}", ctx.source?.name ?? appLabel).replace("{{firstName}}", name?.["firstName"] ?? "").replace("{{lastName}}", name?.["lastName"] ?? "").replace("{{email}}", assembled["emails"]?.["primaryEmail"] ?? "").replace("{{company}}", assembled["companyName"] ?? "").trim().replace(/\s+/g, " ").replace(/\s*—\s*$/, "");
-}
-function extractHost(url) {
-  try {
-    return new URL(url).hostname.replace(/^www\./, "");
-  } catch {
-    return url;
-  }
+  return template.replace("{{source}}", ctx.source?.name ?? label).replace("{{firstName}}", name?.["firstName"] ?? "").replace("{{lastName}}", name?.["lastName"] ?? "").replace("{{email}}", assembled["emails"]?.["primaryEmail"] ?? "").replace("{{company}}", assembled["companyName"] ?? "").trim().replace(/\s+/g, " ").replace(/\s*—\s*$/, "");
 }
 function formatExtValue(value, type) {
   if (type === "LINKS" && typeof value === "string") {
     return { primaryLinkUrl: value, primaryLinkLabel: "" };
   }
+  if (type === "CURRENCY") {
+    const amount = typeof value === "number" ? value : Number(String(value ?? "").replace(/[^\d.]/g, ""));
+    if (!Number.isFinite(amount) || amount <= 0) return void 0;
+    return { amountMicros: Math.round(amount * 1e6), currencyCode: "USD" };
+  }
   return value;
 }
 
+// src/lib/retention.ts
+var CREDENTIAL_KEY_PATTERNS = [
+  "password",
+  "passwd",
+  "secret",
+  "token",
+  "apikey",
+  "api_key",
+  "authorization",
+  "auth",
+  "credential",
+  "privatekey",
+  "private_key",
+  "session",
+  "cookie",
+  "ssn",
+  "socialsecurity",
+  "creditcard",
+  "credit_card",
+  "cardnumber",
+  "card_number",
+  "cvv",
+  "cvc",
+  "pin",
+  "accesskey",
+  "access_key"
+];
+var REDACTED = "[redacted]";
+function isCredentialKey(key) {
+  const norm = key.toLowerCase().replace(/[-\s]/g, "_");
+  return CREDENTIAL_KEY_PATTERNS.some((p) => norm.includes(p));
+}
+function redactCredentials(value, depth = 0) {
+  if (depth > 12 || value === null || typeof value !== "object") return value;
+  if (Array.isArray(value)) return value.map((v) => redactCredentials(v, depth + 1));
+  const out = {};
+  for (const [key, v] of Object.entries(value)) {
+    out[key] = isCredentialKey(key) ? REDACTED : redactCredentials(v, depth + 1);
+  }
+  return out;
+}
+function prepareForStorage(payload) {
+  if (rawPayloadRetention() === "NONE") {
+    return { stored: null, warning: null };
+  }
+  let json;
+  try {
+    json = JSON.stringify(redactCredentials(payload));
+  } catch {
+    return { stored: null, warning: "Payload could not be serialised \u2014 not stored, so replay is unavailable for this log" };
+  }
+  const max = rawPayloadMaxBytes();
+  if (Buffer.byteLength(json, "utf8") > max) {
+    return {
+      stored: null,
+      warning: `Payload exceeds INTAKE_RAW_PAYLOAD_MAX_BYTES (${max}) \u2014 not stored, so replay is unavailable for this log`
+    };
+  }
+  return { stored: json, warning: null };
+}
+
+// src/lib/intake-log-writer.ts
+async function writeIntakeLog(input) {
+  const { ctx, status } = input;
+  const retained = prepareForStorage(ctx.rawPayload);
+  if (retained.warning) ctx.warnings.push(retained.warning);
+  try {
+    const created = await coreApi.post("/intakeLogs", {
+      intakeSourceId: ctx.source?.id ?? null,
+      status,
+      payloadHash: ctx.payloadHash ?? "",
+      idempotencyKey: ctx.idempotencyKey ?? null,
+      rawPayload: retained.stored,
+      recordId: ctx.personId ?? ctx.companyId ?? null,
+      recordType: ctx.recordType ?? null,
+      fieldsCreated: ctx.fieldsCreated,
+      fieldsMatched: ctx.fieldsMatched,
+      overflowCount: ctx.noteFields?.length ?? 0,
+      processingMs: Date.now() - ctx.startedAt,
+      processedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      error: input.error ?? null,
+      spamScore: input.spamScore ?? ctx.spam?.score ?? null,
+      quarantineReason: input.quarantineReason ?? null,
+      replayOfLogId: ctx.replayOfLogId ?? null
+    });
+    return created.data?.createIntakeLog?.id ?? null;
+  } catch {
+    ctx.warnings.push("Intake log write failed");
+    return null;
+  }
+}
+async function bumpSourceCounters(sourceId, outcome) {
+  try {
+    const current = await coreApi.get(`/intakeSources/${sourceId}`);
+    const node = current.data?.intakeSource;
+    const patch = {};
+    if (outcome === "ingested") {
+      patch["totalIngested"] = (node?.totalIngested ?? 0) + 1;
+      patch["lastIngestedAt"] = (/* @__PURE__ */ new Date()).toISOString();
+      patch["healthStatus"] = "HEALTHY";
+      patch["silentSince"] = null;
+    } else {
+      patch["totalFailed"] = (node?.totalFailed ?? 0) + 1;
+    }
+    await coreApi.patch(`/intakeSources/${sourceId}`, patch);
+  } catch {
+  }
+}
+
 // src/lib/stages/write-log.stage.ts
 var WriteLogStage = class {
   name = "write-log";
   async execute(ctx) {
-    try {
-      const status = ctx.personId || ctx.companyId ? "SUCCESS" : "PARTIAL";
-      await coreApi.post("/intakeLogs", {
-        intakeSourceId: ctx.source?.id ?? null,
-        status,
-        payloadHash: ctx.payloadHash ?? "",
-        rawPayload: JSON.stringify(ctx.rawPayload).slice(0, 65e3),
-        // cap at 65k chars
-        recordId: ctx.personId ?? ctx.companyId ?? null,
-        recordType: ctx.recordType ?? null,
-        fieldsCreated: ctx.fieldsCreated,
-        fieldsMatched: ctx.fieldsMatched,
-        overflowCount: ctx.noteFields?.length ?? 0,
-        processingMs: Date.now() - ctx.startedAt,
-        processedAt: (/* @__PURE__ */ new Date()).toISOString()
-      });
-    } catch {
-      ctx.warnings.push("Intake log write failed");
-    }
-    if (ctx.source) {
-      try {
-        const current = await coreApi.get(
-          `/intakeSources/${ctx.source.id}`
-        );
-        const current_count = current.data?.intakeSource?.totalIngested ?? 0;
-        await coreApi.patch(`/intakeSources/${ctx.source.id}`, {
-          totalIngested: current_count + 1,
-          lastIngestedAt: (/* @__PURE__ */ new Date()).toISOString()
-        });
-      } catch {
-      }
-    }
+    const status = ctx.personId || ctx.companyId ? "SUCCESS" : "PARTIAL";
+    await writeIntakeLog({ ctx, status });
+    if (ctx.source) await bumpSourceCounters(ctx.source.id, "ingested");
     return ok(ctx);
   }
 };
 
 // src/lib/pipeline-factory.ts
 function createPipeline(coreClient, metadataClient) {
-  return new Pipeline().use(new LoadSourceStage(coreClient)).use(new VerifySignatureStage()).use(new IdempotencyStage(coreClient)).use(new FlattenStage()).use(new NormalizeStage(coreClient)).use(new SyncSchemaStage(metadataClient)).use(new UpsertRecordStage(coreClient)).use(new WriteLogStage(coreClient));
+  return new Pipeline().use(new LoadSourceStage(coreClient)).use(new VerifySignatureStage()).use(new IdempotencyStage(coreClient)).use(new FlattenStage()).use(new NormalizeStage(coreClient)).use(new QuarantineStage()).use(new SyncSchemaStage(metadataClient)).use(new UpsertRecordStage(coreClient)).use(new WriteLogStage(coreClient));
+}
+
+// src/lib/ingest.ts
+async function runIngestion(options) {
+  const ctx = {
+    sourceSlug: options.sourceSlug,
+    rawBody: options.rawBody,
+    rawPayload: options.rawPayload,
+    headers: options.headers ?? {},
+    startedAt: Date.now(),
+    fieldsCreated: 0,
+    fieldsMatched: 0,
+    warnings: [],
+    events: [],
+    ...options.idempotencyKey ? { idempotencyKey: options.idempotencyKey } : {},
+    ...options.skipDedup ? { skipDedup: true } : {},
+    ...options.skipSpamFilter ? { skipSpamFilter: true } : {},
+    ...options.replayOfLogId ? { replayOfLogId: options.replayOfLogId } : {}
+  };
+  const pipeline = createPipeline(new CoreApiClient(), new MetadataApiClient());
+  const result = await pipeline.run(ctx);
+  if (result.ok) return { ok: true, ctx: result.value };
+  await recordFailure(ctx, result.error);
+  return { ok: false, error: result.error, ctx };
+}
+async function recordFailure(ctx, error) {
+  if (error.code === "SOURCE_NOT_FOUND") return;
+  if (error.code === "DUPLICATE_PAYLOAD") return;
+  const details = error.details ?? {};
+  const quarantined = error.code === "QUARANTINED";
+  const status = quarantined ? "QUARANTINED" : "FAILED";
+  await writeIntakeLog({
+    ctx,
+    status,
+    error: `${error.code}: ${error.message}`,
+    spamScore: details.spamScore ?? null,
+    quarantineReason: quarantined ? details.reason ?? error.message : null
+  });
+  if (ctx.source && !quarantined) await bumpSourceCounters(ctx.source.id, "failed");
+}
+function successBody(ctx, startedAt) {
+  return {
+    success: true,
+    recordId: ctx.personId ?? ctx.companyId,
+    recordType: ctx.recordType,
+    personId: ctx.personId,
+    companyId: ctx.companyId,
+    opportunityId: ctx.opportunityId,
+    noteId: ctx.noteId,
+    fieldsCreated: ctx.fieldsCreated,
+    fieldsMatched: ctx.fieldsMatched,
+    overflowCount: ctx.noteFields?.length ?? 0,
+    spamScore: ctx.spam?.score ?? null,
+    mergeDecisions: ctx.mergeDecisions ?? null,
+    processingMs: Date.now() - startedAt,
+    warnings: ctx.warnings
+  };
+}
+
+// src/lib/replay.ts
+async function loadLog(logId) {
+  try {
+    const res = await coreApi.get(`/intakeLogs/${logId}`);
+    return res.data?.intakeLog ?? null;
+  } catch {
+    return null;
+  }
+}
+async function slugForSource(sourceId) {
+  if (!sourceId) return null;
+  try {
+    const res = await coreApi.get(`/intakeSources/${sourceId}`);
+    return res.data?.intakeSource?.slug ?? null;
+  } catch {
+    return null;
+  }
 }
 
 // src/logic-functions/retry.ts
 var handler = async (params) => {
+  const startedAt = Date.now();
   const logId = params.pathParameters?.["logId"];
-  if (!logId) {
-    return { statusCode: 400, body: { error: "Missing logId in URL" } };
-  }
-  const logResult = await coreApi.get(`/intakeLogs/${logId}`).catch(() => null);
-  const log = logResult?.data?.intakeLog;
-  if (!log) {
-    return { statusCode: 404, body: { error: `IntakeLog ${logId} not found` } };
-  }
+  if (!logId) return { statusCode: 400, body: { error: "Missing logId in URL" } };
+  const log = await loadLog(logId);
+  if (!log) return { statusCode: 404, body: { error: `IntakeLog ${logId} not found` } };
   if (log.status === "SUCCESS") {
     return {
       statusCode: 400,
-      body: { error: "This ingestion already succeeded \u2014 no retry needed", status: log.status }
+      body: {
+        error: "This ingestion already succeeded \u2014 no retry needed. Use POST /s/intake/logs/:logId/replay to re-run it through the current rules.",
+        status: log.status
+      }
+    };
+  }
+  if (log.status === "QUARANTINED") {
+    return {
+      statusCode: 400,
+      body: {
+        error: "This payload is quarantined. Use POST /s/intake/quarantine/:logId/release to let it through.",
+        status: log.status
+      }
     };
   }
   if (!log.rawPayload) {
     return {
       statusCode: 400,
-      body: { error: "No raw payload stored on this log \u2014 retry requires rawPayload field (logs created in v0.2.0+)" }
+      body: {
+        error: "No raw payload stored on this log \u2014 retry needs one. Check INTAKE_RAW_PAYLOAD_RETENTION and INTAKE_RAW_PAYLOAD_MAX_BYTES.",
+        code: "NO_STORED_PAYLOAD"
+      }
     };
   }
   let rawPayload;
@@ -1177,56 +1955,31 @@ var handler = async (params) => {
   } catch {
     return { statusCode: 400, body: { error: "rawPayload is not valid JSON" } };
   }
-  let sourceSlug = "unknown";
-  if (log.intakeSourceId) {
-    const srcResult = await coreApi.get(
-      `/intakeSources/${log.intakeSourceId}`
-    ).catch(() => null);
-    sourceSlug = srcResult?.data?.intakeSource?.slug ?? "unknown";
+  const sourceSlug = await slugForSource(log.intakeSourceId);
+  if (!sourceSlug) {
+    return { statusCode: 400, body: { error: "The source for this log no longer exists" } };
   }
-  const startedAt = Date.now();
-  const coreClient = new CoreApiClient();
-  const metadataClient = new MetadataApiClient();
-  const pipeline = createPipeline(coreClient, metadataClient);
-  const ctx = {
+  const outcome = await runIngestion({
     sourceSlug,
-    rawBody: void 0,
-    // HMAC skipped on retry — source already verified originally
     rawPayload,
-    headers: {},
-    startedAt,
+    // The signature was verified when the payload first arrived and there is no
+    // body to re-verify against; the caller here is already authenticated.
     skipDedup: true,
-    // Critical — bypass idempotency so the payload re-runs
-    fieldsCreated: 0,
-    fieldsMatched: 0,
-    warnings: [],
-    events: []
-  };
-  const result = await pipeline.run(ctx);
-  if (!result.ok) {
+    replayOfLogId: log.id
+  });
+  if (!outcome.ok) {
     return {
       statusCode: 500,
       body: {
-        error: `Retry failed: ${result.error.message}`,
-        code: result.error.code,
+        error: `Retry failed: ${outcome.error.message}`,
+        code: outcome.error.code,
         originalLogId: logId
       }
     };
   }
-  const { value: finalCtx } = result;
   return {
     statusCode: 200,
-    body: {
-      success: true,
-      originalLogId: logId,
-      recordId: finalCtx.personId ?? finalCtx.companyId,
-      recordType: finalCtx.recordType,
-      personId: finalCtx.personId,
-      companyId: finalCtx.companyId,
-      fieldsCreated: finalCtx.fieldsCreated,
-      processingMs: Date.now() - startedAt,
-      warnings: finalCtx.warnings
-    }
+    body: { originalLogId: logId, ...successBody(outcome.ctx, startedAt) }
   };
 };
 var retry_default = defineLogicFunction({