@koda-sl/baker-cli 0.306.6 → 0.306.8

package/README.md

@@ -3736,6 +3736,8 @@ baker studio animate "she keeps walking, camera stays with her, then she stops a
 
 **A rendered clip is not usable anywhere until it is kept** — `keep` is what ingests it into the video library. Unkept takes are never ingested, which is what makes a rejected batch cheap.
 
+**One take of a presenter is an asset; an ad is not.** From the second clip in a conversation that carries a scripted line, `animate` warns that an ad is being assembled by hand and names `baker canvas scaffold-ad` instead. Separate takes have no cut between them, no continuous read, no captions and no end card, so three takes of a presenter are three clips and never one ad. It is a hint and never a refusal — splitting one long read into takes you then cut together is a legitimate shape, and building on a previous take (`--from-clip` / `--from-video`) is not flagged at all.
+
 ### `baker studio get` / `list` / `keep` / `skills`
 
 ```bash

package/dist/cli.js

@@ -22665,6 +22665,20 @@ var lookalikeSpecSchema = z30.object({
   ratio: z30.number().min(0.01).max(0.2).optional(),
   country: z30.string().length(2).optional()
 });
+function valuesOfKey(node, key) {
+  if (Array.isArray(node)) return node.flatMap((entry) => valuesOfKey(entry, key));
+  if (!node || typeof node !== "object") return [];
+  const record = node;
+  return [
+    ...key in record ? [record[key]] : [],
+    ...Object.values(record).flatMap((value) => valuesOfKey(value, key))
+  ];
+}
+function mixedEventSourceTypes(rule) {
+  const types = valuesOfKey(rule, "event_sources").flatMap((sources) => Array.isArray(sources) ? sources : []).map((source) => source?.type).filter((type) => typeof type === "string");
+  const distinct = [...new Set(types)].sort();
+  return distinct.length > 1 ? distinct : [];
+}
 var customAudienceCreateSchema = z30.object({
   name: z30.string().min(1).max(META_LIMITS.audience.nameMax),
   subtype: z30.enum(CUSTOM_AUDIENCE_SUBTYPES),
@@ -22681,6 +22695,21 @@ var customAudienceCreateSchema = z30.object({
   if ((p.subtype === "WEBSITE" || p.subtype === "ENGAGEMENT") && !p.rule) {
     ctx.addIssue({ code: "custom", path: ["rule"], message: `${p.subtype} audiences need a rule (use --file)` });
   }
+  if (p.rule && p.retention_days !== void 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["retention_days"],
+      message: "a rule carries its own window in retention_seconds, so drop retention_days \u2014 Meta takes it only on a customer-file audience, and sending both leaves the review showing a window the audience will not have"
+    });
+  }
+  const mixed = mixedEventSourceTypes(p.rule);
+  if (mixed.length > 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["rule"],
+      message: `one audience covers one kind of source, but this rule mixes ${mixed.join(" and ")} \u2014 split it into one audience per source`
+    });
+  }
 });
 var customAudienceUpdateSchema = z30.object({
   name: z30.string().min(1).max(META_LIMITS.audience.nameMax).optional(),
@@ -23421,6 +23450,7 @@ var audiencesCreateCommand2 = defineCommand57({
     name: "create",
     description: `Stage a new custom audience shell. ${STAGED_NOTE2}
 LOOKALIKE/WEBSITE/ENGAGEMENT specifics go via --file (lookalike_spec / rule). Member-list upload is not staged in v1.
+A WEBSITE/ENGAGEMENT rule carries its own window in retention_seconds, so --retention-days is refused next to one, and one audience covers one kind of event source (a Page and an Instagram profile are two audiences).
 Example: baker ads meta audiences create --name "Site visitors 30d" --subtype WEBSITE --file rule.json`
   },
   args: {
@@ -23428,7 +23458,10 @@ Example: baker ads meta audiences create --name "Site visitors 30d" --subtype WE
     name: { type: "string", description: "Audience name" },
     subtype: { type: "string", description: "CUSTOM|WEBSITE|ENGAGEMENT|LOOKALIKE" },
     description: { type: "string", description: "Description" },
-    "retention-days": { type: "string", description: "Retention window in days" },
+    "retention-days": {
+      type: "string",
+      description: "Retention window in days \u2014 customer-file audiences only; a rule carries its own retention_seconds"
+    },
     file: { type: "string", description: "JSON file with lookalike_spec / rule / full payload" }
   },
   run: async ({ args }) => {
@@ -58456,6 +58489,43 @@ import { defineCommand as defineCommand209 } from "citty";
 // src/commands/studio/animate.ts
 import { defineCommand as defineCommand201 } from "citty";
 
+// src/commands/studio/spokenPace.ts
+var WORDS_PER_SECOND3 = SPOKEN_WORDS_PER_SECOND;
+var spokenWords = spokenWordsIn;
+function wordsThatFit(seconds) {
+  return Math.floor(seconds * WORDS_PER_SECOND3);
+}
+function spokenPaceHint(prompt, seconds, model) {
+  const words2 = spokenWords(prompt);
+  if (words2 === 0) return null;
+  const split = model ? splitScriptFor(words2, model) : null;
+  if (split) {
+    return `The line is ${words2} words \u2014 about ${Math.ceil(words2 / WORDS_PER_SECOND3)}s of speech \u2014 and ${model} renders at most ${split.maxSeconds}s (~${Math.floor(split.maxSeconds * WORDS_PER_SECOND3)} words). It will not refuse and it will not cut: it will RUSH, swallowing syllables. Split the script into ${split.clips} takes of roughly ${split.wordsPerClip} words each, rendered separately and cut together \u2014 break it where the thought breaks, not mid-sentence. Or move to a model that renders longer (bytedance/seedance-2.5 goes to 30s).`;
+  }
+  if (!seconds) return null;
+  const fits = wordsThatFit(seconds);
+  if (words2 <= fits) return null;
+  const rate = (words2 / seconds).toFixed(1);
+  return `The line is ${words2} words and this clip is ${seconds}s \u2014 that is ${rate} words a second against a natural ${WORDS_PER_SECOND3}. The model will not run over, it will RUSH: syllables swallowed, endings clipped, and the take unusable however good the picture. Cut the line to about ${fits} words, or give it the length it needs (${Math.ceil(words2 / WORDS_PER_SECOND3)}s). Do not re-render the same line at the same length and hope.`;
+}
+
+// src/commands/studio/adByHand.ts
+function priorScriptedTakes(batches) {
+  return batches.filter(
+    (batch) => batch.kind === "video" && spokenWords(batch.prompt) > 0 && batch.variants.some((variant) => variant.status !== "failed")
+  ).length;
+}
+function ordinal(n) {
+  const suffix = n % 100 >= 11 && n % 100 <= 13 ? "th" : ["th", "st", "nd", "rd"][n % 10] ?? "th";
+  return `${n}${suffix}`;
+}
+function adByHandHint(input) {
+  if (!input.thisTakeIsScripted || input.buildsOnAClip) return null;
+  if (input.priorScriptedTakes < 1) return null;
+  const which = ordinal(input.priorScriptedTakes + 1);
+  return `This is the ${which} clip with a scripted line in this conversation. Separate takes stay separate \u2014 nothing cuts them together, the audio stops and restarts at every join, and there are no captions and no closing card \u2014 so ${input.priorScriptedTakes + 1} takes of a presenter are ${input.priorScriptedTakes + 1} clips and never one ad. If these are the beats of one ad, stop rendering them one at a time: write them as beats (one line the voice says plus one shot on screen while it is said) and \`baker canvas scaffold-ad\` emits the whole ad \u2014 one canvas, one render, continuous read, synced captions and a brand end card. If they really are consecutive parts of ONE long read you will cut together yourself, carry on.`;
+}
+
 // src/commands/studio/batch.ts
 function projectBatch(generation, full) {
   const compact3 = {
@@ -58670,26 +58740,6 @@ function uploadFailure(path48) {
   };
 }
 
-// src/commands/studio/spokenPace.ts
-var WORDS_PER_SECOND3 = SPOKEN_WORDS_PER_SECOND;
-var spokenWords = spokenWordsIn;
-function wordsThatFit(seconds) {
-  return Math.floor(seconds * WORDS_PER_SECOND3);
-}
-function spokenPaceHint(prompt, seconds, model) {
-  const words2 = spokenWords(prompt);
-  if (words2 === 0) return null;
-  const split = model ? splitScriptFor(words2, model) : null;
-  if (split) {
-    return `The line is ${words2} words \u2014 about ${Math.ceil(words2 / WORDS_PER_SECOND3)}s of speech \u2014 and ${model} renders at most ${split.maxSeconds}s (~${Math.floor(split.maxSeconds * WORDS_PER_SECOND3)} words). It will not refuse and it will not cut: it will RUSH, swallowing syllables. Split the script into ${split.clips} takes of roughly ${split.wordsPerClip} words each, rendered separately and cut together \u2014 break it where the thought breaks, not mid-sentence. Or move to a model that renders longer (bytedance/seedance-2.5 goes to 30s).`;
-  }
-  if (!seconds) return null;
-  const fits = wordsThatFit(seconds);
-  if (words2 <= fits) return null;
-  const rate = (words2 / seconds).toFixed(1);
-  return `The line is ${words2} words and this clip is ${seconds}s \u2014 that is ${rate} words a second against a natural ${WORDS_PER_SECOND3}. The model will not run over, it will RUSH: syllables swallowed, endings clipped, and the take unusable however good the picture. Cut the line to about ${fits} words, or give it the length it needs (${Math.ceil(words2 / WORDS_PER_SECOND3)}s). Do not re-render the same line at the same length and hope.`;
-}
-
 // src/commands/studio/animate.ts
 var MODEL_LIST = VIDEO_MODEL_IDS;
 var DEFAULT_MAX_WAIT_MS = 6e5;
@@ -58931,6 +58981,25 @@ function costHintsFor(body) {
   }
   return hints2;
 }
+var PRIOR_TAKE_WINDOW = 20;
+async function adByHandHintFor(body) {
+  const thisTakeIsScripted = spokenWords(body.prompt) > 0;
+  const buildsOnAClip = (body.clipRefs?.length ?? 0) + (body.videoIds?.length ?? 0) > 0;
+  if (!thisTakeIsScripted || buildsOnAClip) return null;
+  try {
+    const { generations } = await apiGet("/api/studio/generations", {
+      kind: "video",
+      limit: String(PRIOR_TAKE_WINDOW)
+    });
+    return adByHandHint({
+      priorScriptedTakes: priorScriptedTakes(generations),
+      thisTakeIsScripted,
+      buildsOnAClip
+    });
+  } catch {
+    return null;
+  }
+}
 var animateCommand = defineCommand201({
   meta: {
     name: "animate",
@@ -59020,7 +59089,8 @@ var animateCommand = defineCommand201({
       }
       const { imageIds } = args.image ? await resolveLibraryImageIds(args.image, clipImageLimitFor(args)) : { imageIds: [] };
       const body = buildAnimateBody(args, prompt, imageIds);
-      const costHints = costHintsFor(body);
+      const assembling = await adByHandHintFor(body);
+      const preflightHints = [...assembling ? [assembling] : [], ...costHintsFor(body)];
       const start = await apiPost("/api/studio/animate", body);
       const maxWaitMs = resolveMaxWaitMs(args.wait, args["max-wait"], DEFAULT_MAX_WAIT_MS);
       if (maxWaitMs === 0) {
@@ -59029,7 +59099,7 @@ var animateCommand = defineCommand201({
           data: start,
           hints: [
             `Rendering ${start.count} take(s). Read them with \`baker studio get ${start.generationId}\`, then keep the one you want.`,
-            ...costHints
+            ...preflightHints
           ]
         });
         return;
@@ -59039,14 +59109,14 @@ var animateCommand = defineCommand201({
         writeJson({
           ok: true,
           data: { ...start, status: "running" },
-          hints: [waitingHint(outcome, start.generationId, maxWaitMs), ...costHints]
+          hints: [waitingHint(outcome, start.generationId, maxWaitMs), ...preflightHints]
         });
         return;
       }
       writeJson({
         ok: true,
         data: projectBatch(outcome.generation, args.full === true),
-        hints: [...batchHints(outcome.generation), ...costHints]
+        hints: [...batchHints(outcome.generation), ...preflightHints]
       });
     } catch (error) {
       failStudioCommand(error, { withFix: true });