@gentbajko/slopify 0.8.3 → 1.0.0

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

@@ -0,0 +1,166 @@
+import { z } from "zod";
+import { stageKinds, stageStates } from "../../kernel/pipeline.js";
+import { currentRevisionId } from "../revisions/repo.js";
+import { getRevisionView } from "../revisions/view.js";
+import { settleScheduleRunsForProject } from "../schedules/repo.js";
+import { executionPlan, executionView, savedCatalogue } from "./runtime-plan.js";
+import { workPieces } from "./work-records.js";
+const workRow = z.object({
+    id: z.string(),
+    project_id: z.string(),
+    revision_id: z.string(),
+    stage_id: z.string(),
+    kind: z.enum(stageKinds),
+    state: z.enum(stageStates),
+    fingerprint: z.string(),
+});
+export function executionStages(deps, projectId) {
+    const head = currentRevisionId(deps.db, projectId);
+    if (head === undefined)
+        return [];
+    const view = getRevisionView(deps, projectId, head);
+    const rows = deps.db
+        .prepare(`SELECT DISTINCT w.* FROM revision_work w JOIN revision_work_reservations r ON r.work_id=w.id WHERE r.project_id=? AND r.revision_id=?`)
+        .all(projectId, head);
+    const keys = new Set(deps.db
+        .prepare("SELECT work_key FROM revision_work_reservations WHERE revision_id=?")
+        .all(head)
+        .map((row) => String(row.work_key)));
+    return rows
+        .filter((row) => workPieces(deps.db, String(row.id)).some((piece) => {
+        if (!keys.has(piece.key))
+            return false;
+        if (piece.key === "subtitles:timing" && view?.revision.content.subtitleCues !== undefined)
+            return false;
+        if (piece.input.kind === "deferred" && piece.key.endsWith(":future")) {
+            const prefix = piece.key.slice(0, -"future".length);
+            return !rows.some((candidate) => workPieces(deps.db, String(candidate.id)).some((part) => part.input.kind === "tts" && part.key.startsWith(prefix)));
+        }
+        return true;
+    }))
+        .map((value) => {
+        const row = workRow.parse(value);
+        return {
+            id: row.stage_id,
+            projectId,
+            kind: row.kind,
+            state: row.state,
+            work: {
+                projectId,
+                revisionId: row.revision_id,
+                workId: row.id,
+                stageId: row.stage_id,
+                kind: row.kind,
+                fingerprint: row.fingerprint,
+            },
+        };
+    });
+}
+export function invocationReady(deps, work) {
+    const row = deps.db
+        .prepare("SELECT recipe_context FROM revision_work WHERE id=? AND project_id=? AND revision_id=?")
+        .get(work.workId, work.projectId, work.revisionId);
+    if (row?.recipe_context === null || row === undefined)
+        return false;
+    const view = executionView(deps, work.projectId, work.revisionId);
+    if (view === undefined)
+        return false;
+    const plan = executionPlan(deps, view, savedCatalogue(row.recipe_context));
+    const pieces = workPieces(deps.db, work.workId);
+    return pieces.some((piece) => {
+        if (piece.state === "done" ||
+            piece.dispatchState !== "allowed" ||
+            piece.input.kind === "deferred")
+            return false;
+        if (piece.continuation !== null)
+            return true;
+        const recipe = plan.recipes.find((value) => value.key === piece.key && value.fingerprint === piece.fingerprint);
+        if (recipe === undefined || recipe.unresolved || recipe.deferred)
+            return false;
+        return recipe.dependsOn.every((key) => {
+            const dependency = plan.work.find((value) => value.key === key);
+            return dependency?.disposition === "reuse" && !dependency.inflight;
+        });
+    });
+}
+export function executionStandings(deps, projectId) {
+    const revisionId = currentRevisionId(deps.db, projectId);
+    const view = revisionId === undefined ? undefined : getRevisionView(deps, projectId, revisionId);
+    if (view === undefined)
+        return [];
+    const work = executionStages(deps, projectId);
+    return stageKinds.map((kind) => {
+        const source = view.revision.config.sources[kind];
+        const group = work
+            .filter((entry) => entry.kind === kind)
+            .map((entry) => {
+            const pieces = workPieces(deps.db, entry.work.workId);
+            const retained = pieces.length > 0 &&
+                pieces.every((piece) => view.outputs.some((output) => output.workKey === piece.key &&
+                    output.selected &&
+                    output.available &&
+                    output.state === "ready") ||
+                    view.pieces.some((output) => output.key === piece.key &&
+                        output.selected &&
+                        output.available &&
+                        output.piece.state === "done" &&
+                        output.fingerprint === piece.fingerprint));
+            // Save can bind an existing asset without granting its placeholder invocation.
+            return retained ? { ...entry, state: "done" } : entry;
+        });
+        let state = source === "off" ? "skipped" : source === "provide" ? "provided" : "pending";
+        if (group.some((entry) => entry.state === "running"))
+            state = "running";
+        else if (group.some((entry) => entry.state === "failed"))
+            state = "failed";
+        else if (group.some((entry) => entry.state === "canceled"))
+            state = "canceled";
+        else if (group.length > 0)
+            state = group.every((entry) => entry.state === "done")
+                ? source === "provide"
+                    ? "provided"
+                    : "done"
+                : "pending";
+        return { kind, state };
+    });
+}
+export function projectStandings(deps, projectId) {
+    const standings = executionStandings(deps, projectId);
+    for (const stage of standings) {
+        const invocations = executionStages(deps, projectId).filter((work) => work.kind === stage.kind);
+        const current = invocations.reduce((total, work) => {
+            if (work.state === "done")
+                return total + 1;
+            const progress = deps.db
+                .prepare("SELECT progress_current,progress_total FROM revision_work WHERE id=?")
+                .get(work.work.workId);
+            if (typeof progress?.progress_current !== "number" ||
+                typeof progress.progress_total !== "number" ||
+                progress.progress_total <= 0)
+                return total;
+            return total + Math.max(0, Math.min(1, progress.progress_current / progress.progress_total));
+        }, 0);
+        const failed = invocations.find((work) => work.state === "failed");
+        const failure = failed === undefined
+            ? null
+            : (deps.db
+                .prepare("SELECT failure_reason FROM revision_work WHERE id=?")
+                .get(failed.work.workId)?.failure_reason ?? null);
+        deps.db
+            .prepare("UPDATE stages SET state=?,failure_reason=?,progress_current=?,progress_total=?,finished_at=CASE WHEN ?='done' THEN ? ELSE NULL END WHERE project_id=? AND kind=?")
+            .run(stage.state, failure, invocations.length === 0 ? null : current, invocations.length === 0 ? null : invocations.length, stage.state, deps.clock.now().toISOString(), projectId, stage.kind);
+    }
+    settleScheduleRunsForProject(deps.db, projectId, deps.clock.now().toISOString());
+}
+export function recordWorkProgress(deps, event) {
+    if (event.workId === undefined ||
+        event.revisionId === undefined ||
+        !Number.isFinite(event.current) ||
+        !Number.isFinite(event.total) ||
+        event.total <= 0)
+        return;
+    deps.db
+        .prepare("UPDATE revision_work SET progress_current=?,progress_total=? WHERE id=? AND revision_id=? AND project_id=? AND kind=? AND state='running'")
+        .run(Math.max(0, Math.min(event.current, event.total)), event.total, event.workId, event.revisionId, event.projectId, event.stage);
+    projectStandings(deps, event.projectId);
+}

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

@@ -0,0 +1,202 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+import { resolveFont } from "../fonts/index.js";
+import { validateCues } from "../revisions/rules.js";
+import { discardPreparedAssets, writeAsset } from "../storage/assets.js";
+import { outputPath } from "../storage/layout.js";
+import { captionCues, serializeAss, serializeSrt, serializeVtt } from "../subtitles/captions.js";
+import { exportSnapshot, retainedOutput, revisionAudio, revisionTranscript, } from "./runtime-export-inputs.js";
+import { preparedResult, preparedText, publishResult } from "./runtime-publication.js";
+const wordsSchema = z.object({
+    key: z.string(),
+    words: z.array(z.object({
+        text: z.string(),
+        start: z.number().finite().nonnegative(),
+        end: z.number().finite().positive(),
+        confidence: z.number().optional(),
+    })),
+    omissions: z
+        .array(z.object({ start: z.number().finite().nonnegative(), text: z.string() }))
+        .default([]),
+});
+const cuesSchema = z.object({
+    cues: z.array(z.object({
+        text: z.string(),
+        start: z.number().finite().nonnegative(),
+        end: z.number().finite().positive(),
+    })),
+    omissions: wordsSchema.shape.omissions,
+});
+export async function executeSubtitleRecipe(deps, context, piece) {
+    if (!context.maySubmit(piece.id))
+        return "held";
+    context.signal.throwIfAborted();
+    const snapshot = exportSnapshot(deps, context, piece);
+    if (piece.key === "subtitles:timing")
+        return timing(deps, context, piece, snapshot);
+    if (piece.key === "subtitles:cues")
+        return cues(deps, context, piece, snapshot);
+    if (piece.key === "subtitles:files")
+        return files(deps, context, piece, snapshot);
+    throw new Error("Unknown subtitle recipe.");
+}
+async function timing(deps, context, piece, snapshot) {
+    const audio = await revisionAudio(deps, context, snapshot.view);
+    if (audio.length === 0)
+        throw new Error("Subtitles need narration audio.");
+    if (deps.alignSubtitles === undefined)
+        throw new Error("Local subtitle alignment is unavailable in this build.");
+    if (!context.maySubmit(piece.id))
+        return "held";
+    const words = [];
+    const omissions = [];
+    let offset = 0;
+    const total = audio.reduce((sum, segment) => sum + segment.seconds, 0);
+    for (const segment of audio) {
+        context.signal.throwIfAborted();
+        if (segment.path !== null && segment.kind !== "gap") {
+            const aligned = await deps.alignSubtitles({
+                audioPath: segment.path,
+                text: revisionTranscript(deps, snapshot, segment.kind),
+                cacheDir: join(deps.paths.dataDir, "models", "english-subtitles"),
+                ffmpeg: deps.ffmpeg,
+                signal: context.signal,
+                onOmission: (value) => omissions.push({ ...value, start: value.start + offset }),
+                onProgress: (current, maximum) => context.emit({
+                    type: "stage.progress",
+                    projectId: context.work.projectId,
+                    stage: "video",
+                    current: Math.round((100 * (offset + segment.seconds * (maximum > 0 ? current / maximum : 0))) / total),
+                    total: 100,
+                }),
+            });
+            for (const word of aligned) {
+                if (word.end > segment.seconds + 0.1)
+                    throw new Error("Subtitle timing exceeds the narration duration.");
+                words.push({
+                    ...word,
+                    start: word.start + offset,
+                    end: Math.min(word.end, segment.seconds) + offset,
+                });
+            }
+        }
+        offset += segment.seconds;
+    }
+    if (captionCues(words).length === 0)
+        throw new Error("No spoken words could be aligned. Check that the English article matches the audio.");
+    context.signal.throwIfAborted();
+    const output = preparedText(deps, context, piece, "subtitle_words", "subtitles.json", JSON.stringify({ key: piece.logicalFingerprint ?? piece.fingerprint, words, omissions }));
+    await publishResult(deps, context, piece, [output], { words, omissions }, output.asset);
+    return "done";
+}
+async function cues(deps, context, piece, snapshot) {
+    const { view, plan } = snapshot;
+    const manual = view.revision.content.subtitleCues;
+    let value;
+    if (manual !== undefined) {
+        if (plan.work.find((one) => one.key === piece.key)?.disposition === "review")
+            throw new Error("Review the saved captions against the current narration before rebuilding.");
+        const audio = await revisionAudio(deps, context, view);
+        const errors = validateCues(manual.cues, audio.reduce((sum, segment) => sum + segment.seconds, 0));
+        if (errors.length > 0)
+            throw new Error(errors.map((error) => error.message).join(" "));
+        value = { cues: [...manual.cues], omissions: [] };
+    }
+    else {
+        const output = view.outputs.find((one) => one.selected &&
+            one.available &&
+            one.state === "ready" &&
+            one.workKey === "subtitles:timing");
+        if (output === undefined)
+            throw new Error("The revision has no aligned subtitle timing.");
+        const timed = wordsSchema.parse(JSON.parse(readFileSync(outputPath(deps.paths, context.work.projectId, output.output.path), "utf8")));
+        value = { cues: [...captionCues(timed.words)], omissions: timed.omissions };
+    }
+    if (!context.maySubmit(piece.id))
+        return "held";
+    const asset = writeAsset(deps, context.work.projectId, "cues.json", Buffer.from(JSON.stringify(value)));
+    await publishResult(deps, context, piece, [], value, asset);
+    return "done";
+}
+async function files(deps, context, piece, snapshot) {
+    const { view } = snapshot;
+    const config = view.revision.config.subtitles;
+    if (config === undefined || config.mode === "off")
+        throw new Error("The admitted revision has no subtitles.");
+    const row = view.pieces.find((one) => one.key === "subtitles:cues" && one.selected && one.available && one.piece.state === "done");
+    if (row?.piece.payload === null || row?.piece.payload === undefined)
+        throw new Error("The revision has no prepared captions.");
+    const value = cuesSchema.parse(JSON.parse(row.piece.payload));
+    const previous = view.outputs.find((one) => one.output.role === "subtitle_font" && one.selected && one.available);
+    const previousFiles = view.pieces.find((one) => one.key === "subtitles:files" &&
+        one.piece.state === "done" &&
+        (one.selected ||
+            (one.publicationId !== null && one.publicationId === previous?.publicationId)));
+    const savedFont = z
+        .object({
+        font: z
+            .object({
+            id: z.string(),
+            name: z.string(),
+            assName: z.string(),
+            extension: z.enum([".ttf", ".otf", ".ttc"]),
+        })
+            .optional(),
+    })
+        .parse(JSON.parse(previousFiles?.piece.payload ?? "{}")).font;
+    const font = savedFont?.id === config.fontId && previous !== undefined
+        ? { ...savedFont, path: outputPath(deps.paths, context.work.projectId, previous.output.path) }
+        : await resolveFont(deps.paths, config.fontId);
+    if (!context.maySubmit(piece.id))
+        return "held";
+    const prepared = [];
+    try {
+        const frame = view.revision.config.format === "16:9"
+            ? { width: 1920, height: 1080 }
+            : { width: 1080, height: 1920 };
+        for (const [role, filename, text] of [
+            ["subtitles_srt", "subtitles.srt", serializeSrt(value.cues)],
+            ["subtitles_vtt", "subtitles.vtt", serializeVtt(value.cues)],
+            [
+                "subtitle_ass",
+                "subtitles.ass",
+                serializeAss(value.cues, {
+                    ...frame,
+                    fontName: font.assName,
+                    fontSize: config.fontSize,
+                    position: config.position,
+                }),
+            ],
+        ])
+            prepared.push(preparedText(deps, context, piece, role, filename, text));
+        prepared.push(preparedResult(deps, context, piece, "subtitle_font", writeAsset(deps, context.work.projectId, `selected${font.extension}`, readFileSync(font.path))));
+        const media = view.outputs.find((one) => one.selected &&
+            one.available &&
+            one.state === "ready" &&
+            (one.output.role === "audio_export" ||
+                (one.output.role === "video" && config.mode === "files")));
+        if (media !== undefined) {
+            const retained = retainedOutput(deps, view, media);
+            prepared.push({
+                ...retained,
+                output: {
+                    ...retained.output,
+                    meta: {
+                        ...retained.output.meta,
+                        subtitlesMode: "files",
+                        subtitleOmissions: value.omissions,
+                    },
+                },
+            });
+        }
+        await publishResult(deps, context, piece, prepared, {
+            ...value,
+            font: { id: font.id, name: font.name, assName: font.assName, extension: font.extension },
+        });
+        return "done";
+    }
+    finally {
+        discardPreparedAssets(deps, prepared.map((one) => one.asset));
+    }
+}

package/dist/slices/rebuild/service-readiness.js

@@ -0,0 +1,110 @@
+import { readinessIsUsable } from "../../kernel/ports/model.js";
+import { cliPathStatus } from "../settings/cli-paths.js";
+import { hasKey, listVoices } from "../settings/repo.js";
+import { requiresNewSubmission } from "./preview-retained.js";
+import { recipeProviderChoice } from "./recipe-provider-choice.js";
+export function paidChoices(snapshot, view, deps) {
+    const choices = [];
+    for (const recipe of snapshot.recipes) {
+        if (recipe.kind !== "provider" ||
+            snapshot.dispositions.find((row) => row.key === recipe.key)?.disposition === "reuse")
+            continue;
+        if (!requiresNewSubmission(deps, view.revision.id, recipe.key, recipe.fingerprint))
+            continue;
+        const choice = recipeProviderChoice(recipe, view.revision.config);
+        if (choice !== undefined)
+            choices.push(choice);
+    }
+    return [
+        ...new Map(choices.map((choice) => [`${choice.family}:${choice.provider}:${choice.model}`, choice])).values(),
+    ];
+}
+export async function checkReadiness(deps, snapshot, view) {
+    const choices = paidChoices(snapshot, view, deps);
+    if (choices.length === 0)
+        return { fields: [], providers: [] };
+    const providers = await deps.providers();
+    const fields = [];
+    for (const choice of choices) {
+        const provider = providers.find((row) => row.id === choice.provider && row.family === choice.family);
+        if (provider === undefined || !readinessIsUsable(provider.readiness)) {
+            fields.push({
+                field: choice.family,
+                message: provider?.readiness.kind === "cli" && provider.readiness.issue
+                    ? provider.readiness.issue
+                    : "Configure this provider before rebuilding.",
+            });
+            continue;
+        }
+        const models = await deps.modelsFor(choice.provider, choice.family);
+        if (!models.some((row) => row.id === choice.model))
+            fields.push({
+                field: `${choice.family}.model`,
+                message: "Choose an available model before rebuilding.",
+            });
+    }
+    return { fields, providers };
+}
+export function localReadiness(deps, snapshot, view, providers, catalogue) {
+    const fields = [];
+    for (const choice of paidChoices(snapshot, view, deps)) {
+        const model = catalogue[choice.family].find((row) => row.provider === choice.provider &&
+            row.id === choice.model &&
+            row.enabled &&
+            !row.deprecated);
+        if (model === undefined)
+            fields.push({
+                field: `${choice.family}.model`,
+                message: "The selected model is no longer available.",
+            });
+        const provider = providers.find((row) => row.id === choice.provider && row.family === choice.family);
+        if (provider?.cliPath !== undefined &&
+            cliPathStatus(deps.db, provider.id).command !== provider.cliPath.command)
+            fields.push({
+                field: `${choice.family}.cliPath`,
+                message: "The configured CLI command changed. Check readiness again before rebuilding.",
+            });
+        if (provider?.readiness.kind === "keyed" && !hasKey(deps.db, provider.id))
+            fields.push({ field: choice.family, message: "Save the provider key before rebuilding." });
+        if (choice.voice !== undefined &&
+            !listVoices(deps.db).some((row) => row.provider === choice.provider && row.voiceId === choice.voice))
+            fields.push({ field: "audio.voice", message: "Choose a saved voice before rebuilding." });
+    }
+    for (const recipe of snapshot.recipes) {
+        if (snapshot.dispositions.find((row) => row.key === recipe.key)?.disposition === "reuse" ||
+            !requiresNewSubmission(deps, view.revision.id, recipe.key, recipe.fingerprint))
+            continue;
+        const input = recipe.input;
+        if (input.kind === "tts") {
+            const model = catalogue.tts.find((row) => row.provider === input.provider && row.id === input.model);
+            const maximum = model?.tts.maxCharacters;
+            if (maximum !== undefined && input.text.length > maximum)
+                fields.push({
+                    field: `work.${recipe.key}.text`,
+                    message: "This saved physical request exceeds the current model limit. Regenerate this narration group to plan new parts.",
+                });
+        }
+        else if (input.kind === "llm") {
+            const model = catalogue.llm.find((row) => row.provider === input.provider && row.id === input.model);
+            if (input.thinking !== null && model?.llm.thinking?.[input.thinking] === undefined)
+                fields.push({
+                    field: `work.${recipe.key}.thinking`,
+                    message: "The selected thinking setting is no longer supported.",
+                });
+            if (input.webSearch && model?.llm.webSearch !== true)
+                fields.push({
+                    field: `work.${recipe.key}.webSearch`,
+                    message: "This model no longer supports the required web search.",
+                });
+        }
+        else if (input.kind === "image") {
+            const model = catalogue.image.find((row) => row.provider === input.provider && row.id === input.model);
+            if (model !== undefined && !model.image.aspectRatios.includes(input.aspect))
+                fields.push({
+                    field: `work.${recipe.key}.aspect`,
+                    message: "The model does not support this output shape.",
+                });
+        }
+    }
+    return fields;
+}

package/dist/slices/rebuild/service.js

@@ -0,0 +1,149 @@
+import { withProjectControl } from "../control/lock.js";
+import { requestHash } from "../revisions/mutation-request.js";
+import { currentRevisionId } from "../revisions/repo.js";
+import { getRevisionView } from "../revisions/view.js";
+import { previewRebuildSchema, startRebuildSchema, } from "./model.js";
+import { executionSnapshotSchema, planPreview, reviewStillCovers } from "./preview-plan.js";
+import { admissionReceipt, admitPreview, previewById, storePreview } from "./repo.js";
+import { checkReadiness, localReadiness } from "./service-readiness.js";
+export function rebuildConfirmations(required, confirmed, unknownCosts, acknowledged) {
+    const given = new Set(confirmed);
+    if (given.size !== confirmed.length ||
+        required.length !== given.size ||
+        required.some((key) => !given.has(key)))
+        return "review-required";
+    if (unknownCosts > 0 && !acknowledged)
+        return "cost-ack-required";
+    return undefined;
+}
+export async function previewRebuild(deps, input) {
+    const parsed = previewRebuildSchema.safeParse({
+        baseRevisionId: input.baseRevisionId,
+        request: input.request,
+    });
+    if (!parsed.success)
+        return {
+            ok: false,
+            reason: "invalid-selection",
+            fields: parsed.error.issues.map((issue) => ({
+                field: issue.path.join("."),
+                message: issue.message,
+            })),
+        };
+    const view = getRevisionView(deps, input.projectId, input.baseRevisionId);
+    if (view === undefined)
+        return {
+            ok: false,
+            reason: currentRevisionId(deps.db, input.projectId) === undefined ? "no-project" : "conflict",
+        };
+    if (!view.current)
+        return { ok: false, reason: "conflict" };
+    const plan = planPreview(deps, view, deps.catalogue.read(), input.request, deps.ids.next());
+    if (!plan.ok)
+        return plan;
+    storePreview(deps, plan.value.preview, plan.value.execution);
+    return { ok: true, value: plan.value.preview };
+}
+export async function startRebuild(deps, input) {
+    const { projectId, ...body } = input;
+    const parsed = startRebuildSchema.safeParse(body);
+    if (!parsed.success)
+        return {
+            ok: false,
+            reason: "invalid-selection",
+            fields: parsed.error.issues.map((issue) => ({
+                field: issue.path.join("."),
+                message: issue.message,
+            })),
+        };
+    const hash = requestHash("rebuild", input.baseRevisionId, parsed.data);
+    const replay = admissionReceipt(deps.db, projectId, input.idempotencyKey, hash);
+    if (replay !== undefined) {
+        if (replay.ok)
+            wake(deps, projectId, replay.value);
+        return replay;
+    }
+    const preview = previewById(deps.db, projectId, input.previewId);
+    const view = getRevisionView(deps, projectId, input.baseRevisionId);
+    if (view === undefined)
+        return {
+            ok: false,
+            reason: currentRevisionId(deps.db, projectId) === undefined ? "no-project" : "conflict",
+        };
+    if (!view.current)
+        return { ok: false, reason: "conflict" };
+    if (preview === undefined || preview.baseRevisionId !== input.baseRevisionId)
+        return { ok: false, reason: "stale-preview" };
+    const confirmation = rebuildConfirmations(preview.providedReuseRequired, input.confirmedProvidedWorkKeys, preview.costs.unknown, input.acknowledgeUnknownCosts);
+    if (confirmation !== undefined)
+        return { ok: false, reason: confirmation };
+    const row = deps.db
+        .prepare("SELECT execution_json FROM rebuild_previews WHERE id=? AND project_id=?")
+        .get(preview.id, projectId);
+    if (typeof row?.execution_json !== "string")
+        return { ok: false, reason: "stale-preview" };
+    const snapshot = executionSnapshotSchema.parse(JSON.parse(row.execution_json));
+    let ready;
+    try {
+        ready = await checkReadiness(deps, snapshot, view);
+    }
+    catch {
+        deps.log.write("warn", "project.rebuild", {
+            projectId,
+            detail: "Provider readiness could not be loaded.",
+        });
+        return { ok: false, reason: "readiness" };
+    }
+    if (ready.fields.length > 0)
+        return { ok: false, reason: "readiness", fields: ready.fields };
+    return withProjectControl(deps.db, projectId, () => {
+        const again = admissionReceipt(deps.db, projectId, input.idempotencyKey, hash);
+        if (again !== undefined) {
+            if (again.ok)
+                wake(deps, projectId, again.value);
+            return again;
+        }
+        if (currentRevisionId(deps.db, projectId) !== input.baseRevisionId)
+            return { ok: false, reason: "conflict" };
+        const current = getRevisionView(deps, projectId, input.baseRevisionId);
+        if (current === undefined)
+            return { ok: false, reason: "no-project" };
+        const catalogue = deps.catalogue.read();
+        const fresh = planPreview(deps, current, catalogue, preview.selection, preview.id);
+        if (!fresh.ok || !reviewStillCovers(preview, snapshot, fresh.value))
+            return { ok: false, reason: "stale-preview" };
+        const fields = localReadiness(deps, snapshot, current, ready.providers, catalogue);
+        if (fields.length > 0)
+            return { ok: false, reason: "readiness", fields };
+        const admitted = admitPreview(deps, {
+            preview,
+            idempotencyKey: input.idempotencyKey,
+            requestHash: hash,
+        });
+        if (admitted.ok) {
+            deps.emit(projectId, { type: "project.updated", projectId });
+            wake(deps, projectId, admitted.value);
+        }
+        return admitted;
+    });
+}
+function wake(deps, projectId, admission) {
+    const owned = deps.db
+        .prepare("SELECT 1 FROM revision_work WHERE project_id=? AND admission_id=? AND state!='done' AND dispatch_state='allowed' LIMIT 1")
+        .get(projectId, admission.admissionId) !== undefined;
+    const unfinished = owned ||
+        admission.workIds.some((id) => deps.db
+            .prepare("SELECT 1 FROM revision_work WHERE id=? AND project_id=? AND state!='done' AND dispatch_state='allowed'")
+            .get(id, projectId) !== undefined);
+    if (!unfinished && admission.replayed)
+        return;
+    try {
+        deps.runner.tick(projectId);
+    }
+    catch {
+        deps.log.write("warn", "project.rebuild", {
+            projectId,
+            detail: "Rebuild was admitted but the runner could not be notified.",
+        });
+    }
+}