orez 0.2.25 → 0.2.27

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

package/src/worker/cf-patches.ts

@@ -5,9 +5,12 @@
  * can run in SINGLE_PROCESS mode on CF Workers where dynamic import()
  * doesn't work.
  *
- * two patches:
+ * five patches:
  * 1. worker-urls.js — replace file:// URLs with zero-worker:// identifiers
- * 2. processes.js — replace dynamic import() with static worker module lookup
+ * 2. server worker entrypoints — disable CLI auto-start blocks
+ * 3. processes.js — replace dynamic import() with static worker module lookup
+ * 4. write-worker-client.js — run zero-cache's replica writer in-process
+ * 5. pgsql-parser — embed libpg-query wasm bytes for Workers
  *
  * usage in a post-build script:
  *
@@ -24,7 +27,10 @@ export function patchZeroCacheForCF(nodeModulesPath: string): void {
   const zcBase = resolve(nodeModulesPath, '@rocicorp', 'zero', 'out', 'zero-cache', 'src')
 
   patchWorkerUrls(zcBase)
+  patchWorkerEntrypoints(zcBase)
   patchProcesses(zcBase)
+  patchWriteWorkerClient(zcBase)
+  patchPgsqlParserWasm(nodeModulesPath)
 }
 
 function patchWorkerUrls(zcBase: string): void {
@@ -50,11 +56,49 @@ export const CHANGE_STREAMER_URL = u("change-streamer");
 export const REAPER_URL = u("reaper");
 export const REPLICATOR_URL = u("replicator");
 export const SYNCER_URL = u("syncer");
+// write-worker is spawned via 'new Worker()' (node:worker_threads), not via
+// childWorker() — it uses its own URL → worker resolution path. we still expose
+// it here so write-worker-client.js can import it without throwing.
+export const WRITE_WORKER_URL = u("write-worker");
 `
   )
   console.log('[orez] patched zero-cache worker-urls.js')
 }
 
+function patchWorkerEntrypoints(zcBase: string): void {
+  const entrypoints = ['main', 'change-streamer', 'reaper', 'replicator', 'syncer']
+
+  for (const entrypoint of entrypoints) {
+    const entrypointPath = resolve(zcBase, 'server', `${entrypoint}.js`)
+    if (!existsSync(entrypointPath)) {
+      console.warn('[orez] zero-cache worker entrypoint not found at', entrypointPath)
+      continue
+    }
+
+    let code = readFileSync(entrypointPath, 'utf-8')
+    if (code.includes('orez-disable-autostart')) {
+      continue
+    }
+
+    const next = code.replace(
+      /if \(!singleProcessMode\(\)\) exitAfter\(\(\) => runWorker\(must\(parentWorker\), process\.env(?:, \.\.\.process\.argv\.slice\(2\))?\)\);/g,
+      '// orez-disable-autostart: childWorker invokes runWorker explicitly in CF embeds.'
+    )
+
+    if (next === code) {
+      console.warn(
+        `[orez] could not find auto-start guard in ${entrypoint}.js. ` +
+          'zero-cache version may have changed — check compatibility.'
+      )
+      continue
+    }
+
+    code = next
+    writeFileSync(entrypointPath, code)
+    console.log(`[orez] patched zero-cache ${entrypoint}.js (disabled auto-start)`)
+  }
+}
+
 function patchProcesses(zcBase: string): void {
   const processesPath = resolve(zcBase, 'types', 'processes.js')
   if (!existsSync(processesPath)) {
@@ -71,6 +115,9 @@ function patchProcesses(zcBase: string): void {
 
   // add static imports of all zero-cache worker modules at the top.
   // these are relative to processes.js location in @rocicorp/zero.
+  // NOTE: mutator.js and write-worker.js don't export a default `runWorker`
+  // (mutator runs via auto-run guard, write-worker spawns via node:worker_threads
+  // not via childWorker()), so they're not in the lookup table.
   const workerImports = `\
 // patched by orez for CF Workers (static imports replace dynamic import())
 import { default as __zc_main } from "../server/main.js";
@@ -95,10 +142,11 @@ const __zc_workers = {
   const staticLookup =
     '((async () => { ' +
     'const _name = moduleUrl.hostname || moduleUrl.pathname.split("/").pop()?.replace(".js",""); ' +
+    'if (process.env.OREZ_DEBUG_WIRE === "1" || globalThis.__OREZ_DEBUG_WIRE__ === true) console.debug("[orez-zc-worker] start", _name, args); ' +
     'const runWorker = __zc_workers[_name]; ' +
     'if (!runWorker) throw new Error("orez: unknown zero-cache worker: " + _name + " (available: " + Object.keys(__zc_workers).join(", ") + ")"); ' +
-    'return { default: runWorker }; ' +
-    '})()).then(async ({ default: runWorker })'
+    'return { default: runWorker, name: _name }; ' +
+    '})()).then(async ({ default: runWorker, name })'
 
   if (!code.includes(dynamicImportPattern)) {
     console.warn(
@@ -112,3 +160,225 @@ const __zc_workers = {
   writeFileSync(processesPath, code)
   console.log('[orez] patched zero-cache processes.js (static worker imports)')
 }
+
+function patchWriteWorkerClient(zcBase: string): void {
+  const clientPath = resolve(zcBase, 'services', 'replicator', 'write-worker-client.js')
+  if (!existsSync(clientPath)) {
+    console.warn('[orez] write-worker-client.js not found at', clientPath)
+    return
+  }
+
+  let code = readFileSync(clientPath, 'utf-8')
+  if (
+    code.includes('orez-inline-write-worker') &&
+    code.includes('__orez_zero_sqlite_role')
+  ) {
+    return
+  }
+
+  if (
+    !code.includes('orez-inline-write-worker') &&
+    !code.includes('import { Worker } from "node:worker_threads";')
+  ) {
+    console.warn(
+      '[orez] could not find node:worker_threads import in write-worker-client.js. ' +
+        'zero-cache version may have changed — check compatibility.'
+    )
+    return
+  }
+
+  writeFileSync(
+    clientPath,
+    `// patched by orez for CF Workers (orez-inline-write-worker)
+import { must } from "../../../../shared/src/must.js";
+import { Database } from "../../../../zqlite/src/db.js";
+import { createLogContext } from "../../server/logging.js";
+import { StatementRunner } from "../../db/statements.js";
+import { getSubscriptionState } from "./schema/replication-state.js";
+import { ChangeProcessor } from "./change-processor.js";
+
+function applyPragmas(db, pragmas) {
+  db.pragma(\`busy_timeout = \${pragmas.busyTimeout}\`);
+  db.pragma(\`analysis_limit = \${pragmas.analysisLimit}\`);
+  if (pragmas.walAutocheckpoint !== void 0) {
+    db.pragma(\`wal_autocheckpoint = \${pragmas.walAutocheckpoint}\`);
+  }
+}
+
+function createAPI(onWriteError) {
+  let db;
+  let runner;
+  let processor;
+  let mode;
+  let lc;
+
+  function createProcessor() {
+    processor = new ChangeProcessor(must(runner), must(mode), (_lc, err) => {
+      onWriteError(err instanceof Error ? err : new Error(String(err)));
+    });
+  }
+
+  return {
+    init(dbPath, cpMode, pragmas, logConfig) {
+      lc = createLogContext({ log: logConfig }, { worker: "write-worker" });
+      const previousRole = globalThis.__orez_zero_sqlite_role;
+      globalThis.__orez_zero_sqlite_role = "replica-writer";
+      try {
+        db = new Database(lc, dbPath);
+      } finally {
+        if (previousRole === void 0) {
+          delete globalThis.__orez_zero_sqlite_role;
+        } else {
+          globalThis.__orez_zero_sqlite_role = previousRole;
+        }
+      }
+      applyPragmas(db, pragmas);
+      runner = new StatementRunner(db);
+      mode = cpMode;
+      createProcessor();
+    },
+    getSubscriptionState() {
+      return getSubscriptionState(must(runner));
+    },
+    processMessage(downstream) {
+      return must(processor).processMessage(must(lc), downstream);
+    },
+    abort() {
+      must(processor).abort(must(lc));
+      createProcessor();
+    },
+    stop() {
+      db?.close();
+      db = void 0;
+      runner = void 0;
+      processor = void 0;
+    },
+  };
+}
+
+class ThreadWriteWorkerClient {
+  #api;
+  #errorHandler = () => {};
+  #writeError = null;
+
+  constructor() {
+    this.#api = createAPI((err) => {
+      this.#writeError = err;
+      this.#errorHandler(err);
+    });
+  }
+
+  async #call(method, args) {
+    if (this.#writeError) throw this.#writeError;
+    try {
+      const result = this.#api[method](...args);
+      if (this.#writeError) throw this.#writeError;
+      return result;
+    } catch (err) {
+      throw err instanceof Error ? err : new Error(String(err));
+    }
+  }
+
+  init(dbPath, mode, pragmas, logConfig) {
+    return this.#call("init", [dbPath, mode, pragmas, logConfig]);
+  }
+
+  getSubscriptionState() {
+    return this.#call("getSubscriptionState", []);
+  }
+
+  processMessage(downstream) {
+    return this.#call("processMessage", [downstream]);
+  }
+
+  abort() {
+    if (!this.#writeError) {
+      try {
+        this.#api.abort();
+      } catch {
+      }
+    }
+  }
+
+  async stop() {
+    await this.#call("stop", []);
+  }
+
+  onError(handler) {
+    this.#errorHandler = handler;
+  }
+}
+
+export { ThreadWriteWorkerClient, applyPragmas };
+`
+  )
+  console.log('[orez] patched zero-cache write-worker-client.js (inline writer)')
+}
+
+function patchPgsqlParserWasm(nodeModulesPath: string): void {
+  const parserIndexPath = resolve(nodeModulesPath, 'libpg-query', 'wasm', 'index.js')
+  const wasmPath = resolve(nodeModulesPath, 'libpg-query', 'wasm', 'libpg-query.wasm')
+
+  if (!existsSync(parserIndexPath) || !existsSync(wasmPath)) {
+    console.warn('[orez] libpg-query wasm files not found under', nodeModulesPath)
+    return
+  }
+
+  let code = readFileSync(parserIndexPath, 'utf-8')
+  if (
+    code.includes('orez-libpg-query-wasm-binary') &&
+    code.includes('__orezLibPgQueryInit')
+  ) {
+    return
+  }
+  if (code.includes('orez-libpg-query-wasm-binary')) {
+    console.warn(
+      '[orez] libpg-query wasm loader already patched with an older shape. ' +
+        'Reinstall libpg-query or restore node_modules before re-patching.'
+    )
+    return
+  }
+
+  const pattern = 'const initPromise = PgQueryModule().then((module) => {'
+  if (!code.includes(pattern)) {
+    console.warn(
+      '[orez] could not find PgQueryModule init in libpg-query wasm index. ' +
+        'pgsql-parser version may have changed — check compatibility.'
+    )
+    return
+  }
+
+  const wasmBase64 = readFileSync(wasmPath).toString('base64')
+  const replacement = `\
+// orez-libpg-query-wasm-binary: embed parser wasm for CF Workers.
+const __orezLibPgQueryWasmBase64 = '${wasmBase64}';
+function __orezLibPgQueryWasmBinary() {
+    const decode = globalThis.atob
+        ? globalThis.atob(__orezLibPgQueryWasmBase64)
+        : Buffer.from(__orezLibPgQueryWasmBase64, 'base64').toString('binary');
+    const bytes = new Uint8Array(decode.length);
+    for (let i = 0; i < decode.length; i++) bytes[i] = decode.charCodeAt(i);
+    return bytes;
+}
+try {
+    const g = globalThis;
+    if (g.self && !g.self.location) g.self.location = { href: 'https://orez.local/libpg-query.js' };
+    if (!g.location) g.location = { href: 'https://orez.local/libpg-query.js' };
+}
+catch {
+}
+const __orezLibPgQueryPreviousProcessType = globalThis.process?.type;
+if (globalThis.process && !globalThis.process.type) globalThis.process.type = 'renderer';
+const __orezLibPgQueryInit = PgQueryModule({ wasmBinary: __orezLibPgQueryWasmBinary() });
+if (globalThis.process && __orezLibPgQueryPreviousProcessType === undefined) {
+    delete globalThis.process.type;
+}
+else if (globalThis.process) {
+    globalThis.process.type = __orezLibPgQueryPreviousProcessType;
+}
+const initPromise = __orezLibPgQueryInit.then((module) => {`
+
+  code = code.replace(pattern, replacement)
+  writeFileSync(parserIndexPath, code)
+  console.log('[orez] patched libpg-query wasm loader (embedded wasm bytes)')
+}

package/src/worker/shims/node-stub.ts

@@ -64,9 +64,38 @@ export function platform() {
 export function tmpdir() {
   return '/tmp'
 }
+export function homedir() {
+  return '/tmp'
+}
 export function availableParallelism() {
   return 1
 }
+export function loadavg() {
+  return [0, 0, 0]
+}
+export function uptime() {
+  return 0
+}
+export function totalmem() {
+  return 128 * 1024 * 1024
+}
+export function freemem() {
+  return 64 * 1024 * 1024
+}
+export function cpus() {
+  return [{ model: 'worker', speed: 0 }]
+}
+export function networkInterfaces() {
+  return {
+    lo: [
+      {
+        address: '127.0.0.1',
+        family: 'IPv4',
+        internal: true,
+      },
+    ],
+  }
+}
 
 // stub for node:crypto
 export function timingSafeEqual(a: unknown, b: unknown) {
@@ -94,7 +123,23 @@ export class Session {
 
 // stub for node:v8
 export function getHeapStatistics() {
-  return { total_heap_size: 0, used_heap_size: 0 }
+  const heapSizeLimit = 128 * 1024 * 1024
+  return {
+    total_heap_size: 64 * 1024 * 1024,
+    total_heap_size_executable: 0,
+    total_physical_size: 64 * 1024 * 1024,
+    total_available_size: 64 * 1024 * 1024,
+    used_heap_size: 32 * 1024 * 1024,
+    heap_size_limit: heapSizeLimit,
+    malloced_memory: 0,
+    peak_malloced_memory: 0,
+    does_zap_garbage: 0,
+    number_of_native_contexts: 1,
+    number_of_detached_contexts: 0,
+    total_global_handles_size: 0,
+    used_global_handles_size: 0,
+    external_memory: 0,
+  }
 }
 
 // stub for node:zlib
@@ -197,9 +242,16 @@ export default {
   hostname,
   platform,
   tmpdir,
+  homedir,
   availableParallelism,
+  loadavg,
+  uptime,
+  totalmem,
+  freemem,
+  cpus,
   arch,
   release,
+  networkInterfaces,
   existsSync,
   readFileSync,
   writeFileSync,

package/src/worker/shims/oxfmt.ts

@@ -0,0 +1,3 @@
+export async function format(_file: string, content: string) {
+  return { code: content }
+}

package/src/worker/shims/postgres-socket.ts

@@ -151,7 +151,7 @@ class MessagePortSocket extends EventEmitter {
     copy.set(bytes)
 
     try {
-      this.port.postMessage(copy.buffer, [copy.buffer])
+      this.port.postMessage(copy.buffer)
     } catch (err) {
       queueMicrotask(() => this.emit('error', err))
       if (typeof encoding === 'function') encoding()