@gentbajko/slopify 3.13.0 → 3.13.1

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/index.json

@@ -1,4 +1,10 @@
 [
+  {
+    "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