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

package/dist/{funnel-I6XIAEHG.js → funnel-AAX27NH4.js}

@@ -1,24 +1,21 @@
 import {
   flowEventKeys
-} from "./chunk-RL5CP7N6.js";
+} from "./chunk-Y6O7EWYY.js";
 import {
   flowDataPath,
   listFlowSlugs
-} from "./chunk-HROZYQ5H.js";
-import "./chunk-4PDHHHUJ.js";
-import "./chunk-NYIGXDUG.js";
+} from "./chunk-YRQYA2LR.js";
+import {
+  parseEventKey
+} from "./chunk-SSJK7FEV.js";
+import "./chunk-EDLZGTGN.js";
 import {
   writeJsonEnvelope
 } from "./chunk-VFIOJD5M.js";
-import "./chunk-7EPXVICM.js";
+import "./chunk-XF4JUKVF.js";
 import "./chunk-GXDLWBOY.js";
 import "./chunk-TEINLN64.js";
 import "./chunk-ZJWUBJYQ.js";
-import {
-  FUNNEL_VERTICALS,
-  funnelRequestSchema,
-  parseEventKey
-} from "./chunk-HR6IWNKE.js";
 import "./chunk-NE4F3FHN.js";
 import {
   ApiError,
@@ -91,6 +88,453 @@ function unplacedFormHints(steps, forms, counted) {
   ];
 }
 
+// ../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. */
@@ -390,4 +834,4 @@ function workspaceForms() {
 export {
   funnelCommand
 };
-//# sourceMappingURL=funnel-I6XIAEHG.js.map
+//# sourceMappingURL=funnel-AAX27NH4.js.map