@kyneta/leveldb-store 1.3.1 → 1.5.0

package/dist/index.d.ts

@@ -0,0 +1,36 @@
+import { DocId, Store, StoreMeta, StoreRecord } from "@kyneta/exchange";
+
+//#region src/index.d.ts
+declare function encodeStoreRecord(record: StoreRecord): Uint8Array;
+declare function decodeStoreRecord(bytes: Uint8Array): StoreRecord;
+declare class LevelDBStore implements Store {
+  #private;
+  constructor(dbPath: string);
+  currentMeta(docId: DocId): Promise<StoreMeta | null>;
+  append(docId: DocId, record: StoreRecord): Promise<void>;
+  loadAll(docId: DocId): AsyncIterable<StoreRecord>;
+  replace(docId: DocId, records: StoreRecord[]): Promise<void>;
+  delete(docId: DocId): Promise<void>;
+  listDocIds(prefix?: string): AsyncIterable<DocId>;
+  close(): Promise<void>;
+}
+/**
+ * Create a LevelDB storage backend for server-side persistence.
+ *
+ * Returns a `Store` — pass directly to `Exchange({ stores: [...] })`.
+ *
+ * @param dbPath - Directory path where LevelDB stores its files
+ *
+ * @example
+ * ```typescript
+ * import { createLevelDBStore } from "@kyneta/leveldb-store"
+ *
+ * const exchange = new Exchange({
+ *   stores: [createLevelDBStore("./data/exchange-db")],
+ * })
+ * ```
+ */
+declare function createLevelDBStore(dbPath: string): Store;
+//#endregion
+export { LevelDBStore, createLevelDBStore, decodeStoreRecord, encodeStoreRecord };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/index.ts"],"mappings":";;;iBAuDgB,iBAAA,CAAkB,MAAA,EAAQ,WAAA,GAAc,UAAA;AAAA,iBAmCxC,iBAAA,CAAkB,KAAA,EAAO,UAAA,GAAa,WAAA;AAAA,cAsEzC,YAAA,YAAwB,KAAA;EAAA;cAIvB,MAAA;EAUN,WAAA,CAAY,KAAA,EAAO,KAAA,GAAQ,OAAA,CAAQ,SAAA;EAUnC,MAAA,CAAO,KAAA,EAAO,KAAA,EAAO,MAAA,EAAQ,WAAA,GAAc,OAAA;EA0B1C,OAAA,CAAQ,KAAA,EAAO,KAAA,GAAQ,aAAA,CAAc,WAAA;EAUtC,OAAA,CAAQ,KAAA,EAAO,KAAA,EAAO,OAAA,EAAS,WAAA,KAAgB,OAAA;EA2C/C,MAAA,CAAO,KAAA,EAAO,KAAA,GAAQ,OAAA;EAoBrB,UAAA,CAAW,MAAA,YAAkB,aAAA,CAAc,KAAA;EAW5C,KAAA,CAAA,GAAS,OAAA;AAAA;;;;;;;;AAtIjB;;;;;;;;;iBA+JgB,kBAAA,CAAmB,MAAA,WAAiB,KAAA"}

package/dist/index.js

@@ -0,0 +1,188 @@
+import { SeqNoTracker, resolveMetaFromBatch, validateAppend } from "@kyneta/exchange";
+import { ClassicLevel } from "classic-level";
+//#region src/index.ts
+const SEP = "\0";
+const META_PREFIX = `meta${SEP}`;
+const RECORD_PREFIX = `record${SEP}`;
+const SEQ_PAD = 16;
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+function encodeStoreRecord(record) {
+	if (record.kind === "meta") {
+		const metaBytes = encoder.encode(JSON.stringify(record.meta));
+		const buf = new Uint8Array(1 + metaBytes.length);
+		buf[0] = 8;
+		buf.set(metaBytes, 1);
+		return buf;
+	}
+	const { payload, version } = record;
+	let flags = 0;
+	if (payload.kind === "since") flags |= 1;
+	if (payload.encoding === "binary") flags |= 2;
+	const isDataBinary = payload.data instanceof Uint8Array;
+	if (isDataBinary) flags |= 4;
+	const versionBytes = encoder.encode(version);
+	const dataBytes = isDataBinary ? payload.data : encoder.encode(payload.data);
+	const buf = new Uint8Array(5 + versionBytes.length + dataBytes.length);
+	const view = new DataView(buf.buffer);
+	buf[0] = flags;
+	view.setUint32(1, versionBytes.length, false);
+	buf.set(versionBytes, 5);
+	buf.set(dataBytes, 5 + versionBytes.length);
+	return buf;
+}
+function decodeStoreRecord(bytes) {
+	const flagByte = bytes[0];
+	if (flagByte === void 0) throw new Error("empty store record bytes");
+	const flags = flagByte;
+	if ((flags & 128) !== 0) throw new Error("unknown store record format (future-format bit set)");
+	if ((flags & 8) !== 0) {
+		const metaJson = decoder.decode(bytes.subarray(1));
+		return {
+			kind: "meta",
+			meta: JSON.parse(metaJson)
+		};
+	}
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	const kind = (flags & 1) !== 0 ? "since" : "entirety";
+	const encoding = (flags & 2) !== 0 ? "binary" : "json";
+	const isDataBinary = (flags & 4) !== 0;
+	const versionLen = view.getUint32(1, false);
+	const version = decoder.decode(bytes.subarray(5, 5 + versionLen));
+	const dataStart = 5 + versionLen;
+	const rawData = bytes.subarray(dataStart);
+	return {
+		kind: "entry",
+		payload: {
+			kind,
+			encoding,
+			data: isDataBinary ? new Uint8Array(rawData) : decoder.decode(rawData)
+		},
+		version
+	};
+}
+function metaKey(docId) {
+	return `${META_PREFIX}${docId}`;
+}
+function recordPrefix(docId) {
+	return `${RECORD_PREFIX}${docId}${SEP}`;
+}
+function recordKey(docId, seqNo) {
+	return `${recordPrefix(docId)}${String(seqNo).padStart(SEQ_PAD, "0")}`;
+}
+function parseDocIdFromMetaKey(key) {
+	return key.slice(META_PREFIX.length);
+}
+function parseSeqNoFromRecordKey(key, docId) {
+	const prefix = recordPrefix(docId);
+	return Number.parseInt(key.slice(prefix.length), 10);
+}
+var LevelDBStore = class {
+	#db;
+	#seqNos = new SeqNoTracker();
+	constructor(dbPath) {
+		this.#db = new ClassicLevel(dbPath, { valueEncoding: "binary" });
+	}
+	async currentMeta(docId) {
+		try {
+			const raw = await this.#db.get(metaKey(docId));
+			return JSON.parse(decoder.decode(raw));
+		} catch (error) {
+			if (error.code === "LEVEL_NOT_FOUND") return null;
+			throw error;
+		}
+	}
+	async append(docId, record) {
+		const resolved = validateAppend(docId, record, await this.currentMeta(docId));
+		if (resolved !== null) await this.#db.put(metaKey(docId), encoder.encode(JSON.stringify(resolved)));
+		const seq = await this.#seqNos.next(docId, async () => {
+			const prefix = recordPrefix(docId);
+			for await (const key of this.#db.keys({
+				gte: prefix,
+				lt: `${prefix}\xff`,
+				reverse: true,
+				limit: 1
+			})) return parseSeqNoFromRecordKey(key, docId);
+			return null;
+		});
+		await this.#db.put(recordKey(docId, seq), encodeStoreRecord(record));
+	}
+	async *loadAll(docId) {
+		const prefix = recordPrefix(docId);
+		for await (const value of this.#db.values({
+			gte: prefix,
+			lt: `${prefix}\xff`
+		})) yield decodeStoreRecord(value);
+	}
+	async replace(docId, records) {
+		const resolved = resolveMetaFromBatch(records, await this.currentMeta(docId));
+		const prefix = recordPrefix(docId);
+		const keysToDelete = [];
+		for await (const key of this.#db.keys({
+			gte: prefix,
+			lt: `${prefix}\xff`
+		})) keysToDelete.push(key);
+		const ops = keysToDelete.map((key) => ({
+			type: "del",
+			key
+		}));
+		for (let i = 0; i < records.length; i++) ops.push({
+			type: "put",
+			key: recordKey(docId, i),
+			value: encodeStoreRecord(records[i])
+		});
+		ops.push({
+			type: "put",
+			key: metaKey(docId),
+			value: encoder.encode(JSON.stringify(resolved))
+		});
+		await this.#db.batch(ops);
+		this.#seqNos.reset(docId, records.length - 1);
+	}
+	async delete(docId) {
+		const prefix = recordPrefix(docId);
+		const keysToDelete = [metaKey(docId)];
+		for await (const key of this.#db.keys({
+			gte: prefix,
+			lt: `${prefix}\xff`
+		})) keysToDelete.push(key);
+		await this.#db.batch(keysToDelete.map((key) => ({
+			type: "del",
+			key
+		})));
+		this.#seqNos.remove(docId);
+	}
+	async *listDocIds(prefix) {
+		const rangePrefix = prefix !== void 0 ? `${META_PREFIX}${prefix}` : META_PREFIX;
+		for await (const key of this.#db.keys({
+			gte: rangePrefix,
+			lt: `${rangePrefix}\xff`
+		})) yield parseDocIdFromMetaKey(key);
+	}
+	async close() {
+		await this.#db.close();
+	}
+};
+/**
+* Create a LevelDB storage backend for server-side persistence.
+*
+* Returns a `Store` — pass directly to `Exchange({ stores: [...] })`.
+*
+* @param dbPath - Directory path where LevelDB stores its files
+*
+* @example
+* ```typescript
+* import { createLevelDBStore } from "@kyneta/leveldb-store"
+*
+* const exchange = new Exchange({
+*   stores: [createLevelDBStore("./data/exchange-db")],
+* })
+* ```
+*/
+function createLevelDBStore(dbPath) {
+	return new LevelDBStore(dbPath);
+}
+//#endregion
+export { LevelDBStore, createLevelDBStore, decodeStoreRecord, encodeStoreRecord };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["#db","#seqNos"],"sources":["../src/index.ts"],"sourcesContent":["// server — LevelDB storage backend for @kyneta/exchange.\n//\n// Implements the Store interface using classic-level.\n//\n// Key-space design (FoundationDB convention — \\x00 null-byte separator):\n//   meta\\x00{docId}                       → JSON-encoded StoreMeta (materialized index)\n//   record\\x00{docId}\\x00{seqNo}          → binary-encoded StoreRecord (unified stream)\n//\n// The \\x00 separator cannot appear in valid UTF-8 strings, so no docId\n// validation is needed — the key-space imposes zero constraints on callers.\n//\n// SeqNo is a zero-padded 16-digit monotonic counter per doc, tracked in\n// memory. On reboot, the max seqNo for a doc is lazily discovered via a\n// single reverse-iterator seek on first append.\n\nimport {\n  type DocId,\n  resolveMetaFromBatch,\n  SeqNoTracker,\n  type Store,\n  type StoreMeta,\n  type StoreRecord,\n  validateAppend,\n} from \"@kyneta/exchange\"\nimport { ClassicLevel } from \"classic-level\"\n\n// ---------------------------------------------------------------------------\n// Constants\n// ---------------------------------------------------------------------------\n\nconst SEP = \"\\x00\"\nconst META_PREFIX = `meta${SEP}`\nconst RECORD_PREFIX = `record${SEP}`\nconst SEQ_PAD = 16\n\n// ---------------------------------------------------------------------------\n// Binary envelope v2 — pure encode/decode for StoreRecord\n// ---------------------------------------------------------------------------\n\n// Flags byte layout:\n//   bit 0: payload kind     (0 = entirety, 1 = since) — entry records only\n//   bit 1: encoding         (0 = json, 1 = binary) — entry records only\n//   bit 2: data type        (0 = string, 1 = Uint8Array) — entry records only\n//   bit 3: record kind      (0 = entry, 1 = meta)\n//   bit 7: future-format    (0 = current format, reserved)\n//\n// Meta records (bit 3 = 1):\n//   [1 byte flags] [remaining: JSON-encoded StoreMeta]\n//\n// Entry records (bit 3 = 0):\n//   [1 byte flags] [4 bytes version length BE] [N bytes version UTF-8] [remaining: payload data]\n\nconst encoder = new TextEncoder()\nconst decoder = new TextDecoder()\n\nexport function encodeStoreRecord(record: StoreRecord): Uint8Array {\n  if (record.kind === \"meta\") {\n    const metaBytes = encoder.encode(JSON.stringify(record.meta))\n    const buf = new Uint8Array(1 + metaBytes.length)\n    buf[0] = 0x08 // bit 3 set (meta)\n    buf.set(metaBytes, 1)\n    return buf\n  }\n\n  // Entry record\n  const { payload, version } = record\n\n  let flags = 0\n  if (payload.kind === \"since\") flags |= 0x01\n  if (payload.encoding === \"binary\") flags |= 0x02\n\n  const isDataBinary = payload.data instanceof Uint8Array\n  if (isDataBinary) flags |= 0x04\n\n  const versionBytes = encoder.encode(version)\n  const dataBytes = isDataBinary\n    ? (payload.data as Uint8Array)\n    : encoder.encode(payload.data as string)\n\n  const buf = new Uint8Array(1 + 4 + versionBytes.length + dataBytes.length)\n  const view = new DataView(buf.buffer)\n\n  buf[0] = flags\n  view.setUint32(1, versionBytes.length, false) // big-endian\n  buf.set(versionBytes, 5)\n  buf.set(dataBytes, 5 + versionBytes.length)\n\n  return buf\n}\n\nexport function decodeStoreRecord(bytes: Uint8Array): StoreRecord {\n  const flagByte = bytes[0]\n  if (flagByte === undefined) throw new Error(\"empty store record bytes\")\n  const flags = flagByte\n\n  // Check future-format flag (bit 7)\n  if ((flags & 0x80) !== 0) {\n    throw new Error(\"unknown store record format (future-format bit set)\")\n  }\n\n  const isMeta = (flags & 0x08) !== 0\n\n  if (isMeta) {\n    const metaJson = decoder.decode(bytes.subarray(1))\n    return { kind: \"meta\", meta: JSON.parse(metaJson) as StoreMeta }\n  }\n\n  // Entry record\n  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength)\n\n  const kind = (flags & 0x01) !== 0 ? \"since\" : \"entirety\"\n  const encoding = (flags & 0x02) !== 0 ? \"binary\" : \"json\"\n  const isDataBinary = (flags & 0x04) !== 0\n\n  const versionLen = view.getUint32(1, false)\n  const version = decoder.decode(bytes.subarray(5, 5 + versionLen))\n\n  const dataStart = 5 + versionLen\n  const rawData = bytes.subarray(dataStart)\n\n  const data: string | Uint8Array = isDataBinary\n    ? new Uint8Array(rawData)\n    : decoder.decode(rawData)\n\n  return {\n    kind: \"entry\",\n    payload: { kind, encoding, data },\n    version,\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Key helpers\n// ---------------------------------------------------------------------------\n\nfunction metaKey(docId: DocId): string {\n  return `${META_PREFIX}${docId}`\n}\n\nfunction recordPrefix(docId: DocId): string {\n  return `${RECORD_PREFIX}${docId}${SEP}`\n}\n\nfunction recordKey(docId: DocId, seqNo: number): string {\n  return `${recordPrefix(docId)}${String(seqNo).padStart(SEQ_PAD, \"0\")}`\n}\n\nfunction parseDocIdFromMetaKey(key: string): DocId {\n  return key.slice(META_PREFIX.length)\n}\n\nfunction parseSeqNoFromRecordKey(key: string, docId: DocId): number {\n  const prefix = recordPrefix(docId)\n  return Number.parseInt(key.slice(prefix.length), 10)\n}\n\n// ---------------------------------------------------------------------------\n// LevelDBStore\n// ---------------------------------------------------------------------------\n\nexport class LevelDBStore implements Store {\n  readonly #db: ClassicLevel<string, Uint8Array>\n  readonly #seqNos = new SeqNoTracker()\n\n  constructor(dbPath: string) {\n    this.#db = new ClassicLevel(dbPath, {\n      valueEncoding: \"binary\",\n    })\n  }\n\n  // -------------------------------------------------------------------------\n  // Store interface\n  // -------------------------------------------------------------------------\n\n  async currentMeta(docId: DocId): Promise<StoreMeta | null> {\n    try {\n      const raw = await this.#db.get(metaKey(docId))\n      return JSON.parse(decoder.decode(raw)) as StoreMeta\n    } catch (error: any) {\n      if (error.code === \"LEVEL_NOT_FOUND\") return null\n      throw error\n    }\n  }\n\n  async append(docId: DocId, record: StoreRecord): Promise<void> {\n    const existingMeta = await this.currentMeta(docId)\n    const resolved = validateAppend(docId, record, existingMeta)\n\n    if (resolved !== null) {\n      await this.#db.put(\n        metaKey(docId),\n        encoder.encode(JSON.stringify(resolved)),\n      )\n    }\n\n    const seq = await this.#seqNos.next(docId, async () => {\n      const prefix = recordPrefix(docId)\n      for await (const key of this.#db.keys({\n        gte: prefix,\n        lt: `${prefix}\\xff`,\n        reverse: true,\n        limit: 1,\n      })) {\n        return parseSeqNoFromRecordKey(key, docId)\n      }\n      return null\n    })\n    await this.#db.put(recordKey(docId, seq), encodeStoreRecord(record))\n  }\n\n  async *loadAll(docId: DocId): AsyncIterable<StoreRecord> {\n    const prefix = recordPrefix(docId)\n    for await (const value of this.#db.values({\n      gte: prefix,\n      lt: `${prefix}\\xff`,\n    })) {\n      yield decodeStoreRecord(value)\n    }\n  }\n\n  async replace(docId: DocId, records: StoreRecord[]): Promise<void> {\n    const existingMeta = await this.currentMeta(docId)\n\n    // Resolve validates: at least one meta present, immutable fields match.\n    const resolved = resolveMetaFromBatch(records, existingMeta)\n\n    const prefix = recordPrefix(docId)\n\n    // Collect existing record keys to delete\n    const keysToDelete: string[] = []\n    for await (const key of this.#db.keys({\n      gte: prefix,\n      lt: `${prefix}\\xff`,\n    })) {\n      keysToDelete.push(key)\n    }\n\n    // Atomic batch: delete all existing records, write replacements, upsert meta\n    const ops: Array<\n      | { type: \"del\"; key: string }\n      | { type: \"put\"; key: string; value: Uint8Array }\n    > = keysToDelete.map(key => ({ type: \"del\" as const, key }))\n\n    for (let i = 0; i < records.length; i++) {\n      ops.push({\n        type: \"put\",\n        key: recordKey(docId, i),\n        value: encodeStoreRecord(records[i]!),\n      })\n    }\n\n    ops.push({\n      type: \"put\",\n      key: metaKey(docId),\n      value: encoder.encode(JSON.stringify(resolved)),\n    })\n\n    await this.#db.batch(ops)\n\n    // Reset seqNo counter to the last written index\n    this.#seqNos.reset(docId, records.length - 1)\n  }\n\n  async delete(docId: DocId): Promise<void> {\n    const prefix = recordPrefix(docId)\n\n    // Collect record keys to delete\n    const keysToDelete: string[] = [metaKey(docId)]\n    for await (const key of this.#db.keys({\n      gte: prefix,\n      lt: `${prefix}\\xff`,\n    })) {\n      keysToDelete.push(key)\n    }\n\n    await this.#db.batch(\n      keysToDelete.map(key => ({ type: \"del\" as const, key })),\n    )\n\n    // Remove from in-memory seqNo tracker\n    this.#seqNos.remove(docId)\n  }\n\n  async *listDocIds(prefix?: string): AsyncIterable<DocId> {\n    const rangePrefix =\n      prefix !== undefined ? `${META_PREFIX}${prefix}` : META_PREFIX\n    for await (const key of this.#db.keys({\n      gte: rangePrefix,\n      lt: `${rangePrefix}\\xff`,\n    })) {\n      yield parseDocIdFromMetaKey(key)\n    }\n  }\n\n  async close(): Promise<void> {\n    await this.#db.close()\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Factory function\n// ---------------------------------------------------------------------------\n\n/**\n * Create a LevelDB storage backend for server-side persistence.\n *\n * Returns a `Store` — pass directly to `Exchange({ stores: [...] })`.\n *\n * @param dbPath - Directory path where LevelDB stores its files\n *\n * @example\n * ```typescript\n * import { createLevelDBStore } from \"@kyneta/leveldb-store\"\n *\n * const exchange = new Exchange({\n *   stores: [createLevelDBStore(\"./data/exchange-db\")],\n * })\n * ```\n */\nexport function createLevelDBStore(dbPath: string): Store {\n  return new LevelDBStore(dbPath)\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kyneta/leveldb-store",
-  "version": "1.3.1",
+  "version": "1.5.0",
   "description": "LevelDB storage backend for @kyneta/exchange — server-side persistent storage",
   "author": "Duane Johnson",
   "license": "MIT",
@@ -13,34 +13,39 @@
     "access": "public"
   },
   "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "files": [
     "dist",
     "src"
   ],
   "exports": {
-    "./server": {
-      "types": "./dist/server.d.ts",
-      "import": "./dist/server.js"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
     },
+    "./src": "./src/index.ts",
     "./src/*": "./src/*"
   },
   "peerDependencies": {
-    "@kyneta/exchange": "^1.3.1",
-    "@kyneta/schema": "^1.3.1"
+    "@kyneta/exchange": "^1.5.0",
+    "@kyneta/schema": "^1.5.0"
   },
   "dependencies": {
     "classic-level": "^1.4.1"
   },
   "devDependencies": {
     "@types/node": "^22",
-    "tsup": "^8.5.0",
+    "tsdown": "^0.21.9",
     "typescript": "^5.9.2",
     "vitest": "^4.0.17",
-    "@kyneta/exchange": "^1.3.1",
-    "@kyneta/schema": "^1.3.1"
+    "@kyneta/exchange": "^1.5.0",
+    "@kyneta/schema": "^1.5.0"
   },
   "scripts": {
-    "build": "tsup",
+    "build": "tsdown",
     "test": "verify logic",
     "verify": "verify"
   }

package/src/__tests__/leveldb-storage.test.ts

@@ -7,15 +7,17 @@
 import * as fs from "node:fs"
 import * as os from "node:os"
 import * as path from "node:path"
-import type { StoreEntry } from "@kyneta/exchange"
+import type { StoreRecord } from "@kyneta/exchange"
 import {
   collectAll,
   describeStore,
-  makeEntry,
-  plainMetadata,
+  makeBinaryEntryRecord,
+  makeEntryRecord,
+  makeMetaRecord,
+  plainMeta,
 } from "@kyneta/exchange/testing"
 import { afterAll, describe, expect, it } from "vitest"
-import { decodeStoreEntry, encodeStoreEntry, LevelDBStore } from "../server.js"
+import { decodeStoreRecord, encodeStoreRecord, LevelDBStore } from "../index.js"
 
 // ---------------------------------------------------------------------------
 // Temp directory management
@@ -43,13 +45,11 @@ afterAll(() => {
 // Conformance suite — validates the full Store contract
 // ---------------------------------------------------------------------------
 
-describeStore(
-  "LevelDBStore",
-  () => new LevelDBStore(makeTmpDir()),
-  async backend => {
-    if (backend.close) await backend.close()
+describeStore("LevelDBStore", () => new LevelDBStore(makeTmpDir()), {
+  cleanup: async backend => {
+    await backend.close()
   },
-)
+})
 
 // ---------------------------------------------------------------------------
 // LevelDB-specific tests
@@ -61,19 +61,26 @@ describe("LevelDBStore — close + reopen", () => {
 
     // Phase 1: write data then close
     const backend1 = new LevelDBStore(dir)
-    await backend1.ensureDoc("doc-1", plainMetadata)
-    await backend1.append("doc-1", makeEntry("entirety", "v1"))
-    await backend1.append("doc-1", makeEntry("since", "v2"))
+    await backend1.append("doc-1", makeMetaRecord())
+    await backend1.append("doc-1", makeEntryRecord("entirety", "v1"))
+    await backend1.append("doc-1", makeEntryRecord("since", "v2"))
     await backend1.close()
 
     // Phase 2: reopen and verify
     const backend2 = new LevelDBStore(dir)
-    expect(await backend2.lookup("doc-1")).toEqual(plainMetadata)
+    expect(await backend2.currentMeta("doc-1")).toEqual(plainMeta)
 
-    const entries = await collectAll(backend2.loadAll("doc-1"))
+    const records = await collectAll(backend2.loadAll("doc-1"))
+    expect(records).toHaveLength(3)
+    expect(records[0]).toEqual(makeMetaRecord())
+    const entries = records.filter(r => r.kind === "entry")
     expect(entries).toHaveLength(2)
-    expect(entries[0]?.version).toBe("v1")
-    expect(entries[1]?.version).toBe("v2")
+    expect((entries[0] as { kind: "entry"; version: string }).version).toBe(
+      "v1",
+    )
+    expect((entries[1] as { kind: "entry"; version: string }).version).toBe(
+      "v2",
+    )
     await backend2.close()
   })
 
@@ -81,37 +88,51 @@ describe("LevelDBStore — close + reopen", () => {
     const dir = makeTmpDir()
 
     const backend1 = new LevelDBStore(dir)
-    await backend1.ensureDoc("doc-1", plainMetadata)
-    await backend1.append("doc-1", makeEntry("entirety", "v1"))
-    await backend1.append("doc-1", makeEntry("since", "v2"))
+    await backend1.append("doc-1", makeMetaRecord())
+    await backend1.append("doc-1", makeEntryRecord("entirety", "v1"))
+    await backend1.append("doc-1", makeEntryRecord("since", "v2"))
     await backend1.close()
 
     // Reopen and append more
     const backend2 = new LevelDBStore(dir)
-    await backend2.append("doc-1", makeEntry("since", "v3"))
+    await backend2.append("doc-1", makeEntryRecord("since", "v3"))
 
-    const entries = await collectAll(backend2.loadAll("doc-1"))
+    const records = await collectAll(backend2.loadAll("doc-1"))
+    const entries = records.filter(r => r.kind === "entry")
     expect(entries).toHaveLength(3)
-    expect(entries[0]?.version).toBe("v1")
-    expect(entries[1]?.version).toBe("v2")
-    expect(entries[2]?.version).toBe("v3")
+    expect((entries[0] as { kind: "entry"; version: string }).version).toBe(
+      "v1",
+    )
+    expect((entries[1] as { kind: "entry"; version: string }).version).toBe(
+      "v2",
+    )
+    expect((entries[2] as { kind: "entry"; version: string }).version).toBe(
+      "v3",
+    )
     await backend2.close()
   })
 
-  it("replace then reopen preserves the single entry", async () => {
+  it("replace then reopen preserves the replacement records", async () => {
     const dir = makeTmpDir()
 
     const backend1 = new LevelDBStore(dir)
-    await backend1.ensureDoc("doc-1", plainMetadata)
-    await backend1.append("doc-1", makeEntry("since", "v1"))
-    await backend1.append("doc-1", makeEntry("since", "v2"))
-    await backend1.replace("doc-1", makeEntry("entirety", "v3"))
+    await backend1.append("doc-1", makeMetaRecord())
+    await backend1.append("doc-1", makeEntryRecord("since", "v1"))
+    await backend1.append("doc-1", makeEntryRecord("since", "v2"))
+    await backend1.replace("doc-1", [
+      makeMetaRecord(),
+      makeEntryRecord("entirety", "v3"),
+    ])
     await backend1.close()
 
     const backend2 = new LevelDBStore(dir)
-    const entries = await collectAll(backend2.loadAll("doc-1"))
-    expect(entries).toHaveLength(1)
-    expect(entries[0]?.version).toBe("v3")
+    const records = await collectAll(backend2.loadAll("doc-1"))
+    expect(records).toHaveLength(2)
+    expect(records[0]?.kind).toBe("meta")
+    expect(records[1]?.kind).toBe("entry")
+    expect((records[1] as { kind: "entry"; version: string }).version).toBe(
+      "v3",
+    )
     await backend2.close()
   })
 
@@ -119,9 +140,9 @@ describe("LevelDBStore — close + reopen", () => {
     const dir = makeTmpDir()
 
     const backend1 = new LevelDBStore(dir)
-    await backend1.ensureDoc("alpha", plainMetadata)
-    await backend1.ensureDoc("beta", plainMetadata)
-    await backend1.ensureDoc("gamma", plainMetadata)
+    await backend1.append("alpha", makeMetaRecord())
+    await backend1.append("beta", makeMetaRecord())
+    await backend1.append("gamma", makeMetaRecord())
     await backend1.close()
 
     const backend2 = new LevelDBStore(dir)
@@ -135,9 +156,26 @@ describe("LevelDBStore — close + reopen", () => {
 // encode/decode round-trip — pure function unit tests
 // ---------------------------------------------------------------------------
 
-describe("encodeStoreEntry / decodeStoreEntry", () => {
-  it("round-trips a JSON string payload (entirety)", () => {
-    const entry: StoreEntry = {
+describe("encodeStoreRecord / decodeStoreRecord", () => {
+  it("round-trips a meta record", () => {
+    const record: StoreRecord = makeMetaRecord()
+    const decoded = decodeStoreRecord(encodeStoreRecord(record))
+    expect(decoded).toEqual(record)
+  })
+
+  it("round-trips a meta record with custom schemaHash", () => {
+    const record: StoreRecord = makeMetaRecord({ schemaHash: "00custom" })
+    const decoded = decodeStoreRecord(encodeStoreRecord(record))
+    expect(decoded).toEqual(record)
+    expect(decoded.kind).toBe("meta")
+    if (decoded.kind === "meta") {
+      expect(decoded.meta.schemaHash).toBe("00custom")
+    }
+  })
+
+  it("round-trips a JSON string payload entry (entirety)", () => {
+    const record: StoreRecord = {
+      kind: "entry",
       payload: {
         kind: "entirety",
         encoding: "json",
@@ -145,51 +183,75 @@ describe("encodeStoreEntry / decodeStoreEntry", () => {
       },
       version: "42",
     }
-    const decoded = decodeStoreEntry(encodeStoreEntry(entry))
-    expect(decoded).toEqual(entry)
+    const decoded = decodeStoreRecord(encodeStoreRecord(record))
+    expect(decoded).toEqual(record)
   })
 
-  it("round-trips a binary Uint8Array payload (since)", () => {
+  it("round-trips a binary Uint8Array payload entry (since)", () => {
     const bytes = new Uint8Array([0x00, 0x01, 0x02, 0xff, 0xfe])
-    const entry: StoreEntry = {
+    const record: StoreRecord = {
+      kind: "entry",
       payload: { kind: "since", encoding: "binary", data: bytes },
       version: "v7",
     }
-    const decoded = decodeStoreEntry(encodeStoreEntry(entry))
-    expect(decoded.version).toBe("v7")
-    expect(decoded.payload.kind).toBe("since")
-    expect(decoded.payload.encoding).toBe("binary")
-    expect(decoded.payload.data).toBeInstanceOf(Uint8Array)
-    expect(decoded.payload.data).toEqual(bytes)
+    const decoded = decodeStoreRecord(encodeStoreRecord(record))
+    expect(decoded.kind).toBe("entry")
+    if (decoded.kind === "entry") {
+      expect(decoded.version).toBe("v7")
+      expect(decoded.payload.kind).toBe("since")
+      expect(decoded.payload.encoding).toBe("binary")
+      expect(decoded.payload.data).toBeInstanceOf(Uint8Array)
+      expect(decoded.payload.data).toEqual(bytes)
+    }
+  })
+
+  it("round-trips a binary entry record via makeBinaryEntryRecord", () => {
+    const bytes = new Uint8Array([0xde, 0xad, 0xbe, 0xef])
+    const record: StoreRecord = makeBinaryEntryRecord(
+      "entirety",
+      "bin-v1",
+      bytes,
+    )
+    const decoded = decodeStoreRecord(encodeStoreRecord(record))
+    expect(decoded).toEqual(record)
   })
 
   it("handles empty string data", () => {
-    const entry: StoreEntry = {
+    const record: StoreRecord = {
+      kind: "entry",
       payload: { kind: "entirety", encoding: "json", data: "" },
       version: "v0",
     }
-    const decoded = decodeStoreEntry(encodeStoreEntry(entry))
-    expect(decoded).toEqual(entry)
+    const decoded = decodeStoreRecord(encodeStoreRecord(record))
+    expect(decoded).toEqual(record)
   })
 
   it("handles empty Uint8Array data", () => {
-    const entry: StoreEntry = {
+    const record: StoreRecord = {
+      kind: "entry",
       payload: { kind: "since", encoding: "binary", data: new Uint8Array(0) },
       version: "v0",
     }
-    const decoded = decodeStoreEntry(encodeStoreEntry(entry))
-    expect(decoded.payload.data).toBeInstanceOf(Uint8Array)
-    expect((decoded.payload.data as Uint8Array).length).toBe(0)
+    const decoded = decodeStoreRecord(encodeStoreRecord(record))
+    expect(decoded.kind).toBe("entry")
+    if (decoded.kind === "entry") {
+      expect(decoded.payload.data).toBeInstanceOf(Uint8Array)
+      expect((decoded.payload.data as Uint8Array).length).toBe(0)
+    }
   })
 
   it("handles empty version string", () => {
-    const entry: StoreEntry = {
+    const record: StoreRecord = {
+      kind: "entry",
       payload: { kind: "entirety", encoding: "json", data: "{}" },
       version: "",
     }
-    const decoded = decodeStoreEntry(encodeStoreEntry(entry))
-    expect(decoded.version).toBe("")
-    expect(decoded.payload.data).toBe("{}")
+    const decoded = decodeStoreRecord(encodeStoreRecord(record))
+    expect(decoded.kind).toBe("entry")
+    if (decoded.kind === "entry") {
+      expect(decoded.version).toBe("")
+      expect(decoded.payload.data).toBe("{}")
+    }
   })
 
   it("handles large binary payload", () => {
@@ -197,11 +259,40 @@ describe("encodeStoreEntry / decodeStoreEntry", () => {
     for (let i = 0; i < largeData.length; i++) {
       largeData[i] = i % 256
     }
-    const entry: StoreEntry = {
+    const record: StoreRecord = {
+      kind: "entry",
       payload: { kind: "entirety", encoding: "binary", data: largeData },
       version: "large-v1",
     }
-    const decoded = decodeStoreEntry(encodeStoreEntry(entry))
-    expect(decoded.payload.data).toEqual(largeData)
+    const decoded = decodeStoreRecord(encodeStoreRecord(record))
+    expect(decoded.kind).toBe("entry")
+    if (decoded.kind === "entry") {
+      expect(decoded.payload.data).toEqual(largeData)
+    }
+  })
+
+  it("meta record flags byte has bit 3 set", () => {
+    const record: StoreRecord = makeMetaRecord()
+    const encoded = encodeStoreRecord(record)
+    expect(encoded[0]! & 0x08).toBe(0x08) // bit 3 set
+    expect(encoded[0]! & 0x80).toBe(0x00) // bit 7 clear (current format)
+  })
+
+  it("entry record flags byte has bit 3 clear", () => {
+    const record: StoreRecord = makeEntryRecord("entirety", "v1")
+    const encoded = encodeStoreRecord(record)
+    expect(encoded[0]! & 0x08).toBe(0x00) // bit 3 clear
+    expect(encoded[0]! & 0x80).toBe(0x00) // bit 7 clear (current format)
+  })
+
+  it("rejects bytes with future-format bit set", () => {
+    const record: StoreRecord = makeEntryRecord("entirety", "v1")
+    const encoded = encodeStoreRecord(record)
+    encoded[0] = encoded[0]! | 0x80 // set bit 7
+    expect(() => decodeStoreRecord(encoded)).toThrow(/future-format/)
+  })
+
+  it("throws on empty bytes", () => {
+    expect(() => decodeStoreRecord(new Uint8Array(0))).toThrow()
   })
 })

package/src/{server.ts → index.ts}

@@ -3,18 +3,25 @@
 // Implements the Store interface using classic-level.
 //
 // Key-space design (FoundationDB convention — \x00 null-byte separator):
-//   meta\x00{docId}                    → JSON-encoded DocMetadata
-//   entry\x00{docId}\x00{seqNo}       → binary-encoded StoreEntry
+//   meta\x00{docId}                       → JSON-encoded StoreMeta (materialized index)
+//   record\x00{docId}\x00{seqNo}          → binary-encoded StoreRecord (unified stream)
 //
 // The \x00 separator cannot appear in valid UTF-8 strings, so no docId
 // validation is needed — the key-space imposes zero constraints on callers.
 //
-// SeqNo is a zero-padded 10-digit monotonic counter per doc, tracked in
+// SeqNo is a zero-padded 16-digit monotonic counter per doc, tracked in
 // memory. On reboot, the max seqNo for a doc is lazily discovered via a
 // single reverse-iterator seek on first append.
 
-import type { DocId, Store, StoreEntry } from "@kyneta/exchange"
-import type { DocMetadata } from "@kyneta/schema"
+import {
+  type DocId,
+  resolveMetaFromBatch,
+  SeqNoTracker,
+  type Store,
+  type StoreMeta,
+  type StoreRecord,
+  validateAppend,
+} from "@kyneta/exchange"
 import { ClassicLevel } from "classic-level"
 
 // ---------------------------------------------------------------------------
@@ -23,25 +30,40 @@ import { ClassicLevel } from "classic-level"
 
 const SEP = "\x00"
 const META_PREFIX = `meta${SEP}`
-const ENTRY_PREFIX = `entry${SEP}`
-const SEQ_PAD = 10
+const RECORD_PREFIX = `record${SEP}`
+const SEQ_PAD = 16
 
 // ---------------------------------------------------------------------------
-// Binary envelope — pure encode/decode for StoreEntry
+// Binary envelope v2 — pure encode/decode for StoreRecord
 // ---------------------------------------------------------------------------
 
 // Flags byte layout:
-//   bit 0: kind        (0 = entirety, 1 = since)
-//   bit 1: encoding    (0 = json, 1 = binary)
-//   bit 2: data type   (0 = string, 1 = Uint8Array)
+//   bit 0: payload kind     (0 = entirety, 1 = since) — entry records only
+//   bit 1: encoding         (0 = json, 1 = binary) — entry records only
+//   bit 2: data type        (0 = string, 1 = Uint8Array) — entry records only
+//   bit 3: record kind      (0 = entry, 1 = meta)
+//   bit 7: future-format    (0 = current format, reserved)
 //
-// Layout: [1 byte flags] [4 bytes version length BE] [N bytes version UTF-8] [remaining: payload data]
+// Meta records (bit 3 = 1):
+//   [1 byte flags] [remaining: JSON-encoded StoreMeta]
+//
+// Entry records (bit 3 = 0):
+//   [1 byte flags] [4 bytes version length BE] [N bytes version UTF-8] [remaining: payload data]
 
 const encoder = new TextEncoder()
 const decoder = new TextDecoder()
 
-export function encodeStoreEntry(entry: StoreEntry): Uint8Array {
-  const { payload, version } = entry
+export function encodeStoreRecord(record: StoreRecord): Uint8Array {
+  if (record.kind === "meta") {
+    const metaBytes = encoder.encode(JSON.stringify(record.meta))
+    const buf = new Uint8Array(1 + metaBytes.length)
+    buf[0] = 0x08 // bit 3 set (meta)
+    buf.set(metaBytes, 1)
+    return buf
+  }
+
+  // Entry record
+  const { payload, version } = record
 
   let flags = 0
   if (payload.kind === "since") flags |= 0x01
@@ -66,12 +88,26 @@ export function encodeStoreEntry(entry: StoreEntry): Uint8Array {
   return buf
 }
 
-export function decodeStoreEntry(bytes: Uint8Array): StoreEntry {
-  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength)
-
+export function decodeStoreRecord(bytes: Uint8Array): StoreRecord {
   const flagByte = bytes[0]
-  if (flagByte === undefined) throw new Error("empty store entry bytes")
+  if (flagByte === undefined) throw new Error("empty store record bytes")
   const flags = flagByte
+
+  // Check future-format flag (bit 7)
+  if ((flags & 0x80) !== 0) {
+    throw new Error("unknown store record format (future-format bit set)")
+  }
+
+  const isMeta = (flags & 0x08) !== 0
+
+  if (isMeta) {
+    const metaJson = decoder.decode(bytes.subarray(1))
+    return { kind: "meta", meta: JSON.parse(metaJson) as StoreMeta }
+  }
+
+  // Entry record
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength)
+
   const kind = (flags & 0x01) !== 0 ? "since" : "entirety"
   const encoding = (flags & 0x02) !== 0 ? "binary" : "json"
   const isDataBinary = (flags & 0x04) !== 0
@@ -87,6 +123,7 @@ export function decodeStoreEntry(bytes: Uint8Array): StoreEntry {
     : decoder.decode(rawData)
 
   return {
+    kind: "entry",
     payload: { kind, encoding, data },
     version,
   }
@@ -100,20 +137,20 @@ function metaKey(docId: DocId): string {
   return `${META_PREFIX}${docId}`
 }
 
-function entryPrefix(docId: DocId): string {
-  return `${ENTRY_PREFIX}${docId}${SEP}`
+function recordPrefix(docId: DocId): string {
+  return `${RECORD_PREFIX}${docId}${SEP}`
 }
 
-function entryKey(docId: DocId, seqNo: number): string {
-  return `${entryPrefix(docId)}${String(seqNo).padStart(SEQ_PAD, "0")}`
+function recordKey(docId: DocId, seqNo: number): string {
+  return `${recordPrefix(docId)}${String(seqNo).padStart(SEQ_PAD, "0")}`
 }
 
 function parseDocIdFromMetaKey(key: string): DocId {
   return key.slice(META_PREFIX.length)
 }
 
-function parseSeqNoFromEntryKey(key: string, docId: DocId): number {
-  const prefix = entryPrefix(docId)
+function parseSeqNoFromRecordKey(key: string, docId: DocId): number {
+  const prefix = recordPrefix(docId)
   return Number.parseInt(key.slice(prefix.length), 10)
 }
 
@@ -123,7 +160,7 @@ function parseSeqNoFromEntryKey(key: string, docId: DocId): number {
 
 export class LevelDBStore implements Store {
   readonly #db: ClassicLevel<string, Uint8Array>
-  readonly #seqNos: Map<DocId, number> = new Map()
+  readonly #seqNos = new SeqNoTracker()
 
   constructor(dbPath: string) {
     this.#db = new ClassicLevel(dbPath, {
@@ -131,88 +168,65 @@ export class LevelDBStore implements Store {
     })
   }
 
-  // -------------------------------------------------------------------------
-  // Private — seqNo management
-  // -------------------------------------------------------------------------
-
-  /**
-   * Get the next seqNo for a doc. On first call after reboot, discovers
-   * the max existing seqNo via a single reverse-iterator seek.
-   */
-  async #nextSeqNo(docId: DocId): Promise<number> {
-    const cached = this.#seqNos.get(docId)
-    if (cached !== undefined) {
-      const next = cached + 1
-      this.#seqNos.set(docId, next)
-      return next
-    }
-
-    // Lazy discovery: reverse iterate to find the highest existing seqNo
-    const prefix = entryPrefix(docId)
-    let maxSeq = -1
-    for await (const key of this.#db.keys({
-      gte: prefix,
-      lt: `${prefix}\xff`,
-      reverse: true,
-      limit: 1,
-    })) {
-      maxSeq = parseSeqNoFromEntryKey(key, docId)
-    }
-
-    const next = maxSeq + 1
-    this.#seqNos.set(docId, next)
-    return next
-  }
-
   // -------------------------------------------------------------------------
   // Store interface
   // -------------------------------------------------------------------------
 
-  async lookup(docId: DocId): Promise<DocMetadata | null> {
+  async currentMeta(docId: DocId): Promise<StoreMeta | null> {
     try {
       const raw = await this.#db.get(metaKey(docId))
-      return JSON.parse(decoder.decode(raw)) as DocMetadata
+      return JSON.parse(decoder.decode(raw)) as StoreMeta
     } catch (error: any) {
       if (error.code === "LEVEL_NOT_FOUND") return null
       throw error
     }
   }
 
-  async ensureDoc(docId: DocId, metadata: DocMetadata): Promise<void> {
-    try {
-      await this.#db.get(metaKey(docId))
-      // Already exists — no-op (first call wins)
-    } catch (error: any) {
-      if (error.code === "LEVEL_NOT_FOUND") {
-        await this.#db.put(
-          metaKey(docId),
-          encoder.encode(JSON.stringify(metadata)),
-        )
-        return
-      }
-      throw error
+  async append(docId: DocId, record: StoreRecord): Promise<void> {
+    const existingMeta = await this.currentMeta(docId)
+    const resolved = validateAppend(docId, record, existingMeta)
+
+    if (resolved !== null) {
+      await this.#db.put(
+        metaKey(docId),
+        encoder.encode(JSON.stringify(resolved)),
+      )
     }
-  }
 
-  async append(docId: DocId, entry: StoreEntry): Promise<void> {
-    const seq = await this.#nextSeqNo(docId)
-    await this.#db.put(entryKey(docId, seq), encodeStoreEntry(entry))
+    const seq = await this.#seqNos.next(docId, async () => {
+      const prefix = recordPrefix(docId)
+      for await (const key of this.#db.keys({
+        gte: prefix,
+        lt: `${prefix}\xff`,
+        reverse: true,
+        limit: 1,
+      })) {
+        return parseSeqNoFromRecordKey(key, docId)
+      }
+      return null
+    })
+    await this.#db.put(recordKey(docId, seq), encodeStoreRecord(record))
   }
 
-  async *loadAll(docId: DocId): AsyncIterable<StoreEntry> {
-    const prefix = entryPrefix(docId)
+  async *loadAll(docId: DocId): AsyncIterable<StoreRecord> {
+    const prefix = recordPrefix(docId)
     for await (const value of this.#db.values({
       gte: prefix,
       lt: `${prefix}\xff`,
     })) {
-      yield decodeStoreEntry(value)
+      yield decodeStoreRecord(value)
     }
   }
 
-  async replace(docId: DocId, entry: StoreEntry): Promise<void> {
-    const prefix = entryPrefix(docId)
+  async replace(docId: DocId, records: StoreRecord[]): Promise<void> {
+    const existingMeta = await this.currentMeta(docId)
+
+    // Resolve validates: at least one meta present, immutable fields match.
+    const resolved = resolveMetaFromBatch(records, existingMeta)
 
-    // Collect keys to delete
+    const prefix = recordPrefix(docId)
+
+    // Collect existing record keys to delete
     const keysToDelete: string[] = []
     for await (const key of this.#db.keys({
       gte: prefix,
@@ -221,26 +235,36 @@ export class LevelDBStore implements Store {
       keysToDelete.push(key)
     }
 
-    // Atomic batch: delete all existing entries + write the single replacement
+    // Atomic batch: delete all existing records, write replacements, upsert meta
     const ops: Array<
       | { type: "del"; key: string }
       | { type: "put"; key: string; value: Uint8Array }
     > = keysToDelete.map(key => ({ type: "del" as const, key }))
+
+    for (let i = 0; i < records.length; i++) {
+      ops.push({
+        type: "put",
+        key: recordKey(docId, i),
+        value: encodeStoreRecord(records[i]!),
+      })
+    }
+
     ops.push({
       type: "put",
-      key: entryKey(docId, 0),
-      value: encodeStoreEntry(entry),
+      key: metaKey(docId),
+      value: encoder.encode(JSON.stringify(resolved)),
     })
+
     await this.#db.batch(ops)
 
-    // Reset seqNo counter
-    this.#seqNos.set(docId, 0)
+    // Reset seqNo counter to the last written index
+    this.#seqNos.reset(docId, records.length - 1)
   }
 
   async delete(docId: DocId): Promise<void> {
-    const prefix = entryPrefix(docId)
+    const prefix = recordPrefix(docId)
 
-    // Collect entry keys to delete
+    // Collect record keys to delete
     const keysToDelete: string[] = [metaKey(docId)]
     for await (const key of this.#db.keys({
       gte: prefix,
@@ -254,13 +278,15 @@ export class LevelDBStore implements Store {
     )
 
     // Remove from in-memory seqNo tracker
-    this.#seqNos.delete(docId)
+    this.#seqNos.remove(docId)
   }
 
-  async *listDocIds(): AsyncIterable<DocId> {
+  async *listDocIds(prefix?: string): AsyncIterable<DocId> {
+    const rangePrefix =
+      prefix !== undefined ? `${META_PREFIX}${prefix}` : META_PREFIX
     for await (const key of this.#db.keys({
-      gte: META_PREFIX,
-      lt: `${META_PREFIX}\xff`,
+      gte: rangePrefix,
+      lt: `${rangePrefix}\xff`,
     })) {
       yield parseDocIdFromMetaKey(key)
     }
@@ -284,7 +310,7 @@ export class LevelDBStore implements Store {
  *
  * @example
  * ```typescript
- * import { createLevelDBStore } from "@kyneta/leveldb-store/server"
+ * import { createLevelDBStore } from "@kyneta/leveldb-store"
  *
  * const exchange = new Exchange({
  *   stores: [createLevelDBStore("./data/exchange-db")],

package/dist/server.d.ts

@@ -1,36 +0,0 @@
-import { Store, DocId, StoreEntry } from '@kyneta/exchange';
-import { DocMetadata } from '@kyneta/schema';
-
-declare function encodeStoreEntry(entry: StoreEntry): Uint8Array;
-declare function decodeStoreEntry(bytes: Uint8Array): StoreEntry;
-declare class LevelDBStore implements Store {
-    #private;
-    constructor(dbPath: string);
-    lookup(docId: DocId): Promise<DocMetadata | null>;
-    ensureDoc(docId: DocId, metadata: DocMetadata): Promise<void>;
-    append(docId: DocId, entry: StoreEntry): Promise<void>;
-    loadAll(docId: DocId): AsyncIterable<StoreEntry>;
-    replace(docId: DocId, entry: StoreEntry): Promise<void>;
-    delete(docId: DocId): Promise<void>;
-    listDocIds(): AsyncIterable<DocId>;
-    close(): Promise<void>;
-}
-/**
- * Create a LevelDB storage backend for server-side persistence.
- *
- * Returns a `Store` — pass directly to `Exchange({ stores: [...] })`.
- *
- * @param dbPath - Directory path where LevelDB stores its files
- *
- * @example
- * ```typescript
- * import { createLevelDBStore } from "@kyneta/leveldb-store/server"
- *
- * const exchange = new Exchange({
- *   stores: [createLevelDBStore("./data/exchange-db")],
- * })
- * ```
- */
-declare function createLevelDBStore(dbPath: string): Store;
-
-export { LevelDBStore, createLevelDBStore, decodeStoreEntry, encodeStoreEntry };

package/dist/server.js

@@ -1,188 +0,0 @@
-// src/server.ts
-import { ClassicLevel } from "classic-level";
-var SEP = "\0";
-var META_PREFIX = `meta${SEP}`;
-var ENTRY_PREFIX = `entry${SEP}`;
-var SEQ_PAD = 10;
-var encoder = new TextEncoder();
-var decoder = new TextDecoder();
-function encodeStoreEntry(entry) {
-  const { payload, version } = entry;
-  let flags = 0;
-  if (payload.kind === "since") flags |= 1;
-  if (payload.encoding === "binary") flags |= 2;
-  const isDataBinary = payload.data instanceof Uint8Array;
-  if (isDataBinary) flags |= 4;
-  const versionBytes = encoder.encode(version);
-  const dataBytes = isDataBinary ? payload.data : encoder.encode(payload.data);
-  const buf = new Uint8Array(1 + 4 + versionBytes.length + dataBytes.length);
-  const view = new DataView(buf.buffer);
-  buf[0] = flags;
-  view.setUint32(1, versionBytes.length, false);
-  buf.set(versionBytes, 5);
-  buf.set(dataBytes, 5 + versionBytes.length);
-  return buf;
-}
-function decodeStoreEntry(bytes) {
-  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-  const flagByte = bytes[0];
-  if (flagByte === void 0) throw new Error("empty store entry bytes");
-  const flags = flagByte;
-  const kind = (flags & 1) !== 0 ? "since" : "entirety";
-  const encoding = (flags & 2) !== 0 ? "binary" : "json";
-  const isDataBinary = (flags & 4) !== 0;
-  const versionLen = view.getUint32(1, false);
-  const version = decoder.decode(bytes.subarray(5, 5 + versionLen));
-  const dataStart = 5 + versionLen;
-  const rawData = bytes.subarray(dataStart);
-  const data = isDataBinary ? new Uint8Array(rawData) : decoder.decode(rawData);
-  return {
-    payload: { kind, encoding, data },
-    version
-  };
-}
-function metaKey(docId) {
-  return `${META_PREFIX}${docId}`;
-}
-function entryPrefix(docId) {
-  return `${ENTRY_PREFIX}${docId}${SEP}`;
-}
-function entryKey(docId, seqNo) {
-  return `${entryPrefix(docId)}${String(seqNo).padStart(SEQ_PAD, "0")}`;
-}
-function parseDocIdFromMetaKey(key) {
-  return key.slice(META_PREFIX.length);
-}
-function parseSeqNoFromEntryKey(key, docId) {
-  const prefix = entryPrefix(docId);
-  return Number.parseInt(key.slice(prefix.length), 10);
-}
-var LevelDBStore = class {
-  #db;
-  #seqNos = /* @__PURE__ */ new Map();
-  constructor(dbPath) {
-    this.#db = new ClassicLevel(dbPath, {
-      valueEncoding: "binary"
-    });
-  }
-  // -------------------------------------------------------------------------
-  // Private — seqNo management
-  // -------------------------------------------------------------------------
-  /**
-   * Get the next seqNo for a doc. On first call after reboot, discovers
-   * the max existing seqNo via a single reverse-iterator seek.
-   */
-  async #nextSeqNo(docId) {
-    const cached = this.#seqNos.get(docId);
-    if (cached !== void 0) {
-      const next2 = cached + 1;
-      this.#seqNos.set(docId, next2);
-      return next2;
-    }
-    const prefix = entryPrefix(docId);
-    let maxSeq = -1;
-    for await (const key of this.#db.keys({
-      gte: prefix,
-      lt: `${prefix}\xFF`,
-      reverse: true,
-      limit: 1
-    })) {
-      maxSeq = parseSeqNoFromEntryKey(key, docId);
-    }
-    const next = maxSeq + 1;
-    this.#seqNos.set(docId, next);
-    return next;
-  }
-  // -------------------------------------------------------------------------
-  // Store interface
-  // -------------------------------------------------------------------------
-  async lookup(docId) {
-    try {
-      const raw = await this.#db.get(metaKey(docId));
-      return JSON.parse(decoder.decode(raw));
-    } catch (error) {
-      if (error.code === "LEVEL_NOT_FOUND") return null;
-      throw error;
-    }
-  }
-  async ensureDoc(docId, metadata) {
-    try {
-      await this.#db.get(metaKey(docId));
-    } catch (error) {
-      if (error.code === "LEVEL_NOT_FOUND") {
-        await this.#db.put(
-          metaKey(docId),
-          encoder.encode(JSON.stringify(metadata))
-        );
-        return;
-      }
-      throw error;
-    }
-  }
-  async append(docId, entry) {
-    const seq = await this.#nextSeqNo(docId);
-    await this.#db.put(entryKey(docId, seq), encodeStoreEntry(entry));
-  }
-  async *loadAll(docId) {
-    const prefix = entryPrefix(docId);
-    for await (const value of this.#db.values({
-      gte: prefix,
-      lt: `${prefix}\xFF`
-    })) {
-      yield decodeStoreEntry(value);
-    }
-  }
-  async replace(docId, entry) {
-    const prefix = entryPrefix(docId);
-    const keysToDelete = [];
-    for await (const key of this.#db.keys({
-      gte: prefix,
-      lt: `${prefix}\xFF`
-    })) {
-      keysToDelete.push(key);
-    }
-    const ops = keysToDelete.map((key) => ({ type: "del", key }));
-    ops.push({
-      type: "put",
-      key: entryKey(docId, 0),
-      value: encodeStoreEntry(entry)
-    });
-    await this.#db.batch(ops);
-    this.#seqNos.set(docId, 0);
-  }
-  async delete(docId) {
-    const prefix = entryPrefix(docId);
-    const keysToDelete = [metaKey(docId)];
-    for await (const key of this.#db.keys({
-      gte: prefix,
-      lt: `${prefix}\xFF`
-    })) {
-      keysToDelete.push(key);
-    }
-    await this.#db.batch(
-      keysToDelete.map((key) => ({ type: "del", key }))
-    );
-    this.#seqNos.delete(docId);
-  }
-  async *listDocIds() {
-    for await (const key of this.#db.keys({
-      gte: META_PREFIX,
-      lt: `${META_PREFIX}\xFF`
-    })) {
-      yield parseDocIdFromMetaKey(key);
-    }
-  }
-  async close() {
-    await this.#db.close();
-  }
-};
-function createLevelDBStore(dbPath) {
-  return new LevelDBStore(dbPath);
-}
-export {
-  LevelDBStore,
-  createLevelDBStore,
-  decodeStoreEntry,
-  encodeStoreEntry
-};
-//# sourceMappingURL=server.js.map

package/dist/server.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/server.ts"],"sourcesContent":["// server — LevelDB storage backend for @kyneta/exchange.\n//\n// Implements the Store interface using classic-level.\n//\n// Key-space design (FoundationDB convention — \\x00 null-byte separator):\n//   meta\\x00{docId}                    → JSON-encoded DocMetadata\n//   entry\\x00{docId}\\x00{seqNo}       → binary-encoded StoreEntry\n//\n// The \\x00 separator cannot appear in valid UTF-8 strings, so no docId\n// validation is needed — the key-space imposes zero constraints on callers.\n//\n// SeqNo is a zero-padded 10-digit monotonic counter per doc, tracked in\n// memory. On reboot, the max seqNo for a doc is lazily discovered via a\n// single reverse-iterator seek on first append.\n\nimport type { DocId, Store, StoreEntry } from \"@kyneta/exchange\"\nimport type { DocMetadata } from \"@kyneta/schema\"\nimport { ClassicLevel } from \"classic-level\"\n\n// ---------------------------------------------------------------------------\n// Constants\n// ---------------------------------------------------------------------------\n\nconst SEP = \"\\x00\"\nconst META_PREFIX = `meta${SEP}`\nconst ENTRY_PREFIX = `entry${SEP}`\nconst SEQ_PAD = 10\n\n// ---------------------------------------------------------------------------\n// Binary envelope — pure encode/decode for StoreEntry\n// ---------------------------------------------------------------------------\n\n// Flags byte layout:\n//   bit 0: kind        (0 = entirety, 1 = since)\n//   bit 1: encoding    (0 = json, 1 = binary)\n//   bit 2: data type   (0 = string, 1 = Uint8Array)\n//\n// Layout: [1 byte flags] [4 bytes version length BE] [N bytes version UTF-8] [remaining: payload data]\n\nconst encoder = new TextEncoder()\nconst decoder = new TextDecoder()\n\nexport function encodeStoreEntry(entry: StoreEntry): Uint8Array {\n  const { payload, version } = entry\n\n  let flags = 0\n  if (payload.kind === \"since\") flags |= 0x01\n  if (payload.encoding === \"binary\") flags |= 0x02\n\n  const isDataBinary = payload.data instanceof Uint8Array\n  if (isDataBinary) flags |= 0x04\n\n  const versionBytes = encoder.encode(version)\n  const dataBytes = isDataBinary\n    ? (payload.data as Uint8Array)\n    : encoder.encode(payload.data as string)\n\n  const buf = new Uint8Array(1 + 4 + versionBytes.length + dataBytes.length)\n  const view = new DataView(buf.buffer)\n\n  buf[0] = flags\n  view.setUint32(1, versionBytes.length, false) // big-endian\n  buf.set(versionBytes, 5)\n  buf.set(dataBytes, 5 + versionBytes.length)\n\n  return buf\n}\n\nexport function decodeStoreEntry(bytes: Uint8Array): StoreEntry {\n  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength)\n\n  const flagByte = bytes[0]\n  if (flagByte === undefined) throw new Error(\"empty store entry bytes\")\n  const flags = flagByte\n  const kind = (flags & 0x01) !== 0 ? \"since\" : \"entirety\"\n  const encoding = (flags & 0x02) !== 0 ? \"binary\" : \"json\"\n  const isDataBinary = (flags & 0x04) !== 0\n\n  const versionLen = view.getUint32(1, false)\n  const version = decoder.decode(bytes.subarray(5, 5 + versionLen))\n\n  const dataStart = 5 + versionLen\n  const rawData = bytes.subarray(dataStart)\n\n  const data: string | Uint8Array = isDataBinary\n    ? new Uint8Array(rawData)\n    : decoder.decode(rawData)\n\n  return {\n    payload: { kind, encoding, data },\n    version,\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Key helpers\n// ---------------------------------------------------------------------------\n\nfunction metaKey(docId: DocId): string {\n  return `${META_PREFIX}${docId}`\n}\n\nfunction entryPrefix(docId: DocId): string {\n  return `${ENTRY_PREFIX}${docId}${SEP}`\n}\n\nfunction entryKey(docId: DocId, seqNo: number): string {\n  return `${entryPrefix(docId)}${String(seqNo).padStart(SEQ_PAD, \"0\")}`\n}\n\nfunction parseDocIdFromMetaKey(key: string): DocId {\n  return key.slice(META_PREFIX.length)\n}\n\nfunction parseSeqNoFromEntryKey(key: string, docId: DocId): number {\n  const prefix = entryPrefix(docId)\n  return Number.parseInt(key.slice(prefix.length), 10)\n}\n\n// ---------------------------------------------------------------------------\n// LevelDBStore\n// ---------------------------------------------------------------------------\n\nexport class LevelDBStore implements Store {\n  readonly #db: ClassicLevel<string, Uint8Array>\n  readonly #seqNos: Map<DocId, number> = new Map()\n\n  constructor(dbPath: string) {\n    this.#db = new ClassicLevel(dbPath, {\n      valueEncoding: \"binary\",\n    })\n  }\n\n  // -------------------------------------------------------------------------\n  // Private — seqNo management\n  // -------------------------------------------------------------------------\n\n  /**\n   * Get the next seqNo for a doc. On first call after reboot, discovers\n   * the max existing seqNo via a single reverse-iterator seek.\n   */\n  async #nextSeqNo(docId: DocId): Promise<number> {\n    const cached = this.#seqNos.get(docId)\n    if (cached !== undefined) {\n      const next = cached + 1\n      this.#seqNos.set(docId, next)\n      return next\n    }\n\n    // Lazy discovery: reverse iterate to find the highest existing seqNo\n    const prefix = entryPrefix(docId)\n    let maxSeq = -1\n    for await (const key of this.#db.keys({\n      gte: prefix,\n      lt: `${prefix}\\xff`,\n      reverse: true,\n      limit: 1,\n    })) {\n      maxSeq = parseSeqNoFromEntryKey(key, docId)\n    }\n\n    const next = maxSeq + 1\n    this.#seqNos.set(docId, next)\n    return next\n  }\n\n  // -------------------------------------------------------------------------\n  // Store interface\n  // -------------------------------------------------------------------------\n\n  async lookup(docId: DocId): Promise<DocMetadata | null> {\n    try {\n      const raw = await this.#db.get(metaKey(docId))\n      return JSON.parse(decoder.decode(raw)) as DocMetadata\n    } catch (error: any) {\n      if (error.code === \"LEVEL_NOT_FOUND\") return null\n      throw error\n    }\n  }\n\n  async ensureDoc(docId: DocId, metadata: DocMetadata): Promise<void> {\n    try {\n      await this.#db.get(metaKey(docId))\n      // Already exists — no-op (first call wins)\n    } catch (error: any) {\n      if (error.code === \"LEVEL_NOT_FOUND\") {\n        await this.#db.put(\n          metaKey(docId),\n          encoder.encode(JSON.stringify(metadata)),\n        )\n        return\n      }\n      throw error\n    }\n  }\n\n  async append(docId: DocId, entry: StoreEntry): Promise<void> {\n    const seq = await this.#nextSeqNo(docId)\n    await this.#db.put(entryKey(docId, seq), encodeStoreEntry(entry))\n  }\n\n  async *loadAll(docId: DocId): AsyncIterable<StoreEntry> {\n    const prefix = entryPrefix(docId)\n    for await (const value of this.#db.values({\n      gte: prefix,\n      lt: `${prefix}\\xff`,\n    })) {\n      yield decodeStoreEntry(value)\n    }\n  }\n\n  async replace(docId: DocId, entry: StoreEntry): Promise<void> {\n    const prefix = entryPrefix(docId)\n\n    // Collect keys to delete\n    const keysToDelete: string[] = []\n    for await (const key of this.#db.keys({\n      gte: prefix,\n      lt: `${prefix}\\xff`,\n    })) {\n      keysToDelete.push(key)\n    }\n\n    // Atomic batch: delete all existing entries + write the single replacement\n    const ops: Array<\n      | { type: \"del\"; key: string }\n      | { type: \"put\"; key: string; value: Uint8Array }\n    > = keysToDelete.map(key => ({ type: \"del\" as const, key }))\n    ops.push({\n      type: \"put\",\n      key: entryKey(docId, 0),\n      value: encodeStoreEntry(entry),\n    })\n    await this.#db.batch(ops)\n\n    // Reset seqNo counter\n    this.#seqNos.set(docId, 0)\n  }\n\n  async delete(docId: DocId): Promise<void> {\n    const prefix = entryPrefix(docId)\n\n    // Collect entry keys to delete\n    const keysToDelete: string[] = [metaKey(docId)]\n    for await (const key of this.#db.keys({\n      gte: prefix,\n      lt: `${prefix}\\xff`,\n    })) {\n      keysToDelete.push(key)\n    }\n\n    await this.#db.batch(\n      keysToDelete.map(key => ({ type: \"del\" as const, key })),\n    )\n\n    // Remove from in-memory seqNo tracker\n    this.#seqNos.delete(docId)\n  }\n\n  async *listDocIds(): AsyncIterable<DocId> {\n    for await (const key of this.#db.keys({\n      gte: META_PREFIX,\n      lt: `${META_PREFIX}\\xff`,\n    })) {\n      yield parseDocIdFromMetaKey(key)\n    }\n  }\n\n  async close(): Promise<void> {\n    await this.#db.close()\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Factory function\n// ---------------------------------------------------------------------------\n\n/**\n * Create a LevelDB storage backend for server-side persistence.\n *\n * Returns a `Store` — pass directly to `Exchange({ stores: [...] })`.\n *\n * @param dbPath - Directory path where LevelDB stores its files\n *\n * @example\n * ```typescript\n * import { createLevelDBStore } from \"@kyneta/leveldb-store/server\"\n *\n * const exchange = new Exchange({\n *   stores: [createLevelDBStore(\"./data/exchange-db\")],\n * })\n * ```\n */\nexport function createLevelDBStore(dbPath: string): Store {\n  return new LevelDBStore(dbPath)\n}\n"],"mappings":"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","names":["next"]}