@bod.ee/db 0.7.0

package/tests/stream.test.ts

@@ -0,0 +1,385 @@
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { BodDB } from '../src/server/BodDB.ts';
+import { BodClient } from '../src/client/BodClient.ts';
+
+describe('StreamEngine', () => {
+  let db: BodDB;
+
+  beforeEach(() => {
+    db = new BodDB({ path: ':memory:', sweepInterval: 0 });
+  });
+
+  afterEach(() => {
+    db.close();
+  });
+
+  test('read returns events after offset', () => {
+    // Push 10 events
+    const keys: string[] = [];
+    for (let i = 0; i < 10; i++) {
+      keys.push(db.push('events/orders', { i }));
+    }
+
+    // Read all from group with no offset
+    const all = db.stream.read('events/orders', 'g1');
+    expect(all.length).toBe(10);
+    expect((all[0].data as { i: number }).i).toBe(0);
+
+    // Ack up to key 5
+    db.stream.ack('events/orders', 'g1', keys[4]);
+
+    // Read again — should get 5-9
+    const remaining = db.stream.read('events/orders', 'g1');
+    expect(remaining.length).toBe(5);
+    expect((remaining[0].data as { i: number }).i).toBe(5);
+  });
+
+  test('independent offsets per group', () => {
+    for (let i = 0; i < 5; i++) {
+      db.push('events/orders', { i });
+    }
+
+    const allG1 = db.stream.read('events/orders', 'g1');
+    const allG2 = db.stream.read('events/orders', 'g2');
+    expect(allG1.length).toBe(5);
+    expect(allG2.length).toBe(5);
+
+    // Ack all for g1
+    db.stream.ack('events/orders', 'g1', allG1[4].key);
+
+    // g1 should be empty, g2 still has all
+    expect(db.stream.read('events/orders', 'g1').length).toBe(0);
+    expect(db.stream.read('events/orders', 'g2').length).toBe(5);
+  });
+
+  test('subscribe replays and receives live events', () => {
+    // Push 3 events before subscribing
+    for (let i = 0; i < 3; i++) {
+      db.push('events/orders', { i });
+    }
+
+    const received: Array<{ key: string; data: unknown }> = [];
+    const unsub = db.stream.subscribe('events/orders', 'g1', (events) => {
+      received.push(...events);
+    });
+
+    // Should have received replay of 3
+    expect(received.length).toBe(3);
+
+    // Push live event
+    db.push('events/orders', { i: 3 });
+    expect(received.length).toBe(4);
+    expect((received[3].data as { i: number }).i).toBe(3);
+
+    unsub();
+
+    // After unsub, no more events
+    db.push('events/orders', { i: 4 });
+    expect(received.length).toBe(4);
+  });
+
+  test('subscribe resumes from last acked offset', () => {
+    const keys: string[] = [];
+    for (let i = 0; i < 5; i++) {
+      keys.push(db.push('events/orders', { i }));
+    }
+
+    // Ack up to 3rd event
+    db.stream.ack('events/orders', 'g1', keys[2]);
+
+    const received: Array<{ key: string; data: unknown }> = [];
+    const unsub = db.stream.subscribe('events/orders', 'g1', (events) => {
+      received.push(...events);
+    });
+
+    // Should replay only events 3 and 4
+    expect(received.length).toBe(2);
+    expect((received[0].data as { i: number }).i).toBe(3);
+
+    unsub();
+  });
+});
+
+describe('Stream compaction (snapshot model)', () => {
+  let db: BodDB;
+
+  beforeEach(() => {
+    db = new BodDB({ path: ':memory:', sweepInterval: 0 });
+  });
+
+  afterEach(() => {
+    db.close();
+  });
+
+  test('compact maxCount folds excess into snapshot', () => {
+    for (let i = 0; i < 20; i++) {
+      db.push('events/orders', { i });
+    }
+
+    const result = db.stream.compact('events/orders', { maxCount: 5 });
+    expect(result.deleted).toBe(15);
+    // snapshotSize = number of keys in merged state (all events have same `i` key, so 1)
+    expect(result.snapshotSize).toBe(1);
+
+    // Only 5 events remain as live rows
+    const remaining = db.stream.read('events/orders', 'check');
+    expect(remaining.length).toBe(5);
+    expect((remaining[0].data as { i: number }).i).toBe(15);
+
+    // Snapshot is merged final state of folded events
+    const snap = db.stream.snapshot('events/orders');
+    expect(snap).not.toBeNull();
+    // All 15 events had { i: N } — merged into single object, last write wins
+    expect(snap!.data.i).toBe(14);
+  });
+
+  test('compact maxAge folds old events into snapshot', () => {
+    for (let i = 0; i < 10; i++) {
+      db.push('events/orders', { i });
+    }
+
+    // Backdate first 6 events to 2 hours ago
+    const rows = db.storage.db
+      .prepare("SELECT path FROM nodes WHERE path LIKE 'events/orders/%' ORDER BY path ASC")
+      .all() as Array<{ path: string }>;
+    const twoHoursAgo = Date.now() - 7200 * 1000;
+    for (let i = 0; i < 6; i++) {
+      db.storage.db.run('UPDATE nodes SET updated_at = ? WHERE path = ?', [twoHoursAgo, rows[i].path]);
+    }
+
+    const result = db.stream.compact('events/orders', { maxAge: 3600 });
+    expect(result.deleted).toBe(6);
+    expect(db.stream.read('events/orders', 'check').length).toBe(4);
+
+    const snap = db.stream.snapshot('events/orders');
+    // 6 events with { i: 0..5 } merged — last write wins
+    expect(snap!.data.i).toBe(5);
+  });
+
+  test('compact keepKey folds duplicates into snapshot, keyed by field', () => {
+    db.push('events/orders', { orderId: 'o1', status: 'pending' });
+    db.push('events/orders', { orderId: 'o2', status: 'pending' });
+    db.push('events/orders', { orderId: 'o1', status: 'completed' });
+    db.push('events/orders', { orderId: 'o2', status: 'shipped' });
+    db.push('events/orders', { orderId: 'o3', status: 'new' });
+
+    const result = db.stream.compact('events/orders', { keepKey: 'orderId' });
+    expect(result.deleted).toBe(2); // old o1 + old o2
+
+    // Snapshot keyed by orderId
+    const snap = db.stream.snapshot('events/orders');
+    expect(snap).not.toBeNull();
+    expect((snap!.data['o1'] as any).status).toBe('pending'); // first o1 folded
+    expect((snap!.data['o2'] as any).status).toBe('pending'); // first o2 folded
+
+    // 3 events remain live
+    const remaining = db.stream.read('events/orders', 'check');
+    expect(remaining.length).toBe(3);
+  });
+
+  test('materialize merges snapshot + live events', () => {
+    db.push('events/orders', { orderId: 'o1', status: 'pending' });
+    db.push('events/orders', { orderId: 'o2', status: 'pending' });
+    db.push('events/orders', { orderId: 'o1', status: 'completed' });
+
+    db.stream.compact('events/orders', { keepKey: 'orderId' });
+
+    // Add more events on top
+    db.push('events/orders', { orderId: 'o2', status: 'shipped' });
+
+    const view = db.stream.materialize('events/orders', { keepKey: 'orderId' });
+    expect((view['o1'] as any).status).toBe('completed'); // from live event (survived compact)
+    expect((view['o2'] as any).status).toBe('shipped');   // from new event on top
+  });
+
+  test('compact respects consumer group offsets', () => {
+    const keys: string[] = [];
+    for (let i = 0; i < 10; i++) {
+      keys.push(db.push('events/orders', { i }));
+    }
+
+    db.stream.ack('events/orders', 'g1', keys[3]);
+
+    const result = db.stream.compact('events/orders', { maxCount: 2 });
+    // Only events 0-3 are acked, so only those can be folded
+    expect(result.deleted).toBe(4);
+    expect(db.stream.read('events/orders', 'g1').length).toBe(6);
+
+    // Snapshot is merged state of 4 folded events { i: 0..3 }
+    expect(db.stream.snapshot('events/orders')!.data.i).toBe(3);
+  });
+
+  test('auto-compact runs on sweep', () => {
+    const compactDb = new BodDB({
+      path: ':memory:',
+      sweepInterval: 0,
+      compact: { 'events/orders': { maxCount: 3 } },
+    });
+
+    for (let i = 0; i < 10; i++) {
+      compactDb.push('events/orders', { i });
+    }
+
+    compactDb.sweep();
+
+    const remaining = compactDb.stream.read('events/orders', 'check');
+    expect(remaining.length).toBe(3);
+    expect((remaining[0].data as { i: number }).i).toBe(7);
+
+    const snap = compactDb.stream.snapshot('events/orders');
+    // Events i=0..6 merged, last write wins → i=6
+    expect(snap!.data.i).toBe(6);
+
+    compactDb.close();
+  });
+
+  test('incremental compaction merges into existing snapshot', () => {
+    for (let i = 0; i < 10; i++) {
+      db.push('events/orders', { i });
+    }
+
+    // First compact: keep 5 → folds events i=0..4 into snapshot
+    db.stream.compact('events/orders', { maxCount: 5 });
+    expect(db.stream.snapshot('events/orders')!.data.i).toBe(4);
+
+    // Push 5 more
+    for (let i = 10; i < 15; i++) {
+      db.push('events/orders', { i });
+    }
+
+    // Second compact: keep 3 → folds more into snapshot
+    db.stream.compact('events/orders', { maxCount: 3 });
+    const snap = db.stream.snapshot('events/orders');
+    // All merged: last folded event wins → i=11 (events 0..11 folded, 12-14 remain)
+    expect(snap!.data.i).toBe(11);
+    expect(db.stream.read('events/orders', 'check').length).toBe(3);
+  });
+});
+
+describe('Idempotent push', () => {
+  let db: BodDB;
+
+  beforeEach(() => {
+    db = new BodDB({ path: ':memory:', sweepInterval: 0 });
+  });
+
+  afterEach(() => {
+    db.close();
+  });
+
+  test('same idempotencyKey returns same key, no duplicate', () => {
+    const key1 = db.push('events/orders', { order: 1 }, { idempotencyKey: 'idem-1' });
+    const key2 = db.push('events/orders', { order: 2 }, { idempotencyKey: 'idem-1' });
+
+    expect(key1).toBe(key2);
+
+    // Only one row
+    const all = db.stream.read('events/orders', 'check');
+    expect(all.length).toBe(1);
+    expect((all[0].data as { order: number }).order).toBe(1);
+  });
+
+  test('different idempotencyKeys create separate rows', () => {
+    db.push('events/orders', { a: 1 }, { idempotencyKey: 'k1' });
+    db.push('events/orders', { a: 2 }, { idempotencyKey: 'k2' });
+
+    const all = db.stream.read('events/orders', 'check');
+    expect(all.length).toBe(2);
+  });
+});
+
+describe('Stream over transport', () => {
+  let db: BodDB;
+  let client: BodClient;
+
+  beforeEach(async () => {
+    db = new BodDB({ path: ':memory:', sweepInterval: 0, port: 0 });
+    const server = db.serve();
+    client = new BodClient({ url: `ws://localhost:${server.port}` });
+    await client.connect();
+  });
+
+  afterEach(() => {
+    client.disconnect();
+    db.close();
+  });
+
+  test('push 100 events, stream-read gets all', async () => {
+    for (let i = 0; i < 100; i++) {
+      await client.push('events/orders', { i });
+    }
+
+    const reader = client.stream('events/orders', 'billing');
+    const events = await reader.read();
+    expect(events.length).toBe(100);
+    expect(events[0].val()).toEqual({ i: 0 });
+    expect(events[99].val()).toEqual({ i: 99 });
+  });
+
+  test('ack 50, read gets remaining 50', async () => {
+    const keys: string[] = [];
+    for (let i = 0; i < 100; i++) {
+      keys.push(await client.push('events/orders', { i }));
+    }
+
+    const reader = client.stream('events/orders', 'billing');
+    await reader.ack(keys[49]);
+
+    const events = await reader.read();
+    expect(events.length).toBe(50);
+    expect(events[0].val()).toEqual({ i: 50 });
+  });
+
+  test('stream-sub receives live events', async () => {
+    const reader = client.stream('events/orders', 'billing');
+    const received: Array<{ key: string; val: () => unknown }> = [];
+
+    const unsub = reader.on((events) => {
+      received.push(...events);
+    });
+
+    // Give time for sub to register
+    await new Promise(r => setTimeout(r, 50));
+
+    // Push events server-side
+    db.push('events/orders', { live: 1 });
+    db.push('events/orders', { live: 2 });
+
+    await new Promise(r => setTimeout(r, 50));
+
+    expect(received.length).toBe(2);
+    expect(received[0].val()).toEqual({ live: 1 });
+
+    unsub();
+  });
+
+  test('idempotent push over transport', async () => {
+    const key1 = await client.push('events/orders', { a: 1 }, { idempotencyKey: 'dedup-1' });
+    const key2 = await client.push('events/orders', { a: 2 }, { idempotencyKey: 'dedup-1' });
+
+    expect(key1).toBe(key2);
+
+    const events = await client.stream('events/orders', 'check').read();
+    expect(events.length).toBe(1);
+  });
+
+  test('two groups independent offsets over transport', async () => {
+    for (let i = 0; i < 10; i++) {
+      await client.push('events/orders', { i });
+    }
+
+    const r1 = client.stream('events/orders', 'g1');
+    const r2 = client.stream('events/orders', 'g2');
+
+    const e1 = await r1.read();
+    expect(e1.length).toBe(10);
+
+    // Ack all for g1
+    await r1.ack(e1[9].key);
+
+    const e1After = await r1.read();
+    const e2After = await r2.read();
+    expect(e1After.length).toBe(0);
+    expect(e2After.length).toBe(10);
+  });
+});

package/tests/stress.test.ts

@@ -0,0 +1,202 @@
+import { describe, test, expect } from 'bun:test';
+import { BodDB } from '../src/server/BodDB.ts';
+
+function makeDB() { return new BodDB({ path: ':memory:' }); }
+
+describe('Stress: Sequential Writes', () => {
+  test('1000 sequential set ops complete and are readable', () => {
+    const db = makeDB();
+    const N = 1000;
+    for (let i = 0; i < N; i++) db.set(`seq/item${i}`, { v: i, s: `str${i}` });
+    expect(db.get('seq/item0')).toEqual({ v: 0, s: 'str0' });
+    expect(db.get(`seq/item${N - 1}`)).toEqual({ v: N - 1, s: `str${N - 1}` });
+    db.close();
+  });
+
+  test('throughput: 5000 writes finish in < 5s', () => {
+    const db = makeDB();
+    const N = 5000;
+    const t0 = performance.now();
+    for (let i = 0; i < N; i++) db.set(`tput/k${i}`, i);
+    const elapsed = performance.now() - t0;
+    expect(elapsed).toBeLessThan(5000);
+    console.log(`  5000 writes: ${elapsed.toFixed(0)}ms (${Math.round(N / (elapsed / 1000)).toLocaleString()} ops/s)`);
+    db.close();
+  });
+});
+
+describe('Stress: Burst Reads', () => {
+  test('1000 reads of same path return consistent result', () => {
+    const db = makeDB();
+    db.set('read/target', { hello: 'world', n: 42 });
+    for (let i = 0; i < 1000; i++) {
+      expect(db.get('read/target')).toEqual({ hello: 'world', n: 42 });
+    }
+    db.close();
+  });
+
+  test('throughput: 10000 reads finish in < 2s', () => {
+    const db = makeDB();
+    db.set('read/x', { a: 1, b: 2, c: 3 });
+    const N = 10000;
+    const t0 = performance.now();
+    for (let i = 0; i < N; i++) db.get('read/x');
+    const elapsed = performance.now() - t0;
+    expect(elapsed).toBeLessThan(2000);
+    console.log(`  10000 reads: ${elapsed.toFixed(0)}ms (${Math.round(N / (elapsed / 1000)).toLocaleString()} ops/s)`);
+    db.close();
+  });
+});
+
+describe('Stress: Mixed Read/Write', () => {
+  test('interleaved reads and writes produce correct results', () => {
+    const db = makeDB();
+    const N = 500;
+    for (let i = 0; i < N; i++) {
+      db.set(`mixed/k${i % 50}`, { v: i });
+      expect((db.get(`mixed/k${i % 50}`) as any).v).toBe(i);
+    }
+    db.close();
+  });
+
+  test('throughput: 2000 mixed ops finish in < 3s', () => {
+    const db = makeDB();
+    db.set('mixed/seed', { x: 0 });
+    const N = 2000;
+    const t0 = performance.now();
+    for (let i = 0; i < N; i++) {
+      if (i % 3 === 0) db.set(`mixed/k${i % 100}`, i);
+      else db.get(`mixed/k${i % 100}`);
+    }
+    const elapsed = performance.now() - t0;
+    expect(elapsed).toBeLessThan(3000);
+    console.log(`  2000 mixed ops: ${elapsed.toFixed(0)}ms`);
+    db.close();
+  });
+});
+
+describe('Stress: Bulk Update', () => {
+  test('update with 200 keys is atomic and readable', () => {
+    const db = makeDB();
+    const updates: Record<string, unknown> = {};
+    for (let i = 0; i < 200; i++) updates[`bulk/k${i}`] = { v: i };
+    db.update(updates);
+    for (let i = 0; i < 200; i++) expect((db.get(`bulk/k${i}`) as any).v).toBe(i);
+    db.close();
+  });
+
+  test('20 batches × 100 keys each: all values survive', () => {
+    const db = makeDB();
+    for (let b = 0; b < 20; b++) {
+      const updates: Record<string, unknown> = {};
+      for (let k = 0; k < 100; k++) updates[`batch/k${k}`] = b * 100 + k;
+      db.update(updates);
+    }
+    // last batch wins
+    for (let k = 0; k < 100; k++) expect(db.get(`batch/k${k}`)).toBe(19 * 100 + k);
+    db.close();
+  });
+
+  test('throughput: update 500 keys in < 500ms', () => {
+    const db = makeDB();
+    const updates: Record<string, unknown> = {};
+    for (let i = 0; i < 500; i++) updates[`tput/k${i}`] = { i, ts: Date.now() };
+    const t0 = performance.now();
+    db.update(updates);
+    const elapsed = performance.now() - t0;
+    expect(elapsed).toBeLessThan(500);
+    console.log(`  update(500 keys): ${elapsed.toFixed(1)}ms`);
+    db.close();
+  });
+});
+
+describe('Stress: Query Under Load', () => {
+  test('query filters 1000-record dataset correctly', () => {
+    const db = makeDB();
+    const N = 1000;
+    for (let i = 0; i < N; i++) db.set(`users/u${i}`, { score: i % 100, role: i % 4 === 0 ? 'admin' : 'user' });
+    const admins = db.query('users').where('role', '==', 'admin').get();
+    expect(admins.length).toBe(250);
+    const top = db.query('users').where('score', '>=', 95).order('score', 'desc').limit(10).get();
+    expect(top.length).toBeLessThanOrEqual(10);
+    top.forEach(r => expect(r.score).toBeGreaterThanOrEqual(95));
+    db.close();
+  });
+
+  test('throughput: 50 queries on 500 records in < 2s', () => {
+    const db = makeDB();
+    for (let i = 0; i < 500; i++) db.set(`q/u${i}`, { score: i % 100, role: i % 3 === 0 ? 'admin' : 'user' });
+    const t0 = performance.now();
+    for (let i = 0; i < 50; i++) db.query('q').where('role', '==', 'admin').order('score', 'desc').limit(10).get();
+    const elapsed = performance.now() - t0;
+    expect(elapsed).toBeLessThan(2000);
+    console.log(`  50 queries (500 records): ${elapsed.toFixed(0)}ms (${(elapsed / 50).toFixed(1)}ms/query)`);
+    db.close();
+  });
+});
+
+describe('Stress: Deep Path Writes', () => {
+  test('writes and reads at depth 8 are correct', () => {
+    const db = makeDB();
+    const path = 'a/b/c/d/e/f/g/h';
+    db.set(path, { deep: true, val: 42 });
+    expect(db.get(path)).toEqual({ deep: true, val: 42 });
+    expect(db.get('a/b/c/d/e/f/g')).toEqual({ h: { deep: true, val: 42 } });
+    db.close();
+  });
+
+  test('200 unique deep paths are all accessible', () => {
+    const db = makeDB();
+    const N = 200;
+    for (let i = 0; i < N; i++) {
+      const segs = Array.from({ length: 5 }, (_, d) => `l${d}_${i % (5 + d)}`);
+      db.set('deep/' + segs.join('/'), i);
+    }
+    // spot-check: path for i=0 is consistent
+    const segs0 = Array.from({ length: 5 }, (_, d) => `l${d}_${0 % (5 + d)}`);
+    expect(db.get('deep/' + segs0.join('/'))).toBe(0);
+    db.close();
+  });
+
+  test('throughput: 500 depth-6 writes in < 2s', () => {
+    const db = makeDB();
+    const N = 500;
+    const t0 = performance.now();
+    for (let i = 0; i < N; i++) {
+      const segs = Array.from({ length: 6 }, (_, d) => `n${d}_${i % (8 + d)}`);
+      db.set('dp/' + segs.join('/'), i);
+    }
+    const elapsed = performance.now() - t0;
+    expect(elapsed).toBeLessThan(2000);
+    console.log(`  500 depth-6 writes: ${elapsed.toFixed(0)}ms`);
+    db.close();
+  });
+});
+
+describe('Stress: Subscription Fan-out', () => {
+  test('10 listeners all receive events', async () => {
+    const db = makeDB();
+    const received: number[] = Array(10).fill(0);
+    const unsubs = Array.from({ length: 10 }, (_, i) =>
+      db.on('fan/target', () => { received[i]++; })
+    );
+    db.set('fan/target', { v: 1 });
+    db.set('fan/target', { v: 2 });
+    db.set('fan/target', { v: 3 });
+    await Bun.sleep(20);
+    unsubs.forEach(u => u());
+    received.forEach(c => expect(c).toBeGreaterThanOrEqual(1));
+    db.close();
+  });
+
+  test('100 rapid writes to subscribed path do not drop or error', async () => {
+    const db = makeDB();
+    let count = 0;
+    const unsub = db.on('rapid/path', () => { count++; });
+    for (let i = 0; i < 100; i++) db.set('rapid/path', i);
+    await Bun.sleep(50);
+    unsub();
+    expect(count).toBeGreaterThanOrEqual(1);
+    db.close();
+  });
+});

package/tests/subscriptions.test.ts

@@ -0,0 +1,86 @@
+import { describe, test, expect } from 'bun:test';
+import { BodDB } from '../src/server/BodDB.ts';
+
+describe('Subscriptions', () => {
+  test('fires on exact path write', () => {
+    const db = new BodDB();
+    const events: unknown[] = [];
+    db.on('users/u1', (snap) => events.push(snap.val()));
+    db.set('users/u1', { name: 'Alice' });
+    expect(events).toEqual([{ name: 'Alice' }]);
+    db.close();
+  });
+
+  test('fires on ancestor when child changes', () => {
+    const db = new BodDB();
+    const events: unknown[] = [];
+    db.on('users', (snap) => events.push(snap.val()));
+    db.set('users/u1', { name: 'Alice' });
+    expect(events.length).toBe(1);
+    expect(events[0]).toEqual({ u1: { name: 'Alice' } });
+    db.close();
+  });
+
+  test('unsubscribe stops notifications', () => {
+    const db = new BodDB();
+    const events: unknown[] = [];
+    const off = db.on('users/u1', (snap) => events.push(snap.val()));
+    db.set('users/u1', { name: 'Alice' });
+    off();
+    db.set('users/u1', { name: 'Bob' });
+    expect(events.length).toBe(1);
+    db.close();
+  });
+
+  test('child event: added for new children', () => {
+    const db = new BodDB();
+    const events: Array<{ type: string; key: string }> = [];
+    db.onChild('users', (e) => events.push({ type: e.type, key: e.key }));
+    db.set('users/u1', { name: 'Alice' });
+    db.set('users/u2', { name: 'Bob' });
+    expect(events).toEqual([
+      { type: 'added', key: 'u1' },
+      { type: 'added', key: 'u2' },
+    ]);
+    db.close();
+  });
+
+  test('child event: changed for existing children', () => {
+    const db = new BodDB();
+    db.set('users/u1', { name: 'Alice' });
+    const events: Array<{ type: string; key: string }> = [];
+    db.onChild('users', (e) => events.push({ type: e.type, key: e.key }));
+    db.set('users/u1', { name: 'Bob' });
+    expect(events).toEqual([{ type: 'changed', key: 'u1' }]);
+    db.close();
+  });
+
+  test('child event: removed on delete', () => {
+    const db = new BodDB();
+    db.set('users/u1', { name: 'Alice' });
+    const events: Array<{ type: string; key: string }> = [];
+    db.onChild('users', (e) => events.push({ type: e.type, key: e.key }));
+    db.delete('users/u1');
+    expect(events).toEqual([{ type: 'removed', key: 'u1' }]);
+    db.close();
+  });
+
+  test('delete fires subscription with null', () => {
+    const db = new BodDB();
+    db.set('users/u1', { name: 'Alice' });
+    const events: unknown[] = [];
+    db.on('users/u1', (snap) => events.push(snap.val()));
+    db.delete('users/u1');
+    expect(events[0]).toBeNull();
+    db.close();
+  });
+
+  test('multi-path update fires deduped notifications', () => {
+    const db = new BodDB();
+    const events: string[] = [];
+    db.on('users', () => events.push('users'));
+    db.update({ 'users/u1/name': 'Alice', 'users/u2/name': 'Bob' });
+    expect(events.length).toBe(1);
+    db.close();
+  });
+});