@gentbajko/slopify 3.25.9 → 4.0.0

package/dist/slices/template-studio/paid.js

@@ -0,0 +1,348 @@
+import { setTimeout as sleep } from "node:timers/promises";
+import { transact } from "../../kernel/db/tx.js";
+import { internalError } from "../../kernel/errors.js";
+import { derive } from "../../kernel/runner/graph.js";
+import { pendingAdmitted } from "../admission/admitted-work.js";
+import { projectExists, projectPaused, stagesOf } from "../admission/repo.js";
+import { startRun } from "../admission/start.js";
+import { estimateRun } from "../estimate/index.js";
+import { checkDraftReadiness } from "../play-drafts/readiness.js";
+import { templateById } from "../project-templates/repo.js";
+import { recoverProject } from "../rebuild/recovery.js";
+import { previewRebuild, startRebuild } from "../rebuild/service.js";
+import { saveRevision } from "../revisions/mutations.js";
+import { currentRevisionId } from "../revisions/repo.js";
+import { getRevisionView } from "../revisions/view.js";
+import { budgetRoom, budgetWords, fitsBudget } from "./budget.js";
+import { sampleEdit } from "./edit.js";
+import { removeHiddenProject } from "./hidden.js";
+import { continueJobAsSave } from "./jobs.js";
+import { resolveSampleRun, totals } from "./quote.js";
+import { sampleOf, sampleVersions, setSampleVersion, upsertSample } from "./repo.js";
+import { exceedsAcknowledged } from "./save.js";
+import { sampleDocument } from "./scope.js";
+import { defaultSampleTopic } from "./service.js";
+const money = (value) => `$${value.toFixed(2)}`;
+// Why a sample of about `high` (with `unknown` steps unpriced) waits instead of starting, or
+// undefined when it may start.
+export function holdReason(deps, job, cost) {
+    if (exceedsAcknowledged(cost.high, job.ackHigh))
+        return `Waiting: this sample now costs about ${money(cost.high)}, more than the ${money(job.ackHigh)} you saw. Press Make sample (${money(cost.high)}) to make it.`;
+    if (cost.unknown > 0 && !deps.acks.accepted(job.templateId, job.templateVersion))
+        return `Waiting: ${String(cost.unknown)} ${cost.unknown === 1 ? "step of this sample has" : "steps of this sample have"} no known price. Press Make sample to accept that and make it.`;
+    const room = budgetRoom(deps.db, deps.now, deps.timeZone);
+    if (!fitsBudget(room, cost.high, cost.usesPlan))
+        return `Waiting: ${budgetWords(room, cost, "this sample")}, or press Make sample tomorrow.`;
+    return undefined;
+}
+// Whether the sample project still has work going: a stage running or waiting, or work admitted
+// and not yet finished while nothing failed, was canceled or paused. A step still waiting counts
+// only while its stage is unfinished: a run's placeholder for work it turned out not to need
+// (no figure to describe, say) stays pending on a finished stage, and nothing will ever run it.
+export function sampleBusy(db, projectId) {
+    const state = derive(stagesOf(db, projectId), projectPaused(db, projectId));
+    if (state === "running")
+        return true;
+    if (state === "failed" || state === "canceled" || state === "paused")
+        return false;
+    return (db
+        .prepare(`SELECT 1 FROM revision_work w WHERE w.project_id=? AND w.dispatch_state='allowed'
+           AND (w.state='running' OR (w.state='pending' AND EXISTS (SELECT 1 FROM stages s
+             WHERE s.id=w.stage_id AND s.state NOT IN ('done','provided','skipped')))) LIMIT 1`)
+        .get(projectId) !== undefined);
+}
+// Resolves once the project has no work going (`sampleBusy`) and no call in flight.
+export async function settled(deps, projectId, signal) {
+    while (sampleBusy(deps.start.db, projectId) ||
+        deps.start.runner.hasInflight?.(projectId) === true)
+        await sleep(deps.pollMs ?? 2000, undefined, { signal });
+}
+// Whether a restart stopped the project's run short: a step that was running when Slopify quit
+// failed as interrupted, or its admitted work is held until the run is continued.
+function stoppedByRestart(db, projectId) {
+    return (stagesOf(db, projectId).some((stage) => stage.state === "failed" && stage.failureReason === "interrupted") ||
+        db
+            .prepare(`SELECT 1 FROM revision_work w WHERE w.project_id=? AND w.dispatch_state='held'
+           AND ${pendingAdmitted("w")} LIMIT 1`)
+            .get(projectId) !== undefined);
+}
+// What the project's calls billed per use cost since this version's sample started on it.
+function spentSince(db, projectId, version) {
+    const row = db
+        .prepare("SELECT COALESCE(SUM(cost),0) AS spent FROM provider_usage WHERE project_id=? AND on_plan=0 AND created_at>=?")
+        .get(projectId, version.updatedAt);
+    return typeof row?.spent === "number" ? row.spent : 0;
+}
+// What the finished sample says: done, or the failed step's own sentence.
+function outcome(db, projectId) {
+    const stages = stagesOf(db, projectId);
+    const state = derive(stages, projectPaused(db, projectId));
+    if (state === "failed") {
+        const reason = stages.find((stage) => stage.state === "failed")?.failureReason;
+        return {
+            failed: (reason === undefined || reason === null ? undefined : studioWords(reason)) ??
+                "A step of the sample failed without saying why. Press Make sample to try again; if it fails again, use Download diagnostics in Settings and report it.",
+        };
+    }
+    if (state === "canceled" || state === "paused")
+        return { failed: "The sample stopped before it finished. Press Make sample to make it again." };
+    return { failed: null };
+}
+// A step's sentence names a project's Try again (on its stage); a studio's own button for it
+// is another: Make sample for a sample, Compare again for a model comparison. `then` is what
+// follows the button's name in the sentence.
+export function studioWords(reason, button = "Make sample", then = " to try again") {
+    return reason
+        .replace(/choose another model in the Providers section of Edit project/g, "choose another model with Change on that section's “Made with …” line")
+        .replace(/(\b[UuPp](?:se|ress) )?Try again(?: on [A-Z][a-z]+)?/g, (_, verb, at) => {
+        const opens = verb === undefined ? /(^|[.;:!?]\s+)$/.test(reason.slice(0, at)) : /^[UP]/.test(verb);
+        return `${opens ? "Press" : "press"} ${button}${then}`;
+    });
+}
+const refusedSentence = {
+    conflict: "The sample project changed while the sample was being set up. Press Make sample again.",
+    "stale-preview": "What the sample needed changed while it was being set up. Press Make sample again.",
+    readiness: "A provider this template uses isn't set up, so the sample can't start. Set it up in Settings → Providers, then press Make sample.",
+    "cost-ack-required": "Some steps of this sample have no known price. Press Make sample to accept that and make it.",
+};
+export function refused(reason, fields) {
+    const detail = [...new Set((fields ?? []).map((field) => field.message))].join(" ");
+    return (refusedSentence[reason] ??
+        (detail === ""
+            ? "Slopify couldn't start the sample. Press Make sample again; if it fails again, use Download diagnostics in Settings and report it."
+            : `The sample couldn't start: ${detail}`));
+}
+export async function makePaidSample(deps, job, signal) {
+    const { db } = deps.start;
+    const at = () => deps.start.clock.now().toISOString();
+    const template = templateById(db, job.templateId, job.templateVersion);
+    if (template === undefined)
+        return;
+    const mark = (change) => setSampleVersion(db, job.templateId, job.templateVersion, { ...change, at: at() });
+    const record = sampleOf(db, job.templateId);
+    const topic = record?.topic ?? defaultSampleTopic(db);
+    const topicSource = record?.topicSource ?? "fixed";
+    const fullScript = record?.fullScript ?? false;
+    const resolved = await resolveSampleRun(deps.start, sampleDocument(template.document, { topic, fullScript }), fullScript);
+    if (!resolved.ok) {
+        mark({
+            state: "failed",
+            heldReason: `${resolved.problem} Change it in the studio, then press Save.`,
+        });
+        return;
+    }
+    const { run, words } = resolved;
+    const hold = (cost) => holdReason({ db, now: deps.start.clock.now(), acks: deps.acks, timeZone: deps.timeZone }, job, cost);
+    let projectId = record !== undefined && projectExists(db, record.projectId) ? record.projectId : undefined;
+    if (projectId !== undefined) {
+        // Work the last sample started finishes first: it is never stopped from here.
+        await settled(deps, projectId, signal);
+        // This version's sample already started on that project (a restart queued its job again):
+        // it is continued there, never made again on a new one.
+        const head = currentRevisionId(db, projectId);
+        const version = sampleVersions(db, job.templateId).find((one) => one.templateVersion === job.templateVersion);
+        const stopped = stoppedByRestart(db, projectId);
+        // Make sample pressed again after this version's run failed: the run goes on from the
+        // failed step, as Continue the run does on a project. A revision saved over it instead left
+        // the steps after the failed one admitted on the old revision, where nothing ran them.
+        // Make sample has queued the version again by then, so the project's own state says so.
+        const failedHere = derive(stagesOf(db, projectId), projectPaused(db, projectId)) === "failed";
+        if (head !== undefined &&
+            version?.revisionId === head &&
+            (version.state === "making" || stopped || failedHere)) {
+            if (stopped || failedHere) {
+                const usesPlan = totals(estimateRun(run.draft, run.rendered, words, deps.start.catalogue).rows).usesPlan;
+                const left = Math.max(0, (version.quotedHigh ?? 0) - spentSince(db, projectId, version));
+                const waiting = hold({ high: left, unknown: 0, usesPlan });
+                if (waiting !== undefined) {
+                    mark({ state: "held", heldReason: waiting });
+                    return;
+                }
+                const resumed = await recoverProject(deps.rebuild, projectId, {
+                    baseRevisionId: head,
+                    idempotencyKey: deps.start.uuid(),
+                    action: { kind: "resume" },
+                });
+                if (!resumed.ok) {
+                    mark({
+                        state: "failed",
+                        heldReason: stopped
+                            ? `The sample stopped when Slopify quit, and couldn't go on: ${refused(resumed.reason, resumed.fields)}`
+                            : `The sample's failed step couldn't be tried again: ${refused(resumed.reason, resumed.fields)}`,
+                    });
+                    return;
+                }
+                mark({ state: "making", heldReason: null });
+            }
+            await finish(deps, job, projectId, head, signal);
+            return;
+        }
+    }
+    // The sample project a new one replaces. It is removed only once the new one actually
+    // starts: a change that waits or can't start keeps the old sample as it was.
+    let replaced;
+    if (projectId !== undefined && job.kind === "topic") {
+        // A new topic is a new video: the sample starts again on a project of its own, so no
+        // step keeps the old topic as its subject.
+        replaced = {
+            projectId,
+            sentence: "The new topic needs a new sample project, and the old one's files couldn't be removed. Press Make sample again; if it fails again, use Download diagnostics in Settings and report it.",
+        };
+        projectId = undefined;
+    }
+    if (projectId !== undefined) {
+        const base = getRevisionView(deps.rebuild, projectId, currentRevisionId(db, projectId) ?? "");
+        if (base === undefined)
+            projectId = undefined;
+        else {
+            const saved = await saveRevision(deps.rebuild, {
+                projectId,
+                baseRevisionId: base.revision.id,
+                idempotencyKey: deps.start.uuid(),
+                edit: sampleEdit(deps.rebuild, base, run),
+            });
+            if (!saved.ok && saved.reason === "invalid-edit") {
+                // A change the project's editor can't make (a different format, a step switched on
+                // that a revision can't add): the sample starts again on a project of its own.
+                replaced = {
+                    projectId,
+                    sentence: "The sample needs a new project, and the old one's files couldn't be removed. Press Make sample again; if it fails again, use Download diagnostics in Settings and report it.",
+                };
+                projectId = undefined;
+            }
+            else if (!saved.ok) {
+                mark({ state: "failed", heldReason: refused(saved.reason, saved.fields) });
+                return;
+            }
+            else {
+                const revisionId = saved.view.revision.id;
+                const preview = await previewRebuild(deps.rebuild, {
+                    projectId,
+                    baseRevisionId: revisionId,
+                    request: { kind: "allAffected" },
+                });
+                if (!preview.ok) {
+                    mark({
+                        state: "failed",
+                        revisionId,
+                        heldReason: refused(preview.reason, preview.fields),
+                    });
+                    return;
+                }
+                const cost = covered(db, job, preview.value.costs);
+                const waiting = hold(cost);
+                if (waiting !== undefined) {
+                    mark({ state: "held", revisionId, quotedHigh: cost.high, heldReason: waiting });
+                    return;
+                }
+                if (!preview.value.work.some((work) => work.disposition === "generate" || work.disposition === "local")) {
+                    mark({ state: "done", revisionId, heldReason: null });
+                    return;
+                }
+                const started = await startRebuild(deps.rebuild, {
+                    projectId,
+                    baseRevisionId: revisionId,
+                    idempotencyKey: deps.start.uuid(),
+                    previewId: preview.value.id,
+                    // Accepted on Save: unpriced steps the person's quote covered, or ones they accepted.
+                    acknowledgeUnknownCosts: cost.unknown === 0 || deps.acks.accepted(job.templateId, job.templateVersion),
+                    confirmedProvidedWorkKeys: preview.value.providedReuseRequired,
+                });
+                if (!started.ok) {
+                    mark({
+                        state: "failed",
+                        revisionId,
+                        heldReason: refused(started.reason, started.fields),
+                    });
+                    return;
+                }
+                mark({ state: "making", revisionId, quotedHigh: cost.high, heldReason: null });
+                await finish(deps, job, projectId, revisionId, signal);
+                return;
+            }
+        }
+    }
+    // The template's first sample, or one that needs a project of its own.
+    const cost = totals(estimateRun(run.draft, run.rendered, words, deps.start.catalogue).rows);
+    const waiting = hold(cost);
+    if (waiting !== undefined) {
+        mark({ state: "held", quotedHigh: cost.high, heldReason: waiting });
+        return;
+    }
+    // Nothing is spent on a provider that isn't set up: Play's own start checks come first.
+    const ready = await checkDraftReadiness(deps.start, [run]);
+    const missing = ready.fields;
+    if (missing.length > 0) {
+        mark({
+            state: "failed",
+            heldReason: `The sample can't start: ${[...new Set(missing.map((field) => field.message))].join(" ")}`,
+        });
+        return;
+    }
+    if (replaced !== undefined && !removeHiddenProject(deps.rebuild, replaced.projectId).ok) {
+        mark({ state: "failed", heldReason: replaced.sentence });
+        return;
+    }
+    // The sample's row is written before its project, under the id the project will get, so
+    // every file the run writes is in the data dir from the very first one.
+    const reserved = deps.start.ids.next();
+    let given = false;
+    const ids = {
+        next: () => {
+            if (given)
+                return deps.start.ids.next();
+            given = true;
+            return reserved;
+        },
+    };
+    const started = transact(db, () => {
+        upsertSample(db, job.templateId, {
+            projectId: reserved,
+            topic,
+            topicSource,
+            fullScript,
+            at: at(),
+        });
+        const begun = startRun({ ...deps.start, ids }, run.draft, run.rendered, true, run.templates);
+        if (begun.project.id !== reserved)
+            throw new Error(internalError("the sample's project got another id than its row", "Press Make sample again"));
+        // Paid work is under way on this project from here: a restart continues it as this
+        // version's sample (a topic job queued again must not replace it and pay twice).
+        continueJobAsSave(db, job.templateId);
+        mark({
+            state: "making",
+            revisionId: currentRevisionId(db, begun.project.id) ?? null,
+            quotedHigh: cost.high,
+            heldReason: null,
+        });
+        return begun;
+    });
+    const newId = started.project.id;
+    const revisionId = currentRevisionId(db, newId) ?? null;
+    deps.start.runner.tick(newId);
+    await finish(deps, job, newId, revisionId, signal);
+}
+// A step the rebuild can only price once the step before it has answered (the narration of an
+// article still to be written) has no price in its preview. The larger of the preview and the
+// price on record is held against what the person saw. The unpriced steps stay unpriced: they
+// start only once the version is covered (`UnknownAcks`), by the person's acceptance or by a
+// quote of theirs that priced them all, never by a price on record alone.
+function covered(db, job, costs) {
+    const usesPlan = costs.rows.some((row) => row.onPlan === true);
+    const quoted = sampleVersions(db, job.templateId).find((version) => version.templateVersion === job.templateVersion)?.quotedHigh;
+    return {
+        high: quoted === null || quoted === undefined ? costs.high : Math.max(costs.high, quoted),
+        unknown: costs.unknown,
+        usesPlan,
+    };
+}
+async function finish(deps, job, projectId, revisionId, signal) {
+    await settled(deps, projectId, signal);
+    const { failed } = outcome(deps.start.db, projectId);
+    setSampleVersion(deps.start.db, job.templateId, job.templateVersion, {
+        state: failed === null ? "done" : "failed",
+        revisionId,
+        heldReason: failed,
+        at: deps.start.clock.now().toISOString(),
+    });
+}

package/dist/slices/template-studio/quote.js

@@ -0,0 +1,148 @@
+import { projectExists } from "../admission/repo.js";
+import { estimateRun } from "../estimate/index.js";
+import { resolvePlayReview } from "../play-drafts/review.js";
+import { templateById } from "../project-templates/repo.js";
+import { budgetRoom, fitsBudget } from "./budget.js";
+import { sampleOf } from "./repo.js";
+import { sampleDocument } from "./scope.js";
+import { affectedSections } from "./sections.js";
+import { defaultSampleTopic } from "./service.js";
+// The sample's single run as Play's review resolves it, on a draft that is never saved.
+export async function resolveSampleRun(review, document, fullScript) {
+    const at = review.clock.now().toISOString();
+    const view = {
+        draft: { id: review.uuid(), version: 1, createdAt: at, updatedAt: at, document },
+        attachments: [],
+        review: null,
+        pendingStart: null,
+        start: null,
+    };
+    const resolved = await resolvePlayReview(review, view, { unsaved: true });
+    if (!resolved.ok)
+        return {
+            ok: false,
+            problem: resolved.fields.length === 0
+                ? "Play's review refused this setup, so no sample can be made. Open the template in Play (Use in Play) to see why."
+                : `No sample can be made of this setup: ${[...new Set(resolved.fields.map(fieldSentence))].join(" ")}`,
+        };
+    const run = resolved.value.runs[0];
+    if (run === undefined)
+        return {
+            ok: false,
+            problem: "Play's review found no video to make, so no sample can be made.",
+        };
+    return {
+        ok: true,
+        run: { ...run, draft: { ...run.draft, sample: { fullScript } } },
+        words: Number(document.expectedWords) || 1500,
+    };
+}
+// A refused field in the studio's words: an empty keyword is named, with where it is filled.
+export function fieldSentence(field) {
+    if (field.field.startsWith("values."))
+        return `The keyword {{${field.field.slice("values.".length)}}} is empty. Fill it in Subject & research.`;
+    return field.message;
+}
+const sectionOfRow = {
+    Research: "subject",
+    Article: "script",
+    "Intro / outro text": "script",
+    "Narration descriptions": "voice",
+    "Narration Preparation": "voice",
+    "Delivery cue overhead": "voice",
+    Narration: "voice",
+    "Speaker split": "voice",
+    "Conversation script": "voice",
+    Images: "pictures",
+    "Image scenes": "pictures",
+    "Establishing image": "pictures",
+    Thumbnail: "thumbnail",
+    "Thumbnail prompt": "thumbnail",
+    "Export / subtitles": "video",
+    "Animated images": "video",
+    "YouTube description": "upload",
+    Posts: "upload",
+    Shorts: "shorts",
+    Reviews: "reviews",
+    Document: "document",
+};
+export function totals(rows) {
+    const priced = rows.filter((row) => row.high !== null && row.high > 0);
+    return {
+        low: rows.reduce((sum, row) => sum + (row.low ?? 0), 0),
+        high: rows.reduce((sum, row) => sum + (row.high ?? 0), 0),
+        unknown: rows.filter((row) => row.high === null).length,
+        onPlan: rows.some((row) => row.onPlan === true) && priced.every((row) => row.onPlan === true),
+        usesPlan: rows.some((row) => row.onPlan === true),
+    };
+}
+export async function quoteSave(deps, templateId, document) {
+    return quoteSample(deps, templateId, { document });
+}
+// What a sample costs: of a Save (`document`, the sections it outdates), of a new topic (every
+// section) or of the full script switched (the script and what follows it).
+export async function quoteSample(deps, templateId, ask) {
+    const template = templateById(deps.db, templateId);
+    if (template === undefined)
+        return {
+            ok: false,
+            reason: "not-found",
+            message: "This template no longer exists; it may have been deleted. Go to Library → Templates to see your templates.",
+        };
+    const document = ask.document ?? template.document;
+    const sample = sampleOf(deps.db, templateId);
+    const fullScript = ask.fullScript ?? sample?.fullScript ?? false;
+    const scoped = sampleDocument(document, {
+        topic: ask.topic ?? sample?.topic ?? defaultSampleTopic(deps.db),
+        fullScript,
+    });
+    const budget = budgetRoom(deps.db, deps.clock.now(), deps.timeZone);
+    const first = ask.sections === "all" || sample === undefined || !projectExists(deps.db, sample.projectId);
+    const sections = first
+        ? []
+        : Array.isArray(ask.sections)
+            ? ask.sections
+            : affectedSections(template.document, document).filter((section) => section !== "schedule");
+    const resolved = await resolveSampleRun(deps.review, scoped, fullScript);
+    if (!resolved.ok)
+        return {
+            ok: true,
+            value: {
+                version: template.version,
+                first,
+                sections,
+                rows: [],
+                low: 0,
+                high: 0,
+                unknown: 0,
+                onPlan: false,
+                usesPlan: false,
+                budget,
+                fits: false,
+                problem: resolved.problem,
+            },
+        };
+    const estimate = estimateRun(resolved.run.draft, resolved.run.rendered, resolved.words, deps.review.catalogue);
+    const wanted = new Set(sections);
+    const rows = first
+        ? estimate.rows
+        : estimate.rows.filter((row) => {
+            const section = sectionOfRow[row.stage];
+            // A row the studio can't place is counted: a quote may be high, never low.
+            return section === undefined || wanted.has(section);
+        });
+    const sum = totals(rows);
+    return {
+        ok: true,
+        value: {
+            version: template.version,
+            first,
+            sections,
+            rows,
+            ...sum,
+            budget,
+            fits: fitsBudget(budget, sum.high, sum.usesPlan),
+            problem: null,
+        },
+    };
+}

package/dist/slices/template-studio/ready.js

@@ -0,0 +1,104 @@
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { templateById } from "../project-templates/repo.js";
+import { gateOf } from "./gate.js";
+import { gatesOf, writeGate } from "./repo.js";
+import { getStudio, getStudioChecks } from "./service.js";
+// Mark ready: the newest version passes every free check and every section's sample is
+// current (or off, or provided at run time), so its schedules start running it. Only the
+// newest version is marked; one already ready is answered again without checking.
+export const markReadySchema = z
+    .object({ version: z.number().int().positive() })
+    .strict()
+    .readonly();
+const checkLabel = {
+    keywords: "Keywords",
+    providers: "Providers",
+    voice: "Voice",
+    "release-slots": "Release slots",
+    "monthly-cost": "Monthly cost",
+    answerers: "Checkpoints answered",
+};
+// The section states Mark ready accepts: nothing about them is left to look at.
+const settled = new Set(["current", "off", "provided"]);
+export function readyProblems(checks, sections) {
+    return [
+        ...checks
+            .filter((check) => !check.ok)
+            .map((check) => ({
+            label: checkLabel[check.id],
+            sentence: check.sentence,
+            ...(check.fix === undefined ? {} : { fix: check.fix }),
+        })),
+        ...sections
+            .filter((section) => !settled.has(section.state))
+            .map((section) => ({
+            label: section.label,
+            sentence: section.sentence,
+            section: section.id,
+        })),
+    ];
+}
+function sentenceOf(problem) {
+    const fix = problem.fix === undefined ? "" : ` ${problem.fix.label}.`;
+    return `${problem.label}: ${problem.sentence}${fix}`;
+}
+const missingTemplate = "This template no longer exists; it may have been deleted. Go to Library → Templates to see your templates.";
+function notNewest(version, head) {
+    return {
+        ok: false,
+        reason: "conflict",
+        message: `Version ${String(version)} is no longer the newest: the template is at version ${String(head)}. Look over version ${String(head)}'s samples, then press Mark ready.`,
+        problems: [],
+    };
+}
+export async function markReady(deps, templateId, raw) {
+    const parsed = markReadySchema.safeParse(raw);
+    if (!parsed.success)
+        return {
+            ok: false,
+            reason: "invalid-input",
+            message: "The studio sent a request Slopify couldn't read. Reload the page and try again.",
+            problems: [],
+        };
+    const { version } = parsed.data;
+    const template = templateById(deps.db, templateId);
+    if (template === undefined)
+        return { ok: false, reason: "not-found", message: missingTemplate, problems: [] };
+    if (version !== template.version)
+        return notNewest(version, template.version);
+    if (gateOf(gatesOf(deps.db, templateId), version) === "ready")
+        return { ok: true, value: { version, gate: "ready", replayed: true } };
+    const [studio, checks] = await Promise.all([
+        getStudio(deps, templateId),
+        getStudioChecks(deps, templateId),
+    ]);
+    if (!studio.ok || !checks.ok)
+        return { ok: false, reason: "not-found", message: missingTemplate, problems: [] };
+    // Read while the providers were looked up: a Save meanwhile made a newer version.
+    if (studio.value.template.version !== version || checks.value.version !== version)
+        return notNewest(version, Math.max(studio.value.template.version, checks.value.version));
+    const problems = readyProblems(checks.value.checks, studio.value.sections);
+    if (problems.length > 0)
+        return {
+            ok: false,
+            reason: "not-ready",
+            message: `Version ${String(version)} can't be marked ready yet. ${problems.map(sentenceOf).join(" ")}`,
+            problems,
+        };
+    return transact(deps.db, () => {
+        const head = templateById(deps.db, templateId);
+        if (head === undefined)
+            return { ok: false, reason: "not-found", message: missingTemplate, problems: [] };
+        if (head.version !== version)
+            return notNewest(version, head.version);
+        writeGate(deps.db, templateId, {
+            version,
+            state: "ready",
+            carriedFrom: null,
+            checksJson: JSON.stringify(checks.value.checks),
+            markedAt: deps.clock.now().toISOString(),
+        });
+        return { ok: true, value: { version, gate: "ready", replayed: false } };
+    });
+}