@gentbajko/slopify 3.0.3 → 3.0.4

package/dist/adapters/alignment/text.js

@@ -1,5 +1,5 @@
 import { aliasMatches } from "../../kernel/ports/narration-aliases.js";
-import { cardinal, numberForms } from "./numbers.js";
+import { cardinal, numberForms } from "../../kernel/ports/number-words.js";
 // Original display words remain intact; only acoustic matching uses normalized English.
 // Narration aliases ("Dr." said as "Doctor") make the aliased form the default for the
 // written words they cover, with the written form kept as an alternative for audio that

package/dist/adapters/alignment/window.js

@@ -1,8 +1,19 @@
 import { alignWindow, frameSeconds } from "./ctc.js";
 import { agreesWithSpeech } from "./quality.js";
 import { englishSpec } from "./spec.js";
+// ceiling: the longest run of words a voice may say its own way (a year, an abbreviation, a
+// name the model cannot spell) and still be placed between the words around it.
+const theirWayWords = 10;
+const theirWaySeconds = 6;
+// floor: the share of a window's words that must match what is heard, so a recording of
+// other words, or of the right words in the wrong order, is still refused.
+const matchingShare = 0.6;
+// Words either side of a run that hold it in place.
+const holdingWords = 3;
 // Recovery omits bounded transcript spans only after confirming surrounding speech.
-export function alignSpeechWindow(logits, frames, candidate, complete, cutoff, skipBudget, spec = englishSpec) {
+export function alignSpeechWindow(logits, frames, candidate, complete, cutoff, skipBudget, spec = englishSpec, 
+// The window starts right after words already placed, which hold its first words in place.
+held = true) {
     const { gates, mismatch } = spec;
     const agrees = (expected, observed, maximumError) => agreesWithSpeech(expected, observed, maximumError, spec.comparable);
     try {
@@ -16,8 +27,16 @@ export function alignSpeechWindow(logits, frames, candidate, complete, cutoff, s
         if (!(error instanceof Error) || error.message !== mismatch)
             throw error;
     }
+    // Last, words the voice said its own way: after skipped passages, which leave no words to
+    // place and are better told apart.
+    const theirWay = () => {
+        const said = saidTheirWay(logits, frames, candidate, complete, cutoff, spec, held);
+        if (said === undefined)
+            throw new Error(mismatch);
+        return { words: said, skipped: 0, omissionStart: 0 };
+    };
     if (skipBudget <= 0)
-        throw new Error(mismatch);
+        return theirWay();
     const heard = greedy(logits, frames, spec).split(/\s+/);
     for (let skipped = 1; skipped <= Math.min(40, skipBudget, candidate.length - 4); skipped += 1) {
         const remaining = candidate.slice(skipped);
@@ -75,7 +94,67 @@ export function alignSpeechWindow(logits, frames, candidate, complete, cutoff, s
             }
         }
     }
-    throw new Error(mismatch);
+    return theirWay();
+}
+// The window's words when all that differs from what is heard is short runs the voice said its
+// own way ("eleven o four" for 1104, "Saint" for St., a name heard as other letters):
+// forced alignment still places every word, and each run sits between words that match on both
+// sides, so its captions keep time with the ones around it. A run that reaches the end of the
+// window is left for the next one, which starts right before it. Undefined when the words do
+// not match enough of the window, or a run is too long or has nothing holding it.
+export function saidTheirWay(logits, frames, candidate, complete, cutoff, spec, held) {
+    let words;
+    try {
+        words = alignWindow(logits, frames, candidate, complete, spec).words.filter((word) => word.end <= cutoff);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === spec.mismatch)
+            return undefined;
+        throw error;
+    }
+    if (words.length < holdingWords + 1)
+        return undefined;
+    const matches = words.map((word, index) => {
+        const expected = candidate[index]?.spoken ?? "";
+        // A word too short to tell apart takes its neighbours' word for it.
+        if (spec.lettersOnly(expected).length < 3)
+            return true;
+        const heard = greedyBetween(logits, Math.floor(word.start / frameSeconds), Math.min(frames, Math.ceil(word.end / frameSeconds)), spec);
+        return agreesWithSpeech(expected, heard, 0.5, spec.comparable);
+    });
+    if (matches.filter(Boolean).length < words.length * matchingShare)
+        return undefined;
+    let keep = words.length;
+    for (let start = 0; start < words.length; start += 1) {
+        if (matches[start])
+            continue;
+        let end = start;
+        while (end < words.length && !matches[end])
+            end += 1;
+        const after = matches.slice(end, end + holdingWords);
+        const heldAfter = after.length === holdingWords && after.every(Boolean);
+        const heldBefore = start === 0 ? held : matches[start - 1] === true;
+        const first = words[start];
+        const last = words[end - 1];
+        if (first === undefined ||
+            last === undefined ||
+            end - start > theirWayWords ||
+            last.end - first.start > theirWaySeconds)
+            return undefined;
+        if (!heldAfter) {
+            // Nothing after it in this window: the next window starts before the run.
+            keep = start;
+            break;
+        }
+        if (!heldBefore)
+            return undefined;
+        start = end;
+    }
+    if (keep < holdingWords)
+        return undefined;
+    return words
+        .slice(0, keep)
+        .map((word, index) => (matches[index] ? word : { ...word, confidence: 0 }));
 }
 function accepted(logits, frames, candidate, complete, cutoff, spec, maximumError = spec.gates.maximumError) {
     const words = alignWindow(logits, frames, candidate, complete, spec).words.filter((word) => word.end <= cutoff);
@@ -89,10 +168,14 @@ function accepted(logits, frames, candidate, complete, cutoff, spec, maximumErro
     return words;
 }
 export function greedy(logits, frames, spec = englishSpec) {
+    return greedyBetween(logits, 0, frames, spec);
+}
+// What the model heard between two frames.
+function greedyBetween(logits, from, to, spec = englishSpec) {
     const labels = spec.labels;
     let previous = -1;
     let text = "";
-    for (let frame = 0; frame < frames; frame += 1) {
+    for (let frame = from; frame < to; frame += 1) {
         let best = 0;
         for (let label = 1; label < labels; label += 1)
             if ((logits[frame * labels + label] ?? -Infinity) > (logits[frame * labels + best] ?? -Infinity))

package/dist/adapters/alignment/worker.js

@@ -74,7 +74,7 @@ async function run(input) {
             const stuck = () => new SubtitleMismatch(mismatch, sampleAt / sampleRate, snippet(candidate.map((word) => word.text)), snippet(observed.split(/\s+/)));
             let recovered;
             try {
-                recovered = alignSpeechWindow(logits.data, frames, candidate, complete, cutoff, cursor === 0 ? 0 : omissionBudget - omitted, spec);
+                recovered = alignSpeechWindow(logits.data, frames, candidate, complete, cutoff, cursor === 0 ? 0 : omissionBudget - omitted, spec, cursor > 0);
             }
             catch (error) {
                 if (error instanceof Error && error.message === mismatch)

package/dist/edge/http/files.js

@@ -4,6 +4,7 @@ import { z } from "zod";
 import { findDownload, imagesZip } from "../../slices/storage/downloads.js";
 import { fileResponse } from "./byte-range.js";
 import { onInvalid, problem, titleOf } from "./problem.js";
+import { waveformAnswer } from "./waveform.js";
 const projectParam = z.object({
     projectId: z
         .string()
@@ -21,6 +22,7 @@ const assetParam = projectParam.extend({
 // The return type is inferred so Hono keeps the route types; see stagingRoutes.
 export function fileRoutes(deps) {
     const storage = { db: deps.db, paths: deps.paths };
+    const waveform = waveformAnswer(deps.decodePeaks);
     return (new Hono()
         // Declared before :asset so the zip is never read as an asset name.
         .get("/files/:projectId/images.zip", zValidator("param", projectParam, onInvalid), (c) => {
@@ -34,13 +36,19 @@ export function fileRoutes(deps) {
             "content-disposition": disposition(result.filename),
         });
     })
-        .get("/files/:projectId/:asset", zValidator("param", assetParam, onInvalid), (c) => {
+        .get("/files/:projectId/:asset", zValidator("param", assetParam, onInvalid), async (c) => {
         const { projectId, asset } = c.req.valid("param");
         const result = findDownload(storage, projectId, asset);
         if (!result.ok) {
             return missing(c, result.reason);
         }
         const { download } = result;
+        // `?waveform=N`: the audio player's bars instead of the file.
+        if (download.text === undefined) {
+            const bars = await waveform(c, download);
+            if (bars !== undefined)
+                return bars;
+        }
         // The YouTube description and tags as the page shows them, edits and links in.
         if (download.text !== undefined)
             return c.body(download.text, 200, {

package/dist/edge/http/revision-files.js

@@ -5,6 +5,7 @@ import { findRevisionDownload, revisionImagesZip } from "../../slices/revisions/
 import { fileResponse } from "./byte-range.js";
 import { replyForFolder } from "./folder-location.js";
 import { onInvalid, problem, titleOf } from "./problem.js";
+import { waveformAnswer } from "./waveform.js";
 const id = z
     .string()
     .min(1)
@@ -14,6 +15,7 @@ const revisionParam = z.object({ projectId: id, revisionId: id });
 const recordParam = revisionParam.extend({ recordId: id });
 const folderParam = z.object({ id, revisionId: id, recordId: id });
 export function revisionFileRoutes(deps) {
+    const waveform = waveformAnswer(deps.decodePeaks);
     return new Hono()
         .get("/files/:projectId/revisions/:revisionId/images.zip", zValidator("param", revisionParam, onInvalid), (c) => {
         const { projectId, revisionId } = c.req.valid("param");
@@ -26,12 +28,16 @@ export function revisionFileRoutes(deps) {
             "content-disposition": `attachment; filename="${result.filename}"`,
         });
     })
-        .get("/files/:projectId/revisions/:revisionId/:recordId", zValidator("param", recordParam, onInvalid), (c) => {
+        .get("/files/:projectId/revisions/:revisionId/:recordId", zValidator("param", recordParam, onInvalid), async (c) => {
         const { projectId, revisionId, recordId } = c.req.valid("param");
         const result = findRevisionDownload(deps, projectId, revisionId, recordId);
         if (!result.ok)
             return unavailable(c, result.reason);
         const value = result.download;
+        // `?waveform=N`: the audio player's bars instead of the file.
+        const bars = await waveform(c, value);
+        if (bars !== undefined)
+            return bars;
         // `?inline=1` lets the project page open a PDF in a browser tab instead of saving
         // it. Only PDFs: anything else the browser might render stays a download.
         const inline = c.req.query("inline") === "1" && value.contentType === "application/pdf";

package/dist/edge/http/waveform.js

@@ -0,0 +1,77 @@
+import { problem, titleOf } from "./problem.js";
+// The audio player's waveform: `?waveform=N` on a file's own URL answers the file's loudness
+// as N bars from 0 to 1, instead of the file. The peaks come from the same ffmpeg decode as the
+// live view's waveform (`slices/narration/peaks.ts`), ten a second, folded to N.
+// ceiling: bars a player asks for; its track is a few hundred pixels at the widest.
+export const waveformBarsMax = 2000;
+// ceiling: files whose peaks stay in memory. A file keeps its path and size until it is
+// replaced, so a cached row is keyed by both; the oldest goes first.
+const cachedFiles = 100;
+// The average of each of `bars` equal runs of `peaks`; fewer peaks than bars are kept as they
+// are. The average, not the loudest: a long narration's every run has a loud word in it, so
+// the loudest made every bar full height, and the average shows where it is quiet.
+export function foldPeaks(peaks, bars) {
+    if (peaks.length <= bars)
+        return peaks;
+    const step = peaks.length / bars;
+    return Array.from({ length: bars }, (_value, bar) => {
+        const from = Math.floor(bar * step);
+        const end = Math.max(from + 1, Math.min(peaks.length, Math.floor((bar + 1) * step)));
+        let sum = 0;
+        for (let at = from; at < end; at++)
+            sum += peaks[at] ?? 0;
+        return Math.round((sum / (end - from)) * 1000) / 1000;
+    });
+}
+// The answer to a file request asking for its waveform, or undefined when it does not ask.
+export function waveformAnswer(decode) {
+    const cache = new Map();
+    return async (c, file) => {
+        const raw = c.req.query("waveform");
+        if (raw === undefined)
+            return undefined;
+        const bars = Number(raw);
+        if (!Number.isInteger(bars) || bars < 1 || bars > waveformBarsMax)
+            return problem(c, {
+                status: 400,
+                title: titleOf(400),
+                detail: `Ask for a waveform of 1 to ${String(waveformBarsMax)} bars.`,
+            });
+        if (!file.contentType.startsWith("audio/"))
+            return problem(c, {
+                status: 400,
+                title: titleOf(400),
+                detail: "Only an audio file has a waveform. This file plays without one.",
+            });
+        if (decode === undefined)
+            return problem(c, {
+                status: 503,
+                title: titleOf(503),
+                detail: "Slopify can't draw the waveform because ffmpeg isn't available. The audio still plays. Restart Slopify; if it keeps happening, use Download diagnostics in Settings and report it.",
+            });
+        const key = `${file.path}\0${String(file.bytes)}`;
+        let waveform = cache.get(key);
+        if (waveform === undefined) {
+            try {
+                waveform = await decode(file.path, c.req.raw.signal);
+            }
+            catch (error) {
+                return problem(c, {
+                    status: 500,
+                    title: titleOf(500),
+                    detail: `Slopify couldn't read this audio to draw its waveform (${error instanceof Error ? error.message : String(error)}). The audio still plays.`,
+                });
+            }
+            cache.set(key, waveform);
+            while (cache.size > cachedFiles) {
+                const oldest = cache.keys().next().value;
+                if (oldest !== undefined)
+                    cache.delete(oldest);
+            }
+        }
+        return c.json({
+            seconds: waveform.seconds,
+            peaks: foldPeaks(waveform.peaks, bars),
+        });
+    };
+}

package/dist/{adapters/alignment/numbers.js → kernel/ports/number-words.js}

@@ -1,3 +1,6 @@
+// English number words, as a narrator reads digits: subtitle timing matches them against the
+// audio (`adapters/alignment/text.ts`) and the pauses weigh a sentence by how long it takes to
+// say (`slices/narration/pauses.ts`).
 const small = [
     "ZERO",
     "ONE",
@@ -79,13 +82,24 @@ export function numberForms(raw) {
             .map((digit) => small[Number(digit)])
             .join(" ")}`;
     const ordinary = `${cardinal(value)}${decimal}`;
-    const year = value >= 1900 && value <= 2099 && value % 100 >= 10
-        ? `${cardinal(Math.floor(value / 100))} ${cardinal(value % 100)}`
-        : undefined;
-    const forms = year === undefined ? [ordinary] : [year, ordinary];
+    const forms = [...(fraction === undefined ? yearForms(value) : []), ordinary];
     if (suffix === "s")
         return forms.map((form) => `${form.replace(/Y$/, "IE")}S`);
     if (suffix !== undefined)
         return forms.map((form) => form.replace(/[A-Z]+$/, (word) => ordinal[word] ?? (word.endsWith("Y") ? `${word.slice(0, -1)}IETH` : `${word}TH`)));
     return forms;
 }
+// A four-digit number said as a year: "eleven fifty seven", "eleven o four", "thirteen hundred".
+// Any year from 1000 is read this way, not only this age's: a history or a fantasy setting's
+// calendar ("the year 1104") has them all through it. 2000 to 2009 are "two thousand four".
+function yearForms(value) {
+    if (value < 1000 || value > 2099 || (value >= 2000 && value <= 2009))
+        return [];
+    const century = cardinal(Math.floor(value / 100));
+    const rest = value % 100;
+    if (rest === 0)
+        return [`${century} HUNDRED`];
+    if (rest < 10)
+        return [`${century} O ${cardinal(rest)}`, `${century} OH ${cardinal(rest)}`];
+    return [`${century} ${cardinal(rest)}`];
+}

package/dist/patch-notes/3.0.4.md

@@ -0,0 +1,50 @@
+# Slopify 3.0.4
+
+Released 28 September 2026.
+
+3.0.4 keeps long videos moving: subtitles stay in sync through hard stretches instead of stopping the video, Slopify no longer freezes during a long run, and audiobooks and podcasts sound even from one voice to the next. Play's settings are laid out in one tidy grid.
+
+## Highlights
+
+- **Subtitles stay in sync** through years, names and abbreviations the voice says its own way.
+- **No more freezes** while a long video is being made.
+- **Even voices** in audiobooks and podcasts: every line within 1 LU of the narrator.
+- **Visible buttons** to make a stage again, and **a waveform** in the audio player.
+
+## Subtitles
+
+- Years from 1000 on are read as a narrator says them ("eleven fifty seven", "eleven o four", "thirteen hundred"), so history and fantasy dates match their narration.
+- A short stretch the voice says differently from the text, such as a name or an abbreviation, is placed between the words around it rather than stopping the video.
+- When timing does stop, the message says where to listen, and to regenerate the chunk only if words are missing; a voice that read it right, just another way, reads it the same way again.
+
+## Speed
+
+- Slopify no longer stops answering for seconds at a time while a long video is made. The article used to be read again from scratch several times a step.
+
+## Audiobooks and podcasts
+
+- Every speaker's line is levelled to within 1 LU of the narrator's in the audio export, the MP3 and M4B and the video, so no character sits louder than the narrator. The gain changes in the pause between lines and the captions keep their timing.
+- With several speakers the single voice at the top of Narration is hidden when there is no intro or outro, and labelled **Intro and outro voice** when there is.
+- When a provided book only needs a text model to work out who speaks each line, **Text generation** shows under Narration and says what it is used for.
+- **Script by speaker** is in the Download menus of Narration and Article.
+
+## Project page
+
+- Making a whole stage again is a button on its section: **Export the audio again**, **Render the video again**, **Render the PDF again** and the rest. Each still asks first.
+- The Narration stage says when it plays a levelled narration an edit made outdated, and plays the new one beside it until the run levels it.
+- A paused run lists what it still has to make.
+- When the Library's intro or outro has changed since a project copied it, its picker in **Edit settings** lists both: **this project's version** and the **Library version (newer)**. Prompts under **Prompts** say so too, with **Use the Library version** or **Keep this project's version**. Intros and outros were missed before.
+- The audio player shows the narration's waveform.
+
+## Play
+
+- Every section's settings sit in one grid: labels above, equal columns, three or four across a wide screen. Every dropdown and number box is the same size, and image prompts line up in columns.
+
+## Fixes
+
+- The PDF's Sources page reads as text; only the web addresses are links, and an entry that cites several addresses links every one.
+- Pauses between sentences weigh a number by how long it takes to say, skip a name's initial and never lengthen the short breath between two words.
+
+## Upgrading from 3.0.3
+
+- **Nothing becomes outdated.** Audiobooks and podcasts made before get the even voices when their audio is exported again (**Export the audio again**).

package/dist/patch-notes/index.json

@@ -1,4 +1,10 @@
 [
+  {
+    "id": "3.0.4",
+    "title": "Slopify 3.0.4",
+    "version": "3.0.4",
+    "date": "2026-09-28"
+  },
   {
     "id": "3.0.3",
     "title": "Slopify 3.0.3",

package/dist/slices/admission/rules.js

@@ -83,17 +83,7 @@ export function admit(input) {
             });
         }
     }
-    // The LLM row is required only when something in the run actually asks an LLM for text.
-    const needsLlm = sources.research === "generate" ||
-        sources.article === "generate" ||
-        sources.thumbnail === "prompt_by_llm" ||
-        draft.intro?.mode === "llm" ||
-        draft.outro?.mode === "llm" ||
-        usesNarrationPreparation(draft) ||
-        usesYoutubeDescription(draft) ||
-        usesShorts(draft) ||
-        (usesVoices(draft) && draft.voices?.source === "attribute");
-    if (needsLlm && !chosen(draft.llm)) {
+    if (needsLlmFor(draft) && !chosen(draft.llm)) {
         fields.push({ field: "llm", message: "Choose a text (LLM) provider and model." });
     }
     if (sources.article === "generate" && blank(draft.articlePrompt)) {
@@ -323,6 +313,32 @@ function checkValues(draft, requiredSlots, fields) {
 function blank(value) {
     return value === undefined || value.trim() === "";
 }
+export function llmUses(draft) {
+    const sources = draft.sources;
+    const uses = [];
+    if (sources.research === "generate")
+        uses.push({ section: "article", label: "researching the topic" });
+    if (sources.article === "generate")
+        uses.push({ section: "article", label: "writing the article" });
+    if (usesVoices(draft) && draft.voices?.source === "attribute")
+        uses.push({ section: "narration", label: "working out who speaks each line" });
+    if (usesNarrationPreparation(draft))
+        uses.push({ section: "narration", label: "preparing the narration's delivery" });
+    if (draft.intro?.mode === "llm")
+        uses.push({ section: "narration", label: "writing the intro" });
+    if (draft.outro?.mode === "llm")
+        uses.push({ section: "narration", label: "writing the outro" });
+    if (sources.thumbnail === "prompt_by_llm")
+        uses.push({ section: "outputs", label: "writing the thumbnail prompt" });
+    if (usesYoutubeDescription(draft))
+        uses.push({ section: "outputs", label: "writing the YouTube description" });
+    if (usesShorts(draft))
+        uses.push({ section: "outputs", label: "picking the shorts" });
+    return uses;
+}
+export function needsLlmFor(draft) {
+    return llmUses(draft).length > 0;
+}
 export function usesNarrationPreparation(draft) {
     return draft.sources.audio === "generate" && !blank(draft.narrationPrompt);
 }

package/dist/slices/article/plain.js

@@ -1,7 +1,26 @@
 import { remark } from "remark";
 import remarkGfm from "remark-gfm";
 import stripMarkdown from "strip-markdown";
+// ceiling: conversions remembered. The same article is converted again every time a run plans
+// its work, which is several times a step; a long article took seconds each time, on the
+// thread that answers the page. The oldest goes first.
+const remembered = 64;
+const conversions = new Map();
 export function plainText(markdown) {
+    const known = conversions.get(markdown);
+    if (known !== undefined)
+        return known;
+    const text = convert(markdown);
+    conversions.set(markdown, text);
+    while (conversions.size > remembered) {
+        const oldest = conversions.keys().next().value;
+        if (oldest === undefined)
+            break;
+        conversions.delete(oldest);
+    }
+    return text;
+}
+function convert(markdown) {
     const processor = remark().use(remarkGfm).use(stripMarkdown);
     const tree = processor.runSync(processor.parse(markdown));
     const paragraphs = tree.children

package/dist/slices/article/split.js

@@ -8,7 +8,25 @@ const endHeadings = {
     "sources consulted": "sources",
     "pronunciation glossary": "glossary",
 };
+// ceiling: articles whose split is remembered; a run plans from the same article again and
+// again (`plain.ts` says why that matters). The oldest goes first.
+const rememberedSplits = 16;
+const splits = new Map();
 export function splitEndMatter(markdown) {
+    const known = splits.get(markdown);
+    if (known !== undefined)
+        return known;
+    const split = splitOnce(markdown);
+    splits.set(markdown, split);
+    while (splits.size > rememberedSplits) {
+        const oldest = splits.keys().next().value;
+        if (oldest === undefined)
+            break;
+        splits.delete(oldest);
+    }
+    return split;
+}
+function splitOnce(markdown) {
     const marks = endMatterMarks(markdown);
     const first = marks[0];
     if (first === undefined) {
@@ -43,7 +61,22 @@ function endMatterMarks(markdown) {
     }
     return marks;
 }
+// Each end heading's letters, in order: a paragraph whose letters don't hold one of these in
+// order can't be that heading, so it is never converted. Most of an article is such text.
+const headingLetters = Object.keys(endHeadings).map((heading) => heading.replace(/[^a-z]/g, ""));
+function mightBeHeading(source) {
+    const letters = source.toLowerCase().replace(/[^a-z]/g, "");
+    return headingLetters.some((wanted) => {
+        let at = 0;
+        for (const letter of letters)
+            if (letter === wanted[at])
+                at += 1;
+        return at >= wanted.length;
+    });
+}
 function partOf(source) {
+    if (!mightBeHeading(source))
+        return undefined;
     // The heading's own markup is dropped by the same conversion the narration source uses,
     // so nothing here has to know what a heading looks like.
     const heading = plainText(source).trim().toLowerCase().replace(/:$/, "");

package/dist/slices/document/pages.js

@@ -1,4 +1,4 @@
-import { useFace } from "./fonts.js";
+import { faceWidth, useFace } from "./fonts.js";
 const dateFormat = new Intl.DateTimeFormat("en-US", {
     year: "numeric",
     month: "long",
@@ -127,11 +127,40 @@ export function sourcesPage(w, items) {
         const lines = doc.splitTextToSize(item.text, w.contentWidth - bullet - 5);
         w.ensure(sources.line);
         w.write("•", w.left, w.y, fonts.body, sizes.body, "muted");
+        // The entry reads as text; only its addresses are links, each in the link colour and
+        // pointing at itself. An entry whose address isn't in its words (a titled link) is
+        // clickable as a whole, still in text colour.
+        const addresses = [...item.text.matchAll(/https?:\/\/[^\s)>\]]+/g)].map((match) => ({
+            from: match.index,
+            to: match.index + match[0].replace(/[.,;:]+$/, "").length,
+            url: match[0].replace(/[.,;:]+$/, ""),
+        }));
+        const width = (text) => faceWidth(doc, fonts.body, sizes.body, text);
+        let cursor = 0;
         for (const line of lines) {
             w.ensure(sources.line);
-            w.write(line, w.left + bullet, w.y, fonts.body, sizes.body, item.href === null ? "text" : "heading");
-            if (item.href !== null)
-                doc.link(w.left + bullet, w.y - 5, doc.getTextWidth(line), 7, { url: item.href });
+            const start = Math.max(cursor, item.text.indexOf(line, cursor));
+            cursor = start + line.length;
+            let x = w.left + bullet;
+            let at = 0;
+            const draw = (text, color, url) => {
+                if (text === "")
+                    return;
+                w.write(text, x, w.y, fonts.body, sizes.body, color);
+                if (url !== undefined)
+                    doc.link(x, w.y - 5, width(text), 7, { url });
+                x += width(text);
+            };
+            for (const address of addresses) {
+                const from = Math.min(line.length, Math.max(at, address.from - start));
+                const to = Math.min(line.length, Math.max(from, address.to - start));
+                if (to <= from)
+                    continue;
+                draw(line.slice(at, from), "text");
+                draw(line.slice(from, to), "heading", address.url);
+                at = to;
+            }
+            draw(line.slice(at), "text", addresses.length === 0 && item.href !== null ? item.href : undefined);
             w.y += sources.line;
         }
         w.y += sources.gap;