@gentbajko/slopify 3.13.0 → 3.13.2

package/dist/edge/http/projects.js

@@ -17,7 +17,7 @@ import { limitWaitsByProject, listingWait } from "../../slices/run-cost/panel.js
 import { outputsOf } from "../../slices/storage/repo.js";
 import { longVideoStats } from "../../slices/studio/stats.js";
 import { trashProject } from "../../slices/trash/service.js";
-import { setAsideProjects, uploadedProjects } from "../../slices/uploads/repo.js";
+import { setAsideProjects, uploadedAndSettled, uploadedProjects, } from "../../slices/uploads/repo.js";
 import { onInvalid, problem, titleOf } from "./problem.js";
 import { createProject } from "./project-create.js";
 const idParam = z.object({
@@ -37,9 +37,11 @@ export function projectRoutes(deps) {
         log: deps.log,
         hasInflight: deps.runner.hasInflight,
     };
+    // An uploaded project with nothing admitted reads as done (`uploadedAndSettled`).
+    const statusOf = (status, settled) => settled && (status === "paused" || status === "pending") ? "done" : status;
     const summarise = (project) => ({
         ...project,
-        status: derive(stagesOf(deps.db, project.id), project.paused),
+        status: statusOf(derive(stagesOf(deps.db, project.id), project.paused), uploadedAndSettled(deps.db).has(project.id)),
     });
     return (new Hono()
         .post("/", zValidator("json", runDraftSchema, onInvalid), async (c) => {
@@ -65,6 +67,7 @@ export function projectRoutes(deps) {
         const channels = projectChannels(deps.db);
         const uploads = uploadedProjects(deps.db);
         const aside = setAsideProjects(deps.db);
+        const settled = uploadedAndSettled(deps.db);
         const numbers = longVideoStats(deps.db);
         const waits = limitWaitsByProject(deps.db);
         const projects = listProjectHeads(deps.db).map((project) => {
@@ -72,7 +75,7 @@ export function projectRoutes(deps) {
             const waiting = waits.get(project.id);
             return {
                 ...project,
-                status: derive(stages, project.paused),
+                status: statusOf(derive(stages, project.paused), settled.has(project.id)),
                 progress: progressOf(stages),
                 channelId: channels.get(project.id) ?? defaultChannelId,
                 uploadedAt: uploads.get(project.id) ?? null,

package/dist/kernel/remembered.js

@@ -0,0 +1,23 @@
+// The planner rebuilds a project's whole plan several times a runner tick, on the server's one
+// thread, and each rebuild ran the same pure text work again over the full narration: matching
+// the pronunciation glossary, cutting chunks, parsing the glossary. On a 2-hour narration that
+// held the thread for seconds at a time, so the app stopped answering while a project ran.
+// A pure function's last few results, by its exact input. Not a service: nothing is injected or
+// shared but answers the function would give anyway. Results are frozen data, never mutated.
+export function remembered(size, keyOf, work) {
+    const results = new Map();
+    return (...args) => {
+        const key = keyOf(...args);
+        const known = results.get(key);
+        if (known !== undefined || results.has(key)) {
+            results.delete(key);
+            results.set(key, known);
+            return known;
+        }
+        const value = work(...args);
+        results.set(key, value);
+        if (results.size > size)
+            results.delete(results.keys().next().value);
+        return value;
+    };
+}

package/dist/main.js

@@ -62,7 +62,7 @@ import { waitToRetry, wakeRetries } from "./slices/rebuild/retry.js";
 import { createReviewRedos, reviewHold } from "./slices/rebuild/review-redo.js";
 import { materializeAdmittedWork } from "./slices/rebuild/runtime-materialize.js";
 import { runRevisionInvocation } from "./slices/rebuild/runtime-run.js";
-import { executionStages, executionStandings, invocationReady, projectStandings, recordWorkProgress, } from "./slices/rebuild/runtime-store.js";
+import { executionStandings, invocationReady, projectStandings, recordWorkProgress, } from "./slices/rebuild/runtime-store.js";
 import { currentRevisionId } from "./slices/revisions/repo.js";
 import { createLimitGate, resumeAfterRestart } from "./slices/run-cost/limits.js";
 import { createStandaloneMeter, createUsageMeter } from "./slices/run-cost/meter.js";
@@ -759,8 +759,7 @@ export function wireRunner({ onFinished, audioPreviews, db, paths, clock, ids, l
         stages: {
             stagesOf: (projectId) => {
                 materializeAdmittedWork(execution, projectId);
-                projectStandings(execution, projectId);
-                return executionStages(execution, projectId);
+                return projectStandings(execution, projectId);
             },
             standingsOf: (projectId) => executionStandings(execution, projectId),
             ready: (work) => invocationReady(execution, work),

package/dist/patch-notes/3.13.1.md

@@ -0,0 +1,5 @@
+# Slopify 3.13.1
+
+Released 8 October 2026.
+
+- **Slopify keeps answering while a long project runs.** Each time a step started or finished, Slopify worked out the project's whole plan again several times over, on the same thread that answers the app. On a two-hour narration that took about 7 seconds per step, so with steps finishing back to back the app stopped responding for minutes. The repeated text work (matching the pronunciation glossary, cutting chunks, reading the glossary) is now done once and remembered, and the plan is worked out once per step instead of several times. The same project now takes about 1 second per step.

package/dist/patch-notes/3.13.2.md

@@ -0,0 +1,5 @@
+# Slopify 3.13.2
+
+Released 8 October 2026.
+
+- **Uploaded videos no longer show as Paused.** A project you uploaded that was paused, or had a leftover step from an edit after the upload, showed as Paused or Waiting in the project list and on its page. An uploaded project with nothing queued to run now shows as Done. A remake you start on an uploaded video still shows as running until it finishes.

package/dist/patch-notes/index.json

@@ -1,4 +1,16 @@
 [
+  {
+    "id": "3.13.2",
+    "title": "Slopify 3.13.2",
+    "version": "3.13.2",
+    "date": "2026-10-08"
+  },
+  {
+    "id": "3.13.1",
+    "title": "Slopify 3.13.1",
+    "version": "3.13.1",
+    "date": "2026-10-08"
+  },
   {
     "id": "3.13.0",
     "title": "Slopify 3.13.0",

package/dist/slices/narration/chunk.js

@@ -1,3 +1,4 @@
+import { remembered } from "../../kernel/remembered.js";
 export const chunkModes = ["whole", "paragraph", "words", "characters"];
 export const defaultChunkWords = 500;
 export const defaultChunkCharacters = 3000;
@@ -7,7 +8,9 @@ export const defaultChunking = { mode: "whole" };
 // A run of blank lines is one paragraph break, not several, and a line of nothing but
 // spaces between two paragraphs is still a break: strip-markdown output is full of both.
 const paragraphBreak = /\r?\n[ \t\r]*(?:\r?\n[ \t\r]*)+/;
-export function chunkNarration(text, chunking) {
+// Remembered (`kernel/remembered.ts`): every plan rebuild cuts the whole narration again.
+export const chunkNarration = remembered(16, (text, chunking) => `${JSON.stringify(chunking)}\u0000${text}`, cutNarration);
+function cutNarration(text, chunking) {
     switch (chunking.mode) {
         case "whole":
             return nonEmpty([text]);

package/dist/slices/narration/pronunciation.js

@@ -1,5 +1,6 @@
 import { remark } from "remark";
 import remarkGfm from "remark-gfm";
+import { remembered } from "../../kernel/remembered.js";
 // Inworld requires English IPA, not every symbol in Unicode's IPA Extensions block.
 // https://docs.inworld.ai/tts/capabilities/custom-pronunciation
 const ipaAtom = "[ˈˌ]?[abdefghijklmnoprstuvwxzæðŋθɑɒɔəɚɛɜɝɡɪɹʃʊʌʒʔɫɾ][\\u0303\\u031a\\u0325\\u0329\\u032a\\u032c\\u032f\\u035c\\u0361ʰʲʷ]*[ːˑ]?";
@@ -49,7 +50,8 @@ function termIdentity(term) {
 }
 // `language` is the project's (`kernel/ports/languages.ts`): absent or English accepts the
 // standard-English IPA Inworld asks for, as it always did; any other accepts full IPA.
-export function parsePronunciationGlossary(markdown, language) {
+export const parsePronunciationGlossary = remembered(8, (markdown, language) => `${language ?? ""}\u0000${markdown}`, parseGlossary);
+function parseGlossary(markdown, language) {
     const english = language === undefined || language === "en";
     const symbols = english ? ipaSymbols : worldSymbols;
     const kind = english ? "standard-English IPA" : "IPA";
@@ -127,7 +129,9 @@ export function skippedSpeakerPronunciationsNotice(rows) {
     return (`Speaker pronunciations: some entries are skipped and read as ordinary text (${parts.join(". ")}). ` +
         "The rest are used. To use them, fix those entries under Speakers → Pronunciations for that speaker (Play → Narration, or Edit project → Providers).");
 }
-export function pronunciationMatches(source, entries) {
+// Remembered (`kernel/remembered.ts`): every plan rebuild matches the whole narration again.
+export const pronunciationMatches = remembered(1024, (source, entries) => `${source}\u0000${JSON.stringify(entries)}`, matchPronunciations);
+function matchPronunciations(source, entries) {
     if (entries.length === 0)
         return [];
     const ordered = [...entries].sort((a, b) => b.term.length - a.term.length);

package/dist/slices/rebuild/runtime-materialize.js

@@ -28,6 +28,13 @@ export function materializeAdmittedWork(deps, projectId) {
             .all(projectId, head)
             .map((row) => reservation.parse(row));
         const origins = new Map(reservations.map((row) => [row.origin_revision, row]));
+        // The head's view, read once: each narration part used to read the whole version again.
+        let headView = null;
+        const headOnce = () => {
+            if (headView === null)
+                headView = getRevisionView(deps, projectId, head);
+            return headView;
+        };
         for (const origin of origins.values()) {
             const view = executionView(deps, projectId, origin.origin_revision);
             if (view === undefined)
@@ -40,7 +47,7 @@ export function materializeAdmittedWork(deps, projectId) {
                 if (recipe.deferred || recipe.unresolved)
                     continue;
                 if (recipe.input.kind === "tts") {
-                    const current = getRevisionView(deps, projectId, head);
+                    const current = headOnce();
                     const desired = current?.revision.fingerprints[`${recipe.input.logicalKey}:1`];
                     if (desired !== undefined && desired !== recipe.logicalFingerprint)
                         continue;

package/dist/slices/rebuild/runtime-store.js

@@ -46,7 +46,9 @@ export function executionStages(deps, projectId) {
             !reviewsNarration(view.revision.config))
             return false;
         if (piece.input.kind === "deferred" && piece.key.endsWith(":future")) {
-            const cacheKey = String(row.id);
+            // One plan per version and saved catalogue: every placeholder of the same version
+            // asked for the same plan again, a whole-project rebuild each time.
+            const cacheKey = `${String(row.revision_id)}\u0000${String(row.recipe_context)}`;
             let deferred = futureKeys.get(cacheKey);
             if (deferred === undefined) {
                 const origin = executionView(deps, projectId, String(row.revision_id));
@@ -197,6 +199,8 @@ function latestRetry(deps, group) {
     }
     return latest;
 }
+// The stage rows brought up to date, and the steps they were derived from, so the runner's
+// tick uses them rather than deriving the whole plan again.
 export function projectStandings(deps, projectId) {
     // One derivation serves every stage: each builds the whole execution plan.
     const work = executionStages(deps, projectId);
@@ -227,6 +231,7 @@ export function projectStandings(deps, projectId) {
             .run(stage.state, textOf(failure?.failure_reason), textOf(failure?.failure_kind), stage.retryAt ?? null, invocations.length === 0 ? null : current, invocations.length === 0 ? null : invocations.length, stage.state, deps.clock.now().toISOString(), projectId, stage.kind);
     }
     settleScheduleRunsForProject(deps.db, projectId, deps.clock.now().toISOString());
+    return work;
 }
 // Progress moves one number and nothing else. The stage row already counts this invocation's
 // last fraction, from the claim or the previous event, so it takes the difference instead

package/dist/slices/uploads/repo.js

@@ -18,6 +18,17 @@ export function uploadedProjects(db) {
         .all()
         .map((row) => [String(row.project_id), String(row.uploaded_at)]));
 }
+// Uploaded projects with nothing admitted still to run: their leftover steps (a placeholder
+// from an edit after the upload, a pause from a bulk Pause) are not work the person is
+// waiting for, so the listing calls them done rather than "Paused" or "Waiting".
+export function uploadedAndSettled(db) {
+    return new Set(db
+        .prepare(`SELECT u.project_id FROM project_uploads u WHERE NOT EXISTS(
+           SELECT 1 FROM revision_work w WHERE w.project_id=u.project_id
+             AND w.state IN ('pending','running') AND w.dispatch_state!='held')`)
+        .all()
+        .map((row) => String(row.project_id)));
+}
 // "Keep as is": a waiting run the person leaves as it is, until the project's next edit. Set on
 // the current head revision; the listing counts it only while that revision is still the head.
 export function setAside(db, projectId, aside, at) {