@koda-sl/baker-cli 0.573.0 → 0.574.0

package/dist/validate-HIYNINCN.js

@@ -1,135 +0,0 @@
-import {
-  outputRatioWarningsFor,
-  shownBaseline,
-  validateResult
-} from "./chunk-643AA3RB.js";
-import "./chunk-OX5DS7UE.js";
-import {
-  creativeSlugFromCanvasPath
-} from "./chunk-VAV5CCDD.js";
-import {
-  exitOnPrepareError,
-  prepareCanvas
-} from "./chunk-C4BPAMAJ.js";
-import "./chunk-PRHDGULQ.js";
-import "./chunk-Q5DLTIYL.js";
-import "./chunk-CF5I4Q5M.js";
-import "./chunk-EKX37C3T.js";
-import "./chunk-IJ6WA2JW.js";
-import "./chunk-CKN4HQZM.js";
-import "./chunk-6MJKVNLL.js";
-import "./chunk-7GFGFBWZ.js";
-import "./chunk-BNEWJXKU.js";
-import "./chunk-C57CXCTI.js";
-import "./chunk-GQUBM3Z6.js";
-import "./chunk-ITIUWJGQ.js";
-import "./chunk-G6XKD7QE.js";
-import "./chunk-BIBXZJZI.js";
-import "./chunk-Q3G4ZI2U.js";
-import {
-  canvasOutputsRoot
-} from "./chunk-DGHSXHZR.js";
-import {
-  defaultRegistry,
-  validateCanvasDeep
-} from "./chunk-HM4NWA72.js";
-import "./chunk-J4BJLHLQ.js";
-import "./chunk-2N7TB346.js";
-import "./chunk-BFAPSFS7.js";
-import "./chunk-DGCUPJZD.js";
-import "./chunk-OJZKY5UM.js";
-import "./chunk-JGK2FDZW.js";
-import "./chunk-47VWQ7FQ.js";
-import "./chunk-MCJ5I5LR.js";
-import "./chunk-2WZI36D3.js";
-import "./chunk-65Y3RCWP.js";
-import "./chunk-Q736UFSD.js";
-import "./chunk-CBVUO7SK.js";
-import "./chunk-UK4XSLV2.js";
-import "./chunk-O5VSYBUA.js";
-import "./chunk-ICASR3ES.js";
-import "./chunk-QV6AST5T.js";
-import "./chunk-WCU362Z6.js";
-import "./chunk-GIWHHCD6.js";
-import "./chunk-SOPVIIUW.js";
-import "./chunk-G4FG5EQO.js";
-import "./chunk-R7XDGNZD.js";
-import "./chunk-XHWHBGKX.js";
-import "./chunk-LJEJCIHR.js";
-import "./chunk-SIRRBWQ2.js";
-import {
-  optionalTurnId
-} from "./chunk-B64KJW5C.js";
-import "./chunk-NXNOXZGB.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" },
-    full: {
-      type: "boolean",
-      default: false,
-      description: "Also print the per-node cost preview and what the prompt.json and scene projections did"
-    }
-  },
-  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(
-        validateResult(
-          {
-            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)]
-          },
-          { full: args.full === true }
-        ),
-        null,
-        2
-      )}
-`
-    );
-  }
-});
-export {
-  validateCommand
-};
-//# sourceMappingURL=validate-HIYNINCN.js.map

package/dist/variant-RNM36P4J.js

@@ -1,338 +0,0 @@
-import {
-  nextVariantNumber,
-  repointFile,
-  variantNumberOf,
-  variantOfSlug,
-  variantSlug
-} from "./chunk-LA6PPSNA.js";
-import {
-  repeatedValues
-} from "./chunk-ERSX3MKH.js";
-import {
-  apiPost
-} from "./chunk-LJEJCIHR.js";
-import "./chunk-SIRRBWQ2.js";
-import "./chunk-B64KJW5C.js";
-import {
-  registerSchema
-} from "./chunk-NXNOXZGB.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-RNM36P4J.js.map

package/dist/videos-GHFCOTT7.js

@@ -1,146 +0,0 @@
-import {
-  handleMetaError
-} from "./chunk-4HFM5RCP.js";
-import "./chunk-QALAJNBG.js";
-import {
-  writeJsonEnvelope
-} from "./chunk-MPTNN35I.js";
-import {
-  apiGet
-} from "./chunk-LJEJCIHR.js";
-import "./chunk-SIRRBWQ2.js";
-import "./chunk-B64KJW5C.js";
-import {
-  registerSchema
-} from "./chunk-NXNOXZGB.js";
-import "./chunk-YQSBHWOI.js";
-
-// src/commands/ads/meta/videos.ts
-import { createWriteStream, mkdirSync } from "fs";
-import { join } from "path";
-import { Readable } from "stream";
-import { pipeline } from "stream/promises";
-
-// ../api/src/ads-meta/adVideos.ts
-import { z } from "zod";
-var metaAdVideoSchema = z.object({
-  videoId: z.string(),
-  /** Short-lived MP4 address; null when Meta does not hand the file to this connection. */
-  source: z.string().url().nullable(),
-  seconds: z.number().nullable(),
-  title: z.string().nullable(),
-  thumbnail: z.string().url().nullable()
-});
-var metaAdVideosResponseSchema = z.object({
-  adId: z.string().nullable(),
-  creativeId: z.string(),
-  videos: z.array(metaAdVideoSchema)
-});
-
-// src/commands/ads/meta/videos.ts
-import { defineCommand } from "citty";
-var DEFAULT_OUT_DIR = "/tmp/meta-ad-videos";
-function downloadHints(results) {
-  const all = results.flatMap((result) => result.videos);
-  const hints = [];
-  if (all.length === 0)
-    hints.push("No video in these ads: they are image or carousel ads (`creatives --creative-id` shows their assets).");
-  if (all.some((video) => video.file === null && video.url === void 0)) {
-    hints.push(
-      "A video with no file is a copy Meta does not hand to this connection (usually the Page's copy of the same upload); the other video of that ad is the same film."
-    );
-  }
-  if (all.some((video) => video.file !== null)) {
-    hints.push(
-      "Watch before judging: a frame strip (`ffmpeg -i <file> -vf fps=2,scale=240:-1,tile=8x2 strip.jpg`) and the 3-second hold rate from `insights --level ad --intent video`."
-    );
-  }
-  return hints;
-}
-async function download(url, file) {
-  const response = await fetch(url);
-  if (!response.ok || !response.body) throw new Error(`Meta's video address answered ${response.status}`);
-  await pipeline(Readable.fromWeb(response.body), createWriteStream(file));
-  return Number(response.headers.get("content-length") ?? 0);
-}
-async function fetchAndSave(params, outDir, save) {
-  const data = metaAdVideosResponseSchema.parse(await apiGet("/api/ads/meta/videos", params));
-  const owner = data.adId ?? data.creativeId;
-  const videos = [];
-  for (const video of data.videos) {
-    if (!video.source || !save) {
-      videos.push({
-        videoId: video.videoId,
-        file: null,
-        ...video.source ? { url: video.source } : {},
-        seconds: video.seconds,
-        megabytes: null
-      });
-      continue;
-    }
-    const file = join(outDir, `${owner}-${video.videoId}.mp4`);
-    const bytes = await download(video.source, file);
-    videos.push({
-      videoId: video.videoId,
-      file,
-      seconds: video.seconds,
-      megabytes: bytes ? Math.round(bytes / 1e5) / 10 : null
-    });
-  }
-  return { adId: data.adId, creativeId: data.creativeId, videos };
-}
-var splitIds = (value) => typeof value === "string" ? value.split(",").map((id) => id.trim()).filter(Boolean) : [];
-registerSchema({
-  command: "ads.meta.videos",
-  description: "Download the video files of running Meta ads (or creatives) to disk, to watch, cut or analyse them. One call for several ads.",
-  args: {
-    "ad-id": { type: "string", description: "Ad id, or several comma-separated", required: false },
-    "creative-id": { type: "string", description: "Creative id, or several comma-separated", required: false },
-    "out-dir": { type: "string", description: `Where the MP4s go (default ${DEFAULT_OUT_DIR})`, required: false },
-    "url-only": {
-      type: "boolean",
-      description: "Return Meta's short-lived addresses instead of files",
-      required: false
-    }
-  }
-});
-var videosCommand = defineCommand({
-  meta: {
-    name: "videos",
-    description: `Download the video files behind Meta ads, to watch, cut or analyse the company's own ads.
-  baker ads meta videos --ad-id 120211234567890,120211234567891     \u2014 MP4s in ${DEFAULT_OUT_DIR}
-  baker ads meta videos --creative-id 9988 --out-dir /tmp/ads        \u2014 by creative
-Start here when judging video ads: \`insights --level ad --intent video\` names the ads, this gets their files.`
-  },
-  args: {
-    "ad-id": { type: "string", description: "Ad id, or several comma-separated" },
-    "creative-id": { type: "string", description: "Creative id, or several comma-separated" },
-    "out-dir": { type: "string", description: `Where the MP4s go (default ${DEFAULT_OUT_DIR})` },
-    // Not `--no-download`: citty reads any `--no-x` as `x: false`, so that flag would never be set.
-    "url-only": { type: "boolean", description: "Return Meta's short-lived addresses instead of files" }
-  },
-  run: async ({ args }) => {
-    const adIds = splitIds(args["ad-id"]);
-    const creativeIds = splitIds(args["creative-id"]);
-    if (adIds.length + creativeIds.length === 0) {
-      writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message: "Name --ad-id or --creative-id" } });
-      process.exit(1);
-    }
-    const outDir = typeof args["out-dir"] === "string" ? args["out-dir"] : DEFAULT_OUT_DIR;
-    const save = !args["url-only"];
-    if (save) mkdirSync(outDir, { recursive: true });
-    try {
-      const results = [];
-      for (const id of adIds) results.push(await fetchAndSave({ "ad-id": id }, outDir, save));
-      for (const id of creativeIds) results.push(await fetchAndSave({ "creative-id": id }, outDir, save));
-      writeJsonEnvelope({ ok: true, data: results, hints: downloadHints(results) });
-    } catch (err) {
-      handleMetaError(err);
-    }
-  }
-});
-export {
-  downloadHints,
-  videosCommand
-};
-//# sourceMappingURL=videos-GHFCOTT7.js.map

package/dist/videos-XGQL37V4.js

@@ -1,41 +0,0 @@
-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-JIZPYK3Z.js").then((m) => m.getCommand),
-    group: () => import("./group-3DT4UYSR.js").then((m) => m.groupCommand),
-    search: () => import("./search-TXBYKNQC.js").then((m) => m.searchCommand),
-    upload: () => import("./upload-UYE73VLK.js").then((m) => m.uploadCommand),
-    ingest: () => import("./ingest-T3AV5OR4.js").then((m) => m.ingestCommand),
-    fetch: () => import("./fetch-I6P72CDL.js").then((m) => m.fetchCommand),
-    download: () => import("./download-B4IV43AJ.js").then((m) => m.downloadCommand),
-    describe: () => import("./describe-MAGTSOW4.js").then((m) => m.describeCommand),
-    delete: () => import("./delete-SP66F7ZV.js").then((m) => m.deleteCommand),
-    retry: () => import("./retry-YZCBWAHT.js").then((m) => m.retryCommand),
-    tags: () => import("./tags-CVPMOYKI.js").then((m) => m.tagsCommand)
-  }
-});
-export {
-  videosCommand
-};
-//# sourceMappingURL=videos-XGQL37V4.js.map