@gentbajko/slopify 0.8.3 → 1.0.0

package/dist/slices/rebuild/runtime-export-inputs.js

@@ -0,0 +1,109 @@
+import { readFileSync } from "node:fs";
+import { z } from "zod";
+import { plainText } from "../article/plain.js";
+import { splitEndMatter } from "../article/split.js";
+import { outputPath } from "../storage/layout.js";
+import { probeDurationMs } from "../video/ffmpeg.js";
+import { audioTimeline } from "../video/plan.js";
+import { executionPlan, executionView, savedCatalogue } from "./runtime-plan.js";
+export function exportSnapshot(deps, context, piece) {
+    const view = executionView(deps, context.work.projectId, context.work.revisionId);
+    const row = deps.db
+        .prepare("SELECT recipe_context FROM revision_work WHERE id=?")
+        .get(context.work.workId);
+    if (view === undefined || row === undefined)
+        throw new Error("The export revision no longer exists.");
+    const plan = executionPlan(deps, view, savedCatalogue(row.recipe_context));
+    const recipe = plan.recipes.find((one) => one.key === piece.key && one.fingerprint === piece.fingerprint);
+    if (recipe === undefined || recipe.deferred || recipe.unresolved)
+        throw new Error("The export inputs do not match the admitted recipe.");
+    return { view, plan };
+}
+export async function revisionAudio(deps, context, view) {
+    const config = view.revision.config;
+    if (config.sources.audio === "off")
+        return [];
+    const input = async (role) => {
+        const row = view.outputs.find((one) => one.selected && one.available && one.state === "ready" && one.output.role === role);
+        if (row === undefined)
+            return undefined;
+        const path = outputPath(deps.paths, context.work.projectId, row.output.path);
+        const duration = row.output.durationMs ??
+            (await (deps.measureAudio?.(path, context.signal) ??
+                probeDurationMs(deps.ffmpeg, path, context.signal, deps.log)));
+        if (!Number.isFinite(duration) || duration <= 0)
+            throw new Error("The narration duration could not be measured.");
+        return { path, seconds: duration / 1000 };
+    };
+    const body = await input("audio_body");
+    if (body === undefined)
+        throw new Error("The revision has no complete narration.");
+    return audioTimeline({
+        body,
+        intro: config.sources.audio === "generate" && config.intro !== undefined
+            ? await input("audio_intro")
+            : undefined,
+        outro: config.sources.audio === "generate" && config.outro !== undefined
+            ? await input("audio_outro")
+            : undefined,
+        gapSeconds: config.silenceGapSeconds,
+    }, config.sources.video === "off" ? 1 / 48000 : 1 / 30);
+}
+export function revisionTranscript(deps, snapshot, kind) {
+    const { view, plan } = snapshot;
+    const concat = plan.recipes.find((one) => one.key === (kind === "body" ? "audio:body:concat" : `audio:${kind}`));
+    if (concat !== undefined) {
+        const texts = concat.dependsOn.map((key) => {
+            const row = view.pieces.find((one) => one.key === key && one.selected && one.available && one.piece.state === "done");
+            const payload = row?.piece.payload === null || row?.piece.payload === undefined
+                ? undefined
+                : z.object({ text: z.string().optional() }).parse(JSON.parse(row.piece.payload));
+            if (payload?.text !== undefined)
+                return payload.text;
+            const recipe = plan.recipes.find((one) => one.key === key);
+            if (recipe?.input.kind === "tts")
+                return recipe.input.text;
+            if (recipe?.input.kind === "provided" &&
+                Array.isArray(recipe.input.semantic) &&
+                typeof recipe.input.semantic[0] === "string")
+                return recipe.input.semantic[0];
+            throw new Error("The saved narration transcript is incomplete.");
+        });
+        if (texts.length > 0)
+            return texts.join("\n");
+    }
+    if (kind === "body") {
+        const row = view.outputs.find((one) => one.selected && one.available && one.state === "ready" && one.output.role === "article_txt");
+        if (row !== undefined)
+            return readFileSync(outputPath(deps.paths, view.revision.projectId, row.output.path), "utf8");
+        if (view.articleMarkdown !== null)
+            return plainText(splitEndMatter(view.articleMarkdown).body);
+    }
+    throw new Error(`The saved ${kind} narration transcript is missing.`);
+}
+export function retainedOutput(deps, view, row) {
+    const asset = z
+        .object({
+        id: z.string(),
+        project_id: z.string(),
+        path: z.string(),
+        bytes: z.number(),
+        created_at: z.string(),
+    })
+        .parse(deps.db
+        .prepare("SELECT * FROM project_assets WHERE id=? AND project_id=?")
+        .get(row.assetId, view.revision.projectId));
+    return {
+        slot: row.slot,
+        workKey: row.workKey,
+        fingerprint: row.fingerprint,
+        asset: {
+            id: asset.id,
+            projectId: asset.project_id,
+            path: asset.path,
+            bytes: asset.bytes,
+            createdAt: asset.created_at,
+        },
+        output: { ...row.output, id: deps.ids.next(), createdAt: deps.clock.now().toISOString() },
+    };
+}

package/dist/slices/rebuild/runtime-export.js

@@ -0,0 +1,139 @@
+import { copyFileSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { extname, join, relative, sep } from "node:path";
+import { allocateAsset, discardPreparedAssets, sealAsset } from "../storage/assets.js";
+import { outputPath, projectDir } from "../storage/layout.js";
+import { audioExportArgs } from "../video/audio-export.js";
+import { renderArgs, runFfmpeg } from "../video/ffmpeg.js";
+import { planRender } from "../video/plan.js";
+import { exportSnapshot, retainedOutput, revisionAudio, } from "./runtime-export-inputs.js";
+import { preparedResult, preparedText, publishResult } from "./runtime-publication.js";
+export async function executeExportRecipe(deps, context, piece) {
+    if (deps.db
+        .prepare("SELECT state FROM revision_work_pieces WHERE id=? AND work_id=?")
+        .get(piece.id, context.work.workId)?.state === "done")
+        return "done";
+    if (!context.maySubmit(piece.id))
+        return "held";
+    context.signal.throwIfAborted();
+    const snapshot = exportSnapshot(deps, context, piece);
+    const { view } = snapshot;
+    const audio = await revisionAudio(deps, context, view);
+    const wav = piece.key === "export:wav";
+    if (!wav && piece.key !== "export:video")
+        throw new Error("Unknown media export recipe.");
+    if (wav && audio.length === 0)
+        throw new Error("Audio export needs complete narration.");
+    const filename = wav ? "audio.wav" : "video.mp4";
+    const pending = allocateAsset(deps, context.work.projectId, filename);
+    const prepared = [];
+    let directory;
+    try {
+        const captions = snapshot.view.outputs.filter((row) => row.selected && row.available && row.state === "ready" && row.workKey === "subtitles:files");
+        const burn = !wav && view.revision.config.subtitles?.mode === "burn-in";
+        if (burn)
+            directory = captionDirectory(deps, context, snapshot);
+        const mode = burn
+            ? "burn-in"
+            : captions.some((row) => row.output.role === "subtitles_srt") &&
+                captions.some((row) => row.output.role === "subtitles_vtt")
+                ? "files"
+                : "off";
+        const config = view.revision.config;
+        const segment = (kind) => {
+            const row = audio.find((one) => one.kind === kind);
+            return row?.path === null || row === undefined
+                ? undefined
+                : { path: row.path, seconds: row.seconds };
+        };
+        const images = (wav ? [] : view.revision.content.imageOrder).map((key) => {
+            const row = view.outputs.find((one) => one.workKey === `image:${key}` && one.selected && one.available && one.state === "ready");
+            if (row === undefined)
+                throw new Error("The revision is missing an image selected for its slideshow.");
+            return outputPath(deps.paths, context.work.projectId, row.output.path);
+        });
+        const plan = wav
+            ? undefined
+            : planRender({
+                format: config.format,
+                gapSeconds: config.silenceGapSeconds,
+                body: segment("body"),
+                intro: segment("intro"),
+                outro: segment("outro"),
+                images,
+                output: pending.absolutePath,
+            });
+        const totalSeconds = plan?.totalSeconds ?? audio.reduce((sum, row) => sum + row.seconds, 0);
+        const projectDirectory = projectDir(deps.paths, context.work.projectId);
+        const relativePath = (path) => relative(projectDirectory, path).split(sep).join("/");
+        const record = plan === undefined
+            ? {
+                sampleRate: 48000,
+                channels: 2,
+                codec: "pcm_s16le",
+                gapSeconds: config.silenceGapSeconds,
+                totalSeconds,
+                audio: audio.map((row) => ({
+                    ...row,
+                    path: row.path === null ? null : relativePath(row.path),
+                })),
+                output: pending.path,
+            }
+            : {
+                ...plan,
+                output: pending.path,
+                audio: plan.audio.map((row) => ({
+                    ...row,
+                    path: row.path === null ? null : relativePath(row.path),
+                })),
+                images: plan.images.map((row) => ({ ...row, path: relativePath(row.path) })),
+                subtitles: config.subtitles,
+            };
+        if (!context.maySubmit(piece.id))
+            return "held";
+        await runFfmpeg({
+            bin: deps.ffmpeg,
+            args: plan === undefined ? audioExportArgs(audio, pending.absolutePath) : renderArgs(plan, burn),
+            cwd: directory,
+            signal: context.signal,
+            log: deps.log,
+            onProgress: (elapsedMs) => context.emit({
+                type: "stage.progress",
+                projectId: context.work.projectId,
+                stage: "video",
+                current: Math.min(100, Math.round(elapsedMs / (totalSeconds * 10))),
+                total: 100,
+            }),
+        });
+        context.signal.throwIfAborted();
+        const asset = sealAsset(deps, pending);
+        prepared.push(preparedResult(deps, context, piece, wav ? "audio_export" : "video", asset, Math.round(totalSeconds * 1000), { subtitlesMode: mode }));
+        prepared.push(preparedText(deps, context, piece, "render_params", "render.json", JSON.stringify(record)));
+        prepared.push(...captions.map((row) => retainedOutput(deps, view, row)));
+        await publishResult(deps, context, piece, prepared, { totalSeconds }, asset);
+        deps.count?.("stage.completed", { stage: "video" });
+        return "done";
+    }
+    finally {
+        discardPreparedAssets(deps, [pending, ...prepared.map((one) => one.asset)]);
+        if (directory !== undefined)
+            rmSync(directory, { recursive: true, force: true });
+    }
+}
+function captionDirectory(deps, context, snapshot) {
+    const find = (role) => snapshot.view.outputs.find((row) => row.selected && row.available && row.state === "ready" && row.output.role === role);
+    const ass = find("subtitle_ass");
+    const font = find("subtitle_font");
+    if (ass === undefined || font === undefined)
+        throw new Error("Burned subtitles need prepared captions and their saved font.");
+    const directory = mkdtempSync(join(projectDir(deps.paths, context.work.projectId), "render-"));
+    try {
+        mkdirSync(join(directory, "fonts"), { mode: 0o700 });
+        copyFileSync(outputPath(deps.paths, context.work.projectId, ass.output.path), join(directory, "subtitles.ass"));
+        copyFileSync(outputPath(deps.paths, context.work.projectId, font.output.path), join(directory, "fonts", `selected${extname(font.output.path)}`));
+        return directory;
+    }
+    catch (error) {
+        rmSync(directory, { recursive: true, force: true });
+        throw error;
+    }
+}

package/dist/slices/rebuild/runtime-instructions.js

@@ -0,0 +1,51 @@
+import { z } from "zod";
+import { recipeInputSchema } from "./recipe-input-schema.js";
+import { executionView } from "./runtime-plan.js";
+export function frozenInstructions(deps, context, current) {
+    const view = executionView(deps, context.work.projectId, context.work.revisionId);
+    const selected = new Set(view?.pieces
+        .filter((row) => row.selected && row.piece.state === "done")
+        .map((row) => row.piece.id));
+    const rows = deps.db
+        .prepare(`SELECT p.id,p.work_id,p.work_key,p.input_json,p.result_json,p.state FROM revision_work_pieces p JOIN revision_work w ON w.id=p.work_id WHERE w.project_id=? AND w.kind=? ORDER BY w.rowid,p.rowid`)
+        .all(context.work.projectId, context.work.kind);
+    const sections = [];
+    for (const raw of rows) {
+        const row = z
+            .object({
+            id: z.string(),
+            work_id: z.string(),
+            work_key: z.string(),
+            input_json: z.string(),
+            result_json: z.string().nullable(),
+            state: z.string(),
+        })
+            .parse(raw);
+        if (row.id !== current.id &&
+            !selected.has(row.id) &&
+            !(row.work_id === current.workId && row.result_json !== null))
+            continue;
+        const input = recipeInputSchema.parse(JSON.parse(row.input_json));
+        if (input.kind !== "llm")
+            continue;
+        sections.push(`## ${label(row.work_key)}\n\n${input.messages.map((message) => `### ${message.role}\n\n${message.content}`).join("\n\n")}`);
+    }
+    return `${sections.join("\n\n")}\n`;
+}
+function label(key) {
+    if (key === "research:planner")
+        return "Research outline";
+    if (key === "research:notes")
+        return "Research synthesis";
+    if (key.startsWith("research:chapter:"))
+        return `Research chapter ${key.split(":").at(-1)}`;
+    if (key === "article:body")
+        return "Article";
+    if (key.startsWith("article:continuation:"))
+        return `Article continuation ${key.split(":").at(-1)}`;
+    if (key === "entry:intro:text")
+        return "Intro";
+    if (key === "entry:outro:text")
+        return "Outro";
+    return "Thumbnail instructions";
+}

package/dist/slices/rebuild/runtime-local.js

@@ -0,0 +1,137 @@
+import { statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { z } from "zod";
+import { plainText } from "../article/plain.js";
+import { splitEndMatter } from "../article/split.js";
+import { joinNarration } from "../narration/concat.js";
+import { allocateAsset, discardPreparedAssets, sealAsset } from "../storage/assets.js";
+import { outputPath } from "../storage/layout.js";
+import { executionPlan, executionView, savedCatalogue } from "./runtime-plan.js";
+import { preparedResult, preparedText, preparedTexts, publishResult, } from "./runtime-publication.js";
+export async function executeLocalRecipe(deps, context, piece) {
+    if (deps.db
+        .prepare("SELECT state FROM revision_work_pieces WHERE id=? AND work_id=?")
+        .get(piece.id, context.work.workId)?.state === "done")
+        return "done";
+    if (!context.maySubmit(piece.id))
+        return "held";
+    const input = piece.input;
+    if (input.kind === "provided") {
+        if (input.assetId === null)
+            throw new Error("The provided recipe has no retained asset.");
+        const row = z
+            .object({ id: z.string(), project_id: z.string(), path: z.string(), created_at: z.string() })
+            .parse(deps.db
+            .prepare("SELECT * FROM project_assets WHERE id=? AND project_id=?")
+            .get(input.assetId, context.work.projectId));
+        const asset = {
+            id: row.id,
+            projectId: row.project_id,
+            path: row.path,
+            createdAt: row.created_at,
+            bytes: statSync(outputPath(deps.paths, row.project_id, row.path)).size,
+        };
+        const role = piece.key === "audio:provided"
+            ? "audio_body"
+            : piece.key === "thumbnail:image"
+                ? "thumbnail"
+                : piece.key.startsWith("image:")
+                    ? "image"
+                    : undefined;
+        await publishResult(deps, context, piece, role === undefined ? [] : [preparedResult(deps, context, piece, role, asset)], {}, asset);
+        return "done";
+    }
+    if (input.kind !== "local")
+        throw new Error("Expected an exact local recipe.");
+    if (input.operation === "concat-narration") {
+        await concatenate(deps, context, piece);
+        return "done";
+    }
+    if (input.operation === "provided-article" || input.operation === "manual-article") {
+        const text = z.string().parse(input.values);
+        const parts = splitEndMatter(text);
+        await publishResult(deps, context, piece, preparedTexts(deps, context, piece, [
+            ["article_md", "article.md", text],
+            ["article_txt", "article.txt", plainText(parts.body)],
+            ...(parts.sources ? [["sources", "sources.md", parts.sources]] : []),
+            ...(parts.glossary ? [["glossary", "glossary.md", parts.glossary]] : []),
+        ]), { text });
+        return "done";
+    }
+    if (input.operation === "provided-notes") {
+        const text = z.string().parse(input.values);
+        await publishResult(deps, context, piece, [preparedText(deps, context, piece, "notes", "notes.md", text)], { text });
+        return "done";
+    }
+    if (input.operation === "entry-text") {
+        await publishResult(deps, context, piece, [], {
+            text: z.string().parse(input.values),
+            category: piece.key.includes(":intro:") ? "intro" : "outro",
+        });
+        return "done";
+    }
+    throw new Error(`No local executor for ${input.operation}.`);
+}
+async function concatenate(deps, context, piece) {
+    const view = executionView(deps, context.work.projectId, context.work.revisionId);
+    if (view === undefined)
+        throw new Error("The pinned revision is missing.");
+    const row = deps.db
+        .prepare("SELECT recipe_context FROM revision_work WHERE id=?")
+        .get(context.work.workId);
+    const plan = executionPlan(deps, view, savedCatalogue(row?.recipe_context));
+    const recipe = plan.recipes.find((candidate) => candidate.key === piece.key && candidate.fingerprint === piece.fingerprint);
+    if (recipe === undefined)
+        throw new Error("The pinned concatenation no longer matches its inputs.");
+    const files = recipe.dependsOn.map((key) => {
+        const input = view.pieces.find((candidate) => candidate.key === key &&
+            candidate.selected &&
+            candidate.available &&
+            candidate.piece.state === "done" &&
+            candidate.fingerprint === plan.recipes.find((value) => value.key === key)?.fingerprint);
+        if (input?.assetId === null || input === undefined)
+            throw new Error("A narration part has no retained audio.");
+        const asset = deps.db
+            .prepare("SELECT path FROM project_assets WHERE id=? AND project_id=?")
+            .get(input.assetId, context.work.projectId);
+        return outputPath(deps.paths, context.work.projectId, z.string().parse(asset?.path));
+    });
+    const pending = allocateAsset(deps, context.work.projectId, "narration.mp3");
+    try {
+        const durationMs = await joinNarration({ bin: deps.ffmpeg, log: deps.log }, {
+            files,
+            output: pending.absolutePath,
+            listPath: join(dirname(pending.absolutePath), "parts.txt"),
+            signal: context.signal,
+        });
+        context.signal.throwIfAborted();
+        const asset = sealAsset(deps, pending);
+        const role = piece.key === "audio:intro"
+            ? "audio_intro"
+            : piece.key === "audio:outro"
+                ? "audio_outro"
+                : "audio_body";
+        await publishResult(deps, context, piece, [
+            preparedResult(deps, context, piece, role, asset, durationMs, view.revision.config.audio === undefined
+                ? {}
+                : {
+                    provider: view.revision.config.audio.provider,
+                    model: view.revision.config.audio.model,
+                    voice: view.revision.config.audio.voice,
+                }),
+        ], { durationMs }, asset);
+        for (const key of recipe.dependsOn) {
+            const retained = view.pieces.find((candidate) => candidate.key === key && candidate.selected && candidate.available);
+            if (retained?.publicationId === null || retained === undefined)
+                continue;
+            const owner = deps.db
+                .prepare("SELECT work_id FROM revision_work_pieces WHERE id=?")
+                .get(retained.publicationId);
+            if (typeof owner?.work_id === "string")
+                deps.audioPreviews?.clear(context.work.projectId, owner.work_id);
+        }
+    }
+    finally {
+        discardPreparedAssets(deps, [pending]);
+    }
+}

package/dist/slices/rebuild/runtime-materialize.js

@@ -0,0 +1,105 @@
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { currentRevisionId } from "../revisions/repo.js";
+import { getRevisionView } from "../revisions/view.js";
+import { insertInvocation } from "./runtime-admission.js";
+import { bindNarrationReuse, narrationOrdinal } from "./runtime-narration-reuse.js";
+import { executionPlan, executionView, savedCatalogue } from "./runtime-plan.js";
+import { workPieces } from "./work-records.js";
+const reservation = z.object({
+    revision_id: z.string(),
+    work_id: z.string(),
+    work_key: z.string(),
+    fingerprint: z.string(),
+    logical_key: z.string().nullable(),
+    desired_fingerprint: z.string().nullable(),
+    origin_revision: z.string(),
+    recipe_context: z.string(),
+    admission_id: z.string().nullable(),
+});
+export function materializeAdmittedWork(deps, projectId) {
+    transact(deps.db, () => {
+        const head = currentRevisionId(deps.db, projectId);
+        if (head === undefined)
+            return;
+        const reservations = deps.db
+            .prepare(`SELECT r.*,w.revision_id AS origin_revision,w.recipe_context,w.admission_id FROM revision_work_reservations r JOIN revision_work w ON w.id=r.work_id WHERE r.project_id=? AND r.revision_id=? AND w.dispatch_state='allowed' AND w.recipe_context IS NOT NULL`)
+            .all(projectId, head)
+            .map((row) => reservation.parse(row));
+        const origins = new Map(reservations.map((row) => [row.origin_revision, row]));
+        for (const origin of origins.values()) {
+            const view = executionView(deps, projectId, origin.origin_revision);
+            if (view === undefined)
+                continue;
+            const catalogue = savedCatalogue(origin.recipe_context);
+            const plan = executionPlan(deps, view, catalogue);
+            for (const recipe of plan.recipes) {
+                if (!plan.work.some((row) => row.key === recipe.key))
+                    continue;
+                if (recipe.deferred || recipe.unresolved)
+                    continue;
+                if (recipe.input.kind === "tts") {
+                    const current = getRevisionView(deps, projectId, head);
+                    const desired = current?.revision.fingerprints[`${recipe.input.logicalKey}:1`];
+                    if (desired !== undefined && desired !== recipe.logicalFingerprint)
+                        continue;
+                }
+                const own = reservations.find((row) => row.work_key === recipe.key && row.origin_revision === origin.origin_revision);
+                if (own?.fingerprint === recipe.fingerprint)
+                    continue;
+                const anchor = own ??
+                    reservations.find((row) => row.origin_revision === origin.origin_revision && row.work_key === futureKey(recipe));
+                if (anchor === undefined || !desiredAnchor(deps, projectId, head, anchor))
+                    continue;
+                if (own !== undefined &&
+                    workPieces(deps.db, own.work_id).some((piece) => piece.submittedAt !== null || piece.state === "done"))
+                    continue;
+                if (plan.work.find((row) => row.key === recipe.key)?.disposition === "review")
+                    continue;
+                if (own !== undefined) {
+                    deps.db
+                        .prepare("UPDATE revision_work SET state='done' WHERE id=? AND state='pending'")
+                        .run(own.work_id);
+                    deps.db
+                        .prepare("DELETE FROM revision_work_reservations WHERE revision_id=? AND work_key=?")
+                        .run(head, recipe.key);
+                }
+                const placeholder = deps.db
+                    .prepare("SELECT w.dispatch_state FROM revision_work_reservations r JOIN revision_work w ON w.id=r.work_id WHERE r.revision_id=? AND r.work_key=?")
+                    .get(head, recipe.key);
+                if (placeholder !== undefined && placeholder.dispatch_state !== "held")
+                    continue;
+                deps.db
+                    .prepare("DELETE FROM revision_work_reservations WHERE revision_id=? AND work_key=?")
+                    .run(head, recipe.key);
+                if (plan.work.find((row) => row.key === recipe.key)?.disposition === "reuse") {
+                    const ordinal = narrationOrdinal(plan.recipes, recipe.key);
+                    bindNarrationReuse(deps, view, recipe, ordinal);
+                    if (head !== view.revision.id) {
+                        const current = getRevisionView(deps, projectId, head);
+                        if (current !== undefined)
+                            bindNarrationReuse(deps, current, recipe, ordinal);
+                    }
+                }
+                insertInvocation(deps, view, recipe, catalogue, {
+                    key: anchor.logical_key ?? anchor.work_key,
+                    fingerprint: anchor.desired_fingerprint ?? anchor.fingerprint,
+                }, plan.work.find((row) => row.key === recipe.key)?.disposition === "reuse", head, anchor.admission_id);
+            }
+        }
+    });
+}
+function desiredAnchor(deps, projectId, head, row) {
+    const view = getRevisionView(deps, projectId, head);
+    return (view?.revision.fingerprints[row.logical_key ?? row.work_key] ===
+        (row.desired_fingerprint ?? row.fingerprint));
+}
+function futureKey(recipe) {
+    if (recipe.input.kind === "tts")
+        return `audio:${recipe.input.segment}:future`;
+    if (recipe.key.startsWith("research:chapter:"))
+        return "research:planner";
+    if (recipe.key === "article:continuation")
+        return "article:body";
+    return recipe.key;
+}