@koda-sl/baker-cli 0.442.0 → 0.443.0-dev.043c1d4ac

package/dist/chunk-NU7JSWVA.js

@@ -0,0 +1,946 @@
+// src/schemas.ts
+var registry = /* @__PURE__ */ new Map();
+function registerSchema(schema) {
+  registry.set(schema.command, schema);
+}
+function listSchemas() {
+  return [...registry.keys()];
+}
+function spellingKey(name) {
+  return name.toLowerCase().replaceAll("-", "");
+}
+function resolveSchemaName(words, names) {
+  const joined = words.join(".");
+  if (names.includes(joined)) {
+    return joined;
+  }
+  const matches = names.filter((name) => spellingKey(name) === spellingKey(joined));
+  return matches.length === 1 ? matches[0] : void 0;
+}
+function findSchema(words) {
+  const name = resolveSchemaName(words, listSchemas());
+  return name === void 0 ? void 0 : registry.get(name);
+}
+
+// src/unknown-flags.ts
+var ALWAYS_ACCEPTED = /* @__PURE__ */ new Set(["help", "h", "version"]);
+function subCommandsOf(command) {
+  const sub = command.subCommands;
+  return sub && typeof sub === "object" ? sub : null;
+}
+function argsOf(command) {
+  const args = command.args;
+  return args && typeof args === "object" ? args : null;
+}
+function resolveCommand(root, argv) {
+  let command = root;
+  for (const token of argv) {
+    if (token === "--" || token.startsWith("-")) {
+      break;
+    }
+    const subCommands = subCommandsOf(command);
+    if (!subCommands) {
+      break;
+    }
+    const next = subCommands[token];
+    if (next === void 0) {
+      break;
+    }
+    if (typeof next !== "object") {
+      return { command, resolved: false };
+    }
+    command = next;
+  }
+  return { command, resolved: true };
+}
+function typeOf(def) {
+  return def && typeof def === "object" ? def.type : void 0;
+}
+function acceptedNames(command) {
+  const args = argsOf(command);
+  if (!args) {
+    return null;
+  }
+  const names = new Set(ALWAYS_ACCEPTED);
+  for (const [name, def] of Object.entries(args)) {
+    if (typeOf(def) === "positional") {
+      continue;
+    }
+    for (const spelling of [name, kebab(name), camel(name)]) {
+      names.add(spelling);
+      if (typeOf(def) === "boolean") {
+        names.add(`no-${spelling}`);
+      }
+    }
+  }
+  return names;
+}
+function kebab(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function camel(name) {
+  return name.replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
+function findUnknownFlags(root, argv) {
+  const { command, resolved } = resolveCommand(root, argv);
+  if (!resolved) {
+    return [];
+  }
+  const accepted = acceptedNames(command);
+  if (!accepted) {
+    return [];
+  }
+  const unknown = [];
+  for (const token of argv) {
+    if (token === "--") {
+      break;
+    }
+    if (!token.startsWith("--")) {
+      continue;
+    }
+    const name = token.slice(2).split("=")[0] ?? "";
+    if (name.length > 0 && !accepted.has(name) && !unknown.includes(token)) {
+      unknown.push(token);
+    }
+  }
+  return unknown;
+}
+var SYNONYMS = {
+  from: ["start-date", "start", "since"],
+  since: ["start-date", "start"],
+  start: ["start-date", "since"],
+  to: ["end-date", "end", "until"],
+  until: ["end-date", "end"],
+  end: ["end-date", "until"],
+  path: ["landing"],
+  url: ["landing"]
+};
+function closestFlag(unknown, command) {
+  const accepted = acceptedNames(command);
+  if (!accepted) {
+    return null;
+  }
+  const name = unknown.replace(/^--/, "").split("=")[0] ?? "";
+  const synonym = SYNONYMS[name]?.find((candidate) => accepted.has(candidate));
+  if (synonym) {
+    return `--${synonym}`;
+  }
+  const scored = [...accepted].filter((candidate) => !ALWAYS_ACCEPTED.has(candidate)).map((candidate) => ({
+    candidate,
+    prefix: sharedPrefix(name, candidate),
+    distance: editDistance(name, candidate)
+  })).filter(({ prefix, distance }) => prefix >= 4 || distance <= typoBudget(name)).sort((a, b) => b.prefix - a.prefix || a.distance - b.distance);
+  return scored[0] ? `--${scored[0].candidate}` : null;
+}
+function typoBudget(name) {
+  return Math.max(1, Math.floor(name.length / 3));
+}
+function sharedPrefix(a, b) {
+  let i = 0;
+  while (i < a.length && i < b.length && a[i] === b[i]) {
+    i++;
+  }
+  return i;
+}
+function editDistance(a, b) {
+  let previous = Array.from({ length: b.length + 1 }, (_, j) => j);
+  for (let i = 1; i <= a.length; i++) {
+    const current = [i];
+    for (let j = 1; j <= b.length; j++) {
+      const substitution = (previous[j - 1] ?? 0) + (a[i - 1] === b[j - 1] ? 0 : 1);
+      current.push(Math.min((previous[j] ?? 0) + 1, (current[j - 1] ?? 0) + 1, substitution));
+    }
+    previous = current;
+  }
+  return previous[b.length] ?? 0;
+}
+function commandFor(root, argv) {
+  const { command, resolved } = resolveCommand(root, argv);
+  return resolved ? command : null;
+}
+function suggestFlag(unknown, command) {
+  const flag = closestFlag(unknown, command);
+  if (!flag) {
+    return null;
+  }
+  const args = argsOf(command) ?? {};
+  const name = flag.slice(2);
+  const def = args[name] ?? args[camel(name)];
+  const described = def && typeof def === "object" ? def.description : void 0;
+  const description = typeof described === "string" ? described.split(/(?<!\b(?:e\.g|i\.e|vs))\.\s/)[0]?.trim().replace(/\.$/, "") : "";
+  return description ? { flag, description } : { flag };
+}
+function suggestionText(suggestion) {
+  if (!suggestion) {
+    return "";
+  }
+  return suggestion.description ? `Did you mean ${suggestion.flag}? It is described as: ${suggestion.description}. ` : `Did you mean ${suggestion.flag}? `;
+}
+var OUTPUT_EXPLANATION = "This command has no --output option: `--output json` is accepted by every command that prints the JSON envelope, and md or files only where `baker schema` lists `output`. Drop the option and read the default output. ";
+function unknownFlagEnvelope(unknown, commandPath, suggestion, hasSchema) {
+  const list = unknown.join(", ");
+  return {
+    ok: false,
+    error: {
+      code: "UNKNOWN_ARGUMENT",
+      message: `${list} ${unknown.length > 1 ? "are not options" : "is not an option"} of \`baker ${commandPath}\`.`,
+      fix: {
+        action: hasSchema ? "check_schema" : "check_help",
+        explanation: (unknown.some((flag) => flag === "--output" || flag.startsWith("--output=")) ? OUTPUT_EXPLANATION : "") + suggestionText(suggestion) + `Run \`${hasSchema ? `baker schema ${commandPath}` : `baker ${commandPath} --help`}\` to see every option this command takes. Do not re-run the same call: until this version an unrecognised option was accepted and ignored, so a command that looked like it had filtered or narrowed the result was in fact answering the unfiltered question.`
+      },
+      retryable: false
+    }
+  };
+}
+function commandPathOf(root, argv) {
+  const path = [];
+  let command = root;
+  for (const token of argv) {
+    if (token === "--" || token.startsWith("-")) {
+      break;
+    }
+    const subCommands = subCommandsOf(command);
+    const next = subCommands?.[token];
+    if (next === void 0 || typeof next !== "object") {
+      break;
+    }
+    path.push(token);
+    command = next;
+  }
+  return path.join(" ");
+}
+function refuseUnknownFlags(root, argv) {
+  const unknown = findUnknownFlags(root, argv);
+  if (unknown.length === 0) {
+    return;
+  }
+  const command = commandFor(root, argv);
+  const first = unknown[0];
+  const suggestion = command && first ? suggestFlag(first, command) : null;
+  const path = commandPathOf(root, argv);
+  process.stdout.write(
+    `${JSON.stringify(unknownFlagEnvelope(unknown, path, suggestion, findSchema(path.split(" ")) !== void 0), null, 2)}
+`
+  );
+  process.exit(1);
+}
+
+// src/output-flag.ts
+var FLAG = "--output";
+var ENVELOPE = "json";
+var PRINTS_NO_ENVELOPE = /* @__PURE__ */ new Set([
+  "analytics sending-events",
+  "canvas run",
+  "canvas rerun",
+  "canvas sync-definition"
+]);
+function declaredArg(command, name) {
+  const args = command.args;
+  if (!args || typeof args !== "object" || !(name in args)) {
+    return null;
+  }
+  const def = args[name];
+  return def && typeof def === "object" ? def : {};
+}
+function envelopeRequests(argv) {
+  const end = argv.indexOf("--");
+  const limit = end === -1 ? argv.length : end;
+  const found = [];
+  for (let index = 0; index < limit; index++) {
+    const token = argv[index];
+    if (token === `${FLAG}=${ENVELOPE}`) {
+      found.push({ index, length: 1 });
+    } else if (token === FLAG && argv[index + 1] === ENVELOPE && index + 1 < limit) {
+      found.push({ index, length: 2 });
+      index++;
+    }
+  }
+  return found;
+}
+function outputFlagForCommand(root, argv) {
+  const requests = envelopeRequests(argv);
+  if (requests.length === 0) {
+    return argv;
+  }
+  const command = commandFor(root, argv);
+  if (!command || declaredArg(command, "output") || PRINTS_NO_ENVELOPE.has(commandPathOf(root, argv))) {
+    return argv;
+  }
+  const jsonSwitch = declaredArg(command, "json")?.type === "boolean";
+  const dropped = new Set(requests.flatMap(({ index, length }) => length === 2 ? [index, index + 1] : [index]));
+  const first = requests[0]?.index;
+  return argv.flatMap((token, index) => {
+    if (!dropped.has(index)) {
+      return [token];
+    }
+    return jsonSwitch && index === first ? ["--json"] : [];
+  });
+}
+
+// src/field-mask.ts
+var FLAG2 = "--fields";
+function parseFields(value) {
+  return value.split(",").map((field) => field.trim()).filter((field) => field.length > 0);
+}
+function takeFieldsFlag(root, argv) {
+  const end = argv.indexOf("--");
+  const limit = end === -1 ? argv.length : end;
+  const taken = /* @__PURE__ */ new Set();
+  const fields = [];
+  for (let index = 0; index < limit; index++) {
+    const token = argv[index] ?? "";
+    if (token.startsWith(`${FLAG2}=`)) {
+      taken.add(index);
+      fields.push(...parseFields(token.slice(FLAG2.length + 1)));
+    } else if (token === FLAG2) {
+      const value = argv[index + 1];
+      if (value === void 0 || index + 1 >= limit || value.startsWith("-")) {
+        return { argv, fields: null };
+      }
+      taken.add(index).add(index + 1);
+      fields.push(...parseFields(value));
+      index++;
+    }
+  }
+  if (taken.size === 0 || fields.length === 0) {
+    return { argv, fields: null };
+  }
+  const command = commandFor(root, argv);
+  if (!command || declaredArg(command, "fields") || PRINTS_NO_ENVELOPE.has(commandPathOf(root, argv))) {
+    return { argv, fields: null };
+  }
+  return { argv: argv.filter((_, index) => !taken.has(index)), fields };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function pick(record, fields) {
+  return Object.fromEntries(fields.filter((field) => field in record).map((field) => [field, record[field]]));
+}
+function soleList(data) {
+  const lists = Object.entries(data).filter(
+    (entry) => Array.isArray(entry[1]) && entry[1].length > 0 && entry[1].every((item) => isRecord(item))
+  );
+  return lists.length === 1 ? lists[0] ?? null : null;
+}
+function wrappedList(data, fields) {
+  const rowFields = fields.filter((field) => !(field in data));
+  const list = soleList(data);
+  if (list === null || !list[1].some((row) => rowFields.some((field) => field in row))) {
+    return null;
+  }
+  return list[0];
+}
+function recordsOf(data, fields) {
+  if (Array.isArray(data)) {
+    return data;
+  }
+  if (!isRecord(data)) {
+    return [];
+  }
+  const list = wrappedList(data, fields);
+  return list === null ? [data] : data[list];
+}
+function maskData(data, fields) {
+  const maskWith = (keep) => (item) => isRecord(item) ? pick(item, keep) : item;
+  if (Array.isArray(data)) {
+    return data.map(maskWith(fields));
+  }
+  if (!isRecord(data)) {
+    return data;
+  }
+  const list = wrappedList(data, fields);
+  if (list === null) {
+    return pick(data, fields);
+  }
+  const wrapperFields = fields.filter((field) => field in data);
+  const rows = recordsOf(data, fields).map(maskWith(fields.filter((field) => !(field in data))));
+  return { ...wrapperFields.length > 0 ? pick(data, wrapperFields) : data, [list]: rows };
+}
+function unmatchedHint(data, fields) {
+  const records = recordsOf(data, fields).filter(isRecord);
+  if (records.length === 0) {
+    return null;
+  }
+  const keys = isRecord(data) ? [data, ...soleList(data)?.[1] ?? []] : records;
+  const carried = new Set(keys.flatMap((record) => Object.keys(record)));
+  const unmatched = fields.filter((field) => !carried.has(field));
+  if (unmatched.length === 0) {
+    return null;
+  }
+  return `--fields matched nothing for: ${unmatched.join(", ")}. The keys data carries are: ${[...carried].join(", ")}.`;
+}
+function reprint(text, envelope) {
+  const indent = text.trimStart().startsWith("{\n") ? 2 : void 0;
+  return `${JSON.stringify(envelope, null, indent)}${text.endsWith("\n") ? "\n" : ""}`;
+}
+function withHint(envelope, hint) {
+  return { ...envelope, hints: [...Array.isArray(envelope.hints) ? envelope.hints : [], hint] };
+}
+var NO_DATA_HINT = "--fields was not applied: this result carries no data to narrow, so it is printed whole. Drop --fields on this command.";
+function maskPrintedEnvelope(text, fields) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (!isRecord(parsed) || typeof parsed.ok !== "boolean") {
+    return null;
+  }
+  if (parsed.ok !== true || "dryRun" in parsed) {
+    return text;
+  }
+  return reprint(text, maskEnvelope(parsed, fields));
+}
+function maskEnvelope(envelope, fields) {
+  if (!("data" in envelope)) {
+    return withHint(envelope, NO_DATA_HINT);
+  }
+  const masked = { ...envelope, data: maskData(envelope.data, fields) };
+  const miss = unmatchedHint(envelope.data, fields);
+  return miss ? withHint(masked, miss) : masked;
+}
+function maskWrites(stream, fields) {
+  let applied = false;
+  const write2 = stream.write.bind(stream);
+  stream.write = (chunk, ...rest) => {
+    const masked = typeof chunk === "string" ? maskPrintedEnvelope(chunk, fields) : null;
+    if (masked === null) {
+      return write2(chunk, ...rest);
+    }
+    applied = true;
+    return write2(masked, ...rest);
+  };
+  return { sawEnvelope: () => applied };
+}
+function installFieldMask(fields, commandPath) {
+  const mask = maskWrites(process.stdout, fields);
+  process.on("exit", () => {
+    if (!mask.sawEnvelope()) {
+      process.stderr.write(
+        `--fields was not applied: \`baker ${commandPath}\` printed no JSON envelope to narrow. Add --output json to get the envelope, or drop --fields.
+`
+      );
+    }
+  });
+}
+
+// src/output.ts
+var ASPECT_RATIO_MAP = {
+  "1:1": 1,
+  "16:9": 16 / 9,
+  "9:16": 9 / 16,
+  "2:3": 2 / 3,
+  "3:4": 3 / 4,
+  "1:2": 1 / 2,
+  "2:1": 2,
+  "4:5": 4 / 5,
+  "3:2": 3 / 2,
+  "4:3": 4 / 3
+};
+var ASPECT_RATIO_TOLERANCE = 0.08;
+function formatAspectRatio(ratio) {
+  if (ratio === void 0 || ratio === null) {
+    return null;
+  }
+  for (const [label, value] of Object.entries(ASPECT_RATIO_MAP)) {
+    if (Math.abs(ratio - value) / value < ASPECT_RATIO_TOLERANCE) {
+      return label;
+    }
+  }
+  return null;
+}
+function groupSummary(record) {
+  const key = record.groupKey;
+  if (typeof key !== "string" || !key) {
+    return null;
+  }
+  const index = typeof record.groupIndex === "number" ? record.groupIndex : null;
+  const size = typeof record.groupSize === "number" ? record.groupSize : null;
+  return {
+    key,
+    kind: typeof record.groupKind === "string" ? record.groupKind : null,
+    position: index === null ? null : size === null ? `${index + 1}` : `${index + 1} of ${size}`,
+    title: typeof record.groupTitle === "string" ? record.groupTitle : null,
+    url: typeof record.groupUrl === "string" ? record.groupUrl : null
+  };
+}
+function peopleLines(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.flatMap((entry) => {
+    const person = asRecord(entry);
+    const role = typeof person.role === "string" ? person.role : "";
+    if (!role) {
+      return [];
+    }
+    const identity = typeof person.identity === "string" && person.identity ? ` \u2014 ${person.identity}` : "";
+    const appearance = typeof person.appearance === "string" && person.appearance ? ` (${person.appearance})` : "";
+    const speaking = person.speaking === true ? " [speaking]" : "";
+    return [`${role}${identity}${appearance}${speaking}`];
+  });
+}
+function compactImage(image) {
+  const analysis = asRecord(image.analysis);
+  return {
+    _id: String(image._id ?? ""),
+    name: String(image.name ?? ""),
+    imageUrl: String(image.imageUrl ?? ""),
+    description: String(image.description ?? ""),
+    tags: Array.isArray(image.tags) ? image.tags : [],
+    // Two numbers that are not about choosing the image but about placing it.
+    // A remote <BakerImage> with no width/height makes Astro DOWNLOAD the file
+    // at build time just to measure it — one request per image per build, on a
+    // build that is otherwise offline, and a single dropped connection there
+    // fails a client's whole verify. They are cheap enough to always carry, and
+    // burying them behind --full meant the agent placing the image never had
+    // them.
+    width: typeof image.width === "number" ? image.width : null,
+    height: typeof image.height === "number" ? image.height : null,
+    // The facts that decide a pick, so choosing does not need a second call:
+    // whose brand it is, who is in it, and what text is burned in.
+    subject: typeof analysis.subject === "string" ? analysis.subject : null,
+    brandOwnership: typeof analysis.brandOwnership === "string" ? analysis.brandOwnership : null,
+    people: peopleLines(analysis.people),
+    textInImage: Array.isArray(analysis.textInImage) ? analysis.textInImage : [],
+    group: groupSummary(image)
+  };
+}
+function fullImage(image) {
+  const compact = compactImage(image);
+  return {
+    ...compact,
+    aspectRatio: formatAspectRatio(image.aspectRatio),
+    dominantColor: image.dominantColor ?? null,
+    imagePalette: Array.isArray(image.imagePalette) ? image.imagePalette : [],
+    source: String(image.source ?? ""),
+    externalUrl: image.externalUrl ?? null,
+    originalFilename: image.originalFilename ?? null,
+    descriptionContext: image.descriptionContext ?? null,
+    style: typeof asRecord(image.analysis).style === "string" ? asRecord(image.analysis).style : null,
+    composition: typeof asRecord(image.analysis).composition === "string" ? asRecord(image.analysis).composition : null,
+    usageNotes: typeof asRecord(image.analysis).usageNotes === "string" ? asRecord(image.analysis).usageNotes : null,
+    createdAt: image.createdAt ?? null
+  };
+}
+function imageNormalizer(record, full) {
+  if (full) {
+    return fullImage(record);
+  }
+  return compactImage(record);
+}
+function sellingFacts(analysis) {
+  return {
+    format: typeof analysis.format === "string" ? analysis.format : null,
+    tone: typeof analysis.tone === "string" ? analysis.tone : null,
+    productClaims: Array.isArray(analysis.productClaims) ? analysis.productClaims : null
+  };
+}
+function compactVideo(video) {
+  const analysis = asRecord(video.analysis);
+  const sceneCount = typeof video.sceneCount === "number" ? video.sceneCount : Array.isArray(video.scenes) ? video.scenes.length : 0;
+  return {
+    _id: String(video._id ?? ""),
+    name: String(video.name ?? ""),
+    thumbnailUrl: String(video.thumbnailUrl ?? ""),
+    description: String(video.description ?? ""),
+    tags: Array.isArray(video.tags) ? video.tags : [],
+    status: String(video.status ?? ""),
+    // What decides whether this clip is usable, without a second call: who is
+    // on camera and in what role, what language they speak, how it opens, and
+    // how many beats there are to cut from.
+    subject: typeof analysis.subject === "string" ? analysis.subject : null,
+    brandOwnership: typeof analysis.brandOwnership === "string" ? analysis.brandOwnership : null,
+    people: peopleLines(analysis.people),
+    spokenLanguages: Array.isArray(analysis.spokenLanguages) ? analysis.spokenLanguages : [],
+    hook: typeof analysis.hook === "string" ? analysis.hook : null,
+    ...sellingFacts(analysis),
+    sceneCount,
+    group: groupSummary(video)
+  };
+}
+function sceneDecoration(scene) {
+  const shot = typeof scene.shot === "string" && scene.shot ? ` [${scene.shot}]` : "";
+  const change = typeof scene.visualChange === "string" && scene.visualChange ? ` <${scene.visualChange}>` : "";
+  const overlayText = Array.isArray(scene.onScreenText) ? scene.onScreenText.filter(Boolean) : [];
+  let overlay = "";
+  if (scene.hasOverlay === true) {
+    overlay = overlayText.length > 0 ? ` \u2014 banner: "${overlayText.join('" / "')}"` : " \u2014 banner";
+  } else if (scene.hasOverlay === false) {
+    overlay = " \u2014 clean frame";
+  }
+  const spoken = typeof scene.spoken === "string" && scene.spoken ? ` \u2014 says: "${scene.spoken}"` : "";
+  return `${shot}${change}${overlay}${spoken}`;
+}
+function sceneLines(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.flatMap((s) => {
+    const scene = asRecord(s);
+    const title = typeof scene.title === "string" ? scene.title : "";
+    if (!title) {
+      return [];
+    }
+    const start = round2(scene.startSecond);
+    const end = round2(scene.endSecond);
+    const range = start !== null && end !== null ? ` (${start}-${end}s)` : "";
+    return [`${title}${range}${sceneDecoration(scene)}`];
+  });
+}
+function fullVideo(video) {
+  const compact = compactVideo(video);
+  return {
+    ...compact,
+    duration: video.duration ?? null,
+    muxPlaybackId: String(video.muxPlaybackId ?? ""),
+    source: String(video.source ?? ""),
+    // The spoken transcript + AI scene breakdown of the client's own clip — the
+    // "understand what's in this video" payload. Kept out of the compact/search
+    // projection (too large for a list) and surfaced here on --full.
+    transcript: video.transcript ?? null,
+    transcript_segment_count: Array.isArray(video.transcriptSegments) ? video.transcriptSegments.length : 0,
+    scenes: sceneLines(video.scenes),
+    originalFilename: video.originalFilename ?? null,
+    descriptionContext: video.descriptionContext ?? null,
+    shotStyle: typeof asRecord(video.analysis).shotStyle === "string" ? asRecord(video.analysis).shotStyle : null,
+    audioStyle: typeof asRecord(video.analysis).audioStyle === "string" ? asRecord(video.analysis).audioStyle : null,
+    onScreenText: Array.isArray(asRecord(video.analysis).onScreenText) ? asRecord(video.analysis).onScreenText : [],
+    usageNotes: typeof asRecord(video.analysis).usageNotes === "string" ? asRecord(video.analysis).usageNotes : null,
+    createdAt: video.createdAt ?? null
+  };
+}
+function videoNormalizer(record, full) {
+  if (full) {
+    return fullVideo(record);
+  }
+  return compactVideo(record);
+}
+function truncate(text, maxLength) {
+  if (text.length <= maxLength) return text;
+  return `${text.slice(0, maxLength)}...`;
+}
+function compactTestimonial(record) {
+  return {
+    _id: String(record._id ?? ""),
+    reviewerName: String(record.reviewerName ?? ""),
+    reviewText: truncate(String(record.reviewText ?? ""), 200),
+    rating: record.rating ?? null,
+    sentiment: record.sentiment ?? null,
+    tags: Array.isArray(record.tags) ? record.tags : [],
+    sourceType: String(record.sourceType ?? "")
+  };
+}
+function fullTestimonial(record) {
+  const compact = compactTestimonial(record);
+  return {
+    ...compact,
+    reviewText: String(record.reviewText ?? ""),
+    highlight: record.highlight ?? null,
+    summary: record.summary ?? null,
+    language: record.language ?? null,
+    reviewerImageUrl: record.reviewerImageUrl ?? null,
+    sourceUrl: record.sourceUrl ?? null,
+    reviewDate: record.reviewDate ?? null,
+    createdAt: record.createdAt ?? null,
+    status: String(record.status ?? "")
+  };
+}
+function testimonialNormalizer(record, full) {
+  if (full) {
+    return fullTestimonial(record);
+  }
+  return compactTestimonial(record);
+}
+function round2(value) {
+  if (typeof value !== "number" || Number.isNaN(value)) {
+    return null;
+  }
+  return Math.round(value * 100) / 100;
+}
+function asRecord(value) {
+  return value && typeof value === "object" ? value : {};
+}
+function bakerUses(value) {
+  const uses = asRecord(value);
+  const companies = typeof uses.companies === "number" ? uses.companies : 0;
+  if (companies === 0) return {};
+  const count = (n) => typeof n === "number" && n > 0 ? n : void 0;
+  const approved = count(uses.approved);
+  const rejected = count(uses.rejected);
+  return {
+    baker_uses: companies,
+    ...uses.ours === true ? { already_adapted: true } : {},
+    ...approved !== void 0 ? { approved } : {},
+    ...rejected !== void 0 ? { rejected } : {}
+  };
+}
+function dnaMove(dna) {
+  const text = (value) => typeof value === "string" && value ? value : void 0;
+  const visual = text(dna.visual);
+  const container = text(dna.container);
+  const mechanism = text(dna.mechanism);
+  return {
+    ...visual ? { visual } : {},
+    ...container ? { container } : {},
+    ...mechanism ? { mechanism } : {}
+  };
+}
+function dnaAudience(dna) {
+  const text = (value) => typeof value === "string" && value ? value : void 0;
+  const audienceTemperature = text(dna.audience_temperature);
+  const funnelStage = text(dna.funnel_stage);
+  const advertiserSize = text(dna.advertiser_size);
+  const presumes = typeof dna.presumes_brand_knowledge === "boolean" ? dna.presumes_brand_knowledge : void 0;
+  const reason = presumes ? text(dna.brand_knowledge_reason) : void 0;
+  return {
+    ...audienceTemperature ? { audience_temperature: audienceTemperature } : {},
+    ...funnelStage ? { funnel_stage: funnelStage } : {},
+    ...advertiserSize ? { advertiser_size: advertiserSize } : {},
+    ...presumes !== void 0 ? { presumes_brand_knowledge: presumes } : {},
+    ...reason ? { brand_knowledge_reason: reason } : {}
+  };
+}
+function compactWinningAd(record) {
+  const dna = asRecord(record.dna);
+  return {
+    advertiser: String(record.advertiser ?? ""),
+    platform: String(record.platform ?? ""),
+    format: String(record.format ?? ""),
+    relevance: round2(record.relevance),
+    winner_score: round2(record.winner_score),
+    winner_category: typeof record.winner_category === "string" ? record.winner_category : null,
+    days_active: typeof record.days_active === "number" ? record.days_active : null,
+    active: typeof record.active === "boolean" ? record.active : null,
+    summary: String(dna.creative_concept ?? ""),
+    advertiser_id: String(record.advertiser_id ?? ""),
+    ad_id: String(record.ad_id ?? ""),
+    media_url: String(record.media_url ?? ""),
+    ...dnaMove(dna),
+    ...dnaAudience(dna),
+    ...bakerUses(record.baker_uses),
+    ...record.source === "followed" || record.source === "library" ? { source: record.source } : {}
+  };
+}
+function fullWinningAd(record) {
+  const compact = compactWinningAd(record);
+  const dna = asRecord(record.dna);
+  return {
+    ...compact,
+    media_kind: record.media_kind ?? null,
+    reach: record.reach ?? null,
+    angle: dna.angle ?? null,
+    awareness_stage: dna.awareness_stage ?? null,
+    target_persona: dna.target_persona ?? null,
+    hook_archetype: dna.hook_archetype ?? null,
+    mechanism: dna.mechanism ?? null,
+    industry: dna.industry ?? null
+  };
+}
+function winningAdNormalizer(record, full) {
+  if (full) {
+    return fullWinningAd(record);
+  }
+  return compactWinningAd(record);
+}
+function inImageLine(item, text, detailed) {
+  const card = typeof item.card === "number" ? `card ${item.card} \xB7 ` : "";
+  const role = typeof item.role === "string" && item.role.length > 0 ? `${item.role}: ` : "";
+  const position = detailed && typeof item.position === "string" && item.position.length > 0 ? ` [${item.position}]` : "";
+  return `${card}${role}${text}${position}`;
+}
+function overlayLines(value, detailed = false, inImage = false) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.flatMap((o) => {
+    const item = asRecord(o);
+    const text = typeof item.text === "string" ? item.text : "";
+    if (!text) {
+      return [];
+    }
+    if (inImage) {
+      return [inImageLine(item, text, detailed)];
+    }
+    const at = round2(item.appears_at_s);
+    let line = at !== null ? `${text} @${at}s` : text;
+    if (detailed) {
+      const tags = [item.role, item.position].filter((t) => typeof t === "string" && t.length > 0);
+      if (tags.length) {
+        line += ` [${tags.join(", ")}]`;
+      }
+    }
+    return [line];
+  });
+}
+function compactAdContent(record) {
+  const inImage = record.format === "static" || record.format === "carousel";
+  return {
+    ad_id: record.ad_id ?? null,
+    advertiser: record.advertiser ?? null,
+    format: record.format ?? null,
+    media_kind: record.media_kind ?? null,
+    media_url: record.media_url ?? null,
+    summary: record.summary ?? null,
+    transcript: record.transcript ?? null,
+    on_screen_text: overlayLines(record.on_screen_text, false, inImage),
+    // The container a static reference is built on (comparison_table, before_after_split…).
+    ...inImage ? { format_pattern: asRecord(record.layout).format_pattern ?? null } : {},
+    has_captions: typeof record.has_captions === "boolean" ? record.has_captions : null,
+    primary_text: record.primary_text ?? null,
+    headline: record.headline ?? null,
+    cta: record.cta ?? null
+  };
+}
+function filledOnly(value) {
+  return Object.fromEntries(
+    Object.entries(asRecord(value)).filter(
+      ([, v]) => v !== null && v !== void 0 && !(Array.isArray(v) && v.length === 0)
+    )
+  );
+}
+function fullAdContent(record) {
+  const speech = asRecord(record.speech);
+  const pacing = asRecord(record.pacing);
+  const music = asRecord(record.music);
+  return {
+    ...compactAdContent(record),
+    platform: record.platform ?? null,
+    // Re-derive with role/position tags — the lean compact version dropped them.
+    on_screen_text: overlayLines(
+      record.on_screen_text,
+      true,
+      record.format === "static" || record.format === "carousel"
+    ),
+    winner_score: round2(record.winner_score),
+    winner_category: record.winner_category ?? null,
+    angle: record.angle ?? null,
+    hook_archetype: record.hook_archetype ?? null,
+    caption_style: record.caption_style ?? null,
+    has_speech: typeof record.has_speech === "boolean" ? record.has_speech : null,
+    speech_pct_of_runtime: round2(speech.speech_pct_of_runtime),
+    speaker_count: speech.speaker_count ?? null,
+    voiceover_vs_sync: speech.voiceover_vs_sync ?? null,
+    is_direct_address: typeof speech.is_direct_address === "boolean" ? speech.is_direct_address : null,
+    speech_emotion_dominant: speech.speech_emotion_dominant ?? null,
+    scene_count: pacing.scene_count ?? null,
+    avg_shot_length_s: round2(pacing.avg_shot_length_s),
+    pacing_shape: pacing.pacing_shape ?? null,
+    hook_ends_at_s: round2(pacing.hook_ends_at_s),
+    cta_first_shown_at_s: round2(pacing.cta_first_shown_at_s),
+    product_first_appears_at_s: round2(pacing.product_first_appears_at_s),
+    music_track_title: music.track_title ?? null,
+    music_track_artist: music.track_artist ?? null,
+    // How it is built, how it persuades, and what it offers, flattened like
+    // speech/pacing above so --output md renders them, and only when present.
+    ...filledOnly(record.layout),
+    ...filledOnly(record.message),
+    ...filledOnly(record.offer)
+  };
+}
+function adContentNormalizer(record, full) {
+  return full ? fullAdContent(record) : compactAdContent(record);
+}
+function applyFieldMask(data, fields) {
+  const result = {};
+  for (const field of fields) {
+    if (field in data) {
+      result[field] = data[field];
+    }
+  }
+  return result;
+}
+function write(text) {
+  process.stdout.write(text);
+}
+function writeJson(envelope) {
+  write(`${JSON.stringify(envelope, null, 2)}
+`);
+}
+function writeFiles(data, fields) {
+  write(`${fields.join("	")}
+`);
+  for (const item of data) {
+    const values = fields.map((f) => String(item[f] ?? ""));
+    write(`${values.join("	")}
+`);
+  }
+}
+function writeMd(data, fields) {
+  write(`| ${fields.join(" | ")} |
+`);
+  write(`| ${fields.map(() => "---").join(" | ")} |
+`);
+  for (const item of data) {
+    const values = fields.map((f) => String(item[f] ?? ""));
+    write(`| ${values.join(" | ")} |
+`);
+  }
+}
+function normalizeData(envelope, fields, full, normalizer) {
+  const raw = Array.isArray(envelope.data) ? envelope.data : [envelope.data];
+  const items = raw.map((item) => {
+    const record = item;
+    return normalizer(record, full);
+  });
+  if (fields) {
+    return items.map((item) => applyFieldMask(item, fields));
+  }
+  return items;
+}
+function writeOutput(envelope, format, fields, full, normalizer) {
+  if (!envelope.ok || "dryRun" in envelope) {
+    writeJson(envelope);
+    return;
+  }
+  if (format === "json") {
+    write(`${JSON.stringify(fields ? maskEnvelope(envelope, fields) : envelope, null, 2)}
+`);
+    return;
+  }
+  if (format !== "files" && format !== "md") {
+    process.stderr.write(`Unknown --output "${String(format)}". Valid formats: json, files, md. Using json.
+`);
+    writeJson(envelope);
+    return;
+  }
+  const items = normalizeData(envelope, fields, full ?? false, normalizer ?? imageNormalizer);
+  const displayFields = fields ?? Object.keys(items[0] ?? {});
+  if (format === "files") {
+    writeFiles(items, displayFields);
+  } else {
+    writeMd(items, displayFields);
+  }
+  writeHints(envelope.hints);
+}
+function writeHints(hints) {
+  for (const hint of hints ?? []) {
+    process.stderr.write(`${hint}
+`);
+  }
+}
+
+export {
+  registerSchema,
+  listSchemas,
+  findSchema,
+  commandPathOf,
+  refuseUnknownFlags,
+  outputFlagForCommand,
+  takeFieldsFlag,
+  installFieldMask,
+  compactImage,
+  compactVideo,
+  videoNormalizer,
+  testimonialNormalizer,
+  compactWinningAd,
+  fullWinningAd,
+  winningAdNormalizer,
+  adContentNormalizer,
+  applyFieldMask,
+  writeJson,
+  writeOutput
+};
+//# sourceMappingURL=chunk-NU7JSWVA.js.map