@polpo-ai/node 0.15.45 → 0.15.47

package/dist/scheduling/sqlite-schedule-store.d.ts

@@ -0,0 +1,45 @@
+import { type CompleteScheduleRunInput, type CreateScheduleInput, type CreateScheduleRunInput, type Schedule, type ScheduleFilter, type ScheduleLease, type ScheduleMutationOptions, type ScheduleOperationalStatePatch, type ScheduleRun, type ScheduleRunFilter, type ScheduleStore, type UpdateScheduleInput } from "@polpo-ai/core/scheduling";
+interface SQLiteScheduleStoreOptions {
+    now?: () => Date | string;
+    createId?: (kind: "schedule" | "schedule-run") => string;
+}
+/**
+ * Durable local ScheduleStore backed by SQLite.
+ *
+ * The optional native dependency is loaded only by `open()`, so importing the
+ * rest of @polpo-ai/node remains safe in environments without better-sqlite3.
+ */
+export declare class SQLiteScheduleStore implements ScheduleStore {
+    private readonly db;
+    private readonly nowProvider;
+    private readonly createId;
+    private constructor();
+    static open(path: string, options?: SQLiteScheduleStoreOptions): Promise<SQLiteScheduleStore>;
+    create(input: CreateScheduleInput): Promise<Schedule>;
+    list(filter?: ScheduleFilter): Promise<Schedule[]>;
+    get(id: string): Promise<Schedule | null>;
+    update(id: string, patch: UpdateScheduleInput, options?: ScheduleMutationOptions): Promise<Schedule>;
+    markDeleted(id: string, options?: ScheduleMutationOptions): Promise<void>;
+    updateOperationalState(id: string, patch: ScheduleOperationalStatePatch, options?: ScheduleMutationOptions): Promise<Schedule>;
+    createRun(input: CreateScheduleRunInput): Promise<ScheduleRun>;
+    getRun(id: string): Promise<ScheduleRun | null>;
+    listRuns(filter?: ScheduleRunFilter): Promise<ScheduleRun[]>;
+    claimRun(id: string, lease: ScheduleLease): Promise<ScheduleRun | null>;
+    renewLease(id: string, lease: ScheduleLease): Promise<boolean>;
+    startRun(id: string, lease: ScheduleLease): Promise<ScheduleRun>;
+    releaseRun(id: string, lease: ScheduleLease): Promise<ScheduleRun>;
+    completeRun(id: string, input: CompleteScheduleRunInput): Promise<ScheduleRun>;
+    countActiveRuns(scheduleId: string): Promise<number>;
+    close(): void;
+    private insertSchedule;
+    private insertRun;
+    private casRun;
+    private casClaimRun;
+    private requireSchedule;
+    private requireRun;
+    private getRunByIdempotencyKey;
+    private requireOwnedRun;
+    private now;
+}
+export {};
+//# sourceMappingURL=sqlite-schedule-store.d.ts.map

package/dist/scheduling/sqlite-schedule-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-schedule-store.d.ts","sourceRoot":"","sources":["../../src/scheduling/sqlite-schedule-store.ts"],"names":[],"mappings":"AAIA,OAAO,EAcL,KAAK,wBAAwB,EAC7B,KAAK,mBAAmB,EACxB,KAAK,sBAAsB,EAC3B,KAAK,QAAQ,EACb,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,uBAAuB,EAC5B,KAAK,6BAA6B,EAClC,KAAK,WAAW,EAChB,KAAK,iBAAiB,EAGtB,KAAK,aAAa,EAClB,KAAK,mBAAmB,EACzB,MAAM,2BAA2B,CAAC;AAEnC,UAAU,0BAA0B;IAClC,GAAG,CAAC,EAAE,MAAM,IAAI,GAAG,MAAM,CAAC;IAC1B,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,UAAU,GAAG,cAAc,KAAK,MAAM,CAAC;CAC1D;AAoED;;;;;GAKG;AACH,qBAAa,mBAAoB,YAAW,aAAa;IAKrD,OAAO,CAAC,QAAQ,CAAC,EAAE;IAJrB,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAsB;IAClD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAgD;IAEzE,OAAO;WAQM,IAAI,CACf,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,0BAA+B,GACvC,OAAO,CAAC,mBAAmB,CAAC;IAyBzB,MAAM,CAAC,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAAC,QAAQ,CAAC;IA+BrD,IAAI,CAAC,MAAM,GAAE,cAAmB,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;IActD,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC;IAOzC,MAAM,CACV,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,mBAAmB,EAC1B,OAAO,GAAE,uBAA4B,GACpC,OAAO,CAAC,QAAQ,CAAC;IAqDd,WAAW,CACf,EAAE,EAAE,MAAM,EACV,OAAO,GAAE,uBAA4B,GACpC,OAAO,CAAC,IAAI,CAAC;IAkCV,sBAAsB,CAC1B,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,6BAA6B,EACpC,OAAO,GAAE,uBAA4B,GACpC,OAAO,CAAC,QAAQ,CAAC;IAuCd,SAAS,CAAC,KAAK,EAAE,sBAAsB,GAAG,OAAO,CAAC,WAAW,CAAC;IA4C9D,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;IAO/C,QAAQ,CAAC,MAAM,GAAE,iBAAsB,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAiBhE,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;IAsCvE,UAAU,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC;IAuB9D,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,WAAW,CAAC;IA8BhE,UAAU,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,WAAW,CAAC;IAkBlE,WAAW,CACf,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,wBAAwB,GAC9B,OAAO,CAAC,WAAW,CAAC;IA+BjB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAW1D,KAAK,IAAI,IAAI;IAIb,OAAO,CAAC,cAAc;IAgBtB,OAAO,CAAC,SAAS;IAsBjB,OAAO,CAAC,MAAM;IA4Bd,OAAO,CAAC,WAAW;IA6CnB,OAAO,CAAC,eAAe;IAQvB,OAAO,CAAC,UAAU;IAQlB,OAAO,CAAC,sBAAsB;IAO9B,OAAO,CAAC,eAAe;IAiBvB,OAAO,CAAC,GAAG;CASZ"}

package/dist/scheduling/sqlite-schedule-store.js

@@ -0,0 +1,611 @@
+import { mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+import { nanoid } from "nanoid";
+import { ScheduleConflictError, ScheduleInvalidStateError, ScheduleNotFoundError, assertSameScheduleOccurrence, assertScheduleRunStatusTransition, assertScheduleStatusTransition, isTerminalScheduleRunStatus, normalizeCompleteScheduleRunInput, normalizeCreateScheduleInput, normalizeCreateScheduleRunInput, normalizeScheduleLease, normalizeScheduleOperationalStatePatch, normalizeUpdateScheduleInput, } from "@polpo-ai/core/scheduling";
+const SCHEMA = `
+  CREATE TABLE IF NOT EXISTS polpo_schedules_v2 (
+    id TEXT PRIMARY KEY,
+    status TEXT NOT NULL,
+    surface TEXT NOT NULL,
+    revision INTEGER NOT NULL,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    data TEXT NOT NULL
+  );
+
+  CREATE INDEX IF NOT EXISTS polpo_schedules_v2_status_idx
+    ON polpo_schedules_v2 (status, updated_at);
+  CREATE INDEX IF NOT EXISTS polpo_schedules_v2_surface_idx
+    ON polpo_schedules_v2 (surface, created_at);
+
+  CREATE TABLE IF NOT EXISTS polpo_schedule_runs_v2 (
+    id TEXT PRIMARY KEY,
+    schedule_id TEXT NOT NULL,
+    idempotency_key TEXT NOT NULL UNIQUE,
+    status TEXT NOT NULL,
+    attempts INTEGER NOT NULL,
+    occurrence_at TEXT NOT NULL,
+    lease_owner TEXT,
+    lease_token TEXT,
+    lease_expires_at TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    data TEXT NOT NULL,
+    FOREIGN KEY (schedule_id) REFERENCES polpo_schedules_v2(id)
+  );
+
+  CREATE INDEX IF NOT EXISTS polpo_schedule_runs_v2_schedule_idx
+    ON polpo_schedule_runs_v2 (schedule_id, occurrence_at DESC);
+  CREATE INDEX IF NOT EXISTS polpo_schedule_runs_v2_status_idx
+    ON polpo_schedule_runs_v2 (status, occurrence_at);
+  CREATE INDEX IF NOT EXISTS polpo_schedule_runs_v2_lease_idx
+    ON polpo_schedule_runs_v2 (lease_expires_at)
+    WHERE lease_expires_at IS NOT NULL;
+`;
+/**
+ * Durable local ScheduleStore backed by SQLite.
+ *
+ * The optional native dependency is loaded only by `open()`, so importing the
+ * rest of @polpo-ai/node remains safe in environments without better-sqlite3.
+ */
+export class SQLiteScheduleStore {
+    db;
+    nowProvider;
+    createId;
+    constructor(db, options) {
+        this.db = db;
+        this.nowProvider = options.now ?? (() => new Date());
+        this.createId = options.createId ?? ((kind) => `${kind}-${nanoid()}`);
+    }
+    static async open(path, options = {}) {
+        if (typeof path !== "string" || !path.trim()) {
+            throw new Error("SQLite schedule store path must be a non-empty string");
+        }
+        if (path !== ":memory:") {
+            await mkdir(dirname(path), { recursive: true });
+        }
+        let Database;
+        try {
+            Database = (await import("better-sqlite3")).default;
+        }
+        catch (error) {
+            throw new Error("SQLite schedules require the optional better-sqlite3 dependency", { cause: error });
+        }
+        const db = new Database(path);
+        db.pragma("foreign_keys = ON");
+        db.pragma("busy_timeout = 5000");
+        if (path !== ":memory:")
+            db.pragma("journal_mode = WAL");
+        db.exec(SCHEMA);
+        return new SQLiteScheduleStore(db, options);
+    }
+    async create(input) {
+        const now = this.now();
+        const normalized = normalizeCreateScheduleInput(input, { now });
+        const id = normalized.id ?? this.createId("schedule");
+        const schedule = {
+            id,
+            ...(normalized.name === undefined ? {} : { name: normalized.name }),
+            ...(normalized.description === undefined
+                ? {}
+                : { description: normalized.description }),
+            timing: normalized.timing,
+            invocation: normalized.invocation,
+            status: normalized.status,
+            policy: normalized.policy,
+            metadata: normalized.metadata,
+            createdAt: now.toISOString(),
+            updatedAt: now.toISOString(),
+            revision: 1,
+        };
+        try {
+            this.insertSchedule(schedule);
+        }
+        catch (error) {
+            if (isUniqueConstraintError(error)) {
+                throw new ScheduleConflictError(`Schedule "${id}" already exists`);
+            }
+            throw error;
+        }
+        return clone(schedule);
+    }
+    async list(filter = {}) {
+        const statuses = statusSet(filter.status);
+        return this.db.prepare("SELECT * FROM polpo_schedules_v2 ORDER BY created_at ASC, id ASC").all()
+            .map((row) => decodeSchedule(row))
+            .filter((schedule) => (filter.includeDeleted || schedule.status !== "deleted")
+            && (!statuses || statuses.has(schedule.status))
+            && (!filter.surface || schedule.invocation.surface === filter.surface))
+            .map(clone);
+    }
+    async get(id) {
+        const row = this.db.prepare("SELECT * FROM polpo_schedules_v2 WHERE id = ?").get(id);
+        return row ? clone(decodeSchedule(row)) : null;
+    }
+    async update(id, patch, options = {}) {
+        return this.db.transaction(() => {
+            const existing = this.requireSchedule(id);
+            assertExpectedRevision(existing, options.expectedRevision);
+            if (existing.status === "deleted") {
+                throw new ScheduleInvalidStateError(`Schedule "${id}" is deleted`);
+            }
+            const now = this.now();
+            const normalized = normalizeUpdateScheduleInput(patch, { now });
+            const status = normalized.status ?? existing.status;
+            try {
+                assertScheduleStatusTransition(existing.status, status);
+            }
+            catch (error) {
+                throw new ScheduleInvalidStateError(errorMessage(error));
+            }
+            const updated = {
+                ...existing,
+                ...(normalized.timing === undefined ? {} : { timing: normalized.timing }),
+                ...(normalized.invocation === undefined
+                    ? {}
+                    : { invocation: normalized.invocation }),
+                ...(normalized.status === undefined ? {} : { status: normalized.status }),
+                ...(normalized.policy === undefined
+                    ? {}
+                    : { policy: { ...existing.policy, ...normalized.policy } }),
+                ...(normalized.metadata === undefined
+                    ? {}
+                    : { metadata: normalized.metadata }),
+                revision: existing.revision + 1,
+                updatedAt: now.toISOString(),
+            };
+            applyNullableString(updated, "name", normalized.name);
+            applyNullableString(updated, "description", normalized.description);
+            const changes = this.db.prepare(`
+        UPDATE polpo_schedules_v2
+        SET status = ?, surface = ?, revision = ?, updated_at = ?, data = ?
+        WHERE id = ? AND revision = ?
+      `).run(updated.status, updated.invocation.surface, updated.revision, updated.updatedAt, JSON.stringify(updated), id, existing.revision).changes;
+            if (changes !== 1) {
+                throw new ScheduleConflictError(`Schedule "${id}" revision conflict`);
+            }
+            return clone(updated);
+        })();
+    }
+    async markDeleted(id, options = {}) {
+        this.db.transaction(() => {
+            const existing = this.requireSchedule(id);
+            assertExpectedRevision(existing, options.expectedRevision);
+            if (existing.status === "deleted")
+                return;
+            try {
+                assertScheduleStatusTransition(existing.status, "deleted");
+            }
+            catch (error) {
+                throw new ScheduleInvalidStateError(errorMessage(error));
+            }
+            const deleted = {
+                ...existing,
+                status: "deleted",
+                revision: existing.revision + 1,
+                updatedAt: this.now().toISOString(),
+            };
+            const changes = this.db.prepare(`
+        UPDATE polpo_schedules_v2
+        SET status = ?, revision = ?, updated_at = ?, data = ?
+        WHERE id = ? AND revision = ?
+      `).run(deleted.status, deleted.revision, deleted.updatedAt, JSON.stringify(deleted), id, existing.revision).changes;
+            if (changes !== 1) {
+                throw new ScheduleConflictError(`Schedule "${id}" revision conflict`);
+            }
+        })();
+    }
+    async updateOperationalState(id, patch, options = {}) {
+        return this.db.transaction(() => {
+            const existing = this.requireSchedule(id);
+            assertExpectedRevision(existing, options.expectedRevision);
+            const normalized = normalizeScheduleOperationalStatePatch(patch);
+            const updated = {
+                ...existing,
+                revision: existing.revision + 1,
+                updatedAt: this.now().toISOString(),
+            };
+            applyOperationalField(updated, "nextOccurrenceAt", normalized.nextOccurrenceAt);
+            applyOperationalField(updated, "lastOccurrenceAt", normalized.lastOccurrenceAt);
+            applyOperationalField(updated, "driver", normalized.driver);
+            const changes = this.db.prepare(`
+        UPDATE polpo_schedules_v2
+        SET revision = ?, updated_at = ?, data = ?
+        WHERE id = ? AND revision = ?
+      `).run(updated.revision, updated.updatedAt, JSON.stringify(updated), id, existing.revision).changes;
+            if (changes !== 1) {
+                throw new ScheduleConflictError(`Schedule "${id}" revision conflict`);
+            }
+            return clone(updated);
+        })();
+    }
+    async createRun(input) {
+        return this.db.transaction(() => {
+            const normalized = normalizeCreateScheduleRunInput(input);
+            const duplicate = this.getRunByIdempotencyKey(normalized.idempotencyKey);
+            if (duplicate) {
+                assertSameScheduleOccurrence(duplicate, normalized);
+                return clone(duplicate);
+            }
+            const schedule = this.requireSchedule(normalized.scheduleId);
+            if (schedule.status !== "active") {
+                throw new ScheduleInvalidStateError(`Schedule "${schedule.id}" is not active`);
+            }
+            const now = this.now().toISOString();
+            const run = {
+                id: normalized.id ?? this.createId("schedule-run"),
+                scheduleId: normalized.scheduleId,
+                occurrenceAt: normalized.occurrenceAt,
+                triggerId: normalized.triggerId,
+                idempotencyKey: normalized.idempotencyKey,
+                status: "pending",
+                attempts: 0,
+                references: {},
+                createdAt: now,
+                updatedAt: now,
+            };
+            try {
+                this.insertRun(run);
+            }
+            catch (error) {
+                if (!isUniqueConstraintError(error))
+                    throw error;
+                const racedDuplicate = this.getRunByIdempotencyKey(run.idempotencyKey);
+                if (racedDuplicate) {
+                    assertSameScheduleOccurrence(racedDuplicate, normalized);
+                    return clone(racedDuplicate);
+                }
+                throw new ScheduleConflictError(`Schedule run "${run.id}" already exists`);
+            }
+            return clone(run);
+        })();
+    }
+    async getRun(id) {
+        const row = this.db.prepare("SELECT * FROM polpo_schedule_runs_v2 WHERE id = ?").get(id);
+        return row ? clone(decodeRun(row)) : null;
+    }
+    async listRuns(filter = {}) {
+        const statuses = runStatusSet(filter.status);
+        const limit = normalizeLimit(filter.limit);
+        const order = normalizeRunOrder(filter.order);
+        return this.db.prepare(`
+      SELECT * FROM polpo_schedule_runs_v2
+      ORDER BY occurrence_at ${order}, created_at ${order}, id ${order}
+    `).all()
+            .map((row) => decodeRun(row))
+            .filter((run) => (!filter.scheduleId || run.scheduleId === filter.scheduleId)
+            && (!statuses || statuses.has(run.status)))
+            .slice(0, limit)
+            .map(clone);
+    }
+    async claimRun(id, lease) {
+        return this.db.transaction(() => {
+            const now = this.now();
+            const normalizedLease = normalizeScheduleLease(lease, now);
+            const run = this.requireRun(id);
+            if (isTerminalScheduleRunStatus(run.status))
+                return null;
+            const schedule = this.requireSchedule(run.scheduleId);
+            if (schedule.status !== "active")
+                return null;
+            if ((run.status === "claimed" || run.status === "running")
+                && run.lease
+                && Date.parse(run.lease.expiresAt) > now.getTime()) {
+                return null;
+            }
+            if (!["pending", "claimed", "running"].includes(run.status))
+                return null;
+            try {
+                assertScheduleRunStatusTransition(run.status, "claimed");
+            }
+            catch (error) {
+                throw new ScheduleInvalidStateError(errorMessage(error));
+            }
+            const claimed = {
+                ...run,
+                status: "claimed",
+                attempts: run.attempts + 1,
+                lease: normalizedLease,
+                updatedAt: now.toISOString(),
+            };
+            if (!this.casClaimRun(run, claimed, schedule.policy.maxConcurrency, now))
+                return null;
+            return clone(claimed);
+        })();
+    }
+    async renewLease(id, lease) {
+        return this.db.transaction(() => {
+            const now = this.now();
+            const normalizedLease = normalizeScheduleLease(lease, now);
+            const run = this.requireRun(id);
+            if (!activeRun(run)
+                || !run.lease
+                || !leasesMatch(run.lease, normalizedLease)
+                || Date.parse(run.lease.expiresAt) <= now.getTime()
+                || Date.parse(normalizedLease.expiresAt) < Date.parse(run.lease.expiresAt)) {
+                return false;
+            }
+            const renewed = {
+                ...run,
+                lease: normalizedLease,
+                updatedAt: now.toISOString(),
+            };
+            return this.casRun(run, renewed);
+        })();
+    }
+    async startRun(id, lease) {
+        return this.db.transaction(() => {
+            const now = this.now();
+            const normalizedLease = normalizeScheduleLease(lease, now);
+            const run = this.requireOwnedRun(id, normalizedLease, now);
+            const schedule = this.requireSchedule(run.scheduleId);
+            if (schedule.status !== "active") {
+                throw new ScheduleInvalidStateError(`Schedule "${schedule.id}" is not active`);
+            }
+            if (run.status !== "claimed") {
+                throw new ScheduleInvalidStateError(`Schedule run "${id}" must be claimed before it can start`);
+            }
+            const started = {
+                ...run,
+                status: "running",
+                lease: normalizedLease,
+                startedAt: run.startedAt ?? now.toISOString(),
+                updatedAt: now.toISOString(),
+            };
+            if (!this.casRun(run, started)) {
+                throw new ScheduleConflictError(`Schedule run "${id}" changed while starting`);
+            }
+            return clone(started);
+        })();
+    }
+    async releaseRun(id, lease) {
+        return this.db.transaction(() => {
+            const now = this.now();
+            const normalizedLease = normalizeScheduleLease(lease, now);
+            const run = this.requireOwnedRun(id, normalizedLease, now);
+            const released = {
+                ...run,
+                status: "pending",
+                updatedAt: now.toISOString(),
+            };
+            delete released.lease;
+            if (!this.casRun(run, released)) {
+                throw new ScheduleConflictError(`Schedule run "${id}" changed while releasing`);
+            }
+            return clone(released);
+        })();
+    }
+    async completeRun(id, input) {
+        return this.db.transaction(() => {
+            const now = this.now();
+            const completion = normalizeCompleteScheduleRunInput(input, now);
+            const run = this.requireRun(id);
+            if (isTerminalScheduleRunStatus(run.status)) {
+                throw new ScheduleConflictError(`Schedule run "${id}" is already terminal`);
+            }
+            const owned = this.requireOwnedRun(id, completion.lease, now);
+            try {
+                assertScheduleRunStatusTransition(owned.status, completion.status);
+            }
+            catch (error) {
+                throw new ScheduleInvalidStateError(errorMessage(error));
+            }
+            const completed = {
+                ...owned,
+                status: completion.status,
+                references: completion.references,
+                ...(completion.result === undefined ? {} : { result: completion.result }),
+                ...(completion.error === undefined ? {} : { error: completion.error }),
+                completedAt: now.toISOString(),
+                updatedAt: now.toISOString(),
+            };
+            delete completed.lease;
+            if (!this.casRun(owned, completed)) {
+                throw new ScheduleConflictError(`Schedule run "${id}" changed while completing`);
+            }
+            return clone(completed);
+        })();
+    }
+    async countActiveRuns(scheduleId) {
+        const row = this.db.prepare(`
+      SELECT COUNT(*) AS count
+      FROM polpo_schedule_runs_v2
+      WHERE schedule_id = ?
+        AND status IN ('claimed', 'running')
+        AND lease_expires_at > ?
+    `).get(scheduleId, this.now().toISOString());
+        return Number(row.count);
+    }
+    close() {
+        this.db.close();
+    }
+    insertSchedule(schedule) {
+        this.db.prepare(`
+      INSERT INTO polpo_schedules_v2 (
+        id, status, surface, revision, created_at, updated_at, data
+      ) VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(schedule.id, schedule.status, schedule.invocation.surface, schedule.revision, schedule.createdAt, schedule.updatedAt, JSON.stringify(schedule));
+    }
+    insertRun(run) {
+        this.db.prepare(`
+      INSERT INTO polpo_schedule_runs_v2 (
+        id, schedule_id, idempotency_key, status, attempts, occurrence_at,
+        lease_owner, lease_token, lease_expires_at, created_at, updated_at, data
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(run.id, run.scheduleId, run.idempotencyKey, run.status, run.attempts, run.occurrenceAt, run.lease?.owner ?? null, run.lease?.token ?? null, run.lease?.expiresAt ?? null, run.createdAt, run.updatedAt, JSON.stringify(run));
+    }
+    casRun(previous, next) {
+        const changes = this.db.prepare(`
+      UPDATE polpo_schedule_runs_v2
+      SET status = ?, attempts = ?, lease_owner = ?, lease_token = ?,
+          lease_expires_at = ?, updated_at = ?, data = ?
+      WHERE id = ? AND status = ? AND attempts = ? AND updated_at = ?
+        AND COALESCE(lease_owner, '') = ?
+        AND COALESCE(lease_token, '') = ?
+        AND COALESCE(lease_expires_at, '') = ?
+    `).run(next.status, next.attempts, next.lease?.owner ?? null, next.lease?.token ?? null, next.lease?.expiresAt ?? null, next.updatedAt, JSON.stringify(next), previous.id, previous.status, previous.attempts, previous.updatedAt, previous.lease?.owner ?? "", previous.lease?.token ?? "", previous.lease?.expiresAt ?? "").changes;
+        return changes === 1;
+    }
+    casClaimRun(previous, next, maxConcurrency, now) {
+        const changes = this.db.prepare(`
+      UPDATE polpo_schedule_runs_v2
+      SET status = ?, attempts = ?, lease_owner = ?, lease_token = ?,
+          lease_expires_at = ?, updated_at = ?, data = ?
+      WHERE id = ? AND status = ? AND attempts = ? AND updated_at = ?
+        AND COALESCE(lease_owner, '') = ?
+        AND COALESCE(lease_token, '') = ?
+        AND COALESCE(lease_expires_at, '') = ?
+        AND (
+          SELECT COUNT(*)
+          FROM polpo_schedule_runs_v2 AS active
+          WHERE active.schedule_id = ?
+            AND active.id <> ?
+            AND active.status IN ('claimed', 'running')
+            AND active.lease_expires_at > ?
+        ) < ?
+    `).run(next.status, next.attempts, next.lease?.owner ?? null, next.lease?.token ?? null, next.lease?.expiresAt ?? null, next.updatedAt, JSON.stringify(next), previous.id, previous.status, previous.attempts, previous.updatedAt, previous.lease?.owner ?? "", previous.lease?.token ?? "", previous.lease?.expiresAt ?? "", previous.scheduleId, previous.id, now.toISOString(), maxConcurrency).changes;
+        return changes === 1;
+    }
+    requireSchedule(id) {
+        const row = this.db.prepare("SELECT * FROM polpo_schedules_v2 WHERE id = ?").get(id);
+        if (!row)
+            throw new ScheduleNotFoundError("Schedule", id);
+        return decodeSchedule(row);
+    }
+    requireRun(id) {
+        const row = this.db.prepare("SELECT * FROM polpo_schedule_runs_v2 WHERE id = ?").get(id);
+        if (!row)
+            throw new ScheduleNotFoundError("Schedule run", id);
+        return decodeRun(row);
+    }
+    getRunByIdempotencyKey(key) {
+        const row = this.db.prepare("SELECT * FROM polpo_schedule_runs_v2 WHERE idempotency_key = ?").get(key);
+        return row ? decodeRun(row) : null;
+    }
+    requireOwnedRun(id, lease, now) {
+        const run = this.requireRun(id);
+        if (!activeRun(run) || !run.lease || !leasesMatch(run.lease, lease)) {
+            throw new ScheduleConflictError(`Schedule run "${id}" is not owned by this lease`);
+        }
+        if (Date.parse(run.lease.expiresAt) <= now.getTime()) {
+            throw new ScheduleConflictError(`Schedule run "${id}" lease has expired`);
+        }
+        return run;
+    }
+    now() {
+        const now = new Date(this.nowProvider());
+        if (!Number.isFinite(now.getTime())) {
+            throw new ScheduleInvalidStateError("SQLite schedule store clock returned an invalid date");
+        }
+        return now;
+    }
+}
+function decodeSchedule(row) {
+    const schedule = parseRecord(row.data, `schedule "${row.id}"`);
+    if (schedule.id !== row.id
+        || schedule.status !== row.status
+        || schedule.invocation?.surface !== row.surface
+        || schedule.revision !== row.revision
+        || schedule.createdAt !== row.created_at
+        || schedule.updatedAt !== row.updated_at) {
+        throw new ScheduleInvalidStateError(`Persisted schedule "${row.id}" does not match its index columns`);
+    }
+    return schedule;
+}
+function decodeRun(row) {
+    const run = parseRecord(row.data, `schedule run "${row.id}"`);
+    if (run.id !== row.id
+        || run.scheduleId !== row.schedule_id
+        || run.idempotencyKey !== row.idempotency_key
+        || run.status !== row.status
+        || run.attempts !== row.attempts
+        || run.occurrenceAt !== row.occurrence_at
+        || run.createdAt !== row.created_at
+        || run.updatedAt !== row.updated_at
+        || (run.lease?.owner ?? null) !== row.lease_owner
+        || (run.lease?.token ?? null) !== row.lease_token
+        || (run.lease?.expiresAt ?? null) !== row.lease_expires_at) {
+        throw new ScheduleInvalidStateError(`Persisted schedule run "${row.id}" does not match its index columns`);
+    }
+    return run;
+}
+function parseRecord(raw, label) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            throw new Error("expected an object");
+        }
+        return parsed;
+    }
+    catch (error) {
+        throw new ScheduleInvalidStateError(`Failed to decode persisted ${label}: ${errorMessage(error)}`);
+    }
+}
+function assertExpectedRevision(schedule, expected) {
+    if (expected === undefined)
+        return;
+    if (!Number.isInteger(expected) || expected < 1) {
+        throw new Error("Schedule expectedRevision must be a positive integer");
+    }
+    if (schedule.revision !== expected) {
+        throw new ScheduleConflictError(`Schedule "${schedule.id}" revision conflict: expected ${expected}, found ${schedule.revision}`);
+    }
+}
+function applyNullableString(schedule, key, value) {
+    if (value === undefined)
+        return;
+    if (value === null)
+        delete schedule[key];
+    else
+        schedule[key] = value;
+}
+function applyOperationalField(schedule, key, value) {
+    if (value === undefined)
+        return;
+    if (value === null)
+        delete schedule[key];
+    else
+        schedule[key] = value;
+}
+function statusSet(status) {
+    if (status === undefined)
+        return undefined;
+    return new Set(Array.isArray(status) ? status : [status]);
+}
+function runStatusSet(status) {
+    if (status === undefined)
+        return undefined;
+    return new Set(Array.isArray(status) ? status : [status]);
+}
+function normalizeLimit(limit) {
+    if (limit === undefined)
+        return Number.POSITIVE_INFINITY;
+    if (!Number.isInteger(limit) || limit < 1 || limit > 1_000) {
+        throw new Error("Schedule run list limit must be an integer between 1 and 1000");
+    }
+    return limit;
+}
+function normalizeRunOrder(order) {
+    if (order === undefined || order === "desc")
+        return "DESC";
+    if (order === "asc")
+        return "ASC";
+    throw new Error('Schedule run order must be "asc" or "desc"');
+}
+function activeRun(run) {
+    return run.status === "claimed" || run.status === "running";
+}
+function leasesMatch(a, b) {
+    return a.owner === b.owner && a.token === b.token;
+}
+function isUniqueConstraintError(error) {
+    return error instanceof Error
+        && /UNIQUE constraint failed|PRIMARY KEY constraint failed/i.test(error.message);
+}
+function clone(value) {
+    return structuredClone(value);
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+//# sourceMappingURL=sqlite-schedule-store.js.map