@abot-ai/runtime 1.4.0 → 1.6.0

package/dist/src/runtime/scheduler/automation-snapshot-validation.d.ts

@@ -0,0 +1,3 @@
+import type { SchedulerAutomationJob, SchedulerAutomationRun } from "./contracts.js";
+export declare function parseStoredAutomationJob(value: Record<string, unknown>): SchedulerAutomationJob;
+export declare function parseStoredAutomationRun(value: Record<string, unknown>): SchedulerAutomationRun;

package/dist/src/runtime/scheduler/automation-snapshot-validation.js

@@ -0,0 +1,106 @@
+import { normalizeStoredSchedulerSchedule, validateTimeZone } from "./schedule-validation.js";
+function corruptAutomationSchedulerRecord() {
+    throw new Error("scheduler_store_corrupt");
+}
+function hasText(value) {
+    return typeof value === "string" && value.length > 0;
+}
+function hasInstant(value) {
+    return typeof value === "string" && Number.isFinite(Date.parse(value));
+}
+function hasOptionalInstant(value) {
+    return value === undefined || hasInstant(value);
+}
+function hasPositiveRevision(value) {
+    return Number.isSafeInteger(value) && Number(value) > 0;
+}
+export function parseStoredAutomationJob(value) {
+    const target = value.target;
+    if (!target || typeof target !== "object" || Array.isArray(target))
+        corruptAutomationSchedulerRecord();
+    const identity = target;
+    if (identity.kind !== "automation")
+        corruptAutomationSchedulerRecord();
+    if (!hasText(identity.automationId))
+        corruptAutomationSchedulerRecord();
+    if (!hasPositiveRevision(identity.definitionRevision))
+        corruptAutomationSchedulerRecord();
+    if (!hasText(value.id) || !hasText(value.environmentId))
+        corruptAutomationSchedulerRecord();
+    if (!hasText(value.title))
+        corruptAutomationSchedulerRecord();
+    if (typeof value.timeZone !== "string")
+        corruptAutomationSchedulerRecord();
+    validateTimeZone(value.timeZone);
+    if (!hasPositiveRevision(value.revision))
+        corruptAutomationSchedulerRecord();
+    if (!hasInstant(value.createdAt) || !hasInstant(value.updatedAt))
+        corruptAutomationSchedulerRecord();
+    if (value.nextRunAt !== null && !hasInstant(value.nextRunAt))
+        corruptAutomationSchedulerRecord();
+    if (!["active", "paused", "cancelled", "completed"].includes(String(value.state)))
+        corruptAutomationSchedulerRecord();
+    const schedule = normalizeStoredSchedulerSchedule(value.schedule);
+    if (schedule.kind === "manual" && value.nextRunAt !== null)
+        corruptAutomationSchedulerRecord();
+    return { ...value, target: identity, schedule };
+}
+export function parseStoredAutomationRun(value) {
+    const target = value.target;
+    if (!target || typeof target !== "object" || Array.isArray(target))
+        corruptAutomationSchedulerRecord();
+    const identity = target;
+    if (identity.kind !== "automation")
+        corruptAutomationSchedulerRecord();
+    if (!hasText(identity.automationId))
+        corruptAutomationSchedulerRecord();
+    if (!hasPositiveRevision(identity.definitionRevision))
+        corruptAutomationSchedulerRecord();
+    if (!hasText(value.id) || !hasText(value.jobId))
+        corruptAutomationSchedulerRecord();
+    if (!hasText(value.environmentId) || !hasText(value.title))
+        corruptAutomationSchedulerRecord();
+    if (typeof value.timeZone !== "string")
+        corruptAutomationSchedulerRecord();
+    validateTimeZone(value.timeZone);
+    if (!hasPositiveRevision(value.jobRevision))
+        corruptAutomationSchedulerRecord();
+    if (!hasInstant(value.scheduledAt))
+        corruptAutomationSchedulerRecord();
+    if (!hasOptionalInstant(value.admittedAt))
+        corruptAutomationSchedulerRecord();
+    if (!hasOptionalInstant(value.startedAt) || !hasOptionalInstant(value.finishedAt))
+        corruptAutomationSchedulerRecord();
+    if (value.trigger !== "manual" && value.trigger !== "schedule")
+        corruptAutomationSchedulerRecord();
+    if (value.idempotencyKey !== undefined) {
+        if (value.trigger !== "manual")
+            corruptAutomationSchedulerRecord();
+        if (typeof value.idempotencyKey !== "string")
+            corruptAutomationSchedulerRecord();
+        if (!value.idempotencyKey || value.idempotencyKey.length > 128)
+            corruptAutomationSchedulerRecord();
+    }
+    if (value.replayOf !== undefined) {
+        if (value.trigger !== "manual" || !hasText(value.replayOf) ||
+            value.replayOf === value.id)
+            corruptAutomationSchedulerRecord();
+    }
+    if (![
+        "pending",
+        "running",
+        "stopping",
+        "succeeded",
+        "completed_with_skips",
+        "failed",
+        "cancelled",
+        "interrupted",
+        "missed",
+    ].includes(String(value.status)))
+        corruptAutomationSchedulerRecord();
+    if (value.error !== undefined && typeof value.error !== "string")
+        corruptAutomationSchedulerRecord();
+    if (value.reportRef !== undefined && !hasText(value.reportRef))
+        corruptAutomationSchedulerRecord();
+    return value;
+}

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

@@ -1,4 +1,6 @@
 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";
     delayMs: number;
@@ -21,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;
@@ -44,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;
@@ -53,7 +67,24 @@ export interface SchedulerJob {
     prompt: string;
     modelProfileId: string;
     agentMode: AgentMode;
-    toolPermissionMode: "full_access";
+    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;
@@ -62,7 +93,17 @@ 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;
     title: string;
     prompt: string;
@@ -74,6 +115,12 @@ 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;
     jobId: string;
     environmentId: string;
@@ -94,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;
@@ -102,19 +220,27 @@ export interface SchedulerRunOutcome {
 }
 export interface SchedulerExecutor {
     sessionExists(sessionId: string): Promise<boolean>;
-    tryReserve(sessionId: string): (() => void) | null;
+    tryReserve(sessionId: string): (() => void) | null | Promise<(() => void) | null>;
     start(job: SchedulerJob, run: SchedulerRun): Promise<SchedulerRunOutcome>;
 }
 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;
@@ -140,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.d.ts

@@ -1,2 +1,2 @@
 import type { SchedulerStore } from "./contracts.js";
-export declare function createFileSchedulerStore(directory: string): SchedulerStore;
+export declare function createFileSchedulerStore(directory: string, onCommittedChange?: () => void): SchedulerStore;

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

@@ -3,7 +3,7 @@ import { join } from "node:path";
 import { acquireFileLock } from "../adapters/long-term-memory/file-lock/acquisition.js";
 import { SchedulerJournalStore } from "./journal-store.js";
 import { journalReadIdentity, readJournalHead } from "./journal-head.js";
-export function createFileSchedulerStore(directory) {
+export function createFileSchedulerStore(directory, onCommittedChange) {
     let releaseOwner;
     let journal;
     let transactionTail = Promise.resolve();
@@ -43,7 +43,7 @@ export function createFileSchedulerStore(directory) {
                 throw error;
             }
             try {
-                journal = await new SchedulerJournalStore(directory).load();
+                journal = await new SchedulerJournalStore(directory, onCommittedChange).load();
                 await journal.prepareOwned();
             }
             catch (error) {
@@ -62,12 +62,26 @@ export function createFileSchedulerStore(directory) {
             };
         },
         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

@@ -1,10 +1,12 @@
 import { randomUUID } from "node:crypto";
+import { requireSchedulerToolPermissionMode } from "./tool-permission-mode.js";
 import { nextSchedulerOccurrence } from "./next-occurrence.js";
 import { normalizeSchedulerScheduleUpdate } from "./schedule-update.js";
 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);
@@ -24,7 +26,7 @@ export function createSchedulerJob(context, input) {
             prompt: input.prompt,
             modelProfileId: input.modelProfileId,
             agentMode: input.agentMode,
-            toolPermissionMode: "full_access",
+            toolPermissionMode: requireSchedulerToolPermissionMode(input.toolPermissionMode),
             timeZone: input.timeZone,
             schedule,
             state: "active",
@@ -71,7 +73,6 @@ export function updateSchedulerJob(context, jobId, patch) {
             Object.assign(job, editable, {
                 schedule,
                 nextRunAt,
-                toolPermissionMode: "full_access",
                 updatedAt: new Date(now).toISOString(),
                 revision: job.revision + 1,
             });
@@ -107,6 +108,7 @@ function hasSchedulerJobChanges(job, candidate) {
         "prompt",
         "modelProfileId",
         "agentMode",
+        "toolPermissionMode",
         "timeZone",
     ].some((field) => job[field] !== candidate[field]);
 }
@@ -117,6 +119,7 @@ function pickEditableFields(patch) {
         "prompt",
         "modelProfileId",
         "agentMode",
+        "toolPermissionMode",
         "timeZone",
         "schedule",
     ]) {
@@ -186,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));
+}