@koda-sl/baker-cli 0.496.0 → 0.497.0

package/dist/chunk-IFDZZOUC.js

@@ -0,0 +1,903 @@
+import {
+  flowsDir,
+  walkNodes
+} from "./chunk-HPLHAHG5.js";
+
+// ../api/src/activecampaign.ts
+import { z } from "zod";
+var ACTIVECAMPAIGN_FIELD_TYPES = [
+  "standard",
+  "custom",
+  "tags",
+  "lists",
+  "automations",
+  "deal",
+  "account",
+  "note",
+  "event"
+];
+var ACTIVECAMPAIGN_TAGS_KEY = "tags";
+var ACTIVECAMPAIGN_DEAL_FIELDS = [
+  { key: "title", label: "Deal title" },
+  { key: "value", label: "Deal value" },
+  { key: "currency", label: "Deal currency" },
+  { key: "pipeline", label: "Pipeline" },
+  { key: "stage", label: "Stage" },
+  { key: "owner", label: "Deal owner" },
+  { key: "description", label: "Deal description" }
+];
+var ACTIVECAMPAIGN_ACCOUNT_FIELDS = [
+  { key: "name", label: "Account name" },
+  { key: "url", label: "Account website" }
+];
+var ACTIVECAMPAIGN_EVENT_FIELDS = [
+  { key: "name", label: "Event name" },
+  { key: "data", label: "Event details" }
+];
+function splitActiveCampaignNames(value) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const raw of value.split(",")) {
+    const name = raw.trim().slice(0, 255);
+    if (name) seen.add(name);
+  }
+  return [...seen];
+}
+function findActiveCampaignOption(options, named) {
+  const wanted = named.trim();
+  if (!wanted) return void 0;
+  return options.find((option) => option.id === wanted) ?? options.find((option) => option.name.trim().toLowerCase() === wanted.toLowerCase());
+}
+var activeCampaignFieldSchema = z.object({
+  fieldType: z.enum(ACTIVECAMPAIGN_FIELD_TYPES),
+  /** What the mapping stores: the standard field's name, a custom field's id, `tags`, a deal part, …. */
+  fieldKey: z.string(),
+  label: z.string(),
+  /** ActiveCampaign's own type for a custom field (`text`, `date`, `dropdown`, …); null otherwise. */
+  dataType: z.string().nullable(),
+  /** A custom field's personalization tag (`%SECTOR%`), which people recognise it by. */
+  perstag: z.string().nullable()
+});
+function fixedField(fieldType, fieldKey, label, dataType = null) {
+  return { fieldType, fieldKey, label, dataType, perstag: null };
+}
+var ACTIVECAMPAIGN_FIXED_FIELDS = [
+  fixedField("tags", ACTIVECAMPAIGN_TAGS_KEY, "Tags"),
+  fixedField("lists", "lists", "Lists"),
+  fixedField("automations", "automations", "Automations"),
+  ...ACTIVECAMPAIGN_DEAL_FIELDS.map(
+    (field) => fixedField("deal", field.key, field.label, field.key === "value" ? "currency" : null)
+  ),
+  ...ACTIVECAMPAIGN_ACCOUNT_FIELDS.map((field) => fixedField("account", field.key, field.label)),
+  fixedField("note", "note", "Note"),
+  ...ACTIVECAMPAIGN_EVENT_FIELDS.map((field) => fixedField("event", field.key, field.label))
+];
+var activeCampaignOptionSchema = z.object({ id: z.string(), name: z.string() });
+var activeCampaignPipelineSchema = activeCampaignOptionSchema.extend({
+  stages: z.array(activeCampaignOptionSchema)
+});
+var activeCampaignAutomationSchema = activeCampaignOptionSchema.extend({
+  startTags: z.array(z.string()).default([])
+});
+var activeCampaignCatalogSchema = z.object({
+  fields: z.array(activeCampaignFieldSchema),
+  lists: z.array(activeCampaignOptionSchema).default([]),
+  automations: z.array(activeCampaignAutomationSchema).default([]),
+  pipelines: z.array(activeCampaignPipelineSchema).default([]),
+  users: z.array(activeCampaignOptionSchema).default([]),
+  /** Whether events can be sent: an event key is pasted on the connection, or ActiveCampaign reports one (event tracking is on). */
+  eventKeySaved: z.boolean().default(false)
+});
+var activeCampaignFieldsRequestSchema = z.object({
+  /** Connection id; optional when the company has exactly one ActiveCampaign account. */
+  account: z.string().optional()
+});
+var activeCampaignFieldsResponseSchema = z.object({
+  ok: z.literal(true),
+  data: activeCampaignCatalogSchema.extend({ account: z.string() })
+});
+
+// src/commands/flows/value-expression.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+var PREFIXES = ["field", "tracking", "global", "code"];
+function splitParts(raw) {
+  const parts = [];
+  let current = "";
+  let inQuotes = false;
+  for (let i = 0; i < raw.length; i++) {
+    const char = raw[i];
+    if (char === '"') {
+      inQuotes = !inQuotes;
+      current += char;
+    } else if (char === "+" && !inQuotes) {
+      parts.push(current);
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  parts.push(current);
+  if (inQuotes) {
+    throw new MappingError(`Unclosed quote in value \`${raw}\`.`, 'A literal is written "like this".');
+  }
+  return parts.map((part) => part.trim()).filter((part) => part.length > 0);
+}
+var TRANSFORM_REFUSAL = "A value cannot run code. Map the field as it is (firstname=full_name), or split it in the step with a codeExecution that exposes first_name and last_name and map code:first_name.";
+var METHOD_CALL = /\.\s*[A-Za-z_$][\w$]*\s*\(/;
+var TRAILING_INDEX = /\[[^\]]*\]$/;
+function mentionPart(inner) {
+  if (inner.startsWith("tracking.")) return { kind: "tracking", name: inner.slice("tracking.".length) };
+  if (inner.startsWith("global.")) return { kind: "global", name: inner.slice("global.".length) };
+  return referencePart(inner);
+}
+function referencePart(ref) {
+  return /\.codeExecution\.[^.]+$/.test(ref) ? { kind: "code", ref } : { kind: "field", ref };
+}
+function parsePart(part) {
+  if (part.startsWith('"') && part.endsWith('"') && part.length >= 2) {
+    return { kind: "text", text: part.slice(1, -1) };
+  }
+  if (METHOD_CALL.test(part) || TRAILING_INDEX.test(part)) {
+    throw new MappingError(TRANSFORM_REFUSAL);
+  }
+  if (part.startsWith("{{")) {
+    const close = part.indexOf("}}");
+    if (close < 0) {
+      throw new MappingError(
+        `Unclosed \`{{\` in value \`${part}\`.`,
+        "A mention is written {{<stepId>.customForm.<field>}}."
+      );
+    }
+    if (part.slice(close + 2).trim()) throw new MappingError(TRANSFORM_REFUSAL);
+    return mentionPart(part.slice(2, close).trim());
+  }
+  const colon = part.indexOf(":");
+  if (colon <= 0) return referencePart(part);
+  const prefix = part.slice(0, colon);
+  const rest = part.slice(colon + 1).trim();
+  if (!PREFIXES.includes(prefix)) {
+    throw new MappingError(
+      `\`${prefix}:\` is not a value kind.`,
+      `Use one of ${PREFIXES.map((candidate) => `${candidate}:`).join(" ")}, a bare form field name, or a "quoted literal".`
+    );
+  }
+  if (!rest) throw new MappingError(`\`${part}\` names no ${prefix}.`);
+  switch (prefix) {
+    case "tracking":
+      return { kind: "tracking", name: rest.replace(/^tracking\./, "") };
+    case "global":
+      return { kind: "global", name: rest };
+    case "code":
+      return { kind: "code", ref: rest };
+    default:
+      return { kind: "field", ref: rest };
+  }
+}
+function parseValueExpression(raw) {
+  const parts = splitParts(raw);
+  if (parts.length === 0) {
+    throw new MappingError("A --map needs a value on the right of the `=`.");
+  }
+  return parts.map(parsePart);
+}
+function trackingFieldIds() {
+  const path = join(flowsDir(), "..", "tracking.ts");
+  if (!existsSync(path)) return null;
+  try {
+    const source = readFileSync(path, "utf-8");
+    const block = source.match(/TRACKING_FIELD_IDS\s*=\s*\[([\s\S]*?)\]\s*as const/)?.[1];
+    if (!block) return null;
+    const ids = [...block.matchAll(/"(tracking\.[a-z0-9_]+)"/g)].map((match) => match[1]);
+    return ids.length > 0 ? new Set(ids) : null;
+  } catch {
+    return null;
+  }
+}
+function externalOf(node) {
+  const nodeData = node.nodeData ?? {};
+  return nodeData.form?.external ?? {};
+}
+function fieldOwners(tree) {
+  return walkNodes(tree).flatMap((node) => {
+    const external = externalOf(node);
+    if (!Array.isArray(external.fields)) return [];
+    return [
+      {
+        id: String(node.id ?? ""),
+        name: typeof node.name === "string" && node.name ? node.name : "Form",
+        fields: external.fields.map((field) => field?.fieldName).filter((name) => typeof name === "string")
+      }
+    ];
+  });
+}
+function splitRef(ref, segment) {
+  const marker = `.${segment}.`;
+  const at = ref.lastIndexOf(marker);
+  if (at > 0 && !ref.slice(at + marker.length).includes(".")) {
+    return { step: ref.slice(0, at), name: ref.slice(at + marker.length) };
+  }
+  const dot = ref.lastIndexOf(".");
+  if (dot <= 0) return { name: ref };
+  return { step: ref.slice(0, dot), name: ref.slice(dot + 1) };
+}
+function mention(id, label) {
+  return { type: "VariablesMention", attrs: { id, label, mentionSuggestionChar: "{{" } };
+}
+function titleize(value) {
+  return value.split(/[_-]+/).filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+function resolveField(tree, ref) {
+  const { step, name } = splitRef(ref, "customForm");
+  const owners = fieldOwners(tree);
+  const inventory = owners.map((owner2) => `  ${owner2.name} (${owner2.id}): ${owner2.fields.join(", ") || "(no fields)"}`).join("\n");
+  const candidates = owners.filter(
+    (owner2) => owner2.fields.includes(name) && (!step || owner2.name === step || owner2.id === step)
+  );
+  if (candidates.length === 0) {
+    throw new MappingError(`Form field "${ref}" does not exist in this form.`, inventory);
+  }
+  if (candidates.length > 1) {
+    throw new MappingError(
+      `Form field "${name}" exists on ${candidates.length} steps \u2014 say which: field:<step>.${name}`,
+      candidates.map((owner2) => `  field:${owner2.name}.${name}`).join("\n")
+    );
+  }
+  const owner = candidates[0];
+  return mention(`${owner.id}.customForm.${name}`, `${owner.name} => ${titleize(name)}`);
+}
+function resolveTracking(name) {
+  const id = `tracking.${name}`;
+  const known = trackingFieldIds();
+  if (known && !known.has(id)) {
+    const near = [...known].filter((candidate) => candidate.includes(name.split("_")[0] ?? name)).slice(0, 8);
+    throw new MappingError(
+      `\`${id}\` is not a tracking variable.`,
+      near.length > 0 ? `Close matches: ${near.join(", ")}` : "See references/autofill-and-variables.md \xA7 Built-in Tracking Variables."
+    );
+  }
+  return mention(id, id);
+}
+function resolveGlobal(tree, name) {
+  const globals = tree.globalVariables ?? [];
+  const match = globals.find((variable) => variable?.name === name || variable?.id === name);
+  if (!match) {
+    throw new MappingError(
+      `No global variable named "${name}" on this form.`,
+      globals.length > 0 ? `Defined: ${globals.map((variable) => String(variable.name)).join(", ")}` : "This form defines none. Globals live on the first node only \u2014 see references/autofill-and-variables.md \xA7 Global Variables."
+    );
+  }
+  const id = `global.${String(match.id)}`;
+  return mention(id, id);
+}
+function resolveCode(tree, ref) {
+  const { step, name } = splitRef(ref, "codeExecution");
+  const owners = walkNodes(tree).flatMap((node) => {
+    const exposed = externalOf(node).codeExecution?.exposedValues ?? [];
+    const names = exposed.map((value) => value?.name).filter((value) => typeof value === "string");
+    return names.length > 0 ? [{ id: String(node.id ?? ""), name: String(node.name ?? "step"), names }] : [];
+  });
+  const candidates = owners.filter(
+    (owner2) => owner2.names.includes(name) && (!step || owner2.name === step || owner2.id === step)
+  );
+  if (candidates.length !== 1) {
+    throw new MappingError(
+      candidates.length === 0 ? `No codeExecution exposes "${ref}" on this form.` : `"${name}" is exposed by ${candidates.length} steps \u2014 say which: code:<step>.${name}`,
+      owners.length > 0 ? owners.map((owner2) => `  ${owner2.name} (${owner2.id}): ${owner2.names.join(", ")}`).join("\n") : "No step on this form exposes any codeExecution value."
+    );
+  }
+  const owner = candidates[0];
+  return mention(`${owner.id}.codeExecution.${name}`, `${owner.name} => ${titleize(name)}`);
+}
+function buildValueDoc(tree, expression) {
+  const parts = parseValueExpression(expression);
+  const content = parts.map((part) => {
+    switch (part.kind) {
+      case "text":
+        return { type: "text", text: part.text };
+      case "tracking":
+        return resolveTracking(part.name);
+      case "global":
+        return resolveGlobal(tree, part.name);
+      case "code":
+        return resolveCode(tree, part.ref);
+      default:
+        return resolveField(tree, part.ref);
+    }
+  });
+  const single = content.length === 1 && parts[0]?.kind !== "text";
+  return {
+    type: "doc",
+    content: [{ type: "paragraph", content: single ? [...content, { type: "text", text: " " }] : content }]
+  };
+}
+
+// src/commands/flows/mapping.ts
+var MappingError = class extends Error {
+  fix;
+  constructor(message, fix) {
+    super(message);
+    this.name = "MappingError";
+    this.fix = fix;
+  }
+};
+var PAYLOAD = (key) => ({ kind: "list", key, addressedBy: "key" });
+var META_MATCHING = ["em", "fn", "ln", "ph", "external_id", "ge", "db", "ct", "st", "zp", "country"];
+var ADS_MATCHING = [
+  "email",
+  "phone_number",
+  "first_name",
+  "last_name",
+  "street",
+  "city",
+  "region",
+  "postal_code",
+  "country"
+];
+var MAPPING_SLOTS = {
+  googleSpreadsheet: [{ kind: "list", key: "columnMapping", addressedBy: "column" }],
+  hubspotForm: [
+    {
+      kind: "list",
+      key: "fieldMapping",
+      addressedBy: "fieldName",
+      needsFieldType: true,
+      fieldTypeSource: "Pass --hubspot-form <formGuid> and this command reads every property's type off the form itself \u2014 the guid is the `formGuid` in the `destination` request_flow_input returned. `baker hubspot forms view <formGuid>` prints the same list if you want to see it."
+    }
+  ],
+  pipedrive: [
+    {
+      kind: "list",
+      key: "fieldMapping",
+      addressedBy: "fieldKey",
+      entities: ["person", "organization", "lead"],
+      needsFieldType: true,
+      needsIsCustom: true
+    }
+  ],
+  goHighlevelContact: [
+    {
+      kind: "list",
+      key: "fieldMapping",
+      addressedBy: "fieldKey",
+      entities: ["business", "contact", "opportunity"],
+      needsFieldType: true,
+      needsIsCustom: true
+    }
+  ],
+  crmble: [
+    { kind: "list", key: "fieldMapping", addressedBy: "fieldId", entities: ["contact", "lead"], needsFieldType: true }
+  ],
+  activeCampaignContact: [
+    {
+      kind: "list",
+      key: "fieldMapping",
+      addressedBy: "fieldKey",
+      needsFieldType: true,
+      fieldTypes: ACTIVECAMPAIGN_FIELD_TYPES,
+      qualifiedByFieldType: true,
+      fieldTypeSource: 'None to write: this command reads the connected ActiveCampaign account\'s field list itself. Write `email=email`, `firstName=nombre`, a custom field by its id, personalization tag or label (`SECTOR=sector`; `custom.UTM_SOURCE=\u2026` for one only staged so far), `tags="withbaker-"+tracking:page_path`, `lists="Newsletter"`, `automations="Welcome"`, `deal.title=\u2026` / `deal.pipeline="Sales"` / `deal.value=budget`, `account.name=company`, `note=\u2026`, `event.name="demo_requested"`.'
+    }
+  ],
+  email: [{ ...PAYLOAD("fields"), under: "body" }],
+  zapier: [PAYLOAD("payloadKeys")],
+  httpWebhook: [PAYLOAD("payloadKeys")],
+  googleTagManager: [PAYLOAD("dataLayerParams")],
+  googleAnalytics: [PAYLOAD("eventParams")],
+  posthog: [PAYLOAD("eventParams")],
+  amplitude: [PAYLOAD("eventProperties")],
+  hubspot: [PAYLOAD("eventProperties")],
+  vwo: [PAYLOAD("eventProperties")],
+  code: [PAYLOAD("eventProperties")],
+  datafast: [PAYLOAD("goalParams")],
+  meta: [PAYLOAD("eventParams"), { kind: "record", key: "advancedMatching", allowed: META_MATCHING }],
+  chatgptAds: [
+    PAYLOAD("eventParams"),
+    {
+      kind: "record",
+      key: "advancedMatching",
+      allowed: ["em", "ph", "fn", "ln", "external_id", "ct", "st", "zp", "country"]
+    }
+  ],
+  tiktok: [
+    PAYLOAD("eventParams"),
+    { kind: "record", key: "identify", allowed: ["email", "phone_number", "external_id"] }
+  ],
+  pinterest: [PAYLOAD("eventParams"), { kind: "record", key: "enhancedMatching", allowed: ["em", "hashed_maids"] }],
+  googleAds: [
+    { kind: "record", key: "enhancedConversions", allowed: ADS_MATCHING },
+    { kind: "scalar", keys: ["value", "currency", "transactionId"] }
+  ],
+  linkedinInsightTag: [
+    { kind: "record", key: "userMatching", allowed: ["em", "fn", "ln", "title", "companyName", "country"] },
+    { kind: "scalar", keys: ["value", "currency"] }
+  ],
+  twitterAds: [
+    { kind: "record", key: "userMatching", allowed: ["em", "ph"] },
+    { kind: "scalar", keys: ["value", "currency"] }
+  ]
+};
+var UNMAPPABLE = {
+  hotjar: "A Hotjar event carries only its name.",
+  clarity: "A Clarity custom tag carries only its name."
+};
+function slotName(shape) {
+  if (shape.kind === "scalar") return shape.keys.join("/");
+  if (shape.kind === "list" && shape.under) return `${shape.under}.${shape.key}`;
+  return shape.key;
+}
+function shapeFor(type, into) {
+  const slots = MAPPING_SLOTS[type];
+  if (!slots) {
+    const why = UNMAPPABLE[type];
+    throw new MappingError(
+      `Side effect "${type}" has no mappable field.`,
+      why ?? `"${type}" is not a side-effect type this workspace's flow engine defines.`
+    );
+  }
+  if (!into) return slots[0];
+  const chosen = slots.find(
+    (slot) => slot.kind === "scalar" ? slot.keys.includes(into) || into === "scalar" : slot.key === into || slotName(slot) === into
+  );
+  if (!chosen) {
+    throw new MappingError(
+      `"${into}" is not a mappable slot on a ${type} side effect.`,
+      `Slots on ${type}: ${slots.map(slotName).join(", ")}`
+    );
+  }
+  return chosen;
+}
+function namesComeFromAccount(shape) {
+  return shape.kind === "list" && shape.addressedBy !== "key";
+}
+function describeSlots(type) {
+  return (MAPPING_SLOTS[type] ?? []).map((shape) => {
+    if (shape.kind === "record") {
+      return {
+        slot: shape.key,
+        addressedBy: "one of a closed set",
+        keysFrom: "closed",
+        keys: shape.allowed,
+        note: `${type} defines these names; any other is refused.`
+      };
+    }
+    if (shape.kind === "scalar") {
+      return {
+        slot: shape.keys.join("/"),
+        addressedBy: "the field's own name",
+        keysFrom: "closed",
+        keys: shape.keys,
+        note: "Each is a single value on the side effect, mapped like any other."
+      };
+    }
+    if (shape.addressedBy === "key") {
+      return {
+        slot: slotName(shape),
+        addressedBy: "key",
+        keysFrom: "yours",
+        note: "You name these \u2014 they are what the receiving system expects. Ask the user if you do not know them."
+      };
+    }
+    return {
+      slot: slotName(shape),
+      addressedBy: shape.addressedBy,
+      keysFrom: "account",
+      note: "These live in the connected account. Read them off the request_flow_input result; they cannot be guessed.",
+      ...shape.needsFieldType ? { fieldTypes: shape.fieldTypeSource ?? FIELD_TYPE_FROM_INPUT } : {}
+    };
+  });
+}
+var FIELD_TYPE_FROM_INPUT = "Each mapping stores a field type. They come back from request_flow_input with the field list \u2014 write one on the LEFT: <field>:<fieldType>=<value>.";
+function otherSlots(type, used) {
+  return (MAPPING_SLOTS[type] ?? []).filter((slot) => slot !== used).map(slotName);
+}
+var ACTIVECAMPAIGN_BARE_KINDS = /* @__PURE__ */ new Set(["standard", "custom", "tags", "lists", "automations", "note"]);
+function addCustomAliases(catalog, field) {
+  const entry = catalog.get(`custom.${field.fieldKey}`);
+  if (!entry) return;
+  const tag = field.perstag?.replaceAll("%", "");
+  if (tag) catalog.set(`custom.${tag.toUpperCase()}`, entry);
+  const aliases = [field.perstag, tag, field.label].filter((alias) => !!alias);
+  for (const alias of aliases) {
+    const key = alias.trim().toLowerCase();
+    if (key && !catalog.has(key)) catalog.set(key, entry);
+  }
+}
+function activeCampaignDestinationFields(fields) {
+  const catalog = /* @__PURE__ */ new Map();
+  for (const field of fields) {
+    const qualified = `${field.fieldType}.${field.fieldKey}`;
+    const bare = ACTIVECAMPAIGN_BARE_KINDS.has(field.fieldType);
+    const entry = {
+      fieldType: field.fieldType,
+      fieldKey: field.fieldKey,
+      label: field.label,
+      ...bare ? {} : { listedAs: qualified }
+    };
+    catalog.set(qualified, entry);
+    if (bare && !catalog.has(field.fieldKey)) {
+      catalog.set(field.fieldKey, entry);
+    }
+  }
+  for (const field of fields) {
+    if (field.fieldType === "custom") addCustomAliases(catalog, field);
+  }
+  return catalog;
+}
+function activeCampaignUnlistedField(destField) {
+  const match = /^custom\.%?([A-Za-z][A-Za-z0-9_]*)%?$/.exec(destField.trim());
+  if (!match?.[1]) return void 0;
+  const tag = match[1].toUpperCase();
+  return { fieldType: "custom", fieldKey: tag, label: `%${tag}%` };
+}
+function literalText(value) {
+  const paragraphs = (value ?? {}).content;
+  if (!Array.isArray(paragraphs)) return null;
+  const inline = paragraphs.flatMap((paragraph) => paragraph.content ?? []);
+  if (inline.length === 0 || inline.some((node) => node.type !== "text")) return null;
+  return inline.map((node) => node.text ?? "").join("");
+}
+function optionListing(options) {
+  return options.length > 0 ? options.map((option) => `${option.name} (${option.id})`).join(", ") : "none";
+}
+function unknownNames(value, options) {
+  const text = literalText(value);
+  if (text === null) return [];
+  return splitActiveCampaignNames(text).filter((name) => !findActiveCampaignOption(options, name));
+}
+function namedOptionHints(mapped, catalog) {
+  const hints = [];
+  const unknown = (type, key, options, noun) => {
+    for (const name of unknownNames(mapped(type, key)?.value, options)) {
+      hints.push(
+        `ActiveCampaign has no ${noun} called "${name}", so that part will be skipped. It has: ${optionListing(options)}.`
+      );
+    }
+  };
+  unknown("lists", "lists", catalog.lists, "list");
+  unknown("automations", "automations", catalog.automations, "automation");
+  if (mapped("automations", "automations") && catalog.automations.length === 0) {
+    hints.push(
+      "This ActiveCampaign account has no automations. They can only be built in ActiveCampaign \u2014 ask the user to create one."
+    );
+  }
+  unknown("deal", "pipeline", catalog.pipelines, "pipeline");
+  unknown("deal", "owner", catalog.users, "user");
+  return hints;
+}
+function literalTags(value) {
+  const paragraphs = (value ?? {}).content;
+  if (!Array.isArray(paragraphs)) return [];
+  const inline = paragraphs.flatMap((paragraph) => paragraph.content ?? []);
+  return inline.flatMap((node, index) => {
+    if (node.type !== "text") return [];
+    const pieces = (node.text ?? "").split(",");
+    const touchesBefore = index > 0 && inline[index - 1]?.type !== "text";
+    const touchesAfter = index < inline.length - 1 && inline[index + 1]?.type !== "text";
+    return pieces.filter((_, piece) => !(piece === 0 && touchesBefore) && !(piece === pieces.length - 1 && touchesAfter)).map((piece) => piece.trim()).filter((piece) => piece !== "");
+  });
+}
+function doubleEnrollmentHints(mapped, catalog) {
+  const enrolled = literalText(mapped("automations", "automations")?.value);
+  if (enrolled === null) return [];
+  const tags = new Set(literalTags(mapped("tags", "tags")?.value).map((tag) => tag.toLowerCase()));
+  return splitActiveCampaignNames(enrolled).flatMap((name) => {
+    const automation = catalog.automations.find((option) => findActiveCampaignOption([option], name));
+    const tag = automation?.startTags.find((start) => tags.has(start.toLowerCase()));
+    return automation && tag ? [
+      `"${automation.name}" starts when the tag "${tag}" is added, and this Form adds that tag AND enrolls the lead in it \u2014 every lead would run it twice (ActiveCampaign's "runs once" does not stop a direct enrollment). Keep one: drop "${automation.name}" from automations, or drop the tag.`
+    ] : [];
+  });
+}
+function dealHints(fieldMapping, mapped, catalog) {
+  if (!fieldMapping.some((entry) => entry.fieldType === "deal")) return [];
+  const hints = [];
+  if (!mapped("deal", "title") && !mapped("deal", "pipeline")) {
+    hints.push("No deal is created without deal.title or deal.pipeline \u2014 map one of them too.");
+  }
+  if (catalog.pipelines.length === 0) {
+    hints.push("This ActiveCampaign account has no deal pipeline, so no deal can be created until one exists.");
+  }
+  const pipelineText = literalText(mapped("deal", "pipeline")?.value);
+  const pipeline = pipelineText ? findActiveCampaignOption(catalog.pipelines, pipelineText) : catalog.pipelines[0];
+  if (!pipeline) return hints;
+  for (const name of unknownNames(mapped("deal", "stage")?.value, pipeline.stages)) {
+    hints.push(
+      `The pipeline "${pipeline.name}" has no stage called "${name}", so deals land in its first stage. Its stages: ${optionListing(pipeline.stages)}.`
+    );
+  }
+  return hints;
+}
+function attachmentHints(mapped, catalog) {
+  const hints = [];
+  if (mapped("account", "url") && !mapped("account", "name")) {
+    hints.push("account.url is only sent with account.name \u2014 map the company name too.");
+  }
+  if (mapped("event", "data") && !mapped("event", "name")) hints.push("event.data is only sent with event.name.");
+  if (mapped("event", "name") && !catalog.eventKeySaved) {
+    hints.push(
+      "Event tracking is off on this ActiveCampaign account, so the event will be skipped: ask the user to switch event tracking on in ActiveCampaign (Settings \u2192 Tracking \u2192 Event Tracking). There is nothing to paste \u2014 Baker reads the account's event key itself once it is on. Until then only the event is skipped; the contact and the rest still arrive."
+    );
+  }
+  return hints;
+}
+function unlistedCustomHints(fieldMapping, catalog) {
+  const listedIds = new Set(catalog.fields.flatMap((field) => field.fieldType === "custom" ? [field.fieldKey] : []));
+  return fieldMapping.flatMap((entry) => {
+    const key = typeof entry.fieldKey === "string" ? entry.fieldKey : "";
+    if (entry.fieldType !== "custom" || /^\d+$/.test(key) || listedIds.has(key)) return [];
+    return [
+      `custom.${key} is not on the ActiveCampaign account yet. Stage the field (\`baker activecampaign stage field\`) so it exists at Publish; until it does, that value is left empty on each contact.`
+    ];
+  });
+}
+function activeCampaignMappingHints(fieldMapping, catalog) {
+  const mapped = (type, key) => fieldMapping.find((entry) => entry.fieldType === type && entry.fieldKey === key);
+  return [
+    ...namedOptionHints(mapped, catalog),
+    ...doubleEnrollmentHints(mapped, catalog),
+    ...dealHints(fieldMapping, mapped, catalog),
+    ...attachmentHints(mapped, catalog),
+    ...unlistedCustomHints(fieldMapping, catalog)
+  ];
+}
+function parseMapSpec(raw) {
+  const eq = raw.indexOf("=");
+  if (eq <= 0 || eq === raw.length - 1) {
+    throw new MappingError(
+      `--map "${raw}" must be <destField>[:<fieldType>]=<value>`,
+      'Value: a form field (`nombre`), `tracking:utm_source`, `global:Name`, `code:name`, a "literal", or those joined with `+`.'
+    );
+  }
+  const left = raw.slice(0, eq).trim();
+  const expression = raw.slice(eq + 1).trim();
+  const colon = left.indexOf(":");
+  const destField = (colon > 0 ? left.slice(0, colon) : left).trim();
+  const fieldType = colon > 0 ? left.slice(colon + 1).trim() : "";
+  if (!destField) throw new MappingError(`--map "${raw}" names no destination field.`);
+  return { raw, destField, fieldType: fieldType || void 0, expression };
+}
+function sheetEntry(spec, value) {
+  if (!/^[A-Z]{1,3}$/.test(spec.destField)) {
+    throw new MappingError(
+      `--map "${spec.raw}": a Google Sheet is addressed by COLUMN, so the left side must be a column letter (A, B, \u2026 AA), got "${spec.destField}".`,
+      "Read the real destination back from the configured side effect first \u2014 a column letter is a guess until a spreadsheet is picked."
+    );
+  }
+  return { column: spec.destField, value };
+}
+function destinationField(spec, options) {
+  const catalog = options.destinationFields;
+  if (!catalog) return void 0;
+  const match = catalog.get(spec.destField);
+  if (match) return match;
+  const alias = catalog.get(spec.destField.trim().toLowerCase());
+  if (alias?.fieldKey) return alias;
+  const unlisted = options.unlistedField?.(spec.destField);
+  if (unlisted) return unlisted;
+  throw new MappingError(
+    `--map "${spec.raw}": the destination has no field called "${spec.destField}".`,
+    `Fields on it: ${catalogListing(catalog) || "(none)"}`
+  );
+}
+function catalogListing(catalog) {
+  const seen = /* @__PURE__ */ new Set();
+  const names = [];
+  for (const [name, field] of catalog) {
+    if (seen.has(field)) continue;
+    seen.add(field);
+    const key = field.listedAs ?? field.fieldKey ?? name;
+    names.push(field.label && field.label.toLowerCase() !== key.toLowerCase() ? `${key} (${field.label})` : key);
+  }
+  return names.join(", ");
+}
+function fieldTypeFor(type, shape, spec, known) {
+  const resolved = spec.fieldType ?? known?.fieldType;
+  if (resolved && shape.fieldTypes && !shape.fieldTypes.includes(resolved)) {
+    throw new MappingError(
+      `--map "${spec.raw}": "${resolved}" is not a ${type} field type \u2014 expected one of: ${shape.fieldTypes.join(", ")}.`,
+      shape.fieldTypeSource
+    );
+  }
+  if (resolved) return resolved;
+  throw new MappingError(
+    `--map "${spec.raw}": ${type} stores a field type per mapping, and "${spec.destField}" has none \u2014 write it on the left: <field>:<fieldType>=<value>.`,
+    shape.fieldTypeSource ?? FIELD_TYPE_FROM_INPUT
+  );
+}
+function assertCrmOptions(type, shape, options) {
+  const entities = shape.entities;
+  if (entities) {
+    if (!options.entity) {
+      throw new MappingError(
+        `${type} addresses a specific object, so --entity is required (one of: ${entities.join(", ")}).`,
+        "Which object a value lands on is a destination-side fact \u2014 read it back from the configured side effect, do not assume."
+      );
+    }
+    if (!entities.includes(options.entity)) {
+      throw new MappingError(
+        `--entity "${options.entity}" is not valid for ${type} \u2014 expected one of: ${entities.join(", ")}.`
+      );
+    }
+  }
+  if (shape.needsIsCustom && options.isCustomField === void 0) {
+    throw new MappingError(
+      `${type} looks a key up differently for custom and standard fields, so pass --custom or --standard.`,
+      "Mapping a custom field as standard (or the reverse) is accepted and then dropped. The field list from request_flow_input says which each one is."
+    );
+  }
+}
+function buildEntry(type, shape, spec, value, options) {
+  if (shape.key === "columnMapping") {
+    return sheetEntry(spec, value);
+  }
+  if (shape.addressedBy === "key") {
+    if (spec.fieldType) {
+      throw new MappingError(
+        `--map "${spec.raw}": a ${type} ${shape.key} entry is just a name and a value \u2014 it takes no field type.`,
+        `Write it as ${spec.destField}=${spec.expression}`
+      );
+    }
+    return { key: spec.destField, value };
+  }
+  const known = destinationField(spec, options);
+  if (type === "hubspotForm") {
+    return {
+      objectTypeId: options.objectType ?? known?.objectTypeId ?? "0-1",
+      fieldType: fieldTypeFor(type, shape, spec, known),
+      fieldName: spec.destField,
+      value
+    };
+  }
+  assertCrmOptions(type, shape, options);
+  return {
+    ...shape.entities ? { entityType: options.entity } : {},
+    fieldType: fieldTypeFor(type, shape, spec, known),
+    ...shape.needsIsCustom ? { isCustomField: options.isCustomField } : {},
+    [shape.addressedBy]: known?.fieldKey ?? spec.destField,
+    value
+  };
+}
+function listPatch(shape, sideEffect, entries) {
+  if (!shape.under) return { [shape.key]: entries };
+  const owner = sideEffect[shape.under] ?? {};
+  return { [shape.under]: { ...owner, [shape.key]: entries } };
+}
+function existingEntries(shape, sideEffect) {
+  const owner = shape.under ? sideEffect[shape.under] : sideEffect;
+  if (!owner || typeof owner !== "object") return [];
+  const list = owner[shape.key];
+  if (!Array.isArray(list)) return [];
+  return list.filter((entry) => Boolean(entry) && typeof entry === "object");
+}
+function entryAddress(shape, entry) {
+  const value = entry[shape.addressedBy];
+  if (typeof value !== "string") return null;
+  return shape.qualifiedByFieldType && typeof entry.fieldType === "string" ? `${entry.fieldType}.${value}` : value;
+}
+function mergeEntries(shape, existing, incoming) {
+  const address = (entry) => entryAddress(shape, entry);
+  const entries = [...existing];
+  const overwritten = /* @__PURE__ */ new Set();
+  for (const entry of incoming) {
+    const name = address(entry);
+    const at = name === null ? -1 : entries.findIndex((candidate) => address(candidate) === name);
+    if (at === -1) {
+      entries.push(entry);
+      continue;
+    }
+    entries[at] = entry;
+    if (at < existing.length) overwritten.add(at);
+  }
+  const kept = existing.length - overwritten.size;
+  return { entries, written: entries.length - kept, kept };
+}
+function assertMappableOwner(type, shape, sideEffect) {
+  if (shape.under !== "body") return;
+  const format = (sideEffect.body ?? {}).format;
+  if (format !== void 0 && format !== "json") {
+    throw new MappingError(
+      `This ${type} side effect sends \`body.format: "${String(format)}"\`, which is one written message rather than named keys.`,
+      'Set `body` to `{ "format": "json", "fields": [] }` first if you want mapped keys, or write the message in `body.content` and map nothing.'
+    );
+  }
+}
+function buildList(tree, type, shape, sideEffect, specs, options) {
+  assertMappableOwner(type, shape, sideEffect);
+  const incoming = specs.map((raw) => {
+    const spec = parseMapSpec(raw);
+    return buildEntry(type, shape, spec, buildValueDoc(tree, spec.expression), options);
+  });
+  const present = options.replace === true ? [] : existingEntries(shape, sideEffect);
+  const { kept: existing, dropped } = pruneAbsent(shape, present, options);
+  const { entries, written, kept } = mergeEntries(shape, existing, incoming);
+  return { key: slotName(shape), count: written, kept, dropped, patch: listPatch(shape, sideEffect, entries) };
+}
+function pruneAbsent(shape, existing, options) {
+  if (options.pruneMissing !== true) return { kept: existing, dropped: [] };
+  const catalog = options.destinationFields;
+  if (!catalog) {
+    throw new MappingError(
+      "--prune-missing needs the destination's own field list, and it could not be read.",
+      "Name the destination so its fields can be read \u2014 --hubspot-form <formGuid> for HubSpot (an ActiveCampaign side effect is read automatically). `baker flows show <slug>` names the side effect and returns the request_flow_input call that carries the guid."
+    );
+  }
+  const kept = [];
+  const dropped = [];
+  for (const entry of existing) {
+    const name = entryAddress(shape, entry);
+    if (name === null || catalog.has(name)) {
+      kept.push(entry);
+      continue;
+    }
+    dropped.push(name);
+  }
+  return { kept, dropped };
+}
+function buildRecord(tree, type, shape, sideEffect, specs, options) {
+  const existing = options.replace === true ? {} : sideEffect[shape.key] ?? {};
+  const record = Object.fromEntries(shape.allowed.map((slot) => [slot, existing[slot] ?? null]));
+  const filledBefore = shape.allowed.filter((slot) => record[slot] != null);
+  const written = /* @__PURE__ */ new Set();
+  for (const raw of specs) {
+    const spec = parseMapSpec(raw);
+    if (!shape.allowed.includes(spec.destField)) {
+      throw new MappingError(
+        `"${spec.destField}" is not a slot in ${shape.key} on a ${type} side effect.`,
+        `${shape.key} slots: ${shape.allowed.join(", ")}`
+      );
+    }
+    if (spec.fieldType) {
+      throw new MappingError(`--map "${spec.raw}": a ${shape.key} slot takes no field type.`);
+    }
+    record[spec.destField] = buildValueDoc(tree, spec.expression);
+    written.add(spec.destField);
+  }
+  return {
+    key: shape.key,
+    count: written.size,
+    kept: filledBefore.filter((slot) => !written.has(slot)).length,
+    dropped: [],
+    patch: { [shape.key]: record }
+  };
+}
+function buildScalar(tree, type, shape, sideEffect, specs, options) {
+  const patch = options.replace === true ? Object.fromEntries(shape.keys.map((key) => [key, null])) : {};
+  const written = /* @__PURE__ */ new Set();
+  for (const raw of specs) {
+    const spec = parseMapSpec(raw);
+    if (!shape.keys.includes(spec.destField)) {
+      throw new MappingError(
+        `"${spec.destField}" is not a mappable field on a ${type} side effect.`,
+        `Mappable directly: ${shape.keys.join(", ")}`
+      );
+    }
+    if (spec.fieldType) {
+      throw new MappingError(`--map "${spec.raw}": ${spec.destField} takes no field type.`);
+    }
+    patch[spec.destField] = buildValueDoc(tree, spec.expression);
+    written.add(spec.destField);
+  }
+  const kept = options.replace === true ? 0 : shape.keys.filter((key) => !written.has(key) && sideEffect[key] != null).length;
+  return { key: shape.keys.join("/"), count: written.size, kept, dropped: [], patch };
+}
+function buildFieldMapping(tree, sideEffect, specs, options = {}) {
+  const type = String(sideEffect.type ?? "");
+  const shape = shapeFor(type, options.into);
+  if (shape.kind === "record") return buildRecord(tree, type, shape, sideEffect, specs, options);
+  if (shape.kind === "scalar") return buildScalar(tree, type, shape, sideEffect, specs, options);
+  return buildList(tree, type, shape, sideEffect, specs, options);
+}
+
+export {
+  activeCampaignFieldsResponseSchema,
+  MappingError,
+  shapeFor,
+  namesComeFromAccount,
+  describeSlots,
+  otherSlots,
+  activeCampaignDestinationFields,
+  activeCampaignUnlistedField,
+  activeCampaignMappingHints,
+  buildFieldMapping
+};
+//# sourceMappingURL=chunk-IFDZZOUC.js.map