@backloghq/opslog 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 backloghq
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,169 @@
+# opslog
+
+Embedded event-sourced document store for Node.js. Zero native dependencies.
+
+Every mutation is recorded as an operation in an append-only log. Current state is derived by replaying operations from the latest snapshot. You get crash safety, undo, audit trails, and sync-readiness without a database server.
+
+## Install
+
+```bash
+npm install opslog
+```
+
+## Usage
+
+```typescript
+import { Store } from "opslog";
+
+const store = new Store<{ name: string; status: string }>();
+await store.open("./data");
+
+// Create
+await store.set("task-1", { name: "Build API", status: "active" });
+
+// Read
+const task = store.get("task-1");
+
+// Update
+await store.set("task-1", { ...task, status: "done" });
+
+// Delete
+await store.delete("task-1");
+
+// Undo the delete
+await store.undo();
+
+// Query
+const active = store.filter((r) => r.status === "active");
+const count = store.count((r) => r.status === "done");
+
+// Batch (single disk write for multiple operations)
+await store.batch(() => {
+  store.set("a", { name: "A", status: "active" });
+  store.set("b", { name: "B", status: "active" });
+  store.set("c", { name: "C", status: "active" });
+});
+
+// Close (checkpoints automatically)
+await store.close();
+```
+
+State survives restarts — reopen the same directory and everything is there.
+
+## How It Works
+
+```
+data/
+  manifest.json              # Points to current snapshot + ops file
+  snapshots/
+    snap-<timestamp>.json    # Immutable full-state capture
+  ops/
+    ops-<timestamp>.jsonl    # Append-only operation log
+  archive/
+    archive-<period>.json    # Old records, lazy-loaded
+```
+
+**Writes** append an operation (one JSON line) to the ops file. **Reads** come from an in-memory map built from the latest snapshot + ops replay. **Checkpoints** materialize current state as a new immutable snapshot.
+
+Every operation records the previous value, so **undo** pops the last operation and restores the old state. The operations log doubles as an **audit trail** and a natural unit for **sync** between nodes.
+
+## API
+
+### Lifecycle
+
+```typescript
+await store.open(dir, options?)   // Load state from directory
+await store.close()               // Checkpoint and close
+```
+
+### CRUD
+
+```typescript
+store.get(id)                     // Get record by ID
+await store.set(id, value)        // Create or update
+await store.delete(id)            // Remove (throws if not found)
+store.has(id)                     // Check existence
+```
+
+### Query
+
+```typescript
+store.all()                       // All records
+store.entries()                   // All [id, record] pairs
+store.filter(predicate)           // Records matching predicate
+store.count(predicate?)           // Count (all or matching)
+```
+
+### Batch
+
+```typescript
+await store.batch(() => {         // Multiple ops, single disk write
+  store.set("a", valueA);        // Rolls back all on error
+  store.set("b", valueB);
+});
+```
+
+### History
+
+```typescript
+await store.undo()                // Undo last operation
+store.getHistory(id)              // All operations for a record
+store.getOps(since?)              // Operations since timestamp
+```
+
+### Maintenance
+
+```typescript
+await store.compact()             // Create new snapshot, clear ops
+await store.archive(predicate)    // Move matching records to archive
+await store.loadArchive(segment)  // Lazy-load archived records
+store.listArchiveSegments()       // List available archive files
+store.stats()                     // { activeRecords, opsCount, archiveSegments }
+```
+
+## Options
+
+```typescript
+await store.open(dir, {
+  checkpointThreshold: 100,       // Auto-checkpoint after N ops (default: 100)
+  checkpointOnClose: true,        // Checkpoint when close() is called (default: true)
+  version: 1,                     // Schema version
+  migrate: (record, fromVersion) => record, // Migration function
+});
+```
+
+## Crash Safety
+
+- **Ops file**: append-only writes. A crash mid-append loses at most the last operation. Malformed lines are skipped on recovery.
+- **Snapshots**: immutable. Written to a temp file, then atomically renamed.
+- **Manifest**: atomically replaced via temp-file-rename. Always points to a valid snapshot.
+
+No data corruption on crash. At most one in-flight operation is lost.
+
+## Schema Migration
+
+```typescript
+const store = new Store();
+await store.open(dir, {
+  version: 2,
+  migrate: (record, fromVersion) => {
+    if (fromVersion < 2) return { ...record, newField: "default" };
+    return record;
+  },
+});
+```
+
+Records are migrated in memory on open. Next checkpoint persists the migrated state.
+
+## Development
+
+```bash
+npm run build          # Compile TypeScript
+npm run lint           # ESLint
+npm test               # Run tests
+npm run test:coverage  # Tests with coverage
+```
+
+## License
+
+MIT

package/dist/archive.d.ts

@@ -0,0 +1,3 @@
+export declare function writeArchiveSegment<T>(dir: string, period: string, records: Map<string, T>): Promise<string>;
+export declare function loadArchiveSegment<T>(dir: string, relativePath: string): Promise<Map<string, T>>;
+export declare function listArchiveSegments(dir: string): Promise<string[]>;

package/dist/archive.js

@@ -0,0 +1,34 @@
+import { readFile, readdir, rename, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+export async function writeArchiveSegment(dir, period, records) {
+    const filename = `archive-${period}.json`;
+    const path = join(dir, "archive", filename);
+    const segment = {
+        version: 1,
+        period,
+        timestamp: new Date().toISOString(),
+        records: Object.fromEntries(records),
+    };
+    const tmpPath = path + ".tmp";
+    await writeFile(tmpPath, JSON.stringify(segment, null, 2), "utf-8");
+    await rename(tmpPath, path);
+    return `archive/${filename}`;
+}
+export async function loadArchiveSegment(dir, relativePath) {
+    const path = join(dir, relativePath);
+    const content = await readFile(path, "utf-8");
+    const segment = JSON.parse(content);
+    return new Map(Object.entries(segment.records));
+}
+export async function listArchiveSegments(dir) {
+    const archiveDir = join(dir, "archive");
+    try {
+        const files = await readdir(archiveDir);
+        return files
+            .filter((f) => f.startsWith("archive-") && f.endsWith(".json"))
+            .map((f) => `archive/${f}`);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { Store } from "./store.js";
+export type { Operation, Snapshot, Manifest, ManifestStats, ArchiveSegment, StoreOptions, StoreStats, } from "./types.js";

package/dist/index.js

@@ -0,0 +1 @@
+export { Store } from "./store.js";

package/dist/manifest.d.ts

@@ -0,0 +1,4 @@
+import type { Manifest } from "./types.js";
+export declare function readManifest(dir: string): Promise<Manifest | null>;
+export declare function writeManifest(dir: string, manifest: Manifest): Promise<void>;
+export declare function createDefaultManifest(snapshotPath: string, opsPath: string): Manifest;

package/dist/manifest.js

@@ -0,0 +1,34 @@
+import { readFile, rename, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+const MANIFEST_FILE = "manifest.json";
+export async function readManifest(dir) {
+    try {
+        const content = await readFile(join(dir, MANIFEST_FILE), "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeManifest(dir, manifest) {
+    const path = join(dir, MANIFEST_FILE);
+    const tmpPath = path + ".tmp";
+    await writeFile(tmpPath, JSON.stringify(manifest, null, 2), "utf-8");
+    await rename(tmpPath, path);
+}
+export function createDefaultManifest(snapshotPath, opsPath) {
+    const now = new Date().toISOString();
+    return {
+        version: 1,
+        currentSnapshot: snapshotPath,
+        activeOps: opsPath,
+        archiveSegments: [],
+        stats: {
+            activeRecords: 0,
+            archivedRecords: 0,
+            opsCount: 0,
+            created: now,
+            lastCheckpoint: now,
+        },
+    };
+}

package/dist/snapshot.d.ts

@@ -0,0 +1,5 @@
+export declare function writeSnapshot<T>(dir: string, records: Map<string, T>, version: number): Promise<string>;
+export declare function loadSnapshot<T>(dir: string, relativePath: string): Promise<{
+    records: Map<string, T>;
+    version: number;
+}>;

package/dist/snapshot.js

@@ -0,0 +1,23 @@
+import { readFile, rename, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+export async function writeSnapshot(dir, records, version) {
+    const timestamp = new Date().toISOString();
+    const filename = `snap-${Date.now()}.json`;
+    const path = join(dir, "snapshots", filename);
+    const snapshot = {
+        version,
+        timestamp,
+        records: Object.fromEntries(records),
+    };
+    const tmpPath = path + ".tmp";
+    await writeFile(tmpPath, JSON.stringify(snapshot, null, 2), "utf-8");
+    await rename(tmpPath, path);
+    return `snapshots/${filename}`;
+}
+export async function loadSnapshot(dir, relativePath) {
+    const path = join(dir, relativePath);
+    const content = await readFile(path, "utf-8");
+    const snapshot = JSON.parse(content);
+    const records = new Map(Object.entries(snapshot.records));
+    return { records, version: snapshot.version };
+}

package/dist/store.d.ts

@@ -0,0 +1,38 @@
+import type { Operation, StoreOptions, StoreStats } from "./types.js";
+export declare class Store<T = Record<string, unknown>> {
+    private dir;
+    private records;
+    private ops;
+    private archiveSegments;
+    private opened;
+    private version;
+    private activeOpsPath;
+    private created;
+    private options;
+    private batching;
+    private batchOps;
+    open(dir: string, options?: StoreOptions): Promise<void>;
+    close(): Promise<void>;
+    get(id: string): T | undefined;
+    set(id: string, value: T): Promise<void> | void;
+    delete(id: string): Promise<void> | void;
+    has(id: string): boolean;
+    all(): T[];
+    entries(): [string, T][];
+    filter(predicate: (value: T, id: string) => boolean): T[];
+    count(predicate?: (value: T, id: string) => boolean): number;
+    batch(fn: () => void): Promise<void>;
+    undo(): Promise<boolean>;
+    getHistory(id: string): Operation<T>[];
+    getOps(since?: string): Operation<T>[];
+    compact(): Promise<void>;
+    archive(predicate: (value: T, id: string) => boolean, segment?: string): Promise<number>;
+    loadArchive(segment: string): Promise<Map<string, T>>;
+    listArchiveSegments(): string[];
+    stats(): StoreStats;
+    private ensureOpen;
+    private applyOp;
+    private reverseOp;
+    private persistOp;
+    private defaultPeriod;
+}

package/dist/store.js

@@ -0,0 +1,295 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { appendOp, appendOps, readOps, truncateLastOp } from "./wal.js";
+import { loadSnapshot, writeSnapshot } from "./snapshot.js";
+import { createDefaultManifest, readManifest, writeManifest, } from "./manifest.js";
+import { loadArchiveSegment, writeArchiveSegment, } from "./archive.js";
+export class Store {
+    dir = "";
+    records = new Map();
+    ops = [];
+    archiveSegments = [];
+    opened = false;
+    version = 1;
+    activeOpsPath = "";
+    created = "";
+    options = {
+        checkpointThreshold: 100,
+        checkpointOnClose: true,
+        version: 1,
+        migrate: (r) => r,
+    };
+    batching = false;
+    batchOps = [];
+    async open(dir, options) {
+        this.dir = dir;
+        if (options) {
+            this.options = { ...this.options, ...options };
+        }
+        await mkdir(join(dir, "snapshots"), { recursive: true });
+        await mkdir(join(dir, "ops"), { recursive: true });
+        await mkdir(join(dir, "archive"), { recursive: true });
+        const manifest = await readManifest(dir);
+        if (!manifest) {
+            // Fresh store — create empty snapshot and manifest
+            const snapshotPath = await writeSnapshot(dir, new Map(), this.options.version);
+            const opsFilename = `ops-${Date.now()}.jsonl`;
+            const opsPath = `ops/${opsFilename}`;
+            await writeFile(join(dir, opsPath), "", "utf-8");
+            const newManifest = createDefaultManifest(snapshotPath, opsPath);
+            await writeManifest(dir, newManifest);
+            this.version = this.options.version;
+            this.activeOpsPath = opsPath;
+            this.created = newManifest.stats.created;
+            this.archiveSegments = [];
+        }
+        else {
+            // Load existing state
+            const { records, version: storedVersion } = await loadSnapshot(dir, manifest.currentSnapshot);
+            this.records = records;
+            this.version = storedVersion;
+            this.activeOpsPath = manifest.activeOps;
+            this.created = manifest.stats.created;
+            this.archiveSegments = manifest.archiveSegments;
+            // Migrate if needed
+            if (storedVersion < this.options.version) {
+                for (const [id, record] of this.records) {
+                    this.records.set(id, this.options.migrate(record, storedVersion));
+                }
+                this.version = this.options.version;
+            }
+            // Replay ops
+            const ops = await readOps(join(dir, manifest.activeOps));
+            for (const op of ops) {
+                this.applyOp(op);
+            }
+            this.ops = ops;
+        }
+        this.opened = true;
+    }
+    async close() {
+        this.ensureOpen();
+        if (this.options.checkpointOnClose && this.ops.length > 0) {
+            await this.compact();
+        }
+        this.opened = false;
+    }
+    get(id) {
+        this.ensureOpen();
+        return this.records.get(id);
+    }
+    set(id, value) {
+        this.ensureOpen();
+        const prev = this.records.get(id) ?? null;
+        const op = {
+            ts: new Date().toISOString(),
+            op: "set",
+            id,
+            data: value,
+            prev,
+        };
+        this.records.set(id, value);
+        if (this.batching) {
+            this.batchOps.push(op);
+            return;
+        }
+        return this.persistOp(op);
+    }
+    delete(id) {
+        this.ensureOpen();
+        const prev = this.records.get(id);
+        if (prev === undefined) {
+            throw new Error(`Record '${id}' not found`);
+        }
+        const op = {
+            ts: new Date().toISOString(),
+            op: "delete",
+            id,
+            prev,
+        };
+        this.records.delete(id);
+        if (this.batching) {
+            this.batchOps.push(op);
+            return;
+        }
+        return this.persistOp(op);
+    }
+    has(id) {
+        this.ensureOpen();
+        return this.records.has(id);
+    }
+    all() {
+        this.ensureOpen();
+        return Array.from(this.records.values());
+    }
+    entries() {
+        this.ensureOpen();
+        return Array.from(this.records.entries());
+    }
+    filter(predicate) {
+        this.ensureOpen();
+        const results = [];
+        for (const [id, value] of this.records) {
+            if (predicate(value, id))
+                results.push(value);
+        }
+        return results;
+    }
+    count(predicate) {
+        this.ensureOpen();
+        if (!predicate)
+            return this.records.size;
+        let n = 0;
+        for (const [id, value] of this.records) {
+            if (predicate(value, id))
+                n++;
+        }
+        return n;
+    }
+    async batch(fn) {
+        this.ensureOpen();
+        this.batching = true;
+        this.batchOps = [];
+        try {
+            fn();
+            if (this.batchOps.length > 0) {
+                await appendOps(join(this.dir, this.activeOpsPath), this.batchOps);
+                this.ops.push(...this.batchOps);
+                if (this.ops.length >= this.options.checkpointThreshold) {
+                    await this.compact();
+                }
+            }
+        }
+        catch (err) {
+            // Rollback in-memory changes on failure
+            for (const op of this.batchOps.reverse()) {
+                this.reverseOp(op);
+            }
+            throw err;
+        }
+        finally {
+            this.batching = false;
+            this.batchOps = [];
+        }
+    }
+    async undo() {
+        this.ensureOpen();
+        if (this.ops.length === 0)
+            return false;
+        const lastOp = this.ops[this.ops.length - 1];
+        this.reverseOp(lastOp);
+        this.ops.pop();
+        await truncateLastOp(join(this.dir, this.activeOpsPath));
+        return true;
+    }
+    getHistory(id) {
+        this.ensureOpen();
+        return this.ops.filter((op) => op.id === id);
+    }
+    getOps(since) {
+        this.ensureOpen();
+        if (!since)
+            return [...this.ops];
+        return this.ops.filter((op) => op.ts > since);
+    }
+    async compact() {
+        this.ensureOpen();
+        const snapshotPath = await writeSnapshot(this.dir, this.records, this.version);
+        const opsFilename = `ops-${Date.now()}.jsonl`;
+        const opsPath = `ops/${opsFilename}`;
+        await writeFile(join(this.dir, opsPath), "", "utf-8");
+        const updatedManifest = {
+            version: this.version,
+            currentSnapshot: snapshotPath,
+            activeOps: opsPath,
+            archiveSegments: this.archiveSegments,
+            stats: {
+                activeRecords: this.records.size,
+                archivedRecords: 0,
+                opsCount: 0,
+                created: this.created,
+                lastCheckpoint: new Date().toISOString(),
+            },
+        };
+        await writeManifest(this.dir, updatedManifest);
+        this.activeOpsPath = opsPath;
+        this.ops = [];
+    }
+    async archive(predicate, segment) {
+        this.ensureOpen();
+        const toArchive = new Map();
+        for (const [id, value] of this.records) {
+            if (predicate(value, id))
+                toArchive.set(id, value);
+        }
+        if (toArchive.size === 0)
+            return 0;
+        const period = segment ?? this.defaultPeriod();
+        const segmentPath = await writeArchiveSegment(this.dir, period, toArchive);
+        if (!this.archiveSegments.includes(segmentPath)) {
+            this.archiveSegments.push(segmentPath);
+        }
+        for (const id of toArchive.keys()) {
+            this.records.delete(id);
+        }
+        await this.compact();
+        return toArchive.size;
+    }
+    async loadArchive(segment) {
+        this.ensureOpen();
+        const segmentPath = this.archiveSegments.find((s) => s.includes(segment));
+        if (!segmentPath)
+            throw new Error(`Archive segment '${segment}' not found`);
+        return loadArchiveSegment(this.dir, segmentPath);
+    }
+    listArchiveSegments() {
+        this.ensureOpen();
+        return [...this.archiveSegments];
+    }
+    stats() {
+        this.ensureOpen();
+        return {
+            activeRecords: this.records.size,
+            opsCount: this.ops.length,
+            archiveSegments: this.archiveSegments.length,
+        };
+    }
+    ensureOpen() {
+        if (!this.opened)
+            throw new Error("Store is not open. Call open() first.");
+    }
+    applyOp(op) {
+        if (op.op === "set" && op.data !== undefined) {
+            this.records.set(op.id, op.data);
+        }
+        else if (op.op === "delete") {
+            this.records.delete(op.id);
+        }
+    }
+    reverseOp(op) {
+        if (op.prev === null) {
+            // Was a create — reverse by deleting
+            this.records.delete(op.id);
+        }
+        else if (op.op === "delete") {
+            // Was a delete — reverse by restoring
+            this.records.set(op.id, op.prev);
+        }
+        else {
+            // Was an update — reverse by restoring prev
+            this.records.set(op.id, op.prev);
+        }
+    }
+    async persistOp(op) {
+        await appendOp(join(this.dir, this.activeOpsPath), op);
+        this.ops.push(op);
+        if (this.ops.length >= this.options.checkpointThreshold) {
+            await this.compact();
+        }
+    }
+    defaultPeriod() {
+        const now = new Date();
+        const q = Math.ceil((now.getMonth() + 1) / 3);
+        return `${now.getFullYear()}-Q${q}`;
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,52 @@
+export interface Operation<T = Record<string, unknown>> {
+    /** ISO 8601 timestamp */
+    ts: string;
+    /** Operation type */
+    op: "set" | "delete";
+    /** Record ID */
+    id: string;
+    /** New value (present for set operations) */
+    data?: T;
+    /** Previous value (null for creates, full record for updates/deletes) */
+    prev: T | null;
+}
+export interface Snapshot<T = Record<string, unknown>> {
+    version: number;
+    timestamp: string;
+    records: Record<string, T>;
+}
+export interface Manifest {
+    version: number;
+    currentSnapshot: string;
+    activeOps: string;
+    archiveSegments: string[];
+    stats: ManifestStats;
+}
+export interface ManifestStats {
+    activeRecords: number;
+    archivedRecords: number;
+    opsCount: number;
+    created: string;
+    lastCheckpoint: string;
+}
+export interface ArchiveSegment<T = Record<string, unknown>> {
+    version: number;
+    period: string;
+    timestamp: string;
+    records: Record<string, T>;
+}
+export interface StoreOptions {
+    /** Auto-checkpoint after this many operations (default: 100) */
+    checkpointThreshold?: number;
+    /** Checkpoint on close (default: true) */
+    checkpointOnClose?: boolean;
+    /** Schema version for migration (default: 1) */
+    version?: number;
+    /** Migration function: called if stored version < current version */
+    migrate?: (record: unknown, fromVersion: number) => unknown;
+}
+export interface StoreStats {
+    activeRecords: number;
+    opsCount: number;
+    archiveSegments: number;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/wal.d.ts

@@ -0,0 +1,5 @@
+import type { Operation } from "./types.js";
+export declare function appendOp<T>(path: string, op: Operation<T>): Promise<void>;
+export declare function appendOps<T>(path: string, ops: Operation<T>[]): Promise<void>;
+export declare function readOps<T>(path: string): Promise<Operation<T>[]>;
+export declare function truncateLastOp(path: string): Promise<boolean>;

package/dist/wal.js

@@ -0,0 +1,44 @@
+import { appendFile, readFile, writeFile } from "node:fs/promises";
+export async function appendOp(path, op) {
+    await appendFile(path, JSON.stringify(op) + "\n", "utf-8");
+}
+export async function appendOps(path, ops) {
+    const lines = ops.map((op) => JSON.stringify(op)).join("\n") + "\n";
+    await appendFile(path, lines, "utf-8");
+}
+export async function readOps(path) {
+    let content;
+    try {
+        content = await readFile(path, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    const lines = content.trim().split("\n").filter(Boolean);
+    const ops = [];
+    for (const line of lines) {
+        try {
+            ops.push(JSON.parse(line));
+        }
+        catch {
+            // Skip malformed lines (crash recovery)
+        }
+    }
+    return ops;
+}
+export async function truncateLastOp(path) {
+    let content;
+    try {
+        content = await readFile(path, "utf-8");
+    }
+    catch {
+        return false;
+    }
+    const lines = content.trim().split("\n").filter(Boolean);
+    if (lines.length === 0)
+        return false;
+    lines.pop();
+    const newContent = lines.length > 0 ? lines.join("\n") + "\n" : "";
+    await writeFile(path, newContent, "utf-8");
+    return true;
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@backloghq/opslog",
+  "version": "0.1.0",
+  "description": "Embedded event-sourced document store. Append-only operation log with immutable snapshots, zero native dependencies.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "lint": "eslint src/ tests/",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  },
+  "keywords": [
+    "event-sourcing",
+    "append-only",
+    "wal",
+    "document-store",
+    "embedded",
+    "jsonl",
+    "snapshots"
+  ],
+  "author": "mbocevski",
+  "license": "MIT",
+  "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  "devDependencies": {
+    "@eslint/js": "*",
+    "@types/node": "*",
+    "@vitest/coverage-v8": "^4.1.2",
+    "eslint": "*",
+    "typescript": "*",
+    "typescript-eslint": "*",
+    "vitest": "*"
+  }
+}