@gentbajko/slopify 2.5.0 → 3.0.0

package/dist/slices/channels/cast-images.js

@@ -0,0 +1,110 @@
+import { castImageMaxBytes, castImagesPerMember, sniffImage, storeImageBlob } from "./images.js";
+import { castMemberById } from "./repo.js";
+import { castGenerateSchema } from "./schema.js";
+export function uploadCastImage(deps, memberId, bytes) {
+    const room = roomFor(deps, memberId);
+    if (!room.ok)
+        return room;
+    if (bytes.byteLength > castImageMaxBytes)
+        return {
+            ok: false,
+            reason: "not-an-image",
+            message: `This picture is larger than ${String(castImageMaxBytes / 1024 / 1024)} MB. Save it smaller (for example as a JPEG) and upload it again.`,
+        };
+    const mime = sniffImage(bytes);
+    if (mime === undefined)
+        return {
+            ok: false,
+            reason: "not-an-image",
+            message: "This file is not a PNG or JPEG picture. Upload a PNG or JPEG file.",
+        };
+    const at = deps.clock.now().toISOString();
+    const sha256 = storeImageBlob(deps.db, bytes, mime, at);
+    const id = deps.uuid();
+    deps.db
+        .prepare("INSERT INTO cast_images(id,member_id,source,prompt,state,error,sha256,created_at) VALUES (?,?,'upload',NULL,'ready',NULL,?,?)")
+        .run(id, memberId, sha256, at);
+    return { ok: true, value: imageRow(deps, id) };
+}
+// Adds a row in "generating" and returns it at once; the picture lands in the row when the
+// provider answers, or the row turns "failed" with the reason. Characters and creatures are
+// drawn upright, places and objects wide.
+export function generateCastImage(deps, memberId, input) {
+    const parsed = castGenerateSchema.safeParse(input);
+    if (!parsed.success)
+        return { ok: false, reason: "invalid-input" };
+    const room = roomFor(deps, memberId);
+    if (!room.ok)
+        return room;
+    const generate = deps.generateImage;
+    if (generate === undefined)
+        return { ok: false, reason: "no-image-provider" };
+    const id = deps.uuid();
+    deps.db
+        .prepare("INSERT INTO cast_images(id,member_id,source,prompt,state,error,sha256,created_at) VALUES (?,?,'generate',?,'generating',NULL,NULL,?)")
+        .run(id, memberId, parsed.data.prompt, deps.clock.now().toISOString());
+    void generate({
+        ...parsed.data,
+        channelId: room.value.channelId,
+        aspect: aspectOf(room.value.kind),
+    }).then((image) => {
+        const mime = sniffImage(image.bytes);
+        if (mime === undefined || image.bytes.byteLength > castImageMaxBytes) {
+            fail(deps, id, "The provider answered with something that is not a usable PNG or JPEG picture. Press Generate again, or upload a picture instead.");
+            return;
+        }
+        const sha256 = storeImageBlob(deps.db, image.bytes, mime, deps.clock.now().toISOString());
+        deps.db
+            .prepare("UPDATE cast_images SET state='ready',sha256=? WHERE id=? AND state='generating'")
+            .run(sha256, id);
+    }, (error) => {
+        const reason = error instanceof Error ? error.message : String(error);
+        deps.log?.write("warn", "channels.cast-image.failed", { detail: reason.slice(0, 500) });
+        fail(deps, id, `The picture couldn't be made: ${reason.slice(0, 500)} Check the image provider in Settings → Providers, then press Generate again.`);
+    });
+    return { ok: true, value: imageRow(deps, id) };
+}
+export function deleteCastImage(deps, memberId, imageId) {
+    // The bytes stay: a project started with this picture still names it.
+    const changed = deps.db
+        .prepare("DELETE FROM cast_images WHERE id=? AND member_id=?")
+        .run(imageId, memberId);
+    return Number(changed.changes) === 0
+        ? { ok: false, reason: "not-found" }
+        : { ok: true, value: { deleted: true } };
+}
+// A picture still being made when Slopify stopped will never land.
+export function settleInterruptedCastImages(deps) {
+    const changed = deps.db
+        .prepare("UPDATE cast_images SET state='failed',error='Slopify stopped before this picture was finished. Press Generate again.' WHERE state='generating'")
+        .run();
+    return Number(changed.changes);
+}
+function roomFor(deps, memberId) {
+    const member = castMemberById(deps.db, memberId);
+    if (member === undefined)
+        return { ok: false, reason: "not-found" };
+    if (member.images.filter((image) => image.state !== "failed").length >= castImagesPerMember)
+        return {
+            ok: false,
+            reason: "too-many-images",
+            message: `${member.name} already has ${String(castImagesPerMember)} pictures. Delete one before adding another.`,
+        };
+    return { ok: true, value: { kind: member.kind, channelId: member.channelId } };
+}
+function aspectOf(kind) {
+    return kind === "character" || kind === "creature" ? "9:16" : "16:9";
+}
+function fail(deps, id, error) {
+    deps.db
+        .prepare("UPDATE cast_images SET state='failed',error=? WHERE id=? AND state='generating'")
+        .run(error, id);
+}
+function imageRow(deps, id) {
+    const row = deps.db.prepare("SELECT member_id FROM cast_images WHERE id=?").get(id);
+    const member = castMemberById(deps.db, String(row?.member_id));
+    const image = member?.images.find((value) => value.id === id);
+    if (image === undefined)
+        throw new Error("The cast picture could not be read back");
+    return image;
+}

package/dist/slices/channels/cast-match.js

@@ -0,0 +1,32 @@
+// Which cast members a text mentions: a member's name or one of its aliases as a whole word,
+// ignoring case. A word boundary is anything that is not a letter or digit in any script, so
+// "Tiamat's lair" and "(Tiamat)" mention Tiamat and "Tiamatic" or "Tiamats" do not; a plural
+// is an alias to add. Spaces inside a name match any run of whitespace. The members come back
+// in the order the text first mentions them, then in cast order.
+export function castMentions(text, cast) {
+    if (cast === undefined || cast.length === 0 || text.trim() === "")
+        return [];
+    const found = [];
+    for (const [order, member] of cast.entries()) {
+        let first = Number.POSITIVE_INFINITY;
+        for (const term of [member.name, ...member.aliases]) {
+            const at = mentionAt(text, term);
+            if (at !== undefined && at < first)
+                first = at;
+        }
+        if (Number.isFinite(first))
+            found.push({ member, at: first, order });
+    }
+    return found.sort((a, b) => a.at - b.at || a.order - b.order).map((row) => row.member);
+}
+function mentionAt(text, term) {
+    const words = term.trim().split(/\s+/u).filter(Boolean);
+    if (words.length === 0)
+        return undefined;
+    const pattern = new RegExp(`(?<![\\p{L}\\p{N}])${words.map(escapeRegExp).join("\\s+")}(?![\\p{L}\\p{N}])`, "iu");
+    const match = pattern.exec(text);
+    return match === null ? undefined : match.index;
+}
+function escapeRegExp(word) {
+    return word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/dist/slices/channels/images.js

@@ -0,0 +1,19 @@
+import { createHash } from "node:crypto";
+import { insertImageBlob } from "./repo.js";
+// What a picture sent as a reference may weigh: the host helper's bridge carries at most this
+// much per reference image (`bridgeLimits.reference`).
+export const castImageMaxBytes = 10 * 1024 * 1024;
+// Per cast member. Every one is sent with each image that mentions the member.
+export const castImagesPerMember = 4;
+export function sniffImage(bytes) {
+    const png = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
+    if (bytes.length >= png.length && png.every((value, index) => bytes[index] === value))
+        return "image/png";
+    return bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff ? "image/jpeg" : undefined;
+}
+// Stores the bytes under their SHA-256 and returns it; the same picture twice is one row.
+export function storeImageBlob(db, bytes, mime, at) {
+    const sha256 = createHash("sha256").update(bytes).digest("hex");
+    insertImageBlob(db, { sha256, mime, bytes }, at);
+    return sha256;
+}

package/dist/slices/channels/model.js

@@ -0,0 +1,5 @@
+// Every install has this channel (migration 0032). A template or project whose channel is
+// NULL, or names a channel this install does not have, belongs to it.
+export const defaultChannelId = "00000000-0000-4000-8000-000000000001";
+export const defaultChannelName = "My channel";
+export const castKinds = ["character", "creature", "place", "object"];

package/dist/slices/channels/rebrand.js

@@ -0,0 +1,100 @@
+// A project moved to another channel in Edit project, or its brand kit switched on or off:
+// the run takes the new channel's cast as it is now and its brand kit again, as Play does when
+// a run starts (`runs.ts`). The kit fills what is at its default; a value the old channel's kit
+// had put there is replaced by the new kit's, and one the person set themselves is kept.
+// Nothing changes while the channel and the switch stay as they were, so saving any other
+// edit leaves the project's cast and brand exactly as they were.
+import { defaultDocumentTheme } from "../document/model.js";
+import { entryByName } from "../library/repo.js";
+import { channelById, resolveChannelId } from "./repo.js";
+import { brandDocument, castSnapshot } from "./runs.js";
+export function channelChanged(db, before, after) {
+    return resolveChannelId(db, before.channelId) !== resolveChannelId(db, after.channelId);
+}
+export function rebrandedEdit(db, base, edit) {
+    const oldId = resolveChannelId(db, base.channelId);
+    const newId = resolveChannelId(db, edit.config.channelId);
+    const oldKit = base.useBrandKit !== false;
+    const newKit = edit.config.useBrandKit !== false;
+    if (oldId === newId && oldKit === newKit)
+        return edit;
+    const oldBrand = oldKit ? (channelById(db, oldId)?.brand ?? {}) : {};
+    const newBrand = newKit ? (channelById(db, newId)?.brand ?? {}) : {};
+    const { useBrandKit: _kit, cast: _cast, ...rest } = edit.config;
+    let config = {
+        ...rest,
+        channelId: newId,
+        ...(newKit ? {} : { useBrandKit: false }),
+    };
+    // The cast goes with the channel; the brand kit switch never changes it.
+    const cast = oldId === newId ? edit.config.cast : castSnapshot(db, newId);
+    if (cast !== undefined && cast.length > 0)
+        config = { ...config, cast };
+    let content = edit.content;
+    if (config.subtitles !== undefined) {
+        const subtitles = { ...config.subtitles };
+        const font = swapped(subtitles.fontId, oldBrand.captionFontId, newBrand.captionFontId, "default");
+        subtitles.fontId = font ?? "default";
+        assign(subtitles, "color", swapped(subtitles.color, oldBrand.captionColor, newBrand.captionColor));
+        assign(subtitles, "outlineColor", swapped(subtitles.outlineColor, oldBrand.captionOutlineColor, newBrand.captionOutlineColor));
+        config = { ...config, subtitles };
+    }
+    const titleStyle = {};
+    assign(titleStyle, "fontId", swapped(config.titleStyle?.fontId, oldBrand.titleFontId, newBrand.titleFontId));
+    assign(titleStyle, "color", swapped(config.titleStyle?.color, oldBrand.titleColor, newBrand.titleColor));
+    const { titleStyle: _title, endScreen: _end, ...unstyled } = config;
+    const endScreen = swapped(config.endScreen?.text, oldBrand.endScreenText, newBrand.endScreenText);
+    config = {
+        ...unstyled,
+        ...(Object.keys(titleStyle).length === 0 ? {} : { titleStyle }),
+        ...(endScreen === undefined ? {} : { endScreen: { text: endScreen } }),
+    };
+    // An intro or outro is read only while narration is generated.
+    if (config.sources.audio === "generate")
+        for (const category of ["intro", "outro"]) {
+            const current = config[category]?.name;
+            const old = oldBrand[category];
+            const fromOldKit = current === undefined || (old !== undefined && current.toLowerCase() === old.toLowerCase());
+            if (!fromOldKit)
+                continue;
+            const name = newBrand[category];
+            const entry = name === undefined ? undefined : entryByName(db, category, name);
+            if (entry === undefined) {
+                if (current === undefined)
+                    continue;
+                const { [category]: _dropped, ...without } = config;
+                config = without;
+                continue;
+            }
+            config = { ...config, [category]: { name: entry.name, mode: entry.mode } };
+            content = {
+                ...content,
+                promptTemplates: { ...content.promptTemplates, [category]: entry.body },
+            };
+        }
+    // The PDF's theme, while the project makes one.
+    if (config.document !== undefined) {
+        const identity = config.document.custom?.id ?? config.document.theme;
+        const fromOldKit = identity === (oldBrand.documentTheme ?? defaultDocumentTheme) ||
+            (config.document.custom === undefined && config.document.theme === defaultDocumentTheme);
+        if (fromOldKit) {
+            const document = brandDocument(db, newBrand) ?? {
+                theme: defaultDocumentTheme,
+            };
+            config = { ...config, document };
+        }
+    }
+    return { ...edit, config, content };
+}
+// 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);
+    return fromOldKit ? (next ?? fallback) : current;
+}
+function assign(target, key, value) {
+    if (value === undefined)
+        delete target[key];
+    else
+        target[key] = value;
+}

package/dist/slices/channels/repo.js

@@ -0,0 +1,218 @@
+import { z } from "zod";
+import { aiDisclosureSettings } from "../studio/disclosure.js";
+import { channelAmbientBedSchema } from "../video/ambient-bed-schema.js";
+import { castKinds, defaultChannelId, } from "./model.js";
+const brandSchema = z
+    .object({
+    captionFontId: z.string().optional(),
+    captionColor: z.string().optional(),
+    captionOutlineColor: z.string().optional(),
+    titleFontId: z.string().optional(),
+    titleColor: z.string().optional(),
+    intro: z.string().optional(),
+    outro: z.string().optional(),
+    endScreenText: z.string().optional(),
+    documentTheme: z.string().optional(),
+    ambientBed: channelAmbientBedSchema.optional(),
+    language: z.string().optional(),
+})
+    .readonly();
+const channelRow = z.object({
+    id: z.string(),
+    name: z.string(),
+    is_default: z.number(),
+    brand_json: z.string(),
+    series_brief: z.string(),
+    ai_disclosure: z.enum(aiDisclosureSettings),
+    version: z.number(),
+    created_at: z.string(),
+    updated_at: z.string(),
+});
+const memberRow = z.object({
+    id: z.string(),
+    channel_id: z.string(),
+    kind: z.enum(castKinds),
+    name: z.string(),
+    aliases_json: z.string(),
+    description: z.string(),
+    voice_json: z.string().nullable().optional(),
+    version: z.number(),
+    created_at: z.string(),
+    updated_at: z.string(),
+});
+const voiceJson = z.object({
+    provider: z.string(),
+    model: z.string(),
+    voice: z.string(),
+    pace: z.number().optional(),
+    pronunciations: z.string().optional(),
+});
+const imageRow = z.object({
+    id: z.string(),
+    member_id: z.string(),
+    source: z.enum(["upload", "generate"]),
+    prompt: z.string().nullable(),
+    state: z.enum(["ready", "generating", "failed"]),
+    error: z.string().nullable(),
+    sha256: z.string().nullable(),
+    created_at: z.string(),
+});
+function channelOf(row) {
+    const value = channelRow.parse(row);
+    return {
+        id: value.id,
+        name: value.name,
+        isDefault: value.is_default === 1,
+        brand: brandSchema.parse(JSON.parse(value.brand_json)),
+        seriesBrief: value.series_brief,
+        aiDisclosure: value.ai_disclosure,
+        version: value.version,
+        createdAt: value.created_at,
+        updatedAt: value.updated_at,
+    };
+}
+export function channelById(db, id) {
+    const row = db.prepare("SELECT * FROM channels WHERE id=?").get(id);
+    return row === undefined ? undefined : channelOf(row);
+}
+// A channel id as stored on a template or project: NULL or one this install does not have
+// reads as the default channel.
+export function resolveChannelId(db, id) {
+    if (id === null || id === undefined)
+        return defaultChannelId;
+    return db.prepare("SELECT 1 FROM channels WHERE id=?").get(id) === undefined
+        ? defaultChannelId
+        : id;
+}
+export function channelSummaries(db) {
+    const templates = counts(db, "SELECT coalesce(channel_id,'') AS id, count(*) AS n FROM project_templates WHERE deleted_at IS NULL GROUP BY channel_id");
+    const cast = counts(db, "SELECT channel_id AS id, count(*) AS n FROM cast_members GROUP BY channel_id");
+    const rows = db
+        .prepare("SELECT * FROM channels ORDER BY is_default DESC, lower(name), id")
+        .all()
+        .map(channelOf);
+    const known = new Set(rows.map((row) => row.id));
+    // Templates naming no channel, or one that is gone, are the default channel's.
+    const stray = [...templates.entries()]
+        .filter(([id]) => !known.has(id))
+        .reduce((sum, [, n]) => sum + n, 0);
+    return rows.map((row) => ({
+        ...row,
+        templates: (templates.get(row.id) ?? 0) + (row.isDefault ? stray : 0),
+        cast: cast.get(row.id) ?? 0,
+    }));
+}
+function counts(db, sql) {
+    const result = new Map();
+    for (const row of db.prepare(sql).all())
+        result.set(String(row.id), Number(row.n));
+    return result;
+}
+export function castOfChannel(db, channelId) {
+    const members = db
+        .prepare("SELECT * FROM cast_members WHERE channel_id=? ORDER BY lower(name), id")
+        .all(channelId)
+        .map((row) => memberRow.parse(row));
+    const images = new Map();
+    for (const row of db
+        .prepare("SELECT i.* FROM cast_images i JOIN cast_members m ON m.id=i.member_id WHERE m.channel_id=? ORDER BY i.created_at, i.rowid")
+        .all(channelId)) {
+        const image = imageRow.parse(row);
+        const list = images.get(image.member_id) ?? [];
+        list.push(imageOf(image));
+        images.set(image.member_id, list);
+    }
+    return members.map((row) => memberOf(row, images.get(row.id) ?? []));
+}
+export function castMemberById(db, id) {
+    const row = db.prepare("SELECT * FROM cast_members WHERE id=?").get(id);
+    if (row === undefined)
+        return undefined;
+    const images = db
+        .prepare("SELECT * FROM cast_images WHERE member_id=? ORDER BY created_at, rowid")
+        .all(id)
+        .map((value) => imageOf(imageRow.parse(value)));
+    return memberOf(memberRow.parse(row), images);
+}
+function memberOf(row, images) {
+    return {
+        id: row.id,
+        channelId: row.channel_id,
+        kind: row.kind,
+        name: row.name,
+        aliases: z.array(z.string()).parse(JSON.parse(row.aliases_json)),
+        description: row.description,
+        ...(row.voice_json === null || row.voice_json === undefined
+            ? {}
+            : { voice: voiceJson.parse(JSON.parse(row.voice_json)) }),
+        version: row.version,
+        images,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function imageOf(row) {
+    return {
+        id: row.id,
+        source: row.source,
+        prompt: row.prompt,
+        state: row.state,
+        error: row.error,
+        sha256: row.sha256,
+        createdAt: row.created_at,
+    };
+}
+export function templateChannelId(db, templateId) {
+    const row = db.prepare("SELECT channel_id FROM project_templates WHERE id=?").get(templateId);
+    return resolveChannelId(db, typeof row?.channel_id === "string" ? row.channel_id : null);
+}
+// Every template's channel, for the lists that show or filter by it.
+export function templateChannels(db) {
+    const result = new Map();
+    for (const row of db.prepare("SELECT id, channel_id FROM project_templates").all())
+        result.set(String(row.id), resolveChannelId(db, typeof row.channel_id === "string" ? row.channel_id : null));
+    return result;
+}
+// A schedule belongs to the channel of the template it runs, so moving a template moves its
+// schedules with it and the series brief a schedule reads is always its channel's.
+export function scheduleChannel(db, scheduleId) {
+    const row = db.prepare("SELECT template_id FROM schedules WHERE id=?").get(scheduleId);
+    if (typeof row?.template_id !== "string")
+        return undefined;
+    return channelById(db, templateChannelId(db, row.template_id));
+}
+export function projectChannelId(db, projectId) {
+    const row = db
+        .prepare("SELECT channel_id FROM project_channels WHERE project_id=?")
+        .get(projectId);
+    return resolveChannelId(db, typeof row?.channel_id === "string" ? row.channel_id : null);
+}
+// Every project's channel in one read, for the lists that show or filter by it. A project
+// with no row, or naming a channel this install doesn't have, is in the default channel.
+export function projectChannels(db) {
+    const known = new Set(db
+        .prepare("SELECT id FROM channels")
+        .all()
+        .map((row) => String(row.id)));
+    const result = new Map();
+    for (const row of db.prepare("SELECT project_id, channel_id FROM project_channels").all()) {
+        const channel = String(row.channel_id);
+        result.set(String(row.project_id), known.has(channel) ? channel : defaultChannelId);
+    }
+    return result;
+}
+export function setProjectChannel(db, projectId, channelId) {
+    db.prepare("INSERT INTO project_channels(project_id,channel_id) VALUES (?,?) ON CONFLICT(project_id) DO UPDATE SET channel_id=excluded.channel_id").run(projectId, channelId);
+}
+export function imageBlob(db, sha256) {
+    const row = db.prepare("SELECT mime, bytes FROM image_blobs WHERE sha256=?").get(sha256);
+    if (row === undefined)
+        return undefined;
+    const mime = z.enum(["image/png", "image/jpeg"]).parse(row.mime);
+    if (!(row.bytes instanceof Uint8Array))
+        return undefined;
+    return { bytes: new Uint8Array(row.bytes), mime };
+}
+export function insertImageBlob(db, blob, at) {
+    db.prepare("INSERT INTO image_blobs(sha256,mime,bytes,created_at) VALUES (?,?,?,?) ON CONFLICT(sha256) DO NOTHING").run(blob.sha256, blob.mime, blob.bytes, at);
+}

package/dist/slices/channels/runs.js

@@ -0,0 +1,129 @@
+import { languageSchema } from "../../kernel/ports/languages.js";
+import { listDocumentThemes } from "../document/library.js";
+import { documentThemes } from "../document/model.js";
+import { ambientBedFormOf } from "../video/ambient-bed.js";
+import { withCastVoices } from "../voices/cast.js";
+import { castMemberById, castOfChannel, channelById, resolveChannelId, templateChannelId, } from "./repo.js";
+// The channel a Play draft runs in: the one picked on Play, else its template's, else the
+// default channel.
+export function draftChannel(db, document) {
+    const id = document.channelId !== undefined
+        ? resolveChannelId(db, document.channelId)
+        : document.templateSource !== undefined
+            ? templateChannelId(db, document.templateSource.id)
+            : resolveChannelId(db, undefined);
+    const channel = channelById(db, id);
+    if (channel === undefined)
+        throw new Error("The default channel is missing");
+    return channel;
+}
+// The brand kit fills what the draft leaves at its default: the "default" caption font, no
+// intro or outro, no document theme chosen, no ambient sound chosen. A template that sets its own keeps it, and one
+// with "Use the channel's brand kit" off takes nothing from it. An intro, outro or theme the
+// kit names that no longer exists is skipped, not refused: the draft never named it.
+export function brandedForm(db, form, brand, entries) {
+    // The channel's language is not styling, so it applies with the brand kit off too; a
+    // language picked on Play (English included) is the draft's own.
+    const language = form.language === undefined && brand.language !== undefined
+        ? { language: languageSchema.parse(brand.language) }
+        : {};
+    if (form.useBrandKit === false)
+        return { ...form, ...language };
+    const entry = (category, name) => name === undefined
+        ? undefined
+        : entries.find((row) => row.category === category && row.name.toLowerCase() === name.toLowerCase())?.name;
+    const intro = form.intro === "" ? entry("intro", brand.intro) : undefined;
+    const outro = form.outro === "" ? entry("outro", brand.outro) : undefined;
+    const document = form.document === undefined ? brandDocument(db, brand) : undefined;
+    return {
+        ...form,
+        ...language,
+        ...(form.subtitles.fontId === "default" && brand.captionFontId !== undefined
+            ? { subtitles: { ...form.subtitles, fontId: brand.captionFontId } }
+            : {}),
+        ...(intro === undefined ? {} : { intro }),
+        ...(outro === undefined ? {} : { outro }),
+        ...(document === undefined ? {} : { document }),
+        // A setup that never touched its ambient sound takes the channel's; one set to None keeps
+        // none.
+        ...(form.ambientBed === undefined && brand.ambientBed !== undefined
+            ? { ambientBed: ambientBedFormOf(brand.ambientBed) }
+            : {}),
+    };
+}
+export function brandDocument(db, brand) {
+    const name = brand.documentTheme;
+    if (name === undefined)
+        return undefined;
+    const builtIn = documentThemes.find((theme) => theme === name);
+    if (builtIn !== undefined)
+        return { theme: builtIn };
+    const saved = listDocumentThemes(db).find((theme) => theme.id === name);
+    return saved === undefined
+        ? undefined
+        : { theme: "plain", custom: { id: saved.id, name: saved.name, values: saved.values } };
+}
+// What the run carries from its channel beyond the form: the channel itself, the caption and
+// title colours, the end screen, and the cast. Each only when set, so a run from a channel
+// with an empty kit and no cast is the run it always was.
+export function brandedRun(draft, channel, cast, useBrandKit) {
+    const brand = useBrandKit ? channel.brand : {};
+    const colours = brand.captionColor === undefined && brand.captionOutlineColor === undefined
+        ? {}
+        : {
+            ...(brand.captionColor === undefined ? {} : { color: brand.captionColor }),
+            ...(brand.captionOutlineColor === undefined
+                ? {}
+                : { outlineColor: brand.captionOutlineColor }),
+        };
+    const titleStyle = {
+        ...(brand.titleFontId === undefined ? {} : { fontId: brand.titleFontId }),
+        ...(brand.titleColor === undefined ? {} : { color: brand.titleColor }),
+    };
+    return {
+        ...draft,
+        channelId: channel.id,
+        // Kept only when off, so a run with the kit on saves the config it always did.
+        ...(useBrandKit ? {} : { useBrandKit: false }),
+        ...(draft.subtitles !== undefined && Object.keys(colours).length > 0
+            ? { subtitles: { ...colours, ...draft.subtitles } }
+            : {}),
+        ...(Object.keys(titleStyle).length === 0 || draft.titleStyle !== undefined
+            ? {}
+            : { titleStyle }),
+        ...(brand.endScreenText === undefined || draft.endScreen !== undefined
+            ? {}
+            : { endScreen: { text: brand.endScreenText } }),
+        ...(cast.length === 0 ? {} : { cast }),
+    };
+}
+// The channel's cast as a run is started with it: members with at least one finished picture.
+export function castSnapshot(db, channelId) {
+    return castOfChannel(db, channelId).flatMap((member) => {
+        const images = member.images.flatMap((image) => image.state === "ready" && image.sha256 !== null ? [image.sha256] : []);
+        return images.length === 0
+            ? []
+            : [
+                {
+                    name: member.name,
+                    aliases: member.aliases,
+                    description: member.description,
+                    images,
+                },
+            ];
+    });
+}
+// Speakers picked from the cast speak with the cast's voices (and show its portraits) as they
+// are when the run starts. Every door a run starts through - Play, a schedule, a batch, the
+// API - passes its draft through here once; a member is found by id, whichever channel it is
+// on, and a draft without cast speakers comes back unchanged.
+export function castVoicedRun(db, draft) {
+    if (draft.voices === undefined)
+        return draft;
+    const ids = new Set(draft.voices.speakers.flatMap((one) => one.castId ?? []));
+    if (ids.size === 0)
+        return draft;
+    const members = [...ids].flatMap((id) => castMemberById(db, id) ?? []);
+    const voices = withCastVoices(draft.voices, members);
+    return voices === draft.voices ? draft : { ...draft, voices };
+}