local-lite 0.0.19 → 0.0.21

package/dist/react/session.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSession = useSession;
+const react_1 = require("react");
+/**
+ * Reactive React hook for persistent, offline-first user session management.
+ * The session remains authenticated even when offline, ensuring uninterrupted UX.
+ *
+ * Example:
+ * const { user, isAuthenticated, isOffline, signOut } = useSession(client);
+ */
+function useSession(client) {
+    const [session, setSession] = (0, react_1.useState)(null);
+    const [loading, setLoading] = (0, react_1.useState)(true);
+    const [isOffline, setIsOffline] = (0, react_1.useState)(false);
+    const loadSession = (0, react_1.useCallback)(async () => {
+        if (!client) {
+            setSession(null);
+            setLoading(false);
+            return null;
+        }
+        try {
+            const active = await client.session.getActiveSession();
+            setSession(active);
+            return active;
+        }
+        catch {
+            return null;
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [client]);
+    (0, react_1.useEffect)(() => {
+        if (!client) {
+            setSession(null);
+            setLoading(false);
+            return;
+        }
+        let isMounted = true;
+        // Check network
+        const checkNetwork = () => {
+            const net = client.syncWorker?.networkStatusProvider;
+            if (net && typeof net.isOnline === 'function') {
+                const res = net.isOnline();
+                if (typeof res === 'boolean') {
+                    if (isMounted)
+                        setIsOffline(!res);
+                }
+                else if (res && typeof res.then === 'function') {
+                    res.then((online) => {
+                        if (isMounted)
+                            setIsOffline(!online);
+                    });
+                }
+            }
+        };
+        checkNetwork();
+        loadSession();
+        // Listen to session changes
+        const unsubscribeSession = client.events.on('_local_sessions', () => {
+            if (isMounted) {
+                loadSession();
+            }
+        });
+        // Listen to network changes if available
+        const unsubscribeNetwork = client.events.on('network', (status) => {
+            if (isMounted && status && typeof status.online === 'boolean') {
+                setIsOffline(!status.online);
+            }
+        });
+        return () => {
+            isMounted = false;
+            unsubscribeSession();
+            if (typeof unsubscribeNetwork === 'function') {
+                unsubscribeNetwork();
+            }
+        };
+    }, [client, loadSession]);
+    const createSession = (0, react_1.useCallback)(async (options) => {
+        if (!client)
+            throw new Error('Client not provided to useSession.');
+        const res = await client.session.createSession(options);
+        setSession(res);
+        return res;
+    }, [client]);
+    const updateUser = (0, react_1.useCallback)(async (partialUser) => {
+        if (!client)
+            return null;
+        const res = await client.session.updateUser(partialUser);
+        setSession(res);
+        return res;
+    }, [client]);
+    const updateTokens = (0, react_1.useCallback)(async (tokens) => {
+        if (!client)
+            return;
+        await client.session.updateTokens(tokens);
+        await loadSession();
+    }, [client, loadSession]);
+    const signOut = (0, react_1.useCallback)(async () => {
+        if (!client)
+            return;
+        await client.session.clearSession();
+        setSession(null);
+    }, [client]);
+    return {
+        session,
+        user: session ? session.user : null,
+        isAuthenticated: session !== null,
+        isOffline,
+        loading,
+        createSession,
+        updateUser,
+        updateTokens,
+        signOut,
+        refetchSession: loadSession,
+    };
+}

package/dist/reactive/event-emitter.d.ts

@@ -2,6 +2,7 @@ type EventCallback = (data: any) => void;
 export declare class EventEmitter {
     private listeners;
     on(event: string, callback: EventCallback): () => void;
+    off(event: string, callback: EventCallback): void;
     emit(event: string, data: any): void;
 }
 export {};

package/dist/reactive/event-emitter.js

@@ -9,14 +9,17 @@ class EventEmitter {
         }
         this.listeners.get(event).add(callback);
         return () => {
-            const eventSet = this.listeners.get(event);
-            if (eventSet) {
-                eventSet.delete(callback);
-                if (eventSet.size === 0)
-                    this.listeners.delete(event);
-            }
+            this.off(event, callback);
         };
     }
+    off(event, callback) {
+        const eventSet = this.listeners.get(event);
+        if (eventSet) {
+            eventSet.delete(callback);
+            if (eventSet.size === 0)
+                this.listeners.delete(event);
+        }
+    }
     emit(event, data) {
         const eventSet = this.listeners.get(event);
         if (eventSet) {

package/dist/scheduler/cron.d.ts

@@ -0,0 +1,6 @@
+import { ScheduleType } from './types.js';
+export declare function parseScheduleToIntervalMs(schedule: ScheduleType): number;
+/**
+ * Calculates next run timestamp given schedule and last run (or current) timestamp.
+ */
+export declare function calculateNextRun(schedule: ScheduleType, fromTimestamp?: number): number;

package/dist/scheduler/cron.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseScheduleToIntervalMs = parseScheduleToIntervalMs;
+exports.calculateNextRun = calculateNextRun;
+function parseScheduleToIntervalMs(schedule) {
+    if (typeof schedule === 'object' && schedule !== null && 'intervalMs' in schedule) {
+        return Math.max(1000, Number(schedule.intervalMs) || 60000);
+    }
+    if (typeof schedule === 'number') {
+        return Math.max(1000, schedule);
+    }
+    const str = String(schedule).trim().toLowerCase();
+    if (str === 'hourly')
+        return 60 * 60 * 1000;
+    if (str === 'daily')
+        return 24 * 60 * 60 * 1000;
+    if (str === 'weekly')
+        return 7 * 24 * 60 * 60 * 1000;
+    // 'every X seconds/minutes/hours/days'
+    const match = str.match(/^every\s+(\d+)\s*(s|sec|seconds?|m|min|minutes?|h|hours?|d|days?)$/i);
+    if (match) {
+        const val = parseInt(match[1], 10);
+        const unit = match[2].toLowerCase();
+        if (unit.startsWith('s'))
+            return val * 1000;
+        if (unit.startsWith('m'))
+            return val * 60 * 1000;
+        if (unit.startsWith('h'))
+            return val * 60 * 60 * 1000;
+        if (unit.startsWith('d'))
+            return val * 24 * 60 * 60 * 1000;
+    }
+    // 5-field cron expression: min hour dom month dow
+    const parts = str.split(/\s+/);
+    if (parts.length === 5) {
+        // If it's */n in minutes
+        if (parts[0].startsWith('*/')) {
+            const step = parseInt(parts[0].slice(2), 10);
+            if (!isNaN(step) && step > 0) {
+                return step * 60 * 1000;
+            }
+        }
+        // If it's */n in hours (e.g. 0 */2 * * *)
+        if (parts[1].startsWith('*/')) {
+            const step = parseInt(parts[1].slice(2), 10);
+            if (!isNaN(step) && step > 0) {
+                return step * 60 * 60 * 1000;
+            }
+        }
+        // Default fallback for daily cron like 0 9 * * * or 0 0 * * *
+        return 24 * 60 * 60 * 1000;
+    }
+    // Default fallback: 1 hour
+    return 60 * 60 * 1000;
+}
+/**
+ * Calculates next run timestamp given schedule and last run (or current) timestamp.
+ */
+function calculateNextRun(schedule, fromTimestamp = Date.now()) {
+    const interval = parseScheduleToIntervalMs(schedule);
+    return fromTimestamp + interval;
+}

package/dist/scheduler/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types.js';
+export * from './cron.js';
+export * from './store.js';
+export * from './manager.js';

package/dist/scheduler/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types.js"), exports);
+__exportStar(require("./cron.js"), exports);
+__exportStar(require("./store.js"), exports);
+__exportStar(require("./manager.js"), exports);

package/dist/scheduler/manager.d.ts

@@ -0,0 +1,59 @@
+import { DBExecutable } from '../core/schema-manager.js';
+import { JobDefinition, JobRecord, JobRunRecord, JobSchedulerOptions } from './types.js';
+export declare class JobScheduler {
+    private db;
+    private handlers;
+    private timer;
+    private isTicking;
+    private checkIntervalMs;
+    constructor(db: DBExecutable, options?: JobSchedulerOptions);
+    initialize(): Promise<void>;
+    /**
+     * Registers a background recurring job and stores its schedule in SQLite.
+     */
+    register(job: JobDefinition): Promise<JobRecord>;
+    /**
+     * Attaches or updates a handler function for an already registered job id.
+     */
+    setHandler(jobId: string, handler: (job: JobRecord) => Promise<void> | void): void;
+    /**
+     * Removes a job from schedule and handlers.
+     */
+    unregister(jobId: string): Promise<void>;
+    /**
+     * Enables a paused job.
+     */
+    enable(jobId: string): Promise<void>;
+    /**
+     * Disables/pauses a job.
+     */
+    disable(jobId: string): Promise<void>;
+    /**
+     * Manually triggers a job immediately, logging execution in run history.
+     */
+    trigger(jobId: string): Promise<JobRunRecord>;
+    /**
+     * Checks for due jobs and executes them. Safe against reentrant concurrent ticks.
+     */
+    tick(): Promise<number>;
+    /**
+     * Starts periodic background ticker.
+     */
+    start(intervalMs?: number): void;
+    /**
+     * Stops the background periodic ticker.
+     */
+    stop(): void;
+    /**
+     * Returns all scheduled jobs.
+     */
+    getJobs(): Promise<JobRecord[]>;
+    /**
+     * Returns run history for a specific job or all jobs.
+     */
+    getHistory(jobId?: string, limit?: number): Promise<JobRunRecord[]>;
+    /**
+     * Prunes historical run logs older than the given age in milliseconds (default: 30 days).
+     */
+    pruneHistory(maxAgeMs?: number): Promise<void>;
+}

package/dist/scheduler/manager.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobScheduler = void 0;
+const uuid_js_1 = require("../utils/uuid.js");
+const cron_js_1 = require("./cron.js");
+const store_js_1 = require("./store.js");
+class JobScheduler {
+    db;
+    handlers = new Map();
+    timer = null;
+    isTicking = false;
+    checkIntervalMs;
+    constructor(db, options = {}) {
+        this.db = db;
+        this.checkIntervalMs = options.checkIntervalMs ?? 30000;
+    }
+    async initialize() {
+        await store_js_1.JobStore.ensureSchema(this.db);
+    }
+    /**
+     * Registers a background recurring job and stores its schedule in SQLite.
+     */
+    async register(job) {
+        const intervalMs = (0, cron_js_1.parseScheduleToIntervalMs)(job.schedule);
+        const now = Date.now();
+        const nextRunAt = (0, cron_js_1.calculateNextRun)(job.schedule, now);
+        const record = {
+            id: job.id,
+            name: job.name || job.id,
+            schedule: typeof job.schedule === 'string' ? job.schedule : `${intervalMs}ms`,
+            intervalMs,
+            lastRunAt: null,
+            nextRunAt,
+            enabled: job.enabled !== false,
+            payload: job.payload,
+            createdAt: now,
+        };
+        if (job.handler) {
+            this.handlers.set(job.id, job.handler);
+        }
+        await store_js_1.JobStore.upsertJob(this.db, undefined, record);
+        return record;
+    }
+    /**
+     * Attaches or updates a handler function for an already registered job id.
+     */
+    setHandler(jobId, handler) {
+        this.handlers.set(jobId, handler);
+    }
+    /**
+     * Removes a job from schedule and handlers.
+     */
+    async unregister(jobId) {
+        this.handlers.delete(jobId);
+        await store_js_1.JobStore.deleteJob(this.db, undefined, jobId);
+    }
+    /**
+     * Enables a paused job.
+     */
+    async enable(jobId) {
+        await store_js_1.JobStore.setJobEnabled(this.db, undefined, jobId, true);
+    }
+    /**
+     * Disables/pauses a job.
+     */
+    async disable(jobId) {
+        await store_js_1.JobStore.setJobEnabled(this.db, undefined, jobId, false);
+    }
+    /**
+     * Manually triggers a job immediately, logging execution in run history.
+     */
+    async trigger(jobId) {
+        const job = await store_js_1.JobStore.getJob(this.db, undefined, jobId);
+        if (!job) {
+            throw new Error(`Job "${jobId}" not found.`);
+        }
+        const runId = (0, uuid_js_1.generateUUID)();
+        const startedAt = Date.now();
+        const runRecord = {
+            id: runId,
+            jobId,
+            status: 'RUNNING',
+            startedAt,
+            finishedAt: null,
+            durationMs: null,
+        };
+        await store_js_1.JobStore.recordRunStart(this.db, undefined, runRecord);
+        const handler = this.handlers.get(jobId);
+        let runStatus = 'SUCCESS';
+        let runError = null;
+        try {
+            if (handler) {
+                await handler(job);
+            }
+        }
+        catch (err) {
+            runStatus = 'FAILED';
+            runError = err?.message || String(err);
+        }
+        const finishedAt = Date.now();
+        const durationMs = finishedAt - startedAt;
+        await store_js_1.JobStore.recordRunFinish(this.db, undefined, runId, runStatus, finishedAt, durationMs, runError);
+        const nextRunAt = (0, cron_js_1.calculateNextRun)(job.schedule, finishedAt);
+        await store_js_1.JobStore.updateJobSchedule(this.db, undefined, jobId, finishedAt, nextRunAt);
+        return {
+            id: runId,
+            jobId,
+            status: runStatus,
+            startedAt,
+            finishedAt,
+            durationMs,
+            error: runError,
+        };
+    }
+    /**
+     * Checks for due jobs and executes them. Safe against reentrant concurrent ticks.
+     */
+    async tick() {
+        if (this.isTicking)
+            return 0;
+        this.isTicking = true;
+        try {
+            const now = Date.now();
+            const dueJobs = await store_js_1.JobStore.getDueJobs(this.db, undefined, now);
+            if (dueJobs.length === 0)
+                return 0;
+            let executed = 0;
+            for (const job of dueJobs) {
+                try {
+                    await this.trigger(job.id);
+                    executed++;
+                }
+                catch {
+                    // Failure logged in trigger; continue next job
+                }
+            }
+            return executed;
+        }
+        finally {
+            this.isTicking = false;
+        }
+    }
+    /**
+     * Starts periodic background ticker.
+     */
+    start(intervalMs) {
+        if (this.timer)
+            return;
+        const interval = intervalMs ?? this.checkIntervalMs;
+        this.timer = setInterval(() => {
+            this.tick().catch(() => { });
+        }, interval);
+        if (typeof this.timer?.unref === 'function') {
+            this.timer.unref();
+        }
+    }
+    /**
+     * Stops the background periodic ticker.
+     */
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    /**
+     * Returns all scheduled jobs.
+     */
+    async getJobs() {
+        return await store_js_1.JobStore.getAllJobs(this.db);
+    }
+    /**
+     * Returns run history for a specific job or all jobs.
+     */
+    async getHistory(jobId, limit = 50) {
+        return await store_js_1.JobStore.getRuns(this.db, undefined, jobId, limit);
+    }
+    /**
+     * Prunes historical run logs older than the given age in milliseconds (default: 30 days).
+     */
+    async pruneHistory(maxAgeMs = 30 * 24 * 60 * 60 * 1000) {
+        const cutoff = Date.now() - maxAgeMs;
+        await store_js_1.JobStore.pruneRuns(this.db, undefined, cutoff);
+    }
+}
+exports.JobScheduler = JobScheduler;

package/dist/scheduler/store.d.ts

@@ -0,0 +1,20 @@
+import { DBExecutable } from '../core/schema-manager.js';
+import { JobRecord, JobRunRecord } from './types.js';
+export declare const DEFAULT_JOBS_TABLE = "_local_scheduled_jobs";
+export declare const DEFAULT_JOB_RUNS_TABLE = "_local_job_runs";
+export declare function mapJobRow(r: any): JobRecord;
+export declare function mapJobRunRow(r: any): JobRunRecord;
+export declare class JobStore {
+    static ensureSchema(db: DBExecutable, jobsTable?: string, runsTable?: string): Promise<void>;
+    static upsertJob(db: DBExecutable, jobsTable: string | undefined, job: JobRecord): Promise<void>;
+    static getJob(db: DBExecutable, jobsTable: string | undefined, id: string): Promise<JobRecord | null>;
+    static getAllJobs(db: DBExecutable, jobsTable?: string): Promise<JobRecord[]>;
+    static getDueJobs(db: DBExecutable, jobsTable?: string, now?: number): Promise<JobRecord[]>;
+    static updateJobSchedule(db: DBExecutable, jobsTable: string | undefined, id: string, lastRunAt: number, nextRunAt: number): Promise<void>;
+    static setJobEnabled(db: DBExecutable, jobsTable: string | undefined, id: string, enabled: boolean): Promise<void>;
+    static deleteJob(db: DBExecutable, jobsTable: string | undefined, id: string): Promise<void>;
+    static recordRunStart(db: DBExecutable, runsTable: string | undefined, run: JobRunRecord): Promise<void>;
+    static recordRunFinish(db: DBExecutable, runsTable: string | undefined, id: string, status: 'SUCCESS' | 'FAILED', finishedAt: number, durationMs: number, error?: string | null): Promise<void>;
+    static getRuns(db: DBExecutable, runsTable?: string, jobId?: string, limit?: number): Promise<JobRunRecord[]>;
+    static pruneRuns(db: DBExecutable, runsTable: string | undefined, cutoffTimestamp: number): Promise<void>;
+}

package/dist/scheduler/store.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobStore = exports.DEFAULT_JOB_RUNS_TABLE = exports.DEFAULT_JOBS_TABLE = void 0;
+exports.mapJobRow = mapJobRow;
+exports.mapJobRunRow = mapJobRunRow;
+exports.DEFAULT_JOBS_TABLE = '_local_scheduled_jobs';
+exports.DEFAULT_JOB_RUNS_TABLE = '_local_job_runs';
+function mapJobRow(r) {
+    let payload = undefined;
+    if (r.payload) {
+        try {
+            payload = typeof r.payload === 'string' ? JSON.parse(r.payload) : r.payload;
+        }
+        catch {
+            payload = r.payload;
+        }
+    }
+    return {
+        id: r.id,
+        name: r.name,
+        schedule: r.schedule,
+        intervalMs: Number(r.interval_ms || 0),
+        lastRunAt: r.last_run_at != null ? Number(r.last_run_at) : null,
+        nextRunAt: Number(r.next_run_at || 0),
+        enabled: r.enabled === 1 || r.enabled === '1' || r.enabled === true,
+        payload,
+        createdAt: Number(r.created_at || 0),
+    };
+}
+function mapJobRunRow(r) {
+    return {
+        id: r.id,
+        jobId: r.job_id,
+        status: r.status,
+        startedAt: Number(r.started_at || 0),
+        finishedAt: r.finished_at != null ? Number(r.finished_at) : null,
+        durationMs: r.duration_ms != null ? Number(r.duration_ms) : null,
+        error: r.error || null,
+    };
+}
+class JobStore {
+    static async ensureSchema(db, jobsTable = exports.DEFAULT_JOBS_TABLE, runsTable = exports.DEFAULT_JOB_RUNS_TABLE) {
+        await db.execute(`CREATE TABLE IF NOT EXISTS ${jobsTable} (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        schedule TEXT NOT NULL,
+        interval_ms INTEGER NOT NULL,
+        last_run_at INTEGER,
+        next_run_at INTEGER NOT NULL,
+        enabled INTEGER NOT NULL DEFAULT 1,
+        payload TEXT,
+        created_at INTEGER NOT NULL
+      );`);
+        await db.execute(`CREATE INDEX IF NOT EXISTS idx_${jobsTable}_next ON ${jobsTable} (next_run_at);`);
+        await db.execute(`CREATE TABLE IF NOT EXISTS ${runsTable} (
+        id TEXT PRIMARY KEY,
+        job_id TEXT NOT NULL,
+        status TEXT NOT NULL,
+        started_at INTEGER NOT NULL,
+        finished_at INTEGER,
+        duration_ms INTEGER,
+        error TEXT
+      );`);
+        await db.execute(`CREATE INDEX IF NOT EXISTS idx_${runsTable}_job ON ${runsTable} (job_id, started_at);`);
+    }
+    static async upsertJob(db, jobsTable = exports.DEFAULT_JOBS_TABLE, job) {
+        const payloadStr = job.payload !== undefined ? JSON.stringify(job.payload) : null;
+        await db.execute(`INSERT INTO ${jobsTable} (id, name, schedule, interval_ms, last_run_at, next_run_at, enabled, payload, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         name = excluded.name,
+         schedule = excluded.schedule,
+         interval_ms = excluded.interval_ms,
+         last_run_at = excluded.last_run_at,
+         next_run_at = excluded.next_run_at,
+         enabled = excluded.enabled,
+         payload = excluded.payload;`, [
+            job.id,
+            job.name,
+            job.schedule,
+            job.intervalMs,
+            job.lastRunAt ?? null,
+            job.nextRunAt,
+            job.enabled ? 1 : 0,
+            payloadStr,
+            job.createdAt,
+        ]);
+    }
+    static async getJob(db, jobsTable = exports.DEFAULT_JOBS_TABLE, id) {
+        const rows = await db.execute(`SELECT * FROM ${jobsTable} WHERE id = ? LIMIT 1;`, [id]);
+        if (!rows || rows.length === 0)
+            return null;
+        return mapJobRow(rows[0]);
+    }
+    static async getAllJobs(db, jobsTable = exports.DEFAULT_JOBS_TABLE) {
+        const rows = await db.execute(`SELECT * FROM ${jobsTable} ORDER BY next_run_at ASC;`);
+        return (rows || []).map(mapJobRow);
+    }
+    static async getDueJobs(db, jobsTable = exports.DEFAULT_JOBS_TABLE, now = Date.now()) {
+        const rows = await db.execute(`SELECT * FROM ${jobsTable} WHERE enabled = 1 AND next_run_at <= ? ORDER BY next_run_at ASC;`, [now]);
+        return (rows || []).map(mapJobRow);
+    }
+    static async updateJobSchedule(db, jobsTable = exports.DEFAULT_JOBS_TABLE, id, lastRunAt, nextRunAt) {
+        await db.execute(`UPDATE ${jobsTable} SET last_run_at = ?, next_run_at = ? WHERE id = ?;`, [lastRunAt, nextRunAt, id]);
+    }
+    static async setJobEnabled(db, jobsTable = exports.DEFAULT_JOBS_TABLE, id, enabled) {
+        await db.execute(`UPDATE ${jobsTable} SET enabled = ? WHERE id = ?;`, [enabled ? 1 : 0, id]);
+    }
+    static async deleteJob(db, jobsTable = exports.DEFAULT_JOBS_TABLE, id) {
+        await db.execute(`DELETE FROM ${jobsTable} WHERE id = ?;`, [id]);
+    }
+    // --- Run History ---
+    static async recordRunStart(db, runsTable = exports.DEFAULT_JOB_RUNS_TABLE, run) {
+        await db.execute(`INSERT INTO ${runsTable} (id, job_id, status, started_at, finished_at, duration_ms, error)
+       VALUES (?, ?, ?, ?, ?, ?, ?);`, [run.id, run.jobId, run.status, run.startedAt, null, null, null]);
+    }
+    static async recordRunFinish(db, runsTable = exports.DEFAULT_JOB_RUNS_TABLE, id, status, finishedAt, durationMs, error) {
+        await db.execute(`UPDATE ${runsTable} SET status = ?, finished_at = ?, duration_ms = ?, error = ? WHERE id = ?;`, [status, finishedAt, durationMs, error ?? null, id]);
+    }
+    static async getRuns(db, runsTable = exports.DEFAULT_JOB_RUNS_TABLE, jobId, limit = 50) {
+        let rows;
+        if (jobId) {
+            rows = await db.execute(`SELECT * FROM ${runsTable} WHERE job_id = ? ORDER BY started_at DESC LIMIT ?;`, [jobId, limit]);
+        }
+        else {
+            rows = await db.execute(`SELECT * FROM ${runsTable} ORDER BY started_at DESC LIMIT ?;`, [limit]);
+        }
+        return (rows || []).map(mapJobRunRow);
+    }
+    static async pruneRuns(db, runsTable = exports.DEFAULT_JOB_RUNS_TABLE, cutoffTimestamp) {
+        await db.execute(`DELETE FROM ${runsTable} WHERE started_at < ?;`, [cutoffTimestamp]);
+    }
+}
+exports.JobStore = JobStore;