@clipwright/core 0.41.0 → 0.42.0

package/dist/workflows/reference-remake.d.ts

@@ -950,6 +950,11 @@ export declare const planReferenceRemake: z.ZodObject<{
             cover_words: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strict>>>;
     }, z.core.$strict>>;
+    cast: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        asset_id: z.ZodString;
+        role: z.ZodString;
+        action: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
 }, z.core.$strict>;
 /** What a client sends (#1172): the profile, or the analysis_id of an analysis the server reads it from. */
 export declare const planReferenceRemakeRequest: z.ZodObject<{
@@ -1084,6 +1089,11 @@ export declare const planReferenceRemakeRequest: z.ZodObject<{
             cover_words: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strict>>>;
     }, z.core.$strict>>;
+    cast: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        asset_id: z.ZodString;
+        role: z.ZodString;
+        action: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
     reference_profile: z.ZodOptional<z.ZodObject<{
         version: z.ZodLiteral<"reference-profile-v1">;
         source: z.ZodObject<{
@@ -1928,9 +1938,11 @@ export type ReferenceSpanPlanner = (input: {
 }) => ReferenceSpan[];
 type ReferenceGraphic = ReferenceProfile['beats'][number]['graphics'][number];
 /** What the asset library says of a request's asset (#1170): the server reads it, a direct compile may pass none. */
+/** `seconds`: a video asset's measured length, which caps the words its clip covers. */
 export type ReferenceAssetFacts = ReadonlyMap<string, {
     name: string;
     role?: string;
+    seconds?: number;
 }>;
 /** The analysis's name for a graphic in its gap list: its device, else its own kind. */
 export declare const sceneGapWhat: (graphic: ReferenceGraphic) => string;

package/dist/workflows/reference-remake.js

@@ -4,14 +4,15 @@ import { assetId } from '../asset-identity.js';
 import { captionLanguageOf } from '../caption-language.js';
 import { LONG_FORM_QUALIFICATION_MAX_DURATION_SEC } from '../long-form-profile.js';
 import { CANVAS_FPS } from '../media-timebase.js';
-import { estimateDurationSec, WORDS_PER_SECOND_MAX } from '../pacing.js';
+import { estimateDurationSec, WORDS_PER_SECOND_MAX, WORDS_PER_SECOND_MIN } from '../pacing.js';
 import { referenceAnalysisId } from '../reference-analysis.js';
 import { actorIdScope } from '../account-actors.js';
 import { referenceProfileInput } from '../reference-profile.js';
 import { narrationPaceFromVoice, PAUSE_TRIM_CEILING_S, pauseTrimFromVoice } from '../reference-voice.js';
 import { AD_PAUSE_TRIM } from '../ad-pause-trim.js';
 import { countActorShots, coverWordOf, lexicalTokens, planSemanticInserts, quoteOccurrences } from '../semantic-inserts.js';
-import { actorId, callStage, insertBox, isNarratedUgcInput, makeUgcInput, makeUgcInputShape, MAX_INSERTS, MAX_LIVE_SHOTS, MAX_NARRATED_ACTOR_SHOTS, motionStyle, ugcCall, ugcTemplate } from '../skills.js';
+import { actorId, callStage, insertBox, isNarratedUgcInput, makeUgcInput, makeUgcInputShape, MAX_INSERTS, MAX_LIVE_SHOTS, MAX_NARRATED_ACTOR_SHOTS, MAX_PRESENTER_TAKES, MAX_SHOT_CAST, motionStyle, ugcCall, ugcLiveShotCastMember, ugcTemplate } from '../skills.js';
+import { ugcMarkedComponentsRefusal } from '../presenter-takes.js';
 import { CALL_PHONE_DEFAULTS, CALL_STAGE_SIDES } from '../ugc-call.js';
 import { MAX_TEMPLATES, TEMPLATE_ENTER_FRAMES, TEMPLATE_KIND_IDS, TEMPLATE_KINDS, TEMPLATE_PLACEMENTS, templateFaceWarnings, templateMediaOf, templateTextRefusal } from '../templates/index.js';
 import { MAX_SCENES, SCENE_TEXT_MAX_CHARS } from '../ugc-scenes.js';
@@ -62,6 +63,10 @@ const remakeFields = {
         'on screen; true: every beat where they speak or react on screen; false: none. Costs more than the usual take: each shot kind has its own ' +
         'presenter-second price in list_prices, shown on the plan\'s quote.'),
     motion_style: motionStyle.optional().describe('As make_ugc motion_style; spans sit on the script\'s words. Free.'),
+    cast: z.array(ugcLiveShotCastMember).min(1).max(MAX_SHOT_CAST)
+        .refine(cast => new Set(cast.map(person => person.asset_id)).size === cast.length, { message: 'each cast picture appears once' }).optional()
+        .describe(`Up to ${MAX_SHOT_CAST} more people beside the actor in every acting live shot, as make_ugc shots cast: a picture, a role and ` +
+        'what they do. Without an acting live shot the plan names it undrawn.'),
 };
 const revisionPair = (value, context) => {
     if ((value.plan_id === undefined) !== (value.base_version === undefined)) {
@@ -124,6 +129,8 @@ function shotFramingOf(size, take) {
 }
 /** A layer sits under the captions when its top is at most this share of the height below them and its centre this share of the width off theirs. */
 const UNDER_CAPTIONS = 0.03;
+/** A full-frame picture or card the reference showed this long or less was flashed, not held (#1196). */
+const FLASH_HOLD_S = 1.2;
 /** With no caption box measured, a centred layer whose top lies this far below where top-anchored captions start: a line to a short block. */
 const UNMEASURED_CAPTIONS_BELOW = [0.03, 0.15];
 /** The cuts a hook's live shot may take of ours, flash first: both are pictures only, so none adds a sound the customer did not ask for. */
@@ -554,6 +561,15 @@ export function compileReferenceRemake(input, capabilities, planSpans = proporti
         gaps.fitted.push(beat);
         return { fit: 'auto', ...(box ? { box } : {}) };
     };
+    /** A full-frame picture or card the reference only flashed covers the words its measured time takes at our pace, from the beat's first;
+     *  the presenter or the next shot says the rest (#1196). */
+    const flashed = (element, span) => {
+        const shown = element?.entry?.first_visible_s, gone = element?.exit?.last_visible_s;
+        if (shown === undefined || gone === undefined || gone - shown > FLASH_HOLD_S)
+            return {};
+        const found = quote(span.start, Math.max(1, Math.ceil((gone - shown) / (duration / words.length))), span.end);
+        return found && found.end < span.end ? { anchor: found.anchor, cover_words: found.end - found.start } : {};
+    };
     const spans = planSpans({ profile, words });
     const beatAt = (word) => Math.max(0, spans.findIndex(span => span !== null && word >= span.start && word < span.end));
     /** The first script words a quote of the request names, on the beat holding them. */
@@ -776,7 +792,7 @@ export function compileReferenceRemake(input, capabilities, planSpans = proporti
                 push(field === 'overlays' ? { ...item, position: placed }
                     : screen ? { ...item, ...screenSplitOf(measured, graphic.position, index) }
                         : field === 'layout_windows' ? { ...item, layout: 'split', ...(measured ? splitOf(measured, index, media) : {}) }
-                            : { ...item, ...insertFrameOf(measured, asset.media_type, index, media) });
+                            : { ...item, ...insertFrameOf(measured, asset.media_type, index, media), ...(field === 'inserts' ? flashed(measured, span) : {}) });
                 layered = true;
                 fullFrame ||= field === 'inserts';
                 windowed ||= field === 'layout_windows';
@@ -806,6 +822,8 @@ export function compileReferenceRemake(input, capabilities, planSpans = proporti
                 ...(built.placement ? { placement: built.placement } : {}), data: built.data };
             // A measured box over the presenter takes the template whole, drawn as its kind draws with no place of its own (#973 S4, S5).
             const element = elementOf(index, beat.graphics.indexOf(graphic)), definition = TEMPLATE_KINDS.find(entry => entry.kind === built.kind);
+            if ((built.placement ?? definition?.placements[0]) === 'full' && !definition?.quotes && !definition?.spreads)
+                Object.assign(item, flashed(element, span));
             const { position: _place, ...unplaced } = built.data, own = definition?.data.safeParse(unplaced);
             const staged = element && own?.success && (built.placement ?? definition.placements[0]) === 'over'
                 ? stagedPlace(element, definition.rect(own.data, DEFAULT_ASPECT_RATIO, undefined, framing)) : undefined;
@@ -1289,10 +1307,11 @@ export function compileReferenceRemake(input, capabilities, planSpans = proporti
         const action = [...new Set([...beat.gestures ?? []].sort((a, b) => a.at_s - b.at_s).flatMap(entry => GESTURE_ACTIONS[entry.kind] ?? []))].join(', then ');
         const acted = beat.presenter_behaviour === 'reacting' || !!action;
         const wider = shotFramingOf(beat.shot_size, framing);
+        // The request's cast stands beside the actor in every acting shot (#1192): those shots share one setup, so one cast.
         const shot = { id: `ref-${index + 1}-shot`, anchor: { startWord: span.start, endWord: span.end },
             ...beat.presenter_behaviour === 'reacting' ? { kind: 'action', action: action || REACTION }
                 : action ? { kind: 'talking_action', action } : { kind: 'talking' },
-            ...acted && wider ? { framing: wider } : {} };
+            ...acted && wider ? { framing: wider } : {}, ...acted && request.cast ? { cast: request.cast } : {} };
         return [{ beat: index, words: span.end - span.start, shot }];
     });
     const kept = new Set([...wanted].sort((a, b) => b.words - a.words || a.beat - b.beat).slice(0, MAX_LIVE_SHOTS));
@@ -1386,6 +1405,23 @@ export function compileReferenceRemake(input, capabilities, planSpans = proporti
         note(0, `captions at the reference's ${referenceAt} height (there they would cover the presenter's face)`, captionPosition !== referenceAt
             ? `${captionPosition} captions, clear of the face` : byCaptions ? 'kept there: graphics stand by the captions' : 'kept there: no caption height is clear of the face');
     }
+    // A clip shorter than its words would freeze on its last frame: it covers only the words it outlasts at the slowest pace, and the presenter
+    // says the rest (#1198). A fit that leaves the run more presenter shots than it renders is undone first, below.
+    const fitted = new Map();
+    for (const layer of layers.filter(entry => entry.field === 'inserts')) {
+        const item = layer.item;
+        const seconds = item.media_type === 'video' && item.asset_id ? facts?.get(item.asset_id)?.seconds : undefined;
+        const range = seconds === undefined ? undefined : layerWordRange(tokens, item);
+        if (seconds === undefined || range === undefined || typeof range === 'string')
+            continue;
+        const most = Math.floor(seconds * WORDS_PER_SECOND_MIN + 1e-9), short = range.coverWord - range.startWord > most
+            ? quote(range.startWord, most, range.startWord + most) : undefined;
+        if (!short)
+            continue;
+        fitted.set(layer, { item, line: `the clip on "${'quote' in item.anchor ? item.anchor.quote : short.anchor.quote}" covers its first ` +
+                `${short.end - short.start} words, as long as it runs, so it never freezes; the presenter says the rest` });
+        layer.item = { ...item, anchor: short.anchor, cover_words: short.end - short.start };
+    }
     let native = {}, marked = false;
     // Every pass that does not break drops one layer or adds the one marker, so the loop ends.
     for (;;) {
@@ -1432,13 +1468,26 @@ export function compileReferenceRemake(input, capabilities, planSpans = proporti
                 continue;
             }
             // A move the run refuses goes before the layer does: the refused layer's own, else one on a layer the refusal names.
-            const moved = [dropped, ...moves.keys()].find(layer => moves.has(layer) && (layer === dropped || issue.message.includes(`"${layer.item.id}"`)));
+            // A refusal of a transition takes only the transition it names: the refused layer's own, or the cited layer's "whose …" (#1198 item 7).
+            const passing = /would show (a hidden presenter frame|the presenter between)/.test(issue.message);
+            const blamed = (layer) => {
+                const { keys } = moves.get(layer), id = layer.item.id;
+                if (!passing)
+                    return layer === dropped || issue.message.includes(`"${id}"`) ? keys : [];
+                return keys.includes('transition') && (layer === dropped ? issue.message.includes(' has a ') : issue.message.includes(`"${id}", whose `))
+                    ? ['transition'] : [];
+            };
+            const moved = [dropped, ...moves.keys()].find(layer => moves.has(layer) && blamed(layer).length > 0);
             if (moved) {
-                const { keys } = moves.get(moved), item = { ...moved.item };
+                const entry = moves.get(moved), keys = blamed(moved), item = { ...moved.item };
                 for (const key of keys)
                     delete item[key];
                 moved.item = item;
-                moves.delete(moved);
+                const left = entry.keys.filter(key => !keys.includes(key));
+                if (left.length)
+                    moves.set(moved, { keys: left, added: entry.added.filter(line => line.key === undefined || left.includes(line.key)) });
+                else
+                    moves.delete(moved);
                 note(moved.beat, `${moved.kind}: its ${keys.map(key => key.replace('_', ' ')).join(' and ')} (${issue.message})`, keys.map(key => key === 'transition' ? 'a cut' : 'a still picture').join(' and '));
                 continue;
             }
@@ -1462,6 +1511,12 @@ export function compileReferenceRemake(input, capabilities, planSpans = proporti
         })) : undefined;
         const shots = plan ? countActorShots(plan) : 1;
         if (plan && (shots === 0 || shots > MAX_NARRATED_ACTOR_SHOTS)) {
+            const undo = [...fitted.keys()].filter(layer => layers.includes(layer)).at(-1);
+            if (undo) {
+                undo.item = fitted.get(undo).item;
+                fitted.delete(undo);
+                continue;
+            }
             const layerOf = (entry) => inserts.find(layer => layer.item.id === entry.insertId);
             const candidates = plan.inserts.filter(entry => !requested.has(layerOf(entry)));
             if (!candidates.length) {
@@ -1474,6 +1529,38 @@ export function compileReferenceRemake(input, capabilities, planSpans = proporti
             note(dropped.beat, `${dropped.kind} (inserts leave ${shots} actor appearances; a run renders 1 to ${MAX_NARRATED_ACTOR_SHOTS})`, 'left out; the presenter speaks these words');
             continue;
         }
+        // The quote's take budget (#1197), so the plan is never refused at quote: past it a live shot goes, the one on the fewest words first;
+        // with no shot left, a picture the plan placed itself; with only the request's own pictures left, the compile is refused in the quote's words.
+        const overBudget = ugcMarkedComponentsRefusal(checked.data, executor?.field_dispositions.visible_ai_label === 'implemented');
+        if (overBudget) {
+            const wordsOf = (layer) => { const range = rangeOf(layer); return range ? range.coverWord - range.startWord : 0; };
+            const fewest = (candidates) => candidates.reduce((best, layer) => wordsOf(layer) < wordsOf(best) ? layer : best);
+            const shotLayers = layers.filter(layer => layer.field === 'shots');
+            if (shotLayers.length) {
+                const shot = fewest(shotLayers);
+                layers.splice(layers.indexOf(shot), 1);
+                moves.delete(shot);
+                note(shot.beat, `a live shot on this beat (with it the video makes more presenter takes than the ${MAX_PRESENTER_TAKES} one video ` +
+                    'renders, or more than it holds beside your pictures; the shortest shots go first)', 'the presenter\'s usual take');
+                continue;
+            }
+            const pictures = layers.filter(layer => ['inserts', 'overlays', 'layout_windows'].includes(layer.field)
+                || (layer.field === 'templates' && templateMediaOf([layer.item]).length > 0));
+            const placed = pictures.filter(layer => !requested.has(layer));
+            if (!placed.length) {
+                return { kind: 'invalid', issues: [{ kind: 'invalid_request', path: pictures.map(layer => requested.get(layer)).find(Boolean) ?? 'assets',
+                            message: overBudget }] };
+            }
+            const picture = fewest(placed);
+            for (const gone of ours.get(picture) ?? [picture])
+                if (layers.includes(gone)) {
+                    layers.splice(layers.indexOf(gone), 1);
+                    moves.delete(gone);
+                    ours.delete(gone);
+                }
+            note(picture.beat, `${picture.kind} (${overBudget})`, 'left out; the presenter speaks these words');
+            continue;
+        }
         // A remake bills on the long-form tariff: with nothing else narrated, a medium framing (scale 1) over the whole script makes it so.
         const lead = longForm && !marked && !isNarratedUgcInput(native) ? quote(0, 6, words.length) : undefined;
         if (lead) {
@@ -1483,6 +1570,9 @@ export function compileReferenceRemake(input, capabilities, planSpans = proporti
         }
         break;
     }
+    if (request.cast && !layers.some(layer => layer.field === 'shots' && layer.item.cast)) {
+        note(0, `your cast (${request.cast.map(person => person.role).join(', ')})`, 'not drawn: the plan has no acting live shot, where the reference presenter gestures or reacts');
+    }
     const sounded = [...new Set(motion.sounded)].map(beat => beat + 1).join(', ');
     if ((motion.sounded.length || request.edit_sounds === true) && !native.edit_sounds) {
         note(motion.sounded[0] ?? 0, motion.sounded.length ? `the whoosh and click sounds on beats ${sounded}` : 'edit_sounds, a sound on every cut', !soundsOn ? (request.edit_sounds !== true ? 'none' : longForm ? 'none: edit_sounds is not available on this server' : 'none: edit_sounds needs a long-form run')
@@ -1490,6 +1580,7 @@ export function compileReferenceRemake(input, capabilities, planSpans = proporti
                 : 'none unless you ask: compile again with edit_sounds: true for a sound on every cut');
     }
     const added = [...layers.flatMap(layer => moves.get(layer)?.added ?? []).sort((a, b) => a.beat_index - b.beat_index).map(entry => entry.what),
+        ...[...fitted].filter(([layer]) => layers.includes(layer)).map(([, fit]) => fit.line),
         ...native.edit_sounds ? [`a sound on every cut, as you asked${motion.sounded.length ? `; the reference has a whoosh or a click on beats ${sounded}` : ''}`] : [],
         ...native.music ? [`music under the voice, as you asked${music >= 0 ? '; the reference has a music bed' : ''}`] : [],
         ...native.shots ? [`live shots of the presenter on beats ${beatsOf(layers.filter(layer => layer.field === 'shots').map(layer => layer.beat))}, as you asked; ` +