@gentbajko/slopify 0.5.1 → 0.7.0

package/dist/kernel/ports/subtitles.js

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

package/dist/kernel/runner/providers.js

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto";
 import { attempt } from "./attempt.js";
 export function stageProviders(deps, context, pieceId) {
     const ctx = {
@@ -15,7 +16,18 @@ export function stageProviders(deps, context, pieceId) {
             // Resolved once; the adapter reads the stored key per request, so a key replaced
             // mid-run still reaches the next attempt.
             const port = deps.registry.llm(call.provider);
+            const callId = randomUUID();
+            const preview = (text, reset) => context.emit({
+                type: "llm.preview",
+                projectId: context.stage.projectId,
+                stage: context.stage.kind,
+                callId,
+                label: call.previewLabel ?? context.stage.kind,
+                text,
+                ...(reset === undefined ? {} : { reset }),
+            });
             return attempt(ctx, async (signal, progress) => {
+                preview("", true);
                 let text = "";
                 let usage = null;
                 let finishReason = null;
@@ -25,16 +37,19 @@ export function stageProviders(deps, context, pieceId) {
                     ...(call.webSearch === undefined ? {} : { webSearch: call.webSearch }),
                     signal,
                 })) {
+                    signal.throwIfAborted();
                     // Every event is a sign of life, so the idle clock restarts here.
                     progress();
                     if (event.type === "delta") {
                         text += event.text;
+                        preview(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);
@@ -45,33 +60,69 @@ export function stageProviders(deps, context, pieceId) {
                 return answer;
             }, { kind: "llm", streaming: port.capabilities.streams });
         },
-        tts: (call) => {
+        tts: (call, observe) => {
             const port = deps.registry.tts(call.provider);
+            let continuation;
+            const notify = (event) => {
+                try {
+                    observe?.(event);
+                }
+                catch {
+                    // A preview is optional. A broken observer must never repeat a paid call.
+                    deps.log.write("warn", "audio.preview", {
+                        projectId: context.stage.projectId,
+                        stage: "audio",
+                        detail: "Could not update the live audio preview",
+                    });
+                }
+            };
             return attempt(ctx, async (signal, progress) => {
-                const spoken = await port.synthesize({
-                    voiceId: call.voiceId,
-                    text: call.text,
-                    signal,
-                });
-                const reader = spoken.audio.getReader();
-                const chunks = [];
-                let total = 0;
-                for (;;) {
-                    const { done, value } = await reader.read();
-                    if (done || value === undefined) {
-                        break;
+                notify({ type: "start" });
+                try {
+                    const spoken = await port.synthesize({
+                        model: call.model,
+                        voiceId: call.voiceId,
+                        text: call.text,
+                        signal,
+                        onActivity: progress,
+                        continuation: {
+                            read: () => continuation,
+                            write: (token) => {
+                                continuation = token;
+                            },
+                        },
+                    });
+                    const reader = spoken.audio.getReader();
+                    const chunks = [];
+                    let total = 0;
+                    try {
+                        for (;;) {
+                            const { done, value } = await reader.read();
+                            signal.throwIfAborted();
+                            if (done || value === undefined)
+                                break;
+                            progress();
+                            chunks.push(value);
+                            total += value.length;
+                            notify({ type: "chunk", bytes: value });
+                        }
                     }
-                    progress();
-                    chunks.push(value);
-                    total += value.length;
+                    finally {
+                        reader.releaseLock();
+                    }
+                    const bytes = new Uint8Array(total);
+                    let at = 0;
+                    for (const chunk of chunks) {
+                        bytes.set(chunk, at);
+                        at += chunk.length;
+                    }
+                    notify({ type: "complete" });
+                    return { bytes, container: spoken.container };
                 }
-                const bytes = new Uint8Array(total);
-                let at = 0;
-                for (const chunk of chunks) {
-                    bytes.set(chunk, at);
-                    at += chunk.length;
+                catch (error) {
+                    notify({ type: "interrupted" });
+                    throw error;
                 }
-                return { bytes, container: spoken.container };
             }, { kind: "tts", streaming: port.capabilities.streams });
         },
         image: (call) => {

package/dist/main.js

@@ -1,14 +1,15 @@
+import { randomBytes } from "node:crypto";
+import { existsSync } from "node:fs";
 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";
-import { elevenLabsModel } from "./adapters/tts/elevenlabs.js";
-import { openAiTtsModel } from "./adapters/tts/openai.js";
 import { createHub } from "./edge/events/hub.js";
 import { createApp } from "./edge/http/app.js";
+import { createAudioPreviewStore } from "./kernel/audio-preview.js";
 import { systemClock } from "./kernel/clock.js";
 import { openDb } from "./kernel/db/index.js";
 import { migrate } from "./kernel/db/migrate.js";
@@ -21,6 +22,7 @@ import { dependenciesOf } from "./kernel/runner/graph.js";
 import { createRunner } from "./kernel/runner/index.js";
 import { stageProviders } from "./kernel/runner/providers.js";
 import { readVersion } from "./kernel/version.js";
+import { modelSources } from "./model-catalog.js";
 import { claimStage, finishStage, projectById, projectPaused, stagesOf, } from "./slices/admission/repo.js";
 import { prepareProvidedArticleSegments } from "./slices/article/provided-entries.js";
 import { runArticle } from "./slices/article/run.js";
@@ -34,6 +36,12 @@ import { createFlusher } from "./slices/telemetry/flush.js";
 import { record } from "./slices/telemetry/record.js";
 import { runThumbnail } from "./slices/thumbnail/run.js";
 import { renderVideo } from "./slices/video/run.js";
+import { watchActivation } from "./updater/candidate.js";
+import { launchUpdate } from "./updater/install.js";
+import { isUpdateToken } from "./updater/model.js";
+import { npmCommand, updateCommitted } from "./updater/plan.js";
+import { publishedVersion } from "./updater/registry.js";
+import { createUpdater } from "./updater/service.js";
 // ceiling: a burst of finished stages coalesces into one delivery a second later, and the
 // collector gets ten seconds to answer before the attempt is abandoned and the events
 // stay queued.
@@ -77,25 +85,91 @@ export async function boot(config) {
             clock,
             probe: nodeCliProbe,
         });
-        const runner = wire({ db, paths, clock, ids, log, hub, telemetry, flusher, registry, ffmpeg });
+        const audioPreviews = createAudioPreviewStore();
+        const runner = wire({
+            db,
+            paths,
+            clock,
+            ids,
+            log,
+            hub,
+            telemetry,
+            flusher,
+            registry,
+            ffmpeg,
+            audioPreviews,
+        });
+        const updateDb = db;
+        const oldEntry = fileURLToPath(new URL("./edge/cli.js", import.meta.url));
+        const workerEntry = fileURLToPath(new URL("./edge/update-worker.js", import.meta.url));
+        let npm;
+        try {
+            npm = await npmCommand();
+        }
+        catch {
+            log.write("warn", "update", {
+                detail: "npm is unavailable; in-app installation is disabled.",
+            });
+        }
+        let shutdown = async () => {
+            throw new Error("The server is not ready.");
+        };
+        let listeningPort = config.port;
+        const candidateToken = process.env.SLOPIFY_UPDATE_TOKEN ?? "";
+        const pendingActivation = isUpdateToken(candidateToken) && process.env.SLOPIFY_UPDATE_PENDING === "1";
+        const updater = createUpdater({
+            ...(isUpdateToken(candidateToken)
+                ? {
+                    candidate: {
+                        token: candidateToken,
+                        pending: pendingActivation,
+                        committed: () => updateCommitted(paths.dataDir, version, candidateToken),
+                    },
+                }
+                : {}),
+            currentVersion: version,
+            previousUpdateFailed: process.env.SLOPIFY_UPDATE_FAILED === "1",
+            now: () => Date.now(),
+            latest: () => publishedVersion(globalThis.fetch),
+            unsupported: () => !existsSync(oldEntry) || !existsSync(workerEntry)
+                ? "Run Slopify from its installed package to use in-app updates."
+                : npm === undefined
+                    ? "npm is unavailable. Install Node.js with npm to use in-app updates."
+                    : undefined,
+            busy: () => updateDb.prepare("SELECT 1 FROM stages WHERE state = 'running' LIMIT 1").get() !==
+                undefined ||
+                updateDb
+                    .prepare("SELECT id FROM projects")
+                    .all()
+                    .some((row) => typeof row.id === "string" && runner.hasInflight?.(row.id) === true),
+            report: (message) => log.write("warn", "update", { detail: message }),
+            install: async (next, restarting) => {
+                if (npm === undefined)
+                    throw new Error("npm is unavailable.");
+                await launchUpdate(workerEntry, {
+                    version: next,
+                    token: randomBytes(32).toString("hex"),
+                    previousVersion: version,
+                    oldEntry,
+                    dataDir: paths.dataDir,
+                    cwd: process.cwd(),
+                    host: config.host,
+                    port: listeningPort,
+                    npm: { file: npm.file, args: [...npm.args] },
+                }, async () => {
+                    restarting();
+                    await shutdown();
+                });
+            },
+        });
         const app = createApp({
             db,
             paths,
             hub,
             runner,
-            modelsFor: (provider, family) => {
-                if (family === "llm")
-                    return registry.llm(provider).models();
-                if (family === "image")
-                    return registry.image(provider).models();
-                const models = {
-                    elevenlabs: elevenLabsModel,
-                    "openai-tts": openAiTtsModel,
-                    cartesia: cartesiaModel,
-                };
-                const id = models[provider];
-                return Promise.resolve(id === undefined ? [] : [{ id, name: id }]);
-            },
+            updater,
+            audioPreviews,
+            ...modelSources(registry),
             clock,
             ids,
             log,
@@ -105,14 +179,17 @@ export async function boot(config) {
             probe: nodeCliProbe,
         });
         const server = await listen(app, config, log);
+        listeningPort = portOf(server) ?? config.port;
         // Whatever last run left queued goes out at start. Nothing waits for
         // it, and an unreachable collector costs one refused socket.
         flusher.soon();
         const open = db;
-        return {
-            paths,
-            url: urlOf(config.host, portOf(server) ?? config.port),
-            stop: async () => {
+        let stopping;
+        let stopActivation = () => { };
+        shutdown = () => {
+            stopping ??= (async () => {
+                stopActivation();
+                audioPreviews.close();
                 try {
                     // The listener goes first. Aborting the runner while the socket still accepted
                     // requests let a Play arriving during the await start a stage under a fresh
@@ -131,8 +208,12 @@ export async function boot(config) {
                     open.close();
                     lock.release();
                 }
-            },
+            })();
+            return stopping;
         };
+        if (pendingActivation)
+            stopActivation = watchActivation(updater, candidateToken, shutdown, (message) => log.write("warn", "update", { detail: message }));
+        return { paths, url: urlOf(config.host, listeningPort), stop: shutdown };
     }
     catch (error) {
         db?.close();
@@ -140,7 +221,7 @@ export async function boot(config) {
         throw error;
     }
 }
-function wire({ db, paths, clock, ids, log, hub, telemetry, flusher, registry, ffmpeg, }) {
+function wire({ audioPreviews, db, paths, clock, ids, log, hub, telemetry, flusher, registry, ffmpeg, }) {
     // A stage counts what it did and the queue is flushed after each new event. `record`
     // swallows its own failures, so this can neither fail a stage nor widen what leaves the
     // machine - the payload allow-list is checked inside it.
@@ -150,7 +231,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 };
@@ -176,7 +257,7 @@ function wire({ db, paths, clock, ids, log, hub, telemetry, flusher, registry, f
             audio: async (context) => {
                 const wrapped = stageProviders(providers, context);
                 await prepareProvidedArticleSegments(writing, context, wrapped);
-                await runNarration(video, context, wrapped);
+                await runNarration({ ...video, audioPreviews }, context, wrapped);
             },
             images: (context) => runImages(writing, context, stageProviders(providers, context)),
             thumbnail: (context) => runThumbnail(writing, context, stageProviders(providers, context)),

package/dist/model-catalog.js

@@ -0,0 +1,37 @@
+import { falModels } from "./adapters/image/fal.js";
+import { googleImageModels } from "./adapters/image/google.js";
+import { openAiImageModels } from "./adapters/image/openai.js";
+import { replicateModels } from "./adapters/image/replicate.js";
+import { claudeCodeModels } from "./adapters/llm/claude-code.js";
+import { codexModels } from "./adapters/llm/codex.js";
+import { geminiModels } from "./adapters/llm/gemini.js";
+import { cartesiaModels } from "./adapters/tts/cartesia.js";
+import { elevenLabsModels } from "./adapters/tts/elevenlabs.js";
+import { inworldModels } from "./adapters/tts/inworld.js";
+import { openAiTtsModels } from "./adapters/tts/openai.js";
+// Composition keeps provider-specific fallback data out of the HTTP and settings layers.
+export function modelSources(registry) {
+    const fallbacks = {
+        "claude-code": claudeCodeModels,
+        codex: codexModels,
+        gemini: geminiModels,
+        elevenlabs: elevenLabsModels,
+        "openai-tts": openAiTtsModels,
+        cartesia: cartesiaModels,
+        inworld: inworldModels,
+        fal: falModels,
+        replicate: replicateModels,
+        "openai-image": openAiImageModels,
+        "google-image": googleImageModels,
+    };
+    return {
+        modelsFor: (provider, family) => {
+            if (family === "llm")
+                return registry.llm(provider).models();
+            if (family === "image")
+                return registry.image(provider).models();
+            return registry.tts(provider).models();
+        },
+        fallbackModelsFor: (provider) => Object.hasOwn(fallbacks, provider) ? (fallbacks[provider] ?? []) : [],
+    };
+}

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/control/index.js

@@ -15,6 +15,7 @@ async function providerFields(deps, changes) {
                 providers: await deps.providers(),
                 voices: listVoices(deps.db),
                 modelsFor: deps.modelsFor,
+                allowsCustomModels: deps.allowsCustomModels,
             }))(),
             new Promise((_resolve, reject) => {
                 timeout = setTimeout(() => reject(new Error("Provider catalog timed out")), providerCheckTimeoutMs);

package/dist/slices/control/providers.js

@@ -50,6 +50,8 @@ export async function validateProviderChanges(changes, current) {
         const picked = changes[key];
         if (picked === undefined || fields.some((field) => field.field === key))
             continue;
+        if (current.allowsCustomModels?.(picked.provider) === true)
+            continue;
         const models = await current.modelsFor(picked.provider, families[key]);
         if (!models.some((model) => model.id === picked.model)) {
             fields.push({ field: `${key}.model`, message: "Choose a model supported by this provider." });

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;
+}

package/dist/slices/fonts/discovery.js

@@ -0,0 +1,81 @@
+import { createHash } from "node:crypto";
+import { opendir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { extname, join, posix, win32 } from "node:path";
+import { readFontFile, unavailable } from "./files.js";
+import { readFontMetadata } from "./sfnt.js";
+export function systemFontDirectories(platform, env, home) {
+    if (platform === "win32")
+        return [
+            win32.join(env.WINDIR ?? "C:\\Windows", "Fonts"),
+            ...(env.LOCALAPPDATA ? [win32.join(env.LOCALAPPDATA, "Microsoft", "Windows", "Fonts")] : []),
+        ];
+    if (platform === "darwin")
+        return ["/System/Library/Fonts", "/Library/Fonts", posix.join(home, "Library/Fonts")];
+    return [
+        "/usr/share/fonts",
+        "/usr/local/share/fonts",
+        posix.join(env.XDG_DATA_HOME ?? posix.join(home, ".local/share"), "fonts"),
+        posix.join(home, ".fonts"),
+    ];
+}
+export async function discoverSystemFonts() {
+    return scanFontDirectories(systemFontDirectories(process.platform, process.env, homedir()));
+}
+// Fixed roots only, no symlink traversal. Bounds also cover nested font-manager
+// folders and damaged font files, without making the Settings request unbounded.
+export async function scanFontDirectories(roots) {
+    const pending = [...new Set(roots)].map((path) => ({ path, depth: 0 }));
+    const files = new Set();
+    let entries = 0;
+    for (let at = 0; at < pending.length && entries < 10000 && files.size < 2048; at += 1) {
+        const dir = pending[at];
+        if (dir === undefined)
+            continue;
+        try {
+            for await (const entry of await opendir(dir.path)) {
+                entries += 1;
+                const path = join(dir.path, entry.name);
+                if (entry.isDirectory() && dir.depth < 8)
+                    pending.push({ path, depth: dir.depth + 1 });
+                else if (entry.isFile() &&
+                    [".ttf", ".otf", ".ttc"].includes(extname(entry.name).toLowerCase()))
+                    files.add(path);
+                if (entries >= 10000 || files.size >= 2048)
+                    break;
+            }
+        }
+        catch (error) {
+            if (!unavailable(error))
+                throw error;
+        }
+    }
+    const fonts = [];
+    let bytesRead = 0;
+    for (const path of [...files].sort()) {
+        if (bytesRead >= 256 * 1024 * 1024)
+            break;
+        const bytes = await readFontFile(path);
+        if (bytes === undefined)
+            continue;
+        bytesRead += bytes.length;
+        for (const face of readFontMetadata(bytes) ?? []) {
+            const id = createHash("sha256")
+                .update(path)
+                .update("\0")
+                .update(String(face.index))
+                .digest("hex");
+            fonts.push({
+                id: `system-${id}`,
+                name: face.name,
+                family: face.family,
+                source: "system",
+                path,
+                extension: face.extension,
+                assName: face.assName,
+                faceIndex: face.index,
+            });
+        }
+    }
+    return fonts;
+}

package/dist/slices/fonts/files.js

@@ -0,0 +1,37 @@
+import { constants } from "node:fs";
+import { lstat, open } from "node:fs/promises";
+import { fontMaxBytes } from "./model.js";
+export function unavailable(error) {
+    return (error instanceof Error &&
+        "code" in error &&
+        ["ENOENT", "ENOTDIR", "EACCES", "EPERM", "ELOOP"].includes(String(error.code)));
+}
+export async function readFontFile(path) {
+    try {
+        if (!(await lstat(path)).isFile())
+            return undefined;
+        const file = await open(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+        try {
+            const stat = await file.stat();
+            if (!stat.isFile() || stat.size < 12 || stat.size > fontMaxBytes)
+                return undefined;
+            const bytes = Buffer.alloc(stat.size);
+            let offset = 0;
+            while (offset < bytes.length) {
+                const result = await file.read(bytes, offset, bytes.length - offset, offset);
+                if (result.bytesRead === 0)
+                    return undefined;
+                offset += result.bytesRead;
+            }
+            return bytes;
+        }
+        finally {
+            await file.close();
+        }
+    }
+    catch (error) {
+        if (unavailable(error))
+            return undefined;
+        throw error;
+    }
+}

package/dist/slices/fonts/index.js

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

package/dist/slices/fonts/model.js

@@ -0,0 +1,4 @@
+export const fontMaxBytes = 32 * 1024 * 1024;
+export function fontSummary(font) {
+    return { id: font.id, name: font.name, family: font.family, source: font.source };
+}