orez 0.1.43 → 0.1.44

package/src/pg-proxy.ts

@@ -45,24 +45,45 @@ const SCHEMA_CACHE_TTL_MS = 30_000
 // performance tracking
 const proxyStats = { totalWaitMs: 0, totalExecMs: 0, count: 0, batches: 0 }
 
-function isCacheableQuery(query: string): boolean {
-  const q = query.trimStart().toLowerCase()
-  return (
-    (q.includes('information_schema.') ||
-      q.includes('pg_catalog.') ||
-      q.includes('pg_tables') ||
-      q.includes('pg_namespace') ||
-      q.includes('pg_class') ||
-      q.includes('pg_attribute') ||
-      q.includes('pg_type') ||
-      q.includes('pg_publication')) &&
-    !q.startsWith('insert') &&
-    !q.startsWith('update') &&
-    !q.startsWith('delete') &&
-    !q.startsWith('create') &&
-    !q.startsWith('alter') &&
-    !q.startsWith('drop')
-  )
+// query classification helpers — operate on pre-normalized (trimmed+lowercased) query strings
+const SCHEMA_QUERY_MARKERS = [
+  'information_schema.',
+  'pg_catalog.',
+  'pg_tables',
+  'pg_namespace',
+  'pg_class',
+  'pg_attribute',
+  'pg_type',
+  'pg_publication',
+]
+const WRITE_PREFIXES = ['insert', 'update', 'delete', 'copy', 'truncate']
+const DDL_PREFIXES = ['create', 'alter', 'drop']
+const MUTATING_PREFIXES = [...WRITE_PREFIXES, ...DDL_PREFIXES]
+
+function isCacheableNormalized(q: string): boolean {
+  // fast-fail: mutating queries are never cacheable
+  for (const p of MUTATING_PREFIXES) {
+    if (q.startsWith(p)) return false
+  }
+  // check if it touches schema/catalog tables
+  for (const marker of SCHEMA_QUERY_MARKERS) {
+    if (q.includes(marker)) return true
+  }
+  return false
+}
+
+function isWriteNormalized(q: string): boolean {
+  for (const p of WRITE_PREFIXES) {
+    if (q.startsWith(p)) return true
+  }
+  return false
+}
+
+function isDDLNormalized(q: string): boolean {
+  for (const p of DDL_PREFIXES) {
+    if (q.startsWith(p)) return true
+  }
+  return false
 }
 
 function extractQueryText(data: Uint8Array): string | null {
@@ -795,10 +816,13 @@ export async function startPgProxy(
           // intercept and rewrite queries
           data = interceptQuery(data)
 
-          // cache Simple Query (0x51) schema queries
+          // normalize query once for all classification checks
           const isSimpleQuery = msgType === 0x51
           const queryText = isSimpleQuery ? extractQueryText(data) : null
-          const cacheable = queryText && isCacheableQuery(queryText)
+          const queryNorm = queryText ? queryText.trimStart().toLowerCase() : null
+          const cacheable = queryNorm && isCacheableNormalized(queryNorm)
+
+          // cache Simple Query schema queries
           if (cacheable) {
             const cached = schemaQueryCache.get(queryText!)
             if (cached && Date.now() < cached.expiresAt) {
@@ -861,15 +885,8 @@ export async function startPgProxy(
             }
           } else {
             result = await execute()
-            if (isSimpleQuery && queryText) {
-              const q = queryText.trimStart().toLowerCase()
-              if (
-                q.startsWith('create') ||
-                q.startsWith('alter') ||
-                q.startsWith('drop')
-              ) {
-                invalidateSchemaCache()
-              }
+            if (queryNorm && isDDLNormalized(queryNorm)) {
+              invalidateSchemaCache()
             }
           }
 
@@ -877,17 +894,8 @@ export async function startPgProxy(
           result = stripResponseMessages(result, stripRfq)
 
           // signal replication handler on postgres writes for instant sync
-          if (dbName === 'postgres' && isSimpleQuery && queryText) {
-            const q = queryText.trimStart().toLowerCase()
-            if (
-              q.startsWith('insert') ||
-              q.startsWith('update') ||
-              q.startsWith('delete') ||
-              q.startsWith('copy') ||
-              q.startsWith('truncate')
-            ) {
-              signalReplicationChange()
-            }
+          if (dbName === 'postgres' && queryNorm && isWriteNormalized(queryNorm)) {
+            signalReplicationChange()
           }
 
           return result

package/src/pglite-ipc.ts

@@ -26,13 +26,14 @@ interface PendingRequest {
 const WRITE_PREFIXES = ['insert', 'update', 'delete', 'copy', 'truncate']
 // shard-internal tables that the replication handler filters out.
 // signaling for these just causes spurious wakeups + mutex contention.
-const SHARD_INTERNAL_TABLES = ['"replicas"', '"mutations"', '"replicationState"']
+// pre-lowercased so we don't call toLowerCase() per iteration
+const SHARD_INTERNAL_TABLES = ['"replicas"', '"mutations"', '"replicationstate"']
 function isReplicatedWrite(sql: string): boolean {
   const q = sql.trimStart().toLowerCase()
   if (!WRITE_PREFIXES.some((p) => q.startsWith(p))) return false
   // skip shard-internal writes (zero-cache manages these, not replicated)
   for (const t of SHARD_INTERNAL_TABLES) {
-    if (q.includes(t.toLowerCase())) return false
+    if (q.includes(t)) return false
   }
   return true
 }

package/src/pglite-manager.ts

@@ -78,6 +78,41 @@ export interface PGliteInstances {
   cdb: PGlite
 }
 
+// shared setup extracted from the 4 factory functions below
+
+/** migrate old single-instance pgdata dir to the new pgdata-postgres layout */
+function migrateDataDir(config: ZeroLiteConfig): void {
+  const pgliteDataDir = (config.pgliteOptions as Record<string, any>)?.dataDir
+  if (!pgliteDataDir || !String(pgliteDataDir).startsWith('memory://')) {
+    const oldDataPath = resolve(config.dataDir, 'pgdata')
+    const newDataPath = resolve(config.dataDir, 'pgdata-postgres')
+    if (existsSync(oldDataPath) && !existsSync(newDataPath)) {
+      renameSync(oldDataPath, newDataPath)
+      log.debug.pglite('migrated pgdata → pgdata-postgres')
+    }
+  }
+}
+
+/** create publication if ZERO_APP_PUBLICATIONS is set and publication doesn't exist */
+async function ensurePublication(db: {
+  exec(sql: string): Promise<any>
+  query<T>(sql: string, params?: any[]): Promise<{ rows: T[] }>
+}): Promise<void> {
+  await db.exec('CREATE EXTENSION IF NOT EXISTS plpgsql')
+
+  const pubName = process.env.ZERO_APP_PUBLICATIONS?.trim()
+  if (pubName) {
+    const pubs = await db.query<{ count: string }>(
+      `SELECT count(*) as count FROM pg_publication WHERE pubname = $1`,
+      [pubName]
+    )
+    if (Number(pubs.rows[0].count) === 0) {
+      const quoted = '"' + pubName.replace(/"/g, '""') + '"'
+      await db.exec(`CREATE PUBLICATION ${quoted}`)
+    }
+  }
+}
+
 // create a single pglite instance with given dataDir suffix
 async function createInstance(
   config: ZeroLiteConfig,
@@ -174,40 +209,15 @@ async function createInstance(
 export async function createPGliteInstances(
   config: ZeroLiteConfig
 ): Promise<PGliteInstances> {
-  // migrate from old single-instance layout (pgdata → pgdata-postgres)
-  const pgliteDataDir = (config.pgliteOptions as Record<string, any>)?.dataDir
-  if (!pgliteDataDir || !String(pgliteDataDir).startsWith('memory://')) {
-    const oldDataPath = resolve(config.dataDir, 'pgdata')
-    const newDataPath = resolve(config.dataDir, 'pgdata-postgres')
-    if (existsSync(oldDataPath) && !existsSync(newDataPath)) {
-      renameSync(oldDataPath, newDataPath)
-      log.debug.pglite('migrated pgdata → pgdata-postgres')
-    }
-  }
+  migrateDataDir(config)
 
-  // create all 3 instances in parallel (only postgres needs app extensions)
   const [postgres, cvr, cdb] = await Promise.all([
     createInstance(config, 'postgres', true),
     createInstance(config, 'cvr', false),
     createInstance(config, 'cdb', false),
   ])
 
-  // postgres-specific setup
-  await postgres.exec('CREATE EXTENSION IF NOT EXISTS plpgsql')
-
-  // create publication only when explicitly configured
-  const pubName = process.env.ZERO_APP_PUBLICATIONS?.trim()
-  if (pubName) {
-    const pubs = await postgres.query<{ count: string }>(
-      `SELECT count(*) as count FROM pg_publication WHERE pubname = $1`,
-      [pubName]
-    )
-    if (Number(pubs.rows[0].count) === 0) {
-      const quoted = '"' + pubName.replace(/"/g, '""') + '"'
-      await postgres.exec(`CREATE PUBLICATION ${quoted}`)
-    }
-  }
-
+  await ensurePublication(postgres)
   return { postgres, cvr, cdb }
 }
 
@@ -221,17 +231,9 @@ export async function createPGliteInstances(
 export async function createPGliteWorkerInstances(
   config: ZeroLiteConfig
 ): Promise<PGliteInstances> {
-  // migrate from old single-instance layout (pgdata → pgdata-postgres)
-  const pgliteDataDir = (config.pgliteOptions as Record<string, any>)?.dataDir
-  if (!pgliteDataDir || !String(pgliteDataDir).startsWith('memory://')) {
-    const oldDataPath = resolve(config.dataDir, 'pgdata')
-    const newDataPath = resolve(config.dataDir, 'pgdata-postgres')
-    if (existsSync(oldDataPath) && !existsSync(newDataPath)) {
-      renameSync(oldDataPath, newDataPath)
-      log.debug.pglite('migrated pgdata → pgdata-postgres')
-    }
-  }
+  migrateDataDir(config)
 
+  const pgliteDataDir = (config.pgliteOptions as Record<string, any>)?.dataDir
   const useMemory =
     typeof pgliteDataDir === 'string' && pgliteDataDir.startsWith('memory://')
   const {
@@ -259,32 +261,15 @@ export async function createPGliteWorkerInstances(
 
   log.pglite('starting worker threads for postgres, cvr, cdb')
 
-  // create all 3 worker proxies in parallel
   const pgProxy = new PGliteWorkerProxy(makeWorkerConfig('postgres', true))
   const cvrProxy = new PGliteWorkerProxy(makeWorkerConfig('cvr', false))
   const cdbProxy = new PGliteWorkerProxy(makeWorkerConfig('cdb', false))
 
   await Promise.all([pgProxy.waitReady, cvrProxy.waitReady, cdbProxy.waitReady])
-
   log.pglite('all worker threads ready')
 
-  // postgres-specific setup
-  await pgProxy.exec('CREATE EXTENSION IF NOT EXISTS plpgsql')
-
-  // create publication only when explicitly configured
-  const pubName = process.env.ZERO_APP_PUBLICATIONS?.trim()
-  if (pubName) {
-    const pubs = await pgProxy.query<{ count: string }>(
-      `SELECT count(*) as count FROM pg_publication WHERE pubname = $1`,
-      [pubName]
-    )
-    if (Number(pubs.rows[0].count) === 0) {
-      const quoted = '"' + pubName.replace(/"/g, '""') + '"'
-      await pgProxy.exec(`CREATE PUBLICATION ${quoted}`)
-    }
-  }
+  await ensurePublication(pgProxy)
 
-  // cast to PGlite — our proxy implements the same interface surface
   return {
     postgres: pgProxy as unknown as PGlite,
     cvr: cvrProxy as unknown as PGlite,
@@ -302,36 +287,11 @@ export async function createPGliteWorkerInstances(
 export async function createSinglePGliteInstance(
   config: ZeroLiteConfig
 ): Promise<PGliteInstances> {
-  // migrate from old single-instance layout (pgdata → pgdata-postgres)
-  const pgliteDataDir = (config.pgliteOptions as Record<string, any>)?.dataDir
-  if (!pgliteDataDir || !String(pgliteDataDir).startsWith('memory://')) {
-    const oldDataPath = resolve(config.dataDir, 'pgdata')
-    const newDataPath = resolve(config.dataDir, 'pgdata-postgres')
-    if (existsSync(oldDataPath) && !existsSync(newDataPath)) {
-      renameSync(oldDataPath, newDataPath)
-      log.debug.pglite('migrated pgdata → pgdata-postgres')
-    }
-  }
-
+  migrateDataDir(config)
   log.pglite('starting single shared pglite instance')
 
   const db = await createInstance(config, 'postgres', true)
-
-  // postgres-specific setup
-  await db.exec('CREATE EXTENSION IF NOT EXISTS plpgsql')
-
-  // create publication only when explicitly configured
-  const pubName = process.env.ZERO_APP_PUBLICATIONS?.trim()
-  if (pubName) {
-    const pubs = await db.query<{ count: string }>(
-      `SELECT count(*) as count FROM pg_publication WHERE pubname = $1`,
-      [pubName]
-    )
-    if (Number(pubs.rows[0].count) === 0) {
-      const quoted = '"' + pubName.replace(/"/g, '""') + '"'
-      await db.exec(`CREATE PUBLICATION ${quoted}`)
-    }
-  }
+  await ensurePublication(db)
 
   // same instance for all three — pg-proxy detects this and shares a mutex
   return { postgres: db, cvr: db, cdb: db }
@@ -343,17 +303,9 @@ export async function createSinglePGliteInstance(
 export async function createSinglePGliteWorkerInstance(
   config: ZeroLiteConfig
 ): Promise<PGliteInstances> {
-  // migrate from old single-instance layout (pgdata → pgdata-postgres)
-  const pgliteDataDir = (config.pgliteOptions as Record<string, any>)?.dataDir
-  if (!pgliteDataDir || !String(pgliteDataDir).startsWith('memory://')) {
-    const oldDataPath = resolve(config.dataDir, 'pgdata')
-    const newDataPath = resolve(config.dataDir, 'pgdata-postgres')
-    if (existsSync(oldDataPath) && !existsSync(newDataPath)) {
-      renameSync(oldDataPath, newDataPath)
-      log.debug.pglite('migrated pgdata → pgdata-postgres')
-    }
-  }
+  migrateDataDir(config)
 
+  const pgliteDataDir = (config.pgliteOptions as Record<string, any>)?.dataDir
   const useMemory =
     typeof pgliteDataDir === 'string' && pgliteDataDir.startsWith('memory://')
   const {
@@ -383,21 +335,7 @@ export async function createSinglePGliteWorkerInstance(
   await proxy.waitReady
   log.pglite('single worker thread ready')
 
-  // postgres-specific setup
-  await proxy.exec('CREATE EXTENSION IF NOT EXISTS plpgsql')
-
-  // create publication only when explicitly configured
-  const pubName = process.env.ZERO_APP_PUBLICATIONS?.trim()
-  if (pubName) {
-    const pubs = await proxy.query<{ count: string }>(
-      `SELECT count(*) as count FROM pg_publication WHERE pubname = $1`,
-      [pubName]
-    )
-    if (Number(pubs.rows[0].count) === 0) {
-      const quoted = '"' + pubName.replace(/"/g, '""') + '"'
-      await proxy.exec(`CREATE PUBLICATION ${quoted}`)
-    }
-  }
+  await ensurePublication(proxy)
 
   const db = proxy as unknown as PGlite
   return { postgres: db, cvr: db, cdb: db }

package/src/pglite-web-proxy.ts

@@ -0,0 +1,180 @@
+/**
+ * PGlite Web Worker proxy — browser equivalent of pglite-ipc.ts.
+ *
+ * runs in the zero-cache worker, proxies calls to a Web Worker
+ * running the actual PGlite instance. mirrors PGliteWorkerProxy
+ * from pglite-ipc.ts but uses Web Worker postMessage instead of
+ * node worker_threads.
+ *
+ * ArrayBuffers are transferred (not copied) for execProtocolRaw
+ * to keep IPC overhead near-zero for wire protocol data.
+ */
+
+import { signalReplicationChange } from './replication/handler.js'
+
+interface PendingRequest {
+  resolve: (value: any) => void
+  reject: (error: Error) => void
+}
+
+const WRITE_PREFIXES = ['insert', 'update', 'delete', 'copy', 'truncate']
+const SHARD_INTERNAL_TABLES = ['"replicas"', '"mutations"', '"replicationState"']
+
+function isReplicatedWrite(sql: string): boolean {
+  const q = sql.trimStart().toLowerCase()
+  if (!WRITE_PREFIXES.some((p) => q.startsWith(p))) return false
+  for (const t of SHARD_INTERNAL_TABLES) {
+    if (q.includes(t.toLowerCase())) return false
+  }
+  return true
+}
+
+export class PGliteWebProxy {
+  private worker: Worker
+  private pending = new Map<number, PendingRequest>()
+  private nextId = 1
+  private notificationCallbacks = new Map<string, Set<(payload: string) => void>>()
+  readonly name: string
+
+  readonly waitReady: Promise<void>
+
+  // PGlite compat flags
+  closed = false
+  ready = false
+
+  constructor(worker: Worker, name: string) {
+    this.name = name
+    this.worker = worker
+
+    let onReady: () => void
+    this.waitReady = new Promise<void>((resolveReady, rejectReady) => {
+      onReady = () => {
+        this.ready = true
+        resolveReady()
+      }
+
+      const onMessage = (ev: MessageEvent) => {
+        const msg = ev.data
+        if (msg?.type === 'ready') {
+          this.worker.removeEventListener('message', onMessage)
+          this.installMessageHandler()
+          onReady()
+        } else if (msg?.type === 'error' && msg.id === 0) {
+          rejectReady(new Error(msg.message))
+        }
+      }
+
+      this.worker.addEventListener('message', onMessage)
+      this.worker.addEventListener('error', (ev) => {
+        rejectReady(new Error(String(ev)))
+      })
+    })
+  }
+
+  private installMessageHandler() {
+    this.worker.addEventListener('message', (ev: MessageEvent) => {
+      const msg = ev.data
+      if (!msg || typeof msg !== 'object') return
+
+      if (msg.type === 'notification') {
+        const callbacks = this.notificationCallbacks.get(msg.channel)
+        if (callbacks) {
+          for (const cb of callbacks) {
+            try {
+              cb(msg.payload)
+            } catch {}
+          }
+        }
+        return
+      }
+
+      const req = this.pending.get(msg.id)
+      if (!req) return
+      this.pending.delete(msg.id)
+
+      if (msg.type === 'error') {
+        const err = new Error(msg.message) as Error & { code?: string }
+        if (msg.code) err.code = msg.code
+        req.reject(err)
+      } else {
+        req.resolve(msg)
+      }
+    })
+  }
+
+  private send(msg: Record<string, unknown>, transfer?: Transferable[]): Promise<any> {
+    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)
+      }
+    })
+  }
+
+  async execProtocolRaw(
+    data: Uint8Array,
+    options?: { syncToFs?: boolean; throwOnError?: boolean }
+  ): Promise<Uint8Array> {
+    // copy to a transferable buffer then transfer
+    const buf = new ArrayBuffer(data.byteLength)
+    new Uint8Array(buf).set(data)
+    const result = await this.send({ type: 'execProtocolRaw', data: buf, options }, [buf])
+    return new Uint8Array(result.data)
+  }
+
+  async query<T = any>(
+    sql: string,
+    params?: any[]
+  ): Promise<{ rows: T[]; affectedRows?: number }> {
+    const result = await this.send({ type: 'query', sql, params })
+    // signal replication after writes on postgres instance (like orez-node's PGliteWorkerProxy)
+    if (this.name === 'postgres' && isReplicatedWrite(sql)) {
+      signalReplicationChange()
+    }
+    return { rows: result.rows ?? [], affectedRows: result.affectedRows }
+  }
+
+  async exec(sql: string): Promise<{ affectedRows?: number }[]> {
+    const result = await this.send({ type: 'exec', sql })
+    if (this.name === 'postgres' && isReplicatedWrite(sql)) {
+      signalReplicationChange()
+    }
+    return result.results ?? []
+  }
+
+  async listen(
+    channel: string,
+    callback: (payload: string) => void
+  ): Promise<() => Promise<void>> {
+    let callbacks = this.notificationCallbacks.get(channel)
+    if (!callbacks) {
+      callbacks = new Set()
+      this.notificationCallbacks.set(channel, callbacks)
+    }
+    callbacks.add(callback)
+
+    const result = await this.send({ type: 'listen', channel })
+    const listenId = result.id
+
+    return async () => {
+      callbacks!.delete(callback)
+      if (callbacks!.size === 0) {
+        this.notificationCallbacks.delete(channel)
+      }
+      await this.send({ type: 'unlisten', listenId }).catch(() => {})
+    }
+  }
+
+  async close(): Promise<void> {
+    this.closed = true
+    this.ready = false
+    try {
+      await this.send({ type: 'close' })
+    } catch {}
+    this.worker.terminate()
+  }
+}

package/src/pglite-web-worker.ts

@@ -0,0 +1,132 @@
+/**
+ * PGlite Web Worker — browser equivalent of pglite-worker-thread.ts.
+ *
+ * runs a single PGlite instance in a Web Worker. receives commands via
+ * postMessage, executes on PGlite, sends results back. ArrayBuffers
+ * are transferred (not copied) for execProtocolRaw.
+ *
+ * message protocol (same as pglite-worker-thread.ts):
+ *   init: { type: 'init', dataDir, name, withExtensions, pgliteOptions }
+ *   → { type: 'ready' }
+ *
+ *   execProtocolRaw: { type: 'execProtocolRaw', id, data: ArrayBuffer, options }
+ *   → { type: 'result', id, data: ArrayBuffer }
+ *
+ *   query: { type: 'query', id, sql, params }
+ *   → { type: 'result', id, rows, affectedRows }
+ *
+ *   exec: { type: 'exec', id, sql }
+ *   → { type: 'result', id, results: [{ affectedRows }] }
+ *
+ *   listen/unlisten/close: same as pglite-worker-thread.ts
+ */
+
+// NOTE: this file is meant to be bundled with PGlite as external
+// the consumer provides PGlite via importScripts or ESM import
+
+declare const self: any
+
+const listeners = new Map<number, () => Promise<void>>()
+let db: any // PGlite instance — type depends on how it's loaded
+
+self.onmessage = async (ev: MessageEvent) => {
+  const msg = ev.data
+  if (!msg || typeof msg !== 'object') return
+  const { type, id } = msg
+
+  try {
+    switch (type) {
+      case 'init': {
+        // dynamically import PGlite (external, provided by consumer's bundler)
+        const { PGlite } = await import('@electric-sql/pglite')
+        db = new PGlite({
+          dataDir: msg.dataDir || 'idb://orez-pglite',
+          relaxedDurability: true,
+          ...(msg.pgliteOptions || {}),
+          // extensions loaded by consumer if needed
+        })
+        await db.waitReady
+
+        // tune for throughput
+        await db.exec(`
+          SET work_mem = '16MB';
+          SET jit = off;
+        `)
+
+        self.postMessage({ type: 'ready' })
+        break
+      }
+
+      case 'execProtocolRaw': {
+        const input = new Uint8Array(msg.data as ArrayBuffer)
+        const result = await db.execProtocolRaw(input, msg.options)
+        const buf = new ArrayBuffer(result.byteLength)
+        new Uint8Array(buf).set(result)
+        self.postMessage({ type: 'result', id, data: buf }, [buf])
+        break
+      }
+
+      case 'query': {
+        const result = await db.query(msg.sql, msg.params)
+        self.postMessage({
+          type: 'result',
+          id,
+          rows: result.rows,
+          affectedRows: result.affectedRows,
+        })
+        break
+      }
+
+      case 'exec': {
+        const result = await db.exec(msg.sql)
+        const results = result.map((r: any) => ({ affectedRows: r.affectedRows ?? 0 }))
+        self.postMessage({ type: 'result', id, results })
+        break
+      }
+
+      case 'listen': {
+        const unsub = await db.listen(msg.channel, (payload: string) => {
+          self.postMessage({ type: 'notification', channel: msg.channel, payload })
+        })
+        listeners.set(id, unsub)
+        self.postMessage({ type: 'result', id })
+        break
+      }
+
+      case 'unlisten': {
+        const unsub = listeners.get(msg.listenId)
+        if (unsub) {
+          await unsub()
+          listeners.delete(msg.listenId)
+        }
+        self.postMessage({ type: 'result', id })
+        break
+      }
+
+      case 'close': {
+        for (const unsub of listeners.values()) {
+          await unsub().catch(() => {})
+        }
+        listeners.clear()
+        await db.close()
+        self.postMessage({ type: 'result', id })
+        break
+      }
+
+      default:
+        self.postMessage({
+          type: 'error',
+          id,
+          message: `unknown message type: ${type}`,
+        })
+    }
+  } catch (err: unknown) {
+    const error = err as { message?: string; code?: string }
+    self.postMessage({
+      type: 'error',
+      id,
+      message: error?.message || String(err),
+      code: error?.code,
+    })
+  }
+}

package/src/recovery.ts

@@ -100,9 +100,9 @@ export async function recoverFromCdcCorruption(ctx: RecoveryContext): Promise<vo
 
   // clear upstream replication tracking
   const db = instances.postgres
-  await db.exec(`TRUNCATE _orez.changes`).catch(() => {})
+  await db.exec(`TRUNCATE _orez._zero_changes`).catch(() => {})
   await db.exec(`TRUNCATE _orez._zero_replication_slots`).catch(() => {})
-  await db.exec(`ALTER SEQUENCE _orez.watermark RESTART WITH 1`).catch(() => {})
+  await db.exec(`ALTER SEQUENCE _orez._zero_watermark RESTART WITH 1`).catch(() => {})
 
   // drop stale shard schemas
   const shardSchemas = await db.query<{ schemaname: string }>(

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

@@ -151,7 +151,7 @@ describe('change-tracker', () => {
     try {
       await db.exec(`CREATE PUBLICATION "zero_scope"`)
       await installChangeTracking(db) // reinstall picks up publication scope
-      await db.exec(`TRUNCATE _orez.changes`)
+      await db.exec(`TRUNCATE _orez._zero_changes`)
 
       await db.exec(`INSERT INTO public.items (name, value) VALUES ('x', 1)`)
       const changes = await getChangesSince(db, 0)