@gentbajko/slopify 3.25.9 → 4.0.0

package/dist/slices/template-studio/free.js

@@ -0,0 +1,176 @@
+import { errorText } from "../../kernel/errors.js";
+import { StylePreviewError } from "../style-preview/render.js";
+import { normalizeStylePreview, stylePreviewHash } from "../style-preview/settings.js";
+import { documentHash, documentThemeOfTemplate } from "./document-sample.js";
+import { videoSampleRequest } from "./free-video.js";
+import { loudnessGoalOf, loudnessHash } from "./loudness.js";
+// The samples the studio makes on this computer, free: the 30-second video, the loudness before
+// and after, and the PDF. Each is kept by the hash of what it is made from, so a setting changed
+// back, or the same setup in another template, shows at once.
+export const freeKinds = ["video", "loudness", "document"];
+const press = "press Make samples";
+export function createFreeSamples(deps) {
+    const failures = new Map();
+    const making = new Set();
+    const keyOf = (kind, hash) => `${kind}:${hash}`;
+    const videoHash = (document) => stylePreviewHash(normalizeStylePreview(videoSampleRequest(document)));
+    const loudnessHashOf = (document) => {
+        const goal = loudnessGoalOf(document, deps.loudnessDefault());
+        return goal === undefined ? undefined : loudnessHash(goal);
+    };
+    const documentHashOf = (document) => documentHash(documentThemeOfTemplate(document));
+    const attempt = async (kind, hash, work, failure) => {
+        const key = keyOf(kind, hash);
+        making.add(key);
+        failures.delete(key);
+        try {
+            await work();
+        }
+        catch (error) {
+            failures.set(key, failure(error));
+        }
+        finally {
+            making.delete(key);
+        }
+    };
+    const pending = (job, kind, hash, what) => {
+        const key = keyOf(kind, hash);
+        const failed = failures.get(key);
+        if (failed !== undefined)
+            return { state: "needs-fix", sentence: failed, url: null };
+        if (making.has(key) || job.running)
+            return { state: "making", sentence: `Making the ${what} on this computer.`, url: null };
+        if (job.queued)
+            return {
+                state: "waiting",
+                sentence: `The ${what} waits for another template's samples to finish.`,
+                url: null,
+            };
+        return { state: "stale", sentence: `No ${what} for this version yet: ${press}.`, url: null };
+    };
+    return {
+        loudnessHashOf,
+        documentHashOf,
+        make: async (document, signal) => {
+            const { form } = document;
+            if (form.sources.video !== "off" && deps.stylePreviews !== undefined) {
+                const previews = deps.stylePreviews;
+                await attempt("video", videoHash(document), async () => {
+                    await previews.render(videoSampleRequest(document));
+                }, videoFailure);
+            }
+            if (signal.aborted)
+                return;
+            const goal = loudnessGoalOf(document, deps.loudnessDefault());
+            if (goal !== undefined && deps.loudness !== undefined) {
+                const samples = deps.loudness;
+                await attempt("loudness", loudnessHash(goal), () => samples.make(goal, signal), (error) => ffmpegFailure("loudness before and after", error));
+            }
+            if (signal.aborted)
+                return;
+            if (form.sources.document === "generate" && deps.documents !== undefined) {
+                const documents = deps.documents;
+                const theme = documentThemeOfTemplate(document);
+                await attempt("document", documentHash(theme), () => documents.make(theme), (error) => `The PDF sample couldn't be made: ${errorText(error)} Change the theme in Document (PDF) → Fine-tune, then ${press}.`);
+            }
+        },
+        view: (templateId, document, job) => {
+            const { form } = document;
+            const base = `/api/template-studio/${encodeURIComponent(templateId)}`;
+            const unavailable = (what) => ({
+                state: "needs-fix",
+                sentence: `The ${what} can't be made because this Slopify started without ffmpeg. Install ffmpeg, or use the Docker image, then restart Slopify and ${press}.`,
+                url: null,
+            });
+            let video;
+            if (form.sources.video === "off")
+                video = { state: "off", sentence: "The video is off.", url: null };
+            else if (deps.stylePreviews === undefined)
+                video = unavailable("video sample");
+            else {
+                const hash = videoHash(document);
+                const saved = deps.stylePreviews.file(hash);
+                video =
+                    saved === undefined
+                        ? pending(job, "video", hash, "30-second video")
+                        : {
+                            state: "current",
+                            sentence: "30 seconds in your frame, captions, Look and picture timing, on Slopify's sample pictures and narration.",
+                            url: `/api/style-preview/${hash}.mp4?v=${String(saved.version)}`,
+                        };
+            }
+            const lHash = loudnessHashOf(document);
+            let loudness;
+            if (lHash === undefined)
+                loudness = {
+                    state: "off",
+                    sentence: "Level the volume is off: the narration plays as the voice gives it.",
+                    url: null,
+                    beforeUrl: null,
+                    beforeLufs: null,
+                    afterLufs: null,
+                    targetLufs: null,
+                    ceiling: null,
+                };
+            else if (deps.loudness === undefined)
+                loudness = {
+                    ...unavailable("loudness before and after"),
+                    beforeUrl: null,
+                    beforeLufs: null,
+                    afterLufs: null,
+                    targetLufs: null,
+                    ceiling: null,
+                };
+            else {
+                const reading = deps.loudness.reading(lHash);
+                const shown = reading === undefined
+                    ? pending(job, "loudness", lHash, "loudness before and after")
+                    : undefined;
+                loudness = {
+                    ...(shown ?? {
+                        state: "current",
+                        sentence: "Slopify's sample narration as it came, and levelled the way your videos will be. Your own voice's sample replaces it once paid samples are made.",
+                        url: `${base}/loudness/after.mp3?v=${lHash.slice(0, 12)}`,
+                    }),
+                    beforeUrl: `${base}/loudness/before.mp3`,
+                    beforeLufs: reading?.before ?? null,
+                    afterLufs: reading?.after ?? null,
+                    targetLufs: reading?.target ?? null,
+                    ceiling: reading?.ceiling ?? null,
+                };
+            }
+            let pdf;
+            if (form.sources.document !== "generate")
+                pdf = { state: "off", sentence: "The PDF document is off.", url: null };
+            else if (deps.documents === undefined)
+                pdf = unavailable("PDF sample");
+            else {
+                const hash = documentHashOf(document);
+                pdf =
+                    deps.documents.file(hash) === undefined
+                        ? pending(job, "document", hash, "PDF sample")
+                        : {
+                            state: "current",
+                            sentence: "Slopify's sample article laid out in your theme.",
+                            url: `${base}/document.pdf?v=${hash.slice(0, 12)}`,
+                        };
+            }
+            return { video, loudness, document: pdf };
+        },
+    };
+}
+function videoFailure(error) {
+    if (error instanceof StylePreviewError) {
+        if (error.reason === "font-missing")
+            return `The video sample couldn't be made because the caption font is no longer on this computer. Choose another font in Video & captions → Fine-tune, then ${press}.`;
+        if (error.reason === "ffmpeg-missing")
+            return `The video sample couldn't be made because ffmpeg wasn't found. Install ffmpeg, or use the Docker image, then ${press}.`;
+    }
+    return ffmpegFailure("video sample", error);
+}
+function ffmpegFailure(what, error) {
+    const message = errorText(error);
+    if (/\bENOENT\b/.test(message) || message.startsWith("Slopify could not start ffmpeg"))
+        return `The ${what} couldn't be made because ffmpeg wasn't found. Install ffmpeg, or use the Docker image, then ${press}.`;
+    return `The ${what} couldn't be made because ffmpeg stopped with an error. ${press[0]?.toUpperCase()}${press.slice(1)} again; if it fails again, use Download diagnostics in Settings and report it.`;
+}

package/dist/slices/template-studio/gate.js

@@ -0,0 +1,40 @@
+function runnable(byVersion, version, seen = new Set()) {
+    const gate = byVersion.get(version);
+    if (gate === undefined || seen.has(version))
+        return false;
+    if (gate.state !== "carried")
+        return true;
+    const from = gate.carriedFrom;
+    return from !== null && from < version && runnable(byVersion, from, new Set([...seen, version]));
+}
+// The newest version at or below the head that was legacy, marked ready, or carried from a
+// runnable one. Undefined when none was ever checked. What a pack carries.
+export function checkedVersion(gates, head) {
+    const byVersion = new Map(gates.map((gate) => [gate.version, gate]));
+    return [...byVersion.keys()]
+        .filter((version) => version <= head && runnable(byVersion, version))
+        .sort((a, b) => b - a)[0];
+}
+// A template is gated from the first time any of its versions is marked ready in the studio.
+// Before that it follows its newest version as 3.x did, so an edit applies to the next run.
+export function isGated(gates) {
+    return gates.some((gate) => gate.state === "ready");
+}
+// The version a schedule runs: the newest one while the template isn't gated, else the newest
+// checked one (a newer unchecked version waits for Mark ready).
+export function runnableVersion(gates, head) {
+    return isGated(gates) ? checkedVersion(gates, head) : head;
+}
+export function gateOf(gates, version) {
+    return gates.find((gate) => gate.version === version)?.state ?? "unchecked";
+}
+// A version Slopify itself wrote (a model switch, a restore under a new name) keeps the gate of
+// the version it came from, so a schedule is never stopped by a change its user did not make.
+export function carryGate(gates, parent, next) {
+    if (next <= parent)
+        return undefined;
+    const byVersion = new Map(gates.map((gate) => [gate.version, gate]));
+    return runnable(byVersion, parent)
+        ? { version: next, state: "carried", carriedFrom: parent }
+        : undefined;
+}

package/dist/slices/template-studio/hidden.js

@@ -0,0 +1,20 @@
+import { transact } from "../../kernel/db/tx.js";
+import { deleteProject } from "../storage/delete-project.js";
+// Removes one of the studio's hidden projects (a sample made again on its own project, a
+// bake-off copy) for good. What it was charged today stays counted against the sample budget:
+// its priced calls are kept in `template_studio_spend` first, so removing a project never
+// frees budget it already spent.
+export function removeHiddenProject(deps, projectId) {
+    return transact(deps.db, () => {
+        deps.db
+            .prepare(`INSERT INTO template_studio_spend (project_id,cost,created_at)
+         SELECT project_id,cost,created_at FROM provider_usage
+         WHERE project_id=? AND on_plan=0 AND cost > 0`)
+            .run(projectId);
+        const removed = deleteProject(deps, projectId);
+        // A project that stays (running, a file the OS keeps) keeps its own rows: not counted twice.
+        if (!removed.ok)
+            deps.db.prepare("DELETE FROM template_studio_spend WHERE project_id=?").run(projectId);
+        return removed;
+    });
+}

package/dist/slices/template-studio/jobs.js

@@ -0,0 +1,79 @@
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { supersedeQueuedBakeoff } from "./bakeoff-repo.js";
+import { sampleJobKinds } from "./model.js";
+const jobRow = z.object({
+    templateId: z.string(),
+    templateVersion: z.number().int().positive(),
+    ackHigh: z.number(),
+    kind: z.enum(sampleJobKinds),
+    requestedAt: z.string(),
+});
+const columns = "template_id AS templateId,template_version AS templateVersion,ack_high AS ackHigh,kind,requested_at AS requestedAt";
+// Queues a template's sample job. A newer request takes the place of the one still queued; the
+// running one is left to finish and this one waits behind it. A free-only request never takes
+// the place of a queued paid one for the same version, which already makes the free samples,
+// nor of a queued bake-off.
+export function enqueueJob(db, job) {
+    transact(db, () => {
+        const queued = queuedJob(db, job.templateId);
+        if (queued !== undefined &&
+            job.kind === "free" &&
+            queued.kind !== "free" &&
+            (queued.templateVersion === job.templateVersion || queued.kind === "bakeoff"))
+            return;
+        // A bake-off still waiting was priced on the version a paid change replaces: it is
+        // dropped, saying so, and nothing was spent on it.
+        if (queued?.kind === "bakeoff" && job.kind !== "bakeoff")
+            supersedeQueuedBakeoff(db, job.templateId, job.requestedAt);
+        db.prepare(`INSERT INTO template_sample_jobs (template_id,template_version,ack_high,kind,requested_at,state)
+       VALUES (?,?,?,?,?,'queued')
+       ON CONFLICT(template_id,state) DO UPDATE SET template_version=excluded.template_version,
+         ack_high=excluded.ack_high,kind=excluded.kind,requested_at=excluded.requested_at`).run(job.templateId, job.templateVersion, job.ackHigh, job.kind, job.requestedAt);
+    });
+}
+export function queuedJob(db, templateId) {
+    const row = db
+        .prepare(`SELECT ${columns} FROM template_sample_jobs WHERE template_id=? AND state='queued'`)
+        .get(templateId);
+    return row === undefined ? undefined : jobRow.parse(row);
+}
+export function runningJob(db) {
+    const row = db
+        .prepare(`SELECT ${columns} FROM template_sample_jobs WHERE state='running' LIMIT 1`)
+        .get();
+    return row === undefined ? undefined : jobRow.parse(row);
+}
+// The next job to make: the oldest queued one, only while no other is running anywhere, so one
+// sample is made at a time across every template.
+export function claimNextJob(db) {
+    return transact(db, () => {
+        if (runningJob(db) !== undefined)
+            return undefined;
+        const row = db
+            .prepare(`SELECT ${columns} FROM template_sample_jobs WHERE state='queued' ORDER BY requested_at,template_id LIMIT 1`)
+            .get();
+        if (row === undefined)
+            return undefined;
+        const job = jobRow.parse(row);
+        db.prepare("UPDATE template_sample_jobs SET state='running' WHERE template_id=? AND state='queued'").run(job.templateId);
+        return job;
+    });
+}
+// The running job of a template now continues the project its paid work started on: queued
+// again by a restart, it is a Save of the same version, never a new topic's fresh project.
+export function continueJobAsSave(db, templateId) {
+    db.prepare("UPDATE template_sample_jobs SET kind='save' WHERE template_id=? AND state='running' AND kind IN ('topic','full-script')").run(templateId);
+}
+export function finishJob(db, templateId) {
+    db.prepare("DELETE FROM template_sample_jobs WHERE template_id=? AND state='running'").run(templateId);
+}
+// At start: a job that was running when Slopify stopped is queued again, unless a newer one
+// already waits for its template, which then takes its place.
+export function recoverJobs(db) {
+    transact(db, () => {
+        db.prepare(`DELETE FROM template_sample_jobs WHERE state='running' AND template_id IN
+         (SELECT template_id FROM template_sample_jobs WHERE state='queued')`).run();
+        db.prepare("UPDATE template_sample_jobs SET state='queued' WHERE state='running'").run();
+    });
+}

package/dist/slices/template-studio/loudness.js

@@ -0,0 +1,111 @@
+import { createHash, randomUUID } from "node:crypto";
+import { mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+import { levelFile } from "../loudness/loudnorm.js";
+import { encodeHeadroom, videoTruePeak, } from "../loudness/model.js";
+import { runFfmpeg } from "../video/ffmpeg.js";
+// Voice's loudness before and after: Slopify's sample narration as it came, and the same
+// levelled to the template's video target, as the run's master would. Phase 3's own voice sample
+// takes the bundled narration's place.
+// The target a template's video is levelled to, or undefined while Level the volume is off.
+export function loudnessGoalOf(document, fallback) {
+    const chosen = document.form.loudness;
+    if (!(chosen?.enabled ?? fallback.enabled))
+        return undefined;
+    return {
+        lufs: chosen?.videoLufs ?? fallback.videoLufs,
+        truePeak: videoTruePeak - encodeHeadroom,
+    };
+}
+export function loudnessHash(goal) {
+    return createHash("sha256")
+        .update(JSON.stringify({ version: 2, lufs: goal.lufs, truePeak: goal.truePeak }))
+        .digest("hex");
+}
+const readingSchema = z.object({
+    before: z.number(),
+    after: z.number(),
+    target: z.number(),
+    ceiling: z.number(),
+});
+const hashPattern = /^[a-f0-9]{64}$/;
+export function createLoudnessSamples(deps) {
+    const pathOf = (hash, extension) => join(deps.dir, `${hash}.${extension}`);
+    const file = (hash) => {
+        if (!hashPattern.test(hash))
+            return undefined;
+        try {
+            const stats = statSync(pathOf(hash, "mp3"));
+            return stats.isFile() && stats.size > 0
+                ? { path: pathOf(hash, "mp3"), bytes: stats.size }
+                : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    return {
+        source: deps.source,
+        file,
+        reading: (hash) => {
+            if (file(hash) === undefined)
+                return undefined;
+            try {
+                return readingSchema.parse(JSON.parse(readFileSync(pathOf(hash, "json"), "utf8")));
+            }
+            catch {
+                return undefined;
+            }
+        },
+        make: async (goal, signal) => {
+            const hash = loudnessHash(goal);
+            if (file(hash) !== undefined)
+                return;
+            mkdirSync(deps.dir, { recursive: true, mode: 0o700 });
+            const work = join(deps.dir, `${hash}.${randomUUID()}`);
+            const priority = deps.priority?.();
+            const run = { bin: deps.ffmpeg, log: deps.log, signal, priority };
+            try {
+                const levelled = await levelFile(run, deps.source, `${work}.wav`, goal, {
+                    sampleRate: 48_000,
+                    channels: 1,
+                });
+                await runFfmpeg({
+                    bin: deps.ffmpeg,
+                    args: [
+                        "-hide_banner",
+                        "-nostdin",
+                        "-loglevel",
+                        "error",
+                        "-y",
+                        "-i",
+                        `${work}.wav`,
+                        "-c:a",
+                        "libmp3lame",
+                        "-b:a",
+                        "128k",
+                        "-f",
+                        "mp3",
+                        `${work}.mp3`,
+                    ],
+                    signal,
+                    log: deps.log,
+                    priority,
+                    onProgress: () => undefined,
+                });
+                writeFileSync(pathOf(hash, "json"), JSON.stringify({
+                    before: Math.round(levelled.before.integrated * 10) / 10,
+                    after: Math.round(levelled.after.integrated * 10) / 10,
+                    target: goal.lufs,
+                    ceiling: goal.truePeak,
+                }), { mode: 0o600 });
+                renameSync(`${work}.mp3`, pathOf(hash, "mp3"));
+            }
+            finally {
+                rmSync(`${work}.wav`, { force: true });
+                rmSync(`${work}.mp3`, { force: true });
+            }
+        },
+    };
+}

package/dist/slices/template-studio/make.js

@@ -0,0 +1,40 @@
+import { templateById } from "../project-templates/repo.js";
+import { finishJob } from "./jobs.js";
+import { priceScheduledRun } from "./schedule-price.js";
+import { priceKey, templateSchedules } from "./service.js";
+// What one sample job makes: the free samples of its version, its paid sample unless it asked
+// for the free ones only, then the price of each schedule's run, the studio told after each so its page fills in as they land. A template deleted since
+// the job was queued makes nothing.
+export function sampleMaker(deps) {
+    return async (job, signal) => {
+        const template = templateById(deps.db, job.templateId, job.templateVersion);
+        if (template === undefined)
+            return;
+        // A bake-off makes only its copies: the template's own samples are current already.
+        if (job.kind === "bakeoff") {
+            await deps.bakeoff?.(job, signal);
+            deps.changed(template.id);
+            return;
+        }
+        await deps.free.make(template.document, signal);
+        deps.changed(template.id);
+        if (job.kind !== "free" && deps.paid !== undefined && !signal.aborted) {
+            await deps.paid(job, signal);
+            // Made: a quit while the schedules are priced below never queues it again.
+            finishJob(deps.db, job.templateId);
+            deps.changed(template.id);
+        }
+        const head = templateById(deps.db, job.templateId);
+        if (head === undefined)
+            return;
+        for (const schedule of templateSchedules(deps.db, head.id)) {
+            if (signal.aborted)
+                return;
+            const key = priceKey(schedule, head);
+            if (deps.prices.get(key) !== undefined)
+                continue;
+            deps.prices.set(key, await priceScheduledRun(deps.review, head, schedule));
+            deps.changed(head.id);
+        }
+    };
+}

package/dist/slices/template-studio/model.js

@@ -0,0 +1,54 @@
+// Template studio (4.0): a template is set up once, section by section, with live samples on a
+// hidden project, then marked ready for its schedules. Not to be confused with `slices/studio`,
+// which is the YouTube Studio pack and its extension.
+// In pipeline order: the studio's rail shows them so.
+export const templateSections = [
+    "subject",
+    "script",
+    "voice",
+    "pictures",
+    "video",
+    "thumbnail",
+    "shorts",
+    "document",
+    "reviews",
+    "upload",
+    "schedule",
+];
+export const sectionLabel = {
+    subject: "Subject & research",
+    script: "Script",
+    voice: "Voice",
+    pictures: "Pictures",
+    video: "Video & captions",
+    thumbnail: "Thumbnail & title",
+    shorts: "Shorts",
+    document: "Document (PDF)",
+    reviews: "Reviews & checkpoints",
+    upload: "Upload pack",
+    schedule: "Schedule",
+};
+// What a section's sample is: made for the current version, being made, queued behind another,
+// failed with a fix, made for an older version, switched off, or provided by the user at run time.
+export const sectionStates = [
+    "current",
+    "making",
+    "waiting",
+    "needs-fix",
+    "stale",
+    "off",
+    "provided",
+];
+// A version's gate. A version without one was never checked in the studio.
+export const gateStates = ["legacy", "ready", "carried"];
+export const sampleVersionStates = [
+    "queued",
+    "making",
+    "done",
+    "failed",
+    "skipped",
+    "held",
+];
+export const sampleJobKinds = ["save", "topic", "full-script", "bakeoff", "free"];
+// The topic every template's sample is made about until the user picks another.
+export const fallbackSampleTopic = "The history of the lighthouse";