@gentbajko/slopify 3.2.7 → 3.2.9

package/dist/edge/http/studio.js

@@ -9,8 +9,10 @@ import { channelById } from "../../slices/channels/repo.js";
 import { findDownload } from "../../slices/storage/downloads.js";
 import { studioPlaylistMax } from "../../slices/studio/model.js";
 import { packItem, uploadPack } from "../../slices/studio/pack.js";
+import { writeUploadPick } from "../../slices/studio/pick.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 { onInvalid, problem, titleOf } from "./problem.js";
 const id = z
     .string()
@@ -45,6 +47,24 @@ 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({
+    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() });
 // The extension builds the app ships (`scripts/copy-extension.mjs`), by browser.
 const extensionFiles = {
     "chrome.zip": "slopify-studio-chrome.zip",
@@ -91,6 +111,13 @@ 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) => {
+        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);
+    };
     return (new Hono()
         .get("/settings", (c) => {
         // The token is read only by the Slopify page, never by another origin's.
@@ -150,6 +177,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) => {
@@ -182,6 +222,52 @@ 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.
+        // 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
+        // link forgets it.
+        .put("/videos/:projectId", zValidator("param", projectParam, onInvalid), zValidator("json", videoLinkBody, onInvalid), (c) => {
+        const wrong = samePage(c);
+        if (wrong !== undefined)
+            return wrong;
+        const { projectId } = c.req.valid("param");
+        const { short, link } = c.req.valid("json");
+        if (link.trim() === "") {
+            forgetVideo(deps.db, projectId, short ?? null);
+            return c.json({ videos: projectVideos(deps.db, projectId) });
+        }
+        const videoId = videoIdOf(link);
+        if (videoId === undefined)
+            return problem(c, {
+                status: 400,
+                title: titleOf(400),
+                detail: "That isn't a YouTube video link. Copy the video's link from YouTube Studio (Details → Video link, like https://youtu.be/…) and paste it again.",
+            });
+        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);
         if (denied !== undefined)
@@ -275,6 +361,43 @@ export function studioRoutes(deps) {
         const { projectId, short } = c.req.valid("json");
         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) => {
+        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) => {
+        allowOrigin(c, false);
+        if (!extAllowed(c))
+            return refused(c);
+        const tests = waitingAbTests(deps.db).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 });
+    })
+        .post("/ext/ab-tests/result", zValidator("json", abResultBody, 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());
+        return c.json({ ok: true });
     })
         .get("/ext/files/:projectId/:asset", zValidator("param", fileParam, onInvalid), (c) => {
         allowOrigin(c, false);

package/dist/kernel/db/migrations/0045-youtube-videos.sql

@@ -0,0 +1,15 @@
+-- The YouTube video each upload became (the long video, short 0, or short N), as the Slopify
+-- Studio extension read it from Studio's upload dialog or the person pasted its link. With it,
+-- the video's A/B test (its other titles and thumbnails) can wait until the video is public:
+-- a scheduled video is private until then, and Studio tests only public ones. The extension
+-- checks the waiting tests, starts each once its video is public, and reports back.
+CREATE TABLE youtube_videos (
+  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  short INTEGER NOT NULL CHECK (short >= 0),
+  video_id TEXT NOT NULL,
+  recorded_at TEXT NOT NULL,
+  ab_state TEXT NOT NULL DEFAULT 'none' CHECK (ab_state IN ('none', 'waiting', 'started', 'failed')),
+  ab_message TEXT,
+  ab_at TEXT,
+  PRIMARY KEY (project_id, short)
+);

package/dist/patch-notes/3.2.8.md

@@ -0,0 +1,20 @@
+# Slopify 3.2.8
+
+Released 2 October 2026.
+
+3.2.8 starts your A/B tests once a scheduled video goes public, tests the other titles too, and lets the pinned comment and other titles be written again.
+
+## A/B tests after publishing
+
+- YouTube only A/B tests public videos, and a scheduled video is private until its time. The Slopify Studio extension now keeps each upload's YouTube link and starts its A/B test by itself once the video is public: it opens the video in a background tab, fills A/B Testing and presses **Set test**. Chrome has to be open around that time; otherwise the test starts the next time Chrome opens.
+- A/B Testing now tests the **other titles** too: **Title and thumbnail** with two or three thumbnails, **Title only** with one.
+- The project's YouTube section has **On YouTube**: each upload's link (paste one for an upload you made by hand), its A/B test's state, and **Start A/B test** to test any video after the fact.
+
+## YouTube section
+
+- **Write again** is on the pinned comment and the other titles too, not only the description. It still writes every part anew in one AI call; a part you edited keeps your text and offers the new one beside it.
+
+## Upgrading from 3.2.7
+
+- **Download the extension again** (Settings → YouTube Studio → Download), unzip it over the old one and press reload in `chrome://extensions`. It is version 0.3.0, and Chrome asks once to allow its new permissions (a 15-minute timer, and YouTube's public video check).
+- **Nothing becomes outdated.**

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/index.json

@@ -1,4 +1,16 @@
 [
+  {
+    "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",
+    "version": "3.2.8",
+    "date": "2026-10-02"
+  },
   {
     "id": "3.2.7",
     "title": "Slopify 3.2.7",

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(),
 });

package/dist/slices/rebuild/recipe-appearance.js

@@ -1,4 +1,5 @@
 import { withLanguage } from "../../kernel/ports/languages.js";
+import { subjectOf } from "../admission/model.js";
 import { appearanceFor, appearanceMessages, appearanceSchema, usesAppearance, withAppearance, } from "../images/appearance.js";
 import { recipe, selectedReference, } from "./recipe-model.js";
 import { llmInput, llmInputFingerprint } from "./recipe-text.js";
@@ -36,7 +37,7 @@ export function imageAppearance(context, text) {
     const { config } = context;
     if (!pictureBodies(context).some(usesAppearance))
         return undefined;
-    const messages = withLanguage(appearanceMessages({ title: config.title, article: text.articleText ?? "" }), config.language);
+    const messages = withLanguage(appearanceMessages({ title: subjectOf(config), article: text.articleText ?? "" }), config.language);
     const value = recipe(context, imageAppearanceKey, config.sources.images === "generate" ? "images" : "thumbnail", text.articleText === null
         ? {
             kind: "deferred",

package/dist/slices/rebuild/recipe-reference.js

@@ -1,4 +1,4 @@
-import { referenceKey } from "../admission/model.js";
+import { referenceKey, subjectOf } from "../admission/model.js";
 import { usesReference } from "../admission/rules.js";
 import { lookWait, withLooks } from "./recipe-appearance.js";
 import { castFor } from "./recipe-cast.js";
@@ -56,7 +56,7 @@ appearance) {
         prompt,
         // The establishing image sets the look for the whole video, so it is drawn with every
         // member the title mentions as well as the ones its own brief does.
-        ...castField(castFor(config, config.title, prompt)),
+        ...castField(castFor(config, subjectOf(config), prompt)),
     }, [], { unresolved: prompt.trim() === "" });
 }
 // Which image the others are drawn from: the step's fingerprint, so making it again or

package/dist/slices/rebuild/recipe-scenes.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { withLanguage } from "../../kernel/ports/languages.js";
-import { thumbnailCountOf } from "../admission/model.js";
+import { subjectOf, thumbnailCountOf } from "../admission/model.js";
 import { pictureKind, sceneMessages, usesScene } from "../images/scenes.js";
 import { recipe, selectedReference, } from "./recipe-model.js";
 import { llmInput, llmInputFingerprint } from "./recipe-text.js";
@@ -19,7 +19,7 @@ export function thumbnailScenes(context, text) {
         return undefined;
     const count = thumbnailCountOf(config);
     const messages = withLanguage(sceneMessages({
-        title: config.title,
+        title: subjectOf(config),
         article: text.articleText ?? "",
         pictures: [],
         thumbnails: count,
@@ -60,7 +60,7 @@ export function imageScenes(context, text) {
     }
     if (keys.length === 0)
         return undefined;
-    const messages = withLanguage(sceneMessages({ title: config.title, article: text.articleText ?? "", pictures }), config.language);
+    const messages = withLanguage(sceneMessages({ title: subjectOf(config), article: text.articleText ?? "", pictures }), config.language);
     const value = recipe(context, imageScenesKey, "images", text.articleText === null
         ? {
             kind: "deferred",

package/dist/slices/rebuild/recipe-shorts.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { fingerprint } from "../../kernel/runner/work.js";
+import { subjectOf } from "../admission/model.js";
 import { usesShorts } from "../admission/rules.js";
 import { withoutScene } from "../images/scenes.js";
 import { effectiveClips, pickedShortsOf } from "../shorts/clips.js";
@@ -53,7 +54,7 @@ appearance) {
             shorts.count,
             shorts.minSeconds,
             shorts.maxSeconds,
-            config.title,
+            subjectOf(config),
             // The project language, only when it is not English, so English keeps its fingerprint.
             ...(config.language === undefined || config.language === "en" ? [] : [config.language]),
         ],
@@ -113,7 +114,7 @@ appearance) {
         const prompts = {
             ...recipe(context, `${prefix}:prompts`, "video", llmInput(context, imagePromptMessages({
                 style: looked,
-                videoTitle: config.title,
+                videoTitle: subjectOf(config),
                 shortTitle: clip.title,
                 text: clip.text,
                 count,

package/dist/slices/rebuild/recipe-text.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { withLanguage } from "../../kernel/ports/languages.js";
 import { documentIndex } from "../../kernel/ports/llm-documents.js";
 import { fingerprint } from "../../kernel/runner/work.js";
+import { subjectOf } from "../admission/model.js";
 import { usesPronunciationGlossary } from "../admission/rules.js";
 import { render } from "../admission/substitute.js";
 import { articleMessages, continuationMessages } from "../article/continuation.js";
@@ -225,7 +226,7 @@ export function textRecipes(context) {
         const prompt = renderedPrompt(context, "thumbnailPrompt");
         const messages = thumbnailMessages({
             instruction: prompt,
-            title: config.title,
+            title: subjectOf(config),
             values: config.values,
             format: config.format,
             article: articleText ?? "",

package/dist/slices/rebuild/recipe-visual.js

@@ -1,4 +1,4 @@
-import { thumbnailCountOf, thumbnailKey } from "../admission/model.js";
+import { subjectOf, thumbnailCountOf, thumbnailKey } from "../admission/model.js";
 import { usesShortMode } from "../admission/short-mode.js";
 import { render } from "../admission/substitute.js";
 import { withoutScene, withScene } from "../images/scenes.js";
@@ -266,7 +266,7 @@ appearance) {
                 prompt: thumbnailVariantPrompt(prompt, variant),
                 ...(reference === undefined ? {} : { reference: reference.input }),
                 // The thumbnail stands for the whole video, like the establishing image.
-                ...castField(castFor(config, config.title, prompt)),
+                ...castField(castFor(config, subjectOf(config), prompt)),
             }, [
             ...(promptRecipe === undefined ? [] : [promptRecipe.key]),
             ...(reference === undefined ? [] : [reference.key]),

package/dist/slices/revisions/mutations.js

@@ -24,6 +24,7 @@ import { cloneManifest, ensureRevisionStages, projectSelected } from "./projecti
 import { insertAsset, insertRevision } from "./repo.js";
 import { bindNarrationSources, validateNarrationIntent, validateTemplateIntent } from "./rules.js";
 import { revisionEditSchema } from "./schema.js";
+import { keptSubject } from "./subject.js";
 export { bindUpload } from "./mutation-assets.js";
 export { restoreRevision } from "./restore.js";
 export async function saveRevision(deps, input) {
@@ -57,7 +58,7 @@ export async function saveRevision(deps, input) {
             currentRevisionId: base.revision.id,
             fields: replanned.fields,
         };
-    const edit = bindNarrationSources(base, rebrandedEdit(deps.db, base.revision.config, replanned.edit));
+    const edit = bindNarrationSources(base, keptSubject(base.revision.config, rebrandedEdit(deps.db, base.revision.config, replanned.edit)));
     const fields = [
         ...settingProblems(edit),
         ...validateUploads(deps, edit),

package/dist/slices/revisions/subject.js

@@ -0,0 +1,10 @@
+// A renamed project keeps what it is about (`subjectOf`): on the first rename the title it was
+// made with is kept as `subjectTitle`, so the scenes, looks, cast and shorts made from it keep
+// their fingerprints and nothing is drawn again. What shows the title (YouTube's text, the
+// PDF, the files' tags) follows the new name. An edit can't drop a kept subject either.
+export function keptSubject(base, edit) {
+    const subject = base.subjectTitle ?? (edit.config.title !== base.title ? base.title : undefined);
+    if (subject === undefined || edit.config.subjectTitle === subject)
+        return edit;
+    return { ...edit, config: { ...edit.config, subjectTitle: subject } };
+}

package/dist/slices/storage/backup-format.js

@@ -55,6 +55,8 @@ export const projectTables = [
     "project_recovery_requests",
     "youtube_description_edits",
     "project_uploads",
+    // Since 3.2.8: the YouTube video each upload became, and its A/B test.
+    "youtube_videos",
     // Since 2.5.0. Left out on purpose: plan_limit_waits and plan_limit_waiters (an account's
     // current wait, a lease of this install) and prompt_softening (a pending one-off request).
     // Since 3.0.8, narration_retries is left out too: the tries of a run, not of the project.

package/dist/slices/studio/pack.js

@@ -17,6 +17,7 @@ import { usesVoices } from "../voices/model.js";
 import { effectiveDescription } from "../youtube/edits-repo.js";
 import { aiDisclosureOf } from "./disclosure.js";
 import { studioAudience, studioTitleMax, } from "./model.js";
+import { picked, readUploadPick } from "./pick.js";
 import { projectPlaylists, readRealFootage } from "./settings.js";
 // What `shorts.json` holds for each picked clip; only what the pack uses.
 const clipsSchema = z.object({
@@ -112,18 +113,34 @@ export function uploadPack(deps, projectId) {
         missing.push(`Only ${String(thumbnails.length)} of the ${String(count)} thumbnails are made. Regenerate the missing ones in the project's Images section.`);
     if (playlistChoices.length === 0)
         missing.push("No playlist is set for this project's channel, so the playlist step is left to you. Set one in Settings → YouTube Studio → Playlists.");
+    // The video's titles and thumbnails in the project's order, and the ones the person picked
+    // for the upload first (`pick.ts`); the A/B test later tries the rest beside them.
+    const ownTitle = project.title.slice(0, studioTitleMax);
+    const allTitles = [
+        ownTitle,
+        ...(edited?.titles ?? "")
+            .split("\n")
+            .map((one) => one.trim().slice(0, studioTitleMax))
+            .filter((one) => one !== ""),
+    ];
+    const allThumbnails = thumbnails.map(file);
+    const pick = readUploadPick(deps.db, projectId);
+    const arranged = picked(allTitles, allThumbnails, pick);
     const items = [
         {
             kind: "video",
             video: video === undefined ? null : file(video),
-            title: project.title.slice(0, studioTitleMax),
-            titles: (edited?.titles ?? "")
-                .split("\n")
-                .map((one) => one.trim().slice(0, studioTitleMax))
-                .filter((one) => one !== ""),
+            title: arranged.titles[0] ?? ownTitle,
+            titles: arranged.titles.slice(1),
             description: description ?? "",
             tags: tagsOf(tagsFile),
-            thumbnails: thumbnails.map(file),
+            thumbnails: arranged.thumbnails,
+            pickable: {
+                titles: allTitles,
+                thumbnails: allThumbnails,
+                title: pick.title < allTitles.length ? pick.title : 0,
+                thumbnail: pick.thumbnail < allThumbnails.length ? pick.thumbnail : 0,
+            },
             audience: studioAudience,
             alteredContent: disclosure("video"),
             playlists,

package/dist/slices/studio/pick.js

@@ -0,0 +1,32 @@
+import { z } from "zod";
+import { readSetting, writeSetting } from "../settings/repo.js";
+const pickSchema = z.object({
+    title: z.number().int().min(0).max(9),
+    thumbnail: z.number().int().min(0).max(9),
+});
+const keyOf = (projectId) => `studio.uploadPick.${projectId}`;
+export function readUploadPick(db, projectId) {
+    const stored = readSetting(db, keyOf(projectId));
+    if (stored === undefined)
+        return { title: 0, thumbnail: 0 };
+    try {
+        const parsed = pickSchema.safeParse(JSON.parse(stored));
+        return parsed.success ? parsed.data : { title: 0, thumbnail: 0 };
+    }
+    catch {
+        return { title: 0, thumbnail: 0 };
+    }
+}
+export function writeUploadPick(db, projectId, pick) {
+    writeSetting(db, keyOf(projectId), JSON.stringify(pickSchema.parse(pick)));
+}
+// The chosen title first, the others after it in their order; the same for the thumbnails. A
+// pick past the end (a title list rewritten shorter) falls back to the first.
+export function picked(titles, thumbnails, pick) {
+    const first = (list, at) => {
+        const index = at < list.length ? at : 0;
+        const chosen = list[index];
+        return chosen === undefined ? list : [chosen, ...list.filter((_, one) => one !== index)];
+    };
+    return { titles: first(titles, pick.title), thumbnails: first(thumbnails, pick.thumbnail) };
+}

package/dist/slices/studio/videos.js

@@ -0,0 +1,60 @@
+// A YouTube video id: 11 letters, digits, `-` and `_`.
+export const videoIdPattern = /^[A-Za-z0-9_-]{11}$/;
+// The id inside a link as Studio and YouTube show it (youtu.be/ID, watch?v=ID, /shorts/ID,
+// studio's /video/ID/edit), or the bare id.
+export function videoIdOf(text) {
+    const trimmed = text.trim();
+    if (videoIdPattern.test(trimmed))
+        return trimmed;
+    const match = /(?:youtu\.be\/|[?&]v=|\/shorts\/|\/video\/|\/live\/|\/embed\/)([A-Za-z0-9_-]{11})(?![A-Za-z0-9_-])/.exec(trimmed);
+    return match?.[1];
+}
+const slot = (short) => short ?? 0;
+function rowOf(row) {
+    const short = Number(row.short);
+    return {
+        projectId: String(row.project_id),
+        short: short === 0 ? null : short,
+        videoId: String(row.video_id),
+        recordedAt: String(row.recorded_at),
+        abState: String(row.ab_state),
+        abMessage: typeof row.ab_message === "string" ? row.ab_message : null,
+        abAt: typeof row.ab_at === "string" ? row.ab_at : null,
+    };
+}
+// Records (or replaces) the video an upload became. A new video id starts its A/B test over.
+export function recordVideo(db, projectId, short, videoId, at) {
+    db.prepare(`INSERT INTO youtube_videos(project_id,short,video_id,recorded_at) VALUES (?,?,?,?)
+     ON CONFLICT(project_id,short) DO UPDATE SET
+       ab_state=CASE WHEN video_id=excluded.video_id THEN ab_state ELSE 'none' END,
+       ab_message=CASE WHEN video_id=excluded.video_id THEN ab_message ELSE NULL END,
+       ab_at=CASE WHEN video_id=excluded.video_id THEN ab_at ELSE NULL END,
+       video_id=excluded.video_id, recorded_at=excluded.recorded_at`).run(projectId, slot(short), videoId, at);
+}
+export function forgetVideo(db, projectId, short) {
+    db.prepare("DELETE FROM youtube_videos WHERE project_id=? AND short=?").run(projectId, slot(short));
+}
+export function projectVideos(db, projectId) {
+    return db
+        .prepare("SELECT * FROM youtube_videos WHERE project_id=? ORDER BY short")
+        .all(projectId)
+        .map(rowOf);
+}
+export function videoOf(db, projectId, short) {
+    const row = db
+        .prepare("SELECT * FROM youtube_videos WHERE project_id=? AND short=?")
+        .get(projectId, slot(short));
+    return row === undefined ? undefined : rowOf(row);
+}
+// Sets an A/B test's state; false when the project has no video recorded for that upload.
+export function setAbState(db, projectId, short, state, message, at) {
+    return (db
+        .prepare("UPDATE youtube_videos SET ab_state=?, ab_message=?, ab_at=? WHERE project_id=? AND short=?")
+        .run(state, message, at, projectId, slot(short)).changes > 0);
+}
+export function waitingAbTests(db) {
+    return db
+        .prepare("SELECT * FROM youtube_videos WHERE ab_state='waiting' ORDER BY recorded_at")
+        .all()
+        .map(rowOf);
+}