@gentbajko/slopify 3.25.9 → 4.1.0

package/dist/slices/schedules/agenda.js

@@ -1,15 +1,17 @@
 import { z } from "zod";
 import { derive, progressOf } from "../../kernel/runner/graph.js";
 import { liveProject, stageStandingsByProject } from "../admission/repo.js";
-import { readsByWaitBesideFailure } from "../admission/state-words.js";
+import { readsByWaitBesideFailure, retryingAt } from "../admission/state-words.js";
 import { queueEntries } from "../batch/index.js";
 import { sampleIds } from "../onboarding/model.js";
 import { readSampleRecord } from "../onboarding/state.js";
 import { projectHolds } from "../reviews/holds.js";
 import { limitWaitsByProject, listingWait } from "../run-cost/panel.js";
-import { setAsideProjects, uploadedAndSettled, uploadedProjects } from "../uploads/repo.js";
+import { notTemplateSample } from "../template-studio/repo.js";
+import { setAsideProjects, settledProjects, uploadedProjects } from "../uploads/repo.js";
 import { settledStatus } from "../uploads/rules.js";
 import { nextOccurrence } from "./calendar.js";
+import { upcomingDesignRuns } from "./design-agenda.js";
 import { preparedProject } from "./prepare.js";
 import { scheduleRows } from "./repo.js";
 import { calendarMaxDays, } from "./schema.js";
@@ -49,6 +51,8 @@ function upcomingRuns(deps, schedule, now, from, to) {
         return [];
     if (schedule.status !== "active" && schedule.status !== "paused")
         return [];
+    if (schedule.cadence.kind === "by-date")
+        return upcomingDesignRuns(deps.db, schedule, now, from, to);
     const paused = schedule.status === "paused";
     // A paused schedule resumes from the next occurrence after the moment Resume is pressed.
     let at = schedule.nextRunAt === null
@@ -58,6 +62,7 @@ function upcomingRuns(deps, schedule, now, from, to) {
             : new Date(schedule.nextRunAt);
     const template = deps.template(schedule.templateId);
     const templateName = template?.name ?? null;
+    const notReady = deps.notReady?.(schedule.templateId) !== undefined;
     const form = template?.document.form;
     const { items } = schedule;
     const generation = schedule.topicGeneration.mode;
@@ -91,10 +96,13 @@ function upcomingRuns(deps, schedule, now, from, to) {
                             ? "held"
                             : "generated",
                 renderedTitle: title,
+                templateKind: "project",
+                timezone: schedule.timezone,
                 // Prepared ahead (`prepare.ts`): the project the day continues.
                 prepared: title === null || queuedTopic === undefined
                     ? null
                     : (preparedProject(deps.db, schedule.id, title)?.projectId ?? null),
+                notReady,
             });
         if (schedule.cadence.kind === "once")
             break;
@@ -143,8 +151,8 @@ function sampleProjectIds(db) {
 // What a project on the calendar asks of the person, if anything. The same readings Home's
 // Needs you uses: a failed run, a paused run, one a restart stopped (Continue the run), or one
 // waiting for a review. A step failed beside a wait reads by that wait and is listed apart
-// (`stepFailed`). One Kept as is asks nothing, nor does an uploaded one that reads Done
-// (`uploadedAndSettled`).
+// (`stepFailed`). One Kept as is asks nothing, nor does an uploaded or edited one that reads
+// Done (`settledProjects`).
 function needsOf(state, ask) {
     if (state === "failed")
         return "failed";
@@ -162,7 +170,7 @@ function needsOf(state, ask) {
 // the range, with what each needs from the person and whether its video is ready to upload.
 function projectsIn(deps, from, to) {
     const standings = stageStandingsByProject(deps.db);
-    const settled = uploadedAndSettled(deps.db);
+    const settled = settledProjects(deps.db);
     const holds = projectHolds(deps.db, { standings, settled });
     const reviewing = awaitingReview(deps.db, holds);
     const uploads = uploadedProjects(deps.db);
@@ -186,7 +194,8 @@ function projectsIn(deps, from, to) {
          COALESCE(project_controls.paused,0) AS paused,max(stages.finished_at) AS finished_at
        FROM projects LEFT JOIN stages ON stages.project_id=projects.id
        LEFT JOIN project_controls ON project_controls.project_id=projects.id
-       WHERE projects.created_at<? AND ${liveProject()} GROUP BY projects.id
+       WHERE projects.created_at<? AND ${liveProject()} AND ${notTemplateSample()}
+       GROUP BY projects.id
        HAVING COALESCE(project_controls.paused,0)=1 OR count(stages.id)=0
          OR sum(stages.state IN ('pending','running'))>0
          OR COALESCE(max(stages.finished_at),projects.created_at)>=?
@@ -215,6 +224,7 @@ function projectsIn(deps, from, to) {
             !uploads.has(project.id) &&
             !samples.has(project.id);
         const waiting = waits.get(project.id);
+        const retry = state === "running" ? retryingAt(standings.get(project.id) ?? []) : undefined;
         return [
             {
                 id: project.id,
@@ -233,6 +243,7 @@ function projectsIn(deps, from, to) {
                 ...(readsByWaitBesideFailure(state, standings.get(project.id) ?? [])
                     ? { stepFailed: true }
                     : {}),
+                ...(retry === undefined ? {} : { retryAt: retry }),
                 ...(waiting === undefined ? {} : { limitWaits: waiting.map(listingWait) }),
             },
         ];
@@ -244,7 +255,7 @@ function queued(deps) {
             return [];
         const row = deps.db
             .prepare(`SELECT projects.title, batches.created_at FROM projects, batches
-         WHERE projects.id=? AND batches.id=? AND ${liveProject()}`)
+         WHERE projects.id=? AND batches.id=? AND ${liveProject()} AND ${notTemplateSample()}`)
             .get(entry.projectId, entry.batchId);
         if (row === undefined)
             return [];

package/dist/slices/schedules/by-date.js

@@ -0,0 +1,42 @@
+/// <reference lib="esnext.temporal" />
+import { validTimeZone } from "./calendar.js";
+export function rowDate(row, dateField) {
+    const value = (row.values[dateField] ?? "").trim();
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(value))
+        return undefined;
+    try {
+        return Temporal.PlainDate.from(value, { overflow: "reject" });
+    }
+    catch {
+        return undefined;
+    }
+}
+export function designOccurrences(rows, dateField, daysBefore, time, timeZone, now) {
+    if (!validTimeZone(timeZone))
+        return [];
+    const today = Temporal.Instant.fromEpochMilliseconds(now.valueOf())
+        .toZonedDateTimeISO(timeZone)
+        .toPlainDate();
+    const wanted = Temporal.PlainTime.from(time);
+    const found = [];
+    for (const [index, row] of rows.entries()) {
+        const date = rowDate(row, dateField);
+        if (date === undefined)
+            continue;
+        const over = Temporal.PlainDate.compare(date, today) < 0;
+        const planned = date
+            .subtract({ days: daysBefore })
+            .toPlainDateTime(wanted)
+            .toZonedDateTime(timeZone, { disambiguation: "compatible" }).epochMilliseconds;
+        found.push({
+            at: new Date(over ? now.valueOf() : Math.max(planned, now.valueOf())),
+            index,
+            over,
+        });
+    }
+    // Soonest first; rows due at the same moment keep their table order.
+    return found.toSorted((a, b) => a.at.valueOf() - b.at.valueOf() || a.index - b.index);
+}
+export function nextDesignOccurrence(rows, dateField, daysBefore, time, timeZone, now) {
+    return designOccurrences(rows, dateField, daysBefore, time, timeZone, now)[0] ?? null;
+}

package/dist/slices/schedules/calendar.js

@@ -12,6 +12,11 @@ export const cadenceSchema = z.discriminatedUnion("kind", [
         days: z.array(z.number().int().min(0).max(6)).min(1).max(7).readonly(),
     })
         .strict(),
+    // A design schedule: each row of its table is made ahead of the date it holds, at this time
+    // (`by-date.ts`). Only design schedules use it, and `nextOccurrence` is never asked about it.
+    z
+        .object({ kind: z.literal("by-date"), time: z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/) })
+        .strict(),
 ]);
 export function validTimeZone(timeZone) {
     try {

package/dist/slices/schedules/design-agenda.js

@@ -0,0 +1,36 @@
+import { designOccurrences } from "./by-date.js";
+import { designPlanOf } from "./next-run.js";
+// The calendar's runs of a design schedule: one per row still to make, on the day it is made,
+// named by the row's title. A row whose date is over isn't shown; the scheduler skips it.
+export function upcomingDesignRuns(db, schedule, now, from, to) {
+    if (schedule.cadence.kind !== "by-date")
+        return [];
+    const plan = designPlanOf(db, schedule.templateId);
+    if (plan === undefined)
+        return [];
+    return designOccurrences(schedule.items, plan.dateField, plan.daysBefore, schedule.cadence.time, schedule.timezone, now)
+        .filter((one) => !one.over && one.at >= from && one.at < to)
+        .map((one) => {
+        const row = schedule.items[one.index];
+        return {
+            at: one.at.toISOString(),
+            scheduleId: schedule.id,
+            scheduleName: schedule.name,
+            scheduleVersion: schedule.version,
+            paused: schedule.status === "paused",
+            templateId: schedule.templateId,
+            templateVersion: plan.readyVersion ?? plan.headVersion,
+            templateName: plan.name,
+            index: one.index,
+            topic: row?.title ?? null,
+            topicSource: "queued",
+            renderedTitle: row?.title ?? null,
+            prepared: null,
+            templateKind: "design",
+            timezone: schedule.timezone,
+            // A design template's readiness is the designs' own (runnableDesignVersion), not the
+            // template studio's.
+            notReady: false,
+        };
+    });
+}

package/dist/slices/schedules/design-check.js

@@ -0,0 +1,41 @@
+import { designFields } from "../designs/fields.js";
+import { getTemplate } from "../designs/templates.js";
+import { rowDate } from "./by-date.js";
+import { designPlanOf } from "./next-run.js";
+export function checkDesign(deps, input) {
+    const refuse = (message) => ({ ok: false, reason: "invalid-topics", message });
+    if (input.cadence.kind !== "by-date" ||
+        input.topicGeneration.mode !== "off" ||
+        input.topicKeyword !== null ||
+        input.releases.length > 0)
+        return {
+            ok: false,
+            reason: "invalid-input",
+            message: "A poster schedule makes each row's poster ahead of its date: it has no cadence, topic generation or release days. Choose Ahead of each date.",
+        };
+    const template = getTemplate(deps.db, input.templateId);
+    if (template === undefined)
+        return { ok: false, reason: "missing-template" };
+    const plan = designPlanOf(deps.db, input.templateId);
+    if (plan === undefined)
+        return refuse(`The schedule wasn't saved. ${template.name} doesn't say which keyword holds each date. Open it from Templates → Poster templates, choose the date keyword under Schedule, save it, then save the schedule again.`);
+    const fields = designFields(plan.document);
+    const named = fields.length === 0 ? "none" : fields.map((one) => `{{${one}}}`).join(", ");
+    const problems = [];
+    for (const keyword of Object.keys(input.values))
+        if (!fields.includes(keyword))
+            problems.push(`{{${keyword}}} (for every row) is not a keyword of this template (its keywords are ${named}). Remove it.`);
+    for (const [index, row] of input.items.entries()) {
+        const where = `Row ${String(index + 1)} (${row.title})`;
+        for (const keyword of Object.keys(row.values))
+            if (!fields.includes(keyword))
+                problems.push(`${where} fills {{${keyword}}}, which this template doesn't use (its keywords are ${named}). Remove that column.`);
+        if (rowDate(row, plan.dateField) === undefined)
+            problems.push(`${where} has no date in {{${plan.dateField}}}. Write it as YYYY-MM-DD, for example 2026-11-14.`);
+    }
+    if (problems.length === 0)
+        return { ok: true, value: template.headVersion };
+    const shown = problems.slice(0, 5);
+    const more = problems.length - shown.length;
+    return refuse(`The schedule wasn't saved. ${shown.join(" ")}${more > 0 ? ` And ${String(more)} more like these.` : ""}`);
+}

package/dist/slices/schedules/design-run.js

@@ -0,0 +1,126 @@
+/// <reference lib="esnext.temporal" />
+import { transact } from "../../kernel/db/tx.js";
+import { missingValues } from "../designs/fields.js";
+import { makeFromTemplate, quoteDocument } from "../designs/template-make.js";
+import { designOccurrences } from "./by-date.js";
+import { nextOccurrence } from "./calendar.js";
+import { designPlanOf, missedGraceMs, nextRunOf } from "./next-run.js";
+import { insertRun, scheduleById, updateRun } from "./repo.js";
+// One due run of a design schedule, all at once and in one transaction: it takes the row due
+// soonest, makes its piece from the template's ready version and starts the artwork (the only
+// paid step, made in the background by the design runner), removes the row and records the
+// design on the run. Nothing here waits on a provider, so the tick moves on at once.
+//
+// A row whose date is over is removed with a skipped run that says so. A run that can't start
+// (no ready version, a value missing, over the spend limit, no image provider) keeps its row,
+// records why, and tries again at the same time the next day; marking a version ready tries
+// again at once (`refreshDesignSchedules`). None of this reaches needs_attention: it shows on
+// the schedule's runs.
+export function claimDesignRun(deps, schedule, now) {
+    const designs = deps.designs?.();
+    transact(deps.db, () => {
+        const current = scheduleById(deps.db, schedule.id);
+        if (current === undefined ||
+            current.version !== schedule.version ||
+            current.nextRunAt !== schedule.nextRunAt ||
+            current.status !== "active" ||
+            current.cadence.kind !== "by-date")
+            return;
+        const time = current.cadence.time;
+        const plan = designPlanOf(deps.db, current.templateId);
+        const due = plan === undefined
+            ? undefined
+            : designOccurrences(current.items, plan.dateField, plan.daysBefore, time, current.timezone, now)[0];
+        // Rows edited meanwhile: nothing is due yet, so only the next run moves.
+        if (plan === undefined || due === undefined || due.at > now) {
+            setNext(deps, current, nextRunOf(deps.db, current, now), current.items, now);
+            return;
+        }
+        const row = current.items[due.index];
+        if (row === undefined)
+            return;
+        const run = (status, error) => ({
+            id: deps.uuid(),
+            scheduleId: current.id,
+            scheduledFor: schedule.nextRunAt ?? now.toISOString(),
+            status,
+            requestId: null,
+            projectIds: [],
+            designIds: [],
+            estimate: null,
+            startedAt: now.toISOString(),
+            endedAt: status === "running" ? null : now.toISOString(),
+            error,
+        });
+        const without = current.items.filter((_item, index) => index !== due.index);
+        const date = row.values[plan.dateField] ?? "";
+        if (due.over) {
+            insertRun(deps.db, run("skipped", `Skipped: ${row.title} on ${date} is already over.`));
+            setNext(deps, current, nextRunOf(deps.db, { ...current, items: without }, now), without, now);
+            return;
+        }
+        const tomorrow = () => {
+            const next = nextOccurrence({ kind: "daily", time }, current.timezone, now);
+            const soonest = nextRunOf(deps.db, current, new Date(now.valueOf() + 1000));
+            return next === null ? soonest : soonest === null || soonest < next ? next : soonest;
+        };
+        const keep = (status, error) => {
+            insertRun(deps.db, run(status, error));
+            setNext(deps, current, tomorrow(), current.items, now);
+        };
+        // A run Slopify wasn't open for, like a project schedule's: skipped when the schedule skips
+        // missed runs. The row stays and is tried again at the same time the next day.
+        const scheduledFor = schedule.nextRunAt === null ? now : new Date(schedule.nextRunAt);
+        if (current.missedPolicy === "skip" && now.valueOf() - scheduledFor.valueOf() > missedGraceMs)
+            return keep("skipped", `Skipped: Slopify wasn't open at ${time} when ${row.title}'s poster was due, and this schedule skips the runs it misses. It tries again at ${time} tomorrow; to make a missed poster as soon as Slopify opens, set Missed run to Run once when Slopify reopens in Templates → Poster templates → ${plan.name} → Schedule.`);
+        if (designs === undefined)
+            return keep("failed", "Not started: designs aren't available in this copy of Slopify. Restart Slopify; if it keeps happening, reinstall it.");
+        if (plan.readyVersion === null)
+            return keep("skipped", `Not started: ${plan.name} has no version approved for schedules. Open it in Templates → Poster templates and press Approve for schedules.`);
+        const missing = missingValues(plan.document, row.values);
+        if (missing.length > 0) {
+            const list = missing.map((name) => `{{${name}}}`).join(", ");
+            return keep("failed", `Not started: ${row.title} has no ${list} in its row. Fill ${missing.length === 1 ? "it" : "them"} in under Schedules → ${current.name}; the next try is at ${time}.`);
+        }
+        const quote = quoteDocument(designs.catalogue(), plan.document);
+        if (current.spendLimitCents !== null &&
+            (quote.unknown > 0 || quote.high * 100 > current.spendLimitCents))
+            return keep("failed", `Not started: ${row.title}'s poster costs up to $${quote.high.toFixed(2)}${quote.unknown > 0 ? " and some prices are unknown" : ""}, over this schedule's spend limit. Raise the spend limit or choose an image model with a known, lower price.`);
+        const started = run("running", null);
+        if (!insertRun(deps.db, started))
+            return;
+        const made = makeFromTemplate(designs, current.templateId, {
+            mutationId: `schedule-${started.id}`,
+            values: row.values,
+            acknowledgedHigh: quote.high,
+            // A schedule with no spend limit makes pieces whose price is unknown, as it always has.
+            acknowledgedUnknown: quote.unknown > 0,
+            version: plan.readyVersion,
+            name: row.title,
+        }, { scheduleId: current.id, scheduleRunId: started.id });
+        if (!made.ok) {
+            updateRun(deps.db, {
+                ...started,
+                status: "failed",
+                endedAt: now.toISOString(),
+                error: `Not started: ${made.message}`,
+            });
+            setNext(deps, current, tomorrow(), current.items, now);
+            return;
+        }
+        updateRun(deps.db, {
+            ...started,
+            status: "succeeded",
+            designIds: [made.value.id],
+            estimate: [quote],
+            endedAt: now.toISOString(),
+        });
+        setNext(deps, current, nextRunOf(deps.db, { ...current, items: without }, now), without, now);
+    });
+}
+// A design schedule stays active when its table empties: rows added later run as they come.
+function setNext(deps, schedule, next, items, now) {
+    deps.db
+        .prepare("UPDATE schedules SET items_json=?, next_run_at=?, version=version+1, updated_at=? WHERE id=? AND version=?")
+        .run(JSON.stringify(items), next?.toISOString() ?? null, now.toISOString(), schedule.id, schedule.version);
+}

package/dist/slices/schedules/next-run.js

@@ -0,0 +1,62 @@
+import { runnableDesignVersion } from "../designs/gate.js";
+import { getTemplate } from "../designs/templates.js";
+import { nextDesignOccurrence } from "./by-date.js";
+import { nextOccurrence } from "./calendar.js";
+// How late a run may start and still count as on time; later, it was missed (Slopify was
+// closed), and a schedule that skips missed runs skips it.
+export const missedGraceMs = 60_000;
+export function designPlanOf(db, templateId) {
+    const template = getTemplate(db, templateId);
+    if (template === undefined)
+        return undefined;
+    const ready = runnableDesignVersion(db, templateId);
+    const document = ready?.document ?? template.document;
+    const schedule = document.schedule;
+    if (schedule === undefined)
+        return undefined;
+    return {
+        name: ready?.name ?? template.name,
+        dateField: schedule.dateField,
+        daysBefore: schedule.daysBefore,
+        readyVersion: ready?.version ?? null,
+        headVersion: template.headVersion,
+        document,
+    };
+}
+export function nextRunOf(db, schedule, now) {
+    if (schedule.cadence.kind !== "by-date")
+        return nextOccurrence(schedule.cadence, schedule.timezone, now);
+    const plan = designPlanOf(db, schedule.templateId);
+    if (plan === undefined)
+        return null;
+    return (nextDesignOccurrence(schedule.items, plan.dateField, plan.daysBefore, schedule.cadence.time, schedule.timezone, now)?.at ?? null);
+}
+// Every active design schedule of a template takes its next run again, for when a version is
+// marked ready or the template's dates change.
+export function refreshDesignSchedules(db, templateId, now) {
+    const rows = db
+        .prepare(`SELECT id FROM schedules WHERE template_kind='design' AND template_id=? AND status='active' AND deleted_at IS NULL`)
+        .all(templateId)
+        .map((row) => String(row.id));
+    let changed = 0;
+    for (const id of rows) {
+        const raw = db
+            .prepare("SELECT cadence_json, timezone, items_json, next_run_at FROM schedules WHERE id=?")
+            .get(id);
+        if (raw === undefined)
+            continue;
+        const next = nextRunOf(db, {
+            templateKind: "design",
+            templateId,
+            timezone: String(raw.timezone),
+            cadence: JSON.parse(String(raw.cadence_json)),
+            items: JSON.parse(String(raw.items_json)),
+        }, now);
+        const at = next?.toISOString() ?? null;
+        if (at === raw.next_run_at)
+            continue;
+        db.prepare("UPDATE schedules SET next_run_at=?, version=version+1, updated_at=? WHERE id=?").run(at, now.toISOString(), id);
+        changed += 1;
+    }
+    return changed;
+}

package/dist/slices/schedules/prepare.js

@@ -8,6 +8,7 @@ import { createDraft } from "../play-drafts/service.js";
 import { startPlayDraft } from "../play-drafts/start.js";
 import { freshTemplateDraft } from "../project-templates/setup.js";
 import { currentRevisionId } from "../revisions/repo.js";
+import { notTemplateSample } from "../template-studio/repo.js";
 import { scheduleById } from "./repo.js";
 import { renderedTitle, scheduledValues } from "./topic-list.js";
 // The draft a schedule's run starts for one topic: the template as it is now, the topic in its
@@ -43,9 +44,19 @@ export async function prepareTopic(deps, input) {
     const schedule = scheduleById(deps.db, input.scheduleId);
     if (schedule === undefined)
         return { ok: false, reason: "not-found" };
+    // A design schedule's piece is made on its day; there is no video to hold back.
+    if (schedule.templateKind === "design")
+        return { ok: false, reason: "design" };
+    // A paused schedule makes nothing, ahead or on its day.
+    if (schedule.status === "paused")
+        return { ok: false, reason: "paused" };
     const topic = schedule.items.find((item) => item.title === input.title);
     if (topic === undefined)
         return { ok: false, reason: "not-found" };
+    // Prepared ahead is the schedule's run made early: it waits for a ready version too.
+    const notReady = deps.notReady?.(schedule.templateId);
+    if (notReady !== undefined)
+        return { ok: false, reason: "not-ready", detail: notReady };
     const document = scheduledDocument(deps, schedule, topic);
     if (document === undefined)
         return { ok: false, reason: "missing-template" };
@@ -104,9 +115,13 @@ const ended = new Set(["done", "partial", "failed", "canceled"]);
 // run the same title, so only a prepared project counts there.
 export function preparedProject(db, scheduleId, title, byTitle = true) {
     const live = "project_id NOT IN (SELECT project_id FROM project_trash)";
+    // A template studio sample is titled from the template's next queued topic, so it can have
+    // the run's title; it is the studio's alone and never the run's to continue.
     const prepared = db
         .prepare(`SELECT project_id, added_checkpoint FROM prepared_videos
-       WHERE schedule_id=? AND title=? AND ${live} ORDER BY prepared_at DESC LIMIT 1`)
+       WHERE schedule_id=? AND title=? AND ${live}
+         AND ${notTemplateSample("prepared_videos", "project_id")}
+       ORDER BY prepared_at DESC LIMIT 1`)
         .get(scheduleId, title);
     // A prepared project canceled since is no video to continue: the day makes a new one.
     if (typeof prepared?.project_id === "string" &&
@@ -115,7 +130,8 @@ export function preparedProject(db, scheduleId, title, byTitle = true) {
     if (!byTitle)
         return undefined;
     for (const row of db
-        .prepare("SELECT id FROM projects WHERE title=? AND id NOT IN (SELECT project_id FROM project_trash) ORDER BY created_at DESC")
+        .prepare(`SELECT id FROM projects WHERE title=? AND id NOT IN (SELECT project_id FROM project_trash)
+         AND ${notTemplateSample()} ORDER BY created_at DESC`)
         .all(title)) {
         const id = String(row.id);
         if (!ended.has(derive(stagesOf(db, id), projectPaused(db, id))))

package/dist/slices/schedules/repo.js

@@ -4,10 +4,12 @@ import { transact } from "../../kernel/db/tx.js";
 import { derive } from "../../kernel/runner/graph.js";
 import { projectExists, projectPaused, stagesOf } from "../admission/repo.js";
 import { readStartReceipt } from "../play-drafts/start-repo.js";
+import { setupSectionNames } from "../project-templates/setup-sections.js";
 import { scheduleRunSchema, scheduleSummarySchema, } from "./schema.js";
 const rowSchema = z.object({
     id: z.string(),
     name: z.string(),
+    template_kind: z.string(),
     template_id: z.string(),
     template_version: z.number(),
     cadence_json: z.string(),
@@ -33,12 +35,13 @@ const rowSchema = z.object({
     topics_failed_at: z.string().nullable(),
     topics_error: z.string().nullable(),
     releases_json: z.string().nullable(),
+    topic_scoring: z.string(),
     held_topics: z.number(),
 });
-const scheduleColumns = `id,name,template_id,template_version,cadence_json,timezone,missed_policy,
+const scheduleColumns = `id,name,template_kind,template_id,template_version,cadence_json,timezone,missed_policy,
   overlap_policy,spend_limit_cents,items_json,topic_keyword,values_json,status,version,next_run_at,
   created_at,updated_at,deleted_at,brief,topic_mode,topic_min,topic_llm_json,topics_generating_at,
-  topics_generated_at,topics_failed_at,topics_error,releases_json,
+  topics_generated_at,topics_failed_at,topics_error,releases_json,topic_scoring,
   (SELECT count(*) FROM schedule_topics AS held
    WHERE held.schedule_id=schedules.id AND held.state='held') AS held_topics`;
 export function scheduleById(db, id) {
@@ -66,11 +69,11 @@ export function dueSchedules(db, now) {
 }
 export function insertSchedule(db, schedule, creationHash) {
     db.prepare(`INSERT INTO schedules
-      (id,name,template_id,template_version,cadence_json,timezone,missed_policy,overlap_policy,
-       spend_limit_cents,items_json,topic_keyword,values_json,status,version,creation_hash,
-       next_run_at,created_at,updated_at,deleted_at,brief,topic_mode,topic_min,topic_llm_json,
-       releases_json)
-     VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`).run(schedule.id, schedule.name, schedule.templateId, schedule.templateVersion, JSON.stringify(schedule.cadence), schedule.timezone, schedule.missedPolicy, schedule.overlapPolicy, schedule.spendLimitCents, JSON.stringify(schedule.items), schedule.topicKeyword, JSON.stringify(schedule.values), schedule.status, schedule.version, creationHash, schedule.nextRunAt, schedule.createdAt, schedule.updatedAt, schedule.deletedAt, ...generationColumns(schedule));
+      (id,name,template_kind,template_id,template_version,cadence_json,timezone,missed_policy,
+       overlap_policy,spend_limit_cents,items_json,topic_keyword,values_json,status,version,
+       creation_hash,next_run_at,created_at,updated_at,deleted_at,brief,topic_mode,topic_min,
+       topic_llm_json,releases_json,topic_scoring)
+     VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`).run(schedule.id, schedule.name, schedule.templateKind, schedule.templateId, schedule.templateVersion, JSON.stringify(schedule.cadence), schedule.timezone, schedule.missedPolicy, schedule.overlapPolicy, schedule.spendLimitCents, JSON.stringify(schedule.items), schedule.topicKeyword, JSON.stringify(schedule.values), schedule.status, schedule.version, creationHash, schedule.nextRunAt, schedule.createdAt, schedule.updatedAt, schedule.deletedAt, ...generationColumns(schedule));
 }
 function generationColumns(schedule) {
     const generation = schedule.topicGeneration;
@@ -80,18 +83,20 @@ function generationColumns(schedule) {
         generation.keepAtLeast,
         generation.llm === null ? null : JSON.stringify(generation.llm),
         schedule.releases.length === 0 ? null : JSON.stringify(schedule.releases),
+        schedule.topicScoring,
     ];
 }
 export function updateScheduleRow(db, schedule, mutationId, mutationHash, baseVersion) {
     const changed = db
-        .prepare(`UPDATE schedules SET name=?,template_id=?,template_version=?,cadence_json=?,timezone=?,
+        .prepare(`UPDATE schedules SET name=?,template_kind=?,template_id=?,template_version=?,cadence_json=?,timezone=?,
        missed_policy=?,overlap_policy=?,spend_limit_cents=?,items_json=?,topic_keyword=?,
        values_json=?,status=?,version=?,
        next_run_at=?,updated_at=?,mutation_id=?,mutation_hash=?,
-       brief=?,topic_mode=?,topic_min=?,topic_llm_json=?,releases_json=?,topics_failed_at=NULL,
+       brief=?,topic_mode=?,topic_min=?,topic_llm_json=?,releases_json=?,topic_scoring=?,
+       topics_failed_at=NULL,
        topics_error=NULL
        WHERE id=? AND version=? AND deleted_at IS NULL`)
-        .run(schedule.name, schedule.templateId, schedule.templateVersion, JSON.stringify(schedule.cadence), schedule.timezone, schedule.missedPolicy, schedule.overlapPolicy, schedule.spendLimitCents, JSON.stringify(schedule.items), schedule.topicKeyword, JSON.stringify(schedule.values), schedule.status, schedule.version, schedule.nextRunAt, schedule.updatedAt, mutationId, mutationHash, ...generationColumns(schedule), schedule.id, baseVersion);
+        .run(schedule.name, schedule.templateKind, schedule.templateId, schedule.templateVersion, JSON.stringify(schedule.cadence), schedule.timezone, schedule.missedPolicy, schedule.overlapPolicy, schedule.spendLimitCents, JSON.stringify(schedule.items), schedule.topicKeyword, JSON.stringify(schedule.values), schedule.status, schedule.version, schedule.nextRunAt, schedule.updatedAt, mutationId, mutationHash, ...generationColumns(schedule), schedule.id, baseVersion);
     return Number(changed.changes) === 1;
 }
 export function tombstoneScheduleRow(db, id, version, deletedAt) {
@@ -111,8 +116,8 @@ export function setScheduleStatus(db, id, version, status, nextRunAt, updatedAt)
 export function insertRun(db, run) {
     try {
         db.prepare(`INSERT INTO schedule_runs
-       (id,schedule_id,scheduled_for,status,request_id,project_ids_json,estimate_json,started_at,ended_at,error)
-       VALUES (?,?,?,?,?,?,?,?,?,?)`).run(run.id, run.scheduleId, run.scheduledFor, run.status, run.requestId, JSON.stringify(run.projectIds), run.estimate === null ? null : JSON.stringify(run.estimate), run.startedAt, run.endedAt, run.error);
+       (id,schedule_id,scheduled_for,status,request_id,project_ids_json,design_ids_json,estimate_json,started_at,ended_at,error)
+       VALUES (?,?,?,?,?,?,?,?,?,?,?)`).run(run.id, run.scheduleId, run.scheduledFor, run.status, run.requestId, JSON.stringify(run.projectIds), JSON.stringify(run.designIds), run.estimate === null ? null : JSON.stringify(run.estimate), run.startedAt, run.endedAt, run.error);
         return true;
     }
     catch (error) {
@@ -122,8 +127,8 @@ export function insertRun(db, run) {
     }
 }
 export function updateRun(db, run) {
-    db.prepare(`UPDATE schedule_runs SET status=?,request_id=?,project_ids_json=?,estimate_json=?,
-     ended_at=?,error=? WHERE id=?`).run(run.status, run.requestId, JSON.stringify(run.projectIds), run.estimate === null ? null : JSON.stringify(run.estimate), run.endedAt, run.error, run.id);
+    db.prepare(`UPDATE schedule_runs SET status=?,request_id=?,project_ids_json=?,design_ids_json=?,
+     estimate_json=?,ended_at=?,error=? WHERE id=?`).run(run.status, run.requestId, JSON.stringify(run.projectIds), JSON.stringify(run.designIds), run.estimate === null ? null : JSON.stringify(run.estimate), run.endedAt, run.error, run.id);
 }
 export function recordRunStartIdentity(db, run) {
     if (run.requestId === null)
@@ -174,8 +179,8 @@ function consumeTopic(db, scheduleId, used, updatedAt) {
 }
 export function runsForSchedule(db, scheduleId) {
     return db
-        .prepare(`SELECT id,schedule_id,scheduled_for,status,request_id,project_ids_json,estimate_json,
-       started_at,ended_at,error FROM schedule_runs WHERE schedule_id=? ORDER BY started_at DESC,id DESC`)
+        .prepare(`SELECT id,schedule_id,scheduled_for,status,request_id,project_ids_json,design_ids_json,
+       estimate_json,started_at,ended_at,error FROM schedule_runs WHERE schedule_id=? ORDER BY started_at DESC,id DESC`)
         .all(scheduleId)
         .map(parseRun);
 }
@@ -288,6 +293,7 @@ function parseSchedule(row) {
     return scheduleSummarySchema.parse({
         id: value.id,
         name: value.name,
+        templateKind: value.template_kind,
         templateId: value.template_id,
         templateVersion: value.template_version,
         cadence: JSON.parse(value.cadence_json),
@@ -305,6 +311,7 @@ function parseSchedule(row) {
             llm: value.topic_llm_json === null ? null : JSON.parse(value.topic_llm_json),
         },
         releases: value.releases_json === null ? [] : JSON.parse(value.releases_json),
+        topicScoring: value.topic_scoring,
         topics: {
             held: value.held_topics,
             generatingSince: value.topics_generating_at,
@@ -329,6 +336,7 @@ function parseRun(row) {
         status: z.string(),
         request_id: z.string().nullable(),
         project_ids_json: z.string(),
+        design_ids_json: z.string(),
         estimate_json: z.string().nullable(),
         started_at: z.string(),
         ended_at: z.string().nullable(),
@@ -342,6 +350,7 @@ function parseRun(row) {
         status: value.status,
         requestId: value.request_id,
         projectIds: JSON.parse(value.project_ids_json),
+        designIds: JSON.parse(value.design_ids_json),
         estimate: value.estimate_json === null ? null : JSON.parse(value.estimate_json),
         startedAt: value.started_at,
         endedAt: value.ended_at,
@@ -353,12 +362,12 @@ function parseRun(row) {
 const internalRunError = "Slopify hit an internal error while starting this run. The next run will try again; if it keeps happening, use Download diagnostics in Settings and report it.";
 const runErrors = {
     "missing-template": "The template this schedule uses was deleted or changed. Edit the schedule and choose a template again.",
-    "unsupported-media": "This template uses audio, images, a thumbnail, shorts background music or an ambient sound file you supplied, which scheduled runs cannot use. Pick a template that generates these instead, or on Play remove the music under Outputs → More shorts options (or pick Rain, Fireplace or Wind under Video and style → Ambient sound) and save the template again.",
+    "unsupported-media": `This template uses audio, images, a thumbnail, shorts background music or an ambient sound file you supplied, which scheduled runs cannot use. Pick a template that generates these instead, or open this one in Edit template, remove the music under ${setupSectionNames.shorts} (or pick Rain, Fireplace or Wind as the Ambient sound under ${setupSectionNames.video}) and save it again.`,
     "spend-limit": "Not started: the estimated cost was above this schedule's spend limit, or some prices were unknown. Raise the spend limit or choose models with known prices.",
-    readiness: "Not started: a provider was not ready, for example a missing API key, model or voice. Check Settings → Providers; the next run will try again.",
-    "not-found": "The template's settings are no longer valid, for example a prompt or voice it uses was deleted. Fix the template in Library > Templates and save it.",
-    "invalid-draft": "The template's settings are no longer valid, for example a prompt or voice it uses was deleted. Fix the template in Library > Templates and save it.",
-    "invalid-edit": "The template's settings are no longer valid, for example a prompt or voice it uses was deleted. Fix the template in Library > Templates and save it.",
+    readiness: "Not started: a provider was not ready, for example a missing API key, model or voice. Check Settings → Keys & services; the next run will try again.",
+    "not-found": "The template's settings are no longer valid, for example a prompt or voice it uses was deleted. Fix the template in Templates → Edit template and save it.",
+    "invalid-draft": "The template's settings are no longer valid, for example a prompt or voice it uses was deleted. Fix the template in Templates → Edit template and save it.",
+    "invalid-edit": "The template's settings are no longer valid, for example a prompt or voice it uses was deleted. Fix the template in Templates → Edit template and save it.",
     conflict: internalRunError,
     "pending-start": internalRunError,
     "already-started": internalRunError,