Init indexed file

lib/idx/protocol.ts

@@ -0,0 +1,106 @@
+// src/index-file/protocol.ts
+import {
+  INDEX_MAGIC,
+  INDEX_VERSION,
+  INDEX_HEADER_SIZE,
+  INDEX_ENTRY_SIZE,
+  FLAG_VALID,
+} from './constants.js';
+import type { IndexHeader, IndexEntry } from './types.js';
+
+const CRC_TABLE = new Uint32Array(256);
+for (let i = 0; i < 256; i++) {
+  let c = i;
+  for (let j = 0; j < 8; j++) {
+    c = (c & 1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1);
+  }
+  CRC_TABLE[i] = c >>> 0;
+}
+
+export function crc32(buf: Buffer, start = 0, end?: number): number {
+  let crc = 0xFFFFFFFF;
+  const len = end ?? buf.length;
+  for (let i = start; i < len; i++) {
+    crc = CRC_TABLE[(crc ^ buf[i]) & 0xFF] ^ (crc >>> 8);
+  }
+  return (~crc) >>> 0;
+}
+
+export class IndexProtocol {
+  static createHeader(entryCount: number, magic = INDEX_MAGIC): Buffer {
+    const buf = Buffer.alloc(INDEX_HEADER_SIZE);
+    buf.write(magic, 0, 4, 'ascii');
+    buf.writeUInt32LE(INDEX_VERSION, 4);
+    buf.writeBigUInt64LE(BigInt(Date.now()) * 1000000n, 8);
+    buf.writeUInt32LE(INDEX_ENTRY_SIZE, 16);
+    buf.writeUInt32LE(entryCount, 20);
+    buf.writeUInt32LE(0, 24);
+    buf.writeBigUInt64LE(0n, 28);
+    buf.writeUInt32LE(0, 36);
+    return buf;
+  }
+
+  static readHeader(buf: Buffer): IndexHeader {
+    return {
+      magic: buf.toString('ascii', 0, 4),
+      version: buf.readUInt32LE(4),
+      createdAt: buf.readBigUInt64LE(8),
+      entrySize: buf.readUInt32LE(16),
+      entryCount: buf.readUInt32LE(20),
+      validCount: buf.readUInt32LE(24),
+      dataFileSize: buf.readBigUInt64LE(28),
+      lastSequence: buf.readUInt32LE(36),
+      reserved: buf.subarray(40, 64),
+    };
+  }
+
+  static updateHeaderCounts(
+    buf: Buffer,
+    validCount: number,
+    dataFileSize: bigint,
+    lastSequence: number
+  ): void {
+    buf.writeUInt32LE(validCount, 24);
+    buf.writeBigUInt64LE(dataFileSize, 28);
+    buf.writeUInt32LE(lastSequence, 36);
+  }
+
+  static writeEntry(buf: Buffer, index: number, entry: Omit<IndexEntry, 'checksum'>): void {
+    const off = INDEX_HEADER_SIZE + index * INDEX_ENTRY_SIZE;
+
+    buf.writeUInt32LE(entry.sequence, off);
+    buf.writeBigUInt64LE(entry.timestamp, off + 4);
+    buf.writeBigUInt64LE(entry.offset, off + 12);
+    buf.writeUInt32LE(entry.length, off + 20);
+    buf.writeUInt32LE(entry.flags | FLAG_VALID, off + 24);
+
+    const checksum = crc32(buf, off, off + 28);
+    buf.writeUInt32LE(checksum, off + 28);
+  }
+
+  static readEntry(buf: Buffer, index: number): IndexEntry | null {
+    const off = INDEX_HEADER_SIZE + index * INDEX_ENTRY_SIZE;
+    const flags = buf.readUInt32LE(off + 24);
+
+    if (!(flags & FLAG_VALID)) return null;
+
+    return {
+      sequence: buf.readUInt32LE(off),
+      timestamp: buf.readBigUInt64LE(off + 4),
+      offset: buf.readBigUInt64LE(off + 12),
+      length: buf.readUInt32LE(off + 20),
+      flags,
+      checksum: buf.readUInt32LE(off + 28),
+    };
+  }
+
+  static isValidEntry(buf: Buffer, index: number): boolean {
+    const off = INDEX_HEADER_SIZE + index * INDEX_ENTRY_SIZE;
+    const flags = buf.readUInt32LE(off + 24);
+    return (flags & FLAG_VALID) !== 0;
+  }
+
+  static calcFileSize(entryCount: number): number {
+    return INDEX_HEADER_SIZE + INDEX_ENTRY_SIZE * entryCount;
+  }
+}