@koda-sl/baker-cli 0.513.0 → 0.514.0

package/dist/chunk-JOE42ZW6.js

@@ -0,0 +1,2984 @@
+import {
+  INGEST_CLICK_ID_PARAMS,
+  templateMentions
+} from "./chunk-NKQWDEB7.js";
+import {
+  MATCH_COOKIES,
+  isSha256Hex,
+  normalizeIdentity
+} from "./chunk-G4FG5EQO.js";
+
+// ../api/src/analytics/adParams.ts
+var AD_PARAM_ROLES = [
+  "campaign_id",
+  "campaign_name",
+  "adgroup_id",
+  "adgroup_name",
+  "ad_id",
+  "ad_name",
+  "keyword",
+  "match_type",
+  "search_query",
+  "audience",
+  "placement",
+  "network",
+  "site_source",
+  "device",
+  "product_id",
+  "account_name",
+  "other",
+  "ignore"
+];
+var AD_PARAM_ROLE_SPECS = {
+  campaign_id: { role: "campaign_id", label: "Campaign ID", description: "The top level of this account's structure." },
+  campaign_name: { role: "campaign_name", label: "Campaign name", description: "The campaign's name." },
+  adgroup_id: { role: "adgroup_id", label: "Ad group ID", description: "The targeting container inside a campaign." },
+  adgroup_name: { role: "adgroup_name", label: "Ad group name", description: "The ad group's name." },
+  ad_id: { role: "ad_id", label: "Ad ID", description: "The individual ad that was clicked." },
+  ad_name: { role: "ad_name", label: "Ad name", description: "The individual ad's name." },
+  keyword: {
+    role: "keyword",
+    label: "Keyword",
+    description: "The keyword that matched, as it is written in the account \u2014 not what the visitor typed."
+  },
+  match_type: {
+    role: "match_type",
+    label: "Match type",
+    description: "How loosely the keyword matched: broad, phrase or exact."
+  },
+  search_query: { role: "search_query", label: "Search query", description: "What the visitor actually typed." },
+  audience: {
+    role: "audience",
+    label: "Audience",
+    description: "The remarketing list or interest segment the visitor was in."
+  },
+  placement: {
+    role: "placement",
+    label: "Placement",
+    description: "Where the ad appeared \u2014 a feed, a story, a site on the display network."
+  },
+  network: {
+    role: "network",
+    label: "Network",
+    description: "Which network served it: search, a search partner, display, or a video surface."
+  },
+  site_source: {
+    role: "site_source",
+    label: "App",
+    description: "Which app the click came from, on platforms that span several."
+  },
+  device: { role: "device", label: "Device", description: "Mobile, tablet or desktop, as the platform saw it." },
+  product_id: { role: "product_id", label: "Product ID", description: "The shopping item that was clicked." },
+  account_name: {
+    role: "account_name",
+    label: "Account name",
+    description: "Which ad account paid for the click, where an agency runs several."
+  },
+  other: {
+    role: "other",
+    label: "Something else",
+    description: "Keep the values and let me filter by this name, without saying what it means."
+  },
+  ignore: {
+    role: "ignore",
+    label: "Ignore it",
+    description: "Not campaign information. Baker stops storing it and stops asking about it."
+  }
+};
+var RESERVED_PARAM_NAMES = [
+  "utm_source",
+  "utm_medium",
+  "utm_campaign",
+  "utm_content",
+  "utm_term",
+  "utm_id"
+];
+var AD_PLATFORMS = [
+  "google",
+  "meta",
+  "microsoft",
+  "linkedin",
+  "tiktok",
+  "reddit",
+  "pinterest",
+  "snapchat",
+  "chatgpt"
+];
+function isAdPlatform(value) {
+  return AD_PLATFORMS.includes(value);
+}
+var GOOGLE = {
+  platform: "google",
+  label: "Google Ads",
+  docs: "https://developers.google.com/google-ads/api/docs/reporting/valuetrack-mapping",
+  dimensions: [
+    { role: "campaign_id", macro: "{campaignid}", names: ["campaign_id", "campaignid", "gad_campaignid"] },
+    { role: "adgroup_id", macro: "{adgroupid}", names: ["adgroup_id", "adgroupid"] },
+    {
+      role: "ad_id",
+      macro: "{creative}",
+      names: ["ad_id", "creative", "adid"],
+      note: "ValueTrack calls the ad id {creative}."
+    },
+    { role: "keyword", macro: "{keyword}", names: ["keyword", "kw"] },
+    {
+      role: "match_type",
+      macro: "{matchtype}",
+      names: ["match_type", "matchtype", "mt"],
+      note: "b broad, p phrase, e exact, a AI Max."
+    },
+    {
+      role: "network",
+      macro: "{network}",
+      names: ["network", "gad_source"],
+      note: "g search, s partner, d display, ytv YouTube."
+    },
+    { role: "device", macro: "{device}", names: ["device"] },
+    { role: "placement", macro: "{placement}", names: ["placement"] },
+    { role: "product_id", macro: "{product_id}", names: ["product_id"], note: "Shopping campaigns only." }
+  ]
+};
+var META = {
+  platform: "meta",
+  label: "Meta Ads",
+  docs: "https://www.facebook.com/business/help/2360940870872492",
+  dimensions: [
+    { role: "campaign_id", macro: "{{campaign.id}}", names: ["campaign_id", "campaignid"] },
+    { role: "campaign_name", macro: "{{campaign.name}}", names: ["campaign_name", "campaignname"] },
+    {
+      role: "adgroup_id",
+      macro: "{{adset.id}}",
+      names: ["adset_id", "adgroup_id", "adsetid"],
+      note: "Meta calls an ad group an ad set."
+    },
+    { role: "adgroup_name", macro: "{{adset.name}}", names: ["adset_name", "adgroup_name"] },
+    { role: "ad_id", macro: "{{ad.id}}", names: ["ad_id", "adid"] },
+    { role: "ad_name", macro: "{{ad.name}}", names: ["ad_name", "adname"] },
+    {
+      role: "placement",
+      macro: "{{placement}}",
+      names: ["placement", "placement_id"],
+      note: "feed, story, reels and the rest."
+    },
+    {
+      role: "site_source",
+      macro: "{{site_source_name}}",
+      names: ["site_source", "site_source_name"],
+      note: "fb, ig, an or msg."
+    }
+  ]
+};
+var MICROSOFT = {
+  platform: "microsoft",
+  label: "Microsoft Advertising",
+  docs: "https://learn.microsoft.com/en-us/advertising/guides/url-tracking-upgraded-urls",
+  dimensions: [
+    { role: "campaign_id", macro: "{CampaignId}", names: ["campaign_id", "campaignid"] },
+    { role: "campaign_name", macro: "{Campaign}", names: ["campaign_name", "campaignname"] },
+    { role: "adgroup_id", macro: "{AdGroupId}", names: ["adgroup_id", "adgroupid"] },
+    { role: "adgroup_name", macro: "{AdGroup}", names: ["adgroup_name", "adgroupname"] },
+    { role: "ad_id", macro: "{AdId}", names: ["ad_id", "adid"] },
+    { role: "keyword", macro: "{Keyword}", names: ["keyword", "kw"] },
+    { role: "match_type", macro: "{MatchType}", names: ["match_type", "matchtype", "mt"] },
+    {
+      role: "search_query",
+      macro: "{QueryString}",
+      names: ["search_query", "querystring"],
+      note: "What the visitor typed. Google has no equivalent."
+    },
+    { role: "network", macro: "{Network}", names: ["network"] },
+    { role: "device", macro: "{Device}", names: ["device"] }
+  ]
+};
+var LINKEDIN = {
+  platform: "linkedin",
+  label: "LinkedIn Ads",
+  docs: "https://learn.microsoft.com/en-us/linkedin/marketing/integrations/ads-reporting/dynamic-utm-tracking",
+  dimensions: [
+    { role: "account_name", macro: "{{ACCOUNT_NAME}}", names: ["account_name"] },
+    {
+      role: "campaign_id",
+      macro: "{{CAMPAIGN_GROUP_ID}}",
+      names: ["campaign_group_id", "campaign_id"],
+      note: "LinkedIn's campaign group is the level other platforms call a campaign."
+    },
+    { role: "campaign_name", macro: "{{CAMPAIGN_GROUP_NAME}}", names: ["campaign_group_name", "campaign_name"] },
+    {
+      role: "adgroup_id",
+      macro: "{{CAMPAIGN_ID}}",
+      names: ["adgroup_id"],
+      note: "LinkedIn's campaign is the level other platforms call an ad group."
+    },
+    { role: "adgroup_name", macro: "{{CAMPAIGN_NAME}}", names: ["adgroup_name"] },
+    { role: "ad_id", macro: "{{CREATIVE_ID}}", names: ["creative_id", "ad_id"] },
+    { role: "ad_name", macro: "{{CREATIVE_NAME}}", names: ["creative_name", "ad_name"] }
+  ]
+};
+var TIKTOK = {
+  platform: "tiktok",
+  label: "TikTok Ads",
+  docs: "https://ads.tiktok.com/help/article/track-offsite-web-events-with-utm-parameters",
+  dimensions: [
+    { role: "campaign_id", macro: "__CAMPAIGN_ID__", names: ["campaign_id", "campaignid"] },
+    { role: "campaign_name", macro: "__CAMPAIGN_NAME__", names: ["campaign_name", "campaignname"] },
+    {
+      role: "adgroup_id",
+      macro: "__AID__",
+      names: ["adgroup_id", "aid"],
+      note: "__AID__ is the ad GROUP id, not the ad id."
+    },
+    { role: "adgroup_name", macro: "__AID_NAME__", names: ["adgroup_name"] },
+    {
+      role: "ad_id",
+      macro: "__CID__",
+      names: ["ad_id", "cid"],
+      note: "__CID__ is the creative id, not the campaign id."
+    },
+    { role: "ad_name", macro: "__CID_NAME__", names: ["ad_name"] },
+    { role: "placement", macro: "__PLACEMENT__", names: ["placement"], note: "TikTok or TikTok Pangle." }
+  ]
+};
+var REDDIT = {
+  platform: "reddit",
+  label: "Reddit Ads",
+  docs: "https://business.reddithelp.com/s/article/URL-Parameters",
+  dimensions: [
+    { role: "campaign_id", macro: "{{CAMPAIGN_ID}}", names: ["campaign_id", "campaignid"] },
+    { role: "campaign_name", macro: "{{CAMPAIGN_NAME}}", names: ["campaign_name"] },
+    { role: "adgroup_id", macro: "{{ADGROUP_ID}}", names: ["adgroup_id", "ad_group_id"] },
+    { role: "adgroup_name", macro: "{{ADGROUP_NAME}}", names: ["adgroup_name", "ad_group_name"] },
+    { role: "ad_id", macro: "{{AD_ID}}", names: ["ad_id", "adid"] },
+    { role: "ad_name", macro: "{{AD_NAME}}", names: ["ad_name"] },
+    { role: "device", macro: "{{DEVICE_GROUP}}", names: ["device", "device_group"] }
+  ]
+};
+var PINTEREST = {
+  platform: "pinterest",
+  label: "Pinterest Ads",
+  docs: "https://help.pinterest.com/en/business/article/third-party-and-dynamic-tracking",
+  dimensions: [
+    { role: "campaign_id", macro: "{campaignid}", names: ["campaign_id", "campaignid"] },
+    { role: "campaign_name", macro: "{campaign_name}", names: ["campaign_name", "campaignname"] },
+    { role: "adgroup_id", macro: "{adgroupid}", names: ["adgroup_id", "adgroupid"] },
+    { role: "adgroup_name", macro: "{ad_group_name}", names: ["adgroup_name", "adgroupname"] },
+    {
+      role: "ad_id",
+      macro: "{adid}",
+      names: ["ad_id", "adid", "creative_id"],
+      note: "The promoted Pin, not the Pin itself."
+    },
+    { role: "device", macro: "{device}", names: ["device"], note: "c computer, m mobile, t tablet." },
+    { role: "product_id", macro: "{product_id}", names: ["product_id"], note: "Shopping campaigns only." }
+  ]
+};
+var SNAPCHAT = {
+  platform: "snapchat",
+  label: "Snapchat Ads",
+  docs: "https://businesshelp.snapchat.com/s/article/url-parameters",
+  dimensions: [
+    { role: "campaign_id", macro: "{{campaign.id}}", names: ["campaign_id", "campaignid"] },
+    { role: "campaign_name", macro: "{{campaign.name}}", names: ["campaign_name"] },
+    {
+      role: "adgroup_id",
+      macro: "{{adSet.id}}",
+      names: ["adset_id", "adgroup_id"],
+      note: "Case-sensitive: {{adset.id}} does not resolve."
+    },
+    { role: "adgroup_name", macro: "{{adSet.name}}", names: ["adset_name", "adgroup_name"] },
+    { role: "ad_id", macro: "{{ad.id}}", names: ["ad_id", "adid"] },
+    { role: "ad_name", macro: "{{creative.name}}", names: ["ad_name", "creative_name"] }
+  ]
+};
+var CHATGPT = {
+  platform: "chatgpt",
+  label: "ChatGPT Ads",
+  docs: "https://help.openai.com/en/articles/20001212-create-ads-for-chatgpt",
+  dimensions: [
+    { role: "campaign_id", macro: "{campaign_id}", names: ["campaign_id", "campaignid"] },
+    { role: "adgroup_id", macro: "{ad_group_id}", names: ["ad_group_id", "adgroup_id"] },
+    { role: "ad_id", macro: "{ad_id}", names: ["ad_id", "adid"] }
+  ]
+};
+var AD_PLATFORM_DEFINITIONS = {
+  google: GOOGLE,
+  meta: META,
+  microsoft: MICROSOFT,
+  linkedin: LINKEDIN,
+  tiktok: TIKTOK,
+  reddit: REDDIT,
+  pinterest: PINTEREST,
+  snapchat: SNAPCHAT,
+  chatgpt: CHATGPT
+};
+var ESSENTIAL_ROLES = ["campaign_id", "adgroup_id", "ad_id", "keyword", "match_type"];
+function essentialAdDimensions(platform) {
+  return AD_PLATFORM_DEFINITIONS[platform].dimensions.filter((entry) => ESSENTIAL_ROLES.includes(entry.role));
+}
+function normalizeAdParamName(raw) {
+  return raw.trim().toLowerCase().slice(0, 64);
+}
+function builtinFor(platform) {
+  const mapping = {};
+  for (const dimension of AD_PLATFORM_DEFINITIONS[platform].dimensions) {
+    for (const name of dimension.names) mapping[normalizeAdParamName(name)] = dimension.role;
+  }
+  return mapping;
+}
+var BUILTIN = Object.fromEntries(
+  AD_PLATFORMS.map((platform) => [platform, builtinFor(platform)])
+);
+function builtinAdParamMapping(platform) {
+  return BUILTIN[platform];
+}
+var EVERY_BUILTIN_AD_PARAM_NAME = [
+  ...new Set(AD_PLATFORMS.flatMap((platform) => Object.keys(BUILTIN[platform])))
+].sort();
+var CAPTURED_WITHOUT_ROLE = [
+  "account_id",
+  "audience",
+  "device_model",
+  "devicemodel",
+  "experiment",
+  "extensionid",
+  "feed_item_id",
+  "feeditemid",
+  "loc_interest_ms",
+  "loc_physical_ms",
+  "location_interest",
+  "location_physical",
+  "target_id",
+  "targetid"
+].sort();
+
+// ../api/src/analytics/eventKey.ts
+var SEP = ":";
+function formEventKey(flowSlug, nodeId, triggerId) {
+  return ["form", flowSlug, nodeId, triggerId].join(SEP);
+}
+var STORE_PURCHASE_KEY = "page:purchase";
+var CHECKOUT_RECORD_KEY = "page:purchase_observed";
+function isCheckoutRecordKey(key) {
+  return key.trim() === CHECKOUT_RECORD_KEY;
+}
+var CHECKOUT_RECORD_REFUSAL = {
+  message: `"${CHECKOUT_RECORD_KEY}" is the shopper's browser reporting a store order that "${STORE_PURCHASE_KEY}" already counts from the store itself, so counting it would count every sale twice.`,
+  fix: `Count the store's sales with "${STORE_PURCHASE_KEY}" instead (e.g. --event ${STORE_PURCHASE_KEY} --name 'Store purchase'). If it is already counted, nothing more is needed.`
+};
+function isLandingViewKey(key) {
+  return parseEventKey(key)?.family === "view";
+}
+function parseEventKey(key) {
+  const cut = key.indexOf(SEP);
+  if (cut <= 0) return null;
+  const family = key.slice(0, cut);
+  const rest = key.slice(cut + 1);
+  if (rest === "") return null;
+  switch (family) {
+    case "form": {
+      const [flowSlug, nodeId, ...triggerParts] = rest.split(SEP);
+      const triggerId = triggerParts.join(SEP);
+      if (!flowSlug || !nodeId || triggerId === "") return null;
+      return { family: "form", flowSlug, nodeId, triggerId };
+    }
+    case "submit":
+      return { family: "submit", flowSlug: rest };
+    case "page":
+      return { family: "page", eventName: rest };
+    case "exit":
+      return { family: "exit", host: rest };
+    case "view":
+      return { family: "view", landingId: rest };
+    default:
+      return null;
+  }
+}
+
+// ../api/src/analytics/sends.ts
+var SEND_PLATFORMS = [
+  "meta",
+  "chatgptAds",
+  "googleAds",
+  "linkedinInsightTag",
+  "twitterAds",
+  "googleAnalytics"
+];
+function isSendPlatform(value) {
+  return SEND_PLATFORMS.includes(value);
+}
+var SEND_PLATFORM_SPECS = {
+  meta: {
+    title: "Meta",
+    eventMeans: "A Meta event name \u2014 Lead, Purchase, Schedule, or one of your own",
+    eventKind: "name",
+    credentialFields: ["accessToken"],
+    setupHint: "Add the Conversions API access token to the Meta pixel in Tracking"
+  },
+  chatgptAds: {
+    title: "ChatGPT Ads",
+    eventMeans: "A ChatGPT Ads event \u2014 lead_created, order_created, or a custom name",
+    eventKind: "name",
+    credentialFields: ["apiKey"],
+    setupHint: "Add the Conversions API key to the ChatGPT Ads pixel in Tracking"
+  },
+  googleAds: {
+    title: "Google Ads",
+    eventMeans: "One of the account's conversion actions, picked from its list",
+    eventKind: "id",
+    credentialFields: ["oauthProviderId"],
+    setupHint: "Connect the Google Ads conversion tag to a Google Ads account in Tracking"
+  },
+  linkedinInsightTag: {
+    title: "LinkedIn",
+    eventMeans: "The id of a conversion rule in LinkedIn Campaign Manager",
+    eventKind: "id",
+    credentialFields: ["oauthProviderId"],
+    setupHint: "Connect the LinkedIn Insight Tag to a LinkedIn account in Tracking"
+  },
+  twitterAds: {
+    title: "X",
+    eventMeans: "The event tag id from X Events Manager, like tw-oka17-abc12",
+    eventKind: "id",
+    credentialFields: ["oauthProviderId"],
+    setupHint: "Connect the X pixel to an X Ads account in Tracking"
+  },
+  googleAnalytics: {
+    title: "Google Analytics",
+    eventMeans: "A GA4 event name \u2014 generate_lead, purchase, or one of your own",
+    eventKind: "name",
+    credentialFields: ["apiSecret"],
+    setupHint: "Add the Measurement Protocol API secret to the Google Analytics tag in Tracking"
+  }
+};
+var SEND_ORIGINS = ["server", "website", "any"];
+var MAX_SEND_ID = 64;
+var MAX_SEND_EVENT_KEY = 320;
+function sendEventIsTemplated(event) {
+  return templateMentions(event).length > 0;
+}
+function sendEventProblem(platform, event) {
+  if (!isSendPlatform(platform)) return null;
+  if (!sendEventIsTemplated(event)) return null;
+  const spec = SEND_PLATFORM_SPECS[platform];
+  if (spec.eventKind === "name") return null;
+  return `${spec.title} identifies a conversion by an id it issued, so it cannot be written from the event. Paste the id; pass what varies as an extra parameter instead.`;
+}
+
+// ../api/src/analytics/peopleSearch.ts
+import { z } from "zod";
+var PEOPLE_SEARCH_MAX_TERMS = 50;
+var VERBATIM_KINDS = [
+  "browser",
+  "gclid",
+  "wbraid",
+  "gbraid",
+  "dclid",
+  "fbclid",
+  "ttclid",
+  "twclid",
+  "li_fat_id",
+  "msclkid",
+  "rdt_cid",
+  "epik",
+  "sccid",
+  "oppref",
+  "fbp",
+  "fbc"
+];
+var PREFIXES = {
+  email: "email",
+  mail: "email",
+  phone: "phone",
+  tel: "phone",
+  external: "external",
+  contact: "external",
+  hubspot: "external",
+  id: "external",
+  deal: "deal",
+  digest: "digest",
+  hash: "digest",
+  browser: "browser",
+  anon: "browser",
+  ...Object.fromEntries(VERBATIM_KINDS.map((kind) => [kind, kind]))
+};
+var TERM_SEPARATORS = /[\n\r\t,;]+/;
+var EMAIL_SHAPE = /^[^\s@]+@[^\s@]+$/;
+var DIGITS = /^\d+$/;
+var INTERNATIONAL_PHONE = /^(\+|00)[\d\s().-]{7,}$/;
+var META_COOKIE = /^fb\.\d\./;
+function kindOf(value) {
+  if (EMAIL_SHAPE.test(value)) return "email";
+  if (isSha256Hex(value)) return "digest";
+  if (INTERNATIONAL_PHONE.test(value)) return "phone";
+  if (DIGITS.test(value)) return "number";
+  if (META_COOKIE.test(value)) return "fbc";
+  return "key";
+}
+function readTerm(input) {
+  const colon = input.indexOf(":");
+  if (colon > 0) {
+    const kind = PREFIXES[input.slice(0, colon).trim().toLowerCase()];
+    const value = input.slice(colon + 1).trim();
+    if (kind !== void 0 && value !== "") return { input, kind, value };
+  }
+  return { input, kind: kindOf(input), value: input };
+}
+function sameness(term) {
+  switch (term.kind) {
+    case "email":
+    case "phone":
+      return `${term.kind}|${normalizeIdentity({ kind: term.kind, value: term.value }, 1)?.value ?? term.value}`;
+    case "external":
+    case "digest":
+      return `${term.kind}|${term.value.toLowerCase()}`;
+    default:
+      return `${term.kind}|${term.value}`;
+  }
+}
+function parsePeopleQuery(text) {
+  const inputs = (typeof text === "string" ? [text] : text).flatMap((part) => part.split(TERM_SEPARATORS));
+  const seen = /* @__PURE__ */ new Set();
+  const terms = [];
+  for (const raw of inputs) {
+    const input = raw.trim();
+    if (input === "") continue;
+    const term = readTerm(input);
+    const identity = sameness(term);
+    if (seen.has(identity)) continue;
+    seen.add(identity);
+    terms.push(term);
+  }
+  return {
+    terms: terms.slice(0, PEOPLE_SEARCH_MAX_TERMS),
+    dropped: Math.max(0, terms.length - PEOPLE_SEARCH_MAX_TERMS)
+  };
+}
+var personTermInputSchema = z.string().trim().min(1).max(320);
+var peopleSearchInputSchema = z.array(personTermInputSchema).min(1).max(PEOPLE_SEARCH_MAX_TERMS * 4);
+var peopleLookupRequestSchema = z.object({ people: peopleSearchInputSchema });
+var peopleSearchTermSchema = z.object({
+  /** Position in the search; what `personTerms` on a feed row points at. */
+  term: z.number().int(),
+  input: z.string(),
+  kind: z.string(),
+  /**
+   * Why this line could not be looked up as asked, in the reader's words — a
+   * deal HubSpot does not know, HubSpot not connected. Empty when it was.
+   */
+  problem: z.string().default(""),
+  /** A deal's contacts, as found in the CRM. Empty for every other kind. */
+  contacts: z.array(z.string()).default([])
+});
+var peopleLookupRowSchema = peopleSearchTermSchema.extend({
+  found: z.boolean(),
+  events: z.number(),
+  firstSeen: z.string(),
+  lastSeen: z.string(),
+  pageViews: z.number(),
+  landings: z.number(),
+  visits: z.number(),
+  formSubmits: z.number(),
+  /** What the company's own systems reported about them, by event name — CRM stages, orders. */
+  systemEvents: z.array(z.string()),
+  pageEvents: z.array(z.string()),
+  uploads: z.number(),
+  uploadedTo: z.array(z.string()),
+  googleClick: z.boolean(),
+  metaClick: z.boolean(),
+  /** `utm_source`, else the referrer, of the first visit Baker saw. Empty when it saw none. */
+  firstSource: z.string(),
+  /** Every kind of key they are linked by: `email`, `phone`, `external`, `browser`, a click id. */
+  knownBy: z.array(z.string())
+});
+var peopleLookupDataSchema = z.object({
+  people: z.array(peopleLookupRowSchema),
+  /** Lines past the limit, not looked up. */
+  dropped: z.number()
+});
+
+// ../api/src/analytics/sendsWire.ts
+import { z as z2 } from "zod";
+var conversionSendSchema = z2.object({
+  /** Stable within the company. `s1`, `s2` — something a person can type. */
+  id: z2.string().min(1).max(MAX_SEND_ID),
+  /** The event it sends, by key — `page:<name>`, from `events[]` of a plain read. */
+  eventKey: z2.string().min(1).max(MAX_SEND_EVENT_KEY),
+  /** `website` for an event Baker's pixel raised on the company's own site; absent (or `server`) for the API and integrations. */
+  origin: z2.enum(SEND_ORIGINS).optional(),
+  platform: z2.enum(SEND_PLATFORMS),
+  /** The tag's id on Tracking. Must be one of this company's tags of the platform's type, with its server credential set. */
+  tagId: z2.string().min(1).max(120),
+  /** A Meta or GA4 event name; a Google Ads conversion action id; a LinkedIn conversion rule id; an X event tag id. */
+  event: z2.string().min(1).max(255),
+  /** The LinkedIn ad account the conversion rule belongs to. */
+  account: z2.string().max(120).optional(),
+  /** Extra platform parameters: name → template over the event. See `SEND_PARAMETERS[platform]`. */
+  parameters: z2.record(z2.string().min(1).max(64), z2.string().min(1).max(500)).optional()
+});
+var sendUploadSchema = z2.object({
+  sendId: z2.string(),
+  eventUid: z2.string(),
+  /** The event's own name, as it was counted. Empty for a Form's submit, which has none. */
+  eventName: z2.string(),
+  /** The event's key, as `conversions` spells it — what names a Form's submit. */
+  eventKey: z2.string(),
+  /** The Form it happened in, for a `form:` or `submit:` key. */
+  flowSlug: z2.string(),
+  /** ISO instant of the event itself. */
+  eventAt: z2.string(),
+  /** ISO instant of the upload. */
+  dispatchedAt: z2.string(),
+  /** `skipped`: never uploaded, because the event carried nothing the platform can match a person by. */
+  outcome: z2.enum(["success", "failed", "pending", "skipped"]),
+  /** The platform's refusal in its own words, or why it was skipped. Empty otherwise. */
+  error: z2.string(),
+  sessionId: z2.string(),
+  anonId: z2.string()
+});
+var MAX_SENDS_PER_REQUEST = 40;
+var sendsRequestSchema = z2.object({
+  set: z2.array(conversionSendSchema).max(MAX_SENDS_PER_REQUEST).optional(),
+  remove: z2.array(z2.string().min(1).max(MAX_SEND_ID)).max(MAX_SENDS_PER_REQUEST).optional(),
+  /** How many days the outcomes beside each send cover. Default 30. */
+  days: z2.number().int().min(1).max(400).optional(),
+  /** List one send's uploads over the window, newest first, by the send's id. */
+  uploads: z2.string().min(1).max(MAX_SEND_ID).optional(),
+  /** With `uploads`: only the ones the platform refused. */
+  failedOnly: z2.boolean().optional(),
+  /** With `uploads`: only the events skipped, with what each was missing. */
+  skippedOnly: z2.boolean().optional(),
+  /** Also say when each live send was set up, and when an integration named after its event was removed. */
+  history: z2.boolean().optional()
+});
+var sendOutcomeSchema = z2.object({
+  sendId: z2.string(),
+  dispatched: z2.number(),
+  succeeded: z2.number(),
+  failed: z2.number(),
+  pending: z2.number(),
+  lastError: z2.string(),
+  lastAt: z2.string(),
+  /** Events not uploaded: they carried nothing this platform can match a person by. */
+  skipped: z2.number().optional(),
+  lastSkipReason: z2.string().optional()
+});
+var sendsResponseSchema = z2.object({
+  ok: z2.literal(true),
+  data: z2.object({
+    /** The company's sends, as they are live. */
+    sends: z2.array(conversionSendSchema.extend({ outcome: sendOutcomeSchema.optional() })),
+    /** The ops this chat has staged and not yet published. Absent outside a chat. */
+    staged: z2.object({
+      set: z2.array(conversionSendSchema),
+      remove: z2.array(z2.string())
+    }).optional(),
+    /** The platforms, what `event` means on each, what a tag needs on Tracking to send, and the tags that can. */
+    platforms: z2.array(
+      z2.object({
+        platform: z2.string(),
+        title: z2.string(),
+        eventMeans: z2.string(),
+        setupHint: z2.string(),
+        tags: z2.array(z2.object({ tagId: z2.string(), label: z2.string() })),
+        /**
+         * The conversions the platform already holds, by the id a send's `event`
+         * takes and the name the person gave them. Google Ads only: its `event`
+         * is an id Google issued, and an id the account does not hold is
+         * accepted and files against nothing. `label` is the conversion label
+         * the account's tag setup shows (`AW-…/<label>`) — how the person knows it.
+         */
+        conversionActions: z2.array(
+          z2.object({ id: z2.string(), name: z2.string(), primaryForGoal: z2.boolean(), label: z2.string().optional() })
+        ).optional()
+      })
+    ),
+    /** Every field a send forwards. Nothing to map. */
+    carries: z2.array(z2.object({ name: z2.string(), label: z2.string(), group: z2.string(), hashed: z2.boolean() })),
+    /**
+     * The events this company's systems raise, so a send can be pointed at
+     * one: every Source by the key it raises, and every named event the store
+     * saw arrive from a system.
+     */
+    events: z2.array(
+      z2.object({
+        eventKey: z2.string(),
+        /** The event's own name. */
+        name: z2.string(),
+        /** `source` for a Source on Sources, `systems` for a name the API posted, `both` when a page sends it too, `website` for a name Baker's pixel sent — a send on it carries `origin: "website"`. */
+        origin: z2.string(),
+        /**
+         * The last 30 days of it: how many arrived, and how many each platform
+         * could match a person on. The rest would be skipped by a send there.
+         */
+        match: z2.object({ events: z2.number(), platforms: z2.record(z2.string(), z2.number()) }).optional()
+      })
+    ),
+    /** What each platform does with extra parameters, and the names it knows. */
+    parameters: z2.array(
+      z2.object({
+        platform: z2.string(),
+        takes: z2.boolean(),
+        where: z2.string(),
+        known: z2.array(z2.string()),
+        max: z2.number()
+      })
+    ),
+    /** The event fields a parameter template may read, beside `properties.<key>`. */
+    templateFields: z2.array(z2.object({ name: z2.string(), label: z2.string() })),
+    /** One send's uploads, when `uploads` named one. */
+    uploads: z2.object({ sendId: z2.string(), rows: z2.array(sendUploadSchema) }).optional(),
+    /**
+     * When `history` was asked: when each live send was set up (epoch ms), and
+     * when an integration named after its event was last removed, if one was —
+     * what tells a send left on an event nothing raises apart from a mystery.
+     */
+    history: z2.array(z2.object({ sendId: z2.string(), createdAt: z2.number(), integrationRemovedAt: z2.number().optional() })).optional()
+  }),
+  hints: z2.array(z2.string()).optional()
+});
+
+// ../api/src/analytics/unstage.ts
+import { z as z3 } from "zod";
+var ANALYTICS_UNSTAGE_KINDS = ["mapping", "conversion", "send", "source"];
+var analyticsUnstageKindSchema = z3.enum(ANALYTICS_UNSTAGE_KINDS);
+var analyticsUnstageRequestSchema = z3.object({
+  chatId: z3.string().min(1),
+  kind: analyticsUnstageKindSchema.optional(),
+  ref: z3.string().min(1).optional(),
+  /** Everything staged — of `kind` when given, of every kind otherwise. */
+  all: z3.boolean().optional()
+}).refine((body) => body.all === true ? body.ref === void 0 : body.kind !== void 0 && body.ref !== void 0, {
+  message: "Pass --kind with --ref to take back one staged change, or --all (optionally with --kind) to take back everything staged."
+});
+var analyticsUnstageResponseSchema = z3.object({
+  ok: z3.literal(true),
+  data: z3.object({
+    /** How many staged changes were taken back, per kind touched. */
+    removed: z3.partialRecord(analyticsUnstageKindSchema, z3.number().int().min(0))
+  }),
+  hints: z3.array(z3.string()).optional()
+});
+
+// ../api/src/analytics/wire.ts
+import { z as z4 } from "zod";
+
+// ../api/src/analytics/conversions.ts
+var CONVERSION_COUNT_MODES = ["once_per_visit", "every_time"];
+var PRIMARY_CONVERSION_TRIGGER = {
+  calendly: "calendlyEvent.eventScheduled",
+  customForm: "customForm.onFormSubmitted",
+  highlevel: "highlevelEvent.appointmentScheduled",
+  highlevelForm: "highlevelFormEvent.formSubmitted",
+  hubspot: "hubspotForm.onFormSubmitted",
+  hubspotMeeting: "hubspotMeeting.onMeetingScheduled",
+  link: "link.onClick",
+  savvycal: "savvycalEvent.scheduled",
+  text: "text.onButtonClicked"
+};
+var NON_SUBMIT_NODE_TYPES = ["link", "text"];
+var STEP_SUBMIT_TRIGGERS = Object.fromEntries(
+  Object.entries(PRIMARY_CONVERSION_TRIGGER).filter(([nodeType]) => !NON_SUBMIT_NODE_TYPES.includes(nodeType))
+);
+var MAX_CONVERSION_NAME = 80;
+
+// ../api/src/analytics/submissionAnswers.ts
+var MAX_ANSWER_CHARS = 16384;
+var MAX_ANSWER_NAME_CHARS = 120;
+var TRUNCATED = "\u2026";
+function cutToLength(value, max) {
+  if (value.length <= max) return value;
+  return `${[...value].slice(0, max - 1).join("")}${TRUNCATED}`;
+}
+function boundSubmissionAnswers(answers) {
+  const kept = {};
+  for (const [name, value] of Object.entries(answers)) {
+    kept[cutToLength(name, MAX_ANSWER_NAME_CHARS)] = cutToLength(value, MAX_ANSWER_CHARS);
+  }
+  return kept;
+}
+
+// ../api/src/analytics/wire.ts
+var SEND_FILTERS = ["any", "failed", "skipped"];
+var adParamRoleSchema = z4.enum(AD_PARAM_ROLES);
+var ANALYTICS_FULL_BREAKDOWN_LIMIT = 100;
+var ANALYTICS_MAX_PAGE_SIZE = 200;
+var ANALYTICS_MAX_PAGE = 500;
+function isResolvableTimeZone(value) {
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: value });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var analyticsPresetSchema = z4.enum([
+  /** Everything that matters in one call — the default entry point. */
+  "overview",
+  /** Traffic shape: trend, sources, geo, device. */
+  "traffic",
+  /** Per-step drop-off for the company's Forms. */
+  "funnel",
+  /**
+   * One Form in depth: its steps, where people went between them, and how many
+   * converted at the node that actually produced the conversion.
+   *
+   * Distinct from `funnel`, which is a per-step table across every Form.
+   * A Form with branches is not a table — a visitor who leaves step two for
+   * the booking branch and a visitor who leaves it for nothing are the same
+   * row there, and they are the whole question. `paths` returns the edges
+   * between steps, which is what a Sankey draws.
+   */
+  "flow",
+  /** One page in detail. */
+  "page",
+  /**
+   * Every Form trigger that fired, and how much of it produced a side effect.
+   *
+   * Separate from `funnel` because it answers a different question: the funnel
+   * measures the steps a visitor walked, this measures the things they *did* —
+   * clicking the link that redirects them out, an embedded checkout posting
+   * back — most of which have nothing configured against them and none of
+   * which appear as a step.
+   */
+  "triggers",
+  /** What each published build did, so a change can be attributed to a publish. */
+  "releases",
+  /**
+   * One ad dimension broken down, plus what is actually on the URLs.
+   *
+   * Answers the question the ad platform cannot: not how many clicks a keyword
+   * bought, but whether the people it brought read the page, filled the Form
+   * or left immediately. Pair it with `adRole` to choose the dimension; the
+   * parameter inventory comes back either way, because on a half-tagged
+   * account "there is no keyword on 80% of your paid traffic" is the finding.
+   */
+  "ads",
+  /**
+   * Every landing side by side: traffic, entrances, conversion rate, and a
+   * sparkline each, joined to the landing's real name and tags.
+   *
+   * The list view. `page` answers one page in depth and needs to be told which
+   * one; this answers "which of my pages is working" without knowing the
+   * answer first, and is what a landings screen renders.
+   */
+  "landings",
+  /**
+   * The same numbers grouped by the tag a landing is filed under.
+   *
+   * 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",
+  /**
+   * Events a page defined for itself — a section seen, a video played, a
+   * pricing toggle flipped.
+   *
+   * Separate from every other preset because the vocabulary is the page's
+   * rather than the product's. Mixing them into `traffic` would produce a list
+   * half of which the reader has to already know is bespoke.
+   */
+  "events",
+  /**
+   * Browser, OS, engine and viewport of real visitors.
+   *
+   * `traffic` reports the device family, which is enough to notice that mobile
+   * converts worse and not enough to do anything about it. This is narrow
+   * enough to reproduce a bug on.
+   */
+  "devices",
+  /**
+   * Paid acquisition, grouped the way money is spent.
+   *
+   * Distinct from `traffic` in two ways that matter. It groups by SESSION, so a
+   * visitor counts once for the campaign they arrived on rather than once per
+   * page they read. And it reports leads that were actually DELIVERED, not
+   * `form_submit` events — a campaign whose forms all submit and whose CRM is
+   * rejecting every one of them reads as converting perfectly on every other
+   * preset here, and reads as zero delivered on this one.
+   */
+  "paid",
+  /**
+   * Where each submission actually went, and what each destination made of it.
+   *
+   * The preset for "I filled in the form, where is my lead?". One row per
+   * submission listing every destination, its outcome, and the id the
+   * destination gave the record it created — which is what turns "it says
+   * success" into something a client can open and check.
+   */
+  "delivery",
+  /**
+   * Every attempt anybody made at a Form, delivered or not.
+   *
+   * The wider companion to `delivery`, and the one that answers "I filled in
+   * my own form, where is it?" honestly. `delivery` starts from the dispatch,
+   * so a Form wired to no destination produces no row in it at all — which is
+   * correct for "what did we hand to their CRM" and reads as data loss to
+   * everybody else. The grain here is the attempt: one visitor, one Form, one
+   * visit, whether they finished, gave up halfway, or completed a Form that
+   * sends nowhere.
+   */
+  "submissions",
+  /**
+   * Where the people who convert actually are, at whatever resolution is asked
+   * for.
+   *
+   * `traffic` breaks acquisition down by country, which is the right grain for
+   * "which market is this campaign working in" and the wrong one for every
+   * decision a local advertiser makes. A dentist buying a five-mile radius or a
+   * franchise choosing where to open is asking about postcodes, which is also
+   * how the ad platforms sell that targeting.
+   */
+  "geo",
+  /**
+   * Which machines are fetching this site.
+   *
+   * Every other preset here excludes them, which is correct — a crawler is not
+   * an audience — and a verify check now enforces that rather than trusting it. The rows are kept, though, and this is what
+   * they are kept for: whether Google is still crawling a page that was
+   * republished, whether Meta fetched the link preview before spend went
+   * behind the URL, and how much of the traffic is now AI answer engines.
+   */
+  "bots",
+  /**
+   * Which companies are visiting — named by the visitor's own network at the
+   * edge, never a person, and only for visitors who accepted marketing on a
+   * company that switched it on. The website half of an account-based report.
+   */
+  "companies",
+  /**
+   * One visit, replayed end to end — and every visit the same person made
+   * before it.
+   *
+   * The only preset that answers about a *person* rather than a population.
+   * Every other report here aggregates, which is the right shape for "is the
+   * campaign working" and useless for the question a marketer asks the moment
+   * a lead arrives: who was this, where did they come from, what did they read,
+   * and did their details reach the CRM. Answering that from an aggregate is
+   * impossible by construction.
+   *
+   * Needs `sessionId`. Give `identityHash` as well and it also returns the
+   * person's earlier visits, including the anonymous ones from before they ever
+   * identified themselves — which is the difference between "converted on the
+   * first visit" and "converted on the fourth", two very different businesses.
+   */
+  "session",
+  /**
+   * Everybody who visited, one row per person — converted or not.
+   *
+   * The unit here is a *person*, which no other preset has. `traffic` counts
+   * visitors and cannot name one; `delivery` names the ones who became a lead
+   * and is silent about the ninety-odd percent who did not; `session` describes
+   * one visit and has to be told which. This is the list those are read from.
+   *
+   * Grouped by browser cookie, so somebody who came back on Wednesday is one
+   * row and not two. Pass `onlyConverted` for the converted-only cut, and
+   * `landingId` to ask who visited one page.
+   *
+   * Not offered as a `baker analytics` preset, for the same reason `realtime`
+   * is not: it answers about individuals, and an agent writing a client report
+   * should be reading the population.
+   */
+  "people",
+  /**
+   * Who is on the site right now.
+   *
+   * The only preset measured from `now()` rather than over a date window, and
+   * the only one meant to be polled. Kept out of `overview` for exactly that
+   * reason: a live counter has to refresh every few seconds and the rest of the
+   * page must not refetch with it.
+   *
+   * Deliberately not offered as a `baker analytics` preset. The sandbox agent
+   * works asynchronously — by the time it reads an answer, "the last five
+   * minutes" names a window that has passed — so the only thing listing it
+   * would do is add a choice the agent can never usefully pick to the menu it
+   * reads before picking one.
+   */
+  "realtime",
+  /**
+   * What this company counts as a conversion, and everything it could count.
+   *
+   * The two halves of one question, which is why they are one preset: the list
+   * of definitions with what each produced, and the catalogue of every event
+   * these pages actually emitted with whether it is already counted. Reading
+   * the first without the second is how the previous design failed — a
+   * marketer could see that nothing was counted and had no way to find out what
+   * was available to count.
+   */
+  "conversions",
+  /**
+   * Every event as it was stored, newest first — the one preset that does not
+   * reduce.
+   *
+   * Deliberately not offered as a `baker analytics` preset. It is the raw feed
+   * a person watches while wiring something up, and an agent asked to describe
+   * an account wants the counts rather than the tape.
+   */
+  "stream"
+]);
+var ANALYTICS_PRESETS = analyticsPresetSchema.options;
+var ANALYTICS_EVENT_DOORS = ["pages", "website", "server", "integrations"];
+var analyticsQueryRequestSchema = z4.object({
+  preset: analyticsPresetSchema,
+  /** Lookback in days. Ignored when `startDate` is given. */
+  days: z4.coerce.number().int().positive().max(400).optional(),
+  startDate: z4.iso.date().optional(),
+  endDate: z4.iso.date().optional(),
+  /** Required by the `page` preset; ignored by the others. */
+  path: z4.string().max(1024).optional(),
+  /** Narrows `funnel` to one Form. Omitted means every Form. */
+  flowSlug: z4.string().max(120).optional(),
+  /**
+   * How far down the `geo` preset looks. Ignored by every other preset.
+   *
+   * A closed set rather than a column name, because it names a column and a
+   * column name taken from a request must never reach the SQL.
+   */
+  grain: z4.enum(["country", "region", "city", "postal_code", "metro_code"]).optional(),
+  /**
+   * Narrows `geo` to one country before going finer.
+   *
+   * Not optional decoration below country level: postcodes collide across
+   * markets, so a bare `28001` is a Madrid postcode and a US ZIP at once.
+   */
+  country: z4.string().max(8).optional(),
+  /**
+   * Which ad dimension to break down by, or to narrow every other report to.
+   *
+   * A role from the closed vocabulary — `keyword`, `match_type`,
+   * `campaign_id` — never a raw parameter name. The company's own spellings
+   * are resolved from its mapping server-side, so a caller asking for
+   * "keyword" gets `kw` rows from before a rename as well as `keyword` rows
+   * after it, and no request can name a column.
+   */
+  adRole: adParamRoleSchema.optional(),
+  /**
+   * Narrows to one value of `adRole`. Requires `adRole`.
+   *
+   * An empty string with `adRole` set is a real query — "arrived carrying
+   * none of these" — which is how you size the untagged half of an account.
+   * Omit both to leave the report unnarrowed.
+   */
+  adValue: z4.string().max(255).optional(),
+  /**
+   * Read this report in one ad platform's vocabulary, and from its traffic.
+   *
+   * Two effects, and they belong together. A role resolves against the
+   * mapping in force for that platform — so `cid` is TikTok's ad here and
+   * nobody's campaign — and the report narrows to the sessions that arrived
+   * from it, matched on the click id the platform stamps and, failing that,
+   * on `utm_source`. Asking a platform's question of another platform's
+   * traffic is how a keyword report ends up counting Meta visits that could
+   * not have carried a keyword.
+   *
+   * Omit it for the union across every platform, which is the honest
+   * superset and the right default for "how is paid doing".
+   */
+  adPlatform: z4.enum(AD_PLATFORMS).optional(),
+  /**
+   * Read only what came in by one door. See {@link ANALYTICS_EVENT_DOORS}.
+   *
+   * Omit it for all of it, which is the default and the honest superset.
+   * Only the reads where the split is a question somebody asks honour it —
+   * the totals, the trend, the two page-event reads, the conversion
+   * breakdown and the events catalogue. A session-scoped report cannot: an
+   * ingest row carries no `session_id`, deliberately, so there is no visit
+   * for it to be counted in.
+   */
+  eventOrigin: z4.enum(ANALYTICS_EVENT_DOORS).optional(),
+  /**
+   * `stream` only: keep just one kind of event, named by the key
+   * `conversions` hands back in its catalogue.
+   *
+   * The key rather than `eventName`, because three of the four families have
+   * no name of their own — a Form's trigger, a submit, an outbound click —
+   * and a filter that could only name the fourth would be a filter that hides
+   * most of the feed from itself.
+   */
+  eventKey: z4.string().optional(),
+  /**
+   * `stream` only: keep just what one source sent, by the source's name —
+   * the `baker_source` every event from an address or a HubSpot read
+   * carries. Names come from `baker analytics sources`.
+   */
+  sourceName: z4.string().optional(),
+  /**
+   * `stream` only: keep just the uploads a conversion's sends made —
+   * `any` for every upload, `failed` for the ones the platform refused.
+   */
+  sends: z4.enum(SEND_FILTERS).optional(),
+  /** `stream` only: keep just the uploads one send made, by its id (`s1`). */
+  sendId: z4.string().optional(),
+  /** `stream` only: keep what went to one destination (`meta`, `httpWebhook`) — a Form's deliveries and sends' uploads alike. */
+  sentTo: z4.string().max(64).optional(),
+  /** `stream` only: one event by its uid, and every upload made for it — with the platform's verdict on each. */
+  eventUid: z4.string().optional(),
+  /**
+   * `stream` only: list just the rows taken for machine traffic — a headless
+   * browser, a datacenter — instead of the human feed. How an agent sees its
+   * own test visit, which every report rightly leaves out.
+   */
+  machines: z4.boolean().optional(),
+  /** Return the long breakdowns and the per-day trend. */
+  full: z4.boolean().optional(),
+  /**
+   * IANA zone the day boundaries are drawn in. Defaults to UTC.
+   *
+   * Not cosmetic. Bucketing a Madrid client's traffic by UTC days moves two
+   * hours of every evening into the following day, so "Tuesday" is not
+   * Tuesday and a day-of-week comparison is wrong by however much traffic
+   * arrives after 22:00 — which on a consumer landing is a lot of it.
+   *
+   * Validated against the platform's own zone database rather than an enum,
+   * because the list is the platform's and not ours — but validated it must
+   * be. The zone is substituted into the query as a string literal and
+   * ClickHouse rejects one it cannot resolve, so an unrecognised zone used to
+   * fail the whole report as an INTERNAL_ERROR with nothing naming the cause.
+   *
+   * Rejected rather than quietly defaulted to UTC. A silent fallback returns
+   * a report that looks like the one that was asked for and is bucketed on
+   * different days, which is the exact error this parameter exists to
+   * prevent — better to say the zone is unknown than to answer for the wrong
+   * one.
+   */
+  timezone: z4.string().max(64).refine(isResolvableTimeZone, { message: "Unknown timezone \u2014 pass an IANA zone such as Europe/Madrid" }).optional(),
+  /**
+   * How wide one point of a series is.
+   *
+   * Chosen by the caller rather than derived from the window, because the
+   * caller knows what it is drawing: the same 30 days is 30 points on a
+   * dashboard and 4 on a slide. A 24-hour window at `day` granularity is one
+   * bar, which is the shape this exists to prevent.
+   */
+  granularity: z4.enum(["hour", "day", "week", "month"]).optional(),
+  /**
+   * Narrow to one landing by its `internalId`.
+   *
+   * The reference where `path` is a description: it survives the page being
+   * renamed or moved, which is exactly when a before-and-after comparison
+   * matters most and is exactly when `path` stops matching.
+   */
+  landingId: z4.string().max(120).optional(),
+  /** Narrows `landings` to the landings carrying one tag. */
+  tag: z4.string().max(32).optional(),
+  /**
+   * Which visit the `session` preset replays.
+   *
+   * Ignored by every other preset. Not a filter on the aggregates: narrowing
+   * a population report to one visitor produces numbers that are individually
+   * true and collectively meaningless.
+   */
+  sessionId: z4.string().max(120).optional(),
+  /**
+   * Whose earlier visits to resolve, as a lowercase hex digest.
+   *
+   * A digest and never an address: the identity a page sends is hashed in the
+   * browser, and nothing downstream of that ever holds the original.
+   */
+  identityHash: z4.string().max(128).optional(),
+  /** Which page-defined event the `events` preset breaks down. */
+  eventName: z4.string().max(120).optional(),
+  /** Which of that event's own properties to break it down by. */
+  property: z4.string().max(64).optional(),
+  /**
+   * Narrow the breakdown to the rows carrying one property value.
+   *
+   * Not the same as breaking down by a second key. Video is the case that
+   * demanded it: every milestone carries `autoplay`, and the retention curve
+   * of the videos a visitor chose to play is a different curve from the one a
+   * muted hero produces by playing to nobody. Grouping gives the two totals;
+   * only filtering gives either curve.
+   */
+  where: z4.object({ property: z4.string().max(64), value: z4.string().max(120) }).optional(),
+  /**
+   * An ordered funnel over page-defined event names.
+   *
+   * Data rather than schema, deliberately: defining a new funnel is a
+   * parameter on a request, not a migration and a deploy. The order is the
+   * caller's and is enforced — a session counts at step N only if it produced
+   * step N after step N-1, or "saw pricing then clicked demo" and the reverse
+   * would be the same number.
+   */
+  steps: z4.array(z4.string().max(120)).max(10).optional(),
+  /**
+   * Also return the immediately preceding window of the same length.
+   *
+   * The first question anyone asks of a number is "compared to what". Served
+   * as a second full totals read rather than a delta computed in SQL, so the
+   * comparison window is described in the response and a caller can render
+   * either side of it.
+   */
+  compare: z4.boolean().optional(),
+  /** `devices` only: which facet to group on. */
+  deviceGrain: z4.enum(["browser", "os", "engine", "device", "viewport"]).optional(),
+  /**
+   * One browser, by its cookie id.
+   *
+   * Narrows `people` to a single person, narrows `stream` to everything
+   * that person did, and replays that person's whole history on `session` —
+   * every visit they made, not just the one. Given with `sessionId`, the
+   * session wins and this is ignored.
+   *
+   * On `stream` it is a seed rather than a cookie filter: the browser plus
+   * every address, phone, click id and platform cookie ever seen beside it.
+   * Filtering on the cookie alone would drop exactly the rows the reader
+   * came for — a deal a CRM posted names the person and carries no cookie.
+   */
+  anonId: z4.string().max(120).optional(),
+  /**
+   * `stream` and `session`: one person by any key the store recognises them
+   * by — a contact digest, a CRM id, a click id, a platform cookie — for the
+   * rows a system posted about somebody no browser has named yet. A browser
+   * wins when both are given.
+   */
+  personKind: z4.string().max(40).optional(),
+  personValue: z4.string().max(255).optional(),
+  /**
+   * `stream` only: several people, each by whatever the reader holds about
+   * them — an email, a phone, a CRM contact or deal id, a click id, a browser
+   * id, `kind:value` to say which. Emails and phones are hashed by the
+   * server; the plaintext never reaches the store. Wins over the single
+   * person above, and every row comes back naming which of these it is
+   * (`personTerms`), with how each was read in `peopleSearch`.
+   */
+  people: peopleSearchInputSchema.optional(),
+  /**
+   * `people` only: keep only the visitors who converted.
+   *
+   * A parameter rather than a client-side filter because the list is capped:
+   * filtering the most recent 200 visitors down to the ones who converted
+   * usually leaves two, and reads as "we had two leads".
+   */
+  onlyConverted: z4.boolean().optional(),
+  /**
+   * Which page of a list-shaped report to read, 1-based.
+   *
+   * Only three reports are lists of individual things rather than
+   * breakdowns — `people`, `submissions` and `delivery` — and only those
+   * three take this. A breakdown is a top-N by construction: page two of
+   * "your busiest countries" is not a thing anybody wants.
+   *
+   * It exists because the alternative silently stopped being true. Every one
+   * of those lists was capped, the cap was invisible, and the summary line
+   * above the list counted the rows it had been handed — so an account with
+   * four thousand visitors read "200 people visited in this period" with no
+   * indication that the number was the cap talking. A cap that is reported is
+   * a page; a cap that is not is a wrong answer.
+   */
+  page: z4.coerce.number().int().min(1).max(ANALYTICS_MAX_PAGE).optional(),
+  /**
+   * How many rows one page holds. Bounded, because the reader is a browser.
+   *
+   * Omitted, a list keeps the size it had before pagination existed, which is
+   * what keeps `baker analytics submissions --full` returning the same 800
+   * rows it always did for an agent that reads the whole thing in one go.
+   */
+  pageSize: z4.coerce.number().int().min(1).max(ANALYTICS_MAX_PAGE_SIZE).optional()
+}).refine((value) => value.preset !== "page" || typeof value.path === "string", {
+  message: "The 'page' preset needs --path",
+  path: ["path"]
+}).refine(
+  (value) => value.preset !== "session" || typeof value.sessionId === "string" || typeof value.anonId === "string" || typeof value.personValue === "string",
+  {
+    message: "The 'session' preset needs --session, a browser id or a person key",
+    path: ["sessionId"]
+  }
+).refine((value) => value.property === void 0 || typeof value.eventName === "string", {
+  message: "Breaking an event down by a property needs --event too",
+  path: ["property"]
+}).refine((value) => value.where === void 0 || typeof value.property === "string", {
+  message: "Narrowing with --where needs --event and --property too",
+  path: ["where"]
+});
+var analyticsWindowSchema = z4.object({
+  startDate: z4.iso.date(),
+  endDate: z4.iso.date(),
+  days: z4.number().int().positive(),
+  /** True when the window reaches past the datasource TTL, so part of it is simply gone. */
+  beyondRetention: z4.boolean()
+});
+var analyticsTotalsSchema = z4.object({
+  /** Counted from `visitor_new`. */
+  visitors: z4.number().int().nonnegative(),
+  /** Counted from `session_start`. */
+  sessions: z4.number().int().nonnegative(),
+  pageViews: z4.number().int().nonnegative(),
+  /**
+   * Every conversion, counting a visit twice when it converted twice.
+   *
+   * A Form's author can mark an outcome as counting every time it happens — a
+   * download, a repeatable action — so this legitimately runs ahead of
+   * {@link convertingSessions}, and of `sessions`.
+   */
+  conversions: z4.number().int().nonnegative(),
+  /**
+   * Conversions in the window that no landing earned — by people none of the
+   * company's pages saw. Not in `conversions`, which is a page metric; shown
+   * beside it so a deal a CRM reported is never a silent zero. Zero under any
+   * scope.
+   */
+  unplacedConversions: z4.number().int().nonnegative().default(0),
+  /** Visits that produced at least one conversion. Never above `sessions`. */
+  convertingSessions: z4.number().int().nonnegative(),
+  /**
+   * Converting visits per visit, 0–1. Null when there were no visits.
+   *
+   * Over converting visits rather than over conversions, because the second
+   * ratio passes 1 the moment one visit converts twice — and a headline card
+   * reading "125%" is read as a broken report, not as a visitor who did the
+   * thing twice. The count above still says how often it happened.
+   */
+  conversionRate: z4.number().min(0).max(1).nullable(),
+  avgEngagementMs: z4.number().nonnegative().nullable(),
+  /** Page views per session. At or near 1 means visitors leave from the page they land on. */
+  pagesPerSession: z4.number().nonnegative().nullable()
+});
+var analyticsTrendPointSchema = z4.object({
+  /**
+   * The bucket's start, as an ISO instant.
+   *
+   * A full instant rather than a date, because a series is no longer always
+   * daily: at `hour` granularity `2026-08-22` names twenty-four points, and at
+   * `month` it names one that started three weeks earlier. It is also now
+   * timezone-aware, so the same instant is a different calendar day depending
+   * on the zone the caller asked for — which a bare `YYYY-MM-DD` cannot
+   * express without silently choosing one.
+   */
+  bucket: z4.string(),
+  visitors: z4.number().int().nonnegative(),
+  sessions: z4.number().int().nonnegative(),
+  pageViews: z4.number().int().nonnegative(),
+  conversions: z4.number().int().nonnegative()
+});
+var analyticsLandingRowSchema = z4.object({
+  /** The landing's `internalId` — the reference every event carries. */
+  landingId: z4.string(),
+  /** The Convex `landings._id`, so a dashboard can link straight to the row. */
+  landingRef: z4.string(),
+  /**
+   * What a person calls it, or `""` when the dimension has not been mirrored
+   * yet.
+   *
+   * Empty is a real and temporary state — a landing published before the
+   * mirror existed, or one whose sync has not run — and it is reported rather
+   * than papered over with the id, so a caller can say "not synced yet"
+   * instead of showing something that looks like a name and is not.
+   */
+  name: z4.string(),
+  slug: z4.string(),
+  tags: z4.array(z4.string()),
+  views: z4.number().int().nonnegative(),
+  sessions: z4.number().int().nonnegative(),
+  /** Sessions that BEGAN here — the page's Visits on screen, summing to the headline, and its rate's denominator. */
+  entrances: z4.number().int().nonnegative(),
+  visitors: z4.number().int().nonnegative(),
+  /**
+   * Conversions that fired ON this landing — rarely the number to show.
+   *
+   * A landing's outcome usually happens somewhere else: the client's checkout,
+   * their shop, a CRM days later. None of those rows carries a landing id, so
+   * this reads 0 for a page whose visits convert reliably.
+   */
+  conversions: z4.number().int().nonnegative(),
+  /** Visits that converted on this page at least once. */
+  convertingSessions: z4.number().int().nonnegative(),
+  /**
+   * Conversions this landing led to — what the page is bought for.
+   *
+   * The landing rule: a conversion on the page, or anywhere else when this was
+   * the last landing its person viewed, up to 90 days before. So it includes
+   * the sale a returning visitor made next week and the deal a CRM posted with
+   * no cookie at all, and the landings add up to the headline.
+   */
+  creditedConversions: z4.number().int().nonnegative(),
+  /** People whose conversions are credited here. */
+  creditedVisitors: z4.number().int().nonnegative(),
+  /** Visits credited at least one conversion here — the rate's numerator. */
+  creditedVisits: z4.number().int().nonnegative(),
+  outboundClicks: z4.number().int().nonnegative(),
+  /**
+   * `creditedVisits` over `entrances`, capped at 1 — the headline's converted
+   * visits over visits, for one page, so the rows add up to the headline.
+   * Null when no visit started here.
+   *
+   * Converting visits, not conversions: see {@link analyticsTotalsSchema}.
+   */
+  conversionRate: z4.number().min(0).max(1).nullable(),
+  avgEngagementMs: z4.number().nonnegative().nullable(),
+  /**
+   * Views per bucket, zero-filled against the same axis every other landing
+   * in the response uses — so the arrays are the same length and can be drawn
+   * side by side without asking what each element means.
+   */
+  sparkline: z4.array(z4.number().int().nonnegative()),
+  /**
+   * The ad platforms actually sending this page traffic — `google`, `meta`,
+   * `linkedin`, `tiktok`, `x`, `microsoft`.
+   *
+   * Derived from the click ids a visit arrived with, never from `utm_source`:
+   * a label is whatever somebody typed into a tracking template, a `gclid` is a
+   * click. Ordered by traffic, busiest first.
+   */
+  channels: z4.array(z4.string()),
+  /**
+   * Visits that started on the page, per entry of {@link channels}, in the
+   * same order — so a page's marks add up to its share of Ads → Audience.
+   *
+   * The half that makes a mark readable. A mark on its own says "advertised
+   * here", which is why it used to be withheld until three visits had arrived —
+   * and withholding it is what made a page whose whole day was five Meta clicks
+   * show nothing at all. The count says how much, so one test click and a live
+   * campaign are distinguishable by reading rather than by absence.
+   */
+  channelSessions: z4.array(z4.number().int().nonnegative())
+});
+var analyticsTagRowSchema = z4.object({
+  tag: z4.string(),
+  landings: z4.number().int().nonnegative(),
+  views: z4.number().int().nonnegative(),
+  sessions: z4.number().int().nonnegative(),
+  entrances: z4.number().int().nonnegative(),
+  conversions: z4.number().int().nonnegative(),
+  /** Visits that converted on one of this tag's pages. */
+  convertingSessions: z4.number().int().nonnegative(),
+  /** Converting visits per entrance. */
+  conversionRate: z4.number().min(0).max(1).nullable()
+});
+var ANALYTICS_EVENT_ORIGINS = ["site", "systems", "both"];
+var analyticsCustomEventRowSchema = z4.object({
+  eventName: z4.string(),
+  events: z4.number().int().nonnegative(),
+  sessions: z4.number().int().nonnegative(),
+  visitors: z4.number().int().nonnegative(),
+  /**
+   * The property keys this event carries.
+   *
+   * The keys, not the values: a caller has to know what it can break the event
+   * down BY before it can ask, and the values are unbounded where the keys are
+   * capped. This is what lets a dashboard offer the breakdown without the
+   * reader already knowing what the page chose to record.
+   */
+  propertyKeys: z4.array(z4.string()),
+  /**
+   * What these events were worth, per currency.
+   *
+   * A map and never one number, for the reason the person card's `money` is
+   * one: a name carrying 99,882.50 EUR and 1,000 USD is not worth 100,882.50
+   * of anything, and there is no rate in this product to make it so.
+   *
+   * The `''` key is a value a *page* reported — `value` with no currency,
+   * which is a score on the page's own terms rather than money. Kept rather
+   * than dropped, because for those events it is the only number there is.
+   */
+  money: z4.record(z4.string(), z4.number()).default({}),
+  landings: z4.array(z4.string()),
+  /** Which collector produced this name — and `both` when more than one did. */
+  origin: z4.enum(ANALYTICS_EVENT_ORIGINS)
+});
+var analyticsEventBreakdownRowSchema = z4.object({
+  value: z4.string(),
+  events: z4.number().int().nonnegative(),
+  sessions: z4.number().int().nonnegative(),
+  /** Per currency, exactly as {@link analyticsCustomEventRowSchema.money}. */
+  money: z4.record(z4.string(), z4.number()).default({})
+});
+var analyticsCustomFunnelStepSchema = z4.object({
+  stepIndex: z4.number().int().positive(),
+  stepName: z4.string(),
+  sessions: z4.number().int().nonnegative(),
+  /** Share of the sessions that reached the previous step. Null on the first. */
+  stepRate: z4.number().min(0).max(1).nullable(),
+  /** Share of the sessions that reached step one. Null on the first. */
+  overallRate: z4.number().min(0).max(1).nullable()
+});
+var analyticsDeviceRowSchema = z4.object({
+  /** The bucket label — `Chrome 120.0`, `iOS 17.4`, `380–767`. */
+  bucket: z4.string(),
+  sessions: z4.number().int().nonnegative(),
+  pageViews: z4.number().int().nonnegative(),
+  convertingSessions: z4.number().int().nonnegative(),
+  conversions: z4.number().int().nonnegative(),
+  /**
+   * Converting sessions over sessions.
+   *
+   * Over sessions rather than conversions over sessions, because one session
+   * can submit twice and a rate above 1 in a browser-comparison table reads as
+   * a bug in the report rather than as a visitor who filled two forms.
+   */
+  conversionRate: z4.number().min(0).max(1).nullable(),
+  avgEngagementMs: z4.number().nonnegative().nullable()
+});
+var analyticsPageRowSchema = z4.object({
+  path: z4.string(),
+  /**
+   * The landing's own `internalId`, straight out of its `_definition.md`.
+   *
+   * The path says where the page is; this says which page it is, so a number
+   * here lines up with a file the agent can open — and with the same page after
+   * it has been renamed, which the path does not. Empty for a path with no
+   * landing behind it.
+   */
+  landingId: z4.string(),
+  pageViews: z4.number().int().nonnegative(),
+  /** Sessions that began on this page — its value as a landing page. */
+  entrances: z4.number().int().nonnegative(),
+  /**
+   * Conversions that fired ON this page — "which page converts".
+   *
+   * Almost never the number to put beside Entrances. A landing page's job is to
+   * start a visit that converts, and the conversion is usually somewhere else:
+   * the shop, the checkout, a CRM a week later. Read alone this makes every
+   * landing page of a real funnel report zero.
+   */
+  conversions: z4.number().int().nonnegative(),
+  /** Visits that converted on this page at least once. */
+  convertingSessions: z4.number().int().nonnegative(),
+  /**
+   * Conversions credited to this landing page by the landing rule — on it, or
+   * anywhere when it was the last landing page its person viewed, up to 90
+   * days before. The number a landing-page table means by "conversions".
+   */
+  creditedConversions: z4.number().int().nonnegative(),
+  /** People whose conversions are credited here. */
+  creditedVisitors: z4.number().int().nonnegative(),
+  /** Credited people per entrance, 0–1. Null when nobody landed here. */
+  conversionRate: z4.number().min(0).max(1).nullable(),
+  avgEngagementMs: z4.number().nonnegative().nullable()
+});
+var analyticsSourceRowSchema = z4.object({
+  source: z4.string(),
+  medium: z4.string(),
+  sessions: z4.number().int().nonnegative(),
+  conversions: z4.number().int().nonnegative(),
+  conversionRate: z4.number().min(0).max(1).nullable()
+});
+var analyticsCampaignRowSchema = z4.object({
+  utmSource: z4.string(),
+  utmMedium: z4.string(),
+  utmCampaign: z4.string(),
+  /**
+   * The platform a click id proves, or `""` when the visit carried none.
+   *
+   * What separates a campaign the ad breakdown already reports — with its
+   * platform proven and its ad set and ad underneath — from one nothing else
+   * can show: the newsletter, the partner link, the hand-tagged post. The two
+   * are otherwise identical, because `utm_campaign={campaignid}` is the normal
+   * tagging convention and produces the same ids in both places.
+   *
+   * Kept on the row rather than filtered out here: a CLI hint reads an empty
+   * campaign list as "no campaign tagging on any traffic", and dropping the
+   * paid ones would make that fire on a perfectly tagged account.
+   */
+  clickPlatform: z4.string(),
+  sessions: z4.number().int().nonnegative(),
+  conversions: z4.number().int().nonnegative(),
+  conversionRate: z4.number().min(0).max(1).nullable()
+});
+var analyticsRealtimeMinuteSchema = z4.object({
+  /** The minute, as an ISO instant. */
+  minute: z4.string(),
+  visitors: z4.number().int().nonnegative(),
+  pageViews: z4.number().int().nonnegative()
+});
+var analyticsRealtimePageSchema = z4.object({
+  path: z4.string(),
+  /** The landing this path belongs to; empty when no landing claims it. */
+  landingId: z4.string(),
+  visitors: z4.number().int().nonnegative()
+});
+var analyticsRealtimeSchema = z4.object({
+  /** Distinct visitors with any activity inside the active window. */
+  activeNow: z4.number().int().nonnegative(),
+  /** How recently a visitor must have acted to be counted, in minutes. */
+  activeWithinMinutes: z4.number().int().positive(),
+  minutes: z4.array(analyticsRealtimeMinuteSchema),
+  pages: z4.array(analyticsRealtimePageSchema)
+});
+var analyticsDimensionRowSchema = z4.object({
+  key: z4.string(),
+  sessions: z4.number().int().nonnegative(),
+  conversions: z4.number().int().nonnegative(),
+  conversionRate: z4.number().min(0).max(1).nullable()
+});
+var analyticsFunnelStepSchema = z4.object({
+  stepId: z4.string(),
+  stepIndex: z4.number().int().nonnegative(),
+  /** Visits that moved forward into this step. Never events — see `visits`. */
+  views: z4.number().int().nonnegative(),
+  /** Visits that finished this step and moved on. */
+  completions: z4.number().int().nonnegative(),
+  /** Share of viewers who did not complete this step, 0–1. */
+  dropRate: z4.number().min(0).max(1).nullable(),
+  /**
+   * Visits that converted AT this step — the node kind's own outcome trigger
+   * fired here, or the Form was submitted here.
+   *
+   * Usually zero on every step but one. That is the point: a Form has one
+   * conversion, and knowing which step owns it is what stops a drop-off chart
+   * treating the booking widget's "profile viewed" as a funnel stage.
+   */
+  convertedSessions: z4.number().int().nonnegative(),
+  /**
+   * This step is where the Form ends — a confirmation screen, not a loss.
+   *
+   * Stated rather than left to be inferred. The dashboard used to read it off
+   * `dropRate === null`, which is also how a step nobody viewed arrives, so a
+   * converting link node in the middle of a Form was labelled its ending.
+   */
+  isEnding: z4.boolean()
+});
+var analyticsFunnelSchema = z4.object({
+  flowSlug: z4.string(),
+  /**
+   * Visits that saw the Form at all — the denominator for every share here.
+   *
+   * Read this, not `starts`, whenever the question is "out of how many". A
+   * start is recorded at the visitor's FIRST INTERACTION, so the two differ by
+   * exactly the people who looked at the Form and never touched it — usually
+   * most of them, and always the group a drop-off chart exists to find.
+   *
+   * Every count in this object is distinct visits, including each step's
+   * `views` and `completions`. That is load-bearing rather than incidental:
+   * the screen divides these by each other, and while the steps counted events
+   * a Form four people had opened reported one step reached fifteen times and
+   * fourteen people lost.
+   */
+  visits: z4.number().int().nonnegative(),
+  /** Visits that interacted with the Form at all — typed, picked, or advanced. */
+  starts: z4.number().int().nonnegative(),
+  submits: z4.number().int().nonnegative(),
+  /** Conversions per visit that opened the Form, 0–1. */
+  completionRate: z4.number().min(0).max(1).nullable(),
+  /** The step losing the most people. The single most useful field here. */
+  worstStep: analyticsFunnelStepSchema.nullable(),
+  steps: z4.array(analyticsFunnelStepSchema),
+  /**
+   * Visits that converted, counted once each at whichever node did it.
+   *
+   * Read this rather than `submits` whenever the two disagree. `submits` only
+   * fires when a flow runs out of nodes, so a Form that books a call on a
+   * mid-flow Calendly node reports zero submits and every one of its real
+   * bookings here.
+   */
+  convertedSessions: z4.number().int().nonnegative()
+});
+var analyticsPaidRowSchema = z4.object({
+  source: z4.string(),
+  medium: z4.string(),
+  campaign: z4.string(),
+  content: z4.string(),
+  term: z4.string(),
+  /** `google` | `meta` | `tiktok` | `x` | `linkedin` | `microsoft` | `""`. */
+  clickPlatform: z4.string(),
+  sessions: z4.number().int().nonnegative(),
+  convertingSessions: z4.number().int().nonnegative(),
+  conversions: z4.number().int().nonnegative(),
+  /** Leads whose server-side delivery reported success. */
+  delivered: z4.number().int().nonnegative(),
+  /** Leads whose delivery reported failure. Non-zero here is a broken integration. */
+  failedDeliveries: z4.number().int().nonnegative(),
+  /** Distinct people, across devices — only countable where visitors identified themselves. */
+  identifiedPeople: z4.number().int().nonnegative(),
+  /** Converting sessions per session, 0–1. */
+  conversionRate: z4.number().min(0).max(1).nullable(),
+  /** Delivered leads per conversion, 0–1. Below 1 means leads are being lost after submit. */
+  deliveryRate: z4.number().min(0).max(1).nullable()
+});
+var analyticsDeliveryRowSchema = z4.object({
+  eventId: z4.string(),
+  submittedAt: z4.string(),
+  /**
+   * The visit the submission was made in, so a lead can be opened as a story.
+   *
+   * The whole reason a delivery row is worth clicking. Without it a submission
+   * is a timestamp and a CRM outcome, and the questions anybody actually has —
+   * which ad brought them, what they read first, how long they took — are all
+   * on the other side of this one join.
+   */
+  sessionId: z4.string(),
+  /** Lowercase hex digest of who submitted, when the page could identify them. */
+  identityHash: z4.string(),
+  flowSlug: z4.string(),
+  stepId: z4.string(),
+  landingId: z4.string(),
+  destinations: z4.array(z4.string()),
+  dispatched: z4.number().int().nonnegative(),
+  succeeded: z4.number().int().nonnegative(),
+  failed: z4.number().int().nonnegative(),
+  /** Dispatched and never settled. Distinguishing this from failed is "wait" vs "act". */
+  pending: z4.number().int().nonnegative(),
+  /**
+   * The ids the destinations gave back.
+   *
+   * A submission that succeeded everywhere and carries none of these is a real
+   * and previously invisible failure: the integration accepted the call and
+   * dropped the record.
+   */
+  providerRefs: z4.array(z4.string()),
+  sampleError: z4.string()
+});
+var analyticsTriggerRowSchema = z4.object({
+  flowSlug: z4.string(),
+  /** `link`, `customForm`, `iframe`, `hubspotMeeting`, … */
+  nodeType: z4.string(),
+  /** The trigger, verbatim: `link.onClick`, `iframe.checkout_completed`. */
+  triggerId: z4.string(),
+  fires: z4.number().int().nonnegative(),
+  sessions: z4.number().int().nonnegative(),
+  /** How many of those fires produced a side effect. Often zero, on purpose. */
+  sideEffectsFired: z4.number().int().nonnegative()
+});
+var analyticsReleaseRowSchema = z4.object({
+  /** The commit the build came from. */
+  release: z4.string(),
+  firstSeen: z4.string(),
+  lastSeen: z4.string(),
+  sessions: z4.number().int().nonnegative(),
+  pageViews: z4.number().int().nonnegative(),
+  conversions: z4.number().int().nonnegative(),
+  /** Visits that converted on this build at least once. */
+  convertingSessions: z4.number().int().nonnegative(),
+  /** Converting visits per session, 0–1. Null below a usable sample. */
+  conversionRate: z4.number().min(0).max(1).nullable()
+});
+var analyticsGeoRowSchema = z4.object({
+  /** The place itself, at whatever grain was asked for. */
+  place: z4.string(),
+  /** Always carried: a postcode without its country is ambiguous, a city twice over. */
+  country: z4.string(),
+  region: z4.string(),
+  sessions: z4.number().int().nonnegative(),
+  conversions: z4.number().int().nonnegative(),
+  /** Conversions per session, 0–1. Null below a usable sample. */
+  conversionRate: z4.number().min(0).max(1).nullable(),
+  /** People rather than browsers, where the visit identified itself. */
+  identifiedPeople: z4.number().int().nonnegative()
+});
+var analyticsBotRowSchema = z4.object({
+  /** The crawler's name, or `unidentified` for a machine we could not name. */
+  bot: z4.string(),
+  /** `search` | `ai` | `social` | `seo` | `monitoring` | `tool` | `automation`. */
+  category: z4.string(),
+  hits: z4.number().int().nonnegative(),
+  pages: z4.number().int().nonnegative(),
+  lastSeen: z4.string(),
+  samplePaths: z4.array(z4.string())
+});
+var analyticsHiddenMachinesSchema = z4.object({
+  events: z4.number().int().nonnegative(),
+  /** Which signal decided, most first: `ua` is a browser that said it is headless. */
+  reasons: z4.array(
+    z4.object({
+      reason: z4.string(),
+      events: z4.number().int().nonnegative(),
+      lastSeen: z4.string()
+    })
+  )
+});
+var analyticsVisitorCompanyRowSchema = z4.object({
+  /** The network's registered name, as Cloudflare reports it. */
+  name: z4.string(),
+  /** Null in v1 — Cloudflare names a network, never its website. */
+  domain: z4.string().nullable(),
+  /** `high`: the name reads as an organisation. `low`: it only cleared the ISP/cloud/VPN deny-list. */
+  confidence: z4.enum(["high", "low"]),
+  visits: z4.number().int().nonnegative(),
+  pageViews: z4.number().int().nonnegative(),
+  /** Distinct pages read. */
+  pages: z4.number().int().nonnegative(),
+  /** Up to ten of them. */
+  topPages: z4.array(z4.string()),
+  firstSeen: z4.string(),
+  lastSeen: z4.string()
+});
+var analyticsWarningSchema = z4.object({
+  /**
+   * `AD_ROLE_UNMAPPED` is the one that reports a *question* rather than the
+   * data. A role resolves to the parameter names that carry it, and when a
+   * company has mapped none the list is empty — which the filter reads as
+   * "arrived carrying none of these" and answers with a confident zero across
+   * the whole report. Zero is a far more expensive conclusion than "nobody has
+   * said which parameter that is", so the narrowing is dropped and this says so.
+   */
+  code: z4.enum(["LOW_SAMPLE", "NO_DATA", "BEYOND_RETENTION", "AD_ROLE_UNMAPPED"]),
+  message: z4.string()
+});
+var analyticsFlowSummarySchema = z4.object({
+  flowSlug: z4.string(),
+  sessions: z4.number().int().nonnegative(),
+  starts: z4.number().int().nonnegative(),
+  convertedSessions: z4.number().int().nonnegative(),
+  submits: z4.number().int().nonnegative(),
+  stepViews: z4.number().int().nonnegative(),
+  /** Distinct steps anyone reached, across all visits. */
+  stepsSeen: z4.number().int().nonnegative(),
+  deepestStepIndex: z4.number().int().nonnegative(),
+  /** Steps reached per visit, averaged — "how much of this Form do people read". */
+  avgStepsReached: z4.number().nonnegative(),
+  /** Conversions per visit that started, 0–1. */
+  conversionRate: z4.number().min(0).max(1).nullable(),
+  /** Which node ids produced the conversions. Usually one; two means two offers. */
+  conversionSteps: z4.array(z4.string()),
+  /** And by what — `calendlyEvent.eventScheduled`, `customForm.onFormSubmitted`. */
+  conversionTriggers: z4.array(z4.string()),
+  conversionNodeTypes: z4.array(z4.string()),
+  lastSeen: z4.string()
+});
+var analyticsFlowEdgeSchema = z4.object({
+  flowSlug: z4.string(),
+  fromStep: z4.string(),
+  toStep: z4.string(),
+  sessions: z4.number().int().nonnegative()
+});
+var analyticsConversionRowSchema = z4.object({
+  /** What a person calls this outcome. */
+  name: z4.string(),
+  /** Every event counted under this name. One entry unless the name is shared. */
+  eventKeys: z4.array(z4.string()),
+  /**
+   * `once_per_visit` | `every_time` — how repeats inside one visit are counted.
+   *
+   * `mixed` when a shared name spans both, which is a real state and an editing
+   * accident; saying so is what makes it findable.
+   */
+  countMode: z4.string(),
+  /** Counted the way each definition asked to be counted, and credited to a landing. */
+  conversions: z4.number(),
+  /**
+   * Times it happened that no landing earned: by people none of the company's
+   * pages saw, within 90 days. Zero under a landing or an ad scope, where the
+   * gap would mean something else. Absent on a row built before it existed.
+   */
+  unplaced: z4.number().default(0),
+  /** Distinct visits that produced it, never mode-adjusted. The gap between the two is the repeat behaviour. */
+  convertingVisits: z4.number(),
+  /** Null when it has never fired. */
+  lastSeen: z4.string().nullable(),
+  /**
+   * The doors its events came in by in the window, in
+   * {@link ANALYTICS_EVENT_DOORS} order. Empty when it has not fired.
+   */
+  doors: z4.array(z4.enum(ANALYTICS_EVENT_DOORS)).default([]),
+  /** Proposed in this chat: counted from when it is published, so every report reads it as nothing until then. */
+  staged: z4.boolean().optional()
+});
+var analyticsEventCatalogRowSchema = z4.object({
+  /** `form:…` | `submit:…` | `page:…` | `exit:…` — parse with `parseEventKey`. */
+  eventKey: z4.string(),
+  /**
+   * Which collector produced this key — and `both` when more than one did.
+   *
+   * On the row rather than in the key, which is the whole shape of the change
+   * that removed the `server:` family: a picker can say where an event came
+   * from without a filter round-trip, and a report can still separate the two
+   * populations at any grain, but nothing downstream has to learn a second
+   * vocabulary to count one.
+   */
+  origin: z4.enum(ANALYTICS_EVENT_ORIGINS),
+  events: z4.number(),
+  sessions: z4.number(),
+  /** The Form node's kind, for a `form:` key. Empty otherwise. */
+  nodeType: z4.string(),
+  /** The Form this happened in, for a `form:` or `submit:` key. Empty otherwise. */
+  flowSlug: z4.string(),
+  /** Null when it has never fired — only possible for a row we already count. */
+  lastSeen: z4.string().nullable(),
+  /** Already counted as a conversion. Shown, never hidden: a row that vanished on being counted reads as a bug. */
+  isCounted: z4.boolean(),
+  /** The name it is counted under, when it is. */
+  countedAs: z4.string(),
+  /**
+   * The doors on Sources this key's events came through, by name — the
+   * `baker_source` each event carries. Empty for a key nothing on Sources
+   * sent; more than one when two doors used one name.
+   */
+  sources: z4.array(z4.string()),
+  /**
+   * The doors this key's events came in by, in {@link ANALYTICS_EVENT_DOORS}
+   * order, each with its own volume — only the doors it actually used.
+   *
+   * `origin` says site or systems; this says which of the four, which is the
+   * question every picker is read to answer. Defaulted, so a store that
+   * predates the column parses as "no door known" rather than failing.
+   */
+  doors: z4.array(z4.object({ door: z4.enum(ANALYTICS_EVENT_DOORS), events: z4.number(), sessions: z4.number() })).default([])
+});
+var analyticsAdDimensionRowSchema = z4.object({
+  /** The dimension's value. Empty means "arrived carrying none of these". */
+  value: z4.string(),
+  /** Which platform stamped the click, from the click id rather than a label. */
+  platform: z4.string(),
+  sessions: z4.number(),
+  convertingSessions: z4.number(),
+  conversions: z4.number(),
+  bouncedSessions: z4.number(),
+  identifiedPeople: z4.number(),
+  pageViews: z4.number(),
+  engagementMs: z4.number(),
+  /** Conversions per session, or null when nothing arrived. */
+  conversionRate: z4.number().nullable(),
+  /** Bounces per session, or null when nothing arrived. */
+  bounceRate: z4.number().nullable()
+});
+var analyticsAdParamRowSchema = z4.object({
+  name: z4.string(),
+  /** Whether the value is stored, or only the fact that the name appeared. */
+  captured: z4.boolean(),
+  /** The role in force for the platform asked about, built-in or configured. */
+  role: adParamRoleSchema.optional(),
+  /**
+   * True when this company said what it means, rather than Baker knowing it.
+   *
+   * The difference between a row that can be reset to a sensible default and
+   * one where clearing it means "nobody has said".
+   */
+  configured: z4.boolean(),
+  /**
+   * Visits carrying this parameter **that arrived from the platform asked
+   * about**, not visits carrying it anywhere.
+   *
+   * This used to be the second: one inventory of every parameter on every
+   * visit, shown identically under each platform tab. That is wrong on the
+   * facts, and confidently so. A visit arrives from one platform — it has one
+   * click id — so `gclid` traffic cannot also be Meta traffic, and a Meta tab
+   * listing `gad_campaignid` on 1,204 visits invited somebody to name a Google
+   * parameter in Meta's vocabulary and then wonder why no report ever used it.
+   * The count belongs to the platform or it is not a count of anything.
+   */
+  sessions: z4.number(),
+  events: z4.number(),
+  /** Up to five distinct values. Always empty for an uncaptured parameter. */
+  sampleValues: z4.array(z4.string()),
+  lastSeen: z4.string().optional(),
+  /**
+   * True when this row is here because somebody configured it, not because it
+   * arrived.
+   *
+   * The row a mapping made before its first click. A tracking setup is
+   * routinely written the week before the campaign runs, and a tool that can
+   * only describe traffic it has already seen cannot be used at the one moment
+   * somebody sits down to do this properly. Such a row has no visits and no
+   * values, and says so rather than reading as a parameter that stopped
+   * arriving.
+   */
+  awaitingTraffic: z4.boolean().optional()
+});
+var analyticsFlowDestinationsSchema = z4.object({
+  flowSlug: z4.string(),
+  /** Destination types seen — `meta`, `httpWebhook`, `hubspotForm`. */
+  destinations: z4.array(z4.string()),
+  lastSeen: z4.string().optional()
+});
+var analyticsAdPlatformTrafficSchema = z4.object({
+  platform: z4.string(),
+  sessions: z4.number(),
+  conversions: z4.number(),
+  /** How many of those visits carried any campaign parameter at all. */
+  taggedSessions: z4.number()
+});
+var analyticsPageInfoSchema = z4.object({
+  /** Which field of the response was paged. */
+  block: z4.enum(["visitors", "submissions", "deliveries", "stream"]),
+  page: z4.number().int(),
+  pageSize: z4.number().int(),
+  returned: z4.number().int(),
+  hasMore: z4.boolean()
+});
+var analyticsTimelineRowSchema = z4.object({
+  timestamp: z4.string(),
+  /**
+   * The visit this event belongs to, and the browser that made it.
+   *
+   * Empty on anything that belongs to neither — a settlement, and an event a
+   * client's own server posted about somebody who was never on a page. Carried
+   * because the raw feed (`stream`) is a company-wide list rather than one
+   * visit's, so a row has to say who it was about before a reader can get from
+   * it to the person. On a replay both are constant and simply confirm it.
+   */
+  sessionId: z4.string(),
+  anonId: z4.string(),
+  /**
+   * Where the producer put this event in its own order, from 1. `0` means it
+   * did not number this one.
+   *
+   * The tie-break that makes the replay a replay. The timestamp is
+   * milliseconds and the Form engine emits several events in one synchronous
+   * block, so a step completing, the identities it revealed and the next step
+   * coming into view routinely share one — and sorted on the timestamp alone
+   * they came back in an order that matched nothing that happened.
+   */
+  eventSeq: z4.number().int().nonnegative(),
+  /** This event's identity, so two rows can be said to be the same event. */
+  eventUid: z4.string(),
+  /** `page_view`, `form_step_view`, `side_effect_dispatched`, … */
+  eventType: z4.string(),
+  /** `edge`, `beacon`, `server` — where the row was written from. */
+  source: z4.string(),
+  /**
+   * `baker`, `external`, `export` — where the page was, which `source` does
+   * not say. The two together are what decide the row's door; see
+   * `ANALYTICS_EVENT_DOORS`.
+   *
+   * Defaulted rather than required: the column arrived after the corpus did
+   * and carries no default of its own, so a row older than it reads `""`, and
+   * that has to mean "Baker's, as everything was then" rather than fail the
+   * whole row's parse.
+   */
+  deployment: z4.string().default(""),
+  environment: z4.string(),
+  /** The build the page was published from. */
+  release: z4.string(),
+  path: z4.string(),
+  host: z4.string(),
+  landingId: z4.string(),
+  flowSlug: z4.string(),
+  stepId: z4.string(),
+  stepIndex: z4.number().int().nonnegative(),
+  nodeType: z4.string(),
+  triggerId: z4.string(),
+  /** A page-defined event's own name, when this row is one. */
+  eventName: z4.string(),
+  /** Whatever the page attached to a custom event. Strings only, by design. */
+  properties: z4.record(z4.string(), z4.string()),
+  /** Where an outbound click or a link node was going, in full. */
+  targetUrl: z4.string(),
+  /** A number the page reported alongside the event. */
+  value: z4.number(),
+  /**
+   * The currency that number is in, when it has one.
+   *
+   * Only a server-sent event carries it — a page reports a `value` on its own
+   * terms, a CRM reports a deal in euros — and without it the replay prints a
+   * bare `4200.5` beside a closed deal, which is a number nobody can act on.
+   */
+  valueCurrency: z4.string().default(""),
+  /** The visitor's digest, when they had identified themselves by this point. */
+  identityHash: z4.string(),
+  /**
+   * The browser to attribute this row to, once the identity has been resolved.
+   *
+   * `anonId` when the row has one, and otherwise the browser {@link identityHash}
+   * resolves to through `identities`. Empty when neither exists.
+   *
+   * It is a separate field rather than a coalesce into `anonId` because the two
+   * claims are not the same: `anonId` is the cookie the row was written with,
+   * and a server-sent event was written with none and must not start claiming
+   * one. This is the *read's* answer to "who was that", and it is retroactive
+   * and cross-device by construction — a "Deal won" posted in March attaches to
+   * the person the moment they type that address into a Form in April, and to
+   * every browser they have used here.
+   *
+   * Only `event_stream` fills it. Empty everywhere else, which is honest: a
+   * session replay deliberately does not resolve, because an event that
+   * happened during no visit must not be placed inside one.
+   */
+  personAnonId: z4.string().default(""),
+  /**
+   * What this row knows the person by, when it does not know their browser:
+   * `email` | `phone` | `external` | `click` | `cookie`, or empty.
+   *
+   * The feed's Who column reads it. A row naming a person by a means that has
+   * no face here yet — a digest nobody has typed into a Form, an ad click, one
+   * of Meta's cookies — is not a row about nobody, and rendering it as one is
+   * what made the server-sent half of the feed look unattached to the rest.
+   */
+  knownBy: z4.string().default(""),
+  /**
+   * What this row counts as under the company's own conversion definitions, or
+   * empty when it counts as nothing.
+   *
+   * The store's own key, projected rather than rebuilt here, so the feed and
+   * the reports cannot disagree about what one event was. Two rows carrying the
+   * same non-empty key are **one** conversion — the second is stored, listed,
+   * and marked as already counted rather than hidden, because a sender who
+   * posted a deal twice needs to see that the second request arrived.
+   *
+   * Only `event_stream` fills it; empty everywhere else.
+   */
+  conversionKey: z4.string().default(""),
+  /** Which signal took this row for a machine (`ua`, `datacenter`, …). Empty on every human row. */
+  botReason: z4.string().optional(),
+  /**
+   * The browser, OS, device and country the row came from. Only the feed fills
+   * them: how somebody who just tested a page finds their own visit on it
+   * without having typed an email.
+   */
+  browser: z4.string().optional(),
+  os: z4.string().optional(),
+  deviceType: z4.string().optional(),
+  country: z4.string().optional(),
+  /**
+   * Which lines of a people search this row belongs to, by position in
+   * `peopleSearch`. Empty when nobody was searched for.
+   */
+  personTerms: z4.array(z4.number()).optional(),
+  /**
+   * `email` | `phone` — which of the two they gave.
+   *
+   * Load-bearing rather than trivia: a visitor who fills in both fields
+   * produces two `identify` rows in the same millisecond, and without the kind
+   * a replay renders the same sentence twice and reads as a duplicated event.
+   */
+  identityKind: z4.string(),
+  /**
+   * The `user_data` block this event carried, exactly as it arrived.
+   *
+   * The contact digests (`email_sha256`, `phone_sha256`, `external_id_sha256`),
+   * the click ids, Meta's cookies, and the advanced-matching /
+   * enhanced-conversions fields — first name, city, postcode, country. Empty on
+   * everything a page produced, which is most rows.
+   *
+   * **Per event, and deliberately not merged** — unlike the person card, which
+   * merges the same fields newest-wins across everything anyone ever sent. The
+   * question one event answers is "what did *this request* contain", and the
+   * answer has to be allowed to be *worse* than what is known about the person
+   * overall. That is how a sender finds the field they forgot to map: the
+   * person has a postcode, and this event does not.
+   */
+  userData: z4.record(z4.string(), z4.string()).default({}),
+  sideEffectType: z4.string(),
+  sideEffectName: z4.string(),
+  sideEffectId: z4.string(),
+  tagId: z4.string(),
+  messageId: z4.string(),
+  /**
+   * The submission this row belongs to.
+   *
+   * What ties a browser pixel and a server dispatch of the SAME submit
+   * together. Without it they read as two unrelated things that happened to
+   * occur in the same second.
+   */
+  eventId: z4.string(),
+  runId: z4.string(),
+  engagementMs: z4.number().int().nonnegative(),
+  scrollDepth: z4.number().int().nonnegative(),
+  /**
+   * The A/B test this row was stamped into, and which side the edge served —
+   * `a` for the page as it is, `b` for the new variant.
+   *
+   * Set only on rows a page under test produced, which is how a person's story
+   * can say which version they were shown. Empty on a server-sent row: a CRM
+   * knows nothing about the split, and the conversion it posts is attributed
+   * to a side by WHO did it (see `experiment_conversions`), never by a stamp.
+   */
+  experimentId: z4.string().default(""),
+  variant: z4.string().default(""),
+  /** `success` | `failed` | `""` for a dispatch that has not settled yet. */
+  outcome: z4.string(),
+  /** What the destination said when it refused. Empty on success. */
+  error: z4.string(),
+  /** The destination's own id for the record it created, when it gave one. */
+  providerRef: z4.string(),
+  /** When the destination answered, so "it took eleven seconds" is sayable. */
+  settledAt: z4.string()
+});
+var analyticsSubmissionRowSchema = z4.object({
+  sessionId: z4.string(),
+  flowSlug: z4.string(),
+  startedAt: z4.string(),
+  lastAt: z4.string(),
+  anonId: z4.string(),
+  identityHash: z4.string(),
+  identityKind: z4.string(),
+  landingId: z4.string(),
+  path: z4.string(),
+  /** Steps they saw. The denominator for "how far did they get". */
+  stepsReached: z4.number().int().nonnegative(),
+  /** Steps they actually handed something over on. Zero means no attempt. */
+  stepsSubmitted: z4.number().int().nonnegative(),
+  submittedStepIds: z4.array(z4.string()),
+  /** The furthest step they reached, for naming where they stopped. */
+  lastStepId: z4.string(),
+  /** Whether the Form reached an ending, by any of its three routes. */
+  finished: z4.boolean(),
+  conversions: z4.number().int().nonnegative(),
+  destinations: z4.array(z4.string()),
+  /** Destinations that fired as a pixel in the page. */
+  browserDestinations: z4.array(z4.string()),
+  /** Destinations Baker dispatched from the server. */
+  serverDestinations: z4.array(z4.string()),
+  /**
+   * Server-side dispatch runs — the counterpart of `serverDestinations`, NOT of
+   * `destinations`.
+   *
+   * Zero is not "this went nowhere", and reading it that way is a mistake
+   * already made once: it is zero for an attempt abandoned before the step that
+   * fires a destination, and zero for a Form whose only destination is a
+   * browser pixel. `destinations` is the union of both sides and is the column
+   * that answers "did this reach anything at all".
+   */
+  dispatched: z4.number().int().nonnegative(),
+  succeeded: z4.number().int().nonnegative(),
+  failed: z4.number().int().nonnegative(),
+  /** Dispatched and never settled — "wait", as against "act". */
+  pending: z4.number().int().nonnegative(),
+  sampleError: z4.string(),
+  providerRefs: z4.array(z4.string()),
+  /** The submission ids, which is how the panel opens the sealed payload. */
+  eventIds: z4.array(z4.string())
+});
+var analyticsVisitorSessionSchema = z4.object({
+  sessionId: z4.string(),
+  startedAt: z4.string(),
+  endedAt: z4.string(),
+  entryPath: z4.string(),
+  entryLandingId: z4.string(),
+  utmCampaign: z4.string(),
+  referrerSource: z4.string(),
+  deviceType: z4.string(),
+  pageViews: z4.number().int().nonnegative(),
+  conversions: z4.number().int().nonnegative(),
+  /**
+   * True for the visits made BEFORE we knew who this was.
+   *
+   * Shown rather than smoothed over: a history without it invites the reading
+   * that we recognised them all along, when in fact these visits were only
+   * attributed backwards through the browser after they identified themselves.
+   */
+  wasAnonymous: z4.boolean(),
+  engagementMs: z4.number().int().nonnegative()
+});
+var analyticsVisitProfileSchema = z4.object({
+  sessionId: z4.string(),
+  startedAt: z4.string(),
+  endedAt: z4.string(),
+  entryPath: z4.string(),
+  entryLandingId: z4.string(),
+  country: z4.string(),
+  region: z4.string(),
+  city: z4.string(),
+  timezone: z4.string(),
+  /** The network the visit came from. What separates a datacentre from a person. */
+  asOrganization: z4.string(),
+  deviceType: z4.string(),
+  browser: z4.string(),
+  os: z4.string(),
+  referrerSource: z4.string(),
+  referrerDomain: z4.string(),
+  utmSource: z4.string(),
+  utmMedium: z4.string(),
+  utmCampaign: z4.string(),
+  /**
+   * Which platform the click id proves, in the `AD_PLATFORMS` vocabulary —
+   * `google` | `meta` | `tiktok` | `x` | `linkedin` | `microsoft` | `""`.
+   *
+   * The same spelling every mark, mapping and report uses. It briefly said
+   * `google_ads` / `meta_ads` here alone, which meant every logo lookup on the
+   * People screen missed and a paid visit drew a neutral globe.
+   */
+  clickPlatform: z4.string(),
+  /** Every ValueTrack-style parameter the URL carried, unresolved. */
+  campaignParams: z4.record(z4.string(), z4.string()),
+  /** The browser's own cookie id. One person can have several. */
+  anonId: z4.string(),
+  identityHash: z4.string(),
+  /** What the digest was made of — `email`, `phone`. Never the value. */
+  identityKind: z4.string(),
+  pageViews: z4.number().int().nonnegative(),
+  conversions: z4.number().int().nonnegative(),
+  engagementMs: z4.number().int().nonnegative()
+});
+var analyticsPersonKeySchema = z4.object({
+  /** `email` | `phone` | `external` | `browser` | a click-id name | `fbp` | `fbc`. */
+  kind: z4.string(),
+  /** A digest for a contact detail, the value itself for a cookie or a click id. */
+  value: z4.string(),
+  firstSeen: z4.string(),
+  lastSeen: z4.string(),
+  /** How many times it was observed beside another key — every submission repeats it. */
+  observations: z4.number().int().nonnegative(),
+  sessions: z4.number().int().nonnegative(),
+  /** `client` | `edge` | `server` | `ingest` — which collector first saw it. */
+  source: z4.string(),
+  /** The Form it was first seen on, where it came from one. */
+  flowSlug: z4.string(),
+  landingId: z4.string()
+});
+var analyticsPersonProfileSchema = z4.object({
+  firstSeen: z4.string(),
+  lastSeen: z4.string(),
+  sessions: z4.number().int().nonnegative(),
+  /** How many browsers resolved to this person. More than one is cross-device. */
+  devices: z4.number().int().nonnegative(),
+  pageViews: z4.number().int().nonnegative(),
+  conversions: z4.number().int().nonnegative(),
+  /**
+   * What they are worth, per currency — `{ EUR: 4753 }`.
+   *
+   * A map rather than an amount and a code, because the two-column shape had
+   * no honest answer for somebody with a deal in each of two currencies: it
+   * summed them and labelled the total with whichever code came back first.
+   * Only a server event ever carries money, and a retried post is counted
+   * once, on `event_uid`.
+   */
+  money: z4.record(z4.string(), z4.number()),
+  engagementMs: z4.number().int().nonnegative(),
+  /** How many of their events a client's own server posted. */
+  serverEvents: z4.number().int().nonnegative(),
+  country: z4.string(),
+  region: z4.string(),
+  city: z4.string(),
+  deviceType: z4.string(),
+  browser: z4.string(),
+  os: z4.string(),
+  utmSource: z4.string(),
+  utmMedium: z4.string(),
+  utmCampaign: z4.string(),
+  referrerSource: z4.string(),
+  entryLandingId: z4.string(),
+  entryPath: z4.string(),
+  /**
+   * The customer-matching block, merged newest-wins across everything anyone
+   * has ever told us about them — `city`, `postal_code`, `country`,
+   * `first_name_sha256`, `fbp`. Keyed exactly as the store holds it, so a key
+   * ending `_sha256` says its value is a digest and cannot be shown.
+   */
+  matchKeys: z4.record(z4.string(), z4.string())
+});
+var analyticsVisitorRowSchema = z4.object({
+  anonId: z4.string(),
+  firstSeen: z4.string(),
+  lastSeen: z4.string(),
+  sessions: z4.number().int().nonnegative(),
+  pageViews: z4.number().int().nonnegative(),
+  conversions: z4.number().int().nonnegative(),
+  formTriggers: z4.number().int().nonnegative(),
+  outboundClicks: z4.number().int().nonnegative(),
+  engagementMs: z4.number().int().nonnegative(),
+  /** The visit to open by default — the most recent one. */
+  lastSessionId: z4.string(),
+  entryPath: z4.string(),
+  entryLandingId: z4.string(),
+  lastPath: z4.string(),
+  referrerSource: z4.string(),
+  referrerDomain: z4.string(),
+  utmSource: z4.string(),
+  utmMedium: z4.string(),
+  utmCampaign: z4.string(),
+  clickPlatform: z4.string(),
+  campaignParams: z4.record(z4.string(), z4.string()),
+  /**
+   * The click ids this person arrived on, by their own names — `gclid`,
+   * `fbclid`, `msclkid`, `li_fat_id`, `ttclid`, `twclid`, `wbraid`, `gbraid`,
+   * `dclid`, `rdt_cid`, `epik`, `sccid`, `oppref`.
+   *
+   * Only the ones that were present. The endpoint has always returned all eight
+   * columns and nothing above it carried them, so the one screen whose subject
+   * is a person could name the platform that paid for the click and not the
+   * click — which is the value a platform's own reporting is matched on, and
+   * therefore the value somebody is looking for when a conversion did not show
+   * up on the other side.
+   */
+  clickIds: z4.record(z4.string(), z4.string()),
+  country: z4.string(),
+  region: z4.string(),
+  city: z4.string(),
+  timezone: z4.string(),
+  asOrganization: z4.string(),
+  deviceType: z4.string(),
+  browser: z4.string(),
+  os: z4.string(),
+  identityHash: z4.string(),
+  identityKind: z4.string()
+});
+var analyticsMeasureScopeSchema = z4.object({
+  scope: z4.enum(["campaigns", "outcomes", "all", "unknown"]),
+  /** Every event the tag on the client's own site sent in this window. */
+  websiteEvents: z4.number(),
+  /** Browser ids it minted off-Baker. Any at all means the tag is on `all`. */
+  websiteNewVisitors: z4.number()
+});
+var analyticsQueryDataSchema = z4.object({
+  preset: analyticsPresetSchema,
+  window: analyticsWindowSchema,
+  totals: analyticsTotalsSchema,
+  trend: z4.array(analyticsTrendPointSchema).optional(),
+  topPages: z4.array(analyticsPageRowSchema).optional(),
+  topSources: z4.array(analyticsSourceRowSchema).optional(),
+  topCampaigns: z4.array(analyticsCampaignRowSchema).optional(),
+  countries: z4.array(analyticsDimensionRowSchema).optional(),
+  devices: z4.array(analyticsDimensionRowSchema).optional(),
+  funnels: z4.array(analyticsFunnelSchema).optional(),
+  flowSummary: z4.array(analyticsFlowSummarySchema).optional(),
+  flowPaths: z4.array(analyticsFlowEdgeSchema).optional(),
+  triggers: z4.array(analyticsTriggerRowSchema).optional(),
+  releases: z4.array(analyticsReleaseRowSchema).optional(),
+  paid: z4.array(analyticsPaidRowSchema).optional(),
+  measureScope: analyticsMeasureScopeSchema.optional(),
+  deliveries: z4.array(analyticsDeliveryRowSchema).optional(),
+  submissions: z4.array(analyticsSubmissionRowSchema).optional(),
+  geo: z4.array(analyticsGeoRowSchema).optional(),
+  bots: z4.array(analyticsBotRowSchema).optional(),
+  visitorCompanies: z4.array(analyticsVisitorCompanyRowSchema).optional(),
+  landings: z4.array(analyticsLandingRowSchema).optional(),
+  tags: z4.array(analyticsTagRowSchema).optional(),
+  customEvents: z4.array(analyticsCustomEventRowSchema).optional(),
+  eventBreakdown: z4.array(analyticsEventBreakdownRowSchema).optional(),
+  customFunnel: z4.array(analyticsCustomFunnelStepSchema).optional(),
+  deviceBreakdown: z4.array(analyticsDeviceRowSchema).optional(),
+  realtime: analyticsRealtimeSchema.optional(),
+  adDimensions: z4.array(analyticsAdDimensionRowSchema).optional(),
+  adParams: z4.array(analyticsAdParamRowSchema).optional(),
+  /**
+   * Parameters arriving on visits no platform can be named for.
+   *
+   * Kept apart rather than folded into the platform's own list, and kept rather
+   * than dropped. Folding them in is what made every tab identical; dropping
+   * them would lose a parameter that arrives on hand-tagged links, on an email
+   * campaign, or on paid traffic whose click id an ad blocker removed — and
+   * losing it silently, which is the one outcome worse than showing it in the
+   * wrong place. They are evidence, not a to-do list: there is no platform to
+   * map them under, so a reader who recognises one adds it by name to the
+   * platform they know it belongs to.
+   */
+  adParamsUnattributed: z4.array(analyticsAdParamRowSchema).optional(),
+  adPlatformTraffic: z4.array(analyticsAdPlatformTrafficSchema).optional(),
+  flowDestinations: z4.array(analyticsFlowDestinationsSchema).optional(),
+  /** Present only on a report that was asked for by the page. */
+  pageInfo: analyticsPageInfoSchema.optional(),
+  conversions: z4.array(analyticsConversionRowSchema).optional(),
+  /** Every event these pages produced, counted or not. The "add a conversion" picker. */
+  eventCatalog: z4.array(analyticsEventCatalogRowSchema).optional(),
+  timeline: z4.array(analyticsTimelineRowSchema).optional(),
+  /**
+   * The raw feed. Same row shape as a replay, because it is the same rows —
+   * what changes is that this one is bounded by a window rather than by a visit.
+   */
+  stream: z4.array(analyticsTimelineRowSchema).optional(),
+  /** How each line of a people search on `stream` was read — what `personTerms` points at. */
+  peopleSearch: z4.array(peopleSearchTermSchema).optional(),
+  /** `stream` only: what that list left off as machine traffic. Absent when it is narrowed past what a count can follow. */
+  hiddenMachines: analyticsHiddenMachinesSchema.optional(),
+  visitorSessions: z4.array(analyticsVisitorSessionSchema).optional(),
+  /** Every key this person is known by — contact details, browsers, clicks, cookies. */
+  personKeys: z4.array(analyticsPersonKeySchema).optional(),
+  /** The same person, rolled up: their totals across every device, and what is known about them. */
+  personProfile: analyticsPersonProfileSchema.optional(),
+  visitProfile: analyticsVisitProfileSchema.optional(),
+  visitors: z4.array(analyticsVisitorRowSchema).optional(),
+  /**
+   * The same totals for the window immediately before this one, when asked for.
+   *
+   * The comparison window is returned alongside rather than reduced to a set of
+   * deltas, so a caller can show either side of it and does not have to trust
+   * our arithmetic to render "1,240 vs 980".
+   */
+  previous: z4.object({
+    window: analyticsWindowSchema,
+    totals: analyticsTotalsSchema
+  }).optional()
+});
+var analyticsQueryResponseSchema = z4.object({
+  ok: z4.literal(true),
+  data: analyticsQueryDataSchema,
+  warnings: z4.array(analyticsWarningSchema).optional(),
+  hints: z4.array(z4.string()).optional()
+});
+var analyticsConversionsRequestSchema = z4.object({
+  set: z4.array(
+    z4.object({
+      /** `form:<flow>:<step>:<trigger>` | `submit:<flow>` | `page:<name>` | `exit:<host>`. */
+      eventKey: z4.string().max(320),
+      name: z4.string().max(MAX_CONVERSION_NAME),
+      countMode: z4.enum(CONVERSION_COUNT_MODES).optional()
+    })
+  ).max(60).optional(),
+  remove: z4.array(z4.string().max(320)).max(60).optional(),
+  /** Every key counted under `from` moves to `to`, and the sends under the name go with it. */
+  rename: z4.object({ from: z4.string().min(1).max(MAX_CONVERSION_NAME), to: z4.string().min(1).max(MAX_CONVERSION_NAME) }).optional()
+});
+var analyticsConversionsResponseSchema = z4.object({
+  ok: z4.literal(true),
+  data: z4.object({
+    /**
+     * What the company counts — inside a chat, with this chat's proposal on
+     * top: `staged` marks a definition that applies when the chat is published.
+     */
+    definitions: z4.array(
+      z4.object({
+        eventKey: z4.string(),
+        name: z4.string(),
+        countMode: z4.string(),
+        updatedAt: z4.number(),
+        staged: z4.boolean().optional()
+      })
+    ),
+    /** This chat's proposal, when it has one: counted from Publish, and gone if the chat is discarded. */
+    staged: z4.object({
+      set: z4.array(z4.object({ eventKey: z4.string(), name: z4.string() })),
+      remove: z4.array(z4.string())
+    }).optional()
+  }),
+  hints: z4.array(z4.string()).optional()
+});
+var analyticsMappingRequestSchema = z4.object({
+  /**
+   * Which platform these operations are about. Required for a change.
+   *
+   * There is no cross-platform entry to write: the platforms do not describe
+   * the same world, so `cid` is TikTok's ad and half the internet's campaign,
+   * and a keyword on Meta traffic is not a thing that can exist. Omit it only
+   * to read the mapping back.
+   */
+  platform: z4.enum(AD_PLATFORMS).optional(),
+  /** Parameter name → role, on `platform`. Merged over what is stored. */
+  set: z4.record(z4.string().max(64), adParamRoleSchema).optional(),
+  /** Parameter names to stop reading, on `platform`. Applied after `set`. */
+  remove: z4.array(z4.string().max(64)).max(64).optional()
+});
+var analyticsMappingResponseSchema = z4.object({
+  ok: z4.literal(true),
+  data: z4.object({
+    /**
+     * This company's own entries after the change, keyed `<platform>/<name>`.
+     *
+     * Every platform's, not only the one the request named: a caller that has
+     * just mapped `cid` on TikTok is usually about to be asked the same
+     * question about Google, and the answer there is different.
+     */
+    params: z4.record(z4.string(), adParamRoleSchema),
+    /**
+     * Names that are understood without being configured.
+     *
+     * Returned so a caller can tell "already handled" from "not mapped" without
+     * shipping a copy of the built-in list, and so an agent does not spend a
+     * turn configuring `keyword` to mean keyword.
+     */
+    builtIn: z4.array(z4.string()),
+    /**
+     * What the client's own ad account says about each parameter just staged.
+     *
+     * Present only when a Session staged a `set` on a platform whose tracking
+     * configuration Baker can read. `contradicted` is the entry worth stopping
+     * for: the account fills that name with a placeholder meaning something
+     * else, so the answer just given would produce a report that is wrong and
+     * looks entirely plausible.
+     */
+    evidence: z4.record(
+      z4.string(),
+      z4.object({
+        status: z4.enum(["confirmed", "contradicted", "unseen", "not_read"]),
+        macro: z4.string().optional(),
+        suggestedRole: adParamRoleSchema.optional(),
+        source: z4.string().optional(),
+        reason: z4.string().optional()
+      })
+    ).optional(),
+    updatedAt: z4.number().nullable()
+  }),
+  hints: z4.array(z4.string()).optional()
+});
+var analyticsTrackingRequestSchema = z4.object({
+  platform: z4.enum(AD_PLATFORMS).optional(),
+  days: z4.number().int().min(1).max(365).optional()
+});
+var trackingDimensionSchema = z4.object({
+  role: adParamRoleSchema,
+  /** The platform's own macro for it — what goes in the URL. */
+  macro: z4.string(),
+  /** The account's own spelling where it has one, else the canonical name. */
+  name: z4.string(),
+  /**
+   * What has to happen for this dimension to reach a report.
+   *
+   * Four states rather than a boolean, because two of them need opposite fixes
+   * and one of them is not a finding at all. `unmapped` is one
+   * `baker analytics map` call and repairs the history with it; `missing` is a
+   * change to the ad account and everything before it stays unattributable;
+   * `unknown` means no visit arrived and the account could not be read, which
+   * must never be reported as untagged.
+   */
+  state: z4.enum(["covered", "unmapped", "missing", "unknown"]),
+  evidence: z4.string().optional(),
+  note: z4.string().optional()
+});
+var analyticsTrackingPlatformSchema = z4.object({
+  platform: z4.enum(AD_PLATFORMS),
+  label: z4.string(),
+  sessions: z4.number(),
+  /** Whether the ad account itself could be read, and why not when it could not. */
+  account: z4.object({ read: z4.boolean(), templates: z4.number(), reason: z4.string().optional() }),
+  dimensions: z4.array(trackingDimensionSchema),
+  /** Names the URLs already carry that Baker does not read yet. */
+  unmapped: z4.record(z4.string(), adParamRoleSchema),
+  mapCommand: z4.string(),
+  unexplained: z4.array(z4.object({ name: z4.string(), value: z4.string() })),
+  /** The pairs to append to the account's tagging, or `""`. */
+  suffix: z4.string(),
+  whereItGoes: z4.string(),
+  /** Which level to put them at, who can write it, and how an existing value is treated. */
+  fix: z4.string()
+});
+var analyticsTrackingResponseSchema = z4.object({
+  ok: z4.literal(true),
+  data: z4.object({ days: z4.number(), platforms: z4.array(analyticsTrackingPlatformSchema) }),
+  hints: z4.array(z4.string()).optional()
+});
+var boundedReference = (max) => z4.string().transform((value) => cutToLength(value, max));
+var submissionRecordRequestSchema = z4.object({
+  /**
+   * Injected by the Worker from the host or the site key. Never from the page.
+   *
+   * One of the two fields that is still required, because a copy that cannot
+   * be filed under a company cannot be found again by anybody. Bounding it
+   * would produce a row belonging to a company that does not exist, which is
+   * worse than refusing — this is the case where refusing is right.
+   */
+  companyId: z4.string().min(1),
+  /** Shared with every destination this submit was sent to, and with its event. */
+  submissionId: z4.string().min(1).pipe(boundedReference(128)),
+  /**
+   * The Form execution this step belongs to, or `""` from a page published
+   * before attempts existed.
+   *
+   * `submissionId` is minted per node, so two steps of one filling produce two
+   * copies with nothing joining them. This is that join. It changes nothing
+   * else here: a sealed copy is still per step, and still the only payload
+   * anybody keeps.
+   */
+  attemptId: boundedReference(128).default(""),
+  flowSlug: boundedReference(120).default(""),
+  nodeId: boundedReference(120).default(""),
+  nodeType: boundedReference(40).default(""),
+  landingId: boundedReference(120).default(""),
+  release: boundedReference(64).default(""),
+  pageUrl: boundedReference(2048).default(""),
+  /**
+   * A SHA-256 digest, or absent. Never an address.
+   *
+   * The join from a recovered copy to every session the same person had,
+   * without anybody having to open the copy to get there.
+   */
+  identityHash: boundedReference(128).optional(),
+  /**
+   * Degraded rather than refused, like everything else here: an unrecognised
+   * kind costs the copy one label, and refusing it would cost the copy.
+   */
+  identityKind: z4.enum(["email", "phone"]).optional().catch(void 0),
+  /** Injected by the Worker's edge. Kept exactly here and as a /24 everywhere else. */
+  clientIp: boundedReference(64).nullish(),
+  /**
+   * Every answer on the step, free text included. Sealed on arrival.
+   *
+   * Bounded rather than length-checked, and that is the whole of it: a `max()`
+   * here refused the **entire copy** over one long answer, so a visitor who
+   * pasted a paragraph into a free-text field lost the email and the budget
+   * beside it too. See {@link boundSubmissionAnswers}.
+   */
+  answers: z4.record(z4.string(), z4.string()).transform(boundSubmissionAnswers)
+});
+
+// ../api/src/analytics/busy.ts
+var ANALYTICS_BUSY_MESSAGE = "Analytics is busy right now. The numbers will be there in a moment \u2014 try again shortly.";
+function isAnalyticsBusy(message) {
+  return typeof message === "string" && message.includes(ANALYTICS_BUSY_MESSAGE);
+}
+var ANALYTICS_BUSY_FIX = "Nothing went wrong and nothing was lost \u2014 the analytics store was briefly at capacity. Wait a few seconds and ask for the same report again. If you were in the middle of a larger job, carry on with the rest of it and come back to this read; do not abandon the job.";
+var ANALYTICS_BUSY_RETRY_MS = 5e3;
+async function retryOnceIfBusy(read, messageOf, sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))) {
+  try {
+    return await read();
+  } catch (caught) {
+    if (!isAnalyticsBusy(messageOf(caught))) throw caught;
+    await sleep(ANALYTICS_BUSY_RETRY_MS);
+    return await read();
+  }
+}
+
+// ../api/src/analytics/conversionNames.ts
+function normalizeConversionName(name) {
+  return name.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, " ").trim().split(" ").filter((word) => word !== "").map((word) => word.length > 3 && word.endsWith("s") ? word.slice(0, -1) : word).join(" ");
+}
+function findNameCollision(name, existing) {
+  const normalized = normalizeConversionName(name);
+  return existing.find((candidate) => candidate !== name && normalizeConversionName(candidate) === normalized) ?? null;
+}
+var STANDARD_CONVERSION_NAMES = [
+  { name: "Lead", meaning: "Somebody handed over contact details" },
+  { name: "Booked a call", meaning: "A meeting or demo was scheduled" },
+  { name: "Quote requested", meaning: "Somebody asked what it would cost" },
+  { name: "Purchase", meaning: "Money changed hands" },
+  { name: "Signed up", meaning: "An account or trial was created" },
+  { name: "Subscribed", meaning: "Somebody opted in to hear from them again" },
+  { name: "Downloaded", meaning: "A guide, price list or asset was taken" },
+  { name: "Contacted us", meaning: "A call, WhatsApp or email started from the page" }
+];
+
+// ../api/src/analytics/destinations.ts
+var CONVERSION_SEND_PREFIX = "conversionSend:";
+function isConversionSend(type) {
+  return type.startsWith(CONVERSION_SEND_PREFIX);
+}
+var SERVER_SIDE_SENDER_TAG = {
+  metaCapi: "meta",
+  chatgptAdsCapi: "chatgptAds",
+  googleAdsCapi: "googleAds",
+  linkedinCapi: "linkedinInsightTag",
+  twitterAdsCapi: "twitterAds",
+  ga4Mp: "googleAnalytics"
+};
+var DESTINATION_NAMES = {
+  email: "Email",
+  httpWebhook: "HTTP Webhook",
+  zapier: "Zapier",
+  tiktok: "TikTok Pixel",
+  pinterest: "Pinterest Tag",
+  googleTagManager: "Google Tag Manager",
+  amplitude: "Amplitude",
+  hotjar: "Hotjar",
+  clarity: "Microsoft Clarity",
+  hubspot: "HubSpot Events",
+  vwo: "VWO",
+  posthog: "PostHog",
+  datafast: "DataFast",
+  code: "Custom Code",
+  pipedrive: "Pipedrive",
+  googleSpreadsheet: "Google Sheets",
+  hubspotForm: "HubSpot Form",
+  goHighlevelContact: "GoHighLevel",
+  shopifyCustomer: "Shopify",
+  crmble: "Crmble",
+  activeCampaignContact: "ActiveCampaign"
+};
+function destinationKey(type) {
+  const platform = isConversionSend(type) ? type.slice(CONVERSION_SEND_PREFIX.length) : type;
+  return SERVER_SIDE_SENDER_TAG[platform] ?? platform;
+}
+function destinationName(type) {
+  if (type === "") return "";
+  const key = destinationKey(type);
+  if (isSendPlatform(key)) return SEND_PLATFORM_SPECS[key].title;
+  return DESTINATION_NAMES[key] ?? type;
+}
+
+// ../api/src/analytics/row.ts
+var EVENT_ITEMS_MAX = 250;
+
+// ../api/src/analytics/triggers.ts
+var TRIGGERS = {
+  "calendlyEvent.eventScheduled": {
+    what: "Call booked",
+    meaning: "Somebody picked a slot and confirmed it. This is the booking."
+  },
+  "calendlyEvent.dateAndTimeSelected": {
+    what: "Time picked",
+    meaning: "Somebody chose a slot but has not confirmed the booking yet."
+  },
+  "calendlyEvent.eventTypeViewed": {
+    what: "Calendar opened",
+    meaning: "The calendar appeared. Nobody has picked a time yet.",
+    lifecycle: true
+  },
+  "calendlyEvent.profilePageViewed": {
+    what: "Booking page shown",
+    meaning: "Calendly's own page appeared. Nobody has picked a time yet.",
+    lifecycle: true
+  },
+  "customForm.onFormSubmitted": {
+    what: "Form submitted",
+    meaning: "Somebody filled this step in and sent it."
+  },
+  "highlevelEvent.appointmentScheduled": {
+    what: "Appointment booked",
+    meaning: "Somebody picked a slot and confirmed it. This is the booking."
+  },
+  "highlevelEvent.calendarLoaded": {
+    what: "Calendar finished loading",
+    meaning: "The calendar appeared. Nobody has picked a time yet.",
+    lifecycle: true
+  },
+  "highlevelFormEvent.formSubmitted": {
+    what: "Form submitted",
+    meaning: "Somebody filled the form in and sent it."
+  },
+  "highlevelFormEvent.formLoaded": {
+    what: "Form finished loading",
+    meaning: "The form appeared. Nobody has typed anything yet.",
+    lifecycle: true
+  },
+  "hubspotForm.onFormSubmitted": {
+    what: "Form submitted",
+    meaning: "Somebody filled the form in and sent it. This is the one that means a lead."
+  },
+  "hubspotForm.onBeforeFormSubmit": {
+    what: "Form about to be sent",
+    meaning: "Fires an instant before the form is sent \u2014 not the same as it arriving.",
+    lifecycle: true
+  },
+  "hubspotForm.onFormReady": {
+    what: "Form finished loading",
+    meaning: "The form appeared. Nobody has typed anything yet.",
+    lifecycle: true
+  },
+  "hubspotForm.onBeforeFormInit": {
+    what: "Form starting to load",
+    meaning: "Fires before the form has even drawn. It only means the page was opened.",
+    lifecycle: true
+  },
+  "hubspotMeeting.onMeetingScheduled": {
+    what: "Meeting booked",
+    meaning: "Somebody picked a slot and confirmed it. This is the booking."
+  },
+  "link.onClick": {
+    what: "Link clicked",
+    meaning: "Somebody clicked the link on this step and left for wherever it points."
+  },
+  "savvycalEvent.scheduled": {
+    what: "Call booked",
+    meaning: "Somebody picked a slot and confirmed it. This is the booking."
+  },
+  "text.onTextDisplayed": {
+    what: "Screen shown",
+    meaning: "This screen appeared. On a thank-you screen that is the outcome; elsewhere it is not."
+  },
+  "text.onButtonClicked": {
+    what: "Button pressed",
+    meaning: "Somebody pressed the button on this screen."
+  }
+};
+function triggerDescription(triggerId) {
+  return TRIGGERS[triggerId];
+}
+
+// ../api/src/analytics/feedNoise.ts
+var BOOKKEEPING_TYPES = /* @__PURE__ */ new Set([
+  "visitor_new",
+  "session_start",
+  "identify",
+  "form_step_view",
+  "side_effect_settled"
+]);
+var SUBMIT_TRIGGERS = new Set(Object.values(STEP_SUBMIT_TRIGGERS));
+function isEmbedLifecycle(row) {
+  return row.eventType === "form_trigger" && triggerDescription(row.triggerId)?.lifecycle === true;
+}
+function isBookkeepingRow(row) {
+  if (BOOKKEEPING_TYPES.has(row.eventType)) return true;
+  if (isEmbedLifecycle(row)) return true;
+  return row.eventType === "form_trigger" && SUBMIT_TRIGGERS.has(row.triggerId);
+}
+
+// ../api/src/analytics/matchKeys.ts
+var CONTACT_KEYS = ["email", "phone", "external_id", "baker_id"];
+var MATCH_KEY_FIELDS = [...CONTACT_KEYS, ...INGEST_CLICK_ID_PARAMS, ...MATCH_COOKIES];
+var MATCH_KEY_LABELS = {
+  email: "email",
+  phone: "phone",
+  external_id: "external ID",
+  baker_id: "Baker ID",
+  gclid: "Google click",
+  wbraid: "Google click (wbraid)",
+  gbraid: "Google click (gbraid)",
+  dclid: "Google Display click",
+  fbclid: "Meta click",
+  ttclid: "TikTok click",
+  twclid: "X click",
+  li_fat_id: "LinkedIn click",
+  msclkid: "Microsoft click",
+  rdt_cid: "Reddit click",
+  epik: "Pinterest click",
+  sccid: "Snapchat click",
+  oppref: "ChatGPT Ads click",
+  fbp: "Meta browser cookie",
+  fbc: "Meta click cookie"
+};
+function carries(userData, field) {
+  for (const key of [field, `${field}_sha256`, `${field}_preview`]) {
+    const value = userData[key];
+    if (typeof value === "string" && value !== "") return true;
+  }
+  return false;
+}
+function rowMatchKeys(userData) {
+  if (userData === void 0) return [];
+  return MATCH_KEY_FIELDS.filter((field) => carries(userData, field)).map((field) => ({
+    field,
+    label: MATCH_KEY_LABELS[field] ?? field
+  }));
+}
+
+// ../api/src/analytics/trackingTemplate.ts
+function placeholderKey(raw) {
+  return raw.replace(/[{}]/g, "").replace(/^_+|_+$/g, "").trim().toLowerCase();
+}
+var EXTRA_PLACEHOLDER_ROLES = {
+  google: {
+    merchant_id: "product_id",
+    product_partition_id: "product_id"
+  }
+};
+function placeholderRoles(platform) {
+  const roles = {};
+  for (const dimension of AD_PLATFORM_DEFINITIONS[platform].dimensions) {
+    roles[placeholderKey(dimension.macro)] = dimension.role;
+  }
+  return { ...roles, ...EXTRA_PLACEHOLDER_ROLES[platform] ?? {} };
+}
+function paramsFromTemplate(template) {
+  const start = template.indexOf("?");
+  const query = start === -1 ? template : template.slice(start + 1);
+  const params = [];
+  for (const pair of query.split("&")) {
+    const at = pair.indexOf("=");
+    if (at < 1) continue;
+    const name = pair.slice(0, at).trim();
+    if (name === "") continue;
+    params.push({ name, value: pair.slice(at + 1).trim() });
+  }
+  return params;
+}
+function proposeMappingFromTemplate(template, platform) {
+  const builtIn = builtinAdParamMapping(platform);
+  const vocabulary = placeholderRoles(platform);
+  const proposed = {};
+  const unexplained = [];
+  for (const param of paramsFromTemplate(template)) {
+    if (RESERVED_PARAM_NAMES.includes(param.name)) continue;
+    if (param.name in builtIn) continue;
+    const role = vocabulary[placeholderKey(param.value)];
+    if (role) {
+      proposed[param.name] = role;
+      continue;
+    }
+    unexplained.push(param);
+  }
+  return { proposed, unexplained };
+}
+function mappingCommandFor(platform, proposed) {
+  const pairs = Object.entries(proposed).map(([name, role]) => `${name}=${role}`);
+  if (pairs.length === 0) return "";
+  return `baker analytics map --platform ${platform} --set ${pairs.join(",")}`;
+}
+
+export {
+  AD_PARAM_ROLE_SPECS,
+  isAdPlatform,
+  essentialAdDimensions,
+  isAnalyticsBusy,
+  ANALYTICS_BUSY_FIX,
+  retryOnceIfBusy,
+  findNameCollision,
+  STANDARD_CONVERSION_NAMES,
+  CONVERSION_COUNT_MODES,
+  formEventKey,
+  isCheckoutRecordKey,
+  CHECKOUT_RECORD_REFUSAL,
+  isLandingViewKey,
+  parseEventKey,
+  SEND_PLATFORMS,
+  isSendPlatform,
+  sendEventProblem,
+  destinationName,
+  EVENT_ITEMS_MAX,
+  isBookkeepingRow,
+  rowMatchKeys,
+  PEOPLE_SEARCH_MAX_TERMS,
+  parsePeopleQuery,
+  peopleLookupRequestSchema,
+  sendsRequestSchema,
+  proposeMappingFromTemplate,
+  mappingCommandFor,
+  ANALYTICS_UNSTAGE_KINDS,
+  SEND_FILTERS,
+  ANALYTICS_FULL_BREAKDOWN_LIMIT,
+  ANALYTICS_EVENT_DOORS
+};
+//# sourceMappingURL=chunk-JOE42ZW6.js.map