@gentbajko/slopify 2.5.0 → 3.0.0

package/dist/slices/studio/pack.js

@@ -0,0 +1,209 @@
+import { readFileSync, statSync } from "node:fs";
+import { z } from "zod";
+import { thumbnailCountOf } from "../admission/model.js";
+import { projectById } from "../admission/repo.js";
+import { channelById, projectChannelId } from "../channels/repo.js";
+import { namesPhotorealisticPrompt } from "../library/photorealistic.js";
+import { isClipPath } from "../rebuild/runtime-export-edit.js";
+import { listVoices } from "../settings/repo.js";
+import { realPersonVoiceIds } from "../settings/voices.js";
+import { fullVideoLine } from "../shorts/model.js";
+import { assetOf } from "../storage/asset-name.js";
+import { contentTypeOf, downloadName, slugOf } from "../storage/downloads.js";
+import { outputPath } from "../storage/layout.js";
+import { outputsOf } from "../storage/repo.js";
+import { videoEditOf } from "../video/edit-settings.js";
+import { usesVoices } from "../voices/model.js";
+import { effectiveDescription } from "../youtube/edits-repo.js";
+import { aiDisclosureOf } from "./disclosure.js";
+import { studioAudience, studioTitleMax, } from "./model.js";
+import { readRealFootage, readStudioPlaylist } from "./settings.js";
+// What `shorts.json` holds for each picked clip; only what the pack uses.
+const clipsSchema = z.object({
+    shorts: z.array(z.object({
+        number: z.number(),
+        first: z.number().optional(),
+        last: z.number().optional(),
+        title: z.string(),
+        description: z.string(),
+        hashtags: z.array(z.string()),
+    })),
+});
+// Builds the pack from the project's current outputs: the video, the YouTube description and
+// tags, the thumbnails and each short. Nothing is generated here; a part that isn't made yet
+// is left empty and named in `missing` with what to do about it.
+export function uploadPack(deps, projectId) {
+    const project = projectById(deps.db, projectId);
+    if (project === undefined)
+        return { ok: false, reason: "unknown-project" };
+    const config = project.config;
+    const outputs = outputsOf(deps.db, projectId).filter((output) => available(deps, projectId, output));
+    const slug = slugOf(project.title);
+    const file = (output) => ({
+        url: `/files/${projectId}/${assetOf(output)}`,
+        asset: assetOf(output),
+        filename: downloadName(slug, output),
+        contentType: contentTypeOf(output.path),
+        bytes: output.bytes,
+    });
+    const text = (output) => output === undefined
+        ? undefined
+        : readFileSync(outputPath(deps.paths, projectId, output.path), "utf8").trim();
+    const playlist = readStudioPlaylist(deps.db);
+    const missing = [];
+    // The channel's setting, then what the project narrates and shows (`disclosure.ts`).
+    const setting = channelById(deps.db, projectChannelId(deps.db, projectId))?.aiDisclosure ?? "auto";
+    const realPersonVoices = realPersonVoicesOf(deps, config);
+    const uploadedClips = config.sources.images === "provide"
+        ? outputs.filter((output) => output.role === "image" && isClipPath(output.path)).length
+        : 0;
+    const realFootage = uploadedClips > 0 && readRealFootage(deps.db, projectId);
+    const atmosphere = videoEditOf(config).atmosphere;
+    const disclosure = (kind) => aiDisclosureOf({
+        setting,
+        kind,
+        realPersonVoices,
+        // A short's pictures are always drawn anew, never the uploaded clips.
+        realFootage: kind === "video" && realFootage,
+        footageOverlay: atmosphere === "none" ? undefined : atmosphere,
+        photorealistic: kind === "short"
+            ? namesPhotorealisticPrompt(deps.db, config.shorts?.imagePrompt)
+            : config.sources.images === "generate" &&
+                config.imagePrompts.some((prompt) => namesPhotorealisticPrompt(deps.db, prompt.name)),
+    });
+    const video = outputs.find((output) => output.role === "video");
+    if (video === undefined)
+        missing.push("The video isn't made yet. Let the Video stage finish (or use Continue the run on the project page), then open Prepare upload again.");
+    const written = text(outputs.find((output) => output.role === "youtube_description"));
+    const writtenTags = text(outputs.find((output) => output.role === "youtube_tags"));
+    // As the project page shows it: the user's edits, and channel links filled in.
+    const edited = written === undefined
+        ? undefined
+        : effectiveDescription(deps.db, projectId, {
+            description: written,
+            tags: writtenTags ?? "",
+            // The last chapter is checked against the video's own length when it is known.
+            durationSeconds: video?.durationMs === null || video?.durationMs === undefined
+                ? undefined
+                : video.durationMs / 1000,
+        });
+    const tagsFile = edited?.tags ?? writtenTags;
+    const description = edited?.description;
+    if (description === undefined)
+        missing.push(config.youtubeDescription === true
+            ? "The YouTube description isn't written yet. It is written after the video's subtitle timing; wait for the Video stage to finish."
+            : "No YouTube description is written for this project. Turn on YouTube description in Edit project → Video to have one written with chapters and tags.");
+    const count = thumbnailCountOf(config);
+    // The first thumbnail, then the second and third, and never one left from when the project
+    // made three and now makes one.
+    const thumbnails = outputs
+        .filter((output) => output.role === "thumbnail" && (output.meta.index ?? 1) <= count)
+        .sort((a, b) => (a.meta.index ?? 1) - (b.meta.index ?? 1));
+    if (thumbnails.length === 0)
+        missing.push(config.sources.thumbnail === "off"
+            ? "This project makes no thumbnail, so YouTube will pick a frame. Set Thumbnail in Edit project to make or upload one."
+            : "The thumbnail isn't made yet. Let the Thumbnail stage finish, then open Prepare upload again.");
+    else if (thumbnails.length < count)
+        missing.push(`Only ${String(thumbnails.length)} of the ${String(count)} thumbnails are made. Regenerate the missing ones in the project's Images section.`);
+    if (playlist === null)
+        missing.push("No playlist is set, so the playlist step is left to you. Set one in Settings → YouTube Studio.");
+    const items = [
+        {
+            kind: "video",
+            video: video === undefined ? null : file(video),
+            title: project.title.slice(0, studioTitleMax),
+            description: description ?? "",
+            tags: tagsOf(tagsFile),
+            thumbnails: thumbnails.map(file),
+            audience: studioAudience,
+            alteredContent: disclosure("video"),
+            playlist,
+            ...(edited?.chapterNotice === undefined ? {} : { chapterNotice: edited.chapterNotice }),
+        },
+    ];
+    const clips = clipsOf(text(outputs.find((output) => output.role === "shorts")));
+    const shortVideos = outputs.filter((output) => output.role === "short_video");
+    for (const clip of clips) {
+        // The clip's own render: the one cut from the same sentences, else the newest for its
+        // number (a list written before the sentences were kept).
+        const mine = shortVideos.filter((output) => output.meta.short === clip.number);
+        const exact = mine.find((output) => clip.first !== undefined &&
+            output.meta.sentences?.[0] === clip.first &&
+            output.meta.sentences?.[1] === clip.last);
+        const render = exact ?? mine.at(-1);
+        if (render === undefined)
+            missing.push(`Short ${String(clip.number)} isn't rendered yet. Let the Video stage finish, then open Prepare upload again.`);
+        items.push({
+            kind: "short",
+            short: clip.number,
+            video: render === undefined ? null : file(render),
+            title: clip.title.slice(0, studioTitleMax),
+            description: [
+                clip.description,
+                fullVideoLine(config.shorts?.fullVideoLink),
+                "",
+                clip.hashtags.join(" "),
+            ].join("\n"),
+            // The hashtags without their #, as search tags.
+            tags: clip.hashtags.map((tag) => tag.replace(/^#+/, "").trim()).filter((tag) => tag !== ""),
+            // Studio shows a frame of a short; a custom thumbnail isn't offered in its upload dialog.
+            thumbnails: [],
+            audience: studioAudience,
+            alteredContent: disclosure("short"),
+            playlist,
+        });
+    }
+    return {
+        ok: true,
+        pack: {
+            projectId,
+            projectTitle: project.title,
+            items,
+            missing,
+            ...(uploadedClips > 0 ? { footage: { clips: uploadedClips, real: realFootage } } : {}),
+        },
+    };
+}
+// The saved voices marked "Imitates a real person" that narrate the project: its one narration
+// voice, or every speaker's of a multi-voice run. None when the narration isn't an AI voice.
+function realPersonVoicesOf(deps, config) {
+    if (config.sources.audio !== "generate")
+        return [];
+    const narrating = usesVoices(config)
+        ? (config.voices?.speakers ?? []).map((speaker) => speaker.voice)
+        : config.audio === undefined
+            ? []
+            : [config.audio];
+    const flagged = realPersonVoiceIds(deps.db);
+    const names = listVoices(deps.db)
+        .filter((voice) => flagged.has(voice.id) &&
+        narrating.some((one) => one.provider === voice.provider && one.voice === voice.voiceId))
+        .map((voice) => voice.name);
+    return [...new Set(names)];
+}
+// The item the person chose: the long video, or short `short`.
+export function packItem(pack, short) {
+    return pack.items.find((item) => short === undefined ? item.kind === "video" : item.kind === "short" && item.short === short);
+}
+function tagsOf(line) {
+    return (line ?? "")
+        .split(",")
+        .map((tag) => tag.trim())
+        .filter((tag) => tag !== "");
+}
+function clipsOf(text) {
+    if (text === undefined)
+        return [];
+    try {
+        const parsed = clipsSchema.safeParse(JSON.parse(text));
+        return parsed.success ? parsed.data.shorts : [];
+    }
+    catch {
+        return [];
+    }
+}
+function available(deps, projectId, output) {
+    return (statSync(outputPath(deps.paths, projectId, output.path), {
+        throwIfNoEntry: false,
+    })?.isFile() === true);
+}

package/dist/slices/studio/settings.js

@@ -0,0 +1,133 @@
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import { z } from "zod";
+import { readSetting, writeSetting } from "../settings/repo.js";
+import { studioPlaylistMax } from "./model.js";
+// Two rows of the key/value `settings` table. The playlist travels with a backup; the
+// pairing stays on this machine (`slices/storage/portable.ts`): its token is what lets the
+// browser extension read a project's upload pack.
+export const studioPlaylistKey = "studio.playlist";
+export const studioPairingKey = "studio.pairing";
+const pairingSchema = z.object({
+    token: z.string().min(20),
+    origin: z.string().nullable(),
+    pairedAt: z.string().nullable(),
+});
+export function readStudioPlaylist(db) {
+    const stored = readSetting(db, studioPlaylistKey);
+    if (stored === undefined)
+        return null;
+    try {
+        const value = JSON.parse(stored);
+        return typeof value === "string" && value.trim() !== "" ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function studioPlaylistProblem(raw) {
+    return raw.trim().length > studioPlaylistMax
+        ? `The playlist name is longer than YouTube allows (${String(studioPlaylistMax)} characters). Shorten it in Settings → YouTube Studio.`
+        : undefined;
+}
+export function saveStudioPlaylist(db, raw) {
+    const value = raw.trim();
+    if (value === "") {
+        db.prepare("DELETE FROM settings WHERE key = ?").run(studioPlaylistKey);
+        return null;
+    }
+    writeSetting(db, studioPlaylistKey, JSON.stringify(value));
+    return value;
+}
+// The projects whose uploaded clips are real footage (filmed, not generated): ticked in the
+// project's Prepare upload, under AI use. One row holding their ids; YouTube's second AI use
+// case is footage of a real event or place altered by AI (`disclosure.ts`).
+export const studioRealFootageKey = "studio.realFootage";
+function realFootageIds(db) {
+    const stored = readSetting(db, studioRealFootageKey);
+    if (stored === undefined)
+        return [];
+    try {
+        const value = JSON.parse(stored);
+        return Array.isArray(value)
+            ? value.filter((one) => typeof one === "string")
+            : [];
+    }
+    catch {
+        return [];
+    }
+}
+export function readRealFootage(db, projectId) {
+    return realFootageIds(db).includes(projectId);
+}
+export function saveRealFootage(db, projectId, on) {
+    const others = realFootageIds(db).filter((one) => one !== projectId);
+    const next = on ? [...others, projectId].sort() : others;
+    if (next.length === 0)
+        db.prepare("DELETE FROM settings WHERE key = ?").run(studioRealFootageKey);
+    else
+        writeSetting(db, studioRealFootageKey, JSON.stringify(next));
+}
+// The pairing token, made on first read. One per install: a new one (Settings → YouTube
+// Studio → New pairing token) forgets the extension that used the old one.
+export function studioPairing(db) {
+    const stored = readSetting(db, studioPairingKey);
+    if (stored !== undefined) {
+        try {
+            const parsed = pairingSchema.safeParse(JSON.parse(stored));
+            if (parsed.success)
+                return parsed.data;
+        }
+        catch {
+            // A damaged row is replaced below.
+        }
+    }
+    return resetStudioPairing(db);
+}
+export function resetStudioPairing(db) {
+    const pairing = {
+        token: randomBytes(24).toString("base64url"),
+        origin: null,
+        pairedAt: null,
+    };
+    writeSetting(db, studioPairingKey, JSON.stringify(pairing));
+    return pairing;
+}
+// A browser extension's own origin: Chrome's and Firefox's. Web pages never match.
+export function isExtensionOrigin(origin) {
+    return (origin !== undefined && /^(chrome-extension|moz-extension):\/\/[a-z0-9-]{1,64}$/.test(origin));
+}
+export function tokenMatches(pairing, given) {
+    if (given === undefined)
+        return false;
+    const a = Buffer.from(pairing.token);
+    const b = Buffer.from(given);
+    return a.length === b.length && timingSafeEqual(a, b);
+}
+// The token from an `Authorization: Bearer <token>` header.
+export function bearerToken(header) {
+    const match = /^Bearer\s+(\S+)$/.exec(header ?? "");
+    return match?.[1];
+}
+// The extension pairs by sending the token from its own origin; that origin is then the only
+// one the app answers across origins, until a new token is made.
+export function pairStudioExtension(db, token, origin, now) {
+    const pairing = studioPairing(db);
+    if (!tokenMatches(pairing, token))
+        return { ok: false, reason: "bad-token" };
+    if (!isExtensionOrigin(origin))
+        return { ok: false, reason: "not-an-extension" };
+    const next = { ...pairing, origin, pairedAt: now.toISOString() };
+    writeSetting(db, studioPairingKey, JSON.stringify(next));
+    return { ok: true, pairing: next };
+}
+// Whether a request may read upload packs: the right token, and, when the browser names its
+// origin, the paired extension's. A request with no Origin (not from a web page at all) is
+// judged on the token alone.
+export function studioRequestAllowed(db, token, origin) {
+    const pairing = studioPairing(db);
+    if (!tokenMatches(pairing, token))
+        return false;
+    if (origin === undefined)
+        return true;
+    return pairing.origin !== null && origin === pairing.origin;
+}

package/dist/slices/style-preview/images.js

@@ -0,0 +1,61 @@
+import { createHash } from "node:crypto";
+import { readFileSync, statSync } from "node:fs";
+import { imageBlob } from "../channels/repo.js";
+import { outputPath, stagingPath } from "../storage/layout.js";
+import { outputById, stagedFileById } from "../storage/repo.js";
+// ceiling: a provider's image or an upload is a few MB; anything this large is not a picture
+// worth reading into memory for a 270-pixel preview.
+const maxBytes = 40 * 1024 * 1024;
+// Roles whose file is a single still picture.
+const pictureRoles = new Set(["reference", "image", "thumbnail", "short_image"]);
+export function previewPictures(deps) {
+    return (image) => {
+        try {
+            const bytes = read(deps, image);
+            if (bytes === undefined)
+                return undefined;
+            const extension = pictureExtension(bytes);
+            if (extension === undefined)
+                return undefined;
+            return { bytes, extension, sha256: createHash("sha256").update(bytes).digest("hex") };
+        }
+        catch {
+            return undefined;
+        }
+    };
+}
+function read(deps, image) {
+    switch (image.kind) {
+        case "picture":
+            return imageBlob(deps.db, image.sha256)?.bytes;
+        case "upload": {
+            const staged = stagedFileById(deps.db, image.stagedFileId);
+            if (staged === undefined || staged.state !== "staged")
+                return undefined;
+            return readSmall(stagingPath(deps.paths, staged.id));
+        }
+        case "output": {
+            const output = outputById(deps.db, image.outputId);
+            if (output === undefined || !pictureRoles.has(output.role))
+                return undefined;
+            return readSmall(outputPath(deps.paths, output.projectId, output.path));
+        }
+    }
+}
+function readSmall(path) {
+    const size = statSync(path).size;
+    if (size === 0 || size > maxBytes)
+        return undefined;
+    return new Uint8Array(readFileSync(path));
+}
+export function pictureExtension(bytes) {
+    const starts = (...values) => values.every((value, at) => bytes[at] === value);
+    if (starts(0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a))
+        return ".png";
+    if (starts(0xff, 0xd8, 0xff))
+        return ".jpg";
+    const ascii = (from, to) => String.fromCharCode(...bytes.subarray(from, to));
+    if (ascii(0, 4) === "RIFF" && ascii(8, 12) === "WEBP")
+        return ".webp";
+    return undefined;
+}

package/dist/slices/style-preview/render.js

@@ -0,0 +1,161 @@
+import { copyFileSync, existsSync, mkdirSync, mkdtempSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import { join } from "node:path";
+import { defaultMotionStyle, defaultZoomPercent } from "../admission/rules.js";
+import { isMissingFont, resolveFont } from "../fonts/index.js";
+import { serializeAss } from "../subtitles/captions.js";
+import { subtitleFrame } from "../subtitles/layout.js";
+import { runFfmpeg } from "../video/ffmpeg.js";
+import { planRender } from "../video/plan.js";
+import { renderSlideshow } from "../video/slideshow.js";
+import { stylePreviewSeconds } from "./schema.js";
+import { sampleCues } from "./settings.js";
+export class StylePreviewError extends Error {
+    reason;
+    constructor(reason, message) {
+        super(message);
+        this.reason = reason;
+    }
+}
+// ceiling: small enough to render in a few seconds on a laptop, big enough to judge a font.
+// The short side is 270 px; the captions' script keeps its full-size frame and libass scales
+// it, so a caption sits exactly where it would in the real video.
+const previewFrame = {
+    "16:9": { width: 480, height: 270 },
+    "9:16": { width: 270, height: 480 },
+};
+const stillSize = 1280;
+const shotSeconds = stylePreviewSeconds / 3;
+const chapterTitle = "Chapter one";
+// Three stills, each a different colour story with a horizon and a light, so motion, grade
+// and transitions all read. Square, so either format crops them to cover.
+const stills = [
+    `gradients=s=${stillSize}x${stillSize}:c0=0x1d2b53:c1=0xe07a5f:x0=0:y0=0:x1=0:y1=${stillSize}:d=1,` +
+        "drawbox=x=820:y=300:w=140:h=140:color=0xfff1c1@0.9:t=fill," +
+        "drawbox=x=0:y=880:w=iw:h=400:color=0x14213d@0.85:t=fill",
+    `gradients=s=${stillSize}x${stillSize}:c0=0x0b3d2e:c1=0x88c9a1:x0=0:y0=${stillSize}:x1=${stillSize}:y1=0:d=1,` +
+        "drawbox=x=200:y=380:w=260:h=260:color=0xf4f1de@0.8:t=fill," +
+        "drawbox=x=0:y=840:w=iw:h=440:color=0x081c15@0.9:t=fill",
+    `gradients=s=${stillSize}x${stillSize}:c0=0x3d1e6d:c1=0xf2a65a:x0=${stillSize}:y0=0:x1=0:y1=${stillSize}:d=1,` +
+        "drawbox=x=540:y=330:w=200:h=200:color=0xffd166@0.9:t=fill," +
+        "drawbox=x=0:y=820:w=iw:h=460:color=0x1b0f2e@0.85:t=fill",
+];
+export function ffmpegStylePreview(deps) {
+    let samples;
+    const ensureSamples = (signal) => {
+        samples ??= makeSamples(deps, signal).catch((error) => {
+            samples = undefined;
+            throw error;
+        });
+        return samples;
+    };
+    return async (settings, output, signal, picture) => {
+        try {
+            // A real picture is shown for all three shots: the motion, the Look and the captions read
+            // on it, and the transition and chapter card still show at the cuts.
+            const images = picture === undefined ? await ensureSamples(signal) : [picture, picture, picture];
+            await renderPreview(deps, settings, images, output, signal);
+        }
+        catch (error) {
+            throw explained(deps.log, error);
+        }
+    };
+}
+async function makeSamples(deps, signal) {
+    const folder = join(deps.dir, "samples");
+    mkdirSync(folder, { recursive: true, mode: 0o700 });
+    const paths = [];
+    for (const [at, source] of stills.entries()) {
+        const path = join(folder, `still-${String(at + 1)}.png`);
+        paths.push(path);
+        if (existsSync(path))
+            continue;
+        const part = join(folder, `still-${String(at + 1)}.part.png`);
+        await runFfmpeg({
+            bin: deps.ffmpeg,
+            args: [
+                ...["-hide_banner", "-nostdin", "-loglevel", "error", "-y"],
+                ...["-f", "lavfi", "-i", source, "-frames:v", "1", part],
+            ],
+            signal,
+            log: deps.log,
+            onProgress: () => { },
+        });
+        renameSync(part, path);
+    }
+    return paths;
+}
+async function renderPreview(deps, settings, images, output, signal) {
+    // A render on a given picture never made the stills, which is what created the folder.
+    mkdirSync(deps.dir, { recursive: true, mode: 0o700 });
+    const workspace = mkdtempSync(join(deps.dir, "work-"));
+    try {
+        const cardFont = settings.chapterCard === null
+            ? undefined
+            : await resolveFont(deps.paths, settings.chapterCard.fontId);
+        const plan = planRender({
+            format: settings.format,
+            gapSeconds: 0,
+            edgeSeconds: 0,
+            imageSeconds: shotSeconds,
+            zoomPercent: defaultZoomPercent,
+            motionStyle: defaultMotionStyle,
+            images,
+            output,
+            edit: {
+                ...(settings.transition === null ? {} : { transition: settings.transition }),
+                look: settings.look,
+                ...(cardFont === undefined
+                    ? {}
+                    : {
+                        cards: {
+                            // On the cut into the second still, so the transition and the card both show.
+                            chapters: [{ title: chapterTitle, start: shotSeconds }],
+                            font: { path: cardFont.path, name: cardFont.assName },
+                        },
+                    }),
+            },
+        });
+        const edit = {
+            ...plan.editList,
+            ...previewFrame[settings.format],
+            audio: [{ kind: "gap", path: null, seconds: plan.totalSeconds }],
+        };
+        const captions = settings.captions;
+        if (captions !== null) {
+            const font = await resolveFont(deps.paths, captions.fontId);
+            mkdirSync(join(workspace, "fonts"), { mode: 0o700 });
+            copyFileSync(font.path, join(workspace, "fonts", `selected${font.extension}`));
+            writeFileSync(join(workspace, "subtitles.ass"), serializeAss(sampleCues(captions.text, plan.totalSeconds), {
+                ...subtitleFrame(settings.format),
+                fontName: font.assName,
+                fontSize: captions.fontSize,
+                position: captions.position,
+            }), { mode: 0o600 });
+        }
+        await renderSlideshow({
+            bin: deps.ffmpeg,
+            edit,
+            output,
+            burnSubtitles: captions !== null,
+            cwd: workspace,
+            scratch: workspace,
+            signal,
+            log: deps.log,
+            onProgress: () => { },
+        });
+    }
+    finally {
+        rmSync(workspace, { recursive: true, force: true });
+    }
+}
+function explained(log, error) {
+    if (error instanceof StylePreviewError)
+        return error;
+    const message = error instanceof Error ? error.message : String(error);
+    if (isMissingFont(error))
+        return new StylePreviewError("font-missing", "The style preview couldn't render because the chosen caption font is no longer available; it may have been uninstalled or deleted. Choose another font under Subtitles, then press Render again.");
+    if (message.startsWith("Slopify could not start ffmpeg") || /\bENOENT\b/.test(message))
+        return new StylePreviewError("ffmpeg-missing", "The style preview couldn't render because ffmpeg wasn't found. Install ffmpeg, or use the Docker image, then press Render again.");
+    log.write("error", "style-preview.render", { detail: message });
+    return new StylePreviewError("render-failed", "The style preview couldn't render because ffmpeg stopped with an error. Press Render again; if it fails again, use Download diagnostics in Settings and report it.");
+}

package/dist/slices/style-preview/schema.js

@@ -0,0 +1,45 @@
+import { z } from "zod";
+import { formats } from "../../kernel/pipeline.js";
+import { videoEditSchema } from "../admission/schema.js";
+import { subtitleModes, subtitlePositions } from "../subtitles/model.js";
+// "See it before you make it": a few seconds rendered by the real renderer with a project's
+// caption and Look settings, on stills and silence Slopify makes itself. Browser-safe, so
+// Play and Edit project read the same request and reply shapes the server checks.
+// How long the preview runs: three stills of two seconds, so a transition and a chapter
+// card both show.
+export const stylePreviewSeconds = 6;
+export const stylePreviewTextMax = 200;
+export const defaultPreviewText = "Every story begins with a word.";
+// A picture the preview is drawn on instead of the sample stills: the establishing image a
+// draft uploaded (its staged file), one a project already has (its output), or a channel cast
+// member's picture (by content hash). One the server can no longer find falls back to the
+// stills rather than failing the preview.
+export const stylePreviewImageSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("upload"), stagedFileId: z.string().regex(/^[A-Za-z0-9_-]{1,64}$/) }),
+    z.object({ kind: z.literal("output"), outputId: z.string().regex(/^[A-Za-z0-9_-]{1,64}$/) }),
+    z.object({ kind: z.literal("picture"), sha256: z.string().regex(/^[a-f0-9]{64}$/) }),
+]);
+export const stylePreviewRequestSchema = z.object({
+    format: z.enum(formats),
+    subtitles: z.object({
+        mode: z.enum(subtitleModes),
+        fontId: z
+            .string()
+            .max(160)
+            .regex(/^[A-Za-z0-9_-]+$/),
+        fontSize: z.number().finite().min(16).max(120),
+        position: z.enum(subtitlePositions),
+    }),
+    videoEdit: videoEditSchema.optional(),
+    previewText: z.string().max(stylePreviewTextMax).optional(),
+    image: stylePreviewImageSchema.optional(),
+    // Render again even when this exact preview is already saved.
+    force: z.boolean().optional(),
+});
+export const stylePreviewReplySchema = z.object({
+    hash: z.string().regex(/^[a-f0-9]{64}$/),
+    // GET it for the mp4; its query changes whenever the file is rendered again.
+    url: z.string().min(1),
+    cached: z.boolean(),
+    seconds: z.number().positive(),
+});