@abot-ai/runtime 1.5.0 → 1.6.0

package/dist/src/runtime/scheduler/contracts.d.ts

@@ -1,4 +1,5 @@
 import type { AgentMode } from "../../shared/types.js";
+import type { AutomationJournalState } from "../automations/storage-records.js";
 import type { SchedulerToolPermissionMode } from "./tool-permission-mode.js";
 export type SchedulerScheduleInput = {
     kind: "timer";
@@ -22,7 +23,12 @@ export type SchedulerScheduleInput = {
     at: string;
     dayOfMonth: number;
 };
+export type SchedulerAutomationScheduleInput = SchedulerScheduleInput | {
+    kind: "manual";
+};
 export type SchedulerSchedule = {
+    kind: "manual";
+} | {
     kind: "timer";
     delayMs: number;
     at: string;
@@ -45,8 +51,15 @@ export type SchedulerSchedule = {
     at: string;
     dayOfMonth: number;
 };
+export type SchedulerTimedSchedule = Exclude<SchedulerSchedule, {
+    kind: "manual";
+}>;
 export type SchedulerJobState = "active" | "paused" | "cancelled" | "completed";
 export interface SchedulerJob {
+    /** Legacy records omit this discriminator and are normalized when loaded. */
+    target?: Readonly<{
+        kind: "request";
+    }>;
     id: string;
     environmentId: string;
     sessionId: string;
@@ -56,6 +69,23 @@ export interface SchedulerJob {
     agentMode: AgentMode;
     toolPermissionMode: SchedulerToolPermissionMode;
     timeZone: string;
+    schedule: SchedulerTimedSchedule;
+    state: SchedulerJobState;
+    createdAt: string;
+    updatedAt: string;
+    nextRunAt: string | null;
+    revision: number;
+}
+export interface SchedulerAutomationJob {
+    id: string;
+    environmentId: string;
+    target: Readonly<{
+        kind: "automation";
+        automationId: string;
+        definitionRevision: number;
+    }>;
+    title: string;
+    timeZone: string;
     schedule: SchedulerSchedule;
     state: SchedulerJobState;
     createdAt: string;
@@ -63,6 +93,15 @@ export interface SchedulerJob {
     nextRunAt: string | null;
     revision: number;
 }
+export type SchedulerStoredJob = SchedulerJob | SchedulerAutomationJob;
+export interface CreateAutomationSchedulerJobInput {
+    automationId: string;
+    definitionRevision: number;
+    title: string;
+    timeZone: string;
+    schedule: SchedulerAutomationScheduleInput;
+}
+export type UpdateAutomationSchedulerJobInput = Partial<Omit<CreateAutomationSchedulerJobInput, "automationId">>;
 export interface CreateSchedulerJobInput {
     toolPermissionMode?: SchedulerToolPermissionMode;
     sessionId: string;
@@ -76,6 +115,10 @@ export interface CreateSchedulerJobInput {
 export type UpdateSchedulerJobInput = Partial<Omit<CreateSchedulerJobInput, "sessionId">>;
 export type SchedulerRunStatus = "pending" | "running" | "succeeded" | "failed" | "cancelled" | "interrupted" | "missed";
 export interface SchedulerRun {
+    /** Legacy records omit this discriminator and are normalized when loaded. */
+    target?: Readonly<{
+        kind: "request";
+    }>;
     /** Omitted by historical runs, which always used Full. */
     toolPermissionMode?: SchedulerToolPermissionMode;
     id: string;
@@ -98,6 +141,77 @@ export interface SchedulerRun {
     resultMessageId?: string;
     error?: string;
 }
+export interface SchedulerAutomationRun {
+    id: string;
+    jobId: string;
+    environmentId: string;
+    target: Readonly<{
+        kind: "automation";
+        automationId: string;
+        definitionRevision: number;
+    }>;
+    title: string;
+    timeZone: string;
+    jobRevision: number;
+    scheduledAt: string;
+    /** Durable actual admission instant; old automation records fall back to scheduledAt. */
+    admittedAt?: string;
+    startedAt?: string;
+    finishedAt?: string;
+    trigger: "schedule" | "manual";
+    idempotencyKey?: string;
+    replayOf?: string;
+    status: SchedulerRunStatus | "stopping" | "completed_with_skips";
+    error?: string;
+    reportRef?: string;
+}
+export type SchedulerStoredRun = SchedulerRun | SchedulerAutomationRun;
+export interface SchedulerAutomationRunOutcome {
+    status: "succeeded" | "completed_with_skips" | "failed" | "cancelled";
+    error?: string;
+    reportRef?: string;
+}
+export interface SchedulerAutomationStartedRun {
+    /** May resolve at the stop-report deadline before underlying effects settle. */
+    outcome: Promise<SchedulerAutomationRunOutcome>;
+    /** Admission remains reserved until every started effect actually settles. */
+    resourcesSettled: Promise<void>;
+}
+export type PreparedAutomationOccurrence = Readonly<{
+    kind: "no_input";
+    /** Commit source-baseline/observation metadata without creating a Run. */
+    commit?(state: AutomationJournalState): void;
+}> | Readonly<{
+    kind: "ready";
+    inputIds: readonly string[];
+    /** Pure durable-state mutation within the scheduler Run claim transaction. */
+    commit(state: AutomationJournalState, runId: string): void;
+    /** Dispose snapshots when a stale preparation never reaches the claim. */
+    discard?(): Promise<void>;
+}> | Readonly<{
+    kind: "failed";
+    error: string;
+    commit(state: AutomationJournalState, runId: string): void;
+}>;
+export interface SchedulerAutomationExecutor {
+    /** Recover internal transcripts under the journal lease before any dispatch. */
+    reconcileSessions?(): Promise<void>;
+    /** Existing scheduler tick drives bounded payload retention without a new timer. */
+    maintainRetention?(now: number): Promise<void>;
+    tryReserve(automationId: string): (() => void) | null | Promise<(() => void) | null>;
+    prepare(job: SchedulerAutomationJob, candidateRunId: string, trigger: SchedulerAutomationRun["trigger"]): Promise<PreparedAutomationOccurrence>;
+    /** Reuse exact retained input versions without mutating the previous claim. */
+    prepareReplay?(job: SchedulerAutomationJob, previousRun: SchedulerAutomationRun, candidateRunId: string): Promise<PreparedAutomationOccurrence>;
+    start(job: SchedulerAutomationJob, run: SchedulerAutomationRun): SchedulerAutomationStartedRun;
+    /** Signal a durable stop intent; remember it if start has not begun yet. */
+    stop(runId: string): void;
+    /** Synchronous state updates, committed atomically with scheduler recovery. */
+    recover(scheduler: SchedulerSnapshot, automations: AutomationJournalState, recoveredRunIds: readonly string[]): void;
+    /** Synchronous report/reference update in the root terminal commit. */
+    settle(run: SchedulerAutomationRun, automations: AutomationJournalState, outcome: SchedulerAutomationRunOutcome): void;
+    /** Release never-dispatched claims and attach a derived report in one commit. */
+    cancelPending(run: SchedulerAutomationRun, automations: AutomationJournalState, reason: "paused" | "republished" | "stopped"): void;
+}
 export interface SchedulerRunOutcome {
     status: "succeeded" | "failed";
     resultText?: string;
@@ -111,14 +225,22 @@ export interface SchedulerExecutor {
 }
 export interface SchedulerSnapshot {
     schemaVersion: 1;
-    jobs: SchedulerJob[];
-    runs: SchedulerRun[];
+    jobs: SchedulerStoredJob[];
+    runs: SchedulerStoredRun[];
 }
 export interface SchedulerStore {
     acquire(): Promise<() => Promise<void>>;
     read(view?: "active"): Promise<SchedulerSnapshot>;
     update<T>(mutate: (state: SchedulerSnapshot) => T, view?: "active"): Promise<T>;
-    readRuns?(jobId?: string, query?: SchedulerRunListQuery): Promise<SchedulerRun[]>;
+    readRuns?(jobId?: string, query?: SchedulerRunListQuery, target?: "request" | "automation"): Promise<SchedulerStoredRun[]>;
+    readRun?(runId: string): Promise<SchedulerStoredRun | null>;
+    readAutomationRunByKey?(automationId: string, idempotencyKey: string): Promise<SchedulerAutomationRun | null>;
+    /** Compact journal-index count; no retained Run payload hydration. */
+    countAutomationRunsOnDay?(automationId: string, timeZone: string, at: number): Promise<number>;
+    /** The automation facet shares this store's owner lease and journal. */
+    readAutomations?(): Promise<AutomationJournalState>;
+    updateAutomations?<T>(mutate: (state: AutomationJournalState) => T): Promise<T>;
+    updateWithAutomations?<T>(mutate: (scheduler: SchedulerSnapshot, automations: AutomationJournalState) => T, view?: "active"): Promise<T>;
 }
 export interface SchedulerListFilter {
     sessionId?: string;
@@ -144,4 +266,22 @@ export interface SchedulerService {
     runNow(jobId: string): Promise<SchedulerRun>;
     deleteSession(sessionId: string): Promise<void>;
     listRuns(jobId?: string, query?: SchedulerRunListQuery): Promise<SchedulerRun[]>;
+    createAutomationJob(input: CreateAutomationSchedulerJobInput, commitPublication?: (state: AutomationJournalState, candidate: SchedulerAutomationJob) => void): Promise<SchedulerAutomationJob>;
+    getAutomationJob(automationId: string): Promise<SchedulerAutomationJob | null>;
+    listAutomationJobs(): Promise<SchedulerAutomationJob[]>;
+    updateAutomationJob(jobId: string, patch: UpdateAutomationSchedulerJobInput, commitPublication?: (state: AutomationJournalState, candidate: SchedulerAutomationJob) => void): Promise<SchedulerAutomationJob>;
+    pauseAutomationJob(jobId: string): Promise<SchedulerAutomationJob>;
+    resumeAutomationJob(jobId: string): Promise<SchedulerAutomationJob>;
+    runNowAutomation(jobId: string, options?: {
+        idempotencyKey?: string;
+    }): Promise<SchedulerAutomationRun>;
+    rerunAutomationRun(previousRunId: string, options: {
+        idempotencyKey: string;
+        confirmed: true;
+        preflight?(job: SchedulerAutomationJob, previousRun: SchedulerAutomationRun): Promise<void>;
+        validateAdmission(state: AutomationJournalState, job: SchedulerAutomationJob, previousRun: SchedulerAutomationRun): void;
+    }): Promise<SchedulerAutomationRun>;
+    stopAutomationRun(runId: string): Promise<SchedulerAutomationRun>;
+    listAutomationRuns(automationId: string, query?: SchedulerRunListQuery): Promise<SchedulerAutomationRun[]>;
+    getAutomationRun(runId: string): Promise<SchedulerAutomationRun | null>;
 }

package/dist/src/runtime/scheduler/file-store.js

@@ -62,12 +62,26 @@ export function createFileSchedulerStore(directory, onCommittedChange) {
             };
         },
         read: (view) => enqueue(() => readJournal((store) => store.snapshot(view))),
-        readRuns: (jobId, query) => enqueue(() => readJournal((store) => store.readRuns(jobId, query))),
+        readRuns: (jobId, query, target) => enqueue(() => readJournal((store) => store.readRuns(jobId, query, target))),
+        readRun: (runId) => enqueue(() => readJournal((store) => store.readRun(runId))),
+        readAutomationRunByKey: (automationId, idempotencyKey) => enqueue(() => readJournal((store) => store.readAutomationRunByKey(automationId, idempotencyKey))),
+        countAutomationRunsOnDay: (automationId, timeZone, at) => enqueue(() => readJournal((store) => store.countAutomationRunsOnDay(automationId, timeZone, at))),
+        readAutomations: () => enqueue(() => readJournal((store) => store.readAutomations())),
         update: (mutate, view) => enqueue(async () => {
             if (!releaseOwner || !journal)
                 throw new Error("scheduler_store_not_owned");
             return journal.update(mutate, view);
         }),
+        updateAutomations: (mutate) => enqueue(async () => {
+            if (!releaseOwner || !journal)
+                throw new Error("scheduler_store_not_owned");
+            return journal.updateAutomations(mutate);
+        }),
+        updateWithAutomations: (mutate, view) => enqueue(async () => {
+            if (!releaseOwner || !journal)
+                throw new Error("scheduler_store_not_owned");
+            return journal.updateWithAutomations(mutate, view);
+        }),
     };
 }
 function isOwnerContention(error) {

package/dist/src/runtime/scheduler/job-management.js

@@ -6,6 +6,7 @@ import { requireRepresentableIntervalRecurrence } from "./interval-range.js";
 import { cancelPendingRuns, findPendingRun, makeSchedulerRun, requireSchedulerJob, } from "./run-records.js";
 import { normalizeSchedulerSchedule, validateSchedulerJobInput, } from "./schedule-validation.js";
 import { invalidateJob, requireRunningScheduler, } from "./service-context.js";
+import { isRequestSchedulerJob, isRequestSchedulerRun, } from "./scheduler-target.js";
 export function createSchedulerJob(context, input) {
     return context.enqueue(async () => {
         requireRunningScheduler(context);
@@ -188,8 +189,8 @@ export function deleteSchedulerSession(context, sessionId) {
         requireRunningScheduler(context);
         context.deletedSessions.add(sessionId);
         await context.store.update((state) => {
-            state.jobs = state.jobs.filter((job) => job.sessionId !== sessionId);
-            state.runs = state.runs.filter((run) => run.sessionId !== sessionId);
+            state.jobs = state.jobs.filter((job) => !isRequestSchedulerJob(job) || job.sessionId !== sessionId);
+            state.runs = state.runs.filter((run) => !isRequestSchedulerRun(run) || run.sessionId !== sessionId);
         });
     })
         .finally(releaseIntent);

package/dist/src/runtime/scheduler/journal-automation-index.d.ts

@@ -0,0 +1,23 @@
+import { type AutomationCollection, type AutomationJournalState } from "../automations/storage-records.js";
+import type { AutomationTransaction } from "./journal-automation-transaction.js";
+type JournalAutomationEntry = {
+    id: string;
+    file: string;
+    offset: number;
+    revision?: number;
+    automationId?: string;
+};
+export type JournalAutomationIndexState = Record<AutomationCollection, JournalAutomationEntry[]>;
+export declare function emptyAutomationIndexState(): JournalAutomationIndexState;
+export declare function encodeAutomationIndexState(state: JournalAutomationIndexState): JournalAutomationIndexState;
+export declare function parseAutomationIndexState(value: unknown, directory: string, sequence: number): JournalAutomationIndexState;
+export declare class JournalAutomationIndex {
+    private readonly records;
+    constructor(state?: JournalAutomationIndexState);
+    exportState(): JournalAutomationIndexState;
+    validate(transaction: AutomationTransaction): void;
+    apply(transaction: AutomationTransaction, file: string): void;
+    snapshot(): Promise<AutomationJournalState>;
+    private collection;
+}
+export {};

package/dist/src/runtime/scheduler/journal-automation-index.js

@@ -0,0 +1,205 @@
+import { readFile } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { AUTOMATION_COLLECTIONS, emptyAutomationJournalState, } from "../automations/storage-records.js";
+import { parseSchedulerTransaction, } from "./journal-transaction.js";
+function corruptIndex() {
+    throw new Error("scheduler_store_corrupt");
+}
+export function emptyAutomationIndexState() {
+    return {
+        drafts: [],
+        definitions: [],
+        savedAgents: [],
+        grants: [],
+        inputs: [],
+        executions: [],
+        attempts: [],
+        results: [],
+    };
+}
+function recordRevision(collection, record) {
+    if (collection === "drafts" && "storageRevision" in record &&
+        record.storageRevision !== undefined)
+        return record.storageRevision;
+    if (collection === "grants" && "grantRevision" in record)
+        return record.grantRevision;
+    return "revision" in record ? record.revision : undefined;
+}
+function recordOwner(record) {
+    return "automationId" in record ? record.automationId : undefined;
+}
+function hasValidTransactionReference(file, sequence) {
+    if (typeof file !== "string" || !/^[0-9]{16}\.json$/.test(file))
+        return false;
+    const transaction = Number(file.slice(0, -5));
+    return (Number.isSafeInteger(transaction) &&
+        transaction >= 1 &&
+        transaction <= sequence);
+}
+export function encodeAutomationIndexState(state) {
+    const encoded = emptyAutomationIndexState();
+    for (const collection of AUTOMATION_COLLECTIONS) {
+        encoded[collection] = state[collection].map((entry) => ({
+            ...entry,
+            file: basename(entry.file),
+        }));
+    }
+    return encoded;
+}
+export function parseAutomationIndexState(value, directory, sequence) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        corruptIndex();
+    const raw = value;
+    const parsed = emptyAutomationIndexState();
+    for (const collection of AUTOMATION_COLLECTIONS) {
+        const records = raw[collection];
+        if (!Array.isArray(records))
+            corruptIndex();
+        const seen = new Set();
+        parsed[collection] = records.map((item) => {
+            if (!item || typeof item !== "object" || Array.isArray(item))
+                corruptIndex();
+            const entry = item;
+            if (typeof entry.id !== "string" || !entry.id)
+                corruptIndex();
+            if (seen.has(entry.id))
+                corruptIndex();
+            seen.add(entry.id);
+            if (!hasValidTransactionReference(entry.file, sequence))
+                corruptIndex();
+            if (!Number.isSafeInteger(entry.offset) || Number(entry.offset) < 0)
+                corruptIndex();
+            if (entry.revision !== undefined &&
+                (!Number.isSafeInteger(entry.revision) || Number(entry.revision) < 1))
+                corruptIndex();
+            if (entry.automationId !== undefined &&
+                (typeof entry.automationId !== "string" || !entry.automationId))
+                corruptIndex();
+            return {
+                id: entry.id,
+                file: join(directory, entry.file),
+                offset: Number(entry.offset),
+                ...(entry.revision === undefined
+                    ? {}
+                    : { revision: Number(entry.revision) }),
+                ...(entry.automationId === undefined
+                    ? {}
+                    : { automationId: entry.automationId }),
+            };
+        });
+    }
+    if (Object.keys(raw).some((key) => !AUTOMATION_COLLECTIONS.includes(key)))
+        corruptIndex();
+    return parsed;
+}
+export class JournalAutomationIndex {
+    records = new Map();
+    constructor(state = emptyAutomationIndexState()) {
+        for (const collection of AUTOMATION_COLLECTIONS) {
+            this.records.set(collection, new Map(state[collection].map((entry) => [entry.id, entry])));
+        }
+    }
+    exportState() {
+        const state = emptyAutomationIndexState();
+        for (const collection of AUTOMATION_COLLECTIONS)
+            state[collection] = structuredClone([
+                ...this.collection(collection).values(),
+            ]);
+        return state;
+    }
+    validate(transaction) {
+        for (const collection of AUTOMATION_COLLECTIONS) {
+            const delta = transaction[collection];
+            if (!delta)
+                continue;
+            const before = this.collection(collection);
+            const next = new Map(before);
+            for (const id of delta.deleted)
+                next.delete(id);
+            for (const record of delta.upsert) {
+                const previous = before.get(record.id);
+                const revision = recordRevision(collection, record);
+                if (previous?.automationId &&
+                    previous.automationId !== recordOwner(record))
+                    corruptIndex();
+                if (previous &&
+                    ["definitions", "savedAgents", "results"].includes(collection))
+                    corruptIndex();
+                if (previous?.revision !== undefined &&
+                    revision !== undefined &&
+                    revision <= previous.revision)
+                    corruptIndex();
+                next.set(record.id, {
+                    id: record.id,
+                    file: "",
+                    offset: 0,
+                    ...(revision === undefined ? {} : { revision }),
+                    ...(recordOwner(record) === undefined
+                        ? {}
+                        : { automationId: recordOwner(record) }),
+                });
+            }
+            if (delta.order && !containsEveryEntry(next, delta.order))
+                corruptIndex();
+        }
+    }
+    apply(transaction, file) {
+        this.validate(transaction);
+        for (const collection of AUTOMATION_COLLECTIONS) {
+            const delta = transaction[collection];
+            if (!delta)
+                continue;
+            const entries = this.collection(collection);
+            for (const id of delta.deleted)
+                entries.delete(id);
+            delta.upsert.forEach((record, offset) => {
+                entries.set(record.id, {
+                    id: record.id,
+                    file,
+                    offset,
+                    ...(recordRevision(collection, record) === undefined
+                        ? {}
+                        : { revision: recordRevision(collection, record) }),
+                    ...(recordOwner(record) === undefined
+                        ? {}
+                        : { automationId: recordOwner(record) }),
+                });
+            });
+            if (!delta.order)
+                continue;
+            this.records.set(collection, new Map(delta.order.map((id) => [id, entries.get(id)])));
+        }
+    }
+    async snapshot() {
+        const state = emptyAutomationJournalState();
+        const files = new Map();
+        for (const collection of AUTOMATION_COLLECTIONS) {
+            for (const entry of this.collection(collection).values()) {
+                let loaded = files.get(entry.file);
+                if (!loaded) {
+                    loaded = readFile(entry.file, "utf8").then((text) => parseSchedulerTransaction(JSON.parse(text)));
+                    files.set(entry.file, loaded);
+                }
+                const record = (await loaded).automation?.[collection]?.upsert[entry.offset];
+                if (!record || record.id !== entry.id)
+                    corruptIndex();
+                if (recordRevision(collection, record) !== entry.revision)
+                    corruptIndex();
+                if (recordOwner(record) !== entry.automationId)
+                    corruptIndex();
+                state[collection].push(structuredClone(record));
+            }
+        }
+        return state;
+    }
+    collection(collection) {
+        return this.records.get(collection);
+    }
+}
+function containsEveryEntry(entries, order) {
+    if (entries.size !== order.length)
+        return false;
+    if (new Set(order).size !== order.length)
+        return false;
+    return order.every((id) => entries.has(id));
+}

package/dist/src/runtime/scheduler/journal-automation-transaction.d.ts

@@ -0,0 +1,11 @@
+import { type AutomationCollection, type AutomationJournalState, type AutomationStoredRecord } from "../automations/storage-records.js";
+export type AutomationCollectionDelta = {
+    upsert: AutomationStoredRecord[];
+    deleted: string[];
+    order?: string[];
+};
+export type AutomationTransaction = Partial<Record<AutomationCollection, AutomationCollectionDelta>>;
+export declare function parseAutomationTransaction(value: unknown): AutomationTransaction;
+export declare function automationTransaction(before: AutomationJournalState, after: AutomationJournalState): AutomationTransaction;
+export declare function hasAutomationTransactionChanges(value: AutomationTransaction): boolean;
+export declare function hasAutomationRemovals(value: AutomationTransaction): boolean;

package/dist/src/runtime/scheduler/journal-automation-transaction.js

@@ -0,0 +1,90 @@
+import { AUTOMATION_COLLECTIONS, parseAutomationStoredRecord, } from "../automations/storage-records.js";
+function corruptTransaction() {
+    throw new Error("scheduler_store_corrupt");
+}
+function requireIds(value) {
+    if (!Array.isArray(value))
+        corruptTransaction();
+    if (!value.every((id) => typeof id === "string" && id.length > 0))
+        corruptTransaction();
+    if (new Set(value).size !== value.length)
+        corruptTransaction();
+    return [...value];
+}
+export function parseAutomationTransaction(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        corruptTransaction();
+    const raw = value;
+    if (Object.keys(raw).some((key) => !AUTOMATION_COLLECTIONS.includes(key)))
+        corruptTransaction();
+    const parsed = {};
+    for (const collection of AUTOMATION_COLLECTIONS) {
+        const candidate = raw[collection];
+        if (candidate === undefined)
+            continue;
+        if (!candidate || typeof candidate !== "object" || Array.isArray(candidate))
+            corruptTransaction();
+        const delta = candidate;
+        if (!Array.isArray(delta.upsert))
+            corruptTransaction();
+        const upsert = delta.upsert.map((record) => parseAutomationStoredRecord(collection, record));
+        const deleted = requireIds(delta.deleted);
+        const order = delta.order === undefined ? undefined : requireIds(delta.order);
+        const ids = upsert.map((record) => record.id);
+        if (new Set(ids).size !== ids.length)
+            corruptTransaction();
+        if (ids.some((id) => deleted.includes(id)))
+            corruptTransaction();
+        parsed[collection] = {
+            upsert,
+            deleted,
+            ...(order === undefined ? {} : { order }),
+        };
+    }
+    return parsed;
+}
+function changedRecords(before, after) {
+    const originals = new Map(before.map((record) => [record.id, record]));
+    return after.filter((record) => JSON.stringify(originals.get(record.id)) !== JSON.stringify(record));
+}
+function changedOrder(before, after) {
+    const order = after.map((record) => record.id);
+    if (before.length !== order.length)
+        return order;
+    return before.some((record, index) => record.id !== order[index])
+        ? order
+        : undefined;
+}
+export function automationTransaction(before, after) {
+    const delta = {};
+    for (const collection of AUTOMATION_COLLECTIONS) {
+        const previous = before[collection];
+        const next = after[collection];
+        const retained = new Set(next.map((record) => record.id));
+        const deleted = previous
+            .filter((record) => !retained.has(record.id))
+            .map((record) => record.id);
+        const upsert = changedRecords(previous, next);
+        const order = changedOrder(previous, next);
+        if (!upsert.length && !deleted.length && !order)
+            continue;
+        delta[collection] = {
+            upsert,
+            deleted,
+            ...(order ? { order } : {}),
+        };
+    }
+    return delta;
+}
+export function hasAutomationTransactionChanges(value) {
+    return AUTOMATION_COLLECTIONS.some((collection) => {
+        const delta = value[collection];
+        return (!!delta &&
+            (delta.upsert.length > 0 ||
+                delta.deleted.length > 0 ||
+                delta.order !== undefined));
+    });
+}
+export function hasAutomationRemovals(value) {
+    return AUTOMATION_COLLECTIONS.some((collection) => (value[collection]?.deleted.length ?? 0) > 0);
+}

package/dist/src/runtime/scheduler/journal-checkpoint.js

@@ -9,7 +9,10 @@ import { syncJournalDirectory } from "./journal-durability.js";
 export async function loadCheckpointJournalIndex(directory, head) {
     const generationDirectory = join(directory, head.generation);
     const checkpointPath = join(generationDirectory, "checkpoints", head.checkpoint.file);
-    const state = parseJournalIndexState(JSON.parse(await readFile(checkpointPath, "utf8")), generationDirectory, head.generation, head.checkpoint.sequence);
+    const checkpoint = JSON.parse(await readFile(checkpointPath, "utf8"));
+    if (checkpoint?.version !== head.schemaVersion - 2)
+        throw new Error("scheduler_store_corrupt");
+    const state = parseJournalIndexState(checkpoint, generationDirectory, head.generation, head.checkpoint.sequence);
     const index = new SchedulerJournalIndex(state);
     for (let sequence = head.checkpoint.sequence + 1; sequence <= head.sequence; sequence++) {
         const file = join(generationDirectory, journalTransactionName(sequence));
@@ -26,7 +29,7 @@ export async function writeJournalCheckpoint(directory, generation, sequence, in
     parseJournalIndexState(state, join(directory, generation), generation, sequence);
     await writeJournalJson(join(checkpointDirectory, file), state);
     return {
-        schemaVersion: 3,
+        schemaVersion: 4,
         generation,
         sequence,
         checkpoint: { file, sequence },

package/dist/src/runtime/scheduler/journal-head.d.ts

@@ -10,7 +10,7 @@ export type JournalHead = {
     generation: string;
 } | CommittedJournalHead;
 export type CommittedJournalHead = {
-    schemaVersion: 3;
+    schemaVersion: 3 | 4;
     generation: string;
     sequence: number;
     checkpoint: JournalCheckpointReference;

package/dist/src/runtime/scheduler/journal-head.js

@@ -22,7 +22,7 @@ function parseJournalHead(value) {
         corruptJournalHead();
     if (value.schemaVersion === 2)
         return { schemaVersion: 2, generation: value.generation };
-    if (value.schemaVersion !== 3)
+    if (value.schemaVersion !== 3 && value.schemaVersion !== 4)
         corruptJournalHead();
     if (!isJournalSequence(value.sequence))
         corruptJournalHead();
@@ -36,7 +36,7 @@ function parseJournalHead(value) {
     if (!hasBoundedJournalSuffix(value.sequence, checkpoint.sequence))
         corruptJournalHead();
     return {
-        schemaVersion: 3,
+        schemaVersion: value.schemaVersion,
         generation: value.generation,
         sequence: value.sequence,
         checkpoint: {