@gentbajko/slopify 3.2.8 → 3.3.0

package/dist/edge/http/projects.js

@@ -13,6 +13,7 @@ import { adoptBaseline } from "../../slices/revisions/adopt.js";
 import { currentRevisionId } from "../../slices/revisions/repo.js";
 import { limitWaitsByProject, listingWait } from "../../slices/run-cost/panel.js";
 import { outputsOf } from "../../slices/storage/repo.js";
+import { longVideoStats } from "../../slices/studio/stats.js";
 import { trashProject } from "../../slices/trash/service.js";
 import { setAsideProjects, uploadedProjects } from "../../slices/uploads/repo.js";
 import { onInvalid, problem, titleOf } from "./problem.js";
@@ -60,6 +61,7 @@ export function projectRoutes(deps) {
         const channels = projectChannels(deps.db);
         const uploads = uploadedProjects(deps.db);
         const aside = setAsideProjects(deps.db);
+        const numbers = longVideoStats(deps.db);
         const waits = limitWaitsByProject(deps.db);
         const projects = listProjects(deps.db).map((project) => {
             const stages = standings.get(project.id) ?? [];
@@ -71,6 +73,12 @@ export function projectRoutes(deps) {
                 channelId: channels.get(project.id) ?? defaultChannelId,
                 uploadedAt: uploads.get(project.id) ?? null,
                 ...(aside.has(project.id) ? { setAside: true } : {}),
+                ...(numbers.get(project.id)?.views == null
+                    ? {}
+                    : { views: numbers.get(project.id)?.views ?? 0 }),
+                ...(numbers.get(project.id)?.ctr == null
+                    ? {}
+                    : { ctr: numbers.get(project.id)?.ctr ?? 0 }),
                 ...(waiting === undefined ? {} : { limitWaits: waiting.map(listingWait) }),
             };
         });

package/dist/edge/http/studio.js

@@ -4,14 +4,21 @@ import { Readable } from "node:stream";
 import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
 import { z } from "zod";
-import { projectById } from "../../slices/admission/repo.js";
+import { derive } from "../../kernel/runner/graph.js";
+import { listProjects, projectById, stagesOf } from "../../slices/admission/repo.js";
 import { channelById } from "../../slices/channels/repo.js";
+import { readSetting, writeSetting } from "../../slices/settings/repo.js";
 import { findDownload } from "../../slices/storage/downloads.js";
-import { studioPlaylistMax } from "../../slices/studio/model.js";
+import { backfillVideos } from "../../slices/studio/backfill.js";
+import { studioPlaylistMax, studioUploadUrl, } from "../../slices/studio/model.js";
 import { packItem, uploadPack } from "../../slices/studio/pack.js";
-import { enqueueFill, readFillQueue, removeFill, } from "../../slices/studio/queue.js";
-import { bearerToken, isExtensionOrigin, pairStudioExtension, readChannelPlaylists, readStudioPlaylists, resetStudioPairing, saveProjectPlaylists, saveRealFootage, saveStudioPlaylists, studioPairing, studioPlaylistsMax, studioPlaylistsProblem, studioRequestAllowed, } from "../../slices/studio/settings.js";
-import { forgetVideo, projectVideos, recordVideo, setAbState, videoIdOf, videoIdPattern, waitingAbTests, } from "../../slices/studio/videos.js";
+import { writeUploadPick } from "../../slices/studio/pick.js";
+import { assignedSlot, freeSlots, postingPlanSchema, readPlan, setSlot, unschedule, writePlan, } from "../../slices/studio/plan.js";
+import { enqueueFill, fillNow, readFillQueue, removeFill, } from "../../slices/studio/queue.js";
+import { autoCommentKey, bearerToken, isExtensionOrigin, pairStudioExtension, readChannelPlaylists, readStudioPlaylists, resetStudioPairing, saveProjectPlaylists, saveRealFootage, saveStudioPlaylists, studioPairing, studioPlaylistsMax, studioPlaylistsProblem, studioRequestAllowed, } from "../../slices/studio/settings.js";
+import { abResults, abVariantSchema, projectStats, saveAbResult, saveStats, } from "../../slices/studio/stats.js";
+import { confirmUpload, doneVideos, forgetVideo, projectVideos, recordVideo, setTaskState, videoIdOf, videoIdPattern, videoOf, waitingTasks, } from "../../slices/studio/videos.js";
+import { setAsideProjects, uploadedProjects } from "../../slices/uploads/repo.js";
 import { onInvalid, problem, titleOf } from "./problem.js";
 const id = z
     .string()
@@ -46,20 +53,43 @@ const projectPlaylistsBody = z.object({
     playlists: z.array(z.string().max(studioPlaylistMax)).max(studioPlaylistsMax).nullable(),
 });
 const realFootageBody = z.object({ realFootage: z.boolean() });
+const pickBody = z.object({
+    title: z.number().int().min(0).max(9),
+    thumbnail: z.number().int().min(0).max(9),
+});
 const shortField = z.number().int().min(1).max(99).nullable().optional();
 const extVideoBody = z.object({
     projectId: id,
     short: shortField,
     videoId: z.string().regex(videoIdPattern),
 });
-const abResultBody = z.object({
+const videoLinkBody = z.object({ short: shortField, link: z.string().max(500) });
+const slotBody = z.object({
+    slot: z.object({ row: z.string().min(1).max(20), longAt: z.string().max(40) }).nullable(),
+});
+const taskResultBody = z.object({
+    task: z.enum(["finish", "comment"]),
     projectId: id,
     short: shortField,
     ok: z.boolean(),
     message: z.string().max(2000),
 });
-const videoLinkBody = z.object({ short: shortField, link: z.string().max(500) });
-const abTestBody = z.object({ short: shortField, start: z.boolean() });
+const statsBody = z.object({
+    projectId: id,
+    short: shortField,
+    videoId: z.string().regex(videoIdPattern),
+    impressions: z.number().nonnegative().optional(),
+    ctr: z.number().min(0).max(100).optional(),
+    views: z.number().nonnegative().optional(),
+    averageViewSeconds: z.number().nonnegative().optional(),
+    watchHours: z.number().nonnegative().optional(),
+    abVariants: z.array(abVariantSchema).max(3).optional(),
+});
+const backfillBody = z.object({
+    videos: z
+        .array(z.object({ title: z.string().max(200), videoId: z.string().regex(videoIdPattern) }))
+        .max(200),
+});
 // The extension builds the app ships (`scripts/copy-extension.mjs`), by browser.
 const extensionFiles = {
     "chrome.zip": "slopify-studio-chrome.zip",
@@ -106,13 +136,18 @@ export function studioRoutes(deps) {
         title: "Unauthorized",
         detail: "The Slopify Studio extension isn't paired with this Slopify. Copy the pairing token from Slopify's Settings → YouTube Studio into the extension's options and press Pair.",
     });
-    const extAllowed = (c) => studioRequestAllowed(deps.db, bearerToken(c.req.header("authorization")), c.req.header("origin"));
-    // An upload has an A/B test to run when it has other titles or more than one thumbnail.
-    const abTestable = (projectId, short) => {
+    // A project ready to upload takes the plan's next free slot when its upload is prepared;
+    // one whose long video is on YouTube already doesn't.
+    const planned = (projectId) => {
+        if (videoOf(deps.db, projectId, null)?.uploadState === "done")
+            return;
         const result = uploadPack(deps, projectId);
-        const item = result.ok ? packItem(result.pack, short ?? undefined) : undefined;
-        return item !== undefined && (item.titles.length > 0 || item.thumbnails.length > 1);
+        if (!result.ok || result.pack.items[0]?.video == null)
+            return;
+        assignedSlot(deps.db, readPlan(deps.db), projectId, deps.clock.now());
     };
+    const slotChoices = () => freeSlots(deps.db, readPlan(deps.db), deps.clock.now(), 9);
+    const extAllowed = (c) => studioRequestAllowed(deps.db, bearerToken(c.req.header("authorization")), c.req.header("origin"));
     return (new Hono()
         .get("/settings", (c) => {
         // The token is read only by the Slopify page, never by another origin's.
@@ -123,7 +158,29 @@ export function studioRoutes(deps) {
             playlists: readStudioPlaylists(deps.db),
             channelPlaylists: readChannelPlaylists(deps.db),
             pairing: studioPairing(deps.db),
+            autoComment: readSetting(deps.db, autoCommentKey) === "on",
         });
+    })
+        // Post and pin each video's comment once it is public (opt-in: it posts in your name).
+        .put("/settings/auto-comment", zValidator("json", z.object({ on: z.boolean() }), onInvalid), (c) => {
+        const denied = samePage(c);
+        if (denied !== undefined)
+            return denied;
+        writeSetting(deps.db, autoCommentKey, c.req.valid("json").on ? "on" : "off");
+        return c.json({ autoComment: c.req.valid("json").on });
+    })
+        // The posting plan and the coming free slots.
+        .get("/plan", (c) => {
+        const plan = readPlan(deps.db);
+        return c.json({ plan, free: freeSlots(deps.db, plan, deps.clock.now(), 9) });
+    })
+        .put("/plan", zValidator("json", postingPlanSchema, onInvalid), (c) => {
+        const denied = samePage(c);
+        if (denied !== undefined)
+            return denied;
+        writePlan(deps.db, c.req.valid("json"));
+        const plan = readPlan(deps.db);
+        return c.json({ plan, free: freeSlots(deps.db, plan, deps.clock.now(), 9) });
     })
         .put("/settings/playlists", zValidator("json", playlistsBody, onInvalid), (c) => {
         const denied = samePage(c);
@@ -156,10 +213,36 @@ export function studioRoutes(deps) {
         return c.json({ pairing: resetStudioPairing(deps.db) });
     })
         .get("/packs/:projectId", zValidator("param", projectParam, onInvalid), (c) => {
-        const result = uploadPack(deps, c.req.valid("param").projectId);
+        const { projectId } = c.req.valid("param");
+        planned(projectId);
+        const result = uploadPack(deps, projectId);
         if (!result.ok)
             return unknownProject(c);
-        return c.json(result.pack);
+        return c.json({ ...result.pack, slotChoices: slotChoices() });
+    })
+        // Prepare upload's slot picker: another free slot of the plan, or none.
+        .put("/packs/:projectId/slot", zValidator("param", projectParam, onInvalid), zValidator("json", slotBody, onInvalid), (c) => {
+        const denied = samePage(c);
+        if (denied !== undefined)
+            return denied;
+        const { projectId } = c.req.valid("param");
+        const wanted = c.req.valid("json").slot;
+        if (wanted === null)
+            unschedule(deps.db, projectId, deps.clock.now());
+        else {
+            const free = slotChoices().some((one) => one.row === wanted.row && one.longAt === wanted.longAt);
+            if (!free)
+                return problem(c, {
+                    status: 409,
+                    title: titleOf(409),
+                    detail: "That slot is taken or past. Reload Prepare upload and choose one of the slots it lists.",
+                });
+            setSlot(deps.db, projectId, wanted, deps.clock.now());
+        }
+        const result = uploadPack(deps, projectId);
+        return result.ok
+            ? c.json({ ...result.pack, slotChoices: slotChoices() })
+            : unknownProject(c);
     })
         // Prepare upload's AI use tick: the project's uploaded clips are real footage.
         .put("/packs/:projectId/real-footage", zValidator("param", projectParam, onInvalid), zValidator("json", realFootageBody, onInvalid), (c) => {
@@ -172,6 +255,19 @@ export function studioRoutes(deps) {
         saveRealFootage(deps.db, projectId, c.req.valid("json").realFootage);
         const result = uploadPack(deps, projectId);
         return result.ok ? c.json(result.pack) : unknownProject(c);
+    })
+        // Prepare upload's pick: which title and thumbnail the upload carries; the A/B test tries
+        // the others once the video is public.
+        .put("/packs/:projectId/pick", zValidator("param", projectParam, onInvalid), zValidator("json", pickBody, onInvalid), (c) => {
+        const denied = samePage(c);
+        if (denied !== undefined)
+            return denied;
+        const { projectId } = c.req.valid("param");
+        if (!uploadPack(deps, projectId).ok)
+            return unknownProject(c);
+        writeUploadPick(deps.db, projectId, c.req.valid("json"));
+        const result = uploadPack(deps, projectId);
+        return result.ok ? c.json(result.pack) : unknownProject(c);
     })
         // Prepare upload's playlist ticks: which of the channel's playlists this project goes into.
         .put("/packs/:projectId/playlists", zValidator("param", projectParam, onInvalid), zValidator("json", projectPlaylistsBody, onInvalid), (c) => {
@@ -204,6 +300,9 @@ export function studioRoutes(deps) {
         return c.json({ chosen: { projectId, short: short ?? null }, queue: queueView(queue) });
     })
         // What waits for the extension, oldest first: each new upload dialog takes the first.
+        // Studio's numbers for a project's videos, and every finished A/B test (Library).
+        .get("/stats/:projectId", zValidator("param", projectParam, onInvalid), (c) => c.json({ stats: projectStats(deps.db, c.req.valid("param").projectId) }))
+        .get("/ab-results", (c) => c.json({ results: abResults(deps.db) }))
         // The YouTube videos a project's uploads became, and their A/B tests.
         .get("/videos/:projectId", zValidator("param", projectParam, onInvalid), (c) => c.json({ videos: projectVideos(deps.db, c.req.valid("param").projectId) }))
         // A video's link pasted in Slopify, for an upload made without the extension; an empty
@@ -227,28 +326,6 @@ export function studioRoutes(deps) {
             });
         recordVideo(deps.db, projectId, short ?? null, videoId, deps.clock.now().toISOString());
         return c.json({ videos: projectVideos(deps.db, projectId) });
-    })
-        // Start A/B test (or Cancel): the extension starts it once the video is public.
-        .post("/videos/:projectId/ab-test", zValidator("param", projectParam, onInvalid), zValidator("json", abTestBody, onInvalid), (c) => {
-        const wrong = samePage(c);
-        if (wrong !== undefined)
-            return wrong;
-        const { projectId } = c.req.valid("param");
-        const { short, start } = c.req.valid("json");
-        if (start && !abTestable(projectId, short ?? null))
-            return problem(c, {
-                status: 409,
-                title: titleOf(409),
-                detail: "There is nothing to A/B test: this upload has one thumbnail and no other titles. Make more thumbnails (Edit project → Thumbnail) or let the YouTube step write other titles, then try again.",
-            });
-        const set = setAbState(deps.db, projectId, short ?? null, start ? "waiting" : "none", null, deps.clock.now().toISOString());
-        if (!set)
-            return problem(c, {
-                status: 409,
-                title: titleOf(409),
-                detail: "Slopify doesn't know this upload's YouTube video yet. Paste its link (from YouTube Studio → Details → Video link) first.",
-            });
-        return c.json({ videos: projectVideos(deps.db, projectId) });
     })
         .get("/queue", (c) => {
         const denied = samePage(c);
@@ -344,53 +421,218 @@ export function studioRoutes(deps) {
         const left = removeFill(deps.db, projectId, short ?? null, deps.clock.now());
         return c.json({ waiting: left.length });
     })
-        // The extension read the new video's id from Studio's upload dialog. An upload with an
-        // A/B test to run (other titles, or several thumbnails) waits for its video to be public:
-        // scheduled videos are private until then, and Studio tests only public ones.
-        .post("/ext/video", zValidator("json", extVideoBody, onInvalid), (c) => {
+        // Rows of Studio's Content list (title and video id), matched to projects by title so
+        // uploads made by hand get their links too (`backfill.ts`).
+        .post("/ext/backfill", zValidator("json", backfillBody, onInvalid), (c) => {
         allowOrigin(c, false);
         if (!extAllowed(c))
             return refused(c);
-        const { projectId, short, videoId } = c.req.valid("json");
-        recordVideo(deps.db, projectId, short ?? null, videoId, deps.clock.now().toISOString());
-        const testable = abTestable(projectId, short ?? null);
-        if (testable)
-            setAbState(deps.db, projectId, short ?? null, "waiting", null, deps.clock.now().toISOString());
-        return c.json({ abTest: testable });
-    })
-        // The A/B tests waiting for their videos to be public, each with its upload item (titles
-        // and thumbnails). One whose project or item is gone is dropped.
-        .get("/ext/ab-tests", (c) => {
+        const found = backfillVideos(deps, c.req.valid("json").videos, deps.clock.now().toISOString());
+        return c.json({ found });
+    })
+        // The extension popup: finished projects not marked uploaded, each with its video and
+        // shorts, and which of them are on YouTube already (`youtube_videos`).
+        .get("/ext/ready", (c) => {
+        allowOrigin(c, false);
+        if (!extAllowed(c))
+            return refused(c);
+        const uploads = uploadedProjects(deps.db);
+        const aside = setAsideProjects(deps.db);
+        const projects = listProjects(deps.db).flatMap((project) => {
+            if (uploads.has(project.id))
+                return [];
+            const state = derive(stagesOf(deps.db, project.id), project.paused === true);
+            const finished = state === "done" ||
+                state === "partial" ||
+                (state === "pending" && aside.has(project.id));
+            if (!finished)
+                return [];
+            planned(project.id);
+            const result = uploadPack(deps, project.id);
+            if (!result.ok || result.pack.items[0]?.video == null)
+                return [];
+            return [
+                {
+                    projectId: project.id,
+                    title: project.title,
+                    items: result.pack.items.map((item) => ({
+                        kind: item.kind,
+                        short: item.short ?? null,
+                        title: item.title,
+                        ready: item.video !== null,
+                        uploaded: videoOf(deps.db, project.id, item.short ?? null)?.uploadState === "done",
+                        started: videoOf(deps.db, project.id, item.short ?? null)?.uploadState === "filled",
+                        ...(videoOf(deps.db, project.id, item.short ?? null) === undefined
+                            ? {}
+                            : { videoId: videoOf(deps.db, project.id, item.short ?? null)?.videoId }),
+                        ...(item.scheduleAt === undefined ? {} : { scheduleAt: item.scheduleAt }),
+                    })),
+                },
+            ];
+        });
+        return c.json({ projects });
+    })
+        // The popup's click: that upload goes first in line, and the extension opens Studio's
+        // upload page, where the dialog takes it.
+        .post("/ext/upload", zValidator("json", queueItemBody, onInvalid), (c) => {
+        allowOrigin(c, false);
+        if (!extAllowed(c))
+            return refused(c);
+        const { projectId, short } = c.req.valid("json");
+        const result = uploadPack(deps, projectId);
+        if (!result.ok || packItem(result.pack, short ?? undefined) === undefined)
+            return problem(c, {
+                status: 404,
+                title: titleOf(404),
+                detail: "That upload isn't in the project any more. Open the popup again.",
+            });
+        planned(projectId);
+        fillNow(deps.db, projectId, short ?? null, deps.clock.now());
+        return c.json({ url: studioUploadUrl });
+    })
+        // The popup's Upload all Shorts: each short not on YouTube yet waits, in order, and the
+        // upload dialogs take them one after another.
+        .post("/ext/upload-all", zValidator("json", z.object({ projectId: id }), onInvalid), (c) => {
+        allowOrigin(c, false);
+        if (!extAllowed(c))
+            return refused(c);
+        const { projectId } = c.req.valid("json");
+        planned(projectId);
+        const result = uploadPack(deps, projectId);
+        if (!result.ok)
+            return unknownProject(c);
+        const shorts = result.pack.items.filter((item) => item.kind === "short" &&
+            item.video !== null &&
+            videoOf(deps.db, projectId, item.short ?? null)?.uploadState !== "done");
+        // fillNow puts each first, so the last short goes in first and short 1 ends up first.
+        for (const item of shorts.toReversed())
+            fillNow(deps.db, projectId, item.short ?? null, deps.clock.now());
+        return c.json({ url: studioUploadUrl, count: shorts.length });
+    })
+        // One project's upload pack, for a Studio page opened for one of its uploads.
+        .get("/ext/packs/:projectId", zValidator("param", projectParam, onInvalid), (c) => {
         allowOrigin(c, false);
         if (!extAllowed(c))
             return refused(c);
-        const tests = waitingAbTests(deps.db).flatMap((video) => {
+        const result = uploadPack(deps, c.req.valid("param").projectId);
+        return result.ok ? c.json(result.pack) : unknownProject(c);
+    })
+        // What waits for the extension on YouTube's side: the Details touches after an upload,
+        // and the comments to pin once public.
+        .get("/ext/tasks", (c) => {
+        allowOrigin(c, false);
+        if (!extAllowed(c))
+            return refused(c);
+        const withItems = (videos) => videos.flatMap((video) => {
             const result = uploadPack(deps, video.projectId);
             const item = result.ok ? packItem(result.pack, video.short ?? undefined) : undefined;
             return item === undefined
                 ? []
                 : [{ projectId: video.projectId, short: video.short, videoId: video.videoId, item }];
         });
-        return c.json({ tests });
+        return c.json({
+            finish: withItems(waitingTasks(deps.db, "finish")),
+            comments: withItems(waitingTasks(deps.db, "comment")),
+        });
     })
-        .post("/ext/ab-tests/result", zValidator("json", abResultBody, onInvalid), (c) => {
+        .post("/ext/task-result", zValidator("json", taskResultBody, onInvalid), (c) => {
         allowOrigin(c, false);
         if (!extAllowed(c))
             return refused(c);
-        const { projectId, short, ok, message } = c.req.valid("json");
-        setAbState(deps.db, projectId, short ?? null, ok ? "started" : "failed", message, deps.clock.now().toISOString());
+        const { task, projectId, short, ok, message } = c.req.valid("json");
+        setTaskState(deps.db, task, projectId, short ?? null, ok ? "done" : "failed", message);
         return c.json({ ok: true });
+    })
+        // Every video on YouTube, for the numbers the extension reads from Studio.
+        .get("/ext/known-videos", (c) => {
+        allowOrigin(c, false);
+        if (!extAllowed(c))
+            return refused(c);
+        return c.json({
+            videos: doneVideos(deps.db).map((video) => ({
+                projectId: video.projectId,
+                short: video.short,
+                videoId: video.videoId,
+            })),
+        });
+    })
+        .post("/ext/stats", zValidator("json", statsBody, onInvalid), (c) => {
+        allowOrigin(c, false);
+        if (!extAllowed(c))
+            return refused(c);
+        const body = c.req.valid("json");
+        const readAt = deps.clock.now().toISOString();
+        saveStats(deps.db, {
+            projectId: body.projectId,
+            short: body.short ?? null,
+            videoId: body.videoId,
+            readAt,
+            impressions: body.impressions ?? null,
+            ctr: body.ctr ?? null,
+            views: body.views ?? null,
+            averageViewSeconds: body.averageViewSeconds ?? null,
+            watchHours: body.watchHours ?? null,
+        });
+        if (body.abVariants !== undefined && body.abVariants.length > 1)
+            saveAbResult(deps.db, {
+                projectId: body.projectId,
+                short: body.short ?? null,
+                videoId: body.videoId,
+                readAt,
+                variants: body.abVariants,
+            });
+        return c.json({ ok: true });
+    })
+        // The extension read the new video's id from Studio's upload dialog. It is "filled" until
+        // Studio says it was scheduled or published (`/ext/video/done`): a cancelled upload isn't
+        // on YouTube.
+        .post("/ext/video", zValidator("json", extVideoBody, onInvalid), (c) => {
+        allowOrigin(c, false);
+        if (!extAllowed(c))
+            return refused(c);
+        const { projectId, short, videoId } = c.req.valid("json");
+        recordVideo(deps.db, projectId, short ?? null, videoId, deps.clock.now().toISOString(), "filled");
+        return c.json({ recorded: true });
+    })
+        // Studio showed "Video scheduled" or "Video published". An upload with an A/B test to run
+        // (other titles, or several thumbnails) now waits for its video to be public: scheduled
+        // videos are private until then, and Studio tests only public ones.
+        .post("/ext/video/done", zValidator("json", extVideoBody, onInvalid), (c) => {
+        allowOrigin(c, false);
+        if (!extAllowed(c))
+            return refused(c);
+        const { projectId, short, videoId } = c.req.valid("json");
+        if (!confirmUpload(deps.db, projectId, short ?? null, videoId))
+            recordVideo(deps.db, projectId, short ?? null, videoId, deps.clock.now().toISOString());
+        // The Details touches (a short's related video, the long video's end screen and
+        // captions) wait for the extension now, and the comment for the video to be public.
+        const confirmedPack = uploadPack(deps, projectId);
+        const confirmedItem = confirmedPack.ok
+            ? packItem(confirmedPack.pack, short ?? undefined)
+            : undefined;
+        if (confirmedItem !== undefined &&
+            (confirmedItem.relatedVideoId !== undefined ||
+                confirmedItem.endScreenVideoId !== undefined ||
+                confirmedItem.captions !== undefined))
+            setTaskState(deps.db, "finish", projectId, short ?? null, "waiting", null);
+        if (confirmedItem?.kind === "video" &&
+            confirmedItem.pinnedComment !== undefined &&
+            readSetting(deps.db, autoCommentKey) === "on")
+            setTaskState(deps.db, "comment", projectId, short ?? null, "waiting", null);
+        return c.json({ confirmed: true });
     })
         .get("/ext/files/:projectId/:asset", zValidator("param", fileParam, onInvalid), (c) => {
         allowOrigin(c, false);
         if (!studioRequestAllowed(deps.db, bearerToken(c.req.header("authorization")), c.req.header("origin")))
             return refused(c);
         const { projectId, asset } = c.req.valid("param");
-        // Only a pack's own files, its videos and thumbnails: the extension puts the video into
-        // Studio's upload dialog and the thumbnails into Details, and needs nothing else.
+        // Only a pack's own files, its videos, thumbnails and captions: the extension puts the
+        // video into Studio's upload dialog, the thumbnails into Details and the captions file
+        // into Subtitles, and needs nothing else.
         const result = uploadPack(deps, projectId);
         const listed = result.ok &&
             result.pack.items.some((item) => item.video?.asset === asset ||
+                item.captions?.asset === asset ||
                 item.thumbnails.some((thumbnail) => thumbnail.asset === asset));
         const found = listed ? findDownload(deps, projectId, asset) : undefined;
         if (found === undefined || !found.ok)

package/dist/kernel/db/migrations/0046-youtube-upload-state.sql

@@ -0,0 +1,6 @@
+-- Whether an upload reached YouTube: the extension records the video when it fills the Details
+-- ('filled'), and confirms it once Studio says it was scheduled or published ('done'). One
+-- cancelled, or left as a draft, stays 'filled' and is offered for upload again. A pasted link
+-- is 'done', as is every video recorded before this column.
+ALTER TABLE youtube_videos ADD COLUMN upload_state TEXT NOT NULL DEFAULT 'done'
+  CHECK (upload_state IN ('filled', 'done'));

package/dist/kernel/db/migrations/0047-studio-autopilot.sql

@@ -0,0 +1,39 @@
+-- Studio, hands off (3.3.0).
+-- upload_slots: the posting plan's slot each project's upload takes (its long video's time; the
+-- shorts follow from the plan).
+CREATE TABLE upload_slots (
+  project_id TEXT PRIMARY KEY REFERENCES projects(id) ON DELETE CASCADE,
+  row_name TEXT NOT NULL,
+  long_at TEXT NOT NULL,
+  assigned_at TEXT NOT NULL
+);
+-- What the extension does on a confirmed upload's Details page (the shorts' related video, the
+-- long video's end screen and captions), and the pinned comment once it is public.
+ALTER TABLE youtube_videos ADD COLUMN finish_state TEXT NOT NULL DEFAULT 'none'
+  CHECK (finish_state IN ('none', 'waiting', 'done', 'failed'));
+ALTER TABLE youtube_videos ADD COLUMN finish_message TEXT;
+ALTER TABLE youtube_videos ADD COLUMN comment_state TEXT NOT NULL DEFAULT 'none'
+  CHECK (comment_state IN ('none', 'waiting', 'done', 'failed'));
+ALTER TABLE youtube_videos ADD COLUMN comment_message TEXT;
+-- Studio's numbers for each known video, as the extension last read them.
+CREATE TABLE video_stats (
+  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  short INTEGER NOT NULL,
+  video_id TEXT NOT NULL,
+  read_at TEXT NOT NULL,
+  impressions INTEGER,
+  ctr REAL,
+  views INTEGER,
+  average_view_seconds INTEGER,
+  watch_hours REAL,
+  PRIMARY KEY (project_id, short)
+);
+-- A finished A/B test as Studio shows it: each variant's title, thumbnail number and share.
+CREATE TABLE ab_results (
+  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  short INTEGER NOT NULL,
+  video_id TEXT NOT NULL,
+  read_at TEXT NOT NULL,
+  variants TEXT NOT NULL CHECK (json_valid(variants)),
+  PRIMARY KEY (project_id, short)
+);

package/dist/patch-notes/3.2.9.md

@@ -0,0 +1,15 @@
+# Slopify 3.2.9
+
+Released 2 October 2026.
+
+## Projects
+
+- **Renaming a project no longer makes everything again.** The pictures, scenes, looks and shorts stay as they are: they keep what the project was about. What shows the title follows the new name: the YouTube description and other titles, the PDF and the audio files' tags.
+
+## Prepare upload
+
+- **Pick the upload's title and thumbnail.** The A/B test now starts after the video is public, so the upload itself carries one title and one thumbnail: choose the title among the project's and its other titles, and press **Use for upload** on a thumbnail. Fill in YouTube Studio uses your pick, and the A/B test later tries the others beside it.
+
+## Upgrading from 3.2.8
+
+- **Nothing becomes outdated.** A project renamed before this version keeps whatever its rename already queued.

package/dist/patch-notes/3.3.0.md

@@ -0,0 +1,40 @@
+# Slopify 3.3.0
+
+Released 2 October 2026.
+
+## Posting plan
+
+- **Plan the week once.** Settings → YouTube Studio → **Posting plan** is a table: one row per long video, with the long video's day and time and each short's day and time, in your time zone.
+- **Each finished project takes the next free row** when you prepare its upload. Each short goes out the first time its day and hour come round after its own video, so a plan never needs "next week".
+- **Prepare upload shows the slot** (a Schedule step) with a picker to choose another free one, and the extension types the date and time into Studio's Schedule. You press Schedule.
+
+## Project page
+
+- **Shorts and YouTube are part of Video.** The rail has one Video section; the shorts, the YouTube description and On YouTube sit inside it.
+- **On YouTube shows each video's numbers**: views, click-through rate and average view duration, read from Studio once a day. The Projects list shows views and CTR too.
+- **A/B test only when you ask.** An upload gets the title and thumbnail you picked. Press **A/B test** on On YouTube (titles and thumbnails, titles, or thumbnails) and Studio opens with the test filled in; you check it and press Set test and Save.
+
+## Library
+
+- **A/B results**: every finished A/B test the extension read, winner first. **Copy as prompt notes** gives a short summary to paste into the prompts that write titles and thumbnails.
+
+## Projects
+
+- **Renaming a project runs nothing.** Every step keeps what the project was made about, so a new name never rewrites the outro, re-records it or renders the video again. Press **Write again** on the YouTube description if you want it written for the new name.
+
+## YouTube Studio extension (1.0.0)
+
+- **In the Chrome Web Store**, so it updates by itself (Firefox still loads the zip).
+- **Click the extension's icon** to see your finished projects not marked uploaded, each video and short with its planned time and a ✓ once on YouTube. Click one to upload it: Studio's upload page opens and the extension adds the file and fills in the details.
+- **Upload all shorts in one go**: once Studio confirms one upload, the next upload page opens by itself.
+- **An upload counts only once Studio confirms it** ("Video scheduled", "Video published" or "Video saved"). One you cancel, or close as a draft, stays offered ("Upload again").
+- **Finishing touches after the upload**: the subtitles file goes in as captions, the long video's end screen points at the previous episode, and each short's related video is the long video once it is public. On YouTube shows each one waiting, done or failed, and why.
+- **Pinned comment, if you want it** (off by default; Settings → YouTube Studio): once the video is public, the extension posts the project's pinned comment and pins it.
+- **Links fill themselves in.** Open Studio's Content page and the extension matches its videos and shorts to your projects by title. Shorts then link the full video by themselves.
+- **A/B Testing from the popup** on an uploaded long video: Titles and thumbnails, Titles, or Thumbnails.
+
+## Upgrading from 3.2.9
+
+- **Install the extension from the Chrome Web Store** once it's listed (or download it again from Settings → YouTube Studio and reload it in `chrome://extensions`). It is version 1.0.0.
+- **Check the posting plan** in Settings → YouTube Studio; it starts with three long videos a week and their shorts.
+- **Nothing becomes outdated.** A video the extension recorded earlier counts as on YouTube.

package/dist/patch-notes/index.json

@@ -1,4 +1,16 @@
 [
+  {
+    "id": "3.3.0",
+    "title": "Slopify 3.3.0",
+    "version": "3.3.0",
+    "date": "2026-10-02"
+  },
+  {
+    "id": "3.2.9",
+    "title": "Slopify 3.2.9",
+    "version": "3.2.9",
+    "date": "2026-10-02"
+  },
   {
     "id": "3.2.8",
     "title": "Slopify 3.2.8",

package/dist/slices/admission/model.js

@@ -45,3 +45,7 @@ export const referenceKey = "reference:image";
 // mode existed was) or one vertical short of about a minute, made by the same stages with
 // the Shorts renderer's word-by-word captions (`admission/short-mode.ts`).
 export const runModes = ["video", "short"];
+// What the project is about, for the steps that only use the title as context.
+export function subjectOf(config) {
+    return config.subjectTitle ?? config.title;
+}

package/dist/slices/admission/schema.js

@@ -190,4 +190,5 @@ export const runDraftSchema = z.object({
 export const runConfigSchema = runDraftSchema.extend({
     rendered: z.record(z.string(), z.string()),
     titlePattern: z.string().optional(),
+    subjectTitle: z.string().optional(),
 });