@koda-sl/baker-cli 0.291.0 → 0.292.0

package/dist/cli.js

@@ -10681,11 +10681,11 @@ function parseKeywordEntry(raw, defaultMatch) {
 function rawTextEntries(value, rawArgs) {
   return repeatedValues(rawArgs, "text", value).flatMap((v) => v.split(",")).map((v) => v.trim()).filter(Boolean);
 }
-function rawFileEntries(path44) {
-  if (typeof path44 !== "string" || path44.length === 0) {
+function rawFileEntries(path45) {
+  if (typeof path45 !== "string" || path45.length === 0) {
     return [];
   }
-  return readFileSync2(path44, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+  return readFileSync2(path45, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
 }
 function keywordEntries(args, rawArgs) {
   const defaultMatch = typeof args["match-type"] === "string" ? args["match-type"].toUpperCase() : void 0;
@@ -10708,14 +10708,14 @@ function keywordEntries(args, rawArgs) {
   }
   return entries;
 }
-function loadJsonFileArg(path44) {
-  if (typeof path44 !== "string" || path44.length === 0) {
+function loadJsonFileArg(path45) {
+  if (typeof path45 !== "string" || path45.length === 0) {
     return {};
   }
-  const inline = path44.trimStart().startsWith("{");
-  const source = inline ? "inline JSON" : path44;
+  const inline = path45.trimStart().startsWith("{");
+  const source = inline ? "inline JSON" : path45;
   try {
-    const parsed = JSON.parse(inline ? path44 : readFileSync2(path44, "utf8"));
+    const parsed = JSON.parse(inline ? path45 : readFileSync2(path45, "utf8"));
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
       failWriteValidation(`${source} must contain a JSON object`);
     }
@@ -10852,10 +10852,10 @@ async function stageUpdate(kind, customerId, target, payload, hints2) {
 async function stageTarget(kind, customerId, target, hints2) {
   await stageGoogleOp({ kind, customerId, target }, hints2);
 }
-async function draftAction(path44, body, chat) {
+async function draftAction(path45, body, chat) {
   try {
     const chatId = resolveChatId(chat);
-    const response = await apiPost(path44, { chatId, ...body });
+    const response = await apiPost(path45, { chatId, ...body });
     writeJsonEnvelope(response);
   } catch (err) {
     handleGoogleError(err);
@@ -15271,17 +15271,17 @@ function ignoredColumnHints(columns) {
     `Ignored ${columns.length} column(s) that are not part of a conversion: ${columns.join(", ")}. A conversion carries an order id, a date, and something to match on: a click id (gclid / gbraid / wbraid), an email, a phone, or all four of givenName + familyName + country + postalCode. Optionally a value + currency, conversionCount, and eventSource (WEB / APP / IN_STORE / PHONE / OTHER). A column named just \`Name\` is ignored on purpose \u2014 Google needs the first and last name separately, so split it before re-running.`
   ];
 }
-function readRowsFile(path44) {
-  const inline = path44.trimStart().startsWith("[") || path44.trimStart().startsWith("{");
+function readRowsFile(path45) {
+  const inline = path45.trimStart().startsWith("[") || path45.trimStart().startsWith("{");
   let text2;
   try {
-    text2 = inline ? path44 : readFileSync4(path44, "utf8");
+    text2 = inline ? path45 : readFileSync4(path45, "utf8");
   } catch (err) {
-    failWriteValidation(`could not read ${path44}: ${err instanceof Error ? err.message : String(err)}`);
+    failWriteValidation(`could not read ${path45}: ${err instanceof Error ? err.message : String(err)}`);
   }
   const parsed = parseConversionRowsText(text2);
   if (!parsed.ok) {
-    failWriteValidation(`${inline ? "the conversions passed inline" : path44}: ${parsed.error}`);
+    failWriteValidation(`${inline ? "the conversions passed inline" : path45}: ${parsed.error}`);
   }
   return { rows: parsed.rows, ignoredColumns: parsed.ignoredColumns };
 }
@@ -17120,19 +17120,19 @@ function failWriteValidation2(message) {
   writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message } });
   process.exit(1);
 }
-function loadJsonFileArg2(path44) {
-  if (typeof path44 !== "string" || path44.length === 0) {
+function loadJsonFileArg2(path45) {
+  if (typeof path45 !== "string" || path45.length === 0) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync5(path44, "utf8"));
+    const parsed = JSON.parse(readFileSync5(path45, "utf8"));
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      failWriteValidation2(`${path44} must contain a JSON object`);
+      failWriteValidation2(`${path45} must contain a JSON object`);
     }
     return parsed;
   } catch (err) {
     if (err instanceof SyntaxError) {
-      failWriteValidation2(`${path44} is not valid JSON: ${err.message}`);
+      failWriteValidation2(`${path45} is not valid JSON: ${err.message}`);
     }
     throw err;
   }
@@ -17217,15 +17217,15 @@ function parseLocaleFlag(value) {
   }
   return { language: match[1], country: match[2].toUpperCase() };
 }
-function loadTargetingFileArg(path44) {
-  if (typeof path44 !== "string" || path44.length === 0) {
+function loadTargetingFileArg(path45) {
+  if (typeof path45 !== "string" || path45.length === 0) {
     return void 0;
   }
-  const parsed = loadJsonFileArg2(path44);
+  const parsed = loadJsonFileArg2(path45);
   const criteria = parsed.targetingCriteria ?? parsed;
   if (!criteria.include) {
     failWriteValidation2(
-      `${path44} must contain targeting criteria with an "include" block (see baker schema ads.linkedin.campaigns.create)`
+      `${path45} must contain targeting criteria with an "include" block (see baker schema ads.linkedin.campaigns.create)`
     );
   }
   return criteria;
@@ -17260,14 +17260,14 @@ function parseCsvLine(line) {
   cells.push(current);
   return cells.map((cell3) => cell3.trim());
 }
-function parseListFileArg(path44, maxRows) {
-  if (typeof path44 !== "string" || path44.length === 0) {
+function parseListFileArg(path45, maxRows) {
+  if (typeof path45 !== "string" || path45.length === 0) {
     return void 0;
   }
-  const raw = readFileSync5(path44, "utf8");
+  const raw = readFileSync5(path45, "utf8");
   const lines = raw.split(/\r?\n/).filter((line) => line.trim().length > 0);
   if (lines.length < 2) {
-    failWriteValidation2(`${path44} needs a header row and at least one data row`);
+    failWriteValidation2(`${path45} needs a header row and at least one data row`);
   }
   const columns = parseCsvLine(lines[0]).map((column) => column.trim());
   const rows = [];
@@ -17286,7 +17286,7 @@ function parseListFileArg(path44, maxRows) {
     }
   }
   if (rows.length > maxRows) {
-    failWriteValidation2(`${path44} has ${rows.length} rows \u2014 the inline limit is ${maxRows}. Split the list.`);
+    failWriteValidation2(`${path45} has ${rows.length} rows \u2014 the inline limit is ${maxRows}. Split the list.`);
   }
   return { columns, rows };
 }
@@ -17382,11 +17382,11 @@ function readPositionals(args) {
 function splitIdList(raw) {
   return raw.split(",").map((id) => id.trim()).filter(Boolean);
 }
-function idsFileEntries(path44) {
-  if (typeof path44 !== "string" || path44.length === 0) {
+function idsFileEntries(path45) {
+  if (typeof path45 !== "string" || path45.length === 0) {
     return [];
   }
-  return readFileSync5(path44, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#")).flatMap(splitIdList);
+  return readFileSync5(path45, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#")).flatMap(splitIdList);
 }
 function requireTargets(args, entity) {
   const positionals = readPositionals(args);
@@ -20106,9 +20106,9 @@ function compactRow(row) {
     ...destination.postUrn ? { postUrn: destination.postUrn } : {}
   };
 }
-function readPath(row, path44) {
+function readPath(row, path45) {
   let current = row;
-  for (const segment of path44.split(".")) {
+  for (const segment of path45.split(".")) {
     const record = asRecord2(current);
     if (!record) return void 0;
     current = record[segment];
@@ -20118,10 +20118,10 @@ function readPath(row, path44) {
 function projectFields(rows, paths) {
   return rows.map((row) => {
     const projected = {};
-    for (const path44 of paths) {
-      const value = readPath(row, path44);
+    for (const path45 of paths) {
+      const value = readPath(row, path45);
       if (value !== void 0) {
-        projected[path44] = value;
+        projected[path45] = value;
       }
     }
     return projected;
@@ -21717,11 +21717,11 @@ var updateStatusSchema = z29.enum(UPDATE_STATUSES);
 function currencyMinimums2(currencyCode) {
   return CURRENCY_MINIMUMS2[currencyCode] ?? DEFAULT_CURRENCY_MINIMUM2;
 }
-function validateDailyBudgetFloor(money, ctx, path44) {
+function validateDailyBudgetFloor(money, ctx, path45) {
   if (money?.currencyCode) {
     const min = currencyMinimums2(money.currencyCode).dailyBudgetMin;
     if (Number(money.amount) < min) {
-      ctx.addIssue({ code: "custom", path: path44, message: `below the ${min} ${money.currencyCode} daily minimum` });
+      ctx.addIssue({ code: "custom", path: path45, message: `below the ${min} ${money.currencyCode} daily minimum` });
     }
   }
 }
@@ -22481,19 +22481,19 @@ function failWriteValidation3(message) {
   writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message } });
   process.exit(1);
 }
-function loadJsonFileArg3(path44) {
-  if (typeof path44 !== "string" || path44.length === 0) {
+function loadJsonFileArg3(path45) {
+  if (typeof path45 !== "string" || path45.length === 0) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync9(path44, "utf8"));
+    const parsed = JSON.parse(readFileSync9(path45, "utf8"));
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      failWriteValidation3(`${path44} must contain a JSON object`);
+      failWriteValidation3(`${path45} must contain a JSON object`);
     }
     return parsed;
   } catch (err) {
     if (err instanceof SyntaxError) {
-      failWriteValidation3(`${path44} is not valid JSON: ${err.message}`);
+      failWriteValidation3(`${path45} is not valid JSON: ${err.message}`);
     }
     throw err;
   }
@@ -28098,12 +28098,12 @@ function flowExists(slug) {
   return existsSync3(join2(flowsDir(), slug, "_data.json"));
 }
 function readFlowTree(slug) {
-  const path44 = join2(flowsDir(), slug, "_data.json");
-  if (!existsSync3(path44)) {
+  const path45 = join2(flowsDir(), slug, "_data.json");
+  if (!existsSync3(path45)) {
     failLocal(`No form "${slug}". Run "baker flows list" to see the forms in this workspace.`);
   }
   try {
-    return JSON.parse(readFileSync11(path44, "utf-8"));
+    return JSON.parse(readFileSync11(path45, "utf-8"));
   } catch (error) {
     failLocal(`Could not read form "${slug}": ${error instanceof Error ? error.message : String(error)}`);
   }
@@ -30010,11 +30010,11 @@ function unwrap(response) {
   }
   return response.data;
 }
-async function readAvatars(path44, params) {
-  return unwrap(await apiGet(path44, params));
+async function readAvatars(path45, params) {
+  return unwrap(await apiGet(path45, params));
 }
-async function writeAvatars(path44, body) {
-  return unwrap(await apiPost(path44, body));
+async function writeAvatars(path45, body) {
+  return unwrap(await apiPost(path45, body));
 }
 
 // src/commands/avatars/create.ts
@@ -30848,12 +30848,12 @@ function missingFontFiles(urls, available) {
 function planFontAdoption(sources, families) {
   const wanted = new Map(families.map((family) => [normalizeFamily(family), family]));
   const byFamily = /* @__PURE__ */ new Map();
-  for (const { path: path44, source } of sources) {
-    const dir = posix.dirname(path44);
+  for (const { path: path45, source } of sources) {
+    const dir = posix.dirname(path45);
     for (const face of declaredFontFaces(source)) {
       if (!wanted.has(face.family)) continue;
       const perFile = byFamily.get(face.family) ?? /* @__PURE__ */ new Map();
-      perFile.set(path44, [...perFile.get(path44) ?? [], rebaseFontFaceSrc(face.block, dir)]);
+      perFile.set(path45, [...perFile.get(path45) ?? [], rebaseFontFaceSrc(face.block, dir)]);
       byFamily.set(face.family, perFile);
     }
   }
@@ -39542,6 +39542,9 @@ function buildHistoryHints(tests, landing) {
 }
 function buildStartHints(staged) {
   const hints2 = [];
+  for (const entry of staged.drift) {
+    hints2.push(driftHint(staged, entry));
+  }
   if (staged.composition && staged.composition.forked.length === 0) {
     hints2.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.`
@@ -39555,6 +39558,17 @@ function buildStartHints(staged) {
   }
   return hints2;
 }
+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}`;
+}
 
 // ../api/src/experiments/composition.ts
 import { z as z35 } from "zod";
@@ -40112,6 +40126,72 @@ async function readPageInternalId(root, slug) {
   }
 }
 
+// src/commands/experiment/measurement.ts
+import { readFile as readFile24 } from "fs/promises";
+import path31 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) => readFile24(path31.join(root, file), "utf8").catch(() => "")));
+  return sources.flatMap(eventDeclarationsIn);
+}
+
 // src/commands/experiment/update.ts
 function buildUpdateRequest(args, rawArgs) {
   const expect = args.expect === void 0 ? void 0 : String(args.expect);
@@ -40302,16 +40382,10 @@ var startCommand = defineCommand119({
     }
     const evidence = parseEvidence(args.evidence, rawArgs);
     if (evidence && "error" in evidence) fail5(evidence.error);
-    const composition = await readComposition(process.cwd(), String(args.landing), String(args.variant));
-    const [controlForms, variantForms] = await Promise.all([
-      readForms(process.cwd(), String(args.landing)),
-      readForms(process.cwd(), String(args.variant))
-    ]);
-    const newForms = formsOnlyIn(variantForms, controlForms);
-    const [landingInternalId, variantInternalId] = await Promise.all([
-      readPageInternalId(process.cwd(), String(args.landing)),
-      readPageInternalId(process.cwd(), String(args.variant))
-    ]);
+    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),
@@ -40341,7 +40415,8 @@ var startCommand = defineCommand119({
             goal: String(response.data.goal),
             variantGoal: args.variantGoal === void 0 ? void 0 : String(args.variantGoal),
             composition,
-            newForms
+            newForms,
+            drift
           }),
           "Staged. The split starts when this session is published \u2014 publishing is the review of the new variant.",
           "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."
@@ -40735,6 +40810,29 @@ var experimentCommand = defineCommand119({
     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
+  };
+}
 
 // src/commands/flows/index.ts
 import { defineCommand as defineCommand124 } from "citty";
@@ -41032,10 +41130,10 @@ function parseValueExpression(raw) {
   return parts.map(parsePart);
 }
 function trackingFieldIds() {
-  const path44 = join4(flowsDir(), "..", "tracking.ts");
-  if (!existsSync6(path44)) return null;
+  const path45 = join4(flowsDir(), "..", "tracking.ts");
+  if (!existsSync6(path45)) return null;
   try {
-    const source = readFileSync13(path44, "utf-8");
+    const source = readFileSync13(path45, "utf-8");
     const block2 = source.match(/TRACKING_FIELD_IDS\s*=\s*\[([\s\S]*?)\]\s*as const/)?.[1];
     if (!block2) return null;
     const ids = [...block2.matchAll(/"(tracking\.[a-z0-9_]+)"/g)].map((match) => match[1]);
@@ -41576,13 +41674,13 @@ function specsFromFile(parsed) {
     return `${destField}${type}=${entry?.value ?? ""}`;
   });
 }
-function readSpecFile(path44) {
+function readSpecFile(path45) {
   let raw;
   try {
-    raw = path44 === "-" ? readFileSync14(0, "utf-8") : readFileSync14(path44, "utf-8");
+    raw = path45 === "-" ? readFileSync14(0, "utf-8") : readFileSync14(path45, "utf-8");
   } catch (error) {
     refuse(
-      `Could not read ${path44 === "-" ? "the mapping from stdin" : `"${path44}"`}: ${error instanceof Error ? error.message : String(error)}`
+      `Could not read ${path45 === "-" ? "the mapping from stdin" : `"${path45}"`}: ${error instanceof Error ? error.message : String(error)}`
     );
   }
   let parsed;
@@ -41590,7 +41688,7 @@ function readSpecFile(path44) {
     parsed = JSON.parse(raw);
   } catch (error) {
     refuse(
-      `${path44 === "-" ? "stdin" : `"${path44}"`} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
+      `${path45 === "-" ? "stdin" : `"${path45}"`} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
       'Expected { "map": { "<destField>": "<value>", \u2026 } }'
     );
   }
@@ -41860,18 +41958,18 @@ var ARRAY_FIELDS = [
   "tagIds"
 ];
 var ARRAY_OWNERS = ["", "body"];
-function dropUnsetOptionals(sideEffect, path44) {
+function dropUnsetOptionals(sideEffect, path45) {
   return OPTIONAL_STRINGS.flatMap((key) => {
     if (!(key in sideEffect) || sideEffect[key] !== null && sideEffect[key] !== "") return [];
     delete sideEffect[key];
-    return [{ path: path44, change: `dropped \`${key}\` (an optional string is absent, never null)` }];
+    return [{ path: path45, change: `dropped \`${key}\` (an optional string is absent, never null)` }];
   });
 }
-function fillNulledArrays(target, prefix, path44) {
+function fillNulledArrays(target, prefix, path45) {
   return ARRAY_FIELDS.flatMap((key) => {
     if (!(key in target) || target[key] !== null) return [];
     target[key] = [];
-    return [{ path: path44, change: `\`${prefix}${key}: null\` \u2192 \`[]\`` }];
+    return [{ path: path45, change: `\`${prefix}${key}: null\` \u2192 \`[]\`` }];
   });
 }
 function sideEffectsOf(node) {
@@ -41881,13 +41979,13 @@ function sideEffectsOf(node) {
   );
 }
 function normalizeSideEffect(sideEffect, where) {
-  const path44 = `${where} \u2192 ${String(sideEffect.id ?? "side effect")}`;
+  const path45 = `${where} \u2192 ${String(sideEffect.id ?? "side effect")}`;
   const arrays = ARRAY_OWNERS.flatMap((owner) => {
     const target = owner ? sideEffect[owner] : sideEffect;
     if (!target || typeof target !== "object") return [];
-    return fillNulledArrays(target, owner ? `${owner}.` : "", path44);
+    return fillNulledArrays(target, owner ? `${owner}.` : "", path45);
   });
-  return [...dropUnsetOptionals(sideEffect, path44), ...arrays];
+  return [...dropUnsetOptionals(sideEffect, path45), ...arrays];
 }
 function normalizeFlowTree(tree) {
   const changes = [];
@@ -42439,10 +42537,10 @@ async function stageOps(ops) {
     handleError2(err);
   }
 }
-async function draftAction2(path44, body, chat) {
+async function draftAction2(path45, body, chat) {
   const chatId = resolveChatId(chat);
   try {
-    const data = await apiPost(path44, { chatId, ...body });
+    const data = await apiPost(path45, { chatId, ...body });
     writeJsonEnvelope({ ok: true, data });
     return data;
   } catch (err) {
@@ -44856,7 +44954,7 @@ function cropSprite(input, region) {
 
 // src/lib/image/io.ts
 import { randomBytes } from "crypto";
-import { glob as fsGlob, readFile as readFile24, rename, stat as stat6, writeFile as writeFile12 } from "fs/promises";
+import { glob as fsGlob, readFile as readFile25, rename, stat as stat6, writeFile as writeFile12 } from "fs/promises";
 import { dirname as dirname2, extname as extname2, join as join5, resolve as resolve4 } from "path";
 var REMOTE_RE = /^https?:\/\//i;
 var GLOB_RE = /[*?[\]{}]/;
@@ -44889,11 +44987,11 @@ async function readImageBuffer(pathOrUrl) {
     const { buffer } = await fetchExternalBytes(pathOrUrl, { maxBytes: MAX_REMOTE_IMAGE_BYTES });
     return buffer;
   }
-  return readFile24(pathOrUrl);
+  return readFile25(pathOrUrl);
 }
-async function isDirectory(path44) {
+async function isDirectory(path45) {
   try {
-    const s = await stat6(path44);
+    const s = await stat6(path45);
     return s.isDirectory();
   } catch {
     return false;
@@ -45212,13 +45310,13 @@ function resolveDownloadPath({ baseName, extension, out, outIsDirectory: outIsDi
 }
 function disambiguate(paths) {
   const taken = /* @__PURE__ */ new Set();
-  return paths.map((path44) => {
-    if (!taken.has(path44)) {
-      taken.add(path44);
-      return path44;
+  return paths.map((path45) => {
+    if (!taken.has(path45)) {
+      taken.add(path45);
+      return path45;
     }
-    const ext = extname3(path44);
-    const stem = path44.slice(0, path44.length - ext.length);
+    const ext = extname3(path45);
+    const stem = path45.slice(0, path45.length - ext.length);
     let n = 2;
     while (taken.has(`${stem}-${n}${ext}`)) n += 1;
     const unique = `${stem}-${n}${ext}`;
@@ -45344,10 +45442,10 @@ async function runDownloads(plan) {
   const paths = disambiguate(fetched.map((item) => item.path));
   const downloaded = [];
   for (const [index, item] of fetched.entries()) {
-    const path44 = paths[index] ?? item.path;
+    const path45 = paths[index] ?? item.path;
     try {
-      await atomicWrite(path44, item.buffer);
-      downloaded.push({ input: item.input, output: path44, bytes: item.buffer.length, contentType: item.contentType });
+      await atomicWrite(path45, item.buffer);
+      downloaded.push({ input: item.input, output: path45, bytes: item.buffer.length, contentType: item.contentType });
     } catch (err) {
       failed.push({ input: item.input, error: failureMessage(err, "Write failed") });
     }
@@ -48311,8 +48409,8 @@ Full guide: __tooling__/docs/tools/baker/images.md`
 import { defineCommand as defineCommand175 } from "citty";
 
 // src/commands/landing/critique.ts
-import { readdir as readdir12, readFile as readFile26, stat as stat8 } from "fs/promises";
-import path33 from "path";
+import { readdir as readdir12, readFile as readFile27, stat as stat8 } from "fs/promises";
+import path34 from "path";
 import { defineCommand as defineCommand164 } from "citty";
 
 // src/engine/landing/lib/constants.ts
@@ -49504,13 +49602,13 @@ function describeCounts(findings) {
 
 // src/commands/landing/snapshot.ts
 import { mkdir as mkdir9, rename as rename2, writeFile as writeFile13 } from "fs/promises";
-import path31 from "path";
+import path32 from "path";
 var CRITIC_VERSION = "4";
 function critiqueCacheDir(projectRoot) {
-  return path31.join(projectRoot, ".cache", "landing-critique");
+  return path32.join(projectRoot, ".cache", "landing-critique");
 }
 function snapshotPath(projectRoot, slug) {
-  return path31.join(critiqueCacheDir(projectRoot), `${slug}.json`);
+  return path32.join(critiqueCacheDir(projectRoot), `${slug}.json`);
 }
 async function writeCritiqueSnapshot(projectRoot, snapshot) {
   await mkdir9(critiqueCacheDir(projectRoot), { recursive: true });
@@ -49522,8 +49620,8 @@ async function writeCritiqueSnapshot(projectRoot, snapshot) {
 }
 
 // src/commands/landing/source-version.ts
-import { readdir as readdir11, readFile as readFile25, stat as stat7 } from "fs/promises";
-import path32 from "path";
+import { readdir as readdir11, readFile as readFile26, stat as stat7 } from "fs/promises";
+import path33 from "path";
 var CRITIQUED_ROOTS = ["src/pages/", "src/components/"];
 async function landingSourceRelPaths(root, slug) {
   const files = await landingGraphFiles(root, slug);
@@ -49532,7 +49630,7 @@ async function landingSourceRelPaths(root, slug) {
 async function readLandingSources(root, slug) {
   const rel = await landingSourceRelPaths(root, slug);
   const out = [];
-  for (const r of rel) out.push({ path: r, text: await readFile25(path32.join(root, r), "utf8") });
+  for (const r of rel) out.push({ path: r, text: await readFile26(path33.join(root, r), "utf8") });
   return out;
 }
 async function computeLandingSourceSha(root, slug) {
@@ -49541,7 +49639,7 @@ async function computeLandingSourceSha(root, slug) {
   for (const r of rel) {
     let bytes;
     try {
-      bytes = await readFile25(path32.join(root, r));
+      bytes = await readFile26(path33.join(root, r));
     } catch {
       bytes = Buffer.alloc(0);
     }
@@ -49551,16 +49649,16 @@ async function computeLandingSourceSha(root, slug) {
 }
 async function computeLegacyLandingSourceSha(landingDir) {
   const rel = [];
-  if (await isFile2(path32.join(landingDir, "index.astro"))) rel.push("index.astro");
-  for (const abs of await walkAstro(path32.join(landingDir, "_components"))) {
-    rel.push(path32.relative(landingDir, abs).split(path32.sep).join("/"));
+  if (await isFile2(path33.join(landingDir, "index.astro"))) rel.push("index.astro");
+  for (const abs of await walkAstro(path33.join(landingDir, "_components"))) {
+    rel.push(path33.relative(landingDir, abs).split(path33.sep).join("/"));
   }
   rel.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
   const parts = [];
   for (const r of rel) {
     let bytes;
     try {
-      bytes = await readFile25(path32.join(landingDir, r));
+      bytes = await readFile26(path33.join(landingDir, r));
     } catch {
       bytes = Buffer.alloc(0);
     }
@@ -49584,7 +49682,7 @@ async function walkAstro(dir) {
   }
   const out = [];
   for (const entry of entries) {
-    const abs = path32.join(dir, entry.name);
+    const abs = path33.join(dir, entry.name);
     if (entry.isDirectory()) out.push(...await walkAstro(abs));
     else if (entry.isFile() && entry.name.endsWith(".astro")) out.push(abs);
   }
@@ -49645,7 +49743,7 @@ var critiqueCommand2 = defineCommand164({
           { availableSlugs: await listLandingSlugs(projectRoot) }
         );
       }
-      if (!await isDir2(path33.resolve(projectRoot, "src", "pages", slug))) {
+      if (!await isDir2(path34.resolve(projectRoot, "src", "pages", slug))) {
         fail6("NOT_FOUND", `No landing at src/pages/${slug}/`, {
           availableSlugs: await listLandingSlugs(projectRoot)
         });
@@ -49688,7 +49786,7 @@ async function critiqueOne(projectRoot, slug, brand, competitors) {
   const [sources, compositionSha, sourceSha] = await Promise.all([
     readLandingSources(projectRoot, slug),
     computeLandingSourceSha(projectRoot, slug),
-    computeLegacyLandingSourceSha(path33.resolve(projectRoot, "src", "pages", slug))
+    computeLegacyLandingSourceSha(path34.resolve(projectRoot, "src", "pages", slug))
   ]);
   const report = critiqueLanding({ slug, sources, brand, competitors });
   let snapshotFailed = false;
@@ -49708,7 +49806,7 @@ async function critiqueOne(projectRoot, slug, brand, competitors) {
   return { slug, report, snapshotFailed };
 }
 async function readCompetitorNames(projectRoot) {
-  const dir = path33.join(projectRoot, "src", "content", "competitors");
+  const dir = path34.join(projectRoot, "src", "content", "competitors");
   let entries;
   try {
     entries = (await readdir12(dir)).filter((f) => f.endsWith(".md"));
@@ -49717,9 +49815,9 @@ async function readCompetitorNames(projectRoot) {
   }
   const names = [];
   for (const entry of entries) {
-    names.push(path33.basename(entry, ".md").replace(/[-_]+/g, " "));
+    names.push(path34.basename(entry, ".md").replace(/[-_]+/g, " "));
     try {
-      const head = (await readFile26(path33.join(dir, entry), "utf8")).slice(0, 2e3);
+      const head = (await readFile27(path34.join(dir, entry), "utf8")).slice(0, 2e3);
       const titled = /^\s*(?:title|name)\s*:\s*["']?([^"'\n]+)["']?\s*$/im.exec(head);
       if (titled?.[1]) names.push(titled[1].trim());
     } catch {
@@ -49729,7 +49827,7 @@ async function readCompetitorNames(projectRoot) {
 }
 async function listLandingSlugs(projectRoot) {
   try {
-    const entries = await readdir12(path33.join(projectRoot, "src", "pages"), { withFileTypes: true });
+    const entries = await readdir12(path34.join(projectRoot, "src", "pages"), { withFileTypes: true });
     return entries.filter((e) => e.isDirectory() && !e.name.startsWith("_") && !e.name.startsWith(".")).map((e) => e.name).sort();
   } catch {
     return [];
@@ -49881,7 +49979,7 @@ var addCommand = defineCommand165({
 
 // src/commands/landing/inspiration/code.ts
 import { mkdir as mkdir10, writeFile as writeFile14 } from "fs/promises";
-import path34 from "path";
+import path35 from "path";
 import { defineCommand as defineCommand166 } from "citty";
 registerSchema({
   command: "landing.inspiration.code",
@@ -49904,9 +50002,9 @@ var codeCommand = defineCommand166({
     try {
       const id = args.id;
       const data = await apiGet("/api/landing-inspiration/section-code", { id });
-      const dir = path34.join(process.cwd(), ".baker", "inspiration", id);
+      const dir = path35.join(process.cwd(), ".baker", "inspiration", id);
       await mkdir10(dir, { recursive: true });
-      const file = path34.join(dir, "section.html");
+      const file = path35.join(dir, "section.html");
       await writeFile14(file, data.html);
       const hints2 = [INSPIRATION_HINTS.structureNotCopy, INSPIRATION_HINTS.adapt];
       const fidelity = fidelityHint(data.fidelity);
@@ -49916,7 +50014,7 @@ var codeCommand = defineCommand166({
         ok: true,
         data: {
           id,
-          file: path34.relative(process.cwd(), file),
+          file: path35.relative(process.cwd(), file),
           bytes: data.html.length,
           fidelity: data.fidelity,
           reproduction_notes: data.reproductionNotes,
@@ -50348,7 +50446,7 @@ function classifyCaptureFailure(error) {
 
 // src/engine/landing-library/run.ts
 import { mkdir as mkdir11, writeFile as writeFile16 } from "fs/promises";
-import path36 from "path";
+import path37 from "path";
 
 // ../proxy/src/preflight.ts
 import http from "http";
@@ -51764,9 +51862,9 @@ async function renderBundleToPng(browser, html, viewportWidth, options = {}) {
 
 // src/engine/landing-library/report.ts
 import { writeFile as writeFile15 } from "fs/promises";
-import path35 from "path";
+import path36 from "path";
 async function writeCaptureReport(manifest, outDir) {
-  const file = path35.join(outDir, "report.html");
+  const file = path36.join(outDir, "report.html");
   await writeFile15(file, renderReport(manifest));
   return file;
 }
@@ -51945,32 +52043,32 @@ async function reproducePage(args) {
   const { browser, page, outDir, pageUrl, livePageShot } = args;
   const built = await buildSectionBundle(page, "body", pageUrl).catch(() => null);
   if (!built) return { bundle: null, fidelity: null };
-  await writeFile16(path36.join(outDir, "page.html"), built.html);
+  await writeFile16(path37.join(outDir, "page.html"), built.html);
   const rendered = await renderBundleToPng(browser, built.html, DESKTOP_VIEWPORT.width, {
     wholePage: true,
     timeoutMs: 6e4
   });
   if (!rendered || !livePageShot) return { bundle: "page.html", fidelity: null };
-  await writeFile16(path36.join(outDir, "page-rendered.png"), rendered);
+  await writeFile16(path37.join(outDir, "page-rendered.png"), rendered);
   const { score, note } = await scoreFidelity(livePageShot, rendered);
   return { bundle: "page.html", fidelity: score, ...note ? { fidelityNote: note } : {} };
 }
 async function captureOneSection(args) {
   const { browser, page, candidate, sectionsDir, outDir, pageUrl, withCode } = args;
-  const dir = path36.join(sectionsDir, String(candidate.index).padStart(2, "0"));
+  const dir = path37.join(sectionsDir, String(candidate.index).padStart(2, "0"));
   await mkdir11(dir, { recursive: true });
   const desktop = await captureSection(page, candidate);
-  if (desktop) await writeFile16(path36.join(dir, "desktop.png"), desktop);
+  if (desktop) await writeFile16(path37.join(dir, "desktop.png"), desktop);
   const visualHash = desktop ? await perceptualHash(desktop) : null;
   const motion = await collectMotion(page, candidate.selector);
   const built = withCode ? await buildSectionBundle(page, candidate.selector, pageUrl) : null;
   let fidelity = null;
   let fidelityNote;
   if (built) {
-    await writeFile16(path36.join(dir, "section.html"), built.html);
+    await writeFile16(path37.join(dir, "section.html"), built.html);
     const rendered = await renderBundleToPng(browser, built.html, DESKTOP_VIEWPORT.width);
     if (rendered && desktop) {
-      await writeFile16(path36.join(dir, "section-rendered.png"), rendered);
+      await writeFile16(path37.join(dir, "section-rendered.png"), rendered);
       const result = await scoreFidelity(desktop, rendered);
       fidelity = result.score;
       fidelityNote = result.note;
@@ -51978,9 +52076,9 @@ async function captureOneSection(args) {
   }
   return {
     ...candidate,
-    desktopShot: desktop ? path36.relative(outDir, path36.join(dir, "desktop.png")) : null,
+    desktopShot: desktop ? path37.relative(outDir, path37.join(dir, "desktop.png")) : null,
     mobileShot: null,
-    bundle: built ? path36.relative(outDir, path36.join(dir, "section.html")) : null,
+    bundle: built ? path37.relative(outDir, path37.join(dir, "section.html")) : null,
     fidelity,
     ...fidelityNote ? { fidelityNote } : {},
     ...built ? { cssStats: built.stats } : {},
@@ -51999,9 +52097,9 @@ async function captureMobileShots(args) {
     for (const section of sections) {
       const shot = await captureSectionOnMobile(mobile.page, section);
       if (!shot) continue;
-      const file = path36.join(sectionsDir, String(section.index).padStart(2, "0"), "mobile.png");
+      const file = path37.join(sectionsDir, String(section.index).padStart(2, "0"), "mobile.png");
       await writeFile16(file, shot);
-      section.mobileShot = path36.relative(outDir, file);
+      section.mobileShot = path37.relative(outDir, file);
     }
   } finally {
     await mobile.context.close();
@@ -52016,10 +52114,10 @@ async function captureMotionTakes(args) {
   const filmOne = async (section) => {
     const take = await captureMotionTake(browser, pageUrl, section.selector).catch(() => null);
     if (!take) return;
-    const dir = path36.join(sectionsDir, String(section.index).padStart(2, "0"));
-    const file = path36.join(dir, "motion-filmstrip.png");
+    const dir = path37.join(sectionsDir, String(section.index).padStart(2, "0"));
+    const file = path37.join(dir, "motion-filmstrip.png");
     await writeFile16(file, take.filmstrip);
-    section.motionFilmstrip = path36.relative(outDir, file);
+    section.motionFilmstrip = path37.relative(outDir, file);
     log(`  [${section.index}] ${section.motion.summary}`);
   };
   const queue = [...moving];
@@ -52076,7 +52174,7 @@ async function captureAlternateViews(args) {
 async function reproduceWholePage(args) {
   const { browser, page, outDir, pageUrl, withCode, log } = args;
   const fullPage = await page.screenshot({ type: "png", fullPage: true }).catch(() => null);
-  if (fullPage) await writeFile16(path36.join(outDir, "full-page.png"), fullPage);
+  if (fullPage) await writeFile16(path37.join(outDir, "full-page.png"), fullPage);
   if (!withCode) return { bundle: null, fidelity: null };
   const reproduction = await reproducePage({ browser, page, outDir, pageUrl, livePageShot: fullPage });
   log(`page reproduction: ${reproduction.fidelity === null ? "unavailable" : reproduction.fidelity.toFixed(2)}`);
@@ -52147,7 +52245,7 @@ async function openViaLadder(args) {
 async function scrapeLanding(options) {
   const timeoutMs = options.timeoutMs ?? 45e3;
   const log = options.onProgress ?? (() => void 0);
-  const sectionsDir = path36.join(options.outDir, "sections");
+  const sectionsDir = path37.join(options.outDir, "sections");
   const nonPublic = refuseNonPublicUrl(options.url);
   if (nonPublic) {
     throw new BlockedPageError({
@@ -52209,7 +52307,7 @@ async function scrapeLanding(options) {
       security: prepared.security,
       captureTier: tier
     };
-    await writeFile16(path36.join(options.outDir, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
+    await writeFile16(path37.join(options.outDir, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
 `);
     if (options.report !== false) {
       const reportPath = await writeCaptureReport(manifest, options.outDir);
@@ -52224,28 +52322,28 @@ async function scrapeLanding(options) {
 
 // src/commands/landing/inspiration/captureOut.ts
 import { existsSync as existsSync9 } from "fs";
-import path37 from "path";
+import path38 from "path";
 var SCRATCH_DIR = ".baker";
 function isWithin(parent, target) {
-  const relative = path37.relative(parent, target);
-  return relative === "" || !relative.startsWith("..") && !path37.isAbsolute(relative);
+  const relative = path38.relative(parent, target);
+  return relative === "" || !relative.startsWith("..") && !path38.isAbsolute(relative);
 }
 function findRepoRoot(from) {
-  let dir = path37.resolve(from);
+  let dir = path38.resolve(from);
   for (; ; ) {
-    if (existsSync9(path37.join(dir, ".git"))) return dir;
-    const parent = path37.dirname(dir);
+    if (existsSync9(path38.join(dir, ".git"))) return dir;
+    const parent = path38.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
 }
 function checkCaptureOut(out, options) {
   const { cwd, repoRoot } = options;
-  const resolved = path37.resolve(cwd, out);
+  const resolved = path38.resolve(cwd, out);
   if (repoRoot === null || !isWithin(repoRoot, resolved)) return { ok: true };
-  const scratch = path37.join(repoRoot, SCRATCH_DIR);
+  const scratch = path38.join(repoRoot, SCRATCH_DIR);
   if (isWithin(scratch, resolved)) return { ok: true };
-  const suggestion = path37.posix.join(SCRATCH_DIR, "teardowns", path37.basename(resolved) || "capture");
+  const suggestion = path38.posix.join(SCRATCH_DIR, "teardowns", path38.basename(resolved) || "capture");
   return {
     ok: false,
     error: {
@@ -52419,12 +52517,12 @@ var scrapeCommand = defineCommand169({
 });
 
 // src/commands/landing/inspiration/search.ts
-import path39 from "path";
+import path40 from "path";
 import { defineCommand as defineCommand170 } from "citty";
 
 // src/commands/landing/inspiration/shot.ts
 import { mkdir as mkdir12, writeFile as writeFile17 } from "fs/promises";
-import path38 from "path";
+import path39 from "path";
 import sharp6 from "sharp";
 var READABLE_SHOT = {
   maxWidth: 1440,
@@ -52450,9 +52548,9 @@ async function downloadReadableShot(url, file) {
     const response = await fetch(url);
     if (!response.ok) return null;
     const shot = await toReadableShot(Buffer.from(await response.arrayBuffer()));
-    await mkdir12(path38.dirname(file), { recursive: true });
+    await mkdir12(path39.dirname(file), { recursive: true });
     await writeFile17(file, shot);
-    return path38.relative(process.cwd(), file);
+    return path39.relative(process.cwd(), file);
   } catch {
     return null;
   }
@@ -52544,13 +52642,13 @@ function buildSearchBody(args) {
   return body;
 }
 async function downloadShots(results) {
-  const dir = path39.join(process.cwd(), ".baker", "inspiration");
+  const dir = path40.join(process.cwd(), ".baker", "inspiration");
   const saved = /* @__PURE__ */ new Map();
   await Promise.all(
     results.map(async (result) => {
       const file = await downloadReadableShot(
         result.desktopShotUrl,
-        path39.join(dir, `${result.id}.${READABLE_SHOT.extension}`)
+        path40.join(dir, `${result.id}.${READABLE_SHOT.extension}`)
       );
       if (file) saved.set(result.id, file);
     })
@@ -52778,7 +52876,7 @@ var sequencesCommand = defineCommand171({
 });
 
 // src/commands/landing/inspiration/view.ts
-import path40 from "path";
+import path41 from "path";
 import { defineCommand as defineCommand172 } from "citty";
 registerSchema({
   command: "landing.inspiration.view",
@@ -52811,12 +52909,12 @@ var viewCommand2 = defineCommand172({
       const id = args.id;
       const data = await apiGet("/api/landing-inspiration/section", { id });
       const section = data.section;
-      const dir = path40.join(process.cwd(), ".baker", "inspiration", id);
+      const dir = path41.join(process.cwd(), ".baker", "inspiration", id);
       const ext = READABLE_SHOT.extension;
       const [desktop, mobile, filmstrip] = await Promise.all([
-        downloadReadableShot(section.desktopShotUrl, path40.join(dir, `desktop.${ext}`)),
-        downloadReadableShot(section.mobileShotUrl, path40.join(dir, `mobile.${ext}`)),
-        downloadReadableShot(section.motionFilmstripUrl, path40.join(dir, `motion-filmstrip.${ext}`))
+        downloadReadableShot(section.desktopShotUrl, path41.join(dir, `desktop.${ext}`)),
+        downloadReadableShot(section.mobileShotUrl, path41.join(dir, `mobile.${ext}`)),
+        downloadReadableShot(section.motionFilmstripUrl, path41.join(dir, `motion-filmstrip.${ext}`))
       ]);
       const full = args.full;
       const hints2 = [INSPIRATION_HINTS.structureNotCopy, INSPIRATION_HINTS.adapt];
@@ -52922,8 +53020,8 @@ Full guide: __tooling__/docs/tools/baker/landing.md`
 
 // src/commands/landing/variant.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { mkdir as mkdir13, readdir as readdir13, readFile as readFile27, stat as stat9, writeFile as writeFile18 } from "fs/promises";
-import path41 from "path";
+import { mkdir as mkdir13, readdir as readdir13, readFile as readFile28, stat as stat9, writeFile as writeFile18 } from "fs/promises";
+import path42 from "path";
 import { defineCommand as defineCommand174 } from "citty";
 registerSchema({
   command: "landing.variant",
@@ -52950,7 +53048,7 @@ registerSchema({
 var SLUG_RE2 = /^[a-z0-9][a-z0-9-]*$/;
 async function readInternalId(definitionPath) {
   try {
-    const text2 = await readFile27(definitionPath, "utf8");
+    const text2 = await readFile28(definitionPath, "utf8");
     return /^internalId:\s*"?([^"\s]+)"?\s*$/m.exec(text2)?.[1] ?? null;
   } catch {
     return null;
@@ -52959,7 +53057,7 @@ async function readInternalId(definitionPath) {
 async function archivedVariantNumbers(root, internalId) {
   if (!internalId) return [];
   try {
-    const entries = await readdir13(path41.resolve(root, "src/_variants", internalId), { withFileTypes: true });
+    const entries = await readdir13(path42.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 [];
@@ -52989,7 +53087,7 @@ async function exists(p) {
 }
 async function listLandingSlugs2(root) {
   try {
-    const entries = await readdir13(path41.resolve(root, "src", "pages"), { withFileTypes: true });
+    const entries = await readdir13(path42.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 [];
@@ -53005,7 +53103,7 @@ async function listComponents(componentsDir, prefix = "") {
   const out = [];
   for (const entry of entries) {
     const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
-    if (entry.isDirectory()) out.push(...await listComponents(path41.join(componentsDir, entry.name), rel));
+    if (entry.isDirectory()) out.push(...await listComponents(path42.join(componentsDir, entry.name), rel));
     else if (entry.name.endsWith(".astro")) out.push(rel);
   }
   return out.sort();
@@ -53072,16 +53170,16 @@ async function resolveTargets(projectRoot, opts) {
       `"${controlSlug}" is already a variant of "${variantOfSlug(controlSlug)}". Make the next variant of the page itself: \`baker landing variant ${variantOfSlug(controlSlug)}\`.`
     );
   }
-  const controlDir = path41.resolve(projectRoot, "src", "pages", controlSlug);
+  const controlDir = path42.resolve(projectRoot, "src", "pages", controlSlug);
   if (!await isDir3(controlDir)) {
     fail7("NOT_FOUND", `No page at src/pages/${controlSlug}/`, {
       availableSlugs: await listLandingSlugs2(projectRoot)
     });
   }
-  if (!await exists(path41.join(controlDir, "index.astro"))) {
+  if (!await exists(path42.join(controlDir, "index.astro"))) {
     fail7("NOT_FOUND", `src/pages/${controlSlug}/index.astro is missing, so there is no page to make a variant of.`);
   }
-  const internalId = await readInternalId(path41.join(controlDir, "_definition.md"));
+  const internalId = await readInternalId(path42.join(controlDir, "_definition.md"));
   const variantSlugValue = variantSlug(
     controlSlug,
     nextVariantNumber(
@@ -53090,8 +53188,8 @@ async function resolveTargets(projectRoot, opts) {
       await archivedVariantNumbers(projectRoot, internalId)
     )
   );
-  const variantDir = path41.resolve(projectRoot, "src", "pages", variantSlugValue);
-  const available = await listComponents(path41.join(controlDir, "_components"));
+  const variantDir = path42.resolve(projectRoot, "src", "pages", variantSlugValue);
+  const available = await listComponents(path42.join(controlDir, "_components"));
   const forks = [];
   for (const name of parseForks(opts.fork, opts.rawArgs)) {
     const resolved = resolveForkName(name, available);
@@ -53107,26 +53205,26 @@ async function resolveTargets(projectRoot, opts) {
 }
 async function writeVariant(opts) {
   const { controlDir, variantDir, controlSlug, variantSlug: variantSlug2, forks } = opts;
-  const forkedTargets = new Set(forks.map((f) => path41.join(controlDir, "_components", f)));
+  const forkedTargets = new Set(forks.map((f) => path42.join(controlDir, "_components", f)));
   const written = [];
-  const indexText = await readFile27(path41.join(controlDir, "index.astro"), "utf8");
+  const indexText = await readFile28(path42.join(controlDir, "index.astro"), "utf8");
   await mkdir13(variantDir, { recursive: true });
   await writeFile18(
-    path41.join(variantDir, "index.astro"),
+    path42.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 = path41.join(controlDir, "_components", fork);
-    const toFile = path41.join(variantDir, "_components", fork);
-    const text2 = await readFile27(fromFile, "utf8");
-    await mkdir13(path41.dirname(toFile), { recursive: true });
+    const fromFile = path42.join(controlDir, "_components", fork);
+    const toFile = path42.join(variantDir, "_components", fork);
+    const text2 = await readFile28(fromFile, "utf8");
+    await mkdir13(path42.dirname(toFile), { recursive: true });
     await writeFile18(
       toFile,
       repointFile(text2, {
-        fromDir: path41.dirname(fromFile),
-        toDir: path41.dirname(toFile),
+        fromDir: path42.dirname(fromFile),
+        toDir: path42.dirname(toFile),
         controlDir,
         variantDir,
         forkedTargets
@@ -53135,9 +53233,9 @@ async function writeVariant(opts) {
     );
     written.push(`src/pages/${variantSlug2}/_components/${fork}`);
   }
-  const controlDefinitionPath = path41.join(controlDir, "_definition.md");
+  const controlDefinitionPath = path42.join(controlDir, "_definition.md");
   if (await exists(controlDefinitionPath)) {
-    const definition = buildVariantDefinition(await readFile27(controlDefinitionPath, "utf8"), {
+    const definition = buildVariantDefinition(await readFile28(controlDefinitionPath, "utf8"), {
       internalId: randomUUID2().replace(/-/g, "").slice(0, 8),
       variantSlug: variantSlug2,
       controlSlug,
@@ -53145,11 +53243,11 @@ async function writeVariant(opts) {
       ...opts.because ? { because: opts.because } : {},
       ...opts.change ? { change: opts.change } : {}
     });
-    await writeFile18(path41.join(variantDir, "_definition.md"), definition, "utf8");
+    await writeFile18(path42.join(variantDir, "_definition.md"), definition, "utf8");
     written.push(`src/pages/${variantSlug2}/_definition.md`);
   }
-  await mkdir13(path41.join(variantDir, "_images"), { recursive: true });
-  await writeFile18(path41.join(variantDir, "_images", ".gitkeep"), "", "utf8");
+  await mkdir13(path42.join(variantDir, "_images"), { recursive: true });
+  await writeFile18(path42.join(variantDir, "_images", ".gitkeep"), "", "utf8");
   return written;
 }
 var variantCommand = defineCommand174({
@@ -55171,8 +55269,8 @@ var listCommand16 = defineCommand193({
 });
 
 // src/commands/scheduled-actions/templates.ts
-import { readFile as readFile28 } from "fs/promises";
-import path42 from "path";
+import { readFile as readFile29 } from "fs/promises";
+import path43 from "path";
 import { defineCommand as defineCommand194 } from "citty";
 registerSchema({
   command: "scheduled-actions.templates",
@@ -55275,7 +55373,7 @@ Full guide: __tooling__/docs/tools/baker/scheduled-actions.md`
       }
       if (save.length > 0) {
         const briefFile = flag("brief-file");
-        const brief = briefFile.length > 0 ? await readFile28(path42.resolve(briefFile), "utf8") : flag("brief");
+        const brief = briefFile.length > 0 ? await readFile29(path43.resolve(briefFile), "utf8") : flag("brief");
         if (brief.trim().length === 0) {
           failValidation4("--brief-file (preferred) or --brief is required: the brief is the recipe.");
         }
@@ -55746,7 +55844,7 @@ function parseImageRefs(spec) {
 }
 var defaultDeps = {
   ingest: (url) => apiPost("/api/images/ingest", { url, source: "uploaded" }),
-  upload: (path44) => uploadLocalImage({ file: path44, contentType: detectImageContentType(path44), source: "uploaded" })
+  upload: (path45) => uploadLocalImage({ file: path45, contentType: detectImageContentType(path45), source: "uploaded" })
 };
 async function resolveLibraryImageIds(spec, limit, deps = defaultDeps) {
   const refs = parseImageRefs(spec);
@@ -55766,10 +55864,10 @@ async function resolveLibraryImageIds(spec, limit, deps = defaultDeps) {
   }
   return { imageIds, added };
 }
-function uploadFailure(path44) {
+function uploadFailure(path45) {
   return (error) => {
     if (error instanceof ApiError) throw error;
-    throw new ApiError("VALIDATION_ERROR", `Could not read "${path44}" as an image.`);
+    throw new ApiError("VALIDATION_ERROR", `Could not read "${path45}" as an image.`);
   };
 }
 
@@ -56831,10 +56929,10 @@ async function stageOp4(op) {
     handleError5(err);
   }
 }
-async function draftAction3(path44, body, chat) {
+async function draftAction3(path45, body, chat) {
   const chatId = resolveChatId(chat);
   try {
-    const data = await apiPost(path44, { chatId, ...body });
+    const data = await apiPost(path45, { chatId, ...body });
     writeJsonEnvelope({ ok: true, data });
     return data;
   } catch (err) {
@@ -57971,7 +58069,7 @@ var groupCommand2 = defineCommand219({
 // src/commands/videos/ingest.ts
 import { mkdtemp as mkdtemp2, rm as rm8, stat as stat10 } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
-import path43 from "path";
+import path44 from "path";
 import { defineCommand as defineCommand220 } from "citty";
 
 // src/lib/streamUpload.ts
@@ -58322,7 +58420,7 @@ function ingestUrl(args) {
 }
 async function downloadThenIngest(args, country) {
   const vimeoCookie = captureVimeoCookie();
-  const workDir = await mkdtemp2(path43.join(tmpdir3(), "videos-ingest-"));
+  const workDir = await mkdtemp2(path44.join(tmpdir3(), "videos-ingest-"));
   try {
     const probe = await probeYtDlp({ url: args.url, country, vimeoCookie, cookieDir: workDir });
     if (isAudioOnly(probe.info)) {
@@ -58458,7 +58556,7 @@ var searchCommand4 = defineCommand221({
 var tagsCommand6 = makeTagsCommand("videos", "video", "/api/videos/tags");
 
 // src/commands/videos/upload.ts
-import { readFile as readFile29, stat as stat11 } from "fs/promises";
+import { readFile as readFile30, stat as stat11 } from "fs/promises";
 import { basename as basename3, extname as extname4 } from "path";
 import { defineCommand as defineCommand222 } from "citty";
 var MIME_MAP = {
@@ -58555,7 +58653,7 @@ var uploadCommand2 = defineCommand222({
         originalFilename,
         descriptionContext
       });
-      const fileBuffer = await readFile29(filePath);
+      const fileBuffer = await readFile30(filePath);
       const uploadResponse = await fetch(uploadUrl, {
         method: "PUT",
         headers: { "Content-Type": contentType },
@@ -59942,7 +60040,7 @@ function unknownFlagEnvelope(unknown, commandPath, suggestion) {
   };
 }
 function commandPathOf(root, argv) {
-  const path44 = [];
+  const path45 = [];
   let command = root;
   for (const token of argv) {
     if (token === "--" || token.startsWith("-")) {
@@ -59953,10 +60051,10 @@ function commandPathOf(root, argv) {
     if (next === void 0 || typeof next !== "object") {
       break;
     }
-    path44.push(token);
+    path45.push(token);
     command = next;
   }
-  return path44.join(" ");
+  return path45.join(" ");
 }
 function refuseUnknownFlags(root, argv) {
   const unknown = findUnknownFlags(root, argv);