@gentbajko/slopify 3.8.1 → 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.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,10 @@
 [
+  {
+    "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",

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/releases.js

@@ -84,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);
@@ -108,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) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gentbajko/slopify",
-  "version": "3.8.1",
+  "version": "3.8.2",
   "description": "Turn a prompt into a finished video, locally, with your own provider keys",
   "license": "Apache-2.0",
   "author": "Gent Bajko",