videobook 0.0.0-stage → 0.2.0

package/dist/notebook-run-plan.js

@@ -0,0 +1,519 @@
+import { v7 as uuidv7 } from "uuid";
+import { notebookGridTag } from "videobook-engine/notebook-grid";
+import { mutateNotebook } from "./notebook-mutations.js";
+import { failQueuedNotebookCells, notebookCellDefinitionFingerprint, notebookCellIsPaid, notebookCellIsRunnable, notebookCellIsStale, notebookCellMediaType, prepareNotebookGeneration, topologicalOrder, } from "./jobs/run-notebook.js";
+import { queue } from "./queue.js";
+import { assessToolCallEstimate, logUnavailableCostEstimate, } from "./jobs/cost-estimate-assessment.js";
+export function notebookRunPlanRecords(document) {
+    return (document.notebookRunPlans ?? []);
+}
+async function persistNotebookRunPlan(engine, notebookId, record) {
+    const result = await mutateNotebook(engine, notebookId, "persist_notebook_run_plan", (document) => ({
+        ...document,
+        notebookRunPlans: [
+            ...notebookRunPlanRecords(document).filter((candidate) => candidate.planId !== record.planId),
+            record,
+        ],
+    }), {
+        planId: record.planId,
+        status: record.status,
+        paidCellIds: record.paidCellIds,
+        knownCostUsd: record.knownCostUsd,
+        unknownCostCount: record.unknownCostCount,
+    });
+    if (!result.ok)
+        throw new Error(result.error.message);
+}
+async function estimateCall(engine, tool, input, correlation) {
+    const assessment = await assessToolCallEstimate(engine, tool, input);
+    if (!assessment.available) {
+        await logUnavailableCostEstimate({
+            assessment,
+            engine,
+            correlation: {
+                bookId: engine.book.get().bookId,
+                tool,
+                stage: correlation.stage,
+                ...(correlation.notebookId ? { notebookId: correlation.notebookId } : {}),
+                ...(correlation.cellId ? { cellId: correlation.cellId } : {}),
+                ...(correlation.provider ? { provider: correlation.provider } : {}),
+                ...(correlation.model ? { model: correlation.model } : {}),
+            },
+        });
+        return {
+            estimateUnavailable: true,
+            warnings: [],
+        };
+    }
+    return {
+        estimatedCostUsd: assessment.usd,
+        estimateUnavailable: false,
+        warnings: assessment.warnings,
+    };
+}
+function connectedMedia(document, cell) {
+    const cells = new Map(document.cells.map((candidate) => [
+        candidate.id,
+        candidate,
+    ]));
+    return document.edges
+        .filter((edge) => edge.target === cell.id)
+        .flatMap((edge) => {
+        const source = cells.get(edge.source);
+        if (!source)
+            return [];
+        const mediaType = notebookCellMediaType(source);
+        return [{
+                targetInput: edge.targetInput,
+                sourceCellId: source.id,
+                sourceType: source.type,
+                sourceOperation: source.operation ?? null,
+                artifactId: source.outputArtifactId ?? null,
+                disclosure: mediaType === "audio"
+                    ? edge.targetInput === "replace_audio"
+                        ? "local audio is used for post-generation soundtrack replacement"
+                        : "audio-derived context only"
+                    : mediaType === "image"
+                        ? "image bytes are disclosed to the selected provider"
+                        : mediaType === "video"
+                            ? "video bytes are disclosed when the selected model requires them"
+                            : "structured notebook context",
+            }];
+    });
+}
+function requiredSubgraphIds(document, targetCellId) {
+    const incoming = new Map();
+    for (const edge of document.edges) {
+        const sources = incoming.get(edge.target) ?? [];
+        sources.push(edge.source);
+        incoming.set(edge.target, sources);
+    }
+    const seen = new Set();
+    const stack = [targetCellId];
+    while (stack.length > 0) {
+        const id = stack.pop();
+        if (!id || seen.has(id))
+            continue;
+        seen.add(id);
+        for (const source of incoming.get(id) ?? [])
+            stack.push(source);
+    }
+    return seen;
+}
+function cellArtifactId(engine, cell) {
+    const artifactId = cell.outputArtifactId ?? null;
+    if (!artifactId)
+        return null;
+    return engine.artifacts.get(artifactId).ok ? artifactId : null;
+}
+export async function planSelectedNotebookSubgraph(engine, document, targetCellId, sourceSurface, actor) {
+    const target = document.cells.find((cell) => cell.id === targetCellId);
+    if (!target)
+        throw new Error(`Target cell not found: ${targetCellId}`);
+    const allowed = requiredSubgraphIds(document, targetCellId);
+    const ordered = topologicalOrder(document).filter((cell) => allowed.has(cell.id));
+    const planId = uuidv7();
+    const stages = [];
+    const fingerprints = {};
+    const paidCellIds = [];
+    let knownCostUsd = 0;
+    let unknownCostCount = 0;
+    const upstreamOutputs = new Map();
+    for (const cell of ordered) {
+        const missing = cellArtifactId(engine, cell) === null
+            && notebookCellIsRunnable(cell);
+        const stale = notebookCellIsStale(engine, document, cell);
+        const current = !stale && !missing && cellArtifactId(engine, cell) !== null;
+        const definitionFingerprint = notebookCellDefinitionFingerprint(document, cell);
+        fingerprints[cell.id] = definitionFingerprint;
+        const bindings = document.edges
+            .filter((edge) => edge.target === cell.id)
+            .map((edge) => {
+            const source = document.cells.find((candidate) => candidate.id === edge.source);
+            return {
+                targetInput: edge.targetInput,
+                sourceCellId: edge.source,
+                artifactId: source
+                    ? upstreamOutputs.get(source.id) ?? cellArtifactId(engine, source)
+                    : null,
+            };
+        });
+        if (current && cell.id !== target.id) {
+            const reused = cellArtifactId(engine, cell);
+            upstreamOutputs.set(cell.id, reused);
+            stages.push({
+                stageId: `${planId}:reuse:${stages.length}`,
+                kind: "reuse",
+                cellId: cell.id,
+                summary: `${notebookGridTag(cell.slot)} · reuse current output`,
+                cellDefinitionFingerprint: definitionFingerprint,
+                outputArtifactId: reused,
+                insertsOutput: false,
+            });
+            continue;
+        }
+        const paid = notebookCellIsPaid(cell);
+        const runnable = notebookCellIsRunnable(cell) || missing;
+        if (!runnable && cell.id !== target.id) {
+            upstreamOutputs.set(cell.id, cellArtifactId(engine, cell));
+            continue;
+        }
+        if (paid) {
+            paidCellIds.push(cell.id);
+            let tool = cell.tool ?? cell.operation ?? "unknown";
+            let provider = cell.provider ?? null;
+            let model = cell.model ?? null;
+            let actionInput = {};
+            let estimate = {
+                estimateUnavailable: true,
+                warnings: [],
+            };
+            try {
+                const prepared = await prepareNotebookGeneration(engine, document, cell, engine.book.get().bookId, { allowReferenceIssues: true });
+                tool = prepared.tool;
+                provider = prepared.provider;
+                model = prepared.model;
+                actionInput = prepared.input;
+                estimate = await estimateCall(engine, prepared.tool, prepared.input, {
+                    notebookId: document.id,
+                    cellId: cell.id,
+                    provider: prepared.provider,
+                    model: prepared.model,
+                    stage: "plan-subgraph",
+                });
+            }
+            catch {
+                estimate = {
+                    estimateUnavailable: true,
+                    warnings: [],
+                };
+            }
+            if (estimate.estimateUnavailable)
+                unknownCostCount += 1;
+            else
+                knownCostUsd += estimate.estimatedCostUsd ?? 0;
+            stages.push({
+                stageId: `${planId}:paid:${stages.length}`,
+                kind: "queued",
+                cellId: cell.id,
+                summary: `${notebookGridTag(cell.slot)} · ${tool}`,
+                jobType: "generation",
+                tool,
+                input: {
+                    notebook_id: document.id,
+                    cell_id: cell.id,
+                    action_input: actionInput,
+                    connected_media: connectedMedia(document, cell),
+                    cell_definition_fingerprint: definitionFingerprint,
+                    upstream_bindings: bindings,
+                    subgraph_run: true,
+                },
+                provider,
+                model,
+                requiresCoverage: true,
+                cellDefinitionFingerprint: definitionFingerprint,
+                ...(estimate.estimateUnavailable
+                    ? { estimateUnavailable: true }
+                    : { estimatedCostUsd: estimate.estimatedCostUsd }),
+                insertsOutput: false,
+            });
+        }
+        else {
+            stages.push({
+                stageId: `${planId}:local:${stages.length}`,
+                kind: "queued",
+                cellId: cell.id,
+                summary: `${notebookGridTag(cell.slot)} · automatic local rerun`,
+                jobType: "indexing",
+                tool: cell.tool ?? cell.operation ?? "run_notebook",
+                automatic: true,
+                cellDefinitionFingerprint: definitionFingerprint,
+                input: {
+                    notebook_id: document.id,
+                    cell_id: cell.id,
+                    upstream_bindings: bindings,
+                    subgraph_run: true,
+                },
+                insertsOutput: false,
+            });
+        }
+        upstreamOutputs.set(cell.id, null);
+    }
+    const confirmationRequired = paidCellIds.length > 0;
+    const plan = {
+        planVersion: 1,
+        planId,
+        sourceSurface,
+        actor,
+        bookId: engine.book.get().bookId,
+        summary: `Run selected subgraph for ${notebookGridTag(target.slot)}`,
+        normalizedReferences: [{
+                kind: "notebook",
+                targetId: document.id,
+                revision: engine.head,
+            }],
+        stages,
+        confirmation: {
+            required: confirmationRequired,
+            policy: confirmationRequired ? "always" : "reversible-single-step",
+            reason: confirmationRequired
+                ? unknownCostCount > 0
+                    ? `This selected run has ${paidCellIds.length} provider calls; ${unknownCostCount} cannot be priced`
+                    : `This selected run can incur up to $${knownCostUsd.toFixed(4)} in provider spend`
+                : "Only local reversible processing will run",
+        },
+        notebookRun: {
+            notebookId: document.id,
+            targetCellId,
+            mode: "subgraph",
+            subgraphCellIds: ordered.map((cell) => cell.id),
+            staleCellIds: stages
+                .filter((stage) => stage.kind === "queued")
+                .map((stage) => stage.cellId),
+            paidCellCount: paidCellIds.length,
+            knownCostUsd,
+            unknownCostCount,
+            noOp: stages.every((stage) => stage.kind === "reuse") && !notebookCellIsRunnable(target),
+        },
+    };
+    const now = new Date().toISOString();
+    await persistNotebookRunPlan(engine, document.id, {
+        planId,
+        status: "planned",
+        plan,
+        paidCellIds,
+        cellDefinitionFingerprints: fingerprints,
+        knownCostUsd,
+        unknownCostCount,
+        createdAt: now,
+        updatedAt: now,
+    });
+    return plan;
+}
+export async function planNotebookRun(engine, document, sourceSurface, actor, options = {}) {
+    const ordered = topologicalOrder(document);
+    const runnable = ordered.filter((cell) => notebookCellIsRunnable(cell)
+        && (options.force === true
+            || notebookCellIsStale(engine, document, cell)));
+    const paid = runnable.filter(notebookCellIsPaid);
+    const planId = uuidv7();
+    const stages = [];
+    const fingerprints = {};
+    let knownCostUsd = 0;
+    let unknownCostCount = 0;
+    for (const cell of paid) {
+        const prepared = await prepareNotebookGeneration(engine, document, cell, engine.book.get().bookId);
+        let estimate;
+        try {
+            estimate = await estimateCall(engine, prepared.tool, prepared.input, {
+                notebookId: document.id,
+                cellId: cell.id,
+                provider: prepared.provider,
+                model: prepared.model,
+                stage: "plan-workbook",
+            });
+        }
+        catch {
+            estimate = {
+                estimateUnavailable: true,
+                warnings: [],
+            };
+        }
+        if (estimate.estimateUnavailable) {
+            unknownCostCount += 1;
+        }
+        else {
+            knownCostUsd += estimate.estimatedCostUsd ?? 0;
+        }
+        const definitionFingerprint = notebookCellDefinitionFingerprint(document, cell);
+        fingerprints[cell.id] = definitionFingerprint;
+        stages.push({
+            stageId: `${planId}:queued:${stages.length}`,
+            kind: "queued",
+            summary: `${notebookGridTag(cell.slot)} · ${prepared.tool}`,
+            jobType: "generation",
+            tool: prepared.tool,
+            input: {
+                notebook_id: document.id,
+                cell_id: cell.id,
+                action_input: prepared.input,
+                connected_media: connectedMedia(document, cell),
+                cell_definition_fingerprint: definitionFingerprint,
+                workbook_run: true,
+            },
+            provider: prepared.provider,
+            model: prepared.model,
+            ...(estimate.estimateUnavailable
+                ? { estimateUnavailable: true }
+                : { estimatedCostUsd: estimate.estimatedCostUsd }),
+            insertsOutput: false,
+        });
+    }
+    if (stages.length === 0) {
+        stages.push({
+            stageId: `${planId}:queued:0`,
+            kind: "queued",
+            summary: runnable.length === 0
+                ? "Workbook is already current"
+                : `Run ${runnable.length} local workbook cells`,
+            jobType: "indexing",
+            tool: runnable.length === 0 ? "notebook_noop" : "run_notebook",
+            input: {
+                notebook_id: document.id,
+                workbook_run: true,
+                no_op: runnable.length === 0,
+            },
+            insertsOutput: false,
+        });
+    }
+    const plan = {
+        planVersion: 1,
+        planId,
+        sourceSurface,
+        actor,
+        bookId: engine.book.get().bookId,
+        summary: runnable.length === 0
+            ? "Workbook is fully current"
+            : `Run ${runnable.length} stale workbook cells`,
+        normalizedReferences: [{
+                kind: "notebook",
+                targetId: document.id,
+                revision: engine.head,
+            }],
+        stages,
+        confirmation: {
+            required: paid.length > 0,
+            policy: paid.length > 0 ? "always" : "reversible-single-step",
+            reason: paid.length > 0
+                ? unknownCostCount > 0
+                    ? `This run has ${paid.length} provider calls; ${unknownCostCount} cannot be priced`
+                    : `This run can incur up to $${knownCostUsd.toFixed(4)} in provider spend`
+                : runnable.length === 0
+                    ? "No cells need to run"
+                    : "Only local reversible processing will run",
+        },
+        notebookRun: {
+            notebookId: document.id,
+            staleCellIds: runnable.map((cell) => cell.id),
+            localCellCount: runnable.length - paid.length,
+            paidCellCount: paid.length,
+            knownCostUsd,
+            unknownCostCount,
+            noOp: runnable.length === 0,
+            force: options.force === true,
+        },
+    };
+    const now = new Date().toISOString();
+    await persistNotebookRunPlan(engine, document.id, {
+        planId,
+        status: "planned",
+        plan,
+        paidCellIds: paid.map((cell) => cell.id),
+        cellDefinitionFingerprints: fingerprints,
+        knownCostUsd,
+        unknownCostCount,
+        createdAt: now,
+        updatedAt: now,
+    });
+    return plan;
+}
+export async function claimNotebookRunPlan(engine, notebookId, planId, runId, options) {
+    let claimed = null;
+    const updatedAt = new Date().toISOString();
+    const result = await mutateNotebook(engine, notebookId, "claim_notebook_run_plan", (document) => {
+        const record = notebookRunPlanRecords(document).find((candidate) => candidate.planId === planId);
+        if (!record)
+            throw new Error("Notebook run plan is not preserved");
+        if (record.status !== "planned") {
+            throw new Error(`Notebook run plan is already ${record.status}`);
+        }
+        if (record.runId)
+            throw new Error("Notebook run plan is already claimed");
+        void options.confirmUnpriced;
+        for (const cellId of record.paidCellIds) {
+            const cell = document.cells.find((candidate) => candidate.id === cellId);
+            if (!cell)
+                throw new Error(`Planned cell was deleted: ${cellId}`);
+            const actual = notebookCellDefinitionFingerprint(document, cell);
+            const expected = record.cellDefinitionFingerprints[cellId];
+            if (actual !== expected) {
+                throw new Error(`Notebook run plan is stale for ${notebookGridTag(cell.slot)}`);
+            }
+        }
+        const notebookRun = record.plan.notebookRun;
+        const noOp = Boolean(notebookRun
+            && typeof notebookRun === "object"
+            && !Array.isArray(notebookRun)
+            && notebookRun.noOp === true);
+        const force = Boolean(notebookRun
+            && typeof notebookRun === "object"
+            && !Array.isArray(notebookRun)
+            && notebookRun.force === true);
+        const next = {
+            ...record,
+            status: noOp ? "completed" : "queued",
+            ...(!noOp ? { runId } : {}),
+            updatedAt,
+        };
+        claimed = { record: next, noOp, force };
+        return {
+            ...document,
+            notebookRunPlans: notebookRunPlanRecords(document).map((candidate) => candidate.planId === planId ? next : candidate),
+        };
+    }, { notebookId, planId, runId });
+    if (!result.ok)
+        throw new Error(result.error.message);
+    if (!claimed)
+        throw new Error("Notebook run plan claim was not persisted");
+    return claimed;
+}
+function notebookRunSubgraphCellIds(plan) {
+    const notebookRun = plan.notebookRun;
+    if (!notebookRun || typeof notebookRun !== "object" || Array.isArray(notebookRun)) {
+        return undefined;
+    }
+    const raw = notebookRun.subgraphCellIds;
+    if (!Array.isArray(raw) || raw.length === 0)
+        return undefined;
+    const cellIds = raw.filter((id) => typeof id === "string" && id.length > 0);
+    return cellIds.length === raw.length ? cellIds : undefined;
+}
+export async function enqueueNotebookRunPlan(engine, notebookId, planId, options) {
+    const runId = uuidv7();
+    const claimed = await claimNotebookRunPlan(engine, notebookId, planId, runId, { confirmUnpriced: options.confirmUnpriced });
+    if (claimed.noOp)
+        return { status: "completed", planId };
+    const record = claimed.record;
+    const jobId = `run-notebook-${notebookId}-${runId}`;
+    const cellIds = notebookRunSubgraphCellIds(record.plan);
+    try {
+        await queue.enqueue(jobId, {
+            type: "run_notebook",
+            bookId: engine.book.get().bookId,
+            notebookId,
+            runId,
+            runPlanId: planId,
+            generationPlan: record.plan,
+            actor: options.actor,
+            jobId,
+            force: claimed.force,
+            ...(cellIds ? { cellIds } : {}),
+        });
+    }
+    catch (cause) {
+        const message = cause instanceof Error ? cause.message : String(cause);
+        await failQueuedNotebookCells(engine, notebookId, {
+            cellIds: cellIds ?? [],
+            runId,
+            runPlanId: planId,
+            error: message,
+        }).catch(() => undefined);
+        throw cause;
+    }
+    return {
+        status: "queued",
+        planId,
+        runId,
+        jobId,
+    };
+}

package/dist/notebook-shots.js

@@ -0,0 +1,162 @@
+export const MAX_SHOT_SECONDS = 15;
+function roundTime(value) {
+    return Math.round(value * 1000) / 1000;
+}
+export function normalizeShots(shots, sourceDurationSeconds) {
+    if (!(sourceDurationSeconds > 0)) {
+        throw new Error("Source duration must be positive");
+    }
+    const duration = roundTime(sourceDurationSeconds);
+    const cleaned = shots
+        .map((shot) => ({
+        startSeconds: Math.max(0, Math.min(duration, shot.startSeconds)),
+        endSeconds: Math.max(0, Math.min(duration, shot.endSeconds)),
+        label: shot.label?.trim() || undefined,
+        prompt: shot.prompt?.trim() || undefined,
+    }))
+        .filter((shot) => shot.endSeconds > shot.startSeconds)
+        .sort((left, right) => left.startSeconds - right.startSeconds);
+    const raw = cleaned.length > 0
+        ? cleaned
+        : [{ startSeconds: 0, endSeconds: duration }];
+    const covered = [];
+    let cursor = 0;
+    for (const shot of raw) {
+        let start = Math.max(cursor, shot.startSeconds);
+        let end = Math.max(start, shot.endSeconds);
+        if (start > cursor) {
+            covered.push({ startSeconds: cursor, endSeconds: start });
+        }
+        if (covered.length > 0) {
+            const previous = covered[covered.length - 1];
+            if (start < previous.endSeconds)
+                start = previous.endSeconds;
+            if (end < start)
+                end = start;
+        }
+        if (end > start) {
+            covered.push({
+                startSeconds: start,
+                endSeconds: end,
+                ...(shot.label ? { label: shot.label } : {}),
+                ...(shot.prompt ? { prompt: shot.prompt } : {}),
+            });
+            cursor = end;
+        }
+    }
+    if (cursor < duration) {
+        covered.push({ startSeconds: cursor, endSeconds: duration });
+    }
+    if (covered.length === 0) {
+        covered.push({ startSeconds: 0, endSeconds: duration });
+    }
+    covered[0].startSeconds = 0;
+    covered[covered.length - 1].endSeconds = duration;
+    for (let index = 1; index < covered.length; index += 1) {
+        covered[index].startSeconds = covered[index - 1].endSeconds;
+    }
+    const finalRanges = [];
+    for (const shot of covered) {
+        const rangeDuration = roundTime(shot.endSeconds - shot.startSeconds);
+        const partCount = Math.max(1, Math.ceil(rangeDuration / MAX_SHOT_SECONDS));
+        let start = shot.startSeconds;
+        for (let part = 0; part < partCount; part += 1) {
+            const end = part === partCount - 1
+                ? shot.endSeconds
+                : roundTime(shot.startSeconds + rangeDuration * (part + 1) / partCount);
+            finalRanges.push({
+                startSeconds: start,
+                endSeconds: end,
+                ...(shot.label ? { label: shot.label } : {}),
+                ...(shot.prompt ? { prompt: shot.prompt } : {}),
+            });
+            start = end;
+        }
+    }
+    return finalRanges.map((shot, index) => {
+        const durationSeconds = roundTime(shot.endSeconds - shot.startSeconds);
+        return {
+            ordinal: index + 1,
+            startSeconds: roundTime(shot.startSeconds),
+            endSeconds: roundTime(shot.endSeconds),
+            durationSeconds,
+            label: shot.label ?? `Shot ${index + 1}`,
+            ...(shot.prompt ? { prompt: shot.prompt } : {}),
+        };
+    });
+}
+export function overlapSeconds(left, right) {
+    const start = Math.max(left.startSeconds, right.startSeconds);
+    const end = Math.min(left.endSeconds, right.endSeconds);
+    return Math.max(0, end - start);
+}
+/**
+ * Match existing analysis-owned branches to new shots by greatest tick-range
+ * overlap. Unmatched owned branches are removed; unmatched shots are created.
+ */
+export function reconcileOwnedBranches(existing, shots) {
+    const remaining = [...existing];
+    const keep = [];
+    const create = [];
+    for (const shot of shots) {
+        let bestIndex = -1;
+        let bestOverlap = 0;
+        for (let index = 0; index < remaining.length; index += 1) {
+            const candidate = remaining[index];
+            const overlap = overlapSeconds(candidate.range, shot);
+            if (overlap > bestOverlap) {
+                bestOverlap = overlap;
+                bestIndex = index;
+            }
+        }
+        if (bestIndex >= 0 && bestOverlap > 0) {
+            const [matched] = remaining.splice(bestIndex, 1);
+            keep.push({ existing: matched, shot });
+        }
+        else {
+            create.push(shot);
+        }
+    }
+    return {
+        keep,
+        create,
+        remove: remaining,
+    };
+}
+export function parseAnalysisShots(raw) {
+    if (!raw || typeof raw !== "object")
+        return [];
+    const record = raw;
+    const candidates = Array.isArray(record.shots)
+        ? record.shots
+        : Array.isArray(record.scenes)
+            ? record.scenes
+            : [];
+    const shots = [];
+    for (const candidate of candidates) {
+        if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) {
+            continue;
+        }
+        const entry = candidate;
+        const start = Number(entry.startSeconds
+            ?? entry.start
+            ?? entry.start_time
+            ?? (Array.isArray(entry.timestamp) ? entry.timestamp[0] : undefined));
+        const end = Number(entry.endSeconds
+            ?? entry.end
+            ?? entry.end_time
+            ?? (Array.isArray(entry.timestamp) ? entry.timestamp[1] : undefined));
+        if (!Number.isFinite(start) || !Number.isFinite(end) || end <= start)
+            continue;
+        shots.push({
+            startSeconds: start,
+            endSeconds: end,
+            ...(typeof entry.label === "string" ? { label: entry.label } : {}),
+            ...(typeof entry.prompt === "string" ? { prompt: entry.prompt } : {}),
+            ...(typeof entry.title === "string" && !entry.label
+                ? { label: entry.title }
+                : {}),
+        });
+    }
+    return shots;
+}