local-lite 0.0.19 → 0.0.20

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;

package/dist/scheduler/types.d.ts

@@ -0,0 +1,44 @@
+export type ScheduleType = string | {
+    intervalMs: number;
+};
+export interface JobDefinition {
+    id: string;
+    name?: string;
+    /**
+     * Schedule expression:
+     * - Human string (e.g., 'every 10 minutes', 'every 1 hour', 'daily', 'hourly')
+     * - Standard 5-field cron (e.g., '* / 15 * * * *', '0 9 * * *')
+     * - Object with explicit millisecond interval: { intervalMs: 60000 }
+     */
+    schedule: ScheduleType;
+    /**
+     * Function to execute when the job triggers.
+     */
+    handler?: (job: JobRecord) => Promise<void> | void;
+    payload?: any;
+    enabled?: boolean;
+}
+export interface JobRecord {
+    id: string;
+    name: string;
+    schedule: string;
+    intervalMs: number;
+    lastRunAt: number | null;
+    nextRunAt: number;
+    enabled: boolean;
+    payload?: any;
+    createdAt: number;
+}
+export interface JobRunRecord {
+    id: string;
+    jobId: string;
+    status: 'SUCCESS' | 'FAILED' | 'RUNNING';
+    startedAt: number;
+    finishedAt: number | null;
+    durationMs: number | null;
+    error?: string | null;
+}
+export interface JobSchedulerOptions {
+    checkIntervalMs?: number;
+    autoStart?: boolean;
+}

package/dist/scheduler/types.js

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

package/dist/search/index.d.ts

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

package/dist/search/index.js

@@ -0,0 +1,19 @@
+"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("./store.js"), exports);
+__exportStar(require("./manager.js"), exports);

package/dist/search/manager.d.ts

@@ -0,0 +1,42 @@
+import { DBExecutable } from '../core/schema-manager.js';
+import { EventEmitter } from '../reactive/event-emitter.js';
+import { SearchIndexConfig, SearchQueryOptions, SearchResult } from './types.js';
+export declare class SearchManager {
+    private db;
+    private events?;
+    private getRowById?;
+    private indices;
+    private eventListeners;
+    constructor(db: DBExecutable, events?: EventEmitter | undefined, getRowById?: ((table: string, id: string) => Promise<any | null>) | undefined);
+    /**
+     * Registers and creates an FTS5 index for the specified table and columns.
+     * If an EventEmitter is available, hooks automatically update the index on mutations.
+     */
+    createIndex(config: SearchIndexConfig): Promise<void>;
+    /**
+     * Indexes or updates a single record in the FTS index.
+     */
+    indexRecord(table: string, rowId: string, values: Record<string, any>): Promise<void>;
+    /**
+     * Removes a record from the FTS index.
+     */
+    removeRecord(table: string, rowId: string): Promise<void>;
+    /**
+     * Rebuilds the search index for a table from an array of existing records.
+     */
+    rebuildIndex(table: string, records: Array<{
+        id: string;
+    } & Record<string, any>>): Promise<void>;
+    /**
+     * Executes a full-text search query, returning ranked matches with optional snippets and hydrated rows.
+     */
+    query<T = any>(table: string, queryText: string, options?: SearchQueryOptions): Promise<SearchResult<T>[]>;
+    /**
+     * Drops an index and cleans up auto-sync listeners.
+     */
+    dropIndex(table: string): Promise<void>;
+    /**
+     * Returns list of currently indexed table names.
+     */
+    getIndexedTables(): string[];
+}

package/dist/search/manager.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SearchManager = void 0;
+const store_js_1 = require("./store.js");
+class SearchManager {
+    db;
+    events;
+    getRowById;
+    indices = new Map();
+    eventListeners = new Map();
+    constructor(db, events, getRowById) {
+        this.db = db;
+        this.events = events;
+        this.getRowById = getRowById;
+    }
+    /**
+     * Registers and creates an FTS5 index for the specified table and columns.
+     * If an EventEmitter is available, hooks automatically update the index on mutations.
+     */
+    async createIndex(config) {
+        const table = config.table;
+        this.indices.set(table, config);
+        await store_js_1.SearchStore.ensureFtsTable(this.db, config);
+        // Auto-sync via event emitter if configured
+        if (this.events && !this.eventListeners.has(table)) {
+            const listener = async (e) => {
+                try {
+                    if (e.operation === 'DELETE') {
+                        await this.removeRecord(table, e.rowId);
+                    }
+                    else if (e.payload) {
+                        await this.indexRecord(table, e.rowId, e.payload);
+                    }
+                }
+                catch {
+                    // Background sync errors shouldn't crash the event bus
+                }
+            };
+            this.events.on(table, listener);
+            this.eventListeners.set(table, listener);
+        }
+    }
+    /**
+     * Indexes or updates a single record in the FTS index.
+     */
+    async indexRecord(table, rowId, values) {
+        const config = this.indices.get(table);
+        const columns = config ? config.columns : Object.keys(values).filter((k) => k !== 'id');
+        await store_js_1.SearchStore.indexRow(this.db, table, rowId, columns, values);
+    }
+    /**
+     * Removes a record from the FTS index.
+     */
+    async removeRecord(table, rowId) {
+        await store_js_1.SearchStore.removeRow(this.db, table, rowId);
+    }
+    /**
+     * Rebuilds the search index for a table from an array of existing records.
+     */
+    async rebuildIndex(table, records) {
+        const config = this.indices.get(table);
+        if (!config) {
+            throw new Error(`Search index not configured for table "${table}". Call createIndex first.`);
+        }
+        await store_js_1.SearchStore.clearFts(this.db, table);
+        for (const record of records) {
+            await store_js_1.SearchStore.indexRow(this.db, table, record.id, config.columns, record);
+        }
+    }
+    /**
+     * Executes a full-text search query, returning ranked matches with optional snippets and hydrated rows.
+     */
+    async query(table, queryText, options = {}) {
+        const config = this.indices.get(table);
+        const columns = config ? config.columns : [];
+        const matches = await store_js_1.SearchStore.search(this.db, table, columns, queryText, options);
+        const shouldHydrate = options.hydrateRow !== false;
+        const results = [];
+        for (const match of matches) {
+            let data = null;
+            if (shouldHydrate) {
+                if (this.getRowById) {
+                    data = await this.getRowById(table, match.rowId);
+                }
+                else {
+                    try {
+                        const rows = await this.db.execute(`SELECT * FROM ${table} WHERE id = ? LIMIT 1`, [match.rowId]);
+                        data = rows && rows.length > 0 ? rows[0] : null;
+                    }
+                    catch {
+                        data = null;
+                    }
+                }
+            }
+            results.push({
+                rowId: match.rowId,
+                rank: match.rank,
+                snippet: match.snippet,
+                data,
+            });
+        }
+        return results;
+    }
+    /**
+     * Drops an index and cleans up auto-sync listeners.
+     */
+    async dropIndex(table) {
+        this.indices.delete(table);
+        const listener = this.eventListeners.get(table);
+        if (listener && this.events) {
+            this.events.off(table, listener);
+            this.eventListeners.delete(table);
+        }
+        await store_js_1.SearchStore.dropFtsTable(this.db, table);
+    }
+    /**
+     * Returns list of currently indexed table names.
+     */
+    getIndexedTables() {
+        return Array.from(this.indices.keys());
+    }
+}
+exports.SearchManager = SearchManager;

package/dist/search/store.d.ts

@@ -0,0 +1,33 @@
+import { DBExecutable } from '../core/schema-manager.js';
+import { SearchIndexConfig, SearchQueryOptions } from './types.js';
+export declare function getFtsTableName(table: string): string;
+export declare class SearchStore {
+    /**
+     * Ensures the FTS5 virtual table exists for the given table and columns.
+     */
+    static ensureFtsTable(db: DBExecutable, config: SearchIndexConfig): Promise<void>;
+    /**
+     * Drops the FTS5 virtual table.
+     */
+    static dropFtsTable(db: DBExecutable, table: string): Promise<void>;
+    /**
+     * Indexes or updates a single row in the FTS table.
+     */
+    static indexRow(db: DBExecutable, table: string, rowId: string, columns: string[], values: Record<string, any>): Promise<void>;
+    /**
+     * Removes a single row from the FTS table.
+     */
+    static removeRow(db: DBExecutable, table: string, rowId: string): Promise<void>;
+    /**
+     * Clears all rows in the FTS table.
+     */
+    static clearFts(db: DBExecutable, table: string): Promise<void>;
+    /**
+     * Executes a full-text search match query against the FTS5 table.
+     */
+    static search(db: DBExecutable, table: string, columns: string[], queryText: string, options?: SearchQueryOptions): Promise<Array<{
+        rowId: string;
+        rank: number;
+        snippet?: string;
+    }>>;
+}

package/dist/search/store.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SearchStore = void 0;
+exports.getFtsTableName = getFtsTableName;
+function getFtsTableName(table) {
+    return `_fts_${table}`;
+}
+class SearchStore {
+    /**
+     * Ensures the FTS5 virtual table exists for the given table and columns.
+     */
+    static async ensureFtsTable(db, config) {
+        const ftsTable = getFtsTableName(config.table);
+        const cols = config.columns.map((c) => c.trim()).filter(Boolean);
+        const tokenize = config.tokenize || 'unicode61';
+        // row_id is UNINDEXED in FTS5 so it does not pollute search tokens
+        const columnDefs = ['row_id UNINDEXED', ...cols].join(', ');
+        const sql = `CREATE VIRTUAL TABLE IF NOT EXISTS ${ftsTable} USING fts5(${columnDefs}, tokenize='${tokenize}');`;
+        try {
+            await db.execute(sql);
+        }
+        catch (err) {
+            // In case tokenize='unicode61' isn't supported by legacy SQLite build, retry without tokenize option
+            if (err?.message?.includes('tokenize') || err?.message?.includes('unknown tokenizer')) {
+                await db.execute(`CREATE VIRTUAL TABLE IF NOT EXISTS ${ftsTable} USING fts5(${columnDefs});`);
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+    /**
+     * Drops the FTS5 virtual table.
+     */
+    static async dropFtsTable(db, table) {
+        const ftsTable = getFtsTableName(table);
+        await db.execute(`DROP TABLE IF EXISTS ${ftsTable};`);
+    }
+    /**
+     * Indexes or updates a single row in the FTS table.
+     */
+    static async indexRow(db, table, rowId, columns, values) {
+        const ftsTable = getFtsTableName(table);
+        // Delete existing entry if any
+        await db.execute(`DELETE FROM ${ftsTable} WHERE row_id = ?;`, [rowId]);
+        const cols = ['row_id', ...columns];
+        const placeholders = cols.map(() => '?').join(', ');
+        const params = [
+            rowId,
+            ...columns.map((c) => {
+                const val = values[c];
+                if (val === null || val === undefined)
+                    return '';
+                if (typeof val === 'object')
+                    return JSON.stringify(val);
+                return String(val);
+            }),
+        ];
+        await db.execute(`INSERT INTO ${ftsTable} (${cols.join(', ')}) VALUES (${placeholders});`, params);
+    }
+    /**
+     * Removes a single row from the FTS table.
+     */
+    static async removeRow(db, table, rowId) {
+        const ftsTable = getFtsTableName(table);
+        await db.execute(`DELETE FROM ${ftsTable} WHERE row_id = ?;`, [rowId]);
+    }
+    /**
+     * Clears all rows in the FTS table.
+     */
+    static async clearFts(db, table) {
+        const ftsTable = getFtsTableName(table);
+        await db.execute(`DELETE FROM ${ftsTable};`);
+    }
+    /**
+     * Executes a full-text search match query against the FTS5 table.
+     */
+    static async search(db, table, columns, queryText, options = {}) {
+        const ftsTable = getFtsTableName(table);
+        const limit = options.limit ?? 20;
+        const offset = options.offset ?? 0;
+        const preTag = options.highlightPreTag ?? '<mark>';
+        const postTag = options.highlightPostTag ?? '</mark>';
+        // Prepare match phrase: escape quotes or sanitize
+        // If query has multiple terms, SQLite FTS5 supports prefix matching (e.g. "term*")
+        const terms = queryText
+            .trim()
+            .split(/\s+/)
+            .map((t) => t.replace(/["*]/g, ''))
+            .filter(Boolean);
+        if (terms.length === 0) {
+            return [];
+        }
+        // Search query syntax: each term as prefix search: "term1"* "term2"*
+        const matchQuery = terms.map((t) => `"${t}"*`).join(' ');
+        // Snippet column index in FTS5: columns are 0-based: col 0 is row_id, col 1 is columns[0], etc.
+        // We pick column index 1 (or the first indexed text column) for snippet extraction
+        const snippetColIndex = 1;
+        let sql = `
+      SELECT 
+        row_id,
+        rank,
+        snippet(${ftsTable}, ${snippetColIndex}, '${preTag}', '${postTag}', '...', 15) as snippet_text
+      FROM ${ftsTable}
+      WHERE ${ftsTable} MATCH ?
+      ORDER BY rank
+      LIMIT ? OFFSET ?;
+    `;
+        try {
+            const rows = await db.execute(sql, [matchQuery, limit, offset]);
+            return (rows || []).map((r) => ({
+                rowId: String(r.row_id),
+                rank: Number(r.rank ?? 0),
+                snippet: r.snippet_text ?? undefined,
+            }));
+        }
+        catch (err) {
+            // In case snippet() function is unavailable in the environment, fallback to rank-only search
+            if (err?.message?.includes('snippet') || err?.message?.includes('no such function')) {
+                const fallbackSql = `
+          SELECT row_id, rank
+          FROM ${ftsTable}
+          WHERE ${ftsTable} MATCH ?
+          ORDER BY rank
+          LIMIT ? OFFSET ?;
+        `;
+                const rows = await db.execute(fallbackSql, [matchQuery, limit, offset]);
+                return (rows || []).map((r) => ({
+                    rowId: String(r.row_id),
+                    rank: Number(r.rank ?? 0),
+                }));
+            }
+            throw err;
+        }
+    }
+}
+exports.SearchStore = SearchStore;

package/dist/search/types.d.ts

@@ -0,0 +1,49 @@
+export interface SearchIndexConfig {
+    /**
+     * The name of the table to index (e.g. 'properties', 'tenants').
+     */
+    table: string;
+    /**
+     * The text columns to include in the full-text search index.
+     */
+    columns: string[];
+    /**
+     * SQLite FTS tokenizer (e.g. 'unicode61', 'porter', 'ascii').
+     * Default: 'unicode61'
+     */
+    tokenize?: string;
+}
+export interface SearchQueryOptions {
+    /**
+     * Maximum search results to return (default: 20).
+     */
+    limit?: number;
+    /**
+     * Pagination offset.
+     */
+    offset?: number;
+    /**
+     * Whether to include a highlighted snippet matching the search query.
+     * Default: true
+     */
+    highlight?: boolean;
+    /**
+     * Tag prefix for highlights (default: '<mark>').
+     */
+    highlightPreTag?: string;
+    /**
+     * Tag suffix for highlights (default: '</mark>').
+     */
+    highlightPostTag?: string;
+    /**
+     * Whether to hydrate the full row record from the base table.
+     * Default: true
+     */
+    hydrateRow?: boolean;
+}
+export interface SearchResult<T = any> {
+    rowId: string;
+    rank: number;
+    snippet?: string;
+    data?: T | null;
+}

package/dist/search/types.js

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

package/dist/storage/driver.d.ts

@@ -0,0 +1,25 @@
+import { FileDriver } from './types.js';
+/**
+ * Universal in-memory driver (ideal for tests, memory caches, and browser storage fallback).
+ */
+export declare class MemoryFileDriver implements FileDriver {
+    private files;
+    write(key: string, data: Uint8Array): Promise<string>;
+    read(key: string): Promise<Uint8Array | null>;
+    delete(key: string): Promise<void>;
+    exists(key: string): Promise<boolean>;
+    clear(): void;
+}
+/**
+ * Node.js filesystem driver for writing blobs to disk.
+ */
+export declare class NodeFileDriver implements FileDriver {
+    private baseDir;
+    constructor(baseDir?: string);
+    private getFs;
+    private getResolvedPath;
+    write(key: string, data: Uint8Array): Promise<string>;
+    read(key: string): Promise<Uint8Array | null>;
+    delete(key: string): Promise<void>;
+    exists(key: string): Promise<boolean>;
+}