@gentbajko/slopify 3.12.1 → 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.0.md

@@ -0,0 +1,5 @@
+# Slopify 3.13.0
+
+Released 8 October 2026.
+
+- **Editing the article re-voices only what you changed.** Slopify splits the narration into chunks by length, filling each one sentence by sentence from the top. Removing or adding a sentence near the start moved every chunk boundary after it, so every chunk looked new and the whole narration was voiced again. A save that changes the article or narration text now keeps the chunks it had wherever their text is unchanged, and only cuts the edited stretch again. Dropping one line from the top of a 29-chunk narration now re-voices 1 chunk instead of 29. Changing the chunk size in settings still splits the whole narration again.

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,16 @@
 [
+  {
+    "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",
+    "version": "3.13.0",
+    "date": "2026-10-08"
+  },
   {
     "id": "3.12.1",
     "title": "Slopify 3.12.1",

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]);
@@ -19,6 +22,28 @@ export function chunkNarration(text, chunking) {
             return sentenceRuns(text, chunking.characters ?? defaultChunkCharacters, (part) => Array.from(part.trim()).length);
     }
 }
+// The chunks of an edited text, keeping the previous version's chunks wherever their text is
+// still there unchanged: only the stretches between them are cut again. Cutting the whole text
+// afresh packs sentences greedily from the start, so one sentence removed near the top moved
+// every boundary after it and every chunk was voiced again (a 3,800-character edit re-voiced
+// 113,000). `anchors` are the previous chunks in order; without them this is `chunkNarration`.
+export function anchoredChunks(text, chunking, anchors) {
+    if (anchors === undefined || anchors.length === 0)
+        return chunkNarration(text, chunking);
+    const chunks = [];
+    let offset = 0;
+    for (const anchor of anchors) {
+        if (anchor === "")
+            continue;
+        const at = text.indexOf(anchor, offset);
+        if (at < 0)
+            continue;
+        chunks.push(...chunkNarration(text.slice(offset, at), chunking), anchor);
+        offset = at + anchor.length;
+    }
+    chunks.push(...chunkNarration(text.slice(offset), chunking));
+    return chunks;
+}
 // What "N words" counts: runs of non-space. Exported because it is half of the rule -
 // a test that asserts a chunk fits in N has to count the same way the cut did. Chinese,
 // Japanese, Thai and the other scripts written without spaces are counted by the platform's

package/dist/slices/narration/pronunciation-chunks.js

@@ -1,7 +1,21 @@
 import { fingerprint } from "../../kernel/runner/work.js";
-import { chunkNarration, defaultChunkCharacters, defaultChunkWords, } from "./chunk.js";
+import { anchoredChunks, defaultChunkCharacters, defaultChunkWords, } from "./chunk.js";
 import { pronunciationMatches } from "./pronunciation.js";
-export function pronunciationChunks(source, chunking, entries, overriddenKeys = new Set(), sources = {}) {
+export function chunkingFingerprintOf(chunking) {
+    return fingerprint([
+        chunking.mode,
+        chunking.mode === "words"
+            ? (chunking.words ?? defaultChunkWords)
+            : chunking.mode === "characters"
+                ? (chunking.characters ?? defaultChunkCharacters)
+                : null,
+    ]);
+}
+// The plain chunks of a narration text, before pronunciation merges: what anchors record.
+export function narrationChunkTexts(source, chunking, anchors) {
+    return anchoredChunks(source, chunking, anchors?.chunkingFingerprint === chunkingFingerprintOf(chunking) ? anchors.texts : undefined);
+}
+export function pronunciationChunks(source, chunking, entries, overriddenKeys = new Set(), sources = {}, anchors) {
     const occurrences = new Map();
     const usedKeys = new Set();
     const nextKey = (text) => {
@@ -15,7 +29,7 @@ export function pronunciationChunks(source, chunking, entries, overriddenKeys =
         return key;
     };
     let offset = 0;
-    const chunks = chunkNarration(source, chunking).map((text) => {
+    const chunks = narrationChunkTexts(source, chunking, anchors).map((text) => {
         const start = source.indexOf(text, offset);
         if (start < 0)
             throw new Error("Slopify hit an internal error (a narration chunk isn't in the article text). Try again; if it happens again, use Download diagnostics in Settings and report it.");
@@ -23,14 +37,7 @@ export function pronunciationChunks(source, chunking, entries, overriddenKeys =
         return { key: nextKey(text), text, start, end: offset };
     });
     const bodyFingerprint = fingerprint(source);
-    const chunkingFingerprint = fingerprint([
-        chunking.mode,
-        chunking.mode === "words"
-            ? (chunking.words ?? defaultChunkWords)
-            : chunking.mode === "characters"
-                ? (chunking.characters ?? defaultChunkCharacters)
-                : null,
-    ]);
+    const chunkingFingerprint = chunkingFingerprintOf(chunking);
     const starts = new Map(chunks.map((chunk, index) => [chunk.start, index]));
     const ends = new Map(chunks.map((chunk, index) => [chunk.end, index]));
     const pinned = new Map();

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/recipe-audio.js

@@ -14,7 +14,7 @@ import { voiceBodyRecipes } from "./recipe-voices.js";
 export function bodyNarrationGroups(context, text) {
     if (text.narrationText === null)
         return [];
-    const groups = pronunciationChunks(normalizeNarrationText(text.narrationText), context.config.chunking ?? defaultChunking, usesPronunciationGlossary(context.config) && text.glossary?.ok ? text.glossary.entries : [], new Set(Object.keys(context.content.narrationOverrides)), context.content.narrationSources);
+    const groups = pronunciationChunks(normalizeNarrationText(text.narrationText), context.config.chunking ?? defaultChunking, usesPronunciationGlossary(context.config) && text.glossary?.ok ? text.glossary.entries : [], new Set(Object.keys(context.content.narrationOverrides)), context.content.narrationSources, context.content.narrationAnchors);
     // A chunk's key is its text's, so an article edit that makes a chunk say what its narration
     // edit already said (a line dropped from both) would make a new chunk to voice again. It
     // keeps the edited chunk's key instead, and with it the narration already made.

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/revisions/rules.js

@@ -1,11 +1,45 @@
 import { isDeepStrictEqual } from "node:util";
-import { narrationRegenerationKey } from "../narration/plan.js";
+import { defaultChunking } from "../narration/chunk.js";
+import { narrationRegenerationKey, normalizeNarrationText } from "../narration/plan.js";
+import { chunkingFingerprintOf, narrationChunkTexts, } from "../narration/pronunciation-chunks.js";
 import { bodyNarrationGroups } from "../rebuild/recipe-audio.js";
 import { buildRecipes } from "../rebuild/recipe-build.js";
 import { normalizeArticleIntent, validateRevisionEdit } from "../rebuild/recipe-save.js";
 import { textRecipes } from "../rebuild/recipe-text.js";
+// The chunks to keep through this save: when the narration text changes, the chunks it had
+// before (themselves kept from earlier edits), so only the edited stretches are cut and voiced
+// again; when it doesn't, the ones already kept. None once the chunk size changes.
+function narrationAnchorsFor(base, edit, content) {
+    const before = base.revision.config.chunking ?? defaultChunking;
+    const after = edit.config.chunking ?? defaultChunking;
+    const chunkingFingerprint = chunkingFingerprintOf(after);
+    if (chunkingFingerprint !== chunkingFingerprintOf(before))
+        return undefined;
+    const previous = {
+        config: base.revision.config,
+        content: base.revision.content,
+        manifest: base,
+        resolved: {
+            articleMarkdown: base.articleMarkdown,
+            researchNotes: base.revision.config.provided.research ?? null,
+        },
+    };
+    const old = textRecipes(previous).narrationText;
+    const next = textRecipes({ ...previous, config: edit.config, content }).narrationText;
+    if (old === null || next === null)
+        return undefined;
+    const kept = base.revision.content.narrationAnchors;
+    if (normalizeNarrationText(old) === normalizeNarrationText(next))
+        return kept?.chunkingFingerprint === chunkingFingerprint ? kept : undefined;
+    return {
+        chunkingFingerprint,
+        texts: narrationChunkTexts(normalizeNarrationText(old), before, kept),
+    };
+}
 export function bindNarrationSources(base, edit) {
-    const { narrationSources: _submitted, ...content } = normalizeArticleIntent(base, edit);
+    const { narrationSources: _submitted, narrationAnchors: _sent, ...intent } = normalizeArticleIntent(base, edit);
+    const anchors = narrationAnchorsFor(base, edit, intent);
+    const content = anchors === undefined ? intent : { ...intent, narrationAnchors: anchors };
     const keys = new Set([
         ...Object.keys(content.narrationOverrides),
         ...Object.keys(base.revision.content.regenerationTokens),

package/dist/slices/revisions/schema.js

@@ -91,6 +91,14 @@ export const revisionContentSchema = z
         .refine((rows) => Object.keys(rows).length <= 10000 &&
         Object.values(rows).reduce((length, row) => length + row.text.length, 0) <= 500000, "Narration source bindings exceed the article limit.")
         .optional(),
+    narrationAnchors: z
+        .object({
+        chunkingFingerprint: z.string().regex(/^[0-9a-f]{64}$/u),
+        texts: z.array(z.string().min(1).max(500000)).max(10000),
+    })
+        .strict()
+        .refine((row) => row.texts.reduce((length, text) => length + text.length, 0) <= 500000, "Narration anchors exceed the article limit.")
+        .optional(),
     subtitleCues: z
         .object({
         audioFingerprint: z.string().min(1),