@koda-sl/baker-cli 0.313.0-dev.64ea8cd98 → 0.313.0-dev.ca75dc08a

package/README.md

@@ -1382,7 +1382,7 @@ baker funnel --steps '[...]'                          # the whole funnel, restat
 
 **Every write says what it dropped.** `--step` changes one step and leaves the rest as it stands; `--steps` replaces the whole funnel and `--preset` draws over it. Every write returns `removed[]` and a `REMOVED steps:` hint when a step went, so a restatement written from a stale read is caught in the same turn.
 
-**A step says what triggers it, and every trigger is PICKED from `--moments`.** `triggers` is a list and any one of them firing is enough. Three kinds: `{"kind":"event","eventKey":"submit:contact"}` for anything the company's Forms, pages or systems produced (`moments.events`, `moments.sources`), `{"kind":"landing","landingId":"<id>"}` for one landing being viewed (`moments.landings`), and `{"kind":"any_landing"}` for any landing — what the default first step listens for. Nothing has to be named first: the event is used by its own key, and the step shows it by its own words. `moments.events[].origin` tells a page's event (`site`) from one the client's own systems sent (`systems`); `moments.sources` lists the client's systems by the `page:<name>` key each raises, pickable before the first send arrives. **A Form's own endings need nothing set up first** — no Source, no conversion: a Baker page raises them natively, so every Form in the workspace contributes one row to `moments.events` — its **outcome** — at zero, carrying `outcome: true`, `seen: false` and the `step` it happens on. It is the same ending `baker analytics conversions` recommends counting, so a step and a conversion land on the same event; `baker analytics conversions --flow <slug>` lists all of one Form's endings when a step wants another. `baker funnel` also hints, in one line, every workspace Form that reaches no step, with its outcome key. Place one with **`baker funnel --add-trigger <step-key> --event <key>`**, which adds a single way in and leaves the step's name, stage, `after[]` and other triggers untouched — `--step` takes a whole step and silently drops any trigger a restatement forgets. That is what makes a Form built minutes ago pickable. A key typed from memory saves, publishes and counts nobody forever — the hint "has a trigger and nobody reached it while N people entered" is that mistake caught after the fact. A step written with `offlineConversions`, a `conversion` trigger or an `analytics` trigger is refused before any round trip, with the shape to use.
+**A step says what triggers it, and every trigger is PICKED from `--moments`.** `triggers` is a list and any one of them firing is enough. Three kinds: `{"kind":"event","eventKey":"submit:contact"}` for anything the company's Forms, pages or systems produced (`moments.events`, `moments.sources`), `{"kind":"landing","landingId":"<id>"}` for one landing being viewed (`moments.landings`), and `{"kind":"any_landing"}` for any landing — what the default first step listens for. Nothing has to be named first: the event is used by its own key, and the step shows it by its own words. `moments.events[].origin` tells a page's event (`site`) from one the client's own systems sent (`systems`); `moments.sources` lists the client's systems by the `page:<name>` key each raises, pickable before the first send arrives. **A Form's own endings need nothing set up first** — no Source, no conversion: a Baker page raises them natively, so every Form in the workspace has its **outcome** marked in `moments.events` with `outcome: true` and the `step` it happens on — a Form nobody has filled in yet gets that row at zero, `seen: false`. It is the same ending `baker analytics conversions` recommends counting, so a step and a conversion land on the same event; `baker analytics conversions --flow <slug>` lists all of one Form's endings when a step wants another. `baker funnel` also hints, in one line, every workspace Form that reaches no step, with its outcome key. Place one with **`baker funnel --add-trigger <step-key> --event <key>`**, which adds a single way in and leaves the step's name, stage, `after[]` and other triggers untouched — `--step` takes a whole step and silently drops any trigger a restatement forgets. That is what makes a Form built minutes ago pickable. A key typed from memory saves, publishes and counts nobody forever — the hint "has a trigger and nobody reached it while N people entered" is that mistake caught after the fact. A step written with `offlineConversions`, a `conversion` trigger or an `analytics` trigger is refused before any round trip, with the shape to use.
 
 **A landing being viewed can be a step** — where most funnels start — and never a conversion: `baker analytics conversions` refuses a `view:` key.
 

package/dist/cli.js

@@ -47238,28 +47238,37 @@ import { defineCommand as defineCommand129 } from "citty";
 // src/commands/funnel/formMoments.ts
 var MAX_NAMED_FORMS = 8;
 function formMoments(events, forms) {
-  const seen = new Set(events.map((event) => event.eventKey));
-  const rows = [];
+  const outcomes = /* @__PURE__ */ new Map();
   for (const form of forms) {
     const outcome = suggestedEnding(flowEventKeys(form.tree, form.slug));
-    if (outcome === null || seen.has(outcome.eventKey)) continue;
-    seen.add(outcome.eventKey);
-    rows.push({
+    if (outcome !== null) outcomes.set(outcome.eventKey, { slug: form.slug, outcome });
+  }
+  const marked = events.map((event) => {
+    const found = outcomes.get(event.eventKey);
+    if (found === void 0) return event;
+    outcomes.delete(event.eventKey);
+    return { ...event, step: found.outcome.nodeName, outcome: true };
+  });
+  const unfired = [...outcomes.values()].map(
+    ({ slug, outcome }) => ({
       eventKey: outcome.eventKey,
       origin: "site",
-      flowSlug: form.slug,
+      flowSlug: slug,
       ...outcome.nodeType === null ? {} : { nodeType: outcome.nodeType },
       events: 0,
       sessions: 0,
       step: outcome.nodeName,
       seen: false,
       outcome: true
-    });
-  }
-  return rows;
+    })
+  );
+  return [...marked, ...unfired];
 }
 function withFormMoments(moments, forms) {
-  return { ...moments, events: [...moments.events, ...formMoments(moments.events, forms)] };
+  return { ...moments, events: formMoments(moments.events, forms) };
+}
+function formsNamedHere(forms) {
+  return forms.filter((form) => suggestedEnding(flowEventKeys(form.tree, form.slug)) !== null).map((form) => form.slug);
 }
 function unplacedFormHints(steps, forms) {
   const onAStep = new Set(
@@ -47595,7 +47604,14 @@ var funnelRequestSchema = z44.object({
    */
   moments: z44.boolean().optional(),
   /** How many days the counts beside each step cover. Default 30. */
-  days: z44.number().int().min(1).max(400).optional()
+  days: z44.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: z44.array(z44.string().min(1).max(200)).max(1e3).optional()
 });
 var funnelResponseSchema = z44.object({
   ok: z44.literal(true),
@@ -47943,7 +47959,7 @@ var args3 = {
   },
   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 **one row per Form in this workspace \u2014 its OUTCOME** \u2014 at zero, with `outcome: true`, `seen: false` and the `step` it happens on, so a Form built minutes ago is pickable with nothing set up first. It is the booking on a Form that books, the submit on a Form that submits, and it is the same ending `baker analytics conversions` recommends counting, so the step and the conversion land on the same event. One row and not all seven a Form raises: the rest are rarely what a step wants, and `baker analytics conversions --flow <slug>` lists every ending of one Form when they are before anybody has filled it in), `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",
+    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; with **each Form's OUTCOME in this workspace marked** `outcome: true` and the `step` it happens on \u2014 a Form nobody has filled in yet gets that row at zero, `seen: false`, so a Form built minutes ago is pickable with nothing set up first. It is the booking on a Form that books, the submit on a Form that submits, and it is the same ending `baker analytics conversions` recommends counting, so the step and the conversion land on the same event. One marked row and not all seven a Form raises: the rest are rarely what a step wants, and `baker analytics conversions --flow <slug>` lists every ending of one Form, fired or not), `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: {
@@ -47971,8 +47987,13 @@ var funnelCommand2 = defineCommand129({
   run: async ({ args: raw }) => {
     try {
       const parsed = parseFunnelArgs(raw);
-      const response = await apiPost("/api/funnel", funnelWrite(parsed));
       const forms = workspaceForms();
+      const namedByCaller = formsNamedHere(forms);
+      const request = {
+        ...funnelWrite(parsed),
+        ...namedByCaller.length === 0 ? {} : { namedByCaller }
+      };
+      const response = await apiPost("/api/funnel", request);
       const data = response.data.moments === void 0 ? response.data : { ...response.data, moments: withFormMoments(response.data.moments, forms) };
       const hints2 = [...response.hints ?? [], ...unplacedFormHints(response.data.steps ?? [], forms)];
       writeJsonEnvelope({