orez 0.0.49 → 0.0.51

package/src/replication/change-tracker.test.ts

@@ -3,6 +3,8 @@ import { describe, it, expect, beforeEach, afterEach } from 'vitest'
 
 import {
   installChangeTracking,
+  installTriggersOnShardTables,
+  purgeConsumedChanges,
   getChangesSince,
   getCurrentWatermark,
 } from './change-tracker'
@@ -184,3 +186,115 @@ describe('change-tracker', () => {
     expect(special[0].row_data).toMatchObject({ val: 'works' })
   })
 })
+
+describe('shard table tracking', () => {
+  let db: PGlite
+
+  beforeEach(async () => {
+    db = new PGlite()
+    await db.waitReady
+    await installChangeTracking(db)
+  })
+
+  afterEach(async () => {
+    await db.close()
+  })
+
+  it('only tracks clients table in shard schemas, not replicas/mutations', async () => {
+    // zero-cache creates shard schemas like chat_0 with clients, replicas, mutations.
+    // only clients needs tracking — replicas/mutations changes crash zero-cache
+    // with "Unknown table chat_0.replicas" because they aren't in zero's schema.
+    await db.exec(`
+      CREATE SCHEMA chat_0;
+      CREATE TABLE chat_0.clients (
+        "clientGroupID" TEXT NOT NULL,
+        "clientID" TEXT NOT NULL,
+        "lastMutationID" BIGINT,
+        "userID" TEXT,
+        PRIMARY KEY ("clientGroupID", "clientID")
+      );
+      CREATE TABLE chat_0.replicas (
+        id TEXT PRIMARY KEY,
+        version TEXT,
+        cookie TEXT
+      );
+      CREATE TABLE chat_0.mutations (
+        id TEXT PRIMARY KEY,
+        "clientID" TEXT,
+        name TEXT,
+        args JSONB
+      );
+    `)
+
+    await installTriggersOnShardTables(db)
+
+    // insert into all three tables
+    await db.exec(
+      `INSERT INTO chat_0.clients ("clientGroupID", "clientID", "lastMutationID") VALUES ('cg1', 'c1', 1)`
+    )
+    await db.exec(`INSERT INTO chat_0.replicas (id, version) VALUES ('r1', 'v1')`)
+    await db.exec(
+      `INSERT INTO chat_0.mutations (id, "clientID", name) VALUES ('m1', 'c1', 'sendMessage')`
+    )
+
+    const changes = await getChangesSince(db, 0)
+    const tables = changes.map((c) => c.table_name)
+
+    // only clients should be tracked
+    expect(tables).toContain('chat_0.clients')
+    expect(tables).not.toContain('chat_0.replicas')
+    expect(tables).not.toContain('chat_0.mutations')
+  })
+
+  it('purges consumed changes to prevent OOM', async () => {
+    // _zero_changes accumulates forever in 0.0.37. with wasm pglite,
+    // this eventually causes OOM. we need a purge mechanism.
+    await db.exec(`
+      CREATE TABLE public.items (id SERIAL PRIMARY KEY, val TEXT)
+    `)
+    await installChangeTracking(db)
+
+    // insert some data
+    for (let i = 0; i < 10; i++) {
+      await db.exec(`INSERT INTO public.items (val) VALUES ('item${i}')`)
+    }
+
+    const changes = await getChangesSince(db, 0)
+    expect(changes).toHaveLength(10)
+    const lastWatermark = changes[changes.length - 1].watermark
+
+    // purge consumed changes up to the watermark we've processed
+    await purgeConsumedChanges(db, lastWatermark)
+
+    // after purge, no changes before that watermark should remain
+    const remaining = await getChangesSince(db, 0)
+    expect(remaining).toHaveLength(0)
+  })
+
+  it('tracks tables created after initial installChangeTracking', async () => {
+    // simulate zero-cache creating shard schema AFTER replication starts.
+    // in production, zero-cache creates chat_0 schema + clients table
+    // after the replication connection is already established.
+    // the change tracker must pick up these new tables.
+    await db.exec(`
+      CREATE SCHEMA chat_0;
+      CREATE TABLE chat_0.clients (
+        "clientGroupID" TEXT NOT NULL,
+        "clientID" TEXT NOT NULL,
+        "lastMutationID" BIGINT,
+        PRIMARY KEY ("clientGroupID", "clientID")
+      );
+    `)
+
+    // re-running installTriggersOnShardTables should pick up new tables
+    await installTriggersOnShardTables(db)
+
+    await db.exec(
+      `INSERT INTO chat_0.clients ("clientGroupID", "clientID", "lastMutationID") VALUES ('cg1', 'c1', 1)`
+    )
+
+    const changes = await getChangesSince(db, 0)
+    expect(changes).toHaveLength(1)
+    expect(changes[0].table_name).toBe('chat_0.clients')
+  })
+})

package/src/replication/change-tracker.ts

@@ -158,10 +158,31 @@ export async function installTriggersOnShardTables(db: PGlite): Promise<void> {
 
   if (result.rows.length === 0) return
 
+  // only track `clients` — that's the table zero-cache expects in the
+  // replication stream (needed for .server promise resolution). other shard
+  // tables like `replicas` are zero-cache internal state and streaming them
+  // back causes "Unknown table" crashes in zero-cache's change-processor.
   let count = 0
   for (const { nspname } of result.rows) {
+    // remove stale triggers from non-clients tables (from previous versions)
+    const stale = await db.query<{ event_object_table: string }>(
+      `SELECT DISTINCT event_object_table FROM information_schema.triggers
+       WHERE trigger_name = '_zero_change_trigger'
+         AND event_object_schema = $1
+         AND event_object_table != 'clients'`,
+      [nspname]
+    )
+    for (const { event_object_table } of stale.rows) {
+      const qs = quoteIdent(nspname)
+      const qt = quoteIdent(event_object_table)
+      await db.exec(`DROP TRIGGER IF EXISTS _zero_change_trigger ON ${qs}.${qt}`)
+      log.debug.pglite(
+        `removed stale shard trigger from ${nspname}.${event_object_table}`
+      )
+    }
+
     const tables = await db.query<{ tablename: string }>(
-      `SELECT tablename FROM pg_tables WHERE schemaname = $1`,
+      `SELECT tablename FROM pg_tables WHERE schemaname = $1 AND tablename = 'clients'`,
       [nspname]
     )
 
@@ -195,6 +216,17 @@ export async function getChangesSince(
   return result.rows
 }
 
+export async function purgeConsumedChanges(
+  db: PGlite,
+  watermark: number
+): Promise<number> {
+  const result = await db.query<{ count: string }>(
+    'WITH deleted AS (DELETE FROM public._zero_changes WHERE watermark <= $1 RETURNING 1) SELECT count(*)::text AS count FROM deleted',
+    [watermark]
+  )
+  return Number(result.rows[0]?.count || 0)
+}
+
 export async function getCurrentWatermark(db: PGlite): Promise<number> {
   const result = await db.query<{ last_value: string; is_called: boolean }>(
     'SELECT last_value, is_called FROM public._zero_watermark'

package/src/replication/handler.ts

@@ -10,6 +10,7 @@ import { log } from '../log.js'
 import {
   getChangesSince,
   getCurrentWatermark,
+  purgeConsumedChanges,
   installTriggersOnShardTables,
   type ChangeRecord,
 } from './change-tracker.js'
@@ -342,7 +343,7 @@ export async function handleStartReplication(
     for (const schema of relevantSchemas) {
       if (schema === 'public') continue
       const shardTables = await db.query<{ tablename: string }>(
-        `SELECT tablename FROM pg_tables WHERE schemaname = $1`,
+        `SELECT tablename FROM pg_tables WHERE schemaname = $1 AND tablename = 'clients'`,
         [schema]
       )
       for (const { tablename } of shardTables.rows) {
@@ -457,22 +458,60 @@ export async function handleStartReplication(
   let txCounter = 1
 
   // polling + notification loop
-  const pollInterval = 500
+  // adaptive: poll fast when catching up, slow when idle
+  const pollIntervalIdle = 500
+  const pollIntervalCatchUp = 20
+  const batchSize = 2000
+  const purgeEveryN = 10
+  const shardRescanEveryN = 20
   let running = true
+  let pollsSincePurge = 0
+  let pollsSinceShardRescan = 0
 
   const poll = async () => {
     while (running) {
       try {
+        // periodically re-scan for new shard schemas (e.g. chat_0 created by zero-cache)
+        pollsSinceShardRescan++
+        if (pollsSinceShardRescan >= shardRescanEveryN) {
+          pollsSinceShardRescan = 0
+          await mutex.acquire()
+          try {
+            await installTriggersOnShardTables(db)
+          } finally {
+            mutex.release()
+          }
+        }
+
         // acquire mutex to avoid conflicting with proxy connections
         await mutex.acquire()
         let changes: Awaited<ReturnType<typeof getChangesSince>>
         try {
-          changes = await getChangesSince(db, lastWatermark, 100)
+          changes = await getChangesSince(db, lastWatermark, batchSize)
         } finally {
           mutex.release()
         }
 
         if (changes.length > 0) {
+          // filter out shard tables that zero-cache doesn't expect.
+          // only `clients` is needed (for .server promise resolution).
+          // other shard tables (replicas, mutations) crash zero-cache
+          // with "Unknown table" in change-processor.
+          const batchEnd = changes[changes.length - 1].watermark
+          changes = changes.filter((c) => {
+            const dot = c.table_name.indexOf('.')
+            if (dot === -1) return true
+            const schema = c.table_name.substring(0, dot)
+            if (schema === 'public') return true
+            const table = c.table_name.substring(dot + 1)
+            return table === 'clients'
+          })
+
+          if (changes.length === 0) {
+            lastWatermark = batchEnd
+            continue
+          }
+
           await streamChanges(
             changes,
             writer,
@@ -482,14 +521,31 @@ export async function handleStartReplication(
             excludedColumns,
             columnTypeOids
           )
-          lastWatermark = changes[changes.length - 1].watermark
+          lastWatermark = batchEnd
+
+          // purge consumed changes periodically to free wasm memory
+          pollsSincePurge++
+          if (pollsSincePurge >= purgeEveryN) {
+            pollsSincePurge = 0
+            await mutex.acquire()
+            try {
+              const purged = await purgeConsumedChanges(db, lastWatermark)
+              if (purged > 0) {
+                log.debug.proxy(`purged ${purged} consumed changes`)
+              }
+            } finally {
+              mutex.release()
+            }
+          }
         }
 
         // send keepalive
         const ts = nowMicros()
         writer.write(encodeKeepalive(currentLsn, ts, false))
 
-        await new Promise((resolve) => setTimeout(resolve, pollInterval))
+        // if we got a full batch, there's likely more - poll fast
+        const delay = changes.length >= batchSize ? pollIntervalCatchUp : pollIntervalIdle
+        await new Promise((resolve) => setTimeout(resolve, delay))
       } catch (err: unknown) {
         const msg = err instanceof Error ? err.message : String(err)
         log.debug.proxy(`replication poll error: ${msg}`)

package/src/replication/pgoutput-encoder.test.ts

@@ -1,3 +1,5 @@
+import { join } from 'node:path'
+
 import { describe, it, expect } from 'vitest'
 
 import {
@@ -364,6 +366,238 @@ describe('pgoutput-encoder', () => {
     })
   })
 
+  // roundtrip tests: encode with orez → parse with zero-cache's parser
+  // this validates the fundamental contract between orez and zero-cache
+  describe('roundtrip: orez encoder → zero-cache parser', () => {
+    // relative path bypasses package.json exports restriction
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const parserPath = join(
+      import.meta.dirname,
+      '../../node_modules/@rocicorp/zero/out/zero-cache/src/services/change-source/pg/logical-replication/pgoutput-parser.js'
+    )
+    const { PgoutputParser } = require(parserPath)
+
+    // mock type parsers: unknown OIDs default to String (identity for text)
+    const typeParsers = { getTypeParser: () => String }
+
+    function makeParser() {
+      return new PgoutputParser(typeParsers)
+    }
+
+    it('BEGIN roundtrip', () => {
+      const lsn = 0x1000200n
+      const ts = BigInt(Date.now()) * 1000n
+      const parser = makeParser()
+      const parsed = parser.parse(encodeBegin(lsn, ts, 42))
+
+      expect(parsed.tag).toBe('begin')
+      expect(parsed.commitLsn).toBe('00000000/01000200')
+      expect(parsed.xid).toBe(42)
+      expect(parsed.commitTime).toBe(ts)
+    })
+
+    it('COMMIT roundtrip', () => {
+      const lsn = 0x1000200n
+      const endLsn = 0x1000300n
+      const ts = BigInt(Date.now()) * 1000n
+      const parser = makeParser()
+      const parsed = parser.parse(encodeCommit(0, lsn, endLsn, ts))
+
+      expect(parsed.tag).toBe('commit')
+      expect(parsed.commitLsn).toBe('00000000/01000200')
+      expect(parsed.commitEndLsn).toBe('00000000/01000300')
+      expect(parsed.commitTime).toBe(ts)
+    })
+
+    it('RELATION roundtrip', () => {
+      const oid = getTableOid('rt.rel_test')
+      const cols: ColumnInfo[] = [
+        { name: 'id', typeOid: 25, typeMod: -1, isKey: true },
+        { name: 'name', typeOid: 25, typeMod: -1 },
+      ]
+      const parser = makeParser()
+      const parsed = parser.parse(encodeRelation(oid, 'public', 'rel_test', 0x64, cols))
+
+      expect(parsed.tag).toBe('relation')
+      expect(parsed.schema).toBe('public')
+      expect(parsed.name).toBe('rel_test')
+      expect(parsed.columns).toHaveLength(2)
+      expect(parsed.keyColumns).toEqual(['id'])
+    })
+
+    it('INSERT roundtrip', () => {
+      const oid = getTableOid('rt.ins_test')
+      const cols: ColumnInfo[] = [
+        { name: 'id', typeOid: 25, typeMod: -1, isKey: true },
+        { name: 'val', typeOid: 25, typeMod: -1 },
+      ]
+      const parser = makeParser()
+      parser.parse(encodeRelation(oid, 'public', 'ins_test', 0x64, cols))
+
+      const parsed = parser.parse(encodeInsert(oid, { id: 'abc', val: 'hello' }, cols))
+      expect(parsed.tag).toBe('insert')
+      expect(parsed.new.id).toBe('abc')
+      expect(parsed.new.val).toBe('hello')
+    })
+
+    it('INSERT with null', () => {
+      const oid = getTableOid('rt.null_test')
+      const cols: ColumnInfo[] = [
+        { name: 'id', typeOid: 25, typeMod: -1, isKey: true },
+        { name: 'opt', typeOid: 25, typeMod: -1 },
+      ]
+      const parser = makeParser()
+      parser.parse(encodeRelation(oid, 'public', 'null_test', 0x64, cols))
+
+      const parsed = parser.parse(encodeInsert(oid, { id: 'x', opt: null }, cols))
+      expect(parsed.new.opt).toBeNull()
+    })
+
+    it('UPDATE with old row roundtrip', () => {
+      const oid = getTableOid('rt.upd_test')
+      const cols: ColumnInfo[] = [
+        { name: 'id', typeOid: 25, typeMod: -1, isKey: true },
+        { name: 'val', typeOid: 25, typeMod: -1 },
+      ]
+      const parser = makeParser()
+      parser.parse(encodeRelation(oid, 'public', 'upd_test', 0x64, cols))
+
+      const parsed = parser.parse(
+        encodeUpdate(oid, { id: '1', val: 'new' }, { id: '1', val: 'old' }, cols)
+      )
+      expect(parsed.tag).toBe('update')
+      expect(parsed.new.val).toBe('new')
+      expect(parsed.old.val).toBe('old')
+    })
+
+    it('UPDATE without old row', () => {
+      const oid = getTableOid('rt.upd_no_old')
+      const cols: ColumnInfo[] = [
+        { name: 'id', typeOid: 25, typeMod: -1, isKey: true },
+        { name: 'val', typeOid: 25, typeMod: -1 },
+      ]
+      const parser = makeParser()
+      parser.parse(encodeRelation(oid, 'public', 'upd_no_old', 0x64, cols))
+
+      const parsed = parser.parse(encodeUpdate(oid, { id: '1', val: 'v' }, null, cols))
+      expect(parsed.tag).toBe('update')
+      expect(parsed.new.val).toBe('v')
+      expect(parsed.old).toBeNull()
+      expect(parsed.key).toBeNull()
+    })
+
+    it('DELETE roundtrip', () => {
+      const oid = getTableOid('rt.del_test')
+      const cols: ColumnInfo[] = [
+        { name: 'id', typeOid: 25, typeMod: -1, isKey: true },
+        { name: 'val', typeOid: 25, typeMod: -1 },
+      ]
+      const parser = makeParser()
+      parser.parse(encodeRelation(oid, 'public', 'del_test', 0x64, cols))
+
+      const parsed = parser.parse(encodeDelete(oid, { id: 'gone', val: 'x' }, cols))
+      expect(parsed.tag).toBe('delete')
+      expect(parsed.key.id).toBe('gone')
+    })
+
+    it('full transaction: BEGIN → RELATION → INSERT → COMMIT', () => {
+      const parser = makeParser()
+      const lsn = 0x2000000n
+      const endLsn = 0x2000100n
+      const ts = BigInt(Date.now()) * 1000n
+
+      const begin = parser.parse(encodeBegin(lsn, ts, 1))
+      expect(begin.commitLsn).toBe('00000000/02000000')
+
+      const oid = getTableOid('rt.full_tx')
+      const cols: ColumnInfo[] = [
+        { name: 'id', typeOid: 25, typeMod: -1, isKey: true },
+        { name: 'data', typeOid: 25, typeMod: -1 },
+      ]
+      parser.parse(encodeRelation(oid, 'public', 'full_tx', 0x64, cols))
+
+      const ins = parser.parse(encodeInsert(oid, { id: '1', data: 'test' }, cols))
+      expect(ins.new.id).toBe('1')
+
+      const commit = parser.parse(encodeCommit(0, lsn, endLsn, ts))
+      expect(commit.commitLsn).toBe(begin.commitLsn)
+    })
+
+    it('XLogData + CopyData wrapper roundtrip with parser', () => {
+      const lsn = 0x3000000n
+      const ts = BigInt(Date.now()) * 1000n
+      const pgoutput = encodeBegin(lsn, ts, 1)
+      const xlog = wrapXLogData(lsn, lsn, ts, pgoutput)
+      const frame = wrapCopyData(xlog)
+
+      // unwrap CopyData
+      const copyLen = r32(frame, 1)
+      const inner = frame.subarray(5, 1 + copyLen)
+
+      // parse like stream.js
+      expect(inner[0]).toBe(0x77)
+      const streamLsn = new DataView(inner.buffer, inner.byteOffset).getBigUint64(1)
+      expect(streamLsn).toBe(lsn)
+
+      // parse pgoutput
+      const parser = makeParser()
+      const parsed = parser.parse(inner.subarray(25))
+      expect(parsed.tag).toBe('begin')
+      expect(parsed.commitLsn).toBe('00000000/03000000')
+    })
+
+    it('shard schema encoding', () => {
+      const oid = getTableOid('rt.chat_0.clients')
+      const cols: ColumnInfo[] = [
+        { name: 'id', typeOid: 25, typeMod: -1, isKey: true },
+        { name: 'lastMutationID', typeOid: 20, typeMod: -1 },
+      ]
+      const parser = makeParser()
+      const rel = parser.parse(encodeRelation(oid, 'chat_0', 'clients', 0x64, cols))
+      expect(rel.schema).toBe('chat_0')
+      expect(rel.name).toBe('clients')
+    })
+
+    it('LSN ordering: slot < streaming changes', () => {
+      // validates that streaming changes will be seen as "new" by zero-cache
+      let testLsn = 0x1000000n
+      const next = () => {
+        testLsn += 0x100n
+        return testLsn
+      }
+
+      const slotLsn = next() // CREATE_REPLICATION_SLOT
+      const beginLsn = next() // first streaming BEGIN
+      const commitLsn = next() // first streaming COMMIT
+
+      expect(beginLsn).toBeGreaterThan(slotLsn)
+      expect(commitLsn).toBeGreaterThan(beginLsn)
+
+      // verify lexi version ordering is preserved
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      const lexiPath = join(
+        import.meta.dirname,
+        '../../node_modules/@rocicorp/zero/out/zero-cache/src/types/lexi-version.js'
+      )
+      const { versionToLexi } = require(lexiPath)
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      const lsnPath = join(
+        import.meta.dirname,
+        '../../node_modules/@rocicorp/zero/out/zero-cache/src/services/change-source/pg/lsn.js'
+      )
+      const { toBigInt: lsnToBigInt } = require(lsnPath)
+
+      const slotHex = `00000000/${slotLsn.toString(16).padStart(8, '0')}`.toUpperCase()
+      const beginHex = `00000000/${beginLsn.toString(16).padStart(8, '0')}`.toUpperCase()
+
+      const slotVersion = versionToLexi(lsnToBigInt(slotHex))
+      const beginVersion = versionToLexi(lsnToBigInt(beginHex))
+
+      // lexi versions must maintain ordering
+      expect(beginVersion > slotVersion).toBe(true)
+    })
+  })
+
   describe('double-wrap: CopyData(XLogData(message))', () => {
     // this is the exact framing zero-cache expects for every replication message
     it('produces parseable nested structure', () => {

package/src/replication/zero-compat.test.ts

@@ -940,4 +940,108 @@ describe('zero-cache pgoutput compatibility', { timeout: 30000 }, () => {
 
     s.close()
   })
+
+  it('shard replicas/mutations changes NOT streamed (only clients)', async () => {
+    // zero-cache creates shard schemas (chat_0) with clients, replicas, mutations.
+    // if we stream replicas/mutations changes, zero-cache crashes with
+    // "Unknown table chat_0.replicas". only clients changes should be streamed.
+    await db.exec(`
+      CREATE SCHEMA chat_0;
+      CREATE TABLE chat_0.clients (
+        "clientGroupID" TEXT NOT NULL,
+        "clientID" TEXT NOT NULL,
+        "lastMutationID" BIGINT,
+        PRIMARY KEY ("clientGroupID", "clientID")
+      );
+      CREATE TABLE chat_0.replicas (
+        id TEXT PRIMARY KEY,
+        version TEXT
+      );
+      CREATE TABLE chat_0.mutations (
+        id TEXT PRIMARY KEY,
+        "clientID" TEXT,
+        name TEXT
+      );
+    `)
+    await installChangeTracking(db)
+
+    const s = await stream()
+    const q = s.messages
+
+    // insert into all three shard tables + a public table
+    await db.exec(
+      `INSERT INTO chat_0.clients ("clientGroupID", "clientID", "lastMutationID") VALUES ('cg1', 'c1', 1)`
+    )
+    await db.exec(`INSERT INTO chat_0.replicas (id, version) VALUES ('r1', 'v1')`)
+    await db.exec(
+      `INSERT INTO chat_0.mutations (id, "clientID", name) VALUES ('m1', 'c1', 'send')`
+    )
+    await db.exec(`INSERT INTO public.foo (id) VALUES ('normal')`)
+
+    // collect all inserts for a few seconds
+    const inserts: ZcInsert[] = []
+    const deadline = Date.now() + 4000
+    while (Date.now() < deadline) {
+      const m = await q.dequeue(1500).catch(() => null)
+      if (!m) break
+      if (m.tag === 'insert') inserts.push(m as ZcInsert)
+    }
+
+    // should see clients + foo inserts, but NOT replicas or mutations
+    const streamedTables = inserts.map((i) => `${i.relation.schema}.${i.relation.name}`)
+    expect(streamedTables).toContain('public.foo')
+    expect(streamedTables).toContain('chat_0.clients')
+    expect(streamedTables).not.toContain('chat_0.replicas')
+    expect(streamedTables).not.toContain('chat_0.mutations')
+
+    s.close()
+  })
+
+  it('shard clients table created AFTER replication starts still gets tracked', async () => {
+    // zero-cache creates shard schemas after the replication connection is live.
+    // the poll loop must detect new shard tables and install triggers dynamically.
+    const s = await stream()
+    const q = s.messages
+
+    // give replication time to start polling
+    await new Promise((r) => setTimeout(r, 300))
+
+    // now create shard schema (simulating zero-cache's DDL during initial sync)
+    await db.exec(`
+      CREATE SCHEMA chat_0;
+      CREATE TABLE chat_0.clients (
+        "clientGroupID" TEXT NOT NULL,
+        "clientID" TEXT NOT NULL,
+        "lastMutationID" BIGINT,
+        PRIMARY KEY ("clientGroupID", "clientID")
+      );
+    `)
+
+    // wait for poll loop to detect new table (rescan every ~10s)
+    await new Promise((r) => setTimeout(r, 12000))
+
+    // insert data that should be captured
+    await db.exec(
+      `INSERT INTO chat_0.clients ("clientGroupID", "clientID", "lastMutationID") VALUES ('cg1', 'c1', 42)`
+    )
+
+    // the insert should appear in the replication stream
+    let found = false
+    const deadline = Date.now() + 5000
+    while (Date.now() < deadline) {
+      const m = await q.dequeue(2000).catch(() => null)
+      if (!m) break
+      if (m.tag === 'insert') {
+        const ins = m as ZcInsert
+        if (ins.relation.schema === 'chat_0' && ins.relation.name === 'clients') {
+          found = true
+          break
+        }
+      }
+    }
+
+    expect(found).toBe(true)
+
+    s.close()
+  })
 })

package/src/vite-plugin.ts

@@ -9,7 +9,7 @@ export interface OrezPluginOptions extends Partial<ZeroLiteConfig> {
   s3Port?: number
 }
 
-export default function orez(options?: OrezPluginOptions): Plugin {
+export function orezPlugin(options?: OrezPluginOptions): Plugin {
   let stop: (() => Promise<void>) | null = null
   let s3Server: Server | null = null