@gentbajko/slopify 3.8.1 → 3.8.3

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

@@ -0,0 +1,5 @@
+# Slopify 3.8.3
+
+Released 4 October 2026.
+
+- **A narration chunk Slopify records again by itself really does get recorded.** If its first try found the project busy, Slopify kept "busy" as that try's answer and gave it back every time after, even across restarts, so the video stayed failed and the update waited on it forever. A busy answer is no longer kept: the next look asks again and records the chunk. Retries stuck this way before the update start on their own once it is installed.

package/dist/patch-notes/index.json

@@ -1,4 +1,16 @@
 [
+  {
+    "id": "3.8.3",
+    "title": "Slopify 3.8.3",
+    "version": "3.8.3",
+    "date": "2026-10-04"
+  },
+  {
+    "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/rebuild/recovery-repo.js

@@ -37,8 +37,16 @@ export function readRecovery(deps, projectId, input) {
     const row = rowSchema.parse(raw);
     if (row.request_hash !== requestHash("direct-recovery", input.baseRevisionId, input.action))
         return { ok: false, reason: "idempotency-conflict" };
-    if (row.response_json !== null)
-        return recoveryResultSchema.parse(JSON.parse(row.response_json));
+    if (row.response_json !== null) {
+        const saved = recoveryResultSchema.parse(JSON.parse(row.response_json));
+        // "Busy" was the moment's answer, not the request's outcome: one kept from before this was
+        // forgotten is dropped, so the same request asks again instead of replaying it forever.
+        if (busy(saved)) {
+            forget(deps, projectId, input);
+            return undefined;
+        }
+        return saved;
+    }
     return {
         pending: true,
         authority: row.authority_stamp,
@@ -57,11 +65,24 @@ export function reserveRecovery(deps, projectId, input, edit) {
 }
 export function rememberRecovery(deps, projectId, input, result) {
     const response = recoveryResultSchema.parse(result);
+    // Refused because the project was busy: nothing was done, so the same request may come again
+    // (an automatic narration retry keeps its request id) and must be tried again, not replayed.
+    if (busy(response)) {
+        forget(deps, projectId, input);
+        return response;
+    }
     deps.db
         .prepare("UPDATE project_recovery_requests SET response_json=? WHERE project_id=? AND idempotency_key=?")
         .run(JSON.stringify(response), projectId, input.idempotencyKey);
     return response;
 }
+// Busy before anything was saved (a refusal after the revision was saved keeps its answer).
+const busy = (result) => !result.ok && result.reason === "running" && result.intentRevisionId === undefined;
+function forget(deps, projectId, input) {
+    deps.db
+        .prepare("DELETE FROM project_recovery_requests WHERE project_id=? AND idempotency_key=?")
+        .run(projectId, input.idempotencyKey);
+}
 // The head has unfinished stages but nothing that will move them on its own: no call in
 // flight and no admitted, dispatchable work. A saved rerun or edit is admitted by no one
 // until Resume, and work held by a pause, a restart or a failed sibling of its admission

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.3",
   "description": "Turn a prompt into a finished video, locally, with your own provider keys",
   "license": "Apache-2.0",
   "author": "Gent Bajko",