@aicopycoders/exodus 2026.11.1200-beta.24 → 2026.11.1200-beta.26

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1032,10 +1032,14 @@ say yes. If the price changed by then, the start refuses and says the new
1032
1032
  price: show that and ask again. An older CLI is told to update first. An
1033
1033
  admin's start begins at once, as before.
1034
1034
 
1035
- **A video that reached its estimate.** A regular video (not One-take) keeps
1036
- the estimate it showed before the start. When its next take would cost more
1037
- than that, it stops before ordering it and waits for the member. `exodus
1038
- video status` then prints a line that starts "Waiting for you:", with what
1035
+ **A video that needs the member's OK to spend more.** A regular video (not
1036
+ One-take) keeps the estimate it showed before the start. A scene's first take
1037
+ does not stop to ask, even past it; when any other take would take the video's cost
1038
+ past it, the video stops before ordering that take and waits for the member,
1039
+ often while its cost so far is still under the estimate. At the storyboard,
1040
+ `exodus video status` says the storyboard's own estimate when it differs from
1041
+ the one the member started with. When the video waits, `exodus video status`
1042
+ prints a line that starts "Waiting for you:", with what
1039
1043
  the video has cost so far, its estimate, what it wants to film next and
1040
1044
  about what that costs, and under it two commands: `exodus video keep-going
1041
1045
  <runId>` and `exodus video stop-here <runId>`. That choice is the member's,
@@ -337,6 +337,18 @@ export interface CutPace {
337
337
  loudness?: { lufs: number; truePeak: number; passes: 1 | 2; limited?: true; limitedAgain?: number; limit?: number };
338
338
  /** Present only with cutChecks. */
339
339
  checks?: CutChecks;
340
+ /**
341
+ * #4805, written by the worker (scout cut-additions.ts): the sheet's additions the film was made again without,
342
+ * because its last check found a fault at one of them.
343
+ */
344
+ remadeWithout?: Array<"addedCuts" | "pauseTrim" | "roomSound">;
345
+ /**
346
+ * #4805, written by the worker: a fault at one of the sheet's additions that making the film again without them did
347
+ * not fix; the film waits for its member, and `sentence` says why.
348
+ */
349
+ finishHold?: { sentence: string; additions: Array<"addedCuts" | "pauseTrim" | "roomSound"> };
350
+ /** #4805, written by the worker: the sentence the member reads of either (convex customerRunView.ts cutCheckNotes). */
351
+ additionsNote?: string;
340
352
  /** COP-300: present when a sped-up cut burned its captions: the caption file is on the finished cut's clock. */
341
353
  captionClock?: "final";
342
354
  /**
@@ -371,6 +383,26 @@ export interface CutSync {
371
383
  heard: Array<{ text: string; start: number; end: number; lagMs: number; match: number }>;
372
384
  }
373
385
 
386
+ /** COP-357, fps30: the frame rate a film with the phone look is delivered at, by repeated frames. */
387
+ export const DELIVERY_FPS: number;
388
+
389
+ /** The finished cut's frames on its own 24 fps clock: the joined picture's, or round(frames / speed) after a speed step. */
390
+ export function filmFrames(pictureSec: number, speed?: number | null): number;
391
+
392
+ /** #4817: the frames a film delivered at `deliverFps` has, so its picture runs as long as its sound (filmFrames after a speed step, else pictureSec), rounded up. */
393
+ export function deliveredFrames(pictureSec: number, speed: number | null, deliverFps: number): number;
394
+
395
+ /** The bars checkVerdict holds a finished cut to. */
396
+ export const CHECK_BARS: {
397
+ voiceOverBedDb: number;
398
+ minBrollSec: number;
399
+ truePeak: number;
400
+ lufs: number;
401
+ blipSec: number;
402
+ freezeSec: number;
403
+ freezeYavg: number;
404
+ };
405
+
374
406
  /** What cutChecks measured on the finished cut, and what fails its bars. */
375
407
  export interface CutChecks {
376
408
  /** Caption screens holding words of two script lines, in the cut's time before any speed-up; null when no captions were burned. */
@@ -511,6 +543,12 @@ export interface FirstCut {
511
543
  pace?: CutPace;
512
544
  /** COP-300: present only with captionCheck. */
513
545
  sync?: CutSync;
546
+ /**
547
+ * COP-357, fix A: present only when a picture pass of the phone look was laid and the takes were read before it: their
548
+ * frozen runs (freezedetect at -60 dB from 0.2 s), on the finished film's clock, less what a cutaway or the end card
549
+ * covers. The worker joins them at the cut's framing changes, drops those under 2 s, and adds them to the film's own.
550
+ */
551
+ lookFreeze?: Array<{ start: number; end: number; duration: number }>;
514
552
  /** The cut's words on the finished film's clock, as written beside it. */
515
553
  rows?: Array<{ text: string; start: number; end: number; scene?: number }>;
516
554
  /** Present only when the manifest names sounds, beds, a ducked music bed or a music-only master. */
@@ -522,6 +560,11 @@ export interface FirstCut {
522
560
  * present only with the cuts row on. The worker's last guard joins a freeze that one splits (auto-cut.ts withFramingJoins).
523
561
  */
524
562
  framingChangesSec?: number[];
563
+ /**
564
+ * #4805, pauseTrim: where a pause cut at one of Luke's levels joins a take to itself, in seconds on the delivered
565
+ * film's clock; present only with a pause level picked.
566
+ */
567
+ pauseJoinsSec?: number[];
525
568
  /** Present only when the manifest asked for the measured map.
526
569
  * Authored picture time is reserved once per take; only its final split piece
527
570
  * may extend, so earlier pieces never replay the resumed piece's source audio.
@@ -629,5 +672,8 @@ export function sentenceGapCuts(
629
672
  /** jumpCut: a pause over maxGap between two heard words keeps keepAfter after the earlier word and keepBefore before the later. */
630
673
  export interface JumpCut { maxGap: number; keepAfter: number; keepBefore: number }
631
674
  export const JUMP_CUT: JumpCut;
675
+
676
+ /** COP-357, fix A: how the cut reads the takes before the phone look (freezedetect's noise and length) and its side files. */
677
+ export const LOOK_PROBE: { readonly noise: string; readonly minSec: number; readonly freeze: string; readonly motion: string };
632
678
  /** jumpCut on one pause: the span it takes out, or null when it keeps the pause whole. */
633
679
  export function jumpCutSpan(endSec: number, startSec: number, jump?: JumpCut): { s: number; e: number } | null;
@@ -288,6 +288,221 @@ function wholeLinesOf(raw) {
288
288
  return ids.length > 0 ? { wholeLines: ids } : {};
289
289
  }
290
290
 
291
+ /**
292
+ * COP-357, the phone look: a run's saved sheet ("Ultra realism"), written by the worker as three settings, each read only when
293
+ * true, on a cut of its own clock (not a template launch's, not one laid on its measured map).
294
+ * - fps30: the finished file runs at DELIVERY_FPS. The last step of the picture, after the words are burned in, repeats
295
+ * one frame in four (the fps filter), so the cut's own clock (FPS), its edges, its speed step, its captions and its
296
+ * sound stay as they are.
297
+ * - lensSmudge: LENS_SMUDGE, a soft haze of the picture itself laid back over it near one top corner, the brighter
298
+ * one about 1.0 s into the joined takes (brighterSide).
299
+ * - phonePass: PHONE_PASS, grain that changes every frame, softer colour, a light halo and a slow drift of the
300
+ * exposure. No shake.
301
+ * Both picture passes run on the joined takes, before any cutaway, picture, end card or burned word is laid over them,
302
+ * so those stay sharp. The numbers are Luke's, from his free realism test at its light strength and his locked smudge
303
+ * at half strength: tuned at 720x1280, the smudge's places and sizes are scaled here to WIDTH x HEIGHT; his own 1080 run
304
+ * of the phone pass kept its numbers. A pass whose filters this ffmpeg lacks is left out, with a note.
305
+ * With either picture pass the takes are also read before the look, in the same render (LOOK_PROBE); a 30 fps film's
306
+ * motion is read back on FPS, and its caption check reads each caption on the frame the delivered file shows it on.
307
+ */
308
+ export const DELIVERY_FPS = 30;
309
+
310
+ /** The finished cut's frames on FPS: the joined picture's, or round(frames / speed) after a speed step, as its sound ends. */
311
+ export function filmFrames(pictureSec, speed = null) {
312
+ const frames = Math.round(pictureSec * FPS);
313
+ return speed ? Math.round(frames / speed + 1e-9) : frames;
314
+ }
315
+
316
+ /**
317
+ * #4817: the frames a film delivered at `deliverFps` has, so its picture runs as long as its sound: after a speed step
318
+ * the sound ends on filmFrames on FPS, with none it ends on pictureSec itself. Rounded up to a whole delivered frame, so
319
+ * the picture never ends before the sound, and never by a whole frame after it.
320
+ */
321
+ export function deliveredFrames(pictureSec, speed, deliverFps) {
322
+ const soundSec = speed ? filmFrames(pictureSec, speed) / FPS : Number(pictureSec.toFixed(6));
323
+ return Math.ceil(soundSec * deliverFps - 1e-9);
324
+ }
325
+ export const LENS_SMUDGE = {
326
+ /** Where the side is read: this far into the cut. */
327
+ readAtSec: 1,
328
+ /** The mask: its peak of 255 (half of full), its reach in pixels, how it stretches across and down, its falloff. */
329
+ strength: 117, radius: 900, stretch: [1.1, 0.9], power: 1.25,
330
+ /** The mask's centre on each side, in pixels of WIDTH x HEIGHT. */
331
+ centre: { left: [165, 570], right: [900, 450] },
332
+ /** The haze: the picture made this small, blurred round (sigma) and along a line (angle, radius), averaged, scaled up. */
333
+ haze: { width: 180, height: 320, sigma: 6.5, angle: 32, radius: 17 },
334
+ /** The haze softened before it is merged in. */
335
+ tone: { contrast: 0.8, brightness: 0.05, saturation: 0.9 },
336
+ };
337
+ export const PHONE_PASS = {
338
+ grain: { luma: 4, chroma: 2 },
339
+ chromaBlur: 0.8,
340
+ halo: { size: 5, amount: 0.35 },
341
+ /** The exposure's drift, as eq expressions of the time. */
342
+ brightness: "0.008*sin(2*PI*t*0.23+1)+0.004*sin(2*PI*t*0.71+2.4)",
343
+ gamma: "1+0.016*sin(2*PI*t*0.17)",
344
+ };
345
+ /** The filters each picture pass needs that a build of ffmpeg may leave out. */
346
+ export const LOOK_FILTERS = {
347
+ lensSmudge: ["gblur", "dblur", "blend", "eq", "geq", "maskedmerge"],
348
+ phonePass: ["gblur", "eq", "unsharp", "noise"],
349
+ };
350
+
351
+ /**
352
+ * COP-357, fix A: the look's exposure drift hides a frozen picture from both freeze checks (its grain from the worker's
353
+ * too): the worker's freezedetect compares each frame with the first of the freeze, the cut's motion read each frame with
354
+ * the one before, and the drift steps the picture a whole level at a time. So with either
355
+ * picture pass the joined takes are split before the look, in the same render, and a probe branch reads them as the
356
+ * two checks read a film: freezedetect at the worker's -60 dB (scout media-probe.ts FREEZE_NOISE) from 0.2 s, as the
357
+ * guard reads a film whose framing the cut changed (scout auto-cut.ts FRAMING_FREEZE_MIN_SEC: an added cut halves a
358
+ * held pause into pieces under 2 s), and the cut's motion rows, each into a side file in the folder (read, then taken
359
+ * away). The worker joins the runs that meet at a framing change and drops those under 2 s, as it does the film's own.
360
+ * Its times are the takes' clock, before the speed step.
361
+ */
362
+ export const LOOK_PROBE = { noise: "-60dB", minSec: 0.2, freeze: "edit.lookfreeze.txt", motion: "edit.lookmotion.txt" };
363
+ /** The motion read of a picture: each frame's change from the one before, on a 90 px wide copy (motionArgs, LOOK_PROBE). */
364
+ const MOTION_READ = "scale=90:-2,tblend=all_mode=difference,signalstats,metadata=print:key=lavfi.signalstats.YAVG";
365
+
366
+ /** The probe branch's filters, from the takes' split to its sink. */
367
+ export function lookProbeFilter() {
368
+ return `freezedetect=n=${LOOK_PROBE.noise}:d=${LOOK_PROBE.minSec},metadata=print:file=${LOOK_PROBE.freeze},` +
369
+ `${MOTION_READ}:file=${LOOK_PROBE.motion},nullsink`;
370
+ }
371
+
372
+ /** freezedetect's hits in the probe's side file as runs, in its order; one still open at the end runs to `endSec`. */
373
+ export function lookFreezeRunsOf(text, endSec) {
374
+ const runs = [];
375
+ let open = null;
376
+ for (const line of String(text ?? "").split("\n")) {
377
+ // ffmpeg prints a time with %g ("4.16667e-05" for frame 0): the exponent and a sign are part of the number (COP-361).
378
+ const hit = line.match(/^lavfi\.freezedetect\.freeze_(start|end)=([-+]?[\d.]+(?:e[-+]?\d+)?)/i);
379
+ if (!hit) continue;
380
+ if (hit[1] === "start") open = Number(hit[2]);
381
+ else if (open !== null) {
382
+ runs.push([open, Number(hit[2])]);
383
+ open = null;
384
+ }
385
+ }
386
+ if (open !== null && endSec > open) runs.push([open, endSec]);
387
+ return runs;
388
+ }
389
+
390
+ /** The span from `from` to `to` less each covered [a, b]: the pieces left. */
391
+ function uncovered(from, to, covered) {
392
+ let pieces = [[from, to]];
393
+ for (const [a, b] of covered) {
394
+ pieces = pieces.flatMap(([s, e]) => (b <= s || a >= e ? [[s, e]] : [[s, Math.min(e, a)], [Math.max(s, b), e]].filter(([x, y]) => y - x > 1e-9)));
395
+ }
396
+ return pieces;
397
+ }
398
+
399
+ /**
400
+ * What the probe leaves out, on the takes' clock: what covers the whole frame, so the takes are not seen there (a
401
+ * cutaway, the end card). A product picture sits in its box with the takes around it, so it covers nothing.
402
+ */
403
+ export function lookCovered({ cutaways = [], pictures: _pictures = [], endCard = null }) {
404
+ return [...cutaways.map((c) => [c.startSec, c.startSec + c.seconds]), ...(endCard ? [[endCard.in, endCard.out]] : [])];
405
+ }
406
+
407
+ /**
408
+ * The probe's two side files, read on the film's clock (divided by the speed), with what covers the whole frame left
409
+ * out (lookCovered): the freeze runs for the worker's guard, and the motion rows for the cut's freeze check (a covered
410
+ * row never counts as still), and how many frame changes it read of the takes' (`rowsRead` of `changes`). Null when
411
+ * either file cannot be read. Both files are taken away.
412
+ */
413
+ function readLookProbe(here, { pictureSec, speed, covered }) {
414
+ let freezeText;
415
+ let motionText;
416
+ try {
417
+ freezeText = readFileSync(here(LOOK_PROBE.freeze), "utf8");
418
+ motionText = readFileSync(here(LOOK_PROBE.motion), "utf8");
419
+ } catch {
420
+ return null;
421
+ } finally {
422
+ rmSync(here(LOOK_PROBE.freeze), { force: true });
423
+ rmSync(here(LOOK_PROBE.motion), { force: true });
424
+ }
425
+ const freezes = lookFreezeRunsOf(freezeText, pictureSec)
426
+ .flatMap(([from, to]) => uncovered(from, to, covered))
427
+ .map(([from, to]) => ({ start: roundMs(from / speed), end: roundMs(to / speed), duration: roundMs(to / speed - from / speed) }));
428
+ const read = readMotion(motionText);
429
+ const rows = read.map((r) => ({ t: r.t / speed, y: covered.some(([a, b]) => r.t >= a && r.t < b) ? Infinity : r.y }));
430
+ return { freezes, rows, rowsRead: read.length, changes: Math.max(0, Math.round(pictureSec * FPS) - 1) };
431
+ }
432
+
433
+ /** Two freeze runs of one hold, read on two clocks, can miss each other by less than a frame: one run within this. */
434
+ const FREEZE_JOIN_SEC = 1 / FPS;
435
+
436
+ /** Freeze runs ({ at, sec }) merged where they overlap or come within FREEZE_JOIN_SEC, in time order. */
437
+ export function mergedFreezes(runs) {
438
+ const out = [];
439
+ for (const run of [...runs].sort((a, b) => a.at - b.at)) {
440
+ const last = out.at(-1);
441
+ if (last && run.at <= last.at + last.sec + FREEZE_JOIN_SEC + 1e-9) last.sec = roundMs(Math.max(last.at + last.sec, run.at + run.sec) - last.at);
442
+ else out.push({ ...run });
443
+ }
444
+ return out;
445
+ }
446
+
447
+ /**
448
+ * COP-357: when the cut's 24 fps frame that starts at `sec` is first seen in its file repeated to `fps` frames a second.
449
+ * The fps filter shows frame n first at frame floor(n x fps / 24 + 0.5) (rounding to nearest, its default).
450
+ */
451
+ export function deliveredSeenSec(sec, fps) {
452
+ const n = Math.round(sec * FPS);
453
+ return Math.floor((n * fps) / FPS + 0.5) / fps;
454
+ }
455
+
456
+ /** lensSmudge's filters, from the picture labelled `input` to `output`, its mask centred on the `side` top corner. */
457
+ export function lensSmudgeFilters(input, side, output) {
458
+ const s = LENS_SMUDGE;
459
+ const [x, y] = s.centre[side];
460
+ const h = s.haze;
461
+ const t = s.tone;
462
+ return [
463
+ `[${input}]format=gbrp,split=3[lkpic][lkbase][lksmall]`,
464
+ `[lksmall]scale=${h.width}:${h.height},split[lksmall1][lksmall2]`,
465
+ `[lksmall1]gblur=sigma=${h.sigma}[lkround]`,
466
+ `[lksmall2]dblur=angle=${h.angle}:radius=${h.radius}[lkline]`,
467
+ `[lkround][lkline]blend=all_mode=average,scale=${WIDTH}:${HEIGHT}:flags=bilinear[lkhaze]`,
468
+ `[lkpic][lkhaze]blend=all_mode=screen:all_opacity=1,eq=contrast=${t.contrast}:brightness=${t.brightness}:saturation=${t.saturation},format=gbrp[lkhazed]`,
469
+ // One frame of mask, made once: maskedmerge holds an input's last frame to the end of the others (ffmpeg's framesync).
470
+ `nullsrc=s=${WIDTH}x${HEIGHT}:r=${FPS},format=gray,` +
471
+ `geq=lum=${s.strength}*pow(clip(1-hypot((X-${x})/${s.stretch[0]}\\,(Y-${y})/${s.stretch[1]})/${s.radius}\\,0\\,1)\\,${s.power}),` +
472
+ "trim=end_frame=1,format=gbrp[lkmask]",
473
+ `[lkbase][lkhazed][lkmask]maskedmerge,format=yuv420p[${output}]`,
474
+ ];
475
+ }
476
+
477
+ /** phonePass's filter chain. */
478
+ export function phonePassFilter() {
479
+ const p = PHONE_PASS;
480
+ const { size, amount } = p.halo;
481
+ return `gblur=sigma=${p.chromaBlur}:planes=6,unsharp=${size}:${size}:${amount}:${size}:${size}:0,` +
482
+ `noise=c0s=${p.grain.luma}:c0f=t+u:c1s=${p.grain.chroma}:c1f=t+u:c2s=${p.grain.chroma}:c2f=t+u,` +
483
+ `eq=brightness=${p.brightness}:gamma=${p.gamma}:eval=frame`;
484
+ }
485
+
486
+ /**
487
+ * lensSmudge's side: the top corner that is brighter, "left" or "right", in one frame of `file` at `atSec`, made 2 by 3
488
+ * pixels of grey (each top pixel is one half of the frame's top third); null when the frame cannot be read.
489
+ */
490
+ export function brighterSide(file, atSec) {
491
+ const res = spawnSync("ffmpeg", [
492
+ "-v", "error", "-ss", sec(atSec), "-i", file, "-frames:v", "1", "-vf", "scale=2:3:flags=area,format=gray", "-f", "rawvideo", "-",
493
+ ], { maxBuffer: 1 << 16 });
494
+ const px = res.status === 0 && res.stdout?.length >= 2 ? res.stdout : null;
495
+ return px ? (px[0] > px[1] ? "left" : "right") : null;
496
+ }
497
+
498
+ /** The take and its time that the cut shows about `atSec` in (a still shows its picture from its start). */
499
+ function spineFrameAt(spine, atSec) {
500
+ const seg = spine.find((s) => s.startSec + s.seconds > atSec) ?? spine.at(-1);
501
+ if (!seg) return null;
502
+ const into = Math.max(0, Math.min(atSec - seg.startSec, seg.seconds));
503
+ return { file: seg.file, atSec: seg.source === "clip" ? (seg.inSec ?? 0) + into : 0 };
504
+ }
505
+
291
506
  /** Plan 14's on/off cut checks, each read only with cutChecks; paceCheck also carries its numbers. */
292
507
  const PLAN_14_CHECKS = ["floorCheck", "flashCheck", "levelStepCheck", "voFitCheck", "dashGapCheck", "nameCheck"];
293
508
  const isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
@@ -343,6 +558,9 @@ export function finishingOf(manifest) {
343
558
  // COP-355: a saved sheet's pause level and cuts added, each by its name; the lines no added cut falls inside with it.
344
559
  ...(nameIn(PAUSE_TRIMS, f.pauseTrim) ? { pauseTrim: f.pauseTrim } : {}),
345
560
  ...(nameIn(ADDED_CUTS, f.addedCuts) ? { addedCuts: f.addedCuts, ...wholeLinesOf(f.wholeLines) } : {}),
561
+ ...(f.fps30 === true ? { fps30: true } : {}),
562
+ ...(f.lensSmudge === true ? { lensSmudge: true } : {}),
563
+ ...(f.phonePass === true ? { phonePass: true } : {}),
346
564
  // COP-356: the card as a headline at the top (headlineCards), a name only the worker writes from a run's sheet.
347
565
  ...(on.cards && f.cardPlace === "top" ? { cardPlace: "top" } : {}),
348
566
  };
@@ -1075,6 +1293,13 @@ const SETTLED_WINDOWS = 10;
1075
1293
  * silence goes while a soft breath and room tone stay (scout trim.ts).
1076
1294
  */
1077
1295
  const SOUND_OVER_FLOOR_DB = 25;
1296
+ /**
1297
+ * #4803 (a number of ours, for Daniel): reading a word's sound out past its listed edge at a pause level, a dip under
1298
+ * SOUND_DB this long or shorter is still the word (the hush before a "t", as in "eight").
1299
+ */
1300
+ const PAUSE_EDGE_BRIDGE_SEC = 0.1;
1301
+ /** #4803 (a number of ours, for Daniel): a run past such a dip is the word's when it comes within this of the word's loudest. */
1302
+ const PAUSE_EDGE_WORD_DB = 12;
1078
1303
  const FAINT_SOUND_DB = -45;
1079
1304
  /** The directions that ask for a pause (scout clip-qc.ts PAUSE_DIRECTION, NO_PAUSE_DIRECTION, lineWrittenPause). */
1080
1305
  const PAUSE_DIRECTION =
@@ -1139,28 +1364,24 @@ export function sentenceGapCuts(words, lines, levels = null, lineGap = null, jum
1139
1364
  });
1140
1365
  const aligned = alignScript(words ?? [], written);
1141
1366
  if (!aligned) return [];
1142
- const { expected, heardTokenOf, heardWordOf, spokenWords: spoken } = aligned;
1367
+ const { expected, heard: heardTokens, heardTokenOf, heardWordOf, spokenWords: spoken } = aligned;
1368
+ // COP-355 (#4803): at one of Luke's pause levels, a pause's cut reads where the words' sound really ends and starts.
1369
+ const level = PAUSE_LEVELS.has(jump) && levels ? jump : null;
1143
1370
  const cuts = [];
1144
- for (let t = 0; t + 1 < heardWordOf.length; t++) {
1145
- if (heardTokenOf[t + 1] !== heardTokenOf[t] + 1) continue;
1146
- const to = heardWordOf[t + 1];
1147
- if (heardWordOf[t] === to) continue;
1148
- // A joined script token keeps its first word's line and lead-in.
1149
- const [a, b] = [pieces[expected.sourceIndex[t]], pieces[expected.sourceIndex[t + 1]]];
1150
- const newLine = a.li !== b.li;
1151
- // A name heard split in two (#2300) ends on its last heard word.
1152
- const [earlier, later] = [words[spoken.findLast((w) => w < to)], words[to]];
1153
- const sentenceBreak = newLine || SENTENCE_END.test(b.before) || heardSentenceEnd(earlier.w);
1371
+ const cutPause = (earlier, later, { sentenceBreak, newLine, nextLine }) => {
1154
1372
  // Inside a sentence only jumpCut acts, and only on a pause over its longest.
1155
- if (!sentenceBreak && !(jump && jumpCutSpan(earlier.e, later.s, jump))) continue;
1156
- if (WRITTEN_PAUSE.test(b.before) || lines[a.li].asksPause || lines[b.li].asksPause) continue;
1157
- if (newLine && lines[a.li].cuesBeat) continue;
1373
+ if (!sentenceBreak && !(jump && jumpCutSpan(earlier.e, later.s, jump))) return;
1158
1374
  const gap = later.s - earlier.e;
1159
1375
  const heard = levels && soundBetween(levels, earlier.e, later.s);
1160
1376
  // A sound's frame edges widen the cut, so none of it is left in.
1161
1377
  const sound = heard && { s: Math.max(floorFrame(heard.s), ceilFrame(earlier.e)), e: ceilFrame(heard.e) };
1162
1378
  const removed = sound ? sound.e - sound.s : 0;
1163
1379
  const spans = sound ? [sound] : [];
1380
+ // #4803: a word list can time a word late or far too short ("eight" listed from 4.50 s when it is heard from
1381
+ // 4.24 s), so at a level the air each side is kept from where the words' sound really ends and starts (heardEdge).
1382
+ // Which pauses are cut still goes by the listed gap.
1383
+ const wordEnd = level ? heardEdge(levels, earlier.e, 1, sound ? sound.s : later.s, peakDbOf(levels, earlier)) : earlier.e;
1384
+ const wordStart = level ? heardEdge(levels, later.s, -1, sound ? sound.e : wordEnd, peakDbOf(levels, later)) : later.s;
1164
1385
  const [breakMax, gapKeep] =
1165
1386
  lineGap && newLine ? [lineGap.max, lineGap.keep] : [gapMax, SENTENCE_GAP_KEEP_SEC];
1166
1387
  // jumpCut: a pause over its longest keeps its two edges, with a sound in it taken out whole.
@@ -1172,11 +1393,11 @@ export function sentenceGapCuts(words, lines, levels = null, lineGap = null, jum
1172
1393
  // between the kept length and the longest allowed.
1173
1394
  const back = (t) => (sound && t > sound.s ? t + removed : t);
1174
1395
  const [keepAfter, keepBefore] = jumped ? [jump.keepAfter, jump.keepBefore] : [gapKeep / 2, gapKeep / 2];
1175
- const after = ceilFrame(earlier.e + keepAfter);
1396
+ const after = ceilFrame(wordEnd + keepAfter);
1176
1397
  // COP-355: at one of Luke's pause levels, a sound that starts inside the air kept after the word takes that air
1177
1398
  // with it: the silence's cut starts with the sound's, so no piece of the pause of a frame or two is left between them.
1178
1399
  const s = jumped && PAUSE_LEVELS.has(jump) && sound && sound.s < after - 1e-6 ? sound.s : back(after);
1179
- const e = back(floorFrame(later.s - removed - keepBefore));
1400
+ const e = back(floorFrame(wordStart - removed - keepBefore));
1180
1401
  if (e > s) spans.push({ s, e });
1181
1402
  }
1182
1403
  const merged = [];
@@ -1186,11 +1407,36 @@ export function sentenceGapCuts(words, lines, levels = null, lineGap = null, jum
1186
1407
  else merged.push({ ...span });
1187
1408
  }
1188
1409
  const kept = gap - merged.reduce((sum, c) => sum + c.e - c.s, 0);
1189
- const split = lineGap && newLine && paused ? b.li : null;
1410
+ const split = lineGap && newLine && paused ? nextLine : null;
1190
1411
  merged.forEach(({ s, e }, m) => {
1191
1412
  const cut = { s, e, after: earlier.w, gap, kept, sound: Boolean(sound) };
1192
1413
  cuts.push(split !== null && m === merged.length - 1 ? { ...cut, atLine: split } : cut);
1193
1414
  });
1415
+ };
1416
+ for (let t = 0; t + 1 < heardWordOf.length; t++) {
1417
+ const to = heardWordOf[t + 1];
1418
+ if (heardWordOf[t] === to) continue;
1419
+ // A joined script token keeps its first word's line and lead-in.
1420
+ const [a, b] = [pieces[expected.sourceIndex[t]], pieces[expected.sourceIndex[t + 1]]];
1421
+ const newLine = a.li !== b.li;
1422
+ const keptWhole = WRITTEN_PAUSE.test(b.before) || lines[a.li].asksPause || lines[b.li].asksPause || (newLine && lines[a.li].cuesBeat);
1423
+ if (heardTokenOf[t + 1] !== heardTokenOf[t] + 1) {
1424
+ // #4806: at one of Luke's pause levels, a word heard between two script words that the script does not have (an
1425
+ // "um") is a heard word like any other: each pause from the earlier script word through it to the later one is
1426
+ // cut at the level. Neither word is touched, and the pauses a script word's place keeps whole stay whole.
1427
+ if (!PAUSE_LEVELS.has(jump) || keptWhole) continue;
1428
+ const from = heardTokens.lastSourceIndex[heardTokenOf[t]];
1429
+ const chain = [from, ...spoken.filter((w) => w > from && w < to), to];
1430
+ for (let k = 0; k + 1 < chain.length; k++) {
1431
+ cutPause(words[chain[k]], words[chain[k + 1]], { sentenceBreak: false, newLine: false, nextLine: null });
1432
+ }
1433
+ continue;
1434
+ }
1435
+ // A name heard split in two (#2300) ends on its last heard word.
1436
+ const [earlier, later] = [words[spoken.findLast((w) => w < to)], words[to]];
1437
+ const sentenceBreak = newLine || SENTENCE_END.test(b.before) || heardSentenceEnd(earlier.w);
1438
+ if (keptWhole) continue;
1439
+ cutPause(earlier, later, { sentenceBreak, newLine, nextLine: b.li });
1194
1440
  }
1195
1441
  return cuts;
1196
1442
  }
@@ -1224,6 +1470,43 @@ function soundBetween(levels, fromSec, toSec) {
1224
1470
  return resumed < 0 ? null : { s: quiet * windowSec, e: resumed * windowSec };
1225
1471
  }
1226
1472
 
1473
+ /**
1474
+ * #4803: at one of Luke's pause levels, where a word's sound really ends (`dir` 1, from its listed end `from`) or starts
1475
+ * (`dir` -1, from its listed start) on the pause's side, never past `bound`. A run of windows at SOUND_DB or over, from
1476
+ * the listed edge or past a dip of PAUSE_EDGE_BRIDGE_SEC or less, is the word's when it comes within PAUSE_EDGE_WORD_DB
1477
+ * of the word's own loudest window (`wordPeakDb`): the rest of a word its list timed too short ("eight" listed from
1478
+ * 4.50 s and heard from 4.24 s, its "t" after a hush), where a breath, a click or a room's steady noise is quieter. The
1479
+ * edge only ever moves out into the pause.
1480
+ */
1481
+ export function heardEdge(levels, from, dir, bound, wordPeakDb) {
1482
+ const { db, windowSec } = levels;
1483
+ const bridge = Math.round(PAUSE_EDGE_BRIDGE_SEC / windowSec);
1484
+ const step = dir > 0 ? 1 : -1;
1485
+ const inPause = (i) => i >= 0 && i < db.length && (dir > 0 ? i * windowSec < bound - 1e-9 : (i + 1) * windowSec > bound + 1e-9);
1486
+ const edgeOf = (i) => (dir > 0 ? Math.min(bound, (i + 1) * windowSec) : Math.max(bound, i * windowSec));
1487
+ let i = dir > 0 ? Math.ceil(from / windowSec - 1e-9) : Math.floor(from / windowSec + 1e-9) - 1;
1488
+ let edge = from;
1489
+ for (;;) {
1490
+ let dip = 0;
1491
+ while (inPause(i) && db[i] < SOUND_DB && dip <= bridge) { i += step; dip++; }
1492
+ if (!inPause(i) || dip > bridge) break;
1493
+ let loudest = -Infinity;
1494
+ let far = i;
1495
+ for (; inPause(i) && db[i] >= SOUND_DB; i += step) { loudest = Math.max(loudest, db[i]); far = i; }
1496
+ if (loudest < wordPeakDb - PAUSE_EDGE_WORD_DB) break;
1497
+ edge = edgeOf(far);
1498
+ }
1499
+ return dir > 0 ? Math.max(from, edge) : Math.min(from, edge);
1500
+ }
1501
+
1502
+ /** The loudest window of a word's listed span, in dB; -Infinity for none. */
1503
+ function peakDbOf(levels, word) {
1504
+ const { db, windowSec } = levels;
1505
+ let peak = -Infinity;
1506
+ for (let i = Math.floor(word.s / windowSec + 1e-9); i < db.length && i * windowSec < word.e - 1e-9; i++) peak = Math.max(peak, db[i]);
1507
+ return peak;
1508
+ }
1509
+
1227
1510
  /** Scanning forward from `from`, the first window of the first run of SETTLED_WINDOWS quiet windows, or -1. */
1228
1511
  function settledQuiet(db, from) {
1229
1512
  let run = 0;
@@ -1837,9 +2120,9 @@ const HEARD_COMMA = /,["'”’)\]]*$/;
1837
2120
  * addedCuts (COP-355): Luke's locked rule for one take, on its own clock before the speed-up. `realCuts` are the
1838
2121
  * cuts the take holds already; its two edges count as cuts too. `whole` holds the
1839
2122
  * [start, end] spans of the lines no cut may fall inside. A place is the middle of the silence after a heard word that
1840
- * ends a sentence or has a comma, when it is not inside a whole line. While the longest stretch between two cuts runs
1841
- * over `everySec`, a cut goes at a place in it at least ADDED_CUT.clearSec from both its ends: a sentence's end before
1842
- * a comma, then the place nearest its middle. When that stretch has no such place, no more is added. Returns the times
2123
+ * ends a sentence or has a comma, when it is not inside a whole line. While the longest stretch between two cuts that runs
2124
+ * over `everySec` has a place at least ADDED_CUT.clearSec from both its ends, a cut goes at one: a sentence's end
2125
+ * before a comma, then the place nearest its middle. A stretch with no such place is left as it is (#4804). Returns the times
1843
2126
  * of the cuts added, in order, and the longest stretch left with no cut.
1844
2127
  */
1845
2128
  export function addedCutPlan({ words, seconds, realCuts = [], joins = [], everySec, whole = [] }) {
@@ -1855,24 +2138,27 @@ export function addedCutPlan({ words, seconds, realCuts = [], joins = [], everyS
1855
2138
  places.push({ t, rank });
1856
2139
  }
1857
2140
  const added = [];
1858
- const longestOf = () => {
2141
+ const stretches = () => {
1859
2142
  const marks = [...new Set([0, ...realCuts, ...added, seconds])].sort((a, b) => a - b);
1860
- return marks.slice(1).reduce(
1861
- (best, to, k) => (to - marks[k] > best.length + 1e-9 ? { length: to - marks[k], from: marks[k], to } : best),
1862
- { length: 0, from: 0, to: 0 },
1863
- );
2143
+ return marks.slice(1).map((to, k) => ({ length: to - marks[k], from: marks[k], to }));
1864
2144
  };
1865
- for (let gap = longestOf(); gap.length > everySec + 1e-9; gap = longestOf()) {
2145
+ const placesIn = (gap) => places.filter((p) =>
2146
+ p.t >= gap.from + ADDED_CUT.clearSec - 1e-9 && p.t <= gap.to - ADDED_CUT.clearSec + 1e-9 &&
2147
+ added.every((t) => Math.abs(p.t - t) > 0.01));
2148
+ // #4804: a stretch with no place (a line no cut falls inside) is passed over, and the next longest one over
2149
+ // `everySec` is cut, until none over it has a place.
2150
+ for (;;) {
2151
+ const gap = stretches()
2152
+ .filter((g) => g.length > everySec + 1e-9 && placesIn(g).length > 0)
2153
+ .reduce((best, g) => (!best || g.length > best.length + 1e-9 ? g : best), null);
2154
+ if (!gap) break;
1866
2155
  const mid = (gap.from + gap.to) / 2;
1867
- const inside = places.filter((p) =>
1868
- p.t >= gap.from + ADDED_CUT.clearSec - 1e-9 && p.t <= gap.to - ADDED_CUT.clearSec + 1e-9 &&
1869
- added.every((t) => Math.abs(p.t - t) > 0.01));
1870
- if (inside.length === 0) break;
1871
- const best = inside.reduce((a, b) =>
2156
+ const best = placesIn(gap).reduce((a, b) =>
1872
2157
  b.rank < a.rank || (b.rank === a.rank && Math.abs(b.t - mid) < Math.abs(a.t - mid) - 1e-9) ? b : a);
1873
2158
  added.push(best.t);
1874
2159
  }
1875
- return { added: added.map(r6).sort((a, b) => a - b), longest: r6(longestOf().length) };
2160
+ const longest = stretches().reduce((most, g) => Math.max(most, g.length), 0);
2161
+ return { added: added.map(r6).sort((a, b) => a - b), longest: r6(longest) };
1876
2162
  }
1877
2163
 
1878
2164
  /**
@@ -1895,18 +2181,36 @@ function breaksOf(seg) {
1895
2181
 
1896
2182
  /**
1897
2183
  * addedCuts: the frames where a take's framing changes, from the times of its cuts: on whole frames, in order, none
1898
- * within FRAMING_MIN_FRAMES of the one before it or of the take's two edges (`frames` long).
2184
+ * within FRAMING_MIN_FRAMES of the one before it or of the take's two edges (`frames` long). #4805: nor within
2185
+ * FRAMING_MIN_FRAMES of a jump the picture makes inside the take (`jumps`, frames), which is a cut already.
1899
2186
  */
1900
- export function framingFrames(times, frames) {
2187
+ export function framingFrames(times, frames, jumps = []) {
1901
2188
  const kept = [];
1902
2189
  for (const f of [...new Set(times.map((t) => Math.round(t * FPS)))].sort((a, b) => a - b)) {
1903
2190
  if (f < FRAMING_MIN_FRAMES || f > frames - FRAMING_MIN_FRAMES) continue;
1904
2191
  if (kept.length > 0 && f - kept.at(-1) < FRAMING_MIN_FRAMES) continue;
2192
+ if (jumps.some((j) => Math.abs(f - j) < FRAMING_MIN_FRAMES)) continue;
1905
2193
  kept.push(f);
1906
2194
  }
1907
2195
  return kept;
1908
2196
  }
1909
2197
 
2198
+ /**
2199
+ * #4805: where a take's own picture jumps (`fileJumps`, seconds on its file's clock) on the segment's clock: past the
2200
+ * pauses cut out of it before (seg.cuts, on the file's clock) and its trimmed lead-in. A jump inside a part cut out,
2201
+ * or outside the segment, is not on it.
2202
+ */
2203
+ export function takeJumpTimes(seg, fileJumps) {
2204
+ const cuts = [...(seg.cuts ?? [])].sort((a, b) => a.s - b.s);
2205
+ const out = [];
2206
+ for (const r of fileJumps) {
2207
+ if (cuts.some((c) => r >= c.s - 1e-6 && r < c.e - 1e-6)) continue;
2208
+ const t = r - cuts.reduce((sum, c) => sum + (c.e <= r + 1e-6 ? c.e - c.s : 0), 0) - (seg.inSec ?? 0);
2209
+ if (t > 1e-6 && t < seg.seconds - 1e-6) out.push(r6(t));
2210
+ }
2211
+ return out;
2212
+ }
2213
+
1910
2214
  /** addedCuts: where each script line of a talking segment is heard, [start, end] on the segment's clock, by line id. */
1911
2215
  function lineSpans(seg, scriptLines) {
1912
2216
  const lines = seg.lineIds.map((id) => scriptWords(scriptLines.get(id)?.text));
@@ -1956,8 +2260,9 @@ function lineSpans(seg, scriptLines) {
1956
2260
  * framing changes: at every cut it counts, those it held and those added. A line marked whole that its words do not
1957
2261
  * show is taken to run through the whole take, so nothing is added there. Answers the cut's note.
1958
2262
  */
1959
- function placeAddedCuts(spine, scriptLines, everySec, wholeLines) {
2263
+ function placeAddedCuts(spine, scriptLines, everySec, wholeLines, readJumps = () => []) {
1960
2264
  const whole = new Set(wholeLines);
2265
+ const jumpsOf = new Map();
1961
2266
  let count = 0;
1962
2267
  let longest = 0;
1963
2268
  for (const seg of spine) {
@@ -1966,11 +2271,18 @@ function placeAddedCuts(spine, scriptLines, everySec, wholeLines) {
1966
2271
  const held = (seg.lineIds ?? []).filter((id) => whole.has(id)).map((id) => spans.get(id) ?? [0, seg.seconds]);
1967
2272
  const breaks = breaksOf(seg);
1968
2273
  const realCuts = breaks.filter((b) => b.counts).map((b) => b.t);
1969
- const plan = addedCutPlan({ words: seg.words, seconds: seg.seconds, realCuts, joins: breaks.map((b) => b.t), everySec, whole: held });
2274
+ // #4805: a jump the video service made inside the take is a cut the viewer sees: no stretch runs across it, and no
2275
+ // framing change lands within FRAMING_MIN_FRAMES of it.
2276
+ if (!jumpsOf.has(seg.file)) jumpsOf.set(seg.file, readJumps(seg.file) ?? []);
2277
+ const jumps = takeJumpTimes(seg, jumpsOf.get(seg.file));
2278
+ const plan = addedCutPlan({
2279
+ words: seg.words, seconds: seg.seconds, realCuts: [...realCuts, ...jumps], joins: breaks.map((b) => b.t), everySec, whole: held,
2280
+ });
1970
2281
  const frames = Math.round(seg.seconds * FPS);
1971
- const framing = framingFrames([...realCuts, ...plan.added], frames);
2282
+ const jumpFrames = jumps.map((t) => Math.round(t * FPS));
2283
+ const framing = framingFrames([...realCuts, ...plan.added], frames, jumpFrames);
1972
2284
  const added = plan.added.filter((t) => framing.includes(Math.round(t * FPS)));
1973
- const edges = [0, ...framing, frames];
2285
+ const edges = [...new Set([0, ...framing, ...jumpFrames, frames])].sort((a, b) => a - b);
1974
2286
  longest = Math.max(longest, ...edges.slice(1).map((f, k) => (f - edges[k]) / FPS));
1975
2287
  // Set on every take the row reaches, even with no change, so its join with the take before it is seen to (framingAtJoins).
1976
2288
  seg.framing = framing;
@@ -2030,6 +2342,19 @@ export function framingChangeTimes(spine, speed = 1, cutaways = []) {
2030
2342
  .filter((t) => !covered.some(([from, to]) => t >= from && t <= to));
2031
2343
  }
2032
2344
 
2345
+ /**
2346
+ * #4805, pauseTrim: where a pause cut at one of Luke's levels joins a take to itself, in seconds on the delivered film's
2347
+ * clock (as framingChangeTimes), so the worker can tell a fault the trim made.
2348
+ */
2349
+ export function pauseJoinTimes(spine, speed = 1) {
2350
+ const onFilm = (sec) => Math.round((sec / speed) * FPS) / FPS;
2351
+ return spine.flatMap((seg, k) => [
2352
+ // cutPace: a take split at a pause it cut (splitAtPauses) joins its two pieces at the second one's start.
2353
+ ...(k > 0 && seg.cuts?.length && samePiece(spine[k - 1], seg) ? [onFilm(seg.startSec)] : []),
2354
+ ...(seg.cuts?.length && seg.words ? breaksOf(seg).map((b) => onFilm(seg.startSec + b.t)) : []),
2355
+ ]);
2356
+ }
2357
+
2033
2358
  /**
2034
2359
  * addedCuts: a segment's picture, `head` being its chain up to its own framing, split at `seg.framing` into pieces cut by
2035
2360
  * frame number, back to back, every other one in its other framing, and joined again with no sound: every frame is
@@ -3354,7 +3679,7 @@ export function buildTimeline(args) {
3354
3679
 
3355
3680
  function assembleTimeline({
3356
3681
  manifest, storyboard, skip, probe, exists, readWords, readLevels = () => null, stillFill = false, finish = null,
3357
- wholeVoice = null, sourceAd = null, measure = null,
3682
+ wholeVoice = null, sourceAd = null, measure = null, readJumps = () => [],
3358
3683
  }) {
3359
3684
  if (measure) {
3360
3685
  // The measured map: a word's last phoneme end rides with the word through every shift.
@@ -3725,7 +4050,7 @@ function assembleTimeline({
3725
4050
  ? "addedCuts: a cut on a template's clock or a measured map keeps its framing, so no cut was added"
3726
4051
  : !finish.wholeLines?.length
3727
4052
  ? "addedCuts: no line of the script is marked whole, so no cut was added"
3728
- : placeAddedCuts(spine, scriptLines, ADDED_CUTS[finish.addedCuts], finish.wholeLines));
4053
+ : placeAddedCuts(spine, scriptLines, ADDED_CUTS[finish.addedCuts], finish.wholeLines, readJumps));
3729
4054
  }
3730
4055
  // A copied shot no voice runs in lasts its shot's length, its clip trimmed or its last frame held.
3731
4056
  const shotOf = (n) => plans.get(n)?.sourceShot ?? null;
@@ -4346,6 +4671,10 @@ function mappedPiece(seg, i, { addInput, filters, tails, level, resolve }) {
4346
4671
  * chain and the duck under it, and `meters` (cutChecks) names the two files
4347
4672
  * the voice and everything under it are also written to. `pcmMix` keeps the
4348
4673
  * render's sound uncompressed, for a mix the loudness pass then encodes once.
4674
+ * COP-357: `look` lays the lens smudge (`smudge`, its side) and the phone pass
4675
+ * on the joined takes before anything else touches the picture, with `probe`
4676
+ * splitting them off first to LOOK_PROBE's side files, and `deliverFps`
4677
+ * repeats the finished picture's frames to that rate, last.
4349
4678
  */
4350
4679
  export function buildFfmpegArgs(timeline, { resolve, music, out, finish = null, sound = null, voiceOnly = false }) {
4351
4680
  const level = finish && finish.levelSegments === false ? "anull" : LOUDNORM;
@@ -4498,6 +4827,20 @@ export function buildFfmpegArgs(timeline, { resolve, music, out, finish = null,
4498
4827
  }
4499
4828
 
4500
4829
  let videoLabel = "vcat";
4830
+ // COP-357, the phone look: on the joined takes, before any cutaway, picture, end card or burned word is laid over them.
4831
+ // Fix A: with a picture pass, the takes are first split off to the probe, which reads them before the look.
4832
+ if (finish?.look?.probe) {
4833
+ filters.push(`[${videoLabel}]split=2[lookin][lookprobe]`, `[lookprobe]${lookProbeFilter()}`);
4834
+ videoLabel = "lookin";
4835
+ }
4836
+ if (finish?.look?.smudge) {
4837
+ filters.push(...lensSmudgeFilters(videoLabel, finish.look.smudge, "smudged"));
4838
+ videoLabel = "smudged";
4839
+ }
4840
+ if (finish?.look?.phonePass) {
4841
+ filters.push(`[${videoLabel}]${phonePassFilter()}[phoned]`);
4842
+ videoLabel = "phoned";
4843
+ }
4501
4844
  timeline.cutaways.forEach((c, j) => {
4502
4845
  const i =
4503
4846
  c.source === "clip"
@@ -4577,6 +4920,14 @@ export function buildFfmpegArgs(timeline, { resolve, music, out, finish = null,
4577
4920
  filters.push(`[${videoLabel}]subtitles=filename=${finish.ass}[burned]`);
4578
4921
  videoLabel = "burned";
4579
4922
  }
4923
+ // COP-357, fps30: the finished picture, words and all, at the delivered rate by repeated frames; the clock above is FPS.
4924
+ // #4817: it ends on exactly the frames its sound needs (deliveredFrames), its last frame repeated when the graph
4925
+ // ends a frame early, as Debian's ffmpeg 5.1 (the worker's) does after the lens smudge's maskedmerge.
4926
+ if (finish?.deliverFps) {
4927
+ const frames = deliveredFrames(pictureSec, speed, finish.deliverFps);
4928
+ filters.push(`[${videoLabel}]fps=${finish.deliverFps},tpad=stop_mode=clone:stop=-1,trim=end_frame=${frames}[delivered]`);
4929
+ videoLabel = "delivered";
4930
+ }
4580
4931
 
4581
4932
  const beds = [];
4582
4933
  if (sound?.beds?.length) {
@@ -4684,7 +5035,7 @@ export function buildFfmpegArgs(timeline, { resolve, music, out, finish = null,
4684
5035
  // COP-300: the faster sound padded or cut to the faster picture's own length, as each segment's is to its
4685
5036
  // picture's: `fps` ends the picture on round(frames / speed) frames, and atempo runs on past it. The cut can land
4686
5037
  // in a word's tail, so the last END_FADE_SAMPLES fade out, as each segment's edges do, and the end never clicks.
4687
- const end = Math.round(Math.round(pictureSec * FPS) / speed + 1e-9) * SAMPLES_PER_FRAME;
5038
+ const end = filmFrames(pictureSec, speed) * SAMPLES_PER_FRAME;
4688
5039
  filters.push(`[mix]atempo=${speed},apad,atrim=end_sample=${end},afade=t=out:ss=${end - END_FADE_SAMPLES}:ns=${END_FADE_SAMPLES}[mixfaster]`);
4689
5040
  audioLabel = "mixfaster";
4690
5041
  }
@@ -4694,7 +5045,7 @@ export function buildFfmpegArgs(timeline, { resolve, music, out, finish = null,
4694
5045
  ...inputs,
4695
5046
  "-filter_complex", filters.join(";"),
4696
5047
  "-map", `[${videoLabel}]`, "-map", `[${audioLabel}]`,
4697
- "-c:v", "libx264", "-preset", "medium", "-crf", "20", "-r", String(FPS),
5048
+ "-c:v", "libx264", "-preset", "medium", "-crf", "20", "-r", String(finish?.deliverFps ?? FPS),
4698
5049
  // COP-300: a mix the loudness pass finishes keeps its sound uncompressed, so the finished cut's sound is AAC-encoded once.
4699
5050
  ...(finish?.pcmMix ? ["-c:a", "pcm_s16le"] : ["-c:a", "aac", "-b:a", "192k"]),
4700
5051
  "-movflags", "+faststart",
@@ -5830,12 +6181,13 @@ export function checkVerdict(c, bars = CHECK_BARS) {
5830
6181
  }
5831
6182
 
5832
6183
  /** Frame-to-frame change of a file's picture, on a 90 px wide copy, printed per frame. `from`/`seconds` read a stretch. */
5833
- export function motionArgs(file, from = null, seconds = null) {
6184
+ export function motionArgs(file, from = null, seconds = null, readFps = null) {
5834
6185
  return [
5835
6186
  "-hide_banner", "-nostats",
5836
6187
  ...(from !== null ? ["-ss", sec(from)] : []), ...(seconds !== null ? ["-t", sec(seconds)] : []),
5837
6188
  "-i", file, "-an",
5838
- "-vf", "scale=90:-2,tblend=all_mode=difference,signalstats,metadata=print:key=lavfi.signalstats.YAVG:file=-",
6189
+ // COP-357: a film repeated to 30 frames a second is read back on `readFps` (FPS), its own frames, before the change.
6190
+ "-vf", `${readFps ? `fps=${readFps},` : ""}${MOTION_READ}:file=-`,
5839
6191
  "-f", "null", "-",
5840
6192
  ];
5841
6193
  }
@@ -5968,6 +6320,27 @@ export function takesOf(timeline, plans, speed = 1) {
5968
6320
  return takes.map(({ lastSeg, start, ...t }) => ({ ...t, at: start / speed, sec: t.takeSec / speed }));
5969
6321
  }
5970
6322
 
6323
+ /**
6324
+ * #4805: the frames where a picture jumps, as the flash check reads a cut: a change of a cut's size (FLASH_BARS'
6325
+ * spikeYavg, and spikeOverMedian times the median change), from readMotion's rows. Each is the time of the first frame
6326
+ * of the new picture.
6327
+ */
6328
+ export function pictureJumps(motion, bars = FLASH_BARS) {
6329
+ const values = motion.map((m) => m.y).sort((a, b) => a - b);
6330
+ const median = values.length ? values[Math.floor(values.length / 2)] : 0;
6331
+ return motion.filter((r) => r.y >= bars.spikeYavg && r.y >= median * bars.spikeOverMedian).map((r) => r.t);
6332
+ }
6333
+
6334
+ /**
6335
+ * #4805: where a clip's own picture jumps (pictureJumps), on its own clock; none when its picture cannot be read. Read
6336
+ * on the cut's own frame grid (FPS), as the flash check reads a film repeated to 30 frames a second (COP-357), so a
6337
+ * frame shown twice is never a change of its own.
6338
+ */
6339
+ function clipJumps(file) {
6340
+ const read = spawnSync("ffmpeg", motionArgs(file, null, null, FPS), { encoding: "utf8", maxBuffer: 1 << 28 });
6341
+ return read.status === 0 ? pictureJumps(readMotion(read.stdout)) : [];
6342
+ }
6343
+
5971
6344
  /**
5972
6345
  * flashCheck (P-7, Plan 13's 0.12 s piece and one-frame leaks): every shot on
5973
6346
  * screen under maxSec (a one-frame piece included), and every single frame of
@@ -5993,6 +6366,16 @@ export function flashes(shots, motion, bars = FLASH_BARS) {
5993
6366
  return out.sort((a, b) => a.at - b.at);
5994
6367
  }
5995
6368
 
6369
+ /**
6370
+ * freezeCheck's runs: the finished film's, and (COP-357, fix A) the takes' read before the look, merged; the end card,
6371
+ * which the check leaves out, is left out of both.
6372
+ */
6373
+ function cutFreezes(motion, lookRows, endCard, speed) {
6374
+ const found = freezes(motion);
6375
+ if (!lookRows) return found;
6376
+ return mergedFreezes([...found, ...freezes(endCard ? lookRows.filter((r) => r.t < endCard.in / speed) : lookRows)]);
6377
+ }
6378
+
5996
6379
  /** The power mean of some loudness windows, in dB. */
5997
6380
  const meanDb = (db) => 10 * Math.log10(db.reduce((sum, d) => sum + 10 ** (d / 10), 0) / db.length);
5998
6381
 
@@ -6242,11 +6625,11 @@ const roleOf = (seg) => (seg.reaction || seg.audio === "clip" ? "a-roll" : seg.a
6242
6625
  * slow push-in is still picture by design, so freezeCheck reads only the
6243
6626
  * picture before it.
6244
6627
  */
6245
- function checkCut({ timeline, storyboard, screens, rows, scenes, out, loudness, levels, finish = null, sourceAd = null, shotOf = () => null, cards = [], speed = 1, endCard = null }) {
6628
+ function checkCut({ timeline, storyboard, screens, rows, scenes, out, loudness, levels, finish = null, sourceAd = null, shotOf = () => null, cards = [], speed = 1, endCard = null, lookRows = null, readFps = null }) {
6246
6629
  const roles = new Map(timeline.spine.map((seg) => [seg.sceneIndex, roleOf(seg)]));
6247
6630
  for (const c of timeline.cutaways) roles.set(c.sceneIndex, "b-roll");
6248
6631
  const shots = scenes.map((p) => ({ n: p.scene, role: roles.get(p.scene) ?? "b-roll", start: p.startSec, end: roundMs(p.startSec + p.seconds) }));
6249
- const read = spawnSync("ffmpeg", motionArgs(out), { encoding: "utf8", maxBuffer: 1 << 28 });
6632
+ const read = spawnSync("ffmpeg", motionArgs(out, null, null, readFps), { encoding: "utf8", maxBuffer: 1 << 28 });
6250
6633
  const motion = read.status === 0 ? readMotion(read.stdout) : [];
6251
6634
  const finished = loudness ? { i: loudness.lufs, tp: loudness.truePeak } : measureLoudness(out);
6252
6635
  const checks = {
@@ -6260,7 +6643,7 @@ function checkCut({ timeline, storyboard, screens, rows, scenes, out, loudness,
6260
6643
  // null: ffmpeg could not read the motion, so no shot was checked.
6261
6644
  slowShots: motion.length ? slowShots(motionByShot(motion, shots)) : null,
6262
6645
  ...(finish?.blipCheck ? { blips: blips(shots.map((s) => ({ ...s, srcSec: sourceShotSec(sourceAd, shotOf(s.n)) }))) } : {}),
6263
- ...(finish?.freezeCheck ? { freezes: freezes(endCard ? motion.filter((r) => r.t < endCard.in / speed) : motion) } : {}),
6646
+ ...(finish?.freezeCheck ? { freezes: cutFreezes(endCard ? motion.filter((r) => r.t < endCard.in / speed) : motion, lookRows, endCard, speed) } : {}),
6264
6647
  ...plan14Checks({ timeline, storyboard, rows, shots, motion, out, finish, cards, speed }),
6265
6648
  lufs: finished ? round2(finished.i) : null,
6266
6649
  truePeak: finished ? round2(finished.tp) : null,
@@ -7637,6 +8020,7 @@ export function firstCut({ dir, out: outOpt, skip = new Set(), music: musicOn =
7637
8020
  return Array.isArray(rows) && rows.length > 0 ? rows : null;
7638
8021
  },
7639
8022
  readLevels: (file) => clipLevels(here(file)),
8023
+ readJumps: (file) => clipJumps(here(file)),
7640
8024
  ...(readClocks ? { measure: readClocks } : {}),
7641
8025
  ...(finish ? { finish } : {}),
7642
8026
  ...(wholeVoice ? { wholeVoice } : {}),
@@ -7673,6 +8057,8 @@ export function firstCut({ dir, out: outOpt, skip = new Set(), music: musicOn =
7673
8057
  if (finish?.cutPace && (template || protectedMotion)) notes.push("template/action/listening/ending clocks remain real time; cutPace does not accelerate the cut");
7674
8058
  // addedCuts (COP-355): the framing changes made, on the delivered film's clock, for the worker's last guard.
7675
8059
  const framingChangesSec = finish?.addedCuts ? framingChangeTimes(timeline.spine, speed, timeline.cutaways) : null;
8060
+ // #4805: the joins a pause level made, on the same clock, so the worker can make the film again without them.
8061
+ const pauseJoinsSec = finish?.pauseTrim && !finish.keepPauses ? pauseJoinTimes(timeline.spine, speed) : null;
7676
8062
  if (timeline.sourceMap) {
7677
8063
  // The exact bytes every measured clock was read from, for whoever binds an approval to them.
7678
8064
  timeline.sourceMap.sources = readClocks.files().filter(exists).map((file) => {
@@ -7810,6 +8196,40 @@ export function firstCut({ dir, out: outOpt, skip = new Set(), music: musicOn =
7810
8196
  clean = { voice: VOICE_CLEAN, under: UNDER_VOICE };
7811
8197
  }
7812
8198
  }
8199
+ // COP-357, the phone look, on a cut of its own clock only.
8200
+ let look = null;
8201
+ let deliverFps = null;
8202
+ const lookAsked = ["fps30", "lensSmudge", "phonePass"].filter((key) => finish?.[key]);
8203
+ if (lookAsked.length && (template || timeline.mapped)) {
8204
+ notes.push(`${lookAsked.join(", ")} ${lookAsked.length === 1 ? "is" : "are"} not applied to a template launch's cut or one laid on its measured map`);
8205
+ } else if (lookAsked.length) {
8206
+ if (finish.lensSmudge) {
8207
+ const missing = missingFilters(LOOK_FILTERS.lensSmudge);
8208
+ if (missing.length) notes.push(`this ffmpeg has no ${missing.join(", ")} filter, so the lens smudge was not added`);
8209
+ else {
8210
+ const frame = spineFrameAt(timeline.spine, LENS_SMUDGE.readAtSec);
8211
+ const side = frame ? brighterSide(here(frame.file), frame.atSec) : null;
8212
+ look = { smudge: side ?? "right" };
8213
+ notes.push(side
8214
+ ? `lensSmudge: a light smudge on the top ${side}, the brighter corner ${LENS_SMUDGE.readAtSec.toFixed(1)} s into the takes`
8215
+ : `lensSmudge: a light smudge on the top right; the picture ${LENS_SMUDGE.readAtSec.toFixed(1)} s into the takes could not be read for its brighter corner`);
8216
+ }
8217
+ }
8218
+ if (finish.phonePass) {
8219
+ const missing = missingFilters(LOOK_FILTERS.phonePass);
8220
+ if (missing.length) notes.push(`this ffmpeg has no ${missing.join(", ")} filter, so the phone pass was not added`);
8221
+ else {
8222
+ look = { ...look, phonePass: true };
8223
+ notes.push("phonePass: grain and a light phone pass on the takes' picture, no shake");
8224
+ }
8225
+ }
8226
+ // Fix A: a picture pass laid, so the takes are read before it too.
8227
+ if (look) look = { ...look, probe: true };
8228
+ if (finish.fps30) {
8229
+ deliverFps = DELIVERY_FPS;
8230
+ notes.push(`fps30: the film is delivered at ${DELIVERY_FPS} frames a second, one frame in four shown twice; the cut's clock stays at ${FPS}`);
8231
+ }
8232
+ }
7813
8233
  let peakLimit = null;
7814
8234
  if (finish?.limitPeaks) {
7815
8235
  if (hasFilter("alimiter")) peakLimit = PEAK_LIMIT;
@@ -7821,8 +8241,9 @@ export function firstCut({ dir, out: outOpt, skip = new Set(), music: musicOn =
7821
8241
  voice: paths.voice, bed: paths.bed,
7822
8242
  ...(manifest.templateMotion?.enabled === true || manifest.roomTone === false || finish.roomSound === "none" ? { allowAbsentBed: true } : {}),
7823
8243
  } : null;
7824
- // The burn reads its file from the folder ffmpeg runs in, so every path is absolute then.
7825
- const at = ass ? (file) => path.resolve(dir, file) : here;
8244
+ // The burn reads its file from the folder ffmpeg runs in, so every path is absolute then; so does the look's probe,
8245
+ // which writes its side files there.
8246
+ const at = ass || look ? (file) => path.resolve(dir, file) : here;
7826
8247
 
7827
8248
  const templateCut = manifest.templateMotion?.enabled === true || manifest.videoChoice?.videoModel === "template-video";
7828
8249
  const songMaster = templateCut && timeline.wholeVoice?.songOnly === true;
@@ -7969,6 +8390,7 @@ export function firstCut({ dir, out: outOpt, skip = new Set(), music: musicOn =
7969
8390
  ...(room ? { room } : {}),
7970
8391
  ...(pictures.length ? { pictures } : {}), ...(clean ? { clean } : {}), ...(meters ? { meters } : {}),
7971
8392
  ...(endLayers ? { endCard: endLayers } : {}),
8393
+ ...(look ? { look } : {}), ...(deliverFps ? { deliverFps } : {}),
7972
8394
  },
7973
8395
  }
7974
8396
  : {}),
@@ -7978,12 +8400,21 @@ export function firstCut({ dir, out: outOpt, skip = new Set(), music: musicOn =
7978
8400
  rmSync(meters.voice, { force: true });
7979
8401
  rmSync(meters.bed, { force: true });
7980
8402
  }
7981
- const res = spawnSync("ffmpeg", ffmpegArgs, { stdio: "inherit", ...(ass ? { cwd: path.resolve(dir) } : {}) });
8403
+ if (look) for (const file of [LOOK_PROBE.freeze, LOOK_PROBE.motion]) rmSync(here(file), { force: true });
8404
+ const res = spawnSync("ffmpeg", ffmpegArgs, { stdio: "inherit", ...(ass || look ? { cwd: path.resolve(dir) } : {}) });
7982
8405
  if (room?.file) rmSync(room.file, { force: true });
7983
8406
  if (res.status !== 0) {
7984
8407
  const quoted = ffmpegArgs.map((a) => (/[\s\[\];]/.test(a) ? `'${a}'` : a)).join(" ");
7985
8408
  throw new FirstCutError(1, `ffmpeg failed. The command it ran:\n ffmpeg ${quoted}`);
7986
8409
  }
8410
+ // COP-357, fix A: the takes as read before the look, on the film's clock, less what is laid over them.
8411
+ const lookProbe = look ? readLookProbe(here, {
8412
+ pictureSec, speed, covered: lookCovered({ cutaways: timeline.cutaways, pictures, endCard: endLayers }),
8413
+ }) : null;
8414
+ if (look && !lookProbe) notes.push("the takes before the look could not be read for a frozen picture, so only the finished film was checked");
8415
+ if (lookProbe && lookProbe.rowsRead < lookProbe.changes) {
8416
+ notes.push(`the takes before the look were read for ${lookProbe.rowsRead} of their ${lookProbe.changes} frame changes, so a frozen picture in them may have been missed`);
8417
+ }
7987
8418
  let meterLevels = null;
7988
8419
  if (meters) {
7989
8420
  meterLevels = { voiceLufs: measureLufs(meters.voice), bedLufs: meters.allowAbsentBed && !existsSync(meters.bed) ? null : measureLufs(meters.bed) };
@@ -8037,7 +8468,7 @@ export function firstCut({ dir, out: outOpt, skip = new Set(), music: musicOn =
8037
8468
  }
8038
8469
  writeFileSync(sidecars.scenes, `${JSON.stringify(scenes, null, 2)}\n`);
8039
8470
  const sync = finish?.captionCheck
8040
- ? cutSync({ out, speed, scenes, rows, screens: ass && burned ? burned : [], manifest, here, readJson })
8471
+ ? cutSync({ out, speed, scenes, rows, screens: ass && burned ? burned : [], manifest, here, readJson, ...(deliverFps ? { deliverFps } : {}) })
8041
8472
  : null;
8042
8473
  if (sync) writeFileSync(paths.sync, `${JSON.stringify(sync, null, 2)}\n`);
8043
8474
 
@@ -8129,6 +8560,7 @@ export function firstCut({ dir, out: outOpt, skip = new Set(), music: musicOn =
8129
8560
  ? checkCut({
8130
8561
  timeline, storyboard, screens: burned, rows, scenes, out, loudness, levels: meterLevels,
8131
8562
  finish, sourceAd, shotOf: (n) => plans?.get(n)?.sourceShot ?? null, cards: burnedCards, speed, endCard: endLayers,
8563
+ ...(lookProbe ? { lookRows: lookProbe.rows } : {}), ...(deliverFps ? { readFps: FPS } : {}),
8132
8564
  })
8133
8565
  : null;
8134
8566
  // The pace record: the cut's own numbers, the settings it was cut with (so
@@ -8159,6 +8591,9 @@ export function firstCut({ dir, out: outOpt, skip = new Set(), music: musicOn =
8159
8591
  return withSound({
8160
8592
  out, durationSec, manifest, timeline, music, rows, sidecars, pace, ...(sync ? { sync } : {}),
8161
8593
  ...(framingChangesSec ? { framingChangesSec } : {}),
8594
+ ...(pauseJoinsSec ? { pauseJoinsSec } : {}),
8595
+ // COP-357, fix A: for the worker's guard, the takes' frozen runs read before the look, on the film's clock.
8596
+ ...(lookProbe ? { lookFreeze: lookProbe.freezes } : {}),
8162
8597
  });
8163
8598
  }
8164
8599
 
@@ -8169,14 +8604,16 @@ export function firstCut({ dir, out: outOpt, skip = new Set(), music: musicOn =
8169
8604
  * The sections are the cut's takes. The captions, sections and heard words come back with the verdicts, so the
8170
8605
  * worker can judge Check B again on a listen of its own, and cut again from the heard words.
8171
8606
  */
8172
- function cutSync({ out, speed, scenes, rows, screens, manifest, here, readJson }) {
8607
+ function cutSync({ out, speed, scenes, rows, screens, manifest, here, readJson, deliverFps = null }) {
8173
8608
  const sections = [];
8174
8609
  for (const p of scenes) {
8175
8610
  const last = sections.at(-1);
8176
8611
  if (last && last.id === p.scene) last.endSec = roundMs(p.startSec + p.seconds);
8177
8612
  else sections.push({ id: p.scene, startSec: p.startSec, endSec: roundMs(p.startSec + p.seconds) });
8178
8613
  }
8179
- const captions = screens.map((c) => ({ text: c.text, seenSec: roundMs(captionSeenSec(captionStartCs(c.s / speed))) }));
8614
+ // COP-357: a film repeated to deliverFps shows each caption on the delivered frame that first holds its 24 fps frame.
8615
+ const seenOn = (t) => (deliverFps ? deliveredSeenSec(t, deliverFps) : t);
8616
+ const captions = screens.map((c) => ({ text: c.text, seenSec: roundMs(seenOn(captionSeenSec(captionStartCs(c.s / speed)))) }));
8180
8617
  const takes = (manifest.scenes ?? []).flatMap((scene) => {
8181
8618
  const file = scene.wordsFrom === "voice" ? scene.voice : scene.clip;
8182
8619
  const words = readJson(scene.words);
@@ -97,6 +97,10 @@ export interface CustomerRun {
97
97
  estimateUsd: number | null;
98
98
  final: boolean;
99
99
  line: string;
100
+ storyboardEstimate?: {
101
+ usd: number;
102
+ sentence: string;
103
+ };
100
104
  };
101
105
  spendAsk?: {
102
106
  sentence: string;
@@ -283,7 +283,7 @@ export function customerStatusLines(run, dashboardUrl) {
283
283
  run.mode === "guided" ? "Storyboard first" : "In one go",
284
284
  "",
285
285
  ...customerStageLines(run, page),
286
- ...(run.spend ? [run.spend.line] : []),
286
+ ...(run.spend ? [run.spend.line, ...(run.spend.storyboardEstimate ? [run.spend.storyboardEstimate.sentence] : [])] : []),
287
287
  ...spendAskLines(run, run.runId),
288
288
  ...(run.scenes ?? []).flatMap(scene => scene.clip?.speech
289
289
  ? [`Scene ${scene.sceneIndex} speech:`, ...speechSummaryLines(scene.clip.speech).map(line => ` ${line}`)] : []),
@@ -4273,23 +4273,14 @@ export async function statusFlow(runId, json, deps) {
4273
4273
  lines.push(` picture: ${row.frame.lastRedo.label}`);
4274
4274
  for (const found of row.clip?.findings ?? []) {
4275
4275
  const finding = choiceMade(row.clip) ? { ...found, detail: heldChoiceMade(found.detail) } : found;
4276
- if (ONE_TAKE_PLAIN_FINDING_CODES.includes(finding.code)) {
4277
- if (finding.code === ONE_TAKE_LABEL_ALL_FLIPPED_CODE) {
4278
- if (allFlippedSaid)
4279
- continue;
4280
- allFlippedSaid = true;
4281
- }
4282
- lines.push(` ${finding.detail}`);
4283
- continue;
4284
- }
4285
- lines.push(` ${finding.code} (${finding.severity}): ${finding.detail}`);
4286
- const judgeSeverity = finding.judgeSeverity ?? finding.severity;
4287
- if (finding.judgeDetail) {
4288
- lines.push(` checker said (${judgeSeverity}): ${finding.judgeDetail}`);
4289
- }
4290
- else if (judgeSeverity !== finding.severity) {
4291
- lines.push(` checker rated it ${judgeSeverity}`);
4276
+ if (finding.code === ONE_TAKE_LABEL_ALL_FLIPPED_CODE) {
4277
+ if (allFlippedSaid)
4278
+ continue;
4279
+ allFlippedSaid = true;
4292
4280
  }
4281
+ lines.push(` ${finding.detail}`);
4282
+ if (finding.judgeDetail)
4283
+ lines.push(` checker said: ${finding.judgeDetail}`);
4293
4284
  }
4294
4285
  if (row.clip?.error)
4295
4286
  lines.push(` ${row.clip.error}`);
@@ -4309,7 +4300,7 @@ export async function statusFlow(runId, json, deps) {
4309
4300
  lines.push(" word timings: measured on the original voice (close, not frame-exact)");
4310
4301
  }
4311
4302
  for (const finding of row.frame?.findings ?? []) {
4312
- lines.push(` picture: ${finding.code} (${finding.severity}): ${finding.detail}`);
4303
+ lines.push(` picture: ${finding.detail}`);
4313
4304
  }
4314
4305
  }
4315
4306
  if (outputsOfNodeKind(run, "voiceover").some(isNarrationMaster)) {
@@ -4368,7 +4359,6 @@ export const ONE_TAKE_HEARD_AS_CODE = "one-take-words-heard-as";
4368
4359
  export const ONE_TAKE_LABEL_CODES = ["one-take-label-flipped", "one-take-label-unsure", "one-take-label-held", "one-take-label-flipped-all"];
4369
4360
  const ONE_TAKE_LABEL_ALL_FLIPPED_CODE = "one-take-label-flipped-all";
4370
4361
  export const ONE_TAKE_SAID_WRONG_CODES = ["one-take-said-wrong", "one-take-second-listen-failed"];
4371
- const ONE_TAKE_PLAIN_FINDING_CODES = [ONE_TAKE_HEARD_AS_CODE, ...ONE_TAKE_LABEL_CODES, ...ONE_TAKE_SAID_WRONG_CODES];
4372
4362
  const DIRECTOR_STATUS_WORDS = {
4373
4363
  reviewing: "Watching this run",
4374
4364
  waiting: "Waiting for redos to finish",
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@aicopycoders/exodus",
3
- "version": "2026.11.1200-beta.24",
3
+ "version": "2026.11.1200-beta.26",
4
4
  "description": "CLI + Claude Code skills for the Copycoders Exodus ad pipeline",
5
5
  "repository": {
6
6
  "type": "git",