@gentbajko/slopify 0.8.3 → 1.0.0

package/dist/edge/http/app.js

@@ -4,19 +4,28 @@ import { Hono } from "hono";
 import { streamSSE } from "hono/streaming";
 import { actionRoutes } from "./actions.js";
 import { audioPreviewRoutes } from "./audio-preview.js";
+import { checkpointRoutes } from "./checkpoints.js";
+import { diagnosticsRoutes } from "./diagnostics.js";
+import { draftRoutes } from "./drafts.js";
 import { entryRoutes } from "./entries.js";
 import { fileRoutes } from "./files.js";
 import { fontsRoutes } from "./fonts.js";
 import { openFolderRoutes } from "./open-folder.js";
 import { planningRoutes } from "./planning.js";
 import { problem, problemFromError, titleOf } from "./problem.js";
+import { projectTemplateRoutes } from "./project-templates.js";
 import { projectRoutes } from "./projects.js";
 import { promptRoutes } from "./prompts.js";
 import { providerRoutes } from "./providers.js";
+import { revisionFileRoutes, revisionFolderRoutes } from "./revision-files.js";
+import { revisionRoutes } from "./revisions.js";
+import { scheduleRoutes } from "./schedules.js";
 import { settingsRoutes } from "./settings.js";
 import { stagingRoutes } from "./staging.js";
+import { storageRoutes } from "./storage.js";
 import { subtitleRoutes } from "./subtitles.js";
 import { telemetryRoutes } from "./telemetry.js";
+import { tutorialRoutes } from "./tutorial.js";
 import { updateRoutes } from "./update.js";
 import { usageRoutes } from "./usage.js";
 const notBuilt = "The Slopify UI is not built yet. The API is running: try /api/health.\n" +
@@ -29,8 +38,16 @@ function apiRoutes(deps, startedAt) {
         uptimeMs: deps.clock.now().getTime() - startedAt,
     }))
         .route("/staging", stagingRoutes(deps))
+        .route("/storage", storageRoutes(deps))
+        .route("/drafts", draftRoutes(deps.drafts))
+        .route("/diagnostics", diagnosticsRoutes(deps))
+        .route("/project-templates", projectTemplateRoutes(deps.drafts))
+        .route("/schedules", scheduleRoutes(deps.schedules))
         .route("/projects", planningRoutes(deps))
         .route("/projects", projectRoutes(deps))
+        .route("/projects", checkpointRoutes(deps))
+        .route("/projects", revisionRoutes(deps))
+        .route("/projects", revisionFolderRoutes(deps))
         .route("/projects", openFolderRoutes(deps))
         .route("/projects", audioPreviewRoutes(deps))
         .route("/update", updateRoutes(deps))
@@ -44,6 +61,7 @@ function apiRoutes(deps, startedAt) {
         .route("/telemetry", telemetryRoutes(deps))
         .route("/usage", usageRoutes(deps))
         .route("/settings", settingsRoutes(deps))
+        .route("/tutorial", tutorialRoutes(deps))
         .route("/providers", providerRoutes(deps)));
 }
 export function createApp(deps) {
@@ -56,22 +74,36 @@ export function createApp(deps) {
         await next();
     })
         .use("/api/*", async (c, next) => {
-        if (deps.updater === undefined ||
-            ["GET", "HEAD", "OPTIONS"].includes(c.req.method) ||
-            ["/api/update", "/api/update/", "/api/update/activate", "/api/update/activate/"].includes(c.req.path))
+        if (["GET", "HEAD", "OPTIONS"].includes(c.req.method))
             return next();
-        const release = deps.updater.beginMutation();
-        if (release === undefined)
+        const releaseRequest = deps.mutations?.begin();
+        if (deps.mutations !== undefined && releaseRequest === undefined)
+            return problem(c, {
+                status: 503,
+                title: titleOf(503),
+                detail: "Slopify is shutting down. Wait for it to restart before making changes.",
+            });
+        const updateRoute = [
+            "/api/update",
+            "/api/update/",
+            "/api/update/activate",
+            "/api/update/activate/",
+        ].includes(c.req.path);
+        const releaseUpdate = deps.updater === undefined || updateRoute ? undefined : deps.updater.beginMutation();
+        if (deps.updater !== undefined && !updateRoute && releaseUpdate === undefined) {
+            releaseRequest?.();
             return problem(c, {
                 status: 409,
                 title: titleOf(409),
                 detail: "Slopify is updating. Wait for it to restart before making changes.",
             });
+        }
         try {
             await next();
         }
         finally {
-            release();
+            releaseUpdate?.();
+            releaseRequest?.();
         }
     })
         .onError((error, c) => problemFromError(c, error, deps))
@@ -81,6 +113,7 @@ export function createApp(deps) {
         .get("/api/events/projects/:id", (c) => streamSSE(c, (stream) => deps.hub.subscribe(c.req.param("id"), stream, c.req.raw.signal)))
         // Files are served by URL, not through the API.
         .route("/", fileRoutes(deps))
+        .route("/", revisionFileRoutes(deps))
         // The API answers for its whole prefix, so an unknown endpoint is a problem+json 404
         // rather than the SPA's index.html with a 200.
         .all("/api/*", missing);

package/dist/edge/http/audio-preview.js

@@ -1,7 +1,9 @@
 import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
 import { z } from "zod";
+import { currentRevisionId } from "../../slices/revisions/repo.js";
 import { projectTitle } from "../../slices/storage/repo.js";
+import { currentWorkOrigin } from "../events/visibility.js";
 import { onInvalid, problem, titleOf } from "./problem.js";
 const projectParam = z.object({
     projectId: z
@@ -18,12 +20,18 @@ export function audioPreviewRoutes(deps) {
         if (projectTitle(deps.db, projectId) === undefined)
             return missing(c);
         c.header("Cache-Control", "no-store");
-        return c.json({ previews: deps.audioPreviews?.list(projectId) ?? [] });
+        return c.json({
+            revisionId: currentRevisionId(deps.db, projectId) ?? null,
+            previews: (deps.audioPreviews?.list(projectId) ?? []).filter((preview) => currentWorkOrigin(deps.db, projectId, preview)),
+        });
     })
         .get("/:projectId/audio-preview/:previewId", zValidator("param", previewParam, onInvalid), (c) => {
         const { projectId, previewId } = c.req.valid("param");
         if (projectTitle(deps.db, projectId) === undefined)
             return missing(c);
+        const preview = deps.audioPreviews?.list(projectId).find((item) => item.id === previewId);
+        if (preview === undefined || !currentWorkOrigin(deps.db, projectId, preview))
+            return missing(c);
         const stream = deps.audioPreviews?.stream(projectId, previewId, c.req.raw.signal);
         if (stream === undefined)
             return missing(c);

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;