@gentbajko/slopify 3.3.1 → 3.4.0

package/dist/edge/http/studio.js

@@ -10,14 +10,17 @@ import { channelById } from "../../slices/channels/repo.js";
 import { readSetting, writeSetting } from "../../slices/settings/repo.js";
 import { findDownload } from "../../slices/storage/downloads.js";
 import { backfillVideos } from "../../slices/studio/backfill.js";
+import { releaseCalendar } from "../../slices/studio/calendar.js";
 import { studioPlaylistMax, studioUploadUrl, } from "../../slices/studio/model.js";
 import { packItem, uploadPack } from "../../slices/studio/pack.js";
 import { writeUploadPick } from "../../slices/studio/pick.js";
-import { assignedSlot, freeSlots, postingPlanSchema, readPlan, setSlot, unschedule, writePlan, } from "../../slices/studio/plan.js";
+import { postingPlanSchema, readPlan, writePlan } from "../../slices/studio/plan.js";
+import { leadHoursMax, seriesOf } from "../../slices/studio/plan-model.js";
 import { enqueueFill, fillNow, readFillQueue, removeFill, } from "../../slices/studio/queue.js";
+import { allReleases, freeSlots, planReleases, readLeadHours, releasesOf, setRelease, writeLeadHours, } from "../../slices/studio/releases.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 { confirmUpload, doneVideos, forgetVideo, projectVideos, recordVideo, setChecks, 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
@@ -87,8 +90,13 @@ const statsBody = z.object({
 });
 const backfillBody = z.object({
     videos: z
-        .array(z.object({ title: z.string().max(200), videoId: z.string().regex(videoIdPattern) }))
+        .array(z.object({
+        title: z.string().max(200),
+        videoId: z.string().regex(videoIdPattern),
+        checks: z.string().max(100).optional(),
+    }))
         .max(200),
+    close: z.boolean().optional(),
 });
 // The extension builds the app ships (`scripts/copy-extension.mjs`), by browser.
 const extensionFiles = {
@@ -136,17 +144,39 @@ 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.",
     });
-    // 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.
+    // A project ready to upload gets its release times from the posting plan when its upload is
+    // prepared (`releases.ts`); one whose long video is on YouTube already keeps what it has.
     const planned = (projectId) => {
         if (videoOf(deps.db, projectId, null)?.uploadState === "done")
             return;
         const result = uploadPack(deps, projectId);
         if (!result.ok || result.pack.items[0]?.video == null)
             return;
-        assignedSlot(deps.db, readPlan(deps.db), projectId, deps.clock.now());
+        planReleases(deps.db, readPlan(deps.db), {
+            id: projectId,
+            series: result.pack.series,
+            shorts: result.pack.items.filter((item) => item.kind === "short").length,
+        }, deps.clock.now());
+    };
+    const planBody = () => ({
+        plan: readPlan(deps.db),
+        leadHours: readLeadHours(deps.db),
+        series: [...new Set(listProjects(deps.db).map((project) => seriesOf(project.config)))]
+            .filter((one) => one !== "")
+            .toSorted(),
+    });
+    const slotChoices = (projectId, series) => freeSlots(deps.db, readPlan(deps.db), series, deps.clock.now(), 9);
+    // Finished projects not marked uploaded: the popup's list and the calendar's candidates.
+    const finishedProjects = () => {
+        const uploads = uploadedProjects(deps.db);
+        const aside = setAsideProjects(deps.db);
+        return listProjects(deps.db).filter((project) => {
+            if (uploads.has(project.id))
+                return false;
+            const state = derive(stagesOf(deps.db, project.id), project.paused === true);
+            return (state === "done" || state === "partial" || (state === "pending" && aside.has(project.id)));
+        });
     };
-    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) => {
@@ -169,18 +199,61 @@ export function studioRoutes(deps) {
         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) });
-    })
+        // The posting plan, its lead time, and the series the projects use (for the lines' picker).
+        .get("/plan", (c) => c.json(planBody()))
         .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) });
+        return c.json(planBody());
+    })
+        .put("/settings/lead-hours", zValidator("json", z.object({ hours: z.number().int().min(1).max(leadHoursMax) }).strict(), onInvalid), (c) => {
+        const denied = samePage(c);
+        if (denied !== undefined)
+            return denied;
+        writeLeadHours(deps.db, c.req.valid("json").hours);
+        return c.json(planBody());
+    })
+        // Calendar → Releases: the coming weeks' long videos and shorts with their times and
+        // states, the plan's free times, and the finished projects that could fill them.
+        .get("/releases", zValidator("query", z.object({ weeks: z.coerce.number().int().min(1).max(8).optional() })), (c) => {
+        const denied = samePage(c);
+        if (denied !== undefined)
+            return denied;
+        const finished = finishedProjects();
+        // Every finished project gets its times, and so does any project already holding a
+        // release (its shorts may still need theirs).
+        for (const id of new Set([
+            ...finished.map((project) => project.id),
+            ...allReleases(deps.db).map((release) => release.projectId),
+        ]))
+            planned(id);
+        return c.json(releaseCalendar(deps, {
+            now: deps.clock.now(),
+            weeks: c.req.valid("query").weeks ?? 2,
+            candidates: finished.map((project) => project.id),
+        }));
+    })
+        // Moves one release (a time), sets it to "not scheduled" (null), or puts a project into a
+        // free time of the plan (short 0 with its line).
+        .put("/releases/:projectId", zValidator("param", projectParam, onInvalid), zValidator("json", z
+        .object({
+        short: z.number().int().min(0).max(99),
+        at: z.iso.datetime().nullable(),
+        line: z.string().min(1).max(20).optional(),
+    })
+        .strict(), onInvalid), (c) => {
+        const denied = samePage(c);
+        if (denied !== undefined)
+            return denied;
+        const { projectId } = c.req.valid("param");
+        if (uploadPack(deps, projectId).ok === false)
+            return unknownProject(c);
+        const { short, at, line } = c.req.valid("json");
+        setRelease(deps.db, projectId, short, at ?? "", line ?? null, deps.clock.now());
+        planned(projectId);
+        return c.json({ releases: releasesOf(deps.db, projectId) });
     })
         .put("/settings/playlists", zValidator("json", playlistsBody, onInvalid), (c) => {
         const denied = samePage(c);
@@ -218,7 +291,7 @@ export function studioRoutes(deps) {
         const result = uploadPack(deps, projectId);
         if (!result.ok)
             return unknownProject(c);
-        return c.json({ ...result.pack, slotChoices: slotChoices() });
+        return c.json({ ...result.pack, slotChoices: slotChoices(projectId, result.pack.series) });
     })
         // 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) => {
@@ -227,21 +300,25 @@ export function studioRoutes(deps) {
             return denied;
         const { projectId } = c.req.valid("param");
         const wanted = c.req.valid("json").slot;
+        const before = uploadPack(deps, projectId);
+        if (!before.ok)
+            return unknownProject(c);
         if (wanted === null)
-            unschedule(deps.db, projectId, deps.clock.now());
+            setRelease(deps.db, projectId, 0, "", null, deps.clock.now());
         else {
-            const free = slotChoices().some((one) => one.row === wanted.row && one.longAt === wanted.longAt);
+            const free = slotChoices(projectId, before.pack.series).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());
+            setRelease(deps.db, projectId, 0, wanted.longAt, wanted.row, deps.clock.now());
         }
+        planned(projectId);
         const result = uploadPack(deps, projectId);
         return result.ok
-            ? c.json({ ...result.pack, slotChoices: slotChoices() })
+            ? c.json({ ...result.pack, slotChoices: slotChoices(projectId, result.pack.series) })
             : unknownProject(c);
     })
         // Prepare upload's AI use tick: the project's uploaded clips are real footage.
@@ -427,7 +504,11 @@ export function studioRoutes(deps) {
         allowOrigin(c, false);
         if (!extAllowed(c))
             return refused(c);
-        const found = backfillVideos(deps, c.req.valid("json").videos, deps.clock.now().toISOString());
+        const { videos } = c.req.valid("json");
+        const found = backfillVideos(deps, videos, deps.clock.now().toISOString());
+        for (const video of videos)
+            if (video.checks !== undefined)
+                setChecks(deps.db, video.videoId, video.checks);
         return c.json({ found });
     })
         // The extension popup: finished projects not marked uploaded, each with its video and
@@ -436,17 +517,7 @@ export function studioRoutes(deps) {
         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 [];
+        const projects = finishedProjects().flatMap((project) => {
             planned(project.id);
             const result = uploadPack(deps, project.id);
             if (!result.ok || result.pack.items[0]?.video == null)
@@ -465,7 +536,13 @@ export function studioRoutes(deps) {
                         ...(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 }),
+                        ...(item.scheduleAt === undefined
+                            ? {}
+                            : {
+                                scheduleAt: item.scheduleAt,
+                                // When it must be scheduled by, so the checks finish before release.
+                                uploadBy: new Date(Date.parse(item.scheduleAt) - readLeadHours(deps.db) * 3_600_000).toISOString(),
+                            }),
                     })),
                 },
             ];
@@ -530,9 +607,19 @@ export function studioRoutes(deps) {
                 ? []
                 : [{ projectId: video.projectId, short: video.short, videoId: video.videoId, item }];
         });
+        // A video on YouTube, due in the coming weeks, whose checks Studio hasn't cleared (or
+        // the extension hasn't read): the extension reads the Content list for them.
+        const soon = deps.clock.now().getTime();
+        const checks = doneVideos(deps.db).some((video) => {
+            if (video.checks === "ok")
+                return false;
+            const at = releasesOf(deps.db, video.projectId).find((release) => release.short === (video.short ?? 0))?.at;
+            return at !== undefined && at !== "" && Date.parse(at) > soon;
+        });
         return c.json({
             finish: withItems(waitingTasks(deps.db, "finish")),
             comments: withItems(waitingTasks(deps.db, "comment")),
+            checks,
         });
     })
         .post("/ext/task-result", zValidator("json", taskResultBody, onInvalid), (c) => {

package/dist/kernel/db/migrations/0048-releases.sql

@@ -0,0 +1,20 @@
+-- Release calendar (3.4.0): one release time for each long video and each short, in place of
+-- one posting-plan slot per project. short 0 is the long video. release_at '' is "not
+-- scheduled". line is the posting-plan line the time came from (null when picked by hand);
+-- by says whether the plan or the person set it, so moving a long video re-plans only the
+-- shorts the plan placed.
+CREATE TABLE releases (
+  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  short INTEGER NOT NULL CHECK (short >= 0),
+  release_at TEXT NOT NULL,
+  line TEXT,
+  by TEXT NOT NULL DEFAULT 'plan' CHECK (by IN ('plan', 'person')),
+  set_at TEXT NOT NULL,
+  PRIMARY KEY (project_id, short)
+);
+INSERT INTO releases (project_id, short, release_at, line, by, set_at)
+  SELECT project_id, 0, long_at, NULLIF(row_name, ''), 'plan', assigned_at FROM upload_slots;
+DROP TABLE upload_slots;
+-- What Studio's Content list says about a video's checks (copyright, ad suitability), as the
+-- extension last read it: null until read.
+ALTER TABLE youtube_videos ADD COLUMN checks TEXT;

package/dist/patch-notes/3.4.0.md

@@ -0,0 +1,28 @@
+# Slopify 3.4.0
+
+Released 2 October 2026.
+
+## Calendar → Releases
+
+- **Every video and every short has its own release time**, shown week by week in Calendar → **Releases**: the long video on one line, its shorts beside it, each with the time it must be uploaded and scheduled by.
+- **Upload in time for the checks.** Each item is due a set number of hours before its release (24 by default; change it in Settings → YouTube Studio), so YouTube's copyright and ad checks finish while it is still private. An item past that time and not on YouTube shows **Late**.
+- **See where each one stands:** not rendered, upload by…, filled in Studio but not scheduled, or scheduled, with **checks clear** once Studio's Content list shows no restrictions.
+- **Move anything.** Click a time to change it; a long video can also be set to not scheduled. A free time of your plan offers the finished projects that fit it: pick one and press **Put it here**.
+
+## Posting plan
+
+- **Starts empty.** Nothing is scheduled until you add a long video in Settings → YouTube Studio → Posting plan.
+- **No more A, B, C.** One line per long video, each with its own day and time and as many shorts as you post for it (**+ Short**, and × to remove one).
+- **Series.** Each line can take any project or only one series, read from the project's titles (the part after "|"), so a week of three of one series and one of another fills itself the right way.
+- **Shorts never share an hour** with another release; one that would takes the next time of its line.
+
+## YouTube Studio extension (1.1.0)
+
+- **Upload all shorts, one at a time.** The next short opens only after the previous file has fully uploaded, so leaving the page can't stop an upload.
+- **The popup lists what's due first**, with each upload's "by" time, or **late**.
+- **Reads the checks.** While a scheduled video's checks aren't clear, the extension reads Studio's Content list in the background every two hours.
+
+## Upgrading from 3.3.1
+
+- **Your plan and your projects' times carry over.** A project that already had a slot keeps it; its shorts get their times the first time you open Calendar → Releases.
+- **Update the extension** (Settings → YouTube Studio → Download, then reload it in `chrome://extensions`), or let the Chrome Web Store update it once version 1.1.0 is approved.

package/dist/patch-notes/index.json

@@ -1,4 +1,10 @@
 [
+  {
+    "id": "3.4.0",
+    "title": "Slopify 3.4.0",
+    "version": "3.4.0",
+    "date": "2026-10-02"
+  },
   {
     "id": "3.3.1",
     "title": "Slopify 3.3.1",

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

@@ -57,8 +57,9 @@ 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",
+    // Since 3.3.0: Studio's numbers and its A/B results; since 3.4.0 each release time
+    // (`releases`, which took the place of 3.3's `upload_slots`: see `fromUploadSlots`).
+    "releases",
     "video_stats",
     "ab_results",
     // Since 2.5.0. Left out on purpose: plan_limit_waits and plan_limit_waiters (an account's
@@ -183,13 +184,43 @@ export const libraryPartSchema = z
 })
     .strict();
 export const usagePartSchema = z.object({ tables: tablesOf(usageTables) }).strict();
+// A 3.3 backup keeps each project's posting-plan slot in `upload_slots`; it is read as the
+// long video's release, as migration 0048 does with the table itself.
+function fromUploadSlots(value) {
+    if (typeof value !== "object" || value === null)
+        return value;
+    const tables = value.tables;
+    if (typeof tables !== "object" || tables === null || !("upload_slots" in tables))
+        return value;
+    const { upload_slots: slots, ...rest } = tables;
+    const releases = Array.isArray(slots)
+        ? slots.map((slot) => ({
+            project_id: slot.project_id ?? null,
+            short: 0,
+            release_at: slot.long_at ?? "",
+            line: slot.row_name === "" || slot.row_name === undefined ? null : slot.row_name,
+            by: "plan",
+            set_at: slot.assigned_at ?? "",
+        }))
+        : slots;
+    return {
+        ...value,
+        tables: {
+            ...rest,
+            ...(releases === undefined || (Array.isArray(releases) && releases.length === 0)
+                ? {}
+                : { releases }),
+        },
+    };
+}
 export const projectPartSchema = z
+    .preprocess(fromUploadSlots, z
     .object({
     id: backupId,
     tables: tablesOf(projectTables),
     files: z.array(fileEntry).max(maxFilesPerProject),
 })
-    .strict()
+    .strict())
     .refine((part) => part.tables.projects?.length === 1 && part.tables.projects[0]?.id === part.id, "A project part must hold exactly its own project row.");
 export const checksumsSchema = z
     .object({

package/dist/slices/storage/portable.js

@@ -25,6 +25,8 @@ import { realPersonVoicesKey, voiceIdMax, voiceNameMax } from "../settings/voice
 import { whatsNewSeenKey } from "../settings/whats-new.js";
 import { uploadPickPrefix, uploadPickSchema } from "../studio/pick.js";
 import { postingPlanKey, postingPlanSchema } from "../studio/plan.js";
+import { leadHoursMax } from "../studio/plan-model.js";
+import { leadHoursKey } from "../studio/releases.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";
@@ -397,6 +399,8 @@ function portableSettings(settings) {
             storedPlaylistsSchema.parse(parsed);
         else if (key === postingPlanKey)
             postingPlanSchema.parse(parsed);
+        else if (key === leadHoursKey)
+            z.number().int().min(1).max(leadHoursMax).parse(parsed);
         else if (key.startsWith(uploadPickPrefix))
             uploadPickSchema.parse(parsed);
         else if (key === studioProjectPlaylistsKey)

package/dist/slices/studio/backfill.js

@@ -1,6 +1,5 @@
 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) {
@@ -24,9 +23,6 @@ export function backfillVideos(deps, rows, at) {
             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;
         }
     }

package/dist/slices/studio/calendar.js

@@ -0,0 +1,85 @@
+import { listProjects } from "../admission/repo.js";
+import { uploadPack } from "./pack.js";
+import { readPlan } from "./plan.js";
+import { seriesOf } from "./plan-model.js";
+import { allReleases, lineSlots, readLeadHours, releasesOf } from "./releases.js";
+import { videoOf } from "./videos.js";
+const hourMs = 60 * 60 * 1000;
+export function releaseCalendar(deps, options) {
+    const { now } = options;
+    const plan = readPlan(deps.db);
+    const leadMs = readLeadHours(deps.db) * hourMs;
+    const from = new Date(now.getTime() - 24 * hourMs);
+    const until = new Date(now.getTime() + options.weeks * 7 * 24 * hourMs);
+    const inWindow = (iso) => {
+        const at = Date.parse(iso);
+        return at >= from.getTime() && at < until.getTime();
+    };
+    const projects = new Map(listProjects(deps.db).map((project) => [project.id, project]));
+    const longs = allReleases(deps.db).filter((release) => release.short === 0 && projects.has(release.projectId) && inWindow(release.at));
+    const seriesOfLine = (line) => plan.rows.find((row) => row.name === line)?.series ?? "";
+    const entries = longs.map((long) => {
+        const project = projects.get(long.projectId);
+        const pack = uploadPack(deps, long.projectId);
+        const releases = releasesOf(deps.db, long.projectId);
+        const items = pack.ok ? pack.pack.items : [];
+        return {
+            at: long.at,
+            line: long.line,
+            series: project === undefined ? "" : seriesOf(project.config),
+            project: { id: long.projectId, title: project?.title ?? "" },
+            items: items.map((item) => {
+                const short = item.short ?? 0;
+                const at = releases.find((release) => release.short === short)?.at;
+                const release = at === undefined || at === "" ? null : at;
+                const uploadBy = release === null ? null : new Date(Date.parse(release) - leadMs);
+                const video = videoOf(deps.db, long.projectId, item.short ?? null);
+                const state = video?.uploadState === "done"
+                    ? "scheduled"
+                    : video?.uploadState === "filled"
+                        ? "filled"
+                        : item.video === null
+                            ? "not-ready"
+                            : uploadBy !== null && now.getTime() > uploadBy.getTime()
+                                ? "late"
+                                : "ready";
+                return {
+                    short,
+                    title: item.title,
+                    at: release,
+                    uploadBy: uploadBy?.toISOString() ?? null,
+                    state,
+                    checks: video?.checks ?? null,
+                    videoId: video?.videoId ?? null,
+                };
+            }),
+        };
+    });
+    // The plan's long-video times no project holds (the hour is free), from now on.
+    const takenHours = new Set(allReleases(deps.db).map((release) => Math.floor(Date.parse(release.at) / hourMs)));
+    for (const slot of lineSlots(plan, now, until))
+        if (!takenHours.has(Math.floor(Date.parse(slot.longAt) / hourMs)))
+            entries.push({
+                at: slot.longAt,
+                line: slot.row,
+                series: seriesOfLine(slot.row),
+                project: null,
+                items: [],
+            });
+    const scheduled = new Set(allReleases(deps.db)
+        .filter((release) => release.short === 0)
+        .map((release) => release.projectId));
+    return {
+        leadHours: readLeadHours(deps.db),
+        timeZone: plan.timeZone,
+        from: from.toISOString(),
+        until: until.toISOString(),
+        entries: entries.toSorted((left, right) => Date.parse(left.at) - Date.parse(right.at)),
+        candidates: options.candidates.flatMap((id) => {
+            const project = projects.get(id);
+            if (project === undefined || scheduled.has(id))
+                return [];
+            return [{ id, title: project.title, series: seriesOf(project.config) }];
+        }),
+    };
+}

package/dist/slices/studio/pack.js

@@ -19,7 +19,8 @@ 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 { seriesOf } from "./plan-model.js";
+import { scheduleOf } from "./releases.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.
@@ -129,15 +130,9 @@ 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) });
+    // When each upload goes out, from the release calendar (`releases.ts`): the long video's
+    // release and each short's, once the project has them.
+    const schedule = scheduleOf(deps.db, projectId);
     // 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.
@@ -209,9 +204,7 @@ export function uploadPack(deps, projectId) {
             alteredContent: disclosure("short"),
             playlists,
             playlist,
-            ...(schedule?.shortsAt[clip.number - 1] === undefined
-                ? {}
-                : { scheduleAt: schedule.shortsAt[clip.number - 1] }),
+            ...((at) => (at == null ? {} : { scheduleAt: at }))(schedule?.shortsAt[clip.number - 1]),
             ...(longVideo?.uploadState === "done" ? { relatedVideoId: longVideo.videoId } : {}),
         });
     }
@@ -220,6 +213,7 @@ export function uploadPack(deps, projectId) {
         pack: {
             projectId,
             projectTitle: project.title,
+            series: seriesOf(config),
             items,
             ...(schedule === undefined ? {} : { schedule }),
             missing,

package/dist/slices/studio/plan-model.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+// The posting plan's shapes, with nothing from the server, so the web app can import them.
+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({
+    // An inner id, never shown: a release keeps the line it came from.
+    name: z.string().trim().min(1).max(20),
+    // Which projects the line takes: "" takes any, else only a project of that series.
+    series: z.string().trim().max(100).default(""),
+    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),
+});
+// How long before its release a video must be uploaded and scheduled, so YouTube's copyright
+// and ad-suitability checks finish while it is still private.
+export const leadHoursDefault = 24;
+export const leadHoursMax = 168;
+// A project's series: what its titles keep after the topic, read from the title pattern (else
+// the title) after its last "|": "{{Topic}} | Stories To Sleep To" → "Stories To Sleep To".
+// A title without one has no series and fits only a line that takes any.
+export function seriesOf(config) {
+    const source = config.titlePattern ?? config.title;
+    const at = source.lastIndexOf("|");
+    if (at < 0)
+        return "";
+    return source
+        .slice(at + 1)
+        .replace(/\{\{[^{}]*\}\}/g, "")
+        .replace(/\s+/g, " ")
+        .trim();
+}