@gentbajko/slopify 3.8.0 → 3.8.2

package/dist/edge/http/studio.js

@@ -162,17 +162,19 @@ export function studioRoutes(deps) {
         };
     };
     // 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.
+    // prepared (`releases.ts`).
+    // A long video already on YouTube keeps when it went up; its shorts still get times.
     const planned = (projectId) => {
-        if (videoOf(deps.db, projectId, null)?.uploadState === "done")
-            return;
+        const long = videoOf(deps.db, projectId, null);
+        const out = long?.uploadState === "done" ? long.recordedAt : undefined;
         const result = uploadPack(deps, projectId);
-        if (!result.ok || result.pack.items[0]?.video == null)
+        if (!result.ok || (out === undefined && result.pack.items[0]?.video == null))
             return;
         planReleases(deps.db, readPlan(deps.db), {
             id: projectId,
             ...whoOf(projectId, result.pack.series),
             shorts: result.pack.items.filter((item) => item.kind === "short").length,
+            ...(out === undefined ? {} : { longOut: out }),
         }, deps.clock.now());
     };
     // Settings shows only the lines saved there; each schedule shows its own.

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/3.8.2.md

@@ -0,0 +1,6 @@
+# Slopify 3.8.2
+
+Released 4 October 2026.
+
+- **Shorts of a video already on YouTube get release times.** A project whose long video went up before it had a release time left its shorts with none, so the Studio extension had no schedule to type in. Now the long video keeps the time it went up as its release, and its shorts take the release line's short times from the upload lead on (never due sooner than you could upload them).
+- **A narration chunk recorded again by itself no longer gets stuck.** When the voice garbled words, Slopify promised to record the chunk again and carry on, but if the project's last other step was just finishing, the retry waited for a step that never came, and the video stayed failed. It now looks again every 15 seconds until the project is free.

package/dist/patch-notes/index.json

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

package/dist/slices/rebuild/narration-retry.js

@@ -61,6 +61,13 @@ export function createNarrationRetries() {
                 continue;
             running.add(id);
             void recordAgain(deps, retry)
+                .then((waiting) => {
+                // The step that just finished may still count as running when it kicks this (the
+                // runner lets go of it after its `onFinished`), and nothing else finishes to kick
+                // again: look again shortly until the project is free.
+                if (waiting)
+                    setTimeout(() => kick(retry.projectId), retryWaitMs).unref?.();
+            })
                 .catch((error) => {
                 deps.log.write("error", "narration.retry", {
                     projectId: retry.projectId,
@@ -86,11 +93,16 @@ export function createNarrationRetries() {
         kick,
     };
 }
+// How long a retry waiting for the project's other steps waits before it looks again.
+export const retryWaitMs = 15_000;
+// The waits already logged, so looking again doesn't log the same line every 15 seconds.
+const told = new Set();
+// True when the project's other steps are still going and the retry waits for them.
 async function recordAgain(deps, retry) {
     const base = currentRevisionId(deps.db, retry.projectId);
     if (base === undefined) {
         settle(deps.db, retry, "failed", "no project", deps.clock.now().toISOString());
-        return;
+        return false;
     }
     const result = await recoverProject(deps, retry.projectId, {
         baseRevisionId: base,
@@ -106,6 +118,10 @@ async function recordAgain(deps, retry) {
         });
     }
     else if (result.reason === "running") {
+        const key = retryKey(retry);
+        if (told.has(key))
+            return true;
+        told.add(key);
         // Another step of the project is still going (its PDF, say): the retry waits for it and
         // starts when that step finishes, which kicks this again (`onFinished`). Giving up here
         // left the video failed with a message promising a retry that never came.
@@ -113,7 +129,7 @@ async function recordAgain(deps, retry) {
             projectId: retry.projectId,
             detail: `Recording ${retry.chunkKey} again once the project's running steps finish.`,
         });
-        return;
+        return true;
     }
     else {
         settle(deps.db, retry, "failed", refusal(result), now);
@@ -123,6 +139,7 @@ async function recordAgain(deps, retry) {
         });
     }
     deps.emit(retry.projectId, { type: "project.updated", projectId: retry.projectId });
+    return false;
 }
 function refusal(result) {
     const detail = result.fields?.map((field) => field.message).join(" ");

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

@@ -12,9 +12,10 @@ 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 only that schedule's
-    // projects, preferring the ones its run day (`runDay`) made, in the schedule's time zone, and
-    // the calendar shows the schedule's name (`label`).
+    // 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(),

package/dist/slices/studio/plan.js

@@ -1,3 +1,4 @@
+import { templateById } from "../project-templates/repo.js";
 import { scheduleRows } from "../schedules/repo.js";
 import { readSetting, writeSetting } from "../settings/repo.js";
 // The posting plan: a week of long-video slots, each with its shorts. Each schedule sets its
@@ -7,7 +8,7 @@ import { readSetting, writeSetting } from "../settings/repo.js";
 // 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.
@@ -34,6 +35,17 @@ export function readStoredPlan(db) {
         }
     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) {
@@ -42,7 +54,7 @@ export function readPlan(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: "",
+        series: templateSeries(db, schedule.templateId),
         long: release.long,
         shorts: [...release.shorts],
         schedule: schedule.id,

package/dist/slices/studio/releases.js

@@ -47,9 +47,10 @@ function takenHours(db, exceptProject) {
         .filter((release) => release.projectId !== exceptProject)
         .map((release) => Math.floor(Date.parse(release.at) / hourMs)));
 }
-// A schedule's line takes only that schedule's projects; a stored line takes its series (or any).
+// 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.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.
@@ -83,6 +84,14 @@ export function freeSlots(db, plan, who, now, count, exceptProject) {
 export function planReleases(db, plan, project, now) {
     let releases = releasesOf(db, project.id);
     let long = releases.find((release) => release.short === 0);
+    if (long === undefined && project.longOut !== undefined) {
+        const line = plan.rows.find((one) => one.schedule !== undefined && fits(one, project) && one.runDay === project.runDay) ?? plan.rows.find((one) => fits(one, project));
+        if (line === undefined)
+            return;
+        long = { short: 0, at: project.longOut, line: line.name, by: "plan" };
+        write(db, project.id, long, now);
+        releases = releasesOf(db, project.id);
+    }
     if (long === undefined) {
         // 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);
@@ -107,10 +116,12 @@ export function planReleases(db, plan, project, now) {
         if (release.at !== "")
             taken.add(Math.floor(Date.parse(release.at) / hourMs));
     const longAt = new Date(long.at);
+    // A short is never due before it could be uploaded in time.
+    const start = Math.max(longAt.getTime(), now.getTime() + readLeadHours(db) * hourMs);
     const times = line.shorts
-        .flatMap((slot) => zonedTimes(zoneOf(plan, line), slot, longAt, new Date(longAt.getTime() + 5 * 7 * 24 * hourMs)))
+        .flatMap((slot) => zonedTimes(zoneOf(plan, line), slot, new Date(start), new Date(start + 5 * 7 * 24 * hourMs)))
         .toSorted((left, right) => left.getTime() - right.getTime());
-    let after = longAt.getTime();
+    let after = start;
     for (let short = 1; short <= project.shorts; short += 1) {
         const kept = releases.find((release) => release.short === short);
         if (kept !== undefined) {