@abot-ai/runtime 1.5.0 → 1.7.0

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;

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

@@ -1,4 +1,5 @@
 import { parseStoredJob, parseStoredRun } from "./snapshot-validation.js";
+import { hasAutomationTransactionChanges, parseAutomationTransaction, } from "./journal-automation-transaction.js";
 export function parseSchedulerTransaction(value) {
     if (!isSchedulerTransactionRecord(value))
         throw new Error("scheduler_store_corrupt");
@@ -6,7 +7,7 @@ export function parseSchedulerTransaction(value) {
     if (!hasSchedulerTransactionCollections(raw))
         throw new Error("scheduler_store_corrupt");
     const transaction = {
-        version: 1,
+        version: raw.version,
         jobs: raw.jobs.map(parseStoredJob),
         runs: raw.runs.map(parseStoredRun),
         deletedJobs: requireJournalIds(raw.deletedJobs),
@@ -17,6 +18,9 @@ export function parseSchedulerTransaction(value) {
         ...(raw.runOrder === undefined
             ? {}
             : { runOrder: requireJournalIds(raw.runOrder) }),
+        ...(raw.version === 2
+            ? { automation: parseAutomationTransaction(raw.automation ?? {}) }
+            : {}),
     };
     assertJournalTransactionIds(transaction);
     return transaction;
@@ -27,10 +31,12 @@ function isSchedulerTransactionRecord(value) {
     return !Array.isArray(value);
 }
 function hasSchedulerTransactionCollections(value) {
-    if (value.version !== 1)
+    if (value.version !== 1 && value.version !== 2)
         return false;
     if (!Array.isArray(value.jobs))
         return false;
+    if (value.version === 1 && value.automation !== undefined)
+        return false;
     return Array.isArray(value.runs);
 }
 export function assertJournalTransactionIds(transaction) {
@@ -100,5 +106,10 @@ export function hasSchedulerTransactionChanges(value) {
         return true;
     if (value.deletedJobs.length || value.deletedRuns.length)
         return true;
+    if (value.automation && hasAutomationTransactionChanges(value.automation))
+        return true;
     return value.jobOrder !== undefined || value.runOrder !== undefined;
 }
+export function withAutomationTransaction(scheduler, automation) {
+    return { ...scheduler, version: 2, automation };
+}

package/dist/src/runtime/scheduler/next-occurrence.js

@@ -4,6 +4,8 @@ import { addCalendarDays, calendarDateAt, calendarWeekday, resolveCalendarTime,
 /** Strictly after the supplied instant. Never shifts missing calendar dates or times. */
 export function nextSchedulerOccurrence(schedule, timeZone, after) {
     switch (schedule.kind) {
+        case "manual":
+            return null;
         case "timer":
         case "once":
             return Date.parse(schedule.at) > after ? schedule.at : null;

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

@@ -1,3 +1,4 @@
+import { isRequestSchedulerRun } from "./scheduler-target.js";
 export async function settleSchedulerRun(context, run, generation, execution, release) {
     const identity = {
         runId: run.id,
@@ -67,7 +68,7 @@ function canPersistCompletion(context, completion) {
     return !context.deletedSessions.has(completion.sessionId);
 }
 function isUnsettledCapturedRun(run, completion) {
-    if (!run)
+    if (!run || !isRequestSchedulerRun(run))
         return false;
     if (run.status !== "running")
         return false;

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

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import { isRequestSchedulerJob, isRequestSchedulerRun, } from "./scheduler-target.js";
 export function makeSchedulerRun(job, scheduledAt, trigger) {
     return {
         id: randomUUID(),
@@ -19,7 +20,9 @@ export function makeSchedulerRun(job, scheduledAt, trigger) {
     };
 }
 export function findPendingRun(state, jobId) {
-    return state.runs.find((run) => run.jobId === jobId && run.status === "pending");
+    return state.runs.find((run) => isRequestSchedulerRun(run) &&
+        run.jobId === jobId &&
+        run.status === "pending");
 }
 export function cancelPendingRuns(state, jobId, at) {
     for (const run of state.runs) {
@@ -32,11 +35,13 @@ export function cancelPendingRuns(state, jobId, at) {
     }
 }
 export function requireSchedulerJob(state, jobId) {
-    const job = state.jobs.find((candidate) => candidate.id === jobId);
+    const job = state.jobs.find((candidate) => isRequestSchedulerJob(candidate) && candidate.id === jobId);
     if (!job)
         throw new Error("scheduler_job_not_found");
     return job;
 }
 export function hasRunningSession(state, sessionId) {
-    return state.runs.some((run) => run.sessionId === sessionId && run.status === "running");
+    return state.runs.some((run) => isRequestSchedulerRun(run) &&
+        run.sessionId === sessionId &&
+        run.status === "running");
 }

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

@@ -1,3 +1,3 @@
-import type { SchedulerSchedule, SchedulerScheduleInput } from "./contracts.js";
+import type { SchedulerScheduleInput, SchedulerTimedSchedule } from "./contracts.js";
 /** PATCH preserves omitted or exact stored timing; actual edits are new input. */
-export declare function normalizeSchedulerScheduleUpdate(stored: SchedulerSchedule, input: SchedulerScheduleInput | undefined, now: number): SchedulerSchedule;
+export declare function normalizeSchedulerScheduleUpdate(stored: SchedulerTimedSchedule, input: SchedulerScheduleInput | undefined, now: number): SchedulerTimedSchedule;

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

@@ -1,10 +1,10 @@
-import type { CreateSchedulerJobInput, SchedulerSchedule, SchedulerScheduleInput } from "./contracts.js";
+import type { CreateSchedulerJobInput, SchedulerSchedule, SchedulerScheduleInput, SchedulerTimedSchedule } from "./contracts.js";
 export { SchedulerValidationError } from "./validation-error.js";
 export { parseSchedulerInstant } from "./instant-validation.js";
 export declare function requireSchedulerText(value: unknown, field: string): string;
 export declare function validateSchedulerJobInput(input: CreateSchedulerJobInput): void;
 export declare function validateTimeZone(timeZone: string): void;
 export declare function requireCalendarHour(value: unknown): string;
-export declare function normalizeSchedulerSchedule(input: SchedulerScheduleInput, now: number): SchedulerSchedule;
+export declare function normalizeSchedulerSchedule(input: SchedulerScheduleInput, now: number): SchedulerTimedSchedule;
 /** Stored timer deadlines are canonical state, not new relative timer input. */
 export declare function normalizeStoredSchedulerSchedule(schedule: SchedulerSchedule): SchedulerSchedule;

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

@@ -98,6 +98,8 @@ export function normalizeSchedulerSchedule(input, now) {
 }
 /** Stored timer deadlines are canonical state, not new relative timer input. */
 export function normalizeStoredSchedulerSchedule(schedule) {
+    if (schedule?.kind === "manual")
+        return { kind: "manual" };
     if (schedule?.kind !== "timer")
         return normalizeSchedulerSchedule(schedule, 0);
     return {

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

@@ -1,26 +1,38 @@
+import { dispatchPendingAutomationRun, enqueueDueAutomationOccurrences, } from "./automation-scheduler-engine.js";
+import { reconcileAutomationSchedulerCompletions } from "./automation-run-completion.js";
 import { nextSchedulerOccurrence } from "./next-occurrence.js";
 import { reconcileSchedulerCompletions, settleSchedulerRun, } from "./run-completion.js";
 import { findPendingRun, hasRunningSession, makeSchedulerRun, } from "./run-records.js";
-import { canBeginSchedulerRun, jobEpoch, } from "./service-context.js";
+import { canBeginRequestSchedulerRun, jobEpoch, } from "./service-context.js";
+import { isAutomationSchedulerRun, isRequestSchedulerJob, isRequestSchedulerRun, } from "./scheduler-target.js";
 export async function tickScheduler(context) {
     if (!context.running)
         return;
     await reconcileSchedulerCompletions(context);
+    await reconcileAutomationSchedulerCompletions(context);
     if (!context.running)
         return;
     const now = context.now();
+    await context.automationExecutor?.maintainRetention?.(now);
     const snapshot = await context.store.read();
     const hasDue = snapshot.jobs.some((job) => isDueJob(job, now));
     if (hasDue)
         await enqueueDueOccurrences(context, now);
+    await enqueueDueAutomationOccurrences(context, now);
     const pending = (await context.store.read()).runs.filter((run) => run.status === "pending");
     for (const run of pending) {
         if (!context.running)
             return;
+        if (isAutomationSchedulerRun(run)) {
+            await dispatchPendingAutomationRun(context, run);
+            continue;
+        }
         await dispatchPendingRun(context, run);
     }
 }
 function isDueJob(job, now) {
+    if (!isRequestSchedulerJob(job))
+        return false;
     if (job.state !== "active")
         return false;
     if (!job.nextRunAt)
@@ -30,6 +42,8 @@ function isDueJob(job, now) {
 async function enqueueDueOccurrences(context, now) {
     await context.store.update((state) => {
         for (const job of state.jobs) {
+            if (!isRequestSchedulerJob(job))
+                continue;
             if (!isDueJob(job, now))
                 continue;
             const pending = findPendingRun(state, job.id);
@@ -61,7 +75,7 @@ async function dispatchPendingRun(context, pending) {
         await removeDeletedSession(context, pending.sessionId);
         return;
     }
-    if (!canBeginSchedulerRun(context, pending.jobId, pending.sessionId, epoch))
+    if (!canBeginRequestSchedulerRun(context, pending.jobId, pending.sessionId, epoch))
         return;
     const release = await context.executor.tryReserve(pending.sessionId);
     if (!release)
@@ -72,7 +86,7 @@ async function dispatchPendingRun(context, pending) {
         if (!claimed)
             return;
         // Last validity guard and start invocation are in the same synchronous turn.
-        if (!canBeginSchedulerRun(context, pending.jobId, pending.sessionId, epoch)) {
+        if (!canBeginRequestSchedulerRun(context, pending.jobId, pending.sessionId, epoch)) {
             await cancelClaimedRun(context, pending.id);
             return;
         }
@@ -120,15 +134,17 @@ async function lookupPendingRunSession(context, pending) {
 }
 async function claimPendingRun(context, pending, epoch) {
     return context.store.update((state) => {
-        if (!canBeginSchedulerRun(context, pending.jobId, pending.sessionId, epoch))
+        if (!canBeginRequestSchedulerRun(context, pending.jobId, pending.sessionId, epoch))
             return null;
         const job = state.jobs.find((item) => item.id === pending.jobId);
-        if (!job)
+        if (!job || !isRequestSchedulerJob(job))
             return null;
         if (job.state === "cancelled")
             return null;
         const run = state.runs.find((item) => item.id === pending.id);
-        if (!run || run.status !== "pending")
+        if (!run || !isRequestSchedulerRun(run))
+            return null;
+        if (run.status !== "pending")
             return null;
         if (job.state === "paused" && run.trigger !== "manual")
             return null;
@@ -169,7 +185,7 @@ async function cancelClaimedRun(context, runId) {
 }
 async function removeDeletedSession(context, 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);
     });
 }

package/dist/src/runtime/scheduler/scheduler-service.d.ts

@@ -1,10 +1,13 @@
-import type { SchedulerExecutor, SchedulerService, SchedulerStore } from "./contracts.js";
+import type { SchedulerAutomationExecutor, SchedulerExecutor, SchedulerService, SchedulerStore } from "./contracts.js";
+import { type AutomationRunChange } from "./automation-run-change-events.js";
 export interface SchedulerServiceOptions {
     environmentId: string;
     store: SchedulerStore;
     executor: SchedulerExecutor;
+    automationExecutor?: SchedulerAutomationExecutor;
     now?: () => number;
     tickIntervalMs?: number;
     onError?: (error: unknown) => void;
+    onAutomationRunChange?: (change: AutomationRunChange) => void;
 }
 export declare function createSchedulerService(options: SchedulerServiceOptions): SchedulerService;