@gentbajko/slopify 0.8.4 → 1.0.0

package/dist/edge/http/checkpoints.js

@@ -0,0 +1,95 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { z } from "zod";
+import { changeCheckpoints, checkpointChangeSchema, readCheckpointStatus, replayCheckpointApproval, validateCheckpointApproval, } from "../../slices/checkpoints/change.js";
+import { checkpointApprovalSchema, checkpointRowSchema } from "../../slices/checkpoints/schema.js";
+import { withProjectControl } from "../../slices/control/lock.js";
+import { onInvalid, problem, titleOf } from "./problem.js";
+const id = z
+    .string()
+    .min(1)
+    .max(64)
+    .regex(/^[0-9A-Za-z_-]+$/);
+const projectParam = z.object({ id });
+const approvalParam = projectParam.extend({ checkpointId: id });
+const approvalBody = checkpointApprovalSchema
+    .unwrap()
+    .omit({ projectId: true, checkpointId: true, approvedAt: true });
+function refused(c, reason) {
+    const status = reason === "not-found" ? 404 : reason === "invalid-input" ? 400 : 409;
+    return problem(c, {
+        status,
+        title: titleOf(status),
+        detail: "Reload the current checkpoint status before approving or changing this gate.",
+        extensions: { reason },
+    });
+}
+export function checkpointRoutes(deps) {
+    return buildCheckpointRoutes(deps);
+}
+function buildCheckpointRoutes(deps) {
+    const notify = (projectId, revisionId, wake) => {
+        try {
+            deps.hub.emit(projectId, { type: "project.updated", projectId, revisionId });
+        }
+        catch (error) {
+            deps.log.write("error", "checkpoint.notify", {
+                projectId,
+                detail: error instanceof Error ? error.message : String(error),
+            });
+        }
+        if (wake) {
+            try {
+                deps.runner.tick(projectId);
+            }
+            catch (error) {
+                deps.log.write("error", "checkpoint.wake", {
+                    projectId,
+                    detail: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+    };
+    return new Hono()
+        .get("/:id/checkpoints", zValidator("param", projectParam, onInvalid), (c) => {
+        const result = readCheckpointStatus(deps, c.req.valid("param").id);
+        return result.ok ? c.json(result.value) : refused(c, result.reason);
+    })
+        .post("/:id/checkpoints/:checkpointId/approve", zValidator("param", approvalParam, onInvalid), zValidator("json", approvalBody, onInvalid), async (c) => {
+        const { id: projectId, checkpointId } = c.req.valid("param");
+        const identity = c.req.valid("json");
+        return withProjectControl(deps.db, projectId, () => {
+            const replay = replayCheckpointApproval(deps, { ...identity, projectId, checkpointId });
+            if (replay)
+                return replay.ok
+                    ? c.json({ checkpoint: replay.value, replayed: true })
+                    : refused(c, replay.reason);
+            const valid = validateCheckpointApproval(deps, { ...identity, projectId, checkpointId });
+            if (!valid.ok)
+                return refused(c, valid.reason);
+            const authority = deps.runner.checkpoints;
+            if (!authority)
+                return refused(c, "conflict");
+            const result = authority.release(projectId, checkpointId, identity);
+            if (!result.ok && (result.reason !== "duplicate" || result.value === undefined))
+                return refused(c, result.reason);
+            const checkpoint = checkpointRowSchema.parse(result.value);
+            if (result.ok)
+                notify(projectId, identity.revisionId, false);
+            return c.json({ checkpoint, replayed: !result.ok });
+        });
+    })
+        .patch("/:id/checkpoints", zValidator("param", projectParam, onInvalid), zValidator("json", checkpointChangeSchema, onInvalid), async (c) => {
+        const projectId = c.req.valid("param").id;
+        const body = c.req.valid("json");
+        return withProjectControl(deps.db, projectId, () => {
+            const result = changeCheckpoints(deps, { ...body, projectId });
+            if (!result.ok)
+                return refused(c, result.reason);
+            if (result.value.changed)
+                notify(projectId, body.revisionId, result.value.released);
+            const status = readCheckpointStatus(deps, projectId);
+            return status.ok ? c.json(status.value) : refused(c, status.reason);
+        });
+    });
+}

package/dist/edge/http/diagnostics.js

@@ -0,0 +1,31 @@
+import { Hono } from "hono";
+import { providerStatuses } from "../../slices/settings/readiness.js";
+/**
+ * A deliberately boring, secret-free support bundle. It is JSON rather than a
+ * filesystem archive so it can be copied from a remote/local browser and is
+ * still useful when a project output is unavailable.
+ */
+export function diagnosticsRoutes(deps) {
+    return new Hono().get("/", async (c) => {
+        const providers = await providerStatuses({ db: deps.db, probe: deps.probe });
+        const projectCount = deps.db.prepare("SELECT count(*) AS count FROM projects").get();
+        const schema = deps.db.prepare("SELECT max(version) AS version FROM schema_migrations").get();
+        c.header("Cache-Control", "no-store");
+        c.header("Content-Disposition", 'attachment; filename="slopify-diagnostics.json"');
+        return c.json({
+            appVersion: deps.version,
+            schemaVersion: typeof schema?.version === "number" ? schema.version : null,
+            platform: process.platform,
+            nodeMajor: Number.parseInt(process.versions.node.split(".")[0] ?? "0", 10),
+            providers: providers.map((provider) => ({
+                id: provider.id,
+                family: provider.family,
+                displayName: provider.displayName,
+                readiness: provider.readiness,
+                ...(provider.cliPath === undefined ? {} : { cliPath: provider.cliPath }),
+            })),
+            projects: { total: typeof projectCount?.count === "number" ? projectCount.count : 0 },
+            catalogue: deps.catalogue?.status() ?? { warning: "Catalogue unavailable." },
+        });
+    });
+}

package/dist/edge/http/draft-files.js

@@ -0,0 +1,69 @@
+import { createReadStream } from "node:fs";
+import { extname } from "node:path";
+import { Readable } from "node:stream";
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { z } from "zod";
+import { draftAttachmentSchema } from "../../slices/play-drafts/schema.js";
+import { readDraft } from "../../slices/play-drafts/service.js";
+import { uploadDraftAttachment } from "../../slices/play-drafts/uploads.js";
+import { stagingPath } from "../../slices/storage/layout.js";
+import { stagedFileById } from "../../slices/storage/repo.js";
+import { draftProblem } from "./draft-problem.js";
+import { readMultipart } from "./multipart.js";
+import { onInvalid, problem, titleOf } from "./problem.js";
+const params = z.object({ id: z.uuid(), attachmentId: z.uuid() });
+const imageTypes = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".webp": "image/webp",
+    ".gif": "image/gif",
+    ".avif": "image/avif",
+};
+// Inference preserves the route contracts consumed by the SPA client.
+export function draftFileRoutes(service) {
+    return new Hono()
+        .put("/:id/attachments/:attachmentId/file", zValidator("param", params, onInvalid), async (c) => {
+        const { id, attachmentId } = c.req.valid("param");
+        const deps = service();
+        const result = await readMultipart(c.req.raw, (content) => uploadDraftAttachment(deps, { draftId: id, attachmentId, content }));
+        if (result === undefined)
+            return problem(c, {
+                status: 400,
+                title: titleOf(400),
+                detail: "The request carried no file part.",
+            });
+        return result.ok
+            ? c.json(draftAttachmentSchema.parse(result.value))
+            : draftProblem(c, result);
+    })
+        .get("/:id/attachments/:attachmentId/file", zValidator("param", params, onInvalid), (c) => {
+        const deps = service();
+        const { id, attachmentId } = c.req.valid("param");
+        const view = readDraft(deps, id);
+        if (!view.ok)
+            return draftProblem(c, view);
+        const attachment = view.value.attachments.find((a) => a.id === attachmentId);
+        const staged = attachment?.stagedFileId === null || attachment?.stagedFileId === undefined
+            ? undefined
+            : stagedFileById(deps.db, attachment.stagedFileId);
+        const contentType = attachment === undefined ? undefined : imageTypes[extname(attachment.name).toLowerCase()];
+        if (attachment?.state !== "ready" ||
+            attachment.kind === "audio" ||
+            staged?.state !== "staged" ||
+            staged.stageKind !== attachment.kind ||
+            contentType === undefined)
+            return problem(c, {
+                status: 404,
+                title: titleOf(404),
+                detail: "This draft attachment has no preview bytes.",
+            });
+        return c.body(Readable.toWeb(createReadStream(stagingPath(deps.paths, staged.path))), 200, {
+            "content-type": contentType,
+            "content-length": String(staged.bytes),
+            "x-content-type-options": "nosniff",
+            "cache-control": "no-store",
+        });
+    });
+}

package/dist/edge/http/draft-problem.js

@@ -0,0 +1,15 @@
+import { problem, titleOf } from "./problem.js";
+export function draftProblem(c, result) {
+    const status = result.reason === "not-found"
+        ? 404
+        : ["invalid-edit", "readiness"].includes(result.reason)
+            ? 400
+            : 409;
+    const { ok: _ok, ...extensions } = result;
+    return problem(c, {
+        status,
+        title: titleOf(status),
+        detail: "Review the saved draft and the listed fields.",
+        extensions,
+    });
+}

package/dist/edge/http/drafts.js

@@ -0,0 +1,95 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { HTTPException } from "hono/http-exception";
+import { z } from "zod";
+import { draftRow } from "../../slices/play-drafts/repo.js";
+import { reviewDraft } from "../../slices/play-drafts/review.js";
+import { createDraftInputSchema, discardDraftInputSchema, draftViewSchema, playReviewSchema, playStartResultSchema, saveDraftInputSchema, } from "../../slices/play-drafts/schema.js";
+import { createDraft, discardDraft, forkDraft, listDrafts, readDraft, saveDraft, } from "../../slices/play-drafts/service.js";
+import { startPlayDraft } from "../../slices/play-drafts/start.js";
+import { draftFileRoutes } from "./draft-files.js";
+import { draftProblem } from "./draft-problem.js";
+import { onInvalid } from "./problem.js";
+const idParam = z.object({ id: z.uuid() });
+const versionBody = discardDraftInputSchema.unwrap().omit({ id: true });
+const saveBody = saveDraftInputSchema.unwrap().omit({ id: true });
+const startBody = versionBody.extend({ reviewId: z.uuid() }).strict();
+const summariesSchema = z
+    .object({
+    drafts: z.array(z
+        .object({
+        id: z.uuid(),
+        title: z.string(),
+        version: z.number().int().positive(),
+        updatedAt: z.string(),
+        readable: z.boolean(),
+    })
+        .strict()),
+})
+    .strict();
+// Inference preserves the route contracts consumed by the SPA client.
+export function draftRoutes(deps) {
+    const service = () => {
+        if (deps === undefined)
+            throw new HTTPException(404);
+        return deps;
+    };
+    return new Hono()
+        .get("/", (c) => c.json(summariesSchema.parse({ drafts: listDrafts(service()) })))
+        .post("/", zValidator("json", createDraftInputSchema, onInvalid), (c) => {
+        const input = c.req.valid("json");
+        const existing = draftRow(service().db, input.id) !== undefined;
+        const result = createDraft(service(), input);
+        return result.ok
+            ? c.json(draftViewSchema.parse(result.value), existing ? 200 : 201)
+            : draftProblem(c, result);
+    })
+        .get("/:id", zValidator("param", idParam, onInvalid), (c) => {
+        const result = readDraft(service(), c.req.valid("param").id);
+        return result.ok ? c.json(draftViewSchema.parse(result.value)) : draftProblem(c, result);
+    })
+        .put("/:id", zValidator("param", idParam, onInvalid), zValidator("json", saveBody, onInvalid), (c) => {
+        const result = saveDraft(service(), {
+            ...c.req.valid("json"),
+            id: c.req.valid("param").id,
+        });
+        return result.ok ? c.json(draftViewSchema.parse(result.value)) : draftProblem(c, result);
+    })
+        .post("/:id/fork", zValidator("param", idParam, onInvalid), zValidator("json", createDraftInputSchema, onInvalid), (c) => {
+        const input = { ...c.req.valid("json"), sourceId: c.req.valid("param").id };
+        const existing = draftRow(service().db, input.id) !== undefined;
+        const result = forkDraft(service(), input);
+        return result.ok
+            ? c.json(draftViewSchema.parse(result.value), existing ? 200 : 201)
+            : draftProblem(c, result);
+    })
+        .delete("/:id", zValidator("param", idParam, onInvalid), zValidator("json", versionBody, onInvalid), (c) => {
+        const result = discardDraft(service(), {
+            ...c.req.valid("json"),
+            id: c.req.valid("param").id,
+        });
+        return result.ok
+            ? c.json(z
+                .object({ discarded: z.literal(true) })
+                .strict()
+                .parse(result.value))
+            : draftProblem(c, result);
+    })
+        .post("/:id/review", zValidator("param", idParam, onInvalid), zValidator("json", versionBody, onInvalid), async (c) => {
+        const result = await reviewDraft(service(), {
+            ...c.req.valid("json"),
+            id: c.req.valid("param").id,
+        });
+        return result.ok ? c.json(playReviewSchema.parse(result.value)) : draftProblem(c, result);
+    })
+        .post("/:id/start", zValidator("param", idParam, onInvalid), zValidator("json", startBody, onInvalid), async (c) => {
+        const result = await startPlayDraft(service(), {
+            ...c.req.valid("json"),
+            draftId: c.req.valid("param").id,
+        });
+        return result.ok
+            ? c.json(playStartResultSchema.parse(result.value), result.value.replayed ? 200 : 201)
+            : draftProblem(c, result);
+    })
+        .route("/", draftFileRoutes(service));
+}

package/dist/edge/http/multipart.js

@@ -0,0 +1,86 @@
+import { Readable } from "node:stream";
+import { Busboy } from "@fastify/busboy";
+import { HTTPException } from "hono/http-exception";
+// The consumer cannot commit an upload until the entire multipart envelope is valid.
+export async function readMultipart(request, consume) {
+    const contentType = request.headers.get("content-type");
+    if (contentType === null || !contentType.startsWith("multipart/form-data"))
+        throw new HTTPException(415, {
+            message: "An upload is sent as multipart/form-data with the file in one part.",
+        });
+    if (request.body === null)
+        throw new HTTPException(400, { message: "The request carried no body." });
+    let parser;
+    try {
+        parser = new Busboy({
+            headers: { "content-type": contentType },
+            limits: { files: 1, fields: 8 },
+            preservePath: true,
+        });
+    }
+    catch (error) {
+        throw new HTTPException(400, {
+            message: "The multipart boundary is missing or invalid.",
+            cause: error,
+        });
+    }
+    const source = Readable.fromWeb(request.body);
+    let file;
+    let operation;
+    let complete = () => undefined;
+    let rejectEnvelope = () => undefined;
+    const completed = new Promise((resolve, reject) => {
+        complete = resolve;
+        rejectEnvelope = reject;
+    });
+    // Observe immediately: the consumer may reject before it reaches the envelope check.
+    const envelope = completed.then(() => ({ ok: true }), (error) => ({ ok: false, error }));
+    const fail = (error) => {
+        rejectEnvelope(error);
+        file?.destroy(error);
+        source.destroy();
+        parser.destroy();
+    };
+    source.on("error", fail);
+    parser.on("error", (error) => fail(new HTTPException(400, {
+        message: "The multipart request is malformed or incomplete.",
+        cause: error,
+    })));
+    parser.on("finish", () => complete());
+    parser.on("file", (_field, stream, filename) => {
+        file = stream;
+        stream.on("error", fail);
+        async function* content() {
+            for await (const chunk of stream)
+                yield chunk;
+            const result = await envelope;
+            if (!result.ok)
+                throw result.error;
+        }
+        operation = Promise.resolve().then(() => consume(content(), typeof filename === "string" ? filename : ""));
+        void operation.then(() => stream.resume(), (error) => {
+            fail(error instanceof Error ? error : new Error("Upload failed", { cause: error }));
+        });
+    });
+    const abort = () => fail(new Error("Upload request was aborted."));
+    request.signal.addEventListener("abort", abort, { once: true });
+    if (request.signal.aborted)
+        abort();
+    else
+        source.pipe(parser);
+    try {
+        const parsed = await envelope;
+        if (operation !== undefined) {
+            const result = await operation;
+            if (!parsed.ok)
+                throw parsed.error;
+            return result;
+        }
+        if (!parsed.ok)
+            throw parsed.error;
+        return undefined;
+    }
+    finally {
+        request.signal.removeEventListener("abort", abort);
+    }
+}

package/dist/edge/http/mutations.js

@@ -0,0 +1,49 @@
+/** Tracks admitted HTTP writes so shutdown can stop admission, then drain them. */
+export function createMutationLifecycle() {
+    let accepting = true;
+    let active = 0;
+    let drained;
+    let resolveDrain;
+    return {
+        begin: () => {
+            if (!accepting)
+                return undefined;
+            active++;
+            let released = false;
+            return () => {
+                if (released)
+                    return;
+                released = true;
+                active--;
+                if (!accepting && active === 0)
+                    resolveDrain?.();
+            };
+        },
+        stop: () => {
+            accepting = false;
+            if (active === 0)
+                return Promise.resolve();
+            drained ??= new Promise((resolve) => {
+                resolveDrain = resolve;
+            });
+            return drained;
+        },
+    };
+}
+/** Give admitted requests a grace period, then close their sockets and wait for their
+ * middleware `finally` blocks to release the database lease. */
+export async function drainMutationsWithDeadline(drained, terminateConnections, timeoutMs) {
+    let timer;
+    const outcome = await Promise.race([
+        drained.then(() => "drained"),
+        new Promise((resolve) => {
+            timer = setTimeout(() => resolve("expired"), timeoutMs);
+        }),
+    ]);
+    if (timer !== undefined)
+        clearTimeout(timer);
+    if (outcome === "drained")
+        return;
+    terminateConnections();
+    await drained;
+}

package/dist/edge/http/planning.js

@@ -48,7 +48,12 @@ export function planningRoutes(deps) {
                 ...f,
                 message: `${drafts.length > 1 ? `Video ${index + 1}: ` : ""}${f.message}`,
             }));
-            return { draft: accepted, rendered: renderPicked(picked, accepted.values), fields };
+            return {
+                draft: accepted,
+                rendered: renderPicked(picked, accepted.values),
+                templates: Object.fromEntries(picked.bodies.map(({ key, body }) => [key, body])),
+                fields,
+            };
         });
     };
     return new Hono()
@@ -70,6 +75,12 @@ export function planningRoutes(deps) {
     })
         .post("/batch", zValidator("json", batchBody, onInvalid), async (c) => {
         const input = c.req.valid("json");
+        if (input.draft.checkpoints?.length)
+            return problem(c, {
+                status: 409,
+                title: titleOf(409),
+                detail: "Queue checkpoint-enabled projects through Play Review.",
+            });
         if (batchExists(deps.db, input.requestId))
             return c.json({ queue: queueEntries(deps.db, input.requestId) });
         const subtitles = input.draft.subtitles;

package/dist/edge/http/project-templates.js

@@ -0,0 +1,74 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { HTTPException } from "hono/http-exception";
+import { z } from "zod";
+import { createTemplateFromProject, templateFromProjectSchema, } from "../../slices/project-templates/from-project.js";
+import { templateCreateSchema, templateDeleteSchema, templateInstantiateSchema, templateUpdateSchema, } from "../../slices/project-templates/schema.js";
+import { createTemplate, deleteTemplate, instantiateTemplate, listTemplates, readTemplate, updateTemplate, } from "../../slices/project-templates/service.js";
+import { onInvalid, problem, titleOf } from "./problem.js";
+const param = z.object({ id: z.uuid() });
+function refused(c, result) {
+    const status = result.reason === "not-found"
+        ? 404
+        : ["conflict", "referenced-by-schedule"].includes(result.reason)
+            ? 409
+            : 400;
+    return problem(c, {
+        status,
+        title: titleOf(status),
+        detail: result.reason === "referenced-by-schedule"
+            ? "Cancel and delete the schedules using this template before deleting it. Their run history will be retained."
+            : result.reason === "missing-prompt"
+                ? "A selected prompt or entry is unavailable. Choose another before saving the template."
+                : "Reload the template and check its setup before trying again.",
+        extensions: { reason: result.reason },
+    });
+}
+export function projectTemplateRoutes(deps) {
+    return routes(deps);
+}
+function routes(deps) {
+    const service = () => {
+        if (!deps)
+            throw new HTTPException(404);
+        return deps;
+    };
+    return new Hono()
+        .get("/", (c) => c.json({ templates: listTemplates(service()) }))
+        .post("/from-project/:projectId", zValidator("param", templateFromProjectSchema.unwrap().pick({ projectId: true }), onInvalid), zValidator("json", templateFromProjectSchema.unwrap().omit({ projectId: true }), onInvalid), (c) => {
+        const result = createTemplateFromProject(service(), {
+            ...c.req.valid("json"),
+            projectId: c.req.valid("param").projectId,
+        });
+        return result.ok ? c.json(result.value, 201) : refused(c, result);
+    })
+        .post("/", zValidator("json", templateCreateSchema, onInvalid), (c) => {
+        const result = createTemplate(service(), c.req.valid("json"));
+        return result.ok ? c.json(result.value, 201) : refused(c, result);
+    })
+        .get("/:id", zValidator("param", param, onInvalid), zValidator("query", z.object({ version: z.coerce.number().int().positive().optional() }), onInvalid), (c) => {
+        const result = readTemplate(service(), c.req.valid("param").id, c.req.valid("query").version);
+        return result.ok ? c.json(result.value) : refused(c, result);
+    })
+        .put("/:id", zValidator("param", param, onInvalid), zValidator("json", templateUpdateSchema.unwrap().omit({ id: true }), onInvalid), (c) => {
+        const result = updateTemplate(service(), {
+            ...c.req.valid("json"),
+            id: c.req.valid("param").id,
+        });
+        return result.ok ? c.json(result.value) : refused(c, result);
+    })
+        .delete("/:id", zValidator("param", param, onInvalid), zValidator("json", templateDeleteSchema.unwrap().omit({ id: true }), onInvalid), (c) => {
+        const result = deleteTemplate(service(), {
+            ...c.req.valid("json"),
+            id: c.req.valid("param").id,
+        });
+        return result.ok ? c.json(result.value) : refused(c, result);
+    })
+        .post("/:id/instantiate", zValidator("param", param, onInvalid), zValidator("json", templateInstantiateSchema.unwrap().omit({ templateId: true }), onInvalid), (c) => {
+        const result = instantiateTemplate(service(), {
+            ...c.req.valid("json"),
+            templateId: c.req.valid("param").id,
+        });
+        return result.ok ? c.json(result.value, 201) : refused(c, result);
+    });
+}

package/dist/edge/http/projects.js

@@ -9,6 +9,8 @@ import { startRun } from "../../slices/admission/start.js";
 import { withProjectControl } from "../../slices/control/lock.js";
 import { resolveFont } from "../../slices/fonts/index.js";
 import { pickTemplates, renderPicked } from "../../slices/library/slots.js";
+import { adoptBaseline } from "../../slices/revisions/adopt.js";
+import { currentRevisionId } from "../../slices/revisions/repo.js";
 import { deleteProject } from "../../slices/storage/delete-project.js";
 import { outputsOf, stagedFiles } from "../../slices/storage/repo.js";
 import { record } from "../../slices/telemetry/record.js";
@@ -24,6 +26,7 @@ const idParam = z.object({
 // generated from; see stagingRoutes.
 export function projectRoutes(deps) {
     const storage = {
+        catalogue: deps.catalogue,
         db: deps.db,
         paths: deps.paths,
         ids: deps.ids,
@@ -40,13 +43,24 @@ export function projectRoutes(deps) {
         log: deps.log,
         appVersion: deps.version,
     };
-    const storageForDelete = { db: deps.db, paths: deps.paths, log: deps.log };
+    const storageForDelete = {
+        db: deps.db,
+        paths: deps.paths,
+        log: deps.log,
+        hasInflight: deps.runner.hasInflight,
+    };
     const summarise = (project) => ({
         ...project,
         status: derive(stagesOf(deps.db, project.id), project.paused),
     });
     return (new Hono()
         .post("/", zValidator("json", runDraftSchema, onInvalid), async (c) => {
+        if (c.req.valid("json").checkpoints?.length)
+            return problem(c, {
+                status: 409,
+                title: titleOf(409),
+                detail: "Start checkpoint-enabled projects through Play Review.",
+            });
         const requestedSubtitles = c.req.valid("json").subtitles;
         if (requestedSubtitles !== undefined && requestedSubtitles.mode !== "off") {
             try {
@@ -89,7 +103,7 @@ export function projectRoutes(deps) {
         }
         // Rendered from the values admit() has trimmed, so the stored text carries no
         // padding the user did not intend.
-        const { project } = startRun(storage, admitted.draft, renderPicked(picked, admitted.draft.values));
+        const { project } = startRun(storage, admitted.draft, renderPicked(picked, admitted.draft.values), false, Object.fromEntries(picked.bodies.map(({ key, body }) => [key, body])));
         // One event per project created. record() swallows its own
         // failures, so a broken telemetry write cannot cost the user the run.
         record(telemetry, "project.created", {});
@@ -124,7 +138,10 @@ export function projectRoutes(deps) {
                 detail: "No project has that id.",
             });
         }
+        if (deps.catalogue !== undefined)
+            adoptBaseline(deps, project.id);
         return c.json({
+            revisionId: currentRevisionId(deps.db, project.id) ?? null,
             project: summarise(project),
             stages: stagesOf(deps.db, project.id),
             outputs: outputsOf(deps.db, project.id),