@gentbajko/slopify 3.25.9 → 4.0.0

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

@@ -0,0 +1,134 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+import { templateSamplesDir } from "../../kernel/paths.js";
+import { carryGate } from "./gate.js";
+import { gateStates } from "./model.js";
+// The clause that keeps the studio's hidden projects (each template's sample and each
+// bake-off copy, `template_hidden_projects`) out of a query over projects. Every list the user
+// sees uses it (`edge/http/template-sample-isolation.test.ts` asks each GET route); the studio
+// and its runner read those projects by id, which it never limits.
+export function notTemplateSample(alias = "projects", column = "id") {
+    return `NOT EXISTS (SELECT 1 FROM template_hidden_projects h WHERE h.project_id = ${alias}.${column})`;
+}
+const hiddenProject = "SELECT 1 FROM template_hidden_projects WHERE project_id=?";
+export function isTemplateSample(db, projectId) {
+    return db.prepare(hiddenProject).get(projectId) !== undefined;
+}
+// The same question asked on every project event (the shell's tally, the global stream):
+// one prepared statement, reused.
+export function templateSampleCheck(db) {
+    const named = db.prepare(hiddenProject);
+    return (projectId) => named.get(projectId) !== undefined;
+}
+// Which projects' folders are kept in the data dir (`kernel/paths.ts` samples): a project
+// named by a template's sample row, or one whose folder is already there (a sample whose row
+// went with its template keeps its files where they are until the project is deleted).
+export function sampleProjects(db, dataDir) {
+    const named = db.prepare(hiddenProject);
+    const root = templateSamplesDir({ dataDir });
+    return {
+        has: (projectId) => named.get(projectId) !== undefined ||
+            (/^[0-9A-Za-z_-]{1,64}$/u.test(projectId) && existsSync(join(root, projectId))),
+    };
+}
+export function templateSampleProjects(db) {
+    return new Set(db
+        .prepare("SELECT project_id FROM template_hidden_projects")
+        .all()
+        .map((row) => String(row.project_id)));
+}
+// The template whose sample (or bake-off copy) a project is, with its current name; undefined
+// for any other project.
+export function sampleOwner(db, projectId) {
+    const row = db
+        .prepare(`SELECT o.template_id AS templateId, r.name AS name FROM (
+         SELECT template_id, project_id FROM template_samples
+         UNION ALL
+         SELECT b.template_id, c.project_id FROM template_bakeoff_clones c
+           JOIN template_bakeoffs b ON b.id=c.bakeoff_id
+       ) o
+       JOIN project_templates t ON t.id=o.template_id
+       JOIN project_template_revisions r ON r.template_id=t.id AND r.version=t.head_version
+       WHERE o.project_id=?`)
+        .get(projectId);
+    return row === undefined
+        ? undefined
+        : z.object({ templateId: z.string(), name: z.string() }).parse(row);
+}
+const gateRow = z.object({
+    version: z.number().int().positive(),
+    state: z.enum(gateStates),
+    carriedFrom: z.number().int().positive().nullable(),
+});
+export function gatesOf(db, templateId) {
+    return db
+        .prepare("SELECT version,state,carried_from AS carriedFrom FROM template_gates WHERE template_id=? ORDER BY version")
+        .all(templateId)
+        .map((row) => gateRow.parse(row));
+}
+export function sampleOf(db, templateId) {
+    const row = db
+        .prepare("SELECT project_id AS projectId,topic,topic_source AS topicSource,full_script AS fullScript FROM template_samples WHERE template_id=?")
+        .get(templateId);
+    if (row === undefined)
+        return undefined;
+    const parsed = z
+        .object({
+        projectId: z.string(),
+        topic: z.string(),
+        topicSource: z.enum(["fixed", "queued"]),
+        fullScript: z.number(),
+    })
+        .parse(row);
+    return { ...parsed, fullScript: parsed.fullScript === 1 };
+}
+const versionRow = z.object({
+    templateVersion: z.number().int().positive(),
+    revisionId: z.string().nullable(),
+    state: z.enum(["queued", "making", "done", "failed", "skipped", "held"]),
+    quotedHigh: z.number().nullable(),
+    heldReason: z.string().nullable(),
+    updatedAt: z.string(),
+});
+// Each version's paid sample, newest first.
+export function sampleVersions(db, templateId) {
+    return db
+        .prepare(`SELECT template_version AS templateVersion,revision_id AS revisionId,state,quoted_high AS quotedHigh,
+         held_reason AS heldReason,updated_at AS updatedAt
+       FROM template_sample_versions WHERE template_id=? ORDER BY template_version DESC`)
+        .all(templateId)
+        .map((row) => versionRow.parse(row));
+}
+// Records what a version's paid sample is now. A field left out keeps what it was.
+export function setSampleVersion(db, templateId, version, change) {
+    db.prepare(`INSERT INTO template_sample_versions (template_id,template_version,revision_id,state,quoted_high,held_reason,updated_at)
+     VALUES (?,?,?,?,?,?,?)
+     ON CONFLICT(template_id,template_version) DO UPDATE SET state=excluded.state,updated_at=excluded.updated_at,
+       revision_id=CASE WHEN ? THEN excluded.revision_id ELSE revision_id END,
+       quoted_high=CASE WHEN ? THEN excluded.quoted_high ELSE quoted_high END,
+       held_reason=CASE WHEN ? THEN excluded.held_reason ELSE held_reason END`).run(templateId, version, change.revisionId ?? null, change.state, change.quotedHigh ?? null, change.heldReason ?? null, change.at, change.revisionId === undefined ? 0 : 1, change.quotedHigh === undefined ? 0 : 1, change.heldReason === undefined ? 0 : 1);
+}
+// Records the hidden project a template's samples are made on.
+export function upsertSample(db, templateId, sample) {
+    db.prepare(`INSERT INTO template_samples (template_id,project_id,topic,topic_source,full_script,created_at)
+     VALUES (?,?,?,?,?,?)
+     ON CONFLICT(template_id) DO UPDATE SET project_id=excluded.project_id,topic=excluded.topic,
+       topic_source=excluded.topic_source,full_script=excluded.full_script`).run(templateId, sample.projectId, sample.topic, sample.topicSource, sample.fullScript ? 1 : 0, sample.at);
+}
+// Records a version's gate: marked ready (with the checks it passed), or carried from the
+// version a system writer made it from. Marking a carried or legacy version ready replaces it.
+export function writeGate(db, templateId, gate) {
+    db.prepare(`INSERT INTO template_gates (template_id,version,state,carried_from,checks_json,marked_at)
+     VALUES (?,?,?,?,?,?)
+     ON CONFLICT(template_id,version) DO UPDATE SET state=excluded.state,
+       carried_from=excluded.carried_from,checks_json=excluded.checks_json,marked_at=excluded.marked_at`).run(templateId, gate.version, gate.state, gate.carriedFrom, gate.checksJson ?? null, gate.markedAt ?? null);
+}
+// A version Slopify wrote itself from `parent` (a retired model switched, a restore under a new
+// name) keeps its gate: a runnable parent makes `next` carried, so no schedule stops over a
+// change its user didn't make. Call it in the writer's transaction.
+export function carryGateOnto(db, templateId, parent, next) {
+    const carried = carryGate(gatesOf(db, templateId), parent, next);
+    if (carried !== undefined)
+        writeGate(db, templateId, carried);
+}

package/dist/slices/template-studio/reviews-path.js

@@ -0,0 +1,58 @@
+import { reviewStages } from "../reviews/model.js";
+// Every stage named, so a new review stage has to be placed here too.
+const reviewNames = {
+    article: "Script",
+    promise: "The opening's promise",
+    narration: "Narration",
+    images: "Pictures",
+    thumbnail: "Thumbnail",
+    shorts: "Shorts",
+};
+const checkpointNames = {
+    audio: "Before the narration",
+    images: "Before the pictures",
+    video: "Before the video",
+};
+// Checkpoints stop before a stage; reviews judge what a stage made. In run order.
+const order = [
+    "review:article",
+    // Read against the title and thumbnail before the paid narration.
+    "review:promise",
+    "checkpoint:audio",
+    "review:narration",
+    "checkpoint:images",
+    "review:images",
+    "review:thumbnail",
+    "checkpoint:video",
+    "review:shorts",
+];
+export function reviewsPath(document) {
+    const { form } = document;
+    const agent = form.reviews?.reviewer === "agent";
+    const steps = [];
+    for (const stage of form.checkpoints ?? [])
+        steps.push({
+            id: `checkpoint:${stage}`,
+            name: checkpointNames[stage] ?? stage,
+            kind: "checkpoint",
+            by: "you",
+            detail: "The run waits here until you approve it.",
+        });
+    for (const stage of reviewStages) {
+        const mode = form.reviews?.stages[stage]?.mode ?? "off";
+        if (mode === "off")
+            continue;
+        steps.push({
+            id: `review:${stage}`,
+            name: reviewNames[stage],
+            kind: "review",
+            by: agent ? "agent" : "model",
+            detail: `${agent ? "Your agent answers this" : "The reviewer model checks it"}; ${mode === "redo" ? "a failed item is made again" : "a failed item is flagged for you"}.`,
+        });
+    }
+    const rank = (step) => {
+        const at = order.indexOf(step.id);
+        return at === -1 ? order.length : at;
+    };
+    return steps.toSorted((a, b) => rank(a) - rank(b));
+}

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

@@ -0,0 +1,84 @@
+import { setImmediate as yieldToLoop } from "node:timers/promises";
+import { errorText } from "../../kernel/errors.js";
+import { claimNextJob, finishJob, recoverJobs } from "./jobs.js";
+// The studio's one sample loop, beside the schedules' (`schedules/scheduler.ts`): it makes one
+// job at a time across every template and never blocks a request, yielding to the event loop
+// between steps.
+export function createSampleRunner(deps) {
+    const controller = new AbortController();
+    let loop;
+    let nudge;
+    let pending = false;
+    const idleWaiters = [];
+    const settleIdle = () => {
+        for (const resolve of idleWaiters.splice(0))
+            resolve();
+    };
+    const wait = () => new Promise((resolve) => {
+        if (pending || controller.signal.aborted) {
+            resolve();
+            return;
+        }
+        nudge = resolve;
+    });
+    const run = async () => {
+        while (!controller.signal.aborted) {
+            pending = false;
+            await yieldToLoop();
+            const job = claimNextJob(deps.db);
+            if (job === undefined) {
+                settleIdle();
+                await wait();
+                nudge = undefined;
+                continue;
+            }
+            deps.changed(job.templateId);
+            try {
+                await deps.make(job, controller.signal);
+            }
+            catch (error) {
+                if (controller.signal.aborted)
+                    return;
+                deps.log.write("error", "template-studio.sample", {
+                    detail: `The sample job of template ${job.templateId} version ${String(job.templateVersion)} stopped: ${errorText(error)}`,
+                });
+            }
+            if (controller.signal.aborted)
+                return;
+            finishJob(deps.db, job.templateId);
+            deps.changed(job.templateId);
+        }
+    };
+    return {
+        start: () => {
+            if (loop !== undefined)
+                return;
+            recoverJobs(deps.db);
+            loop = run().catch((error) => {
+                deps.log.write("error", "template-studio.runner", {
+                    detail: `The template studio's sample loop stopped: ${errorText(error)}. Restart Slopify to make samples again.`,
+                });
+            });
+        },
+        wake: () => {
+            pending = true;
+            nudge?.();
+        },
+        stop: async () => {
+            controller.abort();
+            nudge?.();
+            await loop;
+            settleIdle();
+        },
+        idle: () => new Promise((resolve) => {
+            if (loop === undefined || controller.signal.aborted) {
+                resolve();
+                return;
+            }
+            idleWaiters.push(resolve);
+            // Settles at once when the loop is already waiting with nothing to do.
+            if (nudge !== undefined && !pending)
+                settleIdle();
+        }),
+    };
+}

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

@@ -0,0 +1,236 @@
+import { z } from "zod";
+import { playDraftDocumentSchema } from "../play-drafts/schema.js";
+import { templateById } from "../project-templates/repo.js";
+import { updateTemplate } from "../project-templates/service.js";
+import { readJsonSetting, writeSetting } from "../settings/repo.js";
+import { budgetWords } from "./budget.js";
+import { enqueueJob } from "./jobs.js";
+import { quoteSave } from "./quote.js";
+import { setSampleVersion } from "./repo.js";
+// Save in the studio: the template's next version, and its sample queued at the price the
+// person saw. A price that went up since, a price unknown that wasn't accepted, or a sample
+// past today's budget is refused with the new quote, so nothing is ever spent unseen.
+export const saveStudioSchema = z
+    .object({
+    mutationId: z.uuid(),
+    baseVersion: z.number().int().positive(),
+    name: z.string().trim().min(1).max(200),
+    document: playDraftDocumentSchema,
+    sample: z.enum(["make", "skip"]),
+    // The high estimate the Save button showed; ignored when the sample is skipped.
+    acknowledgedHigh: z.number().finite().min(0).max(10_000),
+    // That some steps have no price, and the person accepts it.
+    acknowledgedUnknown: z.boolean().optional(),
+})
+    .strict()
+    .readonly();
+// A sample may cost a little more than the person saw before it waits: a quarter more and five
+// cents. Above that, or with any price unknown that wasn't accepted, it waits to be asked again.
+export function exceedsAcknowledged(high, acknowledged) {
+    return high > acknowledged * 1.25 + 0.05;
+}
+// Kept in the database, so a sample a restart stopped continues on what the person accepted.
+const acceptedKey = "templateStudio.unknownAccepted";
+// ceiling: the newest versions of each template; an older one's sample is never made again.
+const keptVersions = 20;
+const acceptedSchema = z.record(z.string(), z.array(z.number().int().positive()));
+export function storedUnknownAcks(db) {
+    const read = () => readJsonSetting(db, acceptedKey, acceptedSchema, {});
+    return {
+        accept: (id, version) => {
+            const all = read();
+            const versions = [...new Set([...(all[id] ?? []), version])]
+                .toSorted((a, b) => b - a)
+                .slice(0, keptVersions);
+            writeSetting(db, acceptedKey, JSON.stringify({ ...all, [id]: versions }));
+        },
+        accepted: (id, version) => (read()[id] ?? []).includes(version),
+    };
+}
+// In memory, for tests and a studio with no database of its own.
+export function createUnknownAcks() {
+    // ceiling: one entry per template version saved with unknown prices since boot.
+    const accepted = new Set();
+    const key = (id, version) => `${id}@${String(version)}`;
+    return {
+        accept: (id, version) => void accepted.add(key(id, version)),
+        accepted: (id, version) => accepted.has(key(id, version)),
+    };
+}
+const money = (value) => `$${value.toFixed(2)}`;
+export async function saveStudio(deps, id, raw) {
+    const parsed = saveStudioSchema.safeParse(raw);
+    if (!parsed.success)
+        return {
+            ok: false,
+            reason: "invalid-input",
+            message: "The studio sent a Save Slopify couldn't read. Reload the page and press Save again.",
+        };
+    const input = parsed.data;
+    const head = templateById(deps.db, id);
+    if (head === undefined)
+        return {
+            ok: false,
+            reason: "not-found",
+            message: "This template no longer exists; it may have been deleted. Go to Library → Templates to see your templates.",
+        };
+    const update = {
+        id,
+        baseVersion: input.baseVersion,
+        mutationId: input.mutationId,
+        name: input.name,
+        document: input.document,
+    };
+    // The same Save sent again (a retry after a lost answer) answers what it did the first time.
+    const last = deps.db.prepare("SELECT mutation_id FROM project_templates WHERE id=?").get(id);
+    if (last?.mutation_id === input.mutationId) {
+        const replay = updateTemplate(deps.review, update);
+        if (!replay.ok)
+            return {
+                ok: false,
+                reason: "conflict",
+                message: "This Save was already sent with different settings. Reload the studio to see what was saved.",
+            };
+        return {
+            ok: true,
+            value: {
+                template: replay.value,
+                sample: input.sample === "make" ? "queued" : "skipped",
+                quote: null,
+                replayed: true,
+            },
+        };
+    }
+    if (head.version !== input.baseVersion)
+        return {
+            ok: false,
+            reason: "conflict",
+            message: `This template changed since you opened it: it is now version ${String(head.version)}. Reload the studio to see the change, then make yours again.`,
+        };
+    let quote = null;
+    if (input.sample === "make") {
+        const quoted = await quoteSave(deps, id, input.document);
+        if (!quoted.ok)
+            return quoted;
+        quote = quoted.value;
+        if (quote.problem !== null)
+            return {
+                ok: false,
+                reason: "invalid-input",
+                message: `${quote.problem} Press Save without a sample to keep the change.`,
+                quote,
+            };
+        if (exceedsAcknowledged(quote.high, input.acknowledgedHigh))
+            return {
+                ok: false,
+                reason: "cost-changed",
+                message: `The sample now costs about ${money(quote.high)}, more than the ${money(input.acknowledgedHigh)} you saw. Press Save again to accept the new price, or Save without a sample.`,
+                quote,
+            };
+        if (quote.unknown > 0 && input.acknowledgedUnknown !== true)
+            return {
+                ok: false,
+                reason: "cost-changed",
+                message: `${String(quote.unknown)} ${quote.unknown === 1 ? "step of this sample has" : "steps of this sample have"} no known price. Tick that you accept unknown costs, then press Save again, or Save without a sample.`,
+                quote,
+            };
+        if (!quote.fits)
+            return {
+                ok: false,
+                reason: "over-budget",
+                message: `${budgetWords(quote.budget, quote, "This sample")}, or press Save without a sample.`,
+                quote,
+            };
+    }
+    const saved = updateTemplate(deps.review, update);
+    if (!saved.ok)
+        return {
+            ok: false,
+            reason: saved.reason === "not-found"
+                ? "not-found"
+                : saved.reason === "conflict"
+                    ? "conflict"
+                    : "invalid-input",
+            message: saved.reason === "missing-prompt"
+                ? "A prompt or intro/outro entry this template uses was deleted. Choose another in the template, then press Save again."
+                : saved.reason === "conflict"
+                    ? "This template changed while you were editing. Reload the studio to see the latest, then make your change again."
+                    : "Some template settings are not valid, for example an image you supplied yourself. Check the template's settings and press Save again.",
+        };
+    const template = saved.value;
+    const at = deps.clock.now().toISOString();
+    if (quote !== null) {
+        // Accepted on this Save: unknown prices the person ticked, or a quote that priced them all.
+        if (input.acknowledgedUnknown === true || quote.unknown === 0)
+            deps.acks.accept(id, template.version);
+        setSampleVersion(deps.db, id, template.version, {
+            state: "queued",
+            at,
+            quotedHigh: quote.high,
+            heldReason: null,
+        });
+    }
+    else
+        setSampleVersion(deps.db, id, template.version, { state: "skipped", at });
+    enqueueJob(deps.db, {
+        templateId: id,
+        templateVersion: template.version,
+        ackHigh: quote === null ? 0 : Math.max(input.acknowledgedHigh, 0),
+        kind: quote === null ? "free" : "save",
+        requestedAt: at,
+    });
+    return {
+        ok: true,
+        value: { template, sample: quote === null ? "skipped" : "queued", quote, replayed: false },
+    };
+}
+export const makeSampleSchema = z
+    .object({
+    version: z.number().int().positive(),
+    // The price the Make sample button showed.
+    acknowledgedHigh: z.number().finite().min(0).max(10_000),
+    acknowledgedUnknown: z.boolean().optional(),
+})
+    .strict()
+    .readonly();
+// Make sample: the current version's paid sample asked for again, at the price shown, after it
+// waited (a higher price, unknown prices, the budget) or failed.
+export function requestSample(deps, id, raw) {
+    const parsed = makeSampleSchema.safeParse(raw);
+    if (!parsed.success)
+        return {
+            ok: false,
+            reason: "invalid-input",
+            message: "The studio sent a request Slopify couldn't read. Reload the page and press Make sample again.",
+        };
+    const head = templateById(deps.db, id);
+    if (head === undefined)
+        return {
+            ok: false,
+            reason: "not-found",
+            message: "This template no longer exists; it may have been deleted. Go to Library → Templates to see your templates.",
+        };
+    if (head.version !== parsed.data.version)
+        return {
+            ok: false,
+            reason: "conflict",
+            message: `This template is now version ${String(head.version)}, not the version ${String(parsed.data.version)} you saw. Reload the studio, then press Make sample.`,
+        };
+    const at = deps.clock.now().toISOString();
+    if (parsed.data.acknowledgedUnknown === true)
+        deps.acks.accept(id, head.version);
+    setSampleVersion(deps.db, id, head.version, {
+        state: "queued",
+        at,
+        quotedHigh: parsed.data.acknowledgedHigh,
+        heldReason: null,
+    });
+    enqueueJob(deps.db, {
+        templateId: id,
+        templateVersion: head.version,
+        ackHigh: parsed.data.acknowledgedHigh,
+        kind: "save",
+        requestedAt: at,
+    });
+    return { ok: true, value: { version: head.version } };
+}