@gentbajko/slopify 3.7.2 → 3.8.1

package/dist/edge/http/studio.js

@@ -9,6 +9,7 @@ import { transact } from "../../kernel/db/tx.js";
 import { derive } from "../../kernel/runner/graph.js";
 import { listProjects, projectById, stagesOf } from "../../slices/admission/repo.js";
 import { channelById } from "../../slices/channels/repo.js";
+import { scheduleById, scheduleRunOfProject } from "../../slices/schedules/repo.js";
 import { readSetting, writeSetting } from "../../slices/settings/repo.js";
 import { findDownload } from "../../slices/storage/downloads.js";
 import { backfillVideos } from "../../slices/studio/backfill.js";
@@ -17,7 +18,7 @@ import { studioPlaylistMax, studioUploadUrl, } from "../../slices/studio/model.j
 import { packItem, uploadPack } from "../../slices/studio/pack.js";
 import { channelPerformance } from "../../slices/studio/performance.js";
 import { writeUploadPick } from "../../slices/studio/pick.js";
-import { postingPlanSchema, readPlan, writePlan } from "../../slices/studio/plan.js";
+import { postingPlanSchema, readPlan, readStoredPlan, weekdayIn, writePlan, } from "../../slices/studio/plan.js";
 import { leadHoursMax, seriesOf } from "../../slices/studio/plan-model.js";
 import { enqueueFill, fillOnly, readFillQueue, removeFill, } from "../../slices/studio/queue.js";
 import { allReleases, freeSlots, planReleases, readLeadHours, releasesOf, setRelease, swapReleases, writeLeadHours, } from "../../slices/studio/releases.js";
@@ -148,6 +149,18 @@ export function studioRoutes(deps) {
         title: "Unauthorized",
         detail: "The Slopify Studio extension isn't paired with this Slopify. Copy the pairing token from Slopify's Settings → YouTube Studio into the extension's options and press Pair.",
     });
+    // A project's place in the plan: its series, and the schedule and run day that made it.
+    const whoOf = (projectId, series) => {
+        const run = scheduleRunOfProject(deps.db, projectId);
+        if (run === undefined)
+            return { series };
+        const schedule = scheduleById(deps.db, run.scheduleId);
+        return {
+            series,
+            schedule: run.scheduleId,
+            runDay: weekdayIn(schedule?.timezone ?? "UTC", new Date(run.scheduledFor)),
+        };
+    };
     // 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) => {
@@ -158,12 +171,13 @@ export function studioRoutes(deps) {
             return;
         planReleases(deps.db, readPlan(deps.db), {
             id: projectId,
-            series: result.pack.series,
+            ...whoOf(projectId, result.pack.series),
             shorts: result.pack.items.filter((item) => item.kind === "short").length,
         }, deps.clock.now());
     };
+    // Settings shows only the lines saved there; each schedule shows its own.
     const planBody = () => ({
-        plan: readPlan(deps.db),
+        plan: readStoredPlan(deps.db),
         leadHours: readLeadHours(deps.db),
         series: [...new Set(listProjects(deps.db).map((project) => seriesOf(project.config)))]
             .filter((one) => one !== "")
@@ -186,7 +200,7 @@ export function studioRoutes(deps) {
                 })),
         };
     };
-    const slotChoices = (projectId, series) => freeSlots(deps.db, readPlan(deps.db), series, deps.clock.now(), 9);
+    const slotChoices = (projectId, series) => freeSlots(deps.db, readPlan(deps.db), whoOf(projectId, 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);

package/dist/kernel/db/migrations/0051-schedule-releases.sql

@@ -0,0 +1,4 @@
+-- Release times on the schedule (3.8.0): for each day the schedule runs, when the project it
+-- makes goes out on YouTube (the long video and each short, a weekday and a time in the
+-- schedule's time zone). Null: the schedule sets none.
+ALTER TABLE schedules ADD COLUMN releases_json TEXT;

package/dist/patch-notes/3.8.0.md

@@ -0,0 +1,9 @@
+# Slopify 3.8.0
+
+Released 4 October 2026.
+
+## Release times live in the schedule
+
+- **Each schedule sets its own release times.** Edit a schedule (Calendar → Schedules → Edit) and press **Set release times**: for each day it runs there is a line with the long video's weekday and time and one for every short its template makes. The number of shorts comes from the template, so there is nothing to add or remove by hand. Times are in the schedule's time zone.
+- **A project goes out on its run's line.** A project a schedule made takes the next free time of the line for the day it ran (else another of that schedule's lines), and its shorts follow it, never in the same hour as another release. Calendar → Releases shows each line under its schedule's name.
+- **Settings → YouTube Studio no longer has a posting plan editor.** It points to the schedules and keeps the upload lead time and the pinned comment. A posting plan saved there before still applies (to projects no schedule made, and when a schedule's own times are taken) until you press **Remove the old plan**. Release times already given don't change.

package/dist/patch-notes/3.8.1.md

@@ -0,0 +1,7 @@
+# Slopify 3.8.1
+
+Released 4 October 2026.
+
+- **A schedule's release times also take its series' other projects.** A project queued by hand from the schedule's topics (or any project whose title ends with the same series as the schedule's template, the part after "|") takes the schedule's release times too, not only the projects the schedule ran itself.
+- **Deleted on YouTube.** Each upload in the project's On YouTube list has a Deleted on YouTube button: press it after deleting the video in Studio, and Slopify forgets it, so the extension offers the upload again.
+- **No upload deadline to watch.** The release calendar marks each time "goes public", and a video that is ready says "Ready to upload": upload and schedule it whenever you like. Only a video still not uploaded in the last day before it goes public is flagged, "Late · upload now", since YouTube's checks may not finish in time.

package/dist/patch-notes/index.json

@@ -1,4 +1,16 @@
 [
+  {
+    "id": "3.8.1",
+    "title": "Slopify 3.8.1",
+    "version": "3.8.1",
+    "date": "2026-10-04"
+  },
+  {
+    "id": "3.8.0",
+    "title": "Slopify 3.8.0",
+    "version": "3.8.0",
+    "date": "2026-10-04"
+  },
   {
     "id": "3.7.2",
     "title": "Slopify 3.7.2",

package/dist/slices/schedules/repo.js

@@ -32,12 +32,13 @@ const rowSchema = z.object({
     topics_generated_at: z.string().nullable(),
     topics_failed_at: z.string().nullable(),
     topics_error: z.string().nullable(),
+    releases_json: z.string().nullable(),
     held_topics: z.number(),
 });
 const scheduleColumns = `id,name,template_id,template_version,cadence_json,timezone,missed_policy,
   overlap_policy,spend_limit_cents,items_json,topic_keyword,values_json,status,version,next_run_at,
   created_at,updated_at,deleted_at,brief,topic_mode,topic_min,topic_llm_json,topics_generating_at,
-  topics_generated_at,topics_failed_at,topics_error,
+  topics_generated_at,topics_failed_at,topics_error,releases_json,
   (SELECT count(*) FROM schedule_topics AS held
    WHERE held.schedule_id=schedules.id AND held.state='held') AS held_topics`;
 export function scheduleById(db, id) {
@@ -67,8 +68,9 @@ export function insertSchedule(db, schedule, creationHash) {
     db.prepare(`INSERT INTO schedules
       (id,name,template_id,template_version,cadence_json,timezone,missed_policy,overlap_policy,
        spend_limit_cents,items_json,topic_keyword,values_json,status,version,creation_hash,
-       next_run_at,created_at,updated_at,deleted_at,brief,topic_mode,topic_min,topic_llm_json)
-     VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`).run(schedule.id, schedule.name, schedule.templateId, schedule.templateVersion, JSON.stringify(schedule.cadence), schedule.timezone, schedule.missedPolicy, schedule.overlapPolicy, schedule.spendLimitCents, JSON.stringify(schedule.items), schedule.topicKeyword, JSON.stringify(schedule.values), schedule.status, schedule.version, creationHash, schedule.nextRunAt, schedule.createdAt, schedule.updatedAt, schedule.deletedAt, ...generationColumns(schedule));
+       next_run_at,created_at,updated_at,deleted_at,brief,topic_mode,topic_min,topic_llm_json,
+       releases_json)
+     VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`).run(schedule.id, schedule.name, schedule.templateId, schedule.templateVersion, JSON.stringify(schedule.cadence), schedule.timezone, schedule.missedPolicy, schedule.overlapPolicy, schedule.spendLimitCents, JSON.stringify(schedule.items), schedule.topicKeyword, JSON.stringify(schedule.values), schedule.status, schedule.version, creationHash, schedule.nextRunAt, schedule.createdAt, schedule.updatedAt, schedule.deletedAt, ...generationColumns(schedule));
 }
 function generationColumns(schedule) {
     const generation = schedule.topicGeneration;
@@ -77,6 +79,7 @@ function generationColumns(schedule) {
         generation.mode,
         generation.keepAtLeast,
         generation.llm === null ? null : JSON.stringify(generation.llm),
+        schedule.releases.length === 0 ? null : JSON.stringify(schedule.releases),
     ];
 }
 export function updateScheduleRow(db, schedule, mutationId, mutationHash, baseVersion) {
@@ -85,7 +88,8 @@ export function updateScheduleRow(db, schedule, mutationId, mutationHash, baseVe
        missed_policy=?,overlap_policy=?,spend_limit_cents=?,items_json=?,topic_keyword=?,
        values_json=?,status=?,version=?,
        next_run_at=?,updated_at=?,mutation_id=?,mutation_hash=?,
-       brief=?,topic_mode=?,topic_min=?,topic_llm_json=?,topics_failed_at=NULL,topics_error=NULL
+       brief=?,topic_mode=?,topic_min=?,topic_llm_json=?,releases_json=?,topics_failed_at=NULL,
+       topics_error=NULL
        WHERE id=? AND version=? AND deleted_at IS NULL`)
         .run(schedule.name, schedule.templateId, schedule.templateVersion, JSON.stringify(schedule.cadence), schedule.timezone, schedule.missedPolicy, schedule.overlapPolicy, schedule.spendLimitCents, JSON.stringify(schedule.items), schedule.topicKeyword, JSON.stringify(schedule.values), schedule.status, schedule.version, schedule.nextRunAt, schedule.updatedAt, mutationId, mutationHash, ...generationColumns(schedule), schedule.id, baseVersion);
     return Number(changed.changes) === 1;
@@ -300,6 +304,7 @@ function parseSchedule(row) {
             keepAtLeast: value.topic_min,
             llm: value.topic_llm_json === null ? null : JSON.parse(value.topic_llm_json),
         },
+        releases: value.releases_json === null ? [] : JSON.parse(value.releases_json),
         topics: {
             held: value.held_topics,
             generatingSince: value.topics_generating_at,
@@ -363,3 +368,15 @@ const runErrors = {
 function runErrorText(error) {
     return Object.hasOwn(runErrors, error) ? (runErrors[error] ?? error) : error;
 }
+// The schedule run that made a project, and the time it was due; undefined for a project made
+// by hand.
+export function scheduleRunOfProject(db, projectId) {
+    const row = db
+        .prepare(`SELECT schedule_runs.schedule_id, schedule_runs.scheduled_for
+       FROM schedule_runs, json_each(schedule_runs.project_ids_json) AS admitted
+       WHERE admitted.value=? ORDER BY schedule_runs.started_at DESC LIMIT 1`)
+        .get(projectId);
+    if (row === undefined)
+        return undefined;
+    return { scheduleId: String(row.schedule_id), scheduledFor: String(row.scheduled_for) };
+}

package/dist/slices/schedules/schema.js

@@ -66,6 +66,25 @@ export const topicStateIdle = {
     failedAt: null,
     error: null,
 };
+// When the project a run makes goes out on YouTube: for one day the schedule runs (`day`, 0 is
+// Sunday), the long video's weekday and time and each short's, in the schedule's time zone.
+// Each goes out the first time its day and hour come round after the one before it.
+const releaseTime = z
+    .object({
+    day: z.number().int().min(0).max(6),
+    time: z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/),
+})
+    .strict()
+    .readonly();
+export const scheduleReleaseSchema = z
+    .object({
+    day: z.number().int().min(0).max(6),
+    long: releaseTime,
+    shorts: z.array(releaseTime).max(10).readonly(),
+})
+    .strict()
+    .readonly();
+const releases = z.array(scheduleReleaseSchema).max(7).readonly();
 // Enough for a year of daily runs, pasted as one list.
 export const queueMax = 500;
 export const scheduleCreateSchema = z
@@ -92,6 +111,7 @@ export const scheduleCreateSchema = z
     // generation reads it.
     brief: z.string().trim().max(briefMax).nullable().default(null),
     topicGeneration: topicGenerationSchema.default(topicGenerationOff),
+    releases: releases.default([]),
 })
     .strict()
     .readonly();
@@ -124,6 +144,7 @@ export const scheduleSummarySchema = z
     values: values.default({}),
     brief: z.string().nullable().default(null),
     topicGeneration: topicGenerationSchema.default(topicGenerationOff),
+    releases: releases.default([]),
     // The generation's own state: how many topics wait for approval, whether an LLM is being
     // asked now, and the last failure's plain reason (cleared by the next success).
     topics: topicState.default(topicStateIdle),

package/dist/slices/schedules/service.js

@@ -216,6 +216,7 @@ function summary(input, nextRunAt, now, status = "active", version = 1, topics =
         values: input.values,
         brief: input.brief === null || input.brief === "" ? null : input.brief,
         topicGeneration: input.topicGeneration,
+        releases: input.releases,
         topics,
         status,
         version,

package/dist/slices/studio/calendar.js

@@ -17,7 +17,11 @@ export function releaseCalendar(deps, options) {
     };
     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 ?? "";
+    // A schedule's line shows the schedule's name; a stored line its series.
+    const seriesOfLine = (line) => {
+        const row = plan.rows.find((one) => one.name === line);
+        return row?.label ?? row?.series ?? "";
+    };
     const entries = longs.map((long) => {
         const project = projects.get(long.projectId);
         const pack = uploadPack(deps, long.projectId);

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

@@ -12,6 +12,14 @@ const rowSchema = z.object({
     series: z.string().trim().max(100).default(""),
     long: slotSchema,
     shorts: z.array(slotSchema).max(10),
+    // A line from a schedule's release times (never stored here): it takes that schedule's
+    // projects and any other of its template's series (`series`), preferring the ones its run day
+    // (`runDay`) made, in the schedule's time zone; the calendar shows the schedule's name
+    // (`label`).
+    schedule: z.string().optional(),
+    runDay: z.number().int().min(0).max(6).optional(),
+    timeZone: z.string().optional(),
+    label: z.string().optional(),
 });
 export const postingPlanSchema = z.object({
     timeZone: z.string().min(1).max(100),

package/dist/slices/studio/plan.js

@@ -1,12 +1,14 @@
-import { z } from "zod";
+import { templateById } from "../project-templates/repo.js";
+import { scheduleRows } from "../schedules/repo.js";
 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
+// The posting plan: a week of long-video slots, each with its shorts. Each schedule sets its
+// own (its release times, one line per day it runs, in its time zone); lines saved in Settings
+// before that are kept in the plan's 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 { postingPlanSchema, weekdays, } from "./plan-model.js";
-import { postingPlanSchema } from "./plan-model.js";
+import { postingPlanSchema, seriesOf } from "./plan-model.js";
 export const postingPlanKey = "studio.postingPlan";
 const key = postingPlanKey;
 // No plan until one is made: nothing is scheduled, and Prepare upload says so.
@@ -16,21 +18,55 @@ export function emptyPlan(timeZone) {
 export function localTimeZone() {
     return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
 }
-export function readPlan(db) {
+// The plan as stored in Settings: the lines made before schedules had release times.
+export function readStoredPlan(db) {
     const stored = readSetting(db, key);
     if (stored !== undefined)
         try {
             const parsed = postingPlanSchema.safeParse(JSON.parse(stored));
             if (parsed.success)
-                return parsed.data;
+                return {
+                    ...parsed.data,
+                    rows: parsed.data.rows.filter((row) => row.schedule === undefined),
+                };
         }
         catch {
             // A broken setting reads as no plan.
         }
     return emptyPlan(localTimeZone());
 }
+// The series of a schedule's template, from its project title ("{{Topic}} | Stories" →
+// "Stories"); "" when the template is gone or its title names none.
+function templateSeries(db, templateId) {
+    try {
+        const title = templateById(db, templateId)?.document.form.title;
+        return title === undefined ? "" : seriesOf({ title });
+    }
+    catch {
+        return "";
+    }
+}
+// The lines every release is planned from: each schedule's release times (one line for each
+// day it runs), then the stored lines.
+export function readPlan(db) {
+    const stored = readStoredPlan(db);
+    const fromSchedules = scheduleRows(db)
+        .filter((schedule) => schedule.deletedAt === null && schedule.status !== "canceled")
+        .flatMap((schedule) => schedule.releases.map((release) => ({
+        name: `s${schedule.id.slice(0, 8)}${String(release.day)}`,
+        series: templateSeries(db, schedule.templateId),
+        long: release.long,
+        shorts: [...release.shorts],
+        schedule: schedule.id,
+        runDay: release.day,
+        timeZone: schedule.timezone,
+        label: schedule.name,
+    })));
+    return { ...stored, rows: [...fromSchedules, ...stored.rows] };
+}
 export function writePlan(db, plan) {
-    writeSetting(db, key, JSON.stringify(postingPlanSchema.parse(plan)));
+    const parsed = postingPlanSchema.parse(plan);
+    writeSetting(db, key, JSON.stringify({ ...parsed, rows: parsed.rows.filter((row) => row.schedule === undefined) }));
 }
 function partsIn(timeZone, at) {
     const format = new Intl.DateTimeFormat("en-US", {
@@ -79,6 +115,10 @@ function addDays(date, days) {
         weekday: next.getUTCDay(),
     };
 }
+// The weekday (0 is Sunday) an instant falls on in the zone.
+export function weekdayIn(timeZone, at) {
+    return localDate(timeZone, at).weekday;
+}
 // The first time the slot's day and hour come round after `after`.
 export function nextOccurrence(timeZone, slot, after) {
     let date = localDate(timeZone, after);

package/dist/slices/studio/releases.js

@@ -47,27 +47,32 @@ function takenHours(db, exceptProject) {
         .filter((release) => release.projectId !== exceptProject)
         .map((release) => Math.floor(Date.parse(release.at) / hourMs)));
 }
-const fits = (line, series) => line.series === "" || line.series === series;
+// A schedule's line takes that schedule's projects and any other of its template's series (a
+// project queued by hand from its topics); a stored line takes its series, or any.
+const fits = (line, who) => line.schedule !== undefined
+    ? line.schedule === who.schedule || (line.series !== "" && line.series === who.series)
+    : line.series === "" || line.series === who.series;
+const zoneOf = (plan, line) => line.timeZone ?? plan.timeZone;
 // The plan's long-video times from `from` to `until`, in order, each with its line.
 export function lineSlots(plan, from, until) {
     return plan.rows
-        .flatMap((line) => zonedTimes(plan.timeZone, line.long, from, until).map((at) => ({
+        .flatMap((line) => zonedTimes(zoneOf(plan, line), line.long, from, until).map((at) => ({
         row: line.name,
         series: line.series,
         longAt: at.toISOString(),
     })))
         .toSorted((left, right) => Date.parse(left.longAt) - Date.parse(right.longAt));
 }
-// The coming long-video times a project of `series` may take: far enough ahead to upload in
-// time, of a line that takes its series, in an hour no other release has.
-export function freeSlots(db, plan, series, now, count, exceptProject) {
+// The coming long-video times a project may take: far enough ahead to upload in time, of a
+// line that takes it, in an hour no other release has.
+export function freeSlots(db, plan, who, now, count, exceptProject) {
     const taken = takenHours(db, exceptProject);
     const from = new Date(now.getTime() + readLeadHours(db) * hourMs);
     return lineSlots(plan, from, new Date(from.getTime() + 8 * 7 * 24 * hourMs))
         .filter((slot) => {
         const line = plan.rows.find((one) => one.name === slot.row);
         return (line !== undefined &&
-            fits(line, series) &&
+            fits(line, who) &&
             !taken.has(Math.floor(Date.parse(slot.longAt) / hourMs)));
     })
         .slice(0, count)
@@ -80,7 +85,13 @@ export function planReleases(db, plan, project, now) {
     let releases = releasesOf(db, project.id);
     let long = releases.find((release) => release.short === 0);
     if (long === undefined) {
-        const slot = freeSlots(db, plan, project.series, now, 1, project.id)[0];
+        // The line of the day its schedule ran comes first, then any line that takes it.
+        const slots = freeSlots(db, plan, project, now, 30, project.id);
+        const own = (row) => {
+            const line = plan.rows.find((one) => one.name === row);
+            return line?.schedule !== undefined && line.runDay === project.runDay;
+        };
+        const slot = slots.find((one) => own(one.row)) ?? slots[0];
         if (slot === undefined)
             return;
         long = { short: 0, at: slot.longAt, line: slot.row, by: "plan" };
@@ -98,7 +109,7 @@ export function planReleases(db, plan, project, now) {
             taken.add(Math.floor(Date.parse(release.at) / hourMs));
     const longAt = new Date(long.at);
     const times = line.shorts
-        .flatMap((slot) => zonedTimes(plan.timeZone, slot, longAt, new Date(longAt.getTime() + 5 * 7 * 24 * hourMs)))
+        .flatMap((slot) => zonedTimes(zoneOf(plan, line), slot, longAt, new Date(longAt.getTime() + 5 * 7 * 24 * hourMs)))
         .toSorted((left, right) => left.getTime() - right.getTime());
     let after = longAt.getTime();
     for (let short = 1; short <= project.shorts; short += 1) {