videobook 0.0.0-stage → 0.2.0

package/dist/notebook-provider-failure.js

@@ -0,0 +1,87 @@
+import { parseModelId } from "./media/model-id.js";
+const PROVIDER_LABELS = {
+    alibaba: "Alibaba",
+    elevenlabs: "ElevenLabs",
+    fal: "Fal",
+    kie: "Kie",
+    openai: "OpenAI",
+    workflow: "Workflow",
+    xai: "xAI",
+};
+const SENSITIVE_ENV_KEY = /(?:^|_)(?:api_key|access_key_id|secret_access_key|token|secret|password|authorization|credential)(?:_|$)/i;
+const SENSITIVE_FIELD = /((?:api[_-]?key|secret[_-]?access[_-]?key|access[_-]?key(?:[_-]?id)?|access[_-]?token|refresh[_-]?token|token|secret|password|authorization|credential)\s*["']?\s*[:=]\s*)(?:"[^"]*"|'[^']*'|Bearer\s+[^\s,;}\]]+|[^\s,;}\]]+)/gi;
+const SENSITIVE_QUERY = /([?&](?:api[_-]?key|key|token|access[_-]?token|refresh[_-]?token|signature|sig|credential|x-amz-credential|x-amz-signature|x-goog-signature)=)[^&\s"'<>]*/gi;
+function providerCell(engine, reference) {
+    const notebook = engine.notebooks.read(reference.notebookId);
+    if (!notebook.ok)
+        return null;
+    return notebook.value.cells.find((cell) => cell.id === reference.cellId) ?? null;
+}
+function providerLabel(cell) {
+    const key = cell?.provider?.trim() || parseModelId(cell?.model ?? "")?.provider;
+    if (!key)
+        return "Provider";
+    return PROVIDER_LABELS[key.toLowerCase()]
+        ?? key.replaceAll("_", " ").replace(/^./, (character) => character.toUpperCase());
+}
+function redactEnvironmentSecrets(message) {
+    let safe = message;
+    for (const [key, value] of Object.entries(process.env)) {
+        if (!value || value.length < 8 || !SENSITIVE_ENV_KEY.test(key))
+            continue;
+        safe = safe.replaceAll(value, "[redacted]");
+    }
+    return safe;
+}
+function sanitizeProviderFailureMessage(message) {
+    const safe = redactEnvironmentSecrets(message
+        .replace(SENSITIVE_FIELD, "$1[redacted]")
+        .replace(SENSITIVE_QUERY, "$1[redacted]"))
+        .replace(/\bBearer\s+[A-Za-z0-9._~+/=-]+/gi, "Bearer [redacted]")
+        .replace(/\bsk-[A-Za-z0-9_-]{16,}\b/g, "[redacted]")
+        .replace(/\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g, "[redacted]")
+        .replace(/\p{Cc}+/gu, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+    return safe.length > 800 ? `${safe.slice(0, 799)}…` : safe;
+}
+export function notebookProviderFailureMessage(engine, reference) {
+    const fallback = `Provider output ${reference.providerArtifactId} failed`;
+    const failure = engine.jobs.failures.read(reference.providerArtifactId);
+    if (!failure.ok || !failure.value)
+        return fallback;
+    const message = sanitizeProviderFailureMessage(failure.value.message);
+    const failCode = failure.value.failCode
+        ? sanitizeProviderFailureMessage(failure.value.failCode).slice(0, 120)
+        : "";
+    if (!message && !failCode)
+        return fallback;
+    const technical = message || failCode;
+    const detail = failCode && !technical.toLowerCase().includes(failCode.toLowerCase())
+        ? `${technical} (${failCode})`
+        : technical;
+    const prefix = `${providerLabel(providerCell(engine, reference))} failed: ${detail}`;
+    return prefix;
+}
+export function hydrateNotebookProviderFailures(engine, document) {
+    const execution = document.execution ?? {};
+    let changed = false;
+    const hydrated = Object.fromEntries(Object.entries(execution).map(([cellId, state]) => {
+        const providerArtifactId = state.providerArtifactId;
+        if (state.status !== "error"
+            || !providerArtifactId
+            || state.error !== `Provider output ${providerArtifactId} failed`) {
+            return [cellId, state];
+        }
+        const error = notebookProviderFailureMessage(engine, {
+            notebookId: document.id,
+            cellId,
+            providerArtifactId,
+        });
+        if (error === state.error)
+            return [cellId, state];
+        changed = true;
+        return [cellId, { ...state, error }];
+    }));
+    return changed ? { ...document, execution: hydrated } : document;
+}

package/dist/notebook-published-post.js

@@ -0,0 +1,26 @@
+export const PUBLISHED_POST_SOURCE_OPERATION = "post_to_x";
+export const PUBLISHED_POST_TARGET_INPUT = "post";
+export function isPublishedPostCell(cell) {
+    return cell.type === "post" || cell.inputs?.sourceOperation === PUBLISHED_POST_SOURCE_OPERATION;
+}
+export function sourceCellForPostedArtifact(notebook, artifactId, cellType) {
+    const holders = notebook.cells.filter((cell) => cell.outputArtifactId === artifactId && !isPublishedPostCell(cell));
+    if (cellType) {
+        const typed = holders.find((cell) => cell.type === cellType);
+        if (typed)
+            return typed;
+    }
+    return holders.find((cell) => cell.type === "video" || cell.type === "image")
+        ?? holders[0]
+        ?? null;
+}
+export function resolvePublishedPostSourceCell(document, cell) {
+    if (!isPublishedPostCell(cell))
+        return cell;
+    const sourceId = cell.type === "post" ? cell.inputs?.post?.source?.cellId : typeof cell.inputs?.sourceCellId === "string"
+        ? cell.inputs.sourceCellId
+        : null;
+    if (!sourceId)
+        return cell;
+    return document.cells.find((candidate) => candidate.id === sourceId) ?? cell;
+}

package/dist/notebook-reference-resolver.js

@@ -0,0 +1,227 @@
+import { isUuidV7, resolveNotebookCellArtifactId, } from "videobook-engine";
+import { notebookGridAddress, notebookGridTag, parseNotebookGridAddress, } from "videobook-engine/notebook-grid";
+import { NOTEBOOK_GRID_ADDRESS_SOURCE, normalizeNotebookReference, replaceNotebookMentions, scanNotebookMentions, } from "videobook-engine/notebook-mentions";
+import { generationInputMentions, scanGenerationInputTokens, } from "./generation-input-mentions.js";
+function mediaType(cell) {
+    if (cell.type === "image"
+        || cell.type === "generate_image")
+        return "image";
+    if (cell.type === "audio"
+        || cell.type === "extract_audio"
+        || cell.type === "generate_audio")
+        return "audio";
+    if (cell.type === "video"
+        || cell.type === "split_video"
+        || cell.type === "generate_video"
+        || cell.type === "concat"
+        || cell.type === "splice")
+        return "video";
+    return null;
+}
+function artifactRecord(engine, artifactId) {
+    if (!engine)
+        return { artifactId };
+    const artifact = engine.artifacts.get(artifactId);
+    return artifact.ok
+        ? {
+            artifactId: artifact.value.artifactId,
+            ...(artifact.value.label ? { artifactLabel: artifact.value.label } : {}),
+        }
+        : null;
+}
+function directArtifact(engine, reference) {
+    if (!engine || !isUuidV7(reference))
+        return null;
+    return artifactRecord(engine, reference);
+}
+function cellMatches(documents, reference) {
+    const slot = parseNotebookGridAddress(reference);
+    if (slot) {
+        return documents.flatMap((document) => {
+            const cell = document.cells.find((candidate) => candidate.slot.row === slot.row
+                && candidate.slot.column === slot.column);
+            return cell ? [{ document, cell }] : [];
+        });
+    }
+    const exact = documents.flatMap((document) => document.cells
+        .filter((cell) => cell.id.toLowerCase() === reference)
+        .map((cell) => ({ document, cell })));
+    if (exact.length > 0)
+        return exact;
+    return documents.flatMap((document) => document.cells
+        .filter((cell) => cell.id.toLowerCase().startsWith(reference))
+        .map((cell) => ({ document, cell })));
+}
+function issue(mention, reference, code, message) {
+    return { mention, reference, code, message };
+}
+export function resolveNotebookArtifactReference(input) {
+    const reference = normalizeNotebookReference(input.reference);
+    const mention = `@${reference}`;
+    if (!reference) {
+        return issue(mention, reference, "not_found", "Notebook reference is required");
+    }
+    const direct = directArtifact(input.engine, reference);
+    if (direct)
+        return { mention, reference, ...direct };
+    const matches = cellMatches(input.documents, reference);
+    if (matches.length === 0) {
+        return issue(mention, reference, "not_found", `Notebook reference ${mention} was not found`);
+    }
+    const mediaMatches = input.requireMedia === false
+        ? matches
+        : matches.filter(({ cell }) => mediaType(cell) !== null);
+    if (mediaMatches.length === 0) {
+        return issue(mention, reference, "not_media", `${mention} is not a media-producing cell`);
+    }
+    const outputMatches = mediaMatches.flatMap(({ document, cell }) => {
+        const artifactId = resolveNotebookCellArtifactId(document, cell);
+        return typeof artifactId === "string"
+            ? [{ document, cell, artifactId }]
+            : [];
+    });
+    if (outputMatches.length === 0) {
+        return issue(mention, reference, "no_output", `${mention} does not have media output yet`);
+    }
+    const artifactIds = [...new Set(outputMatches.map(({ artifactId }) => artifactId))];
+    if (artifactIds.length > 1) {
+        return issue(mention, reference, "ambiguous", `Notebook reference ${mention} is ambiguous; include notebook_id or a longer cell id`);
+    }
+    const artifact = artifactRecord(input.engine, artifactIds[0]);
+    if (!artifact) {
+        return issue(mention, reference, "not_found", `Media output for ${mention} was not found`);
+    }
+    const match = outputMatches[0];
+    return {
+        mention,
+        reference,
+        ...artifact,
+        cellId: match.cell.id,
+        cellAddress: notebookGridTag(match.cell.slot),
+    };
+}
+export function resolveNotebookPromptReferences(input) {
+    const resolved = [];
+    const unresolved = [];
+    const seen = new Set();
+    for (const mention of scanNotebookMentions(input.prompt)) {
+        if (seen.has(mention.reference))
+            continue;
+        seen.add(mention.reference);
+        const result = resolveNotebookArtifactReference({
+            engine: input.engine,
+            documents: [input.document],
+            reference: mention.reference,
+            requireMedia: input.requireMedia,
+        });
+        if ("code" in result) {
+            unresolved.push({ ...result, mention: mention.raw });
+        }
+        else {
+            resolved.push({ ...result, mention: mention.raw });
+        }
+    }
+    const prompt = replaceNotebookMentions(input.prompt, resolved.map((item) => ({
+        reference: item.reference,
+        replacement: `@${item.artifactId}`,
+    })));
+    const unconnected = input.connectedArtifactIds
+        ? resolved
+            .filter((item) => !input.connectedArtifactIds.has(item.artifactId))
+            .map((item) => ({
+            ...item,
+            message: `${item.mention} is referenced but not connected`,
+        }))
+        : [];
+    return { prompt, resolved, unresolved, unconnected };
+}
+function inputTokenResolution(engine, document, token, sourceCellId) {
+    const mention = `@${token}`;
+    if (!sourceCellId) {
+        return issue(mention, token, "not_found", `${mention} is not a connected input`);
+    }
+    const cell = document.cells.find((candidate) => candidate.id === sourceCellId);
+    const artifactId = cell ? resolveNotebookCellArtifactId(document, cell) : undefined;
+    if (!cell || typeof artifactId !== "string") {
+        return issue(mention, token, "no_output", `${mention} does not have media output yet`);
+    }
+    const artifact = artifactRecord(engine, artifactId);
+    if (!artifact) {
+        return issue(mention, token, "not_found", `Media output for ${mention} was not found`);
+    }
+    return {
+        mention,
+        reference: token,
+        ...artifact,
+        cellId: cell.id,
+        cellAddress: notebookGridTag(cell.slot),
+    };
+}
+function gridAddressIssues(prompt) {
+    const seen = new Set();
+    return scanNotebookMentions(prompt).flatMap((mention) => {
+        if (seen.has(mention.reference))
+            return [];
+        seen.add(mention.reference);
+        return [issue(mention.raw, mention.reference, "not_found", `${mention.raw} is a grid address; name connected inputs as @image1, @video1, @audio1`)];
+    });
+}
+/** Resolve "@image1"-style input tokens in a generation prompt to
+ *  "@<artifact-id>". Grid addresses are not inputs and stay unresolved. */
+export function resolveGenerationInputReferences(input) {
+    const sources = new Map(generationInputMentions(input.cell.id, input.document.cells, input.document.edges, typeof input.cell.inputs?.generationMode === "string" ? input.cell.inputs.generationMode : undefined)
+        .map((mention) => [mention.token, mention.sourceCellId]));
+    if (input.cell.inputs?.generationMode === "r2v") {
+        for (const mention of generationInputMentions(input.cell.id, input.document.cells, input.document.edges, "i2v")) {
+            if (mention.token === "firstframe" || mention.token === "lastframe") {
+                sources.set(mention.token, mention.sourceCellId);
+            }
+        }
+    }
+    const resolved = [];
+    const unresolved = [];
+    for (const token of new Set(scanGenerationInputTokens(input.prompt))) {
+        const result = inputTokenResolution(input.engine, input.document, token, sources.get(token));
+        if ("code" in result)
+            unresolved.push(result);
+        else
+            resolved.push(result);
+    }
+    const prompt = replaceNotebookMentions(input.prompt, resolved.map((item) => ({
+        reference: item.reference,
+        replacement: `@${item.artifactId}`,
+    })));
+    return {
+        prompt,
+        resolved,
+        unresolved: [...unresolved, ...gridAddressIssues(prompt)],
+        unconnected: [],
+    };
+}
+// A spoken or typed request names a cell the way the grid labels it: "the image
+// at A1". Bare like that it is prose, so nothing above resolves it, the draft
+// connects no inputs, and the generation prompt keeps words where an address
+// belongs. Tagging closes that gap, but only for addresses this notebook can
+// actually answer -- an unmatched token stays prose.
+const BARE_GRID_ADDRESS = new RegExp(`(?<![\\w@-])(?:${NOTEBOOK_GRID_ADDRESS_SOURCE})(?![\\w-])`, "giu");
+/** Addresses of cells that already hold media this notebook can reference. */
+export function notebookMediaAddresses(document) {
+    const addresses = new Set();
+    for (const cell of document.cells) {
+        if (mediaType(cell) === null)
+            continue;
+        if (typeof resolveNotebookCellArtifactId(document, cell) !== "string") {
+            continue;
+        }
+        addresses.add(notebookGridAddress(cell.slot));
+    }
+    return addresses;
+}
+export function tagNotebookGridAddresses(text, addresses) {
+    if (addresses.size === 0)
+        return text;
+    return text.replace(BARE_GRID_ADDRESS, (match) => {
+        const address = match.toLowerCase();
+        return addresses.has(address) ? `@${address}` : match;
+    });
+}

package/dist/notebook-relayout.js

@@ -0,0 +1,270 @@
+import { notebookCellOccupiedSlots, nearestOriginNotebookGridSlot, nextHorizontalSlotFrom, nextVerticalSlotFrom, nextWaveTileSlot, NOTEBOOK_GRID_COLUMN_COUNT, } from "videobook-engine";
+import { ensureGenerationMediaOutputs, findGenerateAudioOutput, findGenerateImageOutput, findGenerateVideoOutput, } from "./notebook-cell-outputs.js";
+import { slotBelow, slotRight } from "./notebook-placement.js";
+import { arrangeGoalNotebook } from "./notebook-goal-layout.js";
+function bySlotThenId(left, right) {
+    if (left.slot.row !== right.slot.row)
+        return left.slot.row - right.slot.row;
+    if (left.slot.column !== right.slot.column) {
+        return left.slot.column - right.slot.column;
+    }
+    return left.id.localeCompare(right.id);
+}
+function isGenerateVideoOutputCell(document, cell) {
+    if (cell.type !== "video")
+        return false;
+    if (cell.inputs?.mediaRole === "generate-video-output")
+        return true;
+    const producerId = cell.inputs?.producerCellId;
+    if (typeof producerId !== "string")
+        return false;
+    return document.cells.some((candidate) => candidate.id === producerId && candidate.type === "generate_video");
+}
+function isGenerateImageOutputCell(document, cell) {
+    if (cell.type !== "image")
+        return false;
+    if (cell.inputs?.mediaRole === "generate-image-output")
+        return true;
+    const producerId = cell.inputs?.producerCellId;
+    if (typeof producerId !== "string")
+        return false;
+    return document.cells.some((candidate) => candidate.id === producerId && candidate.type === "generate_image");
+}
+function isGenerateAudioOutputCell(document, cell) {
+    if (cell.type !== "audio")
+        return false;
+    if (cell.inputs?.mediaRole === "generate-audio-output")
+        return true;
+    const producerId = cell.inputs?.producerCellId;
+    if (typeof producerId !== "string")
+        return false;
+    return document.cells.some((candidate) => candidate.id === producerId && candidate.type === "generate_audio");
+}
+function isExtractFrameOutputCell(cell) {
+    return cell.type === "image"
+        && cell.inputs?.mediaRole === "extract-frame-output";
+}
+function migrateGenerationArtifacts(engine, document) {
+    return ensureGenerationMediaOutputs(engine, document);
+}
+function assignDirectionalSlots(document) {
+    const newSlots = new Map();
+    const occupied = [];
+    function claim(cellId, slot) {
+        newSlots.set(cellId, slot);
+        occupied.push(slot);
+    }
+    const cells = [...document.cells].sort(bySlotThenId);
+    for (const cell of cells) {
+        if (cell.type !== "timeline")
+            continue;
+        newSlots.set(cell.id, cell.slot);
+        occupied.push(...notebookCellOccupiedSlots(cell));
+    }
+    for (const cell of cells) {
+        if (cell.type !== "image"
+            || isExtractFrameOutputCell(cell)
+            || isGenerateImageOutputCell(document, cell)) {
+            continue;
+        }
+        claim(cell.id, nextHorizontalSlotFrom({ row: 0, column: 0 }, occupied));
+    }
+    for (const cell of cells) {
+        if (cell.type !== "video" || isGenerateVideoOutputCell(document, cell)) {
+            continue;
+        }
+        claim(cell.id, nextVerticalSlotFrom({ row: 0, column: 0 }, occupied));
+    }
+    for (const cell of cells) {
+        if (cell.type !== "audio" || isGenerateAudioOutputCell(document, cell)) {
+            continue;
+        }
+        claim(cell.id, nearestOriginNotebookGridSlot(occupied));
+    }
+    // Wave/lane placement, dependency-ordered so a generation lands below its
+    // sources and a frame chain continues its source video's column. Passes
+    // repeat until nothing new can be placed (unplaceable cells fall through
+    // to the catch-all).
+    function cellSources(target) {
+        const sources = [];
+        for (const edge of document.edges) {
+            if (edge.target !== target.id)
+                continue;
+            const source = document.cells.find((cell) => cell.id === edge.source);
+            if (!source)
+                continue;
+            sources.push(source);
+        }
+        return sources.every((source) => newSlots.has(source.id))
+            ? sources
+            : null;
+    }
+    function claimGenerateImagePair(tile, tileSlot) {
+        claim(tile.id, tileSlot);
+        const output = findGenerateImageOutput(document, tile.id);
+        if (output && !newSlots.has(output.outputCell.id)) {
+            claim(output.outputCell.id, nextHorizontalSlotFrom(slotRight(tileSlot), occupied));
+        }
+    }
+    function claimGenerateAudioPair(tile, tileSlot) {
+        claim(tile.id, tileSlot);
+        const output = findGenerateAudioOutput(document, tile.id);
+        if (output && !newSlots.has(output.outputCell.id)) {
+            claim(output.outputCell.id, nextHorizontalSlotFrom(slotRight(tileSlot), occupied));
+        }
+    }
+    let progressed = true;
+    while (progressed) {
+        progressed = false;
+        for (const tile of cells) {
+            if (tile.type !== "generate_image" || newSlots.has(tile.id))
+                continue;
+            const sources = cellSources(tile);
+            if (!sources)
+                continue;
+            const sourceSlots = sources.map((source) => newSlots.get(source.id));
+            const anchor = sourceSlots.length === 0
+                ? tile.slot
+                : {
+                    row: Math.min(...sourceSlots.map((slot) => slot.row)),
+                    column: Math.min(Math.max(...sourceSlots.map((slot) => slot.column)) + 1, NOTEBOOK_GRID_COLUMN_COUNT - 1),
+                };
+            claimGenerateImagePair(tile, nextHorizontalSlotFrom(anchor, occupied));
+            progressed = true;
+        }
+        for (const tile of cells) {
+            if (tile.type !== "generate_audio" || newSlots.has(tile.id))
+                continue;
+            const sources = cellSources(tile);
+            if (!sources)
+                continue;
+            const sourceSlots = sources.map((source) => newSlots.get(source.id));
+            const anchor = sourceSlots.length === 0
+                ? tile.slot
+                : {
+                    row: Math.min(...sourceSlots.map((slot) => slot.row)),
+                    column: Math.min(Math.max(...sourceSlots.map((slot) => slot.column)) + 1, NOTEBOOK_GRID_COLUMN_COUNT - 1),
+                };
+            claimGenerateAudioPair(tile, nextHorizontalSlotFrom(anchor, occupied));
+            progressed = true;
+        }
+        for (const tile of cells) {
+            if (tile.type !== "generate_video" || newSlots.has(tile.id))
+                continue;
+            const sources = cellSources(tile);
+            if (!sources)
+                continue;
+            const sourceSlots = sources.map((source) => newSlots.get(source.id));
+            const waveRow = sourceSlots.length > 0
+                ? Math.max(...sourceSlots.map((slot) => slot.row)) + 1
+                : tile.slot.row;
+            const baseRowSources = sourceSlots.length > 0
+                && sourceSlots.every((slot) => slot.row === 0);
+            const startColumn = sourceSlots.length === 0
+                ? tile.slot.column
+                : baseRowSources
+                    ? 0
+                    : sourceSlots[0].column;
+            const tileSlot = sourceSlots.length === 0
+                ? nextVerticalSlotFrom(tile.slot, occupied)
+                : nextWaveTileSlot(waveRow, startColumn, occupied);
+            claim(tile.id, tileSlot);
+            const output = findGenerateVideoOutput(document, tile.id);
+            if (output && !newSlots.has(output.outputCell.id)) {
+                claim(output.outputCell.id, nextVerticalSlotFrom(slotBelow(tileSlot), occupied));
+            }
+            progressed = true;
+        }
+        for (const action of cells) {
+            if (!isExtractFrameOutputCell(action) || newSlots.has(action.id))
+                continue;
+            const sourceEdge = document.edges.find((edge) => edge.target === action.id && edge.targetInput === "segment");
+            const sourceCellId = sourceEdge?.source
+                ?? (typeof action.inputs?.sourceCellId === "string"
+                    ? action.inputs.sourceCellId
+                    : undefined);
+            const sourceCell = sourceCellId
+                ? document.cells.find((cell) => cell.id === sourceCellId)
+                : undefined;
+            let videoSlot = null;
+            if (sourceCell?.type === "generate_video") {
+                const output = findGenerateVideoOutput(document, sourceCell.id);
+                const anchorCell = output?.outputCell ?? sourceCell;
+                videoSlot = newSlots.get(anchorCell.id) ?? null;
+            }
+            else if (sourceCell) {
+                videoSlot = newSlots.get(sourceCell.id) ?? null;
+            }
+            if (sourceCell && !videoSlot)
+                continue;
+            const anchor = videoSlot ?? { row: 0, column: 0 };
+            const actionSlot = nextHorizontalSlotFrom(slotRight(anchor), occupied);
+            claim(action.id, actionSlot);
+            progressed = true;
+        }
+    }
+    for (const cell of cells) {
+        if (newSlots.has(cell.id))
+            continue;
+        if (cell.type === "generate_image") {
+            claimGenerateImagePair(cell, nextHorizontalSlotFrom(cell.slot, occupied));
+            continue;
+        }
+        if (cell.type === "generate_audio") {
+            claimGenerateAudioPair(cell, nextHorizontalSlotFrom(cell.slot, occupied));
+            continue;
+        }
+        claim(cell.id, nearestOriginNotebookGridSlot(occupied));
+    }
+    return {
+        ...document,
+        cells: document.cells.map((cell) => ({
+            ...cell,
+            slot: newSlots.get(cell.id) ?? cell.slot,
+        })),
+    };
+}
+export function relayoutNotebookDocument(engine, document) {
+    const migrated = migrateGenerationArtifacts(engine, document);
+    if (migrated.cells.some(cell => cell.type === "goal"))
+        return arrangeGoalNotebook(migrated);
+    return assignDirectionalSlots(migrated);
+}
+export function notebookDocumentsEqual(left, right) {
+    const leftCells = [...left.cells]
+        .map((cell) => ({
+        id: cell.id,
+        type: cell.type,
+        slot: cell.slot,
+        outputArtifactId: cell.outputArtifactId ?? null,
+        inputs: cell.inputs ?? {},
+    }))
+        .sort((a, b) => a.id.localeCompare(b.id));
+    const rightCells = [...right.cells]
+        .map((cell) => ({
+        id: cell.id,
+        type: cell.type,
+        slot: cell.slot,
+        outputArtifactId: cell.outputArtifactId ?? null,
+        inputs: cell.inputs ?? {},
+    }))
+        .sort((a, b) => a.id.localeCompare(b.id));
+    const leftEdges = [...left.edges]
+        .map((edge) => ({
+        source: edge.source,
+        target: edge.target,
+        targetInput: edge.targetInput,
+    }))
+        .sort((a, b) => `${a.source}:${a.target}:${a.targetInput}`
+        .localeCompare(`${b.source}:${b.target}:${b.targetInput}`));
+    const rightEdges = [...right.edges]
+        .map((edge) => ({
+        source: edge.source,
+        target: edge.target,
+        targetInput: edge.targetInput,
+    }))
+        .sort((a, b) => `${a.source}:${a.target}:${a.targetInput}`
+        .localeCompare(`${b.source}:${b.target}:${b.targetInput}`));
+    return JSON.stringify({ cells: leftCells, edges: leftEdges })
+        === JSON.stringify({ cells: rightCells, edges: rightEdges });
+}