@koda-sl/baker-cli 0.452.0-dev.b7636f278 → 0.453.0-dev.914a088e4

package/dist/funnel-MQ2QSCXI.js

@@ -0,0 +1,837 @@
+import {
+  flowEventKeys
+} from "./chunk-EDU6N5NY.js";
+import {
+  flowDataPath,
+  listFlowSlugs
+} from "./chunk-ILBL7RHT.js";
+import {
+  parseEventKey
+} from "./chunk-SSJK7FEV.js";
+import "./chunk-EDLZGTGN.js";
+import {
+  writeJsonEnvelope
+} from "./chunk-XNMSJP2X.js";
+import "./chunk-IDYAVGCS.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-TEINLN64.js";
+import "./chunk-ZJWUBJYQ.js";
+import "./chunk-NE4F3FHN.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-PCKVSSVT.js";
+import "./chunk-MCM3HMNZ.js";
+import "./chunk-UW36KPPH.js";
+import {
+  registerSchema
+} from "./chunk-NU7JSWVA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/funnel/index.ts
+import { readFileSync } from "fs";
+import { defineCommand } from "citty";
+
+// src/commands/funnel/formMoments.ts
+function offeredEndings(form) {
+  return flowEventKeys(form.tree, form.slug).filter((ending) => ending.isCompletion || ending.nodeId === null);
+}
+function formMoments(events, forms, counted) {
+  const endings = /* @__PURE__ */ new Map();
+  for (const form of forms) {
+    for (const ending of offeredEndings(form)) endings.set(ending.eventKey, { slug: form.slug, ending });
+  }
+  const known = events.map((event) => {
+    const found = endings.get(event.eventKey);
+    if (found === void 0) return event;
+    endings.delete(event.eventKey);
+    return { ...event, step: found.ending.nodeName };
+  });
+  const unfired = [...endings.values()].map(({ slug, ending }) => {
+    const countedAs = counted.get(ending.eventKey);
+    return {
+      eventKey: ending.eventKey,
+      origin: "site",
+      flowSlug: slug,
+      ...ending.nodeType === null ? {} : { nodeType: ending.nodeType },
+      events: 0,
+      sessions: 0,
+      step: ending.nodeName,
+      seen: false,
+      ...countedAs === void 0 ? {} : { countedAs }
+    };
+  });
+  return [...known, ...unfired];
+}
+function withFormMoments(moments, forms, counted) {
+  return { ...moments, events: formMoments(moments.events, forms, counted) };
+}
+function formsNamedHere(forms) {
+  return forms.filter((form) => flowEventKeys(form.tree, form.slug).length > 0).map((form) => form.slug);
+}
+function unplacedFormHints(steps, forms, counted) {
+  const onAStep = new Set(
+    steps.flatMap((step) => (step.triggers ?? []).flatMap((trigger) => trigger.eventKey ? [trigger.eventKey] : []))
+  );
+  const unplaced = [];
+  for (const form of forms) {
+    const endings = flowEventKeys(form.tree, form.slug);
+    if (endings.length === 0 || endings.some((ending) => onAStep.has(ending.eventKey))) continue;
+    const countedOn = endings.filter((ending) => counted.has(ending.eventKey));
+    unplaced.push(
+      countedOn.length === 0 ? form.slug : `${form.slug} (counted as ${countedOn.map((ending) => `"${counted.get(ending.eventKey)}" on \`${ending.eventKey}\``).join(", ")})`
+    );
+  }
+  if (unplaced.length === 0) return [];
+  return [
+    `${unplaced.length} Form(s) in this workspace reach no funnel step, so they move nobody along it however many people finish them: ${unplaced.join("; ")}. Which ending moves somebody to which step is your call: \`baker funnel --moments\` lists every Form's endings by the step each happens on, and when the step names do not make it obvious \u2014 a Form that branches into a rejection and a confirmation \u2014 ask the person which one means a lead or a customer. Place it with \`baker funnel --add-trigger <step> --event <key>\`. A Form already counted as a page conversion goes on the funnel by THAT SAME key, or the two numbers disagree for ever.`
+  ];
+}
+
+// ../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/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/wire.ts
+import { z } from "zod";
+var MAX_STEPS = 40;
+var MAX_PER_STEP = 20;
+var funnelTriggerSchema = z.discriminatedUnion("kind", [
+  z.object({
+    id: z.string().min(1).max(64),
+    kind: z.literal("event"),
+    /** The event's key, from `--moments`: `form:…`, `submit:…`, `page:…`, `exit:…`. */
+    eventKey: z.string().min(1).max(320)
+  }),
+  z.object({
+    id: z.string().min(1).max(64),
+    kind: z.literal("landing"),
+    /** The landing's internal id — what the page stamps on its rows, never its slug. */
+    landingId: z.string().min(1).max(120)
+  }),
+  /** Any landing being viewed — what a funnel's first step usually listens for. */
+  z.object({
+    id: z.string().min(1).max(64),
+    kind: z.literal("any_landing")
+  })
+]);
+var funnelStepSchema = z.object({
+  /** Lowercase letters, digits and underscores. Stable — renaming never changes it. */
+  key: z.string().min(1).max(64),
+  /** The client's own words for this step. Shown everywhere; unconstrained. */
+  displayName: z.string().min(1).max(120),
+  stepClass: z.enum(FUNNEL_STEP_CLASSES),
+  /** Predecessor keys. Empty means people come in here. */
+  after: z.array(z.string().max(64)).max(MAX_STEPS).default([]),
+  /** What moves somebody onto this step. Any one of them is enough. */
+  triggers: z.array(funnelTriggerSchema).max(MAX_PER_STEP).default([])
+});
+var funnelRequestSchema = z.object({
+  steps: z.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: z.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: z.object({ stepKey: z.string().min(1).max(64), eventKey: z.string().min(1).max(320) }).optional(),
+  /** ONE way in taken off a step, by the event key it listens for. */
+  removeTrigger: z.object({ stepKey: z.string().min(1).max(64), eventKey: z.string().min(1).max(320) }).optional(),
+  /** One of the ready-made graphs, instead of stating steps. */
+  preset: z.enum(FUNNEL_VERTICALS).optional(),
+  /** Also return the suggestion library and the presets. */
+  templates: z.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: z.boolean().optional(),
+  /** How many days the counts beside each step cover. Default 30. */
+  days: z.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: z.array(z.string().min(1).max(200)).max(1e3).optional()
+});
+var funnelResponseSchema = z.object({
+  ok: z.literal(true),
+  data: z.object({
+    /** The published version, or 0 when this company has never drawn a funnel. */
+    version: z.number(),
+    /** Whether `steps` is a proposal waiting on this chat's publish rather than what is live. */
+    staged: z.boolean(),
+    steps: z.array(
+      z.object({
+        key: z.string(),
+        displayName: z.string(),
+        stepClass: z.string(),
+        after: z.array(z.string()),
+        triggers: z.array(z.record(z.string(), z.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: z.array(
+          z.object({
+            id: z.string(),
+            eventKey: z.string(),
+            platform: z.string(),
+            event: z.string(),
+            /** What happened to it in the window, in one line. */
+            outcome: z.string().optional()
+          })
+        ),
+        /** How many people reached this step in the window. Counted in people, across visits and devices. */
+        people: z.number().optional(),
+        /** How many reached this step or any step after it. */
+        atLeast: z.number().optional(),
+        /** How many got as far as the step before it. Absent for a way in. */
+        before: z.number().optional(),
+        /** `atLeast / before`, 0–1. Absent where there is no before. */
+        share: z.number().optional(),
+        events: z.number().optional(),
+        money: z.record(z.string(), z.number()).optional()
+      })
+    ),
+    /** The window `people` and friends were counted over. */
+    window: z.object({ startDate: z.string(), endDate: z.string(), days: z.number() }).optional(),
+    /** The step that loses the most people, by key. Absent while nothing is lost. */
+    worstStep: z.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: z.array(z.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: z.array(z.object({ eventKey: z.string(), name: z.string() })).optional(),
+    /** Everything a trigger can name, when asked for with `moments`. */
+    moments: z.object({
+      events: z.array(
+        z.object({
+          eventKey: z.string(),
+          /** `site` for a page or Form, `systems` for the client's own server, `both` when both sent it. */
+          origin: z.string().optional(),
+          /** The Form it belongs to, when it belongs to one. */
+          flowSlug: z.string().optional(),
+          nodeType: z.string().optional(),
+          events: z.number(),
+          sessions: z.number(),
+          /** The name it is counted under as a page conversion, when the company counts it. Informational. */
+          countedAs: z.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: z.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: z.boolean().optional()
+        })
+      ),
+      /** The company's sources: a system of theirs that posts events to Baker, by the event name it raises. */
+      sources: z.array(z.object({ eventKey: z.string(), name: z.string(), status: z.string() })),
+      landings: z.array(z.object({ landingId: z.string(), title: z.string(), slug: z.string() }))
+    }).optional(),
+    templates: z.array(
+      z.object({
+        key: z.string(),
+        displayName: z.string(),
+        meaning: z.string(),
+        stepClass: z.string()
+      })
+    ).optional(),
+    presets: z.array(z.object({ vertical: z.string(), label: z.string(), description: z.string(), steps: z.array(z.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: z.array(
+      z.object({
+        stepClass: z.string(),
+        title: z.string(),
+        meaning: z.string(),
+        test: z.string(),
+        examples: z.object({ shop: z.string(), selfServe: z.string(), salesLed: z.string() })
+      })
+    ).optional()
+  }),
+  hints: z.array(z.string()).optional()
+});
+
+// src/commands/funnel/funnelArgs.ts
+var FunnelArgsError = class extends Error {
+  /** Structured remediation, in the shape the CLI's error envelope carries. */
+  fix;
+  constructor(message, fix) {
+    super(message);
+    this.name = "FunnelArgsError";
+    if (fix) {
+      this.fix = fix;
+    }
+  }
+};
+function parseFunnelArgs(raw) {
+  const steps = parseSteps(raw.steps);
+  const step = parseStep(raw.step);
+  const removeStep = parseRemoveStep(raw["remove-step"] ?? raw.removeStep);
+  const preset = parsePreset(raw.preset);
+  const addTrigger = parseWayIn(raw["add-trigger"] ?? raw.addTrigger, raw.event, "--add-trigger");
+  const removeTrigger = parseWayIn(raw["remove-trigger"] ?? raw.removeTrigger, raw.event, "--remove-trigger");
+  const doors = [steps, step, removeStep, preset, addTrigger, removeTrigger].filter(
+    (door) => door !== void 0
+  ).length;
+  if (doors > 1) {
+    throw new FunnelArgsError(
+      "Give one of --steps, --step, --remove-step, --preset, --add-trigger or --remove-trigger, not two."
+    );
+  }
+  const days = raw.days === void 0 ? void 0 : Number(raw.days);
+  if (days !== void 0 && (!Number.isInteger(days) || days <= 0 || days > 400)) {
+    throw new FunnelArgsError("--days must be a whole number of days, from 1 to 400.");
+  }
+  return {
+    ...steps === void 0 ? {} : { steps },
+    ...step === void 0 ? {} : { step },
+    ...removeStep === void 0 ? {} : { removeStep },
+    ...preset === void 0 ? {} : { preset },
+    ...addTrigger === void 0 ? {} : { addTrigger },
+    ...removeTrigger === void 0 ? {} : { removeTrigger },
+    templates: raw.templates === true,
+    moments: raw.moments === true,
+    ...days === void 0 ? {} : { days }
+  };
+}
+function funnelWrite(args2) {
+  const body = {
+    ...args2.steps === void 0 ? {} : { steps: args2.steps },
+    ...args2.step === void 0 ? {} : { step: args2.step },
+    ...args2.removeStep === void 0 ? {} : { removeStep: args2.removeStep },
+    ...args2.preset === void 0 ? {} : { preset: args2.preset },
+    ...args2.addTrigger === void 0 ? {} : { addTrigger: args2.addTrigger },
+    ...args2.removeTrigger === void 0 ? {} : { removeTrigger: args2.removeTrigger },
+    ...args2.templates ? { templates: true } : {},
+    ...args2.moments ? { moments: true } : {},
+    ...args2.days === void 0 ? {} : { days: args2.days }
+  };
+  const parsed = funnelRequestSchema.safeParse(body);
+  if (!parsed.success) {
+    const issue = parsed.error.issues[0];
+    throw new FunnelArgsError(
+      `That funnel cannot be sent \u2014 ${issue?.path.join(".") || "steps"}: ${issue?.message ?? "invalid"}`,
+      {
+        action: "read_the_schema",
+        explanation: "Run `baker schema funnel` for the exact shape of one step, or `baker funnel --templates` for sixteen worked examples plus every field an event carries."
+      }
+    );
+  }
+  return parsed.data;
+}
+function parseSteps(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (typeof raw !== "string") {
+    throw new FunnelArgsError("--steps takes a JSON array of steps.");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (cause) {
+    throw new FunnelArgsError(`--steps is not valid JSON: ${cause instanceof Error ? cause.message : "parse failed"}`, {
+      action: "quote_the_json",
+      explanation: `Wrap the whole array in single quotes so the shell leaves the double quotes alone: --steps '[{"key":"lead",...}]'.`
+    });
+  }
+  if (!Array.isArray(parsed)) {
+    throw new FunnelArgsError("--steps takes an ARRAY of steps, even when the funnel has one step.");
+  }
+  refuseRetiredShapes(parsed);
+  return parsed;
+}
+function parseStep(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (typeof raw !== "string") {
+    throw new FunnelArgsError("--step takes one step as a JSON object.");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (cause) {
+    throw new FunnelArgsError(`--step is not valid JSON: ${cause instanceof Error ? cause.message : "parse failed"}`, {
+      action: "quote_the_json",
+      explanation: `Wrap the object in single quotes so the shell leaves the double quotes alone: --step '{"key":"demo",...}'.`
+    });
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new FunnelArgsError("--step takes ONE step as an object. To restate several, use --steps with an array.");
+  }
+  refuseRetiredShapes([parsed]);
+  return parsed;
+}
+function parseRemoveStep(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (typeof raw !== "string" || raw.trim() === "") {
+    throw new FunnelArgsError("--remove-step takes the key of the step to take off, as `baker funnel` lists it.");
+  }
+  return raw.trim();
+}
+function refuseRetiredShapes(steps) {
+  for (const step of steps) {
+    if (typeof step !== "object" || step === null) continue;
+    const key = String(step.key ?? "?");
+    if ("offlineConversions" in step) {
+      throw new FunnelArgsError(`Step "${key}" puts sends on the step, and a send belongs to the conversion.`, {
+        action: "set_sends_on_the_conversion",
+        explanation: "Drop `offlineConversions`. Name the outcome with `baker analytics conversions`, then `baker analytics sends --set --conversion <name> --platform <p> --tag <tagId> --event <e>`; the step reads its conversions' sends back as `sends[]`."
+      });
+    }
+    const triggers = step.triggers;
+    if (!Array.isArray(triggers)) continue;
+    const kinds = triggers.map(
+      (trigger) => typeof trigger === "object" && trigger !== null ? trigger.kind : void 0
+    );
+    if (kinds.includes("analytics") || kinds.includes("conversion")) {
+      const word = kinds.includes("analytics") ? "analytics" : "conversion";
+      throw new FunnelArgsError(
+        `Step "${key}" has a \`${word}\` trigger, and a step is reached by an event or a landing only.`,
+        {
+          action: "use_an_event_trigger",
+          explanation: 'Pick the moment from `baker funnel --moments` and write it as `{"kind":"event","eventKey":"<from moments.events or moments.sources>"}` \u2014 nothing has to be named first. A landing is `{"kind":"landing","landingId":"<from moments.landings>"}`.'
+        }
+      );
+    }
+  }
+}
+function parsePreset(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (typeof raw !== "string" || !FUNNEL_VERTICALS.includes(raw)) {
+    throw new FunnelArgsError(`--preset must be one of: ${FUNNEL_VERTICALS.join(", ")}`, {
+      action: "list_the_presets",
+      explanation: "Run `baker funnel --templates` to see what each preset contains before picking one."
+    });
+  }
+  return raw;
+}
+function parseWayIn(stepKey, eventKey, flag) {
+  if (stepKey === void 0) return void 0;
+  if (typeof stepKey !== "string" || stepKey.trim() === "") {
+    throw new FunnelArgsError(`${flag} takes the key of the step to change: \`${flag} lead\`.`);
+  }
+  if (typeof eventKey !== "string" || eventKey.trim() === "") {
+    throw new FunnelArgsError(`${flag} needs --event, naming what gets somebody there.`, {
+      action: "read_the_moments",
+      explanation: `Run \`baker funnel --moments\` and copy an \`events[].eventKey\` \u2014 a Form's own outcome is listed there at zero before anybody has filled it in. Then: \`${flag} ${stepKey.trim()} --event "<key>"\`.`
+    });
+  }
+  const key = eventKey.trim();
+  if (flag === "--add-trigger" && parseEventKey(key) === null) {
+    throw new FunnelArgsError(`"${key}" is not an event key, so nothing would ever reach that step through it.`, {
+      action: "read_the_moments",
+      explanation: "Run `baker funnel --moments` and copy an `events[].eventKey`. They look like form:<form>:<step>:<trigger>, submit:<form>, page:<name> or view:<landing>."
+    });
+  }
+  return { stepKey: stepKey.trim(), eventKey: key };
+}
+
+// src/commands/funnel/index.ts
+var args = {
+  steps: {
+    type: "string",
+    description: 'The WHOLE funnel, as a JSON array. One object per step: {"key":"meeting_held","displayName":"Demo held","stepClass":"engaged","after":["lead"],"triggers":[{"id":"t1","kind":"event","eventKey":"page:demo_held"}]}. It REPLACES the funnel rather than adding to it, so read first and restate everything you want to keep. `key` is permanent and reaches reporting and URLs (lowercase, digits, underscores); `displayName` is the client\'s own words and can be anything. `stepClass` is the stage, one of visited, lead, engaged, customer, repeat, lost \u2014 six plain words every business has, used to compare one company\'s funnel with another\'s. `after` is a LIST, so two ways into one step is expressible and normal. `triggers` is what MOVES somebody onto the step, any one of them being enough, and there are three kinds: `{"id":"t1","kind":"event","eventKey":"submit:contact"}` for anything the company\'s Forms, pages or systems produced, used by its own key with nothing named first; `{"id":"t2","kind":"landing","landingId":"<from --moments>"}` for one landing page being viewed; `{"id":"t3","kind":"any_landing"}` for any landing being viewed. Take every key and id from `--moments`. A trigger carries no amount: an event is worth what it says, and a step is worth the sum. Where a step SENDS its people is not written here: a send belongs to the system\'s event (`baker analytics sends`), and the step reads it back as `sends[]`',
+    required: false
+  },
+  step: {
+    type: "string",
+    description: 'ONE step as a JSON object, in the same shape as an entry of --steps. It is added to the funnel as it now stands, or replaces the step with the same `key`, and every other step is left exactly as it is \u2014 the door for adding or changing a stage without restating the rest. Example: --step \'{"key":"demo","displayName":"Demo held","stepClass":"engaged","after":["lead"],"triggers":[{"id":"t1","kind":"event","eventKey":"page:demo_held"}]}\'',
+    required: false
+  },
+  "add-trigger": {
+    type: "string",
+    description: 'The key of ONE step to add a way in to, with `--event` naming what gets somebody there: `--add-trigger lead --event "submit:contact"`. Start here for "this Form should count as a lead" \u2014 it adds that one way in and leaves the step\'s name, stage, `after[]` and every other trigger exactly as they are. Prefer it to `--step`, which takes a WHOLE step and therefore silently removes any trigger the restatement forgets. Adding a key the step already listens for changes nothing. Take the key from `--moments`, never from memory',
+    required: false
+  },
+  "remove-trigger": {
+    type: "string",
+    description: 'The key of ONE step to take a way in OFF, with `--event` naming which: `--remove-trigger lead --event "submit:contact"`. By event key rather than by trigger id, because the id is not something you ever saw. Everything else about the step is untouched',
+    required: false
+  },
+  event: {
+    type: "string",
+    description: "The event key `--add-trigger` or `--remove-trigger` acts on \u2014 an `events[].eventKey` from `--moments`, never invented. Every Form's endings are listed there by the step each happens on, at zero before anybody has filled the Form in; which one means the step is your decision",
+    required: false
+  },
+  "remove-step": {
+    type: "string",
+    description: "The key of one step to take off the funnel. Whatever came after it moves up to whatever came before it, so the chain stays joined. The response lists it under `removed`",
+    required: false
+  },
+  preset: {
+    type: "string",
+    description: "Draw one of the ready-made graphs instead of stating steps: b2b_sales, b2b_inbound, saas_self_serve, saas_sales_assisted, ecommerce_purchase. It draws over the whole funnel \u2014 every company already has one, so prefer --step to change a step. Run --templates first to see what each one contains",
+    required: false
+  },
+  moments: {
+    type: "boolean",
+    description: "Also return everything a trigger can name, so a trigger is PICKED rather than invented: `events` (every event this company's Forms, pages and systems produced in the window, with volume, the Form it belongs to, `origin` \u2014 `site` for a page or Form, `systems` for the client's own server, `both` \u2014 and `countedAs` when the company also counts it as a page conversion, which a trigger does not need; PLUS **every workspace Form's endings** \u2014 each step's completion and its `submit:` \u2014 with the `step` each happens on, at zero and `seen: false` until somebody fires one, so a Form built minutes ago is pickable with nothing set up first, and `countedAs` when the company already counts it. Nothing is marked as the outcome: which ending means a step is YOUR decision \u2014 read the step names, and ask the person when they do not make it obvious (a Form that branches into \u201CNot a fit\u201D and \u201CQuote confirmed\u201D). If the Form is already counted, use that same key, so the step and the conversion agree. `baker analytics conversions --flow <slug>` also lists a widget's housekeeping), `sources` (the client's own systems that post events to Baker, by the `page:<name>` key each raises, pickable before its first send arrives) and `landings` (its pages, by the id a `landing` trigger takes). Use this before writing any `triggers`: a key typed from memory saves, publishes and counts nobody forever. A Form's events need NOTHING set up first \u2014 no Source, no conversion: a Baker page raises them by itself",
+    required: false
+  },
+  days: {
+    type: "string",
+    description: "How many days the counts beside each step cover (default 30, up to 400). Every step comes back with `people` (reached it), `atLeast` (reached it or anything after it), `before` (got as far as the step before) and `share` (atLeast / before) \u2014 counted in PEOPLE across visits and devices, not in visits",
+    required: false
+  },
+  templates: {
+    type: "boolean",
+    description: "Also return the libraries: the suggested steps with their stages, the presets, and `stages[]` (the six stages with the test to apply). Where a step can be sent is not here \u2014 a send belongs to the system's event, and `baker analytics sends` lists the platforms and the tags that can send",
+    required: false
+  }
+};
+registerSchema({
+  command: "funnel",
+  description: "Read the company's funnel, or draw one",
+  args
+});
+var funnelCommand = defineCommand({
+  meta: {
+    name: "funnel",
+    description: 'Start here: run with no flags to see the funnel this company has, with the last 30 days of PEOPLE counted beside every step \u2014 `people` reached it, `atLeast` got at least that far, `before` got as far as the step before, `share` is the ratio, and `worstStep` names where the most people are lost. Every company has one from the day it exists: Visited (any landing) \u2192 Became a lead \u2192 Became a customer, the last two with no way in until somebody gives them one. Then `--moments` for everything a trigger can name (every event the company\'s Forms, pages and systems produced, its sources, its landings, plus each Form\'s own outcome at zero). **To make an event count on a step \u2014 the usual job \u2014 use `--add-trigger <step> --event <key>`:** it adds that one way in and touches nothing else about the step. `--step \'<json>\'` is for adding or renaming a STEP; it replaces the step with that key, so it means restating its `after` and every trigger it keeps, and one left out is gone. A step is reached by three kinds of thing and nothing else: an event by its own key (`{"id":"t1","kind":"event","eventKey":"<from moments.events or moments.sources>"}`), one landing being viewed (`{"id":"t2","kind":"landing","landingId":"<from moments.landings>"}`) or any landing (`{"id":"t3","kind":"any_landing"}`). Nothing has to be named first. Pick every trigger from `--moments`, never from memory. A step with no `triggers` advances NOBODY and reports zero forever without warning \u2014 that is what the hints keep pointing at. There is no default door: a Form is only counted where a trigger names it. Keep it true: a chat that adds a Form, a Source or an event that moves people forward places it on its step in the same chat. Each step comes back with `sends[]`, read-only: where the people who reach it are sent and what happened, read off the system events behind its ways in. A send is set on the event with `baker analytics sends`, never on a step, and once published it spends ad budget \u2014 a failed one is named in the hints. Everything here is STAGED: it becomes the company\'s funnel in one piece when the chat is published \u2014 the client sees it on the canvas in this chat and can edit it there too \u2014 and the previous version stays on file so what was already measured under it is not lost.'
+  },
+  args,
+  run: async ({ args: raw }) => {
+    try {
+      const parsed = parseFunnelArgs(raw);
+      const forms = workspaceForms();
+      const namedByCaller = formsNamedHere(forms);
+      const request = {
+        ...funnelWrite(parsed),
+        ...namedByCaller.length === 0 ? {} : { namedByCaller }
+      };
+      const response = await apiPost("/api/funnel", request);
+      const counted = new Map((response.data.counted ?? []).map((row) => [row.eventKey, row.name]));
+      const data = response.data.moments === void 0 ? response.data : { ...response.data, moments: withFormMoments(response.data.moments, forms, counted) };
+      const hints = [...response.hints ?? [], ...unplacedFormHints(response.data.steps ?? [], forms, counted)];
+      writeJsonEnvelope({
+        ok: true,
+        data,
+        ...hints.length > 0 ? { hints } : {}
+      });
+    } catch (err) {
+      handleError(err);
+    }
+  }
+});
+function handleError(err) {
+  if (err instanceof FunnelArgsError) {
+    writeJsonEnvelope({
+      ok: false,
+      error: { code: "VALIDATION_ERROR", message: err.message, ...err.fix ? { fix: err.fix } : {} }
+    });
+    process.exit(1);
+  }
+  if (err instanceof ApiError) {
+    writeJsonEnvelope({ ok: false, error: { code: err.code, message: err.message } });
+    process.exit(1);
+  }
+  writeJsonEnvelope({
+    ok: false,
+    error: { code: "NETWORK_ERROR", message: err instanceof Error ? err.message : "Unexpected error" }
+  });
+  process.exit(1);
+}
+function workspaceForms() {
+  const forms = [];
+  for (const slug of listFlowSlugs()) {
+    try {
+      forms.push({ slug, tree: JSON.parse(readFileSync(flowDataPath(slug), "utf-8")) });
+    } catch {
+    }
+  }
+  return forms;
+}
+export {
+  funnelCommand
+};
+//# sourceMappingURL=funnel-MQ2QSCXI.js.map