@koda-sl/baker-cli 0.512.0 → 0.514.0

package/dist/chunk-7J3NZBPV.js

@@ -1,2982 +0,0 @@
-import {
-  INGEST_CLICK_ID_PARAMS,
-  MATCH_COOKIES,
-  isSha256Hex,
-  normalizeIdentity,
-  templateMentions
-} from "./chunk-EDLZGTGN.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-7J3NZBPV.js.map