@gentbajko/slopify 2.5.0 → 3.0.0

package/dist/slices/schedules/topic-list.js

@@ -0,0 +1,163 @@
+import { parse, stringify } from "yaml";
+import { detectSlots, render } from "../admission/substitute.js";
+// The longest value one topic may give a keyword. Word counts, names and short notes fit;
+// anything longer belongs in the template.
+export const topicValueMax = 2000;
+export const topicTitleMax = 200;
+// A template's keywords: those its project title names plus those it stores a value for (Play
+// stores one for every keyword its prompts use).
+export function templateKeywords(form) {
+    return [...new Set([...detectSlots(form.title).names, ...Object.keys(form.values)])];
+}
+// The project title a run gets, exactly as the scheduler builds it: the template's values, the
+// schedule's every-run values, the topic's own values, then the topic in its keyword. Without
+// a topic keyword the topic is the whole title.
+export function scheduledValues(form, schedule, topic) {
+    return {
+        ...form.values,
+        ...schedule.values,
+        ...(topic?.values ?? {}),
+        ...(topic !== undefined && schedule.topicKeyword !== null
+            ? { [schedule.topicKeyword]: topic.title }
+            : {}),
+    };
+}
+export function renderedTitle(form, schedule, topic) {
+    return topic !== undefined && schedule.topicKeyword === null
+        ? topic.title
+        : render(form.title, scheduledValues(form, schedule, topic));
+}
+const quote = (name) => `“${name}”`;
+const listed = (names) => names.length === 0 ? "none" : names.map(quote).join(", ");
+function rowName(index, title) {
+    return title === "" ? `Topic ${String(index + 1)}` : `Topic ${String(index + 1)} (${title})`;
+}
+// What is wrong with a queue, one plain sentence per problem naming the row and the key.
+// `keywords` are the template's; `required` must be set on every row (keywords with no
+// every-run value); an item equal to one in `kept` (the saved queue) is not checked again, so
+// a topic saved before these rules keeps working until it is edited.
+export function topicRowProblems(rows, options) {
+    const problems = [];
+    const kept = new Set((options.kept ?? []).map((row) => key(row)));
+    rows.forEach((row, index) => {
+        if (kept.has(key(row)))
+            return;
+        const name = rowName(index, row.title.trim());
+        if (row.title.trim() === "")
+            problems.push(options.topicKeyword === null
+                ? `${name} has no title. Write one, or remove the row.`
+                : `${name} has no ${quote(options.topicKeyword)}, the keyword each topic fills. Write one, or remove the row.`);
+        else if (row.title.trim().length > topicTitleMax)
+            problems.push(`${name} is ${String(row.title.trim().length)} characters; a topic can be at most ${String(topicTitleMax)}. Shorten it.`);
+        for (const [keyword, value] of Object.entries(row.values)) {
+            if (!options.keywords.includes(keyword))
+                problems.push(`${name}: ${quote(keyword)} is not a keyword of this template (its keywords are ${listed(options.keywords)}). Rename it to one of them or remove it.`);
+            else if (value.length > topicValueMax)
+                problems.push(`${name}: ${quote(keyword)} is ${String(value.length)} characters; a topic's value can be at most ${String(topicValueMax)}. Shorten it, or put the long text in the template.`);
+        }
+        for (const keyword of options.required ?? []) {
+            if (keyword === options.topicKeyword)
+                continue;
+            if ((row.values[keyword] ?? "").trim() === "")
+                problems.push(`${name} has no ${quote(keyword)}, and there is no every-run value to fall back on. Give this topic one, or fill ${quote(keyword)} for every run.`);
+        }
+    });
+    return problems;
+}
+function key(row) {
+    return JSON.stringify([
+        row.title,
+        Object.entries(row.values).sort(([a], [b]) => a.localeCompare(b)),
+    ]);
+}
+// One topic per line. A line whose text matches a row already in the queue keeps that row's
+// values (first unused match), so switching to lines and back loses nothing.
+export function rowsFromLines(text, previous) {
+    const unused = [...previous];
+    return text
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line !== "")
+        .map((title) => {
+        const at = unused.findIndex((row) => row.title === title);
+        if (at === -1)
+            return { title, values: {} };
+        const [row] = unused.splice(at, 1);
+        return row ?? { title, values: {} };
+    });
+}
+export function linesFromRows(rows) {
+    return rows.map((row) => row.title).join("\n");
+}
+// The YAML / JSON list: each item is a map of keyword to value, or a plain string (the topic).
+// JSON is YAML, so a JSON array reads the same way. Numbers and yes/no are read as the text
+// they were written as; lists, maps and multi-document files are refused.
+export function parseTopicList(text, options) {
+    if (text.trim() === "")
+        return { ok: true, rows: [] };
+    let data;
+    try {
+        // Every scalar as the string it was written as: "12000", "yes", "0012".
+        data = parse(text, { schema: "failsafe", uniqueKeys: true });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message.split("\n")[0] : "";
+        return {
+            ok: false,
+            problems: [
+                `The list couldn't be read as YAML or JSON: ${message ?? ""}. Write one item per topic, such as "- Topic: Tiamat".`,
+            ],
+        };
+    }
+    if (!Array.isArray(data))
+        return {
+            ok: false,
+            problems: [
+                'The list must be a list of topics: start each one with "- " in YAML, or wrap them in [ ] in JSON.',
+            ],
+        };
+    const problems = [];
+    const rows = [];
+    data.forEach((item, index) => {
+        const name = `Topic ${String(index + 1)}`;
+        if (typeof item === "string") {
+            rows.push({ title: item.trim(), values: {} });
+            return;
+        }
+        if (item === null || typeof item !== "object" || Array.isArray(item)) {
+            problems.push(`${name} is not a topic or a set of keywords. Write it as "- Tiamat" or "- Topic: Tiamat".`);
+            return;
+        }
+        let title = "";
+        const values = {};
+        for (const [written, value] of Object.entries(item)) {
+            const keyword = written.trim();
+            // "Topic:" with nothing after it reads as no value.
+            const raw = value ?? "";
+            if (typeof raw !== "string") {
+                problems.push(`${name}: ${quote(keyword)} holds a list or a map. Give it one value, such as "${keyword}: 12000".`);
+                continue;
+            }
+            if (options.topicKeyword !== null && keyword === options.topicKeyword)
+                title = raw.trim();
+            else if (!options.keywords.includes(keyword))
+                problems.push(`${name}: ${quote(keyword)} is not a keyword of this template (its keywords are ${listed(options.keywords)}). Rename it to one of them or remove it.`);
+            else
+                values[keyword] = raw.trim();
+        }
+        rows.push({ title, values });
+    });
+    // Unknown keys were left out of the rows above, so these name the other problems once.
+    const all = [...problems, ...topicRowProblems(rows, options)];
+    return all.length > 0 ? { ok: false, problems: all } : { ok: true, rows };
+}
+// The queue as YAML: a plain "- title" when a topic sets nothing else, else a map with the
+// topic keyword first. Reading it back with parseTopicList gives the same rows.
+export function formatTopicList(rows, topicKeyword) {
+    if (rows.length === 0)
+        return "";
+    const items = rows.map((row) => Object.keys(row.values).length === 0 || topicKeyword === null
+        ? row.title
+        : { [topicKeyword]: row.title, ...row.values });
+    return stringify(items, { lineWidth: 0 });
+}

package/dist/slices/schedules/topics.js

@@ -0,0 +1,422 @@
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { liveProject } from "../admission/repo.js";
+import { scheduleChannel } from "../channels/repo.js";
+import { channelVideoTitles } from "../channels/videos.js";
+import { scheduleById } from "./repo.js";
+import { heldTopicSchema, queueMax, topicMoveSchema, topicTitleSchema, topicTransferSchema, } from "./schema.js";
+import { newTopics } from "./similar.js";
+// A schedule that finds its own topics asks an LLM whenever its queue holds fewer than
+// `keepAtLeast`. Only one generation per schedule runs at a time: a lease on the schedule row
+// (`topics_generating_at`) is taken before the LLM is asked and cleared after, so a tick and a
+// "Generate topics now" press cannot both ask. A lease older than `leaseMs` belongs to a
+// generation that died with the process and is taken over.
+export const generationTimeoutMs = 10 * 60_000;
+const leaseMs = generationTimeoutMs + 5 * 60_000;
+// A failure is recorded on the schedule and the next tick after this long tries again, so a
+// signed-out CLI or a bad answer is not asked again every 15 seconds.
+export const generationRetryMs = 5 * 60_000;
+// Asked for on top of what is missing, so the duplicates dropped still leave enough.
+const spare = 5;
+const askMax = 50;
+// The prompt lists every title; this only bounds a pathological library.
+const knownMax = 5000;
+export function generationWanted(schedule) {
+    const generation = schedule.topicGeneration;
+    if (generation.mode === "off")
+        return 0;
+    const waiting = schedule.items.length + (generation.mode === "hold" ? schedule.topics.held : 0);
+    return Math.max(0, Math.min(generation.keepAtLeast, queueMax) - waiting);
+}
+// Whether a tick should start a generation for this schedule now.
+export function generationDue(schedule, now) {
+    if (schedule.deletedAt !== null || schedule.status !== "active")
+        return false;
+    if (generationWanted(schedule) === 0)
+        return false;
+    if (schedule.topics.generatingSince !== null && !stale(schedule.topics.generatingSince, now))
+        return false;
+    return (schedule.topics.failedAt === null ||
+        now.valueOf() - new Date(schedule.topics.failedAt).valueOf() >= generationRetryMs);
+}
+function stale(since, now) {
+    return now.valueOf() - new Date(since).valueOf() >= leaseMs;
+}
+// `force` is the "Generate topics now" button: it ignores the retry wait and asks for a few
+// even when the queue is full.
+export async function generateTopics(deps, scheduleId, options = {}) {
+    const now = deps.clock.now();
+    const claimed = transact(deps.db, () => {
+        const schedule = scheduleById(deps.db, scheduleId);
+        if (schedule === undefined || schedule.deletedAt !== null)
+            return { ok: false, reason: "not-found", message: "This schedule no longer exists." };
+        if (schedule.topicGeneration.mode === "off")
+            return {
+                ok: false,
+                reason: "off",
+                message: "Topic generation is off for this schedule. Turn it on under Edit → Topic generation.",
+            };
+        if (schedule.status === "canceled" || schedule.status === "completed")
+            return {
+                ok: false,
+                reason: "off",
+                message: `This schedule is ${schedule.status}, so it needs no more topics.`,
+            };
+        if (!options.force && generationWanted(schedule) === 0)
+            return { ok: false, reason: "full", message: "The queue already has enough topics." };
+        const taken = deps.db
+            .prepare(`UPDATE schedules SET topics_generating_at=?
+         WHERE id=? AND (topics_generating_at IS NULL OR topics_generating_at<=?)`)
+            .run(now.toISOString(), scheduleId, new Date(now.valueOf() - leaseMs).toISOString());
+        if (Number(taken.changes) !== 1)
+            return {
+                ok: false,
+                reason: "busy",
+                message: "Slopify is already generating topics for this schedule. Wait for it to finish.",
+            };
+        return schedule;
+    });
+    if ("ok" in claimed)
+        return claimed;
+    const schedule = claimed;
+    try {
+        return await ask(deps, schedule, options);
+    }
+    finally {
+        deps.db
+            .prepare("UPDATE schedules SET topics_generating_at=NULL WHERE id=? AND topics_generating_at=?")
+            .run(scheduleId, now.toISOString());
+    }
+}
+async function ask(deps, schedule, options) {
+    const fail = (message) => {
+        const failedAt = deps.clock.now();
+        const retry = "Slopify tries again in 5 minutes, or press Generate topics now on the Schedules screen.";
+        const text = `Couldn't generate topics: ${message} ${retry}`;
+        deps.db
+            .prepare("UPDATE schedules SET topics_failed_at=?,topics_error=? WHERE id=?")
+            .run(failedAt.toISOString(), text, schedule.id);
+        return { ok: false, reason: "failed", message: text };
+    };
+    const template = deps.template(schedule.templateId, schedule.templateVersion);
+    const llm = schedule.topicGeneration.llm ?? template?.document.form.llm;
+    if (llm === undefined)
+        return fail("the template this schedule uses was deleted, so there is no LLM to ask. Edit the schedule and choose a template, or pick an LLM under Topic generation.");
+    if (deps.topicLlm === undefined)
+        return fail("no LLM is available in this Slopify. Restart Slopify and try again.");
+    const wanted = Math.max(generationWanted(schedule), options.force ? spare : 0);
+    const known = knownTitles(deps, schedule.id);
+    const signal = AbortSignal.any([
+        AbortSignal.timeout(generationTimeoutMs),
+        ...(options.signal === undefined ? [] : [options.signal]),
+    ]);
+    let answer;
+    try {
+        const answered = await deps.topicLlm({
+            owner: { kind: "schedule", id: schedule.id },
+            purpose: "topics",
+            provider: llm.provider,
+            model: llm.model,
+            ...(llm.thinking === undefined ? {} : { thinking: llm.thinking }),
+            messages: topicMessages(withChannelBrief(deps, schedule), template?.document.form.title, known, Math.min(wanted + spare, askMax)),
+            signal,
+        });
+        answer = answered.text;
+    }
+    catch (error) {
+        if (options.signal?.aborted === true)
+            return { ok: false, reason: "failed", message: "Slopify was closing." };
+        const detail = error instanceof Error ? error.message : String(error);
+        return fail(`${llm.provider} (${llm.model}) did not answer: ${detail.trim().slice(0, 300)}. Check it in Settings → Providers, or pick another LLM under Edit → Topic generation.`);
+    }
+    const suggested = parseTopics(answer);
+    if (suggested.length === 0)
+        return fail(`${llm.provider} (${llm.model}) answered without a list of topics. Try again, or pick another LLM under Edit → Topic generation.`);
+    return transact(deps.db, () => {
+        const current = scheduleById(deps.db, schedule.id);
+        if (current === undefined || current.deletedAt !== null)
+            return { ok: false, reason: "not-found", message: "This schedule no longer exists." };
+        // Checked again against what is there now: a topic added while the LLM was thinking counts.
+        const fresh = newTopics(suggested, knownTitles(deps, schedule.id)).slice(0, Math.max(0, Math.min(wanted, queueMax - current.items.length)));
+        if (fresh.length === 0)
+            return fail("every topic the LLM suggested was already made, queued or turned down for this schedule. Add more detail to the series brief under Edit, so it has new ground to cover.");
+        const at = deps.clock.now().toISOString();
+        const mode = current.topicGeneration.mode === "hold" ? "hold" : "queue";
+        if (mode === "queue") {
+            deps.db
+                .prepare("UPDATE schedules SET items_json=?,version=version+1,updated_at=? WHERE id=? AND deleted_at IS NULL")
+                .run(JSON.stringify([...current.items, ...fresh.map((title) => ({ title, values: {} }))]), at, schedule.id);
+        }
+        else {
+            const start = nextRank(deps, schedule.id);
+            fresh.forEach((title, index) => {
+                deps.db
+                    .prepare(`INSERT INTO schedule_topics (id,schedule_id,title,state,rank,created_at)
+             VALUES (?,?,?,'held',?,?)`)
+                    .run(deps.uuid(), schedule.id, title, start + index, at);
+            });
+        }
+        deps.db
+            .prepare("UPDATE schedules SET topics_generated_at=?,topics_failed_at=NULL,topics_error=NULL WHERE id=?")
+            .run(at, schedule.id);
+        if (mode === "hold") {
+            const waiting = heldTopics(deps, schedule.id).length;
+            try {
+                deps.topicsWaiting?.({
+                    type: "schedule.topics",
+                    scheduleId: schedule.id,
+                    scheduleName: current.name,
+                    added: fresh.length,
+                    waiting,
+                });
+            }
+            catch {
+                // A notification is never a reason to lose the topics.
+            }
+        }
+        return { ok: true, added: fresh.length, mode };
+    });
+}
+function nextRank(deps, scheduleId) {
+    const row = deps.db
+        .prepare("SELECT max(rank) AS rank FROM schedule_topics WHERE schedule_id=? AND state='held'")
+        .get(scheduleId);
+    const rank = z.object({ rank: z.number().nullable() }).parse(row).rank;
+    return rank === null ? 0 : rank + 1;
+}
+// Everything this schedule has queued, held, turned down or used, every project's title, and
+// the titles of the videos its channel made before Slopify (Channel page → Existing videos).
+export function knownTitles(deps, scheduleId) {
+    const schedule = scheduleById(deps.db, scheduleId);
+    const logged = deps.db
+        .prepare("SELECT title FROM schedule_topics WHERE schedule_id=? ORDER BY created_at DESC")
+        .all(scheduleId)
+        .map((row) => z.object({ title: z.string() }).parse(row).title);
+    const projects = deps.db
+        .prepare(`SELECT title FROM projects WHERE ${liveProject()} ORDER BY created_at DESC`)
+        .all()
+        .map((row) => z.object({ title: z.string() }).parse(row).title);
+    const channel = scheduleChannel(deps.db, scheduleId);
+    const existing = channel === undefined ? [] : channelVideoTitles(deps.db, channel.id);
+    return {
+        topics: [...new Set([...(schedule?.items.map((item) => item.title) ?? []), ...logged])],
+        projects: [...new Set([...projects, ...existing])],
+    };
+}
+// A schedule without a brief of its own reads its channel's series brief (the channel of the
+// template it runs); one it sets itself wins.
+export function withChannelBrief(deps, schedule) {
+    if (schedule.brief?.trim())
+        return schedule;
+    const brief = scheduleChannel(deps.db, schedule.id)?.seriesBrief.trim() ?? "";
+    return brief === "" ? schedule : { ...schedule, brief };
+}
+export function topicMessages(schedule, templateTitle, known, count) {
+    const titles = [...new Set([...known.topics, ...known.projects])].slice(0, knownMax);
+    const keyword = schedule.topicKeyword;
+    const fills = keyword !== null && templateTitle?.includes(`{{${keyword}}}`) === true
+        ? `Each topic fills {{${keyword}}} in the video title "${templateTitle}", so write only the topic itself, not a whole title.`
+        : "Each topic becomes the video's subject; write it as a short title.";
+    const brief = schedule.brief?.trim();
+    return [
+        {
+            role: "system",
+            content: "You plan the next videos for a YouTube channel. Answer with a JSON array of strings and nothing else.",
+        },
+        {
+            role: "user",
+            content: [
+                `Suggest ${String(count)} new topics for the series "${schedule.name}".`,
+                "",
+                "Series brief:",
+                brief === undefined || brief === ""
+                    ? "(none given; work out what the channel covers from the titles below)"
+                    : brief,
+                "",
+                `${fills} Keep each under 120 characters.`,
+                "Rank them most view-worthy first: the topics most likely to be watched, as the brief defines it.",
+                "",
+                titles.length === 0
+                    ? "Nothing has been made for this channel yet."
+                    : "Never repeat or rephrase any of these, which were already made, queued or turned down:",
+                ...titles.map((title) => `- ${title}`),
+            ].join("\n"),
+        },
+    ];
+}
+// A JSON array of strings, or failing that one topic per line with bullets and numbers dropped.
+export function parseTopics(answer) {
+    const start = answer.indexOf("[");
+    const end = answer.lastIndexOf("]");
+    let lines;
+    if (start !== -1 && end > start) {
+        try {
+            const parsed = JSON.parse(answer.slice(start, end + 1));
+            if (Array.isArray(parsed))
+                lines = parsed;
+        }
+        catch {
+            lines = undefined;
+        }
+    }
+    lines ??= answer.split(/\r?\n/);
+    return lines
+        .map((line) => typeof line === "string"
+        ? line
+        : typeof line === "object" && line !== null && "title" in line
+            ? String(line.title)
+            : "")
+        .map((line) => line
+        .replace(/^\s*(?:[-*•]|\d+[.)])\s*/, "")
+        .replace(/^["'“”]+|["'“”,]+$/g, "")
+        .replace(/\s+/g, " ")
+        .trim())
+        .filter((line) => line !== "" && line !== "[" && line !== "]" && line.length <= 200);
+}
+export function heldTopics(deps, scheduleId) {
+    return deps.db
+        .prepare(`SELECT id,title,rank,created_at FROM schedule_topics
+       WHERE schedule_id=? AND state='held' ORDER BY rank,created_at,id`)
+        .all(scheduleId)
+        .map((row) => {
+        const value = z
+            .object({ id: z.string(), title: z.string(), rank: z.number(), created_at: z.string() })
+            .parse(row);
+        return heldTopicSchema.parse({
+            id: value.id,
+            title: value.title,
+            rank: value.rank,
+            createdAt: value.created_at,
+        });
+    });
+}
+function openSchedule(deps, scheduleId) {
+    const schedule = scheduleById(deps.db, scheduleId);
+    if (schedule === undefined || schedule.deletedAt !== null)
+        return { ok: false, reason: "not-found" };
+    if (schedule.status === "canceled" || schedule.status === "completed")
+        return { ok: false, reason: "conflict" };
+    return { ok: true, value: schedule };
+}
+// Approved topics join the end of the queue in their ranked order. `edits` renames a topic
+// as it is approved.
+export function approveHeldTopics(deps, scheduleId, ids, edits = {}) {
+    return transact(deps.db, () => {
+        const open = openSchedule(deps, scheduleId);
+        if (!open.ok)
+            return open;
+        const held = heldTopics(deps, scheduleId);
+        const chosen = ids === "all" ? held : held.filter((topic) => ids.includes(topic.id));
+        if (ids !== "all" && chosen.length !== ids.length)
+            return { ok: false, reason: "topic-not-found" };
+        const titles = [];
+        for (const topic of chosen) {
+            const title = topicTitleSchema.safeParse(edits[topic.id] ?? topic.title);
+            if (!title.success)
+                return { ok: false, reason: "invalid-input" };
+            titles.push(title.data);
+        }
+        if (open.value.items.length + titles.length > queueMax)
+            return { ok: false, reason: "queue-full" };
+        const at = deps.clock.now().toISOString();
+        for (const topic of chosen)
+            deps.db.prepare("DELETE FROM schedule_topics WHERE id=?").run(topic.id);
+        deps.db
+            .prepare("UPDATE schedules SET items_json=?,version=version+1,updated_at=? WHERE id=?")
+            .run(JSON.stringify([...open.value.items, ...titles.map((title) => ({ title, values: {} }))]), at, scheduleId);
+        return { ok: true, value: scheduleById(deps.db, scheduleId) };
+    });
+}
+// Turned down topics stay recorded so no later generation suggests them again.
+export function rejectHeldTopic(deps, scheduleId, topicId) {
+    const changed = deps.db
+        .prepare(`UPDATE schedule_topics SET state='rejected',decided_at=?
+       WHERE id=? AND schedule_id=? AND state='held'`)
+        .run(deps.clock.now().toISOString(), topicId, scheduleId);
+    if (Number(changed.changes) !== 1)
+        return { ok: false, reason: "topic-not-found" };
+    return { ok: true, value: scheduleById(deps.db, scheduleId) };
+}
+export function editHeldTopic(deps, scheduleId, topicId, title) {
+    const parsed = topicTitleSchema.safeParse(title);
+    if (!parsed.success)
+        return { ok: false, reason: "invalid-input" };
+    const changed = deps.db
+        .prepare("UPDATE schedule_topics SET title=? WHERE id=? AND schedule_id=? AND state='held'")
+        .run(parsed.data, topicId, scheduleId);
+    if (Number(changed.changes) !== 1)
+        return { ok: false, reason: "topic-not-found" };
+    const topic = heldTopics(deps, scheduleId).find((row) => row.id === topicId);
+    return topic === undefined
+        ? { ok: false, reason: "topic-not-found" }
+        : { ok: true, value: topic };
+}
+// Moves one queued topic to another position. Each run takes the first topic, so this is
+// also what reorders the calendar.
+export function moveTopic(deps, scheduleId, input) {
+    const parsed = topicMoveSchema.safeParse(input);
+    if (!parsed.success)
+        return { ok: false, reason: "invalid-input" };
+    return transact(deps.db, () => {
+        const open = openSchedule(deps, scheduleId);
+        if (!open.ok)
+            return open;
+        const schedule = open.value;
+        if (schedule.version !== parsed.data.baseVersion)
+            return { ok: false, reason: "conflict" };
+        const { from } = parsed.data;
+        if (from >= schedule.items.length)
+            return { ok: false, reason: "invalid-input" };
+        const items = [...schedule.items];
+        const [topic] = items.splice(from, 1);
+        if (topic === undefined)
+            return { ok: false, reason: "invalid-input" };
+        items.splice(Math.min(parsed.data.to, items.length), 0, topic);
+        writeItems(deps, scheduleId, schedule.version, items);
+        return { ok: true, value: scheduleById(deps.db, scheduleId) };
+    });
+}
+// Takes one queued topic off this schedule and puts it on another's queue.
+export function transferTopic(deps, scheduleId, input) {
+    const parsed = topicTransferSchema.safeParse(input);
+    if (!parsed.success)
+        return { ok: false, reason: "invalid-input" };
+    if (parsed.data.targetId === scheduleId)
+        return { ok: false, reason: "invalid-input" };
+    return transact(deps.db, () => {
+        const source = openSchedule(deps, scheduleId);
+        if (!source.ok)
+            return source;
+        const target = openSchedule(deps, parsed.data.targetId);
+        if (!target.ok)
+            return target;
+        if (source.value.version !== parsed.data.baseVersion)
+            return { ok: false, reason: "conflict" };
+        const items = [...source.value.items];
+        const [topic] = items.splice(parsed.data.index, 1);
+        if (topic === undefined)
+            return { ok: false, reason: "invalid-input" };
+        if (target.value.items.length + 1 > queueMax)
+            return { ok: false, reason: "queue-full" };
+        const landing = [...target.value.items];
+        landing.splice(Math.min(parsed.data.position ?? landing.length, landing.length), 0, topic);
+        writeItems(deps, scheduleId, source.value.version, items);
+        writeItems(deps, target.value.id, target.value.version, landing);
+        return {
+            ok: true,
+            value: {
+                source: scheduleById(deps.db, scheduleId),
+                target: scheduleById(deps.db, target.value.id),
+            },
+        };
+    });
+}
+function writeItems(deps, scheduleId, version, items) {
+    deps.db
+        .prepare("UPDATE schedules SET items_json=?,version=version+1,updated_at=? WHERE id=? AND version=?")
+        .run(JSON.stringify(items), deps.clock.now().toISOString(), scheduleId, version);
+}
+// Boot: a generation cannot outlive the process that asked.
+export function releaseTopicLeases(deps) {
+    deps.db.prepare("UPDATE schedules SET topics_generating_at=NULL").run();
+}