@koda-sl/baker-cli 0.534.0-dev.911a80433 → 0.534.0

package/dist/chunk-I7AYMJZA.js

@@ -0,0 +1,783 @@
+import {
+  INGEST_MODES,
+  INGEST_MODE_HEADER
+} from "./chunk-GRQ2AXDX.js";
+import {
+  parse
+} from "./chunk-46YLDIQG.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/website.ts
+var REDIRECTOR_DOMAINS = /* @__PURE__ */ new Set(["goo.gle", "bit.ly", "lnkd.in", "t.co", "ow.ly", "linktr.ee"]);
+var REDIRECTOR_SUFFIXES = /* @__PURE__ */ new Set(["bot"]);
+function normalizeOrgWebsite(website) {
+  const parsed = parse(website ?? "");
+  if (parsed.domain === null || REDIRECTOR_DOMAINS.has(parsed.domain) || REDIRECTOR_SUFFIXES.has(parsed.publicSuffix ?? "")) {
+    return { domain: null, host: parsed.hostname, domainSource: "none" };
+  }
+  const subdomain = parsed.subdomain ?? "";
+  const domainSource = subdomain === "" || subdomain === "www" ? "website" : "subdomain";
+  return { domain: parsed.domain, host: parsed.hostname, domainSource };
+}
+function registrableWebsite(website) {
+  return website === "" ? "" : normalizeOrgWebsite(website.toLowerCase()).domain ?? "";
+}
+
+// ../api/src/accounts/targets.ts
+import { z as z2 } from "zod";
+var TARGET_ACCOUNTS_MAX = 5e3;
+var targetAccountSchema = z2.object({
+  /** Registrable domain: `acme.com`, never `www.acme.com/about`. */
+  domain: z2.string().min(1),
+  name: z2.string().optional(),
+  tier: z2.string().optional()
+});
+var targetAccountsSchema = z2.array(targetAccountSchema).min(1).max(TARGET_ACCOUNTS_MAX);
+function optionalText(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return String(value);
+  return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
+}
+function targetAccountsFrom(entries) {
+  const targets = /* @__PURE__ */ new Map();
+  const unreadable = [];
+  for (const entry of entries) {
+    const raw = typeof entry.domain === "string" ? entry.domain.trim() : "";
+    const domain = registrableWebsite(raw);
+    if (domain === "") {
+      unreadable.push(raw);
+      continue;
+    }
+    if (targets.has(domain)) continue;
+    const name = optionalText(entry.name);
+    const tier = optionalText(entry.tier);
+    targets.set(domain, { domain, ...name ? { name } : {}, ...tier ? { tier } : {} });
+  }
+  return { targets: [...targets.values()], unreadable };
+}
+var tierCountsSchema = z2.object({ total: z2.number(), reached: z2.number(), engaged: z2.number() });
+var targetsSummarySchema = tierCountsSchema.extend({
+  notReached: z2.array(targetAccountSchema),
+  byTier: z2.record(z2.string(), tierCountsSchema).optional()
+});
+
+export {
+  CRM_DEAL_STATUSES,
+  judgeCrmBatch,
+  sheetDelimiter,
+  CRM_COLUMN_FIELDS,
+  exactCrmColumns,
+  crmColumnReading,
+  crmBatchFromSheet,
+  crmPushUrl,
+  crmPushRequestSchema,
+  crmPushBrief,
+  targetAccountsSchema,
+  targetAccountsFrom,
+  targetsSummarySchema
+};
+//# sourceMappingURL=chunk-I7AYMJZA.js.map