@koda-sl/baker-cli 0.572.0 → 0.574.0

package/dist/chunk-YRW2AAKX.js

@@ -0,0 +1,454 @@
+import {
+  MAX_VIDEO_INGEST_BYTES,
+  MAX_VIDEO_INGEST_SECONDS,
+  directDedupeKey,
+  downloadTimeoutMs,
+  isDirectMediaUrl,
+  isDrmProtected,
+  isRegionBlocked,
+  isToolingOrBlockFailure,
+  refuseByDuration,
+  resolveIngestSource,
+  worthDownloadingInstead
+} from "./chunk-FKOECEVC.js";
+import {
+  eachTarget,
+  failWith,
+  positionalTargets
+} from "./chunk-MGUEAG6W.js";
+import {
+  librarySaveHint
+} from "./chunk-I7OJZ7QE.js";
+import {
+  YtDlpError,
+  canonicalUrl,
+  durationSeconds,
+  isAudioOnly,
+  isVimeoAuthFailure,
+  probeYtDlp,
+  runYtDlp,
+  ytDlpBlockSignal
+} from "./chunk-U3LO5TDH.js";
+import {
+  videosIngestRequestSchema
+} from "./chunk-AJ4OO3CV.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-JCFZ7ECN.js";
+import {
+  captureVimeoCookie,
+  isProxyFailure
+} from "./chunk-OMLZ35HJ.js";
+import {
+  maskEnvelope,
+  registerSchema,
+  writeJson
+} from "./chunk-NXNOXZGB.js";
+
+// src/commands/videos/ingest.ts
+import { mkdtemp, rm, stat } from "fs/promises";
+import { tmpdir } from "os";
+import path from "path";
+import { defineCommand } from "citty";
+
+// src/lib/streamUpload.ts
+import { createHash } from "crypto";
+import { createReadStream } from "fs";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
+async function hashFile(filePath) {
+  const hash = createHash("sha256");
+  await pipeline(createReadStream(filePath), hash);
+  return hash.digest("hex");
+}
+async function putFileStreamed(args) {
+  const body = Readable.toWeb(createReadStream(args.filePath));
+  return await fetch(args.putUrl, {
+    method: "PUT",
+    body,
+    headers: {
+      "Content-Type": args.contentType,
+      "Content-Length": String(args.sizeBytes)
+    },
+    duplex: "half"
+  });
+}
+
+// src/commands/videos/ingest.ts
+registerSchema({
+  command: "videos.ingest",
+  description: "Add videos to the library from URLs \u2014 direct files, or YouTube/TikTok/Vimeo pages. Several URLs run at once and return one row each.",
+  args: {
+    url: {
+      type: "string",
+      description: "Video URL (direct file or a watch/post page); pass several to add them at once",
+      required: true
+    },
+    source: { type: "string", description: "Provenance: url | youtube", required: false },
+    "external-id": { type: "string", description: "Provider asset id (deduped on)", required: false },
+    "external-url": { type: "string", description: "Canonical page URL", required: false },
+    download: {
+      type: "boolean",
+      description: "Force the download path instead of letting Baker fetch the URL directly",
+      required: false,
+      default: false
+    },
+    country: {
+      type: "string",
+      description: "Two-letter country to fetch from (e.g. US, DE, JP) \u2014 use when a video is blocked in your region",
+      required: false
+    },
+    context: {
+      type: "string",
+      description: "What you know that the video cannot show \u2014 the campaign, whether the person on camera is a real customer, what it is for. Highest-leverage flag here: it is what makes the clip findable later.",
+      required: false
+    },
+    "dry-run": { type: "boolean", description: "Preview the operation without executing", required: false },
+    fields: {
+      type: "string",
+      description: "Comma-separated field names to keep on each added video; failed URLs are always listed whole",
+      required: false
+    }
+  }
+});
+var ingestCommand = defineCommand({
+  meta: {
+    name: "ingest",
+    description: 'Add videos to the library from URLs. A direct file URL is handed straight to Baker, which fetches it. A page URL (YouTube, TikTok, Vimeo, Instagram) is downloaded here first, then uploaded \u2014 and a direct URL that Baker cannot fetch falls back to that same path automatically. Several URLs are added at once, so a list takes about as long as its slowest clip: pass them all in one call rather than looping.\n\nExamples:\n  baker videos ingest https://www.youtube.com/watch?v=abc123\n  baker videos ingest https://youtu.be/a https://youtu.be/b https://cdn.example.com/c.mp4 --context "Spring campaign testimonials"'
+  },
+  args: {
+    url: { type: "positional", description: "Video URL; pass several to add them at once", required: false },
+    source: { type: "string", description: "Provenance: url | youtube", required: false },
+    "external-id": { type: "string", description: "Provider asset id (one URL only)", required: false },
+    "external-url": { type: "string", description: "Canonical page URL (one URL only)", required: false },
+    download: { type: "boolean", description: "Force the download path", required: false, default: false },
+    country: { type: "string", description: "Two-letter country to fetch from, e.g. US", required: false },
+    context: {
+      type: "string",
+      description: "Context for the analysis \u2014 campaign, who is on camera, intended use (applies to every URL)",
+      required: false
+    },
+    "dry-run": { type: "boolean", description: "Preview without executing", required: false, default: false },
+    fields: { type: "string", description: "Comma-separated field names to keep on each added video", required: false }
+  },
+  run: ({ args }) => runVideoIngest({
+    urls: positionalTargets(args),
+    source: args.source,
+    externalId: args["external-id"],
+    externalUrl: args["external-url"],
+    forceDownload: args.download === true,
+    country: args.country,
+    context: args.context,
+    dryRun: args["dry-run"] === true,
+    fields: typeof args.fields === "string" && args.fields.length > 0 ? args.fields.split(",") : void 0
+  })
+});
+async function runVideoIngest(opts) {
+  const { urls } = opts;
+  if (urls.length === 0) {
+    failWith({ code: "VALIDATION_ERROR", message: "URL is required" });
+  }
+  if (urls.length > 1 && (opts.externalId || opts.externalUrl)) {
+    failWith({
+      code: "VALIDATION_ERROR",
+      message: "--external-id and --external-url name a single video, so they cannot be used with several URLs."
+    });
+  }
+  const country = opts.country?.trim() || void 0;
+  const plans = planIngests(opts);
+  if (opts.dryRun) {
+    const params = plans.map(({ args, direct }) => dryRunParams(args, direct, country));
+    writeJson({
+      ok: true,
+      dryRun: true,
+      operation: "videos.ingest",
+      params: params.length === 1 && params[0] ? params[0] : { items: params }
+    });
+    return;
+  }
+  const byUrl = new Map(plans.map((plan) => [plan.args.url, plan]));
+  const outcomes = await eachTarget(
+    urls,
+    (url) => {
+      const plan = byUrl.get(url);
+      return ingestByRoute(plan.args, plan.direct, country);
+    },
+    ingestFailure
+  );
+  writeIngestOutcomes(outcomes, opts.fields);
+}
+function planIngests(opts) {
+  const plans = opts.urls.map((url) => {
+    const args = {
+      url,
+      source: resolveIngestSource(opts.source, url),
+      externalId: opts.externalId,
+      // Deliberately NOT pre-filled with the pasted URL. Doing so shadowed the
+      // canonical URL the probe resolves (`?? canonicalUrl(...)` below could never
+      // run), so the same video filed under a different `externalUrl` depending on
+      // whether the link was copied from a share sheet, a shorts page or the
+      // address bar. `downloadThenIngest` falls back to `args.url` when the probe
+      // resolves nothing, which is the value this used to hard-code.
+      externalUrl: opts.externalUrl,
+      descriptionContext: opts.context?.trim() || void 0
+    };
+    return { args, direct: !opts.forceDownload && isDirectMediaUrl(url) };
+  });
+  for (const { args } of plans) {
+    const validation = videosIngestRequestSchema.safeParse(args);
+    if (!validation.success) {
+      const problem = validation.error.issues[0];
+      const where = opts.urls.length > 1 ? `${args.url}: ` : "";
+      failWith({
+        code: "VALIDATION_ERROR",
+        message: problem ? `${where}${problem.path.join(".") || "request"}: ${problem.message}` : `${where}Invalid request`
+      });
+    }
+  }
+  return plans;
+}
+function savedVideoHints(outcomes) {
+  const saved = librarySaveHint(
+    "video library",
+    outcomes.flatMap((o) => o.ok && !o.data.deduped ? [o.data.videoId] : [])
+  );
+  return saved ? [saved] : [];
+}
+function writeIngestOutcomes(outcomes, fields) {
+  const [only] = outcomes;
+  const savedHints = savedVideoHints(outcomes);
+  if (outcomes.length === 1 && only) {
+    if (!only.ok) failWith(only.error);
+    if (!fields) {
+      const hints2 = [...ingestHints(only.data) ?? [], ...savedHints];
+      writeJson({ ok: true, data: only.data, ...hints2.length > 0 ? { hints: hints2 } : {} });
+      return;
+    }
+    const shown2 = narrowed(only.data, fields);
+    writeJson({
+      ok: true,
+      data: shown2.data,
+      hints: [...ingestHints(only.data) ?? [], ...shown2.hints, ...savedHints]
+    });
+    return;
+  }
+  const ingested = outcomes.flatMap((o) => o.ok ? [{ url: o.target, ...o.data }] : []);
+  const failed = outcomes.flatMap((o) => o.ok ? [] : [{ url: o.target, error: o.error }]);
+  const hints = ingested.flatMap((row) => (ingestHints(row) ?? []).map((hint) => `${row.url}: ${hint}`));
+  if (ingested.length === 0) {
+    writeJson({
+      ok: false,
+      error: {
+        code: "INGEST_FAILED",
+        message: `None of the ${outcomes.length} videos could be added: ${failed.map((f) => `${f.url} \u2014 ${f.error.message}`).join("; ")}`
+      },
+      hints: failed.flatMap((f) => f.error.fix ? [`${f.url}: ${f.error.fix}`] : [])
+    });
+    process.exit(1);
+  }
+  if (failed.length > 0) {
+    hints.push(
+      `${failed.length} of ${outcomes.length} could not be added \u2014 each one's reason and fix is in failed[]. The rest are in the library; carry on with them.`
+    );
+  }
+  const shown = fields ? narrowed(ingested, fields) : { data: ingested, hints: [] };
+  hints.push(...shown.hints, ...savedHints);
+  writeJson({ ok: true, data: { ingested: shown.data, failed }, ...hints.length > 0 ? { hints } : {} });
+}
+function narrowed(data, fields) {
+  const masked = maskEnvelope({ ok: true, data }, fields);
+  const hints = Array.isArray(masked.hints) ? masked.hints.filter((hint) => typeof hint === "string") : [];
+  return { data: masked.data, hints };
+}
+function ingestHints(data) {
+  if (data.reducedQuality !== true) return void 0;
+  return [
+    "Added, but at standard quality (360p): the site refused to release the full-quality file and this was the best it would hand over. Tell the user \u2014 the clip is in the library and usable, it is just not high-resolution. If they need the crisp version, ask them for the original file and use `baker videos upload <file>`."
+  ];
+}
+function dryRunParams(args, direct, country) {
+  return {
+    url: args.url,
+    source: args.source,
+    // Known up front on the direct route, because it is derived from the URL
+    // alone. The download route's key comes from the probe, which a dry run
+    // does not perform, so there it stays null rather than becoming a guess.
+    externalId: args.externalId ?? (direct ? directDedupeKey(args.source, args.url) : null),
+    // A page URL's canonical form is only known after the probe, which a dry
+    // run does not perform — so this is null rather than a guess.
+    externalUrl: args.externalUrl ?? null,
+    direct,
+    country: country ?? null,
+    descriptionContext: args.descriptionContext ?? null
+  };
+}
+async function ingestByRoute(args, direct, country) {
+  if (!direct) {
+    return { ...await downloadThenIngest(args, country), via: "download" };
+  }
+  try {
+    const externalId = args.externalId ?? directDedupeKey(args.source, args.url);
+    return { ...await ingestUrl({ ...args, externalId }), via: "direct" };
+  } catch (err) {
+    if (!(err instanceof ApiError) || !worthDownloadingInstead(err.code)) throw err;
+    return { ...await downloadThenIngest(args, country), via: "download", fallbackFrom: err.message };
+  }
+}
+function ytDlpFailure(err) {
+  const detail = `${err.stderrTail} ${err.message}`;
+  if (isProxyFailure(ytDlpBlockSignal(detail))) {
+    return failure(
+      "Couldn't download that video: our connection to the internet was refused.",
+      "This is Baker's egress proxy, not the link \u2014 its credentials look wrong or expired. The link is probably fine. Report it; retrying won't help until the proxy is fixed."
+    );
+  }
+  if (isDrmProtected(detail)) {
+    return failure(
+      "That video is copy-protected, so it can't be added to the library.",
+      "The publisher encrypted this one against downloading. Nothing will change that \u2014 not retrying, not a different region. Ask whoever owns the video for the original file and add it with `baker videos upload <file>`."
+    );
+  }
+  if (isVimeoAuthFailure(detail)) {
+    return failure(
+      "Vimeo wouldn't hand over that video \u2014 Baker isn't signed in to Vimeo.",
+      "Vimeo now refuses anonymous downloads entirely, so this needs a signed-in session and the one Baker holds has either expired or was never set. Nothing is wrong with the link. Report it so the Vimeo cookie can be refreshed; meanwhile download the file and use `baker videos upload <file>`."
+    );
+  }
+  if (isRegionBlocked(detail)) {
+    return failure(
+      `That video isn't available in the region we're fetching from. ${err.stderrTail || err.message}`,
+      "Re-run with `--country <two-letter code>` for a country where the video plays \u2014 e.g. `--country US`. Pick the one the video belongs to (the uploader's country is the usual answer); each attempt costs a paid connection, so choose rather than work through the list."
+    );
+  }
+  return failure(
+    `Couldn't download that video. ${err.stderrTail || err.message}`,
+    isToolingOrBlockFailure(detail) ? "The site wouldn't hand over the video \u2014 usually the downloader being out of date against a site that changed, or the request being blocked. Retrying won't help, and the link is probably fine. Report it so the tool can be updated; meanwhile download the file and use `baker videos upload <file>`." : "Check the link is public and playable. Private or age-restricted videos can't be downloaded \u2014 download the file yourself and use `baker videos upload <file>`."
+  );
+}
+function failure(message, fix, code = "INGEST_FAILED") {
+  return { code, message, fix };
+}
+function ingestFailure(err) {
+  if (err instanceof ApiError) return { code: err.code, message: err.message };
+  if (err instanceof YtDlpError) return ytDlpFailure(err);
+  const detail = err instanceof Error ? err.message : String(err);
+  if (detail.includes("timed out after")) {
+    return failure(
+      "That video took too long to download and was stopped part-way.",
+      "Long or slow-serving videos can outrun the download window. Try a shorter clip, or download this one yourself and use `baker videos upload <file>`.",
+      "INTERNAL_ERROR"
+    );
+  }
+  return failure(
+    `Couldn't add that video. ${detail}`,
+    "This is a fault on Baker's side, not a problem with the link. Report it.",
+    "INTERNAL_ERROR"
+  );
+}
+function dedupeKey(args, info) {
+  const id = typeof info.id === "string" ? info.id : void 0;
+  if (!id) return void 0;
+  if (info.extractor === "generic") return `${args.source}:${canonicalUrl(info) ?? args.url}`;
+  return `${args.source}:${id}`;
+}
+function ingestUrl(args) {
+  const body = {
+    url: args.url,
+    source: args.source
+  };
+  if (args.externalId) body.externalId = args.externalId;
+  if (args.externalUrl) body.externalUrl = args.externalUrl;
+  if (args.descriptionContext) body.descriptionContext = args.descriptionContext;
+  return apiPost("/api/videos/ingest", body);
+}
+async function downloadThenIngest(args, country) {
+  const vimeoCookie = captureVimeoCookie();
+  const workDir = await mkdtemp(path.join(tmpdir(), "videos-ingest-"));
+  try {
+    const probe = await probeYtDlp({ url: args.url, country, vimeoCookie, cookieDir: workDir });
+    if (isAudioOnly(probe.info)) {
+      throw new ApiError(
+        "VALIDATION_ERROR",
+        "That link is audio, not video, so it can't go in the video library. Music and podcast links have no picture to store."
+      );
+    }
+    const tooLong = refuseByDuration(durationSeconds(probe.info), MAX_VIDEO_INGEST_SECONDS);
+    if (tooLong) {
+      throw new ApiError("VALIDATION_ERROR", tooLong);
+    }
+    const externalId = args.externalId ?? dedupeKey(args, probe.info);
+    const { filePath, info, tier, reducedQuality } = await runYtDlp({
+      url: args.url,
+      audioOnly: false,
+      workDir,
+      // Deliberately uncapped: take the best the site will release and let Mux
+      // decide what to serve. The 1080p ceiling this replaces was reasoning
+      // about the wrong cost — it saved download bytes by throwing away source
+      // pixels *before* the one system that can make renditions from them ever
+      // saw them, so a 4K master became a 1080p master permanently, for
+      // everything the library is ever asked to do with that clip afterwards.
+      // Downscaling is Mux's job and it is cheap; re-acquiring a master is not.
+      country,
+      vimeoCookie,
+      // Budgeted from the probed length, so the duration we accept and the time
+      // we allow to fetch it cannot drift apart.
+      timeoutMs: downloadTimeoutMs(durationSeconds(probe.info))
+    });
+    const stats = await stat(filePath);
+    if (stats.size > MAX_VIDEO_INGEST_BYTES) {
+      throw new ApiError(
+        "VALIDATION_ERROR",
+        `That video is ${(stats.size / 1024 ** 3).toFixed(1)} GB, over the ${Math.round(MAX_VIDEO_INGEST_BYTES / 1024 ** 3)} GB limit for this route.`
+      );
+    }
+    const publicUrl = await uploadToAssetStore(filePath, stats.size);
+    return {
+      ...await ingestUrl({
+        ...args,
+        url: publicUrl,
+        externalId,
+        externalUrl: args.externalUrl ?? canonicalUrl(probe.info) ?? args.url
+      }),
+      egress: tier,
+      // Named in the result for the same reason `egress` is: a geo-targeted exit
+      // is a deliberate, billable choice and must not be invisible afterwards.
+      ...country ? { country } : {},
+      // Third member of the same family. The site refused the good formats and
+      // the download quietly took the one it would release, which is the right
+      // call — but a clip that is 360p because of that must say so here, or the
+      // only way to find out is to watch it.
+      ...reducedQuality ? { reducedQuality: true } : {},
+      // What the site released, so a clip that came in small is visible in the
+      // answer rather than after the marketer has already looked at it.
+      ...downloadedResolution(info)
+    };
+  } finally {
+    await rm(workDir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+function downloadedResolution(info) {
+  const { width, height } = info;
+  return typeof width === "number" && typeof height === "number" ? { width, height } : {};
+}
+async function uploadToAssetStore(filePath, sizeBytes) {
+  const sha256 = await hashFile(filePath);
+  const { putUrl, publicUrl } = await apiPost("/api/canvas/assets/presign", {
+    sha256,
+    mime: "video/mp4",
+    purpose: "source"
+  });
+  const putRes = await putFileStreamed({ putUrl, filePath, contentType: "video/mp4", sizeBytes });
+  if (!putRes.ok) {
+    throw new ApiError("INTERNAL_ERROR", `Storing the downloaded video failed: HTTP ${putRes.status}`);
+  }
+  return publicUrl;
+}
+
+export {
+  ingestCommand,
+  runVideoIngest,
+  ingestHints
+};
+//# sourceMappingURL=chunk-YRW2AAKX.js.map

package/dist/chunk-YT6YI47O.js

@@ -0,0 +1,178 @@
+import {
+  HEADLINE_SET_FLOOR,
+  SAME_CLAIM_HELD,
+  TELL_QUESTIONS,
+  copySentences,
+  sameClaimQuestion,
+  tellQuestionsFor
+} from "./chunk-4NZ47VXO.js";
+import {
+  rememberedJev
+} from "./chunk-HZ7QUFUW.js";
+import {
+  holdUnbilledSpend
+} from "./chunk-T4HIFVNK.js";
+import {
+  findWorkspaceRoot
+} from "./chunk-CGLNCFAG.js";
+import {
+  CAPABILITY_SURFACE_SPECS,
+  describeOpPayload
+} from "./chunk-3WOFZTGC.js";
+
+// src/commands/capabilities/fix.ts
+function capabilityFix(surface) {
+  const spec = CAPABILITY_SURFACE_SPECS[surface];
+  return {
+    action: `baker capabilities ${surface}`,
+    explanation: `Do not guess another field name. \`baker capabilities ${surface}\` lists every ${spec.label} change with its required and optional fields and the exact values each field accepts, plus what cannot be changed here at all and why. Read it, then either re-stage correctly or tell the user this part is out of reach \u2014 and carry on with the rest of the job either way.`
+  };
+}
+function payloadFix(surface, union, op) {
+  const kind = typeof op === "object" && op !== null ? op.kind : void 0;
+  const shape = typeof kind === "string" ? describeOpPayload(union, kind) : void 0;
+  if (typeof kind !== "string" || shape === void 0) return capabilityFix(surface);
+  return {
+    action: "restage_with_the_listed_fields",
+    explanation: `${kind} takes this payload (a field marked ? may be left out; a quoted value is the only one it accepts):
+${shape}
+Do not guess another field name: re-stage with these fields, or tell the user this part is out of reach \u2014 and carry on with the rest of the job either way.`
+  };
+}
+
+// src/commands/ads/boolean-word-positional.ts
+var BOOLEAN_WORD = /^(true|false)$/i;
+function booleanWordPositionalError(args, entity) {
+  const positionals = Array.isArray(args._) ? args._ : [];
+  const word = positionals.find((value2) => typeof value2 === "string" && BOOLEAN_WORD.test(value2));
+  if (word === void 0) {
+    return void 0;
+  }
+  const value = word.toLowerCase();
+  const raised = Object.keys(args).filter((key) => key !== "_" && args[key] === true);
+  const named = raised.length > 0 ? raised.map((flag) => `--${flag}`).join(" or ") : "a boolean flag";
+  const fix = raised.length > 0 ? raised.map((flag) => `--${flag}=${value}`).join(" or ") : `--<flag>=${value}`;
+  const negated = raised.length === 1 && value === "false" ? ` (or --no-${raised[0]})` : "";
+  return `"${word}" was read as the ${entity} target, not as a value for ${named}. A boolean flag written with a space is set to TRUE and the word is dropped \u2014 attach it instead: ${fix}${negated}.`;
+}
+
+// src/commands/ads/copy-hints.ts
+import path from "path";
+
+// src/engine/copy-tells/judge.ts
+var SAMPLE_MAX = 60;
+var sample = (text) => text.length <= SAMPLE_MAX ? text : `${text.slice(0, SAMPLE_MAX)}\u2026`;
+async function judgedCopyTells(input, ask) {
+  const sentences = input.texts.flatMap((t) => copySentences(t));
+  const pairs = (input.headlineSets ?? []).map((set) => set.map((h) => h.trim()).filter(Boolean)).filter((set) => set.length >= HEADLINE_SET_FLOOR).flatMap((set, s) => set.flatMap((a, i) => set.slice(i + 1).map((b) => ({ set: s, a, b }))));
+  const questions = [...sentences.flatMap(tellQuestionsFor), ...pairs.map(({ a, b }) => sameClaimQuestion(a, b))];
+  if (questions.length === 0) return [];
+  const answers = await ask(questions);
+  if (answers === null) return null;
+  const tells = [];
+  TELL_QUESTIONS.forEach((tell, t) => {
+    const hits = sentences.filter((_, s) => (answers[s * TELL_QUESTIONS.length + t] ?? 0) >= tell.threshold);
+    if (hits.length > 0) tells.push({ id: tell.id, count: hits.length, sample: sample(hits[0]?.text ?? "") });
+  });
+  const offset = sentences.length * TELL_QUESTIONS.length;
+  const cycled = pairs.filter((_, p) => (answers[offset + p] ?? 0) >= SAME_CLAIM_HELD);
+  for (const set of new Set(cycled.map((p) => p.set))) {
+    const inSet = cycled.filter((p) => p.set === set);
+    const { a, b } = inSet[0] ?? { a: "", b: "" };
+    tells.push({ id: "synonym-cycling", count: inSet.length, sample: sample(`"${a}" / "${b}"`) });
+  }
+  return tells;
+}
+
+// src/commands/ads/copy-hints.ts
+var COPY_KEYS = /* @__PURE__ */ new Set([
+  "headline",
+  "headlines",
+  "longheadline",
+  "longheadlines",
+  "shortheadline",
+  "shortheadlines",
+  "description",
+  "descriptions",
+  "primarytext",
+  "primarytexts",
+  "message",
+  "messages",
+  "commentary",
+  "body",
+  "bodies",
+  "text",
+  "calltoaction",
+  "linkdescription",
+  "sitelinktext",
+  "callout",
+  "callouts",
+  "introtext"
+]);
+var HEADLINE_SET_KEYS = /* @__PURE__ */ new Set(["headlines", "longheadlines", "shortheadlines"]);
+var MAX_HINTS = 5;
+var SYNONYM_PAIR_FLOOR = 2;
+function asStrings(value) {
+  const one = (v) => {
+    const text = typeof v === "string" ? v : v !== null && typeof v === "object" ? v.text : "";
+    return typeof text === "string" && text.trim() ? text : void 0;
+  };
+  const values = Array.isArray(value) ? value : [value];
+  return values.map(one).filter((v) => v !== void 0);
+}
+function collectCopy(value, depth = 0) {
+  const texts = [];
+  const headlineSets = [];
+  if (depth > 4 || value === null || typeof value !== "object") return { texts, headlineSets };
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const nested = collectCopy(item, depth + 1);
+      texts.push(...nested.texts);
+      headlineSets.push(...nested.headlineSets);
+    }
+    return { texts, headlineSets };
+  }
+  for (const [key, raw] of Object.entries(value)) {
+    const normalized = key.toLowerCase().replace(/[_-]/g, "");
+    const strings = COPY_KEYS.has(normalized) ? asStrings(raw) : [];
+    if (strings.length > 0) {
+      texts.push(...strings);
+      if (HEADLINE_SET_KEYS.has(normalized) && strings.length > 1) headlineSets.push(strings);
+      continue;
+    }
+    const nested = collectCopy(raw, depth + 1);
+    texts.push(...nested.texts);
+    headlineSets.push(...nested.headlineSets);
+  }
+  return { texts, headlineSets };
+}
+function hintFor(tell) {
+  if (tell.id === "synonym-cycling") {
+    return `AI COPY TELL \u2014 ${tell.count} headline pairs are the same claim reworded (${tell.sample}). A cycled set gives the auction nothing to choose between: make each headline a different claim, not a different verb.`;
+  }
+  return `AI COPY TELL (${tell.id}) \u2014 "${tell.sample}". This construction reads as machine-written; rewrite it as a plain, specific claim before publishing.`;
+}
+async function adCopyHints(payload, ask) {
+  const { texts, headlineSets } = collectCopy(payload);
+  if (texts.length === 0) return [];
+  const cacheDir = path.join(findWorkspaceRoot(process.cwd()) ?? process.cwd(), "canvas", ".cache");
+  const spent = [];
+  const judged = await judgedCopyTells(
+    { texts: texts.flatMap((t) => t.split("\n")), headlineSets },
+    ask ?? rememberedJev(path.join(cacheDir, "copy-tells.json"), (u) => spent.push(u))
+  ).catch(() => null);
+  await holdUnbilledSpend(cacheDir, spent).catch(() => void 0);
+  const cycled = (judged ?? []).filter((t) => t.id === "synonym-cycling" && t.count >= SYNONYM_PAIR_FLOOR).sort((a, b) => b.count - a.count).slice(0, 1);
+  const tells = [...cycled, ...(judged ?? []).filter((t) => t.id !== "synonym-cycling")];
+  tells.sort(
+    (a, b) => (b.id === "synonym-cycling" ? 1 : 0) - (a.id === "synonym-cycling" ? 1 : 0) || b.count - a.count
+  );
+  return tells.slice(0, MAX_HINTS).map(hintFor);
+}
+
+export {
+  payloadFix,
+  booleanWordPositionalError,
+  adCopyHints
+};
+//# sourceMappingURL=chunk-YT6YI47O.js.map