videobook 0.0.0-stage → 0.2.0

package/dist/notebook-cell-outputs.js

@@ -0,0 +1,726 @@
+import { notebookOccupiedSlots } from "videobook-engine/notebook-grid";
+import { findGenerateAudioOutputCell, findGenerateImageOutputCell, findGenerateVideoOutputCell, } from "videobook-engine";
+import { notebookGridTag } from "videobook-engine/notebook-grid";
+import { nextGenerationOutputSlot } from "./notebook-placement.js";
+import { isPublishedPostCell } from "./notebook-published-post.js";
+export const EXTRACT_FRAME_OUTPUT_ROLE = "extract-frame-output";
+export const EXTRACT_AUDIO_OUTPUT_ROLE = "extract-audio-output";
+function extractPairOutputType(extract) {
+    if (extract.type === "extract_audio")
+        return "audio";
+    return null;
+}
+function findLegacyExtractPair(document, extract) {
+    const expectedType = extractPairOutputType(extract);
+    if (!expectedType)
+        return null;
+    for (const edge of document.edges) {
+        if (edge.source !== extract.id || edge.targetInput !== "media")
+            continue;
+        const outputCell = document.cells.find((cell) => cell.id === edge.target);
+        if (outputCell?.type === expectedType) {
+            return { outputCell, outputEdge: edge };
+        }
+    }
+    return null;
+}
+function versionArtifactIds(cell) {
+    const persisted = Array.isArray(cell.inputs?.outputVersionArtifactIds)
+        ? cell.inputs.outputVersionArtifactIds.filter((value) => typeof value === "string" && value.length > 0)
+        : [];
+    return [...new Set([
+            ...persisted,
+            ...(cell.outputArtifactId ? [cell.outputArtifactId] : []),
+        ])];
+}
+function adoptExtractFromPair(extract, outputCell) {
+    const adoptedArtifact = outputCell.outputArtifactId ?? extract.outputArtifactId;
+    const pairInputs = outputCell.inputs ?? {};
+    const extractInputs = extract.inputs ?? {};
+    const inputs = { ...extractInputs };
+    for (const key of [
+        "durationSeconds",
+        "frameMode",
+        "timestampSeconds",
+        "atSeconds",
+    ]) {
+        if (inputs[key] === undefined && pairInputs[key] !== undefined) {
+            inputs[key] = pairInputs[key];
+        }
+    }
+    const outputVersionArtifactIds = [...new Set([
+            ...versionArtifactIds(extract),
+            ...versionArtifactIds(outputCell),
+        ])];
+    if (outputVersionArtifactIds.length > 0) {
+        inputs.outputVersionArtifactIds = outputVersionArtifactIds;
+    }
+    if (adoptedArtifact)
+        inputs.state = "completed";
+    else if (inputs.state === "awaiting-output")
+        delete inputs.state;
+    return {
+        ...extract,
+        ...(adoptedArtifact ? { outputArtifactId: adoptedArtifact } : {}),
+        inputs,
+    };
+}
+export function normalizeLegacyExtractCells(document) {
+    return migrateLegacyExtractAudioCells(migrateLegacyExtractFrameCells(collapseLegacyExtractPairs(document)));
+}
+export function collapseLegacyExtractPairs(document) {
+    const pairs = document.cells.flatMap((extract) => {
+        const pair = findLegacyExtractPair(document, extract);
+        return pair ? [{ extract, ...pair }] : [];
+    });
+    if (pairs.length === 0)
+        return document;
+    const deletedCellIds = new Set(pairs.map((pair) => pair.outputCell.id));
+    const deletedEdgeIds = new Set(pairs.map((pair) => pair.outputEdge.id));
+    const adoptByExtractId = new Map(pairs.map((pair) => [pair.extract.id, pair.outputCell]));
+    const rewireFrom = new Map(pairs.map((pair) => [pair.outputCell.id, pair.extract.id]));
+    const cells = document.cells
+        .filter((cell) => !deletedCellIds.has(cell.id))
+        .map((cell) => {
+        const outputCell = adoptByExtractId.get(cell.id);
+        return outputCell ? adoptExtractFromPair(cell, outputCell) : cell;
+    });
+    const seenEdges = new Set();
+    const edges = [];
+    for (const edge of document.edges) {
+        if (deletedEdgeIds.has(edge.id) || deletedCellIds.has(edge.target)) {
+            continue;
+        }
+        const source = rewireFrom.get(edge.source) ?? edge.source;
+        const next = source === edge.source ? edge : { ...edge, source };
+        const key = `${next.source}:${next.target}:${next.targetInput}`;
+        if (seenEdges.has(key))
+            continue;
+        seenEdges.add(key);
+        edges.push(next);
+    }
+    const execution = { ...(document.execution ?? {}) };
+    for (const pair of pairs) {
+        delete execution[pair.outputCell.id];
+        if (execution[pair.extract.id]?.status === "awaiting-output") {
+            delete execution[pair.extract.id];
+        }
+    }
+    return {
+        ...document,
+        cells,
+        edges,
+        execution,
+    };
+}
+function isLegacyExtractFrameProducer(document, cell) {
+    if (cell.type !== "image")
+        return false;
+    const inputs = cell.inputs ?? {};
+    if (inputs.mediaRole !== undefined)
+        return false;
+    if (cell.operation === "extract_frame")
+        return true;
+    if (inputs.frameMode !== undefined)
+        return true;
+    return document.edges.some((edge) => edge.target === cell.id && edge.targetInput === "video");
+}
+function findLegacyExtractFrameOutput(document, producer) {
+    for (const edge of document.edges) {
+        if (edge.source !== producer.id || edge.targetInput !== "media")
+            continue;
+        const outputCell = document.cells.find((cell) => cell.id === edge.target);
+        if (outputCell?.type === "image") {
+            return { outputCell, outputEdge: edge };
+        }
+    }
+    return null;
+}
+function migratedFrameOutputCell(carrier, producer, sourceCellId) {
+    const inputs = { ...(carrier.inputs ?? {}) };
+    const producerInputs = producer.inputs ?? {};
+    for (const key of ["frameMode", "timestampSeconds", "atSeconds"]) {
+        if (inputs[key] === undefined && producerInputs[key] !== undefined) {
+            inputs[key] = producerInputs[key];
+        }
+    }
+    const outputVersionArtifactIds = [...new Set([
+            ...versionArtifactIds(producer),
+            ...versionArtifactIds(carrier),
+        ])];
+    if (outputVersionArtifactIds.length > 0) {
+        inputs.outputVersionArtifactIds = outputVersionArtifactIds;
+    }
+    inputs.mediaRole = EXTRACT_FRAME_OUTPUT_ROLE;
+    if (sourceCellId)
+        inputs.sourceCellId = sourceCellId;
+    delete inputs.producerCellId;
+    const outputArtifactId = carrier.outputArtifactId ?? producer.outputArtifactId;
+    if (outputArtifactId)
+        inputs.state = "completed";
+    else if (inputs.state === "awaiting-output")
+        delete inputs.state;
+    return {
+        ...carrier,
+        operation: undefined,
+        provider: undefined,
+        model: undefined,
+        tool: undefined,
+        ...(outputArtifactId ? { outputArtifactId } : {}),
+        inputs,
+    };
+}
+export function migrateLegacyExtractAudioCells(document) {
+    const extracts = document.cells.filter((cell) => cell.type === "extract_audio");
+    if (extracts.length === 0)
+        return document;
+    const retargetEdgeIds = new Map();
+    const replaceById = new Map();
+    for (const extract of extracts) {
+        const videoEdge = document.edges.find((edge) => edge.target === extract.id && edge.targetInput === "video") ?? null;
+        if (videoEdge)
+            retargetEdgeIds.set(videoEdge.id, extract.id);
+        const inputs = { ...(extract.inputs ?? {}) };
+        inputs.mediaRole = EXTRACT_AUDIO_OUTPUT_ROLE;
+        if (videoEdge)
+            inputs.sourceCellId = videoEdge.source;
+        delete inputs.producerCellId;
+        if (extract.outputArtifactId)
+            inputs.state = "completed";
+        else if (inputs.state === "awaiting-output")
+            delete inputs.state;
+        replaceById.set(extract.id, {
+            ...extract,
+            type: "audio",
+            operation: undefined,
+            provider: undefined,
+            model: undefined,
+            tool: undefined,
+            inputs,
+        });
+    }
+    const cells = document.cells.map((cell) => replaceById.get(cell.id) ?? cell);
+    const seenTargetInputs = new Set();
+    const edges = [];
+    for (const edge of document.edges) {
+        const retarget = retargetEdgeIds.get(edge.id);
+        const target = retarget ?? edge.target;
+        const targetInput = retarget === undefined ? edge.targetInput : "segment";
+        const next = target === edge.target && targetInput === edge.targetInput
+            ? edge
+            : { ...edge, target, targetInput };
+        const key = `${next.target}:${next.targetInput}`;
+        if (seenTargetInputs.has(key))
+            continue;
+        seenTargetInputs.add(key);
+        edges.push(next);
+    }
+    return { ...document, cells, edges };
+}
+export function migrateLegacyExtractFrameCells(document) {
+    const producers = document.cells.filter((cell) => isLegacyExtractFrameProducer(document, cell));
+    if (producers.length === 0)
+        return document;
+    const deletedCellIds = new Set();
+    const deletedEdgeIds = new Set();
+    const rewireFrom = new Map();
+    const retargetEdgeIds = new Map();
+    const replaceById = new Map();
+    for (const producer of producers) {
+        const videoEdge = document.edges.find((edge) => edge.target === producer.id && edge.targetInput === "video") ?? null;
+        const sourceCellId = videoEdge?.source ?? null;
+        const pair = findLegacyExtractFrameOutput(document, producer);
+        const carrier = pair?.outputCell ?? producer;
+        if (pair) {
+            deletedCellIds.add(producer.id);
+            deletedEdgeIds.add(pair.outputEdge.id);
+            rewireFrom.set(producer.id, carrier.id);
+        }
+        if (videoEdge)
+            retargetEdgeIds.set(videoEdge.id, carrier.id);
+        replaceById.set(carrier.id, migratedFrameOutputCell(carrier, producer, sourceCellId));
+    }
+    const cells = document.cells
+        .filter((cell) => !deletedCellIds.has(cell.id))
+        .map((cell) => replaceById.get(cell.id) ?? cell);
+    const seenTargetInputs = new Set();
+    const edges = [];
+    for (const edge of document.edges) {
+        if (deletedEdgeIds.has(edge.id))
+            continue;
+        const retarget = retargetEdgeIds.get(edge.id);
+        if (retarget === undefined && deletedCellIds.has(edge.target))
+            continue;
+        const source = deletedCellIds.has(edge.source)
+            ? rewireFrom.get(edge.source) ?? edge.source
+            : edge.source;
+        const target = retarget ?? edge.target;
+        const targetInput = retarget === undefined ? edge.targetInput : "segment";
+        const next = source === edge.source
+            && target === edge.target
+            && targetInput === edge.targetInput
+            ? edge
+            : { ...edge, source, target, targetInput };
+        const key = `${next.target}:${next.targetInput}`;
+        if (seenTargetInputs.has(key))
+            continue;
+        seenTargetInputs.add(key);
+        edges.push(next);
+    }
+    const execution = { ...(document.execution ?? {}) };
+    for (const cellId of deletedCellIds) {
+        delete execution[cellId];
+    }
+    for (const carrierId of replaceById.keys()) {
+        if (execution[carrierId]?.status === "awaiting-output") {
+            delete execution[carrierId];
+        }
+    }
+    return {
+        ...document,
+        cells,
+        edges,
+        execution,
+    };
+}
+const GENERATE_IMAGE_OUTPUT_ROLE = "generate-image-output";
+const GENERATE_VIDEO_OUTPUT_ROLE = "generate-video-output";
+const GENERATE_AUDIO_OUTPUT_ROLE = "generate-audio-output";
+const IMAGE_OUTPUT_SPEC = {
+    producerType: "generate_image",
+    outputType: "image",
+    mediaRole: GENERATE_IMAGE_OUTPUT_ROLE,
+    labelSuffix: "image",
+    concurrent: true,
+};
+const VIDEO_OUTPUT_SPEC = {
+    producerType: "generate_video",
+    outputType: "video",
+    mediaRole: GENERATE_VIDEO_OUTPUT_ROLE,
+    labelSuffix: "video",
+    concurrent: true,
+};
+const AUDIO_OUTPUT_SPEC = {
+    producerType: "generate_audio",
+    outputType: "audio",
+    mediaRole: GENERATE_AUDIO_OUTPUT_ROLE,
+    labelSuffix: "audio",
+    concurrent: false,
+};
+export function isConcurrentGenerationProducer(cell) {
+    return cell.type === "generate_image" || cell.type === "generate_video";
+}
+export function isImageVideoGenerationResult(cell) {
+    const role = cell.inputs?.mediaRole;
+    return (cell.type === "image" && role === GENERATE_IMAGE_OUTPUT_ROLE)
+        || (cell.type === "video" && role === GENERATE_VIDEO_OUTPUT_ROLE);
+}
+function generationAcceptedAt(cell) {
+    return typeof cell.inputs?.acceptedAt === "string" ? cell.inputs.acceptedAt : "";
+}
+function compareGenerationResults(left, right) {
+    const byAccepted = generationAcceptedAt(left.outputCell)
+        .localeCompare(generationAcceptedAt(right.outputCell));
+    if (byAccepted !== 0)
+        return byAccepted;
+    return left.outputCell.id.localeCompare(right.outputCell.id);
+}
+function listGenerationOutputs(document, producerCellId, spec) {
+    const matches = [];
+    for (const edge of document.edges) {
+        if (edge.source !== producerCellId || edge.targetInput !== "media")
+            continue;
+        const outputCell = document.cells.find((cell) => cell.id === edge.target);
+        if (outputCell?.type !== spec.outputType)
+            continue;
+        if (isPublishedPostCell(outputCell))
+            continue;
+        const role = outputCell.inputs?.mediaRole;
+        const producer = outputCell.inputs?.producerCellId;
+        if (role === spec.mediaRole
+            || producer === producerCellId
+            || (role === undefined && producer === undefined)) {
+            matches.push({ outputCell, outputEdge: edge });
+        }
+    }
+    return matches.sort(compareGenerationResults);
+}
+export function listGenerateImageOutputs(document, generateImageCellId) {
+    return listGenerationOutputs(document, generateImageCellId, IMAGE_OUTPUT_SPEC);
+}
+export function listGenerateVideoOutputs(document, generateVideoCellId) {
+    return listGenerationOutputs(document, generateVideoCellId, VIDEO_OUTPUT_SPEC);
+}
+function latestCompletedResult(matches) {
+    if (matches.length === 0)
+        return null;
+    const completed = [...matches].reverse().find((match) => typeof match.outputCell.outputArtifactId === "string"
+        && match.outputCell.outputArtifactId.length > 0);
+    return completed ?? matches[matches.length - 1] ?? null;
+}
+function generationOutputInputs(cell, producerCellId, mediaRole, identity) {
+    return {
+        ...(cell.inputs ?? {}),
+        mediaRole,
+        producerCellId,
+        ...(identity?.runId ? { generationRunId: identity.runId } : {}),
+        ...(identity?.planId ? { generationPlanId: identity.planId } : {}),
+        ...(identity?.acceptedAt ? { acceptedAt: identity.acceptedAt } : {}),
+    };
+}
+function generationOutputLabel(producer, labelSuffix) {
+    const base = producer.label ?? notebookGridTag(producer.slot);
+    return `${base} ${labelSuffix}`;
+}
+function stampGenerationOutputCell(producer, outputCell, spec, identity) {
+    const inheritedOutput = {
+        ...outputCell,
+        ...(outputCell.prompt === undefined && producer.prompt !== undefined
+            ? { prompt: producer.prompt }
+            : {}),
+        ...(outputCell.provider === undefined && producer.provider !== undefined
+            ? { provider: producer.provider }
+            : {}),
+        ...(outputCell.model === undefined && producer.model !== undefined
+            ? { model: producer.model }
+            : {}),
+        ...(outputCell.tool === undefined && producer.tool !== undefined
+            ? { tool: producer.tool }
+            : {}),
+    };
+    const inputs = generationOutputInputs(inheritedOutput, producer.id, spec.mediaRole, identity);
+    if (spec.concurrent) {
+        delete inputs.outputVersionArtifactIds;
+    }
+    return { ...inheritedOutput, inputs };
+}
+function requireProducer(document, cellId, spec) {
+    const producer = document.cells.find((cell) => cell.id === cellId);
+    if (producer?.type !== spec.producerType) {
+        const label = spec.producerType === "generate_image"
+            ? "Generate Image"
+            : spec.producerType === "generate_audio"
+                ? "Generate Audio"
+                : "Generate Video";
+        throw new Error(`${label} cell not found: ${cellId}`);
+    }
+    return producer;
+}
+function allocateGenerationResult(engine, document, producerCellId, spec, identity) {
+    const producer = requireProducer(document, producerCellId, spec);
+    const occupied = notebookOccupiedSlots(document.cells);
+    const created = engine.notebooks.createCell({
+        type: spec.outputType,
+        label: generationOutputLabel(producer, spec.labelSuffix),
+        slot: nextGenerationOutputSlot(spec.producerType, producer.slot, occupied),
+        inputs: {
+            state: identity.state ?? "pending",
+        },
+        ...(identity.artifactId ? { outputArtifactId: identity.artifactId } : {}),
+    });
+    const outputCell = stampGenerationOutputCell(producer, created, spec, identity);
+    const outputEdge = engine.notebooks.createEdge({
+        source: producer.id,
+        target: outputCell.id,
+        targetInput: "media",
+    });
+    return {
+        document: {
+            ...document,
+            cells: [
+                ...document.cells.map((cell) => cell.id === producer.id && producer.outputArtifactId
+                    ? { ...cell, outputArtifactId: undefined }
+                    : cell),
+                outputCell,
+            ],
+            edges: [...document.edges, outputEdge],
+        },
+        outputCell,
+        outputEdge,
+        created: true,
+        updated: false,
+    };
+}
+export function allocateGenerateImageResult(engine, document, generateImageCellId, identity) {
+    return allocateGenerationResult(engine, document, generateImageCellId, IMAGE_OUTPUT_SPEC, identity);
+}
+export function allocateGenerateVideoResult(engine, document, generateVideoCellId, identity) {
+    return allocateGenerationResult(engine, document, generateVideoCellId, VIDEO_OUTPUT_SPEC, identity);
+}
+export function allocateGenerateAudioResult(engine, document, generateAudioCellId, identity) {
+    return allocateGenerationResult(engine, document, generateAudioCellId, AUDIO_OUTPUT_SPEC, identity);
+}
+function existingResultForArtifact(matches, artifactId) {
+    return matches.find((match) => match.outputCell.outputArtifactId === artifactId);
+}
+function stripVersionStack(cell) {
+    if (!("outputVersionArtifactIds" in (cell.inputs ?? {})))
+        return cell;
+    const inputs = { ...(cell.inputs ?? {}) };
+    delete inputs.outputVersionArtifactIds;
+    return { ...cell, inputs };
+}
+function expandStackedProducer(engine, document, producer, spec) {
+    let working = document;
+    let results = listGenerationOutputs(working, producer.id, spec);
+    if (results.length === 0 && producer.outputArtifactId) {
+        const allocated = allocateGenerationResult(engine, working, producer.id, spec, {
+            runId: `legacy-inline-${producer.id}`,
+            acceptedAt: producer.id,
+            artifactId: producer.outputArtifactId,
+            state: "completed",
+        });
+        working = {
+            ...allocated.document,
+            cells: allocated.document.cells.map((cell) => cell.id === producer.id ? { ...cell, outputArtifactId: undefined } : cell),
+        };
+        results = listGenerationOutputs(working, producer.id, spec);
+    }
+    const leftoverInline = working.cells.find((cell) => cell.id === producer.id)
+        ?.outputArtifactId;
+    if (leftoverInline && !existingResultForArtifact(results, leftoverInline)) {
+        const allocated = allocateGenerationResult(engine, working, producer.id, spec, {
+            runId: `legacy-inline-${leftoverInline}`,
+            acceptedAt: "0",
+            artifactId: leftoverInline,
+            state: "completed",
+        });
+        working = allocated.document;
+        results = listGenerationOutputs(working, producer.id, spec);
+    }
+    else if (leftoverInline) {
+        working = {
+            ...working,
+            cells: working.cells.map((cell) => cell.id === producer.id ? { ...cell, outputArtifactId: undefined } : cell),
+        };
+    }
+    for (const result of results) {
+        const versions = versionArtifactIds(result.outputCell);
+        const current = result.outputCell.outputArtifactId ?? versions.at(-1);
+        const historical = versions.filter((artifactId) => artifactId !== current);
+        if (historical.length === 0) {
+            if (result.outputCell.inputs?.outputVersionArtifactIds) {
+                working = {
+                    ...working,
+                    cells: working.cells.map((cell) => cell.id === result.outputCell.id ? stripVersionStack(cell) : cell),
+                };
+            }
+            continue;
+        }
+        working = {
+            ...working,
+            cells: working.cells.map((cell) => {
+                if (cell.id !== result.outputCell.id)
+                    return cell;
+                const inputs = { ...(cell.inputs ?? {}) };
+                delete inputs.outputVersionArtifactIds;
+                if (current)
+                    inputs.state = "completed";
+                return {
+                    ...cell,
+                    ...(current ? { outputArtifactId: current } : {}),
+                    inputs,
+                };
+            }),
+        };
+        const live = listGenerationOutputs(working, producer.id, spec);
+        for (const artifactId of historical) {
+            if (existingResultForArtifact(live, artifactId))
+                continue;
+            const allocated = allocateGenerationResult(engine, working, producer.id, spec, {
+                runId: `legacy-stack-${artifactId}`,
+                acceptedAt: "0",
+                artifactId,
+                state: "completed",
+            });
+            working = allocated.document;
+            live.push({
+                outputCell: allocated.outputCell,
+                outputEdge: allocated.outputEdge,
+            });
+        }
+    }
+    return working;
+}
+export function migrateStackedGenerationResults(engine, document) {
+    let working = document;
+    for (const cell of document.cells) {
+        if (cell.type === "generate_image") {
+            working = expandStackedProducer(engine, working, cell, IMAGE_OUTPUT_SPEC);
+        }
+        else if (cell.type === "generate_video") {
+            working = expandStackedProducer(engine, working, cell, VIDEO_OUTPUT_SPEC);
+        }
+    }
+    return working;
+}
+function lookupLatestResult(document, producerCellId, spec, fallback) {
+    const listed = listGenerationOutputs(document, producerCellId, spec);
+    return latestCompletedResult(listed) ?? fallback(document, producerCellId);
+}
+export function findGenerateVideoOutput(document, generateVideoCellId) {
+    return lookupLatestResult(document, generateVideoCellId, VIDEO_OUTPUT_SPEC, findGenerateVideoOutputCell);
+}
+export function findGenerateImageOutput(document, generateImageCellId) {
+    return lookupLatestResult(document, generateImageCellId, IMAGE_OUTPUT_SPEC, findGenerateImageOutputCell);
+}
+export function findGenerateAudioOutput(document, generateAudioCellId) {
+    return findGenerateAudioOutputCell(document, generateAudioCellId);
+}
+export function findGenerationResultForRun(document, producer, identity) {
+    if (identity.outputCellId) {
+        const outputCell = document.cells.find((cell) => cell.id === identity.outputCellId);
+        const outputEdge = document.edges.find((edge) => edge.source === producer.id
+            && edge.target === identity.outputCellId
+            && edge.targetInput === "media");
+        if (!outputCell || !outputEdge)
+            return null;
+        const boundRunId = outputCell.inputs?.generationRunId
+            ?? document.execution?.[outputCell.id]?.runId;
+        if (identity.runId
+            && typeof boundRunId === "string"
+            && boundRunId !== identity.runId) {
+            return null;
+        }
+        return { outputCell, outputEdge };
+    }
+    if (identity.runId) {
+        const spec = producer.type === "generate_image"
+            ? IMAGE_OUTPUT_SPEC
+            : producer.type === "generate_video"
+                ? VIDEO_OUTPUT_SPEC
+                : AUDIO_OUTPUT_SPEC;
+        const match = listGenerationOutputs(document, producer.id, spec).find((item) => item.outputCell.inputs?.generationRunId === identity.runId
+            || document.execution?.[item.outputCell.id]?.runId === identity.runId);
+        if (match)
+            return match;
+        if (spec.concurrent)
+            return null;
+    }
+    return findGenerationMediaOutput(document, producer);
+}
+function ensureAudioOutput(engine, document, generateAudioCellId) {
+    const producer = requireProducer(document, generateAudioCellId, AUDIO_OUTPUT_SPEC);
+    const existing = findGenerateAudioOutput(document, generateAudioCellId);
+    if (existing) {
+        const outputCell = stampGenerationOutputCell(producer, existing.outputCell, AUDIO_OUTPUT_SPEC);
+        const inlineArtifactId = producer.outputArtifactId;
+        const withInline = inlineArtifactId && !outputCell.outputArtifactId
+            ? {
+                ...outputCell,
+                outputArtifactId: inlineArtifactId,
+                inputs: { ...outputCell.inputs, state: "completed" },
+            }
+            : outputCell;
+        const unchanged = existing.outputCell.inputs?.mediaRole === AUDIO_OUTPUT_SPEC.mediaRole
+            && existing.outputCell.inputs?.producerCellId === generateAudioCellId
+            && existing.outputCell.prompt === withInline.prompt
+            && existing.outputCell.provider === withInline.provider
+            && existing.outputCell.model === withInline.model
+            && existing.outputCell.tool === withInline.tool
+            && !producer.outputArtifactId;
+        if (unchanged) {
+            return { document, ...existing, created: false, updated: false };
+        }
+        return {
+            document: {
+                ...document,
+                cells: document.cells.map((cell) => {
+                    if (cell.id === withInline.id)
+                        return withInline;
+                    if (cell.id === producer.id && producer.outputArtifactId) {
+                        return { ...cell, outputArtifactId: undefined };
+                    }
+                    return cell;
+                }),
+            },
+            outputCell: withInline,
+            outputEdge: existing.outputEdge,
+            created: false,
+            updated: true,
+        };
+    }
+    return allocateGenerationResult(engine, document, generateAudioCellId, AUDIO_OUTPUT_SPEC, {
+        runId: `audio-${generateAudioCellId}`,
+        acceptedAt: generateAudioCellId,
+        ...(producer.outputArtifactId
+            ? { artifactId: producer.outputArtifactId, state: "completed" }
+            : {}),
+    });
+}
+export function ensureGenerateVideoOutput(engine, document, generateVideoCellId) {
+    const producer = requireProducer(document, generateVideoCellId, VIDEO_OUTPUT_SPEC);
+    const migrated = expandStackedProducer(engine, document, producer, VIDEO_OUTPUT_SPEC);
+    const existing = findGenerateVideoOutput(migrated, generateVideoCellId);
+    if (existing) {
+        return {
+            document: migrated,
+            ...existing,
+            created: migrated !== document,
+            updated: migrated !== document,
+        };
+    }
+    return allocateGenerateVideoResult(engine, migrated, generateVideoCellId, {
+        runId: `legacy-ensure-${generateVideoCellId}`,
+        acceptedAt: generateVideoCellId,
+    });
+}
+export function ensureGenerateImageOutput(engine, document, generateImageCellId) {
+    const producer = requireProducer(document, generateImageCellId, IMAGE_OUTPUT_SPEC);
+    const migrated = expandStackedProducer(engine, document, producer, IMAGE_OUTPUT_SPEC);
+    const existing = findGenerateImageOutput(migrated, generateImageCellId);
+    if (existing) {
+        return {
+            document: migrated,
+            ...existing,
+            created: migrated !== document,
+            updated: migrated !== document,
+        };
+    }
+    return allocateGenerateImageResult(engine, migrated, generateImageCellId, {
+        runId: `legacy-ensure-${generateImageCellId}`,
+        acceptedAt: generateImageCellId,
+    });
+}
+export function ensureGenerateAudioOutput(engine, document, generateAudioCellId) {
+    return ensureAudioOutput(engine, document, generateAudioCellId);
+}
+export function findGenerationMediaOutput(document, cell) {
+    if (cell.type === "generate_video") {
+        return findGenerateVideoOutput(document, cell.id);
+    }
+    if (cell.type === "generate_image") {
+        return findGenerateImageOutput(document, cell.id);
+    }
+    if (cell.type === "generate_audio") {
+        return findGenerateAudioOutput(document, cell.id);
+    }
+    return null;
+}
+export function ensureGenerationMediaOutput(engine, document, cell) {
+    if (cell.type === "generate_audio") {
+        return ensureGenerateAudioOutput(engine, document, cell.id);
+    }
+    if (cell.type === "generate_video") {
+        const existing = findGenerateVideoOutput(document, cell.id);
+        if (existing)
+            return { document, ...existing, created: false, updated: false };
+        throw new Error(`Generate Video result cell is not allocated for ${cell.id}`);
+    }
+    if (cell.type === "generate_image") {
+        const existing = findGenerateImageOutput(document, cell.id);
+        if (existing)
+            return { document, ...existing, created: false, updated: false };
+        throw new Error(`Generate Image result cell is not allocated for ${cell.id}`);
+    }
+    throw new Error(`Generation output cell is not supported for ${cell.type}`);
+}
+export function ensureGenerationMediaOutputs(engine, document) {
+    let working = migrateStackedGenerationResults(engine, document);
+    for (const cell of working.cells) {
+        if (cell.type !== "generate_audio")
+            continue;
+        working = ensureGenerateAudioOutput(engine, working, cell.id).document;
+    }
+    return working;
+}