@platformatic/sqlite-js-stream 0.0.0-stage → 0.1.1

package/dist/db.js

@@ -0,0 +1,484 @@
+/**
+ * LocalDatabase is the internal engine that reads a SQLite database and its
+ * `-wal` file and writes LTX files into a local cache (`<path>-litestream/ltx/`).
+ *
+ * It is deliberately NOT part of the public API: `Replica`/`Store` take a
+ * database `path` and read directly, so the library is agnostic to whatever
+ * SQLite driver the application uses. To keep snapshots consistent, it holds a
+ * short-lived **read-only** `node:sqlite` read transaction that pins the WAL
+ * (SQLite will not checkpoint/truncate the WAL past an active reader), while
+ * reading the database + WAL files directly.
+ */
+import { DatabaseSync } from 'node:sqlite';
+import { open, readFile, readdir, rename, rm, stat } from 'node:fs/promises';
+import nodePath from 'node:path';
+import { Decoder, Encoder, HeaderFlagNoChecksum, HeaderSize, formatFilename, lockPgno, parseFilename, } from "./ltx/index.js";
+import { FileSink } from "./util/fs.js";
+import { PrevFrameMismatchError, WALFrameHeaderSize, WALHeaderSize, WALReader, WALEOFError, } from "./wal/index.js";
+import { SnapshotLevel } from "./replica-client.js";
+import { mkdirAll } from "./util/fs.js";
+import { DatabaseError } from "./errors.js";
+/** Reads the page size from the SQLite database header (bytes 16-17). */
+function headerPageSize(buf) {
+    const raw = buf.length >= 18 ? (buf[16] << 8) | buf[17] : 0;
+    if (raw === 1)
+        return 65536;
+    return raw || 4096;
+}
+/**
+ * LocalDatabase reads a database + WAL from disk, tracks the local replicated
+ * position, and builds LTX files in the local cache.
+ */
+export class LocalDatabase {
+    path;
+    metaPath;
+    pageSize;
+    conn = null;
+    constructor(path, metaPath, pageSize) {
+        this.path = path;
+        this.metaPath = metaPath;
+        this.pageSize = pageSize;
+    }
+    /**
+     * Open opens a local database reader for `path`. It does not create the
+     * database — the application owns it. `pageSize` is read from the database
+     * header; a missing file falls back to the default page size.
+     */
+    static async open(path) {
+        const metaPath = `${path}-litestream`;
+        await mkdirAll(nodePath.join(metaPath, 'ltx', '0'));
+        let pageSize = 4096;
+        try {
+            const fh = await open(path, 'r');
+            const buf = new Uint8Array(18);
+            await fh.read(buf, 0, 18, 0);
+            await fh.close();
+            pageSize = headerPageSize(buf);
+        }
+        catch {
+            /* database not present yet; use default page size */
+        }
+        return new LocalDatabase(path, metaPath, pageSize);
+    }
+    /** WalPath returns the path to the database's WAL file. */
+    walPath() {
+        return `${this.path}-wal`;
+    }
+    /** LTXDir returns the local LTX root directory. */
+    ltxDir() {
+        return nodePath.join(this.metaPath, 'ltx');
+    }
+    /** LTXLevelDir returns the local LTX directory for a level. */
+    ltxLevelDir(level) {
+        return nodePath.join(this.ltxDir(), String(level));
+    }
+    /** LTXPath returns the local path of a single LTX file. */
+    ltxPath(level, minTXID, maxTXID) {
+        return nodePath.join(this.ltxLevelDir(level), formatFilename(minTXID, maxTXID));
+    }
+    /** Lists local level-0 LTX files, sorted by TXID. */
+    async l0Files() {
+        return this.filesForLevel(0);
+    }
+    /** Lists local LTX files for any level, sorted by TXID. */
+    async filesForLevel(level) {
+        const dir = this.ltxLevelDir(level);
+        const out = [];
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch (err) {
+            if (err.code === 'ENOENT')
+                return out;
+            throw err;
+        }
+        for (const entry of entries) {
+            if (!entry.isFile())
+                continue;
+            let minTXID;
+            let maxTXID;
+            try {
+                ({ minTXID, maxTXID } = parseFilename(entry.name));
+            }
+            catch {
+                continue;
+            }
+            const st = await stat(nodePath.join(dir, entry.name));
+            out.push({ level, minTXID, maxTXID, size: st.size, createdAt: st.mtimeMs });
+        }
+        out.sort((a, b) => (a.minTXID < b.minTXID ? -1 : a.minTXID > b.minTXID ? 1 : 0));
+        return out;
+    }
+    /** Pos returns the maximum TXID in the local level-0 cache (0 if none). */
+    async pos() {
+        const m = await this.maxFile();
+        return m === null ? 0n : m.maxTXID;
+    }
+    /** Returns the local LTX file with the highest maxTXID across all levels. */
+    async maxFile() {
+        let best = null;
+        for (let level = 0; level <= SnapshotLevel; level++) {
+            for (const f of await this.filesForLevel(level)) {
+                if (best === null || f.maxTXID > best.maxTXID)
+                    best = f;
+            }
+        }
+        return best;
+    }
+    /**
+     * Opens (and caches) a read-only connection used to hold a snapshot during
+     * sync/snapshot. Not part of the public API; the DB file must exist.
+     */
+    ensureConn() {
+        if (this.conn === null) {
+            this.conn = new DatabaseSync(this.path, { readOnly: true });
+            this.conn.exec('PRAGMA busy_timeout=5000');
+        }
+        return this.conn;
+    }
+    /**
+     * Pins a WAL snapshot by starting a read transaction and issuing a read that
+     * touches the database (a plain `SELECT 1` does not acquire the WAL read lock).
+     */
+    beginRead() {
+        const conn = this.ensureConn();
+        conn.exec('BEGIN');
+        conn.prepare('SELECT count(*) FROM sqlite_master').get();
+    }
+    /** Releases the pinned read snapshot. */
+    commitRead() {
+        if (this.conn !== null) {
+            this.conn.exec('COMMIT');
+        }
+    }
+    /** Current committed database size, in pages (as seen by the pinned reader). */
+    pageCount() {
+        const r = this.ensureConn().prepare('PRAGMA page_count').get();
+        return r.page_count;
+    }
+    /** Sync builds a level-0 LTX file and writes it to the local cache. */
+    async sync() {
+        const pos = await this.pos();
+        const txID = pos + 1n;
+        this.beginRead();
+        let dbHandle = null;
+        try {
+            const commit = this.pageCount();
+            if (commit === 0)
+                return null;
+            const pageSize = this.pageSize;
+            const lockPg = lockPgno(pageSize);
+            dbHandle = await open(this.path, 'r');
+            const walBuf = await this.readWalOrEmpty();
+            // Determine the previous sync state to resume incremental reading.
+            const prev = await this.prevSyncInfo();
+            let snapshotting = prev === null;
+            let reader = null;
+            let offset = WALHeaderSize;
+            let salt1 = 0;
+            let salt2 = 0;
+            let pageMap = new Map();
+            let maxOffset = 0;
+            let walCommit = 0;
+            let prevCommit = 0;
+            if (!snapshotting && prev !== null) {
+                reader = makeResumeReader(walBuf, prev.walOffset + prev.walSize, prev.salt1, prev.salt2);
+                if (reader === null) {
+                    snapshotting = true; // WAL was reset; fall back to a snapshot base
+                }
+                else {
+                    const pm = reader.pageMap();
+                    pageMap = pm.pageIndex;
+                    maxOffset = pm.maxOffset;
+                    walCommit = pm.commit;
+                    offset = prev.walOffset + prev.walSize;
+                    salt1 = prev.salt1;
+                    salt2 = prev.salt2;
+                    prevCommit = prev.commit;
+                }
+            }
+            const walSize = snapshotting ? 0 : maxOffset > 0 ? maxOffset - offset : 0;
+            if (!snapshotting && walSize === 0) {
+                return null; // no new WAL pages since the last sync
+            }
+            if (snapshotting) {
+                // Read the WAL from the start to build a full page map for the snapshot.
+                try {
+                    const full = new WALReader(walBuf);
+                    const pm = full.pageMap();
+                    pageMap = pm.pageIndex;
+                    walCommit = pm.commit;
+                    salt1 = full.salt1();
+                    salt2 = full.salt2();
+                }
+                catch (err) {
+                    if (!(err instanceof WALEOFError))
+                        throw err;
+                }
+                if (walCommit > 0) {
+                    offset = WALHeaderSize;
+                }
+            }
+            const finalCommit = Math.max(commit, walCommit);
+            // Stream the LTX output directly to a temp file (no whole-file buffer).
+            const dir = this.ltxLevelDir(0);
+            await mkdirAll(dir);
+            const filename = this.ltxPath(0, txID, txID);
+            const tmp = `${filename}.tmp`;
+            const fh = await open(tmp, 'w');
+            const sink = new FileSink(fh);
+            const enc = new Encoder(sink);
+            try {
+                enc.encodeHeader({
+                    version: 3,
+                    flags: HeaderFlagNoChecksum,
+                    pageSize,
+                    commit: finalCommit,
+                    minTXID: txID,
+                    maxTXID: txID,
+                    timestamp: BigInt(Date.now()),
+                    preApplyChecksum: 0n,
+                    walOffset: BigInt(offset),
+                    walSize: BigInt(snapshotting ? Math.max(0, walBuf.length - WALHeaderSize) : walSize),
+                    walSalt1: salt1,
+                    walSalt2: salt2,
+                    nodeID: 0n,
+                });
+                if (snapshotting) {
+                    await this.writePagesFromDB(enc, pageSize, finalCommit, lockPg, pageMap, walBuf, dbHandle);
+                }
+                else {
+                    await this.writePagesFromWAL(enc, pageSize, finalCommit, prevCommit, lockPg, pageMap, walBuf, dbHandle);
+                }
+                enc.close();
+                await sink.flush();
+                await fh.close();
+                await rename(tmp, filename);
+                const size = (await stat(filename)).size;
+                return { level: 0, minTXID: txID, maxTXID: txID, size, createdAt: Date.now() };
+            }
+            catch (err) {
+                await fh.close().catch(() => { });
+                await rm(tmp, { force: true }).catch(() => { });
+                throw err;
+            }
+        }
+        finally {
+            if (dbHandle !== null)
+                await dbHandle.close();
+            this.commitRead();
+        }
+    }
+    /** Writes a full snapshot: every committed page, preferring WAL pages. */
+    async writePagesFromDB(enc, pageSize, commit, lockPg, pageMap, walBuf, dbHandle) {
+        for (let pgno = 1; pgno <= commit; pgno++) {
+            if (pgno === lockPg)
+                continue;
+            enc.encodePage({ pgno, flags: 0 }, await this.readPage(pgno, pageSize, pageMap, walBuf, dbHandle));
+        }
+    }
+    /** Writes an incremental file: changed WAL pages + DB growth pages. */
+    async writePagesFromWAL(enc, pageSize, commit, prevCommit, lockPg, pageMap, walBuf, dbHandle) {
+        // Sorted page numbers present in the WAL change-set.
+        const pgnos = [...pageMap.keys()].sort((a, b) => a - b);
+        const lockPgno = lockPg;
+        // Add DB growth pages (new pages beyond prevCommit not already in pageMap).
+        if (commit > prevCommit) {
+            for (let pgno = prevCommit + 1; pgno <= commit; pgno++) {
+                if (pgno === lockPgno)
+                    continue;
+                if (pageMap.has(pgno))
+                    continue;
+                pgnos.push(pgno);
+            }
+        }
+        for (const pgno of pgnos) {
+            if (pgno === lockPgno)
+                continue;
+            // Growth pages (not in pageMap) come directly from the database file.
+            if (!pageMap.has(pgno)) {
+                const page = new Uint8Array(pageSize);
+                await readExact(dbHandle, page, (pgno - 1) * pageSize);
+                enc.encodePage({ pgno, flags: 0 }, page);
+                continue;
+            }
+            enc.encodePage({ pgno, flags: 0 }, await this.readPage(pgno, pageSize, pageMap, walBuf, dbHandle));
+        }
+    }
+    /**
+     * Snapshot writes a full-database LTX file at `SnapshotLevel` (9) with
+     * MinTXID=1 and MaxTXID equal to the current local position. Returns null if
+     * a snapshot would cover no data (empty database).
+     */
+    async snapshot() {
+        const pos = await this.pos();
+        const maxTXID = pos === 0n ? 1n : pos;
+        this.beginRead();
+        let dbHandle = null;
+        try {
+            const commit = this.pageCount();
+            if (commit === 0)
+                return null;
+            const pageSize = this.pageSize;
+            const lockPg = lockPgno(pageSize);
+            dbHandle = await open(this.path, 'r');
+            const walBuf = await this.readWalOrEmpty();
+            // Build the committed WAL page map for the overlay (may be empty).
+            let pageMap = new Map();
+            let walCommit = 0;
+            let salt1 = 0;
+            let salt2 = 0;
+            if (walBuf.length > 0) {
+                try {
+                    const full = new WALReader(walBuf);
+                    const pm = full.pageMap();
+                    pageMap = pm.pageIndex;
+                    walCommit = pm.commit;
+                    salt1 = full.salt1();
+                    salt2 = full.salt2();
+                }
+                catch (err) {
+                    if (!(err instanceof WALEOFError))
+                        throw err;
+                }
+            }
+            // The commit may only be present in the WAL (not yet checkpointed into
+            // the main database header), so take the larger of the two.
+            const finalCommit = Math.max(commit, walCommit);
+            if (finalCommit === 0)
+                return null;
+            // Stream the LTX output directly to a temp file (no whole-file buffer).
+            const dir = this.ltxLevelDir(9);
+            await mkdirAll(dir);
+            const filename = this.ltxPath(9, 1n, maxTXID);
+            const tmp = `${filename}.tmp`;
+            const fh = await open(tmp, 'w');
+            const sink = new FileSink(fh);
+            const enc = new Encoder(sink);
+            try {
+                enc.encodeHeader({
+                    version: 3,
+                    flags: HeaderFlagNoChecksum,
+                    pageSize,
+                    commit: finalCommit,
+                    minTXID: 1n,
+                    maxTXID,
+                    timestamp: BigInt(Date.now()),
+                    preApplyChecksum: 0n,
+                    walOffset: BigInt(WALHeaderSize),
+                    walSize: BigInt(Math.max(0, walBuf.length - WALHeaderSize)),
+                    walSalt1: salt1,
+                    walSalt2: salt2,
+                    nodeID: 0n,
+                });
+                await this.writePagesFromDB(enc, pageSize, finalCommit, lockPg, pageMap, walBuf, dbHandle);
+                enc.close();
+                await sink.flush();
+                await fh.close();
+            }
+            catch (err) {
+                await fh.close().catch(() => { });
+                await rm(tmp, { force: true }).catch(() => { });
+                throw err;
+            }
+            await rename(tmp, filename);
+            const size = (await stat(filename)).size;
+            return { level: 9, minTXID: 1n, maxTXID, size, createdAt: Date.now() };
+        }
+        finally {
+            if (dbHandle !== null)
+                await dbHandle.close();
+            this.commitRead();
+        }
+    }
+    /** Reads a single page, preferring the WAL over the database file. */
+    async readPage(pgno, pageSize, pageMap, walBuf, dbHandle) {
+        const off = pageMap.get(pgno);
+        if (off !== undefined) {
+            const start = off + WALFrameHeaderSize;
+            return new Uint8Array(walBuf.subarray(start, start + pageSize));
+        }
+        const page = new Uint8Array(pageSize);
+        await readExact(dbHandle, page, (pgno - 1) * pageSize);
+        return page;
+    }
+    /** Reads the WAL file bytes, returning empty if it does not exist. */
+    async readWalOrEmpty() {
+        try {
+            return new Uint8Array(await readFile(this.walPath()));
+        }
+        catch {
+            return new Uint8Array(0);
+        }
+    }
+    /** Decodes the header of the max-TXID local L0 file (or null if none). */
+    async prevSyncInfo() {
+        const max = await this.maxFile();
+        if (max === null)
+            return null;
+        try {
+            // Only the 100-byte header is needed; do not read the whole file.
+            const fh = await open(this.ltxPath(max.level, max.minTXID, max.maxTXID), 'r');
+            try {
+                const buf = new Uint8Array(HeaderSize);
+                await readExact(fh, buf, 0);
+                const hdr = new Decoder(buf);
+                hdr.decodeHeader();
+                const h = hdr.Header();
+                return {
+                    walOffset: Number(h.walOffset),
+                    walSize: Number(h.walSize),
+                    salt1: h.walSalt1,
+                    salt2: h.walSalt2,
+                    commit: h.commit,
+                };
+            }
+            finally {
+                await fh.close();
+            }
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Close releases the internal read-only connection. */
+    close() {
+        if (this.conn !== null) {
+            this.conn.close();
+            this.conn = null;
+        }
+    }
+}
+/** Creates a WALReader positioned at `offset`, or null if it cannot resume. */
+function makeResumeReader(walBuf, offset, salt1, salt2) {
+    if (walBuf.length === 0)
+        return null;
+    if (offset <= WALHeaderSize) {
+        // Starting fresh (or before any frames): read from the header.
+        try {
+            return new WALReader(walBuf);
+        }
+        catch {
+            return null;
+        }
+    }
+    try {
+        return WALReader.withOffset(walBuf, offset, salt1, salt2);
+    }
+    catch (err) {
+        if (err instanceof PrevFrameMismatchError)
+            return null;
+        throw err;
+    }
+}
+/** Reads exactly `buf.length` bytes into `buf` from `handle` at `position`. */
+async function readExact(handle, buf, position) {
+    let offset = 0;
+    while (offset < buf.length) {
+        const { bytesRead } = await handle.read(buf, offset, buf.length - offset, position + offset);
+        if (bytesRead === 0)
+            throw new DatabaseError('unexpected end of file while reading a page');
+        offset += bytesRead;
+    }
+}

package/dist/errors.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Shared error base for sqlite-js-stream.
+ *
+ * Every typed library error extends {@link SqliteJsStreamError} and carries a
+ * stable, Node-style `code` string (e.g. `ERR_NO_MATCHING_BACKUP`). This lets
+ * callers catch any library error with a single `instanceof`, and branch on the
+ * precise failure via `err.code` without matching message text.
+ */
+export declare class SqliteJsStreamError extends Error {
+    /** Stable, machine-readable error code (Node.js convention). */
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+/** A required function argument is missing or invalid (`ERR_INVALID_ARGUMENT`). */
+export declare class InvalidArgumentError extends SqliteJsStreamError {
+    constructor(message: string);
+}
+/** An incremental LTX file's page size differs from the base database. */
+export declare class PageSizeMismatchError extends SqliteJsStreamError {
+    constructor(message: string);
+}
+/** An LTX file is malformed/corrupt or violates the format (`ERR_LTX_FORMAT`). */
+export declare class LTXFormatError extends SqliteJsStreamError {
+    constructor(message: string);
+}
+/** A SQLite WAL file is malformed/corrupt (`ERR_WAL_FORMAT`). */
+export declare class WALFormatError extends SqliteJsStreamError {
+    constructor(message: string);
+}
+/** A replica URL is malformed or uses an unsupported scheme (`ERR_REPLICA_URL`). */
+export declare class ReplicaURLError extends SqliteJsStreamError {
+    constructor(message: string);
+}
+/** A file/backend replica operation failed (`ERR_FILE_REPLICA`). */
+export declare class FileReplicaError extends SqliteJsStreamError {
+    constructor(message: string);
+}
+/** A SQLite database file is missing/invalid or could not be read (`ERR_DATABASE`). */
+export declare class DatabaseError extends SqliteJsStreamError {
+    constructor(message: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,qBAAa,mBAAoB,SAAQ,KAAK;IAC5C,gEAAgE;IAChE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;gBAEV,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAK1C;AAED,mFAAmF;AACnF,qBAAa,oBAAqB,SAAQ,mBAAmB;gBAC/C,OAAO,EAAE,MAAM;CAI5B;AAED,0EAA0E;AAC1E,qBAAa,qBAAsB,SAAQ,mBAAmB;gBAChD,OAAO,EAAE,MAAM;CAI5B;AAED,kFAAkF;AAClF,qBAAa,cAAe,SAAQ,mBAAmB;gBACzC,OAAO,EAAE,MAAM;CAI5B;AAED,iEAAiE;AACjE,qBAAa,cAAe,SAAQ,mBAAmB;gBACzC,OAAO,EAAE,MAAM;CAI5B;AAED,oFAAoF;AACpF,qBAAa,eAAgB,SAAQ,mBAAmB;gBAC1C,OAAO,EAAE,MAAM;CAI5B;AAED,oEAAoE;AACpE,qBAAa,gBAAiB,SAAQ,mBAAmB;gBAC3C,OAAO,EAAE,MAAM;CAI5B;AAED,uFAAuF;AACvF,qBAAa,aAAc,SAAQ,mBAAmB;gBACxC,OAAO,EAAE,MAAM;CAI5B"}

package/dist/errors.js

@@ -0,0 +1,66 @@
+/**
+ * Shared error base for sqlite-js-stream.
+ *
+ * Every typed library error extends {@link SqliteJsStreamError} and carries a
+ * stable, Node-style `code` string (e.g. `ERR_NO_MATCHING_BACKUP`). This lets
+ * callers catch any library error with a single `instanceof`, and branch on the
+ * precise failure via `err.code` without matching message text.
+ */
+export class SqliteJsStreamError extends Error {
+    /** Stable, machine-readable error code (Node.js convention). */
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'SqliteJsStreamError';
+        this.code = code;
+    }
+}
+/** A required function argument is missing or invalid (`ERR_INVALID_ARGUMENT`). */
+export class InvalidArgumentError extends SqliteJsStreamError {
+    constructor(message) {
+        super('ERR_INVALID_ARGUMENT', message);
+        this.name = 'InvalidArgumentError';
+    }
+}
+/** An incremental LTX file's page size differs from the base database. */
+export class PageSizeMismatchError extends SqliteJsStreamError {
+    constructor(message) {
+        super('ERR_PAGE_SIZE_MISMATCH', message);
+        this.name = 'PageSizeMismatchError';
+    }
+}
+/** An LTX file is malformed/corrupt or violates the format (`ERR_LTX_FORMAT`). */
+export class LTXFormatError extends SqliteJsStreamError {
+    constructor(message) {
+        super('ERR_LTX_FORMAT', message);
+        this.name = 'LTXFormatError';
+    }
+}
+/** A SQLite WAL file is malformed/corrupt (`ERR_WAL_FORMAT`). */
+export class WALFormatError extends SqliteJsStreamError {
+    constructor(message) {
+        super('ERR_WAL_FORMAT', message);
+        this.name = 'WALFormatError';
+    }
+}
+/** A replica URL is malformed or uses an unsupported scheme (`ERR_REPLICA_URL`). */
+export class ReplicaURLError extends SqliteJsStreamError {
+    constructor(message) {
+        super('ERR_REPLICA_URL', message);
+        this.name = 'ReplicaURLError';
+    }
+}
+/** A file/backend replica operation failed (`ERR_FILE_REPLICA`). */
+export class FileReplicaError extends SqliteJsStreamError {
+    constructor(message) {
+        super('ERR_FILE_REPLICA', message);
+        this.name = 'FileReplicaError';
+    }
+}
+/** A SQLite database file is missing/invalid or could not be read (`ERR_DATABASE`). */
+export class DatabaseError extends SqliteJsStreamError {
+    constructor(message) {
+        super('ERR_DATABASE', message);
+        this.name = 'DatabaseError';
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * sqlite-js-stream — a Node.js port of Litestream.
+ *
+ * This is the public entry point. For now it only exports the version marker
+ * and placeholder types; the LTX/WAL/DB layers are added in later milestones.
+ */
+export declare const VERSION = "0.1.0";
+export type TXID = bigint;
+export * from './errors.js';
+export * from './ltx/index.js';
+export * from './wal/index.js';
+export * from './replica-client.js';
+export * from './replica-url.js';
+export * from './backends/file/index.js';
+export * from './replica.js';
+export * from './store.js';
+export * from './leaser.js';
+export * from './util/logger.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,eAAO,MAAM,OAAO,UAAU,CAAC;AAE/B,MAAM,MAAM,IAAI,GAAG,MAAM,CAAC;AAE1B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,0BAA0B,CAAC;AAIzC,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAG5B,cAAc,kBAAkB,CAAC"}

package/dist/index.js

@@ -0,0 +1,22 @@
+/**
+ * sqlite-js-stream — a Node.js port of Litestream.
+ *
+ * This is the public entry point. For now it only exports the version marker
+ * and placeholder types; the LTX/WAL/DB layers are added in later milestones.
+ */
+export const VERSION = '0.1.0';
+export * from "./errors.js";
+export * from "./ltx/index.js";
+export * from "./wal/index.js";
+export * from "./replica-client.js";
+export * from "./replica-url.js";
+export * from "./backends/file/index.js";
+// The DB layer (`src/db.ts`) is intentionally NOT part of the public API.
+// `Replica`/`Store` take a database path and read the DB + WAL directly, so the
+// library is agnostic to whatever SQLite driver the application uses.
+export * from "./replica.js";
+export * from "./store.js";
+export * from "./leaser.js";
+// Logger is part of the public ReplicaClient contract; expose it so addons
+// (e.g. the S3 backend) can implement the interface consistently.
+export * from "./util/logger.js";