@gentbajko/slopify 0.8.3 → 1.0.0

package/dist/slices/schedules/repo.js

@@ -0,0 +1,281 @@
+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 { readStartReceipt } from "../play-drafts/start-repo.js";
+import { scheduleRunSchema, scheduleSummarySchema, } from "./schema.js";
+const rowSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    template_id: z.string(),
+    template_version: z.number(),
+    cadence_json: z.string(),
+    timezone: z.string(),
+    missed_policy: z.string(),
+    overlap_policy: z.string(),
+    spend_limit_cents: z.number().nullable(),
+    items_json: z.string(),
+    status: z.string(),
+    version: z.number(),
+    next_run_at: z.string().nullable(),
+    created_at: z.string(),
+    updated_at: z.string(),
+    deleted_at: z.string().nullable(),
+});
+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,status,version,next_run_at,created_at,updated_at,
+       deleted_at
+       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,status,version,next_run_at,created_at,updated_at,
+       deleted_at
+       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,status,version,next_run_at,created_at,updated_at,
+       deleted_at
+       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`)
+        .all(now)
+        .map(parseSchedule);
+}
+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,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.status, schedule.version, creationHash, schedule.nextRunAt, schedule.createdAt, schedule.updatedAt, schedule.deletedAt);
+}
+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=?,status=?,version=?,
+       next_run_at=?,updated_at=?,mutation_id=?,mutation_hash=?
+       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.status, schedule.version, schedule.nextRunAt, schedule.updatedAt, mutationId, mutationHash, schedule.id, baseVersion);
+    return Number(changed.changes) === 1;
+}
+export function tombstoneScheduleRow(db, id, version, deletedAt) {
+    const changed = db
+        .prepare(`UPDATE schedules SET deleted_at=?,next_run_at=NULL,version=version+1,updated_at=?
+       WHERE id=? AND version=? AND deleted_at IS NULL`)
+        .run(deletedAt, deletedAt, id, version);
+    return Number(changed.changes) === 1;
+}
+export function setScheduleStatus(db, id, version, status, nextRunAt, updatedAt) {
+    const changed = db
+        .prepare(`UPDATE schedules SET status=?,next_run_at=?,version=version+1,updated_at=?
+       WHERE id=? AND version=? AND deleted_at IS NULL`)
+        .run(status, nextRunAt, updatedAt, id, version);
+    return Number(changed.changes) === 1;
+}
+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);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes("UNIQUE"))
+            return false;
+        throw error;
+    }
+}
+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);
+}
+export function recordRunStartIdentity(db, run) {
+    if (run.requestId === null)
+        throw new Error("A scheduled Start requires a request identity.");
+    const changed = db
+        .prepare(`UPDATE schedule_runs SET request_id=?,estimate_json=?
+       WHERE id=? AND status='running' AND request_id IS NULL AND project_ids_json='[]'`)
+        .run(run.requestId, run.estimate === null ? null : JSON.stringify(run.estimate), run.id);
+    if (Number(changed.changes) !== 1)
+        throw new Error("The scheduled run could not persist its Start identity.");
+}
+export function recordRunDispatch(db, run, recordedAt) {
+    transact(db, () => {
+        const changed = db
+            .prepare(`UPDATE schedule_runs SET request_id=?,project_ids_json=?,estimate_json=?
+         WHERE id=? AND status='running'`)
+            .run(run.requestId, JSON.stringify(run.projectIds), run.estimate === null ? null : JSON.stringify(run.estimate), run.id);
+        if (Number(changed.changes) !== 1)
+            throw new Error("The scheduled run could not record its admitted projects.");
+        for (const projectId of run.projectIds)
+            settleScheduleRunsForProject(db, projectId, recordedAt);
+    });
+}
+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`)
+        .all(scheduleId)
+        .map(parseRun);
+}
+export function activeRun(db, scheduleId, settledAt) {
+    return transact(db, () => {
+        if (db
+            .prepare("SELECT 1 FROM schedule_runs WHERE schedule_id=? AND status='running' LIMIT 1")
+            .get(scheduleId) !== undefined)
+            return true;
+        const occurrences = db
+            .prepare(`SELECT id,project_ids_json FROM schedule_runs
+         WHERE schedule_id=? AND projects_settled_at IS NULL
+         AND json_array_length(project_ids_json)>0
+         ORDER BY scheduled_for,started_at,id`)
+            .all(scheduleId)
+            .map((row) => z.object({ id: z.string(), project_ids_json: z.string() }).parse(row));
+        let anyActive = false;
+        for (const occurrence of occurrences) {
+            const ids = z.array(z.string()).parse(JSON.parse(occurrence.project_ids_json));
+            if (ids.some((id) => projectIsActive(db, id))) {
+                anyActive = true;
+                continue;
+            }
+            db.prepare("UPDATE schedule_runs SET projects_settled_at=? WHERE id=? AND projects_settled_at IS NULL").run(settledAt, occurrence.id);
+        }
+        return anyActive;
+    });
+}
+/**
+ * Permanently settles every scheduled occurrence containing `projectId` once all projects
+ * admitted by that occurrence are terminal. The runner calls this in the same transaction as
+ * its terminal work write, so a later edit creates a new revision without reopening history.
+ */
+export function settleScheduleRunsForProject(db, projectId, settledAt) {
+    return transact(db, () => {
+        const occurrences = db
+            .prepare(`SELECT DISTINCT schedule_runs.id, schedule_runs.project_ids_json
+         FROM schedule_runs, json_each(schedule_runs.project_ids_json) AS admitted
+         WHERE schedule_runs.projects_settled_at IS NULL AND admitted.value=?`)
+            .all(projectId)
+            .map((row) => z.object({ id: z.string(), project_ids_json: z.string() }).parse(row));
+        let settled = 0;
+        for (const occurrence of occurrences) {
+            const ids = z.array(z.string()).parse(JSON.parse(occurrence.project_ids_json));
+            if (ids.some((id) => projectIsActive(db, id)))
+                continue;
+            const changed = db
+                .prepare("UPDATE schedule_runs SET projects_settled_at=? WHERE id=? AND projects_settled_at IS NULL")
+                .run(settledAt, occurrence.id);
+            settled += Number(changed.changes);
+        }
+        return settled;
+    });
+}
+/** Freeze every terminal admitted occurrence during boot/migration recovery before the UI can
+ * create a new revision on one of its projects. */
+export function settleTerminalScheduleRuns(db, settledAt) {
+    return transact(db, () => {
+        const projectIds = db
+            .prepare(`SELECT DISTINCT admitted.value AS project_id
+         FROM schedule_runs, json_each(schedule_runs.project_ids_json) AS admitted
+         WHERE schedule_runs.projects_settled_at IS NULL`)
+            .all()
+            .map((row) => z.object({ project_id: z.string() }).parse(row).project_id);
+        let settled = 0;
+        for (const projectId of projectIds)
+            settled += settleScheduleRunsForProject(db, projectId, settledAt);
+        return settled;
+    });
+}
+function projectIsActive(db, projectId) {
+    if (db.prepare("SELECT 1 FROM projects WHERE id=?").get(projectId) === undefined)
+        return false;
+    const state = derive(stagesOf(db, projectId), projectPaused(db, projectId));
+    return state !== "done" && state !== "failed" && state !== "canceled";
+}
+export function recoverRunningRuns(db, endedAt, error = "The app stopped while this scheduled run was active.") {
+    return transact(db, () => {
+        const pending = db
+            .prepare(`SELECT id,request_id FROM schedule_runs
+         WHERE status='running' AND request_id IS NOT NULL AND project_ids_json='[]'`)
+            .all()
+            .map((row) => z.object({ id: z.string(), request_id: z.string() }).parse(row));
+        for (const row of pending) {
+            const receipt = readStartReceipt(db, row.request_id);
+            if (receipt === undefined || receipt.result.requestId !== row.request_id)
+                continue;
+            db.prepare(`UPDATE schedule_runs SET project_ids_json=?
+         WHERE id=? AND status='running' AND request_id=? AND project_ids_json='[]'`).run(JSON.stringify(receipt.result.projectIds), row.id, row.request_id);
+        }
+        const admitted = db
+            .prepare(`SELECT project_ids_json FROM schedule_runs
+         WHERE status='running' AND json_array_length(project_ids_json)>0`)
+            .all()
+            .flatMap((row) => {
+            const parsed = z.object({ project_ids_json: z.string() }).parse(row);
+            return z.array(z.string()).parse(JSON.parse(parsed.project_ids_json));
+        });
+        const changed = db
+            .prepare("UPDATE schedule_runs SET status='failed',ended_at=?,error=? WHERE status='running'")
+            .run(endedAt, error);
+        for (const projectId of admitted)
+            settleScheduleRunsForProject(db, projectId, endedAt);
+        return Number(changed.changes);
+    });
+}
+function parseSchedule(row) {
+    const value = rowSchema.parse(row);
+    return scheduleSummarySchema.parse({
+        id: value.id,
+        name: value.name,
+        templateId: value.template_id,
+        templateVersion: value.template_version,
+        cadence: JSON.parse(value.cadence_json),
+        timezone: value.timezone,
+        missedPolicy: value.missed_policy,
+        overlapPolicy: value.overlap_policy,
+        spendLimitCents: value.spend_limit_cents,
+        items: JSON.parse(value.items_json),
+        status: value.status,
+        version: value.version,
+        nextRunAt: value.next_run_at,
+        createdAt: value.created_at,
+        updatedAt: value.updated_at,
+        deletedAt: value.deleted_at,
+    });
+}
+function parseRun(row) {
+    const value = z
+        .object({
+        id: z.string(),
+        schedule_id: z.string(),
+        scheduled_for: z.string(),
+        status: z.string(),
+        request_id: z.string().nullable(),
+        project_ids_json: z.string(),
+        estimate_json: z.string().nullable(),
+        started_at: z.string(),
+        ended_at: z.string().nullable(),
+        error: z.string().nullable(),
+    })
+        .parse(row);
+    return scheduleRunSchema.parse({
+        id: value.id,
+        scheduleId: value.schedule_id,
+        scheduledFor: value.scheduled_for,
+        status: value.status,
+        requestId: value.request_id,
+        projectIds: JSON.parse(value.project_ids_json),
+        estimate: value.estimate_json === null ? null : JSON.parse(value.estimate_json),
+        startedAt: value.started_at,
+        endedAt: value.ended_at,
+        error: value.error,
+    });
+}

package/dist/slices/schedules/scheduler.js

@@ -0,0 +1,144 @@
+import { transact } from "../../kernel/db/tx.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";
+const missedGraceMs = 60_000;
+export function createScheduleRunner(deps) {
+    let ticking = false;
+    return {
+        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.");
+                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)));
+                const failed = settled.find((result) => result.status === "rejected");
+                if (failed)
+                    throw failed.reason;
+            }
+            finally {
+                ticking = false;
+            }
+        },
+        recover: (now = deps.clock.now()) => recoverRunningRuns(deps.db, now.toISOString()),
+    };
+}
+function claim(deps, schedule, now) {
+    if (schedule.nextRunAt === null)
+        return [];
+    const scheduledFor = new Date(schedule.nextRunAt);
+    const occurrence = schedule.missedPolicy === "skip" && now.valueOf() - scheduledFor.valueOf() > missedGraceMs;
+    let next = nextOccurrence(schedule.cadence, schedule.timezone, new Date(scheduledFor.valueOf() + 1000));
+    while (next !== null && next <= now)
+        next = nextOccurrence(schedule.cadence, schedule.timezone, new Date(next.valueOf() + 1000));
+    const status = next === null ? "completed" : schedule.status;
+    return transact(deps.db, () => {
+        const current = scheduleById(deps.db, schedule.id);
+        if (current === undefined ||
+            current.version !== schedule.version ||
+            current.nextRunAt !== schedule.nextRunAt ||
+            current.status !== "active")
+            return [];
+        const overlapping = activeRun(deps.db, schedule.id, now.toISOString());
+        const skip = occurrence || overlapping;
+        const run = {
+            id: deps.uuid(),
+            scheduleId: schedule.id,
+            scheduledFor: scheduledFor.toISOString(),
+            status: skip ? "skipped" : "running",
+            requestId: null,
+            projectIds: [],
+            estimate: null,
+            startedAt: now.toISOString(),
+            endedAt: skip ? now.toISOString() : null,
+            error: skip
+                ? overlapping
+                    ? "Skipped because another occurrence is still running."
+                    : "Skipped because the app missed this occurrence."
+                : null,
+        };
+        if (!insertRun(deps.db, run))
+            return [];
+        deps.db
+            .prepare("UPDATE schedules SET status=?,next_run_at=?,version=version+1,updated_at=? WHERE id=? AND version=?")
+            .run(status, next?.toISOString() ?? null, now.toISOString(), schedule.id, schedule.version);
+        return skip ? [] : [{ run, schedule }];
+    });
+}
+async function execute(deps, claimed) {
+    let run = claimed.run;
+    try {
+        const template = deps.template(claimed.schedule.templateId, claimed.schedule.templateVersion);
+        if (template === undefined)
+            throw new ScheduleDispatchError("missing-template");
+        const document = freshTemplateDraft(deps, template.document, {
+            id: claimed.schedule.templateId,
+            version: claimed.schedule.templateVersion,
+        });
+        const fresh = {
+            ...document,
+            variants: claimed.schedule.items.map((item) => ({
+                id: deps.uuid(),
+                title: item.title,
+                values: item.values,
+            })),
+        };
+        const draft = createDraft(deps, { id: deps.uuid(), document: fresh });
+        if (!draft.ok)
+            throw new ScheduleDispatchError("conflict");
+        const review = await reviewDraft(deps, { id: draft.value.draft.id, baseVersion: 1 });
+        if (!review.ok)
+            throw new ScheduleDispatchError(review.reason);
+        const high = review.value.estimates.reduce((sum, estimate) => sum + estimate.high, 0);
+        if (claimed.schedule.spendLimitCents !== null &&
+            (review.value.estimates.some((estimate) => estimate.unknown > 0) ||
+                high * 100 > claimed.schedule.spendLimitCents))
+            throw new ScheduleDispatchError("spend-limit");
+        run = {
+            ...run,
+            requestId: review.value.id,
+            estimate: review.value.estimates,
+        };
+        recordRunStartIdentity(deps.db, run);
+        const started = await startPlayDraft(deps, {
+            draftId: draft.value.draft.id,
+            baseVersion: 1,
+            reviewId: review.value.id,
+        });
+        if (!started.ok)
+            throw new ScheduleDispatchError(started.reason);
+        run = {
+            ...run,
+            requestId: started.value.requestId,
+            projectIds: started.value.projectIds,
+        };
+        recordRunDispatch(deps.db, run, deps.clock.now().toISOString());
+        run = {
+            ...run,
+            status: "succeeded",
+            endedAt: deps.clock.now().toISOString(),
+        };
+    }
+    catch (error) {
+        run = {
+            ...run,
+            status: "failed",
+            endedAt: deps.clock.now().toISOString(),
+            error: error instanceof ScheduleDispatchError ? error.reason : "The scheduled run failed.",
+        };
+    }
+    updateRun(deps.db, run);
+}
+class ScheduleDispatchError extends Error {
+    reason;
+    constructor(reason) {
+        super(reason);
+        this.reason = reason;
+    }
+}

package/dist/slices/schedules/schema.js

@@ -0,0 +1,80 @@
+import { z } from "zod";
+import { cadenceSchema, validTimeZone } from "./calendar.js";
+const id = z.uuid();
+const keywordName = z
+    .string()
+    .min(1)
+    .max(200)
+    .refine((value) => value === value.trim(), "Keyword names cannot start or end with spaces.");
+const item = z
+    .object({
+    title: z.string().trim().min(1).max(200),
+    values: z.record(keywordName, z.string().max(10000)).readonly(),
+})
+    .strict()
+    .readonly();
+const policy = z.enum(["skip", "run-once"]);
+export const scheduleCreateSchema = z
+    .object({
+    id,
+    name: z.string().trim().min(1).max(200),
+    templateId: id,
+    templateVersion: z.number().int().positive(),
+    cadence: cadenceSchema,
+    timezone: z.string().min(1).max(100).refine(validTimeZone, "Choose a valid IANA timezone."),
+    missedPolicy: policy.default("skip"),
+    overlapPolicy: z.literal("skip").default("skip"),
+    spendLimitCents: z.number().int().nonnegative().nullable().default(null),
+    items: z.array(item).max(49).default([]).readonly(),
+})
+    .strict()
+    .readonly();
+export const scheduleUpdateSchema = scheduleCreateSchema
+    .unwrap()
+    .extend({ baseVersion: z.number().int().positive(), mutationId: id })
+    .strict()
+    .readonly();
+export const scheduleDeleteSchema = z
+    .object({ id, baseVersion: z.number().int().positive() })
+    .strict()
+    .readonly();
+export const scheduleControlSchema = z
+    .object({ id, baseVersion: z.number().int().positive() })
+    .strict()
+    .readonly();
+export const scheduleSummarySchema = z
+    .object({
+    id,
+    name: z.string(),
+    templateId: id,
+    templateVersion: z.number().int().positive(),
+    cadence: cadenceSchema,
+    timezone: z.string(),
+    missedPolicy: policy,
+    overlapPolicy: z.literal("skip"),
+    spendLimitCents: z.number().int().nonnegative().nullable(),
+    items: z.array(item).readonly(),
+    status: z.enum(["active", "paused", "completed", "canceled"]),
+    version: z.number().int().positive(),
+    nextRunAt: z.string().datetime({ offset: true }).nullable(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    deletedAt: z.string().datetime({ offset: true }).nullable(),
+})
+    .strict()
+    .readonly();
+export const scheduleRunSchema = z
+    .object({
+    id,
+    scheduleId: id,
+    scheduledFor: z.string().datetime({ offset: true }),
+    status: z.enum(["running", "succeeded", "failed", "skipped"]),
+    requestId: id.nullable(),
+    projectIds: z.array(z.string()).readonly(),
+    estimate: z.unknown().nullable(),
+    startedAt: z.string().datetime({ offset: true }),
+    endedAt: z.string().datetime({ offset: true }).nullable(),
+    error: z.string().nullable(),
+})
+    .strict()
+    .readonly();

package/dist/slices/schedules/service.js

@@ -0,0 +1,178 @@
+import { z } from "zod";
+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";
+export function listSchedules(deps) {
+    return scheduleRows(deps.db);
+}
+export function listScheduleRuns(deps, id) {
+    if (!z.uuid().safeParse(id).success)
+        return { ok: false, reason: "invalid-input" };
+    const runs = runsForSchedule(deps.db, id);
+    if (!scheduleById(deps.db, id) && runs.length === 0)
+        return { ok: false, reason: "not-found" };
+    return { ok: true, value: runs };
+}
+export function createSchedule(deps, input) {
+    const parsed = scheduleCreateSchema.safeParse(input);
+    if (!parsed.success)
+        return { ok: false, reason: "invalid-input" };
+    const hash = requestHash(parsed.data);
+    return transact(deps.db, () => {
+        const old = deps.db
+            .prepare("SELECT creation_hash,deleted_at FROM schedules WHERE id=?")
+            .get(parsed.data.id);
+        if (old !== undefined) {
+            const saved = z
+                .object({ creation_hash: z.string(), deleted_at: z.string().nullable() })
+                .parse(old);
+            if (saved.deleted_at !== null)
+                return { ok: false, reason: "conflict" };
+            return saved.creation_hash === hash
+                ? { ok: true, value: scheduleById(deps.db, parsed.data.id) }
+                : { ok: false, reason: "conflict" };
+        }
+        const checked = checkTemplate(deps, parsed.data.templateId, parsed.data.templateVersion);
+        if (!checked.ok)
+            return checked;
+        const now = deps.clock.now();
+        const next = nextOccurrence(parsed.data.cadence, parsed.data.timezone, now);
+        if (next === null)
+            return { ok: false, reason: "not-due" };
+        const value = summary(parsed.data, next.toISOString(), now.toISOString());
+        insertSchedule(deps.db, value, hash);
+        return { ok: true, value };
+    });
+}
+export function updateSchedule(deps, input) {
+    const parsed = scheduleUpdateSchema.safeParse(input);
+    if (!parsed.success)
+        return { ok: false, reason: "invalid-input" };
+    const hash = requestHash(parsed.data);
+    return transact(deps.db, () => {
+        const previous = scheduleById(deps.db, parsed.data.id);
+        if (!previous)
+            return { ok: false, reason: "not-found" };
+        const row = deps.db
+            .prepare("SELECT mutation_id,mutation_hash FROM schedules WHERE id=?")
+            .get(previous.id);
+        if (row !== undefined) {
+            const saved = z
+                .object({ mutation_id: z.string().nullable(), mutation_hash: z.string().nullable() })
+                .parse(row);
+            if (saved.mutation_id === parsed.data.mutationId)
+                return saved.mutation_hash === hash
+                    ? { ok: true, value: previous }
+                    : { ok: false, reason: "conflict" };
+        }
+        if (previous.deletedAt !== null)
+            return { ok: false, reason: "conflict" };
+        if (previous.version !== parsed.data.baseVersion)
+            return { ok: false, reason: "conflict" };
+        if (previous.status === "canceled" || previous.status === "completed")
+            return { ok: false, reason: "conflict" };
+        const checked = checkTemplate(deps, parsed.data.templateId, parsed.data.templateVersion);
+        if (!checked.ok)
+            return checked;
+        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);
+        if (!updateScheduleRow(deps.db, value, parsed.data.mutationId, hash, parsed.data.baseVersion))
+            return { ok: false, reason: "conflict" };
+        return { ok: true, value };
+    });
+}
+export function pauseSchedule(deps, input) {
+    return control(deps, input, "paused");
+}
+export function resumeSchedule(deps, input) {
+    const parsed = scheduleControlSchema.safeParse(input);
+    if (!parsed.success)
+        return { ok: false, reason: "invalid-input" };
+    const previous = scheduleById(deps.db, parsed.data.id);
+    if (!previous)
+        return { ok: false, reason: "not-found" };
+    if (previous.deletedAt !== null)
+        return { ok: false, reason: "conflict" };
+    if (previous.version !== parsed.data.baseVersion || previous.status !== "paused")
+        return { ok: false, reason: "conflict" };
+    const next = nextOccurrence(previous.cadence, previous.timezone, deps.clock.now());
+    const status = next === null ? "completed" : "active";
+    if (!setScheduleStatus(deps.db, previous.id, previous.version, status, next?.toISOString() ?? null, deps.clock.now().toISOString()))
+        return { ok: false, reason: "conflict" };
+    return { ok: true, value: scheduleById(deps.db, previous.id) };
+}
+export function cancelSchedule(deps, input) {
+    return control(deps, input, "canceled");
+}
+export function deleteSchedule(deps, input) {
+    const parsed = scheduleDeleteSchema.safeParse(input);
+    if (!parsed.success)
+        return { ok: false, reason: "invalid-input" };
+    const previous = scheduleById(deps.db, parsed.data.id);
+    if (!previous)
+        return { ok: false, reason: "not-found" };
+    if (previous.deletedAt !== null)
+        return { ok: true, value: { deleted: true } };
+    if (previous.version !== parsed.data.baseVersion)
+        return { ok: false, reason: "conflict" };
+    if (previous.status !== "completed" && previous.status !== "canceled")
+        return { ok: false, reason: "cancel-required" };
+    const deletedAt = deps.clock.now().toISOString();
+    return transact(deps.db, () => tombstoneScheduleRow(deps.db, previous.id, previous.version, deletedAt)
+        ? { ok: true, value: { deleted: true } }
+        : { ok: false, reason: "conflict" });
+}
+function control(deps, input, status) {
+    const parsed = scheduleControlSchema.safeParse(input);
+    if (!parsed.success)
+        return { ok: false, reason: "invalid-input" };
+    const previous = scheduleById(deps.db, parsed.data.id);
+    if (!previous)
+        return { ok: false, reason: "not-found" };
+    if (previous.deletedAt !== null)
+        return { ok: false, reason: "conflict" };
+    if (previous.version !== parsed.data.baseVersion ||
+        (previous.status !== "active" && !(status === "canceled" && previous.status === "paused")))
+        return { ok: false, reason: "conflict" };
+    const next = status === "canceled" ? null : previous.nextRunAt;
+    if (!setScheduleStatus(deps.db, previous.id, previous.version, status, next, deps.clock.now().toISOString()))
+        return { ok: false, reason: "conflict" };
+    return { ok: true, value: scheduleById(deps.db, previous.id) };
+}
+function checkTemplate(deps, id, version) {
+    const template = deps.template(id, version);
+    if (!template)
+        return { ok: false, reason: "missing-template" };
+    const sources = template.document.form.sources;
+    const mediaSources = ["audio", "images", "thumbnail"];
+    if (mediaSources.some((kind) => sources[kind] === "provide"))
+        return { ok: false, reason: "unsupported-media" };
+    return { ok: true, value: true };
+}
+function summary(input, nextRunAt, now, status = "active", version = 1) {
+    return {
+        id: input.id,
+        name: input.name,
+        templateId: input.templateId,
+        templateVersion: input.templateVersion,
+        cadence: input.cadence,
+        timezone: input.timezone,
+        missedPolicy: input.missedPolicy,
+        overlapPolicy: input.overlapPolicy,
+        spendLimitCents: input.spendLimitCents,
+        items: input.items,
+        status,
+        version,
+        nextRunAt,
+        createdAt: now,
+        updatedAt: now,
+        deletedAt: null,
+    };
+}