videobook 0.0.0-stage → 0.1.0

package/dist/frame-utils.js

@@ -0,0 +1,27 @@
+export function sampleEvenly(items, maxSamples) {
+    if (maxSamples <= 0)
+        return [];
+    if (items.length <= maxSamples)
+        return items;
+    if (maxSamples === 1)
+        return [items[0]];
+    const sampleStep = (items.length - 1) / (maxSamples - 1);
+    return Array.from({ length: maxSamples }, (_, index) => items[Math.round(index * sampleStep)]);
+}
+function calculateFrameSampleCount(durationSeconds) {
+    const sampleIntervalSeconds = durationSeconds <= 10 ? 2 : 5;
+    const sampleCount = Math.floor(durationSeconds / sampleIntervalSeconds);
+    return Math.max(3, Math.min(30, sampleCount));
+}
+export function formatTimestamp(t) {
+    return t.toFixed(2);
+}
+export function generateTimestamps(durationSeconds) {
+    if (!Number.isFinite(durationSeconds) || durationSeconds <= 0)
+        return [];
+    const sampleCount = calculateFrameSampleCount(durationSeconds);
+    const endMarginSeconds = Math.min(0.1, durationSeconds / sampleCount);
+    const lastTimestampSeconds = durationSeconds - endMarginSeconds;
+    const sampleStepSeconds = lastTimestampSeconds / (sampleCount - 1);
+    return Array.from({ length: sampleCount }, (_, index) => sampleStepSeconds * index);
+}

package/dist/generation-credit-error.js

@@ -0,0 +1,11 @@
+export function isGenerationCreditError(error) {
+    if (!error)
+        return false;
+    const message = error.toLowerCase().replaceAll(/[_-]+/g, " ");
+    return /\b(?:out of|insufficient|not enough|no(?: remaining| more| available)?) credits?\b/.test(message)
+        || /\bcredits? (?:balance )?(?:is |are )?(?:insufficient|exhausted|depleted|too low)\b/.test(message)
+        || /\b(?:insufficient|not enough|low|exhausted) (?:account |credit )?balance\b/.test(message)
+        || /\b(?:account |credit )?balance (?:is )?(?:insufficient|too low|exhausted)\b/.test(message)
+        || /\binsufficient quota\b/.test(message)
+        || /\b(?:exceeds? (?:your|the) (?:remaining |available )?credits?|credits? (?:left|remaining).{0,100}(?:required|requested|needed))\b/.test(message);
+}

package/dist/generation-input-mentions.js

@@ -0,0 +1,117 @@
+// Generation prompts name their media by input slot, never by grid square:
+// "@image1" is the first connected image input, whatever square it sits in, so
+// moving cells around the grid leaves the prompt untouched. The numbering is
+// the order the server hands media to the provider (image_refs, video_refs,
+// audio_refs), so "@image2" in the prompt and "reference image 2" in the
+// payload always mean the same asset. Frame inputs ride their own params and
+// get their own tokens.
+//
+// Pure and dependency-free: the client imports it for the autocomplete menu
+// and the input cards, the server for prompt resolution.
+const FRAME_TOKENS = {
+    first_frame: "firstframe",
+    last_frame: "lastframe",
+};
+// Inputs that feed a dedicated provider param and cannot be named inline.
+const UNNAMED_TARGET_INPUTS = new Set(["replace_audio"]);
+const KIND_ORDER = ["image", "video", "audio"];
+function generationInputMediaKind(cellType) {
+    if (cellType === "image" || cellType === "generate_image")
+        return "image";
+    if (cellType === "audio"
+        || cellType === "extract_audio"
+        || cellType === "generate_audio")
+        return "audio";
+    if (cellType === "video"
+        || cellType === "split_video"
+        || cellType === "generate_video"
+        || cellType === "concat"
+        || cellType === "splice")
+        return "video";
+    return null;
+}
+function numberedKindSlotIndex(targetInput, kind) {
+    if (targetInput === kind)
+        return 1;
+    const prefix = `${kind}_`;
+    if (!targetInput.startsWith(prefix))
+        return null;
+    const suffix = targetInput.slice(prefix.length);
+    if (!/^\d+$/.test(suffix))
+        return null;
+    return Number(suffix);
+}
+/** Stable sort by numbered slot ("image", "image_2", …); unnumbered last. */
+export function sortByKindSlot(entries, kind) {
+    return [...entries].sort((left, right) => {
+        const leftIndex = numberedKindSlotIndex(left.targetInput, kind)
+            ?? Number.MAX_SAFE_INTEGER;
+        const rightIndex = numberedKindSlotIndex(right.targetInput, kind)
+            ?? Number.MAX_SAFE_INTEGER;
+        return leftIndex - rightIndex;
+    });
+}
+function connectedInputs(cellId, cells, edges) {
+    const cellsById = new Map(cells.map((cell) => [cell.id, cell]));
+    return edges.flatMap((edge) => {
+        if (edge.target !== cellId)
+            return [];
+        const source = cellsById.get(edge.source);
+        const kind = source ? generationInputMediaKind(source.type) : null;
+        return kind
+            ? [{ kind, sourceCellId: edge.source, targetInput: edge.targetInput }]
+            : [];
+    });
+}
+function frameMentions(inputs) {
+    return Object.entries(FRAME_TOKENS).flatMap(([targetInput, token]) => {
+        const input = inputs.find((candidate) => candidate.kind === "image" && candidate.targetInput === targetInput);
+        return input ? [{ ...input, token }] : [];
+    });
+}
+function numberedMentions(inputs, kind, modeId) {
+    const named = inputs.filter((input) => input.kind === kind
+        && !(modeId !== "r2v" && kind === "image" && input.targetInput in FRAME_TOKENS)
+        && !UNNAMED_TARGET_INPUTS.has(input.targetInput));
+    return sortByKindSlot(named, kind).map((input, index) => ({
+        ...input,
+        token: `${kind}${index + 1}`,
+    }));
+}
+/** Every prompt-nameable input of a generation cell, in provider order. */
+export function generationInputMentions(cellId, cells, edges, modeId) {
+    const configuredMode = cells.find((cell) => cell.id === cellId)?.inputs?.generationMode;
+    const effectiveMode = modeId ?? configuredMode;
+    const inputs = connectedInputs(cellId, cells, edges);
+    return [
+        ...(effectiveMode === "r2v" ? [] : frameMentions(inputs)),
+        ...KIND_ORDER.flatMap((kind) => numberedMentions(inputs, kind, typeof effectiveMode === "string" ? effectiveMode : undefined)),
+    ];
+}
+export function remapGenerationInputPrompt(prompt, previous, next) {
+    const used = new Set([...previous, ...next].map((mention) => mention.token));
+    const replacements = new Map(previous.map((before) => {
+        const after = next.find((candidate) => candidate.sourceCellId === before.sourceCellId
+            && candidate.targetInput === before.targetInput)
+            ?? next.find((candidate) => candidate.targetInput === before.targetInput);
+        if (after)
+            return [before.token, after.token];
+        if (!next.some((candidate) => candidate.token === before.token))
+            return [before.token, before.token];
+        let index = 1;
+        while (used.has(`${before.kind}${index}`))
+            index += 1;
+        const missing = `${before.kind}${index}`;
+        used.add(missing);
+        return [before.token, missing];
+    }));
+    return prompt.replace(/@((?:image|video|audio)\d+|firstframe|lastframe)(?![\w-])/giu, (match, token) => {
+        const replacement = replacements.get(token.toLowerCase());
+        return replacement && replacement !== token.toLowerCase() ? `@${replacement}` : match;
+    });
+}
+/** "@image1"-style tokens in a prompt, lower-cased and without the "@". */
+export function scanGenerationInputTokens(prompt) {
+    return [...prompt.matchAll(/@((?:image|video|audio)\d+|firstframe|lastframe)(?![\w-])/giu)]
+        .map((match) => match[1].toLowerCase());
+}

package/dist/generation-input-policy.js

@@ -0,0 +1,68 @@
+export function generationModeInputTarget(modeId, kind, target) {
+    return modeId === "r2v" && kind === "image"
+        && (target === "first_frame" || target === "last_frame")
+        ? "image"
+        : target;
+}
+function modeInputs(mode, inputs) {
+    const normalized = inputs.map((input) => ({
+        ...input,
+        target: generationModeInputTarget(mode.id, input.kind, input.target),
+    }));
+    if (mode.id !== "i2v" || mode.slots.some((slot) => slot.targets.includes("image"))) {
+        return normalized;
+    }
+    const available = mode.slots.flatMap((slot) => slot.targets)
+        .filter((target) => target === "first_frame" || target === "last_frame")
+        .filter((target) => !inputs.some((input) => input.target === target));
+    let index = 0;
+    return normalized.map((input) => {
+        if (input.kind !== "image" || input.target !== "image")
+            return input;
+        const target = available[index++];
+        return target ? { ...input, target } : input;
+    });
+}
+function inputLabel(target) {
+    if (target === "replace_audio")
+        return "replacement audio";
+    if (target === "first_frame")
+        return "first frame";
+    if (target === "last_frame")
+        return "last frame";
+    return `${target} reference`;
+}
+export function generationModeInputError(mode, inputs) {
+    const name = mode.id === "default" || mode.id === "text" ? "this model" : mode.id.toUpperCase();
+    const subject = name === "this model" ? "This model" : name;
+    const counts = new Map(mode.slots.map((slot) => [slot.field, 0]));
+    const sorted = modeInputs(mode, inputs).sort((left, right) => Number(right.target !== right.kind) - Number(left.target !== left.kind));
+    for (const input of sorted) {
+        const matching = mode.slots.filter((slot) => slot.kind === input.kind && slot.targets.includes(input.target));
+        if (matching.length === 0) {
+            return `${subject} does not accept ${inputLabel(input.target)} inputs. Change the type or remove that input.`;
+        }
+        const available = matching.filter((slot) => slot.max === null || (counts.get(slot.field) ?? 0) < slot.max)
+            .sort((left, right) => {
+            const leftRequired = Number((counts.get(left.field) ?? 0) < left.min);
+            const rightRequired = Number((counts.get(right.field) ?? 0) < right.min);
+            return rightRequired - leftRequired || left.targets.length - right.targets.length;
+        });
+        const slot = available[0];
+        if (!slot) {
+            const maximum = matching.reduce((total, candidate) => total + (candidate.max ?? 0), 0);
+            return `${subject} accepts at most ${maximum} ${inputLabel(input.target)} input${maximum === 1 ? "" : "s"}. Remove an input or change the model.`;
+        }
+        counts.set(slot.field, (counts.get(slot.field) ?? 0) + 1);
+    }
+    const missing = mode.slots.find((slot) => (counts.get(slot.field) ?? 0) < slot.min);
+    if (missing) {
+        return `Add at least ${missing.min} ${inputLabel(missing.targets[0] ?? missing.kind)} input${missing.min === 1 ? "" : "s"} for ${name}.`;
+    }
+    const group = mode.requiredGroups.find((fields) => !fields.some((field) => (counts.get(field) ?? 0) > 0));
+    if (!group)
+        return null;
+    const labels = [...new Set(mode.slots.filter((slot) => group.includes(slot.field))
+            .flatMap((slot) => slot.targets).map(inputLabel))];
+    return `Add at least one ${labels.join(" or ")} input for ${name}.`;
+}

package/dist/generation-reference-mentions.js

@@ -0,0 +1,97 @@
+import { normalizeNotebookReference, replaceNotebookMentions, stripNotebookMentions, } from "videobook-engine/notebook-mentions";
+function refMentionEntries(refs) {
+    return refs
+        .map((raw, index) => ({
+        ref: normalizeNotebookReference(raw),
+        index,
+    }))
+        .filter((e) => e.ref !== "")
+        .sort((a, b) => b.ref.length - a.ref.length);
+}
+/** Remove "@<ref>" mentions that have no inline marker form (reference video
+ *  clips, first frames) — the asset still rides its body param. */
+export function stripRefMentions(prompt, refs) {
+    return stripNotebookMentions(prompt, refMentionEntries(refs).map(({ ref }) => ref));
+}
+/** Replace "@<ref>" mentions with natural-language noun phrases for Kie
+ *  happyhorse/video-edit and other free-form prompt models with no inline
+ *  marker syntax (the "[Image N]" form belongs to happyhorse 1.1 t2v/i2v/ref
+ *  only). The prompt is a free-form instruction; media rides separate URL
+ *  fields. Rewrite confirmed @<video-ref> → "the source video", each
+ *  @<image-ref> → "reference image N" (1-based in imageRefs), and each
+ *  @<audio-ref> → "reference audio N". Unlisted mentions stay literal. */
+export function replaceHappyHorseAssetMentions(prompt, videoRef, imageRefs, audioRefs = []) {
+    const replacements = [];
+    if (videoRef) {
+        const video = normalizeNotebookReference(videoRef);
+        if (video) {
+            replacements.push({ reference: video, replacement: "the source video" });
+        }
+    }
+    for (const { ref, index } of refMentionEntries(imageRefs)) {
+        replacements.push({
+            reference: ref,
+            replacement: `reference image ${index + 1}`,
+        });
+    }
+    for (const { ref, index } of refMentionEntries(audioRefs)) {
+        replacements.push({
+            reference: ref,
+            replacement: `reference audio ${index + 1}`,
+        });
+    }
+    return replaceNotebookMentions(prompt, replacements);
+}
+/** HappyHorse 1.1 reference-to-video: rewrite confirmed @<image-ref> mentions
+ *  to positional `[Image N]` markers matching the reference_image[] order. */
+export function rewriteImageRefMentionsToBrackets(prompt, imageRefs) {
+    return replaceNotebookMentions(prompt, refMentionEntries(imageRefs).map(({ ref, index }) => ({
+        reference: ref,
+        replacement: `[Image ${index + 1}]`,
+    })));
+}
+/** Seedance r2v: rewrite confirmed asset @refs to `@ImageN` / `@VideoN` /
+ *  `@AudioN` (1-based, matching upload order in each modality array). */
+export function rewriteSeedanceAssetMentions(prompt, refs) {
+    const replacements = [];
+    for (const { ref, index } of refMentionEntries(refs.imageRefs ?? [])) {
+        replacements.push({ reference: ref, replacement: `@Image${index + 1}` });
+    }
+    for (const { ref, index } of refMentionEntries(refs.videoRefs ?? [])) {
+        replacements.push({ reference: ref, replacement: `@Video${index + 1}` });
+    }
+    for (const { ref, index } of refMentionEntries(refs.audioRefs ?? [])) {
+        replacements.push({ reference: ref, replacement: `@Audio${index + 1}` });
+    }
+    return replaceNotebookMentions(prompt, replacements);
+}
+export function rewriteViduReferenceMentions(prompt, imageRefs, audioRefs) {
+    return replaceNotebookMentions(prompt, [
+        ...refMentionEntries(imageRefs).map(({ ref, index }) => ({
+            reference: ref,
+            replacement: `[@reference_image_${index + 1}]`,
+        })),
+        ...refMentionEntries(audioRefs).map(({ ref, index }) => ({
+            reference: ref,
+            replacement: `[reference_audio_${index + 1}]`,
+        })),
+    ]);
+}
+/** Free-form multi-ref natural rewrite when the provider has no inline marker
+ *  syntax: videos → "reference video N" (or "the source video" for a single
+ *  source clip), images → "reference image N", audio → "reference audio N". */
+export function replaceNaturalAssetMentions(prompt, refs) {
+    let out = prompt;
+    if (refs.sourceVideoRef) {
+        out = replaceHappyHorseAssetMentions(out, refs.sourceVideoRef, [], []);
+    }
+    const multiVideos = refs.videoRefs ?? [];
+    out = replaceNotebookMentions(out, refMentionEntries(multiVideos).map(({ ref, index }) => ({
+        reference: ref,
+        replacement: multiVideos.length === 1
+            ? "the source video"
+            : `reference video ${index + 1}`,
+    })));
+    out = replaceHappyHorseAssetMentions(out, null, refs.imageRefs ?? [], refs.audioRefs ?? []);
+    return out;
+}

package/dist/goal-characters.js

@@ -0,0 +1,49 @@
+import { resolveNotebookCellArtifactId } from "videobook-engine";
+import { notebookGridTag } from "videobook-engine/notebook-grid";
+import { replaceNotebookMentions, scanNotebookMentions } from "videobook-engine/notebook-mentions";
+import { resolveNotebookPromptReferences } from "./notebook-reference-resolver.js";
+const GOAL_CHARACTER_HELP = "Mention the reference images in the brief, for example /goal @a1 @a2 as ...";
+export function resolveGoalCharacters(engine, document, brief) {
+    if (scanNotebookMentions(brief).length === 0)
+        throw new Error(GOAL_CHARACTER_HELP);
+    const resolved = resolveNotebookPromptReferences({ engine, document, prompt: brief, requireMedia: true });
+    if (resolved.unresolved.length > 0)
+        throw new Error(resolved.unresolved[0].message);
+    const characters = new Map();
+    for (const reference of resolved.resolved) {
+        const artifact = engine.artifacts.get(reference.artifactId);
+        const cell = document.cells.find(candidate => candidate.id === reference.cellId);
+        if (!artifact.ok || artifact.value.kind !== "image" || !cell || !["image", "generate_image"].includes(cell.type)) {
+            throw new Error(`${reference.mention} is not an image`);
+        }
+        if (!characters.has(reference.artifactId))
+            characters.set(reference.artifactId, {
+                artifactId: reference.artifactId, cellId: cell.id, address: notebookGridTag(cell.slot),
+                label: artifact.value.label || cell.label || `Character ${characters.size + 1}`,
+            });
+    }
+    if (characters.size === 0)
+        throw new Error(GOAL_CHARACTER_HELP);
+    if (characters.size > 8)
+        throw new Error("A goal supports 1–8 reference images");
+    return [...characters.values()];
+}
+export function currentGoalCharacters(document, characters) {
+    return characters.map(character => {
+        const cell = document.cells.find(candidate => candidate.id === character.cellId);
+        if (!cell || resolveNotebookCellArtifactId(document, cell) !== character.artifactId) {
+            throw new Error(`Reference image ${character.address} changed or was removed. Start a new /goal.`);
+        }
+        return { ...character, address: notebookGridTag(cell.slot) };
+    });
+}
+export function goalPlannerBrief(brief, characters, document) {
+    const aliases = document?.cells.flatMap(cell => {
+        const index = characters.findIndex(character => character.artifactId === resolveNotebookCellArtifactId(document, cell));
+        return index < 0 ? [] : [{ reference: notebookGridTag(cell.slot), replacement: `Character ${index + 1}` }];
+    }) ?? [];
+    return replaceNotebookMentions(brief, [...characters.flatMap((character, index) => [
+            { reference: character.address.slice(1), replacement: `Character ${index + 1}` },
+            { reference: character.artifactId, replacement: `Character ${index + 1}` },
+        ]), ...aliases]).replace(/(Character \d)(?=Character \d)/gu, "$1 ");
+}

package/dist/goal-plan-v3.js

@@ -0,0 +1,273 @@
+import { z } from "zod";
+import { notebookGridTag } from "videobook-engine/notebook-grid";
+import { goalPromptWords } from "./goal-prompt-budget.js";
+import { LIGHTNING_COLD_OPEN_SECONDS, LIGHTNING_SCENE_ASPECT_RATIO, LIGHTNING_SCENE_MODEL, LIGHTNING_SCENE_OUTPUT_FORMAT, LIGHTNING_SCENE_PROMPT_WORDS, LIGHTNING_SCENE_RESOLUTION, LIGHTNING_VIDEO_DURATION_SECONDS, LIGHTNING_VIDEO_GENERATE_AUDIO, LIGHTNING_VIDEO_OUTPUT_FORMAT, LIGHTNING_VIDEO_PROMPT_WORDS, LIGHTNING_VIDEO_RESOLUTION, LIGHTNING_VIDEO_MODEL, LIGHTNING_WATERMARK_PROFILE, preservedPrompt, } from "./lightning-defaults.js";
+const IMAGE_LIMIT = 30;
+const VIDEO_LIMIT = 10;
+export const goalMediaRefSchema = z.object({
+    kind: z.enum(["image", "video"]),
+    artifactId: z.string().min(1),
+    cellId: z.string().min(1),
+    address: z.string().min(1),
+    label: z.string(),
+    objectHash: z.string().min(1),
+    slot: z.string().regex(/^@(?:image|video)\d+$/u),
+}).strict();
+export const goalPlanV3Schema = z.object({
+    version: z.literal(3),
+    title: z.string().trim().min(1).max(120),
+    aspectRatio: z.enum(["16:9", "9:16", "1:1"]),
+    scene: z.object({
+        prompt: z.string().trim().min(1).max(4000),
+        tool: z.literal("generate_image"),
+        model: z.literal(LIGHTNING_SCENE_MODEL),
+        aspectRatio: z.enum(["16:9", "9:16", "1:1"]),
+        resolution: z.literal(LIGHTNING_SCENE_RESOLUTION),
+        outputFormat: z.literal(LIGHTNING_SCENE_OUTPUT_FORMAT),
+        imageRefs: z.array(goalMediaRefSchema).max(IMAGE_LIMIT),
+    }).strict(),
+    video: z.object({
+        prompt: z.string().trim().min(1).max(4000),
+        tool: z.literal("generate_video"),
+        model: z.literal(LIGHTNING_VIDEO_MODEL),
+        aspectRatio: z.enum(["16:9", "9:16", "1:1", "adaptive"]),
+        resolution: z.literal(LIGHTNING_VIDEO_RESOLUTION),
+        durationSeconds: z.number().int().min(4).max(30),
+        generateAudio: z.literal(true),
+        outputFormat: z.literal(LIGHTNING_VIDEO_OUTPUT_FORMAT),
+        imageRefs: z.array(goalMediaRefSchema).max(IMAGE_LIMIT),
+        videoRefs: z.array(goalMediaRefSchema).max(VIDEO_LIMIT),
+    }).strict(),
+    references: z.array(goalMediaRefSchema).min(1),
+    sampledFrames: z.array(z.object({
+        artifactId: z.string().min(1),
+        objectHash: z.string().min(1),
+        seconds: z.number().nonnegative(),
+    }).strict()),
+    finish: z.object({
+        suggestedColdOpenSeconds: z.number().positive(),
+        watermark: z.object({
+            platform: z.literal("tiktok"),
+            handle: z.string().min(1),
+            profileUrl: z.string().min(1),
+            mode: z.literal("burn"),
+            handleEndSeconds: z.number().nullable(),
+            qrLeadSeconds: z.number().nullable(),
+            handleOpacity: z.number(),
+            qrOpacity: z.number(),
+            fadeSeconds: z.number(),
+        }).strict(),
+    }).strict(),
+}).strict();
+export function isGoalPlanV3(plan) {
+    return plan?.version === 3;
+}
+export function closestGoalAspectRatio(width, height) {
+    const ratio = Math.log(width / height);
+    const candidates = [["16:9", 16 / 9], ["9:16", 9 / 16], ["1:1", 1]];
+    return candidates.reduce((best, candidate) => Math.abs(ratio - Math.log(candidate[1])) < Math.abs(ratio - Math.log(best[1])) ? candidate : best)[0];
+}
+function goalV3Timing(brief, fallbackAspectRatio = LIGHTNING_SCENE_ASPECT_RATIO) {
+    const aspectRatio = /\b(?:9:16|portrait|vertical)\b/iu.test(brief) ? "9:16"
+        : /\b(?:1:1|square)\b/iu.test(brief) ? "1:1"
+            : /\b(?:16:9|landscape|horizontal)\b/iu.test(brief) ? "16:9"
+                : fallbackAspectRatio;
+    const match = /(?:^|\s)(\d+)[ -]*(?:s|secs?|seconds?)\b/iu.exec(brief);
+    const parsed = match ? Number(match[1]) : Number.NaN;
+    const durationSeconds = Number.isInteger(parsed) && parsed >= 4 && parsed <= 30
+        ? parsed
+        : LIGHTNING_VIDEO_DURATION_SECONDS;
+    return { aspectRatio, durationSeconds };
+}
+function briefProse(brief) {
+    return brief.replace(/@[a-z0-9]+/giu, " ").replace(/\s+/gu, " ").trim();
+}
+function quoted(brief, label) {
+    const specific = new RegExp(`(?:^|\\s)${label}\\s*:\\s*["“]([^"”]+)["”]`, "iu").exec(brief);
+    return specific?.[1]?.trim() || null;
+}
+function authoredCopy(brief) {
+    const generic = /["“]([^"”]+)["”]/u.exec(brief)?.[1]?.trim() || null;
+    return {
+        scene: quoted(brief, "scene") ?? quoted(brief, "image") ?? generic,
+        video: quoted(brief, "video") ?? quoted(brief, "clip") ?? generic,
+    };
+}
+function limitedWords(value, maxWords, authored) {
+    if (authored)
+        return preservedPrompt(value, maxWords, true);
+    if (maxWords < 1)
+        return "";
+    return preservedPrompt(value, maxWords, false);
+}
+function promptWithSlots(body, slots, maxWords, authored) {
+    const kept = limitedWords(body, authored ? maxWords : Math.max(0, maxWords - slots.length), authored);
+    const prompt = [kept, ...slots].filter(part => part.length > 0).join(" ").trim();
+    if (!authored && goalPromptWords(prompt) > maxWords) {
+        return [...slots].join(" ");
+    }
+    return prompt.length > 0 ? prompt : slots.join(" ");
+}
+function framePrompt(body, characterSlots, authored) {
+    const instruction = characterSlots.length > 0
+        ? `Place ${characterSlots.join(" and ")} into @image1, keeping its framing, setting and light.`
+        : "Edit @image1, keeping its framing, setting and light.";
+    const kept = limitedWords(body, LIGHTNING_SCENE_PROMPT_WORDS - goalPromptWords(instruction), authored);
+    return [instruction, kept].filter(part => part.length > 0).join(" ");
+}
+function sceneImageRefs(images, frame) {
+    if (!frame)
+        return images.slice(0, IMAGE_LIMIT);
+    return [frame.reference, ...images].slice(0, IMAGE_LIMIT).map((reference, index) => ({ ...reference, slot: `@image${index + 1}` }));
+}
+function titleFrom(body) {
+    const title = body.split(/\s+/u).filter(Boolean).slice(0, 6).join(" ").slice(0, 80).trim();
+    return title.length > 0 ? title : "Video";
+}
+function assignSlots(references) {
+    let images = 0;
+    let videos = 0;
+    return references.map(reference => {
+        const slot = reference.kind === "video" ? `@video${++videos}` : `@image${++images}`;
+        return { ...reference, slot };
+    });
+}
+export function buildGoalPlanV3(input) {
+    const references = assignSlots(input.references);
+    const images = references.filter(reference => reference.kind === "image");
+    const videos = references.filter(reference => reference.kind === "video");
+    const timing = goalV3Timing(input.brief, input.frame?.aspectRatio);
+    const copy = authoredCopy(input.brief);
+    const prose = briefProse(input.brief);
+    const sceneBody = copy.scene ?? prose;
+    const videoBody = copy.video ?? prose;
+    const sceneRefs = sceneImageRefs(images, input.frame);
+    const videoSlots = [...images.slice(0, IMAGE_LIMIT), ...videos.slice(0, VIDEO_LIMIT)].map(reference => reference.slot);
+    const scenePrompt = input.frame
+        ? framePrompt(sceneBody, sceneRefs.slice(1).map(reference => reference.slot), copy.scene !== null)
+        : promptWithSlots(sceneBody, sceneRefs.map(reference => reference.slot), LIGHTNING_SCENE_PROMPT_WORDS, copy.scene !== null);
+    const videoPrompt = promptWithSlots(videoBody, videoSlots, LIGHTNING_VIDEO_PROMPT_WORDS, copy.video !== null);
+    const profile = LIGHTNING_WATERMARK_PROFILE;
+    return goalPlanV3Schema.parse({
+        version: 3,
+        title: titleFrom(sceneBody || videoBody),
+        aspectRatio: timing.aspectRatio,
+        scene: {
+            prompt: scenePrompt,
+            tool: "generate_image",
+            model: LIGHTNING_SCENE_MODEL,
+            aspectRatio: timing.aspectRatio,
+            resolution: LIGHTNING_SCENE_RESOLUTION,
+            outputFormat: LIGHTNING_SCENE_OUTPUT_FORMAT,
+            imageRefs: sceneRefs,
+        },
+        video: {
+            prompt: videoPrompt,
+            tool: "generate_video",
+            model: LIGHTNING_VIDEO_MODEL,
+            aspectRatio: timing.aspectRatio,
+            resolution: LIGHTNING_VIDEO_RESOLUTION,
+            durationSeconds: timing.durationSeconds,
+            generateAudio: LIGHTNING_VIDEO_GENERATE_AUDIO,
+            outputFormat: LIGHTNING_VIDEO_OUTPUT_FORMAT,
+            imageRefs: images.slice(0, IMAGE_LIMIT),
+            videoRefs: videos.slice(0, VIDEO_LIMIT),
+        },
+        references,
+        sampledFrames: input.frame
+            ? [{ artifactId: input.frame.reference.artifactId, objectHash: input.frame.reference.objectHash, seconds: input.frame.seconds }]
+            : [],
+        finish: {
+            suggestedColdOpenSeconds: LIGHTNING_COLD_OPEN_SECONDS,
+            watermark: {
+                platform: "tiktok",
+                handle: profile.handle,
+                profileUrl: profile.profileUrl,
+                mode: "burn",
+                handleEndSeconds: profile.handleEndSeconds,
+                qrLeadSeconds: profile.qrLeadSeconds,
+                handleOpacity: profile.handleOpacity,
+                qrOpacity: profile.qrOpacity,
+                fadeSeconds: profile.fadeSeconds,
+            },
+        },
+    });
+}
+function liveAddress(document, reference) {
+    const cell = document.cells.find(candidate => candidate.id === reference.cellId);
+    return cell ? { ...reference, address: notebookGridTag(cell.slot) } : reference;
+}
+export function refreshGoalPlanV3(plan, document) {
+    const map = (reference) => liveAddress(document, reference);
+    return {
+        ...plan,
+        references: plan.references.map(map),
+        scene: { ...plan.scene, imageRefs: plan.scene.imageRefs.map(map) },
+        video: {
+            ...plan.video,
+            imageRefs: plan.video.imageRefs.map(map),
+            videoRefs: plan.video.videoRefs.map(map),
+        },
+    };
+}
+function refList(params, role) {
+    const refs = params.refs;
+    const list = refs?.[role];
+    return Array.isArray(list) ? list.filter((entry) => typeof entry === "string") : [];
+}
+function withRefs(params, images, videos) {
+    const refs = {
+        ...(images.length > 0 ? { image: [...images] } : {}),
+        ...(videos.length > 0 ? { video: [...videos] } : {}),
+    };
+    const { refs: _previous, mode: _mode, ...rest } = params;
+    return Object.keys(refs).length > 0 ? { ...rest, refs, ...(params.mode ? { mode: params.mode } : {}) } : rest;
+}
+export function compileGoalV3Approval(plan, stage, sceneAddress) {
+    const [scene, video] = compileGoalV3Steps(plan);
+    if (stage === "frame")
+        return { ...scene, params: withRefs(scene.params, refList(scene.params, "image"), []) };
+    const imageRefs = [...new Set([...(sceneAddress ? [sceneAddress] : []), ...refList(video.params, "image")])];
+    return { ...video, params: withRefs(video.params, imageRefs, refList(video.params, "video")) };
+}
+export function compileGoalV3Steps(plan) {
+    const sceneRefs = plan.scene.imageRefs.slice(0, IMAGE_LIMIT);
+    const videoImages = plan.video.imageRefs.slice(0, IMAGE_LIMIT);
+    const videoRefs = plan.video.videoRefs.slice(0, VIDEO_LIMIT);
+    return [
+        {
+            id: "scene",
+            tool: plan.scene.tool,
+            params: {
+                model: plan.scene.model,
+                prompt: plan.scene.prompt,
+                refs: { image: sceneRefs.map(reference => reference.address) },
+                options: {
+                    aspect_ratio: plan.scene.aspectRatio,
+                    resolution: plan.scene.resolution,
+                    output_format: plan.scene.outputFormat,
+                },
+            },
+        },
+        {
+            id: "video",
+            tool: plan.video.tool,
+            params: {
+                model: plan.video.model,
+                prompt: plan.video.prompt,
+                refs: {
+                    image: videoImages.map(reference => reference.address),
+                    video: videoRefs.map(reference => reference.address),
+                },
+                ...(videoImages.length + videoRefs.length > 0 ? { mode: "r2v" } : {}),
+                options: {
+                    aspect_ratio: plan.video.aspectRatio,
+                    resolution: plan.video.resolution,
+                    duration: plan.video.durationSeconds,
+                    generate_audio: plan.video.generateAudio,
+                    output_format: plan.video.outputFormat,
+                },
+            },
+        },
+    ];
+}