@gentbajko/slopify 3.25.8 → 4.0.0

package/dist/slices/template-studio/say-it-as.js

@@ -0,0 +1,248 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { aliasSpokenMax, aliasWrittenMax, } from "../../kernel/ports/narration-aliases.js";
+import { projectExists } from "../admission/repo.js";
+import { estimateRequests } from "../estimate/index.js";
+import { listNarrationAliases, saveNarrationAliases } from "../narration/aliases-library.js";
+import { parsePronunciationGlossary } from "../narration/pronunciation.js";
+import { templateById } from "../project-templates/repo.js";
+import { outputPath } from "../storage/layout.js";
+import { outputsOf } from "../storage/repo.js";
+import { budgetRoom, budgetWords, fitsBudget } from "./budget.js";
+import { enqueueJob } from "./jobs.js";
+import { sampleOf, setSampleVersion } from "./repo.js";
+import { exceedsAcknowledged } from "./save.js";
+const namesMax = 30;
+const linesMax = 50;
+// The script read for its sentences: a sample's is an outline and a chapter, well under this.
+const scriptBytesMax = 2_000_000;
+const escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+const wordPattern = (word) => new RegExp(`(?<![\\p{L}\\p{N}])${escapeRegExp(word)}(?![\\p{L}\\p{N}])`, "giu");
+function sentencesOf(text) {
+    return text
+        .split(/(?<=[.!?…])\s+|\n+/u)
+        .map((sentence) => sentence.trim())
+        .filter((sentence) => sentence !== "");
+}
+// Every sentence that says the word: whole words, any case.
+export function linesWith(text, written) {
+    const word = written.trim();
+    if (word === "")
+        return [];
+    const pattern = wordPattern(word);
+    return sentencesOf(text)
+        .filter((sentence) => {
+        pattern.lastIndex = 0;
+        return pattern.test(sentence);
+    })
+        .slice(0, linesMax);
+}
+function aliasFor(aliases, term) {
+    return aliases.find((alias) => alias.caseSensitive
+        ? alias.written === term
+        : alias.written.toLowerCase() === term.toLowerCase());
+}
+export function namesToCheck(glossary, script, aliases) {
+    const parsed = glossary === undefined ? undefined : parsePronunciationGlossary(glossary);
+    const entries = parsed?.ok === true ? parsed.entries : [];
+    const lineOf = (term) => script === undefined ? null : (linesWith(script, term)[0] ?? null);
+    const names = entries.map((entry) => ({
+        term: entry.term,
+        ipa: entry.ipa,
+        line: lineOf(entry.term),
+        spokenAs: aliasFor(aliases, entry.term)?.spoken ?? null,
+    }));
+    const seen = new Set(names.map((name) => name.term.toLowerCase()));
+    for (const alias of aliases) {
+        if (seen.has(alias.written.toLowerCase()))
+            continue;
+        const line = lineOf(alias.written);
+        if (line === null)
+            continue;
+        seen.add(alias.written.toLowerCase());
+        names.push({ term: alias.written, ipa: [], line, spokenAs: alias.spoken });
+    }
+    return names.slice(0, namesMax);
+}
+function textOf(deps, projectId, role) {
+    const output = outputsOf(deps.db, projectId)
+        .filter((row) => row.role === role)
+        .at(-1);
+    if (output === undefined)
+        return undefined;
+    const path = outputPath(deps.paths, projectId, output.path);
+    if (!existsSync(path) || statSync(path).size > scriptBytesMax)
+        return undefined;
+    const text = readFileSync(path, "utf8");
+    return text.trim() === "" ? undefined : text;
+}
+// The sample's spoken script and its glossary, or undefined before its first paid sample.
+function sampleTexts(deps, templateId) {
+    const sample = sampleOf(deps.db, templateId);
+    if (sample === undefined || !projectExists(deps.db, sample.projectId))
+        return undefined;
+    return {
+        script: textOf(deps, sample.projectId, "article_txt"),
+        glossary: textOf(deps, sample.projectId, "glossary"),
+    };
+}
+const missingTemplate = "This template no longer exists; it may have been deleted. Go to Library → Templates to see your templates.";
+export function pronunciationsOf(deps, templateId) {
+    const head = templateById(deps.db, templateId);
+    if (head === undefined)
+        return { names: [], aliasesOn: false, voice: null, problem: missingTemplate };
+    const { audio } = head.document.form;
+    const voice = audio.provider !== "" && audio.model !== "" && audio.voice !== ""
+        ? { provider: audio.provider, model: audio.model, voice: audio.voice }
+        : null;
+    const aliasesOn = audio.useNarrationAliases === true;
+    const texts = sampleTexts(deps, templateId);
+    if (texts === undefined)
+        return {
+            names: [],
+            aliasesOn,
+            voice,
+            problem: "The names to check come from the sample's script. Press Save or Make sample to make one.",
+        };
+    const names = namesToCheck(texts.glossary, texts.script, listNarrationAliases(deps.db));
+    return {
+        names,
+        aliasesOn,
+        voice,
+        problem: names.length === 0
+            ? "The sample's script has no Pronunciation Glossary, so there are no names to check. Type a word below to hear it."
+            : null,
+    };
+}
+export const sayItAsSchema = z
+    .object({
+    written: z.string().trim().min(1).max(aliasWrittenMax),
+    spoken: z.string().trim().min(1).max(aliasSpokenMax),
+    // The price the Save button showed.
+    acknowledgedHigh: z.number().finite().min(0).max(10_000),
+    acknowledgedUnknown: z.boolean().optional(),
+})
+    .strict()
+    .readonly();
+const aliasesOff = "This template's voice doesn't use Library → Narration aliases, so “Say it as” would change nothing. Turn on Use narration aliases in Voice → Fine-tune, press Save, then try again.";
+export function quoteSayItAs(deps, templateId, ask) {
+    const head = templateById(deps.db, templateId);
+    if (head === undefined)
+        return { ok: false, reason: "not-found", message: missingTemplate };
+    const budget = budgetRoom(deps.db, deps.clock.now(), deps.timeZone);
+    const { audio } = head.document.form;
+    if (audio.useNarrationAliases !== true)
+        return {
+            ok: true,
+            value: {
+                lines: 0,
+                high: 0,
+                unknown: 0,
+                usesPlan: false,
+                fits: true,
+                budget,
+                problem: aliasesOff,
+            },
+        };
+    const script = sampleTexts(deps, templateId)?.script;
+    const lines = script === undefined ? [] : linesWith(script, ask.written);
+    if (lines.length === 0)
+        return {
+            ok: true,
+            value: { lines: 0, high: 0, unknown: 0, usesPlan: false, fits: true, budget, problem: null },
+        };
+    const pattern = wordPattern(ask.written.trim());
+    const estimate = estimateRequests(lines.map((line) => ({
+        kind: "tts",
+        stage: "Narration",
+        provider: audio.provider,
+        model: audio.model,
+        text: line.replace(pattern, ask.spoken.trim()),
+    })), deps.review.catalogue.read());
+    return {
+        ok: true,
+        value: {
+            lines: lines.length,
+            high: estimate.high,
+            unknown: estimate.unknown,
+            usesPlan: estimate.rows.some((row) => row.onPlan === true),
+            fits: fitsBudget(budget, estimate.high, estimate.rows.some((row) => row.onPlan === true)),
+            budget,
+            problem: null,
+        },
+    };
+}
+const money = (value) => `$${value.toFixed(2)}`;
+export async function sayItAs(deps, templateId, raw) {
+    const parsed = sayItAsSchema.safeParse(raw);
+    if (!parsed.success)
+        return {
+            ok: false,
+            reason: "invalid-input",
+            message: `Type how to say it in 1 to ${String(aliasSpokenMax)} characters, then press Save.`,
+        };
+    const { written, spoken, acknowledgedHigh, acknowledgedUnknown } = parsed.data;
+    const quoted = quoteSayItAs(deps, templateId, { written, spoken });
+    if (!quoted.ok)
+        return quoted;
+    const quote = quoted.value;
+    if (quote.problem !== null)
+        return { ok: false, reason: "invalid-input", message: quote.problem };
+    if (exceedsAcknowledged(quote.high, acknowledgedHigh))
+        return {
+            ok: false,
+            reason: "cost-changed",
+            message: `Voicing these lines again now costs about ${money(quote.high)}, more than the ${money(acknowledgedHigh)} you saw. Press Save again to accept the new price.`,
+            quote,
+        };
+    if (quote.unknown > 0 && acknowledgedUnknown !== true)
+        return {
+            ok: false,
+            reason: "cost-changed",
+            message: "This voice has no known price. Tick that you accept unknown costs, then press Save again.",
+            quote,
+        };
+    if (!quote.fits)
+        return {
+            ok: false,
+            reason: "over-budget",
+            message: `${budgetWords(quote.budget, quote, "Voicing these lines again")}, or try again tomorrow.`,
+            quote,
+        };
+    const head = templateById(deps.db, templateId);
+    if (head === undefined)
+        return { ok: false, reason: "not-found", message: missingTemplate };
+    const alias = { written, spoken, wholeWord: true, caseSensitive: false };
+    const at = deps.clock.now().toISOString();
+    return transact(deps.db, () => {
+        const kept = listNarrationAliases(deps.db).filter((one) => one.written.toLowerCase() !== written.toLowerCase());
+        const saved = saveNarrationAliases(deps, [...kept, alias]);
+        if (!saved.ok)
+            return {
+                ok: false,
+                reason: "invalid-input",
+                message: `The alias wasn't saved: ${saved.fields.map((field) => field.message).join(" ")} Fix it in Library → Narration aliases, then try again.`,
+            };
+        if (quote.lines === 0)
+            return { ok: true, value: { alias, queued: false, quote } };
+        // The sample's next revision copies Library → Narration aliases as they are now, so its
+        // rebuild voices again only the chunks whose spoken words changed.
+        // Its unknown prices were accepted above, or it priced every line.
+        deps.acks.accept(templateId, head.version);
+        setSampleVersion(deps.db, templateId, head.version, {
+            state: "queued",
+            at,
+            quotedHigh: quote.high,
+            heldReason: null,
+        });
+        enqueueJob(deps.db, {
+            templateId,
+            templateVersion: head.version,
+            ackHigh: acknowledgedHigh,
+            kind: "save",
+            requestedAt: at,
+        });
+        return { ok: true, value: { alias, queued: true, quote } };
+    });
+}

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

@@ -0,0 +1,34 @@
+import { templateById } from "../project-templates/repo.js";
+import { gateOf, isGated, runnableVersion } from "./gate.js";
+import { gatesOf } from "./repo.js";
+export function templateGate(db, templateId) {
+    const head = templateById(db, templateId);
+    if (head === undefined)
+        return undefined;
+    const gates = gatesOf(db, templateId);
+    const runs = runnableVersion(gates, head.version) ?? null;
+    return {
+        head: head.version,
+        runs,
+        gated: isGated(gates),
+        gate: gateOf(gates, runs ?? head.version),
+    };
+}
+// The version a schedule runs, previews and checks against. A gated template with nothing it may
+// run answers its newest one, so the schedule can still be edited and its calendar shows
+// titles; its runs wait (`notReadySentence`).
+export function runnableTemplate(db, templateId) {
+    const gate = templateGate(db, templateId);
+    if (gate === undefined)
+        return undefined;
+    return templateById(db, templateId, gate.runs ?? gate.head);
+}
+// Why a schedule's run doesn't start: its gated template has no version it may run. Undefined
+// when it has one, or when the template is gone (the run says that itself).
+export function notReadySentence(db, templateId) {
+    const gate = templateGate(db, templateId);
+    if (gate === undefined || gate.runs !== null)
+        return undefined;
+    const name = templateById(db, templateId)?.name ?? "This schedule's template";
+    return `Not started: ${name} has no version marked ready. Open it in Library → Templates → Open studio and press Mark ready.`;
+}

package/dist/slices/template-studio/schedule-price.js

@@ -0,0 +1,30 @@
+import { resolvePlayReview } from "../play-drafts/review.js";
+import { scheduledDocument } from "../schedules/prepare.js";
+// One scheduled run priced the way Play's review prices it, on a draft that is never saved:
+// the template's version with the schedule's first topic and values. Asked in the sample job,
+// never in a request.
+export async function priceScheduledRun(deps, template, schedule) {
+    const document = scheduledDocument({ ...deps, template: () => template }, schedule, schedule.items[0]);
+    if (document === undefined)
+        return "the template could not be read.";
+    return priceDocument(deps, document);
+}
+export async function priceDocument(deps, document) {
+    const at = deps.clock.now().toISOString();
+    const view = {
+        draft: { id: deps.uuid(), version: 1, createdAt: at, updatedAt: at, document },
+        attachments: [],
+        review: null,
+        pendingStart: null,
+        start: null,
+    };
+    const review = await resolvePlayReview(deps, view, { unsaved: true });
+    if (!review.ok)
+        return review.fields.length === 0
+            ? "Play's review refused this setup. Open the template in Play (Use in Play) to see why."
+            : [...new Set(review.fields.map((field) => field.message))].join(" ");
+    return {
+        high: review.value.estimates.reduce((sum, estimate) => sum + estimate.high, 0),
+        unknown: review.value.estimates.reduce((sum, estimate) => sum + estimate.unknown, 0),
+    };
+}

package/dist/slices/template-studio/schedule-sample.js

@@ -0,0 +1,87 @@
+import { nextOccurrence } from "../schedules/calendar.js";
+import { renderedTitle } from "../schedules/topic-list.js";
+export function upcomingRuns(schedules, document, now, count = 5) {
+    const runs = [];
+    for (const schedule of schedules) {
+        if (schedule.status !== "active" && schedule.status !== "paused")
+            continue;
+        let after = now;
+        for (let index = 0; index < count; index++) {
+            const at = nextOccurrence(schedule.cadence, schedule.timezone, after);
+            if (at === null)
+                break;
+            const topic = schedule.items[index];
+            runs.push({
+                at: at.toISOString(),
+                scheduleId: schedule.id,
+                scheduleName: schedule.name,
+                title: topic === undefined && schedule.topicKeyword !== null
+                    ? document.form.title
+                    : renderedTitle(document.form, schedule, topic).trim() || document.form.title,
+                topic: topic !== undefined,
+                paused: schedule.status === "paused",
+            });
+            after = new Date(at.getTime() + 1);
+        }
+    }
+    return runs.toSorted((a, b) => a.at.localeCompare(b.at)).slice(0, count);
+}
+// How many runs a schedule makes in an average month; a paused one's are counted only
+// `asResumed`.
+export function runsPerMonth(schedule, now, asResumed = false) {
+    if (schedule.status !== "active" && !(asResumed && schedule.status === "paused"))
+        return 0;
+    const { cadence } = schedule;
+    if (cadence.kind === "daily")
+        return 365.25 / 12;
+    if (cadence.kind === "weekly")
+        return (cadence.days.length * 365.25) / 12 / 7;
+    const at = nextOccurrence(cadence, schedule.timezone, now);
+    return at !== null && at.getTime() - now.getTime() <= 30 * 24 * 60 * 60 * 1000 ? 1 : 0;
+}
+export function monthlyCost(schedules, prices, now) {
+    const active = schedules.filter((schedule) => schedule.status === "active");
+    const stopped = schedules.filter((schedule) => schedule.status === "paused");
+    if (active.length === 0 && stopped.length === 0)
+        return null;
+    let pausedRuns = 0;
+    let pausedHigh = 0;
+    for (const schedule of stopped) {
+        const perMonth = runsPerMonth(schedule, now, true);
+        pausedRuns += perMonth;
+        const price = prices.get(schedule.id);
+        if (price !== undefined && typeof price !== "string")
+            pausedHigh += price.high * perMonth;
+    }
+    const paused = {
+        schedules: stopped.length,
+        runs: Math.round(pausedRuns * 10) / 10,
+        high: Math.round(pausedHigh * 100) / 100,
+    };
+    let runs = 0;
+    let high = 0;
+    let unknown = 0;
+    let problem = null;
+    for (const schedule of active) {
+        const perMonth = runsPerMonth(schedule, now);
+        runs += perMonth;
+        const price = prices.get(schedule.id);
+        if (price === undefined || typeof price === "string") {
+            unknown += 1;
+            problem ??=
+                price === undefined
+                    ? `The cost of the runs of ${schedule.name} isn't worked out yet: it is, with the free samples.`
+                    : `The runs of ${schedule.name} couldn't be priced: ${price} Fix it in this studio, press Save, then Make samples.`;
+            continue;
+        }
+        high += price.high * perMonth;
+        unknown += price.unknown;
+    }
+    return {
+        runs: Math.round(runs * 10) / 10,
+        high: Math.round(high * 100) / 100,
+        unknown,
+        problem,
+        paused,
+    };
+}

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

@@ -0,0 +1,218 @@
+import { z } from "zod";
+import { projectTemplateSchema } from "../project-templates/schema.js";
+import { freeCheckIds } from "./checks.js";
+import { gateStates, sampleVersionStates, sectionStates, templateSections } from "./model.js";
+// What GET /api/template-studio/:id answers, browser-safe so the studio page parses the same
+// shape the server writes.
+export const checkSchema = z
+    .object({
+    id: z.enum(freeCheckIds),
+    ok: z.boolean(),
+    sentence: z.string(),
+    fix: z.object({ label: z.string(), href: z.string() }).strict().readonly().optional(),
+})
+    .strict()
+    .readonly();
+export const sectionStatusSchema = z
+    .object({
+    id: z.enum(templateSections),
+    label: z.string(),
+    state: z.enum(sectionStates),
+    sentence: z.string(),
+})
+    .strict()
+    .readonly();
+const freeSampleSchema = z
+    .object({
+    state: z.enum(["current", "making", "waiting", "needs-fix", "stale", "off"]),
+    sentence: z.string(),
+    url: z.string().nullable(),
+})
+    .strict()
+    .readonly();
+export const freeSamplesSchema = z
+    .object({
+    video: freeSampleSchema,
+    loudness: freeSampleSchema
+        .unwrap()
+        .extend({
+        beforeUrl: z.string().nullable(),
+        beforeLufs: z.number().nullable(),
+        afterLufs: z.number().nullable(),
+        targetLufs: z.number().nullable(),
+        ceiling: z.number().nullable(),
+    })
+        .strict()
+        .readonly(),
+    document: freeSampleSchema,
+})
+    .strict()
+    .readonly();
+export const scheduleSampleSchema = z
+    .object({
+    runs: z
+        .array(z
+        .object({
+        at: z.string(),
+        scheduleId: z.string(),
+        scheduleName: z.string(),
+        title: z.string(),
+        topic: z.boolean(),
+        paused: z.boolean(),
+    })
+        .strict()
+        .readonly())
+        .readonly(),
+    cost: z
+        .object({
+        runs: z.number(),
+        high: z.number(),
+        unknown: z.number(),
+        problem: z.string().nullable(),
+        paused: z
+            .object({ schedules: z.number(), runs: z.number(), high: z.number() })
+            .strict()
+            .readonly(),
+    })
+        .strict()
+        .readonly()
+        .nullable(),
+})
+    .strict()
+    .readonly();
+export const pathStepSchema = z
+    .object({
+    id: z.string(),
+    name: z.string(),
+    kind: z.enum(["checkpoint", "review"]),
+    by: z.enum(["you", "model", "agent"]),
+    detail: z.string(),
+})
+    .strict()
+    .readonly();
+// The paid sample: its project's files now, each in its section, and each version's state.
+export const paidViewSchema = z
+    .object({
+    projectId: z.string().nullable(),
+    revisionId: z.string().nullable(),
+    state: z.enum(sampleVersionStates).nullable(),
+    sentence: z.string().nullable(),
+    quotedHigh: z.number().nullable(),
+    article: z.string().nullable(),
+    outputs: z
+        .array(z
+        .object({
+        section: z.enum(templateSections),
+        role: z.string(),
+        url: z.string(),
+        name: z.string(),
+    })
+        .strict()
+        .readonly())
+        .readonly(),
+    versions: z
+        .array(z
+        .object({
+        version: z.number().int().positive(),
+        state: z.enum(sampleVersionStates),
+        updatedAt: z.string(),
+    })
+        .strict()
+        .readonly())
+        .readonly(),
+})
+    .strict()
+    .readonly();
+export const studioViewSchema = z
+    .object({
+    template: projectTemplateSchema,
+    gate: z.enum([...gateStates, "unchecked"]),
+    // The version schedules run: the newest until a version was first marked ready (`gated`),
+    // then the newest checked one (null when none is).
+    runnableVersion: z.number().int().positive().nullable(),
+    gated: z.boolean(),
+    // The newest legacy, ready or carried version, which Export pack carries; null when none.
+    checkedVersion: z.number().int().positive().nullable(),
+    sample: z
+        .object({
+        topic: z.string(),
+        topicSource: z.enum(["fixed", "queued"]),
+        fullScript: z.boolean(),
+    })
+        .strict()
+        .readonly(),
+    sections: z.array(sectionStatusSchema).readonly(),
+    free: freeSamplesSchema,
+    schedule: scheduleSampleSchema,
+    reviews: z.array(pathStepSchema).readonly(),
+    paid: paidViewSchema,
+})
+    .strict()
+    .readonly();
+// GET /api/template-studio/:id/checks: read apart from the studio, since the providers'
+// readiness they need takes seconds to look up.
+export const studioChecksSchema = z
+    .object({ version: z.number().int().positive(), checks: z.array(checkSchema).readonly() })
+    .strict()
+    .readonly();
+const quoteRowSchema = z
+    .object({
+    stage: z.string(),
+    low: z.number().nullable(),
+    high: z.number().nullable(),
+    detail: z.string(),
+    onPlan: z.boolean().optional(),
+    apiLow: z.number().nullable().optional(),
+    apiHigh: z.number().nullable().optional(),
+})
+    .strict()
+    .readonly();
+// POST /api/template-studio/:id/quote: what a Save's sample costs, before anything is spent.
+export const sampleQuoteSchema = z
+    .object({
+    version: z.number().int().positive(),
+    first: z.boolean(),
+    sections: z.array(z.enum(templateSections)).readonly(),
+    rows: z.array(quoteRowSchema).readonly(),
+    low: z.number(),
+    high: z.number(),
+    unknown: z.number().int().nonnegative(),
+    onPlan: z.boolean(),
+    usesPlan: z.boolean(),
+    budget: z
+        .object({
+        budget: z.number(),
+        spent: z.number(),
+        unpriced: z.number().int().nonnegative(),
+        left: z.number(),
+        plans: z.boolean(),
+    })
+        .strict()
+        .readonly(),
+    fits: z.boolean(),
+    problem: z.string().nullable(),
+})
+    .strict()
+    .readonly();
+// GET /api/template-studio/:id/anatomy: a section's prompt cut into who wrote each part.
+export const anatomyViewSchema = z
+    .object({
+    section: z.enum(templateSections),
+    items: z.array(z.object({ key: z.string(), label: z.string() }).strict().readonly()).readonly(),
+    item: z.string().nullable(),
+    segments: z
+        .array(z
+        .object({
+        origin: z.enum(["yours", "keyword", "slopify", "setting"]),
+        text: z.string(),
+        name: z.string().optional(),
+        unfilled: z.literal(true).optional(),
+    })
+        .strict()
+        .readonly())
+        .readonly(),
+    fromSample: z.boolean(),
+    problem: z.string().nullable(),
+})
+    .strict()
+    .readonly();