orez 0.2.24 → 0.2.26

package/src/pglite-ipc.test.ts

@@ -96,4 +96,21 @@ describe('PGliteWorkerProxy', () => {
   test('error propagation with SQL code', async () => {
     await expect(proxy.exec('SELECT * FROM nonexistent_table')).rejects.toThrow()
   })
+
+  test('rejects requests after worker exits', async () => {
+    const local = new PGliteWorkerProxy({
+      dataDir: 'memory://',
+      name: 'exit-test',
+      withExtensions: false,
+      debug: 0,
+      pgliteOptions: {},
+    })
+    await local.waitReady
+
+    await (local as any).worker.terminate()
+
+    await expect(local.query('SELECT 1')).rejects.toThrow(
+      /worker exited|worker is closed/
+    )
+  })
 })

package/src/pglite-ipc.ts

@@ -51,6 +51,8 @@ export class PGliteWorkerProxy {
   private pending = new Map<number, PendingRequest>()
   private nextId = 1
   private notificationCallbacks = new Map<string, Set<(payload: string) => void>>()
+  private closed = false
+  private failure: Error | null = null
   readonly name: string
 
   /** resolves when the worker's PGlite instance is ready */
@@ -89,24 +91,31 @@ export class PGliteWorkerProxy {
 
     // handle unexpected worker crashes
     this.worker.on('error', (err) => {
+      const failure = new Error(`worker crashed: ${err.message}`)
       log.pglite(`worker ${config.name} error: ${err.message}`)
-      for (const [, req] of this.pending) {
-        req.reject(new Error(`worker crashed: ${err.message}`))
-      }
-      this.pending.clear()
+      this.failPending(failure)
     })
 
     this.worker.on('exit', (code) => {
+      if (this.closed) return
       if (code !== 0) {
+        const failure = new Error(`worker exited with code ${code}`)
         log.pglite(`worker ${config.name} exited with code ${code}`)
-        for (const [, req] of this.pending) {
-          req.reject(new Error(`worker exited with code ${code}`))
-        }
-        this.pending.clear()
+        this.failPending(failure)
+        return
       }
+      this.failPending(new Error('worker exited unexpectedly'))
     })
   }
 
+  private failPending(error: Error) {
+    if (!this.failure) this.failure = error
+    for (const [, req] of this.pending) {
+      req.reject(error)
+    }
+    this.pending.clear()
+  }
+
   private installMessageHandler() {
     this.worker.on(
       'message',
@@ -139,14 +148,22 @@ export class PGliteWorkerProxy {
   }
 
   private send(msg: Record<string, unknown>, transfer?: ArrayBuffer[]): Promise<any> {
+    if (this.failure) return Promise.reject(this.failure)
+    if (this.closed) return Promise.reject(new Error('worker is closed'))
+
     const id = this.nextId++
     msg.id = id
     return new Promise((resolve, reject) => {
       this.pending.set(id, { resolve, reject })
-      if (transfer?.length) {
-        this.worker.postMessage(msg, transfer)
-      } else {
-        this.worker.postMessage(msg)
+      try {
+        if (transfer?.length) {
+          this.worker.postMessage(msg, transfer)
+        } else {
+          this.worker.postMessage(msg)
+        }
+      } catch (err) {
+        this.pending.delete(id)
+        reject(err instanceof Error ? err : new Error(String(err)))
       }
     })
   }
@@ -242,6 +259,8 @@ export class PGliteWorkerProxy {
     } catch {
       // worker may already be gone
     }
+    this.closed = true
+    this.failPending(new Error('worker is closed'))
     await this.worker.terminate()
   }
 }

package/src/pglite-web-proxy.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, test } from 'vitest'
+
+import { PGliteWebProxy } from './pglite-web-proxy.js'
+
+class FakeWorker {
+  messages: unknown[] = []
+  terminated = false
+  private listeners = new Map<string, Set<(event: any) => void>>()
+
+  addEventListener(type: string, handler: (event: any) => void) {
+    let handlers = this.listeners.get(type)
+    if (!handlers) {
+      handlers = new Set()
+      this.listeners.set(type, handlers)
+    }
+    handlers.add(handler)
+  }
+
+  removeEventListener(type: string, handler: (event: any) => void) {
+    this.listeners.get(type)?.delete(handler)
+  }
+
+  postMessage(message: unknown) {
+    this.messages.push(message)
+  }
+
+  terminate() {
+    this.terminated = true
+  }
+
+  dispatch(type: string, event: any) {
+    for (const handler of this.listeners.get(type) ?? []) {
+      handler(event)
+    }
+  }
+}
+
+describe('PGliteWebProxy', () => {
+  test('rejects pending and future requests when the worker errors', async () => {
+    const worker = new FakeWorker()
+    const proxy = new PGliteWebProxy(worker as unknown as Worker, 'postgres')
+
+    worker.dispatch('message', { data: { type: 'ready' } })
+    await proxy.waitReady
+
+    const pending = proxy.query('SELECT 1')
+    expect(worker.messages).toHaveLength(1)
+
+    worker.dispatch('error', {
+      error: new Error('pglite worker crashed'),
+      message: 'pglite worker crashed',
+    })
+
+    await expect(pending).rejects.toThrow('pglite worker crashed')
+    await expect(proxy.query('SELECT 2')).rejects.toThrow('pglite worker crashed')
+  })
+})

package/src/pglite-web-proxy.ts

@@ -34,6 +34,7 @@ export class PGliteWebProxy {
   private pending = new Map<number, PendingRequest>()
   private nextId = 1
   private notificationCallbacks = new Map<string, Set<(payload: string) => void>>()
+  private failure: Error | null = null
   readonly name: string
 
   readonly waitReady: Promise<void>
@@ -66,12 +67,26 @@ export class PGliteWebProxy {
 
       this.worker.addEventListener('message', onMessage)
       this.worker.addEventListener('error', (ev) => {
-        rejectReady(new Error(String(ev)))
+        const error = this.errorFromEvent(ev, 'worker failed during startup')
+        this.failPending(error)
+        rejectReady(error)
+      })
+      this.worker.addEventListener('messageerror', (ev) => {
+        const error = this.errorFromEvent(ev, 'worker message error during startup')
+        this.failPending(error)
+        rejectReady(error)
       })
     })
   }
 
   private installMessageHandler() {
+    this.worker.addEventListener('error', (ev) => {
+      this.failPending(this.errorFromEvent(ev, 'worker failed'))
+    })
+    this.worker.addEventListener('messageerror', (ev) => {
+      this.failPending(this.errorFromEvent(ev, 'worker message error'))
+    })
+
     this.worker.addEventListener('message', (ev: MessageEvent) => {
       const msg = ev.data
       if (!msg || typeof msg !== 'object') return
@@ -102,15 +117,40 @@ export class PGliteWebProxy {
     })
   }
 
+  private errorFromEvent(ev: Event, fallback: string): Error {
+    const maybeError = ev as ErrorEvent
+    if (maybeError.error instanceof Error) return maybeError.error
+    if (maybeError.message) return new Error(maybeError.message)
+    return new Error(fallback)
+  }
+
+  private failPending(error: Error) {
+    if (!this.failure) this.failure = error
+    this.closed = true
+    this.ready = false
+    for (const [, req] of this.pending) {
+      req.reject(error)
+    }
+    this.pending.clear()
+  }
+
   private send(msg: Record<string, unknown>, transfer?: Transferable[]): Promise<any> {
+    if (this.failure) return Promise.reject(this.failure)
+    if (this.closed) return Promise.reject(new Error('worker is closed'))
+
     const id = this.nextId++
     msg.id = id
     return new Promise((resolve, reject) => {
       this.pending.set(id, { resolve, reject })
-      if (transfer?.length) {
-        this.worker.postMessage(msg, transfer)
-      } else {
-        this.worker.postMessage(msg)
+      try {
+        if (transfer?.length) {
+          this.worker.postMessage(msg, transfer)
+        } else {
+          this.worker.postMessage(msg)
+        }
+      } catch (err) {
+        this.pending.delete(id)
+        reject(err instanceof Error ? err : new Error(String(err)))
       }
     })
   }
@@ -170,11 +210,12 @@ export class PGliteWebProxy {
   }
 
   async close(): Promise<void> {
-    this.closed = true
-    this.ready = false
     try {
       await this.send({ type: 'close' })
     } catch {}
+    this.closed = true
+    this.ready = false
+    this.failPending(new Error('worker is closed'))
     this.worker.terminate()
   }
 }

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 --