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

package/src/ltx/header.ts

@@ -0,0 +1,126 @@
+/**
+ * LTX header frame marshalling.
+ */
+
+import { HeaderSize, Magic, Version } from './constants.ts';
+import {
+  ChecksumFlag,
+  isValidHeaderFlags,
+  isValidPageSize,
+} from './constants.ts';
+import { assertFull, readU32BE, readU64BE, writeU32BE, writeU64BE } from './bytes.ts';
+import type { Header } from './types.ts';
+import { isSnapshot } from './types.ts';
+import { lockPgno } from './constants.ts';
+import { LTXFormatError } from '../errors.ts';
+
+/**
+ * MarshalBinary encodes a header to its 100-byte representation.
+ */
+export function marshalHeader(h: Header): Uint8Array {
+  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: Uint8Array): Header {
+  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: number): boolean {
+  return (flags & 0x00000002) !== 0;
+}
+
+/** Validate returns an error (thrown) if h is invalid. */
+export function validateHeader(h: Header): void {
+  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: Header): number {
+  return lockPgno(h.pageSize);
+}

package/src/ltx/index.ts

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

package/src/ltx/lz4.ts

@@ -0,0 +1,279 @@
+/**
+ * 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).
+ */
+
+import lz4 from 'lz4js';
+import { LTXFormatError } from '../errors.ts';
+
+// Compressor constants, mirrored from `internal/lz4block/block.go`.
+const HASH_LOG = 16;
+const HT_SIZE = 1 << HASH_LOG; // 65536 hash-table entries.
+const WIN_SIZE = 1 << 16; // 64 KiB window.
+const WIN_MASK = WIN_SIZE - 1;
+const MIN_MATCH = 4;
+const MF_LIMIT = 10 + MIN_MATCH; // Last match cannot start within the last 14 bytes.
+const ADAPT_SKIP_LOG = 7;
+const PRIME6 = 227718039650203n;
+const U64_MASK = 0xffffffffffffffffn;
+const U32_MASK = 0xffffffffn;
+
+// Hash table state. `inUse` is a bitmap so we can clear the table cheaply.
+const hashTable = new Uint16Array(HT_SIZE);
+const inUse = new Uint32Array(HT_SIZE / 32);
+
+/**
+ * compressBlockBound returns the maximum compressed size for `n` input bytes
+ * using the Fast compressor (`n + n/255 + 16`).
+ */
+export function compressBlockBound(n: number): number {
+  return n + ((n / 255) | 0) + 16;
+}
+
+/** Hashes the lower 6 bytes of a 64-bit little-endian value into a hash index. */
+function blockHash(x: bigint): number {
+  return Number((((x << 16n) * PRIME6) & U64_MASK) >> 48n);
+}
+
+/** Reads the 64-bit little-endian value at `o` (used by the Fast scan). */
+function readU64(b: Uint8Array, o: number): bigint {
+  let x = 0n;
+  for (let i = 7; i >= 0; i--) x = (x << 8n) | BigInt(b[o + i]);
+  return x;
+}
+
+/** Reads the 32-bit little-endian value at `o`. */
+function readU32(b: Uint8Array, o: number): number {
+  return (b[o] | (b[o + 1] << 8) | (b[o + 2] << 16) | (b[o + 3] << 24)) >>> 0;
+}
+
+/** Returns the number of leading zero bytes in a 64-bit little-endian value. */
+function trailingZeroBytes(x: bigint): number {
+  let n = 0;
+  while ((x & 0xffn) === 0n && n < 8) {
+    x >>= 8n;
+    n++;
+  }
+  return n;
+}
+
+/**
+ * Look up the two 16-bit halves of a stored match offset for a hash. Mirrors
+ * `Compressor.get`: the table stores 16-bit offsets relative to a 64 KiB block
+ * boundary. Returns a position that may be before the start of the window (in
+ * which case `offset >= WIN_SIZE` short-circuits the candidate check).
+ */
+function tableGet(h: number, si: number): number {
+  h &= HT_SIZE - 1;
+  let i = 0;
+  if (inUse[h >>> 5] & (1 << (h & 31))) i = hashTable[h];
+  i += si & ~WIN_MASK;
+  if (i >= si) i -= WIN_SIZE;
+  return i;
+}
+
+function tablePut(h: number, si: number): void {
+  h &= HT_SIZE - 1;
+  hashTable[h] = si & 0xffff;
+  inUse[h >>> 5] |= 1 << (h & 31);
+}
+
+/**
+ * Compresses `src` into `dst` as a Fast-mode LZ4 block, writing at offset 0.
+ * Mirrors `lz4block.Compressor.CompressBlock`. Returns the number of bytes
+ * written, or 0 if `dst` is too small (which happens only when the caller does
+ * not size `dst` with `compressBlockBound`).
+ */
+function compressBlockInto(src: Uint8Array, dst: Uint8Array): number {
+  // Clear the reused table so output is deterministic (issue #65).
+  inUse.fill(0);
+
+  // In normal use `dst` is sized by `compressBlockBound`, so the compressor
+  // always emits a valid block (even for incompressible input). An undersized
+  // `dst` is caught by the `di >= dst.length` guards below and returns 0.
+
+  let si = 0;
+  let di = 0;
+  let anchor = 0;
+  const sn = src.length - MF_LIMIT;
+
+  if (sn > 0) {
+    for (; si < sn;) {
+      const match = readU64(src, si);
+      let h = blockHash(match);
+      const h2 = blockHash(match >> 8n);
+      const ref = tableGet(h, si);
+      const ref2 = tableGet(h2, si + 1);
+      tablePut(h, si);
+      tablePut(h2, si + 1);
+
+      let offset = si - ref;
+
+      if (offset <= 0 || offset >= WIN_SIZE || (match & U32_MASK) !== BigInt(readU32(src, ref))) {
+        h = blockHash(match >> 16n);
+        const ref3 = tableGet(h, si + 2);
+        si += 1;
+        offset = si - ref2;
+        if (offset <= 0 || offset >= WIN_SIZE || ((match >> 8n) & U32_MASK) !== BigInt(readU32(src, ref2))) {
+          si += 1;
+          offset = si - ref3;
+          tablePut(h, si);
+          if (offset <= 0 || offset >= WIN_SIZE || ((match >> 16n) & U32_MASK) !== BigInt(readU32(src, ref3))) {
+            si += 2 + ((si - anchor) >>> ADAPT_SKIP_LOG);
+            continue;
+          }
+        }
+      }
+
+      // Match found.
+      let lLen = si - anchor;
+      let mLen = 4;
+
+      // Extend backwards, reducing literals.
+      let tOff = si - offset - 1;
+      while (lLen > 0 && tOff >= 0 && src[si - 1] === src[tOff]) {
+        si--;
+        tOff--;
+        lLen--;
+        mLen++;
+      }
+
+      // Continue search at the end of the match. `matchBase` is the position
+      // just past the first 4 matched bytes.
+      const matchBase = si + MIN_MATCH;
+      si = si + mLen;
+
+      // Find the longest match by comparing 8 bytes at a time.
+      while (si + 8 <= sn) {
+        const x = readU64(src, si) ^ readU64(src, si - offset);
+        if (x === 0n) {
+          si += 8;
+        } else {
+          si += trailingZeroBytes(x);
+          break;
+        }
+      }
+
+      mLen = si - matchBase;
+
+      if (di >= dst.length) return 0;
+      if (mLen < 0xf) dst[di] = mLen;
+      else dst[di] = 0xf;
+
+      // Encode literal length.
+      if (lLen < 0xf) {
+        dst[di] |= lLen << 4;
+      } else {
+        dst[di] |= 0xf0;
+        di++;
+        let l = lLen - 0xf;
+        while (l >= 0xff && di < dst.length) {
+          dst[di] = 0xff;
+          di++;
+          l -= 0xff;
+        }
+        if (di >= dst.length) return 0;
+        dst[di] = l;
+      }
+      di++;
+
+      if (di + lLen > dst.length) return 0;
+      dst.set(src.subarray(anchor, anchor + lLen), di);
+      di += lLen + 2;
+      anchor = si;
+
+      if (di > dst.length) return 0;
+      dst[di - 2] = offset & 0xff;
+      dst[di - 1] = (offset >> 8) & 0xff;
+
+      // Encode match length part 2.
+      if (mLen >= 0xf) {
+        let m = mLen - 0xf;
+        while (m >= 0xff && di < dst.length) {
+          dst[di] = 0xff;
+          di++;
+          m -= 0xff;
+        }
+        if (di >= dst.length) return 0;
+        dst[di] = m;
+        di++;
+      }
+      if (si >= sn) break;
+
+      // Hash match end-2.
+      h = blockHash(readU64(src, si - 2));
+      tablePut(h, si - 2);
+    }
+  }
+
+  // Last literals.
+  if (di >= dst.length) return 0;
+  const lLen = src.length - anchor;
+  if (lLen < 0xf) {
+    dst[di] = lLen << 4;
+  } else {
+    dst[di] = 0xf0;
+    di++;
+    let l = lLen - 0xf;
+    while (l >= 0xff && di < dst.length) {
+      dst[di] = 0xff;
+      di++;
+      l -= 0xff;
+    }
+    if (di >= dst.length) return 0;
+    dst[di] = l;
+  }
+  di++;
+
+  if (di + (src.length - anchor) > dst.length) return 0;
+  dst.set(src.subarray(anchor), di);
+  di += src.length - anchor;
+  return di;
+}
+
+/**
+ * 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 function compressBlock(data: Uint8Array): Uint8Array {
+  const dst = new Uint8Array(compressBlockBound(data.length));
+  const n = compressBlockInto(data, dst);
+  return dst.slice(0, n);
+}
+
+/**
+ * decompressBlock decompresses an LZ4 block into a buffer of exactly
+ * `uncompressedSize` bytes. Throws if the block is invalid or produces a
+ * different size.
+ */
+export function decompressBlock(data: Uint8Array, uncompressedSize: number): Uint8Array {
+  const dst = new Uint8Array(uncompressedSize);
+  const n = lz4.decompressBlock(data, dst, 0, data.length, 0);
+  if (n !== uncompressedSize) {
+    throw new LTXFormatError(`lz4 block decompressed to ${n} bytes, expected ${uncompressedSize}`);
+  }
+  return dst;
+}
+
+/**
+ * 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 function decompressBlockInto(data: Uint8Array, dst: Uint8Array): number {
+  return lz4.decompressBlock(data, dst, 0, data.length, 0);
+}

package/src/ltx/page-index.ts

@@ -0,0 +1,140 @@
+/**
+ * LTX page index encoding/decoding.
+ *
+ * The page index is a sequence of varint triples `(pgno, offset, size)` in
+ * ascending page order, terminated by a zero varint, followed by an 8-byte
+ * big-endian size of the varint bytes (excluding the size field itself).
+ */
+
+import { readU64BE } from './bytes.ts';
+import type { ByteReader } from './byte-reader.ts';
+import type { PageIndex, TXID } from './types.ts';
+import { LTXFormatError } from '../errors.ts';
+
+const MAX_INT64 = 0x7fffffffffffffffn;
+
+/** Encodes a u64 as a little-endian LEB128 varint (same as Go's uvarint). */
+export function encodeUvarint(v: bigint): Uint8Array {
+  const out: number[] = [];
+  for (;;) {
+    const b = Number(v & 0x7fn);
+    v >>= 7n;
+    if (v !== 0n) {
+      out.push(b | 0x80);
+    } else {
+      out.push(b);
+      break;
+    }
+  }
+  return Uint8Array.from(out);
+}
+
+/** Decodes a u64 varint from r, advancing its position. */
+export function readUvarint(r: ByteReader): bigint {
+  let x = 0n;
+  let s = 0n;
+  for (let i = 0; i < 10; i++) {
+    const b = r.readByte();
+    if (b < 0x80) {
+      if (i === 9 && b > 1) {
+        throw new LTXFormatError('uvarint overflows 64 bits');
+      }
+      return x | (BigInt(b) << s);
+    }
+    x |= BigInt(b & 0x7f) << s;
+    s += 7n;
+  }
+  throw new LTXFormatError('uvarint overflows 64 bits');
+}
+
+/**
+ * Parses the page index section from r. observe, if non-null, receives every
+ * byte consumed (for checksumming); fn receives each record in file order.
+ */
+export function parsePageIndex(
+  r: ByteReader,
+  observe: ((buf: Uint8Array) => void) | null,
+  fn: (pgno: number, offset: number, size: number) => void,
+): void {
+  let consumed = 0;
+  let prevPgno = 0;
+
+  for (;;) {
+    const start = r.pos;
+    const pgno = readUvarint(r);
+    if (pgno === 0n) {
+      // End marker.
+      observe?.(r.slice(start, r.pos));
+      consumed += r.pos - start;
+      break;
+    }
+    if (pgno > 0xffffffffn) {
+      throw new LTXFormatError(`page index pgno ${pgno} out of range`);
+    }
+    if (pgno <= BigInt(prevPgno)) {
+      throw new LTXFormatError(`page index out of order: ${pgno} after ${prevPgno}`);
+    }
+    const offset = readUvarint(r);
+    const size = readUvarint(r);
+    if (offset > MAX_INT64 || size > MAX_INT64) {
+      throw new LTXFormatError(`page index pgno ${pgno} offset/size out of range`);
+    }
+    observe?.(r.slice(start, r.pos));
+    consumed += r.pos - start;
+    prevPgno = Number(pgno);
+    fn(Number(pgno), Number(offset), Number(size));
+  }
+
+  // Read trailing size field.
+  const sizeBuf = r.readFull(8);
+  observe?.(sizeBuf);
+  const indexSize = readU64BE(sizeBuf, 0);
+  if (indexSize !== BigInt(consumed)) {
+    throw new LTXFormatError(`page index size mismatch: field=${indexSize} read=${consumed}`);
+  }
+}
+
+/**
+ * DecodePageIndex decodes the page index from r, starting at the current
+ * position, into a Map keyed by page number.
+ */
+export function decodePageIndex(
+  r: ByteReader,
+  level: number,
+  minTXID: TXID,
+  maxTXID: TXID,
+): PageIndex {
+  const index: PageIndex = new Map();
+  parsePageIndex(
+    r,
+    null,
+    (pgno, offset, size) => {
+      index.set(pgno, {
+        level,
+        minTXID,
+        maxTXID,
+        offset,
+        size,
+      });
+    },
+  );
+  return index;
+}
+
+/** Encodes a single page index record `(pgno, offset, size)` as a varint buffer. */
+export function encodePageIndexRecord(pgno: number, offset: number, size: number): Uint8Array {
+  const parts = [
+    encodeUvarint(BigInt(pgno)),
+    encodeUvarint(BigInt(offset)),
+    encodeUvarint(BigInt(size)),
+  ];
+  let total = 0;
+  for (const p of parts) total += p.length;
+  const out = new Uint8Array(total);
+  let o = 0;
+  for (const p of parts) {
+    out.set(p, o);
+    o += p.length;
+  }
+  return out;
+}

package/src/ltx/page.ts

@@ -0,0 +1,80 @@
+/**
+ * LTX page header marshalling.
+ */
+
+import { PageHeaderSize, PageHeaderFlagSize, MaxPageSize } from './constants.ts';
+import { assertFull, readU16BE, readU32BE, writeU16BE, writeU32BE } from './bytes.ts';
+import { decompressBlockInto } from './lz4.ts';
+import type { PageHeader } from './types.ts';
+import { LTXFormatError } from '../errors.ts';
+
+/** MarshalBinary encodes a PageHeader to its 6-byte representation. */
+export function marshalPageHeader(h: PageHeader): Uint8Array {
+  const b = new Uint8Array(PageHeaderSize);
+  writeU32BE(b, 0, h.pgno);
+  writeU16BE(b, 4, h.flags);
+  return b;
+}
+
+/** UnmarshalBinary decodes a PageHeader from a byte slice. */
+export function unmarshalPageHeader(b: Uint8Array): PageHeader {
+  assertFull(b, 0, PageHeaderSize);
+  return {
+    pgno: readU32BE(b, 0),
+    flags: readU16BE(b, 4),
+  };
+}
+
+/** Validate returns an error (thrown) if h is invalid. */
+export function validatePageHeader(h: PageHeader): void {
+  if (h.pgno === 0) {
+    throw new LTXFormatError('page number required');
+  }
+  if ((h.flags & ~PageHeaderFlagSize) !== 0) {
+    throw new LTXFormatError(`invalid page header flags: 0x${h.flags.toString(16)}`);
+  }
+}
+
+/** The decoded result of a single LTX page frame. */
+export interface DecodedPage {
+  header: PageHeader;
+  data: Uint8Array;
+}
+
+/**
+ * DecodePageData decodes a single page frame from `b` (which must start at a
+ * page header). Matches Go's `ltx.DecodePageData`. For an empty (zero) page
+ * header, `data` is an empty buffer.
+ *
+ * Note: the uncompressed byte length is unknown here; LTX pages are at most
+ * `MaxPageSize`, so we decompress into a 64KiB buffer and slice to the bytes
+ * written. Callers that know the page size should use `DecodePage` in the
+ * decoder for the size-accurate path.
+ */
+export function decodePageData(b: Uint8Array): DecodedPage {
+  const header = unmarshalPageHeader(b);
+  if (header.pgno === 0 && header.flags === 0) {
+    return { header, data: new Uint8Array(0) };
+  }
+  validatePageHeader(header);
+
+  if ((header.flags & PageHeaderFlagSize) !== 0) {
+    if (b.length < PageHeaderSize + 4) {
+      throw new LTXFormatError('buffer too small for size prefix');
+    }
+    const dataSize = readU32BE(b, PageHeaderSize);
+    const offset = PageHeaderSize + 4;
+    if (b.length < offset + dataSize) {
+      throw new LTXFormatError(`buffer too small for data: need ${offset + dataSize}, have ${b.length}`);
+    }
+    const compressed = b.subarray(offset, offset + dataSize);
+    const buf = new Uint8Array(MaxPageSize);
+    const n = decompressBlockInto(compressed, buf);
+    if (n <= 0) {
+      throw new LTXFormatError('decompress block failed');
+    }
+    return { header, data: buf.subarray(0, n) };
+  }
+
+  throw new LTXFormatError('legacy LZ4 frame format not supported');
+}

package/src/ltx/sink.ts

@@ -0,0 +1,33 @@
+/**
+ * Output sink abstraction for the LTX encoder and other writers.
+ * A sink must accept ordered byte chunks; the encoder counts total bytes via
+ * its own `n` counter so sinks do not need to be seekable.
+ */
+export interface ByteSink {
+  write(bytes: Uint8Array): void;
+}
+
+/** In-memory sink that accumulates bytes into a single growable buffer. */
+export class BufferSink implements ByteSink {
+  private chunks: Uint8Array[] = [];
+  private _length = 0;
+
+  write(bytes: Uint8Array): void {
+    this.chunks.push(Uint8Array.from(bytes));
+    this._length += bytes.length;
+  }
+
+  get length(): number {
+    return this._length;
+  }
+
+  toBuffer(): Uint8Array {
+    const out = new Uint8Array(this._length);
+    let o = 0;
+    for (const c of this.chunks) {
+      out.set(c, o);
+      o += c.length;
+    }
+    return out;
+  }
+}