@gentbajko/slopify 0.5.1 → 0.6.1

package/dist/assets/fonts/OFL.txt

@@ -0,0 +1,93 @@
+Copyright 2017 The Barlow Project Authors (https://github.com/jpt/barlow)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

package/dist/assets/fonts/SOURCE.txt

@@ -0,0 +1,7 @@
+Barlow-Regular.ttf
+Source: https://raw.githubusercontent.com/google/fonts/6cdf01867df0813c2390f90dff7dc66c87f14cf7/ofl/barlow/Barlow-Regular.ttf
+SHA-256: 95aa02c7c43096e0dd44d787ba6216864a67157e402adab59b35572e0c1577ea
+
+OFL.txt
+Source: https://raw.githubusercontent.com/google/fonts/6cdf01867df0813c2390f90dff7dc66c87f14cf7/ofl/barlow/OFL.txt
+SHA-256: 186d750eb496a4c17a76385f82be6aea2ac1cf2de074a811d63786cf374ea73f

package/dist/edge/http/app.js

@@ -5,12 +5,14 @@ import { streamSSE } from "hono/streaming";
 import { actionRoutes } from "./actions.js";
 import { entryRoutes } from "./entries.js";
 import { fileRoutes } from "./files.js";
+import { fontsRoutes } from "./fonts.js";
 import { problem, problemFromError, titleOf } from "./problem.js";
 import { projectRoutes } from "./projects.js";
 import { promptRoutes } from "./prompts.js";
 import { providerRoutes } from "./providers.js";
 import { settingsRoutes } from "./settings.js";
 import { stagingRoutes } from "./staging.js";
+import { subtitleRoutes } from "./subtitles.js";
 import { telemetryRoutes } from "./telemetry.js";
 import { usageRoutes } from "./usage.js";
 const notBuilt = "The Slopify UI is not built yet. The API is running: try /api/health.\n" +
@@ -27,6 +29,8 @@ function apiRoutes(deps, startedAt) {
         // The re-run and cancel actions sit on the same prefix as the project itself; they
         // are their own router because they are their own concern.
         .route("/projects", actionRoutes(deps))
+        .route("/projects", subtitleRoutes(deps))
+        .route("/fonts", fontsRoutes(deps))
         .route("/prompts", promptRoutes(deps))
         .route("/entries", entryRoutes(deps))
         .route("/telemetry", telemetryRoutes(deps))

package/dist/edge/http/fonts.js

@@ -0,0 +1,147 @@
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { Busboy } from "@fastify/busboy";
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { z } from "zod";
+import { fontIdPattern, fontMaxBytes, isMissingFont, listFonts, previewFont, uploadFont, } from "../../slices/fonts/index.js";
+import { problem, titleOf } from "./problem.js";
+const idParam = z.object({ id: z.string().regex(fontIdPattern) });
+// Inferred so the Hono client retains all response shapes.
+export function fontsRoutes(deps) {
+    return new Hono()
+        .get("/", async (c) => c.json({ fonts: await listFonts(deps.paths) }))
+        .post("/", async (c) => {
+        const contentType = c.req.header("content-type");
+        if (contentType === undefined || !contentType.toLowerCase().startsWith("multipart/form-data"))
+            return problem(c, {
+                status: 415,
+                title: titleOf(415),
+                detail: "Upload one .ttf or .otf file as multipart/form-data.",
+            });
+        const body = c.req.raw.body;
+        if (body === null)
+            return problem(c, {
+                status: 400,
+                title: titleOf(400),
+                detail: "The request carried no font file.",
+            });
+        const part = await readUpload(contentType, body);
+        if (!part.ok) {
+            const tooLarge = part.reason === "too-large";
+            return problem(c, {
+                status: tooLarge ? 413 : 400,
+                title: tooLarge ? "Content Too Large" : titleOf(400),
+                detail: tooLarge
+                    ? "A font file must be no larger than 32 MiB."
+                    : "Upload exactly one complete font file in the file part.",
+            });
+        }
+        const result = await uploadFont(deps.paths, part.upload);
+        if (!result.ok)
+            return problem(c, failure(result.reason));
+        return c.json({ font: result.font }, 201);
+    })
+        .get("/:id/file", zValidator("param", idParam, (result, c) => {
+        if (!result.success)
+            return problem(c, { status: 404, title: titleOf(404), detail: "No font has that id." });
+        return undefined;
+    }), async (c) => {
+        try {
+            const preview = await previewFont(deps.paths, c.req.valid("param").id);
+            return c.body(Uint8Array.from(preview.content), 200, {
+                "content-type": preview.contentType,
+                "x-content-type-options": "nosniff",
+                "cache-control": "private, max-age=300",
+            });
+        }
+        catch (error) {
+            if (!isMissingFont(error))
+                throw error;
+            return problem(c, { status: 404, title: titleOf(404), detail: "No font has that id." });
+        }
+    });
+}
+// Bounded buffering is intentional for small font files. No file is committed until
+// the entire multipart envelope finishes, so a second part or truncation cannot save it.
+async function readUpload(contentType, body) {
+    let parser;
+    try {
+        parser = new Busboy({
+            headers: { "content-type": contentType },
+            preservePath: true,
+            limits: { files: 1, fields: 0, parts: 1, fileSize: fontMaxBytes + 1 },
+        });
+    }
+    catch {
+        return { ok: false, reason: "multipart" };
+    }
+    const chunks = [];
+    let filename;
+    let count = 0;
+    let invalid = false;
+    let tooLarge = false;
+    parser.on("file", (field, stream, name) => {
+        filename = name;
+        if (field !== "file")
+            invalid = true;
+        stream.on("data", (chunk) => {
+            count += chunk.byteLength;
+            if (count > fontMaxBytes)
+                tooLarge = true;
+            else
+                chunks.push(chunk);
+        });
+        stream.on("limit", () => {
+            tooLarge = true;
+        });
+        stream.on("error", (error) => {
+            invalid = true;
+            parser.destroy(error);
+        });
+    });
+    parser.on("filesLimit", () => {
+        invalid = true;
+    });
+    parser.on("fieldsLimit", () => {
+        invalid = true;
+    });
+    parser.on("partsLimit", () => {
+        invalid = true;
+    });
+    try {
+        await pipeline(Readable.fromWeb(body), parser);
+    }
+    catch {
+        return { ok: false, reason: "multipart" };
+    }
+    if (tooLarge)
+        return { ok: false, reason: "too-large" };
+    if (invalid || filename === undefined)
+        return { ok: false, reason: "multipart" };
+    return { ok: true, upload: { filename, content: Buffer.concat(chunks, count) } };
+}
+function failure(reason) {
+    switch (reason) {
+        case "too-large":
+            return {
+                status: 413,
+                title: "Content Too Large",
+                detail: "A font file must be no larger than 32 MiB.",
+            };
+        case "unsupported-format":
+            return { status: 415, title: titleOf(415), detail: "Choose a .ttf or .otf font file." };
+        case "unsafe-filename":
+            return {
+                status: 400,
+                title: titleOf(400),
+                detail: "The font filename cannot contain a path or control character.",
+            };
+        case "invalid-font":
+            return {
+                status: 400,
+                title: titleOf(400),
+                detail: "This file is not a supported, valid TrueType or OpenType font.",
+            };
+    }
+}

package/dist/edge/http/projects.js

@@ -6,6 +6,7 @@ import { listProjects, projectById, runDraftSchema, stageStandingsByProject, sta
 import { admit } from "../../slices/admission/rules.js";
 import { startRun } from "../../slices/admission/start.js";
 import { withProjectControl } from "../../slices/control/lock.js";
+import { resolveFont } from "../../slices/fonts/index.js";
 import { pickTemplates, renderPicked } from "../../slices/library/slots.js";
 import { deleteProject } from "../../slices/storage/delete-project.js";
 import { outputsOf, stagedFiles } from "../../slices/storage/repo.js";
@@ -44,7 +45,28 @@ export function projectRoutes(deps) {
         status: derive(stagesOf(deps.db, project.id), project.paused),
     });
     return (new Hono()
-        .post("/", zValidator("json", runDraftSchema, onInvalid), (c) => {
+        .post("/", zValidator("json", runDraftSchema, onInvalid), async (c) => {
+        const requestedSubtitles = c.req.valid("json").subtitles;
+        if (requestedSubtitles !== undefined && requestedSubtitles.mode !== "off") {
+            try {
+                await resolveFont(deps.paths, requestedSubtitles.fontId);
+            }
+            catch {
+                return problem(c, {
+                    status: 400,
+                    title: titleOf(400),
+                    detail: "Choose an available subtitle font before starting.",
+                    extensions: {
+                        fields: [
+                            {
+                                field: "subtitles.fontId",
+                                message: "This font is no longer available; choose another or upload it again.",
+                            },
+                        ],
+                    },
+                });
+            }
+        }
         // The bodies are read here, at the click, so an edit made since the
         // prompt was selected is the one that runs.
         const picked = pickTemplates(deps.db, c.req.valid("json"));

package/dist/edge/http/providers.js

@@ -1,6 +1,7 @@
 import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
 import { z } from "zod";
+import { cliPathMaxLength, saveCliPath } from "../../slices/settings/cli-paths.js";
 import { keyStatus, removeProviderKey, saveProviderKey } from "../../slices/settings/keys.js";
 import { providerById, providerIds } from "../../slices/settings/model.js";
 import { providerStatuses } from "../../slices/settings/readiness.js";
@@ -9,6 +10,7 @@ const providerParam = z.object({ id: z.enum(providerIds) });
 // ceiling: no format check is allowed on a key, so the only thing said about the value is
 // that it is a string of a length a key could plausibly have. Raise the bound if a provider
 // ever issues something longer.
+const pathBody = z.object({ path: z.string().max(cliPathMaxLength) });
 const keyBody = z.object({ key: z.string().min(1).max(4096) });
 // The return type is inferred so Hono keeps the route types the SPA's client is
 // generated from; see stagingRoutes.
@@ -19,6 +21,17 @@ export function providerRoutes(deps) {
         // What Settings draws its rails from and Play its dropdowns: every provider, with
         // the one fact that decides whether it is selectable.
         .get("/", async (c) => c.json({ providers: await providerStatuses(readiness) }))
+        .put("/:id/path", zValidator("param", providerParam, onInvalid), zValidator("json", pathBody, onInvalid), async (c) => {
+        const result = await saveCliPath(readiness, c.req.valid("param").id, c.req.valid("json").path);
+        if (!result.ok)
+            return problem(c, {
+                status: 400,
+                title: titleOf(400),
+                detail: result.message,
+                extensions: { fields: [{ field: "path", message: result.message }] },
+            });
+        return c.json(result.status);
+    })
         .put("/:id/key", zValidator("param", providerParam, onInvalid), zValidator("json", keyBody, onInvalid), (c) => {
         const { id } = c.req.valid("param");
         const result = saveProviderKey(keys, id, c.req.valid("json").key);

package/dist/edge/http/subtitles.js

@@ -0,0 +1,92 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { derive } from "../../kernel/runner/graph.js";
+import { projectById, resetStage, stagesOf, updateProjectConfig, } from "../../slices/admission/repo.js";
+import { withProjectControl } from "../../slices/control/lock.js";
+import { resolveFont } from "../../slices/fonts/index.js";
+import { outputsOf } from "../../slices/storage/repo.js";
+import { subtitleConfigSchema } from "../../slices/subtitles/model.js";
+import { onInvalid, problem, titleOf } from "./problem.js";
+const idParam = z.object({
+    id: z
+        .string()
+        .min(1)
+        .max(64)
+        .regex(/^[0-9A-Za-z_-]+$/),
+});
+export function subtitleRoutes(deps) {
+    return new Hono().patch("/:id/subtitles", zValidator("param", idParam, onInvalid), zValidator("json", subtitleConfigSchema, onInvalid), async (c) => {
+        const { id } = c.req.valid("param");
+        return withProjectControl(deps.db, id, async () => {
+            const project = projectById(deps.db, id);
+            if (project === undefined)
+                return problem(c, {
+                    status: 404,
+                    title: titleOf(404),
+                    detail: "No project has that id.",
+                });
+            const stages = stagesOf(deps.db, id);
+            if (stages.some((stage) => stage.state === "running") || deps.runner.hasInflight?.(id))
+                return problem(c, {
+                    status: 409,
+                    title: titleOf(409),
+                    detail: "Pause the run and wait for its active work to stop before changing subtitles.",
+                });
+            const chosen = c.req.valid("json");
+            if (chosen.mode !== "off" && project.config.sources.audio === "off")
+                return problem(c, {
+                    status: 400,
+                    title: titleOf(400),
+                    detail: "Subtitles need narration audio.",
+                });
+            const subtitles = project.config.sources.video === "off" && chosen.mode === "burn-in"
+                ? { ...chosen, mode: "files" }
+                : chosen;
+            if (subtitles.mode !== "off" && subtitles.fontId !== project.config.subtitles?.fontId) {
+                try {
+                    await resolveFont(deps.paths, subtitles.fontId);
+                }
+                catch {
+                    return problem(c, {
+                        status: 400,
+                        title: titleOf(400),
+                        detail: "That font is no longer available. Choose another font or upload it again.",
+                    });
+                }
+            }
+            // Font discovery awaits filesystem work; a pending runner may have claimed a
+            // stage during that time. Recheck synchronously immediately before the write.
+            if (stagesOf(deps.db, id).some((stage) => stage.state === "running") ||
+                deps.runner.hasInflight?.(id)) {
+                return problem(c, {
+                    status: 409,
+                    title: titleOf(409),
+                    detail: "Pause the run before changing subtitles.",
+                });
+            }
+            const video = stages.find((stage) => stage.kind === "video");
+            transact(deps.db, () => {
+                updateProjectConfig(deps.db, id, { ...project.config, subtitles }, deps.clock.now().toISOString());
+                // Only the local final export is invalidated. Existing provider outputs and
+                // the last finished export remain intact until its replacement succeeds.
+                if (video !== undefined &&
+                    (project.config.sources.audio !== "off" || project.config.sources.video !== "off"))
+                    resetStage(deps.db, video.id);
+            });
+            deps.hub.emit(id, { type: "project.updated", projectId: id });
+            if (project.paused !== true)
+                deps.runner.tick(id);
+            const current = stagesOf(deps.db, id);
+            return c.json({
+                project: {
+                    ...projectById(deps.db, id),
+                    status: derive(current, project.paused === true),
+                },
+                stages: current,
+                outputs: outputsOf(deps.db, id),
+            });
+        });
+    });
+}

package/dist/kernel/cli-command.js

@@ -0,0 +1,45 @@
+import { readFileSync, statSync } from "node:fs";
+import { extname, isAbsolute, join, resolve, win32 } from "node:path";
+// Keep prompts out of cmd.exe: npm launchers name a JavaScript entry point that
+// Node can execute directly with an argv array, including quotes and newlines.
+export function cliCommand(binary) {
+    const file = process.platform === "win32" ? windowsFile(binary) : binary;
+    if (/\.[cm]?js$/i.test(file))
+        return { file: process.execPath, args: [resolve(file)] };
+    if (process.platform !== "win32" || !/\.(cmd|bat)$/i.test(file))
+        return { file, args: [] };
+    const stat = statSync(file);
+    if (!stat.isFile() || stat.size > 64 * 1024)
+        throw unsupportedShim();
+    const target = windowsShimTarget(file, readFileSync(file, "utf8"));
+    if (target === undefined || !statSync(target, { throwIfNoEntry: false })?.isFile())
+        throw unsupportedShim();
+    return { file: process.execPath, args: [target] };
+}
+export function windowsShimTarget(file, source) {
+    if (!/(?:node|bun)(?:\.exe)?/i.test(source))
+        return undefined;
+    // npm's cmd-shim uses %dp0%, older launchers use %~dp0. The remainder must
+    // be a literal relative script path, followed by the original argument list.
+    const matched = /"(?:%dp0%|%~dp0)[\\/]?([^"%\r\n]+\.[cm]?js)"\s+%\*/i.exec(source);
+    if (matched?.[1] === undefined || win32.isAbsolute(matched[1]))
+        return undefined;
+    return win32.resolve(win32.dirname(file), matched[1]);
+}
+function windowsFile(binary) {
+    const path = Object.entries(process.env).find(([key]) => key.toLowerCase() === "path")?.[1] ?? "";
+    const directories = isAbsolute(binary) || /[\\/]/.test(binary) ? [""] : path.split(";");
+    const suffixes = extname(binary) === "" ? [".exe", ".com", ".cmd", ".bat", ""] : [""];
+    for (const directory of directories) {
+        for (const suffix of suffixes) {
+            const file = directory === "" ? binary + suffix : join(directory.replace(/^"|"$/g, ""), binary + suffix);
+            if (statSync(file, { throwIfNoEntry: false })?.isFile())
+                return resolve(file);
+        }
+    }
+    // Let spawn report its usual ENOENT when no executable exists.
+    return binary;
+}
+function unsupportedShim() {
+    return new Error("This batch launcher is not a supported Node CLI shim. Select the CLI's .exe or JavaScript entry file instead.");
+}

package/dist/kernel/ports/subtitles.js

@@ -0,0 +1 @@
+export {};

package/dist/kernel/runner/providers.js

@@ -30,11 +30,12 @@ export function stageProviders(deps, context, pieceId) {
                     if (event.type === "delta") {
                         text += event.text;
                     }
-                    else {
+                    else if (event.type === "done") {
                         usage = event.usage;
                         finishReason = event.finishReason;
                     }
-                    onEvent?.(event);
+                    if (event.type !== "activity")
+                        onEvent?.(event);
                 }
                 const answer = { text, usage, finishReason };
                 const unusable = call.check?.(answer);

package/dist/main.js

@@ -2,6 +2,7 @@ import { fileURLToPath } from "node:url";
 import { serve } from "@hono/node-server";
 import ffmpegStatic from "ffmpeg-static";
 import { buildRegistry } from "./adapter-registry.js";
+import { alignSubtitles } from "./adapters/alignment/index.js";
 import { prepareFfmpeg } from "./adapters/ffmpeg.js";
 import { nodeRunCli } from "./adapters/llm/run-cli.js";
 import { cartesiaModel } from "./adapters/tts/cartesia.js";
@@ -150,7 +151,7 @@ function wire({ db, paths, clock, ids, log, hub, telemetry, flusher, registry, f
     };
     // The audio stage joins its chunks with the same binary the render uses, so it takes
     // the same seven dependencies.
-    const video = { db, paths, ids, clock, log, ffmpeg, count };
+    const video = { db, paths, ids, clock, log, ffmpeg, count, alignSubtitles };
     // Research, the article, the images and the thumbnail all write into the same project
     // folder from the same database handle, so they take the same six dependencies.
     const writing = { db, paths, ids, clock, log, count };

package/dist/slices/admission/repo.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { stageKinds, stageStates } from "../../kernel/pipeline.js";
 import { chunkModes } from "../narration/chunk.js";
+import { subtitleConfigSchema } from "../subtitles/model.js";
 import { entryModes, formats, stageSources } from "./model.js";
 const providerChoice = z.object({ provider: z.string(), model: z.string() });
 const entryChoice = z.object({ name: z.string(), mode: z.enum(entryModes) });
@@ -39,6 +40,7 @@ export const runDraftSchema = z.object({
     // a mode not listed here would never reach the audio stage.
     chunking: z.object({ mode: z.enum(chunkModes), words: z.number().optional() }).optional(),
     silenceGapSeconds: z.number(),
+    subtitles: subtitleConfigSchema.optional(),
 });
 export const runConfigSchema = runDraftSchema.extend({
     rendered: z.record(z.string(), z.string()),

package/dist/slices/admission/rules.js

@@ -71,6 +71,9 @@ export function admit(input) {
         blank(draft.thumbnailPrompt)) {
         fields.push({ field: "thumbnailPrompt", message: "Pick a thumbnail prompt." });
     }
+    if (sources.audio === "off" && draft.subtitles !== undefined && draft.subtitles.mode !== "off") {
+        fields.push({ field: "subtitles.mode", message: "Subtitles need narration audio." });
+    }
     checkProvided(draft, input.staged, fields);
     checkValues(draft, input.requiredSlots, fields);
     if (!Number.isFinite(draft.silenceGapSeconds) ||
@@ -104,6 +107,9 @@ export function normaliseDraft(draft) {
     return {
         ...draft,
         title: draft.title.trim(),
+        subtitles: sources.video === "off" && draft.subtitles?.mode === "burn-in"
+            ? { ...draft.subtitles, mode: "files" }
+            : draft.subtitles,
         sources,
         values,
         intro: sources.audio === "generate" ? draft.intro : undefined,

package/dist/slices/fonts/catalog.js

@@ -0,0 +1,95 @@
+import { createHash } from "node:crypto";
+import { lstat, readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { discoverSystemFonts } from "./discovery.js";
+import { readFontFile, unavailable } from "./files.js";
+import { fontSummary } from "./model.js";
+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));
+export async function listFonts(paths) {
+    const [defaultFont, uploaded, system] = await Promise.all([
+        bundledFont(),
+        uploadedFonts(paths),
+        discoverSystemFonts(),
+    ]);
+    return [defaultFont, ...uploaded, ...system].map(fontSummary);
+}
+export async function resolveFont(paths, id) {
+    if (!fontIdPattern.test(id))
+        throw missingFont();
+    if (id === "default")
+        return bundledFont();
+    const fonts = id.startsWith("uploaded-")
+        ? await uploadedFonts(paths, id)
+        : await discoverSystemFonts();
+    const font = fonts.find((font) => font.id === id);
+    if (font === undefined)
+        throw missingFont();
+    return font;
+}
+export function missingFont() {
+    return new Error("The selected font is no longer available. Choose another font.", {
+        cause: "font-not-found",
+    });
+}
+export function isMissingFont(error) {
+    return error instanceof Error && error.cause === "font-not-found";
+}
+async function bundledFont() {
+    const bytes = await readFontFile(bundled);
+    const face = bytes === undefined ? undefined : readFontMetadata(bytes)?.[0];
+    if (face === undefined)
+        throw new Error("Slopify's bundled Barlow font is missing or invalid. Reinstall Slopify.");
+    return {
+        id: "default",
+        name: face.name,
+        family: face.family,
+        source: "bundled",
+        path: bundled,
+        extension: ".ttf",
+        assName: face.assName,
+        faceIndex: 0,
+    };
+}
+async function uploadedFonts(paths, wanted) {
+    const root = join(paths.dataDir, "fonts");
+    let names;
+    try {
+        if (!(await lstat(root)).isDirectory())
+            return [];
+        names = wanted === undefined ? await readdir(root) : [`${wanted}.ttf`, `${wanted}.otf`];
+    }
+    catch (error) {
+        if (unavailable(error))
+            return [];
+        throw error;
+    }
+    const result = [];
+    for (const name of names.toSorted()) {
+        const id = uploadName.exec(name)?.[1];
+        if (id === undefined)
+            continue;
+        const path = join(root, name);
+        const bytes = await readFontFile(path);
+        if (bytes === undefined ||
+            `uploaded-${createHash("sha256").update(bytes).digest("hex")}` !== id)
+            continue;
+        const face = readFontMetadata(bytes)?.[0];
+        if (face === undefined || face.extension === ".ttc")
+            continue;
+        result.push({
+            id,
+            name: face.name,
+            family: face.family,
+            source: "uploaded",
+            path,
+            extension: face.extension,
+            assName: face.assName,
+            faceIndex: 0,
+        });
+    }
+    return result;
+}