@gentbajko/slopify 3.0.6 → 3.0.8

package/dist/adapters/tts/elevenlabs.js

@@ -13,6 +13,8 @@ export const elevenLabsBase = "https://api.elevenlabs.io/v1";
 // keep arriving.
 export const elevenLabsModel = "eleven_multilingual_v2";
 export const elevenLabsModels = [
+    { id: "eleven_v4", name: "Eleven v4" },
+    { id: "eleven_v4_turbo", name: "Eleven v4 Turbo" },
     { id: "eleven_v3", name: "Eleven v3" },
     { id: "eleven_multilingual_v2", name: "Eleven Multilingual v2" },
     { id: "eleven_flash_v2_5", name: "Eleven Flash v2.5" },

package/dist/assets/document/fonts/Literata-OFL.txt

@@ -0,0 +1,93 @@
+Copyright 2017 The Literata Project Authors (https://github.com/googlefonts/literata)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

package/dist/assets/document/fonts/SOURCE.txt

@@ -3,9 +3,21 @@ Cinzel 2.000 by Natanael Gama, from the embedded font data of the lore2script2 P
 (same owner). Copyright and licence are read from each file's own name table.
 Upstream: https://github.com/NDISCOVER/Cinzel
 
+Literata-Regular.ttf, Literata-SemiBold.ttf, Literata-Italic.ttf, Literata-SemiBoldItalic.ttf
+Literata 3 by TypeTogether, instanced from Google Fonts' variable Literata[opsz,wght].ttf and
+Literata-Italic[opsz,wght].ttf (https://github.com/google/fonts/tree/main/ofl/literata) at
+opsz 12 and wght 400 / 600, subset to Latin, Greek, Cyrillic, punctuation and symbols
+(fontTools instancer and subsetter).
+
 OFL.txt
-SIL Open Font License 1.1, with the copyright line from the fonts' name table.
+SIL Open Font License 1.1, with the copyright line from the fonts' name table (Cinzel).
+Literata-OFL.txt
+SIL Open Font License 1.1 for Literata, as published with it.
 7445469e9f302618200b15b1645d6aa3565b93a6634a0f9e5cd069c7fc2343fe  Cinzel-Black.ttf
 cbe8f6a665cc58d4540b6ce2a29e6f1b7e096fa6835aea1d2ffb40c088c5cdf6  Cinzel-Bold.ttf
 3d50001a451ba6cfd3ef07a2dfb0c564980a5229f70decdfa23f08f4a30e1bed  Cinzel-Medium.ttf
 540b628614b728fc87e50b883189a524dac4d8163ca4a0f8e49b499910762e86  Cinzel-Regular.ttf
+184bbf724352ffbf7313dc9463f4d242246bcc587aaf10a78f0f4fe826a547bb  Literata-Italic.ttf
+efcb6ed9f994f21e3a1759d193d655708d4b836568616967cef80c6a015481cd  Literata-Regular.ttf
+a0eeda32c8098fee2cabf5951f6f65aa9396121053e511a11406076f2cd41569  Literata-SemiBoldItalic.ttf
+68415d934f51efd396dfdfc5628ba4bc35042b7ac753e3a4b75b677b970c89a1  Literata-SemiBold.ttf

package/dist/assets/models.yaml

@@ -328,6 +328,32 @@ image:
         - 16:9
         - 9:16
 tts:
+  - provider: elevenlabs
+    id: eleven_v4
+    name: Eleven v4
+    source: https://elevenlabs.io/docs/overview/models
+    keywords:
+      - tts
+    pricing:
+      perMillionCharacters: 22
+      note: Launch API rate, verified 2026-09-28 and offered for two weeks; the most expressive ElevenLabs model, 90+ languages. Your plan,
+        voice and account credits affect actual cost.
+    tts:
+      maxCharacters: 10000
+      streaming: true
+  - provider: elevenlabs
+    id: eleven_v4_turbo
+    name: Eleven v4 Turbo
+    source: https://elevenlabs.io/docs/overview/models
+    keywords:
+      - tts
+    pricing:
+      perMillionCharacters: 11
+      note: Launch API rate, verified 2026-09-28 and offered for two weeks; the fast v4, for low latency. Your plan,
+        voice and account credits affect actual cost.
+    tts:
+      maxCharacters: 10000
+      streaming: true
   - provider: elevenlabs
     id: eleven_v3
     name: Eleven v3

package/dist/edge/autostart/native.js

@@ -77,6 +77,10 @@ export function createNativeAutostart(o) {
         const ours = text.includes(platform === "linux" ? desktopMarker : launcherMarker);
         return { state: ours ? "ours" : "foreign", text };
     }
+    const thisLauncher = launcherRef(platform, at.launcher);
+    function runsThisFolder(now) {
+        return now.state === "ours" && (now.text?.includes(thisLauncher) ?? false);
+    }
     function state(enabled) {
         return {
             available: true,
@@ -113,7 +117,9 @@ export function createNativeAutostart(o) {
         await o.fs.write(at.entry, entryText, 0o644);
     }
     return {
-        status: async () => state((await entryNow()).state === "ours"),
+        // On only when the entry starts this data folder: a second Slopify (another --data-dir,
+        // a test copy) sees the switch off, so turning it off there can't remove this one's entry.
+        status: async () => state(runsThisFolder(await entryNow())),
         enable: async () => {
             if (platform === "win32") {
                 const problem = windowsPathProblem(o.dataDir);
@@ -121,6 +127,8 @@ export function createNativeAutostart(o) {
                     throw new Error(problem);
             }
             const now = await entryNow();
+            if (now.state === "ours" && !runsThisFolder(now))
+                throw new Error(`Another Slopify, with a different data folder, already starts when you log in (${at.where}). Slopify left it alone. Turn it off in that Slopify's Settings → General, or delete ${platform === "win32" ? `the ${runValue} entry in Task Manager → Startup apps` : "that file"}, then turn the switch on here again.`);
             if (now.state === "foreign")
                 throw new Error(platform === "win32"
                     ? `Your start-up list already has an entry named ${runValue} that Slopify didn't make (${runKey}). Slopify left it alone. Remove it in Task Manager → Startup apps, or rename it, then turn the switch on again.`
@@ -131,7 +139,8 @@ export function createNativeAutostart(o) {
         },
         disable: async () => {
             const now = await entryNow();
-            if (now.state === "ours") {
+            // Only this data folder's entry: another Slopify's is not this switch's to remove.
+            if (runsThisFolder(now)) {
                 if (platform === "win32") {
                     const result = await o.exec("reg", ["delete", runKey, "/v", runValue, "/f"]);
                     if (result.code !== 0)
@@ -151,7 +160,7 @@ export function createNativeAutostart(o) {
             const now = await entryNow();
             // Only the entry that runs this data folder's launcher: a Slopify started with another
             // --data-dir must not take over the one the switch was turned on from.
-            if (now.state !== "ours" || !now.text?.includes(launcherRef(platform, at.launcher)))
+            if (!runsThisFolder(now))
                 return;
             await writeLauncher();
             await writeEntry(now.text);

package/dist/kernel/db/migrations/0042-narration-retries.sql

@@ -0,0 +1,13 @@
+-- A narration chunk whose audio stopped matching its text is recorded again by itself: the
+-- caption step asks for it here, and the retry starts once that step's failure is saved. The
+-- count caps it at two tries per chunk; `state` is what the last try did.
+CREATE TABLE narration_retries (
+ project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+ chunk_key TEXT NOT NULL,
+ tries INTEGER NOT NULL CHECK (tries > 0),
+ state TEXT NOT NULL CHECK (state IN ('pending', 'started', 'failed')),
+ detail TEXT,
+ updated_at TEXT NOT NULL,
+ PRIMARY KEY(project_id, chunk_key)
+);
+CREATE INDEX narration_retries_pending ON narration_retries(state) WHERE state = 'pending';

package/dist/main.js

@@ -55,6 +55,7 @@ import { createNotificationSender } from "./slices/notifications/send.js";
 import { readNotificationUrl } from "./slices/notifications/settings.js";
 import { seedSamples } from "./slices/onboarding/sample.js";
 import { templateById } from "./slices/project-templates/repo.js";
+import { createNarrationRetries } from "./slices/rebuild/narration-retry.js";
 import { recoverProject } from "./slices/rebuild/recovery.js";
 import { claimWork, finishWork, maySubmit } from "./slices/rebuild/repo.js";
 import { waitToRetry, wakeRetries } from "./slices/rebuild/retry.js";
@@ -261,8 +262,12 @@ export async function boot(config, options = {}) {
         });
         const audioPreviews = createAudioPreviewStore();
         const reviewRedos = createReviewRedos();
+        const narrationRetries = createNarrationRetries();
         const runner = wireRunner({
-            onFinished: (work) => reviewRedos.kick(work.projectId),
+            onFinished: (work) => {
+                reviewRedos.kick(work.projectId);
+                narrationRetries.kick(work.projectId);
+            },
             db,
             paths,
             clock,
@@ -386,6 +391,9 @@ export async function boot(config, options = {}) {
         // Redos a review asked for before the last shutdown start now.
         reviewRedos.bind(rebuild);
         reviewRedos.kick();
+        // So do narration chunks the captions asked to record again.
+        narrationRetries.bind(rebuild);
+        narrationRetries.kick();
         // A stage that was waiting for a CLI's plan limits when the app stopped carries on waiting.
         void resumeAfterRestart(db, async (projectId) => {
             const baseRevisionId = currentRevisionId(runtimeDb, projectId);

package/dist/patch-notes/3.0.7.md

@@ -0,0 +1,33 @@
+# Slopify 3.0.7
+
+Released 28 September 2026.
+
+3.0.7 makes schedules show the template version they really use, adds Literata to PDF themes, and keeps pinned comments short.
+
+## Highlights
+
+- **Schedules show the template they run.** Editing a schedule shows each template at its newest version.
+- **Literata for PDFs**, a text face made for long reading.
+- **Short pinned comments:** a line or two, not paragraphs.
+- **New project** in the sidebar.
+
+## Schedules
+
+- Edit schedule lists every template at its newest version, the one every run uses, and saving records it. It used to show the version the schedule was first saved with ("· v3") and offer no other, even though runs already used the newest.
+
+## PDF themes
+
+- PDF themes can use **Literata** in regular, bold, italic and bold italic: a text face made for long reading on screens.
+
+## YouTube description
+
+- The pinned comment is one or two short sentences (about 200 characters): a question viewers can answer and an ask for the next topic. It was two to four paragraphs.
+
+## Everywhere
+
+- **New video** is now **New project**, in the sidebar, on Home and Projects, and as the `C` command: a project can be an audiobook, a podcast or a PDF as well as a video.
+- ElevenLabs lists **Eleven v4** and **Eleven v4 Turbo** even before the model list is checked.
+
+## Upgrading from 3.0.6
+
+- **Nothing becomes outdated.** To see a schedule's newest template version, open it and press **Save changes** once.

package/dist/patch-notes/3.0.8.md

@@ -0,0 +1,23 @@
+# Slopify 3.0.8
+
+Released 29 September 2026.
+
+3.0.8 fixes a garbled narration sentence by itself instead of stopping the run.
+
+## Highlights
+
+- **Garbled narration is recorded again by itself.** A run no longer stops for a sentence the voice mumbled or skipped.
+
+## Narration
+
+- When captions find the narration no longer matches the text (the voice garbled or skipped a sentence), Slopify records that narration chunk again by itself, rebuilds the narration, captions and video, and carries on. It used to stop the run until you pressed Regenerate on the chunk in Edit project → Narration and continued.
+- Each chunk gets two tries. The step says which try is running; if the audio still doesn't match after both, the voice reads something its own way (a year, an abbreviation or a name), and the step says to reword that sentence in Edit project → Narration.
+- Uploaded narration, captions you edited by hand and multi-voice turns aren't retried: they stop and ask, as before.
+
+## Everywhere
+
+- **Start Slopify when I log in** belongs to one data folder. A second Slopify on the same account (another `--data-dir`) sees the switch off and can no longer remove or take over the first one's login entry.
+
+## Upgrading from 3.0.7
+
+- **Nothing becomes outdated.** Retries start with the next run that finds a mismatch.

package/dist/patch-notes/index.json

@@ -1,4 +1,16 @@
 [
+  {
+    "id": "3.0.8",
+    "title": "Slopify 3.0.8",
+    "version": "3.0.8",
+    "date": "2026-09-29"
+  },
+  {
+    "id": "3.0.7",
+    "title": "Slopify 3.0.7",
+    "version": "3.0.7",
+    "date": "2026-09-28"
+  },
   {
     "id": "3.0.6",
     "title": "Slopify 3.0.6",

package/dist/slices/document/fonts.js

@@ -1,7 +1,7 @@
 import { readFileSync } from "node:fs";
-// The bundled Cinzel weights (SIL OFL 1.1, assets/document/fonts/OFL.txt) and the page
-// texture. Read on every render rather than kept in memory: four fonts and one image are
-// under a megabyte, and a document is made once per article.
+// The bundled Cinzel weights and Literata styles (SIL OFL 1.1, assets/document/fonts) and the
+// page texture. Read on every render rather than kept in memory: eight fonts and one image
+// are about a megabyte and a half, and a document is made once per article.
 const assets = new URL("../../assets/document/", import.meta.url);
 const cinzelFiles = {
     normal: "Cinzel-Regular.ttf",
@@ -9,13 +9,27 @@ const cinzelFiles = {
     bold: "Cinzel-Bold.ttf",
     black: "Cinzel-Black.ttf",
 };
+// Literata, a text face made for long reading on screens: its text optical size, at 400 and
+// 600 for bold (a heavier bold crowds a page of body text).
+const literataFiles = {
+    normal: "Literata-Regular.ttf",
+    bold: "Literata-SemiBold.ttf",
+    italic: "Literata-Italic.ttf",
+    bolditalic: "Literata-SemiBoldItalic.ttf",
+};
+function readFonts(files) {
+    return Object.fromEntries(Object.entries(files).map(([style, file]) => [
+        style,
+        readFileSync(new URL(`fonts/${file}`, assets)).toString("base64"),
+    ]));
+}
 export function readDocumentAssets() {
     try {
-        const cinzel = Object.fromEntries(Object.entries(cinzelFiles).map(([style, file]) => [
-            style,
-            readFileSync(new URL(`fonts/${file}`, assets)).toString("base64"),
-        ]));
-        return { cinzel, parchment: new Uint8Array(readFileSync(new URL("background.jpg", assets))) };
+        return {
+            cinzel: readFonts(cinzelFiles),
+            literata: readFonts(literataFiles),
+            parchment: new Uint8Array(readFileSync(new URL("background.jpg", assets))),
+        };
     }
     catch (error) {
         throw new Error(`Slopify couldn't read the fonts and page texture it makes documents with (${error instanceof Error ? error.message : String(error)}). Its installation is incomplete: reinstall or update Slopify, then use Try again on Document.`, { cause: error });
@@ -23,12 +37,16 @@ export function readDocumentAssets() {
 }
 export function registerFonts(doc, fonts) {
     for (const [style, file] of Object.entries(cinzelFiles)) {
-        doc.addFileToVFS(file, fonts[style]);
+        doc.addFileToVFS(file, fonts.cinzel[style]);
         doc.addFont(file, "Cinzel", style);
     }
+    for (const [style, file] of Object.entries(literataFiles)) {
+        doc.addFileToVFS(file, fonts.literata[style]);
+        doc.addFont(file, "Literata", style);
+    }
 }
-// Cinzel exists only in the four bundled weights; the standard fonts only in normal, bold,
-// italic and bold italic. A face asking for anything else gets the nearest one.
+// Cinzel exists only in the four bundled weights; Literata and the standard fonts only in
+// normal, bold, italic and bold italic. A face asking for anything else gets the nearest one.
 export function useFace(doc, face, size) {
     doc.setFont(face.family, styleFor(face));
     doc.setFontSize(size);

package/dist/slices/document/render.js

@@ -22,7 +22,7 @@ export function renderDocument(input) {
         format: theme.page.format,
         compress: true,
     });
-    registerFonts(doc, input.assets.cinzel);
+    registerFonts(doc, input.assets);
     const fill = (template) => template.replaceAll("{title}", input.title).trim();
     doc.setProperties({
         title: input.title,

package/dist/slices/document/theme.js

@@ -1,8 +1,8 @@
 import { legacyDiceMasterTheme } from "./legacy-dicemaster.js";
 import { defaultDocumentTheme, documentThemeOf, legacyDocumentTheme, } from "./model.js";
-// "Cinzel" is bundled (assets/document/fonts) in the styles below; the other three are the
-// PDF standard fonts every reader has.
-export const fontFamilies = ["Cinzel", "times", "helvetica", "courier"];
+// "Cinzel" and "Literata" are bundled (assets/document/fonts); the other three are the PDF
+// standard fonts every reader has.
+export const fontFamilies = ["Cinzel", "Literata", "times", "helvetica", "courier"];
 export const fontStyles = ["normal", "medium", "bold", "black", "italic", "bolditalic"];
 const cinzel = (style, letterSpacing) => ({
     family: "Cinzel",

package/dist/slices/rebuild/narration-retry.js

@@ -0,0 +1,128 @@
+import { createHash } from "node:crypto";
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { currentRevisionId } from "../revisions/repo.js";
+import { recoverProject } from "./recovery.js";
+// How many times one narration chunk is recorded again by itself. A voice that garbles a
+// sentence rarely does it twice; one that reads a name its own way does it every time, so
+// after this the run stops and asks the person.
+export const narrationRetryLimit = 2;
+const row = z.object({
+    project_id: z.string(),
+    chunk_key: z.string(),
+    tries: z.number(),
+    state: z.enum(["pending", "started", "failed"]),
+});
+// Asked by the caption step when the audio stopped matching the text in a chunk. Returns the
+// try this is (1 or 2), or undefined once the chunk has had its tries.
+export function requestNarrationRetry(db, input) {
+    return transact(db, () => {
+        const saved = db
+            .prepare("SELECT tries FROM narration_retries WHERE project_id=? AND chunk_key=?")
+            .get(input.projectId, input.chunkKey);
+        const tries = saved === undefined ? 0 : z.number().parse(saved.tries);
+        if (tries >= narrationRetryLimit)
+            return undefined;
+        db.prepare(`INSERT INTO narration_retries(project_id, chunk_key, tries, state, detail, updated_at)
+       VALUES (?, ?, 1, 'pending', NULL, ?)
+       ON CONFLICT(project_id, chunk_key)
+       DO UPDATE SET tries=tries+1, state='pending', detail=NULL, updated_at=excluded.updated_at`).run(input.projectId, input.chunkKey, input.now);
+        return tries + 1;
+    });
+}
+export function pendingNarrationRetries(db, projectId) {
+    const rows = projectId === undefined
+        ? db.prepare("SELECT * FROM narration_retries WHERE state='pending'").all()
+        : db
+            .prepare("SELECT * FROM narration_retries WHERE state='pending' AND project_id=?")
+            .all(projectId);
+    return rows.map((value) => {
+        const parsed = row.parse(value);
+        return { projectId: parsed.project_id, chunkKey: parsed.chunk_key, tries: parsed.tries };
+    });
+}
+function settle(db, retry, state, detail, now) {
+    db.prepare("UPDATE narration_retries SET state=?, detail=?, updated_at=? WHERE project_id=? AND chunk_key=? AND tries=?").run(state, detail, now, retry.projectId, retry.chunkKey, retry.tries);
+}
+// Starts the retries the caption step asked for, once its failure is saved (the runner's
+// `onFinished`). The chunk is made again through Redo's path: a new regeneration token saved as
+// a new project version, then the chunk and everything built on it (the joined narration,
+// the captions, the video) rebuilt as ordinary work.
+export function createNarrationRetries() {
+    let bound;
+    const running = new Set();
+    const kick = (projectId) => {
+        const deps = bound;
+        if (deps === undefined)
+            return;
+        for (const retry of pendingNarrationRetries(deps.db, projectId)) {
+            const id = `${retry.projectId}\n${retry.chunkKey}`;
+            if (running.has(id))
+                continue;
+            running.add(id);
+            void recordAgain(deps, retry)
+                .catch((error) => {
+                deps.log.write("error", "narration.retry", {
+                    projectId: retry.projectId,
+                    detail: error instanceof Error ? error.message : String(error),
+                });
+                settle(deps.db, retry, "failed", "internal error", deps.clock.now().toISOString());
+            })
+                .finally(() => {
+                running.delete(id);
+                try {
+                    deps.runner.tick(retry.projectId);
+                }
+                catch {
+                    // The next tick of this project picks the released work up.
+                }
+            });
+        }
+    };
+    return {
+        bind: (deps) => {
+            bound = deps;
+        },
+        kick,
+    };
+}
+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;
+    }
+    const result = await recoverProject(deps, retry.projectId, {
+        baseRevisionId: base,
+        idempotencyKey: retryKey(retry),
+        action: { kind: "redo", item: retry.chunkKey },
+    }, { pendingSuperseded: true });
+    const now = deps.clock.now().toISOString();
+    if (result.ok) {
+        settle(deps.db, retry, "started", null, now);
+        deps.log.write("info", "narration.retry", {
+            projectId: retry.projectId,
+            detail: `Recording ${retry.chunkKey} again (try ${String(retry.tries)} of ${String(narrationRetryLimit)}).`,
+        });
+    }
+    else {
+        settle(deps.db, retry, "failed", refusal(result), now);
+        deps.log.write("warn", "narration.retry", {
+            projectId: retry.projectId,
+            detail: `Could not record ${retry.chunkKey} again: ${refusal(result)}`,
+        });
+    }
+    deps.emit(retry.projectId, { type: "project.updated", projectId: retry.projectId });
+}
+function refusal(result) {
+    const detail = result.fields?.map((field) => field.message).join(" ");
+    return detail ? `${result.reason}: ${detail}` : result.reason;
+}
+// One request identity per try, so a restart that starts the same try again gets the first
+// start's answer instead of a second recording.
+export function retryKey(retry) {
+    const hex = createHash("sha256")
+        .update(`narration-retry:${retry.projectId}:${retry.chunkKey}:${String(retry.tries)}`)
+        .digest("hex");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-4${hex.slice(13, 16)}-8${hex.slice(17, 20)}-${hex.slice(20, 32)}`;
+}

package/dist/slices/rebuild/recovery-selection.js

@@ -44,6 +44,13 @@ export function redoTarget(view, plan, item) {
         return plan.recipes.some((row) => row.key === `${item}:prompts`)
             ? own([`${item}:prompts`])
             : undefined;
+    // One narration chunk, by the key the Narration editor regenerates it by: its TTS requests
+    // are the roots (`narration-retry.ts`).
+    const chunk = plan.recipes
+        .filter((row) => row.input.kind === "tts" && row.input.logicalKey === item)
+        .map((row) => row.key);
+    if (chunk.length > 0)
+        return own(chunk);
     return plan.recipes.some((row) => row.key === item && row.kind === "provider")
         ? own([item])
         : undefined;