@gentbajko/slopify 3.9.1 → 3.10.0

package/dist/slices/admission/heads.js

@@ -0,0 +1,59 @@
+import { z } from "zod";
+import { bookSchema } from "../voices/model.js";
+import { formats } from "./model.js";
+import { liveProject } from "./repo.js";
+import { runConfigSchema } from "./schema.js";
+// Every live project for 07 Projects, Home and the command palette, newest first, with only the
+// settings a list row reads. SQLite picks the three values out of the stored configuration, so
+// a list never parses or sends a project's rendered prompts, provided text or episode memory.
+const headRow = z.object({
+    id: z.string(),
+    title: z.string(),
+    format: z.enum(formats),
+    created_at: z.string(),
+    updated_at: z.string(),
+    paused: z.number().default(0),
+    sources: z.string(),
+    article_prompt: z.string().nullable(),
+    book: z.string().nullable(),
+});
+const listingConfigSchema = z.object({
+    sources: runConfigSchema.shape.sources,
+    articlePrompt: z.string().optional(),
+    voices: z.object({ book: bookSchema.optional() }).optional(),
+});
+const headSelect = `SELECT projects.id, projects.title, projects.format, projects.created_at,
+  projects.updated_at, COALESCE(project_controls.paused, 0) AS paused,
+  json_extract(projects.config, '$.sources') AS sources,
+  json_extract(projects.config, '$.articlePrompt') AS article_prompt,
+  json_extract(projects.config, '$.voices.book') AS book
+  FROM projects LEFT JOIN project_controls ON project_controls.project_id = projects.id`;
+export function listProjectHeads(db) {
+    return db
+        .prepare(`${headSelect} WHERE ${liveProject()} ORDER BY created_at DESC, id DESC`)
+        .all()
+        .map((raw) => {
+        const row = headRow.parse(raw);
+        return {
+            id: row.id,
+            title: row.title,
+            format: row.format,
+            config: listingConfigOf(row),
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+            paused: row.paused === 1,
+        };
+    });
+}
+function listingConfigOf(row) {
+    const parsed = listingConfigSchema.parse({
+        sources: JSON.parse(row.sources),
+        ...(row.article_prompt === null ? {} : { articlePrompt: row.article_prompt }),
+        ...(row.book === null ? {} : { voices: { book: JSON.parse(row.book) } }),
+    });
+    return {
+        sources: parsed.sources,
+        ...(parsed.articlePrompt === undefined ? {} : { articlePrompt: parsed.articlePrompt }),
+        ...(parsed.voices?.book === undefined ? {} : { voices: { book: parsed.voices.book } }),
+    };
+}

package/dist/slices/admission/rules.js

@@ -222,7 +222,10 @@ function checkImagePrompts(draft, fields) {
 function checkProvided(draft, staged, fields) {
     const { sources, provided } = draft;
     if (sources.research === "provide" && blank(provided.research)) {
-        fields.push({ field: "provided.research", message: "Paste the research notes." });
+        fields.push({
+            field: "provided.research",
+            message: "Paste the text to adapt, or your research notes.",
+        });
     }
     if (sources.article === "provide" && blank(provided.article)) {
         fields.push({ field: "provided.article", message: "Paste the article." });
@@ -324,6 +327,8 @@ export function llmUses(draft) {
         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 (usesVoices(draft) && draft.voices?.source === "adapt")
+        uses.push({ section: "narration", label: "rewriting the text as a conversation" });
     if (usesNarrationPreparation(draft))
         uses.push({ section: "narration", label: "preparing the narration's delivery" });
     if (draft.intro?.mode === "llm")

package/dist/slices/batch/index.js

@@ -84,3 +84,25 @@ export function pumpQueue(db, runner) {
         return;
     }
 }
+// Batch queue's Up and Down: a video still waiting its turn trades places with the next waiting
+// one before or after it. A video already started (active) or finished keeps its place, so
+// nothing admitted is ever overtaken.
+export function moveQueued(db, projectId, by) {
+    return transact(db, () => {
+        const waiting = queueEntries(db).filter((entry) => entry.state === "queued");
+        const at = waiting.findIndex((entry) => entry.projectId === projectId);
+        if (at === -1)
+            return { ok: false, reason: "not-queued" };
+        const other = waiting[at + by];
+        const self = waiting[at];
+        if (other === undefined || self === undefined)
+            return { ok: false, reason: "edge" };
+        // `position` is the row's key, so the swap goes through a free one.
+        const free = -1 - Math.max(self.position, other.position);
+        const set = db.prepare("UPDATE project_queue SET position = ? WHERE project_id = ?");
+        set.run(free, self.projectId);
+        set.run(self.position, other.projectId);
+        set.run(other.position, self.projectId);
+        return { ok: true, queue: queueEntries(db) };
+    });
+}

package/dist/slices/channels/rebrand.js

@@ -89,9 +89,15 @@ export function rebrandedEdit(db, base, edit) {
 // The value a brand-kit setting takes: the new kit's when the current one is unset, the
 // fallback, or what the old kit put there; otherwise the person's own, kept.
 function swapped(current, old, next, fallback) {
-    const fromOldKit = current === undefined || current === fallback || (old !== undefined && current === old);
+    const fromOldKit = current === undefined || current === fallback || (old !== undefined && same(current, old));
     return fromOldKit ? (next ?? fallback) : current;
 }
+// Channels store colours as #RRGGBB, a project's own colour boxes may hold #rrggbb: the same colour.
+function same(one, other) {
+    return one.startsWith("#") && other.startsWith("#")
+        ? one.toLowerCase() === other.toLowerCase()
+        : one === other;
+}
 function assign(target, key, value) {
     if (value === undefined)
         delete target[key];

package/dist/slices/channels/repo.js

@@ -38,6 +38,7 @@ const memberRow = z.object({
     description: z.string(),
     voice_json: z.string().nullable().optional(),
     host: z.number().optional(),
+    position: z.number().optional(),
     version: z.number(),
     created_at: z.string(),
     updated_at: z.string(),
@@ -112,7 +113,7 @@ function counts(db, sql) {
 }
 export function castOfChannel(db, channelId) {
     const members = db
-        .prepare("SELECT * FROM cast_members WHERE channel_id=? ORDER BY lower(name), id")
+        .prepare("SELECT * FROM cast_members WHERE channel_id=? ORDER BY position, lower(name), id")
         .all(channelId)
         .map((row) => memberRow.parse(row));
     const images = new Map();

package/dist/slices/channels/schema.js

@@ -123,6 +123,11 @@ export const castMemberCreateSchema = castMemberInputSchema.extend({ id }).stric
 export const castMemberUpdateSchema = castMemberInputSchema
     .extend({ baseVersion: z.number().int().positive() })
     .strict();
+// Moves one member to a place in its channel's cast (0 is first); a place past the end is last.
+export const castMoveSchema = z
+    .object({ memberId: id, to: z.number().int().nonnegative() })
+    .strict()
+    .readonly();
 export const castGenerateSchema = z
     .object({
     prompt: z

package/dist/slices/channels/service.js

@@ -1,7 +1,7 @@
 import { transact } from "../../kernel/db/tx.js";
 import { defaultChannelId } from "./model.js";
 import { castMemberById, castOfChannel, channelById, channelSummaries } from "./repo.js";
-import { castMemberCreateSchema, castMemberUpdateSchema, channelAiDisclosureSchema, channelCreateSchema, channelUpdateSchema, templateChannelSchema, } from "./schema.js";
+import { castMemberCreateSchema, castMemberUpdateSchema, castMoveSchema, channelAiDisclosureSchema, channelCreateSchema, channelUpdateSchema, templateChannelSchema, } from "./schema.js";
 export function listChannels(deps) {
     return channelSummaries(deps.db);
 }
@@ -127,8 +127,8 @@ export function createCastMember(deps, channelId, input) {
                 : { ok: false, reason: "conflict" };
         const at = deps.clock.now().toISOString();
         deps.db
-            .prepare("INSERT INTO cast_members(id,channel_id,kind,name,aliases_json,description,voice_json,host,created_at,updated_at) VALUES (?,?,?,?,?,?,?,?,?,?)")
-            .run(id, channelId, kind, name, JSON.stringify(unique(aliases, name)), description, voice === undefined || voice === null ? null : JSON.stringify(voice), host === true ? 1 : 0, at, at);
+            .prepare("INSERT INTO cast_members(id,channel_id,kind,name,aliases_json,description,voice_json,host,position,created_at,updated_at) VALUES (?,?,?,?,?,?,?,?,(SELECT coalesce(max(position)+1,0) FROM cast_members WHERE channel_id=?),?,?)")
+            .run(id, channelId, kind, name, JSON.stringify(unique(aliases, name)), description, voice === undefined || voice === null ? null : JSON.stringify(voice), host === true ? 1 : 0, channelId, at, at);
         const created = castMemberById(deps.db, id);
         if (created === undefined)
             throw new Error("The new cast member could not be read back");
@@ -167,6 +167,26 @@ export function deleteCastMember(deps, id) {
         ? { ok: false, reason: "not-found" }
         : { ok: true, value: { deleted: true } };
 }
+// Moves a member to a place in its channel's cast and numbers the whole cast again from 0, so
+// the order never depends on ties. Answers with the cast in its new order.
+export function moveCastMember(deps, channelId, input) {
+    const parsed = castMoveSchema.safeParse(input);
+    if (!parsed.success)
+        return { ok: false, reason: "invalid-input" };
+    const { memberId, to } = parsed.data;
+    return transact(deps.db, () => {
+        const order = castOfChannel(deps.db, channelId).map((member) => member.id);
+        const from = order.indexOf(memberId);
+        if (from < 0)
+            return { ok: false, reason: "not-found" };
+        order.splice(from, 1);
+        order.splice(Math.min(to, order.length), 0, memberId);
+        const place = deps.db.prepare("UPDATE cast_members SET position=? WHERE id=?");
+        for (const [index, id] of order.entries())
+            place.run(index, id);
+        return { ok: true, value: castOfChannel(deps.db, channelId) };
+    });
+}
 // Aliases compared without case, the name itself left out: matching ignores case anyway.
 function unique(aliases, name) {
     const seen = new Set([name.toLowerCase()]);

package/dist/slices/estimate/index.js

@@ -147,6 +147,8 @@ export function estimateRun(draft, rendered, expectedWords, catalogue) {
                 requests.push({ ...choice, kind: "tts-estimate", characters: extras + llmExtras });
             if (draft.voices?.source === "attribute")
                 text("Speaker split", articleChars + 1500, Math.round(articleChars * 1.1), "One LLM call hands the text's passages to the speakers.");
+            if (draft.voices?.source === "adapt")
+                text("Conversation script", articleChars + 1500, Math.round(articleChars * 1.2), "One LLM call rewrites the text as a conversation between the speakers; the article stays as written.");
         }
         else
             requests.push(generatedArticle || llmExtras > 0

package/dist/slices/library/transfer.js

@@ -0,0 +1,164 @@
+import { z } from "zod";
+import { documentThemeNameMax } from "../document/model.js";
+import { documentThemeSchema } from "../document/theme-schema.js";
+import { narrationAliasSchema } from "../narration/aliases-schema.js";
+import { bodyMax, entryCategories, entryModes, nameMax, promptKinds, } from "./model.js";
+// The file Library → Import or export writes and reads: prompts, intros and outros, PDF themes
+// and narration aliases as plain items, not database rows (the full backup in
+// slices/storage/backup-format.ts carries rows for one install's own restore). One item that
+// doesn't fit is skipped with its reason; the rest still import. Browser-safe: the web app
+// builds and reads these files, then saves each item through the same routes as its editor.
+export const libraryFileFormat = "slopify-library";
+export const libraryFileVersion = 1;
+// Far above a real Library, low enough that a wrong file is refused before it is parsed.
+export const libraryFileMaxBytes = 20 * 1024 * 1024;
+const itemsMax = 10_000;
+const sectionWords = {
+    prompts: "prompts",
+    entries: "intros or outros",
+    documentThemes: "PDF themes",
+    aliases: "narration aliases",
+};
+// Only what the editor saves travels: ids, keywords and dates are the install's own.
+const pickers = {
+    prompts: (item) => ({ kind: item.kind, name: item.name, body: item.body }),
+    entries: (item) => ({
+        category: item.category,
+        mode: item.mode,
+        name: item.name,
+        body: item.body,
+    }),
+    documentThemes: (item) => ({ name: item.name, values: item.values }),
+    aliases: (item) => ({
+        written: item.written,
+        spoken: item.spoken,
+        wholeWord: item.wholeWord,
+        caseSensitive: item.caseSensitive,
+    }),
+};
+export function libraryFile(sections, now) {
+    return {
+        format: libraryFileFormat,
+        version: libraryFileVersion,
+        exportedAt: now.toISOString(),
+        ...(sections.prompts === undefined ? {} : { prompts: sections.prompts.map(pickers.prompts) }),
+        ...(sections.entries === undefined ? {} : { entries: sections.entries.map(pickers.entries) }),
+        ...(sections.documentThemes === undefined
+            ? {}
+            : { documentThemes: sections.documentThemes.map(pickers.documentThemes) }),
+        ...(sections.aliases === undefined ? {} : { aliases: sections.aliases.map(pickers.aliases) }),
+    };
+}
+const name = (max) => z
+    .string({ error: "it has no name." })
+    .trim()
+    .min(1, { error: "it has no name." })
+    .max(max, { error: `its name is longer than ${String(max)} characters.` });
+const body = z
+    .string({ error: "it has no text." })
+    .max(bodyMax, { error: `its text is longer than ${String(bodyMax)} characters.` });
+const itemSchemas = {
+    prompts: z.object({
+        kind: z.enum(promptKinds, { error: `its kind isn't one of ${promptKinds.join(", ")}.` }),
+        name: name(nameMax),
+        body,
+    }),
+    entries: z.object({
+        category: z.enum(entryCategories, { error: "it is neither an intro nor an outro." }),
+        mode: z.enum(entryModes, { error: `its mode isn't one of ${entryModes.join(", ")}.` }),
+        name: name(nameMax),
+        body,
+    }),
+    documentThemes: z.object({ name: name(documentThemeNameMax), values: documentThemeSchema }),
+    aliases: narrationAliasSchema,
+};
+const head = z
+    .object({ format: z.literal(libraryFileFormat), version: z.number().int().positive() })
+    .loose();
+// Reads one section of a file. A wrong or newer file is refused as a whole, with what to do.
+export function readLibraryFile(text, section) {
+    const what = sectionWords[section];
+    let raw;
+    try {
+        raw = JSON.parse(text);
+    }
+    catch {
+        return {
+            ok: false,
+            message: `it isn't a Slopify library file (the text isn't JSON). Pick a .json file made by Export.`,
+        };
+    }
+    const top = head.safeParse(raw);
+    if (!top.success)
+        return {
+            ok: false,
+            message: `it isn't a Slopify library file. Pick a .json file made by Export on a Library tab.`,
+        };
+    if (top.data.version > libraryFileVersion)
+        return {
+            ok: false,
+            message: "it was made by a newer Slopify. Update Slopify (Settings → Updates), then import it again.",
+        };
+    const list = top.data[section];
+    if (!Array.isArray(list) || list.length === 0)
+        return {
+            ok: false,
+            message: `it holds no ${what}. Import it on the Library tab it was exported from.`,
+        };
+    if (list.length > itemsMax)
+        return {
+            ok: false,
+            message: `it holds more than ${String(itemsMax)} ${what}. Split it into smaller files.`,
+        };
+    const items = [];
+    const skipped = [];
+    const schema = itemSchemas[section];
+    for (const [index, each] of list.entries()) {
+        const parsed = schema.safeParse(each);
+        if (parsed.success)
+            items.push(parsed.data);
+        else
+            skipped.push({ item: labelOf(each, index), reason: reasonOf(parsed.error) });
+    }
+    return { ok: true, items, skipped };
+}
+function labelOf(item, index) {
+    const named = z.object({ name: z.string().trim().min(1) }).safeParse(item);
+    if (named.success)
+        return named.data.name;
+    const written = z.object({ written: z.string().trim().min(1) }).safeParse(item);
+    return written.success ? written.data.written : `Item ${String(index + 1)}`;
+}
+function reasonOf(error) {
+    const issue = error.issues[0];
+    if (issue === undefined)
+        return "it doesn't fit.";
+    const [first] = issue.path;
+    if (first === "values")
+        return `its setting ${issue.path.slice(1).join(".")}: ${issue.message}`;
+    if (first === "written" || first === "spoken")
+        return `its ${first === "written" ? "written form" : "spoken form"} is empty or too long.`;
+    if (typeof first === "string" && /^it/u.test(issue.message))
+        return issue.message;
+    return first === undefined ? "it isn't an item." : `its ${String(first)} is missing or wrong.`;
+}
+// A name nobody uses yet in `taken` (lower-cased): the name itself, else "<name> (imported)",
+// "<name> (imported 2)"… The base is cut so the suffix still fits `max`.
+export function importedName(wanted, taken, max) {
+    return freeName(wanted, taken, max, (n) => n === 1 ? " (imported)" : ` (imported ${String(n)})`);
+}
+// Duplicate selected names each copy "<name> copy", then "<name> copy 2"…
+export function copyName(wanted, taken, max) {
+    return freeName(wanted, taken, max, (n) => (n === 1 ? " copy" : ` copy ${String(n)}`), false);
+}
+function freeName(wanted, taken, max, suffix, keepIfFree = true) {
+    const base = wanted.trim();
+    if (keepIfFree && !taken.has(base.toLowerCase()))
+        return base;
+    for (let n = 1;; n += 1) {
+        const end = suffix(n);
+        const candidate = `${base.slice(0, Math.max(0, max - end.length)).trimEnd()}${end}`;
+        if (!taken.has(candidate.toLowerCase()))
+            return candidate;
+    }
+}

package/dist/slices/narration/aliases-table.js

@@ -0,0 +1,82 @@
+// Tab-separated when the file says so (or its first line holds a tab), comma-separated else.
+export function readAliasTable(text, fileName = "") {
+    const firstLine = text.split(/\r?\n/u, 1)[0] ?? "";
+    const separator = /\.tsv$/iu.test(fileName) || firstLine.includes("\t") ? "\t" : ",";
+    const aliases = [];
+    const skipped = [];
+    for (const { line, cells } of rowsOf(text.replace(/^/u, ""), separator)) {
+        if (cells.every((cell) => cell.trim() === ""))
+            continue;
+        const written = (cells[0] ?? "").trim();
+        const spoken = (cells[1] ?? "").trim();
+        // A header row the spreadsheet kept: "Written,Say it as".
+        if (line === 1 && /^written\b/iu.test(written))
+            continue;
+        if (written === "" || spoken === "") {
+            skipped.push(line);
+            continue;
+        }
+        aliases.push({ written, spoken, wholeWord: true, caseSensitive: false });
+    }
+    return { aliases, skipped };
+}
+export function aliasTable(aliases, separator) {
+    const cell = (value) => separator === "\t"
+        ? value.replace(/[\t\r\n]+/gu, " ")
+        : /[",\r\n]/u.test(value)
+            ? `"${value.replace(/"/gu, '""')}"`
+            : value;
+    return `${[["Written", "Say it as"], ...aliases.map((alias) => [alias.written, alias.spoken])]
+        .map((row) => row.map(cell).join(separator))
+        .join("\n")}\n`;
+}
+// RFC 4180 fields: a quoted field may hold the separator, "" for a quote, and line breaks.
+function rowsOf(text, separator) {
+    const rows = [];
+    let cells = [];
+    let cell = "";
+    let quoted = false;
+    let line = 1;
+    let rowLine = 1;
+    for (let at = 0; at < text.length; at += 1) {
+        const char = text[at];
+        if (quoted) {
+            if (char === '"' && text[at + 1] === '"') {
+                cell += '"';
+                at += 1;
+            }
+            else if (char === '"')
+                quoted = false;
+            else {
+                if (char === "\n")
+                    line += 1;
+                cell += char;
+            }
+        }
+        else if (char === '"' && cell.trim() === "") {
+            quoted = true;
+            cell = "";
+        }
+        else if (char === separator) {
+            cells.push(cell);
+            cell = "";
+        }
+        else if (char === "\n" || char === "\r") {
+            if (char === "\r" && text[at + 1] === "\n")
+                at += 1;
+            cells.push(cell);
+            rows.push({ line: rowLine, cells });
+            cells = [];
+            cell = "";
+            line += 1;
+            rowLine = line;
+        }
+        else
+            cell += char;
+    }
+    if (cell !== "" || cells.length > 0) {
+        cells.push(cell);
+        rows.push({ line: rowLine, cells });
+    }
+    return rows;
+}

package/dist/slices/outputs/add.js

@@ -0,0 +1,192 @@
+import { stageKinds } from "../../kernel/pipeline.js";
+import { sourceOf } from "../admission/model.js";
+import { defaultVoicesSettings } from "../voices/model.js";
+// Another output made from a project that already exists: the same brief, sources and
+// accepted text, with one more kind of result switched on. It is a new revision of the same
+// project, so the results already accepted are reused by the rebuild and only the new stages
+// run. A podcast is an adaptation: the text model rewrites the article as a two-host
+// conversation for the narration (`voices` source `adapt`), the article stays as written and the
+// conversation is kept beside it as the script. That rewrite is said in the plan (`adapts`) and
+// has to be accepted explicitly. A project has one narration, so an audiobook or podcast is
+// not added over narration it already has.
+export const addableOutputs = [
+    "narration",
+    "audiobook",
+    "images",
+    "video",
+    "pdf",
+    "podcast",
+];
+export const addableOutputLabels = {
+    narration: "Narration",
+    audiobook: "Audiobook (chaptered MP3 and M4B)",
+    images: "Images",
+    video: "Video",
+    pdf: "PDF",
+    podcast: "Podcast (adapts your text into a conversation)",
+};
+// What one stage's result is called where the plan lists it.
+const stageResults = {
+    research: "Research notes and sources",
+    article: "Accepted article text",
+    audio: "Narration",
+    images: "Slideshow images",
+    thumbnail: "Thumbnail",
+    video: "Video",
+    document: "PDF",
+};
+export function planAddedOutput(config, kind) {
+    const on = (stage) => sourceOf(config.sources, stage) !== "off";
+    if (!on("article") && kind !== "images")
+        return {
+            ok: false,
+            reason: "needs-article",
+            message: `${addableOutputLabels[kind]} is made from the project's text, and this project has none. Open Settings in this project, set Article to Generate or Provide, save, then add it.`,
+        };
+    if (present(config, kind))
+        return {
+            ok: false,
+            reason: "already",
+            message: `This project already makes ${lowerLabel(kind)}. Find it in its section on the left.`,
+        };
+    if ((kind === "audiobook" || kind === "podcast") && on("audio"))
+        return {
+            ok: false,
+            reason: "narration-taken",
+            message: `This project already has narration, and a project has one: ${kind === "podcast" ? "a podcast" : "an audiobook"} would replace it. Keep it, or change its format under Speakers in this project's Settings → Providers.`,
+        };
+    const sources = switchedOn(config, kind);
+    const next = {
+        ...config,
+        sources,
+        ...(kind === "audiobook" ? { voices: audiobookVoices(config) } : {}),
+        ...(kind === "podcast" ? { voices: podcastVoices(config) } : {}),
+        // A description or shorts are parts of a video: switched on with one, never charged for
+        // when only narration or a PDF is added.
+        ...(kind === "video" || on("audio")
+            ? {}
+            : { youtubeDescription: undefined, shorts: undefined }),
+    };
+    const stages = stageKinds.filter((stage) => !on(stage) && sourceOf(sources, stage) !== "off");
+    const kept = stageKinds.filter((stage) => on(stage) && stage !== "thumbnail");
+    return {
+        ok: true,
+        plan: {
+            kind,
+            config: next,
+            stages,
+            reused: ["Brief: title, prompts and keywords", ...kept.map((stage) => stageResults[stage])],
+            created: createdWords(kind, stages),
+            textUse: kind === "podcast"
+                ? "Adapted: the text model rewrites your article as a conversation between two hosts for the narration. The article stays as written; the conversation is kept beside it as the script."
+                : kind === "images"
+                    ? "Your text is not changed."
+                    : "Your text is used as written: nothing is rewritten.",
+            adapts: kind === "podcast",
+        },
+    };
+}
+function present(config, kind) {
+    const on = (stage) => sourceOf(config.sources, stage) !== "off";
+    switch (kind) {
+        case "narration":
+            return on("audio");
+        case "audiobook":
+            return on("audio") && config.voices?.audioFiles === true;
+        case "images":
+            return on("images");
+        case "video":
+            return on("video");
+        case "pdf":
+            return on("document");
+        case "podcast":
+            return on("audio") && config.voices?.format === "podcast";
+    }
+}
+function switchedOn(config, kind) {
+    const sources = config.sources;
+    const audio = sources.audio === "off" ? "generate" : sources.audio;
+    switch (kind) {
+        case "narration":
+        case "audiobook":
+        case "podcast":
+            return { ...sources, audio };
+        case "images":
+            return { ...sources, images: "generate" };
+        case "video":
+            return {
+                ...sources,
+                audio,
+                images: sources.images === "off" ? "generate" : sources.images,
+                video: "generate",
+            };
+        case "pdf":
+            return { ...sources, document: "generate" };
+    }
+}
+// One narrator reading the text as written; the text model only hands any quoted dialogue to
+// the speakers (`attribute`). An audiobook the project already sets up keeps its own speakers.
+function audiobookVoices(config) {
+    const base = config.voices ?? {
+        ...defaultVoicesSettings("audiobook"),
+        source: "attribute",
+    };
+    const voice = config.audio;
+    return {
+        ...base,
+        audioFiles: true,
+        speakers: base.speakers.map((speaker) => speaker.voice.voice === "" && voice !== undefined
+            ? {
+                ...speaker,
+                voice: { provider: voice.provider, model: voice.model, voice: voice.voice },
+            }
+            : speaker),
+    };
+}
+// Two hosts talk the article through; the first speaks in the project's narration voice and
+// the second needs a voice of its own, chosen in Settings.
+function podcastVoices(config) {
+    const base = { ...defaultVoicesSettings("podcast"), source: "adapt", audioFiles: true };
+    const voice = config.audio;
+    return {
+        ...base,
+        speakers: base.speakers.map((speaker, at) => at === 0 && voice !== undefined
+            ? {
+                ...speaker,
+                voice: { provider: voice.provider, model: voice.model, voice: voice.voice },
+            }
+            : speaker),
+    };
+}
+function createdWords(kind, stages) {
+    const words = [];
+    if (kind === "podcast")
+        words.push("A conversation script adapted from your article");
+    if (stages.includes("audio"))
+        words.push(kind === "audiobook"
+            ? "Narration by the narrator voice"
+            : kind === "podcast"
+                ? "Narration by the two hosts"
+                : "Narration of the text");
+    if (kind === "podcast")
+        words.push("The episode as MP3 and M4B with chapters");
+    if (kind === "audiobook")
+        words.push("Chaptered MP3 and M4B files");
+    if (kind === "narration")
+        words.push("The narration as one audio file");
+    if (stages.includes("images"))
+        words.push("Slideshow images");
+    if (stages.includes("video"))
+        words.push("The rendered video");
+    if (stages.includes("document"))
+        words.push("The PDF, with a linked contents page");
+    return words;
+}
+function lowerLabel(kind) {
+    const label = addableOutputLabels[kind];
+    if (kind === "pdf")
+        return "a PDF";
+    if (kind === "podcast")
+        return "a podcast";
+    return label.charAt(0).toLowerCase() + label.slice(1);
+}