@koda-sl/baker-cli 0.524.0 → 0.526.0

package/dist/analytics-OUNKG2FW.js

@@ -0,0 +1,2437 @@
+import {
+  readTargetsFile
+} from "./chunk-S6VFDNSQ.js";
+import "./chunk-I7AYMJZA.js";
+import {
+  flowEventKeys,
+  flowNodes
+} from "./chunk-Z4ZYFIDQ.js";
+import {
+  flowDataPath,
+  flowExists,
+  listFlowSlugs,
+  readFlowTree
+} from "./chunk-W7C7HZFJ.js";
+import {
+  INGEST_ARRIVALS_MAX,
+  eventIngestUrl,
+  ingestBrief
+} from "./chunk-EIDJCUMM.js";
+import "./chunk-GRQ2AXDX.js";
+import {
+  TAG_MANAGER_TIMEOUT_MS
+} from "./chunk-TTKDFRON.js";
+import {
+  peopleArgs,
+  peopleLimitError
+} from "./chunk-4VSD4NSZ.js";
+import {
+  analyticsErrorEnvelope
+} from "./chunk-ZL5YETKR.js";
+import {
+  ConversionArgsError,
+  conversionsWrite,
+  parseConversionsArgs
+} from "./chunk-SXML3LQN.js";
+import {
+  AD_PARAM_ROLE_SPECS,
+  ANALYTICS_EVENT_DOORS,
+  ANALYTICS_FULL_BREAKDOWN_LIMIT,
+  SEND_FILTERS,
+  STANDARD_CONVERSION_NAMES,
+  destinationName,
+  essentialAdDimensions,
+  isAdPlatform,
+  isBookkeepingRow,
+  parseEventKey,
+  rowMatchKeys
+} from "./chunk-B65WCT6M.js";
+import "./chunk-NKQWDEB7.js";
+import {
+  repeatedValues
+} from "./chunk-ERSX3MKH.js";
+import "./chunk-D5FY4FAK.js";
+import {
+  writeJsonEnvelope
+} from "./chunk-HPDGVK6R.js";
+import {
+  flowNodeTriggers
+} from "./chunk-HVJJEQDQ.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-NSBNIPIW.js";
+import "./chunk-46YLDIQG.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-B4UVJCJ4.js";
+import "./chunk-AFQF6ISC.js";
+import {
+  getEnv
+} from "./chunk-52IYZCRS.js";
+import {
+  registerSchema
+} from "./chunk-FSGJSREN.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/analytics/index.ts
+import { readFileSync } from "fs";
+import { defineCommand } from "citty";
+
+// src/commands/analytics/conversionCandidates.ts
+function compact(row) {
+  return {
+    eventKey: row.eventKey,
+    events: row.events,
+    sessions: row.sessions,
+    ...row.isCounted ? { countedAs: row.countedAs } : {}
+  };
+}
+function foldByForm(rows) {
+  const byForm = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const form = byForm.get(row.flowSlug) ?? { form: row.flowSlug, keys: 0, countedKeys: 0, events: 0 };
+    form.keys += 1;
+    if (row.isCounted) form.countedKeys += 1;
+    form.events += row.events;
+    byForm.set(row.flowSlug, form);
+  }
+  return [...byForm.values()];
+}
+function candidatesForFlow(catalogue, flowSlug) {
+  return flowSlug === void 0 ? [...catalogue] : catalogue.filter((row) => row.flowSlug === flowSlug);
+}
+var FOLDED_FORMS_HINT = "A Form's candidates are folded into its `flows` row (`keys` fired, `events`; no `counted` means it counts nothing), or a `formCandidates` row when not listed. `--candidates --flow <slug>` lists that Form's keys; `--full` adds every field of every key.";
+function candidatesView(rows, options) {
+  if (options.full) return { candidates: rows };
+  if (options.flowSlug !== void 0) return { candidates: rows.map(compact) };
+  const forms = foldByForm(rows.filter((row) => row.flowSlug !== ""));
+  return {
+    candidates: rows.filter((row) => row.flowSlug === "").map(compact),
+    ...forms.length > 0 ? { formCandidates: forms } : {}
+  };
+}
+function fullFlagHints(args, format) {
+  if (!args.full || args.candidates && format !== "md") return [];
+  return ["`--full` only applies to `--candidates --output json`, so it changed nothing here."];
+}
+function compactConversionsEnvelope(envelope, options) {
+  const { candidates, flows, ...data } = envelope.data;
+  if (candidates === void 0) return { ...envelope };
+  const { formCandidates, ...view } = candidatesView(candidates, options);
+  const traffic = new Map(formCandidates?.map((form) => [form.form, form]));
+  const merged = flows?.map(({ slug, counted, noConversion }) => {
+    const form = traffic.get(slug);
+    traffic.delete(slug);
+    return {
+      slug,
+      ...counted.length > 0 ? { counted } : {},
+      ...noConversion !== null ? { noConversion } : {},
+      keys: form?.keys ?? 0,
+      events: form?.events ?? 0
+    };
+  });
+  const hints = [...envelope.hints ?? [], ...formCandidates ? [FOLDED_FORMS_HINT] : []];
+  return {
+    ...envelope,
+    data: {
+      ...data,
+      ...merged ? { flows: merged } : {},
+      ...view,
+      ...traffic.size > 0 ? { formCandidates: [...traffic.values()] } : {}
+    },
+    ...hints.length > 0 ? { hints } : {}
+  };
+}
+
+// src/commands/analytics/conversionHints.ts
+var NAMED_CANDIDATES = 3;
+function conversionHints(definitions, candidates, askedForCandidates) {
+  const hints = [];
+  if (definitions.length === 0) {
+    hints.push(
+      "Nothing is counted as a conversion, so EVERY conversion number in every other report is zero \u2014 whatever visitors actually did. Baker never guesses which event is the point of a page. Run `baker analytics conversions --candidates` to see what these pages produce, then count the ones that are worth money."
+    );
+    if (!askedForCandidates && candidates.length > 0) {
+      const top = candidates.slice(0, NAMED_CANDIDATES).map((row) => row.eventKey).join(", ");
+      hints.push(`${candidates.length} distinct events are available to count. Busiest: ${top}.`);
+    }
+    return hints;
+  }
+  const silent = definitions.filter((row) => row.lastSeen === null);
+  if (silent.length > 0) {
+    hints.push(
+      `${silent.length} counted outcome(s) have never fired in this window: ${silent.slice(0, NAMED_CANDIDATES).map((row) => row.name).join(
+        ", "
+      )}. Either the page never reaches them, or the wrong event was named \u2014 check against --candidates before reporting a conversion rate.`
+    );
+  }
+  const uncounted = candidates.filter((row) => !row.isCounted);
+  const busiest = uncounted[0];
+  if (busiest && busiest.sessions > 0) {
+    const counted = candidates.filter((row) => row.isCounted);
+    const busiestCounted = counted.reduce((max, row) => Math.max(max, row.sessions), 0);
+    if (busiest.sessions > busiestCounted) {
+      hints.push(
+        `\`${busiest.eventKey}\` happened in ${busiest.sessions} visits and is not counted \u2014 more than anything that is. Check it is not the real outcome.`
+      );
+    }
+  }
+  return hints;
+}
+function namingHints(definitions) {
+  const names = [...new Set(definitions.map((row) => row.name))];
+  if (names.length === 0) {
+    return [
+      `Nothing is named yet, so the first name sets the vocabulary for this company. Start from the standard set \u2014 ${STANDARD_CONVERSION_NAMES.map((entry) => entry.name).join(", ")} \u2014 and stay in the company's own language once one exists.`
+    ];
+  }
+  return [
+    `Names in use here: ${names.join(", ")}. Reuse one EXACTLY when another Form produces the same outcome \u2014 that is what makes them one number \u2014 and use \`--rename "<old>" --to "<existing>"\` to merge two that should always have been one.`
+  ];
+}
+function stagedHints(definitions) {
+  const staged = definitions.filter((row) => row.staged === true);
+  if (staged.length === 0) return [];
+  return [
+    `Staged on this chat, not counted yet: ${staged.map((row) => `"${row.name}"`).join(", ")}. The person sees ${staged.length === 1 ? "it" : "them"} under Sources in the chat's changes, on the event's own row, and ${staged.length === 1 ? "it counts" : "they count"} from when they publish the chat; discarding the chat drops ${staged.length === 1 ? "it" : "them"}. Publishing also rescores events Baker ALREADY RECORDED under the key \u2014 never anything that happened in HubSpot or elsewhere before the event existed, so an event this chat just made starts at zero. Tell them that, not that it is already counted.`,
+    'When you talk to the person, call each event by its name ("Appointment scheduled"), never its key (`page:Appointment scheduled`): the key is how Baker spells it internally, and the `page:` part means nothing to them.'
+  ];
+}
+
+// src/commands/analytics/conversionList.ts
+function mergeStoredWithCounts(stored, reported) {
+  const counts = new Map(reported.map((row) => [row.name, row]));
+  const groups = /* @__PURE__ */ new Map();
+  for (const row of stored) {
+    const group = groups.get(row.name) ?? [];
+    group.push(row);
+    groups.set(row.name, group);
+  }
+  return [...groups.entries()].map(([name, rows]) => {
+    const modes = new Set(rows.map((row) => row.countMode));
+    const counted = counts.get(name);
+    return {
+      name,
+      eventKeys: rows.map((row) => row.eventKey).sort(),
+      // A real state and usually an editing accident, which is why it is said
+      // out loud rather than resolved to one of them.
+      countMode: modes.size === 1 ? [...modes][0] : "mixed",
+      // Zero rather than absent: an outcome that is counted and has never
+      // fired is the most actionable row on this report, and dropping it
+      // would make it indistinguishable from one nobody has named.
+      conversions: counted?.conversions ?? 0,
+      convertingVisits: counted?.convertingVisits ?? 0,
+      unplaced: counted?.unplaced ?? 0,
+      lastSeen: counted?.lastSeen ?? null,
+      doors: counted?.doors ?? [],
+      ...rows.some((row) => row.staged === true) ? { staged: true } : {}
+    };
+  }).sort((a, b) => a.name.localeCompare(b.name));
+}
+
+// src/commands/analytics/render.ts
+var SPARKLINE_POINTS = 30;
+var DASHBOARD_ONLY_FIELDS = /* @__PURE__ */ new Set([
+  // The Convex row id. It exists so a dashboard can link to the row; an agent
+  // addresses a landing by `landingId`, which is the id in its `_definition.md`.
+  "landingRef"
+]);
+function isAbsent(value) {
+  if (value === "") return true;
+  if (Array.isArray(value)) return value.length === 0;
+  if (typeof value === "object" && value !== null) return Object.keys(value).length === 0;
+  return false;
+}
+function resample(series, points) {
+  if (series.length <= points || points < 1) return [...series];
+  const out = [];
+  for (let i = 0; i < points; i += 1) {
+    const from = Math.floor(i * series.length / points);
+    const to = Math.floor((i + 1) * series.length / points);
+    let sum = 0;
+    for (let j = from; j < to; j += 1) sum += series[j] ?? 0;
+    out.push(sum);
+  }
+  return out;
+}
+function pruneValue(value, full) {
+  if (Array.isArray(value)) return value.map((entry) => pruneValue(entry, full));
+  if (typeof value === "object" && value !== null) {
+    return pruneRow(value, full);
+  }
+  return value;
+}
+function pruneRow(row, full) {
+  const out = {};
+  for (const [key, value] of Object.entries(row)) {
+    if (DASHBOARD_ONLY_FIELDS.has(key)) continue;
+    if (key === "sparkline" && Array.isArray(value)) {
+      if (!full) continue;
+      out[key] = resample(value, SPARKLINE_POINTS);
+      continue;
+    }
+    if (isAbsent(value)) continue;
+    out[key] = pruneValue(value, full);
+  }
+  return out;
+}
+function pruneForAgent(data, full) {
+  return pruneRow(data, full);
+}
+function isTabular(rows) {
+  return rows.every(
+    (row) => typeof row === "object" && row !== null && !Array.isArray(row) && Object.values(row).every(
+      (value) => value === null || typeof value !== "object" || Array.isArray(value) && value.every((e) => typeof e !== "object")
+    )
+  );
+}
+function cell(value, key) {
+  if (value === null || value === void 0) return "";
+  if (Array.isArray(value)) return value.join(" ");
+  if (typeof value === "number" && !Number.isInteger(value)) {
+    if (key?.endsWith("Ms")) return String(Math.round(value));
+    return value.toFixed(4).replace(/0+$/, "").replace(/\.$/, "");
+  }
+  return String(value);
+}
+var IDENTITY_COLUMNS = [
+  "landingId",
+  "name",
+  "slug",
+  "path",
+  "flowSlug",
+  "stepId",
+  "value",
+  "key",
+  "bucket",
+  "tag",
+  "eventName",
+  "release",
+  "place",
+  "bot",
+  "source",
+  "medium",
+  "campaign",
+  "platform",
+  "sessionId",
+  "eventId"
+];
+function byIdentityFirst(a, b) {
+  const ia = IDENTITY_COLUMNS.indexOf(a);
+  const ib = IDENTITY_COLUMNS.indexOf(b);
+  if (ia !== -1 || ib !== -1)
+    return (ia === -1 ? Number.MAX_SAFE_INTEGER : ia) - (ib === -1 ? Number.MAX_SAFE_INTEGER : ib);
+  return 0;
+}
+var BLOCK_ORDER = ["window", "totals", "previous", "pageInfo"];
+function byBlockOrder(a, b) {
+  const rank = (key) => {
+    const at = BLOCK_ORDER.indexOf(key);
+    if (at !== -1) return at;
+    return key === "preset" ? BLOCK_ORDER.length + 1 : BLOCK_ORDER.length;
+  };
+  return rank(a) - rank(b);
+}
+function columnsOf(rows) {
+  const seen = [];
+  for (const row of rows) {
+    for (const key of Object.keys(row)) {
+      if (!seen.includes(key)) seen.push(key);
+    }
+  }
+  return seen.filter((key) => rows.some((row) => !isAbsent(row[key]) && row[key] !== null && row[key] !== void 0)).sort(byIdentityFirst);
+}
+function table(rows) {
+  const cols = columnsOf(rows);
+  if (cols.length === 0) return "";
+  const head = `| ${cols.join(" | ")} |`;
+  const rule = `| ${cols.map(() => "---").join(" | ")} |`;
+  const body = rows.map((row) => `| ${cols.map((col) => cell(row[col], col)).join(" | ")} |`);
+  return [head, rule, ...body].join("\n");
+}
+function isRowList(value) {
+  return Array.isArray(value) && value.length > 0 && value.every((entry) => typeof entry === "object" && entry !== null && !Array.isArray(entry));
+}
+function labelOf(row, index) {
+  for (const key of IDENTITY_COLUMNS) {
+    const value = row[key];
+    if (typeof value === "string" && value !== "") return value;
+  }
+  return `#${index + 1}`;
+}
+function nestedBlock(name, rows) {
+  const parents = rows.map(
+    (row) => Object.fromEntries(Object.entries(row).filter(([, value]) => !isRowList(value) && !isPlainRow(value)))
+  );
+  const parts = [`### ${name}`, table(parents)];
+  rows.forEach((row, index) => {
+    for (const [key, value] of Object.entries(row)) {
+      if (isRowList(value)) parts.push(`#### ${name}[${labelOf(row, index)}].${key}`, table(value));
+      else if (isPlainRow(value)) parts.push(`#### ${name}[${labelOf(row, index)}].${key}`, table([value]));
+    }
+  });
+  return parts.filter((part) => part !== "").join("\n");
+}
+function isPlainRow(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function block(name, value) {
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "";
+    if (isTabular(value)) return `### ${name}
+${table(value)}`;
+    if (isRowList(value)) return nestedBlock(name, value);
+    return `### ${name}
+${JSON.stringify(value)}`;
+  }
+  if (typeof value === "object" && value !== null) {
+    const entries = Object.entries(value);
+    if (entries.length === 0) return "";
+    if (entries.every(([, v]) => v === null || typeof v !== "object")) {
+      return `### ${name}
+${entries.map(([k, v]) => `- ${k}: ${v === null ? "null" : cell(v, k)}`).join("\n")}`;
+    }
+    return `### ${name}
+${JSON.stringify(value)}`;
+  }
+  return `### ${name}
+${cell(value)}`;
+}
+function renderMarkdown(envelope) {
+  const parts = [];
+  for (const warning of envelope.warnings ?? []) parts.push(`> **${warning.code}** \u2014 ${warning.message}`);
+  for (const hint of envelope.hints ?? []) parts.push(`> ${hint}`);
+  for (const [name, value] of Object.entries(envelope.data).sort(([a], [b]) => byBlockOrder(a, b))) {
+    const rendered = block(name, value);
+    if (rendered !== "") parts.push(rendered);
+  }
+  return `${parts.join("\n\n")}
+`;
+}
+function missingBreakdownHint(data, asked) {
+  if (asked.eventName === void 0) return [];
+  const breakdown = data.eventBreakdown;
+  if (Array.isArray(breakdown) && breakdown.length > 0) return [];
+  const known = Array.isArray(data.customEvents) ? data.customEvents.flatMap((row) => isPlainRow(row) && typeof row.eventName === "string" ? [row.eventName] : []) : [];
+  return [
+    `No rows came back for --event ${asked.eventName}${asked.property ? ` --property ${asked.property}` : ""}. That event or property does not exist on these pages${known.length > 0 ? `; the ones that do are: ${known.slice(0, 12).join(", ")}${known.length > 12 ? ", \u2026" : ""}` : ""}.`
+  ];
+}
+var ANALYTICS_OUTPUT_FORMATS = ["json", "md"];
+function isAnalyticsOutputFormat(value) {
+  return ANALYTICS_OUTPUT_FORMATS.includes(value);
+}
+function writeAnalyticsReport(envelope, format) {
+  if (format === "md") {
+    process.stdout.write(renderMarkdown(envelope));
+    return;
+  }
+  process.stdout.write(`${JSON.stringify(envelope)}
+`);
+}
+var ROWS_BEFORE_FORMAT_HINT = 25;
+function rowCount(data) {
+  let total = 0;
+  for (const value of Object.values(data)) {
+    if (Array.isArray(value)) total += value.length;
+  }
+  return total;
+}
+function formatHint(data, format) {
+  if (format === "md") return [];
+  const rows = rowCount(data);
+  if (rows < ROWS_BEFORE_FORMAT_HINT) return [];
+  return [
+    `This report is ${rows} rows. If you are going to read the numbers rather than pick one field out of them, --output md returns the same answer as tables, typically a third to a half smaller.`
+  ];
+}
+
+// src/commands/analytics/conversionsMarkdown.ts
+function doorsCell(doors) {
+  return doors.map((door) => `${door.door}=${door.events}/${door.sessions}`).join(" ");
+}
+function eventKeysCell(eventKeys) {
+  const formKeys = eventKeys.filter((key) => key.startsWith("form:")).length;
+  const others = eventKeys.filter((key) => !key.startsWith("form:"));
+  return [...others, ...formKeys > 0 ? [`${formKeys} Form ending(s)`] : []].join(" + ");
+}
+function trafficByForm(candidates) {
+  const byForm = /* @__PURE__ */ new Map();
+  for (const row of candidates) {
+    const form = byForm.get(row.flowSlug) ?? { "endings seen": 0, "endings counted": 0, events: 0, lastSeen: "" };
+    if (row.events > 0) form["endings seen"] += 1;
+    if (row.isCounted) form["endings counted"] += 1;
+    form.events += row.events;
+    if (row.lastSeen && row.lastSeen.slice(0, 10) > form.lastSeen) form.lastSeen = row.lastSeen.slice(0, 10);
+    byForm.set(row.flowSlug, form);
+  }
+  return byForm;
+}
+var NO_TRAFFIC = { "endings seen": 0, "endings counted": 0, events: 0, lastSeen: "" };
+var FORM_KEYS_HINT = "A Form's candidates are one row per Form: `baker analytics conversions --flow <slug>` lists that Form's event keys, and `--candidates --full --output json` lists every key with every field.";
+function renderConversionsMarkdown(envelope) {
+  const { definitions, flow, flows, candidates } = envelope.data;
+  const data = {
+    definitions: definitions.map(({ name, eventKeys, ...row }) => ({
+      name,
+      eventKeys: eventKeysCell(eventKeys),
+      ...row
+    }))
+  };
+  if (flow) {
+    data.flow = { slug: flow.slug, noConversionReason: flow.noConversionReason };
+    data.flowEndings = flow.endings;
+  }
+  const traffic = candidates ? trafficByForm(candidates.filter((row) => row.flowSlug !== "")) : /* @__PURE__ */ new Map();
+  if (flows) {
+    data.flows = flows.map((row) => ({
+      slug: row.slug,
+      counted: row.counted.map((entry) => `${entry.name} @ ${entry.step}`).join("; "),
+      noConversion: row.noConversion,
+      ...candidates ? traffic.get(row.slug) ?? NO_TRAFFIC : {}
+    }));
+  }
+  const hints = [...envelope.hints ?? []];
+  if (candidates) {
+    const listed = new Set(flows?.map((row) => row.slug));
+    const unlisted = [...traffic].filter(([slug]) => !listed.has(slug));
+    if (unlisted.length > 0) data.formCandidates = unlisted.map(([form, row]) => ({ form, ...row }));
+    data.candidates = candidates.filter((row) => row.flowSlug === "").map(({ doors, flowSlug: _flowSlug, nodeType: _nodeType, ...row }) => ({
+      ...row,
+      "doors (events/sessions)": doorsCell(doors)
+    }));
+    if (traffic.size > 0) hints.push(FORM_KEYS_HINT);
+  }
+  return renderMarkdown({ data, ...hints.length > 0 ? { hints } : {} });
+}
+function withFormatHint(envelope, format) {
+  const hints = [...envelope.hints ?? [], ...formatHint({ ...envelope.data }, format)];
+  return { ...envelope, ...hints.length > 0 ? { hints } : {} };
+}
+
+// src/commands/analytics/debugLink.ts
+function debugStartHints(started) {
+  if (started.link === null) {
+    return [
+      `Code ${started.code} records for two hours. Run it again with --url <the page to test> for a link to send, or add ?baker_debug=${started.code} to that page's address yourself.`
+    ];
+  }
+  return [
+    `Send the person this link: ${started.link} \u2014 they open it in the browser they normally use, accept the cookie banner, do exactly what did not work (open the widget, start the call, submit the form), then tell you they are done. Then run \`baker analytics debug ${started.code}\`. It records for two hours, nothing it records is counted anywhere, and emails and phone numbers are masked.`
+  ];
+}
+function inner(row) {
+  if (!row.data) return "";
+  try {
+    const parsed = JSON.parse(row.data);
+    const name = parsed.event ?? parsed.action ?? parsed.name;
+    return typeof name === "string" ? name : "";
+  } catch {
+    return "";
+  }
+}
+function isTagManagerNoise(label) {
+  return label.startsWith("gtm.") || label.startsWith("cookie_consent") || label === "consent" || label === "set";
+}
+var FOLLOWS_WITHIN_MS = 2e3;
+function debugReadHints(read) {
+  if (read.records.length === 0) {
+    return [
+      `Nothing recorded under ${read.code}: the Baker tag never loaded on a visit with this link. Either the link was not opened yet, the cookie banner was not accepted (on a site that loads Tag Manager only after consent, the tag never starts), or the site dropped ?baker_debug from the address before the tag ran. ${read.active ? "The link still records \u2014 ask them to try again." : "The link has expired; start a new one."}`
+    ];
+  }
+  const hints = [];
+  const boot = read.records.find((row) => row.kind === "pixel" && row.label === "boot");
+  if (boot?.data?.includes('"measuring":false')) {
+    hints.push(
+      "The tag did not measure this visit (its scope or the visitor's consent ruled it out), so its `track` calls sent nothing to Baker. The records below are still what the page heard."
+    );
+  }
+  const messages = read.records.filter((row) => row.kind === "message" && row.from && row.from !== "null");
+  const byOrigin = /* @__PURE__ */ new Map();
+  for (const row of messages) {
+    const said = byOrigin.get(row.from ?? "") ?? /* @__PURE__ */ new Map();
+    const what = inner(row) ? `${row.label} (${inner(row)})` : row.label;
+    said.set(what, (said.get(what) ?? 0) + 1);
+    byOrigin.set(row.from ?? "", said);
+  }
+  for (const [origin, said] of byOrigin) {
+    hints.push(
+      `${origin} sent: ${[...said].map(([what, count]) => count > 1 ? `${what} \xD7${count}` : what).join(", ")}. An event that is not on this list was never sent by that frame on this visit \u2014 the tag manager could not have passed it on.`
+    );
+  }
+  const unanswered = messages.filter(
+    (message) => !read.records.some(
+      (row) => row.kind === "dataLayer" && !isTagManagerNoise(row.label) && // Either side of it: a listener the site registered before the tag
+      // ran first, so its push is stamped before the message is.
+      Math.abs(row.t - message.t) <= FOLLOWS_WITHIN_MS
+    )
+  );
+  if (unanswered.length > 0) {
+    hints.push(
+      `${[...new Set(unanswered.map((row) => row.label))].join(", ")}: arrived as a message and no dataLayer event followed, so no tag listening for one could fire. Compare the message (--full) with the listener in the container (\`baker tag-manager read --entities tag --full\`) \u2014 a different \`type\` or event name is the usual cause.`
+    );
+  }
+  const tracked = read.records.filter((row) => row.kind === "track").map((row) => row.label);
+  if (tracked.length > 0) {
+    hints.push(
+      `The tag was asked to send: ${[...new Set(tracked)].join(", ")}. These reach Baker's feed within a minute or two (\`baker analytics feed --origin website --days 1\`).`
+    );
+  }
+  if (read.dropped > 0)
+    hints.push(`${read.dropped} records arrived after this link had kept its maximum and were not kept.`);
+  return hints;
+}
+function compactDebugRead(read, full) {
+  if (full) return read;
+  return { ...read, records: read.records.map(({ data: _data, ...row }) => row) };
+}
+
+// src/commands/analytics/feedRows.ts
+function isStreamRow(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function enrich(row) {
+  const out = { ...row };
+  const destination = typeof row.sideEffectType === "string" ? row.sideEffectType : "";
+  if (destination !== "") out.destination = destinationName(destination);
+  const keys = rowMatchKeys(row.userData);
+  if (keys.length > 0) out.matchedBy = keys.map((key) => key.field);
+  return out;
+}
+function shapeFeed(stream, everything) {
+  if (!Array.isArray(stream)) return { rows: [], heldBack: 0 };
+  const rows = stream.filter(isStreamRow);
+  const kept = everything ? rows : rows.filter((row) => !isBookkeepingRow({ eventType: row.eventType ?? "", triggerId: row.triggerId ?? "" }));
+  return { rows: kept.map(enrich), heldBack: rows.length - kept.length };
+}
+function feedHints(shape) {
+  const hints = [];
+  if (shape.heldBack > 0) {
+    hints.push(
+      `${shape.heldBack} ${shape.heldBack === 1 ? "row is" : "rows are"} not listed: rows recorded to work the reports out \u2014 identifications, step views, session starts, a destination's answer already folded onto its dispatch \u2014 and embedded forms and calendars announcing that they drew. Add --everything to see them.`
+    );
+  }
+  const upload = shape.rows.find((row) => row.sideEffectType !== void 0 && row.eventId !== void 0);
+  if (upload !== void 0) {
+    hints.push(
+      `A delivery row carries the event it was made for in \`eventId\`. \`baker analytics feed --uid ${String(upload.eventId)}\` returns that event and every upload made for it, each with the platform's verdict.`
+    );
+  }
+  return hints;
+}
+function hiddenMachinesHints(hidden) {
+  if (hidden === void 0 || hidden.events === 0) return [];
+  const headless = hidden.reasons.some((share) => share.reason === "ua");
+  const why = headless ? "a headless browser, which is what agent-browser is, so a check you ran on the site lands here" : "a datacenter or crawler network, or headers no real browser sends";
+  return [
+    `${hidden.events} events in this window came from machines and are not listed \u2014 stored, but left out of the feed and every report (${why}). They arrived; this is not lost data. \`baker analytics feed --bots\` lists them, each with its \`botReason\`. Never present them to the client as visits.`
+  ];
+}
+function peopleSearchHints(search, rows) {
+  const found = new Set(rows.flatMap((row) => Array.isArray(row.personTerms) ? row.personTerms : []));
+  return search.filter((term) => !found.has(term.term)).map(
+    (term) => term.problem !== "" ? `${term.input}: ${term.problem}` : `${term.input}: nothing in this window on this page. \`baker analytics lookup --person '${term.input}'\` reads everything Baker ever saw of them.`
+  );
+}
+
+// src/commands/analytics/flowConversionKeys.ts
+function formKeyRefusal(eventKey, tree, slug) {
+  const parsed = parseEventKey(eventKey);
+  if (parsed?.family !== "form" || parsed.flowSlug !== slug) return null;
+  const node = flowNodes(tree).find((candidate) => candidate.id === parsed.nodeId);
+  if (!node) {
+    return {
+      message: `"${slug}" has no step with id "${parsed.nodeId}", so this key would be stored and count zero forever.`,
+      fix: `Steps in this Form: ${flowNodes(tree).map((n) => `${String(n.id)} (${String(n.name ?? "unnamed")})`).join(", ")}. \`baker analytics conversions --flow ${slug}\` prints each one already spelled as an event key.`
+    };
+  }
+  const triggers = flowNodeTriggers(node.nodeData);
+  if (!triggers.known || triggers.available.includes(parsed.triggerId)) return null;
+  return {
+    message: `Step "${String(node.name ?? node.id)}" never raises \`${parsed.triggerId}\`, so counting it would score zero however many people reach that step.`,
+    fix: triggers.available.length > 0 ? `It raises: ${triggers.available.join(", ")}.` : triggers.why ?? "That step raises nothing a conversion could be counted on."
+  };
+}
+function joinFlowConversions(candidates, definitions) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const definition of definitions) {
+    for (const key of definition.eventKeys) byKey.set(key, definition.name);
+  }
+  return candidates.map((candidate) => ({ ...candidate, countedAs: byKey.get(candidate.eventKey) ?? null }));
+}
+function flowConversionHints(slug, rows, noConversionReason) {
+  const counted = rows.filter((row) => row.countedAs !== null);
+  if (counted.length > 0) {
+    return [
+      `Baker counts ${counted.length} of this Form's endings: ${counted.map((row) => `${row.countedAs} (${row.nodeName})`).join(
+        ", "
+      )}. Every other ending here scores nothing \u2014 count another with \`--event <key> --name <outcome>\`, reusing the SAME name to make two Forms one number.`
+    ];
+  }
+  if (noConversionReason) {
+    return [
+      `Nothing here is counted, and that is on purpose: this Form declares no outcome \u2014 "${noConversionReason}". Leave it alone unless that has stopped being true.`
+    ];
+  }
+  return [
+    `Nothing on "${slug}" is counted, so it converts nobody on every report however many people finish it. Which ending is its outcome is your call, never Baker's: read the endings above by the step each happens on (\`nodeName\`), and when the step names do not make it obvious \u2014 a Form that branches into a rejection and a confirmation \u2014 ask the person which one means a real result. Then \`baker analytics conversions --event "<key>" --name "<what a person calls it>"\`. If this Form is already on a funnel step, count the key that step uses, so the two numbers agree.`,
+    `If this Form has no outcome of its own \u2014 it hands the visitor to a shop, a portal or a funnel that converts them there \u2014 say so instead, with \`noConversion: { "reason": "\u2026" }\` on its first step.`
+  ];
+}
+function flowCoverage(forms, definitions) {
+  return forms.map(({ slug, tree }) => {
+    const rows = joinFlowConversions(flowEventKeys(tree, slug), definitions);
+    const declared = tree?.noConversion?.reason;
+    const seen = /* @__PURE__ */ new Set();
+    return {
+      slug,
+      counted: rows.filter((row) => row.countedAs !== null).filter((row) => {
+        const key = `${row.countedAs} ${row.nodeName}`;
+        if (seen.has(key)) return false;
+        seen.add(key);
+        return true;
+      }).map((row) => ({ name: String(row.countedAs), step: row.nodeName })),
+      noConversion: typeof declared === "string" && declared.trim() !== "" ? declared.trim() : null
+    };
+  });
+}
+function flowCoverageHints(coverage) {
+  const unset = coverage.filter((row) => row.counted.length === 0 && row.noConversion === null);
+  if (unset.length === 0) return [];
+  return [
+    `${unset.length} of ${coverage.length} Form(s) here count nothing, so every report shows them converting nobody: ${unset.map((row) => row.slug).join(
+      ", "
+    )}. Read each one's endings with \`baker analytics conversions --flow <slug>\` and name the outcome, or declare on its first step why it has none.`
+  ];
+}
+
+// src/commands/analytics/hints.ts
+var SEVERE_STEP_DROP = 0.6;
+var MIN_SESSIONS_FOR_RATES = 100;
+var SHALLOW_ENGAGEMENT_MS = 1e4;
+function percent(value) {
+  return `${Math.round(value * 100)}%`;
+}
+var MIN_SESSIONS_FOR_TAGGING_CLAIM = 20;
+function shapeHints(data) {
+  const hints = [];
+  const pageInfo = data.pageInfo;
+  if (pageInfo?.hasMore) {
+    hints.push(
+      `This is page ${pageInfo.page} of ${pageInfo.block} (${pageInfo.returned} rows) and there are more \u2014 pass --page ${pageInfo.page + 1} for the next one. Do not report a total from one page.`
+    );
+  }
+  for (const entry of data.adPlatformTraffic ?? []) {
+    if (entry.sessions >= MIN_SESSIONS_FOR_TAGGING_CLAIM && entry.taggedSessions === 0) {
+      hints.push(
+        `${entry.sessions} visits arrived from ${entry.platform} carrying no campaign parameters at all \u2014 the ad URLs are untagged, so there is nothing for a mapping to read. That is a change in their ad account, not in Baker.`
+      );
+    }
+  }
+  const unread = (data.adParams ?? []).filter((row) => row.role === void 0 && row.sessions > 0);
+  if (unread.length > 0) {
+    const named = unread.slice(0, 8).map((row) => `${row.name} (${row.sessions} visits)`).join(", ");
+    hints.push(
+      `Nothing reads these parameters yet: ${named}${unread.length > 8 ? ", \u2026" : ""}. Their values are not being stored \u2014 only the fact that the name appeared \u2014 so any breakdown over them is empty rather than wrong. Name each one with \`baker analytics map --platform <platform> --set <name>=<role>\`; mapping also fixes the history for a parameter Baker was already capturing.`
+    );
+  }
+  const unplaceable = data.adParamsUnattributed ?? [];
+  if (unplaceable.length > 0) {
+    hints.push(
+      `Some parameters arrive on visits with no click id and no recognised source, so no platform can be named for them: ${unplaceable.map((row) => row.name).join(", ")}. If you know where they come from, map them with --platform on that platform.`
+    );
+  }
+  return hints;
+}
+function adHierarchyHints(data, platform) {
+  if (platform === void 0) return [];
+  const traffic = (data.adPlatformTraffic ?? []).find((entry) => entry.platform === platform);
+  if (traffic === void 0 || traffic.sessions < MIN_SESSIONS_FOR_TAGGING_CLAIM) return [];
+  if (traffic.taggedSessions === 0) return [];
+  const carried = new Set(
+    (data.adParams ?? []).filter((row) => row.role !== void 0 && row.awaitingTraffic !== true).map((row) => row.role)
+  );
+  const missing = essentialAdDimensions(platform).filter((entry) => !carried.has(entry.role));
+  if (missing.length === 0) return [];
+  const suffix = missing.map((entry) => `${entry.names[0] ?? entry.role}=${entry.macro}`).join("&");
+  return [
+    `${platform} traffic carries no ${missing.map((entry) => AD_PARAM_ROLE_SPECS[entry.role].label.toLowerCase()).join(", ")}, so no report can say which ad sent a visit \u2014 only which platform. Add \`${suffix}\` to that account's tracking template. This cannot be backfilled: a parameter's values are only stored once it starts arriving.`
+  ];
+}
+function sessionlessHint(data, origin) {
+  if (data.totals.pageViews === 0 || data.totals.sessions > 0) return [];
+  if (origin === "server") {
+    return [
+      "No sessions, because this report is scoped to events a client's own server posted and those carry no visit \u2014 a session would be an invented one. Every per-visitor rate here is null for the same reason; read the counts, and drop --origin for anything about behaviour."
+    ];
+  }
+  return [
+    "Pages were served but no sessions were counted \u2014 visitors are declining analytics consent, so traffic is measurable and per-visitor behaviour is not. Say so rather than reporting zero visitors."
+  ];
+}
+function measureScopeHint(data) {
+  const scope = data.measureScope?.scope;
+  if (scope === "all") {
+    return [
+      "This company's website tag measures EVERY visitor of their own website, but this report does not: visits, views and conversions here count only people who visited a Baker landing, and a sale on their site counts only when its person viewed a landing in the 90 days before it. Everything else the tag sees is in `baker analytics feed`, not in these numbers."
+    ];
+  }
+  if (scope === "outcomes") {
+    return [
+      "This company's website tag reports outcomes only, so no browsing on their own site is measured. Visits and views cover Baker pages alone, and a drop-off between a Baker page and a sale is invisible rather than absent."
+    ];
+  }
+  return [];
+}
+function buildAnalyticsHints(data, platform, origin) {
+  const hints = [];
+  hints.push(...measureScopeHint(data));
+  for (const funnel of data.funnels ?? []) {
+    const worst = funnel.worstStep;
+    if (worst && worst.dropRate !== null && worst.dropRate >= SEVERE_STEP_DROP) {
+      hints.push(
+        `Form "${funnel.flowSlug}" loses ${percent(worst.dropRate)} of people at step "${worst.stepId}" \u2014 open the flow-builder skill and look at what that step asks for.`
+      );
+    }
+  }
+  if (data.totals.sessions > 0 && data.totals.sessions < MIN_SESSIONS_FOR_RATES) {
+    hints.push(
+      "Too few sessions to read rates as reliable \u2014 report the absolute numbers and say the period is small, rather than quoting a conversion rate."
+    );
+  }
+  if (data.totals.avgEngagementMs !== null && data.totals.avgEngagementMs < SHALLOW_ENGAGEMENT_MS) {
+    hints.push(
+      "Visitors leave in under ten seconds on average \u2014 that is usually a mismatch between the ad and the page, not a form problem. Check the top sources against the page's headline."
+    );
+  }
+  hints.push(...sessionlessHint(data, origin));
+  hints.push(...shapeHints(data));
+  hints.push(...adHierarchyHints(data, platform));
+  if ((data.topCampaigns ?? []).length === 0 && (data.topSources ?? []).length > 0) {
+    hints.push(
+      "No campaign tagging on any traffic \u2014 ad clicks cannot be attributed to a campaign until the destination URLs carry utm parameters."
+    );
+  }
+  hints.push(...campaignOriginHints(data.topCampaigns));
+  return hints;
+}
+function campaignOriginHints(rows) {
+  const campaigns = rows ?? [];
+  const fromAds = campaigns.filter((row) => row.clickPlatform !== "");
+  if (fromAds.length === 0) return [];
+  const own = campaigns.length - fromAds.length;
+  return [
+    `${fromAds.length} of these campaigns arrived on an ad click (\`clickPlatform\` is set). \`baker analytics ads --role campaign_id\` MAY report the same campaigns under the platform's own ids \u2014 check before you quote both, or you will count one campaign twice. It may equally report nothing: \`ads\` only reads parameters the account tags separately, and \`utm_campaign\` is reserved and never reaches it, so an account whose only campaign signal is \`utm_campaign\` has its campaigns HERE and nowhere else. Never report "no campaigns" on the strength of an empty \`ads\`. ${own === 0 ? "Every row here came from an ad." : `The other ${own} carry no click id at all \u2014 a newsletter, a partner link, a tagged post \u2014 and only this report can show them.`}`
+  ];
+}
+
+// src/commands/analytics/presets.ts
+var ANALYTICS_PRESET_INFO = [
+  {
+    name: "overview",
+    description: "Everything at once: traffic, top pages with their conversion rates, where visitors came from, the worst step of every Form, and what the conversion number consists of \u2014 one row per outcome the company marked, by the name they gave it. Start here. A `conversions` row at zero means the outcome is marked and has never fired, which is usually a Form that never reaches it.",
+    playbook: "landing \u2014 diagnose a page that gets traffic but few leads"
+  },
+  {
+    name: "traffic",
+    description: "Where visitors come from \u2014 trend, sources, campaigns, countries, devices.",
+    playbook: "the platform playbook for the channel that dominates"
+  },
+  {
+    name: "funnel",
+    description: "Per-step drop-off for the company's Forms. Narrow to one with --flow.",
+    playbook: "flow-builder \u2014 fix the step that loses people"
+  },
+  {
+    name: "flow",
+    description: "One Form in depth: conversions counted at the node that produced them, step-to-step paths for a branching Form, the per-step table, every trigger raised, and each marked conversion by name. Read convertedSessions rather than submits \u2014 a Form whose scheduling widget sits mid-flow never emits a submit and reports zero on every other report. An empty `conversions` array means nobody has marked what this Form is for, so every conversion number for it is a zero rather than a measurement \u2014 Baker never guesses which ending is the point of a Form. Mark it in the Forms builder or with `conversions: [{ triggerId }]` on the node. Before proposing a mark, check that Form's `_data.json` for `noConversion` on its first step: that is its author saying the outcome happens somewhere Baker cannot see, so its zero is a finished answer rather than a gap. The declaration lives in the Form and never reaches this report, which is built entirely from the event store. `flowDestinations` is the other half and is evidence rather than a count: which Forms demonstrably handed something over in this window. Read it against the scaffold's `flow-no-destination` warning before acting on one \u2014 the stored picture of a Form is only rewritten when it is published, so a destination added since then shows there and not in the tree.",
+    playbook: "flow-builder \u2014 fix the branch or the step that loses people"
+  },
+  {
+    name: "page",
+    description: "One page in detail. Requires --path.",
+    playbook: "landing"
+  },
+  {
+    name: "triggers",
+    description: "What visitors did inside a Form and how much of it fired a side effect \u2014 link clicks that leave the site, scheduling widgets, embedded checkouts. The funnel shows the steps they walked; this shows what they did. A trigger with many fires and no side effects is behaviour nobody is measuring yet.",
+    playbook: "flow-builder \u2014 wire up what matters, or tags for what should be measured"
+  },
+  {
+    name: "paid",
+    description: "Paid campaigns, grouped by session rather than by page view, with the click ids that resolve to a real ad click \u2014 and, crucially, how many of those leads were actually DELIVERED to the CRM. A campaign whose forms all submit and whose integration is rejecting every one of them looks perfect on every other preset and reads as zero delivered here.",
+    playbook: "the platform playbook for the channel \u2014 or tags, when the gap is delivery rather than acquisition"
+  },
+  {
+    name: "delivery",
+    description: 'Where each submission actually went: every destination it reached, whether that destination accepted it, and the id the destination gave the record it created. Failures only by default; --full lists every submission. This is the preset for "I filled in the form, where is my lead?".',
+    playbook: "flow-builder \u2014 repair the destination that is refusing leads"
+  },
+  {
+    name: "submissions",
+    description: "Every attempt anybody made at a Form \u2014 one visitor, one Form, one visit \u2014 finished, abandoned halfway, or completed on a Form that sends nowhere. The honest companion to `delivery`, which is built from dispatches and so cannot show a Form with no destination at all. Read it when the question is what was collected rather than what was handed over. A list, so it pages.",
+    playbook: "flow-builder \u2014 the Form that collects and sends nothing is the one to wire up"
+  },
+  {
+    name: "geo",
+    description: "Where the people who convert actually are, at whatever resolution you ask for: country, region, city, postcode or US DMA. Country answers 'which market is this working in'; postcode answers the question a local advertiser is actually asking, and matches the unit Google and Meta sell that targeting in.",
+    playbook: "the platform playbook for the channel \u2014 narrow the targeting to where it already works"
+  },
+  {
+    name: "bots",
+    description: "Which machines fetch this site. Every other report here excludes them; this one reads them. Answers whether Google is still crawling a page after it was republished, whether Meta fetched a link preview before spend went behind the URL, and how much of the traffic is now AI answer engines.",
+    playbook: "landing \u2014 a page that stopped being crawled stops ranking, weeks before the traffic shows it"
+  },
+  {
+    name: "companies",
+    description: "Which companies are visiting, named by the visitor's own network \u2014 never a person \u2014 with visits, pages read and first/last seen. Recorded only for visitors who accepted marketing cookies, on a company that switched it on. --targets keeps the target accounts that came and lists the ones that did not.",
+    playbook: "abm-playbook \u2014 which target accounts the ads warmed enough to read the pages"
+  },
+  {
+    name: "landings",
+    description: "Every landing side by side \u2014 views, entrances, conversion rate and a sparkline each, under the name a person gave it. Answers 'which of my pages is working' without having to know the answer first; `page` then answers one of them in depth. --tag narrows it to a campaign.",
+    playbook: "landing \u2014 pick the page worth working on before working on one"
+  },
+  {
+    name: "tags",
+    description: "The same numbers rolled up by the tag a landing is filed under \u2014 the unit a campaign is actually run at. A client asks how the September push did, and September was six landings.",
+    playbook: "the platform playbook for the channel \u2014 judge the campaign, not the page"
+  },
+  {
+    name: "events",
+    description: "Events the pages define for themselves: a section seen, a video played, a button clicked. Lists each with the property keys it carries so it can be broken down, and takes --steps for an ORDERED funnel over them \u2014 where a session only counts at a step if it reached it after the one before, so 'saw pricing then clicked demo' is not the same number as the reverse.",
+    playbook: "landing \u2014 measure the part of the page the Form funnel cannot see"
+  },
+  {
+    name: "devices",
+    description: "Browser, OS, engine or viewport of real visitors, with the conversion rate of each. Narrow enough to reproduce a bug on: 'mobile converts worse' is not actionable, 'Safari 17 under 380px converts at a third of the rate' is.",
+    playbook: "landing \u2014 fix the client the page is broken on"
+  },
+  {
+    name: "releases",
+    description: "Traffic and conversions per published build, newest first. Answers whether a change to a page moved the numbers.",
+    playbook: "landing \u2014 compare a page before and after a change"
+  },
+  {
+    name: "conversions",
+    description: "What this company counts as a conversion, and what each one produced. The report every other conversion number is derived from, so read it FIRST whenever a conversion figure looks wrong or reads zero: an empty list means nothing is counted and every conversion number everywhere is zero, whatever visitors did. `baker analytics conversions --candidates` lists everything these pages actually produce \u2014 every Form step, every data-baker-* event, every outbound destination \u2014 and counting one applies immediately and rescores the whole history, with no publish. Anything can be counted, not just a Form.",
+    playbook: "run `baker analytics conversions` \u2014 this one is fixed with the command, not with a skill"
+  }
+];
+
+// ../api/src/accounts/companyName.ts
+var NOISE_WORDS = /* @__PURE__ */ new Set([
+  "inc",
+  "incorporated",
+  "llc",
+  "ltd",
+  "limited",
+  "plc",
+  "corp",
+  "corporation",
+  "co",
+  "company",
+  "gmbh",
+  "ag",
+  "kg",
+  "bv",
+  "nv",
+  "sa",
+  "sau",
+  "sl",
+  "slu",
+  "sas",
+  "sarl",
+  "srl",
+  "spa",
+  "oy",
+  "ab",
+  "as",
+  "aps",
+  "pty",
+  "lda",
+  "ltda",
+  "kk",
+  "group",
+  "grupo",
+  "holding",
+  "holdings",
+  "the"
+]);
+function companyNameKey(name) {
+  return name.normalize("NFD").replace(new RegExp("\\p{Diacritic}", "gu"), "").toLowerCase().replace(/\./g, "").split(/[^\p{L}\p{N}]+/u).filter((word) => word !== "" && !NOISE_WORDS.has(word)).join(" ");
+}
+
+// src/commands/analytics/visitorCompanies.ts
+var VISITOR_COMPANIES_FULL_ROWS = ANALYTICS_FULL_BREAKDOWN_LIMIT * 8;
+function targetKey(target) {
+  return companyNameKey(target.name ?? target.domain.split(".")[0] ?? "");
+}
+function visitorCompanyHints(companies) {
+  if (companies.length === 0) {
+    return [
+      "No visitor companies in this window. They are recorded only when an admin has turned on 'Show which companies visit your pages' (Settings \u2192 General), the company measures in full, and the visitor accepted marketing cookies \u2014 so an empty list does not mean no target account came. Tell the user which of those to check rather than reporting zero interest."
+    ];
+  }
+  const hints = [
+    "Each name is the visitor's network as registered, never a person, and there is no website: match accounts by name (`--targets` does it), and never present a row as an individual's visit."
+  ];
+  if (companies.some((company) => company.confidence === "low")) {
+    hints.push(
+      "Rows with confidence low are a business only because their network is not a known ISP, carrier, cloud or VPN. Check the name reads as a real company before it goes into a sales brief."
+    );
+  }
+  return hints;
+}
+function matchTargets(companies, targets) {
+  const visitorByKey = /* @__PURE__ */ new Map();
+  for (const company of companies) {
+    const key = companyNameKey(company.name);
+    if (key !== "" && !visitorByKey.has(key)) visitorByKey.set(key, company);
+  }
+  const matched = [];
+  const notVisited = [];
+  const byTier = /* @__PURE__ */ new Map();
+  for (const target of targets) {
+    const key = targetKey(target);
+    const visitor = key === "" ? void 0 : visitorByKey.get(key);
+    if (visitor) matched.push({ ...visitor, target: target.domain });
+    else notVisited.push(target);
+    if (target.tier !== void 0) {
+      const tier = byTier.get(target.tier) ?? { total: 0, visited: 0 };
+      tier.total += 1;
+      if (visitor) tier.visited += 1;
+      byTier.set(target.tier, tier);
+    }
+  }
+  const summary = { total: targets.length, visited: targets.length - notVisited.length, notVisited };
+  return {
+    companies: matched,
+    targets: byTier.size > 0 ? { ...summary, byTier: Object.fromEntries(byTier) } : summary
+  };
+}
+function refineCompaniesReport(data, companies, targets) {
+  if (!targets) {
+    data.visitorCompanies = data.visitorCompanies ?? [];
+    return visitorCompanyHints(companies);
+  }
+  const matched = matchTargets(companies, targets.targets);
+  data.visitorCompanies = matched.companies;
+  data.targets = matched.targets;
+  const skipped = targets.unreadable.length > 0 ? [`Skipped targets that are not a website: ${targets.unreadable.map((entry) => `"${entry}"`).join(", ")}.`] : [];
+  const cut = companies.length >= VISITOR_COMPANIES_FULL_ROWS ? [
+    `Only the ${VISITOR_COMPANIES_FULL_ROWS} companies with the most visits were matched, so a target in notVisited may have come with fewer visits. Narrow the window (--days 7) and run it again before telling anyone an account never visited.`
+  ] : [];
+  return [...visitorCompanyHints(matched.companies.length > 0 ? matched.companies : companies), ...skipped, ...cut];
+}
+
+// src/commands/analytics/websiteTagCheck.ts
+var BAKER_CALL = /baker\s*\.\s*(?:track|conversion)\s*\(\s*(["'])([^"'\n]{1,120})\1/g;
+function tagHtml(raw) {
+  if (typeof raw !== "object" || raw === null) return "";
+  const parameters = raw.parameter;
+  if (!Array.isArray(parameters)) return "";
+  const html = parameters.find(
+    (parameter) => typeof parameter === "object" && parameter !== null && parameter.key === "html" && typeof parameter.value === "string"
+  );
+  return html?.value ?? "";
+}
+function checkWebsiteEvents(tags, catalog) {
+  const expected = /* @__PURE__ */ new Map();
+  for (const tag of tags) {
+    for (const match of tagHtml(tag.raw).matchAll(BAKER_CALL)) {
+      const name = match[2];
+      if (name === void 0) continue;
+      const entry = expected.get(name) ?? { tags: [], paused: true };
+      entry.tags.push(tag.name);
+      entry.paused = entry.paused && tag.paused === true;
+      expected.set(name, entry);
+    }
+  }
+  const seen = new Map((catalog ?? []).map((row) => [row.eventKey, row]));
+  const events = [...expected].map(([name, { tags: sentBy, paused }]) => {
+    const arrived = seen.get(`page:${name}`);
+    const events2 = arrived?.events ?? 0;
+    const status = paused ? "paused" : catalog === null ? "not_checked" : events2 > 0 ? "arriving" : "never_seen";
+    return { name, tags: sentBy, paused, status, events: events2, lastSeen: arrived?.lastSeen ?? null };
+  });
+  return { events };
+}
+function websiteEventCheckHints(events, days) {
+  const hints = [];
+  const missing = events.filter((event) => event.status === "never_seen");
+  if (missing.length > 0) {
+    hints.push(
+      `${missing.map((event) => `\`${event.name}\``).join(", ")}: a tag sends ${missing.length === 1 ? "it" : "them"} and no real visit brought one in ${days} days. Tag Manager only fires the tag when something on the page pushes its trigger \u2014 find out whether the page ever does: \`baker analytics debug --start\` gives the person a link that records what their browser hears, and the agent-browser recipe "what a live site tells its tag manager" reads a widget's code for when it sends each event.`
+    );
+  }
+  const paused = events.filter((event) => event.status === "paused");
+  if (paused.length > 0) {
+    hints.push(
+      `${paused.map((event) => `\`${event.name}\``).join(", ")}: every tag sending ${paused.length === 1 ? "it is" : "them is"} paused in Tag Manager, so nothing is sent. That is a setting in the container, not a fault on the site.`
+    );
+  }
+  const doubled = events.filter((event) => event.tags.length > 1);
+  if (doubled.length > 0) {
+    hints.push(
+      `${doubled.map((event) => `\`${event.name}\` (${event.tags.join(", ")})`).join("; ")}: sent by more than one tag, so one moment can arrive twice. Give each call the same \`eventId\` or keep one tag.`
+    );
+  }
+  return hints;
+}
+
+// src/commands/analytics/websiteTagHints.ts
+function asTyped(origin) {
+  return origin.replace(/^https?:\/\//, "");
+}
+function suggestionHint(suggested) {
+  if (suggested.length === 0) return [];
+  const commands = suggested.map((origin) => `baker analytics sites --add ${asTyped(origin)}`).join("  \xB7  ");
+  return [
+    `Baker publishes landing pages on ${suggested.map(asTyped).join(", ")} for this company, and no declared website covers ${suggested.length === 1 ? "it" : "them"}. Declaring the domain covers every subdomain of it \u2014 the marketing site, the shop, the booking page, and the ones that do not exist yet: ${commands}`
+  ];
+}
+function websiteTagHints(response) {
+  const hints = [];
+  if (response.origins.length === 0) {
+    hints.push(
+      "NO WEBSITE DECLARED \u2014 this tag will be ignored everywhere it is installed, silently, with no failing request to find. Declare the site before installing anything: baker analytics sites --add <the client's domain>. It takes effect at once and needs no republish."
+    );
+  }
+  hints.push(...suggestionHint(response.suggestedOrigins));
+  if (response.firstParty) {
+    hints.push(
+      `This tag loads from ${response.host} \u2014 the client's own domain, not Baker's \u2014 so the script and every event it sends travel first-party, which a content blocker has no list entry for. The trade is a dependency: if that domain is ever removed from Baker, this tag 404s and measurement stops. Re-run this command after any domain change.`
+    );
+  }
+  if (response.measure === "all") {
+    hints.push(
+      "This tag measures the client's WHOLE WEBSITE \u2014 every visitor and every page view, not only the people your campaigns brought. Their reports will describe their business rather than their campaigns, and outcomes their site produces from organic, email and direct traffic will land in their conversion numbers. Only correct if somebody asked for that; otherwise re-run without --measure."
+    );
+  }
+  if (response.measure === "campaigns" && !response.campaignsCanMatch) {
+    hints.push(
+      "THIS TAG WILL MEASURE NOBODY \u2014 and will look installed. `campaigns` scope recognises a visitor by a first-party cookie, and a browser does not carry one between two different registrable domains. This company's landings are not on a subdomain of the site this tag goes on, so no visitor can ever match. Two fixes: put the landings on a subdomain of the client's own domain (a custom domain in Baker), or install with --measure outcomes, which measures no browsing and reports the outcomes the site tells Baker about."
+    );
+  } else if (response.measure === "campaigns") {
+    hints.push(
+      "This tag measures only visitors who have been on one of this company's Baker landing pages \u2014 their whole journey through the site, to the outcome. Anybody else is not measured at all. Use --measure all only if the client asked for their whole website measured."
+    );
+  }
+  hints.push(
+    'Reporting an outcome is not the same as counting it. After a `window.baker.track("name")` call is live, name it with: baker analytics conversions --event page:<name> --name "<what to call it>". That applies immediately and counts everything already collected.'
+  );
+  return hints;
+}
+function analyticsSitesHints(response) {
+  const hints = [];
+  if (response.origins.length === 0) {
+    hints.push(
+      "No website is declared, so this company's measurement tag is ignored wherever it is installed \u2014 silently, with no failing request to find. Add one with: baker analytics sites --add <the client's domain>"
+    );
+  }
+  hints.push(...suggestionHint(response.suggestedOrigins));
+  if (response.added.length > 0) {
+    hints.push(
+      `Live now. A tag already installed on ${response.added.map(asTyped).join(", ")} starts being accepted immediately \u2014 there is no new tag to paste and nothing to publish. Only events sent from here on are kept; the ones refused before this were never stored and cannot be recovered.`
+    );
+  }
+  if (response.removed.length > 0) {
+    hints.push(
+      `Measurement from ${response.removed.map(asTyped).join(", ")} will stop at once, with no error on that site \u2014 a tag still installed there goes quiet. Everything already collected from it is kept.`
+    );
+  }
+  hints.push(
+    "One entry covers everything under it: example.com answers for www., go. and shop.eu. It never widens upward, so declaring go.example.com leaves example.com uncovered \u2014 declare the domain, not the subdomain you are installing on today."
+  );
+  return hints;
+}
+
+// src/commands/analytics/index.ts
+var SHARED_ARGS = {
+  days: { type: "string", description: "Lookback window in days (default: 30)", required: false },
+  "start-date": { type: "string", description: "Explicit start date (YYYY-MM-DD)", required: false },
+  "end-date": { type: "string", description: "Explicit end date (YYYY-MM-DD, inclusive)", required: false },
+  full: {
+    type: "boolean",
+    description: "Return long breakdowns and the per-day trend instead of the top few",
+    required: false
+  },
+  timezone: {
+    type: "string",
+    description: "IANA zone the day boundaries are drawn in, e.g. Europe/Madrid (default: UTC). Pass the client's zone \u2014 in UTC, two hours of every Spanish evening land on the following day",
+    required: false
+  },
+  granularity: {
+    type: "string",
+    description: "hour | day (default) | week | month \u2014 how wide one point of the trend is",
+    required: false
+  },
+  compare: {
+    type: "boolean",
+    description: "Also return the preceding window of the same length, so every total has something to be read against",
+    required: false
+  },
+  landing: {
+    type: "string",
+    description: "Narrow the whole report to one landing, by the internalId in its _definition.md \u2014 get it from `baker analytics landings`. Works on every report here: sources, geography, paid campaigns, Form drop-off and delivery all answer for that page alone. Prefer it over --path, which stops matching the moment a page is moved or renamed",
+    required: false
+  },
+  role: {
+    type: "string",
+    description: 'Narrow the whole report to visits that arrived on one ad dimension: keyword, match_type, campaign_id, adgroup_id, ad_id, placement, network, audience, device, search_query and the rest \u2014 run `baker analytics ads` for the full list and what this company actually sends. Pair it with --value. It selects the VISITS that arrived on that value and keeps everything they then did, so `--role keyword --value "solar panels"` answers what those people read and whether they converted, not just where they landed',
+    required: false
+  },
+  value: {
+    type: "string",
+    description: "The value of --role to narrow to. Pass an empty string to get the visits that arrived carrying no such parameter, which is how you size the untagged half of an account",
+    required: false
+  },
+  page: {
+    type: "string",
+    description: "Which page of a list report to read, 1-based. `delivery` and `submissions` are the lists here; every other report is a breakdown, which is a top-N by construction and ignores this. The response carries pageInfo.hasMore \u2014 when it is true there ARE more rows, so never report a total from one page",
+    required: false
+  },
+  "page-size": {
+    type: "string",
+    description: "Rows per page, up to 200 (default 50 when --page is given). Without --page or --page-size a list comes back at its old size, so nothing that worked before changes",
+    required: false
+  },
+  platform: {
+    type: "string",
+    description: "Read the whole report in one ad platform's vocabulary, and from its traffic only: google, meta, microsoft, linkedin, tiktok, reddit, pinterest, snapchat, chatgpt. Two effects at once \u2014 --role resolves against the spellings that platform uses (`cid` is TikTok's ad and nobody else's campaign) and the report narrows to the visits that arrived from it. Start here when comparing platforms, because without it every dimension is the union across all of them and one parameter can land under two roles",
+    required: false
+  },
+  origin: {
+    type: "string",
+    description: "Read one door only: `pages` for a browser on a page Baker publishes, `website` for a browser on the client's OWN website (the measurement tag), `server` for what their server posted to POST /v1/events. Omit it for all three, which is the default and the honest superset. Reach for it when a number moved and nothing on the pages changed \u2014 a CRM replaying history and a tag on the client's own site both land in the same totals as a landing page visitor, and this is the only thing that separates them. Honoured by overview, traffic, events and conversions; every session-scoped report ignores it, because a server-sent event carries no visit to be counted in",
+    required: false
+  },
+  output: {
+    type: "string",
+    description: "json (default) | md. `md` renders each block as a table \u2014 one header instead of the keys repeated on every row \u2014 which is 20-50% smaller than the JSON on a typical report and more on a long breakdown. Reach for it whenever you are going to read the numbers rather than pick one field out of them. Both carry the same warnings and hints",
+    required: false
+  }
+};
+function handleError(err) {
+  writeJsonEnvelope({ ok: false, error: analyticsErrorEnvelope(err) });
+  process.exit(1);
+}
+function pageOf(args) {
+  const size = args["page-size"];
+  return {
+    ...args.page ? { page: Number(args.page) } : {},
+    ...size ? { pageSize: Number(size) } : {}
+  };
+}
+function isWholePositive(raw) {
+  return /^[1-9]\d*$/.test(String(raw));
+}
+function paginationError(args) {
+  if (args.page !== void 0 && !isWholePositive(args.page)) {
+    return `--page takes a page number of a list report (1, 2, \u2026), not "${String(args.page)}". To narrow a report to one page of the site, pass --landing <internalId> (from \`baker analytics landings\`), or read one path with \`baker analytics page --path /pricing\`.`;
+  }
+  const size = args["page-size"];
+  if (size !== void 0 && !isWholePositive(size)) {
+    return `--page-size takes a number of rows (1 to 200), not "${String(size)}".`;
+  }
+  return null;
+}
+function requestBody(args, options) {
+  const candidates = {
+    preset: options.preset,
+    days: args.days ? Number(args.days) : void 0,
+    startDate: args["start-date"],
+    endDate: args["end-date"],
+    full: args.full ? true : void 0,
+    compare: args.compare ? true : void 0,
+    timezone: args.timezone ? String(args.timezone) : void 0,
+    granularity: args.granularity ? String(args.granularity) : void 0,
+    path: options.path,
+    flowSlug: options.flowSlug,
+    grain: options.grain,
+    country: options.country,
+    // Read off the shared flag unless a preset resolved one itself. Every
+    // report takes it, so wiring it per-preset would be fifteen identical lines
+    // and, historically, four of them missing.
+    landingId: options.landingId ?? (args.landing ? String(args.landing) : void 0),
+    tag: options.tag,
+    eventName: options.eventName,
+    property: options.property,
+    where: options.where,
+    steps: options.steps && options.steps.length > 0 ? options.steps : void 0,
+    deviceGrain: options.deviceGrain,
+    adRole: options.adRole ?? (args.role ? String(args.role) : void 0),
+    // Deliberately not dropped when empty: with a role set, an empty value is a
+    // real question — "the visits that arrived carrying none of these" — and the
+    // filter below would otherwise strip it and silently widen the report to
+    // everything.
+    adValue: args.role !== void 0 && args.value !== void 0 ? String(args.value) : void 0,
+    adPlatform: args.platform ? String(args.platform) : void 0,
+    eventOrigin: args.origin ? String(args.origin) : void 0,
+    eventKey: options.eventKey,
+    sourceName: options.sourceName,
+    sends: options.sends,
+    // `feed --send` and `--uid` were parsed and then dropped here, so both
+    // answered with the whole unnarrowed feed as if they had worked.
+    sendId: options.sendId,
+    sentTo: options.sentTo,
+    eventUid: options.eventUid,
+    people: options.people,
+    machines: options.machines,
+    ...pageOf(args)
+  };
+  return Object.fromEntries(
+    Object.entries(candidates).filter(([key, value]) => value !== void 0 && (value !== "" || key === "adValue"))
+  );
+}
+var EVENT_ORIGINS = ANALYTICS_EVENT_DOORS;
+function feedReportHints(feed, data) {
+  if (feed === void 0) return [];
+  return [
+    ...feedHints(feed),
+    ...hiddenMachinesHints(data.hiddenMachines),
+    ...peopleSearchHints(data.peopleSearch ?? [], feed.rows)
+  ];
+}
+async function runPreset(args, options, refine) {
+  const origin = args.origin === void 0 ? "" : String(args.origin);
+  if (origin !== "" && !EVENT_ORIGINS.includes(origin)) {
+    writeJsonEnvelope({
+      ok: false,
+      error: {
+        code: "VALIDATION_ERROR",
+        message: `Unknown --origin "${origin}". Use one of: ${EVENT_ORIGINS.join(", ")}, or omit it for all three.`
+      }
+    });
+    process.exit(1);
+  }
+  const pagination = paginationError(args);
+  if (pagination) {
+    writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message: pagination } });
+    process.exit(1);
+  }
+  try {
+    const response = await apiPost("/api/analytics/query", requestBody(args, options));
+    const requestedPlatform = args.platform === void 0 ? "" : String(args.platform);
+    const adPlatformScope = isAdPlatform(requestedPlatform) ? requestedPlatform : void 0;
+    const format = outputFormatOrExit(args.output);
+    const data = pruneForAgent(response.data, args.full === true);
+    const feed = "stream" in data ? shapeFeed(data.stream, args.everything === true) : void 0;
+    if (feed !== void 0) data.stream = feed.rows;
+    const refinedHints = refine ? refine(data, response.data) : [];
+    const hints = [
+      ...feedReportHints(feed, response.data),
+      // The platform the ad blocks were scoped to, so the tagging hint can
+      // only speak about the inventory it was actually given. `adParams` is one
+      // platform's list; a hint drawn from it without knowing which platform
+      // would be a claim about Meta made from Google's URLs.
+      ...buildAnalyticsHints(response.data, adPlatformScope, origin === "" ? void 0 : origin),
+      ...missingBreakdownHint(response.data, {
+        eventName: options.eventName,
+        property: options.property
+      }),
+      ...refinedHints,
+      ...formatHint(data, format)
+    ];
+    writeAnalyticsReport(
+      {
+        ok: true,
+        data,
+        ...response.warnings && response.warnings.length > 0 ? { warnings: response.warnings } : {},
+        ...hints.length > 0 ? { hints } : {}
+      },
+      format
+    );
+  } catch (err) {
+    handleError(err);
+  }
+}
+function outputFormatOrExit(raw) {
+  const format = raw === void 0 ? "json" : String(raw);
+  if (!isAnalyticsOutputFormat(format)) {
+    writeJsonEnvelope({
+      ok: false,
+      error: {
+        code: "VALIDATION_ERROR",
+        message: `Unknown --output "${format}". Use one of: ${ANALYTICS_OUTPUT_FORMATS.join(", ")}.`
+      }
+    });
+    process.exit(1);
+  }
+  return format;
+}
+function presetCommand(options) {
+  registerSchema({
+    command: `analytics.${options.name}`,
+    description: options.description,
+    args: { ...SHARED_ARGS, ...options.extraArgs ?? {} }
+  });
+  return defineCommand({
+    meta: { name: options.name, description: options.description },
+    args: { ...SHARED_ARGS, ...options.extraArgs ?? {} },
+    run: async ({ args }) => {
+      const resolved = options.resolve ? options.resolve(args) : { preset: options.preset };
+      if ("error" in resolved) {
+        writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message: resolved.error } });
+        process.exit(1);
+      }
+      await runPreset(args, resolved);
+    }
+  });
+}
+var overviewCommand = presetCommand({
+  name: "overview",
+  preset: "overview",
+  description: "Start here: traffic, top pages and their conversion rates, where visitors came from, and the worst step of every Form \u2014 in one call."
+});
+var trafficCommand = presetCommand({
+  name: "traffic",
+  preset: "traffic",
+  description: "Where visitors come from \u2014 trend, sources, campaigns, countries and devices."
+});
+var funnelCommand = presetCommand({
+  name: "funnel",
+  preset: "funnel",
+  description: "Per-step drop-off for the company's Forms. Narrow to one with --flow.",
+  extraArgs: { flow: { type: "string", description: "Form slug (default: every Form)", required: false } },
+  resolve: (args) => ({ preset: "funnel", flowSlug: args.flow ? String(args.flow) : void 0 })
+});
+var flowCommand = presetCommand({
+  name: "flow",
+  preset: "flow",
+  description: "One Form in depth: how many people it converted, where they went between steps, the per-step table, and every trigger it raised. Every count is DISTINCT VISITS, so quote shares against `funnels[].visits` \u2014 the visits that opened the Form \u2014 and never against `starts`, which is only the visits that touched it. The gap between the two is people who read the Form and left, and on most Forms it is the largest loss there is. Read `flowSummary.convertedSessions`, not `submits` \u2014 a Form that books a call on a scheduling node in the MIDDLE of the flow never emits a submit, so it reports zero submits and every one of its real bookings as conversions. `flowPaths` is the flow as edges between steps, bracketed by __flow_start__, __flow_converted__ and __flow_exit__, which is how a branching Form is read at all: a per-step table cannot say that of the people who left step two, forty went to the booking branch and ninety went nowhere. `flowDestinations` is the other half and is evidence rather than a count: which Forms demonstrably handed something over in this window. Read it against the scaffold's `flow-no-destination` warning before acting on one \u2014 the stored picture of a Form is only rewritten when it is published, so a destination added since then shows there and not in the tree.",
+  extraArgs: { flow: { type: "string", description: "Form slug (default: every Form)", required: false } },
+  resolve: (args) => ({ preset: "flow", flowSlug: args.flow ? String(args.flow) : void 0 })
+});
+var pageCommand = presetCommand({
+  name: "page",
+  preset: "page",
+  description: "One page in detail \u2014 its traffic, entrances, engagement and conversion rate.",
+  extraArgs: { path: { type: "string", description: "Page path, e.g. /pricing (no trailing slash)", required: true } },
+  resolve: (args) => args.path ? { preset: "page", path: String(args.path) } : {
+    error: "Provide --path, e.g. --path /pricing. Run `baker analytics overview` to see which paths have traffic."
+  }
+});
+var triggersCommand = presetCommand({
+  name: "triggers",
+  preset: "triggers",
+  description: "What visitors actually do inside a Form \u2014 link clicks that send them off the site, scheduling widgets, embedded checkouts \u2014 and how much of it fires a side effect. Narrow to one Form with --flow.",
+  extraArgs: { flow: { type: "string", description: "Form slug (default: every Form)", required: false } },
+  resolve: (args) => ({ preset: "triggers", flowSlug: args.flow ? String(args.flow) : void 0 })
+});
+var releasesCommand = presetCommand({
+  name: "releases",
+  preset: "releases",
+  description: "Traffic and conversions per published build, newest first. Use it to tell whether a change to a page moved the numbers, instead of guessing from the date."
+});
+var paidCommand = presetCommand({
+  name: "paid",
+  preset: "paid",
+  description: "Paid campaigns, counted per visit rather than per page view, with the click ids that resolve to a real ad click \u2014 and how many of those leads were actually delivered. A campaign whose forms all submit while the CRM rejects every one of them reads as perfect everywhere else and as zero delivered here."
+});
+var deliveryCommand = presetCommand({
+  name: "delivery",
+  preset: "delivery",
+  description: "Where each submission went: every destination it reached, whether that destination accepted it, and the id it gave the record it created. Failures first; --full lists every submission. Start here when someone says a lead never arrived."
+});
+var submissionsCommand = presetCommand({
+  name: "submissions",
+  preset: "submissions",
+  description: "Every attempt anybody made at a Form \u2014 one visitor, one Form, one visit \u2014 whether they finished, gave up halfway, or completed a Form that sends nowhere. Read this rather than `delivery` when the question is what was collected: `delivery` starts from the dispatch, so a Form with no destination produces no row there at all. `stepsReached` against `stepsSubmitted` says how far they got; `finished` says whether the Form reached an ending; `destinations` is what it demonstrably reached, which beats the picture in its _data.json. A list, so it pages \u2014 read pageInfo.hasMore before quoting a total. Narrow to one Form with --flow.",
+  extraArgs: { flow: { type: "string", description: "Form slug (default: every Form)", required: false } },
+  resolve: (args) => ({ preset: "submissions", flowSlug: args.flow ? String(args.flow) : void 0 })
+});
+var geoCommand = presetCommand({
+  name: "geo",
+  preset: "geo",
+  description: "Where the people who convert actually are. Country by default; --grain city|postal_code|metro_code goes finer, and --country narrows first so postcodes do not collide across markets. Use this when the campaign is local \u2014 a radius around a branch is a set of postcodes, never a set of countries.",
+  extraArgs: {
+    grain: {
+      type: "string",
+      description: "country (default) | region | city | postal_code | metro_code",
+      required: false
+    },
+    country: { type: "string", description: "Two-letter code to look inside, e.g. ES", required: false }
+  },
+  resolve: (args) => ({
+    preset: "geo",
+    grain: args.grain ? String(args.grain) : void 0,
+    country: args.country ? String(args.country) : void 0
+  })
+});
+var botsCommand = presetCommand({
+  name: "bots",
+  preset: "bots",
+  description: "Which machines are fetching this site \u2014 search crawlers, AI answer engines, link-preview scrapers, SEO tools \u2014 and whether each one is genuine or only claims to be. Every other report excludes these; this is the one that reads them. Use it to check that a republished page is still being crawled, or that Meta fetched a link preview before spend goes behind the URL."
+});
+var COMPANIES_DESCRIPTION = "Which companies are visiting these pages \u2014 named by the visitor's own network, never a person \u2014 with visits, pages read and first/last seen. Only recorded when an admin turned on 'Show which companies visit your pages', the company measures in full, and the visitor accepted marketing cookies; home and mobile connections are never named. --targets <file> keeps the target accounts that came and lists the ones that did not \u2014 the website half of an ABM report.";
+var COMPANIES_ARGS = {
+  ...SHARED_ARGS,
+  targets: {
+    type: "string",
+    description: 'The target-account list `baker accounts --targets` takes: a .csv (a domain or website column; name and tier optional) or a .json file (["acme.com", \u2026] or [{"domain": "acme.com", "name": "Acme", "tier": 1}, \u2026]). Matched by company NAME, because a visitor company has no website \u2014 give each target its name; one without matches only when its name starts with the domain\'s first word. Build one with `node __tooling__/scripts/target-accounts.mjs --out targets.csv`',
+    required: false
+  }
+};
+registerSchema({ command: "analytics.companies", description: COMPANIES_DESCRIPTION, args: COMPANIES_ARGS });
+var companiesCommand = defineCommand({
+  meta: { name: "companies", description: COMPANIES_DESCRIPTION },
+  args: COMPANIES_ARGS,
+  run: async ({ args }) => {
+    let targets;
+    if (args.targets) {
+      try {
+        targets = readTargetsFile(String(args.targets), readFileSync(String(args.targets), "utf8"));
+      } catch (err) {
+        writeJsonEnvelope({
+          ok: false,
+          error: {
+            code: "VALIDATION_ERROR",
+            message: `Could not read --targets ${String(args.targets)}: ${err instanceof Error ? err.message : String(err)}`
+          }
+        });
+        process.exit(1);
+      }
+    }
+    const request = targets ? { ...args, full: true } : args;
+    await runPreset(
+      request,
+      { preset: "companies" },
+      (data, raw) => refineCompaniesReport(data, raw.visitorCompanies ?? [], targets)
+    );
+  }
+});
+var landingsCommand = presetCommand({
+  name: "landings",
+  preset: "landings",
+  description: "Every landing side by side \u2014 views, entrances, conversion rate and a sparkline each, under the name a person gave it rather than its id. This is the one that answers 'which of my pages is working' without having to know the answer first; `page` answers one page in depth once this has named it. Narrow to a campaign with --tag.",
+  extraArgs: {
+    tag: { type: "string", description: "Only landings filed under this tag", required: false }
+  },
+  resolve: (args) => ({ preset: "landings", tag: args.tag ? String(args.tag) : void 0 })
+});
+var tagsCommand = presetCommand({
+  name: "tags",
+  preset: "tags",
+  description: "The same numbers grouped by the tag a landing is filed under \u2014 the unit a campaign is actually run at. Nobody asks how /pricing-b did; they ask how the September push did, and September was six landings. Tags are declared in each landing's _definition.md."
+});
+var eventsCommand = presetCommand({
+  name: "events",
+  preset: "events",
+  description: "Events the pages define for themselves \u2014 a section scrolled into view, a video played, a button clicked. Lists each one with the property keys it carries, so you can then break it down: --event video --property milestone. Pass --steps a,b,c for an ORDERED funnel over them, where a session only counts at each step if it got there after the one before.",
+  extraArgs: {
+    event: { type: "string", description: "Break this one event down (needs --property too)", required: false },
+    property: { type: "string", description: "Which of that event's property keys to group by", required: false },
+    where: {
+      type: "string",
+      description: "Narrow to one property value before grouping, as key=value \u2014 e.g. --event vsl --property milestone --where autoplay=0 for the retention curve of the videos visitors chose to play, rather than the one a muted hero produces on its own",
+      required: false
+    },
+    steps: {
+      type: "string",
+      description: "Comma-separated event names, in order, for a funnel \u2014 e.g. hero_view,pricing_view,demo_click",
+      required: false
+    }
+  },
+  resolve: (args) => {
+    const steps = args.steps ? String(args.steps).split(",").map((step) => step.trim()).filter((step) => step !== "") : void 0;
+    if (args.property && !args.event) {
+      return {
+        error: "Breaking an event down by a property needs --event too, e.g. --event video --property milestone"
+      };
+    }
+    if (steps && steps.length < 2) {
+      return { error: "A funnel needs at least two steps, e.g. --steps hero_view,pricing_view" };
+    }
+    let where;
+    if (args.where) {
+      const raw = String(args.where);
+      const at = raw.indexOf("=");
+      if (at < 1) {
+        return { error: "--where takes key=value, e.g. --where autoplay=0" };
+      }
+      if (!args.property) {
+        return { error: "--where narrows a breakdown, so it needs --event and --property too" };
+      }
+      where = { property: raw.slice(0, at), value: raw.slice(at + 1) };
+    }
+    return {
+      preset: "events",
+      eventName: args.event ? String(args.event) : void 0,
+      property: args.property ? String(args.property) : void 0,
+      where,
+      steps
+    };
+  }
+});
+var FEED_OUTCOMES = {
+  counted: {},
+  sent: { sends: "any" },
+  refused: { sends: "failed" },
+  skipped: { sends: "skipped" },
+  test: { elsewhere: "baker analytics arrivals --mode test" },
+  "not-counted": { elsewhere: "baker analytics arrivals --outcome rejected" }
+};
+function feedRequest(args) {
+  const tooMany = peopleLimitError(args);
+  if (tooMany !== void 0) return { error: tooMany };
+  const raw = args.sends === void 0 ? void 0 : String(args.sends);
+  if (raw !== void 0 && !SEND_FILTERS.includes(raw)) {
+    return { error: `--sends is one of ${SEND_FILTERS.join(", ")}, not "${raw}".` };
+  }
+  const sends = raw;
+  const outcome = args.outcome === void 0 ? void 0 : String(args.outcome);
+  if (outcome !== void 0) {
+    const mapped = FEED_OUTCOMES[outcome];
+    if (mapped === void 0) {
+      return { error: `--outcome is one of: ${Object.keys(FEED_OUTCOMES).join(", ")}. Not "${outcome}".` };
+    }
+    if (mapped.elsewhere !== void 0) {
+      return {
+        error: `--outcome ${outcome} is not on the feed: those requests never became events. Run \`${mapped.elsewhere}\` instead.`
+      };
+    }
+    if (mapped.sends !== void 0 && sends === void 0) {
+      return { ...feedNarrowing(args), sends: mapped.sends };
+    }
+  }
+  return { ...feedNarrowing(args), ...sends === void 0 ? {} : { sends } };
+}
+function feedNarrowing(args) {
+  return {
+    preset: "stream",
+    ...args.source ? { sourceName: String(args.source) } : {},
+    ...args.kind ? { eventKey: String(args.kind) } : {},
+    ...args.send ? { sendId: String(args.send) } : {},
+    ...args["sent-to"] ? { sentTo: String(args["sent-to"]) } : {},
+    ...args.uid ? { eventUid: String(args.uid) } : {},
+    ...args.bots === true ? { machines: true } : {},
+    ...peopleArgs(args)
+  };
+}
+var feedCommand = presetCommand({
+  name: "feed",
+  preset: "stream",
+  description: 'Every event recorded in the window, newest first, exactly as it was stored \u2014 the Measure \u2192 Events tab as rows. The one report that does not reduce, for "did anything arrive from Zapier today" and "what did that HubSpot read actually carry". --source <name> keeps one source\'s events (names from `baker analytics sources`; every event from an address or a HubSpot read carries its source\'s name as `baker_source`); --kind <event key> keeps one kind (keys from `conversions`); --origin pages|website|server keeps one door (a page Baker publishes, the client\'s own website, or their systems); --sends any|failed keeps only the uploads a conversion\'s sends made to Meta, Google Ads and the rest \u2014 `failed` is the rows behind "6 failed" on `baker analytics sends`, each with the platform\'s own words in `error`. Paged with --page; test sends and refusals are on `arrivals`, because they never became an event.',
+  extraArgs: {
+    outcome: {
+      type: "string",
+      description: "counted | sent | refused | skipped | test | not-counted \u2014 the Measure \u2192 Events outcome menu, in its own words. `counted` is every stored event (the default); `sent` and `refused` are the uploads an ad platform took and turned away; `skipped` are a send's events never uploaded because they carried nothing the platform matches a person by (no Meta click or email, no gclid, no li_fat_id\u2026), each with what was missing in `error`; `test` and `not-counted` never became events and are answered by `baker analytics arrivals`, which this names if you ask for them",
+      required: false
+    },
+    sends: {
+      type: "string",
+      description: "any | failed | skipped \u2014 only what was SENT ON: every delivery a Form's actions made (a Meta or Google Ads pixel fired, a Conversions API call, a webhook, an email, a CRM contact) and every upload an event's send made (side_effect_type conversionSend:<platform>); `failed` keeps the ones the destination refused, with its reason in `error`; `skipped` the events a send never uploaded, with what they were missing in `error`. The same narrowing as --outcome sent | refused | skipped",
+      required: false
+    },
+    "sent-to": {
+      type: "string",
+      description: `One destination, by its type \u2014 meta, googleAds, linkedinInsightTag, httpWebhook, email, hubspot\u2026 \u2014 keeping both a Form's deliveries there and the uploads sends made to it. The answer to "what went to Meta"`,
+      required: false
+    },
+    send: {
+      type: "string",
+      description: "One send's uploads and nothing else, by its id from `baker analytics sends` (`s1`) \u2014 the rows behind that send's outcome, each with its verdict. Implies --sends any; add --sends failed for the refused ones only",
+      required: false
+    },
+    uid: {
+      type: "string",
+      description: 'One event by its `event_uid`, together with every upload a send made for it (the rows carrying it as `event_id`), each with the platform\'s verdict \u2014 the answer to "is this the event that triggered that upload"',
+      required: false
+    },
+    source: {
+      type: "string",
+      description: "One source, by its name from `baker analytics sources` \u2014 an address a tool posts to, or a HubSpot read. Omit it for every event, sourced or not",
+      required: false
+    },
+    kind: {
+      type: "string",
+      description: "One kind of event, by the key `baker analytics conversions` lists (page:Deal won, form:contact:\u2026)",
+      required: false
+    },
+    person: {
+      type: "string",
+      description: "One or more people and everything they did, by whatever identifies them \u2014 comma-separated: an email, a phone (+34\u2026), a HubSpot contact id, deal:<HubSpot deal id>, a gclid/fbclid, or the `anonId` off any row. Prefix to be exact (email:, phone:, hubspot:, deal:, gclid:, fbclid:, browser:). Emails and phones are hashed by Baker, never stored in the clear. Each is resolved to the whole person \u2014 across devices and every address, phone, CRM id, ad click and cookie ever seen beside it \u2014 so the deal their CRM posted is on the list beside the page view that named them. Every row says which of them it is in `personTerms` (positions in `peopleSearch`). Up to 50; `baker analytics lookup` answers the same list as one summary line each",
+      required: false
+    },
+    "people-file": {
+      type: "string",
+      description: "A file with one person per line, read like --person \u2014 a column pasted from a CRM export",
+      required: false
+    },
+    bots: {
+      type: "boolean",
+      description: "List ONLY the events taken for machine traffic \u2014 a headless browser (agent-browser is one: every check you run on a site from it lands here), a datacenter network \u2014 each with its `botReason`. Stored, but left out of the feed and every report. Reach for it to confirm a test visit you just made arrived; never quote these rows to the client as visitors",
+      required: false
+    },
+    everything: {
+      type: "boolean",
+      description: "Include the rows held back by default: the ones recorded so the reports can be worked out (identifications, step views, session starts, a destination's answer already folded onto its dispatch) and embedded forms and calendars announcing that they drew. Reach for it when debugging the collector rather than an integration \u2014 an embed that draws and never fires again is only visible here",
+      required: false
+    }
+  },
+  resolve: (args) => feedRequest(args)
+});
+var devicesCommand = presetCommand({
+  name: "devices",
+  preset: "devices",
+  description: "What visitors are actually using, narrow enough to reproduce a bug on: browser and version, OS and version, rendering engine, or viewport width. `traffic` says mobile converts worse; this says it is Safari 17 on viewports under 380px, which is a browser you can open and a width you can resize to.",
+  extraArgs: {
+    grain: {
+      type: "string",
+      description: "browser (default) | os | engine | device | viewport",
+      required: false
+    }
+  },
+  resolve: (args) => ({
+    preset: "devices",
+    deviceGrain: args.grain ? String(args.grain) : void 0
+  })
+});
+var presetsCommand = defineCommand({
+  meta: { name: "presets", description: "List the available reports and what each answers." },
+  run: () => {
+    writeJsonEnvelope({ ok: true, data: ANALYTICS_PRESET_INFO });
+  }
+});
+var adsCommand = presetCommand({
+  name: "ads",
+  preset: "ads",
+  description: "What the ad platforms told us about each click, and what those people then did. `--role keyword` breaks the window down by keyword with conversions AND bounced visits beside each one \u2014 the ad platform can tell you a keyword got clicks, only this can tell you the people it brought left immediately. Three things come back either way. `adPlatformTraffic` is visits, conversions and TAGGED visits per platform \u2014 read it first, because a platform with visits and zero tagged visits has untagged ad URLs and no mapping will ever help it. `adParams` is the parameters arriving on the traffic of the platform in --platform (Google when none is given), never a shared list: a visit comes from one platform, so `gclid` traffic is not also Meta traffic. A parameter with no `role` is one nobody has told us the meaning of, and until somebody does its values are not stored at all \u2014 only the fact that the name appeared. `adParamsUnattributed` is the parameters on visits with no click id and no recognisable source, which belong to no platform and can only be placed by somebody who recognises them. Map any of them with `baker analytics map`.",
+  extraArgs: {}
+});
+var mapCommand = (() => {
+  const args = {
+    platform: {
+      type: "string",
+      description: "Which platform these parameters belong to: google, meta, microsoft, linkedin, tiktok, reddit, pinterest, snapchat, chatgpt. REQUIRED with --set or --remove, because there is no such thing as a parameter that means one thing everywhere \u2014 `cid` is TikTok's ad and everyone else's campaign, and Meta cannot send a keyword at all. Leave it off only to read the whole mapping back",
+      required: false
+    },
+    set: {
+      type: "string",
+      description: "Parameter=role pairs, comma separated: --set kw=keyword,mt=match_type. Roles come from `baker analytics ads` (every row lists the role in force). Two of them are the flexible ones: `other` captures a parameter and lets you filter by its own name without claiming it means anything, and `ignore` says it is not campaign information at all \u2014 Baker stops storing it and stops listing it as something to deal with",
+      required: false
+    },
+    remove: {
+      type: "string",
+      description: "Parameter names to stop reading, comma separated. Only affects this company's own entries, and only within --platform \u2014 removing an entry scoped to TikTok needs the same --platform tiktok that set it",
+      required: false
+    }
+  };
+  registerSchema({
+    command: "analytics.map",
+    description: "Stage how this company's campaign URLs spell each ad dimension, applied on publish",
+    args
+  });
+  return defineCommand({
+    meta: {
+      name: "map",
+      description: "Teach Baker how this company's campaign URLs spell each ad dimension on one platform \u2014 `--platform google --set kw=keyword`. Run it with no flags to see the whole mapping, including what this chat has already staged. STAGED, not applied: the answers are reviewed in the chat and take effect when it is published, so nothing you map here changes a report or what the edge stores until then; discarding the chat takes them all back. Mappings are always per platform, because the platforms do not describe the same world: `builtIn` in the response is what that platform is already understood to send, so you do not spend a turn mapping `keyword` to keyword. Each --set is checked against the client's OWN ad account \u2014 `evidence` in the response says whether their tracking template really fills that name with what you claimed. Read it: `contradicted` means the account disagrees, and mapping it your way would produce a report that is wrong and looks plausible. Renaming a parameter Baker already captured fixes the history too, because roles are applied when a report is read; naming one it never read only starts collecting it from the publish onward, since no value was stored. You do NOT need to have seen a parameter to map it: a name nobody has sent yet is a valid --set, which is how a tracking template gets configured before the campaign that uses it runs. To drop an answer, --remove takes it back to whatever Baker knows by itself, and --set <name>=ignore says it is not campaign information at all so it stops being listed."
+    },
+    args,
+    run: async ({ args: raw }) => {
+      try {
+        const body = {
+          platform: raw.platform === void 0 ? void 0 : String(raw.platform),
+          set: parsePairs(raw.set === void 0 ? void 0 : String(raw.set)),
+          remove: parseList(raw.remove === void 0 ? void 0 : String(raw.remove))
+        };
+        const response = await apiPost("/api/analytics/mapping", body);
+        writeJsonEnvelope(response);
+      } catch (err) {
+        handleError(err);
+      }
+    }
+  });
+})();
+var trackingCommand = (() => {
+  const args = {
+    platform: {
+      type: "string",
+      description: "One platform: google, meta, microsoft, linkedin, tiktok, reddit, pinterest, snapchat, chatgpt. Omit to check the ones worth checking \u2014 every platform sending visits, plus Google and Meta, whose accounts Baker can read directly",
+      required: false
+    },
+    days: { type: "string", description: "Lookback window for the traffic half (default: 30)", required: false }
+  };
+  registerSchema({
+    command: "analytics.tracking",
+    description: "Check whether a platform's ad URLs carry the campaign, ad group and ad a report needs",
+    args
+  });
+  return defineCommand({
+    meta: {
+      name: "tracking",
+      description: `Check whether this company's ad URLs carry the dimensions any budget decision needs \u2014 the campaign, the ad group, the ad, and the keyword where the platform has one.
+
+Read this before auditing an ad account and before answering any "which ad performed best" question. Each dimension comes back in one of four states, and they need different things:
+  covered  \u2014 arriving and understood, nothing to do
+  unmapped \u2014 the URLs carry it under a name Baker does not read yet. Free to fix, and it repairs the traffic already collected: run the \`mapCommand\` in the response
+  missing  \u2014 nothing carries it. \`fix\` says which LEVELS that platform accepts tagging at (widest first \u2014 prefer it), which Baker can stage and which the user must do by hand, and how each field treats what is already in it. \`suffix\` is only the MISSING pairs, so read the current value, add them, write the union. This one cannot be filled in later \u2014 a parameter's values are only stored once it starts arriving
+  unknown  \u2014 no visit arrived AND the account could not be read. Not a finding; do not report it as untagged
+
+Baker reads the client's own Google tracking templates and Meta URL parameters, so a platform that has not run yet still gets a real answer.
+
+Examples:
+  baker analytics tracking
+  baker analytics tracking --platform meta
+  baker analytics tracking --platform google --days 90`
+    },
+    args,
+    run: async ({ args: raw }) => {
+      try {
+        const platform = raw.platform === void 0 ? void 0 : String(raw.platform);
+        if (platform !== void 0 && !isAdPlatform(platform)) {
+          writeJsonEnvelope({
+            ok: false,
+            error: { code: "BAD_REQUEST", message: `Unknown platform "${platform}"` }
+          });
+          process.exit(1);
+        }
+        const days = raw.days === void 0 ? void 0 : Number(raw.days);
+        const response = await apiPost("/api/analytics/tracking", {
+          ...platform ? { platform } : {},
+          ...days !== void 0 && Number.isFinite(days) ? { days } : {}
+        });
+        writeJsonEnvelope(response);
+      } catch (err) {
+        handleError(err);
+      }
+    }
+  });
+})();
+function localFormKeyRefusal(eventKey) {
+  const parsed = parseEventKey(eventKey);
+  if (parsed?.family !== "form") return null;
+  if (!flowExists(parsed.flowSlug)) return null;
+  return formKeyRefusal(eventKey, readFlowTree(parsed.flowSlug), parsed.flowSlug);
+}
+function refuseUnmatchableKey(eventKey) {
+  const refusal = eventKey === void 0 ? null : localFormKeyRefusal(eventKey);
+  if (!refusal) return;
+  writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message: refusal.message, fix: refusal.fix } });
+  process.exit(1);
+}
+function readWorkspaceFlows() {
+  return listFlowSlugs().flatMap((slug) => {
+    try {
+      return [{ slug, tree: JSON.parse(readFileSync(flowDataPath(slug), "utf-8")) }];
+    } catch {
+      return [];
+    }
+  });
+}
+function readFlowConversions(slug, definitions) {
+  const tree = readFlowTree(slug);
+  const declared = tree.noConversion;
+  const reason = declared && typeof declared === "object" && typeof declared.reason === "string" ? String(declared.reason) : null;
+  return {
+    slug,
+    noConversionReason: reason,
+    endings: joinFlowConversions(flowEventKeys(tree, slug), definitions)
+  };
+}
+function conversionsEnvelope(args, definitions, candidates, leadingHints = []) {
+  const flow = args.flowSlug === void 0 ? null : readFlowConversions(args.flowSlug, definitions);
+  const forms = flow === null ? readWorkspaceFlows() : [];
+  const coverage = flowCoverage(forms, definitions);
+  const page = pageCandidates(definitions, candidates, args.candidates);
+  const hints = [
+    ...leadingHints,
+    ...flow ? flowConversionHints(flow.slug, flow.endings, flow.noConversionReason) : [],
+    ...flowCoverageHints(coverage),
+    ...stagedHints(definitions),
+    ...page.hints,
+    ...namingHints(definitions)
+  ];
+  return {
+    ok: true,
+    data: {
+      definitions,
+      ...flow ? { flow } : {},
+      ...coverage.length > 0 ? { flows: coverage } : {},
+      ...args.candidates ? { candidates: candidatesForFlow(page.candidates, args.flowSlug) } : {}
+    },
+    ...hints.length > 0 ? { hints } : {}
+  };
+}
+async function readConversionCounts(post, days, wrote) {
+  try {
+    const report = await post("/api/analytics/query", { preset: "conversions", days });
+    return { conversions: report.data.conversions ?? [], eventCatalog: report.data.eventCatalog ?? [], hints: [] };
+  } catch (err) {
+    if (!wrote) throw err;
+    const reason = err instanceof Error ? err.message : String(err);
+    return {
+      conversions: [],
+      eventCatalog: [],
+      hints: [`The change above was saved; its counts could not be read, so none are shown. ${reason}`]
+    };
+  }
+}
+var conversionsCommand = (() => {
+  const args = {
+    event: {
+      type: "string",
+      description: "The event to start counting, from the `candidates` or `--flow` list: form:<form>:<step>:<trigger>, submit:<form>, page:<name>, or exit:<host>. Requires --name. REPEATABLE \u2014 pass it several times with one --name to count all of them as that single outcome, which is the whole point of the name. Inside a chat it is STAGED: the chat lists it under Sources, on its event, and it counts from when the chat is published \u2014 then it scores the WHOLE history, not just from then on, so counting the right event also corrects last month's reports. An event a client's system sends (the API, HubSpot) counts here too: it is credited to the LAST LANDING its person viewed, up to 90 days before, so a deal won weeks later is that landing's conversion. A person who never saw a landing is not counted at all. Such an event is usually also a funnel step (`baker funnel`) and a send (`baker analytics sends`)",
+      required: false
+    },
+    name: {
+      type: "string",
+      description: "What to call this outcome on every report \u2014 'Booked a call', 'Quote requested'. Baker groups by EXACT name: reuse one this company already counts and the two become one row and one number, which is how a call booked on three Forms reads as one outcome. Read the existing names first (run with no flags) and reuse one before inventing another; a name that only differs by case, accent, punctuation or a plural is refused, because it would split the number in two",
+      required: false
+    },
+    rename: {
+      type: "string",
+      description: "An outcome's current name. With --to, renames every event counted under it. Renaming ONTO a name that already exists MERGES them into one row and one number \u2014 the way to fix a company whose Forms each invented their own word for the same outcome",
+      required: false
+    },
+    to: {
+      type: "string",
+      description: "The new name for --rename",
+      required: false
+    },
+    "remove-name": {
+      type: "string",
+      description: "Stop counting an outcome entirely, by name \u2014 removes every event counted under it. Use --remove for a single event key instead",
+      required: false
+    },
+    "count-mode": {
+      type: "string",
+      description: "once_per_visit (default) or every_time. Ask whether doing it twice in one visit is one outcome or two: a booking clicked twice is one booking, a guide downloaded twice is two downloads. Getting this wrong inflates the rate every budget is set by. Pass it with --event and no --name to change the mode of something already counted, keeping its name",
+      required: false
+    },
+    remove: {
+      type: "string",
+      description: "An event key to stop counting. REPEATABLE. Removes it from the history too, for the same reason adding it fills the history in",
+      required: false
+    },
+    candidates: {
+      type: "boolean",
+      description: "Also list every event these pages actually produced, ranked by volume, with whether it is already counted. This is where an event key comes from \u2014 do not invent one. Compact by default in JSON: each page or system event is one line (eventKey, events, sessions, countedAs when counted) and a Form's keys fold onto its `flows` row as `keys` and `events` (or a `formCandidates` row for a Form not in `flows`). Add --flow <slug> for that Form's keys only, and --full --output json for every field of every row",
+      required: false
+    },
+    full: {
+      type: "boolean",
+      description: "With --candidates: every field of every candidate (origin, nodeType, flowSlug, lastSeen, sources, doors) and every Form key unfolded. Large on a busy company \u2014 narrow it with --flow first",
+      required: false
+    },
+    flow: {
+      type: "string",
+      description: "A Form slug. Lists that Form's own endings already spelled as event keys, each with the name Baker counts it under or nothing \u2014 read off the Form's file, so it works on a Form built minutes ago that has never been visited, which is exactly when --candidates is empty. With --candidates, narrows the candidates to that Form's keys. Use it whenever you create or edit a Form: it is the only way to see that the Form counts nothing before it is published counting nothing",
+      required: false
+    },
+    days: {
+      type: "string",
+      description: "Lookback for the counts and for --candidates. Default 30",
+      required: false
+    },
+    output: SHARED_ARGS.output
+  };
+  registerSchema({
+    command: "analytics.conversions",
+    description: "Read or change what this company counts as a conversion on its pages. Also `--flow <slug>` for one Form's own endings as event keys, whether or not any of them has fired.",
+    args
+  });
+  return defineCommand({
+    meta: {
+      name: "conversions",
+      description: "What this company counts as a conversion \u2014 the numerator of every conversion rate on Measure. A page event (a Form ending, a data-baker-* event) and an event one of the client's systems sends (a HubSpot event made with `baker analytics sources --create-hubspot`, an order the server posts) both count; a system's event is credited to the last landing its person viewed. A HubSpot event is `page:<its name>` here \u2014 `--event 'page:Deal won' --name 'Deal won'`. Run with no flags first: an empty `definitions` list means every conversion number in every other report is zero \u2014 not because nobody converted, but because nothing is marked as converting, and Baker never guesses. Add `--candidates` to see everything these pages actually do (every Form step, every data-baker-* event, every outbound destination) with counts and whether it is already counted; that list is where an event key comes from, so never invent one. It is compact: a Form's keys fold onto its `flows` row, `--candidates --flow <slug>` lists one Form's keys, and `--full --output json` returns every field of every row. Then `--event <key> --name 'Booked a call'` to count it. Inside a chat a change is STAGED: the person sees it under Sources in the chat's changes, on the event's own row and it applies when they publish, retroactively \u2014 the whole history is rescored, so a company that has been running for a month gets a month of correct numbers. A read shows a proposal marked `staged`. Call an event by its name when you talk to the person, never by its key. Two events given the SAME --name are one row and one number. `--remove <key>` stops counting one. `--flow <slug>` answers the other direction \u2014 what one Form counts, with every ending it has already spelled as an event key, read from the Form itself so it works before a single visitor has seen it. Run it whenever you create or edit a Form: a Form nobody named an outcome for is published converting nobody, and no report says so."
+    },
+    args,
+    run: async ({ args: raw }) => {
+      try {
+        const format = outputFormatOrExit(raw.output);
+        const args2 = parseConversionsArgs(raw, process.argv);
+        for (const eventKey of args2.eventKeys) refuseUnmatchableKey(eventKey);
+        const before = await apiPost("/api/analytics/conversions", {});
+        const write = conversionsWrite(args2, before.data.definitions);
+        const answer = write ? await apiPost("/api/analytics/conversions", write) : before;
+        const stored = answer.data.definitions;
+        const report = await readConversionCounts(
+          (path, body) => apiPost(path, body),
+          args2.days,
+          write !== null
+        );
+        const envelope = conversionsEnvelope(
+          args2,
+          mergeStoredWithCounts(stored, report.conversions),
+          report.eventCatalog,
+          [...answer.hints ?? [], ...report.hints, ...fullFlagHints(args2, format)]
+        );
+        if (format === "md") process.stdout.write(renderConversionsMarkdown(envelope));
+        else writeJsonEnvelope(withFormatHint(compactConversionsEnvelope(envelope, args2), format));
+      } catch (err) {
+        if (err instanceof ConversionArgsError) {
+          if (err.fix !== void 0) {
+            writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message: err.message, fix: err.fix } });
+            process.exit(1);
+          }
+          handleError(new ApiError("VALIDATION_ERROR", err.message));
+          return;
+        }
+        handleError(err);
+      }
+    }
+  });
+})();
+function pageCandidates(definitions, catalogue, listing) {
+  return { candidates: [...catalogue], hints: conversionHints(definitions, catalogue, listing) };
+}
+function parsePairs(raw) {
+  if (raw === void 0) return void 0;
+  const out = {};
+  for (const pair of raw.split(",")) {
+    const [name, role] = pair.split("=");
+    if (name?.trim() && role?.trim()) out[name.trim()] = role.trim();
+  }
+  return out;
+}
+function parseList(raw) {
+  if (raw === void 0) return void 0;
+  const out = raw.split(",").map((entry) => entry.trim()).filter((entry) => entry !== "");
+  return out.length > 0 ? out : void 0;
+}
+var arrivalsCommand = (() => {
+  const args = {
+    mode: {
+      type: "string",
+      description: "live | test. Rehearsals (X-Baker-Mode: test) are accepted and write nothing, so they never reach a report \u2014 filter to them to confirm a rehearsal landed, or to live to see only what counted",
+      required: false
+    },
+    outcome: {
+      type: "string",
+      description: "accepted | rejected. Start with rejected: it is the half the sender's own logs threw away, and the reason to open this at all",
+      required: false
+    },
+    event: {
+      type: "string",
+      description: "Only this event_name, for a company posting several kinds",
+      required: false
+    },
+    limit: {
+      type: "string",
+      description: `How many to return, newest first (default 25, max ${INGEST_ARRIVALS_MAX})`,
+      required: false
+    },
+    full: {
+      type: "boolean",
+      description: "Also return the masked request body and the per-field identity previews. Reach for it only once the codes have not explained it \u2014 it is most of the bytes",
+      required: false
+    }
+  };
+  registerSchema({
+    command: "analytics.arrivals",
+    description: "What a client's own server posted to POST /v1/events in the last 48 hours, and why any of it was refused",
+    args
+  });
+  return defineCommand({
+    meta: {
+      name: "arrivals",
+      description: `Every request a client's own server posted to POST /v1/events in the last 48 hours \u2014 accepted, refused or rehearsed. The one place a server-side integration can be debugged.
+
+Read this FIRST whenever somebody says events are being sent and nothing shows up. Four different causes look identical from the sender's side and only this tells them apart:
+  the request never reached us          \u2014 nothing here at all: the key, the URL, or their own dispatch
+  it was refused                        \u2014 rejectCode says which rule, rejectMessage says what the field had to be
+  it was a rehearsal                    \u2014 mode: test is accepted, answered identically, and writes nothing on purpose
+  it landed                             \u2014 then the question is a report's, not the endpoint's
+
+Examples:
+  baker analytics arrivals                      \u2014 the last 25, newest first
+  baker analytics arrivals --outcome rejected   \u2014 only the refusals, which is usually the whole answer
+  baker analytics arrivals --mode test          \u2014 did the rehearsal they just ran actually arrive
+  baker analytics arrivals --event deal_won     \u2014 one kind only
+  baker analytics arrivals --full --limit 5     \u2014 the masked body, when the codes have not explained it`
+    },
+    args,
+    run: async ({ args: raw }) => {
+      try {
+        const limit = raw.limit === void 0 ? void 0 : Number(raw.limit);
+        const response = await apiPost("/api/analytics/arrivals", {
+          ...raw.mode ? { mode: String(raw.mode) } : {},
+          ...raw.outcome ? { outcome: String(raw.outcome) } : {},
+          ...raw.event ? { eventName: String(raw.event) } : {},
+          ...limit !== void 0 && Number.isFinite(limit) ? { limit } : {},
+          ...raw.full ? { full: true } : {}
+        });
+        writeJsonEnvelope(response);
+      } catch (err) {
+        handleError(err);
+      }
+    }
+  });
+})();
+function sendingEventsAddress(env) {
+  return eventIngestUrl(env.BAKER_PUBLIC_API_URL, env.BAKER_API_URL);
+}
+var sendingEventsCommand = (() => {
+  registerSchema({
+    command: "analytics.sending-events",
+    description: "The POST /v1/events contract as Markdown, for whoever is writing the integration",
+    args: {}
+  });
+  return defineCommand({
+    meta: {
+      name: "sending-events",
+      description: `The complete contract for sending events into Baker from a client's own systems \u2014 a CRM marking a deal won, a back office recording a refund \u2014 as Markdown you can hand straight to whoever writes the integration.
+
+Use it whenever a client wants an outcome that happens AFTER the lead leaves the page to show up in Baker. Every bound, every rejection code and every rule is read off the code that enforces it, so it cannot go stale; the six mistakes that all produce a 200 are called out before the reader starts rather than explained afterwards.
+
+It contains no key \u2014 the brief says to read one from an environment variable, and the key itself is minted in the dashboard under Settings \u2192 API keys. Never put one in a file or a message.
+
+Examples:
+  baker analytics sending-events              \u2014 the contract, as Markdown
+  baker analytics arrivals --outcome rejected \u2014 after they have wired it up, what is being refused`
+    },
+    args: {},
+    run: () => {
+      process.stdout.write(`${ingestBrief(sendingEventsAddress(getEnv()))}
+`);
+    }
+  });
+})();
+var websiteTagCommand = (() => {
+  registerSchema({
+    command: "analytics.website-tag",
+    description: "The measurement tag for a website Baker does not publish, with this company's key in it",
+    args: {
+      measure: {
+        type: "string",
+        required: false,
+        description: 'Whose activity to measure: "campaigns" (default), "outcomes" or "all"'
+      },
+      check: {
+        type: "boolean",
+        required: false,
+        description: "Every event the Tag Manager container sends Baker, and whether a real visit has brought it"
+      },
+      days: { type: "string", required: false, description: "With --check: how far back to look (default 30)" }
+    }
+  });
+  return defineCommand({
+    meta: {
+      name: "website-tag",
+      description: `The one script tag that measures a website Baker does not publish \u2014 the client's own site, their shop, their booking page \u2014 with this company's site key already in it, plus the whole install as Markdown.
+
+Reach for it whenever measurement has to reach a page Baker did not build. What it returns is real and complete: the tag, the websites the key is accepted from, and the rules for the hidden form fields, the identify call and the conversion call.
+
+Three things worth knowing before you install it:
+  the origins list                    \u2014 the key is IGNORED from any origin not on it, silently. An empty list means the tag will measure nothing.
+  Tag Manager is usually the way in   \u2014 a Custom HTML tag on All Pages. If the client has a container connected, you can stage that yourself (baker tag-manager).
+  in a container, use tagManagerTag   \u2014 the response carries two tags. \`tag\` is for a page somebody can edit; \`tagManagerTag\` is the one to stage, because a container rebuilds a Custom HTML tag's script element from its src alone and drops the key, so \`tag\` measures nothing there, published and silent. Check it on the page afterwards: window.baker in the browser console.
+  --measure decides the BILL          \u2014 the tag goes on every page whatever you do; this decides whose activity is measured. Leave it alone unless the client asked for their whole website.
+
+  --measure campaigns  (default)  people your Baker campaigns brought to the site. Their whole journey, through to the outcome. Nobody else is measured at all.
+  --measure outcomes              nobody's browsing. Only what the site reports with window.baker.track(...), and forms it wired to Baker.
+  --measure all                   every visitor and every page view of the whole website. Their reports then describe their business, not their campaigns, and outcomes from organic, email and direct land in their conversion numbers. A decision, never a default.
+
+Examples:
+  baker analytics website-tag                   \u2014 the tag, the origins and the install brief
+  baker analytics website-tag --measure all     \u2014 measure their whole website, because they asked for that
+  baker analytics website-tag --check           \u2014 every event Tag Manager sends Baker, and which never arrived
+  baker analytics events --origin website       \u2014 after it is live, what that website is reporting`
+    },
+    args: {
+      measure: {
+        type: "string",
+        description: 'Whose activity to measure: "campaigns" (default), "outcomes" or "all". Widening is a decision \u2014 see above.'
+      },
+      check: {
+        type: "boolean",
+        description: 'Read the connected Tag Manager container for every window.baker.track call its tags make, and say which events a real visit has brought in the window and which never arrived. Start here when "an event is missing": an event the container sends and nobody has seen is invisible on every other report'
+      },
+      days: { type: "string", description: "With --check: how many days back to look for each event (default 30)" }
+    },
+    run: async (ctx) => {
+      if (ctx.args.check === true) {
+        await runWebsiteEventCheck(Number(ctx.args.days ?? 30) || 30);
+        return;
+      }
+      try {
+        const measure = typeof ctx.args.measure === "string" ? ctx.args.measure : void 0;
+        const envelope = await apiPost(
+          "/api/analytics/website-tag",
+          measure ? { measure } : {}
+        );
+        writeJsonEnvelope({ ...envelope, hints: websiteTagHints(envelope.data) });
+      } catch (err) {
+        handleError(err);
+      }
+    }
+  });
+})();
+async function runWebsiteEventCheck(days) {
+  let tags;
+  try {
+    tags = (await apiPost(
+      "/api/tag-manager/read",
+      { entities: ["tag"], full: true },
+      { timeoutMs: TAG_MANAGER_TIMEOUT_MS }
+    )).tags;
+  } catch (err) {
+    writeJsonEnvelope({
+      ok: false,
+      error: {
+        code: "TAG_MANAGER_UNAVAILABLE",
+        message: `The check reads the website's Tag Manager container, and it could not: ${err instanceof Error ? err.message : String(err)}`,
+        fix: {
+          action: "continue_without",
+          explanation: "Without a connected container there is no list of what the site is wired to send. Read what did arrive with `baker analytics feed --origin website`, and ask the person to connect Tag Manager if the site uses it."
+        }
+      }
+    });
+    process.exit(1);
+  }
+  try {
+    let catalog;
+    let unread = "";
+    try {
+      const response = await apiPost("/api/analytics/query", {
+        preset: "conversions",
+        eventOrigin: "website",
+        days
+      });
+      catalog = response.data.eventCatalog ?? [];
+    } catch (err) {
+      catalog = null;
+      unread = err instanceof Error ? err.message : String(err);
+    }
+    const { events } = checkWebsiteEvents(tags, catalog);
+    const hints = websiteEventCheckHints(events, days);
+    if (catalog === null) {
+      hints.push(
+        `What arrived could not be read (${unread}), so this lists what the container sends, unchecked. \`baker analytics feed --origin website\` is the other half once reading works.`
+      );
+    }
+    if (events.length === 0) {
+      hints.push(
+        "No tag in the container calls window.baker.track, so the website sends Baker page views and nothing else. Outcomes come from tags you stage with `baker tag-manager`."
+      );
+    }
+    writeJsonEnvelope({ ok: true, data: { days, events }, hints });
+  } catch (err) {
+    handleError(err);
+  }
+}
+var DEBUG_ARGS = {
+  code: {
+    type: "positional",
+    required: false,
+    description: "The code `--start` returned: read what was recorded under it"
+  },
+  start: {
+    type: "boolean",
+    required: false,
+    description: "Mint a debug link for the person to open in their own browser"
+  },
+  url: {
+    type: "string",
+    required: false,
+    description: "With --start: the page the person should open (the link is built on it)"
+  },
+  full: { type: "boolean", required: false, description: "Every record's payload, masked, not just what it was" }
+};
+registerSchema({
+  command: "analytics.debug",
+  description: "A link that records what a person's own browser heard on their website, and the read of it",
+  args: DEBUG_ARGS
+});
+var debugCommand = defineCommand({
+  meta: {
+    name: "debug",
+    description: `Watch a real visit from the person's own browser: what the page heard \u2014 messages from its iframes, custom events, dataLayer pushes \u2014 and what Baker's website tag did with it.
+
+Start here when an event from the client's own website never arrives and a test from your browser cannot settle it: a voice, video or chat widget your headless browser cannot run, a login that is theirs, a cookie banner only they answer. Your own browser is flagged as a bot and in no report, so their visit is the test that counts.
+
+  baker analytics debug --start --url https://client.com/   \u2014 a link to send them; it records for two hours
+  baker analytics debug <code>                               \u2014 what their visit recorded, in order, with what to read first
+  baker analytics debug <code> --full                        \u2014 every record's payload (emails and phones masked)
+
+Nothing recorded is counted or shown in Baker; it is purged a day later.`
+  },
+  args: DEBUG_ARGS,
+  run: async ({ args }) => {
+    try {
+      if (args.start === true) {
+        const response2 = await apiPost("/api/analytics/debug", {
+          start: true,
+          ...typeof args.url === "string" && args.url !== "" ? { url: args.url } : {}
+        });
+        writeJsonEnvelope({ ok: true, data: response2.data, hints: debugStartHints(response2.data) });
+        return;
+      }
+      if (typeof args.code !== "string" || args.code === "") {
+        writeJsonEnvelope({
+          ok: false,
+          error: {
+            code: "VALIDATION_ERROR",
+            message: "Pass --start to mint a debug link, or the code it returned to read it."
+          }
+        });
+        process.exit(1);
+      }
+      const response = await apiPost("/api/analytics/debug", {
+        code: args.code,
+        full: true
+      });
+      writeJsonEnvelope({
+        ok: true,
+        data: compactDebugRead(response.data, args.full === true),
+        hints: debugReadHints(response.data)
+      });
+    } catch (err) {
+      handleError(err);
+    }
+  }
+});
+var sitesCommand = (() => {
+  registerSchema({
+    command: "analytics.sites",
+    description: "The websites this company's measurement tag is accepted from, and adding or removing one",
+    args: {
+      add: { type: "string", required: false, description: "Website address to accept measurement from" },
+      remove: { type: "string", required: false, description: "Website address to stop accepting measurement from" }
+    }
+  });
+  return defineCommand({
+    meta: {
+      name: "sites",
+      description: `Which websites this company's measurement tag is accepted from \u2014 and the command that changes it.
+
+The site key ships in the source of every page it is pasted on, so this list is the whole of what stops a stranger who read it appending forged conversions to these numbers. A tag on a website that is NOT on this list is ignored, silently, with no failing request anywhere. That is the single most common reason an install measures nothing.
+
+One entry covers the estate under it: example.com answers for www.example.com, go.example.com and shop.eu.example.com. It never widens upward \u2014 declaring go.example.com does NOT cover example.com \u2014 so declare the DOMAIN, not the subdomain you happen to be installing on today.
+
+Start here:
+  baker analytics sites                              \u2014 what is declared now, and what is worth adding
+  baker analytics sites --add example.com            \u2014 accept measurement from that site and everything under it
+  baker analytics sites --remove old-site.com
+
+Examples:
+  baker analytics website-tag                        \u2014 get the tag; if its origins are empty, come here first
+  baker analytics sites --add foodforjoe.es          \u2014 one entry covering www., go. and shop.`
+    },
+    args: {
+      add: {
+        type: "string",
+        description: "Website address to accept measurement from, e.g. example.com \u2014 covers every subdomain of it. Repeat for several"
+      },
+      remove: { type: "string", description: "Website address to stop accepting measurement from" }
+    },
+    run: async (ctx) => {
+      try {
+        const raw = ctx.rawArgs;
+        const body = {
+          add: repeatedValues(raw, "add", ctx.args.add),
+          remove: repeatedValues(raw, "remove", ctx.args.remove)
+        };
+        const envelope = await apiPost("/api/analytics/sites", body);
+        writeJsonEnvelope({ ...envelope, hints: analyticsSitesHints(envelope.data) });
+      } catch (err) {
+        handleError(err);
+      }
+    }
+  });
+})();
+var analyticsCommand = defineCommand({
+  meta: {
+    name: "analytics",
+    description: `Baker's own web analytics for this company's published pages. No connection to set up \u2014 data starts the moment a page is published.
+
+Start here:
+  baker analytics overview                    \u2014 traffic, pages, sources and Form drop-off in one call
+  baker analytics landings                    \u2014 every page side by side, with a sparkline each
+  baker analytics presets                     \u2014 what each report answers
+
+Examples:
+  baker analytics overview --days 7
+  baker analytics funnel --flow contact       \u2014 which step loses people
+  baker analytics flow --flow contact         \u2014 that Form in depth: conversions, step-to-step paths, triggers
+  baker analytics overview --landing ld_7f2a  \u2014 the whole report for one page only
+  baker analytics page --path /pricing        \u2014 one page in detail
+  baker analytics triggers --flow contact     \u2014 what people did in the Form, wired up or not
+  baker analytics paid --days 30              \u2014 campaigns by click id, and how many leads actually arrived
+  baker analytics delivery                    \u2014 submissions whose destination refused them
+  baker analytics submissions --flow contact  \u2014 every attempt at that Form, delivered or not
+  baker analytics releases                    \u2014 did the last publish change anything
+  baker analytics traffic --days 90 --full    \u2014 full breakdowns and the per-day trend
+  baker analytics geo --grain postal_code --country ES \u2014 which postcodes convert
+  baker analytics bots --days 30              \u2014 is the site still being crawled
+  baker analytics companies --targets targets.csv \u2014 which target accounts visited, and which did not
+  baker analytics landings --tag q3           \u2014 how the Q3 campaign's pages did
+  baker analytics tags                        \u2014 the same numbers rolled up per campaign
+  baker analytics events --event video --property milestone \u2014 how far people watch
+  baker analytics events --event video --property milestone --where autoplay=0 \u2014 ...among videos they chose to play
+  baker analytics events --steps hero_view,pricing_view,demo_click   \u2014 an ordered page funnel
+  baker analytics devices --grain viewport    \u2014 which widths the page has to survive
+  baker analytics ads                         \u2014 every campaign parameter on this company's URLs, and what we make of it
+  baker analytics ads --role keyword          \u2014 keywords by conversions AND by how many bounced
+  baker analytics ads --platform google --role keyword \u2014 the same, in Google's vocabulary and from Google's traffic only
+  baker analytics overview --role keyword --value "solar panels" \u2014 the whole report for those visits only
+  baker analytics tracking                    \u2014 do the ad URLs carry the campaign, ad group and ad at all
+  baker analytics tracking --platform meta    \u2014 the same for one platform, read from their own ad account
+  baker analytics map --platform google --set kw=keyword   \u2014 stage a parameter name, seen or not yet
+  baker analytics map --platform google --remove kw        \u2014 take that answer back
+  baker analytics unstage --kind conversion --ref 'page:Deal won' \u2014 take back a change this chat staged
+  baker analytics delivery --page 2 --page-size 50         \u2014 the next page of a long list
+  baker analytics overview --compare          \u2014 this window against the one before it
+  baker analytics website-tag                 \u2014 the tag for a website Baker does not publish, key included
+  baker analytics sending-events              \u2014 the contract for a client's server to post its own events
+  baker analytics arrivals --outcome rejected \u2014 what their server posted that we refused, and why
+  baker analytics events --origin server      \u2014 the events their systems reported, not ours
+  baker analytics lookup --person 'ana@empresa.com, deal:40001234567'   \u2014 which of these people Baker has, and what it saw of each
+  baker analytics feed --person 'ana@empresa.com' --days 90              \u2014 everything one person did, in order
+Full guide: __tooling__/docs/tools/baker/analytics.md`
+  },
+  subCommands: {
+    overview: overviewCommand,
+    traffic: trafficCommand,
+    funnel: funnelCommand,
+    flow: flowCommand,
+    page: pageCommand,
+    triggers: triggersCommand,
+    releases: releasesCommand,
+    paid: paidCommand,
+    delivery: deliveryCommand,
+    submissions: submissionsCommand,
+    geo: geoCommand,
+    bots: botsCommand,
+    companies: companiesCommand,
+    landings: landingsCommand,
+    tags: tagsCommand,
+    events: eventsCommand,
+    feed: feedCommand,
+    lookup: () => import("./lookup-IUQWU346.js").then((m) => m.lookupCommand),
+    devices: devicesCommand,
+    ads: adsCommand,
+    conversions: conversionsCommand,
+    sends: () => import("./sends-43FU3SJN.js").then((m) => m.sendsCommand),
+    map: mapCommand,
+    unstage: () => import("./unstage-YSVQ6DLB.js").then((m) => m.unstageCommand),
+    tracking: trackingCommand,
+    arrivals: arrivalsCommand,
+    "sending-events": sendingEventsCommand,
+    sources: () => import("./sources-PUZ4WV4Q.js").then((m) => m.sourcesCommand),
+    "website-tag": websiteTagCommand,
+    debug: debugCommand,
+    sites: sitesCommand,
+    plan: () => import("./plan-VHMWZU7F.js").then((m) => m.planCommand),
+    questionnaire: () => import("./questionnaire-32BQ4ZUX.js").then((m) => m.questionnaireCommand),
+    presets: presetsCommand
+  }
+});
+export {
+  analyticsCommand,
+  conversionsEnvelope,
+  feedRequest,
+  paginationError,
+  readConversionCounts,
+  requestBody,
+  sendingEventsAddress
+};
+//# sourceMappingURL=analytics-OUNKG2FW.js.map