@koda-sl/baker-cli 0.449.0 → 0.450.0-dev.b454c3dd2

package/dist/chunk-HR6IWNKE.js

@@ -0,0 +1,2942 @@
+// ../api/src/analytics/eventKey.ts
+var SEP = ":";
+function formEventKey(flowSlug, nodeId, triggerId) {
+  return ["form", flowSlug, nodeId, triggerId].join(SEP);
+}
+function isLandingViewKey(key2) {
+  return parseEventKey(key2)?.family === "view";
+}
+function parseEventKey(key2) {
+  const cut = key2.indexOf(SEP);
+  if (cut <= 0) return null;
+  const family = key2.slice(0, cut);
+  const rest = key2.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/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/peopleSearch.ts
+import { z } from "zod";
+
+// ../api/src/identity/digest.ts
+var SHA256_HEX = /^[0-9a-fA-F]{64}$/;
+function isSha256Hex(value) {
+  return SHA256_HEX.test(value);
+}
+
+// ../api/src/identity/email.ts
+function normalizeEmailV1(raw) {
+  const trimmed = raw.trim().toLowerCase();
+  return trimmed === "" ? null : trimmed;
+}
+var EMAIL = /^[^\s@]+@[^\s@.]+(?:\.[^\s@.]+)+$/;
+function normalizeEmailV2(raw) {
+  const trimmed = raw.trim().toLowerCase();
+  return EMAIL.test(trimmed) ? trimmed : null;
+}
+
+// ../api/src/identity/phone.ts
+function normalizePhoneV1(raw) {
+  const digits = raw.trim().toLowerCase().replace(/[^0-9]/g, "");
+  return digits === "" ? null : `+${digits}`;
+}
+var PHONE_PUNCTUATION = /[\s()./-]/g;
+var E164 = /^\+[1-9]\d{7,14}$/;
+function normalizePhoneV2(raw) {
+  const compact = raw.replace(PHONE_PUNCTUATION, "");
+  const e164 = compact.startsWith("00") ? `+${compact.slice(2)}` : compact;
+  return E164.test(e164) ? e164 : null;
+}
+
+// ../api/src/identity/index.ts
+function normalizeIdentity(raw, version) {
+  const value = raw.kind === "email" ? version === 1 ? normalizeEmailV1(raw.value) : normalizeEmailV2(raw.value) : version === 1 ? normalizePhoneV1(raw.value) : normalizePhoneV2(raw.value);
+  return value === null ? null : { kind: raw.kind, value, normalizationVersion: version };
+}
+
+// ../api/src/analytics/peopleSearch.ts
+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(text2) {
+  const inputs = (typeof text2 === "string" ? [text2] : text2).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/wire.ts
+import { z as z2 } 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 = z2.enum(AD_PARAM_ROLES);
+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 = z2.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",
+  /**
+   * 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 = z2.object({
+  preset: analyticsPresetSchema,
+  /** Lookback in days. Ignored when `startDate` is given. */
+  days: z2.coerce.number().int().positive().max(400).optional(),
+  startDate: z2.iso.date().optional(),
+  endDate: z2.iso.date().optional(),
+  /** Required by the `page` preset; ignored by the others. */
+  path: z2.string().max(1024).optional(),
+  /** Narrows `funnel` to one Form. Omitted means every Form. */
+  flowSlug: z2.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: z2.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: z2.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: z2.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: z2.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: z2.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: z2.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: z2.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: z2.enum(SEND_FILTERS).optional(),
+  /** `stream` only: keep just the uploads one send made, by its id (`s1`). */
+  sendId: z2.string().optional(),
+  /** `stream` only: keep what went to one destination (`meta`, `httpWebhook`) — a Form's deliveries and sends' uploads alike. */
+  sentTo: z2.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: z2.string().optional(),
+  /** Return the long breakdowns and the per-day trend. */
+  full: z2.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: z2.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: z2.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: z2.string().max(120).optional(),
+  /** Narrows `landings` to the landings carrying one tag. */
+  tag: z2.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: z2.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: z2.string().max(128).optional(),
+  /** Which page-defined event the `events` preset breaks down. */
+  eventName: z2.string().max(120).optional(),
+  /** Which of that event's own properties to break it down by. */
+  property: z2.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: z2.object({ property: z2.string().max(64), value: z2.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: z2.array(z2.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: z2.boolean().optional(),
+  /** `devices` only: which facet to group on. */
+  deviceGrain: z2.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: z2.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: z2.string().max(40).optional(),
+  personValue: z2.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: z2.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: z2.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: z2.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 = z2.object({
+  startDate: z2.iso.date(),
+  endDate: z2.iso.date(),
+  days: z2.number().int().positive(),
+  /** True when the window reaches past the datasource TTL, so part of it is simply gone. */
+  beyondRetention: z2.boolean()
+});
+var analyticsTotalsSchema = z2.object({
+  /** Counted from `visitor_new`. */
+  visitors: z2.number().int().nonnegative(),
+  /** Counted from `session_start`. */
+  sessions: z2.number().int().nonnegative(),
+  pageViews: z2.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: z2.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: z2.number().int().nonnegative().default(0),
+  /** Visits that produced at least one conversion. Never above `sessions`. */
+  convertingSessions: z2.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: z2.number().min(0).max(1).nullable(),
+  avgEngagementMs: z2.number().nonnegative().nullable(),
+  /** Page views per session. At or near 1 means visitors leave from the page they land on. */
+  pagesPerSession: z2.number().nonnegative().nullable()
+});
+var analyticsTrendPointSchema = z2.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: z2.string(),
+  visitors: z2.number().int().nonnegative(),
+  sessions: z2.number().int().nonnegative(),
+  pageViews: z2.number().int().nonnegative(),
+  conversions: z2.number().int().nonnegative()
+});
+var analyticsLandingRowSchema = z2.object({
+  /** The landing's `internalId` — the reference every event carries. */
+  landingId: z2.string(),
+  /** The Convex `landings._id`, so a dashboard can link straight to the row. */
+  landingRef: z2.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: z2.string(),
+  slug: z2.string(),
+  tags: z2.array(z2.string()),
+  views: z2.number().int().nonnegative(),
+  sessions: z2.number().int().nonnegative(),
+  /** Sessions that BEGAN here. The honest denominator for this page's rate. */
+  entrances: z2.number().int().nonnegative(),
+  visitors: z2.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: z2.number().int().nonnegative(),
+  /** Visits that converted on this page at least once. */
+  convertingSessions: z2.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: z2.number().int().nonnegative(),
+  /** People whose conversions are credited here. */
+  creditedVisitors: z2.number().int().nonnegative(),
+  outboundClicks: z2.number().int().nonnegative(),
+  /**
+   * Visits credited a conversion, per visit. Null when nobody visited.
+   *
+   * Converting visits, not conversions: see {@link analyticsTotalsSchema}.
+   */
+  conversionRate: z2.number().min(0).max(1).nullable(),
+  avgEngagementMs: z2.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: z2.array(z2.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: z2.array(z2.string()),
+  /**
+   * Visits per entry of {@link channels}, in the same order.
+   *
+   * 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: z2.array(z2.number().int().nonnegative())
+});
+var analyticsTagRowSchema = z2.object({
+  tag: z2.string(),
+  landings: z2.number().int().nonnegative(),
+  views: z2.number().int().nonnegative(),
+  sessions: z2.number().int().nonnegative(),
+  entrances: z2.number().int().nonnegative(),
+  conversions: z2.number().int().nonnegative(),
+  /** Visits that converted on one of this tag's pages. */
+  convertingSessions: z2.number().int().nonnegative(),
+  /** Converting visits per entrance. */
+  conversionRate: z2.number().min(0).max(1).nullable()
+});
+var ANALYTICS_EVENT_ORIGINS = ["site", "systems", "both"];
+var analyticsCustomEventRowSchema = z2.object({
+  eventName: z2.string(),
+  events: z2.number().int().nonnegative(),
+  sessions: z2.number().int().nonnegative(),
+  visitors: z2.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: z2.array(z2.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: z2.record(z2.string(), z2.number()).default({}),
+  landings: z2.array(z2.string()),
+  /** Which collector produced this name — and `both` when more than one did. */
+  origin: z2.enum(ANALYTICS_EVENT_ORIGINS)
+});
+var analyticsEventBreakdownRowSchema = z2.object({
+  value: z2.string(),
+  events: z2.number().int().nonnegative(),
+  sessions: z2.number().int().nonnegative(),
+  /** Per currency, exactly as {@link analyticsCustomEventRowSchema.money}. */
+  money: z2.record(z2.string(), z2.number()).default({})
+});
+var analyticsCustomFunnelStepSchema = z2.object({
+  stepIndex: z2.number().int().positive(),
+  stepName: z2.string(),
+  sessions: z2.number().int().nonnegative(),
+  /** Share of the sessions that reached the previous step. Null on the first. */
+  stepRate: z2.number().min(0).max(1).nullable(),
+  /** Share of the sessions that reached step one. Null on the first. */
+  overallRate: z2.number().min(0).max(1).nullable()
+});
+var analyticsDeviceRowSchema = z2.object({
+  /** The bucket label — `Chrome 120.0`, `iOS 17.4`, `380–767`. */
+  bucket: z2.string(),
+  sessions: z2.number().int().nonnegative(),
+  pageViews: z2.number().int().nonnegative(),
+  convertingSessions: z2.number().int().nonnegative(),
+  conversions: z2.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: z2.number().min(0).max(1).nullable(),
+  avgEngagementMs: z2.number().nonnegative().nullable()
+});
+var analyticsPageRowSchema = z2.object({
+  path: z2.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: z2.string(),
+  pageViews: z2.number().int().nonnegative(),
+  /** Sessions that began on this page — its value as a landing page. */
+  entrances: z2.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: z2.number().int().nonnegative(),
+  /** Visits that converted on this page at least once. */
+  convertingSessions: z2.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: z2.number().int().nonnegative(),
+  /** People whose conversions are credited here. */
+  creditedVisitors: z2.number().int().nonnegative(),
+  /** Credited people per entrance, 0–1. Null when nobody landed here. */
+  conversionRate: z2.number().min(0).max(1).nullable(),
+  avgEngagementMs: z2.number().nonnegative().nullable()
+});
+var analyticsSourceRowSchema = z2.object({
+  source: z2.string(),
+  medium: z2.string(),
+  sessions: z2.number().int().nonnegative(),
+  conversions: z2.number().int().nonnegative(),
+  conversionRate: z2.number().min(0).max(1).nullable()
+});
+var analyticsCampaignRowSchema = z2.object({
+  utmSource: z2.string(),
+  utmMedium: z2.string(),
+  utmCampaign: z2.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: z2.string(),
+  sessions: z2.number().int().nonnegative(),
+  conversions: z2.number().int().nonnegative(),
+  conversionRate: z2.number().min(0).max(1).nullable()
+});
+var analyticsRealtimeMinuteSchema = z2.object({
+  /** The minute, as an ISO instant. */
+  minute: z2.string(),
+  visitors: z2.number().int().nonnegative(),
+  pageViews: z2.number().int().nonnegative()
+});
+var analyticsRealtimePageSchema = z2.object({
+  path: z2.string(),
+  /** The landing this path belongs to; empty when no landing claims it. */
+  landingId: z2.string(),
+  visitors: z2.number().int().nonnegative()
+});
+var analyticsRealtimeSchema = z2.object({
+  /** Distinct visitors with any activity inside the active window. */
+  activeNow: z2.number().int().nonnegative(),
+  /** How recently a visitor must have acted to be counted, in minutes. */
+  activeWithinMinutes: z2.number().int().positive(),
+  minutes: z2.array(analyticsRealtimeMinuteSchema),
+  pages: z2.array(analyticsRealtimePageSchema)
+});
+var analyticsDimensionRowSchema = z2.object({
+  key: z2.string(),
+  sessions: z2.number().int().nonnegative(),
+  conversions: z2.number().int().nonnegative(),
+  conversionRate: z2.number().min(0).max(1).nullable()
+});
+var analyticsFunnelStepSchema = z2.object({
+  stepId: z2.string(),
+  stepIndex: z2.number().int().nonnegative(),
+  /** Visits that moved forward into this step. Never events — see `visits`. */
+  views: z2.number().int().nonnegative(),
+  /** Visits that finished this step and moved on. */
+  completions: z2.number().int().nonnegative(),
+  /** Share of viewers who did not complete this step, 0–1. */
+  dropRate: z2.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: z2.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: z2.boolean()
+});
+var analyticsFunnelSchema = z2.object({
+  flowSlug: z2.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: z2.number().int().nonnegative(),
+  /** Visits that interacted with the Form at all — typed, picked, or advanced. */
+  starts: z2.number().int().nonnegative(),
+  submits: z2.number().int().nonnegative(),
+  /** Conversions per visit that opened the Form, 0–1. */
+  completionRate: z2.number().min(0).max(1).nullable(),
+  /** The step losing the most people. The single most useful field here. */
+  worstStep: analyticsFunnelStepSchema.nullable(),
+  steps: z2.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: z2.number().int().nonnegative()
+});
+var analyticsPaidRowSchema = z2.object({
+  source: z2.string(),
+  medium: z2.string(),
+  campaign: z2.string(),
+  content: z2.string(),
+  term: z2.string(),
+  /** `google` | `meta` | `tiktok` | `x` | `linkedin` | `microsoft` | `""`. */
+  clickPlatform: z2.string(),
+  sessions: z2.number().int().nonnegative(),
+  convertingSessions: z2.number().int().nonnegative(),
+  conversions: z2.number().int().nonnegative(),
+  /** Leads whose server-side delivery reported success. */
+  delivered: z2.number().int().nonnegative(),
+  /** Leads whose delivery reported failure. Non-zero here is a broken integration. */
+  failedDeliveries: z2.number().int().nonnegative(),
+  /** Distinct people, across devices — only countable where visitors identified themselves. */
+  identifiedPeople: z2.number().int().nonnegative(),
+  /** Converting sessions per session, 0–1. */
+  conversionRate: z2.number().min(0).max(1).nullable(),
+  /** Delivered leads per conversion, 0–1. Below 1 means leads are being lost after submit. */
+  deliveryRate: z2.number().min(0).max(1).nullable()
+});
+var analyticsDeliveryRowSchema = z2.object({
+  eventId: z2.string(),
+  submittedAt: z2.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: z2.string(),
+  /** Lowercase hex digest of who submitted, when the page could identify them. */
+  identityHash: z2.string(),
+  flowSlug: z2.string(),
+  stepId: z2.string(),
+  landingId: z2.string(),
+  destinations: z2.array(z2.string()),
+  dispatched: z2.number().int().nonnegative(),
+  succeeded: z2.number().int().nonnegative(),
+  failed: z2.number().int().nonnegative(),
+  /** Dispatched and never settled. Distinguishing this from failed is "wait" vs "act". */
+  pending: z2.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: z2.array(z2.string()),
+  sampleError: z2.string()
+});
+var analyticsTriggerRowSchema = z2.object({
+  flowSlug: z2.string(),
+  /** `link`, `customForm`, `iframe`, `hubspotMeeting`, … */
+  nodeType: z2.string(),
+  /** The trigger, verbatim: `link.onClick`, `iframe.checkout_completed`. */
+  triggerId: z2.string(),
+  fires: z2.number().int().nonnegative(),
+  sessions: z2.number().int().nonnegative(),
+  /** How many of those fires produced a side effect. Often zero, on purpose. */
+  sideEffectsFired: z2.number().int().nonnegative()
+});
+var analyticsReleaseRowSchema = z2.object({
+  /** The commit the build came from. */
+  release: z2.string(),
+  firstSeen: z2.string(),
+  lastSeen: z2.string(),
+  sessions: z2.number().int().nonnegative(),
+  pageViews: z2.number().int().nonnegative(),
+  conversions: z2.number().int().nonnegative(),
+  /** Visits that converted on this build at least once. */
+  convertingSessions: z2.number().int().nonnegative(),
+  /** Converting visits per session, 0–1. Null below a usable sample. */
+  conversionRate: z2.number().min(0).max(1).nullable()
+});
+var analyticsGeoRowSchema = z2.object({
+  /** The place itself, at whatever grain was asked for. */
+  place: z2.string(),
+  /** Always carried: a postcode without its country is ambiguous, a city twice over. */
+  country: z2.string(),
+  region: z2.string(),
+  sessions: z2.number().int().nonnegative(),
+  conversions: z2.number().int().nonnegative(),
+  /** Conversions per session, 0–1. Null below a usable sample. */
+  conversionRate: z2.number().min(0).max(1).nullable(),
+  /** People rather than browsers, where the visit identified itself. */
+  identifiedPeople: z2.number().int().nonnegative()
+});
+var analyticsBotRowSchema = z2.object({
+  /** The crawler's name, or `unidentified` for a machine we could not name. */
+  bot: z2.string(),
+  /** `search` | `ai` | `social` | `seo` | `monitoring` | `tool` | `automation`. */
+  category: z2.string(),
+  hits: z2.number().int().nonnegative(),
+  pages: z2.number().int().nonnegative(),
+  lastSeen: z2.string(),
+  samplePaths: z2.array(z2.string())
+});
+var analyticsWarningSchema = z2.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: z2.enum(["LOW_SAMPLE", "NO_DATA", "BEYOND_RETENTION", "AD_ROLE_UNMAPPED"]),
+  message: z2.string()
+});
+var analyticsFlowSummarySchema = z2.object({
+  flowSlug: z2.string(),
+  sessions: z2.number().int().nonnegative(),
+  starts: z2.number().int().nonnegative(),
+  convertedSessions: z2.number().int().nonnegative(),
+  submits: z2.number().int().nonnegative(),
+  stepViews: z2.number().int().nonnegative(),
+  /** Distinct steps anyone reached, across all visits. */
+  stepsSeen: z2.number().int().nonnegative(),
+  deepestStepIndex: z2.number().int().nonnegative(),
+  /** Steps reached per visit, averaged — "how much of this Form do people read". */
+  avgStepsReached: z2.number().nonnegative(),
+  /** Conversions per visit that started, 0–1. */
+  conversionRate: z2.number().min(0).max(1).nullable(),
+  /** Which node ids produced the conversions. Usually one; two means two offers. */
+  conversionSteps: z2.array(z2.string()),
+  /** And by what — `calendlyEvent.eventScheduled`, `customForm.onFormSubmitted`. */
+  conversionTriggers: z2.array(z2.string()),
+  conversionNodeTypes: z2.array(z2.string()),
+  lastSeen: z2.string()
+});
+var analyticsFlowEdgeSchema = z2.object({
+  flowSlug: z2.string(),
+  fromStep: z2.string(),
+  toStep: z2.string(),
+  sessions: z2.number().int().nonnegative()
+});
+var analyticsConversionRowSchema = z2.object({
+  /** What a person calls this outcome. */
+  name: z2.string(),
+  /** Every event counted under this name. One entry unless the name is shared. */
+  eventKeys: z2.array(z2.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: z2.string(),
+  /** Counted the way each definition asked to be counted, and credited to a landing. */
+  conversions: z2.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: z2.number().default(0),
+  /** Distinct visits that produced it, never mode-adjusted. The gap between the two is the repeat behaviour. */
+  convertingVisits: z2.number(),
+  /** Null when it has never fired. */
+  lastSeen: z2.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: z2.array(z2.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: z2.boolean().optional()
+});
+var analyticsEventCatalogRowSchema = z2.object({
+  /** `form:…` | `submit:…` | `page:…` | `exit:…` — parse with `parseEventKey`. */
+  eventKey: z2.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: z2.enum(ANALYTICS_EVENT_ORIGINS),
+  events: z2.number(),
+  sessions: z2.number(),
+  /** The Form node's kind, for a `form:` key. Empty otherwise. */
+  nodeType: z2.string(),
+  /** The Form this happened in, for a `form:` or `submit:` key. Empty otherwise. */
+  flowSlug: z2.string(),
+  /** Null when it has never fired — only possible for a row we already count. */
+  lastSeen: z2.string().nullable(),
+  /** Already counted as a conversion. Shown, never hidden: a row that vanished on being counted reads as a bug. */
+  isCounted: z2.boolean(),
+  /** The name it is counted under, when it is. */
+  countedAs: z2.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: z2.array(z2.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: z2.array(z2.object({ door: z2.enum(ANALYTICS_EVENT_DOORS), events: z2.number(), sessions: z2.number() })).default([])
+});
+var analyticsAdDimensionRowSchema = z2.object({
+  /** The dimension's value. Empty means "arrived carrying none of these". */
+  value: z2.string(),
+  /** Which platform stamped the click, from the click id rather than a label. */
+  platform: z2.string(),
+  sessions: z2.number(),
+  convertingSessions: z2.number(),
+  conversions: z2.number(),
+  bouncedSessions: z2.number(),
+  identifiedPeople: z2.number(),
+  pageViews: z2.number(),
+  engagementMs: z2.number(),
+  /** Conversions per session, or null when nothing arrived. */
+  conversionRate: z2.number().nullable(),
+  /** Bounces per session, or null when nothing arrived. */
+  bounceRate: z2.number().nullable()
+});
+var analyticsAdParamRowSchema = z2.object({
+  name: z2.string(),
+  /** Whether the value is stored, or only the fact that the name appeared. */
+  captured: z2.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: z2.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: z2.number(),
+  events: z2.number(),
+  /** Up to five distinct values. Always empty for an uncaptured parameter. */
+  sampleValues: z2.array(z2.string()),
+  lastSeen: z2.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: z2.boolean().optional()
+});
+var analyticsFlowDestinationsSchema = z2.object({
+  flowSlug: z2.string(),
+  /** Destination types seen — `meta`, `httpWebhook`, `hubspotForm`. */
+  destinations: z2.array(z2.string()),
+  lastSeen: z2.string().optional()
+});
+var analyticsAdPlatformTrafficSchema = z2.object({
+  platform: z2.string(),
+  sessions: z2.number(),
+  conversions: z2.number(),
+  /** How many of those visits carried any campaign parameter at all. */
+  taggedSessions: z2.number()
+});
+var analyticsPageInfoSchema = z2.object({
+  /** Which field of the response was paged. */
+  block: z2.enum(["visitors", "submissions", "deliveries", "stream"]),
+  page: z2.number().int(),
+  pageSize: z2.number().int(),
+  returned: z2.number().int(),
+  hasMore: z2.boolean()
+});
+var analyticsTimelineRowSchema = z2.object({
+  timestamp: z2.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: z2.string(),
+  anonId: z2.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: z2.number().int().nonnegative(),
+  /** This event's identity, so two rows can be said to be the same event. */
+  eventUid: z2.string(),
+  /** `page_view`, `form_step_view`, `side_effect_dispatched`, … */
+  eventType: z2.string(),
+  /** `edge`, `beacon`, `server` — where the row was written from. */
+  source: z2.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: z2.string().default(""),
+  environment: z2.string(),
+  /** The build the page was published from. */
+  release: z2.string(),
+  path: z2.string(),
+  host: z2.string(),
+  landingId: z2.string(),
+  flowSlug: z2.string(),
+  stepId: z2.string(),
+  stepIndex: z2.number().int().nonnegative(),
+  nodeType: z2.string(),
+  triggerId: z2.string(),
+  /** A page-defined event's own name, when this row is one. */
+  eventName: z2.string(),
+  /** Whatever the page attached to a custom event. Strings only, by design. */
+  properties: z2.record(z2.string(), z2.string()),
+  /** Where an outbound click or a link node was going, in full. */
+  targetUrl: z2.string(),
+  /** A number the page reported alongside the event. */
+  value: z2.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: z2.string().default(""),
+  /** The visitor's digest, when they had identified themselves by this point. */
+  identityHash: z2.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: z2.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: z2.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: z2.string().default(""),
+  /**
+   * Which lines of a people search this row belongs to, by position in
+   * `peopleSearch`. Empty when nobody was searched for.
+   */
+  personTerms: z2.array(z2.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: z2.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: z2.record(z2.string(), z2.string()).default({}),
+  sideEffectType: z2.string(),
+  sideEffectName: z2.string(),
+  sideEffectId: z2.string(),
+  tagId: z2.string(),
+  messageId: z2.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: z2.string(),
+  runId: z2.string(),
+  engagementMs: z2.number().int().nonnegative(),
+  scrollDepth: z2.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: z2.string().default(""),
+  variant: z2.string().default(""),
+  /** `success` | `failed` | `""` for a dispatch that has not settled yet. */
+  outcome: z2.string(),
+  /** What the destination said when it refused. Empty on success. */
+  error: z2.string(),
+  /** The destination's own id for the record it created, when it gave one. */
+  providerRef: z2.string(),
+  /** When the destination answered, so "it took eleven seconds" is sayable. */
+  settledAt: z2.string()
+});
+var analyticsSubmissionRowSchema = z2.object({
+  sessionId: z2.string(),
+  flowSlug: z2.string(),
+  startedAt: z2.string(),
+  lastAt: z2.string(),
+  anonId: z2.string(),
+  identityHash: z2.string(),
+  identityKind: z2.string(),
+  landingId: z2.string(),
+  path: z2.string(),
+  /** Steps they saw. The denominator for "how far did they get". */
+  stepsReached: z2.number().int().nonnegative(),
+  /** Steps they actually handed something over on. Zero means no attempt. */
+  stepsSubmitted: z2.number().int().nonnegative(),
+  submittedStepIds: z2.array(z2.string()),
+  /** The furthest step they reached, for naming where they stopped. */
+  lastStepId: z2.string(),
+  /** Whether the Form reached an ending, by any of its three routes. */
+  finished: z2.boolean(),
+  conversions: z2.number().int().nonnegative(),
+  destinations: z2.array(z2.string()),
+  /** Destinations that fired as a pixel in the page. */
+  browserDestinations: z2.array(z2.string()),
+  /** Destinations Baker dispatched from the server. */
+  serverDestinations: z2.array(z2.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: z2.number().int().nonnegative(),
+  succeeded: z2.number().int().nonnegative(),
+  failed: z2.number().int().nonnegative(),
+  /** Dispatched and never settled — "wait", as against "act". */
+  pending: z2.number().int().nonnegative(),
+  sampleError: z2.string(),
+  providerRefs: z2.array(z2.string()),
+  /** The submission ids, which is how the panel opens the sealed payload. */
+  eventIds: z2.array(z2.string())
+});
+var analyticsVisitorSessionSchema = z2.object({
+  sessionId: z2.string(),
+  startedAt: z2.string(),
+  endedAt: z2.string(),
+  entryPath: z2.string(),
+  entryLandingId: z2.string(),
+  utmCampaign: z2.string(),
+  referrerSource: z2.string(),
+  deviceType: z2.string(),
+  pageViews: z2.number().int().nonnegative(),
+  conversions: z2.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: z2.boolean(),
+  engagementMs: z2.number().int().nonnegative()
+});
+var analyticsVisitProfileSchema = z2.object({
+  sessionId: z2.string(),
+  startedAt: z2.string(),
+  endedAt: z2.string(),
+  entryPath: z2.string(),
+  entryLandingId: z2.string(),
+  country: z2.string(),
+  region: z2.string(),
+  city: z2.string(),
+  timezone: z2.string(),
+  /** The network the visit came from. What separates a datacentre from a person. */
+  asOrganization: z2.string(),
+  deviceType: z2.string(),
+  browser: z2.string(),
+  os: z2.string(),
+  referrerSource: z2.string(),
+  referrerDomain: z2.string(),
+  utmSource: z2.string(),
+  utmMedium: z2.string(),
+  utmCampaign: z2.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: z2.string(),
+  /** Every ValueTrack-style parameter the URL carried, unresolved. */
+  campaignParams: z2.record(z2.string(), z2.string()),
+  /** The browser's own cookie id. One person can have several. */
+  anonId: z2.string(),
+  identityHash: z2.string(),
+  /** What the digest was made of — `email`, `phone`. Never the value. */
+  identityKind: z2.string(),
+  pageViews: z2.number().int().nonnegative(),
+  conversions: z2.number().int().nonnegative(),
+  engagementMs: z2.number().int().nonnegative()
+});
+var analyticsPersonKeySchema = z2.object({
+  /** `email` | `phone` | `external` | `browser` | a click-id name | `fbp` | `fbc`. */
+  kind: z2.string(),
+  /** A digest for a contact detail, the value itself for a cookie or a click id. */
+  value: z2.string(),
+  firstSeen: z2.string(),
+  lastSeen: z2.string(),
+  /** How many times it was observed beside another key — every submission repeats it. */
+  observations: z2.number().int().nonnegative(),
+  sessions: z2.number().int().nonnegative(),
+  /** `client` | `edge` | `server` | `ingest` — which collector first saw it. */
+  source: z2.string(),
+  /** The Form it was first seen on, where it came from one. */
+  flowSlug: z2.string(),
+  landingId: z2.string()
+});
+var analyticsPersonProfileSchema = z2.object({
+  firstSeen: z2.string(),
+  lastSeen: z2.string(),
+  sessions: z2.number().int().nonnegative(),
+  /** How many browsers resolved to this person. More than one is cross-device. */
+  devices: z2.number().int().nonnegative(),
+  pageViews: z2.number().int().nonnegative(),
+  conversions: z2.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: z2.record(z2.string(), z2.number()),
+  engagementMs: z2.number().int().nonnegative(),
+  /** How many of their events a client's own server posted. */
+  serverEvents: z2.number().int().nonnegative(),
+  country: z2.string(),
+  region: z2.string(),
+  city: z2.string(),
+  deviceType: z2.string(),
+  browser: z2.string(),
+  os: z2.string(),
+  utmSource: z2.string(),
+  utmMedium: z2.string(),
+  utmCampaign: z2.string(),
+  referrerSource: z2.string(),
+  entryLandingId: z2.string(),
+  entryPath: z2.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: z2.record(z2.string(), z2.string())
+});
+var analyticsVisitorRowSchema = z2.object({
+  anonId: z2.string(),
+  firstSeen: z2.string(),
+  lastSeen: z2.string(),
+  sessions: z2.number().int().nonnegative(),
+  pageViews: z2.number().int().nonnegative(),
+  conversions: z2.number().int().nonnegative(),
+  formTriggers: z2.number().int().nonnegative(),
+  outboundClicks: z2.number().int().nonnegative(),
+  engagementMs: z2.number().int().nonnegative(),
+  /** The visit to open by default — the most recent one. */
+  lastSessionId: z2.string(),
+  entryPath: z2.string(),
+  entryLandingId: z2.string(),
+  lastPath: z2.string(),
+  referrerSource: z2.string(),
+  referrerDomain: z2.string(),
+  utmSource: z2.string(),
+  utmMedium: z2.string(),
+  utmCampaign: z2.string(),
+  clickPlatform: z2.string(),
+  campaignParams: z2.record(z2.string(), z2.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: z2.record(z2.string(), z2.string()),
+  country: z2.string(),
+  region: z2.string(),
+  city: z2.string(),
+  timezone: z2.string(),
+  asOrganization: z2.string(),
+  deviceType: z2.string(),
+  browser: z2.string(),
+  os: z2.string(),
+  identityHash: z2.string(),
+  identityKind: z2.string()
+});
+var analyticsMeasureScopeSchema = z2.object({
+  scope: z2.enum(["campaigns", "outcomes", "all", "unknown"]),
+  /** Every event the tag on the client's own site sent in this window. */
+  websiteEvents: z2.number(),
+  /** Browser ids it minted off-Baker. Any at all means the tag is on `all`. */
+  websiteNewVisitors: z2.number()
+});
+var analyticsQueryDataSchema = z2.object({
+  preset: analyticsPresetSchema,
+  window: analyticsWindowSchema,
+  totals: analyticsTotalsSchema,
+  trend: z2.array(analyticsTrendPointSchema).optional(),
+  topPages: z2.array(analyticsPageRowSchema).optional(),
+  topSources: z2.array(analyticsSourceRowSchema).optional(),
+  topCampaigns: z2.array(analyticsCampaignRowSchema).optional(),
+  countries: z2.array(analyticsDimensionRowSchema).optional(),
+  devices: z2.array(analyticsDimensionRowSchema).optional(),
+  funnels: z2.array(analyticsFunnelSchema).optional(),
+  flowSummary: z2.array(analyticsFlowSummarySchema).optional(),
+  flowPaths: z2.array(analyticsFlowEdgeSchema).optional(),
+  triggers: z2.array(analyticsTriggerRowSchema).optional(),
+  releases: z2.array(analyticsReleaseRowSchema).optional(),
+  paid: z2.array(analyticsPaidRowSchema).optional(),
+  measureScope: analyticsMeasureScopeSchema.optional(),
+  deliveries: z2.array(analyticsDeliveryRowSchema).optional(),
+  submissions: z2.array(analyticsSubmissionRowSchema).optional(),
+  geo: z2.array(analyticsGeoRowSchema).optional(),
+  bots: z2.array(analyticsBotRowSchema).optional(),
+  landings: z2.array(analyticsLandingRowSchema).optional(),
+  tags: z2.array(analyticsTagRowSchema).optional(),
+  customEvents: z2.array(analyticsCustomEventRowSchema).optional(),
+  eventBreakdown: z2.array(analyticsEventBreakdownRowSchema).optional(),
+  customFunnel: z2.array(analyticsCustomFunnelStepSchema).optional(),
+  deviceBreakdown: z2.array(analyticsDeviceRowSchema).optional(),
+  realtime: analyticsRealtimeSchema.optional(),
+  adDimensions: z2.array(analyticsAdDimensionRowSchema).optional(),
+  adParams: z2.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: z2.array(analyticsAdParamRowSchema).optional(),
+  adPlatformTraffic: z2.array(analyticsAdPlatformTrafficSchema).optional(),
+  flowDestinations: z2.array(analyticsFlowDestinationsSchema).optional(),
+  /** Present only on a report that was asked for by the page. */
+  pageInfo: analyticsPageInfoSchema.optional(),
+  conversions: z2.array(analyticsConversionRowSchema).optional(),
+  /** Every event these pages produced, counted or not. The "add a conversion" picker. */
+  eventCatalog: z2.array(analyticsEventCatalogRowSchema).optional(),
+  timeline: z2.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: z2.array(analyticsTimelineRowSchema).optional(),
+  /** How each line of a people search on `stream` was read — what `personTerms` points at. */
+  peopleSearch: z2.array(peopleSearchTermSchema).optional(),
+  visitorSessions: z2.array(analyticsVisitorSessionSchema).optional(),
+  /** Every key this person is known by — contact details, browsers, clicks, cookies. */
+  personKeys: z2.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: z2.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: z2.object({
+    window: analyticsWindowSchema,
+    totals: analyticsTotalsSchema
+  }).optional()
+});
+var analyticsQueryResponseSchema = z2.object({
+  ok: z2.literal(true),
+  data: analyticsQueryDataSchema,
+  warnings: z2.array(analyticsWarningSchema).optional(),
+  hints: z2.array(z2.string()).optional()
+});
+var analyticsConversionsRequestSchema = z2.object({
+  set: z2.array(
+    z2.object({
+      /** `form:<flow>:<step>:<trigger>` | `submit:<flow>` | `page:<name>` | `exit:<host>`. */
+      eventKey: z2.string().max(320),
+      name: z2.string().max(MAX_CONVERSION_NAME),
+      countMode: z2.enum(CONVERSION_COUNT_MODES).optional()
+    })
+  ).max(60).optional(),
+  remove: z2.array(z2.string().max(320)).max(60).optional(),
+  /** Every key counted under `from` moves to `to`, and the sends under the name go with it. */
+  rename: z2.object({ from: z2.string().min(1).max(MAX_CONVERSION_NAME), to: z2.string().min(1).max(MAX_CONVERSION_NAME) }).optional()
+});
+var analyticsConversionsResponseSchema = z2.object({
+  ok: z2.literal(true),
+  data: z2.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: z2.array(
+      z2.object({
+        eventKey: z2.string(),
+        name: z2.string(),
+        countMode: z2.string(),
+        updatedAt: z2.number(),
+        staged: z2.boolean().optional()
+      })
+    ),
+    /** This chat's proposal, when it has one: counted from Publish, and gone if the chat is discarded. */
+    staged: z2.object({
+      set: z2.array(z2.object({ eventKey: z2.string(), name: z2.string() })),
+      remove: z2.array(z2.string())
+    }).optional()
+  }),
+  hints: z2.array(z2.string()).optional()
+});
+var analyticsMappingRequestSchema = z2.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: z2.enum(AD_PLATFORMS).optional(),
+  /** Parameter name → role, on `platform`. Merged over what is stored. */
+  set: z2.record(z2.string().max(64), adParamRoleSchema).optional(),
+  /** Parameter names to stop reading, on `platform`. Applied after `set`. */
+  remove: z2.array(z2.string().max(64)).max(64).optional()
+});
+var analyticsMappingResponseSchema = z2.object({
+  ok: z2.literal(true),
+  data: z2.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: z2.record(z2.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: z2.array(z2.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: z2.record(
+      z2.string(),
+      z2.object({
+        status: z2.enum(["confirmed", "contradicted", "unseen", "not_read"]),
+        macro: z2.string().optional(),
+        suggestedRole: adParamRoleSchema.optional(),
+        source: z2.string().optional(),
+        reason: z2.string().optional()
+      })
+    ).optional(),
+    updatedAt: z2.number().nullable()
+  }),
+  hints: z2.array(z2.string()).optional()
+});
+var analyticsTrackingRequestSchema = z2.object({
+  platform: z2.enum(AD_PLATFORMS).optional(),
+  days: z2.number().int().min(1).max(365).optional()
+});
+var trackingDimensionSchema = z2.object({
+  role: adParamRoleSchema,
+  /** The platform's own macro for it — what goes in the URL. */
+  macro: z2.string(),
+  /** The account's own spelling where it has one, else the canonical name. */
+  name: z2.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: z2.enum(["covered", "unmapped", "missing", "unknown"]),
+  evidence: z2.string().optional(),
+  note: z2.string().optional()
+});
+var analyticsTrackingPlatformSchema = z2.object({
+  platform: z2.enum(AD_PLATFORMS),
+  label: z2.string(),
+  sessions: z2.number(),
+  /** Whether the ad account itself could be read, and why not when it could not. */
+  account: z2.object({ read: z2.boolean(), templates: z2.number(), reason: z2.string().optional() }),
+  dimensions: z2.array(trackingDimensionSchema),
+  /** Names the URLs already carry that Baker does not read yet. */
+  unmapped: z2.record(z2.string(), adParamRoleSchema),
+  mapCommand: z2.string(),
+  unexplained: z2.array(z2.object({ name: z2.string(), value: z2.string() })),
+  /** The pairs to append to the account's tagging, or `""`. */
+  suffix: z2.string(),
+  whereItGoes: z2.string(),
+  /** Which level to put them at, who can write it, and how an existing value is treated. */
+  fix: z2.string()
+});
+var analyticsTrackingResponseSchema = z2.object({
+  ok: z2.literal(true),
+  data: z2.object({ days: z2.number(), platforms: z2.array(analyticsTrackingPlatformSchema) }),
+  hints: z2.array(z2.string()).optional()
+});
+var boundedReference = (max) => z2.string().transform((value) => cutToLength(value, max));
+var submissionRecordRequestSchema = z2.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: z2.string().min(1),
+  /** Shared with every destination this submit was sent to, and with its event. */
+  submissionId: z2.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: z2.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: z2.record(z2.string(), z2.string()).transform(boundSubmissionAnswers)
+});
+
+// ../api/src/analytics/trackingPlan.ts
+import { z as z4 } from "zod";
+
+// ../api/src/funnel/wire.ts
+import { z as z3 } from "zod";
+
+// ../api/src/funnel/stepTemplates.ts
+var FUNNEL_STEP_TEMPLATES = [
+  {
+    key: "saw_offer",
+    displayName: "Saw the offer",
+    meaning: "Someone opened one of your landing pages \u2014 where most journeys start",
+    stepClass: "visited",
+    classNote: "The only `visited` template: a landing being viewed is a step, never an outcome.",
+    aliases: ["saw the offer", "visited", "landing viewed", "page viewed", "visit", "visitor"],
+    // Never sent anywhere: every platform already counts its own page views,
+    // and uploading a view as a conversion would teach it to optimise for
+    // nothing.
+    platformDefaults: {}
+  },
+  {
+    key: "lead",
+    displayName: "Lead",
+    meaning: "Someone left their details \u2014 the starting point of most journeys",
+    stepClass: "lead",
+    aliases: ["lead", "new lead", "inbound lead", "enquiry", "inquiry", "form submission"],
+    platformDefaults: {
+      meta: { eventName: "Lead", standard: true },
+      googleAds: { category: "Submit lead form" },
+      linkedin: { type: "LEAD", verified: true }
+    }
+  },
+  {
+    key: "signed_up",
+    displayName: "Signed up",
+    meaning: "Someone created an account",
+    stepClass: "lead",
+    classNote: "Same fact as a lead reached a different way \u2014 we now know who they are.",
+    aliases: ["signed up", "sign up", "registered", "registration", "account created", "new user"],
+    platformDefaults: {
+      meta: { eventName: "CompleteRegistration", standard: true },
+      googleAds: { category: "Sign-up" },
+      linkedin: { type: "SIGN_UP", verified: true }
+    }
+  },
+  {
+    key: "add_to_cart",
+    displayName: "Added to cart",
+    meaning: "Something went into the cart",
+    stepClass: "engaged",
+    aliases: ["added to cart", "add to cart", "cart"],
+    platformDefaults: {
+      meta: { eventName: "AddToCart", standard: true },
+      googleAds: { category: "Add to cart" },
+      linkedin: { type: "ADD_TO_CART", verified: true }
+    }
+  },
+  {
+    key: "checkout_started",
+    displayName: "Started checkout",
+    meaning: "The checkout began",
+    stepClass: "engaged",
+    aliases: ["started checkout", "checkout started", "checkout", "begin checkout"],
+    platformDefaults: {
+      meta: { eventName: "InitiateCheckout", standard: true },
+      googleAds: { category: "Begin checkout" },
+      // Written from the documentation and never checked against the live
+      // enum, which is what `verified: false` is for — carried as a caveat
+      // rather than quietly resolved.
+      linkedin: { type: "START_CHECKOUT", verified: false, fallback: "OTHER" }
+    }
+  },
+  {
+    key: "trial_started",
+    displayName: "Trial started",
+    meaning: "A free trial began",
+    stepClass: "engaged",
+    classNote: "A trial is use, not payment \u2014 engaged, never customer.",
+    aliases: ["trial", "trial started", "free trial", "in trial"],
+    platformDefaults: {
+      meta: { eventName: "StartTrial", standard: true },
+      googleAds: { category: "Sign-up" },
+      linkedin: { type: "OTHER", verified: true }
+    }
+  },
+  {
+    key: "qualified_lead",
+    displayName: "Qualified lead",
+    meaning: "The lead matches who you sell to",
+    stepClass: "engaged",
+    aliases: ["qualified lead", "qualified", "mql", "sql", "sales qualified lead", "marketing qualified lead"],
+    platformDefaults: {
+      meta: { eventName: "QualifiedLead", standard: false },
+      googleAds: { category: "Qualified lead" },
+      linkedin: { type: "QUALIFIED_LEAD", verified: true }
+    }
+  },
+  {
+    key: "contacted",
+    displayName: "Contacted",
+    meaning: "Your team reached out",
+    stepClass: "engaged",
+    classNote: "Engaged even though the move came from the seller: it is a real forward interaction.",
+    aliases: ["contacted", "contact", "outreach", "follow up", "first contact", "attempting contact"],
+    platformDefaults: {
+      meta: { eventName: "Contact", standard: true },
+      googleAds: { category: "Contact" },
+      linkedin: { type: "CONTACT", verified: true }
+    }
+  },
+  {
+    key: "meeting_scheduled",
+    displayName: "Meeting booked",
+    meaning: "A meeting is on the calendar",
+    stepClass: "engaged",
+    aliases: [
+      "meeting booked",
+      "meeting scheduled",
+      "demo scheduled",
+      "demo booked",
+      "appointment booked",
+      "call booked"
+    ],
+    platformDefaults: {
+      meta: { eventName: "Schedule", standard: true },
+      googleAds: { category: "Book appointment" },
+      // LinkedIn has SCHEDULE and BOOK_APPOINTMENT separately; the second is the
+      // one that means a reservation.
+      linkedin: { type: "BOOK_APPOINTMENT", verified: true }
+    }
+  },
+  {
+    key: "meeting_held",
+    displayName: "Meeting held",
+    meaning: "The meeting actually happened \u2014 kept apart from booking because no-show is a real number",
+    stepClass: "engaged",
+    aliases: ["meeting held", "meeting done", "demo held", "demo done", "demo completed", "call held"],
+    platformDefaults: {
+      meta: { eventName: "MeetingHeld", standard: false },
+      googleAds: { category: "Other" },
+      linkedin: { type: "OTHER", verified: true }
+    }
+  },
+  {
+    key: "opportunity",
+    displayName: "Opportunity open",
+    meaning: "A deal is open \u2014 send the estimated value if you have one",
+    stepClass: "engaged",
+    classNote: "A number behind an intention is still no money, so engaged rather than customer.",
+    aliases: ["opportunity", "proposal sent", "proposal", "negotiation", "in negotiation", "quote sent", "deal open"],
+    platformDefaults: {
+      meta: { eventName: "Opportunity", standard: false },
+      googleAds: { category: "Request quote" },
+      linkedin: { type: "REQUEST_QUOTE", verified: true }
+    }
+  },
+  {
+    key: "won",
+    displayName: "Deal won",
+    meaning: "The deal closed \u2014 the amount is required here",
+    stepClass: "customer",
+    aliases: ["won", "closed won", "deal won", "purchase", "sale"],
+    platformDefaults: {
+      meta: { eventName: "Purchase", standard: true },
+      // Which of the two depends on whether the company reports a revenue
+      // amount. It is a per-company answer, so it stays a fork, not a constant.
+      googleAds: { category: "Purchase", alternative: "Converted lead" },
+      linkedin: { type: "PURCHASE", verified: true }
+    }
+  },
+  {
+    key: "subscribed",
+    displayName: "Subscription started",
+    meaning: "A paying subscription began \u2014 the amount is the recurring one",
+    stepClass: "customer",
+    classNote: "Customer, not repeat: it is the first money. Repeat is what happens after \u2014 see the renewed template.",
+    aliases: ["subscribed", "subscription started", "new subscription", "paying"],
+    platformDefaults: {
+      meta: { eventName: "Subscribe", standard: true },
+      googleAds: { category: "Purchase" },
+      linkedin: { type: "PURCHASE", verified: true }
+    }
+  },
+  {
+    key: "renewed",
+    displayName: "Subscription renewed",
+    meaning: "An existing customer paid again or expanded \u2014 the amount is what they paid this time",
+    stepClass: "repeat",
+    classNote: "The smallest honest member of `repeat`. Without it every SaaS funnel drawn from this library ends at `subscribed` and the stage has nothing to hold. The recurring lifecycle beyond renewal \u2014 upgrades, churn, refunds \u2014 is a bigger conversation than a template.",
+    aliases: ["renewed", "renewal", "subscription renewed", "expansion", "upsell"],
+    platformDefaults: {
+      meta: { eventName: "Renewed", standard: false },
+      googleAds: { category: "Purchase" },
+      linkedin: { type: "PURCHASE", verified: true }
+    }
+  },
+  {
+    key: "application_submitted",
+    displayName: "Application submitted",
+    meaning: "Someone submitted an application \u2014 a course, a policy, a credit line",
+    stepClass: "engaged",
+    classNote: "For education, events, fintech and insurance. Strong intent, no money yet.",
+    aliases: ["application submitted", "application", "applied", "application received"],
+    platformDefaults: {
+      meta: { eventName: "SubmitApplication", standard: true },
+      googleAds: { category: "Submit lead form" },
+      linkedin: { type: "SUBMIT_APPLICATION", verified: true }
+    }
+  },
+  {
+    key: "lost",
+    displayName: "Lost",
+    meaning: "It did not go ahead \u2014 the deal fell through, or the lead was never a fit",
+    stepClass: "lost",
+    classNote: "Terminal and never sent anywhere. It can happen at any depth, which is why the order check leaves it alone.",
+    aliases: [
+      "lost",
+      "closed lost",
+      "deal lost",
+      "no budget",
+      "not interested",
+      "disqualified",
+      "unqualified",
+      "not a fit",
+      "spam",
+      "duplicate",
+      "junk"
+    ],
+    platformDefaults: {}
+  }
+];
+var TEMPLATES_BY_KEY = new Map(
+  FUNNEL_STEP_TEMPLATES.map((template) => [template.key, template])
+);
+var FUNNEL_VERTICALS = [
+  "b2b_sales",
+  "b2b_inbound",
+  "saas_self_serve",
+  "saas_sales_assisted",
+  "ecommerce_purchase"
+];
+
+// ../api/src/funnel/vocabulary.ts
+var FUNNEL_STEP_CLASSES = [
+  /** Saw the offer: a landing opened, an ad clicked through. */
+  "visited",
+  /** We know who they are: a form sent, an account created. */
+  "lead",
+  /** Something real happened: a call booked, a trial started, a quote asked for, a cart filled. */
+  "engaged",
+  /** Paid, or signed. */
+  "customer",
+  /** Paid again, renewed, or grew. */
+  "repeat",
+  /** Terminal. Did not go ahead, or was never a fit. */
+  "lost"
+];
+
+// ../api/src/funnel/wire.ts
+var MAX_STEPS = 40;
+var MAX_PER_STEP = 20;
+var funnelTriggerSchema = z3.discriminatedUnion("kind", [
+  z3.object({
+    id: z3.string().min(1).max(64),
+    kind: z3.literal("event"),
+    /** The event's key, from `--moments`: `form:…`, `submit:…`, `page:…`, `exit:…`. */
+    eventKey: z3.string().min(1).max(320)
+  }),
+  z3.object({
+    id: z3.string().min(1).max(64),
+    kind: z3.literal("landing"),
+    /** The landing's internal id — what the page stamps on its rows, never its slug. */
+    landingId: z3.string().min(1).max(120)
+  }),
+  /** Any landing being viewed — what a funnel's first step usually listens for. */
+  z3.object({
+    id: z3.string().min(1).max(64),
+    kind: z3.literal("any_landing")
+  })
+]);
+var funnelStepSchema = z3.object({
+  /** Lowercase letters, digits and underscores. Stable — renaming never changes it. */
+  key: z3.string().min(1).max(64),
+  /** The client's own words for this step. Shown everywhere; unconstrained. */
+  displayName: z3.string().min(1).max(120),
+  stepClass: z3.enum(FUNNEL_STEP_CLASSES),
+  /** Predecessor keys. Empty means people come in here. */
+  after: z3.array(z3.string().max(64)).max(MAX_STEPS).default([]),
+  /** What moves somebody onto this step. Any one of them is enough. */
+  triggers: z3.array(funnelTriggerSchema).max(MAX_PER_STEP).default([])
+});
+var funnelRequestSchema = z3.object({
+  steps: z3.array(funnelStepSchema).max(MAX_STEPS).optional(),
+  /** One step, added or replaced by its key. Everything else is untouched. */
+  step: funnelStepSchema.optional(),
+  /** One step taken out by key; whatever came after it moves up to whatever came before it. */
+  removeStep: z3.string().min(1).max(64).optional(),
+  /**
+   * ONE way in added to a step, leaving the rest of that step alone.
+   *
+   * `step` takes a whole step, so adding a way in through it means restating
+   * the step's name, stage, `after[]` and every trigger it already had — and a
+   * trigger left out of that restatement is silently removed. This is the door
+   * for the thing that is actually being asked ("this Form's booking should
+   * count here"), and it cannot drop anything.
+   */
+  addTrigger: z3.object({ stepKey: z3.string().min(1).max(64), eventKey: z3.string().min(1).max(320) }).optional(),
+  /** ONE way in taken off a step, by the event key it listens for. */
+  removeTrigger: z3.object({ stepKey: z3.string().min(1).max(64), eventKey: z3.string().min(1).max(320) }).optional(),
+  /** One of the ready-made graphs, instead of stating steps. */
+  preset: z3.enum(FUNNEL_VERTICALS).optional(),
+  /** Also return the suggestion library and the presets. */
+  templates: z3.boolean().optional(),
+  /**
+   * Also return everything a trigger can name: every event this company's
+   * Forms, pages and systems have actually produced, its sources, and its
+   * landings. The list to pick a trigger FROM, so nobody has to guess.
+   */
+  moments: z3.boolean().optional(),
+  /** How many days the counts beside each step cover. Default 30. */
+  days: z3.number().int().min(1).max(400).optional(),
+  /**
+   * The Forms, by slug, the caller names itself when no step counts them —
+   * `baker funnel` reads its own workspace and names each with the key that
+   * places it. The backend leaves them out of its own hint, so no Form is
+   * named twice.
+   */
+  namedByCaller: z3.array(z3.string().min(1).max(200)).max(1e3).optional()
+});
+var funnelResponseSchema = z3.object({
+  ok: z3.literal(true),
+  data: z3.object({
+    /** The published version, or 0 when this company has never drawn a funnel. */
+    version: z3.number(),
+    /** Whether `steps` is a proposal waiting on this chat's publish rather than what is live. */
+    staged: z3.boolean(),
+    steps: z3.array(
+      z3.object({
+        key: z3.string(),
+        displayName: z3.string(),
+        stepClass: z3.string(),
+        after: z3.array(z3.string()),
+        triggers: z3.array(z3.record(z3.string(), z3.unknown())),
+        /**
+         * Where the people who reach this step are sent: the sends of every
+         * system event among its triggers. Read-only here — a send belongs to
+         * the event and is set with `baker analytics sends`.
+         */
+        sends: z3.array(
+          z3.object({
+            id: z3.string(),
+            eventKey: z3.string(),
+            platform: z3.string(),
+            event: z3.string(),
+            /** What happened to it in the window, in one line. */
+            outcome: z3.string().optional()
+          })
+        ),
+        /** How many people reached this step in the window. Counted in people, across visits and devices. */
+        people: z3.number().optional(),
+        /** How many reached this step or any step after it. */
+        atLeast: z3.number().optional(),
+        /** How many got as far as the step before it. Absent for a way in. */
+        before: z3.number().optional(),
+        /** `atLeast / before`, 0–1. Absent where there is no before. */
+        share: z3.number().optional(),
+        events: z3.number().optional(),
+        money: z3.record(z3.string(), z3.number()).optional()
+      })
+    ),
+    /** The window `people` and friends were counted over. */
+    window: z3.object({ startDate: z3.string(), endDate: z3.string(), days: z3.number() }).optional(),
+    /** The step that loses the most people, by key. Absent while nothing is lost. */
+    worstStep: z3.string().optional(),
+    /**
+     * The steps this write took off the funnel, by key. Present on every write,
+     * empty when nothing was dropped — the answer to "did my restatement forget
+     * one", given in the same turn.
+     */
+    removed: z3.array(z3.string()).optional(),
+    /**
+     * What this company counts as page conversions, this chat's staged counts
+     * included, by event key and name. Here so a Form's ending can say it is
+     * already counted — the agent choosing a step's way in should use that
+     * same key — and outside `moments` because the plain read's hints say it too.
+     */
+    counted: z3.array(z3.object({ eventKey: z3.string(), name: z3.string() })).optional(),
+    /** Everything a trigger can name, when asked for with `moments`. */
+    moments: z3.object({
+      events: z3.array(
+        z3.object({
+          eventKey: z3.string(),
+          /** `site` for a page or Form, `systems` for the client's own server, `both` when both sent it. */
+          origin: z3.string().optional(),
+          /** The Form it belongs to, when it belongs to one. */
+          flowSlug: z3.string().optional(),
+          nodeType: z3.string().optional(),
+          events: z3.number(),
+          sessions: z3.number(),
+          /** The name it is counted under as a page conversion, when the company counts it. Informational. */
+          countedAs: z3.string().optional(),
+          /**
+           * The step of the Form this happens on, in the Form's own words —
+           * never a node id. Present on a Form's ending read from the Form
+           * itself, which is the only place the name is known.
+           */
+          step: z3.string().optional(),
+          /**
+           * `false` on an ending a Form raises natively but nobody has fired
+           * yet — derived from the Form, offered at zero, exactly as a
+           * Source is offered before its first send. Absent means it came
+           * from the event store and therefore happened.
+           */
+          seen: z3.boolean().optional()
+        })
+      ),
+      /** The company's sources: a system of theirs that posts events to Baker, by the event name it raises. */
+      sources: z3.array(z3.object({ eventKey: z3.string(), name: z3.string(), status: z3.string() })),
+      landings: z3.array(z3.object({ landingId: z3.string(), title: z3.string(), slug: z3.string() }))
+    }).optional(),
+    templates: z3.array(
+      z3.object({
+        key: z3.string(),
+        displayName: z3.string(),
+        meaning: z3.string(),
+        stepClass: z3.string()
+      })
+    ).optional(),
+    presets: z3.array(z3.object({ vertical: z3.string(), label: z3.string(), description: z3.string(), steps: z3.array(z3.string()) })).optional(),
+    /**
+     * What each stage means, the test to apply, and the same stage in three
+     * shapes of business.
+     *
+     * The stage is the one thing in a funnel a company does not invent, so it
+     * is the one thing the agent has to get right on the company's behalf —
+     * and "engaged: did something real" cannot settle whether a trial is
+     * engaged or customer. Same source as the dashboard's stage picker, so the
+     * two cannot teach it differently.
+     */
+    stages: z3.array(
+      z3.object({
+        stepClass: z3.string(),
+        title: z3.string(),
+        meaning: z3.string(),
+        test: z3.string(),
+        examples: z3.object({ shop: z3.string(), selfServe: z3.string(), salesLed: z3.string() })
+      })
+    ).optional()
+  }),
+  hints: z3.array(z3.string()).optional()
+});
+
+// ../api/src/analytics/trackingPlan.ts
+var text = z4.string().trim().min(1).max(2e3);
+var key = z4.string().trim().min(1).max(100);
+var webUrl = z4.url().refine((value) => ["https:", "http:"].includes(new URL(value).protocol), "Use a website address");
+var trackingEventSchema = z4.object({
+  eventKey: key.refine((value) => parseEventKey(value) !== null, "Use an existing Baker event key"),
+  name: text,
+  purpose: z4.enum(["conversion", "progress", "diagnostic", "uncounted"]),
+  door: z4.enum(ANALYTICS_EVENT_DOORS),
+  sourceEvent: key.optional(),
+  emitterEvidence: text.optional(),
+  status: z4.enum(["prepared", "waiting", "published", "verified"]),
+  requirement: text.optional(),
+  owner: text.optional(),
+  verificationEvidence: text.optional()
+}).superRefine((event, ctx) => {
+  if (event.status === "waiting") {
+    if (!event.requirement || !event.owner) ctx.addIssue({ code: "custom", message: "A waiting event needs its requirement and owner" });
+  } else if (!event.emitterEvidence) {
+    ctx.addIssue({ code: "custom", message: "A prepared event needs evidence that the source emits it" });
+  }
+  if (["published", "verified"].includes(event.status) && !event.verificationEvidence) {
+    ctx.addIssue({ code: "custom", message: "Published or verified tracking needs evidence; a staged tag is only prepared" });
+  }
+});
+var trackingJourneySchema = z4.object({
+  key,
+  name: text,
+  entryUrls: z4.array(webUrl).max(50),
+  destinationUrl: webUrl,
+  strategy: z4.enum(["native", "embed", "api", "link"]),
+  status: z4.enum(["supported", "waiting"]),
+  requiredFields: z4.array(key).max(100),
+  attribution: text,
+  acceptanceEvidence: text.optional(),
+  continuationEvidence: text.optional(),
+  requirement: text.optional(),
+  owner: text.optional()
+}).superRefine((journey, ctx) => {
+  if (journey.strategy === "link" && journey.requiredFields.length > 0) ctx.addIssue({ code: "custom", message: "A link handoff must not capture details that the destination asks for again" });
+  if (journey.status === "waiting" && (!journey.requirement || !journey.owner)) ctx.addIssue({ code: "custom", message: "A waiting journey needs its requirement and owner" });
+  if (journey.status === "supported" && journey.strategy === "api" && (!journey.acceptanceEvidence || !journey.continuationEvidence)) ctx.addIssue({ code: "custom", message: "An API replacement needs accepted-submission and continuation evidence" });
+});
+var trackingPlanSchema = z4.object({
+  journeys: z4.array(trackingJourneySchema).max(30),
+  events: z4.array(trackingEventSchema).max(100)
+}).superRefine((plan, ctx) => {
+  for (const entries of [plan.journeys.map((journey) => journey.key), plan.events.map((event) => event.eventKey)]) {
+    if (new Set(entries).size !== entries.length) ctx.addIssue({ code: "custom", message: "Each journey and event must appear once" });
+  }
+});
+var variableName = z4.string().trim().min(1).max(200).refine((value) => !/[{}<>"'\\\r\n]/.test(value), "Use a plain container variable name");
+var trackingInstallationSchema = z4.object({
+  containerId: key,
+  baseTagName: key,
+  folderId: key.optional(),
+  consent: z4.enum(["auto", "strict"]).default("auto"),
+  measure: z4.enum(["campaigns", "outcomes", "all"]).default("campaigns"),
+  events: z4.array(z4.object({
+    eventKey: key.refine((value) => parseEventKey(value) !== null, "Use an existing Baker event key"),
+    tagName: key,
+    triggerId: key,
+    properties: z4.record(key, variableName).default({}),
+    eventIdVariable: variableName.optional()
+  })).max(50)
+});
+var trackingPlanRequestSchema = z4.object({ chatId: z4.string().optional(), plan: trackingPlanSchema.optional(), wireConversions: z4.boolean().default(false), steps: z4.array(funnelStepSchema).max(30).optional(), installation: trackingInstallationSchema.optional() }).superRefine((request, ctx) => {
+  if (!request.plan && (request.installation || request.wireConversions || request.steps)) ctx.addIssue({ code: "custom", message: "Preparation needs the agreed tracking plan" });
+});
+var trackingPlanResponseSchema = z4.object({ ok: z4.literal(true), data: z4.object({ plan: trackingPlanSchema.nullable(), staged: z4.boolean() }), hints: z4.array(z4.string()).optional() });
+
+export {
+  formEventKey,
+  isLandingViewKey,
+  parseEventKey,
+  FUNNEL_VERTICALS,
+  funnelRequestSchema,
+  AD_PARAM_ROLE_SPECS,
+  RESERVED_PARAM_NAMES,
+  isAdPlatform,
+  AD_PLATFORM_DEFINITIONS,
+  essentialAdDimensions,
+  builtinAdParamMapping,
+  CONVERSION_COUNT_MODES,
+  STEP_SUBMIT_TRIGGERS,
+  PEOPLE_SEARCH_MAX_TERMS,
+  parsePeopleQuery,
+  peopleLookupRequestSchema,
+  SEND_FILTERS,
+  ANALYTICS_EVENT_DOORS,
+  trackingPlanSchema,
+  trackingPlanRequestSchema,
+  trackingPlanResponseSchema
+};
+//# sourceMappingURL=chunk-HR6IWNKE.js.map