@gentbajko/slopify 0.8.4 → 1.0.0

package/dist/slices/revisions/schema.js

@@ -0,0 +1,160 @@
+import { z } from "zod";
+import { stageKinds } from "../../kernel/pipeline.js";
+import { pieceKinds, pieceStates } from "../../kernel/runner/piece-repo.js";
+import { runConfigSchema } from "../admission/schema.js";
+import { outputSchema } from "../storage/schema.js";
+const id = z
+    .string()
+    .min(1)
+    .max(64)
+    .regex(/^[0-9A-Za-z_-]+$/);
+const workKey = z.string().min(1).max(256);
+const tokens = z.record(workKey, id);
+const cue = z
+    .object({
+    id,
+    text: z.string().trim().min(1).max(10000),
+    start: z.number().finite().nonnegative(),
+    end: z.number().finite().positive(),
+})
+    .strict()
+    .refine((value) => value.end > value.start, {
+    path: ["end"],
+    message: "End must be after start.",
+});
+export const revisionContentSchema = z
+    .object({
+    articleMarkdown: z.string().max(500000).optional(),
+    articleEdited: z.boolean().default(false),
+    provided: z
+        .object({
+        research: id.optional(),
+        article: id.optional(),
+        audio: id.optional(),
+        thumbnail: id.optional(),
+    })
+        .strict(),
+    imageOrder: z.array(id).max(60),
+    imageDefinitions: z.record(id, z
+        .object({
+        source: z.enum(["generate", "provide"]),
+        assetId: id.nullable(),
+        prompt: z.string().max(500000).nullable(),
+        templateKey: z.string().min(1).max(256).nullable().optional(),
+    })
+        .strict()),
+    narrationOverrides: z.record(workKey, z.discriminatedUnion("kind", [
+        z.object({ kind: z.literal("asset"), assetId: id }).strict(),
+        z.object({ kind: z.literal("text"), text: z.string().trim().min(1).max(500000) }).strict(),
+    ])),
+    subtitleCues: z
+        .object({
+        audioFingerprint: z.string().min(1),
+        cues: z.array(cue),
+    })
+        .strict()
+        .optional(),
+    regenerationTokens: tokens,
+    promptTemplates: z.record(z.string().min(1), z.string().max(500000).nullable()),
+})
+    .strict();
+export const revisionEditSchema = z
+    .object({
+    config: runConfigSchema.strict(),
+    content: revisionContentSchema,
+    regenerate: z.array(workKey).optional(),
+    uploads: z
+        .array(z
+        .object({
+        stagedFileId: id,
+        destination: z.discriminatedUnion("kind", [
+            z
+                .object({ kind: z.literal("provided"), stage: z.enum(["audio", "thumbnail"]) })
+                .strict(),
+            z.object({ kind: z.literal("image"), imageKey: id }).strict(),
+            z.object({ kind: z.literal("narration"), key: workKey }).strict(),
+        ]),
+    })
+        .strict())
+        .max(10000)
+        .optional(),
+})
+    .strict();
+export const saveRevisionSchema = z
+    .object({
+    baseRevisionId: id,
+    idempotencyKey: id,
+    edit: revisionEditSchema,
+})
+    .strict();
+export const restoreRevisionSchema = z
+    .object({
+    baseRevisionId: id,
+    idempotencyKey: id,
+    targetRevisionId: id,
+})
+    .strict();
+export const projectRevisionSchema = z.object({
+    id,
+    projectId: id,
+    parentId: id.nullable(),
+    restoredFromId: id.nullable(),
+    config: runConfigSchema,
+    content: revisionContentSchema,
+    fingerprints: z.record(workKey, z.string()),
+    createdAt: z.string(),
+});
+export const stagePieceSchema = z.object({
+    id,
+    stageId: id,
+    kind: z.enum(pieceKinds),
+    idx: z.number().int(),
+    state: z.enum(pieceStates),
+    payload: z.string().nullable(),
+});
+const manifestOutputSchema = z.object({
+    slot: z.string(),
+    workKey,
+    assetId: id,
+    output: outputSchema,
+    fingerprint: z.string(),
+    state: z.enum(["ready", "outdated", "review"]),
+});
+const manifestPieceSchema = z.object({
+    key: workKey,
+    stageKind: z.enum(stageKinds),
+    piece: stagePieceSchema,
+    assetId: id.nullable(),
+    fingerprint: z.string(),
+});
+const viewFields = {
+    recordId: id,
+    publicationId: id.nullable(),
+    selected: z.boolean(),
+    available: z.boolean(),
+};
+export const revisionViewSchema = z.object({
+    articleMarkdown: z.string().nullable(),
+    revision: projectRevisionSchema,
+    outputs: z.array(manifestOutputSchema.extend(viewFields)),
+    pieces: z.array(manifestPieceSchema.extend(viewFields)),
+    current: z.boolean(),
+});
+export const revisionSummarySchema = z.object({
+    id,
+    parentId: id.nullable(),
+    restoredFromId: id.nullable(),
+    title: z.string(),
+    createdAt: z.string(),
+    current: z.boolean(),
+});
+export const revisionMutationSuccessSchema = z.object({
+    ok: z.literal(true),
+    view: revisionViewSchema,
+    duplicate: z.boolean(),
+});
+export const baselineSuccessSchema = z.object({
+    ok: z.literal(true),
+    view: revisionViewSchema,
+    created: z.boolean(),
+});

package/dist/slices/revisions/view.js

@@ -0,0 +1,44 @@
+import { readFileSync, statSync } from "node:fs";
+import { z } from "zod";
+import { outputPath } from "../storage/layout.js";
+import { currentRevisionId, outputsForRevision, piecesForRevision, revisionById } from "./repo.js";
+export function getRevisionView(deps, projectId, revisionId) {
+    const revision = revisionById(deps.db, projectId, revisionId);
+    if (revision === undefined)
+        return undefined;
+    const available = (assetId) => {
+        const row = deps.db
+            .prepare("SELECT path FROM project_assets WHERE project_id=? AND id=?")
+            .get(projectId, assetId);
+        if (row === undefined)
+            throw new Error(`Revision asset ${assetId} is not registered.`);
+        const path = z.object({ path: z.string() }).parse(row).path;
+        return (statSync(outputPath(deps.paths, projectId, path), { throwIfNoEntry: false })?.isFile() ===
+            true);
+    };
+    const outputs = outputsForRevision(deps.db, projectId, revisionId).map((row) => ({
+        ...row,
+        available: available(row.assetId),
+    }));
+    const pieces = piecesForRevision(deps.db, projectId, revisionId).map((row) => ({
+        ...row,
+        available: row.assetId === null || available(row.assetId),
+    }));
+    return {
+        revision,
+        outputs,
+        pieces,
+        current: currentRevisionId(deps.db, projectId) === revisionId,
+        articleMarkdown: resolvedArticleMarkdown(deps, revision, outputs),
+    };
+}
+export function resolvedArticleMarkdown(deps, revision, outputs) {
+    if (revision.content.articleEdited === true && revision.content.articleMarkdown !== undefined)
+        return revision.content.articleMarkdown;
+    const article = outputs.find((one) => one.selected && one.available && one.output.role === "article_md");
+    if (article !== undefined)
+        return readFileSync(outputPath(deps.paths, revision.projectId, article.output.path), "utf8");
+    return revision.config.sources.article === "provide"
+        ? (revision.config.provided.article ?? null)
+        : null;
+}

package/dist/slices/schedules/calendar.js

@@ -0,0 +1,47 @@
+/// <reference lib="esnext.temporal" />
+import { z } from "zod";
+export const cadenceSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("once"), at: z.string().datetime({ offset: true }) }).strict(),
+    z
+        .object({ kind: z.literal("daily"), time: z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/) })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("weekly"),
+        time: z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/),
+        days: z.array(z.number().int().min(0).max(6)).min(1).max(7).readonly(),
+    })
+        .strict(),
+]);
+export function validTimeZone(timeZone) {
+    try {
+        new Intl.DateTimeFormat("en", { timeZone }).format();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function nextOccurrence(cadence, timeZone, now) {
+    if (!validTimeZone(timeZone))
+        return null;
+    if (cadence.kind === "once") {
+        const at = new Date(cadence.at);
+        return Number.isNaN(at.valueOf()) || at <= now ? null : at;
+    }
+    const current = Temporal.Instant.fromEpochMilliseconds(now.valueOf())
+        .toZonedDateTimeISO(timeZone)
+        .toPlainDate();
+    const wanted = Temporal.PlainTime.from(cadence.time);
+    for (let offset = 0; offset <= 8; offset++) {
+        const day = current.add({ days: offset });
+        if (cadence.kind === "weekly" && !cadence.days.includes(day.dayOfWeek % 7))
+            continue;
+        const candidate = day.toPlainDateTime(wanted).toZonedDateTime(timeZone, {
+            disambiguation: "compatible",
+        });
+        if (candidate.epochMilliseconds > now.valueOf())
+            return new Date(candidate.epochMilliseconds);
+    }
+    return null;
+}

package/dist/slices/schedules/model.js

@@ -0,0 +1 @@
+export {};

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;
+    }
+}