@gentbajko/slopify 2.1.1 → 2.2.0

package/dist/assets/document/SOURCE.txt

@@ -5,3 +5,7 @@ SHA-256: 18f9701b476f299e942cbb99c05ba3267d8341df2b6136e3aebbafad83b03b31
 
 fonts/
 Cinzel, SIL Open Font License 1.1: see fonts/SOURCE.txt and fonts/OFL.txt.
+
+sample-cover.jpg
+A plain gradient made with ImageMagick for the Library theme preview, standing in for a project's
+thumbnail. No third-party content.

package/dist/edge/http/app.js

@@ -6,6 +6,7 @@ import { actionRoutes } from "./actions.js";
 import { audioPreviewRoutes } from "./audio-preview.js";
 import { checkpointRoutes } from "./checkpoints.js";
 import { diagnosticsRoutes } from "./diagnostics.js";
+import { documentThemeRoutes } from "./document-themes.js";
 import { draftRoutes } from "./drafts.js";
 import { entryRoutes } from "./entries.js";
 import { fileRoutes } from "./files.js";
@@ -16,6 +17,7 @@ import { problem, problemFromError, titleOf } from "./problem.js";
 import { projectTemplateRoutes } from "./project-templates.js";
 import { projectRoutes } from "./projects.js";
 import { promptRoutes } from "./prompts.js";
+import { pronunciationRoutes } from "./pronunciations.js";
 import { providerRoutes } from "./providers.js";
 import { revisionFileRoutes, revisionFolderRoutes } from "./revision-files.js";
 import { revisionRoutes } from "./revisions.js";
@@ -58,6 +60,8 @@ function apiRoutes(deps, startedAt) {
         .route("/fonts", fontsRoutes(deps))
         .route("/prompts", promptRoutes(deps))
         .route("/entries", entryRoutes(deps))
+        .route("/document-themes", documentThemeRoutes(deps))
+        .route("/pronunciations", pronunciationRoutes(deps))
         .route("/telemetry", telemetryRoutes(deps))
         .route("/usage", usageRoutes(deps))
         .route("/settings", settingsRoutes(deps))

package/dist/edge/http/document-themes.js

@@ -0,0 +1,80 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { z } from "zod";
+import { createDocumentTheme, listDocumentThemes, removeDocumentTheme, updateDocumentTheme, } from "../../slices/document/library.js";
+import { documentThemeLabels, documentThemes } from "../../slices/document/model.js";
+import { renderSampleDocument } from "../../slices/document/sample.js";
+import { builtInTheme, resolveTheme } from "../../slices/document/theme.js";
+import { documentThemeSchema } from "../../slices/document/theme-schema.js";
+import { onInvalid, problem, titleOf } from "./problem.js";
+const idParam = z.object({
+    id: z
+        .string()
+        .min(1)
+        .max(64)
+        .regex(/^[0-9A-Za-z_-]+$/),
+});
+// Shape only: the values' ranges are the slice's, so the editor gets field-by-field sentences.
+const themeBody = z.object({ name: z.string(), values: z.unknown() });
+// Library → Documents. The return type is inferred so Hono keeps the route types the SPA's
+// client is generated from; see stagingRoutes.
+export function documentThemeRoutes(deps) {
+    const library = { db: deps.db, ids: deps.ids, clock: deps.clock };
+    return (new Hono()
+        // The built-ins come with their values, so Duplicate starts from them.
+        .get("/", (c) => c.json({
+        builtIns: documentThemes.map((name) => ({
+            name,
+            label: documentThemeLabels[name],
+            values: builtInTheme(name),
+        })),
+        themes: listDocumentThemes(deps.db),
+    }))
+        .post("/", zValidator("json", themeBody, onInvalid), (c) => {
+        const result = createDocumentTheme(library, c.req.valid("json"));
+        return result.ok ? c.json(result.value, 201) : refused(c, result);
+    })
+        .put("/:id", zValidator("param", idParam, onInvalid), zValidator("json", themeBody, onInvalid), (c) => {
+        const result = updateDocumentTheme(library, c.req.valid("param").id, c.req.valid("json"));
+        return result.ok ? c.json(result.value) : refused(c, result);
+    })
+        // A project keeps its own copy of a theme's values, so nothing cascades.
+        .delete("/:id", zValidator("param", idParam, onInvalid), (c) => {
+        const result = removeDocumentTheme(library, c.req.valid("param").id);
+        return result.ok ? c.body(null, 204) : refused(c, result);
+    })
+        // The editor's live preview: the sample article laid out with unsaved values.
+        .post("/preview", zValidator("json", z.object({ values: documentThemeSchema }), onInvalid), (c) => {
+        const rendered = renderSampleDocument(resolveTheme(c.req.valid("json").values));
+        return c.body(rendered.bytes.slice().buffer, 200, {
+            "Content-Type": "application/pdf",
+            "Cache-Control": "no-store",
+        });
+    }));
+}
+function refused(c, failure) {
+    switch (failure.reason) {
+        case "invalid":
+            return problem(c, {
+                status: 400,
+                title: titleOf(400),
+                detail: "This theme can't be saved yet. Fix the highlighted settings and try again.",
+                extensions: { fields: failure.fields },
+            });
+        case "duplicate-name": {
+            const message = "Another document theme already has this name. Choose a different name.";
+            return problem(c, {
+                status: 409,
+                title: titleOf(409),
+                detail: message,
+                extensions: { fields: [{ field: "name", message }] },
+            });
+        }
+        case "not-found":
+            return problem(c, {
+                status: 404,
+                title: titleOf(404),
+                detail: "This document theme no longer exists; it may have been deleted in another tab. Go back to Library → Documents.",
+            });
+    }
+}

package/dist/edge/http/pronunciations.js

@@ -0,0 +1,17 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { z } from "zod";
+import { collectSharedGlossary } from "../../slices/narration/shared-glossary.js";
+import { onInvalid } from "./problem.js";
+// The pronunciations of every project's glossary, merged, for Edit project to copy into a
+// project that shares them. `except` leaves out the project being edited, whose own glossary
+// already comes first.
+export function pronunciationRoutes(deps) {
+    return new Hono().get("/shared", zValidator("query", z.object({
+        except: z
+            .string()
+            .max(64)
+            .regex(/^[0-9A-Za-z_-]*$/)
+            .optional(),
+    }), onInvalid), (c) => c.json(collectSharedGlossary(deps, c.req.valid("query").except)));
+}

package/dist/kernel/db/migrations/0016-document-themes.sql

@@ -0,0 +1,10 @@
+-- Document themes saved in Library → Documents. A project keeps its own copy of the values
+-- it was given, so nothing references these rows and a delete never cascades.
+CREATE TABLE document_themes (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  values_json TEXT NOT NULL CHECK (json_valid(values_json)),
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+CREATE UNIQUE INDEX document_themes_name ON document_themes(lower(name));

package/dist/slices/admission/schema.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { thinkingModes } from "../../kernel/ports/llm.js";
 import { checkpointStageSchema } from "../checkpoints/schema.js";
-import { documentThemes } from "../document/model.js";
+import { documentSettingsSchema } from "../document/theme-schema.js";
 import { chunkModes } from "../narration/chunk.js";
 import { subtitleConfigSchema } from "../subtitles/model.js";
 import { entryModes, formats, motionStyles, stageSources } from "./model.js";
@@ -37,7 +37,19 @@ export const runDraftSchema = z.object({
     }),
     llm: providerChoice.optional(),
     audio: providerChoice
-        .extend({ voice: z.string(), usePronunciationGlossary: z.boolean().optional() })
+        .extend({
+        voice: z.string(),
+        usePronunciationGlossary: z.boolean().optional(),
+        shareGlossary: z.boolean().optional(),
+    })
+        .optional(),
+    sharedGlossary: z
+        .array(z.object({
+        term: z.string().min(1).max(200),
+        ipa: z.array(z.string().min(1).max(200)).min(1).max(20).readonly(),
+    }))
+        .max(20000)
+        .readonly()
         .optional(),
     images: providerChoice.optional(),
     articlePrompt: z.string().optional(),
@@ -71,7 +83,7 @@ export const runDraftSchema = z.object({
     motionStyle: z.enum(motionStyles).default(defaultMotionStyle),
     edgeSilenceSeconds: z.number().default(defaultEdgeSilenceSeconds),
     subtitles: subtitleConfigSchema.optional(),
-    document: z.object({ theme: z.enum(documentThemes) }).optional(),
+    document: documentSettingsSchema.optional(),
     youtubeDescription: z.boolean().optional(),
     descriptionPrompt: z.string().optional(),
 });

package/dist/slices/admission/start.js

@@ -1,12 +1,14 @@
 import { transact } from "../../kernel/db/tx.js";
 import { stageKinds } from "../../kernel/pipeline.js";
 import { storeArticleText } from "../article/store.js";
+import { collectSharedGlossary } from "../narration/shared-glossary.js";
 import { admitInitialRevision } from "../rebuild/runtime-admission.js";
 import { adoptBaseline } from "../revisions/adopt.js";
 import { attachStagedFile, storeText } from "../storage/staging.js";
 import { releaseStagedFile } from "../storage/staging-refs.js";
 import { sourceOf, } from "./model.js";
 import { insertProject, insertStage } from "./repo.js";
+import { usesPronunciationGlossary } from "./rules.js";
 // Provide → `provided` with its output attached; Off → `skipped`;
 // everything else → `pending`.
 export function initialState(source) {
@@ -20,7 +22,14 @@ export function initialState(source) {
 export function startRun(deps, draft, rendered, retainStaged = false, templates) {
     const id = deps.ids.next();
     const at = deps.clock.now().toISOString();
-    const config = { ...draft, rendered };
+    const shared = usesPronunciationGlossary(draft) && draft.audio?.shareGlossary === true
+        ? collectSharedGlossary(deps).entries
+        : [];
+    const config = {
+        ...draft,
+        rendered,
+        ...(shared.length === 0 ? {} : { sharedGlossary: shared }),
+    };
     const project = {
         id,
         title: draft.title,

package/dist/slices/article/source-lines.js

@@ -0,0 +1,20 @@
+// The entries of an article's "Sources Consulted" section, one per source. Models write the
+// list as bullets, as numbered lines, or as plain lines with no blank line between them;
+// markdown would join the last kind into one paragraph, so the section is read line by line
+// instead. A line indented under an entry continues it. The section starts with its own
+// heading (`splitEndMatter` cuts it there), which is not an entry. Browser-safe: the project
+// page lists the same entries the PDF prints.
+const marker = /^(?:[-*+]|\d+[.)])\s+/u;
+export function sourceEntries(section) {
+    const lines = section.split(/\r?\n/u).filter((line) => line.trim() !== "");
+    const entries = [];
+    for (const raw of lines.slice(1)) {
+        const line = raw.trim().replace(marker, "").trim();
+        const last = entries.length - 1;
+        if (/^\s/u.test(raw) && !marker.test(raw.trim()) && last >= 0)
+            entries[last] = `${entries[last] ?? ""} ${line}`;
+        else if (line !== "")
+            entries.push(line);
+    }
+    return entries;
+}

package/dist/slices/document/library.js

@@ -0,0 +1,77 @@
+import { isUniqueConstraint } from "../../kernel/db/index.js";
+import { documentThemeNameProblems } from "./model.js";
+import { documentThemeSchema } from "./theme-schema.js";
+export function listDocumentThemes(db) {
+    return db
+        .prepare("SELECT id,name,values_json,updated_at FROM document_themes ORDER BY lower(name),id")
+        .all()
+        .flatMap((row) => {
+        // A row whose values no longer parse (hand-edited, or from a newer Slopify) is left
+        // out rather than breaking the whole list.
+        const values = documentThemeSchema.safeParse(JSON.parse(String(row.values_json)));
+        return values.success
+            ? [
+                {
+                    id: String(row.id),
+                    name: String(row.name),
+                    values: values.data,
+                    updatedAt: String(row.updated_at),
+                },
+            ]
+            : [];
+    });
+}
+export function createDocumentTheme(deps, draft) {
+    const checked = check(draft);
+    if (!checked.ok)
+        return checked;
+    const now = deps.clock.now().toISOString();
+    const theme = { id: deps.ids.next(), ...checked.value, updatedAt: now };
+    return written(() => {
+        deps.db
+            .prepare("INSERT INTO document_themes(id,name,values_json,created_at,updated_at) VALUES (?,?,?,?,?)")
+            .run(theme.id, theme.name, JSON.stringify(theme.values), now, now);
+        return true;
+    }, theme);
+}
+export function updateDocumentTheme(deps, id, draft) {
+    const checked = check(draft);
+    if (!checked.ok)
+        return checked;
+    const now = deps.clock.now().toISOString();
+    const theme = { id, ...checked.value, updatedAt: now };
+    return written(() => deps.db
+        .prepare("UPDATE document_themes SET name=?,values_json=?,updated_at=? WHERE id=?")
+        .run(theme.name, JSON.stringify(theme.values), now, id).changes > 0, theme);
+}
+export function removeDocumentTheme(deps, id) {
+    return deps.db.prepare("DELETE FROM document_themes WHERE id=?").run(id).changes > 0
+        ? { ok: true, value: null }
+        : { ok: false, reason: "not-found" };
+}
+function check(draft) {
+    const named = documentThemeNameProblems(draft.name);
+    const values = documentThemeSchema.safeParse(draft.values);
+    const fields = [
+        ...named,
+        ...(values.success
+            ? []
+            : values.error.issues.map((issue) => ({
+                field: `values.${issue.path.join(".")}`,
+                message: issue.message,
+            }))),
+    ];
+    if (fields.length > 0 || !values.success)
+        return { ok: false, reason: "invalid", fields };
+    return { ok: true, value: { name: draft.name.trim(), values: values.data } };
+}
+function written(write, value) {
+    try {
+        return write() ? { ok: true, value } : { ok: false, reason: "not-found" };
+    }
+    catch (error) {
+        if (isUniqueConstraint(error))
+            return { ok: false, reason: "duplicate-name" };
+        throw error;
+    }
+}

package/dist/slices/document/model.js

@@ -9,3 +9,22 @@ export const documentThemeLabels = {
 export function documentThemeOf(settings) {
     return settings?.theme ?? defaultDocumentTheme;
 }
+// The name a project's theme is shown by: the Library theme's own, or the built-in's label.
+export function documentThemeLabel(settings) {
+    return settings?.custom?.name ?? documentThemeLabels[documentThemeOf(settings)];
+}
+export const documentThemeNameMax = 80;
+// The editor's sentences for a name, shared so the page refuses what the server would.
+export function documentThemeNameProblems(name) {
+    const trimmed = name.trim();
+    if (trimmed === "")
+        return [{ field: "name", message: "Give the theme a name." }];
+    if (trimmed.length > documentThemeNameMax)
+        return [
+            {
+                field: "name",
+                message: `Keep the name under ${String(documentThemeNameMax)} characters.`,
+            },
+        ];
+    return [];
+}

package/dist/slices/document/sample.js

@@ -0,0 +1,51 @@
+import { readFileSync } from "node:fs";
+import { readDocumentAssets } from "./fonts.js";
+import { renderDocument } from "./render.js";
+// What the Library theme editor previews: a short article with every kind of block the
+// renderer styles (levels of heading, a drop-cap paragraph, emphasis, a link, a list, a
+// quote, a rule and a sources list), a stand-in cover and a fixed date, so only the theme
+// changes between previews.
+const title = "The Lighthouse at Grey Point";
+const article = `# ${title}
+
+The lighthouse at Grey Point has warned ships off the northern reef for nearly two centuries, and its keepers kept **careful logs** of every storm, wreck and *strange light* seen from the gallery. Most of those logs survive in the [county archive](https://example.com/archive), and they read like a slow, patient novel.
+
+## Chapter 1: The First Keepers
+
+The first keeper arrived in the spring with a wife, two children and a crate of lamp oil that was meant to last the winter. It lasted six weeks, and the rest of that season was lit by whale oil bought from passing boats at ruinous prices.
+
+- The tower was finished in 1834
+- The lamp was replaced twice before 1900
+- The last keeper left in 1961
+
+> The sea does not care what the light costs.
+
+### A note on the logs
+
+Entries are short, written in pencil, and nearly always begin with the wind.
+
+## Chapter 2: The Automatic Light
+
+When the light was automated, the cottage stood empty for thirty years. Walkers still report seeing a lamp in its window on winter evenings, although the power was cut long ago and the door has been bricked up since the last survey.
+
+---
+
+The tower is open to visitors on summer weekends.
+
+## Sources Consulted
+
+- [County Archive: Grey Point Logs](https://example.com/logs)
+- Coastal Lights of the North, second edition
+`;
+const cover = new URL("../../assets/document/sample-cover.jpg", import.meta.url);
+export function renderSampleDocument(theme) {
+    return renderDocument({
+        title,
+        articleMarkdown: article,
+        researchNotes: null,
+        cover: new Uint8Array(readFileSync(cover)),
+        theme,
+        writtenOn: new Date("2026-01-15T12:00:00Z"),
+        assets: readDocumentAssets(),
+    });
+}

package/dist/slices/document/sources.js

@@ -1,3 +1,4 @@
+import { sourceEntries } from "../article/source-lines.js";
 import { splitEndMatter } from "../article/split.js";
 import { markdownBlocks, markdownLinks, runsText } from "./blocks.js";
 // The pronunciation glossary is narration's business and is left out; the sources section
@@ -16,18 +17,12 @@ export function documentText(articleMarkdown, researchNotes) {
     return { blocks: markdownBlocks(parts.body), sources: [...listed, ...cited] };
 }
 function sourceItems(section) {
-    if (section.trim() === "")
-        return [];
-    // The section's own heading, whether a `#` line or a bold paragraph, is its first block.
-    return markdownBlocks(section)
-        .slice(1)
-        .flatMap((block) => {
-        if (block.kind !== "item" && block.kind !== "paragraph" && block.kind !== "quote")
-            return [];
-        const text = runsText(block.runs).trim();
+    return sourceEntries(section).flatMap((entry) => {
+        const runs = markdownBlocks(entry).flatMap((block) => ("runs" in block ? block.runs : []));
+        const text = runsText(runs).trim();
         if (text === "")
             return [];
-        const href = block.runs.find((run) => run.href !== null)?.href ??
+        const href = runs.find((run) => run.href !== null)?.href ??
             /https?:\/\/[^\s)>\]]+/.exec(text)?.[0] ??
             null;
         return [{ text, href }];

package/dist/slices/document/theme-schema.js

@@ -0,0 +1,172 @@
+import { z } from "zod";
+import { documentThemeNameMax, documentThemes } from "./model.js";
+import { fontFamilies, fontStyles } from "./theme.js";
+// Every value of a document theme with the range the renderer draws sensibly within, so a
+// saved theme, a project config and the editor's preview all refuse the same values.
+// Browser-safe: the Library editor reads the limits from here too.
+const mm = (min, max) => {
+    const range = { error: `Use a value from ${String(min)} to ${String(max)}.` };
+    return z.number({ error: "Enter a number." }).finite(range).min(min, range).max(max, range);
+};
+const color = z.string().regex(/^#?([0-9a-f]{3}|[0-9a-f]{6})$/i, "Use a colour like #8c1e14.");
+const line = z.string().max(300, { error: "Keep this under 300 characters." });
+const nullableLine = line.nullable();
+const url = z.string().max(500, { error: "Keep this under 500 characters." }).nullable();
+const face = z
+    .object({
+    family: z.enum(fontFamilies),
+    style: z.enum(fontStyles),
+    letterSpacing: mm(-0.5, 2),
+})
+    .strict();
+export const documentThemeSchema = z
+    .object({
+    page: z
+        .object({
+        format: z.enum(["a4", "letter"]),
+        margin: mm(5, 60),
+        contentTop: mm(5, 80),
+    })
+        .strict(),
+    background: z.object({ image: z.enum(["parchment"]).nullable(), color }).strict(),
+    colors: z.object({ heading: color, text: color, muted: color, faint: color }).strict(),
+    fonts: z
+        .object({
+        body: face,
+        strong: face,
+        emphasis: face,
+        heading: face,
+        dramatic: face,
+        decorative: face,
+        dropCap: face,
+        footer: face,
+    })
+        .strict(),
+    sizes: z
+        .object({
+        brand: mm(6, 72),
+        title: mm(6, 72),
+        section: mm(6, 72),
+        heading: mm(6, 72),
+        subheading: mm(6, 72),
+        body: mm(6, 24),
+        footer: mm(5, 24),
+        meta: mm(5, 24),
+    })
+        .strict(),
+    spacing: z
+        .object({
+        bodyLine: mm(3, 20),
+        headingLine: mm(3, 30),
+        subheadingLine: mm(3, 30),
+        paragraphGap: mm(0, 3),
+        headingGap: mm(0, 5),
+        itemGap: mm(0, 3),
+        listIndent: mm(0, 30),
+        quoteIndent: mm(0, 40),
+        ruleWidth: mm(0, 150),
+    })
+        .strict(),
+    dropCap: z
+        .object({
+        enabled: z.boolean(),
+        lines: z.union([z.literal(2), z.literal(3), z.literal(4)]),
+        scale: mm(1, 5),
+        gap: mm(0, 20),
+        minLength: z
+            .number({ error: "Enter a number." })
+            .int({ error: "Use a whole number." })
+            .min(0, { error: "Use a value from 0 to 2000." })
+            .max(2000, { error: "Use a value from 0 to 2000." }),
+        minRoom: mm(0, 1),
+    })
+        .strict(),
+    titlePage: z
+        .object({
+        brandY: mm(10, 200),
+        taglineOffset: mm(0, 60),
+        titleY: mm(10, 250),
+        titleLine: mm(3, 40),
+        metaOffset: mm(0, 100),
+        metaLine: mm(3, 30),
+        showDate: z.boolean(),
+        showWordCount: z.boolean(),
+        cover: z.object({ enabled: z.boolean(), gap: mm(0, 40), maxHeight: mm(20, 200) }).strict(),
+    })
+        .strict(),
+    contents: z
+        .object({
+        enabled: z.boolean(),
+        title: line,
+        depth: z.union([z.literal(1), z.literal(2), z.literal(3)]),
+        titleOffset: mm(0, 100),
+        firstEntryOffset: mm(0, 150),
+        line: mm(3, 30),
+        indent: mm(0, 30),
+    })
+        .strict(),
+    header: z
+        .object({
+        enabled: z.boolean(),
+        top: mm(3, 60),
+        maxTitleCharacters: z
+            .number({ error: "Enter a number." })
+            .int({ error: "Use a whole number." })
+            .min(5, { error: "Use a value from 5 to 200." })
+            .max(200, { error: "Use a value from 5 to 200." }),
+    })
+        .strict(),
+    footer: z
+        .object({
+        enabled: z.boolean(),
+        bottom: mm(3, 60),
+        reserve: mm(0, 60),
+        text: line,
+    })
+        .strict(),
+    brand: z
+        .object({
+        name: nullableLine,
+        url,
+        tagline: nullableLine,
+        linkLabel: nullableLine,
+    })
+        .strict(),
+    metadata: z
+        .object({ author: line, subject: line, keywords: z.string().max(1000), creator: line })
+        .strict(),
+    sources: z
+        .object({
+        enabled: z.boolean(),
+        title: line,
+        titleOffset: mm(0, 100),
+        bodyOffset: mm(0, 150),
+        line: mm(3, 30),
+        gap: mm(0, 20),
+    })
+        .strict(),
+    endPage: z
+        .object({
+        enabled: z.boolean(),
+        title: line,
+        titleOffset: mm(0, 100),
+        bodyOffset: mm(0, 150),
+        lines: z.array(line).max(60).readonly(),
+        showDocumentDetails: z.boolean(),
+        link: z.object({ text: line, url }).strict().nullable(),
+        closing: nullableLine,
+    })
+        .strict(),
+})
+    .strict();
+export const customDocumentThemeSchema = z
+    .object({
+    id: z.string().min(1).max(64),
+    name: z.string().min(1).max(documentThemeNameMax),
+    values: documentThemeSchema,
+})
+    .strict();
+// A project's, a draft's and a template's document settings.
+export const documentSettingsSchema = z
+    .object({ theme: z.enum(documentThemes), custom: customDocumentThemeSchema.optional() })
+    .strict();

package/dist/slices/document/theme.js

@@ -1,4 +1,4 @@
-import { defaultDocumentTheme } from "./model.js";
+import { defaultDocumentTheme, documentThemeOf, } 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"];
@@ -122,6 +122,13 @@ const plain = {
 export function builtInTheme(name) {
     return name === "plain" ? resolveTheme(plain) : resolveTheme();
 }
+// The theme a project's document is drawn with: its copy of a Library theme, or a built-in.
+export function resolvedDocumentTheme(settings) {
+    const custom = settings?.custom;
+    return custom === undefined
+        ? builtInTheme(documentThemeOf(settings))
+        : resolveTheme(custom.values);
+}
 export function defaultTheme() {
     return builtInTheme(defaultDocumentTheme);
 }

package/dist/slices/narration/shared-glossary.js

@@ -0,0 +1,51 @@
+import { readFileSync } from "node:fs";
+import { outputPath } from "../storage/layout.js";
+import { parsePronunciationGlossary } from "./pronunciation.js";
+export function collectSharedGlossary(deps, exceptProjectId) {
+    const rows = deps.db
+        .prepare(`SELECT o.project_id AS projectId, a.path AS path FROM revision_outputs o
+       JOIN project_heads h ON h.project_id=o.project_id AND h.revision_id=o.revision_id
+       JOIN project_assets a ON a.id=o.asset_id
+       WHERE o.slot='article:glossary' AND o.selected=1 AND o.state='ready' AND o.project_id<>?
+       ORDER BY o.created_at DESC`)
+        .all(exceptProjectId ?? "");
+    const merged = new Map();
+    const contributors = new Set();
+    for (const row of rows) {
+        const projectId = String(row.projectId);
+        let text;
+        try {
+            text = readFileSync(outputPath(deps.paths, projectId, String(row.path)), "utf8");
+        }
+        catch {
+            // A glossary file removed by hand or by a cleanup has nothing to share.
+            continue;
+        }
+        const parsed = parsePronunciationGlossary(text);
+        // A glossary that doesn't parse can't be trusted in someone else's narration either.
+        if (!parsed.ok)
+            continue;
+        for (const entry of parsed.entries) {
+            const key = glossaryKey(entry.term);
+            if (merged.has(key))
+                continue;
+            merged.set(key, { term: entry.term, ipa: [...entry.ipa] });
+            contributors.add(projectId);
+        }
+    }
+    return {
+        entries: [...merged.values()].sort((a, b) => a.term.localeCompare(b.term)),
+        projects: contributors.size,
+    };
+}
+// A project's own glossary comes first; a shared term it already defines is left out, so
+// there is never a conflict for the parser to refuse.
+export function withSharedGlossary(own, shared) {
+    if (shared === undefined || shared.length === 0)
+        return own;
+    const taken = new Set(own.map((entry) => glossaryKey(entry.term)));
+    return [...own, ...shared.filter((entry) => !taken.has(glossaryKey(entry.term)))];
+}
+function glossaryKey(term) {
+    return term.normalize("NFC").toLocaleLowerCase("en").replace(/\s+/gu, " ").trim();
+}