feat: introduce novel hyper-p2p-distributed-event-bus v0.1.0 - first distributed event sourcing + pub/sub primitive with vector clocks, P2P gossip, Hyperbee replay for Bare/Pear. Full code, tests, README, docs/architecture + api with Mermaid, examples. Concurrent workspace README update + roadmap progress. Scanned all modules for Node.js builtins (100% bare-* compliant). Autonomous Holepunch dev run on 2026-05-20.

hyper-p2p-distributed-event-bus/test/test.js

@@ -0,0 +1,107 @@
+const test = require('bare-test')
+const HyperP2PDistributedEventBus = require('../index.js')
+const path = require('bare-path')
+const fs = require('bare-fs/promises')
+const crypto = require('bare-crypto')
+
+test('hyper-p2p-distributed-event-bus - basic lifecycle and publish/subscribe', async (t) => {
+  const bus1 = new HyperP2PDistributedEventBus({ 
+    storageDir: path.join(process.cwd(), 'test-storage-bus1-' + Date.now()),
+    topic: crypto.randomBytes(32)
+  })
+  const bus2 = new HyperP2PDistributedEventBus({ 
+    storageDir: path.join(process.cwd(), 'test-storage-bus2-' + Date.now()),
+    topic: bus1.topic 
+  })
+
+  await bus1.ready()
+  await bus2.ready()
+
+  let received = []
+  const unsub = bus2.subscribe('test-topic', (event) => {
+    received.push(event)
+  })
+
+  const published = await bus1.publish('test-topic', { message: 'hello from p2p', value: 42 })
+
+  // Allow propagation time
+  await new Promise(resolve => setTimeout(resolve, 500))
+
+  t.ok(received.length >= 1, 'should receive at least one event')
+  t.is(received[0].payload.message, 'hello from p2p')
+  t.is(received[0].topic, 'test-topic')
+  t.ok(received[0].id)
+  t.ok(received[0].vectorClock)
+
+  unsub()
+  await bus1.close()
+  await bus2.close()
+
+  // Cleanup storage
+  try { await fs.rm(bus1.storageDir, { recursive: true, force: true }) } catch {}
+  try { await fs.rm(bus2.storageDir, { recursive: true, force: true }) } catch {}
+})
+
+test('hyper-p2p-distributed-event-bus - vector clock and dedup', async (t) => {
+  const bus = new HyperP2PDistributedEventBus({
+    storageDir: path.join(process.cwd(), 'test-storage-vc-' + Date.now())
+  })
+  await bus.ready()
+
+  const e1 = await bus.publish('vc-test', { seq: 1 })
+  const e2 = await bus.publish('vc-test', { seq: 2 })
+
+  t.ok(e1.vectorClock)
+  t.ok(e2.vectorClock)
+  t.is(Object.keys(e1.vectorClock).length > 0, true)
+
+  // Replay test
+  const replayed = await bus.replay('vc-test', { limit: 10 })
+  t.ok(replayed.length >= 2)
+
+  await bus.close()
+  try { await fs.rm(bus.storageDir, { recursive: true, force: true }) } catch {}
+})
+
+test('hyper-p2p-distributed-event-bus - persistence and replay', async (t) => {
+  const storageDir = path.join(process.cwd(), 'test-storage-persist-' + Date.now())
+  const bus = new HyperP2PDistributedEventBus({ storageDir })
+  await bus.ready()
+
+  await bus.publish('persist-topic', { data: 'first' })
+  await bus.publish('persist-topic', { data: 'second' })
+
+  await bus.close()
+
+  // Re-open and replay
+  const bus2 = new HyperP2PDistributedEventBus({ storageDir })
+  await bus2.ready()
+
+  const replayed = await bus2.replay('persist-topic')
+  t.ok(replayed.length >= 2)
+  t.is(replayed[0].payload.data, 'first')
+
+  await bus2.close()
+  try { await fs.rm(storageDir, { recursive: true, force: true }) } catch {}
+})
+
+test('hyper-p2p-distributed-event-bus - filter subscription', async (t) => {
+  const bus = new HyperP2PDistributedEventBus({
+    storageDir: path.join(process.cwd(), 'test-storage-filter-' + Date.now())
+  })
+  await bus.ready()
+
+  let filtered = []
+  bus.subscribe('filtered-topic', (e) => filtered.push(e), { type: 'important' })
+
+  await bus.publish('filtered-topic', { type: 'important', msg: 'yes' })
+  await bus.publish('filtered-topic', { type: 'normal', msg: 'no' })
+
+  await new Promise(r => setTimeout(r, 100))
+
+  t.is(filtered.length, 1)
+  t.is(filtered[0].payload.msg, 'yes')
+
+  await bus.close()
+  try { await fs.rm(bus.storageDir, { recursive: true, force: true }) } catch {}
+})