@gentbajko/slopify 2.3.1 → 2.5.0

package/dist/slices/backups/model.js

@@ -0,0 +1,65 @@
+import { z } from "zod";
+import { validTimeZone } from "../schedules/calendar.js";
+// Scheduled backups write the same archive Export everything downloads (storage/backup-export)
+// into a folder on disk, once a day, keeping the newest few. The settings table holds the
+// configuration and the last result under two keys no backup carries: exportableSettings
+// only lets known portable keys through, and a folder path belongs to this machine alone.
+export const configKey = "backups.config";
+export const statusKey = "backups.status";
+export const keepMin = 1;
+export const keepMax = 30;
+export const folderMax = 1024;
+const time = z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "Pick a time as HH:MM, 00:00 to 23:59.");
+export const backupConfigInputSchema = z
+    .object({
+    enabled: z.boolean(),
+    time,
+    timeZone: z
+        .string()
+        .min(1)
+        .max(64)
+        .refine(validTimeZone, "This time zone is not one Slopify knows."),
+    keep: z
+        .number()
+        .int()
+        .min(keepMin)
+        .max(keepMax, `Keep between ${keepMin} and ${keepMax} backups.`),
+    // null is the default folder, so moving the projects folder moves the backups with it.
+    folder: z.string().trim().min(1).max(folderMax).nullable(),
+})
+    .strict();
+export const storedConfigSchema = backupConfigInputSchema.extend({
+    // When the toggle was last turned on. A slot before it does not count, so turning backups on
+    // at 14:00 waits for tonight's 03:00 instead of starting a multi-gigabyte copy at once.
+    enabledAt: z.string().nullable(),
+});
+// Off by default, for new and existing installs alike: an archive holds every project's video
+// and can be many gigabytes, so filling a disk with copies is something the user asks for.
+export function defaultConfig(timeZone) {
+    return { enabled: false, time: "03:00", timeZone, keep: 5, folder: null, enabledAt: null };
+}
+export const triggers = ["scheduled", "catch-up", "manual"];
+export const backupStatusSchema = z.object({
+    lastAttemptAt: z.string().nullable(),
+    // "waiting": projects were being made, so the backup is held until they finish.
+    lastResult: z.enum(["succeeded", "failed", "waiting"]).nullable(),
+    lastTrigger: z.enum(triggers).nullable(),
+    // The slot the last attempt was for, so a failure is retried for that slot, not repeated.
+    lastSlot: z.string().nullable(),
+    detail: z.string().nullable(),
+    lastSuccessAt: z.string().nullable(),
+    lastSuccessFile: z.string().nullable(),
+    lastSuccessBytes: z.number().int().min(0).nullable(),
+    lastDurationMs: z.number().int().min(0).nullable(),
+});
+export const emptyStatus = {
+    lastAttemptAt: null,
+    lastResult: null,
+    lastTrigger: null,
+    lastSlot: null,
+    detail: null,
+    lastSuccessAt: null,
+    lastSuccessFile: null,
+    lastSuccessBytes: null,
+    lastDurationMs: null,
+};

package/dist/slices/backups/repo.js

@@ -0,0 +1,28 @@
+import { readSetting, writeSetting } from "../settings/repo.js";
+import { backupStatusSchema, configKey, defaultConfig, emptyStatus, statusKey, storedConfigSchema, } from "./model.js";
+// A value this build cannot read (hand-edited, or written by a newer Slopify) falls back to
+// the default rather than stopping the app; the next save writes a good one.
+export function readConfig(db, fallbackTimeZone) {
+    const parsed = storedConfigSchema.safeParse(parseJson(readSetting(db, configKey)));
+    return parsed.success ? parsed.data : defaultConfig(fallbackTimeZone);
+}
+export function writeConfig(db, config) {
+    writeSetting(db, configKey, JSON.stringify(storedConfigSchema.parse(config)));
+}
+export function readStatus(db) {
+    const parsed = backupStatusSchema.safeParse(parseJson(readSetting(db, statusKey)));
+    return parsed.success ? parsed.data : emptyStatus;
+}
+export function writeStatus(db, status) {
+    writeSetting(db, statusKey, JSON.stringify(backupStatusSchema.parse(status)));
+}
+function parseJson(value) {
+    if (value === undefined)
+        return undefined;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/slices/backups/schedule.js

@@ -0,0 +1,60 @@
+import { nextOccurrence } from "../schedules/calendar.js";
+// After a start, the first backup waits this long so it never competes with the boot's own
+// work (migrations, reconcile, the queue resuming).
+export const startupDelayMs = 2 * 60_000;
+// A failed backup is tried again this often until the slot's backup succeeds or the next slot.
+export const retryAfterFailureMs = 60 * 60_000;
+// A backup held back by projects being made looks again this often.
+export const retryAfterWaitingMs = 10 * 60_000;
+// A slot missed while Slopify was off is made up for after the next start, unless a backup
+// already succeeded this recently ("about a day", with room for a slot that ran late).
+export const catchUpFreshMs = 20 * 60 * 60_000;
+// The most recent time-of-day slot at or before `now`, in the configured zone. Days are 23 to 25
+// hours long, so 26 hours back always holds at least one slot.
+export function latestSlot(time, timeZone, now) {
+    const daily = { kind: "daily", time };
+    let slot = nextOccurrence(daily, timeZone, new Date(now.valueOf() - 26 * 60 * 60_000));
+    if (slot === null || slot > now)
+        return null;
+    for (;;) {
+        const next = nextOccurrence(daily, timeZone, slot);
+        if (next === null || next > now)
+            return slot;
+        slot = next;
+    }
+}
+export function nextSlot(time, timeZone, now) {
+    return nextOccurrence({ kind: "daily", time }, timeZone, now);
+}
+// At most one automatic backup per daily slot. A slot is due once no backup has succeeded
+// since it; a slot that passed while Slopify was off is caught up after the next start.
+export function decideBackup(input) {
+    const { config, status, now, bootedAt } = input;
+    if (!config.enabled)
+        return { due: false, reason: "off" };
+    if (input.running)
+        return { due: false, reason: "running" };
+    const slot = latestSlot(config.time, config.timeZone, now);
+    if (slot === null)
+        return { due: false, reason: "not-yet" };
+    if (config.enabledAt !== null && slot.valueOf() < Date.parse(config.enabledAt))
+        return { due: false, reason: "not-yet" };
+    const lastSuccess = status.lastSuccessAt === null ? null : Date.parse(status.lastSuccessAt);
+    if (lastSuccess !== null && lastSuccess >= slot.valueOf())
+        return { due: false, reason: "done" };
+    const missed = bootedAt.valueOf() > slot.valueOf();
+    if (missed && lastSuccess !== null && now.valueOf() - lastSuccess < catchUpFreshMs)
+        return { due: false, reason: "done" };
+    if (now.valueOf() - bootedAt.valueOf() < startupDelayMs)
+        return { due: false, reason: "starting" };
+    if (status.lastSlot === slot.toISOString() && status.lastAttemptAt !== null) {
+        const wait = status.lastResult === "failed"
+            ? retryAfterFailureMs
+            : status.lastResult === "waiting"
+                ? retryAfterWaitingMs
+                : 0;
+        if (now.valueOf() - Date.parse(status.lastAttemptAt) < wait)
+            return { due: false, reason: "retry-later" };
+    }
+    return { due: true, slot: slot.toISOString(), trigger: missed ? "catch-up" : "scheduled" };
+}

package/dist/slices/backups/service.js

@@ -0,0 +1,311 @@
+import { statfs } from "node:fs/promises";
+import { BackupBusyError, planBackup, streamBackup, } from "../storage/backup-export.js";
+import { defaultBackupsDir } from "../storage/layout.js";
+import { backupFileName, codeOf, ensureFolder, listBackups, pruneBackups, removeLeftovers, writeAtomically, } from "./files.js";
+import { effectiveFolder, folderProblem, hostFolder } from "./folder.js";
+import { readConfig, readStatus, writeConfig, writeStatus } from "./repo.js";
+import { decideBackup, nextSlot } from "./schedule.js";
+// Scheduled backups reuse Export everything's own code path (planBackup, streamBackup) and so
+// its rule too: nothing is copied while a project is being made, because its files are still
+// being written. A backup that meets one waits and looks again, so it never competes with a
+// render; the writing itself yields to the event loop after every chunk.
+export function createBackupService(deps) {
+    let current;
+    let stopped = false;
+    const zone = deps.serverTimeZone ?? (Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC");
+    const config = () => readConfig(deps.db, zone);
+    const folderOf = (value) => effectiveFolder(deps.paths, value.folder);
+    const record = (status) => {
+        try {
+            writeStatus(deps.db, status);
+        }
+        catch (error) {
+            deps.log.write("error", "backups.status", { detail: String(error) });
+        }
+    };
+    const start = (plan, trigger, slot, release) => {
+        const abort = new AbortController();
+        const done = write(plan, trigger, slot, abort.signal)
+            .catch((error) => {
+            deps.log.write("error", "backups.run", { detail: String(error) });
+        })
+            .finally(() => {
+            release();
+            current = undefined;
+        });
+        current = { abort, done };
+        return done;
+    };
+    async function write(plan, trigger, slot, signal) {
+        const settings = config();
+        const folder = folderOf(settings);
+        const startedAt = deps.clock.now();
+        const previous = readStatus(deps.db);
+        const attempt = {
+            ...previous,
+            lastAttemptAt: startedAt.toISOString(),
+            lastTrigger: trigger,
+            lastSlot: slot,
+        };
+        try {
+            await ensureFolder(folder);
+            await removeLeftovers(folder);
+            await checkSpace(folder, plan.archiveBytes);
+            const name = backupFileName(startedAt);
+            const written = await writeAtomically(folder, name, streamBackup(plan), signal);
+            let detail = null;
+            try {
+                await pruneBackups(folder, settings.keep);
+            }
+            catch (error) {
+                deps.log.write("warn", "backups.prune", { detail: String(error) });
+                detail = `The backup was saved, but older backups in ${folder} could not be removed (${codeOf(error) ?? "unknown error"}), so more than ${settings.keep} are kept. Check Slopify can delete files in that folder, or pick another Folder in Settings → Backups.`;
+            }
+            record({
+                ...attempt,
+                lastResult: "succeeded",
+                detail,
+                lastSuccessAt: deps.clock.now().toISOString(),
+                lastSuccessFile: written.path,
+                lastSuccessBytes: written.bytes,
+                lastDurationMs: deps.clock.now().valueOf() - startedAt.valueOf(),
+            });
+        }
+        catch (error) {
+            deps.log.write("error", "backups.run", { detail: String(error) });
+            record({
+                ...attempt,
+                lastResult: "failed",
+                detail: explain(error, folder, trigger !== "manual", signal),
+                lastDurationMs: deps.clock.now().valueOf() - startedAt.valueOf(),
+            });
+        }
+    }
+    const waiting = (projects, trigger, slot) => {
+        record({
+            ...readStatus(deps.db),
+            lastAttemptAt: deps.clock.now().toISOString(),
+            lastResult: "waiting",
+            lastTrigger: trigger,
+            lastSlot: slot,
+            detail: `Waiting for ${named(projects)} to finish: a backup never copies a project while its files are being written. It starts by itself when they finish or are paused.`,
+            lastDurationMs: null,
+        });
+    };
+    return {
+        view: async () => {
+            const settings = config();
+            const folder = folderOf(settings);
+            const now = deps.clock.now();
+            let files = [];
+            try {
+                files = await listBackups(folder);
+            }
+            catch {
+                files = [];
+            }
+            const decision = decideBackup({
+                config: settings,
+                status: readStatus(deps.db),
+                now,
+                bootedAt: deps.bootedAt,
+                running: current !== undefined,
+            });
+            const overdue = decision.due || (!decision.due && ["starting", "retry-later"].includes(decision.reason));
+            return {
+                config: {
+                    enabled: settings.enabled,
+                    time: settings.time,
+                    timeZone: settings.timeZone,
+                    keep: settings.keep,
+                    folder: settings.folder,
+                },
+                folder,
+                defaultFolder: defaultBackupsDir(deps.paths),
+                hostFolder: hostFolder(deps.paths, deps.location, folder),
+                container: deps.location.container,
+                running: current !== undefined,
+                nextRunAt: settings.enabled
+                    ? (nextSlot(settings.time, settings.timeZone, now)?.toISOString() ?? null)
+                    : null,
+                overdue: settings.enabled && overdue,
+                status: readStatus(deps.db),
+                files,
+            };
+        },
+        save: (input) => {
+            const problem = folderProblem(deps.paths, input.folder);
+            if (problem !== undefined)
+                return { ok: false, detail: problem };
+            const before = config();
+            const now = deps.clock.now().toISOString();
+            const moved = before.time !== input.time || before.timeZone !== input.timeZone;
+            const enabledAt = !input.enabled
+                ? null
+                : !before.enabled || moved || before.enabledAt === null
+                    ? now
+                    : before.enabledAt;
+            writeConfig(deps.db, { ...input, enabledAt });
+            return { ok: true };
+        },
+        runNow: () => {
+            if (stopped)
+                return {
+                    ok: false,
+                    status: 409,
+                    detail: "Slopify is shutting down. Start it again, then press Back up now.",
+                };
+            if (current !== undefined)
+                return {
+                    ok: false,
+                    status: 409,
+                    detail: "A backup is already being written. Wait for it to finish; its result shows here.",
+                };
+            const problem = folderProblem(deps.paths, config().folder);
+            if (problem !== undefined)
+                return { ok: false, status: 400, detail: problem };
+            const release = deps.beginMutation === undefined ? () => { } : deps.beginMutation();
+            if (release === undefined)
+                return busyUpdating();
+            let plan;
+            try {
+                plan = planBackup(deps);
+            }
+            catch (error) {
+                release();
+                if (error instanceof BackupBusyError)
+                    return {
+                        ok: false,
+                        status: 409,
+                        detail: `Slopify can't back up while ${named(error.projects)} ${error.projects.length === 1 ? "is" : "are"} being made: their files are still being written. Wait for them to finish, or pause them on their project page, then press Back up now again.`,
+                    };
+                throw error;
+            }
+            void start(plan, "manual", null, release);
+            return { ok: true };
+        },
+        tick: async () => {
+            if (stopped || current !== undefined)
+                return;
+            const settings = config();
+            const decision = decideBackup({
+                config: settings,
+                status: readStatus(deps.db),
+                now: deps.clock.now(),
+                bootedAt: deps.bootedAt,
+                running: false,
+            });
+            if (!decision.due)
+                return;
+            if (folderProblem(deps.paths, settings.folder) !== undefined)
+                return;
+            const release = deps.beginMutation === undefined ? () => { } : deps.beginMutation();
+            // An update is being installed; the backup runs after the restart.
+            if (release === undefined)
+                return;
+            let plan;
+            try {
+                plan = planBackup(deps);
+            }
+            catch (error) {
+                release();
+                if (error instanceof BackupBusyError) {
+                    waiting(error.projects, decision.trigger, decision.slot);
+                    return;
+                }
+                deps.log.write("error", "backups.plan", { detail: String(error) });
+                record({
+                    ...readStatus(deps.db),
+                    lastAttemptAt: deps.clock.now().toISOString(),
+                    lastResult: "failed",
+                    lastTrigger: decision.trigger,
+                    lastSlot: decision.slot,
+                    detail: "The backup was not saved because Slopify could not read what to back up. It tries again in an hour; if it keeps failing, use Download diagnostics in Settings and report it.",
+                    lastDurationMs: null,
+                });
+                return;
+            }
+            await start(plan, decision.trigger, decision.slot, release);
+        },
+        stop: async () => {
+            stopped = true;
+            const running = current;
+            if (running === undefined)
+                return;
+            running.abort.abort(new Error("Slopify is stopping."));
+            await running.done;
+        },
+    };
+}
+function busyUpdating() {
+    return {
+        ok: false,
+        status: 409,
+        detail: "Slopify is installing an update. Press Back up now again after it restarts.",
+    };
+}
+async function checkSpace(folder, needed) {
+    let free;
+    try {
+        const stats = await statfs(folder);
+        free = Number(stats.bavail) * Number(stats.bsize);
+    }
+    catch {
+        return;
+    }
+    if (free < needed)
+        throw new NoSpaceError(needed, free);
+}
+class NoSpaceError extends Error {
+    needed;
+    free;
+    constructor(needed, free) {
+        super("Not enough free space for the backup.");
+        this.needed = needed;
+        this.free = free;
+    }
+}
+function named(projects) {
+    const titles = projects
+        .slice(0, 3)
+        .map((project) => `"${project.title}"`)
+        .join(", ");
+    return projects.length > 3 ? `${titles} and ${projects.length - 3} more` : titles;
+}
+// What failed, why, and what to change - the sentence Settings → Backups shows.
+export function explain(error, folder, retries, signal) {
+    const fix = "Pick another Folder in Settings → Backups, or leave it empty to use the default";
+    if (signal?.aborted === true && error === signal.reason)
+        return "The backup was not saved: Slopify stopped while writing it, and the unfinished file was removed. It runs again after Slopify starts.";
+    if (error instanceof NoSpaceError)
+        return `The backup was not saved: it needs about ${bytes(error.needed)}, but the disk holding ${folder} has ${bytes(error.free)} free. Free up space there, lower "Keep last" in Settings → Backups, or pick another Folder.`;
+    switch (codeOf(error)) {
+        case "ENOSPC":
+        case "EDQUOT":
+            return `The backup was not saved: the disk holding ${folder} ran out of space. Free up space there, lower "Keep last" in Settings → Backups, or pick another Folder.`;
+        case "EACCES":
+        case "EPERM":
+        case "EROFS":
+            return `The backup was not saved: Slopify is not allowed to write to ${folder}. ${fix}.`;
+        case "ENOTDIR":
+        case "EEXIST":
+            return `The backup was not saved: ${folder} (or a part of its path) is a file, not a folder. ${fix}.`;
+    }
+    const again = retries
+        ? "It tries again within the hour, or press Back up now"
+        : "Press Back up now to try again";
+    if (error instanceof Error &&
+        error.message.endsWith("changed while the backup was being written."))
+        return `The backup was not saved: a project file changed while it was being copied. ${again}.`;
+    return `The backup was not saved because of an unexpected error. ${again}; if it keeps failing, use Download diagnostics in Settings and report it.`;
+}
+function bytes(value) {
+    const units = ["B", "KB", "MB", "GB", "TB"];
+    let amount = value;
+    let unit = 0;
+    while (amount >= 1024 && unit < units.length - 1) {
+        amount /= 1024;
+        unit += 1;
+    }
+    return `${amount >= 10 || unit === 0 ? amount.toFixed(0) : amount.toFixed(1)} ${units[unit]}`;
+}

package/dist/slices/batch/index.js

@@ -48,6 +48,8 @@ export function enqueueBatch(deps, batchId, runs, retainStaged = false) {
             if (draft.sources.images === "provide")
                 for (const id of draft.provided.images ?? [])
                     used.add(id);
+            if (draft.shorts?.enabled === true && draft.provided.shortsMusic)
+                used.add(draft.provided.shortsMusic);
         }
         for (const id of retainStaged ? [] : used) {
             sources.add(id);

package/dist/slices/estimate/index.js

@@ -1,12 +1,17 @@
 import { z } from "zod";
 import { sourceOf } from "../admission/model.js";
-import { usesNarrationPreparation, usesYoutubeDescription } from "../admission/rules.js";
+import { imageSecondsProblem, usesNarrationPreparation, usesReference, usesShorts, usesYoutubeDescription, } from "../admission/rules.js";
 import { plainText } from "../article/plain.js";
 import { splitEndMatter } from "../article/split.js";
 import { chunkNarration, defaultChunking } from "../narration/chunk.js";
 import { normalizeNarrationText } from "../narration/plan.js";
 import { preparationMessages } from "../narration/preparation.js";
+import { defaultShortsImagePrompt, defaultShortsPrompt, shortsImageUpperBound, shortsSettingsProblems, } from "../shorts/model.js";
+import { animatedClipSeconds, animatedImageIndexes, usesAnimation, videoEditProblems, } from "../video/edit-settings.js";
 import { defaultDescriptionPrompt } from "../youtube/model.js";
+// ceiling: the most chapters "Chapter openers" is charged for before the article exists, the
+// top of the 5-12 chapters the built-in YouTube description prompt asks for.
+const chapterOpenersMax = 12;
 import { estimateRequests, groupEstimateRows } from "./requests.js";
 export { estimateRequests } from "./requests.js";
 export function estimateRun(draft, rendered, expectedWords, catalogue) {
@@ -34,7 +39,10 @@ export function estimateRun(draft, rendered, expectedWords, catalogue) {
         !model.deprecated)?.pricing.note ?? "Model or account pricing is unknown.";
     const generatedArticle = draft.sources.article === "generate";
     const articleChars = generatedArticle ? expectedWords * 6 : (draft.provided.article?.length ?? 0);
-    const promptChars = Object.entries(rendered).reduce((sum, [key, value]) => sum + (key === "narration" || key === "description" ? 0 : value.length), 0);
+    const promptChars = Object.entries(rendered).reduce((sum, [key, value]) => sum +
+        (key === "narration" || key === "description" || key === "shorts" || key === "shortsImage"
+            ? 0
+            : value.length), 0);
     const local = (stage, detail) => {
         requests.push({ kind: "local", stage, detail });
     };
@@ -112,6 +120,14 @@ export function estimateRun(draft, rendered, expectedWords, catalogue) {
         });
     if (images === 0)
         local("Images", "Provided or off.");
+    // The establishing image is one more image when it is made from a prompt.
+    if (usesReference(draft) && draft.reference?.source === "prompt")
+        requests.push({
+            kind: "image",
+            stage: "Establishing image",
+            provider: image.provider,
+            model: image.model,
+        });
     if (["from_prompt", "prompt_by_llm"].includes(draft.sources.thumbnail))
         requests.push({
             kind: "image",
@@ -132,6 +148,53 @@ export function estimateRun(draft, rendered, expectedWords, catalogue) {
             : defaultDescriptionPrompt.length) +
             Math.round(articleChars * 1.05) +
             1500, 2400, "One LLM call on the timed transcript.");
+    // Shorts: one call picks the clips from the numbered transcript, one per clip writes its
+    // image prompts, and the images are charged at the most the step can ask for, every clip
+    // at the longest length allowed.
+    const shorts = draft.shorts;
+    // Numbers the run would refuse are not priced: a typo of 3000 shorts would list them all.
+    if (usesShorts(draft) &&
+        shorts !== undefined &&
+        shortsSettingsProblems(shorts).length === 0 &&
+        imageSecondsProblem(draft.imageSeconds) === undefined) {
+        text("Shorts", (rendered.shorts?.trim() ? rendered.shorts.length : defaultShortsPrompt.length) +
+            Math.round(articleChars * 1.15) +
+            1500, 400 * shorts.count, "One LLM call on the numbered transcript picks the clips.");
+        const style = rendered.shortsImage?.trim()
+            ? rendered.shortsImage.length
+            : defaultShortsImagePrompt.length;
+        for (let clip = 0; clip < shorts.count; clip++)
+            text("Shorts", style + 3000, 2400, "One LLM call per short writes its image prompts.");
+        const count = shortsImageUpperBound(shorts, draft.imageSeconds);
+        for (let index = 0; index < count; index++)
+            requests.push({
+                kind: "image",
+                stage: "Shorts",
+                provider: image.provider,
+                model: image.model,
+                detail: `Up to ${String(count)} vertical images. ${imageNote}`,
+            });
+    }
+    // Animated images: one clip from the image-to-video model per animated image, each priced
+    // as the catalogue prices one clip. Only drawn images are animated; the chapter openers are
+    // charged at the most there can be, one per image up to twelve chapters.
+    const edit = draft.videoEdit;
+    if (usesAnimation(draft) && edit !== undefined && videoEditProblems(draft).length === 0) {
+        const clips = edit.animate === "every"
+            ? animatedImageIndexes(edit, images).length
+            : Math.min(images, chapterOpenersMax);
+        const note = data.image.find((model) => model.provider === image.provider && model.id === edit.animateModel)?.pricing.note ?? "Model or account pricing is unknown.";
+        for (let index = 0; index < clips; index++)
+            requests.push({
+                kind: "image",
+                stage: "Animated images",
+                provider: image.provider,
+                model: edit.animateModel,
+                detail: edit.animate === "every"
+                    ? `${String(clips)} clips of ${String(animatedClipSeconds)} seconds. ${note}`
+                    : `Up to ${String(clips)} clips of ${String(animatedClipSeconds)} seconds, one per chapter opening. ${note}`,
+            });
+    }
     if (sourceOf(draft.sources, "document") === "generate")
         local("Document", "Laid out locally from the article; no API fee.");
     return {

package/dist/slices/fonts/catalog.js

@@ -9,6 +9,9 @@ import { readFontMetadata } from "./sfnt.js";
 export const fontIdPattern = /^(?:default|(?:system|uploaded)-[a-f0-9]{64})$/;
 const uploadName = /^(uploaded-[a-f0-9]{64})\.(ttf|otf)$/;
 const bundled = fileURLToPath(new URL("../../assets/fonts/Barlow-Regular.ttf", import.meta.url));
+// Barlow's own Bold face, for text drawn bold in the bundled font (the shorts' captions);
+// not listed as a font of its own.
+const bundledBold = fileURLToPath(new URL("../../assets/fonts/Barlow-Bold.ttf", import.meta.url));
 export async function listFonts(paths) {
     const [defaultFont, uploaded, system] = await Promise.all([
         bundledFont(),
@@ -30,6 +33,26 @@ export async function resolveFont(paths, id) {
         throw missingFont();
     return font;
 }
+// The font to draw bold text in: for the bundled Barlow its real Bold face, so the letters
+// are drawn as designed; any other font is the font itself, which libass emboldens.
+export async function resolveBoldFont(paths, id) {
+    if (id !== "default")
+        return resolveFont(paths, id);
+    const bytes = await readFontFile(bundledBold);
+    const face = bytes === undefined ? undefined : readFontMetadata(bytes)?.[0];
+    if (face === undefined)
+        throw new Error("Slopify's bundled Barlow Bold font is missing or invalid. Reinstall Slopify.");
+    return {
+        id: "default",
+        name: face.name,
+        family: face.family,
+        source: "bundled",
+        path: bundledBold,
+        extension: ".ttf",
+        assName: face.assName,
+        faceIndex: 0,
+    };
+}
 export function missingFont() {
     return new Error("The chosen caption font is no longer available; it may have been uninstalled or deleted. Choose another font in Edit project → Subtitles, then try again.", {
         cause: "font-not-found",

package/dist/slices/fonts/index.js

@@ -1,4 +1,4 @@
-export { fontIdPattern, isMissingFont, listFonts, resolveFont } from "./catalog.js";
+export { fontIdPattern, isMissingFont, listFonts, resolveBoldFont, resolveFont, } from "./catalog.js";
 export { fontMaxBytes } from "./model.js";
 export { previewFont } from "./preview.js";
 export { standaloneFont } from "./sfnt.js";

package/dist/slices/library/model.js

@@ -2,7 +2,14 @@
 // set covers both, which is why the drafts, the lint and the save path below are shared
 // rather than mirrored.
 export { entryModes } from "../admission/model.js";
-export const promptKinds = ["article", "image", "thumbnail", "narration", "description"];
+export const promptKinds = [
+    "article",
+    "image",
+    "thumbnail",
+    "narration",
+    "description",
+    "shorts",
+];
 export const entryCategories = ["intro", "outro"];
 // The name is what the Play pickers show, so it shares admission's title bound.
 export const nameMax = 200;