videobook 0.0.0-stage → 0.2.0

package/dist/notebook-credit-retry.js

@@ -0,0 +1,45 @@
+import { isGenerationCreditError } from "./generation-credit-error.js";
+export function creditRetryProducer(document, outputCellId) {
+    const output = document.cells.find((cell) => cell.id === outputCellId);
+    if (!output || !["image", "video", "audio"].includes(output.type))
+        return null;
+    const edge = document.edges.find((candidate) => candidate.target === output.id && candidate.targetInput === "media");
+    return document.cells.find((cell) => cell.id === edge?.source && cell.type === `generate_${output.type}`) ?? null;
+}
+export function removeCreditFailedOutput(engine, document, producerCellId, outputCellId) {
+    const producer = creditRetryProducer(document, outputCellId);
+    if (producer?.id !== producerCellId) {
+        throw new Error("The failed output no longer belongs to this generator");
+    }
+    if (producer.type === "generate_audio" && document.edges.some((edge) => edge.source === producer.id && edge.targetInput === "media" && edge.target !== outputCellId
+        && document.cells.some((cell) => cell.id === edge.target && cell.type === "audio"))) {
+        throw new Error("This generator has another audio output; retry would replace that media");
+    }
+    const output = document.cells.find((cell) => cell.id === outputCellId);
+    const state = document.execution?.[outputCellId];
+    const providerArtifactId = state?.providerArtifactId ?? output.outputArtifactId;
+    if ((output.outputArtifactId && output.outputArtifactId !== providerArtifactId)
+        || (Array.isArray(output.inputs?.outputVersionArtifactIds)
+            && output.inputs.outputVersionArtifactIds.some((id) => id !== providerArtifactId))) {
+        throw new Error("This output contains earlier media; run its generator to preserve those versions");
+    }
+    const failure = providerArtifactId ? engine.jobs.failures.read(providerArtifactId) : null;
+    const pending = providerArtifactId ? engine.jobs.pending.read(providerArtifactId) : null;
+    const message = failure?.ok && failure.value
+        ? `${failure.value.message} ${failure.value.failCode ?? ""}`
+        : state?.error;
+    if ((state && state.status !== "error")
+        || (providerArtifactId && (!failure?.ok || !failure.value))
+        || (pending?.ok && pending.value)
+        || !isGenerationCreditError(message)) {
+        throw new Error("Retry with deletion is only available for an out-of-credits failure");
+    }
+    const execution = { ...document.execution };
+    delete execution[outputCellId];
+    return {
+        ...document,
+        cells: document.cells.filter((cell) => cell.id !== outputCellId),
+        edges: document.edges.filter((edge) => edge.source !== outputCellId && edge.target !== outputCellId),
+        execution,
+    };
+}

package/dist/notebook-fixtures.js

@@ -0,0 +1,8 @@
+export const MULTYCULTY_FIXTURE_OWNER = "multyculty-default";
+export function analysisFixtureForCell(cell) {
+    if (cell.inputs?.fixtureOwner === MULTYCULTY_FIXTURE_OWNER)
+        return null;
+    return cell.inputs?.fixtureAnalysis
+        ?? cell.inputs?.analysisFixture
+        ?? null;
+}

package/dist/notebook-generation-contract.js

@@ -0,0 +1,77 @@
+import { generationModeInputError } from "./generation-input-policy.js";
+function slotKind(role) {
+    if (role === "video")
+        return "video";
+    if (role === "audio")
+        return "audio";
+    return "image";
+}
+function modeSlots(model, roles) {
+    const slots = model.slots
+        .filter((slot) => roles.includes(slot.role))
+        .map((slot) => ({ field: slot.role, kind: slotKind(slot.role), targets: [slot.role], min: slot.min, max: slot.max }));
+    return model.media === "video"
+        ? [...slots, { field: "replace_audio", kind: "audio", targets: ["replace_audio"], min: 0, max: 1 }]
+        : slots;
+}
+export function notebookGenerationInputContract(model) {
+    return {
+        modes: model.modes.map((mode) => ({
+            id: mode.id,
+            slots: modeSlots(model, mode.roles),
+            requiredGroups: mode.requireAny && mode.requireAny.length > 0 ? [[...mode.requireAny]] : [],
+        })),
+    };
+}
+function cellInputKind(cell) {
+    if (cell.type === "image"
+        || cell.type === "generate_image")
+        return "image";
+    if (cell.type === "video"
+        || cell.type === "split_video"
+        || cell.type === "generate_video"
+        || cell.type === "concat"
+        || cell.type === "splice")
+        return "video";
+    if (cell.type === "audio"
+        || cell.type === "extract_audio"
+        || cell.type === "generate_audio")
+        return "audio";
+    return null;
+}
+function connectedInputTarget(kind, targetInput) {
+    if (targetInput === "first_frame" || targetInput === "last_frame") {
+        return targetInput;
+    }
+    if (kind === "audio" && targetInput === "replace_audio") {
+        return targetInput;
+    }
+    return kind;
+}
+function connectedInputs(document, cell) {
+    const cells = new Map(document.cells.map((candidate) => [candidate.id, candidate]));
+    return document.edges.flatMap((edge) => {
+        if (edge.target !== cell.id)
+            return [];
+        const source = cells.get(edge.source);
+        const kind = source ? cellInputKind(source) : null;
+        return kind
+            ? [{ kind, target: connectedInputTarget(kind, edge.targetInput) }]
+            : [];
+    });
+}
+export function notebookGenerationInputsAreCompatible(contract, document, cell, modeId) {
+    const inputs = connectedInputs(document, cell);
+    const configuredModes = modeId
+        ? contract.modes.filter((candidate) => candidate.id === modeId)
+        : contract.modes;
+    const modes = modeId === "default" && configuredModes.length === 0
+        ? contract.modes
+        : configuredModes;
+    return modes.some((candidate) => generationModeInputError(candidate, inputs) === null);
+}
+export function notebookGenerationInputError(contract, document, cell, modeId) {
+    const candidate = contract.modes.find((mode) => mode.id === modeId)
+        ?? (contract.modes.length === 1 ? contract.modes[0] : undefined);
+    return candidate ? generationModeInputError(candidate, connectedInputs(document, cell)) : null;
+}

package/dist/notebook-generation-controls.js

@@ -0,0 +1,145 @@
+const connectionOwnedFields = new Set([
+    "book_id",
+    "project_slug",
+    "prompt",
+    "text",
+    "character_image_refs",
+    "image_refs",
+    "image_ref",
+    "first_frame_ref",
+    "last_frame_ref",
+    "end_frame_ref",
+    "video_refs",
+    "motion_video_refs",
+    "video_ref",
+    "first_clip_ref",
+    "audio_refs",
+    "audio_ref",
+    "driving_audio_ref",
+    "replace_audio_with",
+    "_provider",
+]);
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : null;
+}
+function controlValue(value) {
+    return typeof value === "string"
+        || typeof value === "number"
+        || typeof value === "boolean"
+        ? value
+        : undefined;
+}
+function labelFor(name) {
+    if (name === "model")
+        return "Variant";
+    if (name === "output_resolution")
+        return "Resolution";
+    return name
+        .replaceAll("_", " ")
+        .replace(/^./, (character) => character.toUpperCase());
+}
+function controlKind(property, options) {
+    if (options.length > 0) {
+        const valueType = options.every((value) => typeof value === "number")
+            ? "number"
+            : options.every((value) => typeof value === "boolean")
+                ? "boolean"
+                : "string";
+        return { kind: "select", valueType };
+    }
+    if (property.type === "boolean") {
+        return { kind: "boolean", valueType: "boolean" };
+    }
+    if (property.type === "integer" || property.type === "number") {
+        return { kind: "number", valueType: "number" };
+    }
+    if (property.type === "string") {
+        return { kind: "text", valueType: "string" };
+    }
+    return null;
+}
+export function notebookGenerationControls(value, overrides = {}) {
+    const schema = record(value);
+    const properties = record(schema?.properties);
+    if (!properties)
+        return [];
+    const required = new Set(Array.isArray(schema?.required)
+        ? schema.required.filter((entry) => typeof entry === "string")
+        : []);
+    const defaults = record(schema?.defaults) ?? {};
+    return Object.entries(properties).flatMap(([name, rawProperty]) => {
+        if (connectionOwnedFields.has(name))
+            return [];
+        const property = record(rawProperty);
+        if (!property)
+            return [];
+        const options = Array.isArray(property.enum)
+            ? property.enum.flatMap((entry) => {
+                const parsed = controlValue(entry);
+                return parsed === undefined ? [] : [parsed];
+            })
+            : [];
+        const type = controlKind(property, options);
+        if (!type)
+            return [];
+        const defaultValue = controlValue(overrides[name] ?? defaults[name] ?? property.default);
+        return [{
+                name,
+                label: labelFor(name),
+                ...type,
+                required: required.has(name),
+                ...(defaultValue === undefined ? {} : { defaultValue }),
+                ...(options.length === 0 ? {} : { options }),
+                ...(typeof property.minimum === "number"
+                    ? { minimum: property.minimum }
+                    : {}),
+                ...(typeof property.maximum === "number"
+                    ? { maximum: property.maximum }
+                    : {}),
+                ...(property.exclusiveMinimum === true ? { exclusiveMinimum: true } : {}),
+                ...(property.exclusiveMaximum === true ? { exclusiveMaximum: true } : {}),
+                description: typeof property.description === "string"
+                    ? property.description
+                    : labelFor(name),
+            }];
+    });
+}
+function optionControl(option) {
+    const options = option.enumValues.flatMap((value) => {
+        const parsed = controlValue(value);
+        return parsed === undefined ? [] : [parsed];
+    });
+    const kind = options.length > 0
+        ? "select"
+        : option.valueType === "boolean"
+            ? "boolean"
+            : option.valueType === "number" || option.valueType === "integer"
+                ? "number"
+                : option.valueType === "string" ? "text" : null;
+    if (!kind)
+        return null;
+    const valueType = options.length > 0
+        ? options.every((value) => typeof value === "number") ? "number" : "string"
+        : kind === "boolean" ? "boolean" : kind === "number" ? "number" : "string";
+    const defaultValue = controlValue(option.defaultValue);
+    return {
+        name: option.name,
+        label: labelFor(option.name),
+        kind,
+        valueType,
+        required: option.required,
+        ...(defaultValue === undefined ? {} : { defaultValue }),
+        ...(options.length === 0 ? {} : { options }),
+        ...(option.minimum !== undefined ? { minimum: option.minimum } : {}),
+        ...(option.maximum !== undefined ? { maximum: option.maximum } : {}),
+        description: option.description || labelFor(option.name),
+    };
+}
+export function controlsForModel(model) {
+    return model.options.flatMap((option) => {
+        const control = optionControl(option);
+        return control ? [control] : [];
+    });
+}

package/dist/notebook-goal-layout.js

@@ -0,0 +1,40 @@
+import { NOTEBOOK_GRID_COLUMN_COUNT, NOTEBOOK_GRID_ROW_COUNT } from "videobook-engine/notebook-grid";
+function readingOrder(left, right) {
+    return left.slot.row - right.slot.row || left.slot.column - right.slot.column || left.id.localeCompare(right.id);
+}
+export function arrangeGoalNotebook(document, reserve = {}) {
+    const goals = document.cells.filter(cell => cell.type === "goal").sort(readingOrder);
+    if (goals.length === 0)
+        return document;
+    const references = new Set(goals.flatMap(goal => Array.isArray(goal.inputs?.characters)
+        ? goal.inputs.characters.flatMap((character) => character && typeof character === "object" && "cellId" in character && typeof character.cellId === "string" ? [character.cellId] : [])
+        : []));
+    const outputs = new Set(document.edges.filter(edge => document.cells.some(cell => cell.id === edge.source && cell.type === "generate_image")).map(edge => edge.target));
+    const ordered = [...document.cells].sort((left, right) => left.id.localeCompare(right.id));
+    const referenceImages = document.cells.filter(cell => cell.type === "image" && (references.has(cell.id)
+        || !outputs.has(cell.id) && !cell.inputs?.producerCellId && !cell.inputs?.mediaRole)).sort(readingOrder);
+    const referenceIds = new Set(referenceImages.map(cell => cell.id));
+    const generators = ordered.filter(cell => cell.type.startsWith("generate_") || cell.type === "prompt");
+    const images = ordered.filter(cell => cell.type === "image" && !referenceIds.has(cell.id));
+    const videos = ordered.filter(cell => cell.type === "video");
+    const timelines = document.cells.filter(cell => cell.type === "timeline").sort(readingOrder);
+    const slots = new Map();
+    let row = 0;
+    const place = (cells, extra = 0, minimumRows = 1) => {
+        cells.forEach((cell, index) => slots.set(cell.id, { row: row + Math.floor(index / NOTEBOOK_GRID_COLUMN_COUNT), column: index % NOTEBOOK_GRID_COLUMN_COUNT }));
+        row += Math.max(minimumRows, Math.ceil((cells.length + extra) / NOTEBOOK_GRID_COLUMN_COUNT));
+    };
+    place(referenceImages, 0, 0);
+    place([...goals, ...generators], reserve.generators);
+    place(images, reserve.images);
+    place(videos, reserve.videos);
+    for (const timeline of timelines) {
+        slots.set(timeline.id, { row, column: 0 });
+        row += 1;
+    }
+    row += reserve.timelines ?? 0;
+    place(ordered.filter(cell => !slots.has(cell.id)), 0, 0);
+    if (row > NOTEBOOK_GRID_ROW_COUNT)
+        throw new Error(`The goal layout needs ${row} rows, but the grid supports ${NOTEBOOK_GRID_ROW_COUNT}. Remove unused cells before continuing.`);
+    return { ...document, cells: document.cells.map(cell => ({ ...cell, slot: slots.get(cell.id) })) };
+}

package/dist/notebook-graph.js

@@ -0,0 +1,37 @@
+export function notebookConnectionWouldCreateCycle(edges, sourceCellId, targetCellId) {
+    if (sourceCellId === targetCellId)
+        return true;
+    const children = new Map();
+    for (const edge of edges) {
+        const targets = children.get(edge.source) ?? [];
+        targets.push(edge.target);
+        children.set(edge.source, targets);
+    }
+    const visited = new Set();
+    const stack = [targetCellId];
+    while (stack.length > 0) {
+        const cellId = stack.pop();
+        if (!cellId || visited.has(cellId))
+            continue;
+        if (cellId === sourceCellId)
+            return true;
+        visited.add(cellId);
+        stack.push(...(children.get(cellId) ?? []));
+    }
+    return false;
+}
+export function notebookConnectionEdges(cells, edges, sourceCellId, targetCellId) {
+    if (!notebookConnectionWouldCreateCycle(edges, sourceCellId, targetCellId)) {
+        return edges;
+    }
+    const source = cells.find((cell) => cell.id === sourceCellId);
+    if (sourceCellId === targetCellId
+        || source?.type !== "image"
+        || !source.outputArtifactId)
+        return null;
+    const retained = edges.filter((edge) => edge.target !== sourceCellId
+        || !notebookConnectionWouldCreateCycle(edges, edge.source, targetCellId));
+    return notebookConnectionWouldCreateCycle(retained, sourceCellId, targetCellId)
+        ? null
+        : retained;
+}

package/dist/notebook-image-edit.js

@@ -0,0 +1,84 @@
+import { z } from "zod";
+import { findImageEditModel } from "./image-edit-models.js";
+import { resolveImageRef } from "./tools/_media-refs.js";
+import { previewPlaceholderUrl } from "./preview-payload.js";
+import { previewImageSubjectEditRequest } from "./jobs/image-subjects.js";
+const boxSchema = z.object({
+    x: z.number().min(0).max(1), y: z.number().min(0).max(1),
+    width: z.number().positive().max(1), height: z.number().positive().max(1),
+}).refine((box) => box.x + box.width <= 1.000001 && box.y + box.height <= 1.000001, { message: "Edit regions must fit inside the image" });
+const editInputsSchema = z.object({
+    generationMode: z.enum(["whole-image", "subject-edit", "subject-remove", "region-edit", "region-remove", "region-replace"]),
+    sourceArtifactId: z.string().min(1),
+    sourceObjectHash: z.string().min(1),
+    subjectIds: z.array(z.string().min(1)).default([]),
+    editRegions: z.array(boxSchema).optional(),
+    regions: z.array(z.object({
+        box: boxSchema.optional(), subjectId: z.string().optional(),
+        replacementArtifactId: z.string().min(1), note: z.string().optional(),
+    }).refine((region) => Boolean(region.box || region.subjectId))).optional(),
+});
+export async function prepareNotebookImageEdit(engine, document, cell, prompt) {
+    const inputs = editInputsSchema.parse(cell.inputs);
+    const incoming = document.edges.filter((edge) => edge.target === cell.id);
+    const source = incoming.length === 1 ? document.cells.find((candidate) => candidate.id === incoming[0].source) : null;
+    if (!source || (source.outputArtifactId !== inputs.sourceArtifactId
+        && !(Array.isArray(source.inputs?.outputVersionArtifactIds)
+            && source.inputs.outputVersionArtifactIds.includes(inputs.sourceArtifactId)))) {
+        throw new Error("This edit requires its original connected source image. Open the image editor to choose a different source.");
+    }
+    const mode = inputs.generationMode;
+    const regional = mode === "region-edit" || mode === "region-remove";
+    if (regional && !inputs.editRegions?.length)
+        throw new Error("This edit has no saved regions");
+    if (mode === "region-replace" && !inputs.regions?.length)
+        throw new Error("This edit has no saved replacement regions");
+    const local = mode === "subject-remove";
+    const model = findImageEditModel(cell.model ?? "");
+    if (!local && !model)
+        throw new Error(`Unknown image edit model: ${cell.model}`);
+    const replacementIds = mode === "region-replace"
+        ? [...new Set(inputs.regions.map((region) => region.replacementArtifactId))] : [];
+    if (model?.maxInputImages !== null && model?.maxInputImages !== undefined
+        && 1 + replacementIds.length > model.maxInputImages) {
+        throw new Error(`${model.label} accepts at most ${model.maxInputImages} image inputs`);
+    }
+    const replacementRefs = [];
+    for (const id of replacementIds) {
+        const ref = await resolveImageRef(engine, id);
+        if (!ref.ok)
+            throw new Error(ref.error);
+        replacementRefs.push(ref.value);
+    }
+    const jobInput = {
+        sourceArtifactId: inputs.sourceArtifactId,
+        sourceObjectHash: inputs.sourceObjectHash,
+        subjectIds: inputs.subjectIds,
+        operation: mode === "whole-image" ? "whole_image"
+            : mode === "region-replace" ? "replace"
+                : mode.endsWith("remove") ? "remove" : "edit",
+        prompt,
+        ...(regional ? { editRegions: inputs.editRegions } : {}),
+        ...(mode === "region-replace" ? { regions: inputs.regions, replacementRefs } : {}),
+        ...(local ? {} : { modelId: model.id }),
+    };
+    const refs = [inputs.sourceArtifactId, ...replacementIds];
+    const request = await previewImageSubjectEditRequest(engine, jobInput, refs.map(previewPlaceholderUrl));
+    const previewInput = Object.fromEntries(Object.entries(request.input).map(([key, value]) => [
+        key, Array.isArray(value) && (key === "image_urls" || key === "input_urls")
+            ? value.map((url) => {
+                const id = refs.find((ref) => previewPlaceholderUrl(ref) === url);
+                return id ? `@${id}` : url;
+            }) : value,
+    ]));
+    const provider = local ? "local" : request.model === "grok-imagine-image-2-0/image-edit" ? "kie" : model.provider;
+    return {
+        jobInput,
+        input: { prompt, model: request.model, operation: jobInput.operation, image_refs: refs },
+        provider,
+        model: request.model,
+        providerPayload: provider === "fal"
+            ? { endpoint_id: request.model, input: previewInput }
+            : { model: request.model, input: previewInput },
+    };
+}

package/dist/notebook-initial-generation-prompt.js

@@ -0,0 +1,222 @@
+import { NOTEBOOK_GRID_ADDRESS_SOURCE } from "videobook-engine/notebook-mentions";
+import { generationInputMentions } from "./generation-input-mentions.js";
+const INITIAL_PROMPT_KEY = "initialGenerationPrompt";
+const INITIAL_PROMPT_VERSION = 1;
+function generationKind(cell) {
+    if (cell.type === "generate_image")
+        return "image";
+    if (cell.type === "generate_video")
+        return "video";
+    return null;
+}
+function mediaKind(cell) {
+    if (cell.type === "image" || cell.type === "generate_image")
+        return "image";
+    if (cell.type === "video"
+        || cell.type === "generate_video"
+        || cell.type === "split_video"
+        || cell.type === "concat"
+        || cell.type === "splice")
+        return "video";
+    if (cell.type === "audio"
+        || cell.type === "generate_audio"
+        || cell.type === "extract_audio")
+        return "audio";
+    return null;
+}
+function initialPromptRecord(cell) {
+    const value = cell.inputs?.[INITIAL_PROMPT_KEY];
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const record = value;
+    return typeof record.prompt === "string"
+        && typeof record.version === "number"
+        ? { prompt: record.prompt, version: record.version }
+        : null;
+}
+function cleanCue(value) {
+    const cue = value
+        ?.replace(new RegExp(` ?@${NOTEBOOK_GRID_ADDRESS_SOURCE}(?![\\w-])`, "giu"), "")
+        .replace(/ ?@[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}(?![\w-])/giu, "")
+        .replace(/ ?@(?:(?:image|video|audio)\d+|firstframe|lastframe)(?![\w-])/giu, "")
+        .replace(/\s+/gu, " ")
+        .trim()
+        .replace(/^(?:please\s+)?(?:create|generate|make|render)\s+(?:(?:a|an|the)\s+)?(?:(?:image|video|picture|photo|clip)\s+)?(?:of\s+)?/iu, "")
+        .replace(/^(?:a|an|the)\s+/iu, "")
+        .replace(/[.!?]+$/u, "")
+        .trim();
+    return cue || null;
+}
+function cellPrompt(cell) {
+    if (cell.prompt?.trim())
+        return cell.prompt;
+    const resolved = cell.inputs?.resolvedPrompt;
+    if (typeof resolved === "string" && resolved.trim())
+        return resolved;
+    return undefined;
+}
+function promptInputs(document, cell) {
+    const cells = new Map(document.cells.map((candidate) => [candidate.id, candidate]));
+    const targetOrder = new Map([
+        ["first_frame", 0],
+        ["last_frame", 1],
+        ["image", 2],
+        ["video", 3],
+        ["audio", 4],
+        ["replace_audio", 5],
+    ]);
+    const tokens = new Map(generationInputMentions(cell.id, document.cells, document.edges, typeof cell.inputs?.generationMode === "string" ? cell.inputs.generationMode : undefined)
+        .map((mention) => [`${mention.sourceCellId}:${mention.targetInput}`, mention.token]));
+    return document.edges
+        .filter((edge) => edge.target === cell.id && edge.targetInput !== "media")
+        .flatMap((edge) => {
+        const source = cells.get(edge.source);
+        const kind = source ? mediaKind(source) : null;
+        const producerId = source?.inputs?.producerCellId;
+        const producer = typeof producerId === "string"
+            ? cells.get(producerId)
+            : undefined;
+        return source && kind
+            ? [{
+                    cell: source,
+                    token: tokens.get(`${edge.source}:${edge.targetInput}`) ?? null,
+                    cue: cleanCue(cellPrompt(producer ?? source) ?? cellPrompt(source)),
+                    kind,
+                    targetInput: edge.targetInput,
+                }]
+            : [];
+    })
+        .sort((left, right) => {
+        const targetDifference = (targetOrder.get(left.targetInput) ?? 99)
+            - (targetOrder.get(right.targetInput) ?? 99);
+        if (targetDifference !== 0)
+            return targetDifference;
+        if (left.cell.slot.row !== right.cell.slot.row) {
+            return left.cell.slot.row - right.cell.slot.row;
+        }
+        return left.cell.slot.column - right.cell.slot.column;
+    });
+}
+function inputRole(generation, input) {
+    if (input.targetInput === "first_frame")
+        return "Start frame";
+    if (input.targetInput === "last_frame")
+        return "End frame";
+    if (input.targetInput === "replace_audio")
+        return "Replacement audio";
+    if (input.kind === "image") {
+        return generation === "video" ? "Subject image" : "Reference image";
+    }
+    if (input.kind === "video") {
+        return generation === "video" ? "Motion video" : "Scene video";
+    }
+    if (input.kind === "audio")
+        return "Audio";
+    return "Source";
+}
+function describeInput(generation, input) {
+    return `${inputRole(generation, input)}${input.token ? ` @${input.token}` : ""}`
+        + `${input.cue ? `: ${input.cue}` : ""}.`;
+}
+function fallbackPrompt(kind) {
+    if (kind === "image")
+        return "Clear subject, coherent scene.";
+    return "Clear subject, coherent motion.";
+}
+function buildInitialGenerationPrompt(document, cell) {
+    const kind = generationKind(cell);
+    if (!kind)
+        return cell.prompt?.trim() ?? "";
+    const inputs = promptInputs(document, cell);
+    if (inputs.length === 0)
+        return fallbackPrompt(kind);
+    const descriptions = inputs.map((input) => describeInput(kind, input));
+    if (kind === "image") {
+        return [
+            ...descriptions,
+            "Preserve subject, composition.",
+            "Render clean image.",
+        ].join(" ");
+    }
+    const directives = [];
+    const firstFrame = inputs.some((input) => input.targetInput === "first_frame");
+    const lastFrame = inputs.some((input) => input.targetInput === "last_frame");
+    const hasImage = inputs.some((input) => input.kind === "image");
+    const hasVideo = inputs.some((input) => input.kind === "video");
+    const hasAudio = inputs.some((input) => input.kind === "audio");
+    if (firstFrame && lastFrame)
+        directives.push("Animate smooth frame transition.");
+    else if (hasImage)
+        directives.push("Animate subject.");
+    if (hasVideo)
+        directives.push("Match motion, timing.");
+    if (hasAudio)
+        directives.push("Sync action, timing.");
+    if (hasImage)
+        directives.push("Preserve identity, composition.");
+    directives.push("Render coherent video.");
+    return [...descriptions, ...directives].join(" ");
+}
+export function resolvedInitialGenerationPrompt(document, cell) {
+    const prompt = cell.prompt?.trim() ?? "";
+    const record = initialPromptRecord(cell);
+    if (record && prompt === record.prompt.trim()) {
+        return buildInitialGenerationPrompt(document, cell);
+    }
+    return prompt || buildInitialGenerationPrompt(document, cell);
+}
+export function seedInitialGenerationPrompt(document, cellId) {
+    const target = document.cells.find((cell) => cell.id === cellId);
+    if (!target || !generationKind(target))
+        return document;
+    const record = initialPromptRecord(target);
+    const currentPrompt = target.prompt?.trim() ?? "";
+    if (currentPrompt && (!record || currentPrompt !== record.prompt.trim())) {
+        return document;
+    }
+    const prompt = buildInitialGenerationPrompt(document, target);
+    if (currentPrompt === prompt
+        && record?.prompt === prompt
+        && record.version === INITIAL_PROMPT_VERSION)
+        return document;
+    return {
+        ...document,
+        cells: document.cells.map((cell) => cell.id === cellId
+            ? {
+                ...cell,
+                prompt,
+                inputs: {
+                    ...(cell.inputs ?? {}),
+                    [INITIAL_PROMPT_KEY]: {
+                        prompt,
+                        version: INITIAL_PROMPT_VERSION,
+                    },
+                },
+            }
+            : cell),
+    };
+}
+export function refreshInitialGenerationPrompts(document) {
+    return document.cells.reduce((current, cell) => initialPromptRecord(cell)
+        ? seedInitialGenerationPrompt(current, cell.id)
+        : current, document);
+}
+export function reconcileInitialGenerationPrompt(previous, next) {
+    const record = initialPromptRecord(next) ?? initialPromptRecord(previous);
+    if (!record)
+        return next;
+    if ((next.prompt?.trim() ?? "") === record.prompt.trim()) {
+        return initialPromptRecord(next)
+            ? next
+            : {
+                ...next,
+                inputs: {
+                    ...(next.inputs ?? {}),
+                    [INITIAL_PROMPT_KEY]: record,
+                },
+            };
+    }
+    const inputs = { ...(next.inputs ?? {}) };
+    delete inputs[INITIAL_PROMPT_KEY];
+    return { ...next, inputs };
+}