local-lite 0.0.19 → 0.0.20

package/dist/kv/store.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KVStore = exports.DEFAULT_KV_TABLE = void 0;
+exports.mapKVRow = mapKVRow;
+exports.DEFAULT_KV_TABLE = '_local_kv';
+function mapKVRow(r) {
+    let val = r.value;
+    const type = r.type;
+    if (type === 'number') {
+        val = Number(val);
+    }
+    else if (type === 'boolean') {
+        val = val === 'true' || val === '1' || val === 1;
+    }
+    else if (type === 'json') {
+        try {
+            val = JSON.parse(val);
+        }
+        catch {
+            // fallback
+        }
+    }
+    return {
+        key: r.key,
+        value: val,
+        type: r.type,
+        createdAt: Number(r.created_at || 0),
+        updatedAt: Number(r.updated_at || 0),
+        expiresAt: r.expires_at != null ? Number(r.expires_at) : null,
+    };
+}
+class KVStore {
+    static async ensureSchema(db, tableName = exports.DEFAULT_KV_TABLE) {
+        await db.execute(`CREATE TABLE IF NOT EXISTS ${tableName} (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL,
+        type TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        expires_at INTEGER
+      );`);
+        await db.execute(`CREATE INDEX IF NOT EXISTS idx_${tableName}_expires ON ${tableName} (expires_at);`);
+    }
+    static async set(db, tableName = exports.DEFAULT_KV_TABLE, key, valueStr, type, now, expiresAt) {
+        await db.execute(`INSERT INTO ${tableName} (key, value, type, created_at, updated_at, expires_at)
+       VALUES (?, ?, ?, ?, ?, ?)
+       ON CONFLICT(key) DO UPDATE SET
+         value = excluded.value,
+         type = excluded.type,
+         updated_at = excluded.updated_at,
+         expires_at = excluded.expires_at;`, [key, valueStr, type, now, now, expiresAt]);
+    }
+    static async get(db, tableName = exports.DEFAULT_KV_TABLE, key) {
+        const rows = await db.execute(`SELECT * FROM ${tableName} WHERE key = ? LIMIT 1;`, [key]);
+        if (!rows || rows.length === 0)
+            return null;
+        return mapKVRow(rows[0]);
+    }
+    static async delete(db, tableName = exports.DEFAULT_KV_TABLE, key) {
+        await db.execute(`DELETE FROM ${tableName} WHERE key = ?;`, [key]);
+        return true;
+    }
+    static async listKeys(db, tableName = exports.DEFAULT_KV_TABLE, prefix) {
+        let rows;
+        if (prefix) {
+            rows = await db.execute(`SELECT key, expires_at FROM ${tableName} WHERE key LIKE ? ORDER BY key ASC;`, [`${prefix}%`]);
+        }
+        else {
+            rows = await db.execute(`SELECT key, expires_at FROM ${tableName} ORDER BY key ASC;`);
+        }
+        const now = Date.now();
+        return (rows || [])
+            .filter((r) => r.expires_at == null || Number(r.expires_at) > now)
+            .map((r) => r.key);
+    }
+    static async clear(db, tableName = exports.DEFAULT_KV_TABLE) {
+        await db.execute(`DELETE FROM ${tableName};`);
+    }
+    static async pruneExpired(db, tableName = exports.DEFAULT_KV_TABLE) {
+        const now = Date.now();
+        await db.execute(`DELETE FROM ${tableName} WHERE expires_at IS NOT NULL AND expires_at <= ?;`, [now]);
+        return 0;
+    }
+}
+exports.KVStore = KVStore;

package/dist/kv/types.d.ts

@@ -0,0 +1,27 @@
+export interface KVSetOptions {
+    /**
+     * Time-to-live in milliseconds from current time.
+     */
+    ttlMs?: number;
+    /**
+     * Explicit Unix timestamp in milliseconds when this key expires.
+     */
+    expiresAt?: number;
+}
+export interface KVSetSecretOptions extends KVSetOptions {
+    /**
+     * Passphrase used to encrypt the value using AES-256-GCM.
+     */
+    passphrase: string;
+}
+export interface KVRecord<T = any> {
+    key: string;
+    value: T;
+    type: 'string' | 'number' | 'boolean' | 'json' | 'encrypted';
+    createdAt: number;
+    updatedAt: number;
+    expiresAt?: number | null;
+}
+export interface KVStoreOptions {
+    tableName?: string;
+}

package/dist/kv/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/react/index.d.ts

@@ -131,3 +131,5 @@ export { SyncInspector } from './SyncInspector.js';
 export type { SyncInspectorProps } from './SyncInspector.js';
 export * from './auth.js';
 export * from './backups.js';
+export * from './kv.js';
+export * from './search.js';

package/dist/react/index.js

@@ -646,3 +646,5 @@ var SyncInspector_js_1 = require("./SyncInspector.js");
 Object.defineProperty(exports, "SyncInspector", { enumerable: true, get: function () { return SyncInspector_js_1.SyncInspector; } });
 __exportStar(require("./auth.js"), exports);
 __exportStar(require("./backups.js"), exports);
+__exportStar(require("./kv.js"), exports);
+__exportStar(require("./search.js"), exports);

package/dist/react/kv.d.ts

@@ -0,0 +1,9 @@
+import { LocalFirstClient } from '../core/client.js';
+/**
+ * Reactive React hook for client.kv key-value preferences.
+ * Automatically re-renders whenever the key is updated or deleted.
+ *
+ * Example:
+ * const [theme, setTheme, loading] = useKV(client, 'theme', 'light');
+ */
+export declare function useKV<T = any>(client: LocalFirstClient | null | undefined, key: string, defaultValue?: T): [T | undefined, (value: T) => Promise<void>, boolean];

package/dist/react/kv.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useKV = useKV;
+const react_1 = require("react");
+/**
+ * Reactive React hook for client.kv key-value preferences.
+ * Automatically re-renders whenever the key is updated or deleted.
+ *
+ * Example:
+ * const [theme, setTheme, loading] = useKV(client, 'theme', 'light');
+ */
+function useKV(client, key, defaultValue) {
+    const [value, setValueState] = (0, react_1.useState)(defaultValue);
+    const [loading, setLoading] = (0, react_1.useState)(true);
+    (0, react_1.useEffect)(() => {
+        if (!client) {
+            setValueState(defaultValue);
+            setLoading(false);
+            return;
+        }
+        let isMounted = true;
+        const load = async () => {
+            try {
+                const val = await client.kv.get(key, defaultValue);
+                if (isMounted) {
+                    setValueState(val);
+                    setLoading(false);
+                }
+            }
+            catch {
+                if (isMounted)
+                    setLoading(false);
+            }
+        };
+        load();
+        const unsubscribe = client.events.on('_local_kv', (e) => {
+            if (!e || e.key === key || !e.key) {
+                load();
+            }
+        });
+        return () => {
+            isMounted = false;
+            unsubscribe();
+        };
+    }, [client, key, defaultValue]);
+    const setKVValue = (0, react_1.useCallback)(async (newValue) => {
+        if (!client)
+            return;
+        await client.kv.set(key, newValue);
+        setValueState(newValue);
+    }, [client, key]);
+    return [value, setKVValue, loading];
+}

package/dist/react/search.d.ts

@@ -0,0 +1,19 @@
+import { LocalFirstClient } from '../core/client.js';
+import { SearchQueryOptions, SearchResult } from '../search/types.js';
+export interface UseSearchOptions extends SearchQueryOptions {
+    /**
+     * Debounce delay in milliseconds (default: 150ms).
+     */
+    debounceMs?: number;
+}
+/**
+ * Reactive React hook for instant full-text search with automatic debouncing.
+ *
+ * Example:
+ * const { results, loading, error } = useSearch(client, 'properties', searchQuery);
+ */
+export declare function useSearch<T = any>(client: LocalFirstClient | null | undefined, table: string, queryText: string, options?: UseSearchOptions): {
+    results: SearchResult<T>[];
+    loading: boolean;
+    error: Error | null;
+};

package/dist/react/search.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSearch = useSearch;
+const react_1 = require("react");
+/**
+ * Reactive React hook for instant full-text search with automatic debouncing.
+ *
+ * Example:
+ * const { results, loading, error } = useSearch(client, 'properties', searchQuery);
+ */
+function useSearch(client, table, queryText, options) {
+    const [results, setResults] = (0, react_1.useState)([]);
+    const [loading, setLoading] = (0, react_1.useState)(false);
+    const [error, setError] = (0, react_1.useState)(null);
+    const debounceMs = options?.debounceMs ?? 150;
+    (0, react_1.useEffect)(() => {
+        if (!client || !table || !queryText.trim()) {
+            setResults([]);
+            setLoading(false);
+            return;
+        }
+        let isMounted = true;
+        setLoading(true);
+        const timer = setTimeout(async () => {
+            try {
+                const res = await client.search.query(table, queryText, options);
+                if (isMounted) {
+                    setResults(res);
+                    setError(null);
+                }
+            }
+            catch (err) {
+                if (isMounted) {
+                    setError(err instanceof Error ? err : new Error(String(err)));
+                }
+            }
+            finally {
+                if (isMounted) {
+                    setLoading(false);
+                }
+            }
+        }, debounceMs);
+        return () => {
+            isMounted = false;
+            clearTimeout(timer);
+        };
+    }, [client, table, queryText, debounceMs]);
+    return { results, loading, error };
+}

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