@abot-ai/runtime 1.5.0 → 1.6.0

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

@@ -1,31 +1,42 @@
-import type { SchedulerJob, SchedulerRun } from "./contracts.js";
-export type JournalRunEntry = Pick<SchedulerRun, "id" | "jobId" | "sessionId" | "environmentId" | "jobRevision" | "scheduledAt" | "requestId" | "status"> & {
+import type { SchedulerStoredJob, SchedulerStoredRun } from "./contracts.js";
+import { type JournalAutomationIndexState } from "./journal-automation-index.js";
+export type JournalRunEntry = Pick<SchedulerStoredRun, "id" | "jobId" | "environmentId" | "jobRevision" | "scheduledAt" | "status"> & {
+    target?: SchedulerStoredRun["target"];
+    sessionId?: string;
+    requestId?: string;
+    idempotencyKey?: string;
+    admittedAt?: string;
     file: string;
     offset: number;
-    active?: SchedulerRun;
+    active?: SchedulerStoredRun;
 };
 export type JournalIndexState = {
-    jobs: SchedulerJob[];
+    jobs: SchedulerStoredJob[];
     runs: JournalRunEntry[];
+    automations: JournalAutomationIndexState;
 };
 export declare function encodeJournalIndexState(state: JournalIndexState, generation: string, sequence: number): {
     version: number;
     generation: string;
     sequence: number;
-    jobs: SchedulerJob[];
+    jobs: SchedulerStoredJob[];
     runs: {
         file: string;
         id: string;
-        requestId: string;
-        sessionId: string;
         environmentId: string;
-        status: import("./contracts.js").SchedulerRunStatus;
+        status: import("./contracts.js").SchedulerRunStatus | "stopping" | "completed_with_skips";
         jobId: string;
         scheduledAt: string;
         jobRevision: number;
+        target?: SchedulerStoredRun["target"];
+        sessionId?: string;
+        requestId?: string;
+        idempotencyKey?: string;
+        admittedAt?: string;
         offset: number;
-        active?: SchedulerRun;
+        active?: SchedulerStoredRun;
     }[];
+    automations: JournalAutomationIndexState;
 };
 export declare function parseJournalIndexState(value: unknown, directory: string, generation: string, sequence: number): JournalIndexState;
-export declare function matchesIndexedJournalRun(run: SchedulerRun | undefined, entry: JournalRunEntry): run is SchedulerRun;
+export declare function matchesIndexedJournalRun(run: SchedulerStoredRun | undefined, entry: JournalRunEntry): run is SchedulerStoredRun;

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

@@ -1,18 +1,21 @@
 import { basename, join } from "node:path";
+import { isAutomationSchedulerJob, isAutomationSchedulerRun, } from "./scheduler-target.js";
 import { parseStoredJob, parseStoredRun } from "./snapshot-validation.js";
+import { emptyAutomationIndexState, encodeAutomationIndexState, parseAutomationIndexState, } from "./journal-automation-index.js";
 export function encodeJournalIndexState(state, generation, sequence) {
     return {
-        version: 1,
+        version: 2,
         generation,
         sequence,
         jobs: state.jobs,
         runs: state.runs.map((entry) => ({ ...entry, file: basename(entry.file) })),
+        automations: encodeAutomationIndexState(state.automations),
     };
 }
 export function parseJournalIndexState(value, directory, generation, sequence) {
     if (!isIndexObject(value))
         corruptJournalIndex();
-    if (value.version !== 1)
+    if (value.version !== 1 && value.version !== 2)
         corruptJournalIndex();
     if (value.generation !== generation)
         corruptJournalIndex();
@@ -29,24 +32,36 @@ export function parseJournalIndexState(value, directory, generation, sequence) {
     const runs = value.runs.map((entry) => parseJournalRunEntry(entry, directory, sequence, owners));
     if (new Set(runs.map((entry) => entry.id)).size !== runs.length)
         corruptJournalIndex();
-    return { jobs, runs };
+    const automations = value.version === 1
+        ? emptyAutomationIndexState()
+        : parseAutomationIndexState(value.automations, directory, sequence);
+    return { jobs, runs, automations };
 }
 function parseJournalRunEntry(value, directory, sequence, jobs) {
     if (!isIndexObject(value))
         corruptJournalIndex();
-    for (const field of [
-        "id",
-        "jobId",
-        "sessionId",
-        "environmentId",
-        "requestId",
-        "scheduledAt",
-    ]) {
+    for (const field of ["id", "jobId", "environmentId", "scheduledAt"]) {
         if (typeof value[field] !== "string")
             corruptJournalIndex();
     }
+    if (!hasIndexedRunTarget(value))
+        corruptJournalIndex();
+    if (value.idempotencyKey !== undefined) {
+        if (value.target === undefined || !isIndexObject(value.target))
+            corruptJournalIndex();
+        if (value.target.kind !== "automation")
+            corruptJournalIndex();
+        if (!isValidIdempotencyKey(value.idempotencyKey))
+            corruptJournalIndex();
+    }
     if (!Number.isFinite(Date.parse(String(value.scheduledAt))))
         corruptJournalIndex();
+    if (value.admittedAt !== undefined) {
+        if (!isIndexObject(value.target) || value.target.kind !== "automation" ||
+            typeof value.admittedAt !== "string" ||
+            !Number.isFinite(Date.parse(value.admittedAt)))
+            corruptJournalIndex();
+    }
     if (!isPositiveIndexInteger(value.jobRevision))
         corruptJournalIndex();
     if (!isNonnegativeIndexInteger(value.offset))
@@ -76,24 +91,63 @@ export function matchesIndexedJournalRun(run, entry) {
     const fields = [
         "id",
         "jobId",
-        "sessionId",
         "environmentId",
         "jobRevision",
         "scheduledAt",
-        "requestId",
         "status",
     ];
-    return fields.every((field) => run[field] === entry[field]);
+    if (!fields.every((field) => run[field] === entry[field]))
+        return false;
+    if (isAutomationSchedulerRun(run)) {
+        if (entry.target?.kind !== "automation")
+            return false;
+        if (run.target.automationId !== entry.target.automationId)
+            return false;
+        return run.target.definitionRevision === entry.target.definitionRevision &&
+            run.idempotencyKey === entry.idempotencyKey &&
+            run.admittedAt === entry.admittedAt;
+    }
+    if (entry.target?.kind === "automation")
+        return false;
+    return run.sessionId === entry.sessionId && run.requestId === entry.requestId;
 }
 function requireIndexedRunOwner(entry, job) {
     if (!job)
         corruptJournalIndex();
-    if (entry.sessionId !== job.sessionId)
-        corruptJournalIndex();
     if (entry.environmentId !== job.environmentId)
         corruptJournalIndex();
     if (entry.jobRevision > job.revision)
         corruptJournalIndex();
+    if (isAutomationSchedulerJob(job)) {
+        if (entry.target?.kind !== "automation")
+            corruptJournalIndex();
+        if (entry.target.automationId !== job.target.automationId)
+            corruptJournalIndex();
+        if (entry.target.definitionRevision > job.target.definitionRevision)
+            corruptJournalIndex();
+        return;
+    }
+    if (entry.target?.kind === "automation")
+        corruptJournalIndex();
+    if (entry.sessionId !== job.sessionId)
+        corruptJournalIndex();
+}
+function hasIndexedRunTarget(value) {
+    if (value.target === undefined) {
+        return typeof value.sessionId === "string" && typeof value.requestId === "string";
+    }
+    if (!isIndexObject(value.target))
+        return false;
+    if (value.target.kind === "request") {
+        return typeof value.sessionId === "string" && typeof value.requestId === "string";
+    }
+    if (value.target.kind !== "automation")
+        return false;
+    if (typeof value.target.automationId !== "string")
+        return false;
+    if (!isPositiveIndexInteger(value.target.definitionRevision))
+        return false;
+    return value.sessionId === undefined && value.requestId === undefined;
 }
 function isIndexObject(value) {
     if (value === null || typeof value !== "object")
@@ -103,6 +157,9 @@ function isIndexObject(value) {
 function isPositiveIndexInteger(value) {
     return Number.isSafeInteger(value) && Number(value) >= 1;
 }
+function isValidIdempotencyKey(value) {
+    return typeof value === "string" && value.length > 0 && value.length <= 128;
+}
 function isNonnegativeIndexInteger(value) {
     return Number.isSafeInteger(value) && Number(value) >= 0;
 }
@@ -122,7 +179,9 @@ function isIndexedRunStatus(value) {
     return [
         "pending",
         "running",
+        "stopping",
         "succeeded",
+        "completed_with_skips",
         "failed",
         "cancelled",
         "interrupted",
@@ -130,7 +189,7 @@ function isIndexedRunStatus(value) {
     ].includes(value);
 }
 function requiresActiveRunPayload(status) {
-    return status === "pending" || status === "running";
+    return status === "pending" || status === "running" || status === "stopping";
 }
 function corruptJournalIndex() {
     throw new Error("scheduler_store_corrupt");

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

@@ -1,10 +1,12 @@
-import type { SchedulerRun, SchedulerRunListQuery, SchedulerSnapshot } from "./contracts.js";
+import type { AutomationJournalState } from "../automations/storage-records.js";
+import type { SchedulerRunListQuery, SchedulerSnapshot, SchedulerStoredRun } from "./contracts.js";
 import { type SchedulerTransaction } from "./journal-transaction.js";
 import { type JournalIndexState } from "./journal-index-state.js";
 export declare class SchedulerJournalIndex {
     private jobs;
     private runs;
     private active;
+    private automations;
     constructor(state?: JournalIndexState);
     exportState(): JournalIndexState;
     validate(transaction: SchedulerTransaction): void;
@@ -15,8 +17,12 @@ export declare class SchedulerJournalIndex {
     private updateActiveRun;
     private applyRunOrder;
     snapshot(view?: "active"): Promise<SchedulerSnapshot>;
-    readRuns(jobId?: string, query?: SchedulerRunListQuery): Promise<SchedulerRun[]>;
+    readAutomations(): Promise<AutomationJournalState>;
+    readRuns(jobId?: string, query?: SchedulerRunListQuery, target?: "request" | "automation"): Promise<SchedulerStoredRun[]>;
+    readRun(runId: string): Promise<SchedulerStoredRun | null>;
+    readAutomationRunByKey(automationId: string, idempotencyKey: string): Promise<import("./contracts.js").SchedulerAutomationRun | null>;
+    countAutomationRunsOnDay(automationId: string, timeZone: string, at: number): number;
     private removeRun;
     private removeJob;
 }
-export declare function isActiveSchedulerRun(run: SchedulerRun): boolean;
+export declare function isActiveSchedulerRun(run: SchedulerStoredRun): boolean;

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

@@ -1,12 +1,17 @@
 import { readFile } from "node:fs/promises";
+import { isAutomationSchedulerJob, isAutomationSchedulerRun, schedulerTargetKey, } from "./scheduler-target.js";
 import { assertJournalTransactionIds, parseSchedulerTransaction, } from "./journal-transaction.js";
 import { querySchedulerRuns } from "./run-list-query.js";
+import { calendarDateAt } from "./calendar-time.js";
 import { matchesIndexedJournalRun, } from "./journal-index-state.js";
+import { JournalAutomationIndex } from "./journal-automation-index.js";
 export class SchedulerJournalIndex {
     jobs = new Map();
     runs = new Map();
     active = new Map();
+    automations;
     constructor(state) {
+        this.automations = new JournalAutomationIndex(state?.automations);
         if (!state)
             return;
         const detached = structuredClone(state);
@@ -21,6 +26,7 @@ export class SchedulerJournalIndex {
         return structuredClone({
             jobs: [...this.jobs.values()],
             runs: [...this.runs.values()],
+            automations: this.automations.exportState(),
         });
     }
     validate(transaction) {
@@ -37,6 +43,8 @@ export class SchedulerJournalIndex {
             assertJournalOrder(jobs, transaction.jobOrder);
         if (transaction.runOrder)
             assertJournalOrder(this.prospectiveRunIds(transaction), transaction.runOrder);
+        if (transaction.automation)
+            this.automations.validate(transaction.automation);
     }
     validateChangedJobHistory(transaction) {
         const changed = new Map(transaction.jobs
@@ -80,19 +88,23 @@ export class SchedulerJournalIndex {
         if (transaction.jobOrder)
             this.jobs = orderedJournalRecords(this.jobs, transaction.jobOrder);
         this.applyRunOrder(transaction.runOrder);
+        if (transaction.automation)
+            this.automations.apply(transaction.automation, file);
     }
     applyRun(run, file, offset) {
         const entry = {
             id: run.id,
             jobId: run.jobId,
-            sessionId: run.sessionId,
             environmentId: run.environmentId,
             jobRevision: run.jobRevision,
             scheduledAt: run.scheduledAt,
-            requestId: run.requestId,
             status: run.status,
             file,
             offset,
+            ...(isAutomationSchedulerRun(run)
+                ? { target: run.target, idempotencyKey: run.idempotencyKey,
+                    admittedAt: run.admittedAt }
+                : { sessionId: run.sessionId, requestId: run.requestId }),
         };
         this.updateActiveRun(run, entry);
         this.runs.set(run.id, entry);
@@ -120,8 +132,17 @@ export class SchedulerJournalIndex {
                 : await this.readRuns(),
         };
     }
-    async readRuns(jobId, query) {
-        const selected = querySchedulerRuns([...this.runs.values()], jobId, query);
+    async readAutomations() {
+        return this.automations.snapshot();
+    }
+    async readRuns(jobId, query, target) {
+        const scoped = [...this.runs.values()].filter((entry) => {
+            if (!target)
+                return true;
+            const kind = entry.target?.kind ?? "request";
+            return kind === target;
+        });
+        const selected = querySchedulerRuns(scoped, jobId, query);
         const files = new Map();
         const result = [];
         for (const entry of selected) {
@@ -141,6 +162,47 @@ export class SchedulerJournalIndex {
         }
         return result;
     }
+    async readRun(runId) {
+        const entry = this.runs.get(runId);
+        if (!entry)
+            return null;
+        if (entry.active)
+            return structuredClone(entry.active);
+        const transaction = parseSchedulerTransaction(JSON.parse(await readFile(entry.file, "utf8")));
+        const run = transaction.runs[entry.offset];
+        if (!matchesIndexedJournalRun(run, entry))
+            throw new Error("scheduler_store_corrupt");
+        return structuredClone(run);
+    }
+    async readAutomationRunByKey(automationId, idempotencyKey) {
+        const entry = [...this.runs.values()].find((item) => item.target?.kind === "automation" &&
+            item.target.automationId === automationId &&
+            item.idempotencyKey === idempotencyKey);
+        if (!entry)
+            return null;
+        const run = await this.readRun(entry.id);
+        if (!run || !isAutomationSchedulerRun(run))
+            throw new Error("scheduler_store_corrupt");
+        return run;
+    }
+    countAutomationRunsOnDay(automationId, timeZone, at) {
+        const day = calendarDateAt(at, timeZone);
+        let count = 0;
+        for (const entry of this.runs.values()) {
+            if (entry.target?.kind !== "automation" ||
+                entry.target.automationId !== automationId ||
+                entry.status === "missed")
+                continue;
+            const admittedAt = Date.parse(entry.admittedAt ?? entry.scheduledAt);
+            if (Math.abs(admittedAt - at) > 48 * 60 * 60_000)
+                continue;
+            const admittedDay = calendarDateAt(admittedAt, timeZone);
+            if (admittedDay.year === day.year && admittedDay.month === day.month &&
+                admittedDay.day === day.day)
+                count += 1;
+        }
+        return count;
+    }
     removeRun(id) {
         this.runs.delete(id);
         this.active.delete(id);
@@ -154,7 +216,9 @@ export class SchedulerJournalIndex {
     }
 }
 export function isActiveSchedulerRun(run) {
-    return run.status === "pending" || run.status === "running";
+    if (run.status === "pending" || run.status === "running")
+        return true;
+    return run.status === "stopping";
 }
 function orderedJournalRecords(records, order) {
     assertJournalOrder(records, order);
@@ -174,7 +238,7 @@ function containsEveryJournalRecord(records, order) {
 function requiresJournalHistoryValidation(previous, next) {
     if (!previous)
         return false;
-    if (previous.sessionId !== next.sessionId)
+    if (schedulerTargetKey(previous) !== schedulerTargetKey(next))
         return true;
     if (previous.environmentId !== next.environmentId)
         return true;
@@ -187,9 +251,20 @@ function assertJournalRunOwner(run, job) {
 function hasConsistentJournalRunOwner(run, job) {
     if (!job)
         return false;
-    if (run.sessionId !== job.sessionId)
-        return false;
     if (run.environmentId !== job.environmentId)
         return false;
-    return run.jobRevision <= job.revision;
+    if (run.jobRevision > job.revision)
+        return false;
+    if (isAutomationSchedulerJob(job)) {
+        if (run.target?.kind !== "automation")
+            return false;
+        if (run.target.automationId !== job.target.automationId)
+            return false;
+        return run.target.definitionRevision <= job.target.definitionRevision;
+    }
+    if (run.target?.kind === "automation")
+        return false;
+    if (!("sessionId" in run))
+        return false;
+    return run.sessionId === job.sessionId;
 }

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

@@ -1,3 +1,4 @@
+import { type AutomationJournalState } from "../automations/storage-records.js";
 import type { SchedulerRunListQuery, SchedulerSnapshot } from "./contracts.js";
 export declare class SchedulerJournalStore {
     private readonly directory;
@@ -13,8 +14,15 @@ export declare class SchedulerJournalStore {
     load(): Promise<this>;
     prepareOwned(): Promise<void>;
     snapshot(view?: "active"): Promise<SchedulerSnapshot>;
-    readRuns(jobId?: string, query?: SchedulerRunListQuery): Promise<import("./contracts.js").SchedulerRun[]>;
+    readRuns(jobId?: string, query?: SchedulerRunListQuery, target?: "request" | "automation"): Promise<import("./contracts.js").SchedulerStoredRun[]>;
+    readRun(runId: string): Promise<import("./contracts.js").SchedulerStoredRun | null>;
+    readAutomationRunByKey(automationId: string, idempotencyKey: string): Promise<import("./contracts.js").SchedulerAutomationRun | null>;
+    countAutomationRunsOnDay(automationId: string, timeZone: string, at: number): Promise<number>;
+    readAutomations(): Promise<AutomationJournalState>;
     update<T>(mutate: (state: SchedulerSnapshot) => T, view?: "active"): Promise<T>;
+    updateAutomations<T>(mutate: (state: AutomationJournalState) => T): Promise<T>;
+    updateWithAutomations<T>(mutate: (scheduler: SchedulerSnapshot, automations: AutomationJournalState) => T, view?: "active"): Promise<T>;
+    private append;
     private replaceGeneration;
     private notifyCommittedChange;
     private ensureOwnedDirectoriesSynced;

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

@@ -1,10 +1,14 @@
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
+import { AUTOMATION_COLLECTIONS, emptyAutomationJournalState, parseAutomationJournalState, } from "../automations/storage-records.js";
 import { SchedulerJournalIndex, isActiveSchedulerRun, } from "./journal-index.js";
 import { cleanObsoleteJournalGenerations, createJournalGeneration, initialJournalTransaction, isMissingJournalFile, journalTransactionName, loadJournalIndex, SCHEDULER_MANIFEST, writeJournalJson, } from "./journal-files.js";
-import { hasSchedulerTransactionChanges, schedulerTransaction, } from "./journal-transaction.js";
+import { hasSchedulerTransactionChanges, schedulerTransaction, withAutomationTransaction, } from "./journal-transaction.js";
+import { automationTransaction, hasAutomationRemovals, } from "./journal-automation-transaction.js";
 import { querySchedulerRuns } from "./run-list-query.js";
+import { calendarDateAt } from "./calendar-time.js";
 import { parseSchedulerSnapshot } from "./snapshot-validation.js";
+import { isAutomationSchedulerRun } from "./scheduler-target.js";
 import { MAX_JOURNAL_SUFFIX, readJournalHead, } from "./journal-head.js";
 import { cleanObsoleteJournalCheckpoints, loadCheckpointJournalIndex, writeJournalCheckpoint, } from "./journal-checkpoint.js";
 import { JournalPublicationSyncError, syncJournalDirectory, syncJournalDirectoryPath, } from "./journal-durability.js";
@@ -25,7 +29,7 @@ export class SchedulerJournalStore {
     async load() {
         const head = await readJournalHead(this.directory);
         this.generation = head?.generation;
-        if (head?.schemaVersion === 3) {
+        if (head?.schemaVersion === 3 || head?.schemaVersion === 4) {
             const loaded = await loadCheckpointJournalIndex(this.directory, head);
             this.index = loaded.index;
             this.sequence = loaded.sequence;
@@ -54,6 +58,8 @@ export class SchedulerJournalStore {
         await cleanObsoleteJournalGenerations(this.directory, this.generation);
         if (this.legacy)
             await this.replaceGeneration(this.legacy);
+        else if (this.head?.schemaVersion === 3)
+            await this.replaceGeneration(await this.index.snapshot());
         if (requiresJournalCheckpoint(this.head, this.sequence)) {
             const head = await writeJournalCheckpoint(this.directory, this.generation, this.sequence, this.index);
             await this.publishHead(head);
@@ -70,11 +76,51 @@ export class SchedulerJournalStore {
             : this.legacy.runs;
         return structuredClone({ ...this.legacy, runs });
     }
-    async readRuns(jobId, query) {
+    async readRuns(jobId, query, target) {
         this.requireDurablePublication();
         if (!this.legacy)
-            return this.index.readRuns(jobId, query);
-        return structuredClone(querySchedulerRuns(this.legacy.runs, jobId, query));
+            return this.index.readRuns(jobId, query, target);
+        const scoped = this.legacy.runs.filter((run) => !target || (run.target?.kind ?? "request") === target);
+        return structuredClone(querySchedulerRuns(scoped, jobId, query));
+    }
+    async readRun(runId) {
+        this.requireDurablePublication();
+        if (!this.legacy)
+            return this.index.readRun(runId);
+        const run = this.legacy.runs.find((item) => item.id === runId);
+        return run ? structuredClone(run) : null;
+    }
+    async readAutomationRunByKey(automationId, idempotencyKey) {
+        this.requireDurablePublication();
+        if (!this.legacy)
+            return this.index.readAutomationRunByKey(automationId, idempotencyKey);
+        const run = this.legacy.runs.find((item) => isAutomationSchedulerRun(item) &&
+            item.target.automationId === automationId &&
+            item.idempotencyKey === idempotencyKey);
+        return run && isAutomationSchedulerRun(run) ? structuredClone(run) : null;
+    }
+    async countAutomationRunsOnDay(automationId, timeZone, at) {
+        this.requireDurablePublication();
+        if (!this.legacy)
+            return this.index.countAutomationRunsOnDay(automationId, timeZone, at);
+        const day = calendarDateAt(at, timeZone);
+        return this.legacy.runs.filter((run) => {
+            if (!isAutomationSchedulerRun(run) ||
+                run.target.automationId !== automationId || run.status === "missed")
+                return false;
+            const admittedAt = Date.parse(run.admittedAt ?? run.scheduledAt);
+            if (Math.abs(admittedAt - at) > 48 * 60 * 60_000)
+                return false;
+            const admittedDay = calendarDateAt(admittedAt, timeZone);
+            return admittedDay.year === day.year && admittedDay.month === day.month &&
+                admittedDay.day === day.day;
+        }).length;
+    }
+    async readAutomations() {
+        this.requireDurablePublication();
+        if (this.legacy)
+            return emptyAutomationJournalState();
+        return this.index.readAutomations();
     }
     async update(mutate, view) {
         // Retry storage cleanup before, never after committing an ordinary mutation.
@@ -94,6 +140,52 @@ export class SchedulerJournalStore {
             await this.replaceGeneration(complete, true);
             return result;
         }
+        await this.append(delta);
+        return result;
+    }
+    async updateAutomations(mutate) {
+        await this.prepareOwned();
+        const before = await this.readAutomations();
+        const candidate = structuredClone(before);
+        const result = structuredClone(mutate(candidate));
+        const after = parseAutomationJournalState(structuredClone(candidate));
+        const automation = automationTransaction(before, after);
+        const delta = withAutomationTransaction(initialJournalTransaction(), automation);
+        if (!hasSchedulerTransactionChanges(delta))
+            return result;
+        this.index.validate(delta);
+        if (hasAutomationRemovals(automation)) {
+            await this.replaceGeneration(await this.snapshot(), true, after);
+            return result;
+        }
+        await this.append(delta);
+        return result;
+    }
+    async updateWithAutomations(mutate, view) {
+        await this.prepareOwned();
+        const schedulerBefore = await this.snapshot(view);
+        const automationBefore = await this.readAutomations();
+        const schedulerCandidate = structuredClone(schedulerBefore);
+        const automationCandidate = structuredClone(automationBefore);
+        const result = structuredClone(mutate(schedulerCandidate, automationCandidate));
+        const schedulerAfter = parseSchedulerSnapshot(structuredClone(schedulerCandidate));
+        const automationAfter = parseAutomationJournalState(structuredClone(automationCandidate));
+        const automation = automationTransaction(automationBefore, automationAfter);
+        const delta = withAutomationTransaction(schedulerTransaction(schedulerBefore, schedulerAfter, view), automation);
+        if (!hasSchedulerTransactionChanges(delta))
+            return result;
+        this.index.validate(delta);
+        if (hasJournalRemovals(delta) || hasAutomationRemovals(automation)) {
+            const complete = view === "active"
+                ? applyWorkingChanges(await this.snapshot(), delta)
+                : schedulerAfter;
+            await this.replaceGeneration(complete, true, automationAfter);
+            return result;
+        }
+        await this.append(delta);
+        return result;
+    }
+    async append(delta) {
         const file = join(this.directory, this.generation, journalTransactionName(this.sequence + 1));
         await writeJournalJson(file, delta);
         const head = { ...this.head, sequence: this.sequence + 1 };
@@ -102,9 +194,9 @@ export class SchedulerJournalStore {
         this.sequence += 1;
         this.head = head;
         this.notifyCommittedChange();
-        return result;
     }
-    async replaceGeneration(snapshot, hasLogicalChange = false) {
+    async replaceGeneration(snapshot, hasLogicalChange = false, automations) {
+        const automationState = automations ?? (await this.readAutomations());
         const generation = await createJournalGeneration(this.directory);
         const index = new SchedulerJournalIndex();
         let sequence = 0;
@@ -122,6 +214,17 @@ export class SchedulerJournalStore {
                 runs: snapshot.runs.slice(offset, offset + 32),
             });
         }
+        for (const collection of AUTOMATION_COLLECTIONS) {
+            const records = automationState[collection];
+            for (let offset = 0; offset < records.length; offset += 32) {
+                await append(withAutomationTransaction(initialJournalTransaction(), {
+                    [collection]: {
+                        upsert: records.slice(offset, offset + 32),
+                        deleted: [],
+                    },
+                }));
+            }
+        }
         const head = await writeJournalCheckpoint(this.directory, generation, sequence, index);
         await this.publishHead(head);
         this.index = index;

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

@@ -1,14 +1,17 @@
-import type { SchedulerJob, SchedulerRun, SchedulerSnapshot } from "./contracts.js";
+import type { SchedulerSnapshot, SchedulerStoredJob, SchedulerStoredRun } from "./contracts.js";
+import { type AutomationTransaction } from "./journal-automation-transaction.js";
 export interface SchedulerTransaction {
-    version: 1;
-    jobs: SchedulerJob[];
-    runs: SchedulerRun[];
+    version: 1 | 2;
+    jobs: SchedulerStoredJob[];
+    runs: SchedulerStoredRun[];
     deletedJobs: string[];
     deletedRuns: string[];
     jobOrder?: string[];
     runOrder?: string[];
+    automation?: AutomationTransaction;
 }
 export declare function parseSchedulerTransaction(value: unknown): SchedulerTransaction;
 export declare function assertJournalTransactionIds(transaction: SchedulerTransaction): void;
 export declare function schedulerTransaction(before: SchedulerSnapshot, after: SchedulerSnapshot, view?: "active"): SchedulerTransaction;
 export declare function hasSchedulerTransactionChanges(value: SchedulerTransaction): boolean;
+export declare function withAutomationTransaction(scheduler: SchedulerTransaction, automation: AutomationTransaction): SchedulerTransaction;