@gentbajko/slopify 2.5.0 → 3.0.0

package/dist/slices/schedules/repo.js

@@ -1,7 +1,8 @@
+import { randomUUID } from "node:crypto";
 import { z } from "zod";
 import { transact } from "../../kernel/db/tx.js";
 import { derive } from "../../kernel/runner/graph.js";
-import { projectPaused, stagesOf } from "../admission/repo.js";
+import { projectExists, projectPaused, stagesOf } from "../admission/repo.js";
 import { readStartReceipt } from "../play-drafts/start-repo.js";
 import { scheduleRunSchema, scheduleSummarySchema, } from "./schema.js";
 const rowSchema = z.object({
@@ -23,30 +24,39 @@ const rowSchema = z.object({
     created_at: z.string(),
     updated_at: z.string(),
     deleted_at: z.string().nullable(),
+    brief: z.string().nullable(),
+    topic_mode: z.string(),
+    topic_min: z.number(),
+    topic_llm_json: z.string().nullable(),
+    topics_generating_at: z.string().nullable(),
+    topics_generated_at: z.string().nullable(),
+    topics_failed_at: z.string().nullable(),
+    topics_error: z.string().nullable(),
+    held_topics: z.number(),
 });
+const scheduleColumns = `id,name,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,
+  (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) {
     const row = db
-        .prepare(`SELECT id,name,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
+        .prepare(`SELECT ${scheduleColumns}
        FROM schedules WHERE id=?`)
         .get(id);
     return row === undefined ? undefined : parseSchedule(row);
 }
 export function scheduleRows(db) {
     return db
-        .prepare(`SELECT id,name,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
+        .prepare(`SELECT ${scheduleColumns}
        FROM schedules ORDER BY created_at DESC,id`)
         .all()
         .map(parseSchedule);
 }
 export function dueSchedules(db, now) {
     return db
-        .prepare(`SELECT id,name,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
+        .prepare(`SELECT ${scheduleColumns}
        FROM schedules WHERE deleted_at IS NULL AND status='active' AND next_run_at IS NOT NULL
        AND next_run_at <= ?
        ORDER BY next_run_at,id`)
@@ -57,17 +67,27 @@ 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)
-     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);
+       next_run_at,created_at,updated_at,deleted_at,brief,topic_mode,topic_min,topic_llm_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));
+}
+function generationColumns(schedule) {
+    const generation = schedule.topicGeneration;
+    return [
+        schedule.brief,
+        generation.mode,
+        generation.keepAtLeast,
+        generation.llm === null ? null : JSON.stringify(generation.llm),
+    ];
 }
 export function updateScheduleRow(db, schedule, mutationId, mutationHash, baseVersion) {
     const changed = db
         .prepare(`UPDATE schedules SET name=?,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=?
+       next_run_at=?,updated_at=?,mutation_id=?,mutation_hash=?,
+       brief=?,topic_mode=?,topic_min=?,topic_llm_json=?,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, schedule.id, baseVersion);
+        .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);
     return Number(changed.changes) === 1;
 }
 export function tombstoneScheduleRow(db, id, version, deletedAt) {
@@ -138,7 +158,13 @@ function consumeTopic(db, scheduleId, used, updatedAt) {
     if (at === -1)
         return;
     const items = schedule.items.filter((_item, index) => index !== at);
-    const done = items.length === 0 && (schedule.status === "active" || schedule.status === "paused");
+    // A schedule that finds its own topics keeps going when its queue empties.
+    const done = items.length === 0 &&
+        schedule.topicGeneration.mode === "off" &&
+        (schedule.status === "active" || schedule.status === "paused");
+    // Remembered so topic generation never suggests it again.
+    db.prepare(`INSERT INTO schedule_topics (id,schedule_id,title,state,rank,created_at,decided_at)
+     VALUES (?,?,?,'used',0,?,?)`).run(randomUUID(), scheduleId, used.title, updatedAt, updatedAt);
     db.prepare(`UPDATE schedules SET items_json=?,status=?,next_run_at=?,version=version+1,updated_at=?
      WHERE id=? AND deleted_at IS NULL`).run(JSON.stringify(items), done ? "completed" : schedule.status, done ? null : schedule.nextRunAt, updatedAt, scheduleId);
 }
@@ -217,10 +243,11 @@ export function settleTerminalScheduleRuns(db, settledAt) {
     });
 }
 function projectIsActive(db, projectId) {
-    if (db.prepare("SELECT 1 FROM projects WHERE id=?").get(projectId) === undefined)
+    // A project in the trash takes no part in a schedule's overlap: it cannot run there.
+    if (!projectExists(db, projectId))
         return false;
     const state = derive(stagesOf(db, projectId), projectPaused(db, projectId));
-    return state !== "done" && state !== "failed" && state !== "canceled";
+    return state !== "done" && state !== "partial" && state !== "failed" && state !== "canceled";
 }
 export function recoverRunningRuns(db, endedAt, error = "Slopify was closed while this run was in progress. Check its video in Projects; the next run will go ahead as planned.") {
     return transact(db, () => {
@@ -267,6 +294,19 @@ function parseSchedule(row) {
         items: JSON.parse(value.items_json),
         topicKeyword: value.topic_keyword,
         values: JSON.parse(value.values_json),
+        brief: value.brief,
+        topicGeneration: {
+            mode: value.topic_mode,
+            keepAtLeast: value.topic_min,
+            llm: value.topic_llm_json === null ? null : JSON.parse(value.topic_llm_json),
+        },
+        topics: {
+            held: value.held_topics,
+            generatingSince: value.topics_generating_at,
+            generatedAt: value.topics_generated_at,
+            failedAt: value.topics_failed_at,
+            error: value.topics_error,
+        },
         status: value.status,
         version: value.version,
         nextRunAt: value.next_run_at,
@@ -308,7 +348,7 @@ 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 or shorts background music you supplied, which scheduled runs cannot use. Pick a template that generates these instead, or remove the music under Outputs → Export → More shorts options on Play 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 on Play remove the music under Outputs → Export → More shorts options (or pick Rain, Fireplace or Wind under Outputs → Export → Ambient sound) and save the template 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.",

package/dist/slices/schedules/scheduler.js

@@ -1,21 +1,62 @@
 import { transact } from "../../kernel/db/tx.js";
-import { render } from "../admission/substitute.js";
 import { reviewDraft } from "../play-drafts/review.js";
 import { createDraft } from "../play-drafts/service.js";
 import { startPlayDraft } from "../play-drafts/start.js";
 import { freshTemplateDraft } from "../project-templates/setup.js";
 import { nextOccurrence } from "./calendar.js";
-import { activeRun, dueSchedules, insertRun, recordRunDispatch, recordRunStartIdentity, recoverRunningRuns, scheduleById, updateRun, } from "./repo.js";
+import { activeRun, dueSchedules, insertRun, recordRunDispatch, recordRunStartIdentity, recoverRunningRuns, scheduleById, scheduleRows, updateRun, } from "./repo.js";
+import { renderedTitle, scheduledValues } from "./topic-list.js";
+import { generateTopics, generationDue, releaseTopicLeases } from "./topics.js";
 const missedGraceMs = 60_000;
 export function createScheduleRunner(deps) {
     let ticking = false;
+    // ceiling: one entry per schedule generating now.
+    const generations = new Set();
+    const stopping = new AbortController();
+    const generated = async () => {
+        while (generations.size > 0)
+            await Promise.allSettled([...generations]);
+    };
+    // Topic generation can take minutes, so a tick starts it and moves on: another schedule's
+    // run is never late because of it. The lease inside `generateTopics` is what keeps it to
+    // one at a time per schedule.
+    const start = (scheduleId, force) => {
+        if (stopping.signal.aborted)
+            return;
+        const running = generateTopics(deps, scheduleId, { signal: stopping.signal, force })
+            .then((result) => {
+            if (!result.ok && result.reason === "failed")
+                deps.log.write("warn", "schedule.topics", { detail: result.message });
+        })
+            .catch(() => {
+            deps.log.write("error", "schedule.topics", {
+                detail: "Topic generation could not record its result.",
+            });
+        })
+            .finally(() => {
+            generations.delete(running);
+        });
+        generations.add(running);
+    };
+    const startGenerations = (now) => {
+        for (const schedule of scheduleRows(deps.db))
+            if (generationDue(schedule, now))
+                start(schedule.id, false);
+    };
     return {
+        generated,
+        requestTopics: (scheduleId) => start(scheduleId, true),
+        stop: async () => {
+            stopping.abort();
+            await generated();
+        },
         tick: async (now = deps.clock.now()) => {
             if (ticking)
                 return;
             ticking = true;
             try {
                 recoverRunningRuns(deps.db, now.toISOString(), "The previous schedule tick could not record this run's result.");
+                startGenerations(now);
                 const due = dueSchedules(deps.db, now.toISOString());
                 const claimed = due.flatMap((schedule) => claim(deps, schedule, now));
                 const settled = await Promise.allSettled(claimed.map((entry) => execute(deps, entry)));
@@ -27,7 +68,10 @@ export function createScheduleRunner(deps) {
                 ticking = false;
             }
         },
-        recover: (now = deps.clock.now()) => recoverRunningRuns(deps.db, now.toISOString()),
+        recover: (now = deps.clock.now()) => {
+            releaseTopicLeases(deps);
+            return recoverRunningRuns(deps.db, now.toISOString());
+        },
     };
 }
 function claim(deps, schedule, now) {
@@ -47,7 +91,11 @@ function claim(deps, schedule, now) {
             current.status !== "active")
             return [];
         const overlapping = activeRun(deps.db, schedule.id, now.toISOString());
-        const skip = occurrence || overlapping;
+        // A schedule that finds its own topics never runs the template without one.
+        const noTopic = current.topicGeneration.mode !== "off" && current.items.length === 0
+            ? noTopicReason(current)
+            : null;
+        const skip = occurrence || overlapping || noTopic !== null;
         const run = {
             id: deps.uuid(),
             scheduleId: schedule.id,
@@ -61,7 +109,9 @@ function claim(deps, schedule, now) {
             error: skip
                 ? overlapping
                     ? "Skipped because the previous run of this schedule was still going."
-                    : "Skipped because Slopify was not running at the scheduled time."
+                    : occurrence
+                        ? "Skipped because Slopify was not running at the scheduled time."
+                        : noTopic
                 : null,
         };
         if (!insertRun(deps.db, run))
@@ -72,6 +122,14 @@ function claim(deps, schedule, now) {
         return skip ? [] : [{ run, schedule }];
     });
 }
+function noTopicReason(schedule) {
+    const { held, error } = schedule.topics;
+    if (held > 0)
+        return `Skipped because no topic was approved: ${String(held)} ${held === 1 ? "topic is" : "topics are"} waiting for you. Approve them under Schedules → ${schedule.name} → Topics waiting.`;
+    if (error !== null)
+        return `Skipped because the topic queue was empty. ${error}`;
+    return "Skipped because the topic queue was empty and new topics were still being generated. The next run uses the first one.";
+}
 async function execute(deps, claimed) {
     let run = claimed.run;
     try {
@@ -139,18 +197,11 @@ async function execute(deps, claimed) {
 // same keywords, so "D&D Lore: {{Topic}}" names the project after the topic. A topic saved
 // before topics had a keyword brings its own title and values instead.
 function runForm(form, schedule, topic) {
-    const values = {
-        ...form.values,
-        ...schedule.values,
-        ...(topic?.values ?? {}),
-        ...(topic !== undefined && schedule.topicKeyword !== null
-            ? { [schedule.topicKeyword]: topic.title }
-            : {}),
+    return {
+        ...form,
+        title: renderedTitle(form, schedule, topic),
+        values: scheduledValues(form, schedule, topic),
     };
-    const title = topic !== undefined && schedule.topicKeyword === null
-        ? topic.title
-        : render(form.title, values);
-    return { ...form, title, values };
 }
 class ScheduleDispatchError extends Error {
     reason;

package/dist/slices/schedules/schema.js

@@ -1,4 +1,6 @@
 import { z } from "zod";
+import { projectStates } from "../../kernel/pipeline.js";
+import { thinkingModes } from "../../kernel/ports/llm.js";
 import { cadenceSchema, validTimeZone } from "./calendar.js";
 const id = z.uuid();
 const keywordName = z
@@ -9,14 +11,58 @@ const keywordName = z
 const values = z.record(keywordName, z.string().max(10000)).readonly();
 // A queued topic. Each run takes the first one and removes it once its project starts.
 // `values` is only filled on schedules saved before topics had one keyword.
+export const topicTitleSchema = z.string().trim().min(1).max(200);
 const item = z
     .object({
-    title: z.string().trim().min(1).max(200),
+    title: topicTitleSchema,
     values,
 })
     .strict()
     .readonly();
 const policy = z.enum(["skip", "run-once"]);
+export const topicModes = ["off", "queue", "hold"];
+export const topicMinDefault = 10;
+export const briefMax = 4000;
+// Whether a schedule asks an LLM for topics when its queue runs low, and whether they join the
+// queue at once or wait for approval. `llm` is null for the template's own LLM.
+export const topicGenerationSchema = z
+    .object({
+    mode: z.enum(topicModes),
+    keepAtLeast: z.number().int().min(1).max(100),
+    llm: z
+        .object({
+        provider: z.string().min(1).max(100),
+        model: z.string().min(1).max(200),
+        thinking: z.enum(thinkingModes).optional(),
+    })
+        .strict()
+        .readonly()
+        .nullable(),
+})
+    .strict()
+    .readonly();
+export const topicGenerationOff = {
+    mode: "off",
+    keepAtLeast: topicMinDefault,
+    llm: null,
+};
+const topicState = z
+    .object({
+    held: z.number().int().nonnegative(),
+    generatingSince: z.string().nullable(),
+    generatedAt: z.string().nullable(),
+    failedAt: z.string().nullable(),
+    error: z.string().nullable(),
+})
+    .strict()
+    .readonly();
+export const topicStateIdle = {
+    held: 0,
+    generatingSince: null,
+    generatedAt: null,
+    failedAt: null,
+    error: null,
+};
 // Enough for a year of daily runs, pasted as one list.
 export const queueMax = 500;
 export const scheduleCreateSchema = z
@@ -39,6 +85,10 @@ export const scheduleCreateSchema = z
     topicKeyword: keywordName.nullable().default(null),
     // Keywords every run uses as they are, such as the word counts.
     values: values.default({}),
+    // What the channel covers, its style and what makes a topic worth watching. Only topic
+    // generation reads it.
+    brief: z.string().trim().max(briefMax).nullable().default(null),
+    topicGeneration: topicGenerationSchema.default(topicGenerationOff),
 })
     .strict()
     .readonly();
@@ -69,6 +119,11 @@ export const scheduleSummarySchema = z
     items: z.array(item).readonly(),
     topicKeyword: z.string().nullable().default(null),
     values: values.default({}),
+    brief: z.string().nullable().default(null),
+    topicGeneration: topicGenerationSchema.default(topicGenerationOff),
+    // The generation's own state: how many topics wait for approval, whether an LLM is being
+    // asked now, and the last failure's plain reason (cleared by the next success).
+    topics: topicState.default(topicStateIdle),
     status: z.enum(["active", "paused", "completed", "canceled"]),
     version: z.number().int().positive(),
     nextRunAt: z.string().datetime({ offset: true }).nullable(),
@@ -93,3 +148,85 @@ export const scheduleRunSchema = z
 })
     .strict()
     .readonly();
+export const heldTopicSchema = z
+    .object({ id, title: z.string(), rank: z.number().int(), createdAt: z.string() })
+    .strict()
+    .readonly();
+// Reordering is by position against the version the person saw, so a run taking the first
+// topic meanwhile makes the move refuse instead of moving the wrong one.
+export const topicMoveSchema = z
+    .object({
+    baseVersion: z.number().int().positive(),
+    from: z.number().int().nonnegative(),
+    to: z.number().int().nonnegative(),
+})
+    .strict()
+    .readonly();
+// The calendar: what will run, what is running or finished, and what waits in the batch queue.
+// `topicSource` says where a run's topic comes from: the queue (`topic` names it), topics held
+// for approval, a generation still to come, or none (the template as saved).
+export const calendarRunSchema = z
+    .object({
+    at: z.string(),
+    scheduleId: id,
+    scheduleName: z.string(),
+    scheduleVersion: z.number().int().positive(),
+    paused: z.boolean(),
+    templateId: id,
+    templateVersion: z.number().int().positive(),
+    templateName: z.string().nullable(),
+    // The topic's position in the schedule's queue, for reordering; null without one.
+    index: z.number().int().nonnegative().nullable(),
+    topic: z.string().nullable(),
+    topicSource: z.enum(["queued", "held", "generated", "template"]),
+    // The project title this run will get, the way the scheduler builds it; null when it can't
+    // be known yet (a topic still to be approved or generated, or a deleted template). Older
+    // servers leave it out.
+    renderedTitle: z.string().nullable().default(null),
+})
+    .strict()
+    .readonly();
+export const calendarProjectSchema = z
+    .object({
+    id: z.string(),
+    title: z.string(),
+    state: z.enum(projectStates),
+    createdAt: z.string(),
+    finishedAt: z.string().nullable(),
+    scheduleId: z.string().nullable(),
+})
+    .strict()
+    .readonly();
+export const calendarQueuedSchema = z
+    .object({
+    projectId: z.string(),
+    title: z.string(),
+    batchId: z.string(),
+    position: z.number().int(),
+    state: z.enum(["queued", "active"]),
+    queuedAt: z.string(),
+})
+    .strict()
+    .readonly();
+export const calendarSchema = z
+    .object({
+    from: z.string(),
+    to: z.string(),
+    runs: z.array(calendarRunSchema).readonly(),
+    projects: z.array(calendarProjectSchema).readonly(),
+    queued: z.array(calendarQueuedSchema).readonly(),
+})
+    .strict()
+    .readonly();
+// A calendar covers at most this many days per request.
+export const calendarMaxDays = 92;
+export const topicTransferSchema = z
+    .object({
+    baseVersion: z.number().int().positive(),
+    index: z.number().int().nonnegative(),
+    targetId: id,
+    // Where it lands in the other schedule's queue; the end when left out.
+    position: z.number().int().nonnegative().optional(),
+})
+    .strict()
+    .readonly();

package/dist/slices/schedules/service.js

@@ -3,7 +3,8 @@ import { transact } from "../../kernel/db/tx.js";
 import { requestHash } from "../play-drafts/repo.js";
 import { nextOccurrence } from "./calendar.js";
 import { insertSchedule, runsForSchedule, scheduleById, scheduleRows, setScheduleStatus, tombstoneScheduleRow, updateScheduleRow, } from "./repo.js";
-import { scheduleControlSchema, scheduleCreateSchema, scheduleDeleteSchema, scheduleUpdateSchema, } from "./schema.js";
+import { scheduleControlSchema, scheduleCreateSchema, scheduleDeleteSchema, scheduleUpdateSchema, topicStateIdle, } from "./schema.js";
+import { templateKeywords, topicRowProblems } from "./topic-list.js";
 export function listSchedules(deps) {
     return scheduleRows(deps.db);
 }
@@ -37,6 +38,9 @@ export function createSchedule(deps, input) {
         const checked = checkTemplate(deps, parsed.data.templateId, parsed.data.templateVersion);
         if (!checked.ok)
             return checked;
+        const topics = checkTopics(deps, parsed.data, []);
+        if (!topics.ok)
+            return topics;
         const now = deps.clock.now();
         const next = nextOccurrence(parsed.data.cadence, parsed.data.timezone, now);
         if (next === null)
@@ -76,13 +80,18 @@ export function updateSchedule(deps, input) {
         const checked = checkTemplate(deps, parsed.data.templateId, parsed.data.templateVersion);
         if (!checked.ok)
             return checked;
+        const topics = checkTopics(deps, parsed.data, previous.items);
+        if (!topics.ok)
+            return topics;
         const now = deps.clock.now();
         const next = previous.status === "active"
             ? nextOccurrence(parsed.data.cadence, parsed.data.timezone, now)
             : previous.nextRunAt === null
                 ? null
                 : nextOccurrence(parsed.data.cadence, parsed.data.timezone, now);
-        const value = summary(parsed.data, next?.toISOString() ?? null, now.toISOString(), previous.status, previous.version + 1);
+        const value = summary(parsed.data, next?.toISOString() ?? null, now.toISOString(), previous.status, previous.version + 1, 
+        // Saving clears a recorded generation failure, so the next tick tries again.
+        { ...previous.topics, failedAt: null, error: null });
         if (!updateScheduleRow(deps.db, value, parsed.data.mutationId, hash, parsed.data.baseVersion))
             return { ok: false, reason: "conflict" };
         return { ok: true, value };
@@ -154,14 +163,41 @@ function checkTemplate(deps, id, version) {
     const mediaSources = ["audio", "images", "thumbnail"];
     const { form } = template.document;
     // A supplied file is attached again on Play, which a scheduled run cannot do; the shorts'
-    // background music is one too.
+    // background music is one too, and so is the ambient bed's own file.
     if (mediaSources.some((kind) => sources[kind] === "provide") ||
         (form.shorts?.enabled === true && form.provided.shortsMusic) ||
+        form.ambientBed?.source === "upload" ||
         (sources.images === "generate" && form.reference?.source === "provide"))
         return { ok: false, reason: "unsupported-media" };
     return { ok: true, value: true };
 }
-function summary(input, nextRunAt, now, status = "active", version = 1) {
+// The queue's keywords must be the template's: a topic (or an every-run value) naming a keyword
+// the template doesn't use would silently do nothing. Topics saved before, unchanged, are left
+// alone, so a queue from before this check still saves.
+function checkTopics(deps, input, kept) {
+    const template = deps.template(input.templateId, input.templateVersion);
+    if (!template)
+        return { ok: false, reason: "missing-template" };
+    const keywords = templateKeywords(template.document.form);
+    const named = keywords.length === 0 ? "none" : keywords.map((one) => `“${one}”`).join(", ");
+    const problems = [];
+    if (input.topicKeyword !== null && !keywords.includes(input.topicKeyword))
+        problems.push(`The topic keyword “${input.topicKeyword}” is not in this template (its keywords are ${named}). Pick another under Each topic fills.`);
+    for (const keyword of Object.keys(input.values))
+        if (!keywords.includes(keyword))
+            problems.push(`“${keyword}” (for every run) is not a keyword of this template (its keywords are ${named}). Remove it, or pick the template that uses it.`);
+    problems.push(...topicRowProblems(input.items, { keywords, topicKeyword: input.topicKeyword, kept }));
+    if (problems.length === 0)
+        return { ok: true, value: true };
+    const shown = problems.slice(0, 5);
+    const more = problems.length - shown.length;
+    return {
+        ok: false,
+        reason: "invalid-topics",
+        message: `The schedule wasn't saved. ${shown.join(" ")}${more > 0 ? ` And ${String(more)} more like these.` : ""}`,
+    };
+}
+function summary(input, nextRunAt, now, status = "active", version = 1, topics = topicStateIdle) {
     return {
         id: input.id,
         name: input.name,
@@ -175,6 +211,9 @@ function summary(input, nextRunAt, now, status = "active", version = 1) {
         items: input.items,
         topicKeyword: input.topicKeyword,
         values: input.values,
+        brief: input.brief === null || input.brief === "" ? null : input.brief,
+        topicGeneration: input.topicGeneration,
+        topics,
         status,
         version,
         nextRunAt,

package/dist/slices/schedules/similar.js

@@ -0,0 +1,90 @@
+// Near-duplicate checks for generated topics. Pure, so the web bundle can import it too.
+//
+// Two topics are the same when, after normalising (accents dropped, lower case, punctuation
+// to spaces, "&" read as "and"):
+// - the texts are equal, or
+// - their word sets overlap by at least `jaccardMin` (shared words / all words), or
+// - one's words all appear in the other's and cover at least `containmentMin` of it
+//   ("Tiamat" and "Tiamat's Lair" are one video; "Red Dragons" and "Blue Dragons" are two).
+// Words are compared without filler words ("the", "of", …) and without a plural "s".
+// A project title is compared more loosely: every word of the topic appearing in it is enough,
+// because the title wraps the topic in the template's own words ("D&D Lore: Tiamat").
+export const jaccardMin = 0.6;
+export const containmentMin = 0.5;
+const filler = new Set([
+    "a",
+    "an",
+    "the",
+    "of",
+    "and",
+    "or",
+    "in",
+    "on",
+    "to",
+    "for",
+    "with",
+    "vs",
+    "s",
+]);
+export function normaliseTopic(text) {
+    return text
+        .normalize("NFKD")
+        .replace(/\p{M}/gu, "")
+        .toLowerCase()
+        .replace(/&/g, " and ")
+        .replace(/[^\p{L}\p{N}]+/gu, " ")
+        .trim();
+}
+export function topicWords(text) {
+    const words = normaliseTopic(text)
+        .split(" ")
+        .filter((word) => word !== "" && !filler.has(word))
+        .map((word) => word.length > 3 && word.endsWith("s") && !word.endsWith("ss") ? word.slice(0, -1) : word);
+    return new Set(words);
+}
+function shared(a, b) {
+    let count = 0;
+    for (const word of a)
+        if (b.has(word))
+            count += 1;
+    return count;
+}
+export function similarTopics(a, b) {
+    const left = normaliseTopic(a);
+    const right = normaliseTopic(b);
+    if (left === right)
+        return left !== "";
+    const wa = topicWords(a);
+    const wb = topicWords(b);
+    if (wa.size === 0 || wb.size === 0)
+        return false;
+    const common = shared(wa, wb);
+    if (common / (wa.size + wb.size - common) >= jaccardMin)
+        return true;
+    const small = Math.min(wa.size, wb.size);
+    const large = Math.max(wa.size, wb.size);
+    return common === small && small / large >= containmentMin;
+}
+// A topic already made as a project: all of its words appear in the project's title.
+export function topicInTitle(topic, title) {
+    if (similarTopics(topic, title))
+        return true;
+    const words = topicWords(topic);
+    if (words.size === 0)
+        return false;
+    return shared(words, topicWords(title)) === words.size;
+}
+// Keeps the candidates that are new, in their order, dropping repeats among themselves too.
+export function newTopics(candidates, known) {
+    const kept = [];
+    for (const candidate of candidates) {
+        if (known.topics.some((topic) => similarTopics(candidate, topic)))
+            continue;
+        if (known.projects.some((title) => topicInTitle(candidate, title)))
+            continue;
+        if (kept.some((topic) => similarTopics(candidate, topic)))
+            continue;
+        kept.push(candidate);
+    }
+    return kept;
+}