@dtudury/streamo 1.0.1 → 3.0.0

package/public/streamo/registrySync.test.js

@@ -1,373 +0,0 @@
-import { WebSocketServer } from 'ws'
-import { describe } from './utils/testing.js'
-import { RepoRegistry } from './RepoRegistry.js'
-import { attachStreamSync } from './outletSync.js'
-import { registrySync } from './registrySync.js'
-
-// makeVerifiedWritableStream only rejects invalid SIGNATURE chunks —
-// plain data chunks pass through even with fake keys.  33 bytes = compressed pubkey size.
-const fakeKey = (n = 0) => '02' + n.toString(16).padStart(2, '0').repeat(32)  // 66-char hex
-
-/** Wait up to `ms` ms for `fn()` to return truthy, polling every 10 ms. */
-function waitFor (fn, ms = 500) {
-  return new Promise((resolve, reject) => {
-    const start = Date.now()
-    const poll = () => {
-      const v = fn()
-      if (v) return resolve(v)
-      if (Date.now() - start > ms) return reject(new Error('waitFor timeout'))
-      setTimeout(poll, 10)
-    }
-    poll()
-  })
-}
-
-/** Start a WebSocketServer on a random port backed by a registry. */
-function startServer (registry) {
-  return new Promise((resolve, reject) => {
-    const wss = new WebSocketServer({ port: 0 })
-    wss.on('listening', () => {
-      const { port } = wss.address()
-      attachStreamSync(wss, registry, 'test-outlet')
-      resolve({ wss, port })
-    })
-    wss.on('error', reject)
-  })
-}
-
-describe(import.meta.url, ({ test }) => {
-  test('onOpen fires after registry.open resolves', async ({ assert }) => {
-    const registry = new RepoRegistry()
-    const calls = []
-    registry.onOpen((key, repo) => calls.push({ key, repo }))
-    const repo = await registry.open('abc')
-    assert.equal(calls.length, 1)
-    assert.equal(calls[0].key, 'abc')
-    assert.ok(calls[0].repo === repo)
-  })
-
-  test('offOpen removes the callback', async ({ assert }) => {
-    const registry = new RepoRegistry()
-    let count = 0
-    const cb = () => count++
-    registry.onOpen(cb)
-    await registry.open('x')
-    registry.offOpen(cb)
-    await registry.open('y')
-    assert.equal(count, 1)
-  })
-
-  test('onOpen not called for already-open key (concurrent open)', async ({ assert }) => {
-    const registry = new RepoRegistry()
-    let count = 0
-    registry.onOpen(() => count++)
-    await Promise.all([registry.open('k'), registry.open('k'), registry.open('k')])
-    assert.equal(count, 1)
-  })
-
-  test('two registries sync an existing repo via registrySync', async ({ assert }) => {
-    const serverRegistry = new RepoRegistry()
-    const { wss, port } = await startServer(serverRegistry)
-
-    const keyHex = fakeKey(1)
-    const serverRepo = await serverRegistry.open(keyHex)
-    serverRepo.set({ hello: 'world' })
-
-    const clientRegistry = new RepoRegistry()
-    const { ws } = await registrySync(clientRegistry, 'localhost', port, { filter: k => k === keyHex })
-
-    await waitFor(() => clientRegistry.get(keyHex)?.get('hello') === 'world')
-    assert.equal(clientRegistry.get(keyHex).get('hello'), 'world')
-
-    ws.close()
-    await new Promise(r => wss.close(r))
-  })
-
-  test('changes on server after connect are synced to client', async ({ assert }) => {
-    const serverRegistry = new RepoRegistry()
-    const { wss, port } = await startServer(serverRegistry)
-
-    const keyHex = fakeKey(2)
-    const serverRepo = await serverRegistry.open(keyHex)
-    serverRepo.set({ v: 1 })
-
-    const clientRegistry = new RepoRegistry()
-    const { ws } = await registrySync(clientRegistry, 'localhost', port, { filter: k => k === keyHex })
-
-    await waitFor(() => clientRegistry.get(keyHex)?.get('v') === 1)
-
-    serverRepo.set({ v: 2 })
-    await waitFor(() => clientRegistry.get(keyHex)?.get('v') === 2)
-    assert.equal(clientRegistry.get(keyHex).get('v'), 2)
-
-    ws.close()
-    await new Promise(r => wss.close(r))
-  })
-
-  test('newly opened server repos are announced and synced', async ({ assert }) => {
-    const serverRegistry = new RepoRegistry()
-    const { wss, port } = await startServer(serverRegistry)
-
-    const keyHex = fakeKey(3)
-    const clientRegistry = new RepoRegistry()
-    const { ws } = await registrySync(clientRegistry, 'localhost', port)
-
-    const serverRepo = await serverRegistry.open(keyHex)
-    serverRepo.set({ late: true })
-
-    await waitFor(() => clientRegistry.get(keyHex)?.get('late') === true)
-    assert.equal(clientRegistry.get(keyHex).get('late'), true)
-
-    ws.close()
-    await new Promise(r => wss.close(r))
-  })
-
-  test('filter prevents unwanted repos from syncing', async ({ assert }) => {
-    const serverRegistry = new RepoRegistry()
-    const { wss, port } = await startServer(serverRegistry)
-
-    const keyA = fakeKey(4)
-    const keyB = fakeKey(5)
-
-    const repoA = await serverRegistry.open(keyA)
-    repoA.set({ name: 'a' })
-    const repoB = await serverRegistry.open(keyB)
-    repoB.set({ name: 'b' })
-
-    const clientRegistry = new RepoRegistry()
-    const { ws } = await registrySync(clientRegistry, 'localhost', port, { filter: k => k === keyA })
-
-    await waitFor(() => clientRegistry.get(keyA)?.get('name') === 'a')
-    assert.equal(clientRegistry.get(keyA).get('name'), 'a')
-
-    await new Promise(r => setTimeout(r, 100))
-    assert.equal(clientRegistry.get(keyB), undefined, 'keyB was filtered out')
-
-    ws.close()
-    await new Promise(r => wss.close(r))
-  })
-
-  test('two peers with different repos each sync both after connecting', async ({ assert }) => {
-    const registryA = new RepoRegistry()
-    const registryB = new RepoRegistry()
-
-    const keyA = fakeKey(6)
-    const keyB = fakeKey(7)
-
-    const repoA = await registryA.open(keyA)
-    repoA.set({ owner: 'A' })
-    const repoB = await registryB.open(keyB)
-    repoB.set({ owner: 'B' })
-
-    const { wss, port } = await startServer(registryA)
-    const { ws } = await registrySync(registryB, 'localhost', port)
-
-    await waitFor(() => registryA.get(keyB)?.get('owner') === 'B')
-    await waitFor(() => registryB.get(keyA)?.get('owner') === 'A')
-
-    assert.equal(registryA.get(keyB).get('owner'), 'B')
-    assert.equal(registryB.get(keyA).get('owner'), 'A')
-
-    ws.close()
-    await new Promise(r => wss.close(r))
-  })
-
-  test('follow: auto-subscribes to repos referenced in a synced repo\'s value', async ({ assert }) => {
-    // Simulates a chat app: rootRepo lists participant keys; client follows the
-    // root and should automatically discover and sync all participant repos.
-    const serverRegistry = new RepoRegistry()
-    const { wss, port } = await startServer(serverRegistry)
-
-    const rootKey = fakeKey(10)
-    const aliceKey = fakeKey(11)
-    const bobKey = fakeKey(12)
-
-    const rootRepo = await serverRegistry.open(rootKey)
-    const aliceRepo = await serverRegistry.open(aliceKey)
-    const bobRepo = await serverRegistry.open(bobKey)
-
-    aliceRepo.set({ name: 'alice', message: 'hello' })
-    bobRepo.set({ name: 'bob', message: 'hey' })
-    rootRepo.set({ members: [aliceKey, bobKey] })
-
-    const clientRegistry = new RepoRegistry()
-    const { ws } = await registrySync(clientRegistry, 'localhost', port, {
-      filter: k => k === rootKey,  // only explicitly subscribe to root
-      follow: (keyHex, repo, subscribe) => {
-        // extract participant keys from the chat repo
-        for (const memberKey of repo.get('members') ?? []) subscribe(memberKey)
-      }
-    })
-
-    // Root syncs via filter; participants sync via follow
-    await waitFor(() => clientRegistry.get(aliceKey)?.get('name') === 'alice')
-    await waitFor(() => clientRegistry.get(bobKey)?.get('name') === 'bob')
-
-    assert.equal(clientRegistry.get(aliceKey).get('name'), 'alice')
-    assert.equal(clientRegistry.get(bobKey).get('name'), 'bob')
-
-    ws.close()
-    await new Promise(r => wss.close(r))
-  })
-
-  test('follow: re-runs when a repo changes and discovers newly added refs', async ({ assert }) => {
-    const serverRegistry = new RepoRegistry()
-    const { wss, port } = await startServer(serverRegistry)
-
-    const rootKey = fakeKey(13)
-    const carolKey = fakeKey(14)
-
-    const rootRepo = await serverRegistry.open(rootKey)
-    rootRepo.set({ members: [] })  // starts empty
-
-    const clientRegistry = new RepoRegistry()
-    const { ws } = await registrySync(clientRegistry, 'localhost', port, {
-      filter: k => k === rootKey,
-      follow: (keyHex, repo, subscribe) => {
-        for (const memberKey of repo.get('members') ?? []) subscribe(memberKey)
-      }
-    })
-
-    await waitFor(() => clientRegistry.get(rootKey)?.get('members') !== undefined)
-
-    // Carol joins: her repo is added to the server, root is updated to list her
-    const carolRepo = await serverRegistry.open(carolKey)
-    carolRepo.set({ name: 'carol' })
-    rootRepo.set({ members: [carolKey] })
-
-    await waitFor(() => clientRegistry.get(carolKey)?.get('name') === 'carol')
-    assert.equal(clientRegistry.get(carolKey).get('name'), 'carol')
-
-    ws.close()
-    await new Promise(r => wss.close(r))
-  })
-
-  test('announce is routed to interested peers', async ({ assert }) => {
-    const { wss, port } = await startServer(new RepoRegistry())
-    const topic = fakeKey(20)
-    const announced = fakeKey(21)
-
-    const received = []
-    const sessionA = await registrySync(new RepoRegistry(), 'localhost', port, {
-      onAnnounce: (key, t) => received.push({ key, topic: t })
-    })
-    sessionA.interest(topic)
-
-    const sessionB = await registrySync(new RepoRegistry(), 'localhost', port)
-
-    // Give the interest message time to reach the server
-    await new Promise(r => setTimeout(r, 50))
-    sessionB.announce(announced, topic)
-
-    await waitFor(() => received.length === 1)
-    assert.equal(received[0].key, announced)
-    assert.equal(received[0].topic, topic)
-
-    sessionA.close()
-    sessionB.close()
-    await new Promise(r => wss.close(r))
-  })
-
-  test('announce is not received without interest', async ({ assert }) => {
-    const { wss, port } = await startServer(new RepoRegistry())
-    const topic = fakeKey(22)
-    const announced = fakeKey(23)
-
-    const received = []
-    const sessionA = await registrySync(new RepoRegistry(), 'localhost', port, {
-      onAnnounce: (key) => received.push(key)
-    })
-    // sessionA does NOT call interest(topic)
-
-    const sessionB = await registrySync(new RepoRegistry(), 'localhost', port)
-    await new Promise(r => setTimeout(r, 50))
-    sessionB.announce(announced, topic)
-
-    await new Promise(r => setTimeout(r, 100))
-    assert.equal(received.length, 0, 'no announcements without interest')
-
-    sessionA.close()
-    sessionB.close()
-    await new Promise(r => wss.close(r))
-  })
-
-  test('announce reaches multiple interested peers', async ({ assert }) => {
-    const { wss, port } = await startServer(new RepoRegistry())
-    const topic = fakeKey(24)
-    const announced = fakeKey(25)
-
-    const receivedA = [], receivedB = []
-    const sessionA = await registrySync(new RepoRegistry(), 'localhost', port, {
-      onAnnounce: (key) => receivedA.push(key)
-    })
-    const sessionB = await registrySync(new RepoRegistry(), 'localhost', port, {
-      onAnnounce: (key) => receivedB.push(key)
-    })
-    sessionA.interest(topic)
-    sessionB.interest(topic)
-
-    const sessionC = await registrySync(new RepoRegistry(), 'localhost', port)
-    await new Promise(r => setTimeout(r, 50))
-    sessionC.announce(announced, topic)
-
-    await waitFor(() => receivedA.length === 1 && receivedB.length === 1)
-    assert.equal(receivedA[0], announced)
-    assert.equal(receivedB[0], announced)
-
-    sessionA.close()
-    sessionB.close()
-    sessionC.close()
-    await new Promise(r => wss.close(r))
-  })
-
-  test('announce is not echoed back to the sender', async ({ assert }) => {
-    const { wss, port } = await startServer(new RepoRegistry())
-    const topic = fakeKey(26)
-    const announced = fakeKey(27)
-
-    const received = []
-    const session = await registrySync(new RepoRegistry(), 'localhost', port, {
-      onAnnounce: (key) => received.push(key)
-    })
-    session.interest(topic)
-
-    await new Promise(r => setTimeout(r, 50))
-    session.announce(announced, topic)  // sender declares interest and announces
-
-    await new Promise(r => setTimeout(r, 100))
-    assert.equal(received.length, 0, 'sender should not receive its own announcement')
-
-    session.close()
-    await new Promise(r => wss.close(r))
-  })
-
-  test('after disconnect, interest is cleaned up and announcements stop', async ({ assert }) => {
-    const { wss, port } = await startServer(new RepoRegistry())
-    const topic = fakeKey(28)
-    const announced = fakeKey(29)
-
-    const received = []
-    const sessionA = await registrySync(new RepoRegistry(), 'localhost', port, {
-      onAnnounce: (key) => received.push(key)
-    })
-    sessionA.interest(topic)
-
-    const sessionB = await registrySync(new RepoRegistry(), 'localhost', port)
-
-    // Confirm routing works before disconnect
-    await new Promise(r => setTimeout(r, 50))
-    sessionB.announce(announced, topic)
-    await waitFor(() => received.length === 1)
-
-    // Disconnect A, then announce again
-    sessionA.close()
-    await new Promise(r => setTimeout(r, 50))
-    sessionB.announce(announced, topic)
-
-    await new Promise(r => setTimeout(r, 100))
-    assert.equal(received.length, 1, 'no more announcements after disconnect')
-
-    sessionB.close()
-    await new Promise(r => wss.close(r))
-  })
-})

package/public/streamo/sync.test.js

@@ -1,144 +0,0 @@
-import { describe } from './utils/testing.js'
-import { RepoRegistry as StreamRegistry } from './RepoRegistry.js'
-import { outletSync } from './outletSync.js'
-import { originSync } from './originSync.js'
-
-const KEY = 'aabbccddeeff0011'
-
-// Wait until predicate(stream) returns true.
-// Accesses stream.byteLength explicitly so the watcher re-runs on every append,
-// regardless of whether the predicate itself touches a reactive path.
-function waitFor (stream, predicate, timeout = 2000) {
-  return new Promise((resolve, reject) => {
-    const t = setTimeout(() => reject(new Error('timeout')), timeout)
-    let done = false
-    stream.watch('waitFor', () => {
-      if (!done && predicate(stream)) {
-        done = true
-        clearTimeout(t)
-        resolve()
-      }
-    })
-  })
-}
-
-describe(import.meta.url, ({ test }) => {
-  test('outlet syncs existing stream data to a new origin', async ({ assert }) => {
-    const serverRegistry = new StreamRegistry()
-    const serverStream = await serverRegistry.open(KEY)
-    serverStream.set({ hello: 'world' })
-
-    const wss = outletSync(serverRegistry, 0)
-    await new Promise(resolve => wss.on('listening', resolve))
-    const { port } = wss.address()
-
-    const clientRegistry = new StreamRegistry()
-    const clientStream = await clientRegistry.open(KEY)
-    const ws = await originSync(clientStream, KEY, 'localhost', port)
-
-    await waitFor(clientStream, s => s.get('hello') === 'world')
-    assert.equal(clientStream.get('hello'), 'world', 'client received server data')
-
-    ws.close()
-    for (const c of wss.clients) c.terminate()
-    wss.close()
-  })
-
-  test('origin syncs local data up to the outlet', async ({ assert }) => {
-    const serverRegistry = new StreamRegistry()
-    const wss = outletSync(serverRegistry, 0)
-    await new Promise(resolve => wss.on('listening', resolve))
-    const { port } = wss.address()
-
-    const clientRegistry = new StreamRegistry()
-    const clientStream = await clientRegistry.open(KEY)
-    clientStream.set({ from: 'client' })
-
-    const ws = await originSync(clientStream, KEY, 'localhost', port)
-    const serverStream = await serverRegistry.open(KEY)
-
-    await waitFor(serverStream, s => s.get('from') === 'client')
-    assert.equal(serverStream.get('from'), 'client', 'server received client data')
-
-    ws.close()
-    for (const c of wss.clients) c.terminate()
-    wss.close()
-  })
-
-  test('two origins converge on the same byte stream', async ({ assert }) => {
-    const serverRegistry = new StreamRegistry()
-    const wss = outletSync(serverRegistry, 0)
-    await new Promise(resolve => wss.on('listening', resolve))
-    const { port } = wss.address()
-
-    const r1 = new StreamRegistry()
-    const r2 = new StreamRegistry()
-    const s1 = await r1.open(KEY)
-    const s2 = await r2.open(KEY)
-
-    s1.set({ x: 1 })
-    s2.set({ x: 2 })
-
-    // NOTE: these are bare Streamos, not Repos — no commit records, no parent
-    // pointers.  The two streams have conflicting chunks at the same byte
-    // offsets; both arrive at the server and each other via dedup-append.
-    // byteLength convergence is all we can assert here: the merged stream
-    // contains all unique chunks from both writers but the second writer's
-    // value address is no longer valid in the merged layout.  This is a known
-    // limitation; see ROADMAP "multi-device write conflict detection".
-    const ws1 = await originSync(s1, KEY, 'localhost', port)
-    const ws2 = await originSync(s2, KEY, 'localhost', port)
-
-    const serverStream = await serverRegistry.open(KEY)
-    await waitFor(serverStream, s => s.byteLength >= s1.byteLength && s.byteLength >= s2.byteLength)
-    await waitFor(s1, s => s.byteLength >= serverStream.byteLength)
-    await waitFor(s2, s => s.byteLength >= serverStream.byteLength)
-
-    assert.equal(s1.byteLength, s2.byteLength, 'both clients converged to same byteLength')
-    assert.equal(s1.byteLength, serverStream.byteLength, 'clients match server')
-
-    ws1.close(); ws2.close()
-    for (const c of wss.clients) c.terminate()
-    wss.close()
-  })
-
-  test('relay forwards data between server and client without writing its own commits', async ({ assert }) => {
-    // Server
-    const serverRegistry = new StreamRegistry()
-    const serverStream = await serverRegistry.open(KEY)
-    serverStream.set({ hello: 'from-server' })
-    const serverWss = outletSync(serverRegistry, 0)
-    await new Promise(resolve => serverWss.on('listening', resolve))
-    const serverPort = serverWss.address().port
-
-    // Relay: originSync upstream to server, outletSync downstream for clients.
-    // The relay never calls set() or commit() — it only accumulates and re-serves
-    // the byte stream it receives.
-    const relayRegistry = new StreamRegistry()
-    const relayStream = await relayRegistry.open(KEY)
-    await originSync(relayStream, KEY, 'localhost', serverPort)
-    const relayWss = outletSync(relayRegistry, 0)
-    await new Promise(resolve => relayWss.on('listening', resolve))
-    const relayPort = relayWss.address().port
-
-    // Client connects to relay only — no direct server connection
-    const clientRegistry = new StreamRegistry()
-    const clientStream = await clientRegistry.open(KEY)
-    const clientWs = await originSync(clientStream, KEY, 'localhost', relayPort)
-
-    // Server data reaches client via relay
-    await waitFor(clientStream, s => s.get('hello') === 'from-server')
-    assert.equal(clientStream.get('hello'), 'from-server', 'relay forwarded server data to client')
-
-    // Client data propagates back through relay to server
-    clientStream.set({ hello: 'from-client' })
-    await waitFor(serverStream, s => s.get('hello') === 'from-client')
-    assert.equal(serverStream.get('hello'), 'from-client', 'relay forwarded client data to server')
-
-    clientWs.close()
-    for (const c of relayWss.clients) c.terminate()
-    relayWss.close()
-    for (const c of serverWss.clients) c.terminate()
-    serverWss.close()
-  })
-})

package/public/streamo/utils/mockDOM.js

@@ -1,113 +0,0 @@
-/**
- * Minimal DOM mock for testing mount() in Node.
- *
- * Implements only the subset of DOM APIs that hx.js mount() actually calls:
- *   - createElement / createElementNS / createTextNode / createComment / createDocumentFragment
- *   - appendChild, remove, before, nextSibling, childNodes
- *   - setAttribute, getAttribute, removeAttribute, toggleAttribute
- *   - textContent (read)
- */
-
-class MockNode {
-  #children = []
-  #parent = null
-
-  constructor (nodeType) {
-    this.nodeType = nodeType
-  }
-
-  get childNodes () { return [...this.#children] }
-  get parentNode () { return this.#parent }
-
-  get textContent () {
-    return this.#children.map(c => c.textContent).join('')
-  }
-
-  get nextSibling () {
-    if (!this.#parent) return null
-    const sibs = this.#parent.#children
-    return sibs[sibs.indexOf(this) + 1] ?? null
-  }
-
-  appendChild (child) {
-    if (child.#parent) child.remove()
-    child.#parent = this
-    this.#children.push(child)
-    return child
-  }
-
-  remove () {
-    if (!this.#parent) return
-    this.#parent.#children = this.#parent.#children.filter(c => c !== this)
-    this.#parent = null
-  }
-
-  before (...nodes) {
-    if (!this.#parent) return
-    const i = this.#parent.#children.indexOf(this)
-    const toInsert = []
-    for (const n of nodes) {
-      if (n.nodeType === 11) { // DocumentFragment
-        const cs = [...n.#children]
-        n.#children = []
-        cs.forEach(c => { c.#parent = this.#parent })
-        toInsert.push(...cs)
-      } else {
-        if (n.#parent) n.remove()
-        n.#parent = this.#parent
-        toInsert.push(n)
-      }
-    }
-    this.#parent.#children.splice(i, 0, ...toInsert)
-  }
-}
-
-class MockElement extends MockNode {
-  #attrs = {}
-
-  constructor (tag) {
-    super(1)
-    this.tag = tag
-  }
-
-  setAttribute (name, val) { this.#attrs[name] = String(val) }
-  getAttribute (name) { return this.#attrs[name] ?? null }
-  removeAttribute (name) { delete this.#attrs[name] }
-  toggleAttribute (name, force) {
-    if (force) this.#attrs[name] = ''
-    else delete this.#attrs[name]
-  }
-  addEventListener () {}
-}
-
-class MockText extends MockNode {
-  constructor (value) {
-    super(3)
-    this.nodeValue = value
-  }
-
-  get textContent () { return this.nodeValue }
-}
-
-class MockComment extends MockNode {
-  constructor (value) {
-    super(8)
-    this.nodeValue = value
-  }
-
-  get textContent () { return '' }
-}
-
-class MockFragment extends MockNode {
-  constructor () { super(11) }
-}
-
-export const mockDocument = {
-  createElement: tag => new MockElement(tag),
-  createElementNS: (_ns, tag) => new MockElement(tag),
-  createTextNode: text => new MockText(text),
-  createComment: text => new MockComment(text),
-  createDocumentFragment: () => new MockFragment()
-}
-
-export { MockNode }