@koda-sl/baker-cli 0.490.0 → 0.492.0

package/dist/chunk-IBY44U2M.js

@@ -0,0 +1,1079 @@
+import {
+  INGEST_MODES,
+  INGEST_MODE_HEADER
+} from "./chunk-GRQ2AXDX.js";
+import {
+  calendarDaySchema,
+  todayUtc,
+  windowTooLong
+} from "./chunk-DAO63OOP.js";
+
+// ../api/src/accounts/crm.ts
+import { z } from "zod";
+var CRM_DEAL_STATUSES = ["open", "won", "lost"];
+var text = (max) => z.string().trim().max(max);
+function needed(context, field, message) {
+  context.addIssue({ code: "custom", path: [field], message, params: { missing: true } });
+}
+var ISO_INSTANT = /^(\d{4}-\d{2}-\d{2})([T ]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?)?(Z|[+-]\d{2}:?\d{2})?$/;
+var instantSchema = z.string().transform((value, context) => {
+  const slashed = /^(\d{1,2})[/.](\d{1,2})[/.](\d{4})$/.exec(value);
+  if (slashed) {
+    const [, first, second, year] = slashed;
+    context.addIssue({
+      code: "custom",
+      message: `${value} could be either day first or month first \u2014 write it as ${year}-${second?.padStart(2, "0")}-${first?.padStart(2, "0")} or ${year}-${first?.padStart(2, "0")}-${second?.padStart(2, "0")}`
+    });
+    return z.NEVER;
+  }
+  const iso = ISO_INSTANT.exec(value);
+  const ms = iso ? Date.parse(`${iso[1]}${iso[2]?.replace(" ", "T") ?? "T00:00:00"}${iso[3] ?? "Z"}`) : Number.NaN;
+  if (!Number.isFinite(ms)) {
+    context.addIssue({ code: "custom", message: `${value} is not a date \u2014 use YYYY-MM-DD or an ISO 8601 time` });
+    return z.NEVER;
+  }
+  return new Date(ms).toISOString();
+});
+var amountSchema = z.union([z.number(), z.string().trim()]).transform((value, context) => {
+  const amount = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(amount) || amount < 0 || typeof value === "string" && value === "") {
+    context.addIssue({ code: "custom", message: `${value} is not an amount \u2014 send a number like 12000.50` });
+    return z.NEVER;
+  }
+  return amount;
+});
+var companyFields = z.strictObject({
+  id: text(128).optional(),
+  name: text(300).optional(),
+  domain: text(253).optional(),
+  linkedinPage: text(300).optional(),
+  deleted: z.boolean().optional()
+});
+var companySchema = companyFields.superRefine((company, context) => {
+  if (company.id || company.domain || company.linkedinPage) return;
+  needed(context, "id", "needed \u2014 or the company's website or LinkedIn page, to know it by");
+});
+var dealFields = z.strictObject({
+  id: text(128).min(1),
+  companyId: text(128).optional(),
+  companyDomain: text(253).optional(),
+  /** The company's name, for a deal sent with `companyDomain` and no company of its own. */
+  companyName: text(300).optional(),
+  /** The company's LinkedIn page, likewise — the surest match of all. */
+  companyLinkedinPage: text(300).optional(),
+  name: text(300).optional(),
+  amount: amountSchema.nullable().optional(),
+  currency: z.string().trim().regex(/^[A-Za-z]{3}$/, "use a three-letter currency code like EUR").transform((code) => code.toUpperCase()).optional(),
+  pipeline: text(128).optional(),
+  stage: text(128).optional(),
+  status: z.enum(CRM_DEAL_STATUSES).optional(),
+  createdAt: instantSchema.optional(),
+  closedAt: instantSchema.nullable().optional(),
+  deleted: z.boolean().optional()
+});
+var dealSchema = dealFields.superRefine((deal, context) => {
+  if (deal.deleted === true) return;
+  if (deal.createdAt === void 0) needed(context, "createdAt", "needed \u2014 the day the deal was created");
+  if ((deal.status === "won" || deal.status === "lost") && !deal.closedAt) {
+    needed(context, "closedAt", "needed when status is won or lost");
+  }
+});
+var CRM_REJECTION_CODES = ["personal_data", "unknown_field", "missing_field", "invalid_field"];
+var PERSON_FIELD = /e-?mail|phone|mobile|first_?name|last_?name|full_?name|contact|person|owner|address|birth/i;
+var EMAIL_IN_TEXT = /[^\s@]+@[^\s@]+\.[^\s@]+/;
+var FIELDS = {
+  company: Object.keys(companyFields.shape),
+  deal: Object.keys(dealFields.shape)
+};
+function personIn(raw) {
+  if (raw === null || typeof raw !== "object") return null;
+  for (const [field, value] of Object.entries(raw)) {
+    if (PERSON_FIELD.test(field)) return `${field} names a person \u2014 Baker takes companies and deals, never people`;
+    if (typeof value === "string" && EMAIL_IN_TEXT.test(value)) {
+      return `${field} holds an email address \u2014 Baker takes companies and deals, never people`;
+    }
+  }
+  return null;
+}
+function issueMessage(issue) {
+  const field = issue.path.join(".");
+  return field === "" ? issue.message : `${field}: ${issue.message}`;
+}
+function rejectionFor(kind, issues) {
+  const unknown = issues.find((issue) => issue.code === "unrecognized_keys");
+  if (unknown && unknown.code === "unrecognized_keys") {
+    return {
+      code: "unknown_field",
+      message: `unknown field ${unknown.keys.join(", ")} \u2014 send only ${FIELDS[kind].join(", ")}`
+    };
+  }
+  const missing = issues.find(
+    (issue) => issue.code === "invalid_type" && issue.input === void 0 || issue.code === "custom" && issue.params?.missing === true
+  );
+  return {
+    code: missing ? "missing_field" : "invalid_field",
+    message: issues.map(issueMessage).join("; ")
+  };
+}
+function recordId(raw) {
+  const id = raw?.id;
+  return typeof id === "string" ? id : "";
+}
+function judgeRecord(kind, schema, raw, index, rejected) {
+  const base = { kind, index, id: recordId(raw) };
+  const person = personIn(raw);
+  if (person !== null) {
+    rejected.push({ ...base, code: "personal_data", message: person });
+    return null;
+  }
+  const parsed = schema.safeParse(raw);
+  if (!parsed.success) {
+    rejected.push({ ...base, ...rejectionFor(kind, parsed.error.issues) });
+    return null;
+  }
+  return parsed.data;
+}
+function judgeCrmBatch(batch) {
+  const judged = { companies: [], deals: [], rejected: [] };
+  (batch.companies ?? []).forEach((raw, index) => {
+    const company = judgeRecord("company", companySchema, raw, index, judged.rejected);
+    if (company === null) return;
+    judged.companies.push({
+      id: company.id ?? "",
+      name: company.name ?? "",
+      domain: company.domain ?? "",
+      linkedinPage: company.linkedinPage ?? "",
+      deleted: company.deleted === true
+    });
+  });
+  (batch.deals ?? []).forEach((raw, index) => {
+    const deal = judgeRecord("deal", dealSchema, raw, index, judged.rejected);
+    if (deal === null) return;
+    judged.deals.push({
+      id: deal.id,
+      companyId: deal.companyId ?? "",
+      companyDomain: deal.companyDomain ?? "",
+      companyName: deal.companyName ?? "",
+      companyLinkedinPage: deal.companyLinkedinPage ?? "",
+      name: deal.name ?? "",
+      amount: deal.amount ?? null,
+      currency: deal.currency ?? "",
+      pipeline: deal.pipeline ?? "",
+      stage: deal.stage ?? "",
+      status: deal.status ?? null,
+      createdAt: deal.createdAt ?? null,
+      closedAt: deal.closedAt ?? null,
+      deleted: deal.deleted === true
+    });
+  });
+  return judged;
+}
+function sheetDelimiter(text2) {
+  const header = text2.split(/\r?\n/, 1)[0] ?? "";
+  const count = (mark) => header.split(mark).length - 1;
+  return [",", ";", "	"].reduce((best, mark) => count(mark) > count(best) ? mark : best, ",");
+}
+function sheetAmount(cell) {
+  if (/^-?\d+(\.\d+)?e[+-]?\d+$/i.test(cell)) return cell;
+  const compact = cell.replace(/[\s\u00a0]/g, "").replace(/[^\d.,-]/g, "");
+  const decimal = /[.,](\d{1,2}|\d{4,})$/.exec(compact);
+  if (!decimal) return compact.replace(/[.,]/g, "");
+  const whole = compact.slice(0, decimal.index).replace(/[.,]/g, "");
+  return `${whole}.${decimal[1]}`;
+}
+var CRM_SHEET_COLUMNS = {
+  deals: [
+    {
+      header: "Deal ID",
+      field: "id",
+      need: "required",
+      takes: "Your CRM's id for the deal. The same id again updates the row instead of adding one.",
+      example: "deal-001",
+      example2: "deal-002"
+    },
+    {
+      header: "Created date",
+      field: "createdAt",
+      need: "required",
+      takes: "The day the deal was created, like 2026-06-15. It dates the deal as pipeline.",
+      example: "2026-06-15",
+      example2: "2026-02-01"
+    },
+    {
+      header: "Website",
+      field: "companyDomain",
+      need: "required",
+      takes: "The website of the deal's company, like acme.com. It is how Baker finds the company among those your ads reached.",
+      note: "or Company LinkedIn",
+      example: "acme.com",
+      example2: "globex.com"
+    },
+    {
+      header: "Amount",
+      field: "amount",
+      need: "recommended",
+      takes: "The deal's value, like 24000. Without it the deal counts but adds no value.",
+      example: "24000",
+      example2: "8000"
+    },
+    {
+      header: "Currency",
+      field: "currency",
+      need: "recommended",
+      takes: "Three letters: EUR, USD, GBP\u2026",
+      example: "EUR",
+      example2: "EUR"
+    },
+    {
+      header: "Status",
+      field: "status",
+      need: "recommended",
+      takes: "open, won or lost. Without it, you choose which stages mean won and lost.",
+      example: "open",
+      example2: "won"
+    },
+    {
+      header: "Close date",
+      field: "closedAt",
+      need: "recommended",
+      takes: "The day it was won or lost. Needed once Status is won or lost.",
+      example: "",
+      example2: "2026-04-20"
+    },
+    {
+      header: "Company",
+      field: "companyName",
+      need: "optional",
+      takes: "The company's name, as the Accounts screen shows it.",
+      example: "Acme Inc",
+      example2: "Globex"
+    },
+    {
+      header: "Company LinkedIn",
+      field: "companyLinkedinPage",
+      need: "optional",
+      takes: "The company's LinkedIn page. The surest match of all, and enough without a Website.",
+      example: "https://www.linkedin.com/company/acme-inc",
+      example2: ""
+    },
+    {
+      header: "Deal name",
+      field: "name",
+      need: "optional",
+      takes: "The deal's name.",
+      example: "Acme annual plan",
+      example2: "Globex pilot"
+    },
+    {
+      header: "Pipeline",
+      field: "pipeline",
+      need: "optional",
+      takes: "Its pipeline, if you use several.",
+      example: "Sales",
+      example2: "Sales"
+    },
+    {
+      header: "Stage",
+      field: "stage",
+      need: "optional",
+      takes: "Its stage.",
+      example: "Proposal",
+      example2: "Closed Won"
+    }
+  ],
+  companies: [
+    {
+      header: "Website",
+      field: "domain",
+      need: "required",
+      takes: "The company's website, like acme.com. It is how Baker finds the company among those your ads reached.",
+      note: "or LinkedIn page",
+      example: "acme.com",
+      example2: "globex.com"
+    },
+    {
+      header: "Company name",
+      field: "name",
+      need: "recommended",
+      takes: "The company's name, as the Accounts screen shows it.",
+      example: "Acme Inc",
+      example2: "Globex"
+    },
+    {
+      header: "LinkedIn page",
+      field: "linkedinPage",
+      need: "optional",
+      takes: "The company's LinkedIn page. The surest match of all, and enough without a Website.",
+      example: "https://www.linkedin.com/company/acme-inc",
+      example2: ""
+    },
+    {
+      header: "Company ID",
+      field: "id",
+      need: "optional",
+      takes: "Your CRM's id for the company. Only needed when your deals name their company by this id.",
+      example: "acct-001",
+      example2: ""
+    }
+  ]
+};
+function sheetTemplate(columns) {
+  return [
+    columns.map((column) => column.header).join(","),
+    columns.map((column) => column.example).join(","),
+    columns.map((column) => column.example2 ?? "").join(","),
+    ""
+  ].join("\n");
+}
+var CRM_SHEET_TEMPLATE = sheetTemplate(CRM_SHEET_COLUMNS.deals);
+var CRM_COMPANY_SHEET_TEMPLATE = sheetTemplate(CRM_SHEET_COLUMNS.companies);
+var DATE_FIELDS = /* @__PURE__ */ new Set(["createdAt", "closedAt"]);
+var SLASHED_DAY = /^(\d{1,2})[/.](\d{1,2})[/.](\d{4})$/;
+var SHEET_EPOCH_MS = Date.UTC(1899, 11, 30);
+var DAY_MS = 864e5;
+function slashOrder(cells) {
+  for (const cell of cells) {
+    const parts = SLASHED_DAY.exec(cell);
+    if (!parts) continue;
+    if (Number(parts[1]) > 12) return "dmy";
+    if (Number(parts[2]) > 12) return "mdy";
+  }
+  return null;
+}
+function sheetDate(cell, order) {
+  if (/^\d{5}(\.\d+)?$/.test(cell)) {
+    return new Date(SHEET_EPOCH_MS + Math.round(Number(cell) * DAY_MS)).toISOString().slice(0, 10);
+  }
+  const parts = SLASHED_DAY.exec(cell);
+  if (!parts || order === null) return cell;
+  const [, first = "", second = "", year] = parts;
+  const [day, month] = order === "dmy" ? [first, second] : [second, first];
+  return `${year}-${month.padStart(2, "0")}-${day.padStart(2, "0")}`;
+}
+function sheetCell(field, cell, order) {
+  if (field === "amount") return sheetAmount(cell);
+  if (field === "status") return cell.toLowerCase();
+  if (DATE_FIELDS.has(field)) return sheetDate(cell, order);
+  return cell;
+}
+function sheetRecords(rows, columns) {
+  const cells = (field) => rows.flatMap(
+    (row) => Object.entries(row).filter(([column]) => columns[column] === field).map(([, cell]) => String(cell ?? "").trim())
+  );
+  const order = slashOrder([...DATE_FIELDS].flatMap(cells));
+  return rows.map((row) => {
+    const record = {};
+    for (const [column, raw] of Object.entries(row)) {
+      const field = columns[column];
+      const cell = String(raw ?? "").trim();
+      if (field === void 0 || cell === "" || record[field] !== void 0) continue;
+      record[field] = sheetCell(field, cell, order);
+    }
+    return record;
+  });
+}
+function sheetHeaders(rows) {
+  return [...new Set(rows.flatMap((row) => Object.keys(row)))];
+}
+var CRM_COLUMN_FIELDS = [
+  "id",
+  "name",
+  "companyId",
+  "companyName",
+  "companyDomain",
+  "companyLinkedinPage",
+  "amount",
+  "currency",
+  "pipeline",
+  "stage",
+  "status",
+  "createdAt",
+  "closedAt"
+];
+var COMPANY_AS_DEAL = {
+  id: "companyId",
+  name: "companyName",
+  domain: "companyDomain",
+  linkedinPage: "companyLinkedinPage"
+};
+var COMPANY_FIELD = {
+  companyId: "id",
+  companyName: "name",
+  companyDomain: "domain",
+  companyLinkedinPage: "linkedinPage"
+};
+var DEAL_ONLY = /* @__PURE__ */ new Set([
+  "id",
+  "name",
+  "amount",
+  "pipeline",
+  "stage",
+  "status",
+  "closedAt"
+]);
+var headerKey = (header) => header.toLowerCase().replace(/[^\p{L}\p{N}]/gu, "");
+var SHARED_NAMES = /* @__PURE__ */ new Set(["id", "name"]);
+var isSharedName = (header) => SHARED_NAMES.has(headerKey(header));
+var EXACT = new Map([
+  ...CRM_COLUMN_FIELDS.map((field) => [headerKey(field), field]),
+  [headerKey("domain"), "companyDomain"],
+  [headerKey("linkedinPage"), "companyLinkedinPage"],
+  ...CRM_SHEET_COLUMNS.deals.map((column) => [headerKey(column.header), column.field]),
+  ...CRM_SHEET_COLUMNS.companies.map((column) => [
+    headerKey(column.header),
+    COMPANY_AS_DEAL[column.field]
+  ])
+]);
+function exactCrmColumns(headers) {
+  const meanings = {};
+  for (const header of headers) {
+    const field = EXACT.get(headerKey(header));
+    if (field !== void 0) meanings[header] = field;
+  }
+  return meanings;
+}
+function crmColumnReading(meanings, kind) {
+  const entries = Object.entries(meanings);
+  const read = kind ?? (entries.some(([header, field]) => DEAL_ONLY.has(field) && !isSharedName(header)) ? "deals" : "companies");
+  const columns = {};
+  for (const [header, field] of entries) {
+    const target = read === "deals" ? field : isSharedName(header) ? field : COMPANY_FIELD[field];
+    if (target !== void 0) columns[header] = target;
+  }
+  return { kind: read, columns };
+}
+function crmBatchFromSheet(rows, reading) {
+  const headers = sheetHeaders(rows);
+  const { kind, columns } = typeof reading === "object" ? reading : crmColumnReading(exactCrmColumns(headers), reading);
+  const records = sheetRecords(rows, columns);
+  return {
+    kind,
+    batch: kind === "deals" ? { deals: records } : { companies: records },
+    ignoredColumns: headers.filter((header) => columns[header] === void 0)
+  };
+}
+var CRM_PUSH_PATH = "/v1/accounts/crm";
+var CRM_PUSH_BATCH_MAX = 500;
+function crmPushUrl(brandedUrl, convexSiteUrl) {
+  return `${(brandedUrl || convexSiteUrl).replace(/\/$/, "")}${CRM_PUSH_PATH}`;
+}
+var crmPushRequestSchema = z.strictObject({
+  companies: z.array(z.unknown()).optional(),
+  deals: z.array(z.unknown()).optional()
+}).refine((body) => (body.companies?.length ?? 0) + (body.deals?.length ?? 0) > 0, {
+  message: "send at least one company or deal"
+}).refine((body) => (body.companies?.length ?? 0) + (body.deals?.length ?? 0) <= CRM_PUSH_BATCH_MAX, {
+  message: `at most ${CRM_PUSH_BATCH_MAX} companies and deals per request \u2014 split the batch`
+});
+var crmRejectionSchema = z.object({
+  kind: z.enum(["company", "deal"]),
+  index: z.number().int().nonnegative(),
+  id: z.string(),
+  code: z.enum(CRM_REJECTION_CODES),
+  message: z.string()
+});
+var crmPushResponseSchema = z.object({
+  /** Echoed from `X-Baker-Mode`: a `test` request is judged in full and stores nothing. */
+  mode: z.enum(INGEST_MODES),
+  received: z.object({ companies: z.number().int(), deals: z.number().int() }),
+  /** Passed the checks: stored in a live send, only judged in a test. */
+  accepted: z.object({ companies: z.number().int(), deals: z.number().int() }),
+  deleted: z.object({ companies: z.number().int(), deals: z.number().int() }),
+  rejected: z.array(crmRejectionSchema)
+});
+var crmContentsSchema = z.object({
+  companies: z.number().int(),
+  deals: z.number().int(),
+  stages: z.array(
+    z.object({
+      pipeline: z.string(),
+      stage: z.string(),
+      deals: z.number().int(),
+      /** Sent as `status: won`. */
+      won: z.number().int(),
+      /** Sent as `status: lost`. */
+      lost: z.number().int()
+    })
+  )
+});
+var CRM_SEND_VIAS = ["api", "upload", "sheet"];
+var crmPushSummarySchema = z.object({
+  at: z.number(),
+  via: z.enum(CRM_SEND_VIAS),
+  companies: z.number().int(),
+  deals: z.number().int(),
+  deleted: z.number().int(),
+  rejected: z.number().int(),
+  samples: z.array(
+    z.object({ kind: z.enum(["company", "deal"]), id: z.string(), code: z.string(), message: z.string() })
+  )
+});
+var crmSheetLinkSchema = z.object({
+  id: z.string(),
+  spreadsheetName: z.string(),
+  /** Where the sheet opens — for a person, or a scenario that writes its rows. */
+  url: z.string().optional(),
+  tab: z.string(),
+  kind: z.enum(["deals", "companies"]),
+  lastRead: z.object({
+    at: z.number(),
+    ok: z.boolean(),
+    companies: z.number().int(),
+    deals: z.number().int(),
+    /** Records the sheet no longer has, removed from Baker. */
+    removed: z.number().int(),
+    rejected: z.number().int(),
+    /** Why the read failed or what was held back, in words. */
+    message: z.string().optional()
+  }).nullable()
+});
+var accountsCrmStatusResponseSchema = z.object({
+  ok: z.literal(true),
+  data: z.object({
+    /**
+     * Always true, for CLIs from when Account insights was a per-company
+     * switch: they read its absence as "switched off". Drop it once no
+     * Runtime runs one of them.
+     */
+    enabled: z.literal(true).optional(),
+    /** `hubspot` (Baker reads it), `api` (the client sends it), or null before anyone chose. */
+    source: z.enum(["hubspot", "api"]).nullable(),
+    /** Where a client's system sends. */
+    url: z.string(),
+    lastLive: crmPushSummarySchema.nullable(),
+    lastTest: crmPushSummarySchema.nullable(),
+    /** Google Sheets Baker reads every night, with how the last read went. */
+    sheets: z.array(crmSheetLinkSchema),
+    /** What the sent CRM holds; null unless the source is `api`. */
+    contents: crmContentsSchema.nullable()
+  })
+});
+var accountsCrmSheetRequestSchema = z.object({
+  /** The Google Drive connection to make it with, when the company has more than one. */
+  account: z.string().optional()
+});
+var accountsCrmSheetResponseSchema = z.object({
+  ok: z.literal(true),
+  data: z.object({
+    /** False when the company already had the sheet: it is handed back, never made twice. */
+    created: z.boolean(),
+    spreadsheetName: z.string(),
+    url: z.string(),
+    tabs: z.array(z.string())
+  })
+});
+var CRM_PUSH_EXAMPLE = {
+  companies: [{ id: "acct-001", name: "Acme Inc", domain: "acme.com", linkedinPage: "acme-inc" }],
+  deals: [
+    {
+      id: "deal-001",
+      companyId: "acct-001",
+      name: "Acme \u2014 annual plan",
+      amount: 24e3,
+      currency: "EUR",
+      stage: "Proposal",
+      status: "open",
+      createdAt: "2026-06-15"
+    }
+  ]
+};
+var MODE_HINT = `
+# Check it first: add -H '${INGEST_MODE_HEADER}: test' \u2014 judged the same way, nothing stored.`;
+var PEOPLE_NOTE = "Anything naming a person \u2014 a contact, an owner, an email or phone \u2014 is refused, never stored.";
+var CRM_COMPANY_FIELDS = [
+  {
+    name: "id",
+    need: "conditional",
+    takes: "Your CRM's id for the company (1\u2013128 characters).",
+    note: "Without one, Baker knows the company by its domain (or LinkedIn page) \u2014 fine for a plain list of target companies."
+  },
+  { name: "name", need: "optional", takes: "The company's name, as the Accounts screen shows it." },
+  {
+    name: "domain",
+    need: "optional",
+    takes: "Its website \u2014 acme.com or https://www.acme.com both work.",
+    note: "The main way a company is matched to the LinkedIn companies your ads reached. Send it whenever you have it."
+  },
+  {
+    name: "linkedinPage",
+    need: "optional",
+    takes: "Its LinkedIn page: the URL or the part after /company/.",
+    note: "The surest match of all when the website is shared or missing."
+  },
+  { name: "deleted", need: "optional", takes: "true to remove a company sent before. Only the id is needed." }
+];
+var CRM_DEAL_FIELDS = [
+  {
+    name: "id",
+    need: "required",
+    takes: "Your CRM's id for the deal (1\u2013128 characters). Sending it again updates it."
+  },
+  {
+    name: "createdAt",
+    need: "required",
+    takes: "The day it was created: 2026-06-15 or an ISO 8601 time.",
+    note: "What dates it as pipeline."
+  },
+  {
+    name: "companyId",
+    need: "conditional",
+    takes: "The id of its company, as sent in companies.",
+    note: "Or send companyDomain (and companyName) instead and skip companies altogether. Use one way consistently. A deal with neither is kept but cannot be influenced."
+  },
+  { name: "companyDomain", need: "conditional", takes: "Its company's website, when you send no companies." },
+  { name: "companyName", need: "optional", takes: "Its company's name, with companyDomain." },
+  {
+    name: "companyLinkedinPage",
+    need: "optional",
+    takes: "Its company's LinkedIn page, with companyDomain: the surest match."
+  },
+  { name: "name", need: "optional", takes: "The deal's name." },
+  {
+    name: "amount",
+    need: "optional",
+    takes: 'Its value: 24000 or "24000.00". Left out, the deal counts but adds no value.'
+  },
+  { name: "currency", need: "optional", takes: "Three letters: EUR, USD, GBP\u2026" },
+  { name: "pipeline", need: "optional", takes: "Its pipeline's name or id, if you use several." },
+  { name: "stage", need: "optional", takes: "Its stage's name or id." },
+  {
+    name: "status",
+    need: "optional",
+    takes: "open, won or lost.",
+    note: "Send it and Baker needs nothing else to tell won from lost. Without it, choose which stages mean won and lost in Measure \u2192 Accounts."
+  },
+  {
+    name: "closedAt",
+    need: "conditional",
+    takes: "The day it was won or lost.",
+    note: "Needed when status is won or lost: it dates the revenue."
+  },
+  { name: "deleted", need: "optional", takes: "true to remove a deal sent before. Only the id is needed." }
+];
+var CRM_RESPONSE_FIELDS = [
+  { name: "mode", need: "required", takes: "live or test, echoed from X-Baker-Mode." },
+  { name: "received", need: "required", takes: "How many companies and deals arrived." },
+  { name: "accepted", need: "required", takes: "How many passed the checks \u2014 stored, unless it was a test." },
+  { name: "deleted", need: "required", takes: "How many removals were accepted." },
+  {
+    name: "rejected",
+    need: "required",
+    takes: "Each refused record: kind, index, id, code and a message saying what to fix.",
+    note: `Codes: ${CRM_REJECTION_CODES.join(", ")}. ${PEOPLE_NOTE}`
+  }
+];
+function fieldTable(fields) {
+  return [
+    "| Field | Need | Takes |",
+    "| --- | --- | --- |",
+    ...fields.map(
+      (field) => `| \`${field.name}\` | ${field.need} | ${field.takes}${field.note ? ` ${field.note}` : ""} |`
+    )
+  ].join("\n");
+}
+function crmPushBrief(url) {
+  return `# Sending your CRM to Baker
+
+Baker compares the companies your LinkedIn ads reached with your deals. When Baker cannot read
+your CRM itself, your system sends the companies and deals here \u2014 only what you choose to send.
+
+\`POST ${url}\` with \`Authorization: Bearer <key>\` and \`Content-Type: application/json\`.
+
+1. **Use a key that can only send CRM data.** Create it in Baker \u2192 Measure \u2192 Accounts \u2192 Deal
+   settings (or Settings \u2192 API keys, "Sending CRM data only"). Never put it in source or a chat;
+   read it from an environment variable.
+2. **Send \`${INGEST_MODE_HEADER}: test\` while you build.** It is judged exactly the same way and
+   stores nothing.
+3. **Send everything once, then what changes.** Sending a record again with the same \`id\`
+   updates it; \`"deleted": true\` removes it. Up to ${CRM_PUSH_BATCH_MAX} records per request; a
+   nightly job of your deals changed since the last run is plenty.
+4. **Companies and deals only.** ${PEOPLE_NOTE}
+
+Body: \`{ "companies": [ \u2026 ], "deals": [ \u2026 ] }\` \u2014 either list may be left out.
+
+## Companies
+
+${fieldTable(CRM_COMPANY_FIELDS)}
+
+## Deals
+
+${fieldTable(CRM_DEAL_FIELDS)}
+
+## The answer
+
+A \`200\` with \`{ "ok": true, "data": { \u2026 } }\`. One bad record never refuses the others: read
+\`rejected\`.
+
+${fieldTable(CRM_RESPONSE_FIELDS)}
+
+## Example
+
+\`\`\`json
+${JSON.stringify(CRM_PUSH_EXAMPLE, null, 2)}
+\`\`\`
+`;
+}
+
+// ../api/src/accounts/crm-columns.ts
+var COLUMN_HELD = 0.7;
+var SAMPLE_CHARS = 60;
+var EMAIL = /[^\s@]+@[^\s@]+\.[^\s@]+/g;
+var CRITERIA = {
+  id: "The deal's own unique id or number in the CRM (a deal, opportunity or record id of the deal), not the company's id",
+  name: "The deal's own title (a deal or opportunity name), not the name of the company or of a person",
+  companyId: "The CRM's unique id (or record id) of the company or account the row is about or the deal is with",
+  companyName: "The name of the company, account or organization the row is about or the deal is with",
+  companyDomain: "The company's website or web domain, like acme.com",
+  companyLinkedinPage: "The company's LinkedIn page address",
+  amount: "The deal's own value in money (its amount, value or size), not a weighted or forecast amount, not a company's revenue or turnover, not a probability, a percentage or a count",
+  currency: "The currency the amount is in, like EUR or USD",
+  pipeline: "Which sales pipeline the deal belongs to, not its stage",
+  stage: "The deal's stage or state in the sales pipeline, in any words (like Proposal, Negotiation, Closed Won, Ganado), not the status of a lead or a contact",
+  status: "Whether the deal is open, won or lost, written as exactly the English word open, won or lost",
+  createdAt: "The date the deal or the company was created, opened or added to the CRM",
+  closedAt: "The date the deal was closed (won or lost) or is expected to close",
+  none: "Anything else: a person (an owner, a contact, a person's name, email or phone), who created or last changed the record, a probability, a weighted amount, a company's revenue or size, a lead's or contact's status, a next step, a source, notes, an industry, a date of last activity, or any other field"
+};
+var QUESTION = "`column` is the header of a column in a spreadsheet exported from a CRM, in any language or in the CRM's own wording, and `cells` are values from that column. `sheet` lists every header of the spreadsheet, for context. Which field does `column` hold?";
+function sampleCell(cell) {
+  return cell.replace(EMAIL, "<email address>").slice(0, SAMPLE_CHARS);
+}
+function crmColumnQuestions(columns, headers = columns.map((column) => column.header)) {
+  const sheet = headers.join(" | ");
+  return columns.map(({ header, samples }) => ({
+    type: "choice",
+    instructions: {
+      sheet,
+      column: header,
+      cells: samples.length > 0 ? samples.map(sampleCell).join(" | ") : "(empty)",
+      question: QUESTION
+    },
+    criteria: CRITERIA
+  }));
+}
+var isCrmColumnField = (choice) => CRM_COLUMN_FIELDS.includes(choice);
+var isStatusCell = (cell) => CRM_DEAL_STATUSES.includes(cell.trim().toLowerCase());
+function crmColumnMeanings(columns, answers, held = COLUMN_HELD) {
+  const meanings = {};
+  columns.forEach(({ header, samples }, index) => {
+    const answer = answers[index];
+    if (answer === void 0 || !("choice" in answer)) return;
+    const { choice, probabilities } = answer;
+    if (!isCrmColumnField(choice) || (probabilities[choice] ?? 0) < held) return;
+    meanings[header] = choice === "status" && !samples.every(isStatusCell) ? "stage" : choice;
+  });
+  return meanings;
+}
+
+// ../api/src/accounts/index.ts
+import { z as z2 } from "zod";
+var INFLUENCE_MODEL_KINDS = ["engagement", "awareness", "intent"];
+var INFLUENCE_METRICS = ["impressions", "engagements", "clicks"];
+var DEFAULT_LOOKBACK_MONTHS = 12;
+var MATCH_CONFIDENCES = ["high", "low"];
+var MODEL_METRIC = {
+  engagement: { metric: "engagements", threshold: 3 },
+  awareness: { metric: "impressions", threshold: 7 },
+  intent: { metric: "clicks", threshold: 3 }
+};
+function influenceParams(settings, override = {}) {
+  const kind = override.model ?? settings.model.kind;
+  const model = MODEL_METRIC[kind];
+  const wholeAtLeastOne = (value) => value !== void 0 && Number.isInteger(value) && value >= 1;
+  const threshold = override.threshold ?? (override.model === void 0 ? settings.model.threshold : void 0);
+  return {
+    metric: model.metric,
+    threshold: wholeAtLeastOne(threshold) ? threshold : model.threshold,
+    lookbackMonths: wholeAtLeastOne(settings.lookbackMonths) ? settings.lookbackMonths : DEFAULT_LOOKBACK_MONTHS
+  };
+}
+var ACCOUNTS_MAX_MONTHS = 24;
+var windowFields = {
+  /** Calendar months including the current one. */
+  lastMonths: z2.number().int().min(1).max(ACCOUNTS_MAX_MONTHS).optional(),
+  start: calendarDaySchema.optional(),
+  end: calendarDaySchema.optional()
+};
+var ruleOverrideFields = {
+  model: z2.enum(INFLUENCE_MODEL_KINDS).optional(),
+  threshold: z2.number().int().min(1).optional()
+};
+function windowRules(req, ctx) {
+  if (req.start !== void 0 && req.lastMonths !== void 0) {
+    ctx.addIssue({ code: "custom", path: ["lastMonths"], message: "pass lastMonths or start/end, not both" });
+  }
+  if (req.end !== void 0 && req.start === void 0) {
+    ctx.addIssue({ code: "custom", path: ["end"], message: "end needs a start" });
+  }
+  if (req.start !== void 0 && req.end !== void 0 && req.end < req.start) {
+    ctx.addIssue({ code: "custom", path: ["end"], message: "end is before start" });
+    return;
+  }
+  const tooLong = req.start === void 0 ? null : windowTooLong(req.start, req.end ?? todayUtc(), ACCOUNTS_MAX_MONTHS);
+  if (tooLong !== null) ctx.addIssue({ code: "custom", path: ["start"], message: tooLong });
+}
+var accountsWindowSchema = z2.object({ start: z2.string(), end: z2.string() });
+var influenceParamsSchema = z2.object({
+  metric: z2.enum(INFLUENCE_METRICS),
+  threshold: z2.number(),
+  lookbackMonths: z2.number()
+});
+var ACCOUNTS_ENGAGEMENT_DEFAULT_LIMIT = 500;
+var ACCOUNTS_ENGAGEMENT_MAX_LIMIT = 5e3;
+var accountEngagementRowSchema = z2.object({
+  /** LinkedIn organization id; `urn:li:organization:<orgId>` on LinkedIn. */
+  orgId: z2.string(),
+  /** Empty until the nightly sync has looked the company up. */
+  name: z2.string(),
+  domain: z2.string(),
+  impressions: z2.number(),
+  clicks: z2.number(),
+  engagements: z2.number(),
+  videoViews: z2.number(),
+  /** LinkedIn does not always report spend per company; 0 then. */
+  costLocal: z2.number(),
+  currency: z2.string(),
+  /** Months in the window the company saw or did anything. */
+  monthsActive: z2.number(),
+  lastMonth: z2.string().nullable(),
+  /** The same-length period just before the window. */
+  previous: z2.object({ impressions: z2.number(), clicks: z2.number(), engagements: z2.number() }),
+  /** By engagements against the previous period. */
+  flag: z2.enum(["new", "rising"]).nullable(),
+  crmCompanyId: z2.string().nullable(),
+  /** The matched CRM company's name; null without a match. Optional for older servers. */
+  crmCompanyName: z2.string().nullable().optional(),
+  matchConfidence: z2.enum(MATCH_CONFIDENCES).nullable(),
+  hasOpenDeal: z2.boolean(),
+  hasWonDeal: z2.boolean(),
+  hasLostDeal: z2.boolean(),
+  /** When the company's most recent lost deal closed (created, when it has no close date), ISO; null without one. */
+  lastLostAt: z2.string().nullable(),
+  /**
+   * People whose work email named the company's domain on the website or the
+   * API in the period, and how many became leads — the touches beside the ads.
+   * Null when none did; absent from older servers.
+   */
+  website: z2.object({ people: z2.number(), leads: z2.number() }).nullable().optional()
+});
+var accountWebsiteRowSchema = z2.object({
+  domain: z2.string(),
+  people: z2.number(),
+  leads: z2.number(),
+  /** ISO. */
+  firstSeen: z2.string(),
+  /** ISO. */
+  lastSeen: z2.string()
+});
+function accountDealStatus(row) {
+  if (row.hasWonDeal) return "won";
+  if (row.hasOpenDeal) return "open";
+  if (row.hasLostDeal) return "lost";
+  return "none";
+}
+var LOST_DEAL_COOLDOWN_MONTHS = 6;
+function monthsBefore(day, months) {
+  const [year, month, date] = day.split("-").map(Number);
+  const index = (year ?? 1970) * 12 + ((month ?? 1) - 1) - months;
+  const lastDate = new Date(Date.UTC(Math.floor(index / 12), index % 12 + 1, 0)).getUTCDate();
+  return new Date(Date.UTC(Math.floor(index / 12), index % 12, Math.min(date ?? 1, lastDate))).toISOString().slice(0, 10);
+}
+function warmAccounts(rows, today, options = {}) {
+  const cooldownStart = monthsBefore(today, LOST_DEAL_COOLDOWN_MONTHS);
+  const { minimum } = options;
+  return rows.filter(
+    (row) => row.flag !== null && (minimum === void 0 || row[minimum.metric] >= minimum.value) && !row.hasOpenDeal && !row.hasWonDeal && !(row.lastLostAt !== null && row.lastLostAt.slice(0, 10) >= cooldownStart)
+  );
+}
+var accountsEngagementRequestSchema = z2.object({
+  ...windowFields,
+  /** One campaign's companies; every campaign together when absent. */
+  campaignId: z2.string().regex(/^\d+$/, "use the numeric campaign id").optional(),
+  /** Companies per page. */
+  limit: z2.number().int().min(1).max(ACCOUNTS_ENGAGEMENT_MAX_LIMIT).default(ACCOUNTS_ENGAGEMENT_DEFAULT_LIMIT),
+  /** Which page, 1-based, most engaged first. */
+  page: z2.number().int().min(1).default(1)
+}).superRefine(windowRules);
+var accountsEngagementResponseSchema = z2.object({
+  ok: z2.literal(true),
+  data: z2.object({
+    window: accountsWindowSchema,
+    previousWindow: accountsWindowSchema,
+    companies: z2.array(accountEngagementRowSchema),
+    /** True when more companies were reached than this page and the ones before it hold. */
+    truncated: z2.boolean(),
+    /** Which page this is, and how many companies there are in all. Absent from older servers. */
+    pageInfo: z2.object({ page: z2.number(), pageSize: z2.number(), total: z2.number(), hasMore: z2.boolean() }).optional(),
+    /** The company's influence rule (the default one before setup): the minimum `baker accounts warm` applies. */
+    rule: influenceParamsSchema.optional()
+  })
+});
+var INFLUENCE_BASES = ["pipeline", "revenue"];
+var accountDealRowSchema = z2.object({
+  dealId: z2.string(),
+  dealName: z2.string(),
+  crmCompanyId: z2.string(),
+  companyName: z2.string(),
+  domain: z2.string(),
+  /** Null when the deal has no amount — unknown, not zero. */
+  amount: z2.number().nullable(),
+  currency: z2.string(),
+  /** Created (pipeline) or closed won (revenue), ISO. The date the lookback counts back from. */
+  referenceAt: z2.string(),
+  /** By the won and lost stages chosen in the settings. */
+  status: z2.enum(["open", "won", "lost"]),
+  /** The model's metric, summed over the company's lookback months. */
+  touchValue: z2.number(),
+  /** The first month inside the lookback the company was reached, `YYYY-MM-01`. */
+  firstTouchMonth: z2.string().nullable(),
+  /** How surely the CRM company is the LinkedIn one; null when no LinkedIn company matched. */
+  matchConfidence: z2.enum(MATCH_CONFIDENCES).nullable(),
+  /** The company crossed the threshold — whatever the match confidence. */
+  influenced: z2.boolean()
+});
+var moneyByCurrencySchema = z2.record(z2.string(), z2.number());
+var influenceSummarySchema = z2.object({
+  /** Every deal in the window for this basis. */
+  deals: z2.number(),
+  /** Influenced, confirmed matches only — the headline. */
+  influencedDeals: z2.number(),
+  influencedValue: moneyByCurrencySchema,
+  /** Influenced deals with no amount entered: counted, not valued. */
+  dealsWithoutAmount: z2.number(),
+  /** Influenced through a match nobody confirmed yet; not in the headline. */
+  lowConfidenceDeals: z2.number(),
+  lowConfidenceValue: moneyByCurrencySchema,
+  /** LinkedIn spend on the companies reached in the window, per currency. */
+  spend: moneyByCurrencySchema,
+  /** Influenced value per 1 of spend — only when both are in the same single currency. */
+  valuePerSpend: z2.object({ currency: z2.string(), value: z2.number() }).nullable()
+});
+var accountsInfluencedRequestSchema = z2.object({
+  ...windowFields,
+  /** `pipeline`: deals created in the window and not won. `revenue`: deals closed won in the window. */
+  basis: z2.enum(INFLUENCE_BASES).default("pipeline"),
+  /** Every deal in the window, influenced or not; compact returns the influenced ones. */
+  full: z2.boolean().default(false),
+  ...ruleOverrideFields
+}).superRefine(windowRules);
+var accountsInfluencedResponseSchema = z2.object({
+  ok: z2.literal(true),
+  data: z2.object({
+    window: accountsWindowSchema,
+    basis: z2.enum(INFLUENCE_BASES),
+    rule: influenceParamsSchema,
+    summary: influenceSummarySchema,
+    /** Influenced deals on confirmed matches; with `full`, every deal in the window. */
+    deals: z2.array(accountDealRowSchema),
+    /** Influenced through a match nobody confirmed yet. Not in `summary`'s headline. */
+    lowConfidence: z2.array(accountDealRowSchema),
+    /** True when the window held more deals than one read returns. */
+    truncated: z2.boolean()
+  })
+});
+var accountsCompanyRequestSchema = z2.object({
+  /** LinkedIn organization id, or its `urn:li:organization:` URN. */
+  orgId: z2.string().transform((value) => value.replace(/^urn:li:organization:/, "")).pipe(z2.string().regex(/^\d+$/, "use the LinkedIn company id or its urn:li:organization URN")).optional(),
+  /** The company's website domain, `acme.com`. */
+  domain: z2.string().min(3).max(253).transform(
+    (value) => value.trim().toLowerCase().replace(/^https?:\/\//, "").replace(/^www\./, "").replace(/\/.*$/, "")
+  ).optional()
+}).refine((req) => req.orgId === void 0 !== (req.domain === void 0), {
+  message: "Give a LinkedIn company id or a domain, one of the two."
+});
+var accountCompanyMonthSchema = z2.object({
+  orgId: z2.string(),
+  /** Empty for the whole ad account; a campaign id otherwise. */
+  campaignId: z2.string(),
+  /** LinkedIn's name for the campaign; null for the account-wide row, or when LinkedIn could not be asked. */
+  campaignName: z2.string().nullable(),
+  month: z2.string(),
+  impressions: z2.number(),
+  clicks: z2.number(),
+  engagements: z2.number()
+});
+var accountCompanyDealSchema = z2.object({
+  dealId: z2.string(),
+  dealName: z2.string(),
+  amount: z2.number().nullable(),
+  currency: z2.string(),
+  status: z2.enum(["open", "won", "lost"]),
+  createdAt: z2.string(),
+  closedAt: z2.string().nullable(),
+  /**
+   * The rule's metric over the lookback ending with the deal's reference month
+   * (created; closed for a won deal), from the pages in `orgs`. Absent before
+   * setup or when the company matched no CRM company.
+   */
+  touchValue: z2.number().optional(),
+  /** `touchValue` reached the rule's threshold. */
+  influenced: z2.boolean().optional()
+});
+var accountCompanyOrgSchema = z2.object({
+  orgId: z2.string(),
+  name: z2.string(),
+  domain: z2.string(),
+  crmCompanyId: z2.string().nullable(),
+  matchConfidence: z2.enum(MATCH_CONFIDENCES).nullable()
+});
+var accountsCompanyResponseSchema = z2.object({
+  ok: z2.literal(true),
+  data: z2.object({
+    /** Usually one; a domain can name several LinkedIn pages of the same company. */
+    orgs: z2.array(accountCompanyOrgSchema),
+    /** Month by month, per campaign (and the account-wide row, `campaignId: ""`), oldest first. */
+    months: z2.array(accountCompanyMonthSchema),
+    /** Deals of the matched CRM company, oldest first. */
+    deals: z2.array(accountCompanyDealSchema),
+    /** The rule `influenced` and `touchValue` on each deal were read with; absent before setup. */
+    rule: influenceParamsSchema.optional()
+  })
+});
+var accountsCampaignsRequestSchema = z2.object({ ...windowFields, ...ruleOverrideFields, basis: z2.enum(INFLUENCE_BASES).default("pipeline") }).superRefine(windowRules);
+var accountCampaignRowSchema = z2.object({
+  campaignId: z2.string(),
+  /** LinkedIn's name for the campaign; null when LinkedIn could not be asked or no longer lists it. */
+  campaignName: z2.string().nullable(),
+  /** Companies that saw at least one impression in the window. */
+  companiesReached: z2.number(),
+  /** Companies with at least one engagement in the window. */
+  companiesEngaged: z2.number(),
+  /** Influenced deals (of the read's basis) this campaign touched in their lookback. Overlaps other campaigns. */
+  influencedDeals: z2.number(),
+  influencedValue: moneyByCurrencySchema
+});
+var accountsCampaignsResponseSchema = z2.object({
+  ok: z2.literal(true),
+  data: z2.object({
+    window: accountsWindowSchema,
+    /** Optional for older servers, which read pipeline only. */
+    basis: z2.enum(INFLUENCE_BASES).optional(),
+    rule: influenceParamsSchema,
+    campaigns: z2.array(accountCampaignRowSchema)
+  })
+});
+var ACCOUNTS_NO_SETTINGS_MESSAGE = "Account insights are not set up yet: in Measure \u2192 Accounts, say where your deals are (HubSpot or another CRM) and what won and lost mean.";
+
+export {
+  judgeCrmBatch,
+  sheetDelimiter,
+  exactCrmColumns,
+  crmColumnReading,
+  crmBatchFromSheet,
+  crmPushUrl,
+  crmPushRequestSchema,
+  crmPushBrief,
+  crmColumnQuestions,
+  crmColumnMeanings,
+  INFLUENCE_MODEL_KINDS,
+  influenceParams,
+  ACCOUNTS_ENGAGEMENT_MAX_LIMIT,
+  accountDealStatus,
+  warmAccounts,
+  accountsEngagementRequestSchema,
+  accountsInfluencedRequestSchema,
+  accountsCompanyRequestSchema,
+  accountsCampaignsRequestSchema,
+  ACCOUNTS_NO_SETTINGS_MESSAGE
+};
+//# sourceMappingURL=chunk-IBY44U2M.js.map