orez 0.2.25 → 0.2.26

package/src/replication/change-tracker.ts

@@ -20,6 +20,16 @@ export interface ChangeTrackingDb {
   query<T>(sql: string, params?: unknown[]): Promise<{ rows: T[] }>
 }
 
+// PGlite returns JSONB columns as parsed objects; the DO backend returns them
+// as JSON strings (it stores `row_data TEXT`). normalize once at the consumer
+// boundary so callers always get an object.
+function jsonRecord(value: unknown): Record<string, unknown> | null {
+  if (value === null || value === undefined) return null
+  if (typeof value === 'object') return value as Record<string, unknown>
+  if (typeof value !== 'string' || value === '') return null
+  return JSON.parse(value) as Record<string, unknown>
+}
+
 export async function installChangeTracking(db: ChangeTrackingDb): Promise<void> {
   // use _orez schema for internal tables - survives pg_restore of public schema
   await db.exec(`CREATE SCHEMA IF NOT EXISTS _orez`)
@@ -241,7 +251,12 @@ export async function getChangesSince(
     'SELECT watermark, table_name, op, row_data, old_data FROM _orez._zero_changes WHERE watermark > $1 ORDER BY watermark LIMIT $2',
     [watermark, limit]
   )
-  return result.rows
+  return result.rows.map((row) => ({
+    ...row,
+    watermark: Number(row.watermark),
+    row_data: jsonRecord(row.row_data),
+    old_data: jsonRecord(row.old_data),
+  }))
 }
 
 export async function purgeConsumedChanges(

package/src/replication/handler.test.ts

@@ -174,6 +174,19 @@ describe('handleStartReplication', () => {
     return types
   }
 
+  function countCopyDataFrames(buf: Uint8Array): number {
+    const dv = new DataView(buf.buffer, buf.byteOffset, buf.byteLength)
+    let pos = 0
+    let count = 0
+    while (pos < buf.length) {
+      if (buf[pos] !== 0x64) return count
+      const len = dv.getInt32(pos + 1)
+      pos += 1 + len
+      count++
+    }
+    return count
+  }
+
   it('sends CopyBothResponse first', async () => {
     const { written, writer } = createWriter()
 
@@ -238,6 +251,28 @@ describe('handleStartReplication', () => {
     expect(insIdx).toBeLessThan(comIdx)
   })
 
+  it('writes one CopyData frame per socket chunk', async () => {
+    const { written, writer } = createWriter()
+
+    replicationPromise = handleStartReplication(
+      'START_REPLICATION SLOT "s" LOGICAL 0/0',
+      writer,
+      db,
+      testMutex
+    )
+
+    await new Promise((r) => setTimeout(r, 100))
+    await db.exec(`INSERT INTO public.items (name, value) VALUES ('chunked', 123)`)
+    signalReplicationChange()
+    await new Promise((r) => setTimeout(r, 700))
+
+    const copyDataWrites = written.filter((msg) => msg[0] === 0x64)
+    expect(copyDataWrites.length).toBeGreaterThanOrEqual(4)
+    for (const msg of copyDataWrites) {
+      expect(countCopyDataFrames(msg)).toBe(1)
+    }
+  })
+
   it('streams UPDATE and DELETE operations', async () => {
     const { written, writer } = createWriter()
 

package/src/replication/handler.ts

@@ -117,6 +117,10 @@ let _replicationWakeup: (() => void) | null = null
  *  called by the proxy after executing writes on the postgres instance. */
 export function signalReplicationChange() {
   _replicationWakeup?.()
+  const globalWakeup = (globalThis as any).__orez_signal_replication
+  if (typeof globalWakeup === 'function' && globalWakeup !== _replicationWakeup) {
+    globalWakeup()
+  }
 }
 
 // cached setup results so reconnects skip the expensive mutex-holding setup phase.
@@ -1146,8 +1150,9 @@ async function streamChanges(
   const endLsn = nextLsn()
   messages.push(encodeWrappedChange(endLsn, endLsn, ts, encodeCommit(0, lsn, endLsn, ts)))
 
-  // write messages individually — works for both TCP sockets and in-process
-  // pipes (browser pipe handler parses one message per write() call)
+  // The MessagePort-backed socket delivers each write as one readable chunk.
+  // zero-cache parses one replication payload per chunk, so each CopyData frame
+  // must be written separately.
   let totalSize = 0
   for (const msg of messages) totalSize += msg.length
   log.debug.repl(

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

@@ -40,6 +40,24 @@ function rText(buf: Uint8Array, off: number): [string, number] {
   const str = new TextDecoder().decode(buf.subarray(off + 4, off + 4 + len))
   return [str, off + 4 + len]
 }
+function rTupleTextValues(buf: Uint8Array, off: number): [Array<string | null>, number] {
+  const values: Array<string | null> = []
+  const count = r16(buf, off)
+  let pos = off + 2
+  for (let i = 0; i < count; i++) {
+    const kind = buf[pos++]
+    if (kind === 0x6e) {
+      values.push(null)
+      continue
+    }
+    expect(kind).toBe(0x74)
+    const len = r32(buf, pos)
+    pos += 4
+    values.push(new TextDecoder().decode(buf.subarray(pos, pos + len)))
+    pos += len
+  }
+  return [values, pos]
+}
 
 describe('pgoutput-encoder', () => {
   describe('encodeBegin', () => {
@@ -276,6 +294,26 @@ describe('pgoutput-encoder', () => {
       }
       expect(buf[pos]).toBe(0x4e) // 'N' new tuple marker
     })
+
+    it('encodes sqlite integer booleans as postgres bool text', () => {
+      const boolCols: ColumnInfo[] = [
+        { name: 'id', typeOid: 25, typeMod: -1, isKey: true },
+        { name: 'completed', typeOid: 16, typeMod: -1 },
+      ]
+      const buf = encodeUpdate(
+        16384,
+        { id: '1', completed: 1 },
+        { id: '1', completed: 0 },
+        boolCols
+      )
+
+      expect(buf[5]).toBe(0x4f) // 'O' old tuple
+      const [oldValues, afterOld] = rTupleTextValues(buf, 6)
+      expect(oldValues).toEqual(['1', 'f'])
+      expect(buf[afterOld]).toBe(0x4e) // 'N' new tuple
+      const [newValues] = rTupleTextValues(buf, afterOld + 1)
+      expect(newValues).toEqual(['1', 't'])
+    })
   })
 
   describe('encodeDelete', () => {
@@ -364,6 +402,12 @@ describe('pgoutput-encoder', () => {
       const b = getTableOid('oid_test_y')
       expect(a).not.toBe(b)
     })
+
+    it('matches DoBackend catalog oids for flattened schema tables', () => {
+      expect(getTableOid('public.todo')).toBe(4392680)
+      expect(getTableOid('todo_0.clients')).toBe(9663976)
+      expect(getTableOid('todo_0.mutations')).toBe(8519194)
+    })
   })
 
   // roundtrip tests: encode with orez → parse with zero-cache's parser
@@ -384,8 +428,16 @@ describe('pgoutput-encoder', () => {
       PgoutputParser = (await import(parserPath)).PgoutputParser
     })
 
-    function makeParser() {
-      return new PgoutputParser(typeParsers)
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    function makeParser(parserOverrides: any = typeParsers) {
+      return new PgoutputParser(parserOverrides)
+    }
+
+    function makeBoolAwareParser() {
+      return makeParser({
+        getTypeParser: (oid: number) =>
+          oid === 16 ? (value: string) => value === 't' : String,
+      })
     }
 
     it('BEGIN roundtrip', () => {
@@ -490,6 +542,23 @@ describe('pgoutput-encoder', () => {
       expect(parsed.key).toBeNull()
     })
 
+    it('UPDATE roundtrip decodes sqlite boolean integers through zero-cache parser', () => {
+      const oid = getTableOid('rt.bool_update')
+      const cols: ColumnInfo[] = [
+        { name: 'id', typeOid: 25, typeMod: -1, isKey: true },
+        { name: 'completed', typeOid: 16, typeMod: -1 },
+      ]
+      const parser = makeBoolAwareParser()
+      parser.parse(encodeRelation(oid, 'public', 'bool_update', 0x64, cols))
+
+      const parsed = parser.parse(
+        encodeUpdate(oid, { id: '1', completed: 1 }, { id: '1', completed: 0 }, cols)
+      )
+      expect(parsed.tag).toBe('update')
+      expect(parsed.old.completed).toBe(false)
+      expect(parsed.new.completed).toBe(true)
+    })
+
     it('DELETE roundtrip', () => {
       const oid = getTableOid('rt.del_test')
       const cols: ColumnInfo[] = [

package/src/replication/pgoutput-encoder.ts

@@ -9,21 +9,32 @@
 
 // postgres epoch: 2000-01-01 in microseconds from unix epoch
 const PG_EPOCH_MICROS = 946684800000000n
+const PG_TYPE_BOOL = 16
+const PG_TYPE_TIMESTAMP = 1114
+const PG_TYPE_TIMESTAMPTZ = 1184
 
 // shared encoder instance - avoids per-call allocation
 const encoder = new TextEncoder()
 
-// table oid tracking
-const tableOids = new Map<string, number>()
-let nextOid = 16384
+function flattenRelationName(tableName: string): string {
+  const dot = tableName.indexOf('.')
+  if (dot < 0) return tableName
+  const schema = tableName.slice(0, dot)
+  const name = tableName.slice(dot + 1)
+  if (schema === 'public') return name
+  if (schema === '_orez' && name === '_zero_changes') return '_zero_changes'
+  if (schema === '_orez' && name === '_zero_replication_slots')
+    return '_orez__zero_replication_slots'
+  if (schema === '_orez') return `_orez__${name}`
+  if (schema === '_zero') return `_zero_${name}`
+  return `${schema}_${name}`
+}
 
 function getTableOid(tableName: string): number {
-  let oid = tableOids.get(tableName)
-  if (!oid) {
-    oid = nextOid++
-    tableOids.set(tableName, oid)
-  }
-  return oid
+  let hash = 0
+  const key = `table:${flattenRelationName(tableName)}`
+  for (let i = 0; i < key.length; i++) hash = (hash * 33 + key.charCodeAt(i)) >>> 0
+  return 50_000 + (hash % 10_000_000)
 }
 
 export interface ColumnInfo {
@@ -42,6 +53,50 @@ export function inferColumns(row: Record<string, unknown>): ColumnInfo[] {
   }))
 }
 
+function postgresBooleanText(value: unknown): string | null {
+  if (typeof value === 'boolean') return value ? 't' : 'f'
+  if (typeof value === 'number') return value === 0 ? 'f' : 't'
+  if (typeof value === 'bigint') return value === 0n ? 'f' : 't'
+  if (typeof value !== 'string') return null
+  switch (value.trim().toLowerCase()) {
+    case 't':
+    case 'true':
+    case '1':
+      return 't'
+    case 'f':
+    case 'false':
+    case '0':
+      return 'f'
+    default:
+      return null
+  }
+}
+
+function postgresTupleTextValue(value: unknown, column: ColumnInfo): string {
+  if (column.typeOid === PG_TYPE_BOOL) {
+    const booleanText = postgresBooleanText(value)
+    if (booleanText !== null) return booleanText
+  }
+
+  if (typeof value === 'boolean') return value ? 't' : 'f'
+  if (typeof value === 'object') return JSON.stringify(value)
+
+  let strVal = String(value)
+  // normalize ISO timestamps to postgres text format.
+  // to_jsonb() produces "2026-03-19T07:20:11.643" but postgres
+  // pgoutput sends "2026-03-19 07:20:11.643" (space, no T).
+  // mismatch causes zero-cache to see different values during
+  // mutation reconciliation, triggering unnecessary rebases.
+  if (
+    (column.typeOid === PG_TYPE_TIMESTAMP || column.typeOid === PG_TYPE_TIMESTAMPTZ) &&
+    typeof value === 'string' &&
+    value.length >= 19
+  ) {
+    strVal = strVal.replace('T', ' ')
+  }
+  return strVal
+}
+
 // reusable scratch buffer for building messages (64KB, grows if needed)
 let scratch = new Uint8Array(65536)
 let scratchView = new DataView(scratch.buffer)
@@ -175,27 +230,7 @@ function encodeTupleDataInto(
       ensureScratch(pos + 1)
       scratch[pos++] = 0x6e // 'n' for null
     } else {
-      // convert to postgresql text format
-      let strVal: string
-      if (typeof val === 'boolean') {
-        strVal = val ? 't' : 'f'
-      } else if (typeof val === 'object') {
-        strVal = JSON.stringify(val)
-      } else {
-        strVal = String(val)
-        // normalize ISO timestamps to postgres text format.
-        // to_jsonb() produces "2026-03-19T07:20:11.643" but postgres
-        // pgoutput sends "2026-03-19 07:20:11.643" (space, no T).
-        // mismatch causes zero-cache to see different values during
-        // mutation reconciliation, triggering unnecessary rebases.
-        if (
-          (col.typeOid === 1114 || col.typeOid === 1184) &&
-          typeof val === 'string' &&
-          val.length >= 19
-        ) {
-          strVal = strVal.replace('T', ' ')
-        }
-      }
+      const strVal = postgresTupleTextValue(val, col)
       const bytes = encoder.encode(strVal)
       ensureScratch(pos + 1 + 4 + bytes.length)
       scratch[pos++] = 0x74 // 't' for text

package/src/worker/browser-build-config.test.ts

@@ -5,6 +5,7 @@ import {
   getBrowserDefine,
   getBrowserBuildConfig,
 } from './browser-build-config.js'
+import { getHeapStatistics } from './shims/node-stub.js'
 
 describe('browser build config', () => {
   describe('getBrowserAliases', () => {
@@ -19,6 +20,7 @@ describe('browser build config', () => {
       expect(aliases['@rocicorp/zero-sqlite3']).toBe('orez/worker/shims/sqlite')
       expect(aliases.fastify).toBe('orez/worker/shims/fastify')
       expect(aliases.ws).toBe('orez/worker/shims/ws')
+      expect(aliases.oxfmt).toBe('orez/worker/shims/oxfmt')
     })
 
     it('includes Node.js polyfills', () => {
@@ -26,6 +28,7 @@ describe('browser build config', () => {
       expect(aliases['node:events']).toBe('events')
       expect(aliases['node:stream']).toBe('orez/worker/shims/stream-browser')
       expect(aliases['node:path']).toBe('path-browserify')
+      expect(aliases['node:os']).toBe('orez/worker/shims/node-stub')
     })
 
     it('includes Node.js stubs', () => {
@@ -35,6 +38,7 @@ describe('browser build config', () => {
       expect(aliases['node:child_process']).toBe('orez/worker/shims/node-stub')
       expect(aliases['node:http']).toBe('orez/worker/shims/node-stub')
       expect(aliases['node:crypto']).toBe('orez/worker/shims/node-stub')
+      expect(aliases['node:v8']).toBe('orez/worker/shims/node-stub')
     })
   })
 
@@ -56,4 +60,12 @@ describe('browser build config', () => {
       expect(config.bundle).toBe(true)
     })
   })
+
+  describe('node:v8 shim', () => {
+    it('reports a positive worker heap budget', () => {
+      const stats = getHeapStatistics()
+      expect(stats.heap_size_limit).toBe(128 * 1024 * 1024)
+      expect(stats.heap_size_limit - stats.used_heap_size).toBeGreaterThan(0)
+    })
+  })
 })

package/src/worker/browser-build-config.ts

@@ -49,6 +49,7 @@ export function getBrowserAliases(): Record<string, string> {
     '@rocicorp/zero-sqlite3': 'orez/worker/shims/sqlite',
     fastify: 'orez/worker/shims/fastify',
     ws: 'orez/worker/shims/ws',
+    oxfmt: 'orez/worker/shims/oxfmt',
 
     // -- Node.js built-in polyfills --
     // these are needed because zero-cache imports node: modules.
@@ -60,7 +61,7 @@ export function getBrowserAliases(): Record<string, string> {
     'crypto-browserify': 'orez/worker/shims/node-stub',
     'node:stream': 'orez/worker/shims/stream-browser',
     'node:path': 'path-browserify',
-    'node:os': 'os-browserify/browser',
+    'node:os': 'orez/worker/shims/node-stub',
 
     // -- stubs for Node.js modules that zero-cache imports but doesn't --
     // -- use in SINGLE_PROCESS mode --