@gentbajko/slopify 3.2.9 → 3.3.1

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

@@ -123,7 +123,7 @@ appearance) {
                 // Only for a short, so every long video keeps its fingerprint: the word-by-word
                 // captions are drawn from the word timing in the caption font, under the title.
                 ...(short
-                    ? [["short-v1", config.subtitles?.fontId ?? "default", config.title, timing]]
+                    ? [["short-v1", config.subtitles?.fontId ?? "default", subjectOf(config), timing]]
                     : []),
                 // Only while the video has an ambient bed, so every video without one keeps the
                 // fingerprint it always had.
@@ -213,7 +213,7 @@ appearance) {
                 kind: "provided",
                 version: 1,
                 assetId: content.provided.thumbnail ?? null,
-                semantic: [config.title, config.format],
+                semantic: [subjectOf(config), config.format],
             }, [], { unresolved: content.provided.thumbnail === undefined }),
         ];
     const promptRecipe = textRecipes.find((value) => value.key === "thumbnail:prompt");

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

@@ -1,3 +1,4 @@
+import { subjectOf } from "../admission/model.js";
 import { usesYoutubeDescription } from "../admission/rules.js";
 import { recipe, resourceIdentity, } from "./recipe-model.js";
 import { renderedPrompt } from "./recipe-text.js";
@@ -24,7 +25,7 @@ export function youtubeRecipes(context, exports) {
                 // Blank means the built-in prompt; the step fills it in, so a new built-in wording
                 // ships as a new operation version rather than a silent change here.
                 config.descriptionPrompt?.trim() ? renderedPrompt(context, "description") : "",
-                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]),
             ],

package/dist/slices/revisions/subject.js

@@ -1,7 +1,6 @@
 // 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.
+// made with is kept as `subjectTitle`, and every step's fingerprint reads it, so a rename runs
+// nothing. 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)

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

@@ -57,6 +57,10 @@ export const projectTables = [
     "project_uploads",
     // Since 3.2.8: the YouTube video each upload became, and its A/B test.
     "youtube_videos",
+    // Since 3.3.0: each project's posting-plan slot, Studio's numbers and its A/B results.
+    "upload_slots",
+    "video_stats",
+    "ab_results",
     // 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/storage/portable.js

@@ -23,7 +23,9 @@ import { appearances, providerById, providerIds } from "../settings/model.js";
 import { listVoices } from "../settings/repo.js";
 import { realPersonVoicesKey, voiceIdMax, voiceNameMax } from "../settings/voices.js";
 import { whatsNewSeenKey } from "../settings/whats-new.js";
-import { storedPlaylistsSchema, storedProjectPlaylistsSchema, studioChannelPlaylistPrefix, studioFillQueuePrefix, studioPairingKey, studioPlaylistKey, studioProjectPlaylistsKey, studioRealFootageKey, } from "../studio/settings.js";
+import { uploadPickPrefix, uploadPickSchema } from "../studio/pick.js";
+import { postingPlanKey, postingPlanSchema } from "../studio/plan.js";
+import { autoCommentKey, storedPlaylistsSchema, storedProjectPlaylistsSchema, studioChannelPlaylistPrefix, studioFillQueuePrefix, studioPairingKey, studioPlaylistKey, studioProjectPlaylistsKey, studioRealFootageKey, } from "../studio/settings.js";
 import { channelLinksKey } from "../youtube/edits-repo.js";
 import { defaultBackupsDir, projectDir, stagingPath } from "./layout.js";
 import { stageKinds } from "./model.js";
@@ -379,6 +381,11 @@ function portableSettings(settings) {
             key === whatsNewSeenKey ||
             key === patchNotesSeenKey)
             continue;
+        if (key === autoCommentKey) {
+            z.enum(["on", "off"]).parse(value);
+            portable[key] = value;
+            continue;
+        }
         const parsed = storedJson(value);
         if (key === "silenceGapSeconds")
             storedSilenceGap.parse(parsed);
@@ -388,6 +395,10 @@ function portableSettings(settings) {
             storedLoudness.parse(parsed);
         else if (key === studioPlaylistKey || key.startsWith(studioChannelPlaylistPrefix))
             storedPlaylistsSchema.parse(parsed);
+        else if (key === postingPlanKey)
+            postingPlanSchema.parse(parsed);
+        else if (key.startsWith(uploadPickPrefix))
+            uploadPickSchema.parse(parsed);
         else if (key === studioProjectPlaylistsKey)
             storedProjectPlaylistsSchema.parse(parsed);
         else if (key === channelLinksKey)

package/dist/slices/studio/backfill.js

@@ -0,0 +1,34 @@
+import { listProjects } from "../admission/repo.js";
+import { uploadPack } from "./pack.js";
+import { clearSlot } from "./plan.js";
+import { projectVideos, recordVideo } from "./videos.js";
+const norm = (title) => title.trim().replace(/\s+/g, " ").toLowerCase();
+export function backfillVideos(deps, rows, at) {
+    const byTitle = new Map();
+    for (const row of rows)
+        byTitle.set(norm(row.title), row.videoId);
+    if (byTitle.size === 0)
+        return 0;
+    let found = 0;
+    for (const project of listProjects(deps.db)) {
+        const known = projectVideos(deps.db, project.id).filter((one) => one.uploadState === "done");
+        const result = uploadPack(deps, project.id);
+        if (!result.ok)
+            continue;
+        for (const item of result.pack.items) {
+            const short = item.short ?? null;
+            if (known.some((one) => one.short === short))
+                continue;
+            const titles = item.pickable?.titles ?? [item.title, ...item.titles];
+            const videoId = titles.map((one) => byTitle.get(norm(one))).find((one) => one !== undefined);
+            if (videoId === undefined)
+                continue;
+            recordVideo(deps.db, project.id, short, videoId, at);
+            // Uploaded by hand before: its long video holds no slot of the posting plan.
+            if (short === null)
+                clearSlot(deps.db, project.id);
+            found += 1;
+        }
+    }
+    return found;
+}

package/dist/slices/studio/model.js

@@ -21,6 +21,8 @@ export const studioSteps = [
     "audience",
     "altered",
     "tags",
+    // Studio's Visibility step: when it goes out, from the posting plan.
+    "schedule",
 ];
 // Tags as Studio's field takes them: comma-separated.
 export function tagsLine(tags) {

package/dist/slices/studio/pack.js

@@ -14,11 +14,14 @@ import { outputPath } from "../storage/layout.js";
 import { outputsOf } from "../storage/repo.js";
 import { videoEditOf } from "../video/edit-settings.js";
 import { usesVoices } from "../voices/model.js";
-import { effectiveDescription } from "../youtube/edits-repo.js";
+import { effectiveDescription, readDescriptionEdits } from "../youtube/edits-repo.js";
+import { linkKey, previousVideoLink } from "../youtube/placeholders.js";
 import { aiDisclosureOf } from "./disclosure.js";
 import { studioAudience, studioTitleMax, } from "./model.js";
 import { picked, readUploadPick } from "./pick.js";
+import { readPlan, scheduleOf } from "./plan.js";
 import { projectPlaylists, readRealFootage } from "./settings.js";
+import { previousLongVideo, videoIdOf, videoOf } from "./videos.js";
 // What `shorts.json` holds for each picked clip; only what the pack uses.
 const clipsSchema = z.object({
     shorts: z.array(z.object({
@@ -88,6 +91,7 @@ export function uploadPack(deps, projectId) {
             description: written,
             tags: writtenTags ?? "",
             titles: text(outputs.find((output) => output.role === "youtube_titles")),
+            pinnedComment: text(outputs.find((output) => output.role === "youtube_pinned_comment")),
             // The last chapter is checked against the video's own length when it is known.
             durationSeconds: video?.durationMs === null || video?.durationMs === undefined
                 ? undefined
@@ -125,6 +129,22 @@ export function uploadPack(deps, projectId) {
     ];
     const allThumbnails = thumbnails.map(file);
     const pick = readUploadPick(deps.db, projectId);
+    // When each upload goes out, from the posting plan's slot (`plan.ts`), once the project has
+    // one: the long video at the slot, each short at its own time after it.
+    const plan = readPlan(deps.db);
+    const slotRow = deps.db
+        .prepare("SELECT row_name, long_at FROM upload_slots WHERE project_id=?")
+        .get(projectId);
+    const schedule = slotRow === undefined || String(slotRow.long_at) === ""
+        ? undefined
+        : scheduleOf(plan, { row: String(slotRow.row_name), longAt: String(slotRow.long_at) });
+    // The long video's captions, its end screen's video (the project's Previous video, else the
+    // long video uploaded before it) and the comment to pin; a short's related video is the
+    // long video, once it is on YouTube.
+    const captions = outputs.find((output) => output.role === "subtitles_srt");
+    const previous = edited === undefined ? undefined : readPreviousVideo(deps.db, projectId);
+    const endScreenVideoId = previous ?? previousLongVideo(deps.db, projectId);
+    const pinnedComment = edited?.pinnedComment.trim() ?? "";
     const arranged = picked(allTitles, allThumbnails, pick);
     const items = [
         {
@@ -146,8 +166,17 @@ export function uploadPack(deps, projectId) {
             playlists,
             playlist,
             ...(edited?.chapterNotice === undefined ? {} : { chapterNotice: edited.chapterNotice }),
+            ...(schedule === undefined ? {} : { scheduleAt: schedule.longAt }),
+            ...(captions === undefined ? {} : { captions: file(captions) }),
+            ...(endScreenVideoId === undefined ? {} : { endScreenVideoId }),
+            ...(pinnedComment === "" ? {} : { pinnedComment }),
         },
     ];
+    // The shorts link the long video: the link set in the project, else the one Slopify knows
+    // the video by on YouTube (`videos.ts`).
+    const longVideo = videoOf(deps.db, projectId, null);
+    const fullVideoLink = config.shorts?.fullVideoLink ??
+        (longVideo?.uploadState === "done" ? `https://youtu.be/${longVideo.videoId}` : undefined);
     const clips = clipsOf(text(outputs.find((output) => output.role === "shorts")));
     const shortVideos = outputs.filter((output) => output.role === "short_video");
     for (const clip of clips) {
@@ -168,7 +197,7 @@ export function uploadPack(deps, projectId) {
             titles: [],
             description: [
                 clip.description,
-                fullVideoLine(config.shorts?.fullVideoLink),
+                fullVideoLine(fullVideoLink),
                 "",
                 clip.hashtags.join(" "),
             ].join("\n"),
@@ -180,6 +209,10 @@ export function uploadPack(deps, projectId) {
             alteredContent: disclosure("short"),
             playlists,
             playlist,
+            ...(schedule?.shortsAt[clip.number - 1] === undefined
+                ? {}
+                : { scheduleAt: schedule.shortsAt[clip.number - 1] }),
+            ...(longVideo?.uploadState === "done" ? { relatedVideoId: longVideo.videoId } : {}),
         });
     }
     return {
@@ -188,6 +221,7 @@ export function uploadPack(deps, projectId) {
             projectId,
             projectTitle: project.title,
             items,
+            ...(schedule === undefined ? {} : { schedule }),
             missing,
             playlistChoices,
             ...(uploadedClips > 0 ? { footage: { clips: uploadedClips, real: realFootage } } : {}),
@@ -237,3 +271,8 @@ function available(deps, projectId, output) {
         throwIfNoEntry: false,
     })?.isFile() === true);
 }
+// The project's Previous video link (YouTube section), as a video id.
+function readPreviousVideo(db, projectId) {
+    const link = readDescriptionEdits(db, projectId).links.find((one) => linkKey(one.name) === linkKey(previousVideoLink))?.url;
+    return link === undefined ? undefined : videoIdOf(link);
+}

package/dist/slices/studio/pick.js

@@ -1,16 +1,17 @@
 import { z } from "zod";
 import { readSetting, writeSetting } from "../settings/repo.js";
-const pickSchema = z.object({
+export const uploadPickSchema = 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 const uploadPickPrefix = "studio.uploadPick.";
+const keyOf = (projectId) => `${uploadPickPrefix}${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));
+        const parsed = uploadPickSchema.safeParse(JSON.parse(stored));
         return parsed.success ? parsed.data : { title: 0, thumbnail: 0 };
     }
     catch {
@@ -18,7 +19,7 @@ export function readUploadPick(db, projectId) {
     }
 }
 export function writeUploadPick(db, projectId, pick) {
-    writeSetting(db, keyOf(projectId), JSON.stringify(pickSchema.parse(pick)));
+    writeSetting(db, keyOf(projectId), JSON.stringify(uploadPickSchema.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.

package/dist/slices/studio/plan.js

@@ -0,0 +1,190 @@
+import { z } from "zod";
+import { readSetting, writeSetting } from "../settings/repo.js";
+// The posting plan (Settings → YouTube Studio → Posting plan): a week of long-video slots, each
+// with its shorts, kept in one time zone. A finished project takes the next free slot when its
+// upload is prepared; each of its shorts goes out at the first time its day and hour come round
+// after its own long video, so a plan never needs "next week" notes. The extension types the
+// times into Studio's schedule, in the browser's own time zone.
+export const weekdays = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+const slotSchema = z.object({
+    day: z.number().int().min(0).max(6),
+    time: z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/),
+});
+const rowSchema = z.object({
+    name: z.string().trim().min(1).max(20),
+    long: slotSchema,
+    shorts: z.array(slotSchema).max(10),
+});
+export const postingPlanSchema = z.object({
+    timeZone: z.string().min(1).max(100),
+    rows: z.array(rowSchema).max(14),
+});
+export const postingPlanKey = "studio.postingPlan";
+const key = postingPlanKey;
+// Three long videos a week, five shorts each, the channel's own times.
+export function defaultPlan(timeZone) {
+    const at = (day, time) => ({ day, time });
+    return {
+        timeZone,
+        rows: [
+            {
+                name: "A",
+                long: at(0, "20:00"),
+                shorts: [at(1, "00:00"), at(1, "17:00"), at(2, "00:00"), at(2, "17:00"), at(3, "17:00")],
+            },
+            {
+                name: "B",
+                long: at(2, "20:00"),
+                shorts: [at(3, "00:00"), at(4, "00:00"), at(4, "17:00"), at(5, "17:00"), at(6, "17:00")],
+            },
+            {
+                name: "C",
+                long: at(4, "20:00"),
+                shorts: [at(5, "00:00"), at(6, "00:00"), at(6, "21:00"), at(0, "00:00"), at(0, "17:00")],
+            },
+        ],
+    };
+}
+export function localTimeZone() {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+}
+export function readPlan(db) {
+    const stored = readSetting(db, key);
+    if (stored !== undefined)
+        try {
+            const parsed = postingPlanSchema.safeParse(JSON.parse(stored));
+            if (parsed.success)
+                return parsed.data;
+        }
+        catch {
+            // A broken setting reads as the default plan.
+        }
+    return defaultPlan(localTimeZone());
+}
+export function writePlan(db, plan) {
+    writeSetting(db, key, JSON.stringify(postingPlanSchema.parse(plan)));
+}
+function partsIn(timeZone, at) {
+    const format = new Intl.DateTimeFormat("en-US", {
+        timeZone,
+        hourCycle: "h23",
+        year: "numeric",
+        month: "numeric",
+        day: "numeric",
+        hour: "numeric",
+        minute: "numeric",
+        second: "numeric",
+    });
+    const out = {};
+    for (const part of format.formatToParts(at))
+        if (part.type !== "literal")
+            out[part.type] = Number(part.value);
+    return out;
+}
+// How far the zone is ahead of UTC at that instant, in milliseconds.
+function offsetAt(timeZone, at) {
+    const p = partsIn(timeZone, at);
+    const local = Date.UTC(p.year ?? 0, (p.month ?? 1) - 1, p.day ?? 1, p.hour ?? 0, p.minute ?? 0, p.second ?? 0);
+    return local - Math.floor(at.getTime() / 1000) * 1000;
+}
+// The instant a wall-clock time names in the zone (the later reading when a clock change
+// makes it ambiguous, the hour after when it skips it).
+export function zonedInstant(timeZone, date, time) {
+    const [hour, minute] = time.split(":").map(Number);
+    const wall = Date.UTC(date.year, date.month - 1, date.day, hour ?? 0, minute ?? 0);
+    const first = wall - offsetAt(timeZone, new Date(wall));
+    return new Date(wall - offsetAt(timeZone, new Date(first)));
+}
+function localDate(timeZone, at) {
+    const p = partsIn(timeZone, at);
+    const year = p.year ?? 1970;
+    const month = p.month ?? 1;
+    const day = p.day ?? 1;
+    return { year, month, day, weekday: new Date(Date.UTC(year, month - 1, day)).getUTCDay() };
+}
+function addDays(date, days) {
+    const next = new Date(Date.UTC(date.year, date.month - 1, date.day + days));
+    return {
+        year: next.getUTCFullYear(),
+        month: next.getUTCMonth() + 1,
+        day: next.getUTCDate(),
+        weekday: next.getUTCDay(),
+    };
+}
+// The first time the slot's day and hour come round after `after`.
+export function nextOccurrence(timeZone, slot, after) {
+    let date = localDate(timeZone, after);
+    for (let step = 0; step < 15; step += 1, date = addDays(date, 1)) {
+        if (date.weekday !== slot.day)
+            continue;
+        const at = zonedInstant(timeZone, date, slot.time);
+        if (at.getTime() > after.getTime())
+            return at;
+    }
+    return new Date(after.getTime() + 7 * 24 * 60 * 60 * 1000);
+}
+// The coming long-video slots in time order, from `now` (a slot starting within the hour is
+// too close to prepare), over `weeks` weeks.
+export function comingSlots(plan, now, weeks = 8) {
+    const soonest = now.getTime() + 60 * 60 * 1000;
+    const start = localDate(plan.timeZone, now);
+    const slots = [];
+    for (let day = 0; day < weeks * 7; day += 1) {
+        const date = addDays(start, day);
+        for (const row of plan.rows) {
+            if (row.long.day !== date.weekday)
+                continue;
+            const at = zonedInstant(plan.timeZone, date, row.long.time);
+            if (at.getTime() >= soonest)
+                slots.push({ row: row.name, at });
+        }
+    }
+    return slots
+        .toSorted((left, right) => left.at.getTime() - right.at.getTime())
+        .map((slot) => ({ row: slot.row, longAt: slot.at.toISOString() }));
+}
+export function scheduleOf(plan, slot) {
+    const row = plan.rows.find((one) => one.name === slot.row);
+    const longAt = new Date(slot.longAt);
+    return {
+        ...slot,
+        shortsAt: (row?.shorts ?? []).map((short) => nextOccurrence(plan.timeZone, short, longAt).toISOString()),
+    };
+}
+// The project's slot: the one it was given, else the next free one, kept from now on. A project
+// set to "Not scheduled" keeps an empty row, so it isn't given one again.
+export function assignedSlot(db, plan, projectId, now) {
+    const row = db
+        .prepare("SELECT row_name, long_at FROM upload_slots WHERE project_id=?")
+        .get(projectId);
+    if (row !== undefined)
+        return String(row.long_at) === ""
+            ? undefined
+            : { row: String(row.row_name), longAt: String(row.long_at) };
+    const free = freeSlots(db, plan, now, 1)[0];
+    if (free === undefined)
+        return undefined;
+    setSlot(db, projectId, free, now);
+    return free;
+}
+export function freeSlots(db, plan, now, count) {
+    const taken = new Set(db
+        .prepare("SELECT long_at FROM upload_slots")
+        .all()
+        .map((row) => String(row.long_at)));
+    return comingSlots(plan, now)
+        .filter((slot) => !taken.has(slot.longAt))
+        .slice(0, count);
+}
+export function setSlot(db, projectId, slot, now) {
+    db.prepare(`INSERT INTO upload_slots(project_id,row_name,long_at,assigned_at) VALUES (?,?,?,?)
+     ON CONFLICT(project_id) DO UPDATE SET row_name=excluded.row_name, long_at=excluded.long_at,
+       assigned_at=excluded.assigned_at`).run(projectId, slot.row, slot.longAt, now.toISOString());
+}
+// "Not scheduled": the project takes no slot until one is chosen for it.
+export function unschedule(db, projectId, now) {
+    setSlot(db, projectId, { row: "", longAt: "" }, now);
+}
+export function clearSlot(db, projectId) {
+    db.prepare("DELETE FROM upload_slots WHERE project_id=?").run(projectId);
+}

package/dist/slices/studio/queue.js

@@ -67,3 +67,10 @@ export function removeFill(db, projectId, short, now) {
     write(db, queueKey(db), next);
     return next;
 }
+// The extension popup's pick: this item goes first, so the upload dialog it opens gets it.
+export function fillNow(db, projectId, short, now) {
+    const others = readFillQueue(db, now).filter((entry) => !same(entry, projectId, short));
+    const next = [{ projectId, short, at: now.toISOString() }, ...others].slice(0, fillQueueMax);
+    write(db, queueKey(db), next);
+    return next;
+}

package/dist/slices/studio/settings.js

@@ -140,6 +140,8 @@ export function saveProjectPlaylists(db, projectId, names) {
 // project's Prepare upload, under AI use. One row holding their ids; YouTube's second AI use
 // case is footage of a real event or place altered by AI (`disclosure.ts`).
 export const studioRealFootageKey = "studio.realFootage";
+// "on" or "off": whether the extension posts and pins each video's comment once it is public.
+export const autoCommentKey = "studio.autoComment";
 function realFootageIds(db) {
     const stored = readSetting(db, studioRealFootageKey);
     if (stored === undefined)

package/dist/slices/studio/stats.js

@@ -0,0 +1,71 @@
+import { z } from "zod";
+export const abVariantSchema = z.object({
+    title: z.string().max(200).nullable(),
+    // Which thumbnail (1-3) the variant showed, when Studio says.
+    thumbnail: z.number().int().min(1).max(3).nullable(),
+    // Its share of watch time, percent.
+    share: z.number().min(0).max(100).nullable(),
+    winner: z.boolean(),
+});
+const slot = (short) => short ?? 0;
+const num = (value) => (typeof value === "number" ? value : null);
+export function saveStats(db, stats) {
+    db.prepare(`INSERT INTO video_stats(project_id,short,video_id,read_at,impressions,ctr,views,average_view_seconds,watch_hours)
+     VALUES (?,?,?,?,?,?,?,?,?) ON CONFLICT(project_id,short) DO UPDATE SET video_id=excluded.video_id,
+     read_at=excluded.read_at, impressions=excluded.impressions, ctr=excluded.ctr, views=excluded.views,
+     average_view_seconds=excluded.average_view_seconds, watch_hours=excluded.watch_hours`).run(stats.projectId, slot(stats.short), stats.videoId, stats.readAt, stats.impressions, stats.ctr, stats.views, stats.averageViewSeconds, stats.watchHours);
+}
+function statsOf(row) {
+    const short = Number(row.short);
+    return {
+        projectId: String(row.project_id),
+        short: short === 0 ? null : short,
+        videoId: String(row.video_id),
+        readAt: String(row.read_at),
+        impressions: num(row.impressions),
+        ctr: num(row.ctr),
+        views: num(row.views),
+        averageViewSeconds: num(row.average_view_seconds),
+        watchHours: num(row.watch_hours),
+    };
+}
+export function projectStats(db, projectId) {
+    return db
+        .prepare("SELECT * FROM video_stats WHERE project_id=? ORDER BY short")
+        .all(projectId)
+        .map(statsOf);
+}
+// Each project's long video's numbers, for the Projects list.
+export function longVideoStats(db) {
+    return new Map(db
+        .prepare("SELECT * FROM video_stats WHERE short=0")
+        .all()
+        .map((row) => [String(row.project_id), statsOf(row)]));
+}
+export function saveAbResult(db, result) {
+    db.prepare(`INSERT INTO ab_results(project_id,short,video_id,read_at,variants) VALUES (?,?,?,?,?)
+     ON CONFLICT(project_id,short) DO UPDATE SET video_id=excluded.video_id, read_at=excluded.read_at,
+     variants=excluded.variants`).run(result.projectId, slot(result.short), result.videoId, result.readAt, JSON.stringify(result.variants));
+}
+export function abResults(db) {
+    return db
+        .prepare(`SELECT r.*, p.title AS project_title FROM ab_results r JOIN projects p ON p.id=r.project_id
+       ORDER BY r.read_at DESC`)
+        .all()
+        .flatMap((row) => {
+        const parsed = z.array(abVariantSchema).safeParse(JSON.parse(String(row.variants)));
+        if (!parsed.success)
+            return [];
+        const short = Number(row.short);
+        return [
+            {
+                projectId: String(row.project_id),
+                projectTitle: String(row.project_title),
+                short: short === 0 ? null : short,
+                videoId: String(row.video_id),
+                readAt: String(row.read_at),
+                variants: parsed.data,
+            },
+        ];
+    });
+}

package/dist/slices/studio/videos.js

@@ -1,3 +1,4 @@
+const taskState = (value) => value === "waiting" || value === "done" || value === "failed" ? value : "none";
 // 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,
@@ -17,19 +18,34 @@ function rowOf(row) {
         short: short === 0 ? null : short,
         videoId: String(row.video_id),
         recordedAt: String(row.recorded_at),
+        uploadState: row.upload_state === "filled" ? "filled" : "done",
         abState: String(row.ab_state),
+        finishState: taskState(row.finish_state),
+        finishMessage: typeof row.finish_message === "string" ? row.finish_message : null,
+        commentState: taskState(row.comment_state),
+        commentMessage: typeof row.comment_message === "string" ? row.comment_message : null,
         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 (?,?,?,?)
+// Records (or replaces) the video an upload became: "filled" from the upload dialog, "done"
+// once confirmed or pasted. A new video id starts its A/B test over; a confirmed video isn't
+// taken back to "filled" by filling it again.
+export function recordVideo(db, projectId, short, videoId, at, state = "done") {
+    db.prepare(`INSERT INTO youtube_videos(project_id,short,video_id,recorded_at,upload_state) 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);
+       upload_state=CASE WHEN video_id=excluded.video_id AND upload_state='done' THEN 'done'
+         ELSE excluded.upload_state END,
+       video_id=excluded.video_id, recorded_at=excluded.recorded_at`).run(projectId, slot(short), videoId, at, state);
+}
+// Studio said the upload was scheduled or published. False when no such upload was filled.
+export function confirmUpload(db, projectId, short, videoId) {
+    return (db
+        .prepare("UPDATE youtube_videos SET upload_state='done' WHERE project_id=? AND short=? AND video_id=?")
+        .run(projectId, slot(short), videoId).changes > 0);
 }
 export function forgetVideo(db, projectId, short) {
     db.prepare("DELETE FROM youtube_videos WHERE project_id=? AND short=?").run(projectId, slot(short));
@@ -46,15 +62,33 @@ export function videoOf(db, projectId, 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 setTaskState(db, task, projectId, short, state, message) {
+    const column = task === "finish" ? "finish" : "comment";
+    db.prepare(`UPDATE youtube_videos SET ${column}_state=?, ${column}_message=? WHERE project_id=? AND short=?`).run(state, message, projectId, slot(short));
 }
-export function waitingAbTests(db) {
+export function waitingTasks(db, task) {
+    const column = task === "finish" ? "finish_state" : "comment_state";
     return db
-        .prepare("SELECT * FROM youtube_videos WHERE ab_state='waiting' ORDER BY recorded_at")
+        .prepare(`SELECT * FROM youtube_videos WHERE ${column}='waiting' ORDER BY recorded_at`)
         .all()
         .map(rowOf);
 }
+// Every video on YouTube, for the numbers the extension reads from Studio.
+export function doneVideos(db) {
+    return db
+        .prepare("SELECT * FROM youtube_videos WHERE upload_state='done' ORDER BY recorded_at DESC")
+        .all()
+        .map(rowOf);
+}
+// The long video uploaded last before this project's, for its end screen ("the previous
+// episode"), when the project names none.
+export function previousLongVideo(db, projectId) {
+    const own = db
+        .prepare("SELECT recorded_at FROM youtube_videos WHERE project_id=? AND short=0")
+        .get(projectId);
+    const row = db
+        .prepare(`SELECT video_id FROM youtube_videos WHERE short=0 AND project_id<>? AND upload_state='done'
+       AND (? IS NULL OR recorded_at < ?) ORDER BY recorded_at DESC LIMIT 1`)
+        .get(projectId, own?.recorded_at ?? null, own?.recorded_at ?? null);
+    return typeof row?.video_id === "string" ? row.video_id : undefined;
+}

package/dist/slices/youtube/titles.js

@@ -1,6 +1,6 @@
-// A title made from a pattern with keywords ("{{Topic}} | D&D Lore To Sleep To") keeps its
+// A title made from a pattern with keywords ("{{Topic}} | Stories To Sleep To") keeps its
 // fixed wording in YouTube's title A/B test: the other titles change only what the keywords
-// stand for ("Tiamat, the Five-Headed Dragon Queen | D&D Lore To Sleep To"). A title without
+// stand for ("The Lighthouse Keeper | Stories To Sleep To"). A title without
 // keywords has nothing fixed, and its other titles are free.
 const slot = /\{\{([^{}\n]*)\}\}/g;
 // Undefined when the project kept no pattern, or the pattern has no keyword.