@koda-sl/baker-cli 0.531.0 → 0.533.0

package/dist/use-HGX7ZRH5.js

@@ -0,0 +1,111 @@
+import {
+  eachTarget,
+  failWith,
+  positionalTargets,
+  writeTargetRows
+} from "./chunk-PG5R35QY.js";
+import {
+  apiGet,
+  apiPost
+} from "./chunk-CIW3Q7B2.js";
+import "./chunk-O7AMKMII.js";
+import "./chunk-VPF5A7CM.js";
+import {
+  registerSchema
+} from "./chunk-HZPTQRX6.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/images/use.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "images.use",
+  description: "Ingest URLs and wait for the library records to be ready. Several URLs are stored and waited on together, one row each.",
+  args: {
+    url: { type: "string", description: "Image URL; pass several to store and wait on them together", required: true },
+    source: { type: "string", description: "Image source enum", required: false, default: "uploaded" },
+    "max-wait": { type: "number", description: "Max wait ms", required: false, default: 3e4 },
+    context: {
+      type: "string",
+      description: "Free-text hint passed to Gemini describe to bias the generated description and tags",
+      required: false
+    },
+    output: { type: "string", description: "Output format: json|files|md", required: false, default: "json" },
+    fields: { type: "string", description: "Comma-separated field names to include", required: false },
+    full: { type: "boolean", description: "Include full metadata", required: false, default: false }
+  }
+});
+var POLL_INTERVAL_MS = 1500;
+var useCommand = defineCommand({
+  meta: {
+    name: "use",
+    description: "Sugar over `ingest`: download \u2192 store \u2192 wait until describe + embed complete \u2192 return ready library record. Several URLs are stored and waited on together, so a list takes about one image's wait \u2014 pass them all in one call rather than looping; --context applies to every one.\n\nExamples:\n  baker images use https://cdn.example.com/hero.png --source uploaded\n  baker images use https://acme.com/a.jpg https://acme.com/b.jpg --source website"
+  },
+  args: {
+    url: { type: "positional", description: "Image URL; pass several to wait on them together", required: false },
+    source: { type: "string", description: "Source enum", required: false },
+    "max-wait": { type: "string", description: "Max wait ms (default 30000)", required: false },
+    context: { type: "string", description: "Description context hint", required: false },
+    output: { type: "string", description: "Output format: json|files|md", required: false, default: "json" },
+    fields: { type: "string", description: "Comma-separated field names to include", required: false },
+    full: { type: "boolean", description: "Include full metadata", required: false, default: false }
+  },
+  run: async ({ args }) => {
+    const urls = positionalTargets(args);
+    if (urls.length === 0) failWith({ code: "VALIDATION_ERROR", message: "URL is required" });
+    const source = args.source ?? "uploaded";
+    const maxWait = args["max-wait"] ? Number(args["max-wait"]) : 3e4;
+    const ingests = await eachTarget(urls, (url) => {
+      const ingestBody = { url, source };
+      if (args.context) ingestBody.descriptionContext = args.context;
+      return apiPost("/api/images/ingest", ingestBody);
+    });
+    const outcomes = await waitUntilReady(ingests, maxWait);
+    const format = typeof args.output === "string" && args.output.length > 0 ? args.output : "json";
+    writeTargetRows(
+      outcomes.map(
+        (outcome) => outcome.ok ? {
+          ...outcome,
+          data: format === "json" ? { url: outcome.target, ...outcome.data.ingestResult, image: outcome.data.doc } : outcome.data.doc
+        } : outcome
+      ),
+      {
+        format,
+        fields: typeof args.fields === "string" && args.fields.length > 0 ? args.fields.split(",") : void 0,
+        full: args.full === true
+      }
+    );
+  }
+});
+async function waitUntilReady(ingests, maxWait) {
+  const settled = ingests.map(
+    (outcome) => outcome.ok ? void 0 : outcome
+  );
+  const deadline = Date.now() + maxWait;
+  let pending = ingests.flatMap((outcome, index) => outcome.ok ? [{ index, ingestResult: outcome.data }] : []);
+  while (pending.length > 0 && Date.now() < deadline) {
+    const reads = await eachTarget(
+      pending.map(({ ingestResult }) => ingestResult.imageId),
+      (id) => apiGet("/api/images/get", { id })
+    );
+    pending = pending.filter(({ index, ingestResult }, i) => {
+      const read = reads[i];
+      const target = ingests[index].target;
+      if (!read.ok) settled[index] = { target, ok: false, error: read.error };
+      else if (read.data.status === "ready" || read.data.status === "error")
+        settled[index] = { target, ok: true, data: { ingestResult, doc: read.data } };
+      return settled[index] === void 0;
+    });
+    if (pending.length > 0) await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+  }
+  return ingests.map(
+    (outcome, index) => settled[index] ?? {
+      target: outcome.target,
+      ok: false,
+      error: { code: "TIMEOUT", message: `Image not ready within ${maxWait}ms` }
+    }
+  );
+}
+export {
+  useCommand
+};
+//# sourceMappingURL=use-HGX7ZRH5.js.map

package/dist/use-HGX7ZRH5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/images/use.ts"],"sourcesContent":["import type { ImageDoc, ImagesIngestRequest, ImagesIngestResponse } from \"@baker/api\";\nimport { defineCommand } from \"citty\";\nimport { apiGet, apiPost } from \"../../client.ts\";\nimport {\n  eachTarget,\n  failWith,\n  positionalTargets,\n  type TargetOutcome,\n  writeTargetRows,\n} from \"../../lib/batchTargets.ts\";\nimport type { OutputFormat } from \"../../output.ts\";\nimport { registerSchema } from \"../../schemas.ts\";\n\nregisterSchema({\n  command: \"images.use\",\n  description:\n    \"Ingest URLs and wait for the library records to be ready. Several URLs are stored and waited on together, one row each.\",\n  args: {\n    url: { type: \"string\", description: \"Image URL; pass several to store and wait on them together\", required: true },\n    source: { type: \"string\", description: \"Image source enum\", required: false, default: \"uploaded\" },\n    \"max-wait\": { type: \"number\", description: \"Max wait ms\", required: false, default: 30000 },\n    context: {\n      type: \"string\",\n      description: \"Free-text hint passed to Gemini describe to bias the generated description and tags\",\n      required: false,\n    },\n    output: { type: \"string\", description: \"Output format: json|files|md\", required: false, default: \"json\" },\n    fields: { type: \"string\", description: \"Comma-separated field names to include\", required: false },\n    full: { type: \"boolean\", description: \"Include full metadata\", required: false, default: false },\n  },\n});\n\nconst POLL_INTERVAL_MS = 1500;\n\nexport const useCommand = defineCommand({\n  meta: {\n    name: \"use\",\n    description:\n      \"Sugar over `ingest`: download → store → wait until describe + embed complete → return ready library record. Several URLs are stored and waited on together, so a list takes about one image's wait — pass them all in one call rather than looping; --context applies to every one.\\n\\nExamples:\\n  baker images use https://cdn.example.com/hero.png --source uploaded\\n  baker images use https://acme.com/a.jpg https://acme.com/b.jpg --source website\",\n  },\n  args: {\n    url: { type: \"positional\", description: \"Image URL; pass several to wait on them together\", required: false },\n    source: { type: \"string\", description: \"Source enum\", required: false },\n    \"max-wait\": { type: \"string\", description: \"Max wait ms (default 30000)\", required: false },\n    context: { type: \"string\", description: \"Description context hint\", required: false },\n    output: { type: \"string\", description: \"Output format: json|files|md\", required: false, default: \"json\" },\n    fields: { type: \"string\", description: \"Comma-separated field names to include\", required: false },\n    full: { type: \"boolean\", description: \"Include full metadata\", required: false, default: false },\n  },\n  run: async ({ args }) => {\n    const urls = positionalTargets(args);\n    if (urls.length === 0) failWith({ code: \"VALIDATION_ERROR\", message: \"URL is required\" });\n    const source = (args.source as string | undefined) ?? \"uploaded\";\n    const maxWait = args[\"max-wait\"] ? Number(args[\"max-wait\"]) : 30000;\n\n    // Every URL is stored first, then all of them are polled together against\n    // one deadline, so a list costs one max-wait rather than one per wave.\n    const ingests = await eachTarget(urls, (url) => {\n      const ingestBody: ImagesIngestRequest = { url, source: source as ImagesIngestRequest[\"source\"] };\n      if (args.context) ingestBody.descriptionContext = args.context as string;\n      return apiPost<ImagesIngestResponse>(\"/api/images/ingest\", ingestBody);\n    });\n    const outcomes = await waitUntilReady(ingests, maxWait);\n\n    // `json` keeps the ingest result alongside the finished row, which is the\n    // shape callers already parse. The table formats tabulate the row itself —\n    // the ingest result is three scalars with no columns worth printing.\n    const format = typeof args.output === \"string\" && args.output.length > 0 ? (args.output as OutputFormat) : \"json\";\n    writeTargetRows(\n      outcomes.map((outcome) =>\n        outcome.ok\n          ? {\n              ...outcome,\n              data:\n                format === \"json\"\n                  ? { url: outcome.target, ...outcome.data.ingestResult, image: outcome.data.doc }\n                  : outcome.data.doc,\n            }\n          : outcome,\n      ),\n      {\n        format,\n        fields: typeof args.fields === \"string\" && args.fields.length > 0 ? args.fields.split(\",\") : undefined,\n        full: args.full === true,\n      },\n    );\n  },\n});\n\ntype ReadyImage = { ingestResult: ImagesIngestResponse; doc: ImageDoc };\n\n/**\n * Poll every stored image until it is ready or failed, all under one deadline:\n * each round reads only the ones still processing, and whatever is still\n * processing when the deadline passes is reported as a timeout.\n */\nasync function waitUntilReady(\n  ingests: TargetOutcome<ImagesIngestResponse>[],\n  maxWait: number,\n): Promise<TargetOutcome<ReadyImage>[]> {\n  const settled: (TargetOutcome<ReadyImage> | undefined)[] = ingests.map((outcome) =>\n    outcome.ok ? undefined : outcome,\n  );\n  const deadline = Date.now() + maxWait;\n  let pending = ingests.flatMap((outcome, index) => (outcome.ok ? [{ index, ingestResult: outcome.data }] : []));\n  while (pending.length > 0 && Date.now() < deadline) {\n    const reads = await eachTarget(\n      pending.map(({ ingestResult }) => ingestResult.imageId),\n      (id) => apiGet<ImageDoc>(\"/api/images/get\", { id }),\n    );\n    pending = pending.filter(({ index, ingestResult }, i) => {\n      const read = reads[i] as TargetOutcome<ImageDoc>;\n      const target = (ingests[index] as TargetOutcome<ImagesIngestResponse>).target;\n      if (!read.ok) settled[index] = { target, ok: false, error: read.error };\n      else if (read.data.status === \"ready\" || read.data.status === \"error\")\n        settled[index] = { target, ok: true, data: { ingestResult, doc: read.data } };\n      return settled[index] === undefined;\n    });\n    if (pending.length > 0) await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));\n  }\n  return ingests.map(\n    (outcome, index) =>\n      settled[index] ?? {\n        target: outcome.target,\n        ok: false,\n        error: { code: \"TIMEOUT\", message: `Image not ready within ${maxWait}ms` },\n      },\n  );\n}\n"],"mappings":"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","names":[]}

package/dist/validate-NB6PS5PF.js

@@ -0,0 +1,122 @@
+import {
+  outputRatioWarningsFor,
+  shownBaseline
+} from "./chunk-SEYCF446.js";
+import {
+  creativeSlugFromCanvasPath
+} from "./chunk-YE4RCEEJ.js";
+import "./chunk-OPUEQSKM.js";
+import {
+  exitOnPrepareError,
+  prepareCanvas
+} from "./chunk-3OSBCYKA.js";
+import "./chunk-3JV4T6XW.js";
+import "./chunk-EKX37C3T.js";
+import "./chunk-ENUCJ6AO.js";
+import "./chunk-UROKPFIS.js";
+import "./chunk-3QQHPRRB.js";
+import "./chunk-ZOH672S6.js";
+import "./chunk-UFUYTWEF.js";
+import "./chunk-DWW5QSUF.js";
+import "./chunk-FSTDWVXG.js";
+import "./chunk-FUR7R4D7.js";
+import "./chunk-QOBA6PHB.js";
+import "./chunk-GYMZCJX6.js";
+import "./chunk-AGU4KGT6.js";
+import {
+  canvasOutputsRoot
+} from "./chunk-R5LRBDEM.js";
+import {
+  defaultRegistry,
+  validateCanvasDeep
+} from "./chunk-PE4ZP7MX.js";
+import "./chunk-4Y7IJ2PU.js";
+import "./chunk-3WTCMBDC.js";
+import "./chunk-DGCUPJZD.js";
+import "./chunk-BXUUKRMM.js";
+import "./chunk-RRC7F3QQ.js";
+import "./chunk-KITVYLEX.js";
+import "./chunk-MCJ5I5LR.js";
+import "./chunk-2WZI36D3.js";
+import "./chunk-65Y3RCWP.js";
+import "./chunk-CNPYG4F3.js";
+import "./chunk-SVNH6P7O.js";
+import "./chunk-YJYKSMLF.js";
+import "./chunk-L763CNKH.js";
+import "./chunk-HVJJEQDQ.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-NSBNIPIW.js";
+import "./chunk-46YLDIQG.js";
+import "./chunk-CIW3Q7B2.js";
+import "./chunk-O7AMKMII.js";
+import {
+  optionalTurnId
+} from "./chunk-VPF5A7CM.js";
+import "./chunk-HZPTQRX6.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/canvas/validate.ts
+import path from "path";
+import { defineCommand } from "citty";
+var validateCommand = defineCommand({
+  meta: {
+    name: "validate",
+    description: "Validate a canvas JSON file (no execution). Brings the canvas up to date with its prompt.json first (prompt.json and, for a video, scenes/*.json edits are written into the canvas, exactly as `run` does), then checks it: a per-node cost preview, each node's deep validators (composition meta checks for hyperframe_render/_snapshot), and each generator prompt measured with its {{slots}} filled against the model's character cap (PROMPT_OVER_MODEL_LIMIT)."
+  },
+  args: { file: { type: "positional", required: true, description: "Path to canvas JSON" } },
+  async run({ args }) {
+    const filePath = path.resolve(String(args.file));
+    const slug = creativeSlugFromCanvasPath(filePath) ?? void 0;
+    const baseline = slug ? (await shownBaseline({
+      canvasRoot: canvasOutputsRoot(filePath),
+      slug,
+      creativeDir: path.dirname(filePath),
+      turnId: optionalTurnId(),
+      record: false
+    })).baseline : void 0;
+    let prepared;
+    try {
+      prepared = await prepareCanvas(filePath, {
+        gate: true,
+        log: (line) => process.stderr.write(`${line}
+`),
+        ...baseline ? { baseline } : {}
+      });
+    } catch (e) {
+      exitOnPrepareError(e);
+    }
+    const result = await validateCanvasDeep(prepared.canvas, defaultRegistry());
+    if (!result.ok) {
+      process.stderr.write(`${JSON.stringify({ ok: false, error: { code: "validation", issues: result.issues } }, null, 2)}
+`);
+      process.exit(2);
+      return;
+    }
+    process.stdout.write(
+      `${JSON.stringify(
+        {
+          ok: true,
+          total_nodes: result.canvas.nodes.length,
+          estimated_credits: result.estimatedCredits,
+          cost_preview: result.perNodeCredits ?? [],
+          style_projection: prepared.projections.style,
+          scene_projection: prepared.projections.scenes,
+          canvas_updated: prepared.written,
+          normalized_paths: prepared.rewrites,
+          warnings: [...result.warnings ?? [], ...await outputRatioWarningsFor(prepared.canvas, filePath)]
+        },
+        null,
+        2
+      )}
+`
+    );
+  }
+});
+export {
+  validateCommand
+};
+//# sourceMappingURL=validate-NB6PS5PF.js.map

package/dist/variant-O7LXOA2E.js

@@ -0,0 +1,338 @@
+import {
+  nextVariantNumber,
+  repointFile,
+  variantNumberOf,
+  variantOfSlug,
+  variantSlug
+} from "./chunk-LA6PPSNA.js";
+import {
+  repeatedValues
+} from "./chunk-ERSX3MKH.js";
+import {
+  apiPost
+} from "./chunk-CIW3Q7B2.js";
+import "./chunk-O7AMKMII.js";
+import "./chunk-VPF5A7CM.js";
+import {
+  registerSchema
+} from "./chunk-HZPTQRX6.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/landing/variant.ts
+import { randomUUID } from "crypto";
+import { mkdir, readdir, readFile, stat, writeFile } from "fs/promises";
+import path from "path";
+import { defineCommand } from "citty";
+registerSchema({
+  command: "landing.variant",
+  description: "Create a new variant of a page, for an A/B test. The variant shares the page's sections instead of copying them, so the only difference between the two is the one you fork \u2014 which is the only way the test measures what you think it measures. Run `baker experiment plan` FIRST: most pages cannot settle most questions.",
+  args: {
+    page: { type: "string", description: "The page to make a variant of, by slug", required: true },
+    fork: {
+      type: "string",
+      description: "The component the variant owns its own copy of, named as it appears under _components/ (`Hero.astro`, or `hero/Card.astro`). Repeat for several. Everything else is shared with the control, so a later edit to the control reaches both arms and cannot skew the test.",
+      required: false
+    },
+    because: {
+      type: "string",
+      description: "What you SAW that makes this worth building \u2014 the observation, not the change. Required here, before the page exists, because a reason written afterwards is a caption for a page rather than the reason for one.",
+      required: true
+    },
+    change: {
+      type: "string",
+      description: "What is different about this version, in the client's words \u2014 \u201Cput the booking form in the hero\u201D.",
+      required: true
+    }
+  }
+});
+var SLUG_RE = /^[a-z0-9][a-z0-9-]*$/;
+async function readInternalId(definitionPath) {
+  try {
+    const text = await readFile(definitionPath, "utf8");
+    return /^internalId:\s*"?([^"\s]+)"?\s*$/m.exec(text)?.[1] ?? null;
+  } catch {
+    return null;
+  }
+}
+async function archivedVariantNumbers(root, internalId) {
+  if (!internalId) return [];
+  try {
+    const entries = await readdir(path.resolve(root, "src/_variants", internalId), { withFileTypes: true });
+    return entries.filter((entry) => entry.isDirectory()).map((entry) => Number(entry.name)).filter((n) => Number.isInteger(n) && n > 0);
+  } catch {
+    return [];
+  }
+}
+function fail(code, message, fix) {
+  process.stderr.write(
+    `${JSON.stringify({ ok: false, error: { code, message, ...fix ? { fix } : {} } }, null, 2)}
+`
+  );
+  process.exit(2);
+}
+async function isDir(p) {
+  try {
+    return (await stat(p)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function exists(p) {
+  try {
+    await stat(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function listLandingSlugs(root) {
+  try {
+    const entries = await readdir(path.resolve(root, "src", "pages"), { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory() && !e.name.startsWith("_") && !e.name.startsWith(".")).map((e) => e.name).sort();
+  } catch {
+    return [];
+  }
+}
+async function listComponents(componentsDir, prefix = "") {
+  let entries;
+  try {
+    entries = await readdir(componentsDir, { 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 listComponents(path.join(componentsDir, entry.name), rel));
+    else if (entry.name.endsWith(".astro")) out.push(rel);
+  }
+  return out.sort();
+}
+function resolveForkName(requested, available) {
+  const cleaned = requested.replace(/^\.?\/?(_components\/)?/, "");
+  for (const candidate of [cleaned, `${cleaned}.astro`]) {
+    if (available.includes(candidate)) return candidate;
+  }
+  const basename = (p) => p.slice(p.lastIndexOf("/") + 1);
+  const matches = available.filter((a) => basename(a) === cleaned || basename(a) === `${cleaned}.astro`);
+  return matches.length === 1 ? matches[0] ?? null : null;
+}
+function parseForks(fork, rawArgs) {
+  const names = repeatedValues(rawArgs, "fork", fork).flatMap((s) => s.split(",")).map((s) => s.trim()).filter((s) => s.length > 0);
+  return [...new Set(names)];
+}
+function pageInTest(status, page) {
+  for (const test of status.experiments) {
+    if (test.landingSlug !== page) continue;
+    if (test.status !== "finished") {
+      return `${page} is already in a test (${test.experimentId}, against ${test.variantSlug}, ${test.status}). One page has one test at a time \u2014 read it with \`baker experiment status --landing ${page}\`, and end it with \`baker experiment finish\` before building the next version.`;
+    }
+    if (test.fold === "owed" || test.fold === "landing") {
+      return `The last test on ${page} was won by ${test.variantSlug}, and the page is still being updated to match \u2014 run \`baker experiment fold\` and publish before building the next version.`;
+    }
+  }
+  return null;
+}
+function buildVariantDefinition(controlDefinition, opts) {
+  const frontmatter = controlDefinition.match(/^---\n[\s\S]*?\n---/)?.[0] ?? "---\n---";
+  let out = frontmatter;
+  out = out.replace(/^internalId:.*$/m, `internalId: "${opts.internalId}"`);
+  out = out.replace(/^internalTitle:\s*(.*)$/m, (_m, title) => `internalTitle: ${title.trim()} (variant)`);
+  const shared = opts.forks.length > 0 ? opts.forks.join(", ") : "nothing yet";
+  const note = [
+    "",
+    `# Version ${variantNumberOf(opts.variantSlug) ?? "?"} of \`${opts.controlSlug}\` \u2014 for an A/B test`,
+    "",
+    `This is not a page. It is one version of \`${opts.controlSlug}\`, shown to half of that page's visitors while a test runs; the address bar keeps saying \`/${opts.controlSlug}/\` and this folder has no address of its own. Everything about the page \u2014 the campaign, the audience, the offer, the proof \u2014 is in \`src/pages/${opts.controlSlug}/_definition.md\`, and that is where it is edited. This file only says what is different here.`,
+    "",
+    `**Only this differs:** ${shared}. Every other section is imported from \`${opts.controlSlug}\`, on purpose \u2014 an edit to the page reaches both versions, so the test keeps measuring the one difference rather than a drift between two copies. Edit only the files under \`src/pages/${opts.variantSlug}/_components/\`.`,
+    ...opts.because ? ["", `**Because:** ${opts.because}`] : [],
+    ...opts.change ? ["", `**We changed:** ${opts.change}`] : [],
+    "",
+    `Run \`baker experiment start --landing ${opts.controlSlug} --variant ${opts.variantSlug} --because "\u2026" --change "\u2026"\` to begin, and read the result with \`baker experiment status\`. When the test ends, \`baker experiment fold\` moves the version that won into the page and removes this folder.`,
+    ""
+  ].join("\n");
+  return `${out.trimEnd()}
+${note}`;
+}
+async function resolveTargets(projectRoot, opts) {
+  const { controlSlug } = opts;
+  if (!SLUG_RE.test(controlSlug)) {
+    fail(
+      "INVALID_SLUG",
+      `"${controlSlug}" is not a page slug \u2014 use the folder name directly under src/pages/ (lowercase letters, digits and dashes).`,
+      { argument: "page", availableSlugs: await listLandingSlugs(projectRoot) }
+    );
+  }
+  if (variantOfSlug(controlSlug) !== null) {
+    fail(
+      "INVALID_SLUG",
+      `"${controlSlug}" is already a variant of "${variantOfSlug(controlSlug)}". Make the next variant of the page itself: \`baker landing variant ${variantOfSlug(controlSlug)}\`.`
+    );
+  }
+  const controlDir = path.resolve(projectRoot, "src", "pages", controlSlug);
+  if (!await isDir(controlDir)) {
+    fail("NOT_FOUND", `No page at src/pages/${controlSlug}/`, {
+      availableSlugs: await listLandingSlugs(projectRoot)
+    });
+  }
+  if (!await exists(path.join(controlDir, "index.astro"))) {
+    fail("NOT_FOUND", `src/pages/${controlSlug}/index.astro is missing, so there is no page to make a variant of.`);
+  }
+  const internalId = await readInternalId(path.join(controlDir, "_definition.md"));
+  const variantSlugValue = variantSlug(
+    controlSlug,
+    nextVariantNumber(
+      controlSlug,
+      await listLandingSlugs(projectRoot),
+      await archivedVariantNumbers(projectRoot, internalId)
+    )
+  );
+  const variantDir = path.resolve(projectRoot, "src", "pages", variantSlugValue);
+  const available = await listComponents(path.join(controlDir, "_components"));
+  const forks = [];
+  for (const name of parseForks(opts.fork, opts.rawArgs)) {
+    const resolved = resolveForkName(name, available);
+    if (resolved === null) {
+      fail("NOT_FOUND", `"${name}" is not a component of ${controlSlug}.`, {
+        availableComponents: available,
+        hint: "Name it as it appears under _components/ \u2014 `Hero.astro`, or `hero/Card.astro`."
+      });
+    }
+    forks.push(resolved);
+  }
+  return { controlDir, variantDir, variantSlug: variantSlugValue, available, forks };
+}
+async function writeVariant(opts) {
+  const { controlDir, variantDir, controlSlug, variantSlug: variantSlug2, forks } = opts;
+  const forkedTargets = new Set(forks.map((f) => path.join(controlDir, "_components", f)));
+  const written = [];
+  const indexText = await readFile(path.join(controlDir, "index.astro"), "utf8");
+  await mkdir(variantDir, { recursive: true });
+  await writeFile(
+    path.join(variantDir, "index.astro"),
+    repointFile(indexText, { fromDir: controlDir, toDir: variantDir, controlDir, variantDir, forkedTargets }),
+    "utf8"
+  );
+  written.push(`src/pages/${variantSlug2}/index.astro`);
+  for (const fork of forks) {
+    const fromFile = path.join(controlDir, "_components", fork);
+    const toFile = path.join(variantDir, "_components", fork);
+    const text = await readFile(fromFile, "utf8");
+    await mkdir(path.dirname(toFile), { recursive: true });
+    await writeFile(
+      toFile,
+      repointFile(text, {
+        fromDir: path.dirname(fromFile),
+        toDir: path.dirname(toFile),
+        controlDir,
+        variantDir,
+        forkedTargets
+      }),
+      "utf8"
+    );
+    written.push(`src/pages/${variantSlug2}/_components/${fork}`);
+  }
+  const controlDefinitionPath = path.join(controlDir, "_definition.md");
+  if (await exists(controlDefinitionPath)) {
+    const definition = buildVariantDefinition(await readFile(controlDefinitionPath, "utf8"), {
+      internalId: randomUUID().replace(/-/g, "").slice(0, 8),
+      variantSlug: variantSlug2,
+      controlSlug,
+      forks,
+      ...opts.because ? { because: opts.because } : {},
+      ...opts.change ? { change: opts.change } : {}
+    });
+    await writeFile(path.join(variantDir, "_definition.md"), definition, "utf8");
+    written.push(`src/pages/${variantSlug2}/_definition.md`);
+  }
+  await mkdir(path.join(variantDir, "_images"), { recursive: true });
+  await writeFile(path.join(variantDir, "_images", ".gitkeep"), "", "utf8");
+  return written;
+}
+var variantCommand = defineCommand({
+  meta: {
+    name: "variant",
+    description: "Create a new variant of a page, for an A/B test. The variant SHARES the page's sections and forks only the component you name, so the two versions differ by exactly the thing you are testing. It is a version of that page, not a page of its own: it is never indexed, never listed, and has no public URL \u2014 both versions answer at the page's own address. Run `baker experiment plan` first \u2014 most pages do not have the traffic to settle most questions."
+  },
+  args: {
+    page: { type: "positional", required: true, description: "The page to make a variant of, by slug" },
+    fork: {
+      type: "string",
+      description: "Component the variant owns its own copy of (`Hero.astro`). Repeat for several."
+    },
+    because: {
+      type: "string",
+      required: true,
+      description: "What you SAW that makes this worth building \u2014 the observation, not the change. Required here, before the page exists, because a reason written afterwards is a caption for a page rather than the reason for one, and a test with no stated belief teaches nothing whichever way it lands. Recorded in the page's notes and passed to `baker experiment start`."
+    },
+    change: {
+      type: "string",
+      required: true,
+      description: "What is different about this version, in the client's words \u2014 \u201Cput the booking form in the hero\u201D."
+    }
+  },
+  async run({ args, rawArgs }) {
+    const projectRoot = process.cwd();
+    const controlSlug = String(args.page);
+    const { controlDir, variantDir, variantSlug: variantSlug2, available, forks } = await resolveTargets(projectRoot, {
+      controlSlug,
+      fork: args.fork,
+      rawArgs
+    });
+    let status;
+    try {
+      const response = await apiPost("/api/experiments/status", {
+        landingSlug: controlSlug
+      });
+      status = response.data;
+    } catch (error) {
+      fail(
+        "UNAVAILABLE",
+        `Could not check whether ${controlSlug} is already in a test (${error instanceof Error ? error.message : String(error)}). Nothing was written \u2014 run \`baker experiment status --landing ${controlSlug}\` and try again.`
+      );
+    }
+    const taken = pageInTest(status, controlSlug);
+    if (taken) fail("CONFLICT", taken, { landing: controlSlug });
+    const written = await writeVariant({
+      controlDir,
+      variantDir,
+      controlSlug,
+      variantSlug: variantSlug2,
+      forks,
+      because: String(args.because),
+      change: String(args.change)
+    });
+    const hints = [
+      forks.length === 0 ? `MISSING --fork: ${variantSlug2} currently renders exactly ${controlSlug}, so a test between them cannot conclude anything. Re-run with --fork <Component>, or copy the one section your change touches into src/pages/${variantSlug2}/_components/ and repoint that import.` : `Edit only src/pages/${variantSlug2}/_components/${forks.join(", ")} \u2014 every other section is shared with ${controlSlug}, and editing a shared one changes both arms at once.`,
+      `Preview both at http://localhost:4321/${controlSlug}/ and http://localhost:4321/${variantSlug2}/ and check they differ only where you meant. Once it is live, only the first of those two answers \u2014 a variant has no public address of its own, and \`/${controlSlug}/?_bkr_preview=b\` is how anyone looks at it.`,
+      `Then: baker experiment start --landing ${controlSlug} --variant ${variantSlug2} --because "${String(args.because)}" --change "${String(args.change)}". Nothing is split until the session is published \u2014 the person publishing is the review of this page.`
+    ];
+    process.stdout.write(
+      `${JSON.stringify(
+        {
+          ok: true,
+          data: {
+            page: controlSlug,
+            slug: variantSlug2,
+            forked: forks,
+            shared: available.filter((c) => !forks.includes(c)),
+            written
+          },
+          hints
+        },
+        null,
+        2
+      )}
+`
+    );
+  }
+});
+export {
+  buildVariantDefinition,
+  pageInTest,
+  parseForks,
+  resolveForkName,
+  variantCommand
+};
+//# sourceMappingURL=variant-O7LXOA2E.js.map

package/dist/videos-SS2Y6FJF.js

@@ -0,0 +1,41 @@
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/videos/index.ts
+import { defineCommand } from "citty";
+var videosCommand = defineCommand({
+  meta: {
+    name: "videos",
+    description: `Find and manage videos in Baker. Subcommands: search, get, upload, ingest, fetch, download, describe, delete, retry, tags.
+
+Examples:
+  baker videos search "product demo" --limit 5
+  baker videos search "tutorial" --tags explainer
+  baker videos get <video-id>
+  baker videos upload ./demo.mp4
+  baker videos ingest https://www.youtube.com/watch?v=abc123
+  baker videos fetch https://www.youtube.com/watch?v=abc123 --out ./clips
+  baker videos download <video-id> --out /tmp/clips   # a library video as a local .mp4 to edit
+  baker videos describe <video-id> --description "Customer testimonial, 30s"
+  baker videos delete <video-id> --dry-run
+  baker videos retry <video-id>                    # process a failed video again
+  baker videos tags                                # list; tags create|update|delete for custom tags
+Full guide: __tooling__/docs/tools/baker/videos.md`
+  },
+  subCommands: {
+    get: () => import("./get-5E4YJKPO.js").then((m) => m.getCommand),
+    group: () => import("./group-XVDH2ONO.js").then((m) => m.groupCommand),
+    search: () => import("./search-LFTFNDMC.js").then((m) => m.searchCommand),
+    upload: () => import("./upload-WASRCKS4.js").then((m) => m.uploadCommand),
+    ingest: () => import("./ingest-6R7XUL46.js").then((m) => m.ingestCommand),
+    fetch: () => import("./fetch-EHP2FK6Y.js").then((m) => m.fetchCommand),
+    download: () => import("./download-KN2I55SA.js").then((m) => m.downloadCommand),
+    describe: () => import("./describe-GIG46DT5.js").then((m) => m.describeCommand),
+    delete: () => import("./delete-R3LXCKA4.js").then((m) => m.deleteCommand),
+    retry: () => import("./retry-ZQUJPKQH.js").then((m) => m.retryCommand),
+    tags: () => import("./tags-XY6R2VJ6.js").then((m) => m.tagsCommand)
+  }
+});
+export {
+  videosCommand
+};
+//# sourceMappingURL=videos-SS2Y6FJF.js.map