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

package/dist/ltx/encoder.d.ts

@@ -0,0 +1,49 @@
+/**
+ * LTX encoder.
+ *
+ * Mirrors Go's `ltx.Encoder`. The encoder streams header, page frames, page
+ * index, and trailer to a `ByteSink`, maintaining a running CRC-64 ISO file
+ * checksum over all logical content (header, page headers, compressed-size
+ * prefixes, *decompressed* page data, page index bytes, and the trailer's
+ * post-apply checksum) plus a byte counter for page-index offsets.
+ */
+import type { ByteSink } from './sink.js';
+import type { Header, PageHeader, Trailer } from './types.js';
+/** Encoder writes an LTX file to a ByteSink. */
+export declare class Encoder {
+    private sink;
+    private state;
+    private header;
+    private trailer;
+    private hash;
+    private index;
+    private n;
+    private prevPgno;
+    private pagesWritten;
+    constructor(sink: ByteSink);
+    /** Returns the number of bytes written to the sink so far. */
+    N(): number;
+    /** Returns a shallow copy of the header. */
+    Header(): Header;
+    /** Returns the trailer (file checksum valid after Close()). */
+    Trailer(): Trailer;
+    /** Returns the replication position after applying this file. */
+    PostApplyPos(): {
+        txID: bigint;
+        postApplyChecksum: bigint;
+    };
+    /** SetPostApplyChecksum sets the database checksum to record in the trailer. */
+    setPostApplyChecksum(chk: bigint): void;
+    /** EncodeHeader writes the header frame and initializes the checksum. */
+    encodeHeader(h: Header): void;
+    /**
+     * EncodePage writes a single page frame. `data` must be exactly the page
+     * size and `hdr.pgno` must be in ascending order and not the lock page.
+     */
+    encodePage(hdr: PageHeader, data: Uint8Array): void;
+    /** Close writes the end-of-pages marker, page index, and trailer. */
+    close(): void;
+    /** Writes to the sink, feeding the checksum and byte counter. */
+    private write;
+}
+//# sourceMappingURL=encoder.d.ts.map

package/dist/ltx/encoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoder.d.ts","sourceRoot":"","sources":["../../src/ltx/encoder.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAYH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAkB9D,gDAAgD;AAChD,qBAAa,OAAO;IAClB,OAAO,CAAC,IAAI,CAAW;IACvB,OAAO,CAAC,KAAK,CAAuB;IACpC,OAAO,CAAC,MAAM,CAAU;IACxB,OAAO,CAAC,OAAO,CAAwD;IACvE,OAAO,CAAC,IAAI,CAAe;IAC3B,OAAO,CAAC,KAAK,CAAoB;IACjC,OAAO,CAAC,CAAC,CAAK;IACd,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,YAAY,CAAK;gBAEb,IAAI,EAAE,QAAQ;IAI1B,8DAA8D;IAC9D,CAAC,IAAI,MAAM;IAIX,4CAA4C;IAC5C,MAAM,IAAI,MAAM;IAIhB,+DAA+D;IAC/D,OAAO,IAAI,OAAO;IAIlB,iEAAiE;IACjE,YAAY;;;;IAOZ,gFAAgF;IAChF,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAIvC,yEAAyE;IACzE,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAY7B;;;OAGG;IACH,UAAU,CAAC,GAAG,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,GAAG,IAAI;IA4DnD,qEAAqE;IACrE,KAAK,IAAI,IAAI;IAgCb,iEAAiE;IACjE,OAAO,CAAC,KAAK;CAKd"}

package/dist/ltx/encoder.js

@@ -0,0 +1,159 @@
+/**
+ * LTX encoder.
+ *
+ * Mirrors Go's `ltx.Encoder`. The encoder streams header, page frames, page
+ * index, and trailer to a `ByteSink`, maintaining a running CRC-64 ISO file
+ * checksum over all logical content (header, page headers, compressed-size
+ * prefixes, *decompressed* page data, page index bytes, and the trailer's
+ * post-apply checksum) plus a byte counter for page-index offsets.
+ */
+import { ChecksumFlag, PageHeaderFlagSize, PageHeaderSize, TrailerChecksumOffset, TrailerSize, lockPgno, } from "./constants.js";
+import { Crc64 } from "./crc64.js";
+import { u32BE, u64BE } from "./bytes.js";
+import { marshalHeader, validateHeader } from "./header.js";
+import { marshalPageHeader, validatePageHeader } from "./page.js";
+import { marshalTrailer, validateTrailer } from "./trailer.js";
+import { encodePageIndexRecord, encodeUvarint } from "./page-index.js";
+import { compressBlock } from "./lz4.js";
+import { LTXFormatError } from "../errors.js";
+const stateHeader = 'header';
+const statePage = 'page';
+const stateClosed = 'closed';
+/** Encoder writes an LTX file to a ByteSink. */
+export class Encoder {
+    sink;
+    state = stateHeader;
+    header;
+    trailer = { postApplyChecksum: 0n, fileChecksum: 0n };
+    hash = new Crc64();
+    index = [];
+    n = 0;
+    prevPgno = 0;
+    pagesWritten = 0;
+    constructor(sink) {
+        this.sink = sink;
+    }
+    /** Returns the number of bytes written to the sink so far. */
+    N() {
+        return this.n;
+    }
+    /** Returns a shallow copy of the header. */
+    Header() {
+        return this.header;
+    }
+    /** Returns the trailer (file checksum valid after Close()). */
+    Trailer() {
+        return this.trailer;
+    }
+    /** Returns the replication position after applying this file. */
+    PostApplyPos() {
+        return {
+            txID: this.header.maxTXID,
+            postApplyChecksum: this.trailer.postApplyChecksum,
+        };
+    }
+    /** SetPostApplyChecksum sets the database checksum to record in the trailer. */
+    setPostApplyChecksum(chk) {
+        this.trailer.postApplyChecksum = chk;
+    }
+    /** EncodeHeader writes the header frame and initializes the checksum. */
+    encodeHeader(h) {
+        if (this.state === stateClosed)
+            throw new LTXFormatError('ltx encoder closed');
+        if (this.state !== stateHeader) {
+            throw new LTXFormatError(`cannot encode header frame, expected ${this.state}`);
+        }
+        validateHeader(h);
+        this.header = h;
+        this.hash = new Crc64();
+        this.write(marshalHeader(h));
+        this.state = statePage;
+    }
+    /**
+     * EncodePage writes a single page frame. `data` must be exactly the page
+     * size and `hdr.pgno` must be in ascending order and not the lock page.
+     */
+    encodePage(hdr, data) {
+        if (this.state === stateClosed)
+            throw new LTXFormatError('ltx encoder closed');
+        if (this.state !== statePage) {
+            throw new LTXFormatError(`cannot encode page header, expected ${this.state}`);
+        }
+        if (hdr.pgno > this.header.commit) {
+            throw new LTXFormatError(`page number ${hdr.pgno} out-of-bounds for commit size ${this.header.commit}`);
+        }
+        validatePageHeader(hdr);
+        if (data.length !== this.header.pageSize) {
+            throw new LTXFormatError(`invalid page buffer size: ${data.length}, expecting ${this.header.pageSize}`);
+        }
+        const lockPg = lockPgno(this.header.pageSize);
+        if (hdr.pgno === lockPg) {
+            throw new LTXFormatError(`cannot encode lock page: pgno=${hdr.pgno}`);
+        }
+        // Enforce page ordering.
+        if (this.header.minTXID === 1n) {
+            // Snapshot files must include all pages up to commit, in order.
+            if (this.prevPgno === 0 && hdr.pgno !== 1) {
+                throw new LTXFormatError('snapshot transaction file must start with page number 1');
+            }
+            if (this.prevPgno === lockPg - 1) {
+                if (hdr.pgno !== this.prevPgno + 2) {
+                    throw new LTXFormatError(`nonsequential page numbers in snapshot transaction (skip lock page): ${this.prevPgno},${hdr.pgno}`);
+                }
+            }
+            else if (this.prevPgno !== 0 && hdr.pgno !== this.prevPgno + 1) {
+                throw new LTXFormatError(`nonsequential page numbers in snapshot transaction: ${this.prevPgno},${hdr.pgno}`);
+            }
+        }
+        else {
+            if (this.prevPgno >= hdr.pgno) {
+                throw new LTXFormatError(`out-of-order page numbers: ${this.prevPgno},${hdr.pgno}`);
+            }
+        }
+        const offset = this.n;
+        const compressed = compressBlock(data);
+        const fhdr = { pgno: hdr.pgno, flags: hdr.flags | PageHeaderFlagSize };
+        this.write(marshalPageHeader(fhdr));
+        this.write(u32BE(compressed.length));
+        this.sink.write(compressed);
+        this.hash.update(data); // hash the raw (uncompressed) page data
+        this.n += compressed.length;
+        this.pagesWritten++;
+        this.prevPgno = hdr.pgno;
+        this.index.push({ pgno: hdr.pgno, offset, size: this.n - offset });
+    }
+    /** Close writes the end-of-pages marker, page index, and trailer. */
+    close() {
+        if (this.state === stateClosed)
+            return;
+        if (this.state !== statePage) {
+            throw new LTXFormatError(`cannot close, expected ${this.state}`);
+        }
+        // Empty page header terminates the page block.
+        const zero = new Uint8Array(PageHeaderSize);
+        this.write(zero);
+        // Write the page index.
+        const start = this.n;
+        for (const e of this.index) {
+            this.write(encodePageIndexRecord(e.pgno, e.offset, e.size));
+        }
+        this.write(encodeUvarint(0n)); // end marker
+        this.write(u64BE(BigInt(this.n - start))); // size of index varint bytes
+        // Marshal trailer (post-apply checksum set, file checksum pending).
+        const t = marshalTrailer(this.trailer);
+        this.hash.update(t.subarray(0, TrailerChecksumOffset));
+        this.n += TrailerChecksumOffset;
+        this.trailer.fileChecksum = ChecksumFlag | this.hash.sum64();
+        validateTrailer(this.trailer, this.header);
+        // Remarshal with the file checksum and write to the sink (not hashed).
+        this.sink.write(marshalTrailer(this.trailer));
+        this.n += TrailerSize - TrailerChecksumOffset;
+        this.state = stateClosed;
+    }
+    /** Writes to the sink, feeding the checksum and byte counter. */
+    write(b) {
+        this.sink.write(b);
+        this.hash.update(b);
+        this.n += b.length;
+    }
+}

package/dist/ltx/file-info.d.ts

@@ -0,0 +1,24 @@
+/**
+ * LTX file metadata and iteration over a set of LTX files.
+ */
+import type { FileInfo, TXID } from './types.js';
+import { isContiguous } from './types.js';
+/** Sorts FileInfo by (level, minTXID, maxTXID), in place. */
+export declare function sortFileInfo(a: FileInfo[]): FileInfo[];
+/** MaxTXID returns the largest maxTXID in a slice, or 0n if empty. */
+export declare function maxTXID(a: readonly FileInfo[]): TXID;
+/** SliceFileIterator iterates over a sorted slice of LTX file metadata. */
+export declare class FileInfoSliceIterator {
+    private a;
+    private init;
+    private current;
+    constructor(a: FileInfo[]);
+    next(): boolean;
+    err(): Error | null;
+    item(): FileInfo | null;
+    close(): void;
+}
+/** Returns all LTX files from an iterator as an array. */
+export declare function sliceFileIterator(itr: FileInfoSliceIterator): FileInfo[];
+export { isContiguous };
+//# sourceMappingURL=file-info.d.ts.map

package/dist/ltx/file-info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-info.d.ts","sourceRoot":"","sources":["../../src/ltx/file-info.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE1C,6DAA6D;AAC7D,wBAAgB,YAAY,CAAC,CAAC,EAAE,QAAQ,EAAE,GAAG,QAAQ,EAAE,CAOtD;AAED,sEAAsE;AACtE,wBAAgB,OAAO,CAAC,CAAC,EAAE,SAAS,QAAQ,EAAE,GAAG,IAAI,CAOpD;AAED,2EAA2E;AAC3E,qBAAa,qBAAqB;IAChC,OAAO,CAAC,CAAC,CAAa;IACtB,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,OAAO,CAAyB;gBAE5B,CAAC,EAAE,QAAQ,EAAE;IAIzB,IAAI,IAAI,OAAO;IAmBf,GAAG,IAAI,KAAK,GAAG,IAAI;IAInB,IAAI,IAAI,QAAQ,GAAG,IAAI;IAIvB,KAAK,IAAI,IAAI;CAGd;AAED,0DAA0D;AAC1D,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,qBAAqB,GAAG,QAAQ,EAAE,CAQxE;AAED,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/ltx/file-info.js

@@ -0,0 +1,74 @@
+/**
+ * LTX file metadata and iteration over a set of LTX files.
+ */
+import { isContiguous } from "./types.js";
+/** Sorts FileInfo by (level, minTXID, maxTXID), in place. */
+export function sortFileInfo(a) {
+    a.sort((x, y) => {
+        if (x.level !== y.level)
+            return x.level - y.level;
+        if (x.minTXID !== y.minTXID)
+            return x.minTXID < y.minTXID ? -1 : 1;
+        return x.maxTXID < y.maxTXID ? -1 : x.maxTXID > y.maxTXID ? 1 : 0;
+    });
+    return a;
+}
+/** MaxTXID returns the largest maxTXID in a slice, or 0n if empty. */
+export function maxTXID(a) {
+    if (a.length === 0)
+        return 0n;
+    let m = a[0].maxTXID;
+    for (const info of a) {
+        if (info.maxTXID > m)
+            m = info.maxTXID;
+    }
+    return m;
+}
+/** SliceFileIterator iterates over a sorted slice of LTX file metadata. */
+export class FileInfoSliceIterator {
+    a;
+    init = false;
+    current = null;
+    constructor(a) {
+        this.a = sortFileInfo([...a]);
+    }
+    next() {
+        if (!this.init) {
+            this.init = true;
+            if (this.a.length === 0) {
+                this.current = null;
+                return false;
+            }
+            this.current = this.a[0];
+            return true;
+        }
+        this.a = this.a.slice(1);
+        if (this.a.length === 0) {
+            this.current = null;
+            return false;
+        }
+        this.current = this.a[0];
+        return true;
+    }
+    err() {
+        return null;
+    }
+    item() {
+        return this.current;
+    }
+    close() {
+        /* nothing to release */
+    }
+}
+/** Returns all LTX files from an iterator as an array. */
+export function sliceFileIterator(itr) {
+    const out = [];
+    while (itr.next()) {
+        const item = itr.item();
+        if (item)
+            out.push(item);
+    }
+    itr.close();
+    return out;
+}
+export { isContiguous };

package/dist/ltx/filename.d.ts

@@ -0,0 +1,13 @@
+/**
+ * LTX filename parsing/formatting.
+ *
+ * Names are `{minTXID:016x}-{maxTXID:016x}.ltx`.
+ */
+/** FormatFilename returns an LTX filename representing a TXID range. */
+export declare function formatFilename(minTXID: bigint, maxTXID: bigint): string;
+/** ParseFilename parses a transaction range from an LTX filename. */
+export declare function parseFilename(name: string): {
+    minTXID: bigint;
+    maxTXID: bigint;
+};
+//# sourceMappingURL=filename.d.ts.map

package/dist/ltx/filename.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filename.d.ts","sourceRoot":"","sources":["../../src/ltx/filename.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAOH,wEAAwE;AACxE,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAEvE;AAED,qEAAqE;AACrE,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAShF"}

package/dist/ltx/filename.js

@@ -0,0 +1,23 @@
+/**
+ * LTX filename parsing/formatting.
+ *
+ * Names are `{minTXID:016x}-{maxTXID:016x}.ltx`.
+ */
+import { formatTXID } from "./types.js";
+import { LTXFormatError } from "../errors.js";
+const FILENAME_RE = /^([0-9a-f]{16})-([0-9a-f]{16})\.ltx$/;
+/** FormatFilename returns an LTX filename representing a TXID range. */
+export function formatFilename(minTXID, maxTXID) {
+    return `${formatTXID(minTXID)}-${formatTXID(maxTXID)}.ltx`;
+}
+/** ParseFilename parses a transaction range from an LTX filename. */
+export function parseFilename(name) {
+    const m = FILENAME_RE.exec(name);
+    if (m === null) {
+        throw new LTXFormatError(`invalid ltx filename: ${name}`);
+    }
+    return {
+        minTXID: BigInt(`0x${m[1]}`),
+        maxTXID: BigInt(`0x${m[2]}`),
+    };
+}

package/dist/ltx/header.d.ts

@@ -0,0 +1,17 @@
+/**
+ * LTX header frame marshalling.
+ */
+import type { Header } from './types.js';
+/**
+ * MarshalBinary encodes a header to its 100-byte representation.
+ */
+export declare function marshalHeader(h: Header): Uint8Array;
+/**
+ * UnmarshalBinary decodes a header from a byte slice.
+ * Sets `version` from the magic and returns the header.
+ */
+export declare function unmarshalHeader(b: Uint8Array): Header;
+/** Validate returns an error (thrown) if h is invalid. */
+export declare function validateHeader(h: Header): void;
+export declare function headerLockPgno(h: Header): number;
+//# sourceMappingURL=header.d.ts.map

package/dist/ltx/header.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"header.d.ts","sourceRoot":"","sources":["../../src/ltx/header.ts"],"names":[],"mappings":"AAAA;;GAEG;AASH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAKzC;;GAEG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,UAAU,CAgBnD;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,UAAU,GAAG,MAAM,CAqBrD;AAMD,0DAA0D;AAC1D,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAoD9C;AAED,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAEhD"}

package/dist/ltx/header.js

@@ -0,0 +1,115 @@
+/**
+ * LTX header frame marshalling.
+ */
+import { HeaderSize, Magic, Version } from "./constants.js";
+import { ChecksumFlag, isValidHeaderFlags, isValidPageSize, } from "./constants.js";
+import { assertFull, readU32BE, readU64BE, writeU32BE, writeU64BE } from "./bytes.js";
+import { isSnapshot } from "./types.js";
+import { lockPgno } from "./constants.js";
+import { LTXFormatError } from "../errors.js";
+/**
+ * MarshalBinary encodes a header to its 100-byte representation.
+ */
+export function marshalHeader(h) {
+    const b = new Uint8Array(HeaderSize);
+    for (let i = 0; i < 4; i++)
+        b[i] = Magic.charCodeAt(i);
+    writeU32BE(b, 4, h.flags);
+    writeU32BE(b, 8, h.pageSize);
+    writeU32BE(b, 12, h.commit);
+    writeU64BE(b, 16, h.minTXID);
+    writeU64BE(b, 24, h.maxTXID);
+    writeU64BE(b, 32, h.timestamp);
+    writeU64BE(b, 40, h.preApplyChecksum);
+    writeU64BE(b, 48, h.walOffset);
+    writeU64BE(b, 56, h.walSize);
+    writeU32BE(b, 64, h.walSalt1);
+    writeU32BE(b, 68, h.walSalt2);
+    writeU64BE(b, 72, h.nodeID);
+    return b;
+}
+/**
+ * UnmarshalBinary decodes a header from a byte slice.
+ * Sets `version` from the magic and returns the header.
+ */
+export function unmarshalHeader(b) {
+    assertFull(b, 0, HeaderSize);
+    const magic = String.fromCharCode(b[0], b[1], b[2], b[3]);
+    if (magic !== Magic) {
+        throw new LTXFormatError('invalid LTX file');
+    }
+    return {
+        version: Version,
+        flags: readU32BE(b, 4),
+        pageSize: readU32BE(b, 8),
+        commit: readU32BE(b, 12),
+        minTXID: readU64BE(b, 16),
+        maxTXID: readU64BE(b, 24),
+        timestamp: readU64BE(b, 32),
+        preApplyChecksum: readU64BE(b, 40),
+        walOffset: readU64BE(b, 48),
+        walSize: readU64BE(b, 56),
+        walSalt1: readU32BE(b, 64),
+        walSalt2: readU32BE(b, 68),
+        nodeID: readU64BE(b, 72),
+    };
+}
+function noChecksum(flags) {
+    return (flags & 0x00000002) !== 0;
+}
+/** Validate returns an error (thrown) if h is invalid. */
+export function validateHeader(h) {
+    if (h.version !== Version) {
+        throw new LTXFormatError('invalid version');
+    }
+    if (!isValidHeaderFlags(h.flags)) {
+        throw new LTXFormatError(`invalid flags: 0x${h.flags.toString(16)}`);
+    }
+    if (!isValidPageSize(h.pageSize)) {
+        throw new LTXFormatError(`invalid page size: ${h.pageSize}`);
+    }
+    if (h.minTXID === 0n) {
+        throw new LTXFormatError('minimum transaction id required');
+    }
+    if (h.maxTXID === 0n) {
+        throw new LTXFormatError('maximum transaction id required');
+    }
+    if (h.minTXID > h.maxTXID) {
+        throw new LTXFormatError(`transaction ids out of order: (${h.minTXID},${h.maxTXID})`);
+    }
+    if (h.walOffset < 0n) {
+        throw new LTXFormatError(`wal offset cannot be negative: ${h.walOffset}`);
+    }
+    if (h.walSize < 0n) {
+        throw new LTXFormatError(`wal size cannot be negative: ${h.walSize}`);
+    }
+    if ((h.walSalt1 !== 0 || h.walSalt2 !== 0) && h.walOffset === 0n) {
+        throw new LTXFormatError('wal offset required if salt exists');
+    }
+    if (h.walOffset === 0n && h.walSize !== 0n) {
+        throw new LTXFormatError('wal offset required if wal size exists');
+    }
+    const snap = isSnapshot(h);
+    const nc = noChecksum(h.flags);
+    if (snap) {
+        if (h.preApplyChecksum !== 0n) {
+            throw new LTXFormatError('pre-apply checksum must be zero on snapshots');
+        }
+    }
+    else if (nc) {
+        if (h.preApplyChecksum !== 0n) {
+            throw new LTXFormatError('pre-apply checksum not allowed');
+        }
+    }
+    else {
+        if (h.preApplyChecksum === 0n) {
+            throw new LTXFormatError('pre-apply checksum required on non-snapshot files');
+        }
+        if ((h.preApplyChecksum & ChecksumFlag) === 0n) {
+            throw new LTXFormatError('invalid pre-apply checksum format');
+        }
+    }
+}
+export function headerLockPgno(h) {
+    return lockPgno(h.pageSize);
+}

package/dist/ltx/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * LTX format module — public surface for reading/writing LTX files.
+ */
+export * from './constants.js';
+export * from './types.js';
+export * from './crc64.js';
+export * from './checksum.js';
+export * from './bytes.js';
+export * from './byte-reader.js';
+export * from './filename.js';
+export * from './page-index.js';
+export * from './header.js';
+export * from './page.js';
+export * from './trailer.js';
+export * from './sink.js';
+export * from './encoder.js';
+export * from './decoder.js';
+export * from './stream.js';
+export * from './compactor.js';
+export * from './streaming-compactor.js';
+export * from './file-info.js';
+export * from './compaction-level.js';
+export { compressBlock, decompressBlock } from './lz4.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/ltx/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ltx/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC;AAChC,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,0BAA0B,CAAC;AACzC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,uBAAuB,CAAC;AAItC,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC"}

package/dist/ltx/index.js

@@ -0,0 +1,25 @@
+/**
+ * LTX format module — public surface for reading/writing LTX files.
+ */
+export * from "./constants.js";
+export * from "./types.js";
+export * from "./crc64.js";
+export * from "./checksum.js";
+export * from "./bytes.js";
+export * from "./byte-reader.js";
+export * from "./filename.js";
+export * from "./page-index.js";
+export * from "./header.js";
+export * from "./page.js";
+export * from "./trailer.js";
+export * from "./sink.js";
+export * from "./encoder.js";
+export * from "./decoder.js";
+export * from "./stream.js";
+export * from "./compactor.js";
+export * from "./streaming-compactor.js";
+export * from "./file-info.js";
+export * from "./compaction-level.js";
+// LZ4 block codec is internal (not part of the public LTX surface) but
+// exposed for the WAL/DB layers.
+export { compressBlock, decompressBlock } from "./lz4.js";

package/dist/ltx/lz4.d.ts

@@ -0,0 +1,41 @@
+/**
+ * LZ4 block-codec adapter.
+ *
+ * The LTX format uses LZ4 **block** format (not frame format), matching Go's
+ * `github.com/pierrec/lz4/v4` `CompressBlock`/`UncompressBlock`.
+ *
+ * `compressBlock` is a direct TypeScript port of `pierrec/lz4/v4`'s internal
+ * `lz4block.Compressor.CompressBlock` (the default Fast compressor used by
+ * litestream). It is **byte-identical** to Go's output for the same input, so
+ * LTX files we write match Go's `superfly/ltx` encoder exactly (validated
+ * against the Go fixtures in `test/ltx/go-interop.test.ts` and CI's
+ * `interop-go` job).
+ *
+ * `decompressBlock`/`decompressBlockInto` delegate to the pure-JS `lz4js`
+ * implementation, which decodes any conforming LZ4 block (decompression does
+ * not need to be byte-identical).
+ */
+/**
+ * compressBlockBound returns the maximum compressed size for `n` input bytes
+ * using the Fast compressor (`n + n/255 + 16`).
+ */
+export declare function compressBlockBound(n: number): number;
+/**
+ * compressBlock compresses `data` as a Fast-mode LZ4 block and returns the
+ * compressed bytes. The result is byte-identical to Go's `pierrec/lz4/v4`
+ * `CompressBlock` for the same input.
+ */
+export declare function compressBlock(data: Uint8Array): Uint8Array;
+/**
+ * decompressBlock decompresses an LZ4 block into a buffer of exactly
+ * `uncompressedSize` bytes. Throws if the block is invalid or produces a
+ * different size.
+ */
+export declare function decompressBlock(data: Uint8Array, uncompressedSize: number): Uint8Array;
+/**
+ * decompressBlockInto decompresses an LZ4 block into `dst` and returns the
+ * number of bytes written. Does not require knowing the uncompressed size
+ * ahead of time.
+ */
+export declare function decompressBlockInto(data: Uint8Array, dst: Uint8Array): number;
+//# sourceMappingURL=lz4.d.ts.map

package/dist/ltx/lz4.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lz4.d.ts","sourceRoot":"","sources":["../../src/ltx/lz4.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAqBH;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAEpD;AA2MD;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAI1D;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,GAAG,UAAU,CAOtF;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,EAAE,UAAU,GAAG,MAAM,CAE7E"}