@abot-ai/runtime 1.5.0 → 1.6.0

package/dist/src/runtime/scheduler/automation-run-change-events.js

@@ -0,0 +1,77 @@
+import { isAutomationSchedulerRun } from "./scheduler-target.js";
+function isTerminalAutomationRun(status) {
+    return ["succeeded", "completed_with_skips", "failed", "cancelled", "interrupted", "missed"]
+        .includes(status);
+}
+function automationRunChangePhase(status) {
+    if (status === "running")
+        return "started";
+    if (isTerminalAutomationRun(status))
+        return "finished";
+    return null;
+}
+function automationRunStatuses(state) {
+    return new Map(state.runs.filter(isAutomationSchedulerRun)
+        .map((run) => [run.id, run.status]));
+}
+function changedAutomationRuns(previous, state) {
+    const changes = [];
+    for (const run of state.runs) {
+        if (!isAutomationSchedulerRun(run))
+            continue;
+        if (previous.get(run.id) === run.status)
+            continue;
+        const phase = automationRunChangePhase(run.status);
+        if (!phase)
+            continue;
+        changes.push({
+            phase,
+            environmentId: run.environmentId,
+            automationId: run.target.automationId,
+            runId: run.id,
+            title: run.title,
+            status: run.status,
+        });
+    }
+    return changes;
+}
+/** Publish only transitions whose scheduler transaction committed successfully. */
+export function observeAutomationRunChanges(store, onChange) {
+    function publish(changes) {
+        for (const change of changes) {
+            try {
+                onChange(change);
+            }
+            catch {
+                // A notification observer cannot change the result of a durable commit.
+            }
+        }
+    }
+    return {
+        ...store,
+        async update(mutate, view) {
+            let changes = [];
+            const result = await store.update((state) => {
+                const previous = automationRunStatuses(state);
+                const value = mutate(state);
+                changes = changedAutomationRuns(previous, state);
+                return value;
+            }, view);
+            publish(changes);
+            return result;
+        },
+        ...(store.updateWithAutomations ? {
+            async updateWithAutomations(mutate, view) {
+                let changes = [];
+                const result = await store.updateWithAutomations((scheduler, automations) => {
+                    const previous = automationRunStatuses(scheduler);
+                    const value = mutate(scheduler, automations);
+                    changes = changedAutomationRuns(previous, scheduler);
+                    return value;
+                }, view);
+                publish(changes);
+                return result;
+            },
+        } : {}),
+    };
+}

package/dist/src/runtime/scheduler/automation-run-completion.d.ts

@@ -0,0 +1,11 @@
+import type { SchedulerAutomationRun, SchedulerAutomationRunOutcome, SchedulerAutomationStartedRun } from "./contracts.js";
+import type { SchedulerContext } from "./service-context.js";
+export interface AutomationSchedulerRunCompletion {
+    runId: string;
+    automationId: string;
+    generation: number;
+    outcome: SchedulerAutomationRunOutcome;
+    finishedAt: string;
+}
+export declare function settleAutomationSchedulerRun(context: SchedulerContext, run: SchedulerAutomationRun, generation: number, execution: SchedulerAutomationStartedRun, release: () => void): Promise<void>;
+export declare function reconcileAutomationSchedulerCompletions(context: SchedulerContext): Promise<void>;

package/dist/src/runtime/scheduler/automation-run-completion.js

@@ -0,0 +1,93 @@
+import { isAutomationSchedulerRun } from "./scheduler-target.js";
+export async function settleAutomationSchedulerRun(context, run, generation, execution, release) {
+    const resourcesSettled = execution.resourcesSettled.catch((error) => {
+        try {
+            context.onError(error);
+        }
+        catch {
+            // A diagnostic callback cannot release admission before effects settle.
+        }
+    });
+    try {
+        const outcome = await execution.outcome.catch((error) => ({
+            status: "failed",
+            error: error instanceof Error ? error.message : String(error),
+        }));
+        const completion = {
+            runId: run.id,
+            automationId: run.target.automationId,
+            generation,
+            outcome,
+            finishedAt: new Date(context.now()).toISOString(),
+        };
+        await context.enqueue(async () => {
+            if (!canPersistAutomationCompletion(context, completion))
+                return;
+            context.pendingAutomationCompletions.set(run.id, completion);
+            await persistAutomationCompletion(context, completion);
+        });
+    }
+    catch (error) {
+        context.onError(error);
+    }
+    finally {
+        try {
+            await resourcesSettled;
+        }
+        finally {
+            release();
+        }
+    }
+}
+export async function reconcileAutomationSchedulerCompletions(context) {
+    for (const completion of context.pendingAutomationCompletions.values()) {
+        await persistAutomationCompletion(context, completion);
+    }
+}
+async function persistAutomationCompletion(context, completion) {
+    if (!canPersistAutomationCompletion(context, completion)) {
+        context.pendingAutomationCompletions.delete(completion.runId);
+        return;
+    }
+    const update = context.store.updateWithAutomations;
+    if (!update)
+        throw new Error("automation_store_unavailable");
+    try {
+        await update((scheduler, automations) => {
+            if (!canPersistAutomationCompletion(context, completion))
+                return;
+            const run = scheduler.runs.find((item) => item.id === completion.runId);
+            if (!isUnsettledAutomationRun(run, completion))
+                return;
+            if (!context.automationExecutor)
+                throw new Error("automation_executor_unavailable");
+            context.automationExecutor.settle(run, automations, completion.outcome);
+            const execution = automations.executions.find((item) => item.id === run.id);
+            const reportRef = completion.outcome.reportRef ?? execution?.reportRef;
+            if (!reportRef)
+                throw new Error("automation_report_missing");
+            run.status = completion.outcome.status;
+            run.finishedAt = completion.finishedAt;
+            run.reportRef = reportRef;
+            if (completion.outcome.error)
+                run.error = completion.outcome.error;
+        });
+        context.pendingAutomationCompletions.delete(completion.runId);
+    }
+    catch (error) {
+        // Only retry the terminal commit; never re-execute its effect.
+        context.onError(error);
+    }
+}
+function canPersistAutomationCompletion(context, completion) {
+    if (!context.running)
+        return false;
+    return context.generation === completion.generation;
+}
+function isUnsettledAutomationRun(run, completion) {
+    if (!run || !isAutomationSchedulerRun(run))
+        return false;
+    if (run.target.automationId !== completion.automationId)
+        return false;
+    return run.status === "running" || run.status === "stopping";
+}

package/dist/src/runtime/scheduler/automation-run-control.d.ts

@@ -0,0 +1,3 @@
+import type { SchedulerAutomationRun } from "./contracts.js";
+import { type SchedulerContext } from "./service-context.js";
+export declare function stopAutomationSchedulerRun(context: SchedulerContext, runId: string): Promise<SchedulerAutomationRun>;

package/dist/src/runtime/scheduler/automation-run-control.js

@@ -0,0 +1,48 @@
+import { requireCommittedAutomationExecution } from "./automation-job-management.js";
+import { requireRunningScheduler } from "./service-context.js";
+import { isAutomationSchedulerRun } from "./scheduler-target.js";
+export function stopAutomationSchedulerRun(context, runId) {
+    return context.enqueue(async () => {
+        requireRunningScheduler(context);
+        const update = context.store.updateWithAutomations;
+        const executor = context.automationExecutor;
+        if (!update || !executor)
+            throw new Error("automation_executor_unavailable");
+        let signalStop = false;
+        const run = await update((scheduler, automations) => {
+            const candidate = scheduler.runs.find((item) => item.id === runId);
+            if (!candidate || !isAutomationSchedulerRun(candidate))
+                throw new Error("automation_run_not_found");
+            if (candidate.status === "pending") {
+                executor.cancelPending(candidate, automations, "stopped");
+                const execution = requireCommittedAutomationExecution(automations, runId);
+                if (!execution.reportRef)
+                    throw new Error("automation_report_missing");
+                candidate.status = "cancelled";
+                candidate.reportRef = execution.reportRef;
+                candidate.finishedAt = new Date(context.now()).toISOString();
+                return candidate;
+            }
+            if (candidate.status === "running") {
+                const at = new Date(context.now()).toISOString();
+                const execution = requireCommittedAutomationExecution(automations, runId);
+                replaceExecution(automations.executions, execution, { ...execution, revision: execution.revision + 1, stopRequestedAt: at });
+                candidate.status = "stopping";
+                signalStop = true;
+                return candidate;
+            }
+            if (candidate.status === "stopping")
+                signalStop = true;
+            return candidate;
+        });
+        if (signalStop)
+            executor.stop(runId);
+        return run;
+    });
+}
+function replaceExecution(executions, existing, updated) {
+    const index = executions.findIndex((item) => item.id === existing.id);
+    if (index < 0)
+        throw new Error("automation_execution_checkpoint_missing");
+    executions[index] = updated;
+}

package/dist/src/runtime/scheduler/automation-run-records.d.ts

@@ -0,0 +1,5 @@
+import type { SchedulerAutomationJob, SchedulerAutomationRun, SchedulerSnapshot } from "./contracts.js";
+export declare function makeAutomationSchedulerRun(job: SchedulerAutomationJob, id: string, scheduledAt: string, trigger: SchedulerAutomationRun["trigger"], idempotencyKey?: string, admittedAt?: string): SchedulerAutomationRun;
+export declare function findPendingAutomationRun(state: SchedulerSnapshot, jobId: string): SchedulerAutomationRun | undefined;
+export declare function hasActiveAutomationRun(state: SchedulerSnapshot, automationId: string): boolean;
+export declare function requireAutomationSchedulerJob(state: SchedulerSnapshot, jobId: string): SchedulerAutomationJob;

package/dist/src/runtime/scheduler/automation-run-records.js

@@ -0,0 +1,37 @@
+import { isAutomationSchedulerJob, isAutomationSchedulerRun, } from "./scheduler-target.js";
+export function makeAutomationSchedulerRun(job, id, scheduledAt, trigger, idempotencyKey, admittedAt) {
+    return {
+        id,
+        jobId: job.id,
+        environmentId: job.environmentId,
+        target: { ...job.target },
+        title: job.title,
+        timeZone: job.timeZone,
+        jobRevision: job.revision,
+        scheduledAt,
+        admittedAt: admittedAt ?? scheduledAt,
+        trigger,
+        ...(idempotencyKey ? { idempotencyKey } : {}),
+        status: "pending",
+    };
+}
+export function findPendingAutomationRun(state, jobId) {
+    return state.runs.find((run) => isAutomationSchedulerRun(run) &&
+        run.jobId === jobId &&
+        run.status === "pending");
+}
+export function hasActiveAutomationRun(state, automationId) {
+    return state.runs.some((run) => {
+        if (!isAutomationSchedulerRun(run))
+            return false;
+        if (run.target.automationId !== automationId)
+            return false;
+        return ["pending", "running", "stopping"].includes(run.status);
+    });
+}
+export function requireAutomationSchedulerJob(state, jobId) {
+    const job = state.jobs.find((candidate) => isAutomationSchedulerJob(candidate) && candidate.id === jobId);
+    if (!job)
+        throw new Error("automation_job_not_found");
+    return job;
+}

package/dist/src/runtime/scheduler/automation-schedule.d.ts

@@ -0,0 +1,10 @@
+import type { SchedulerAutomationScheduleInput, SchedulerSchedule } from "./contracts.js";
+export declare function normalizeAutomationSchedule(input: SchedulerAutomationScheduleInput, now: number, previous?: AutomationScheduleTiming): SchedulerSchedule;
+export type AutomationScheduleTiming = Readonly<{
+    schedule: SchedulerSchedule;
+    timeZone: string;
+    authoredSchedule?: SchedulerAutomationScheduleInput;
+}>;
+export declare function hasAutomationScheduleTimingChanged(schedule: SchedulerSchedule, timeZone: string, previous?: AutomationScheduleTiming): boolean;
+/** Shared by schedule admission and draft readiness; stored runs do not reschedule. */
+export declare function requireAutomationScheduleOccurrence(schedule: SchedulerSchedule, timeZone: string, now: number): string | null;

package/dist/src/runtime/scheduler/automation-schedule.js

@@ -0,0 +1,48 @@
+import { normalizeSchedulerSchedule } from "./schedule-validation.js";
+import { requireRepresentableIntervalRecurrence } from "./interval-range.js";
+import { nextSchedulerOccurrence } from "./next-occurrence.js";
+import { SchedulerValidationError } from "./validation-error.js";
+export function normalizeAutomationSchedule(input, now, previous) {
+    if (input?.kind === "manual")
+        return { kind: "manual" };
+    if (hasUnchangedRelativeAutomationSchedule(input, previous))
+        return previous.schedule;
+    return normalizeSchedulerSchedule(input, now);
+}
+function hasUnchangedRelativeAutomationSchedule(input, previous) {
+    if (!input || !previous?.authoredSchedule)
+        return false;
+    const authored = previous.authoredSchedule;
+    const stored = previous.schedule;
+    if (input.kind === "timer")
+        return hasMatchingTimerDelay(input, authored, stored);
+    if (input.kind !== "interval")
+        return false;
+    if (authored.kind !== "interval" || stored.kind !== "interval")
+        return false;
+    if (input.anchorAt !== undefined || authored.anchorAt !== undefined)
+        return false;
+    return input.everyMs === authored.everyMs && input.everyMs === stored.everyMs;
+}
+function hasMatchingTimerDelay(input, authored, stored) {
+    if (authored.kind !== "timer" || stored.kind !== "timer")
+        return false;
+    return input.delayMs === authored.delayMs && input.delayMs === stored.delayMs;
+}
+export function hasAutomationScheduleTimingChanged(schedule, timeZone, previous) {
+    if (!previous)
+        return true;
+    if (JSON.stringify(schedule) !== JSON.stringify(previous.schedule))
+        return true;
+    if (timeZone === previous.timeZone)
+        return false;
+    return schedule.kind === "daily" || schedule.kind === "weekly" || schedule.kind === "monthly";
+}
+/** Shared by schedule admission and draft readiness; stored runs do not reschedule. */
+export function requireAutomationScheduleOccurrence(schedule, timeZone, now) {
+    requireRepresentableIntervalRecurrence(schedule, now);
+    const nextRunAt = nextSchedulerOccurrence(schedule, timeZone, now);
+    if (schedule.kind === "manual" || nextRunAt)
+        return nextRunAt;
+    throw new SchedulerValidationError("scheduler_schedule_in_past", "Choose a schedule with a future occurrence within the supported date range.");
+}

package/dist/src/runtime/scheduler/automation-scheduler-engine.d.ts

@@ -0,0 +1,4 @@
+import type { SchedulerAutomationRun } from "./contracts.js";
+import { type SchedulerContext } from "./service-context.js";
+export declare function enqueueDueAutomationOccurrences(context: SchedulerContext, now: number): Promise<void>;
+export declare function dispatchPendingAutomationRun(context: SchedulerContext, pending: SchedulerAutomationRun): Promise<void>;

package/dist/src/runtime/scheduler/automation-scheduler-engine.js

@@ -0,0 +1,188 @@
+import { randomUUID } from "node:crypto";
+import { hasActiveAutomationRun, makeAutomationSchedulerRun, } from "./automation-run-records.js";
+import { requireCommittedAutomationExecution } from "./automation-job-management.js";
+import { hasReachedAutomationDailyRunLimit } from "./automation-run-budget.js";
+import { settleAutomationSchedulerRun } from "./automation-run-completion.js";
+import { nextSchedulerOccurrence } from "./next-occurrence.js";
+import { canBeginSchedulerRun, jobEpoch, } from "./service-context.js";
+import { isAutomationSchedulerJob, isAutomationSchedulerRun, } from "./scheduler-target.js";
+export async function enqueueDueAutomationOccurrences(context, now) {
+    if (!context.automationExecutor)
+        return;
+    const snapshot = await context.store.read();
+    for (const candidate of snapshot.jobs) {
+        if (!isDueAutomationJob(candidate, now))
+            continue;
+        if (hasActiveAutomationRun(snapshot, candidate.target.automationId))
+            continue;
+        await prepareDueAutomationOccurrence(context, candidate, now);
+    }
+}
+function isDueAutomationJob(job, now) {
+    if (!isAutomationSchedulerJob(job))
+        return false;
+    if (job.state !== "active" || !job.nextRunAt)
+        return false;
+    return Date.parse(job.nextRunAt) <= now;
+}
+async function prepareDueAutomationOccurrence(context, job, now) {
+    const executor = context.automationExecutor;
+    if (!executor)
+        throw new Error("automation_executor_unavailable");
+    const epoch = jobEpoch(context, job.id);
+    const candidateRunId = randomUUID();
+    const prepared = await executor.prepare(job, candidateRunId, "schedule");
+    if (prepared.kind === "no_input") {
+        const update = context.store.updateWithAutomations;
+        if (!update)
+            throw new Error("automation_store_unavailable");
+        await update((state, automations) => {
+            const live = matchingDueAutomationJob(context, state, job, epoch, now);
+            if (!live)
+                return;
+            prepared.commit?.(automations);
+            advanceAutomationOccurrence(live, now);
+        });
+        return;
+    }
+    let claimed = false;
+    try {
+        if (await hasReachedAutomationDailyRunLimit(context, job, now)) {
+            await context.store.update((state) => {
+                const live = matchingDueAutomationJob(context, state, job, epoch, now);
+                if (live)
+                    advanceAutomationOccurrence(live, now);
+            });
+            return;
+        }
+        const update = context.store.updateWithAutomations;
+        if (!update)
+            throw new Error("automation_store_unavailable");
+        const committed = await update((state, automations) => {
+            const live = matchingDueAutomationJob(context, state, job, epoch, now);
+            if (!live)
+                return;
+            if (hasActiveAutomationRun(state, live.target.automationId))
+                return;
+            const run = makeAutomationSchedulerRun(live, candidateRunId, live.nextRunAt, "schedule", undefined, new Date(now).toISOString());
+            prepared.commit(automations, run.id);
+            const execution = requireCommittedAutomationExecution(automations, run.id);
+            if (prepared.kind === "failed") {
+                requireFailedOccurrenceReport(prepared, execution.reportRef);
+                run.status = "failed";
+                run.error = prepared.error;
+                run.reportRef = execution.reportRef;
+                run.finishedAt = new Date(now).toISOString();
+                live.state = "paused";
+                live.updatedAt = run.finishedAt;
+                live.revision += 1;
+            }
+            else {
+                advanceAutomationOccurrence(live, now);
+            }
+            state.runs.push(run);
+            return true;
+        });
+        claimed = committed === true;
+    }
+    finally {
+        if (!claimed && prepared.kind === "ready")
+            await prepared.discard?.();
+    }
+}
+function requireFailedOccurrenceReport(prepared, reportRef) {
+    if (!prepared.error || !reportRef)
+        throw new Error("automation_report_missing");
+}
+function matchingDueAutomationJob(context, state, prepared, epoch, now) {
+    if (!canBeginSchedulerRun(context, prepared.id, epoch))
+        return null;
+    const live = state.jobs.find((candidate) => candidate.id === prepared.id);
+    if (!live || !isDueAutomationJob(live, now))
+        return null;
+    if (live.revision !== prepared.revision)
+        return null;
+    if (live.nextRunAt !== prepared.nextRunAt)
+        return null;
+    return live;
+}
+function advanceAutomationOccurrence(job, now) {
+    job.nextRunAt = nextSchedulerOccurrence(job.schedule, job.timeZone, now);
+    if (!job.nextRunAt)
+        job.state = "completed";
+}
+export async function dispatchPendingAutomationRun(context, pending) {
+    const executor = context.automationExecutor;
+    if (!executor)
+        throw new Error("automation_executor_unavailable");
+    const epoch = jobEpoch(context, pending.jobId);
+    if (!canBeginSchedulerRun(context, pending.jobId, epoch))
+        return;
+    const release = await executor.tryReserve(pending.target.automationId);
+    if (!release)
+        return;
+    let delegated = false;
+    try {
+        const claimed = await claimPendingAutomationRun(context, pending, epoch);
+        if (!claimed)
+            return;
+        // The durable pending -> running claim is the admission boundary. Once it
+        // succeeds, a later Job edit may affect future runs but not this snapshot.
+        const execution = startCapturedAutomationRun(context, claimed.job, claimed.run);
+        delegated = true;
+        void settleAutomationSchedulerRun(context, claimed.run, context.generation, execution, release);
+    }
+    finally {
+        if (!delegated)
+            release();
+    }
+}
+async function claimPendingAutomationRun(context, pending, epoch) {
+    return context.store.update((state) => {
+        if (!canBeginSchedulerRun(context, pending.jobId, epoch))
+            return null;
+        const job = state.jobs.find((item) => item.id === pending.jobId);
+        if (!job || !isAutomationSchedulerJob(job))
+            return null;
+        if (job.state === "cancelled")
+            return null;
+        const run = state.runs.find((item) => item.id === pending.id);
+        if (!run || !isAutomationSchedulerRun(run))
+            return null;
+        if (run.status !== "pending")
+            return null;
+        if (job.state === "paused" && run.trigger !== "manual")
+            return null;
+        if (hasRunningAutomationRun(state, run))
+            return null;
+        run.status = "running";
+        run.startedAt = new Date(context.now()).toISOString();
+        return { job, run };
+    });
+}
+function hasRunningAutomationRun(state, candidate) {
+    return state.runs.some((run) => {
+        if (!isAutomationSchedulerRun(run) || run.id === candidate.id)
+            return false;
+        if (run.target.automationId !== candidate.target.automationId)
+            return false;
+        return run.status === "running" || run.status === "stopping";
+    });
+}
+function startCapturedAutomationRun(context, job, run) {
+    try {
+        return context.automationExecutor.start({
+            ...job,
+            target: { ...run.target },
+            title: run.title,
+            timeZone: run.timeZone,
+            revision: run.jobRevision,
+        }, run);
+    }
+    catch (error) {
+        return {
+            outcome: Promise.reject(error),
+            resourcesSettled: Promise.resolve(),
+        };
+    }
+}

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