twenty-app-intake 0.2.1 → 0.4.0

package/src/logic-functions/replay-log.mjs

@@ -0,0 +1,1987 @@
+import { createRequire as __createRequire } from 'module';
+const require = __createRequire(import.meta.url);
+
+// twenty-sdk-define-stub:__twenty-sdk-define-stub__
+var __defineFactoryStub = (config) => ({
+  success: true,
+  config,
+  errors: []
+});
+var __anyHandler = {
+  get(_target, prop) {
+    if (prop === "__esModule") return true;
+    if (prop === Symbol.toPrimitive) return () => "";
+    if (typeof prop === "symbol") return void 0;
+    return new Proxy(() => void 0, __anyHandler);
+  },
+  apply() {
+    return new Proxy(() => void 0, __anyHandler);
+  }
+};
+var __anyStub = new Proxy(() => void 0, __anyHandler);
+var defineLogicFunction = __defineFactoryStub;
+
+// src/constants/universal-identifiers.ts
+var IDS = {
+  APPLICATION: "96a389dd-384a-43a1-a376-9d3cf01b6ab7",
+  DEFAULT_ROLE: "3dd2cdb0-32c7-44b4-9f7b-0a9c667ec249",
+  // Objects
+  INTAKE_SOURCE_OBJECT: "8c1c227c-db7d-4834-b328-cacbe8af0bfc",
+  INTAKE_LOG_OBJECT: "b77a2439-1503-4ef6-ab8b-8f4293bc19da",
+  INTAKE_FIELD_RULE_OBJECT: "e74df817-ff25-4bfb-bdf0-651662ca327e",
+  // IntakeSource fields
+  INTAKE_SOURCE_NAME: "0deb7e4b-bb90-4c86-b903-5208b42041e2",
+  INTAKE_SOURCE_SLUG: "18f7645b-2dce-4145-b1b6-9cc3332c0578",
+  INTAKE_SOURCE_TARGET_OBJECT: "65f3d7f7-a601-4375-9c67-684d0044620b",
+  INTAKE_SOURCE_SECRET: "4c919402-07f5-4041-ade6-a42402f1881f",
+  INTAKE_SOURCE_STATUS: "6f1fa6fe-02b4-48ab-b1ee-97c600bbf483",
+  INTAKE_SOURCE_CREATE_OPP: "67ae59aa-2275-4ef2-b594-137f6bfafd99",
+  INTAKE_SOURCE_OPP_TEMPLATE: "3907b346-77a6-4c79-a4d7-6e1cc20bb82b",
+  INTAKE_SOURCE_TOTAL_INGESTED: "69655a93-bc70-48bd-874e-aeccc63ee1a8",
+  INTAKE_SOURCE_TOTAL_FAILED: "27b3a499-183e-4cc3-8e40-938f953a986d",
+  INTAKE_SOURCE_LAST_INGESTED: "e167f628-9865-468e-894a-b4b6150cec26",
+  // IntakeLog fields
+  INTAKE_LOG_SOURCE_RELATION: "b1c623ea-7a9a-47a5-bee4-35fdd668a637",
+  INTAKE_LOG_STATUS: "8b6d26d1-f89c-486c-a617-9f9f6a9ca36d",
+  INTAKE_LOG_PAYLOAD_HASH: "c43bb1ad-e78a-4c60-bd95-02475ede7f44",
+  INTAKE_LOG_RECORD_ID: "77a55116-a64b-4954-8369-341022dd5bdd",
+  INTAKE_LOG_RECORD_TYPE: "02154e96-5808-48ed-8838-51083f174550",
+  INTAKE_LOG_FIELDS_CREATED: "2295ca2b-b559-4b38-9771-12dd8d3d76d7",
+  INTAKE_LOG_FIELDS_MATCHED: "83d07a0f-5bcd-4fb1-9759-f9b04b9381d8",
+  INTAKE_LOG_OVERFLOW_COUNT: "4090acb1-f48a-4957-bb91-c642f8f434a7",
+  INTAKE_LOG_PROCESSING_MS: "a9191f27-4b40-42e9-8cce-20c75900e12c",
+  INTAKE_LOG_ERROR: "8d9979f1-9774-43a8-b958-d1b37bd4ecc7",
+  INTAKE_LOG_PROCESSED_AT: "a8d99fbd-722e-4987-8afe-b830ac026f0a",
+  // IntakeFieldRule fields
+  INTAKE_FIELD_RULE_SOURCE_RELATION: "396dd1f1-3873-4efa-a6bb-7b41eda14d83",
+  INTAKE_FIELD_RULE_INPUT_PATTERN: "757201a0-9f64-47b9-bf3a-a793074bf84e",
+  INTAKE_FIELD_RULE_CANONICAL_NAME: "fafebc55-a2cc-4c9f-975b-050c2676659d",
+  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",
+  REGISTER_LOGIC_FUNCTION: "56d46e18-6cae-4d99-9893-b7d70740c9db",
+  // IntakeSource reverse relation fields
+  INTAKE_SOURCE_LOGS_REVERSE: "6ecfa369-22e0-4812-bb75-4338cea8be65",
+  INTAKE_SOURCE_RULES_REVERSE: "776fefaf-0eee-4ec0-93e0-d11bd80c1e20",
+  // v0.2.0 — rawPayload + retry + post-install + UI
+  INTAKE_LOG_RAW_PAYLOAD: "b65c9e1c-f2c1-4c52-a5b3-1e1ac3139692",
+  RETRY_LOGIC_FUNCTION: "90f20396-a69a-4ae4-af20-6be65c565bb5",
+  POST_INSTALL_LOGIC_FUNCTION: "e836fdd6-fd54-4aa4-ba6d-87d5a02148ef",
+  LOG_RETRY_FRONT_COMPONENT: "0cb97f6d-30e2-48c8-90e1-241b82870b4d",
+  FIELD_RULES_TABLE_FRONT_COMPONENT: "c35faad9-3468-4746-9c1c-b13d73e5e09b",
+  SOURCE_PAGE_LAYOUT: "8c894ba8-5c8c-45ed-b0af-1d22ede93eb9",
+  SOURCE_LAYOUT_TAB_RULES: "80f5c49a-083c-4062-8bd5-ae158abb6c33",
+  SOURCE_LAYOUT_TAB_RULES_WIDGET: "26a9ebb7-1d59-4b03-a018-56968f6df224",
+  LOG_PAGE_LAYOUT: "b0972802-ede5-463c-9f59-cb05f04957db",
+  LOG_LAYOUT_TAB_RETRY: "6b109695-ba3a-43de-a31a-23119ccf87ba",
+  LOG_LAYOUT_TAB_RETRY_WIDGET: "11727c1a-5145-46de-9742-88d07d64c72e",
+  SAMPLE_RULE_PHONE: "8440da8d-8ac4-4f4b-baa2-4d62936cde35",
+  SAMPLE_RULE_EMAIL: "d123cde4-05aa-44e1-86f6-454be1d7048b",
+  SAMPLE_RULE_FULLNAME: "00e49fe8-1b48-4f5b-aaf4-414d0923c712",
+  // Views & Navigation
+  SOURCES_VIEW: "4435cd43-5c13-472f-b4f9-b686c0f46285",
+  LOGS_VIEW: "a2cd0a93-9778-4ba5-99d9-b8b89c4fb39d",
+  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 = [];
+  use(stage) {
+    this.stages.push(stage);
+    return this;
+  }
+  async run(initial) {
+    let ctx = initial;
+    for (const stage of this.stages) {
+      const result = await stage.execute(ctx);
+      if (!result.ok) {
+        return {
+          ok: false,
+          error: { ...result.error, stage: stage.name }
+        };
+      }
+      ctx = result.value;
+      ctx.events.push({ stage: stage.name, message: "completed" });
+    }
+    return { ok: true, value: ctx };
+  }
+};
+
+// src/lib/result.ts
+var ErrorCode = {
+  INVALID_SIGNATURE: "INVALID_SIGNATURE",
+  INVALID_PAYLOAD: "INVALID_PAYLOAD",
+  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",
+  SCHEMA_FETCH_FAILED: "SCHEMA_FETCH_FAILED",
+  INTERNAL_ERROR: "INTERNAL_ERROR"
+};
+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;
+  }
+  client;
+  name = "load-source";
+  async execute(ctx) {
+    const node = await this.fetch(ctx.sourceSlug);
+    if (!node) {
+      return err(ErrorCode.SOURCE_NOT_FOUND, `No Intake source found with slug "${ctx.sourceSlug}"`);
+    }
+    if (node.status === "PAUSED") {
+      return err(ErrorCode.SOURCE_PAUSED, `Source "${node.name}" is paused`);
+    }
+    return ok({
+      ...ctx,
+      source: {
+        id: node.id,
+        name: node.name,
+        slug: node.slug,
+        targetObject: node.targetObject,
+        webhookSecret: node.webhookSecret ?? null,
+        status: node.status,
+        createOpportunity: node.createOpportunity ?? true,
+        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";
+var VerifySignatureStage = class {
+  name = "verify-signature";
+  async execute(ctx) {
+    const secret = ctx.source?.webhookSecret;
+    const requireHmac = process.env["INTAKE_REQUIRE_HMAC"] === "true";
+    if (!secret) {
+      if (requireHmac) return err(ErrorCode.INVALID_SIGNATURE, "This source has no webhook secret \u2014 INTAKE_REQUIRE_HMAC is enabled");
+      return ok(ctx);
+    }
+    const signature = ctx.headers["x-webhook-signature"];
+    if (!signature) {
+      return err(ErrorCode.INVALID_SIGNATURE, "Missing X-Webhook-Signature header");
+    }
+    if (!ctx.rawBody) {
+      ctx.warnings.push("rawBody unavailable \u2014 skipping HMAC verification");
+      return ok(ctx);
+    }
+    const expected = createHmac("sha256", secret).update(ctx.rawBody).digest("hex");
+    const sigBuf = Buffer.from(signature.replace(/^sha256=/, ""));
+    const expBuf = Buffer.from(expected);
+    if (sigBuf.length !== expBuf.length || !timingSafeEqual(sigBuf, expBuf)) {
+      return err(ErrorCode.INVALID_SIGNATURE, "Webhook signature verification failed");
+    }
+    return ok(ctx);
+  }
+};
+
+// src/lib/idempotency.ts
+import { createHash } from "node:crypto";
+function computePayloadHash(payload) {
+  const stable = stableStringify(payload);
+  return createHash("sha256").update(stable).digest("hex");
+}
+function stableStringify(value) {
+  if (value === null || value === void 0) return String(value);
+  if (typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) {
+    return "[" + value.map(stableStringify).join(",") + "]";
+  }
+  const obj = value;
+  const sorted = Object.keys(obj).sort().map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k])}`).join(",");
+  return "{" + sorted + "}";
+}
+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) {
+    this.client = client;
+  }
+  client;
+  name = "idempotency";
+  async execute(ctx) {
+    const hash = computePayloadHash(ctx.rawPayload);
+    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 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 ${String(prior.status).toLowerCase()} (log ${prior.id})`,
+        { priorLogId: prior.id, priorRecordId: prior.recordId }
+      );
+    }
+    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;
+    }
+  }
+};
+
+// src/lib/flattener.ts
+var MAX_DEPTH = 8;
+function flatten(input, prefix = "", depth = 0, seen = /* @__PURE__ */ new WeakSet()) {
+  if (depth > MAX_DEPTH) return {};
+  if (input === null || input === void 0) return {};
+  if (typeof input !== "object") {
+    return prefix ? { [prefix]: input } : {};
+  }
+  if (Array.isArray(input)) {
+    return prefix ? { [prefix]: input } : {};
+  }
+  const obj = input;
+  if (seen.has(obj)) return {};
+  seen.add(obj);
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const newKey = prefix ? `${prefix}${toPascalSegment(key)}` : toCamelSegment(key);
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      const nested = flatten(value, newKey, depth + 1, seen);
+      Object.assign(result, nested);
+    } else {
+      result[newKey] = value;
+    }
+  }
+  return result;
+}
+function toCamelSegment(s) {
+  return s.replace(/[-_]([a-zA-Z0-9])/g, (_, c) => c.toUpperCase());
+}
+function toPascalSegment(s) {
+  const camel = toCamelSegment(s);
+  return camel.charAt(0).toUpperCase() + camel.slice(1);
+}
+function detectStructure(raw) {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+    return { type: "flat", data: {} };
+  }
+  const obj = raw;
+  const hasObjectCompany = "company" in obj && typeof obj["company"] === "object" && obj["company"] !== null && !Array.isArray(obj["company"]);
+  const hasObjectPerson = "person" in obj && typeof obj["person"] === "object" && obj["person"] !== null && !Array.isArray(obj["person"]);
+  if (!hasObjectCompany && !hasObjectPerson) {
+    return { type: "flat", data: flatten(obj) };
+  }
+  const company = hasObjectCompany ? obj["company"] : null;
+  const person = hasObjectPerson ? obj["person"] : null;
+  const extra = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (k === "company" || k === "person") continue;
+    const nested = flatten({ [k]: v });
+    Object.assign(extra, nested);
+  }
+  return { type: "structured", company, person, extra };
+}
+
+// src/lib/stages/flatten.stage.ts
+var FlattenStage = class {
+  name = "flatten";
+  async execute(ctx) {
+    const structure = detectStructure(ctx.rawPayload);
+    if (structure.type === "structured") {
+      const extraFlat = flatten(structure.extra ?? {});
+      return ok({
+        ...ctx,
+        structuredCompany: structure.company ?? void 0,
+        structuredPerson: structure.person ?? void 0,
+        flat: extraFlat
+      });
+    }
+    return ok({ ...ctx, flat: structure.data });
+  }
+};
+
+// src/constants/field-map.ts
+function normaliseKey(key) {
+  return key.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/[-\s.]/g, "_").replace(/_{2,}/g, "_");
+}
+var FIELD_MAP = {
+  // ── Phone ─────────────────────────────────────────────────────────────────
+  phone: { canonicalName: "phone", twentyType: "PHONES", action: "field" },
+  phone_number: { canonicalName: "phone", twentyType: "PHONES", action: "field" },
+  tel: { canonicalName: "phone", twentyType: "PHONES", action: "field" },
+  telephone: { canonicalName: "phone", twentyType: "PHONES", action: "field" },
+  mobile: { canonicalName: "phone", twentyType: "PHONES", action: "field" },
+  mobile_number: { canonicalName: "phone", twentyType: "PHONES", action: "field" },
+  cell: { canonicalName: "phone", twentyType: "PHONES", action: "field" },
+  cell_phone: { canonicalName: "phone", twentyType: "PHONES", action: "field" },
+  contact_phone: { canonicalName: "phone", twentyType: "PHONES", action: "field" },
+  phone1: { canonicalName: "phone", twentyType: "PHONES", action: "field" },
+  primary_phone: { canonicalName: "phone", twentyType: "PHONES", action: "field" },
+  // ── Email ─────────────────────────────────────────────────────────────────
+  email: { canonicalName: "email", twentyType: "EMAILS", action: "field" },
+  email_address: { canonicalName: "email", twentyType: "EMAILS", action: "field" },
+  e_mail: { canonicalName: "email", twentyType: "EMAILS", action: "field" },
+  contact_email: { canonicalName: "email", twentyType: "EMAILS", action: "field" },
+  email1: { canonicalName: "email", twentyType: "EMAILS", action: "field" },
+  user_email: { canonicalName: "email", twentyType: "EMAILS", action: "field" },
+  primary_email: { canonicalName: "email", twentyType: "EMAILS", action: "field" },
+  // ── First name ────────────────────────────────────────────────────────────
+  first_name: { canonicalName: "firstName", twentyType: "TEXT", action: "field" },
+  fname: { canonicalName: "firstName", twentyType: "TEXT", action: "field" },
+  given_name: { canonicalName: "firstName", twentyType: "TEXT", action: "field" },
+  forename: { canonicalName: "firstName", twentyType: "TEXT", action: "field" },
+  // ── Last name ─────────────────────────────────────────────────────────────
+  last_name: { canonicalName: "lastName", twentyType: "TEXT", action: "field" },
+  lname: { canonicalName: "lastName", twentyType: "TEXT", action: "field" },
+  surname: { canonicalName: "lastName", twentyType: "TEXT", action: "field" },
+  family_name: { canonicalName: "lastName", twentyType: "TEXT", action: "field" },
+  // ── Full name (will be split on ingest) ───────────────────────────────────
+  name: { canonicalName: "fullName", twentyType: "FULL_NAME", action: "field" },
+  full_name: { canonicalName: "fullName", twentyType: "FULL_NAME", action: "field" },
+  contact_name: { canonicalName: "fullName", twentyType: "FULL_NAME", action: "field" },
+  your_name: { canonicalName: "fullName", twentyType: "FULL_NAME", action: "field" },
+  // ── Company ───────────────────────────────────────────────────────────────
+  company: { canonicalName: "companyName", twentyType: "TEXT", action: "field" },
+  company_name: { canonicalName: "companyName", twentyType: "TEXT", action: "field" },
+  business: { canonicalName: "companyName", twentyType: "TEXT", action: "field" },
+  business_name: { canonicalName: "companyName", twentyType: "TEXT", action: "field" },
+  organization: { canonicalName: "companyName", twentyType: "TEXT", action: "field" },
+  organisation: { canonicalName: "companyName", twentyType: "TEXT", action: "field" },
+  employer: { canonicalName: "companyName", twentyType: "TEXT", action: "field" },
+  firm: { canonicalName: "companyName", twentyType: "TEXT", action: "field" },
+  // ── Website / Domain ──────────────────────────────────────────────────────
+  website: { canonicalName: "domainName", twentyType: "LINKS", action: "field" },
+  website_url: { canonicalName: "domainName", twentyType: "LINKS", action: "field" },
+  url: { canonicalName: "domainName", twentyType: "LINKS", action: "field" },
+  domain: { canonicalName: "domainName", twentyType: "LINKS", action: "field" },
+  homepage: { canonicalName: "domainName", twentyType: "LINKS", action: "field" },
+  web: { canonicalName: "domainName", twentyType: "LINKS", action: "field" },
+  site: { canonicalName: "domainName", twentyType: "LINKS", action: "field" },
+  site_url: { canonicalName: "domainName", twentyType: "LINKS", action: "field" },
+  // ── Address ───────────────────────────────────────────────────────────────
+  street: { canonicalName: "addressStreet1", twentyType: "TEXT", action: "field" },
+  street_address: { canonicalName: "addressStreet1", twentyType: "TEXT", action: "field" },
+  address_line_1: { canonicalName: "addressStreet1", twentyType: "TEXT", action: "field" },
+  address1: { canonicalName: "addressStreet1", twentyType: "TEXT", action: "field" },
+  address_line_2: { canonicalName: "addressStreet2", twentyType: "TEXT", action: "field" },
+  address2: { canonicalName: "addressStreet2", twentyType: "TEXT", action: "field" },
+  city: { canonicalName: "addressCity", twentyType: "TEXT", action: "field" },
+  address_city: { canonicalName: "addressCity", twentyType: "TEXT", action: "field" },
+  town: { canonicalName: "addressCity", twentyType: "TEXT", action: "field" },
+  state: { canonicalName: "addressState", twentyType: "TEXT", action: "field" },
+  province: { canonicalName: "addressState", twentyType: "TEXT", action: "field" },
+  region: { canonicalName: "addressState", twentyType: "TEXT", action: "field" },
+  address_state: { canonicalName: "addressState", twentyType: "TEXT", action: "field" },
+  zip: { canonicalName: "addressPostcode", twentyType: "TEXT", action: "field" },
+  zip_code: { canonicalName: "addressPostcode", twentyType: "TEXT", action: "field" },
+  postal_code: { canonicalName: "addressPostcode", twentyType: "TEXT", action: "field" },
+  postcode: { canonicalName: "addressPostcode", twentyType: "TEXT", action: "field" },
+  country: { canonicalName: "addressCountry", twentyType: "TEXT", action: "field" },
+  address_country: { canonicalName: "addressCountry", twentyType: "TEXT", action: "field" },
+  // ── Social ────────────────────────────────────────────────────────────────
+  linkedin: { canonicalName: "linkedInLink", twentyType: "LINKS", action: "field" },
+  linkedin_url: { canonicalName: "linkedInLink", twentyType: "LINKS", action: "field" },
+  linkedin_profile: { canonicalName: "linkedInLink", twentyType: "LINKS", action: "field" },
+  twitter: { canonicalName: "xLink", twentyType: "LINKS", action: "field" },
+  twitter_url: { canonicalName: "xLink", twentyType: "LINKS", action: "field" },
+  x_profile: { canonicalName: "xLink", twentyType: "LINKS", action: "field" },
+  // ── Pipeline-specific (Google / business intel) ───────────────────────────
+  google_places_url: { canonicalName: "extGooglePlacesUrl", twentyType: "LINKS", action: "field" },
+  places_url: { canonicalName: "extGooglePlacesUrl", twentyType: "LINKS", action: "field" },
+  google_maps_url: { canonicalName: "extGooglePlacesUrl", twentyType: "LINKS", action: "field" },
+  maps_url: { canonicalName: "extGooglePlacesUrl", twentyType: "LINKS", action: "field" },
+  rating: { canonicalName: "extGoogleRating", twentyType: "NUMBER", action: "field" },
+  google_rating: { canonicalName: "extGoogleRating", twentyType: "NUMBER", action: "field" },
+  stars: { canonicalName: "extGoogleRating", twentyType: "NUMBER", action: "field" },
+  review_count: { canonicalName: "extReviewCount", twentyType: "NUMBER", action: "field" },
+  reviews_count: { canonicalName: "extReviewCount", twentyType: "NUMBER", action: "field" },
+  total_reviews: { canonicalName: "extReviewCount", twentyType: "NUMBER", action: "field" },
+  num_reviews: { canonicalName: "extReviewCount", twentyType: "NUMBER", action: "field" },
+  marketing_score: { canonicalName: "extMarketingScore", twentyType: "NUMBER", action: "field" },
+  lead_score: { canonicalName: "extLeadScore", twentyType: "NUMBER", action: "field" },
+  analyzed_url: { canonicalName: "extAnalyzedUrl", twentyType: "LINKS", action: "field" },
+  // ── UTM — always captured in note ────────────────────────────────────────
+  utm_source: { canonicalName: "utm_source", twentyType: "TEXT", action: "note" },
+  utm_medium: { canonicalName: "utm_medium", twentyType: "TEXT", action: "note" },
+  utm_campaign: { canonicalName: "utm_campaign", twentyType: "TEXT", action: "note" },
+  utm_content: { canonicalName: "utm_content", twentyType: "TEXT", action: "note" },
+  utm_term: { canonicalName: "utm_term", twentyType: "TEXT", action: "note" },
+  ref: { canonicalName: "ref", twentyType: "TEXT", action: "note" },
+  referrer: { canonicalName: "referrer", twentyType: "TEXT", action: "note" },
+  source_page: { canonicalName: "source_page", twentyType: "TEXT", action: "note" },
+  landing_page: { canonicalName: "landing_page", twentyType: "TEXT", action: "note" },
+  // ── Known note fields — always prose ─────────────────────────────────────
+  message: { canonicalName: "message", twentyType: "RICH_TEXT", action: "note" },
+  description: { canonicalName: "description", twentyType: "RICH_TEXT", action: "note" },
+  analysis: { canonicalName: "analysis", twentyType: "RICH_TEXT", action: "note" },
+  notes: { canonicalName: "notes", twentyType: "RICH_TEXT", action: "note" },
+  comments: { canonicalName: "comments", twentyType: "RICH_TEXT", action: "note" },
+  summary: { canonicalName: "summary", twentyType: "RICH_TEXT", action: "note" },
+  inquiry: { canonicalName: "inquiry", twentyType: "RICH_TEXT", action: "note" },
+  body: { canonicalName: "body", twentyType: "RICH_TEXT", action: "note" },
+  details: { canonicalName: "details", twentyType: "RICH_TEXT", action: "note" },
+  content: { canonicalName: "content", twentyType: "RICH_TEXT", action: "note" },
+  text: { canonicalName: "text", twentyType: "RICH_TEXT", action: "note" },
+  feedback: { canonicalName: "feedback", twentyType: "RICH_TEXT", action: "note" },
+  about: { canonicalName: "about", twentyType: "RICH_TEXT", action: "note" },
+  additional_info: { canonicalName: "additional_info", twentyType: "RICH_TEXT", action: "note" },
+  // ── System / internal — skip entirely ────────────────────────────────────
+  _id: { canonicalName: "_id", twentyType: "TEXT", action: "skip" },
+  __v: { canonicalName: "__v", twentyType: "TEXT", action: "skip" },
+  created_at: { canonicalName: "createdAt", twentyType: "DATE_TIME", action: "skip" },
+  updated_at: { canonicalName: "updatedAt", twentyType: "DATE_TIME", action: "skip" },
+  form_id: { canonicalName: "form_id", twentyType: "TEXT", action: "skip" },
+  submission_id: { canonicalName: "submission_id", twentyType: "TEXT", action: "skip" },
+  token: { canonicalName: "token", twentyType: "TEXT", action: "skip" },
+  password: { canonicalName: "password", twentyType: "TEXT", action: "skip" },
+  secret: { canonicalName: "secret", twentyType: "TEXT", action: "skip" }
+};
+
+// src/lib/type-detector.ts
+var URL_RE = /^https?:\/\/[^\s/$.?#].[^\s]*$/i;
+var EMAIL_RE = /^[^@\s]+@[^@\s]+\.[^@\s]{2,}$/;
+var PHONE_RE = /^[+]?[(]?[0-9]{1,4}[)]?[-\s.]?[(]?[0-9]{1,4}[)]?[-\s.]?[0-9]{3,9}([-\s.][0-9]{1,9})?$/;
+var DATE_RE = /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}(:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})?)?)?$/;
+function detectType(value) {
+  if (value === null || value === void 0) return "TEXT";
+  if (typeof value === "boolean") return "BOOLEAN";
+  if (typeof value === "number") return "NUMBER";
+  if (typeof value === "string") {
+    const s = value.trim();
+    if (!s) return "TEXT";
+    if (URL_RE.test(s)) return "LINKS";
+    if (EMAIL_RE.test(s)) return "EMAILS";
+    if (PHONE_RE.test(s)) return "PHONES";
+    if (DATE_RE.test(s)) return "DATE_TIME";
+    if (!isNaN(Number(s)) && s !== "") return "NUMBER";
+    return "TEXT";
+  }
+  if (Array.isArray(value)) return "RAW_JSON";
+  if (typeof value === "object") return "RAW_JSON";
+  return "TEXT";
+}
+
+// src/lib/classifier.ts
+var PROSE_KEYS = /* @__PURE__ */ new Set([
+  "message",
+  "description",
+  "analysis",
+  "notes",
+  "comments",
+  "summary",
+  "inquiry",
+  "body",
+  "details",
+  "content",
+  "text",
+  "feedback",
+  "about",
+  "additional_info",
+  "info",
+  "context",
+  "requirements",
+  "goals",
+  "challenges",
+  "question",
+  "request"
+]);
+var NOTE_KEY_PREFIXES = ["utm_", "ga_", "fb_", "gclid", "msclkid"];
+var SENTENCE_RE = /[.!?]\s+[A-Z]/g;
+var LINE_BREAK_RE = /\n|\r/;
+function classify(key, value) {
+  const normKey = key.toLowerCase().replace(/[-\s]/g, "_");
+  if (Array.isArray(value)) return "note";
+  if (value !== null && typeof value === "object") return "note";
+  if (PROSE_KEYS.has(normKey)) return "note";
+  if (NOTE_KEY_PREFIXES.some((p) => normKey.startsWith(p))) return "note";
+  if (typeof value === "string") {
+    if (LINE_BREAK_RE.test(value)) return "note";
+    const matches = value.match(SENTENCE_RE);
+    if (matches && matches.length >= 2) return "note";
+  }
+  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(
+    ([key, value]) => normalizeField(key, value, sorted)
+  );
+}
+function normalizeField(key, value, rules) {
+  const lookupKey = normaliseKey(key);
+  const builtIn = FIELD_MAP[lookupKey];
+  if (builtIn) {
+    return {
+      originalKey: key,
+      canonicalName: builtIn.canonicalName,
+      twentyType: builtIn.twentyType,
+      action: builtIn.action,
+      value,
+      source: "builtin",
+      targetObject: "auto"
+    };
+  }
+  for (const rule of rules) {
+    let matches = false;
+    try {
+      matches = rule.inputPattern === key || rule.inputPattern === lookupKey || new RegExp(rule.inputPattern, "i").test(key);
+    } catch {
+      matches = rule.inputPattern === key;
+    }
+    if (matches) {
+      return {
+        originalKey: key,
+        canonicalName: rule.canonicalName,
+        twentyType: typeForRule(rule),
+        action: actionForRule(rule),
+        value,
+        source: "rule",
+        targetObject: parseTargetObject(rule.targetObject),
+        mergeStrategy: parseFieldMergeStrategy(rule.mergeStrategy)
+      };
+    }
+  }
+  const detectedType = detectType(value);
+  const classification = classify(key, value);
+  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",
+    targetObject
+  };
+}
+function toExtFieldName(key) {
+  const cleaned = key.replace(/[-_\s]+([a-zA-Z0-9])/g, (_, c) => c.toUpperCase()).replace(/[^a-zA-Z0-9]/g, "");
+  return "ext" + cleaned.charAt(0).toUpperCase() + cleaned.slice(1);
+}
+function partition(fields) {
+  const crmFields = [];
+  const noteFields = [];
+  const skipped = [];
+  for (const f of fields) {
+    if (f.action === "skip") skipped.push(f);
+    else if (f.action === "note") noteFields.push(f);
+    else crmFields.push(f);
+  }
+  return { crmFields, noteFields, skipped };
+}
+function assembleComposites(crmFields) {
+  const assembled = {};
+  const consumed = /* @__PURE__ */ new Set();
+  const firstName = crmFields.find((f) => f.canonicalName === "firstName");
+  const lastName = crmFields.find((f) => f.canonicalName === "lastName");
+  const fullName = crmFields.find((f) => f.canonicalName === "fullName");
+  if (fullName && !firstName && !lastName) {
+    const parts = splitFullName(String(fullName.value ?? ""));
+    assembled["name"] = { firstName: parts[0], lastName: parts[1] };
+    consumed.add("fullName");
+  } else if (firstName || lastName) {
+    assembled["name"] = {
+      firstName: String(firstName?.value ?? ""),
+      lastName: String(lastName?.value ?? "")
+    };
+    if (firstName) consumed.add("firstName");
+    if (lastName) consumed.add("lastName");
+  }
+  const email = crmFields.find((f) => f.canonicalName === "email");
+  if (email) {
+    assembled["emails"] = { primaryEmail: String(email.value ?? "") };
+    consumed.add("email");
+  }
+  const phone = crmFields.find((f) => f.canonicalName === "phone");
+  if (phone) {
+    const raw = String(phone.value ?? "");
+    assembled["phones"] = {
+      primaryPhoneNumber: raw.replace(/\D/g, "").slice(-10),
+      primaryPhoneCountryCode: "US",
+      primaryPhoneCallingCode: "+1"
+    };
+    consumed.add("phone");
+  }
+  const domain = crmFields.find((f) => f.canonicalName === "domainName");
+  if (domain) {
+    assembled["domainName"] = {
+      primaryLinkUrl: String(domain.value ?? ""),
+      primaryLinkLabel: ""
+    };
+    consumed.add("domainName");
+  }
+  const addressFields = [
+    ["addressStreet1", "addressStreet1"],
+    ["addressStreet2", "addressStreet2"],
+    ["addressCity", "addressCity"],
+    ["addressState", "addressState"],
+    ["addressPostcode", "addressPostcode"],
+    ["addressCountry", "addressCountry"]
+  ];
+  const addressParts = {};
+  for (const [canonical, outKey] of addressFields) {
+    const f = crmFields.find((x) => x.canonicalName === canonical);
+    if (f) {
+      addressParts[outKey] = f.value;
+      consumed.add(canonical);
+    }
+  }
+  if (Object.keys(addressParts).length > 0) {
+    assembled["address"] = addressParts;
+  }
+  const remainder = crmFields.filter((f) => !consumed.has(f.canonicalName));
+  return { assembled, remainder };
+}
+function splitFullName(fullName) {
+  const parts = fullName.trim().split(/\s+/);
+  if (parts.length === 0) return ["", ""];
+  if (parts.length === 1) return [parts[0] ?? "", ""];
+  const lastName = parts.pop() ?? "";
+  return [parts.join(" "), lastName];
+}
+
+// src/lib/stages/normalize.stage.ts
+var NormalizeStage = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  name = "normalize";
+  async execute(ctx) {
+    if (!ctx.flat) {
+      return err(ErrorCode.INTERNAL_ERROR, "FlattenStage must run before NormalizeStage");
+    }
+    const rules = await this.loadRules(ctx.source?.id);
+    const normalized = normalizeFields(ctx.flat, rules);
+    const { crmFields, noteFields } = partition(normalized);
+    return ok({
+      ...ctx,
+      normalizedFields: normalized,
+      crmFields,
+      noteFields
+    });
+  }
+  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({
+        intakeFieldRules: {
+          __args: {
+            filter: { and: [filter, { isActive: { eq: true } }] },
+            orderBy: { priority: "DescNullsLast" }
+          },
+          edges: {
+            node: {
+              inputPattern: true,
+              canonicalName: true,
+              fieldType: true,
+              priority: true
+            }
+          }
+        }
+      });
+      return (result.intakeFieldRules?.edges ?? []).map((e) => e.node);
+    } catch {
+      return [];
+    }
+  }
+};
+
+// 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
+      };
+    }
+  }
+  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 };
+}
+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([
+  "name",
+  "emails",
+  "phones",
+  "domainName",
+  "address",
+  "linkedInLink",
+  "xLink",
+  "companyName",
+  "firstName",
+  "lastName",
+  "fullName",
+  "jobTitle",
+  "city",
+  "employees",
+  "annualRecurringRevenue",
+  "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);
+    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");
+    }
+    const resolved = ctx.crmFields.map((f) => ({
+      ...f,
+      targetObject: this.resolveTarget(f.targetObject, primary, ctx)
+    }));
+    let fieldsCreated = 0;
+    let fieldsMatched = 0;
+    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) {
+        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);
+      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 (meta.fields.has(name)) {
+          field.writable = true;
+          fieldsMatched++;
+          continue;
+        }
+        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 (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, name, field.twentyType);
+        if (created) {
+          meta.fields.add(name);
+          this.objectCache.get(objectName)?.fields.add(name);
+          extCount++;
+          fieldsCreated++;
+          field.writable = true;
+        } else {
+          ctx.warnings.push(`Could not create field "${name}" on ${objectName} \u2014 will go to note`);
+          demoted.push(field);
+        }
+      }
+    }
+    const demotedSet = new Set(demoted);
+    return ok({
+      ...ctx,
+      crmFields: resolved.filter((f) => !demotedSet.has(f)),
+      noteFields: [...ctx.noteFields ?? [], ...demoted],
+      fieldsCreated,
+      fieldsMatched
+    });
+  }
+  /** 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";
+    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));
+    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);
+    if (cached && Date.now() - cached.at < this.TTL) return cached;
+    try {
+      const res = await metaApi.get("/objects");
+      const objects = Array.isArray(res) ? res : res.data ?? [];
+      const node = objects.find((o) => o.nameSingular === objectName);
+      if (!node) return null;
+      const fields = new Set((node.fields ?? []).map((f) => f.name));
+      const entry = { id: node.id, fields, at: Date.now() };
+      this.objectCache.set(objectName, entry);
+      return entry;
+    } catch {
+      return null;
+    }
+  }
+  async createField(objectMetadataId, name, type) {
+    try {
+      await metaApi.post("/fields", {
+        objectMetadataId,
+        name,
+        label: toLabel(name),
+        type,
+        description: "Auto-created by Intake",
+        icon: "IconPlug"
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+function toLabel(name) {
+  return name.replace(/^ext_/, "").replace(/_/g, " ").replace(/([A-Z])/g, " $1").split(" ").map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join(" ").trim();
+}
+
+// src/lib/note-formatter.ts
+function formatNote(sourceName, fields) {
+  const lines = [];
+  lines.push(`**Source:** ${sourceName}`);
+  const entries = buildEntries(fields);
+  for (const { label, value } of entries) {
+    const formatted = formatValue(value);
+    if (formatted !== null) {
+      lines.push(`**${label}:** ${formatted}`);
+    }
+  }
+  return lines.join("\n");
+}
+function buildEntries(fields) {
+  return Object.entries(fields).map(([key, value]) => ({
+    label: toLabel2(key),
+    value
+  }));
+}
+function toLabel2(key) {
+  return key.replace(/^ext_/, "").replace(/_/g, " ").replace(/([A-Z])/g, " $1").split(" ").map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join(" ").trim();
+}
+function formatValue(value) {
+  if (value === null || value === void 0 || value === "") return null;
+  if (Array.isArray(value)) return value.join(", ");
+  if (typeof value === "object") {
+    try {
+      return JSON.stringify(value, null, 2);
+    } catch {
+      return String(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) {
+    if (!ctx.crmFields) return err(ErrorCode.INTERNAL_ERROR, "No CRM fields to upsert");
+    const cleanFields = ctx.crmFields.filter((f) => !f.originalKey.startsWith("__"));
+    const { assembled, remainder } = assembleComposites(cleanFields);
+    for (const f of remainder) assembled[f.canonicalName] = f.value;
+    const structuredCompany = ctx.structuredCompany;
+    const structuredPerson = ctx.structuredPerson;
+    const rawCompanyName = structuredCompany?.["name"] ?? assembled["companyName"];
+    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 (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, 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, customFor("person"), ctx, patchExisting);
+      }
+      let opportunityId;
+      if (ctx.source?.createOpportunity && (personId || companyId)) {
+        opportunityId = await this.createOpportunity(assembled, personId, companyId, ctx.crmFields ?? [], customFor("opportunity"), ctx);
+      }
+      let noteId;
+      const noteFields = ctx.noteFields ?? [];
+      if (noteFields.length > 0) {
+        const overflow = {};
+        for (const f of noteFields) overflow[f.canonicalName] = f.value;
+        noteId = await this.createNote(overflow, personId, companyId, ctx);
+      }
+      return ok({
+        ...ctx,
+        personId,
+        companyId,
+        opportunityId,
+        noteId,
+        recordType: personId ? "PERSON" : "COMPANY"
+      });
+    } catch (e) {
+      return err(ErrorCode.RECORD_UPSERT_FAILED, `Failed to upsert record: ${String(e)}`);
+    }
+  }
+  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"];
+    if (!standard["address"] && assembled["address"]) standard["address"] = assembled["address"];
+    const domain = standard["domainName"]?.["primaryLinkUrl"];
+    let companyId;
+    if (domain) {
+      const existing = await findCompanyByDomain(domain);
+      if (existing) {
+        await patchExisting("companies", "company", existing, { ...standard, ...customData });
+        return existing.id;
+      }
+    }
+    if (!companyId) {
+      try {
+        const created = await coreApi.post("/companies", standard);
+        companyId = created.data.createCompany.id;
+      } catch (e) {
+        if (String(e).toLowerCase().includes("duplicate") && standard["name"]) {
+          try {
+            const found = await gql(
+              `query FindCompany($name: String!) { companies(filter: { name: { eq: $name } }) { edges { node { id } } } }`,
+              { name: String(standard["name"]) }
+            );
+            companyId = found.data?.companies?.edges?.[0]?.node?.id;
+          } catch {
+          }
+        }
+        if (!companyId) throw e;
+      }
+    }
+    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, 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"];
+    if (!standard["phones"] && assembled["phones"]) standard["phones"] = assembled["phones"];
+    if (companyId) standard["companyId"] = companyId;
+    const emails = standard["emails"] ?? assembled["emails"];
+    const email = emails?.["primaryEmail"];
+    let personId;
+    if (email) {
+      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 (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, crmFields, customData, ctx) {
+    let opportunityId;
+    try {
+      const name = buildOpportunityName(ctx, assembled);
+      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);
+      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 label = appLabel();
+      const created = await coreApi.post("/notes", {
+        title: `${ctx.source?.name ?? label} \u2014 Lead`,
+        bodyV2: { markdown }
+      });
+      const noteId = created.data.createNote.id;
+      if (personId) {
+        await coreApi.post("/noteTargets", { noteId, personId }).catch(() => null);
+      }
+      if (companyId) {
+        await coreApi.post("/noteTargets", { noteId, companyId }).catch(() => null);
+      }
+      return noteId;
+    } catch {
+      ctx.warnings.push("Note creation failed \u2014 record was still created");
+      return void 0;
+    }
+  }
+};
+function buildOpportunityName(ctx, assembled) {
+  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 ?? 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) {
+    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 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");
+}
+
+// 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;
+  }
+}
+async function replayLog(log) {
+  if (!log.rawPayload) {
+    return {
+      logId: log.id,
+      ok: false,
+      reason: "No stored payload \u2014 retention was off, or the payload exceeded the size cap when it arrived"
+    };
+  }
+  let payload;
+  try {
+    const parsed = JSON.parse(log.rawPayload);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return { logId: log.id, ok: false, reason: "Stored payload is not a JSON object" };
+    }
+    payload = parsed;
+  } catch {
+    return { logId: log.id, ok: false, reason: "Stored payload is not valid JSON" };
+  }
+  const slug = await slugForSource(log.intakeSourceId);
+  if (!slug) {
+    return { logId: log.id, ok: false, reason: "The source for this log no longer exists" };
+  }
+  const outcome = await runIngestion({
+    sourceSlug: slug,
+    rawPayload: payload,
+    // The signature was checked when the payload first arrived; there is no body
+    // to re-verify against and the request is now coming from an authenticated
+    // operator rather than the network.
+    skipDedup: true,
+    replayOfLogId: log.id
+  });
+  if (!outcome.ok) {
+    return { logId: log.id, ok: false, reason: `${outcome.error.code}: ${outcome.error.message}` };
+  }
+  return {
+    logId: log.id,
+    ok: true,
+    recordId: outcome.ctx.personId ?? outcome.ctx.companyId,
+    personId: outcome.ctx.personId,
+    companyId: outcome.ctx.companyId,
+    opportunityId: outcome.ctx.opportunityId,
+    fieldsCreated: outcome.ctx.fieldsCreated,
+    warnings: outcome.ctx.warnings
+  };
+}
+
+// src/logic-functions/replay-log.ts
+var handler = async (params) => {
+  const logId = params.pathParameters?.["logId"];
+  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` } };
+  const result = await replayLog(log);
+  if (!result.ok) {
+    return {
+      statusCode: result.reason?.startsWith("No stored payload") ? 400 : 500,
+      body: { error: result.reason, logId, code: "REPLAY_FAILED" }
+    };
+  }
+  return {
+    statusCode: 200,
+    body: {
+      success: true,
+      replayedLogId: logId,
+      recordId: result.recordId,
+      personId: result.personId,
+      companyId: result.companyId,
+      opportunityId: result.opportunityId,
+      fieldsCreated: result.fieldsCreated,
+      warnings: result.warnings
+    }
+  };
+};
+var replay_log_default = defineLogicFunction({
+  universalIdentifier: IDS.REPLAY_LOG_LOGIC_FUNCTION,
+  name: "intake-replay-log",
+  description: "Re-run a single stored payload through the current field rules.",
+  timeoutSeconds: 30,
+  handler,
+  httpRouteTriggerSettings: {
+    path: "/intake/logs/:logId/replay",
+    httpMethod: "POST",
+    isAuthRequired: true
+  }
+});
+export {
+  replay_log_default as default
+};
+//# sourceMappingURL=replay-log.mjs.map