@gentbajko/slopify 0.8.4 → 1.0.0

package/dist/slices/rebuild/model.js

@@ -0,0 +1,94 @@
+import { z } from "zod";
+import { stageKinds } from "../../kernel/pipeline.js";
+export const rebuildSelectionSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("allAffected") }).strict(),
+    z
+        .object({
+        kind: z.literal("selected"),
+        workKeys: z.array(z.string().min(1).max(200)).min(1).max(10000),
+    })
+        .strict(),
+]);
+const revisionId = z.string().min(1).max(64);
+export const previewRebuildSchema = z
+    .object({
+    baseRevisionId: revisionId,
+    request: rebuildSelectionSchema,
+})
+    .strict();
+export const startRebuildSchema = z
+    .object({
+    baseRevisionId: revisionId,
+    idempotencyKey: z.uuid(),
+    previewId: z.string().min(1).max(64),
+    acknowledgeUnknownCosts: z.boolean(),
+    confirmedProvidedWorkKeys: z.array(z.string().min(1).max(200)).max(10000),
+})
+    .strict();
+const costRowSchema = z.object({
+    stage: z.string(),
+    low: z.number().finite().nonnegative().nullable(),
+    high: z.number().finite().nonnegative().nullable(),
+    detail: z.string(),
+});
+const costEstimateSchema = z.object({
+    currency: z.literal("USD"),
+    rows: z.array(costRowSchema),
+    low: z.number().finite().nonnegative(),
+    high: z.number().finite().nonnegative(),
+    unknown: z.number().int().nonnegative(),
+    expectedWords: z.number().finite().nonnegative(),
+    catalogueDate: z.string().nullable(),
+    assumptions: z.array(z.string()),
+});
+export const rebuildAdmissionSchema = z.object({
+    revisionId,
+    admissionId: z.string().min(1).max(64),
+    workIds: z.array(z.string().min(1).max(64)),
+    replayed: z.boolean(),
+});
+export const rebuildPreviewSchema = z.object({
+    id: z.string().min(1).max(64),
+    projectId: z.string().min(1).max(64),
+    baseRevisionId: revisionId,
+    planFingerprint: z.string().min(1),
+    selection: rebuildSelectionSchema,
+    changedInputs: z.array(z.object({ path: z.string(), before: z.string().nullable(), after: z.string().nullable() })),
+    work: z.array(z.object({
+        key: z.string(),
+        stage: z.enum(stageKinds),
+        kind: z.enum(["provider", "local", "provided"]),
+        disposition: z.enum(["reuse", "generate", "local", "review", "blocked"]),
+        requestFingerprint: z.string(),
+        fingerprint: z.string(),
+        dependsOn: z.array(z.string()),
+        reason: z.string(),
+        inflight: z.boolean(),
+        pieceIds: z.array(z.string()),
+    })),
+    retained: z.array(z.object({
+        slot: z.string(),
+        outputId: z.string(),
+        assetId: z.string(),
+        state: z.enum(["ready", "outdated", "review"]),
+    })),
+    providedReuseRequired: z.array(z.string()),
+    costs: costEstimateSchema,
+    wholeRequestNotice: z.string().nullable(),
+    warnings: z.array(z.string()),
+    review: z
+        .object({
+        inputChanges: z.array(z.object({
+            label: z.string(),
+            before: z.string().nullable(),
+            after: z.string().nullable(),
+        })),
+        requests: z.array(z.object({
+            key: z.string(),
+            label: z.string(),
+            text: z.string().nullable(),
+            settings: z.string().nullable(),
+        })),
+    })
+        .optional(),
+});

package/dist/slices/rebuild/narration-history.js

@@ -0,0 +1,43 @@
+import { statSync } from "node:fs";
+import { z } from "zod";
+import { stagePieceSchema } from "../revisions/schema.js";
+import { outputPath } from "../storage/layout.js";
+export function retainedNarrationPieces(deps, projectId) {
+    return deps.db
+        .prepare(`SELECT p.piece_key,p.asset_id,p.fingerprint,p.descriptor,a.path FROM revision_pieces p
+    JOIN project_assets a ON a.id=p.asset_id AND a.project_id=p.project_id
+    WHERE p.project_id=? AND p.stage_kind='audio' ORDER BY p.created_at,p.id`)
+        .all(projectId)
+        .map((value) => {
+        const row = z
+            .object({
+            piece_key: z.string(),
+            asset_id: z.string(),
+            fingerprint: z.string(),
+            descriptor: z.string(),
+            path: z.string(),
+        })
+            .parse(value);
+        return {
+            key: row.piece_key,
+            stageKind: "audio",
+            assetId: row.asset_id,
+            fingerprint: row.fingerprint,
+            piece: stagePieceSchema.parse(JSON.parse(row.descriptor)),
+            available: statSync(outputPath(deps.paths, projectId, row.path), {
+                throwIfNoEntry: false,
+            })?.isFile() === true,
+        };
+    });
+}
+export function referencedAssetsAvailable(deps, projectId, ids) {
+    return ids.filter((id) => {
+        const row = deps.db
+            .prepare("SELECT path FROM project_assets WHERE project_id=? AND id=?")
+            .get(projectId, id);
+        return (row !== undefined &&
+            statSync(outputPath(deps.paths, projectId, z.string().parse(row.path)), {
+                throwIfNoEntry: false,
+            })?.isFile() === true);
+    });
+}

package/dist/slices/rebuild/narration-reuse.js

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import { fingerprint } from "../../kernel/runner/work.js";
+export function matchingNarrationPiece(recipe, pieces, available) {
+    if (recipe.input.kind !== "tts")
+        return undefined;
+    const noRegeneration = recipe.fingerprint === fingerprint([recipe.requestFingerprint, null]);
+    return pieces.find((piece) => {
+        if (piece.stageKind !== "audio" ||
+            piece.piece.state !== "done" ||
+            piece.assetId === null ||
+            !available.has(piece.assetId))
+            return false;
+        const parsed = z
+            .object({ requestFingerprint: z.string() })
+            .safeParse(JSON.parse(piece.piece.payload ?? "null"));
+        return (parsed.success &&
+            parsed.data.requestFingerprint === recipe.requestFingerprint &&
+            (noRegeneration || piece.fingerprint === recipe.fingerprint));
+    });
+}

package/dist/slices/rebuild/preview-details.js

@@ -0,0 +1,144 @@
+import { stageKinds } from "../../kernel/pipeline.js";
+import { getRevisionView } from "../revisions/view.js";
+export function previewDetails(deps, view, allRecipes, selected) {
+    const parent = view.revision.parentId === null
+        ? undefined
+        : getRevisionView(deps, view.revision.projectId, view.revision.parentId);
+    const requests = allRecipes.flatMap((row) => {
+        if (!selected.has(row.key))
+            return [];
+        const input = row.input;
+        const narration = narrationIdentity(row);
+        if (narration !== undefined) {
+            const groups = [
+                ...new Set(allRecipes.flatMap((one) => {
+                    const identity = narrationIdentity(one);
+                    return identity?.segment === narration.segment ? [identity.logicalKey] : [];
+                })),
+            ];
+            const siblings = allRecipes.filter((one) => narrationIdentity(one)?.logicalKey === narration.logicalKey);
+            const segment = narration.segment === "body" ? "Body" : narration.segment === "intro" ? "Intro" : "Outro";
+            const text = input.kind === "tts"
+                ? input.text
+                : input.kind === "provided" &&
+                    Array.isArray(input.semantic) &&
+                    typeof input.semantic[0] === "string"
+                    ? input.semantic[0]
+                    : null;
+            return [
+                {
+                    key: row.key,
+                    label: `${segment} narration chunk ${groups.indexOf(narration.logicalKey) + 1} · request ${siblings.findIndex((one) => one.key === row.key) + 1}`,
+                    text,
+                    settings: input.kind === "tts"
+                        ? [input.provider, input.model, input.voice].join(" · ")
+                        : "Provided audio",
+                },
+            ];
+        }
+        if (input.kind === "image") {
+            const index = view.revision.content.imageOrder.indexOf(row.key.slice("image:".length));
+            return [
+                {
+                    key: row.key,
+                    label: index < 0 ? "Thumbnail image" : `Image ${index + 1}`,
+                    text: input.prompt,
+                    settings: [input.provider, input.model, input.aspect].join(" · "),
+                },
+            ];
+        }
+        if (input.kind === "llm") {
+            const peers = allRecipes.filter((one) => one.stage === row.stage && one.input.kind === "llm");
+            const category = row.key.startsWith("entry:intro")
+                ? "Intro text"
+                : row.key.startsWith("entry:outro")
+                    ? "Outro text"
+                    : row.stage === "article"
+                        ? "Article"
+                        : row.stage === "research"
+                            ? "Research"
+                            : "Thumbnail prompt";
+            return [
+                {
+                    key: row.key,
+                    label: `${category} request ${peers.findIndex((one) => one.key === row.key) + 1}`,
+                    text: input.messages
+                        .map((message) => `${message.role}:\n${message.content}`)
+                        .join("\n\n"),
+                    settings: [input.provider, input.model, input.thinking]
+                        .filter((value) => value !== null)
+                        .join(" · "),
+                },
+            ];
+        }
+        return [];
+    });
+    return { inputChanges: parent === undefined ? [] : inputChanges(parent, view), requests };
+}
+function narrationIdentity(row) {
+    if (row.input.kind === "tts")
+        return { logicalKey: row.input.logicalKey, segment: row.input.segment };
+    if (row.input.kind !== "provided")
+        return undefined;
+    const match = /^audio:(body:.+|intro|outro):[0-9]+$/.exec(row.key);
+    if (match === null)
+        return undefined;
+    return {
+        logicalKey: row.key.slice(0, row.key.lastIndexOf(":")),
+        segment: row.key.startsWith("audio:body:")
+            ? "body"
+            : row.key.startsWith("audio:intro:")
+                ? "intro"
+                : "outro",
+    };
+}
+function inputChanges(parent, view) {
+    const before = parent.revision.config;
+    const after = view.revision.config;
+    const old = parent.revision.content;
+    const next = view.revision.content;
+    const changes = [];
+    const add = (label, previous, current) => {
+        const text = (value) => value == null ? null : typeof value === "string" ? value : JSON.stringify(value, null, 2);
+        const a = text(previous);
+        const b = text(current);
+        if (a !== b)
+            changes.push({ label, before: a, after: b });
+    };
+    add("Project title", before.title, after.title);
+    add("Aspect ratio", before.format, after.format);
+    for (const kind of stageKinds)
+        add(`${kind[0]?.toUpperCase()}${kind.slice(1)} source`, before.sources[kind], after.sources[kind]);
+    for (const [name, a, b] of [
+        ["Text", before.llm, after.llm],
+        ["Narration", before.audio, after.audio],
+        ["Images", before.images, after.images],
+    ]) {
+        add(`${name} provider`, a?.provider, b?.provider);
+        add(`${name} model`, a?.model, b?.model);
+        add(`${name} thinking`, a?.thinking, b?.thinking);
+    }
+    add("Narration voice", before.audio?.voice, after.audio?.voice);
+    add("Narration chunking", before.chunking, after.chunking);
+    add("Silence gap (seconds)", before.silenceGapSeconds, after.silenceGapSeconds);
+    add("Intro", before.intro, after.intro);
+    add("Outro", before.outro, after.outro);
+    add("Subtitle settings", before.subtitles, after.subtitles);
+    add("Article text", parent.articleMarkdown, view.articleMarkdown);
+    add("Provided research", before.provided.research, after.provided.research);
+    for (const key of new Set([...Object.keys(before.values), ...Object.keys(after.values)]))
+        add(`Keyword: ${key}`, before.values[key], after.values[key]);
+    for (const key of new Set([...Object.keys(before.rendered), ...Object.keys(after.rendered)]))
+        add(`Prompt: ${key}`, before.rendered[key], after.rendered[key]);
+    if (old.imageOrder.join("\0") !== next.imageOrder.join("\0")) {
+        const label = (key) => old.imageOrder.includes(key) ? `Image ${old.imageOrder.indexOf(key) + 1}` : "New image";
+        add("Image order", old.imageOrder.map(label).join(", "), next.imageOrder.map(label).join(", "));
+    }
+    for (const [index, key] of next.imageOrder.entries()) {
+        add(`Image ${index + 1} prompt`, old.imageDefinitions[key]?.prompt, next.imageDefinitions[key]?.prompt);
+        if (old.imageDefinitions[key]?.assetId !== next.imageDefinitions[key]?.assetId)
+            add(`Image ${index + 1} file`, old.imageDefinitions[key]?.assetId == null ? null : "Previous file", next.imageDefinitions[key]?.assetId == null ? null : "Replacement file");
+    }
+    add("Manual captions", old.subtitleCues?.cues, next.subtitleCues?.cues);
+    return changes;
+}

package/dist/slices/rebuild/preview-plan.js

@@ -0,0 +1,223 @@
+import { z } from "zod";
+import { catalogueSchema } from "../../catalog/schema.js";
+import { stageKinds } from "../../kernel/pipeline.js";
+import { estimateRequests } from "../estimate/index.js";
+import { requestHash } from "../revisions/mutation-request.js";
+import { previewDetails } from "./preview-details.js";
+import { hasSubmittedRequest, requiresNewSubmission, retainedPreviewPlan, } from "./preview-retained.js";
+import { providedDependencyFingerprint } from "./provided-review.js";
+import { recipeInputSchema } from "./recipe-input-schema.js";
+import { recipeProviderChoice } from "./recipe-provider-choice.js";
+import { priceRecipe } from "./recipe-work.js";
+import { narrationOrdinal } from "./runtime-narration-reuse.js";
+import { executionCatalogue } from "./runtime-plan.js";
+export const executionSnapshotSchema = z.object({
+    version: z.literal(1),
+    submissions: z
+        .array(z.object({ key: z.string(), submit: z.boolean(), uncertain: z.boolean() }))
+        .default([]),
+    catalogue: catalogueSchema,
+    recipes: z.array(z.object({
+        key: z.string(),
+        stage: z.enum(stageKinds),
+        kind: z.enum(["provider", "local", "provided"]),
+        requestFingerprint: z.string(),
+        fingerprint: z.string(),
+        logicalFingerprint: z.string(),
+        dependsOn: z.array(z.string()),
+        unresolved: z.boolean(),
+        deferred: z.boolean(),
+        input: recipeInputSchema,
+    })),
+    dispositions: z.array(z.object({ key: z.string(), disposition: z.string() })),
+    assets: z.array(z.object({ id: z.string(), path: z.string(), available: z.boolean() })),
+    reviews: z.array(z.object({ key: z.string(), fingerprint: z.string() })),
+    anchors: z.record(z.string(), z.string()),
+    ordinals: z.record(z.string(), z.number().int()),
+});
+export function planPreview(deps, view, catalogue, selection, id) {
+    const plan = retainedPreviewPlan(deps, view, catalogue);
+    const requested = selection.kind === "allAffected"
+        ? plan.work.filter((row) => row.disposition !== "reuse").map((row) => row.key)
+        : selection.workKeys;
+    if (new Set(requested).size !== requested.length)
+        return invalid("Choose each work item only once.");
+    const selected = new Set();
+    const visiting = new Set();
+    const visit = (key) => {
+        if (selected.has(key))
+            return true;
+        if (visiting.has(key))
+            return false;
+        const work = plan.work.find((row) => row.key === key);
+        const recipe = plan.recipes.find((row) => row.key === key);
+        if (work === undefined || recipe === undefined)
+            return false;
+        if (recipe.input.kind === "provided" && recipe.unresolved)
+            return false;
+        if (recipe.unresolved && recipe.dependsOn.length === 0 && !recipe.deferred)
+            return false;
+        visiting.add(key);
+        if (work.disposition !== "reuse")
+            for (const dependency of recipe.dependsOn)
+                if (!visit(dependency))
+                    return false;
+        visiting.delete(key);
+        selected.add(key);
+        return true;
+    };
+    for (const key of requested)
+        if (!visit(key))
+            return invalid(`Work ${key} is disabled, unknown, or has an unavailable prerequisite.`);
+    const recipes = plan.recipes.filter((row) => selected.has(row.key));
+    const reservations = deps.db
+        .prepare(`SELECT r.work_key,r.fingerprint,w.state,w.recipe_context,r.piece_id FROM revision_work_reservations r JOIN revision_work w ON w.id=r.work_id WHERE r.revision_id=?`)
+        .all(view.revision.id);
+    const work = plan.work
+        .filter((row) => selected.has(row.key))
+        .map((row) => {
+        const old = reservations.find((one) => one.work_key === row.key &&
+            one.fingerprint === row.fingerprint &&
+            one.state !== "done" &&
+            typeof one.recipe_context === "string");
+        return old === undefined
+            ? row
+            : {
+                ...row,
+                inflight: old.state === "running",
+                pieceIds: typeof old.piece_id === "string" ? [old.piece_id] : [],
+            };
+    });
+    const relevantAssets = new Map();
+    for (const row of view.outputs)
+        if (row.selected && selected.has(row.workKey))
+            relevantAssets.set(row.assetId, {
+                id: row.assetId,
+                path: row.output.path,
+                available: row.available,
+            });
+    for (const row of view.pieces)
+        if (row.selected && selected.has(row.key) && row.assetId !== null) {
+            const asset = deps.db
+                .prepare("SELECT path FROM project_assets WHERE id=? AND project_id=?")
+                .get(row.assetId, view.revision.projectId);
+            relevantAssets.set(row.assetId, {
+                id: row.assetId,
+                path: String(asset?.path ?? ""),
+                available: row.available,
+            });
+        }
+    for (const recipe of recipes)
+        if (recipe.input.kind === "provided" && recipe.input.assetId !== null) {
+            const asset = deps.db
+                .prepare("SELECT path FROM project_assets WHERE id=? AND project_id=?")
+                .get(recipe.input.assetId, view.revision.projectId);
+            relevantAssets.set(recipe.input.assetId, {
+                id: recipe.input.assetId,
+                path: String(asset?.path ?? ""),
+                available: !recipe.unresolved,
+            });
+        }
+    const snapshot = selectedCatalogue(executionCatalogue(catalogue, view.revision.config), recipes, view);
+    const submissions = work
+        .filter((row) => row.kind === "provider")
+        .map((row) => {
+        const submit = row.disposition !== "reuse" &&
+            !row.inflight &&
+            requiresNewSubmission(deps, view.revision.id, row.key, row.fingerprint);
+        return {
+            key: row.key,
+            submit,
+            uncertain: submit && hasSubmittedRequest(deps, view.revision.id, row.key, row.fingerprint),
+        };
+    });
+    const execution = {
+        version: 1,
+        submissions,
+        catalogue: snapshot,
+        recipes: recipes.map((row) => ({ ...row, dependsOn: [...row.dependsOn] })),
+        dispositions: work.map((row) => ({ key: row.key, disposition: row.disposition })),
+        assets: [...relevantAssets.values()].sort((a, b) => a.id.localeCompare(b.id)),
+        reviews: plan.providedReuseRequired
+            .filter((key) => selected.has(key))
+            .map((key) => ({ key, fingerprint: providedDependencyFingerprint(plan, key) })),
+        ordinals: Object.fromEntries(recipes.map((row) => [row.key, narrationOrdinal(plan.recipes, row.key)])),
+        anchors: Object.fromEntries(recipes.map((recipe) => {
+            const key = recipe.input.kind === "tts" ? `${recipe.input.logicalKey}:1` : recipe.key;
+            return [key, view.revision.fingerprints[key] ?? recipe.logicalFingerprint];
+        })),
+    };
+    const preview = {
+        id,
+        projectId: view.revision.projectId,
+        baseRevisionId: view.revision.id,
+        selection,
+        planFingerprint: executionFingerprint(view.revision.id, execution),
+        work,
+        review: previewDetails(deps, view, plan.recipes, selected),
+        changedInputs: plan.changedInputs.filter((row) => selected.has(row.path)),
+        retained: view.outputs
+            .filter((row) => row.selected)
+            .map((row) => ({
+            slot: row.slot,
+            outputId: row.output.id,
+            assetId: row.assetId,
+            state: row.state,
+        })),
+        providedReuseRequired: execution.reviews.map((row) => row.key),
+        costs: estimateRequests(work.map((row) => priceRecipe(row.inflight || !requiresNewSubmission(deps, view.revision.id, row.key, row.fingerprint)
+            ? { ...row, disposition: "reuse" }
+            : row, recipes.find((recipe) => recipe.key === row.key))), snapshot),
+        wholeRequestNotice: plan.wholeRequestNotice,
+        warnings: submissions.some((row) => row.uncertain)
+            ? [
+                "A previous request was submitted without a saved result or resumable job. Retrying may charge you again.",
+            ]
+            : [],
+    };
+    return { ok: true, value: { preview, execution } };
+}
+function invalid(message) {
+    return {
+        ok: false,
+        reason: "invalid-selection",
+        fields: [{ field: "request.workKeys", message }],
+    };
+}
+function selectedCatalogue(catalogue, recipes, view) {
+    const uses = new Set(recipes.flatMap((row) => {
+        const choice = recipeProviderChoice(row, view.revision.config);
+        return choice === undefined ? [] : [`${choice.family}:${choice.provider}:${choice.model}`];
+    }));
+    const selected = {
+        llm: catalogue.llm.filter((row) => uses.has(`llm:${row.provider}:${row.id}`)),
+        tts: catalogue.tts.filter((row) => uses.has(`tts:${row.provider}:${row.id}`)),
+        image: catalogue.image.filter((row) => uses.has(`image:${row.provider}:${row.id}`)),
+    };
+    const providers = new Set([...selected.llm, ...selected.tts, ...selected.image].map((row) => row.provider));
+    return {
+        ...catalogue,
+        ...selected,
+        providers: Object.fromEntries(Object.entries(catalogue.providers).filter(([id]) => providers.has(id))),
+    };
+}
+function executionFingerprint(revisionId, execution) {
+    return requestHash("rebuild-plan-v1", revisionId, {
+        ...execution,
+        catalogue: { ...execution.catalogue, updatedAt: "1970-01-01" },
+    });
+}
+export function reviewStillCovers(reviewed, snapshot, fresh) {
+    if (reviewed.planFingerprint === fresh.preview.planFingerprint)
+        return true;
+    const escalated = fresh.execution.submissions.some((current) => {
+        const old = snapshot.submissions.find((row) => row.key === current.key);
+        return current.submit && (old?.submit !== true || (current.uncertain && !old.uncertain));
+    });
+    // A paid request may become a free join while readiness loads, never the reverse.
+    return (!escalated &&
+        executionFingerprint(reviewed.baseRevisionId, {
+            ...fresh.execution,
+            submissions: snapshot.submissions,
+        }) === reviewed.planFingerprint);
+}

package/dist/slices/rebuild/preview-retained.js

@@ -0,0 +1,128 @@
+import { continuationLimit } from "../article/continuation.js";
+import { executionPlan, executionView, savedCatalogue } from "./runtime-plan.js";
+import { workPieces } from "./work-records.js";
+export function retainedPreviewPlan(deps, view, catalogue) {
+    const current = executionPlan(deps, view, catalogue);
+    const replacements = new Map();
+    const groups = new Set();
+    const reservations = deps.db
+        .prepare(`SELECT r.*,w.revision_id AS origin_revision,w.recipe_context,w.state FROM revision_work_reservations r JOIN revision_work w ON w.id=r.work_id WHERE r.revision_id=? AND w.recipe_context IS NOT NULL AND w.state!='done'`)
+        .all(view.revision.id);
+    const origins = new Map();
+    for (const row of reservations) {
+        const anchor = String(row.logical_key ?? row.work_key);
+        if (view.revision.fingerprints[anchor] !== row.desired_fingerprint)
+            continue;
+        const piece = workPieces(deps.db, String(row.work_id)).find((one) => one.id === row.piece_id);
+        if (piece === undefined)
+            continue;
+        const originKey = `${row.origin_revision}:${row.recipe_context}`;
+        let original = origins.get(originKey);
+        if (original === undefined) {
+            const origin = executionView(deps, view.revision.projectId, String(row.origin_revision));
+            if (origin === undefined)
+                continue;
+            original = executionPlan(deps, origin, savedCatalogue(row.recipe_context));
+            origins.set(originKey, original);
+        }
+        const recipe = original.recipes.find((one) => one.key === piece.key);
+        if (recipe === undefined)
+            continue;
+        replacements.set(piece.key, {
+            ...recipe,
+            input: piece.input,
+            fingerprint: piece.fingerprint,
+            requestFingerprint: piece.requestFingerprint,
+            logicalFingerprint: piece.logicalFingerprint ?? recipe.logicalFingerprint,
+        });
+        if (piece.input.kind === "tts") {
+            const logicalKey = piece.input.logicalKey;
+            groups.add(logicalKey);
+            for (const sibling of original.recipes)
+                if (sibling.input.kind === "tts" &&
+                    sibling.input.logicalKey === logicalKey &&
+                    !replacements.has(sibling.key))
+                    replacements.set(sibling.key, sibling);
+        }
+    }
+    const recipes = current.recipes.flatMap((row) => {
+        const replacement = replacements.get(row.key);
+        if (replacement !== undefined)
+            return [replacement];
+        if (row.input.kind === "tts" && groups.has(row.input.logicalKey))
+            return [];
+        return [row];
+    });
+    for (const row of replacements.values())
+        if (!recipes.some((one) => one.key === row.key))
+            recipes.push(row);
+    const work = recipes.flatMap((recipe) => {
+        const row = current.work.find((one) => one.key === recipe.key);
+        if (row !== undefined)
+            return [
+                {
+                    ...row,
+                    requestFingerprint: recipe.requestFingerprint,
+                    fingerprint: recipe.fingerprint,
+                    dependsOn: recipe.dependsOn,
+                    kind: recipe.kind,
+                    stage: recipe.stage,
+                },
+            ];
+        if (!replacements.has(recipe.key))
+            return [];
+        return [
+            {
+                key: recipe.key,
+                stage: recipe.stage,
+                kind: recipe.kind,
+                requestFingerprint: recipe.requestFingerprint,
+                fingerprint: recipe.fingerprint,
+                dependsOn: recipe.dependsOn,
+                disposition: recipe.kind === "local" ? "local" : "generate",
+                reason: "Continue the exact admitted request.",
+                inflight: false,
+                pieceIds: [],
+            },
+        ];
+    });
+    return { ...current, recipes, work };
+}
+export function requiresNewSubmission(deps, revisionId, key, fingerprint) {
+    const row = deps.db
+        .prepare(`SELECT w.id,w.state,w.dispatch_state,p.continuation FROM revision_work_reservations r JOIN revision_work w ON w.id=r.work_id JOIN revision_work_pieces p ON p.id=r.piece_id WHERE r.revision_id=? AND r.work_key=? AND r.fingerprint=? AND w.recipe_context IS NOT NULL`)
+        .get(revisionId, key, fingerprint);
+    return (row === undefined ||
+        (row.state !== "running" &&
+            !(row.state === "pending" && row.dispatch_state === "allowed") &&
+            row.continuation === null &&
+            !(key === "article:body" && cachedArticleComplete(deps, revisionId, String(row.id)))));
+}
+function cachedArticleComplete(deps, revisionId, workId) {
+    const answers = deps.db
+        .prepare(`SELECT p.work_key,json_extract(p.result_json,'$.finishReason') AS finish_reason
+       FROM revision_work_pieces p
+       JOIN revision_work_reservations r ON r.piece_id=p.id AND r.work_id=p.work_id
+         AND r.work_key=p.work_key AND r.fingerprint=p.fingerprint
+       JOIN project_revisions v ON v.id=r.revision_id
+       JOIN json_each(v.fingerprints) f ON f.key=COALESCE(r.logical_key,r.work_key)
+         AND f.value=COALESCE(r.desired_fingerprint,r.fingerprint)
+       WHERE r.revision_id=? AND p.work_id=? AND p.result_json IS NOT NULL
+         AND json_extract(p.input_json,'$.kind')='llm'
+         AND COALESCE(r.logical_key,r.work_key)='article:body'`)
+        .all(revisionId, workId);
+    for (let part = 0; part <= continuationLimit; part += 1) {
+        const key = part === 0 ? "article:body" : `article:continuation:${part}`;
+        const answer = answers.find((row) => row.work_key === key);
+        if (answer === undefined)
+            return false;
+        if (answer.finish_reason !== "length")
+            return true;
+    }
+    return false;
+}
+export function hasSubmittedRequest(deps, revisionId, key, fingerprint) {
+    return (deps.db
+        .prepare(`SELECT 1 FROM revision_work_reservations r JOIN revision_work_pieces p ON p.id=r.piece_id WHERE r.revision_id=? AND r.work_key=? AND r.fingerprint=? AND p.submitted_at IS NOT NULL AND p.continuation IS NULL AND p.state!='done'`)
+        .get(revisionId, key, fingerprint) !== undefined);
+}