@koda-sl/baker-cli 0.531.0 → 0.533.0

package/dist/experiment-MO6MT6OJ.js

@@ -1,1397 +0,0 @@
-import {
-  landingGraphFiles
-} from "./chunk-Z3ENMCFE.js";
-import {
-  repointMoved,
-  variantNumberOf
-} from "./chunk-LA6PPSNA.js";
-import {
-  repeatedValues
-} from "./chunk-ERSX3MKH.js";
-import {
-  writeJsonEnvelope
-} from "./chunk-HPDGVK6R.js";
-import {
-  ApiError,
-  apiPost
-} from "./chunk-B4UVJCJ4.js";
-import "./chunk-AFQF6ISC.js";
-import "./chunk-52IYZCRS.js";
-import {
-  registerSchema
-} from "./chunk-FSGJSREN.js";
-import "./chunk-YQSBHWOI.js";
-
-// src/commands/experiment/index.ts
-import { defineCommand } from "citty";
-
-// src/commands/experiment/composition.ts
-import { readdir, readFile } from "fs/promises";
-import path from "path";
-function sectionsUnder(files, slug) {
-  const prefix = `src/pages/${slug}/`;
-  return files.filter((file) => file.startsWith(prefix) && !file.slice(prefix.length).startsWith("index.")).sort();
-}
-function compositionOf(controlSlug, variantSlug, variantGraph) {
-  return {
-    forked: sectionsUnder(variantGraph, variantSlug),
-    shared: sectionsUnder(variantGraph, controlSlug)
-  };
-}
-async function readComposition(root, controlSlug, variantSlug) {
-  try {
-    const graph = await landingGraphFiles(root, variantSlug);
-    return compositionOf(controlSlug, variantSlug, [...graph]);
-  } catch {
-    return void 0;
-  }
-}
-var FLOW_REFERENCE_RES = [
-  /["'][^"']*flow-engine\/flows\/([A-Za-z0-9._-]+)/g,
-  /data-flow-form\s*=\s*["']([^"']+)["']/g,
-  /flowName\s*=\s*["']([^"']+)["']/g
-];
-function formsReferenced(texts, knownFlows2) {
-  const found = /* @__PURE__ */ new Set();
-  for (const text of texts) {
-    for (const re of FLOW_REFERENCE_RES) {
-      for (const match of text.matchAll(re)) {
-        const flow = match[1];
-        if (flow && knownFlows2.has(flow)) found.add(flow);
-      }
-    }
-  }
-  return [...found].sort();
-}
-function formsOnlyIn(these, those) {
-  const other = new Set(those);
-  return these.filter((flow) => !other.has(flow));
-}
-async function knownFlows(root) {
-  try {
-    const entries = await readdir(path.join(root, "src/lib/flow-engine/flows"), { withFileTypes: true });
-    return new Set(entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name));
-  } catch {
-    return /* @__PURE__ */ new Set();
-  }
-}
-async function readForms(root, slug) {
-  try {
-    const [files, flows] = await Promise.all([landingGraphFiles(root, slug), knownFlows(root)]);
-    if (flows.size === 0) return [];
-    const texts = await Promise.all(
-      [...files].filter((file) => /\.(astro|ts|tsx|js|mjs)$/.test(file)).map((file) => readFile(path.join(root, file), "utf8"))
-    );
-    return formsReferenced(texts, flows);
-  } catch {
-    return [];
-  }
-}
-
-// src/commands/experiment/fold.ts
-import { statSync } from "fs";
-import { cp, mkdir, readdir as readdir2, readFile as readFile2, rm, stat, writeFile } from "fs/promises";
-import path2 from "path";
-var ARCHIVE_ROOT = "src/_variants";
-var QUOTED_RELATIVE = /(['"])(\.\.?\/[^'"]*)\1/g;
-function posix(p) {
-  return p.split(path2.sep).join("/");
-}
-async function isDir(p) {
-  try {
-    return (await stat(p)).isDirectory();
-  } catch {
-    return false;
-  }
-}
-async function filesUnder(dir, prefix = "") {
-  let entries;
-  try {
-    entries = await readdir2(dir, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-  const out = [];
-  for (const entry of entries) {
-    const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
-    if (entry.isDirectory()) out.push(...await filesUnder(path2.join(dir, entry.name), rel));
-    else out.push(rel);
-  }
-  return out.sort();
-}
-var TEXT_EXT = /\.(astro|ts|tsx|js|jsx|mjs|cjs|vue|svelte|md|json|css)$/;
-function archiveRelPath(abs, base) {
-  if (!abs.startsWith(base + path2.sep)) return null;
-  return posix(path2.relative(base, abs));
-}
-async function archiveArm(opts) {
-  const { root, armDir, pageDir, archiveDir, armSlug } = opts;
-  const targets = await archiveContents({ root, armDir, pageDir, armSlug });
-  const archivedBySource = new Map([...targets].map(([rel, abs]) => [abs, path2.join(archiveDir, rel)]));
-  const written = [];
-  for (const [rel, abs] of [...targets].sort()) {
-    const dest = path2.join(archiveDir, rel);
-    await mkdir(path2.dirname(dest), { recursive: true });
-    if (!TEXT_EXT.test(rel)) {
-      await cp(abs, dest);
-    } else {
-      const text = await readFile2(abs, "utf8");
-      await writeFile(dest, repointIntoArchive(text, abs, dest, archivedBySource), "utf8");
-    }
-    written.push(posix(path2.relative(root, dest)));
-  }
-  return written;
-}
-async function archiveContents(opts) {
-  const { root, armDir, pageDir, armSlug } = opts;
-  const graph = await landingGraphFiles(root, armSlug);
-  const reachable = new Set([...graph].map((rel) => path2.resolve(root, rel)));
-  for (const rel of await filesUnder(armDir)) reachable.add(path2.join(armDir, rel));
-  const sorted = [...reachable].sort();
-  const targets = /* @__PURE__ */ new Map();
-  for (const base of [pageDir, armDir]) {
-    for (const abs of sorted) {
-      const rel = archiveRelPath(abs, base);
-      if (rel === null || rel === "_definition.md") continue;
-      targets.set(rel, abs);
-    }
-  }
-  return targets;
-}
-function repointIntoArchive(text, sourceAbs, destAbs, archivedBySource) {
-  const fromDir = path2.dirname(sourceAbs);
-  const toDir = path2.dirname(destAbs);
-  return text.replace(QUOTED_RELATIVE, (match, quote, spec, offset) => {
-    const [specPath, suffix] = splitSuffix(spec);
-    const target = path2.resolve(fromDir, specPath);
-    const resolved = resolveInArchive(target, archivedBySource) ?? resolveOnDisk(target, isImportPosition(text, offset));
-    if (resolved === null) return match;
-    const rel = posix(path2.relative(toDir, resolved));
-    return `${quote}${rel.startsWith(".") ? rel : `./${rel}`}${suffix}${quote}`;
-  });
-}
-function splitSuffix(spec) {
-  const cut = spec.search(/[?#]/);
-  return cut === -1 ? [spec, ""] : [spec.slice(0, cut), spec.slice(cut)];
-}
-var EXTENSIONS = ["", ".astro", ".ts", ".tsx", ".js", ".jsx", ".mjs"];
-function resolveInArchive(base, archivedBySource) {
-  for (const suffix of [...EXTENSIONS, "/index.astro", "/index.ts"]) {
-    const hit = archivedBySource.get(base + suffix);
-    if (hit !== void 0) return hit;
-  }
-  return null;
-}
-function isImportPosition(text, offset) {
-  return /\b(?:from|import|require)\s*\(?\s*$/.test(text.slice(Math.max(0, offset - 64), offset));
-}
-function resolveOnDisk(base, allowDirectoryIndex) {
-  const candidates = allowDirectoryIndex ? [...EXTENSIONS, "/index.astro", "/index.ts", "/index.js"] : EXTENSIONS;
-  for (const suffix of candidates) {
-    try {
-      if (statSync(base + suffix).isFile()) return base + suffix;
-    } catch {
-    }
-  }
-  return null;
-}
-async function promoteVariantFiles(opts) {
-  const { root, pageDir, variantDir } = opts;
-  const written = [];
-  for (const rel of await filesUnder(variantDir)) {
-    if (rel === "_definition.md") continue;
-    const from = path2.join(variantDir, rel);
-    const to = path2.join(pageDir, rel);
-    await mkdir(path2.dirname(to), { recursive: true });
-    if (!TEXT_EXT.test(rel)) {
-      await cp(from, to);
-    } else {
-      const text = await readFile2(from, "utf8");
-      await writeFile(
-        to,
-        repointMoved(text, {
-          fromDir: path2.dirname(from),
-          toDir: path2.dirname(to),
-          movedFrom: variantDir,
-          movedTo: pageDir
-        }),
-        "utf8"
-      );
-    }
-    written.push(posix(path2.relative(root, to)));
-  }
-  return written;
-}
-function archiveRecord(target, variantNumber) {
-  return `${JSON.stringify(
-    {
-      experimentId: target.experimentId,
-      page: target.landingSlug,
-      pageInternalId: target.landingInternalId,
-      variant: target.variantSlug,
-      variantNumber,
-      // Which arm this snapshot is. On a control win the variant lost; on a
-      // variant win what lost is the page's own previous content, which never
-      // had a number of its own — so it is filed under the test that rejected
-      // it, which is the only number that means anything about it.
-      arm: target.survivor === "variant" ? "page-before-this-test" : "variant"
-    },
-    null,
-    2
-  )}
-`;
-}
-async function foldExperiment(root, target) {
-  const pageDir = path2.resolve(root, "src/pages", target.landingSlug);
-  const variantDir = path2.resolve(root, "src/pages", target.variantSlug);
-  const variantNumber = variantNumberOf(target.variantSlug);
-  if (variantNumber === null) {
-    return {
-      error: `\u201C${target.variantSlug}\u201D is not a variant of \u201C${target.landingSlug}\u201D, so there is nothing to fold`
-    };
-  }
-  if (!await isDir(pageDir)) {
-    return { error: `There is no page at src/pages/${target.landingSlug}/` };
-  }
-  if (!await isDir(variantDir)) {
-    return { error: `src/pages/${target.variantSlug}/ is already gone \u2014 this test looks folded in already` };
-  }
-  const archiveKey = target.landingInternalId ?? target.landingSlug;
-  const archiveDir = path2.resolve(root, ARCHIVE_ROOT, archiveKey, String(variantNumber));
-  await rm(archiveDir, { recursive: true, force: true });
-  await mkdir(archiveDir, { recursive: true });
-  const written = await archiveArm({
-    root,
-    armDir: target.survivor === "variant" ? pageDir : variantDir,
-    pageDir,
-    archiveDir,
-    armSlug: target.survivor === "variant" ? target.landingSlug : target.variantSlug
-  });
-  await writeFile(path2.join(archiveDir, "_variant.json"), archiveRecord(target, variantNumber), "utf8");
-  written.push(posix(path2.join(ARCHIVE_ROOT, archiveKey, String(variantNumber), "_variant.json")));
-  if (target.survivor === "variant") {
-    written.push(...await promoteVariantFiles({ root, pageDir, variantDir }));
-  }
-  await rm(variantDir, { recursive: true, force: true });
-  return {
-    experimentId: target.experimentId,
-    page: target.landingSlug,
-    archivedTo: posix(path2.join(ARCHIVE_ROOT, archiveKey, String(variantNumber))),
-    written,
-    removed: [`src/pages/${target.variantSlug}`]
-  };
-}
-
-// ../api/src/experiments/hypothesis.ts
-import { z } from "zod";
-var experimentEvidenceSourceSchema = z.enum([
-  "baker_analytics",
-  "clarity",
-  "ads",
-  "search_console",
-  "research",
-  "inspiration",
-  "client",
-  "hunch"
-]);
-var experimentEvidenceSchema = z.object({
-  source: experimentEvidenceSourceSchema,
-  note: z.string().min(1).max(200),
-  /**
-   * Where to go and look. Not a `z.url()` — a report inside Baker is reached by
-   * a relative path, and rejecting those would push every in-product citation
-   * into the note where nothing can link it.
-   */
-  href: z.string().max(500).optional()
-});
-var experimentHypothesisSchema = z.object({
-  /**
-   * The observation. The one genuinely new field, and the reason for the rest.
-   *
-   * Without it a lost test teaches nothing, because there is no belief for the
-   * result to be evidence against — which is how a testing programme ends up as
-   * a list of tests instead of a list of things learned.
-   */
-  because: z.string().min(1).max(300),
-  /**
-   * The change, in the client's words.
-   *
-   * The machine-checkable truth lives in `plan.composition.forked`; this is what
-   * a person reads. The two are allowed to differ in wording and cannot differ
-   * in fact, because the brief shows both.
-   */
-  change: z.string().min(1).max(200),
-  /** Which way the goal is expected to move. See the note at the top of this file. */
-  expect: z.enum(["increase", "decrease"]).default("increase"),
-  evidence: z.array(experimentEvidenceSchema).max(5).optional()
-});
-var experimentHypothesisOutcomeSchema = z.enum([
-  "supported",
-  "refuted_opposite",
-  "refuted_no_effect",
-  "unanswered"
-]);
-
-// ../api/src/experiments/wait.ts
-var DAY_MS = 24 * 60 * 60 * 1e3;
-function count(value, unit) {
-  return `about ${value} ${unit}${value === 1 ? "" : "s"}`;
-}
-function describeWait(earliestDecisionAt, now) {
-  const days = (earliestDecisionAt - now) / DAY_MS;
-  if (days <= 0) return "any moment now";
-  if (days < 1) return "within a day";
-  if (days < 14) return count(Math.round(days), "day");
-  if (days < 60) return count(Math.round(days / 7), "week");
-  return count(Math.round(days / 30), "month");
-}
-function roughCount(count2) {
-  if (count2 < 10) return `about ${Math.max(1, Math.round(count2)).toLocaleString("en-US")}`;
-  const magnitude = 10 ** Math.max(1, Math.floor(Math.log10(count2)) - 1);
-  return `about ${(Math.round(count2 / magnitude) * magnitude).toLocaleString("en-US")}`;
-}
-
-// src/commands/experiment/hints.ts
-var LIVE_HINT = {
-  keep_running: (row, now) => `${row.experimentId} cannot yet tell the two pages apart \u2014 do not end it hoping for a result. ${describeWait2(row, now)} To the user, say only this in plain words: "${row.summary}" plus how much more data it needs and roughly when. Never quote confidence, chance-better or intervals to them \u2014 those numbers confuse marketers and decide nothing.`,
-  winner: (row) => row.winner === "variant" ? `${row.experimentId} has a winner: the new variant. Run \`baker experiment finish --id ${row.experimentId} --keep variant\` to show it to everyone, then \`baker experiment fold\`.` : `${row.experimentId}: the new version is proven worse and is STILL being shown to half the visitors. Run \`baker experiment finish --id ${row.experimentId} --keep original\` now.`,
-  no_difference: (row) => `${row.experimentId} measured the two pages as alike \u2014 it collected enough traffic to see the change it was looking for, and there was none. End it with \`--keep original\` and test a bigger change \u2014 a headline, an offer, the shape of the page, not a button colour.`,
-  cannot_win: (row) => `${row.experimentId}: the new version cannot win \u2014 even its best case is under the lift this test was looking for, so there is nothing left to find. Run \`baker experiment finish --id ${row.experimentId} --keep original --reason numbers_clear\` and write down what it taught.`,
-  stopped_early_harmful: (row) => `${row.experimentId} is doing damage and is STILL being shown to visitors. Run \`baker experiment finish --id ${row.experimentId} --keep original\` now.`,
-  // Unreachable on a live test — only ending one produces it. The Record is
-  // exhaustive by type so a verdict added upstream fails to compile here rather
-  // than printing nothing.
-  inconclusive: (row) => `${row.experimentId} was ended before it concluded and found nothing.`,
-  invalid: (row) => `${row.experimentId} cannot be read: ${row.invalidReason === "crossover" ? "too many visitors saw both versions" : "the traffic did not split evenly"}. End it with \`--keep original\` and start again rather than reporting anything from it.`
-};
-function describeWait2(row, now) {
-  if (row.willNotConclude) {
-    return "This page's traffic will not settle it at any point, so end it with `--keep original` and test a bigger change.";
-  }
-  if (row.earliestDecisionAt === null) {
-    return "This page has produced no visitors yet, so there is nothing to project a finish date from.";
-  }
-  if (row.stillNeeded === null) {
-    return `It already has the data it needs; the verdict waits only until it has seen a full day of visitors \u2014 ${describeWait(row.earliestDecisionAt, now)}.`;
-  }
-  const needed = `It needs ${roughCount(row.stillNeeded.visitors)} more visitors (${roughCount(row.stillNeeded.conversions)} more conversions) for an answer if the gap holds \u2014 `;
-  return `${needed}${describeWait(row.earliestDecisionAt, now)} at today's traffic (${new Date(row.earliestDecisionAt).toISOString().slice(0, 10)}). A test is gated on this data, never on days.`;
-}
-function pausedNote(row) {
-  return row.status === "paused" ? `${row.experimentId} is paused \u2014 everyone sees the original. \`baker experiment resume --id ${row.experimentId}\` restarts the split with the same sides. ` : "";
-}
-function unlearnedHint(experiments) {
-  const unlearned = experiments.filter(
-    (row) => row.status === "finished" && row.learning === null && row.verdict !== "inconclusive"
-  );
-  if (unlearned.length === 0) return null;
-  const ids = unlearned.map((row) => row.experimentId).join(", ");
-  return `${unlearned.length === 1 ? "One finished test has" : `${unlearned.length} finished tests have`} no learning written down yet (${ids}). Say what it taught in one or two sentences \u2014 what the client should believe about this page now \u2014 with \`baker experiment update --id <id> --learning "\u2026"\`. It is what \`plan\` hands the next test.`;
-}
-function buildStatusHints(experiments, now = Date.now()) {
-  const hints = experiments.filter((row) => row.status !== "finished").map((row) => pausedNote(row) + LIVE_HINT[row.verdict](row, now));
-  const unlearned = unlearnedHint(experiments);
-  if (unlearned) hints.push(unlearned);
-  if (experiments.length === 0) {
-    hints.push(
-      "No tests yet. `baker experiment plan --landing <slug> --variant <slug>` says whether a page has enough traffic for one before you build the alternative."
-    );
-  }
-  return hints;
-}
-function asLift(value) {
-  return `+${Math.round(value * 100)}%`;
-}
-function horizonsHint(plan) {
-  const settled = plan.horizons.filter((horizon) => horizon.detectableLift !== null);
-  if (settled.length === 0) {
-    return "At this page's traffic no window up to 90 days would gather enough visitors to settle anything, at any size of change. The constraint is the traffic, not the test.";
-  }
-  const parts = settled.map((horizon) => `${horizon.days} days \u2192 ${asLift(horizon.detectableLift ?? 0)}`);
-  return `The smallest change each window could settle on this page's traffic: ${parts.join(", ")}. Design the alternative to be at least that different.`;
-}
-function conversionsHint(plan) {
-  if (plan.conversions.length <= 1) return null;
-  const others = plan.conversions.filter((entry) => entry.eventKey !== plan.goal);
-  return `This page's visitors also went on to: ${others.map((entry) => `\`${entry.eventKey}\`${entry.name ? ` (\u201C${entry.name}\u201D)` : ""} \u2014 ${entry.convertingVisitors}`).join(
-    ", "
-  )}. Any of them can be the goal (--goal <key>); the named ones are reported beside it on every result, and decide nothing.`;
-}
-function pastTestLine(test) {
-  const outcome = {
-    supported: "the idea held",
-    refuted_opposite: "the idea was WRONG \u2014 the change made it worse",
-    refuted_no_effect: "no difference \u2014 the change did not matter",
-    unanswered: "never answered"
-  };
-  const kept = test.survivor === "variant" ? "the new version was kept" : "the original was kept";
-  const learning = test.learning ? ` Learning: ${test.learning}` : "";
-  return `\u201C${test.hypothesis.change}\u201D (${test.experimentId}, ${test.ranForDays} days): ${outcome[test.hypothesisOutcome]}; ${kept}${test.againstVerdict ? " against the numbers" : ""}.${learning}`;
-}
-function pastTestsHint(plan) {
-  if (plan.pastTests.length === 0) return null;
-  const lines = plan.pastTests.slice(0, 5).map(pastTestLine);
-  const more = plan.pastTests.length > 5 ? ` \u2026and ${plan.pastTests.length - 5} more \u2014 \`baker experiment history --landing <slug>\` lists them all.` : "";
-  return `This page has been tested before \u2014 read this before choosing what to change, and build on it rather than repeating it: ${lines.join(" ")}${more}`;
-}
-function buildPlanHints(plan) {
-  const horizons = horizonsHint(plan);
-  const past = pastTestsHint(plan);
-  if (!plan.canRun) {
-    return [
-      plan.reason ?? "This test cannot run on this page.",
-      ...horizons && plan.visitors > 0 ? [horizons] : [],
-      ...past ? [past] : [],
-      "A test that cannot conclude is worse than no test \u2014 it still produces a number, and somebody acts on it."
-    ];
-  }
-  const hints = [
-    ...past ? [past] : [],
-    // First, because it changes how every number below should be read: a plan
-    // sized on a stand-in is a guide, and the agent must say so to the client
-    // rather than quote "about 70 days" as though it were measured.
-    ...plan.warning ? [plan.warning] : [],
-    `This test is read on \u201C${plan.goal}\u201D. That is fixed when it starts and cannot be changed later.`,
-    // Fires at the exact moment the hypothesis gets invented, whether or not
-    // the agent read the family doc. `plan` says a question CAN be settled here
-    // and says nothing about which question is worth asking — and a well-run
-    // test of a bad idea spends the page's traffic and returns `no_difference`.
-    "Now decide WHAT to change, from evidence rather than taste. These numbers say which page and which step; they cannot say why. A second opinion answers why \u2014 Microsoft Clarity for what visitors actually do on the page, `baker gsc` for what they searched, `baker ads <platform>` for what the ad promised, `baker ga4` for the client's own measurement. `baker capabilities` lists everything this client has in one call. Message match \u2014 what the ad or the search promised against what the page opens with \u2014 is the cheapest hypothesis worth testing and is wrong surprisingly often.",
-    // The base always works, so a missing integration is never a reason to
-    // stop. Naming what it would have shown is worth more to the client than
-    // either a silent gap or a run that waited.
-    "If none of that is connected, this page's own drop-off is enough to test on \u2014 say which source you lacked and what it would have told you, then run the test anyway. A test never waits on an integration."
-  ];
-  const conversions = conversionsHint(plan);
-  if (conversions) hints.push(conversions);
-  if (plan.estimatedDays !== null && plan.estimatedDays > 60) {
-    hints.push(
-      `At this page's recent traffic it would take about ${plan.estimatedDays} days \u2014 a guide, not a limit: it ends when the numbers are clear, and more traffic (a campaign, ads) shortens it. If the traffic will stay as it is, test a bigger change, which needs fewer visitors to detect.`
-    );
-  }
-  if (horizons) hints.push(horizons);
-  return hints;
-}
-function buildHistoryHints(tests, landing) {
-  if (tests.length === 0) {
-    return [
-      landing ? `No finished test on \u201C${landing}\u201D yet \u2014 nothing to build on, and nothing to avoid repeating. \`baker experiment plan\` says whether the page can settle one.` : "No finished tests yet. `baker experiment plan --landing <slug> --variant <slug>` says whether a page can settle one."
-    ];
-  }
-  const hints = [];
-  const supported = tests.filter((test) => test.hypothesisOutcome === "supported");
-  const refuted = tests.filter((test) => test.hypothesisOutcome === "refuted_opposite");
-  const noEffect = tests.filter((test) => test.hypothesisOutcome === "refuted_no_effect");
-  if (supported.length > 0) {
-    hints.push(
-      `Held: ${supported.map((test) => `\u201C${test.hypothesis.change}\u201D on ${test.landingSlug}`).join("; ")}. Build on these \u2014 the same insight usually has more in it.`
-    );
-  }
-  if (refuted.length > 0) {
-    hints.push(
-      `Made it worse: ${refuted.map((test) => `\u201C${test.hypothesis.change}\u201D on ${test.landingSlug}`).join("; ")}. Do not propose these again as they were; the observation behind each may still be right, the change was not.`
-    );
-  }
-  if (noEffect.length > 0) {
-    hints.push(
-      `Did not matter: ${noEffect.map((test) => `\u201C${test.hypothesis.change}\u201D on ${test.landingSlug}`).join("; ")}. The next change on these pages has to be bigger \u2014 a headline, an offer, the shape of the page.`
-    );
-  }
-  const unlearned = tests.filter((test) => test.learning === null && test.verdict !== "inconclusive");
-  if (unlearned.length > 0) {
-    hints.push(
-      `${unlearned.length === 1 ? "One test has" : `${unlearned.length} tests have`} no learning written down (${unlearned.map((test) => test.experimentId).join(", ")}). Read its numbers and write one: \`baker experiment update --id <id> --learning "\u2026"\`.`
-    );
-  }
-  return hints;
-}
-function buildStartHints(staged) {
-  const hints = [];
-  for (const entry of staged.drift) {
-    hints.push(driftHint(staged, entry));
-  }
-  if (staged.composition && staged.composition.forked.length === 0) {
-    hints.push(
-      `\u201C${staged.variant}\u201D does not have its own copy of any section \u2014 it renders exactly the same page as \u201C${staged.landing}\u201D, so this test cannot find anything. Fork the section you want to test (\`baker landing variant ${staged.landing} --fork Hero.astro\`) and edit only that file.`
-    );
-  }
-  if (staged.newForms.length > 0 && staged.variantGoal === void 0) {
-    const forms = staged.newForms.map((flow) => `\u201C${flow}\u201D`).join(", ");
-    hints.push(
-      `\u201C${staged.variant}\u201D uses ${staged.newForms.length === 1 ? "a Form" : "Forms"} the page does not: ${forms}. The test reads the new version on \`${staged.goal}\`, the page's event \u2014 if the new version converts by reaching this Form's ending instead, it can never convert on that key and the test will call it harmful. Say its own event: \`baker experiment update --id <id> --variant-goal submit:${staged.newForms[0]}\` (or the confirmation step's \`form:${staged.newForms[0]}:<node>:<trigger>\` key, from \`baker analytics conversions --candidates\` once the Form has been opened in the preview).`
-    );
-  }
-  return hints;
-}
-function driftHint(staged, entry) {
-  const suffix = ` Check both versions before reading that number, and give the new version's step its own name if it is not the same action (\`baker analytics conversions --candidates\`).`;
-  if (entry.reason === "trigger_differs") {
-    return `\u201C${staged.landing}\u201D and \u201C${staged.variant}\u201D both count \`${entry.name}\`, but one fires it when the element is **scrolled into view** and the other when the visitor **does something**. Those are two different questions with one answer, and the test will report a difference that is the trigger rather than the page.${suffix}`;
-  }
-  if (entry.reason === "variant_only_missing" || entry.reason === "control_only_missing") {
-    const missing = entry.reason === "variant_only_missing" ? staged.variant : staged.landing;
-    return `Only one version fires \`${entry.name}\` \u2014 \u201C${missing}\u201D does not declare it at all, so it can only ever read zero for that conversion and the comparison will look like a collapse.${suffix}`;
-  }
-  return `Both versions count \`${entry.name}\`, and the section the test changed is what fires it \u2014 the markup around it is not the same on the two pages. If the new version fires it on a different action (a block that is visible from the start rather than one the visitor opens), that conversion is comparing two different things.${suffix}`;
-}
-
-// src/commands/experiment/hypothesis.ts
-var SOURCES = experimentEvidenceSourceSchema.options.join(", ");
-function parseOne(raw) {
-  const separator = raw.indexOf(":");
-  if (separator === -1) {
-    return { error: `Write the evidence as source:note \u2014 for example \`${raw}:what you saw\`. Sources: ${SOURCES}` };
-  }
-  const source = experimentEvidenceSourceSchema.safeParse(raw.slice(0, separator).trim());
-  if (!source.success) {
-    return { error: `\u201C${raw.slice(0, separator).trim()}\u201D is not one of the evidence sources. Use one of: ${SOURCES}` };
-  }
-  const rest = raw.slice(separator + 1).trim();
-  const pipe = rest.lastIndexOf("|");
-  const note = (pipe === -1 ? rest : rest.slice(0, pipe)).trim();
-  const href = pipe === -1 ? void 0 : rest.slice(pipe + 1).trim();
-  if (note === "") {
-    return { error: `Say what ${source.data} showed: --evidence "${source.data}:what you saw"` };
-  }
-  return href ? { source: source.data, note, href } : { source: source.data, note };
-}
-function parseEvidence(raw, rawArgs) {
-  const entries = repeatedValues(rawArgs, "evidence", raw).map((entry) => entry.trim()).filter((entry) => entry !== "");
-  if (entries.length === 0) return void 0;
-  const parsed = [];
-  for (const entry of entries) {
-    const one = parseOne(entry);
-    if ("error" in one) return one;
-    parsed.push(one);
-  }
-  return parsed;
-}
-
-// src/commands/experiment/identity.ts
-import { readFile as readFile3 } from "fs/promises";
-import path3 from "path";
-async function readPageInternalId(root, slug) {
-  try {
-    const text = await readFile3(path3.resolve(root, "src", "pages", slug, "_definition.md"), "utf8");
-    return /^internalId:\s*"?([^"\s]+)"?\s*$/m.exec(text)?.[1];
-  } catch {
-    return void 0;
-  }
-}
-
-// src/commands/experiment/measurement.ts
-import { readFile as readFile4 } from "fs/promises";
-import path4 from "path";
-function eventDeclarationsIn(source) {
-  const found = [];
-  const pattern = /\b(data-baker-(?:view|event))\s*=\s*["']([^"']+)["']/g;
-  for (const match of source.matchAll(pattern)) {
-    const at = match.index;
-    const opens = source.lastIndexOf("<", at);
-    const closes = source.indexOf(">", at);
-    found.push({
-      name: match[2],
-      attribute: match[1],
-      markup: normalise(source.slice(opens < 0 ? at : opens, closes < 0 ? at + match[0].length : closes + 1))
-    });
-  }
-  return found;
-}
-function normalise(markup) {
-  return markup.replace(/\s+/g, " ").trim();
-}
-function measurementDrift(control, variant) {
-  const names = [...new Set([...control, ...variant].map((entry) => entry.name))].sort();
-  return names.flatMap((name) => {
-    const left = control.filter((entry) => entry.name === name);
-    const right = variant.filter((entry) => entry.name === name);
-    if (right.length === 0) return [{ name, reason: "variant_only_missing" }];
-    if (left.length === 0) return [{ name, reason: "control_only_missing" }];
-    if (setOf(left, (entry) => entry.attribute) !== setOf(right, (entry) => entry.attribute)) {
-      return [{ name, reason: "trigger_differs" }];
-    }
-    if (setOf(left, (entry) => entry.markup) !== setOf(right, (entry) => entry.markup)) {
-      return [{ name, reason: "markup_differs" }];
-    }
-    return [];
-  });
-}
-function setOf(entries, of) {
-  return [...new Set(entries.map(of))].sort().join("\n");
-}
-async function readMeasurementDrift(root, controlSlug, composition) {
-  if (!composition) return [];
-  try {
-    const pageSections = sectionsOf([...await landingGraphFiles(root, controlSlug)], controlSlug);
-    const shared = new Set(composition.shared);
-    const [control, variant] = await Promise.all([
-      declarationsOf(
-        root,
-        pageSections.filter((file) => !shared.has(file))
-      ),
-      declarationsOf(root, composition.forked)
-    ]);
-    return measurementDrift(control, variant);
-  } catch {
-    return [];
-  }
-}
-function sectionsOf(files, slug) {
-  const prefix = `src/pages/${slug}/`;
-  return files.filter((file) => file.startsWith(prefix) && !file.slice(prefix.length).startsWith("index."));
-}
-async function declarationsOf(root, files) {
-  const sources = await Promise.all(files.map((file) => readFile4(path4.join(root, file), "utf8").catch(() => "")));
-  return sources.flatMap(eventDeclarationsIn);
-}
-
-// src/commands/experiment/readout.ts
-function isoMoment(ms) {
-  return ms === null ? null : new Date(ms).toISOString();
-}
-function isoDay(ms) {
-  return ms === null ? null : new Date(ms).toISOString().slice(0, 10);
-}
-function compactArm(arm) {
-  return { visitors: arm.visitors, conversions: arm.conversions, rate: Math.round(arm.rate * 1e4) / 1e4 };
-}
-function compactMetric(metric) {
-  return {
-    name: metric.name,
-    reading: metric.reading,
-    control: metric.control.conversions,
-    variant: metric.variant.conversions
-  };
-}
-function fullArm(arm) {
-  return {
-    ...arm,
-    ...arm.snapshotCapturedAt === void 0 ? {} : { snapshotCapturedAt: isoMoment(arm.snapshotCapturedAt) }
-  };
-}
-function statusReadout(row, { full, now }) {
-  const decisionWhen = {
-    earliestDecisionAt: isoDay(row.earliestDecisionAt),
-    ...row.earliestDecisionAt === null ? {} : { earliestDecisionIn: describeWait(row.earliestDecisionAt, now) }
-  };
-  const moments = {
-    // A held test has not started; its `startedAt` is a placeholder the first
-    // resume replaces, and `pausedAt` already dates the hold.
-    ...row.onHold ? {} : { startedAt: isoMoment(row.startedAt) },
-    pausedAt: isoMoment(row.pausedAt),
-    finishedAt: isoMoment(row.finishedAt)
-  };
-  if (full) {
-    return {
-      ...row,
-      ...moments,
-      ...decisionWhen,
-      control: fullArm(row.control),
-      variant: fullArm(row.variant)
-    };
-  }
-  return {
-    experimentId: row.experimentId,
-    landingSlug: row.landingSlug,
-    variantSlug: row.variantSlug,
-    status: row.status,
-    // Published with the split off: `resume` is what starts it, not what restarts it.
-    ...row.onHold ? { onHold: true } : {},
-    verdict: row.verdict,
-    summary: row.summary,
-    ...row.winner === null ? {} : { winner: row.winner },
-    ...row.invalidReason === null ? {} : { invalidReason: row.invalidReason },
-    stillNeeded: row.stillNeeded,
-    ...decisionWhen,
-    willNotConclude: row.willNotConclude,
-    control: compactArm(row.control),
-    variant: compactArm(row.variant),
-    secondary: row.secondary.map(compactMetric),
-    hypothesisStatement: row.hypothesisStatement,
-    minDetectableRelativeLift: row.minDetectableRelativeLift,
-    goal: row.goal,
-    ...row.variantGoal === null ? {} : { variantGoal: row.variantGoal },
-    goalLabel: row.goalLabel,
-    ...moments,
-    ...row.status === "finished" ? {
-      survivor: row.survivor,
-      hypothesisOutcome: row.hypothesisOutcome,
-      fold: row.fold,
-      learning: row.learning,
-      endReason: row.endReason
-    } : {}
-  };
-}
-
-// src/commands/experiment/update.ts
-function buildUpdateRequest(args, rawArgs) {
-  const expect = args.expect === void 0 ? void 0 : String(args.expect);
-  if (expect !== void 0 && expect !== "increase" && expect !== "decrease") {
-    return {
-      error: "`--expect` is either `increase` or `decrease` \u2014 which way should the goal move if you are right?"
-    };
-  }
-  const evidence = parseEvidence(args.evidence, rawArgs);
-  if (evidence && "error" in evidence) return evidence;
-  const lift = args.lift === void 0 ? void 0 : Number(args.lift);
-  if (lift !== void 0 && !(lift > 0)) {
-    return {
-      error: "`--lift` is the smallest improvement worth detecting, relative \u2014 0.2 is +20%. It must be above zero."
-    };
-  }
-  const request = {
-    experimentId: String(args.id),
-    ...typed("because", args.because),
-    ...typed("change", args.change),
-    ...typed("goal", args.goal),
-    ...typed("variantGoal", args.variantGoal),
-    ...typed("learning", args.learning),
-    ...expect === void 0 ? {} : { expect },
-    ...evidence ? { evidence } : {},
-    ...lift === void 0 ? {} : { minDetectableRelativeLift: lift }
-  };
-  if (Object.keys(request).length === 1) {
-    return {
-      error: "Nothing to change. Pass --because, --change or --evidence; on a finished test, --learning; on a test that has not been published yet, also --expect, --goal, --variant-goal or --lift"
-    };
-  }
-  return request;
-}
-function typed(key, value) {
-  return value === void 0 ? {} : { [key]: String(value) };
-}
-
-// src/commands/experiment/index.ts
-var GOAL_ARG = {
-  type: "string",
-  description: "The ONE event the test is read on, by its key: `form:<flow>:<node>:<trigger>` (a Form reaching a step), `submit:<flow>` (a Form finished), `page:<name>` (a page event or one the client's systems post), `exit:<host>` (a click out). `baker analytics conversions --candidates` lists the keys these pages produce, and `plan` lists the ones this page's visitors went on to do. Fixed for the life of the test. Optional when exactly one of them is a named conversion; otherwise say which. Every conversion the company has named is reported beside the goal and decides nothing.",
-  required: false
-};
-var VARIANT_GOAL_ARG = {
-  type: "string",
-  description: "The event the NEW version is read on, when it is not the page's \u2014 a variant that swaps the Form for a shorter one converts on the new Form's ending (`submit:<new-flow>`, or its confirmation step's `form:` key). Same vocabulary as --goal. Leave it out when both versions convert on the same event, which is the common case.",
-  required: false
-};
-var LIFT_ARG = {
-  type: "string",
-  description: "The smallest improvement worth detecting, relative \u2014 0.2 is +20% (default). The single most consequential number here: halving it roughly quadruples the traffic needed. Ask for the smallest lift that would actually change what the client does, not the smallest one you would like to see.",
-  required: false
-};
-var BECAUSE_ARG = {
-  type: "string",
-  description: "What you SAW that makes this worth testing \u2014 the observation, not the change. \u201C60% of visitors never scroll past the hero\u201D, \u201CCPL doubled after the new headline\u201D. This is the field that makes a losing test worth something: without it there is no belief for the result to be evidence against, and the next test is no better informed than this one.",
-  required: true
-};
-var CHANGE_ARG = {
-  type: "string",
-  description: "What is different about the alternative version, in the client's words \u2014 \u201Cput the booking form in the hero\u201D. One thing. Say it as the reader of the report would.",
-  required: true
-};
-var EXPECT_ARG = {
-  type: "string",
-  description: "Which way you expect the goal to move: `increase` (default) or `decrease`. This is what lets Baker report whether your hypothesis HELD, rather than only which page won \u2014 a test the original page wins is not a win, it is the change having made things worse, and that is the most useful thing a test can tell you.",
-  required: false
-};
-var EVIDENCE_ARG = {
-  type: "string",
-  description: "Where the observation came from, as `source:what it showed`, optionally `|link`. Repeatable. Sources: baker_analytics, clarity, ads, search_console, research, inspiration, client, hunch. Use `hunch` honestly when there is no data \u2014 a stated guess is worth more than a guess dressed as analytics.",
-  required: false
-};
-var HOLD_ARG = {
-  type: "boolean",
-  required: false,
-  description: "Publish both versions with the split off, so the client can look at the new version by its link (`/<page>/?_bkr_preview=b`) before any visitor is sent to it. Switch it on afterwards with `baker experiment resume --id <id>`. Use it whenever somebody has to approve the new version first."
-};
-var BASELINE_ARG = {
-  type: "string",
-  description: "The share of visitors you expect to do the goal, as a fraction \u2014 0.05 is 5% \u2014 for a page whose history cannot say: a new page, or one about to get its first campaign. Without it a page with no conversions yet is sized on the company-wide rate for the outcome, or on 3%. The sizing is a guide either way: the test runs until the numbers are clear.",
-  required: false
-};
-var ID_ARG = { type: "string", description: "The test, by its id", required: true };
-var LEARNING_ARG = {
-  type: "string",
-  description: "What this test taught, in one or two sentences the client should believe about this page from now on \u2014 \u201Cthe price is not the objection, the install date is\u201D. The one part of the record the numbers cannot write, and what `plan` hands the next test on this page. Finished tests only.",
-  required: false
-};
-var REASON_ARG = {
-  type: "string",
-  description: "Why the test is being ended, as distinct from what the numbers said: `numbers_clear` (the result was clear enough to act on), `not_settling` (too little traffic or too small a difference \u2014 waiting would not help), `page_changing` (the page has to change for another reason), `test_flawed` (the wrong goal, a broken variant). Always say \u2014 the dashboard asks a person the same question, and the next test on this page is planned differently after each answer.",
-  required: false
-};
-var LANDING_FILTER_ARG = {
-  type: "string",
-  description: "Only the tests on one page, by its slug",
-  required: false
-};
-function sizingHints(data) {
-  return typeof data.warning === "string" ? [data.warning] : [];
-}
-function fail(message) {
-  writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message } });
-  process.exit(1);
-}
-function reportApiError(error) {
-  if (error instanceof ApiError) {
-    writeJsonEnvelope({ ok: false, error: { code: error.code ?? "ERROR", message: error.message } });
-    process.exit(1);
-  }
-  throw error;
-}
-registerSchema({
-  command: "experiment.plan",
-  description: "Whether a page can settle a question, and how long it might take, before anything is built",
-  args: {
-    landing: { type: "string", description: "The page under test, by slug", required: true },
-    variant: { type: "string", description: "The new variant's slug, `<page>--<n>`", required: true },
-    goal: GOAL_ARG,
-    variantGoal: VARIANT_GOAL_ARG,
-    lift: LIFT_ARG,
-    baseline: BASELINE_ARG
-  }
-});
-var planCommand = defineCommand({
-  meta: {
-    name: "plan",
-    description: "Start here, BEFORE building the alternative page. Says which event the test would be read on, which events the page's visitors actually go on to do (by key, with the conversion name each is counted under), how long it might take at this page's traffic, and what a 14, 28, 56 or 90-day window could settle. The duration is a guide, never a finish line \u2014 a test ends when the numbers are clear, and a page with no traffic yet can still be tested (`warning` says what it was sized on). What IS refused is a test that could not be measured: a goal this page has demonstrably never produced."
-  },
-  args: {
-    landing: { type: "string", description: "The page under test, by slug", required: true },
-    variant: { type: "string", description: "The new variant's slug, `<page>--<n>`", required: true },
-    goal: GOAL_ARG,
-    variantGoal: VARIANT_GOAL_ARG,
-    lift: LIFT_ARG,
-    baseline: BASELINE_ARG
-  },
-  run: async ({ args }) => {
-    try {
-      const response = await apiPost("/api/experiments/plan", {
-        landingSlug: String(args.landing),
-        variantSlug: String(args.variant),
-        ...args.goal ? { goal: String(args.goal) } : {},
-        ...args.variantGoal ? { variantGoal: String(args.variantGoal) } : {},
-        ...args.lift ? { minDetectableRelativeLift: Number(args.lift) } : {},
-        ...args.baseline ? { baselineRate: Number(args.baseline) } : {}
-      });
-      writeJsonEnvelope({ ok: true, data: response.data, hints: buildPlanHints(response.data) });
-    } catch (error) {
-      reportApiError(error);
-    }
-  }
-});
-registerSchema({
-  command: "experiment.start",
-  description: "Stage an A/B test between a page and a new variant of it",
-  args: {
-    landing: { type: "string", description: "The page under test, by slug", required: true },
-    variant: { type: "string", description: "The new variant's slug, `<page>--<n>`", required: true },
-    because: BECAUSE_ARG,
-    change: CHANGE_ARG,
-    expect: EXPECT_ARG,
-    evidence: EVIDENCE_ARG,
-    goal: GOAL_ARG,
-    variantGoal: VARIANT_GOAL_ARG,
-    lift: LIFT_ARG,
-    baseline: BASELINE_ARG,
-    hold: HOLD_ARG
-  }
-});
-function startOptions(args) {
-  return {
-    ...args.goal ? { goal: String(args.goal) } : {},
-    ...args.variantGoal ? { variantGoal: String(args.variantGoal) } : {},
-    ...args.lift ? { minDetectableRelativeLift: Number(args.lift) } : {},
-    ...args.baseline ? { baselineRate: Number(args.baseline) } : {},
-    ...args.hold ? { held: true } : {}
-  };
-}
-function stagedHint(held, landing) {
-  return held ? `Staged on hold. Publishing puts both versions live but splits nobody: everyone keeps getting the page, and the new version opens only at /${landing}/?_bkr_preview=b \u2014 send that link to whoever has to approve it, and say that anyone with it can open it (it is not a private link). Once they have, \`baker experiment status --landing ${landing}\` gives the test's id and \`baker experiment resume --id <id>\` switches the split on; the test is dated from then.` : "Staged. The split starts when this session is published \u2014 publishing is the review of the new variant.";
-}
-var startCommand = defineCommand({
-  meta: {
-    name: "start",
-    description: "Stage a test between the page and its new variant. Visitors are split between the two versions at the edge, so there is no flicker and nothing for an ad blocker to suppress. Nothing goes live until the session is published \u2014 the person publishing is the review of the new variant. Re-runs `plan` first and refuses on the same grounds."
-  },
-  args: {
-    landing: { type: "string", description: "The page under test, by slug", required: true },
-    variant: { type: "string", description: "The new variant's slug, `<page>--<n>`", required: true },
-    because: BECAUSE_ARG,
-    change: CHANGE_ARG,
-    expect: EXPECT_ARG,
-    evidence: EVIDENCE_ARG,
-    goal: GOAL_ARG,
-    variantGoal: VARIANT_GOAL_ARG,
-    lift: LIFT_ARG,
-    baseline: BASELINE_ARG,
-    hold: HOLD_ARG
-  },
-  run: async ({ args, rawArgs }) => {
-    const expect = args.expect === void 0 ? "increase" : String(args.expect);
-    if (expect !== "increase" && expect !== "decrease") {
-      fail("`--expect` is either `increase` or `decrease` \u2014 which way should the goal move if you are right?");
-    }
-    const evidence = parseEvidence(args.evidence, rawArgs);
-    if (evidence && "error" in evidence) fail(evidence.error);
-    const { composition, newForms, drift, landingInternalId, variantInternalId } = await readStartContext(
-      String(args.landing),
-      String(args.variant)
-    );
-    try {
-      const response = await apiPost("/api/experiments/start", {
-        landingSlug: String(args.landing),
-        variantSlug: String(args.variant),
-        ...landingInternalId ? { landingInternalId } : {},
-        ...variantInternalId ? { variantInternalId } : {},
-        hypothesis: {
-          because: String(args.because),
-          change: String(args.change),
-          expect,
-          ...evidence ? { evidence } : {}
-        },
-        ...composition ? { composition } : {},
-        ...startOptions(args)
-      });
-      writeJsonEnvelope({
-        ok: true,
-        data: response.data,
-        hints: [
-          ...sizingHints(response.data),
-          ...buildStartHints({
-            landing: String(args.landing),
-            variant: String(args.variant),
-            goal: String(response.data.goal),
-            variantGoal: args.variantGoal === void 0 ? void 0 : String(args.variantGoal),
-            composition,
-            newForms,
-            drift
-          }),
-          stagedHint(Boolean(args.hold), String(args.landing)),
-          "Check it as often as you like \u2014 `baker experiment status` is safe to read at any moment and holds its error rate however often you ask. What is never safe is reading the numbers instead of the verdict: `keep_running` means this test cannot yet tell the two pages apart, whatever the rates happen to say today."
-        ]
-      });
-    } catch (error) {
-      reportApiError(error);
-    }
-  }
-});
-registerSchema({
-  command: "experiment.status",
-  description: "The verdict on every A/B test, running, paused and finished",
-  args: {
-    id: { type: "string", description: "One test, by its id", required: false },
-    landing: LANDING_FILTER_ARG,
-    full: {
-      type: "boolean",
-      description: "Every field the dashboard reads too \u2014 the hypothesis in parts, what each version owns, the preview pictures and the posteriors behind the verdict",
-      required: false
-    }
-  }
-});
-var statusCommand = defineCommand({
-  meta: {
-    name: "status",
-    description: "The verdict on each test. Read `verdict` and nothing else to decide: keep_running | winner | no_difference | cannot_win | invalid. `cannot_win` means even the best case is under the lift the test was looking for \u2014 end it and keep the original. `stillNeeded` is the data (visitors, conversions) the test still needs; a test is gated on data, never on days. `earliestDecisionAt` is the day this page's traffic would get it there (YYYY-MM-DD) and `earliestDecisionIn` how far off that is \u2014 say those, never work a date out yourself. `summary` is one sentence you can show the client, and `secondary` lists every other conversion the company counts on the same two arms \u2014 context, never a second decision. The numbers under `--full` are for printing, never for deciding \u2014 a test that says keep_running has not finished, however good its numbers look."
-  },
-  args: {
-    id: { type: "string", description: "One test, by its id", required: false },
-    landing: LANDING_FILTER_ARG,
-    full: {
-      type: "boolean",
-      description: "Every field the dashboard reads too \u2014 the hypothesis in parts, what each version owns, the preview pictures and the posteriors behind the verdict",
-      required: false
-    }
-  },
-  run: async ({ args }) => {
-    try {
-      const response = await apiPost("/api/experiments/status", {
-        ...args.id ? { experimentId: String(args.id) } : {},
-        ...args.landing ? { landingSlug: String(args.landing) } : {},
-        ...args.full === true ? { full: true } : {}
-      });
-      const now = Date.now();
-      writeJsonEnvelope({
-        ok: true,
-        data: {
-          experiments: response.data.experiments.map((row) => statusReadout(row, { full: args.full === true, now }))
-        },
-        hints: buildStatusHints(response.data.experiments, now)
-      });
-    } catch (error) {
-      reportApiError(error);
-    }
-  }
-});
-registerSchema({
-  command: "experiment.history",
-  description: "Every finished A/B test with what it found and what it taught \u2014 the record to read before proposing the next one",
-  args: {
-    landing: LANDING_FILTER_ARG,
-    limit: { type: "string", description: "At most this many, newest first (default all)", required: false }
-  }
-});
-var historyCommand = defineCommand({
-  meta: {
-    name: "history",
-    description: "What was tested before and what it taught. Finished tests only, newest first: the claim, what was different, what the numbers said, what was kept and whether that went against them, and the `learning` somebody wrote down. Read it \u2014 `--landing <slug>` for one page \u2014 BEFORE proposing a test: a refuted idea proposed again spends the page's traffic to return the same answer, and a supported one is what the next test should build on. `plan` hands the same entries back as `pastTests` for the page it sizes."
-  },
-  args: {
-    landing: LANDING_FILTER_ARG,
-    limit: { type: "string", description: "At most this many, newest first", required: false }
-  },
-  run: async ({ args }) => {
-    const limit = args.limit === void 0 ? void 0 : Number(args.limit);
-    if (limit !== void 0 && !(Number.isInteger(limit) && limit > 0)) fail("`--limit` is a whole number above zero");
-    try {
-      const response = await apiPost("/api/experiments/history", {
-        ...args.landing ? { landingSlug: String(args.landing) } : {},
-        ...limit === void 0 ? {} : { limit }
-      });
-      writeJsonEnvelope({
-        ok: true,
-        data: response.data,
-        hints: buildHistoryHints(response.data.tests, args.landing === void 0 ? void 0 : String(args.landing))
-      });
-    } catch (error) {
-      reportApiError(error);
-    }
-  }
-});
-registerSchema({
-  command: "experiment.finish",
-  description: "End a test now and send all its traffic to the version you name",
-  args: {
-    id: ID_ARG,
-    keep: {
-      type: "string",
-      description: "Which version stays live: `original` or `variant`. Required \u2014 the verdict is a recommendation and this is the decision. A test that has not concluded can be ended too; it is recorded as inconclusive, never as a finding. Going against a verdict is allowed and is recorded as such.",
-      required: true
-    },
-    reason: REASON_ARG,
-    learning: LEARNING_ARG
-  }
-});
-var END_REASONS = ["numbers_clear", "not_settling", "page_changing", "test_flawed"];
-function finishHints(data, given) {
-  const { reason } = given;
-  const args = { learning: given.learning };
-  return [
-    `Done. Everyone now sees the ${data.survivor === "variant" ? "new variant" : "original"}.`,
-    ...data.againstVerdict ? [
-      `You kept the ${data.survivor === "variant" ? "new variant" : "original"} although the numbers favoured the other version (${data.verdict}). That is recorded on the test \u2014 say why in the write-up.`
-    ] : [],
-    ...data.verdict === "keep_running" ? [
-      "This test had not concluded, so it is recorded as inconclusive \u2014 nobody found out. Never report it as no difference."
-    ] : [],
-    ...data.survivor === "variant" ? [
-      "Now run `baker experiment fold` \u2014 it moves the winning version into the page itself and archives the other one. Until that lands the page is served by a rewrite, and it cannot be tested again."
-    ] : [],
-    ...args.learning || data.verdict === "keep_running" ? [] : [
-      'Write down what this taught while it is fresh: `baker experiment update --id <id> --learning "\u2026"` \u2014 one or two sentences the client should believe about this page now. It is what the next test on this page starts from.'
-    ],
-    ...reason ? [] : [
-      "No `--reason` was given, so the record says what the numbers had reached but not why anyone stopped looking. Next time pass one: numbers_clear, not_settling, page_changing or test_flawed."
-    ]
-  ];
-}
-var finishCommand = defineCommand({
-  meta: {
-    name: "finish",
-    description: "End a test now and send all its traffic to the version you name. Takes effect within seconds \u2014 nothing to publish. Read `baker experiment status` first: `winner` says which version the numbers favour, `keep_running` means they have not spoken yet and ending records `inconclusive`. Keeping the variant owes a `fold`. A test staged in this session and not yet published is simply taken back off it."
-  },
-  args: {
-    id: ID_ARG,
-    keep: {
-      type: "string",
-      description: "Which version stays live: `original` or `variant`.",
-      required: true
-    },
-    reason: REASON_ARG,
-    learning: LEARNING_ARG
-  },
-  run: async ({ args }) => {
-    const keep = String(args.keep);
-    if (keep !== "original" && keep !== "variant") {
-      fail("`--keep` is either `original` or `variant` \u2014 which version should everyone see from now on?");
-    }
-    const reason = args.reason === void 0 ? void 0 : String(args.reason);
-    if (reason !== void 0 && !END_REASONS.some((known) => known === reason)) {
-      fail(`\`--reason\` is one of ${END_REASONS.join(", ")} \u2014 why is this test being ended?`);
-    }
-    try {
-      const response = await apiPost(
-        "/api/experiments/finish",
-        {
-          experimentId: String(args.id),
-          keep,
-          ...reason ? { reason } : {},
-          ...args.learning ? { learning: String(args.learning) } : {}
-        }
-      );
-      if ("unstaged" in response.data) {
-        writeJsonEnvelope({
-          ok: true,
-          data: response.data,
-          hints: ["That test had not been published yet, so it was taken back off this session. Nothing was split."]
-        });
-        return;
-      }
-      const data = response.data;
-      writeJsonEnvelope({ ok: true, data, hints: finishHints(data, { reason, learning: args.learning }) });
-    } catch (error) {
-      reportApiError(error);
-    }
-  }
-});
-registerSchema({
-  command: "experiment.cancel",
-  description: "Call a test off \u2014 take a staged one back off the session, or end a live one keeping the original",
-  args: { id: ID_ARG }
-});
-var cancelCommand = defineCommand({
-  meta: {
-    name: "cancel",
-    description: "Call a test off. A test staged in this session and not yet published is simply taken back off it \u2014 nothing was split. A test that is live is ended now with everyone sent back to the original: what the numbers had said is recorded as it stood (usually `inconclusive`), and the variant page stays in the workspace, unserved. `finish --keep` is the same act with the choice of version; this is the shortcut for \u201Cstop, keep the page as it is\u201D."
-  },
-  args: { id: ID_ARG },
-  run: async ({ args }) => {
-    try {
-      const response = await apiPost(
-        "/api/experiments/finish",
-        { experimentId: String(args.id), keep: "original" }
-      );
-      if ("unstaged" in response.data) {
-        writeJsonEnvelope({
-          ok: true,
-          data: response.data,
-          hints: ["That test had not been published yet, so it was taken back off this session. Nothing was split."]
-        });
-        return;
-      }
-      const data = response.data;
-      writeJsonEnvelope({
-        ok: true,
-        data,
-        hints: [
-          "Ended. Everyone sees the original page now, and the split stopped within seconds.",
-          ...data.verdict === "keep_running" ? [
-            "It had not concluded, so it is recorded as inconclusive \u2014 nobody found out. Never report it as no difference."
-          ] : data.againstVerdict ? [
-            `The numbers favoured the new variant (${data.verdict}), so this is recorded as a decision against them. Say why in the write-up.`
-          ] : [],
-          "The variant page is still in the workspace and served to nobody. Run `baker experiment fold` to archive it, or leave it for a later test."
-        ]
-      });
-    } catch (error) {
-      reportApiError(error);
-    }
-  }
-});
-registerSchema({
-  command: "experiment.update",
-  description: "Change what a test says about itself \u2014 its wording always, its measurement only while it is still staged",
-  args: {
-    id: ID_ARG,
-    because: { ...BECAUSE_ARG, required: false },
-    change: { ...CHANGE_ARG, required: false },
-    evidence: EVIDENCE_ARG,
-    expect: { ...EXPECT_ARG, description: "Staged tests only. `increase` or `decrease`." },
-    goal: { ...GOAL_ARG, description: "Staged tests only. The event the test is read on, by key." },
-    variantGoal: {
-      ...VARIANT_GOAL_ARG,
-      description: "Staged tests only. The new version's own event, when it differs."
-    },
-    lift: { ...LIFT_ARG, description: "Staged tests only. The smallest lift worth detecting." },
-    learning: LEARNING_ARG
-  }
-});
-var updateCommand = defineCommand({
-  meta: {
-    name: "update",
-    description: "Change what a test says about itself. The observation (`--because`), the change in the client's words (`--change`) and the evidence cited (`--evidence`) can change at any time \u2014 they describe the test, and a write-up corrected after the fact is still the write-up of the same test. On a FINISHED test, `--learning` writes down what it taught. What the test MEASURES \u2014 `--goal`, `--lift`, `--expect` \u2014 can only change while it is still staged in this session: once visitors have been split, moving the goal or the finish line is how a result gets argued into existence. To measure something else on a live test, `finish` it and start a new one."
-  },
-  args: {
-    id: ID_ARG,
-    because: { ...BECAUSE_ARG, required: false },
-    change: { ...CHANGE_ARG, required: false },
-    evidence: EVIDENCE_ARG,
-    expect: { ...EXPECT_ARG, description: "Staged tests only. `increase` or `decrease`." },
-    goal: { ...GOAL_ARG, description: "Staged tests only. The event the test is read on, by key." },
-    variantGoal: {
-      ...VARIANT_GOAL_ARG,
-      description: "Staged tests only. The new version's own event, when it differs."
-    },
-    lift: { ...LIFT_ARG, description: "Staged tests only. The smallest lift worth detecting." },
-    learning: LEARNING_ARG
-  },
-  run: async ({ args, rawArgs }) => {
-    const request = buildUpdateRequest(args, rawArgs);
-    if ("error" in request) fail(request.error);
-    try {
-      const response = await apiPost("/api/experiments/update", request);
-      writeJsonEnvelope({
-        ok: true,
-        data: response.data,
-        hints: [
-          response.data.staged ? "Updated and re-sized. It still starts when this session is published." : request.learning !== void 0 ? "Updated. What this test taught is on its record now, and `plan` hands it to the next test on this page." : "Updated. The test keeps running exactly as it was \u2014 only its wording changed.",
-          `It now reads: ${response.data.hypothesisStatement}`
-        ]
-      });
-    } catch (error) {
-      reportApiError(error);
-    }
-  }
-});
-registerSchema({
-  command: "experiment.pause",
-  description: "Switch a test's split off \u2014 everyone sees the original until it is resumed",
-  args: { id: ID_ARG }
-});
-var pauseCommand = defineCommand({
-  meta: {
-    name: "pause",
-    description: "Switch the split off now. Everyone sees the original; visitors already assigned keep their side, so resuming continues the same test rather than starting a new one. Use it when the new variant has to come down for a while \u2014 a broken price, a campaign that needs the original \u2014 without throwing the test away."
-  },
-  args: { id: ID_ARG },
-  run: async ({ args }) => {
-    try {
-      await apiPost("/api/experiments/pause", { experimentId: String(args.id) });
-      writeJsonEnvelope({
-        ok: true,
-        data: { paused: true },
-        hints: [
-          `Paused. Everyone sees the original page now. \`baker experiment resume --id ${String(args.id)}\` restarts the split with the same sides.`
-        ]
-      });
-    } catch (error) {
-      reportApiError(error);
-    }
-  }
-});
-registerSchema({
-  command: "experiment.resume",
-  description: "Switch a paused test's split back on \u2014 or, for a test published on hold, switch it on for the first time",
-  args: { id: ID_ARG }
-});
-var resumeCommand = defineCommand({
-  meta: {
-    name: "resume",
-    description: "Switch a paused test's split back on. Visitors already assigned see the same side they saw before. A test published on hold (`start --hold`) starts here, and is dated from now."
-  },
-  args: { id: ID_ARG },
-  run: async ({ args }) => {
-    try {
-      await apiPost("/api/experiments/resume", { experimentId: String(args.id) });
-      writeJsonEnvelope({
-        ok: true,
-        data: { resumed: true },
-        hints: ["Resumed. The split is back on, with the same sides."]
-      });
-    } catch (error) {
-      reportApiError(error);
-    }
-  }
-});
-registerSchema({
-  command: "experiment.fold",
-  description: "Make the page's own content the version that won, and archive the one that lost",
-  args: {
-    id: { type: "string", description: "One test, by its id. Omit to fold every test that owes one", required: false }
-  }
-});
-var foldCommand = defineCommand({
-  meta: {
-    name: "fold",
-    description: "Finish the job a finished test started: move the winning version into the page's own folder, archive the version that lost, and delete the extra page. Until this runs, the page is served by a rewrite at the edge while its own source says something else \u2014 so the repo does not say what the URL serves, and the page cannot be tested again. Start here: run it with no arguments after any test ends, then publish."
-  },
-  args: {
-    id: { type: "string", description: "One test, by its id. Omit to fold every test that owes one", required: false }
-  },
-  run: async ({ args }) => {
-    try {
-      const asked = await apiPost("/api/experiments/fold", {
-        ...args.id ? { experimentId: String(args.id) } : {}
-      });
-      const owed = asked.data.owed;
-      if (owed.length === 0) {
-        writeJsonEnvelope({
-          ok: true,
-          data: { folded: [] },
-          hints: ["Nothing to fold \u2014 every finished test's result is already the page's own content."]
-        });
-        return;
-      }
-      const folded = [];
-      const failures = [];
-      for (const target of owed) {
-        const result = await foldExperiment(process.cwd(), target);
-        if ("error" in result) failures.push(`${target.landingSlug}: ${result.error}`);
-        else folded.push(result);
-      }
-      if (folded.length > 0) {
-        await apiPost("/api/experiments/fold", {
-          applied: true,
-          experimentIds: folded.map((result) => result.experimentId),
-          ...args.id ? { experimentId: String(args.id) } : {}
-        });
-      }
-      writeJsonEnvelope({
-        ok: true,
-        data: { folded, failures },
-        hints: [
-          folded.length > 0 ? `Publish this session to make it real. Until the build lands, the winning version is still served by a rewrite \u2014 Baker drops that by itself once the new pages are live, so there is nothing to do afterwards.` : "Nothing was folded.",
-          ...failures.length > 0 ? [`Could not fold: ${failures.join("; ")}`] : [],
-          ...folded.length > 0 ? [
-            `The version that lost is kept at ${folded.map((f) => f.archivedTo).join(", ")} \u2014 a self-contained copy, so it still shows what was actually measured after the page moves on. Never edit it.`
-          ] : []
-        ]
-      });
-    } catch (error) {
-      reportApiError(error);
-    }
-  }
-});
-var experimentCommand = defineCommand({
-  meta: {
-    name: "experiment",
-    description: "Run an A/B test between a landing page and a new variant of it, and be told which one is better. Always `plan` first: most pages do not get enough traffic to settle most questions, and a test that cannot conclude still produces a number somebody will act on. Nothing ends a test on its own \u2014 `finish` does, when you or the client decide."
-  },
-  subCommands: {
-    plan: planCommand,
-    start: startCommand,
-    update: updateCommand,
-    status: statusCommand,
-    history: historyCommand,
-    pause: pauseCommand,
-    resume: resumeCommand,
-    finish: finishCommand,
-    cancel: cancelCommand,
-    fold: foldCommand
-  }
-});
-async function readStartContext(landing, variant) {
-  const root = process.cwd();
-  const composition = await readComposition(root, landing, variant);
-  const [controlForms, variantForms, landingInternalId, variantInternalId] = await Promise.all([
-    readForms(root, landing),
-    readForms(root, variant),
-    // Each page's own identity, so a renamed folder cannot detach the test —
-    // the variant has no row in Baker until this session is published.
-    readPageInternalId(root, landing),
-    readPageInternalId(root, variant)
-  ]);
-  return {
-    composition,
-    newForms: formsOnlyIn(variantForms, controlForms),
-    // Whether the two versions still fire the company's conversions on the same
-    // action. Nothing downstream can ask this — a split can be perfect while the
-    // two pages disagree about what an event means — and the only place the
-    // answer exists is the workspace this command is already standing in.
-    drift: await readMeasurementDrift(root, landing, composition),
-    landingInternalId,
-    variantInternalId
-  };
-}
-export {
-  experimentCommand
-};
-//# sourceMappingURL=experiment-MO6MT6OJ.js.map