twenty-app-intake 0.2.0

package/src/logic-functions/webhook.mjs

@@ -0,0 +1,1213 @@
+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/logic-functions/webhook.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",
+  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",
+  // 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"
+};
+
+// 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",
+  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 LoadSourceStage = class {
+  constructor(client) {
+    this.client = 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;
+    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}}"
+      }
+    });
+  }
+};
+
+// 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/stages/idempotency.stage.ts
+var IdempotencyStage = class {
+  constructor(client) {
+    this.client = client;
+  }
+  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 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)) {
+      return err(
+        ErrorCode.DUPLICATE_PAYLOAD,
+        `Duplicate payload \u2014 already processed ${prior.status.toLowerCase()} (log ${prior.id})`,
+        { priorLogId: prior.id, priorRecordId: prior.recordId }
+      );
+    }
+    return ok({ ...ctx, payloadHash: hash });
+  }
+};
+
+// 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/normalizer.ts
+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"
+    };
+  }
+  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: rule.fieldType,
+        action: rule.action,
+        value,
+        source: "rule"
+      };
+    }
+  }
+  const detectedType = detectType(value);
+  const classification = classify(key, value);
+  const canonicalName = classification === "field" ? toExtFieldName(key) : lookupKey;
+  return {
+    originalKey: key,
+    canonicalName,
+    twentyType: detectedType,
+    action: classification === "field" ? "field" : classification,
+    value,
+    source: "passthrough"
+  };
+}
+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;
+  }
+  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
+            }
+          }
+        }
+      });
+      return (result.intakeFieldRules?.edges ?? []).map((e) => e.node);
+    } catch {
+      return [];
+    }
+  }
+};
+
+// 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/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"
+]);
+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") {
+      ctx.warnings.push("Field creation disabled by INTAKE_FIELD_CREATION_ENABLED setting \u2014 ext fields skipped");
+      return ok(ctx);
+    }
+    const targets = this.targetObjects(ctx);
+    let fieldsCreated = 0;
+    let fieldsMatched = 0;
+    for (const objectName of targets) {
+      const meta = await this.getObjectMeta(objectName);
+      if (!meta) 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)) {
+          fieldsMatched++;
+          continue;
+        }
+        if (!/^ext[A-Z]/.test(field.canonicalName)) {
+          fieldsMatched++;
+          continue;
+        }
+        if (meta.fields.has(field.canonicalName)) {
+          fieldsMatched++;
+          continue;
+        }
+        if (currentExtCount >= maxExt) {
+          ctx.warnings.push(`ext field limit (${maxExt}) reached for ${objectName} \u2014 "${field.canonicalName}" goes to note`);
+          continue;
+        }
+        const created = await this.createField(meta.id, field.canonicalName, field.twentyType);
+        if (created) {
+          meta.fields.add(field.canonicalName);
+          this.objectCache.get(objectName)?.fields.add(field.canonicalName);
+          fieldsCreated++;
+        } else {
+          ctx.warnings.push(`Could not create field "${field.canonicalName}" on ${objectName} \u2014 will go to note`);
+        }
+      }
+    }
+    return ok({ ...ctx, fieldsCreated, fieldsMatched });
+  }
+  targetObjects(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));
+    const out = [];
+    if (hasPersonData) out.push("person");
+    else if (hasCompanyData) out.push("company");
+    return out.length > 0 ? out : ["person"];
+  }
+  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/stages/upsert-record.stage.ts
+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 extFieldTypes = /* @__PURE__ */ new Map();
+    for (const f of ctx.crmFields ?? []) {
+      if (/^ext[A-Z]/.test(f.canonicalName)) extFieldTypes.set(f.canonicalName, f.twentyType);
+    }
+    try {
+      let companyId;
+      let personId;
+      const needsCompany = rawCompanyName || ctx.source?.targetObject === "COMPANY";
+      if (needsCompany) {
+        companyId = await this.upsertCompany(assembled, structuredCompany ?? {}, rawCompanyName, extFieldTypes, ctx);
+      }
+      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);
+      }
+      let opportunityId;
+      if (ctx.source?.createOpportunity && (personId || companyId)) {
+        opportunityId = await this.createOpportunity(assembled, personId, companyId, 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, extFieldTypes, ctx) {
+    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 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 {
+      }
+    }
+    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(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)}`);
+        });
+      }
+    }
+    return companyId;
+  }
+  async upsertPerson(assembled, structuredPerson, companyId, extFieldTypes, ctx) {
+    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) {
+      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 {
+      }
+    }
+    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)}`);
+        });
+      }
+    }
+    return personId;
+  }
+  async createOpportunity(assembled, personId, companyId, ctx) {
+    try {
+      const name = buildOpportunityName(ctx, assembled);
+      const stage = process.env["INTAKE_DEFAULT_OPP_STAGE"] ?? "NEW";
+      const data = { name, stage };
+      if (personId) data["pointOfContactId"] = personId;
+      if (companyId) data["companyId"] = companyId;
+      const created = await coreApi.post("/opportunities", data);
+      return created.data.createOpportunity.id;
+    } catch {
+      ctx.warnings.push("Opportunity creation failed \u2014 record was still created");
+      return void 0;
+    }
+  }
+  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 created = await coreApi.post("/notes", {
+        title: `${ctx.source?.name ?? appLabel} \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 appLabel = process.env["INTAKE_APP_LABEL"] ?? "Intake";
+  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;
+  }
+}
+function formatExtValue(value, type) {
+  if (type === "LINKS" && typeof value === "string") {
+    return { primaryLinkUrl: value, primaryLinkLabel: "" };
+  }
+  return value;
+}
+
+// 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 {
+      }
+    }
+    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));
+}
+
+// src/logic-functions/webhook.ts
+var handler = async (params) => {
+  const startedAt = Date.now();
+  const sourceSlug = params.pathParameters?.["slug"];
+  if (!sourceSlug) {
+    return { statusCode: 400, body: { error: "Missing source slug in URL", code: "INVALID_PAYLOAD" } };
+  }
+  let rawPayload = {};
+  if (params.body && typeof params.body === "object" && !Array.isArray(params.body)) {
+    rawPayload = params.body;
+  }
+  const coreClient = new CoreApiClient();
+  const metadataClient = new MetadataApiClient();
+  const pipeline = createPipeline(coreClient, metadataClient);
+  const ctx = {
+    sourceSlug,
+    rawBody: params.rawBody,
+    rawPayload,
+    headers: params.headers ?? {},
+    startedAt,
+    fieldsCreated: 0,
+    fieldsMatched: 0,
+    warnings: [],
+    events: []
+  };
+  const result = await pipeline.run(ctx);
+  if (!result.ok) {
+    const { code, message } = result.error;
+    const statusCode = code === "INVALID_SIGNATURE" ? 401 : code === "SOURCE_NOT_FOUND" ? 404 : code === "SOURCE_PAUSED" ? 423 : code === "DUPLICATE_PAYLOAD" ? 200 : 500;
+    return { statusCode, body: { error: message, code } };
+  }
+  const { value: finalCtx } = result;
+  return {
+    statusCode: 200,
+    body: {
+      success: true,
+      recordId: finalCtx.personId ?? finalCtx.companyId,
+      recordType: finalCtx.recordType,
+      personId: finalCtx.personId,
+      companyId: finalCtx.companyId,
+      opportunityId: finalCtx.opportunityId,
+      fieldsCreated: finalCtx.fieldsCreated,
+      fieldsMatched: finalCtx.fieldsMatched,
+      overflowCount: finalCtx.noteFields?.length ?? 0,
+      processingMs: Date.now() - startedAt,
+      warnings: finalCtx.warnings
+    }
+  };
+};
+var webhook_default = defineLogicFunction({
+  universalIdentifier: IDS.WEBHOOK_LOGIC_FUNCTION,
+  name: "intake-webhook",
+  description: "Receives lead payloads from any source and ingests them into Twenty CRM.",
+  timeoutSeconds: 30,
+  handler,
+  httpRouteTriggerSettings: {
+    path: "/intake/:slug",
+    httpMethod: "POST",
+    isAuthRequired: false,
+    forwardedRequestHeaders: ["x-webhook-signature", "x-intake-source", "content-type"]
+  }
+});
+export {
+  webhook_default as default
+};
+//# sourceMappingURL=webhook.mjs.map