orez 0.2.25 → 0.2.26

package/src/pg-proxy-do-backend.test.ts

@@ -0,0 +1,3890 @@
+import { createServer, type Server } from 'node:http'
+
+import { afterEach, describe, expect, test } from 'vitest'
+
+import { DoBackend } from './pg-proxy-do-backend.js'
+
+const encoder = new TextEncoder()
+let servers: Server[] = []
+
+function cstr(s: string): Uint8Array {
+  const encoded = encoder.encode(s)
+  const out = new Uint8Array(encoded.length + 1)
+  out.set(encoded)
+  return out
+}
+
+function i16(v: number): Uint8Array {
+  const out = new Uint8Array(2)
+  new DataView(out.buffer).setInt16(0, v)
+  return out
+}
+
+function i32(v: number): Uint8Array {
+  const out = new Uint8Array(4)
+  new DataView(out.buffer).setInt32(0, v)
+  return out
+}
+
+function concat(...parts: Uint8Array[]): Uint8Array {
+  const out = new Uint8Array(parts.reduce((sum, part) => sum + part.length, 0))
+  let offset = 0
+  for (const part of parts) {
+    out.set(part, offset)
+    offset += part.length
+  }
+  return out
+}
+
+function msg(type: number, payload: Uint8Array): Uint8Array {
+  return concat(new Uint8Array([type]), i32(payload.length + 4), payload)
+}
+
+function parseMessage(sql: string, name = '', paramOIDs: number[] = []): Uint8Array {
+  return msg(
+    0x50,
+    concat(
+      cstr(name),
+      cstr(sql),
+      i16(paramOIDs.length),
+      ...paramOIDs.map((oid) => {
+        const out = new Uint8Array(4)
+        new DataView(out.buffer).setUint32(0, oid)
+        return out
+      })
+    )
+  )
+}
+
+function describeStatement(name = ''): Uint8Array {
+  return msg(0x44, concat(encoder.encode('S'), cstr(name)))
+}
+
+function describePortal(name = ''): Uint8Array {
+  return msg(0x44, concat(encoder.encode('P'), cstr(name)))
+}
+
+function bindStatement(statement = '', portal = ''): Uint8Array {
+  return msg(0x42, concat(cstr(portal), cstr(statement), i16(0), i16(0), i16(0)))
+}
+
+function bindStatementParams(params: unknown[], statement = '', portal = ''): Uint8Array {
+  return msg(
+    0x42,
+    concat(
+      cstr(portal),
+      cstr(statement),
+      i16(0),
+      i16(params.length),
+      ...params.map((param) => {
+        if (param === null || param === undefined) return i32(-1)
+        const encoded = encoder.encode(String(param))
+        return concat(i32(encoded.length), encoded)
+      }),
+      i16(0)
+    )
+  )
+}
+
+function executePortal(portal = ''): Uint8Array {
+  return msg(0x45, concat(cstr(portal), i32(0)))
+}
+
+function closePortal(name = ''): Uint8Array {
+  return msg(0x43, concat(encoder.encode('P'), cstr(name)))
+}
+
+function closeStatement(name = ''): Uint8Array {
+  return msg(0x43, concat(encoder.encode('S'), cstr(name)))
+}
+
+function messageTypes(data: Uint8Array): string[] {
+  const types: string[] = []
+  for (let offset = 0; offset < data.length; ) {
+    types.push(String.fromCharCode(data[offset]))
+    const len = new DataView(data.buffer, data.byteOffset + offset + 1, 4).getInt32(0)
+    offset += 1 + len
+  }
+  return types
+}
+
+function readyForQueryStatuses(data: Uint8Array): string[] {
+  const statuses: string[] = []
+  for (let offset = 0; offset < data.length; ) {
+    const type = data[offset]
+    const len = new DataView(data.buffer, data.byteOffset + offset + 1, 4).getInt32(0)
+    if (type === 0x5a) statuses.push(String.fromCharCode(data[offset + 5]))
+    offset += 1 + len
+  }
+  return statuses
+}
+
+function rowDescriptionOids(data: Uint8Array): Record<string, number> {
+  const oids: Record<string, number> = {}
+  for (let offset = 0; offset < data.length; ) {
+    const type = data[offset]
+    const len = new DataView(data.buffer, data.byteOffset + offset + 1, 4).getInt32(0)
+    if (type === 0x54) {
+      const view = new DataView(data.buffer, data.byteOffset + offset, 1 + len)
+      const count = view.getInt16(5)
+      let pos = 7
+      for (let i = 0; i < count; i++) {
+        const nameStart = pos
+        while (pos < 1 + len && data[offset + pos] !== 0) pos++
+        const name = new TextDecoder().decode(
+          data.subarray(offset + nameStart, offset + pos)
+        )
+        pos++
+        pos += 6
+        oids[name] = view.getUint32(pos)
+        pos += 12
+      }
+    }
+    offset += 1 + len
+  }
+  return oids
+}
+
+function rowDescriptionNames(data: Uint8Array): string[] {
+  for (let offset = 0; offset < data.length; ) {
+    const type = data[offset]
+    const len = new DataView(data.buffer, data.byteOffset + offset + 1, 4).getInt32(0)
+    if (type === 0x54) {
+      const view = new DataView(data.buffer, data.byteOffset + offset, 1 + len)
+      const count = view.getInt16(5)
+      let pos = 7
+      const names: string[] = []
+      for (let i = 0; i < count; i++) {
+        const nameStart = pos
+        while (pos < 1 + len && data[offset + pos] !== 0) pos++
+        names.push(
+          new TextDecoder().decode(data.subarray(offset + nameStart, offset + pos))
+        )
+        pos += 19
+      }
+      return names
+    }
+    offset += 1 + len
+  }
+  return []
+}
+
+function parameterDescriptionOids(data: Uint8Array): number[] {
+  for (let offset = 0; offset < data.length; ) {
+    const type = data[offset]
+    const len = new DataView(data.buffer, data.byteOffset + offset + 1, 4).getInt32(0)
+    if (type === 0x74) {
+      const view = new DataView(data.buffer, data.byteOffset + offset, 1 + len)
+      const count = view.getInt16(5)
+      return Array.from({ length: count }, (_, index) => view.getUint32(7 + index * 4))
+    }
+    offset += 1 + len
+  }
+  return []
+}
+
+function dataRowValues(data: Uint8Array): (string | null)[][] {
+  const rows: (string | null)[][] = []
+  for (let offset = 0; offset < data.length; ) {
+    const type = data[offset]
+    const len = new DataView(data.buffer, data.byteOffset + offset + 1, 4).getInt32(0)
+    if (type === 0x44) {
+      const view = new DataView(data.buffer, data.byteOffset + offset, 1 + len)
+      const count = view.getInt16(5)
+      let pos = 7
+      const row: (string | null)[] = []
+      for (let i = 0; i < count; i++) {
+        const valueLength = view.getInt32(pos)
+        pos += 4
+        if (valueLength === -1) {
+          row.push(null)
+          continue
+        }
+        row.push(
+          new TextDecoder().decode(
+            data.subarray(offset + pos, offset + pos + valueLength)
+          )
+        )
+        pos += valueLength
+      }
+      rows.push(row)
+    }
+    offset += 1 + len
+  }
+  return rows
+}
+
+function compactSQL(sql: string): string {
+  return sql.replace(/\s+/g, ' ').trim()
+}
+
+function sqlContaining(sqls: string[], needle: string): string {
+  const found = [...sqls].reverse().find((sql) => compactSQL(sql).includes(needle))
+  expect(found).toBeDefined()
+  return found ?? ''
+}
+
+function startDoHttp(
+  handler: (sql: string, url: URL) => { rows?: unknown[]; columns?: string[] } | Response
+): Promise<{
+  url: string
+  requests: URL[]
+  sqls: string[]
+  params: unknown[][]
+  bodies: any[]
+}> {
+  const requests: URL[] = []
+  const sqls: string[] = []
+  const params: unknown[][] = []
+  const bodies: any[] = []
+  const server = createServer(async (req, res) => {
+    const url = new URL(req.url || '/', 'http://127.0.0.1')
+    requests.push(url)
+    let body = ''
+    req.on('data', (chunk) => {
+      body += chunk
+    })
+    req.on('end', () => {
+      const parsed = body ? JSON.parse(body) : {}
+      bodies.push(parsed)
+      if (url.pathname === '/batch') {
+        const statements = Array.isArray(parsed.statements) ? parsed.statements : []
+        sqls.push(
+          ...statements.map((statement: any) =>
+            typeof statement === 'string' ? statement : statement.sql
+          )
+        )
+        res.setHeader('content-type', 'application/json')
+        res.end(
+          JSON.stringify({
+            results: statements.map(() => ({ rows: [], columns: [] })),
+          })
+        )
+        return
+      }
+      const sql = parsed.sql || ''
+      sqls.push(sql)
+      params.push(Array.isArray(parsed.params) ? parsed.params : [])
+      const result = handler(sql, url)
+      if (result instanceof Response) {
+        res.statusCode = result.status
+        result.text().then((text) => res.end(text))
+        return
+      }
+      res.setHeader('content-type', 'application/json')
+      res.end(JSON.stringify({ rows: result.rows ?? [], columns: result.columns ?? [] }))
+    })
+  })
+  servers.push(server)
+
+  return new Promise((resolve, reject) => {
+    server.once('error', reject)
+    server.listen(0, '127.0.0.1', () => {
+      const addr = server.address()
+      if (!addr || typeof addr === 'string') {
+        reject(new Error('server did not bind to a tcp port'))
+        return
+      }
+      resolve({
+        url: `http://127.0.0.1:${addr.port}`,
+        requests,
+        sqls,
+        params,
+        bodies,
+      })
+    })
+  })
+}
+
+afterEach(async () => {
+  await Promise.all(
+    servers.map(
+      (server) =>
+        new Promise<void>((resolve) => {
+          server.close(() => resolve())
+        })
+    )
+  )
+  servers = []
+})
+
+describe('DoBackend', () => {
+  test('sends the configured Durable Object namespace on every SQL request', async () => {
+    const http = await startDoHttp(() => ({ rows: [{ ok: 1 }], columns: ['ok'] }))
+    const backend = new DoBackend(http.url, 'postgres', 'chat-test-namespace')
+    await backend.waitReady
+
+    await backend.query('SELECT 1 AS ok')
+
+    expect(http.requests.length).toBeGreaterThanOrEqual(2)
+    expect(http.requests.every((url) => url.searchParams.get('db') === 'postgres')).toBe(
+      true
+    )
+    expect(
+      http.requests.every((url) => url.searchParams.get('ns') === 'chat-test-namespace')
+    ).toBe(true)
+  })
+
+  test('describes prepared statements with parameter and row metadata', async () => {
+    const http = await startDoHttp((sql) => {
+      if (sql.includes('_orez_describe')) return { rows: [], columns: ['value'] }
+      return { rows: [{ value: 'ok' }], columns: ['value'] }
+    })
+    const backend = new DoBackend(http.url, 'postgres', 'describe-test')
+    await backend.waitReady
+
+    expect(
+      messageTypes(
+        await backend.execProtocolRaw(parseMessage('SELECT $1 AS value', '', [25]))
+      )
+    ).toEqual(['1'])
+    expect(messageTypes(await backend.execProtocolRaw(describeStatement()))).toEqual([
+      't',
+      'T',
+    ])
+  })
+
+  test('returns row metadata for zero-row selects', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: ['id'] }))
+    const backend = new DoBackend(http.url, 'postgres', 'zero-row-test')
+    await backend.waitReady
+
+    const result = await backend.execProtocolRaw(
+      msg(0x51, cstr('SELECT id FROM message WHERE 1 = 0'))
+    )
+
+    expect(messageTypes(result)).toEqual(['T', 'C', 'Z'])
+  })
+
+  test('rewrites pg_column_size totals as ordinary SQL instead of catalog probes', async () => {
+    const http = await startDoHttp((sql) => {
+      if (compactSQL(sql).includes('length')) {
+        return { rows: [{ totalBytes: 42 }], columns: ['totalBytes'] }
+      }
+      return { rows: [], columns: [] }
+    })
+    const backend = new DoBackend(http.url, 'postgres', 'pg-column-size-test')
+    await backend.waitReady
+
+    await backend.execProtocolRaw(
+      parseMessage(`
+        SELECT (
+          SUM(COALESCE(pg_column_size("id"), 0)) +
+          SUM(COALESCE(pg_column_size("payload"), 0))
+        ) AS "totalBytes"
+        FROM public.message
+      `)
+    )
+    await backend.execProtocolRaw(bindStatement())
+    const result = await backend.execProtocolRaw(executePortal())
+
+    const sent = compactSQL(http.sqls.at(-1) || '')
+    expect(messageTypes(result)).toEqual(['T', 'D', 'C'])
+    expect(dataRowValues(result)).toEqual([['42']])
+    expect(sent).toContain('length')
+    expect(sent).toContain('FROM message')
+    expect(sent).not.toContain('pg_column_size')
+    expect(sent).not.toContain('public.message')
+  })
+
+  test('streams COPY TO STDOUT from a parsed select query', async () => {
+    const http = await startDoHttp(() => ({
+      rows: [{ id: 'm1', deleted: 0 }],
+      columns: ['id', 'deleted'],
+    }))
+    const backend = new DoBackend(http.url, 'postgres', 'copy-test')
+    await backend.waitReady
+    await backend.exec(`
+      CREATE TABLE public.message (
+        id text PRIMARY KEY,
+        deleted boolean NOT NULL DEFAULT false
+      )
+    `)
+
+    const result = await backend.execProtocolRaw(
+      msg(0x51, cstr('COPY (SELECT id, deleted FROM public.message) TO STDOUT'))
+    )
+
+    expect(messageTypes(result)).toEqual(['H', 'd', 'c', 'C', 'Z'])
+    expect(new TextDecoder().decode(result)).toContain('m1\tf\n')
+    expect(http.sqls.some((sql) => compactSQL(sql).includes('FROM message'))).toBe(true)
+  })
+
+  test('formats timestamp typed rows as postgres text for DataRow and COPY', async () => {
+    const http = await startDoHttp((sql) => {
+      if (compactSQL(sql).startsWith('SELECT')) {
+        return {
+          rows: [
+            { id: 'm1', createdAt: '2026-05-25T20:17:28.377Z' },
+            { id: 'm2', createdAt: '1779746873949.0' },
+          ],
+          columns: ['id', 'createdAt'],
+        }
+      }
+      return { rows: [], columns: [] }
+    })
+    const backend = new DoBackend(http.url, 'postgres', 'timestamp-format-test')
+    await backend.waitReady
+
+    await backend.exec(`
+      CREATE TABLE public.message (
+        id text PRIMARY KEY,
+        "createdAt" timestamptz NOT NULL
+      )
+    `)
+
+    const select = await backend.execProtocolRaw(
+      msg(0x51, cstr('SELECT id, "createdAt" FROM public.message'))
+    )
+    const copy = await backend.execProtocolRaw(
+      msg(0x51, cstr('COPY (SELECT id, "createdAt" FROM public.message) TO STDOUT'))
+    )
+
+    expect(rowDescriptionOids(select)).toMatchObject({ createdAt: 1184 })
+    expect(dataRowValues(select)).toEqual([
+      ['m1', '2026-05-25 20:17:28.377+00'],
+      ['m2', '2026-05-25 22:07:53.949+00'],
+    ])
+    expect(new TextDecoder().decode(copy)).toContain('m1\t2026-05-25 20:17:28.377+00\n')
+    expect(new TextDecoder().decode(copy)).toContain('m2\t2026-05-25 22:07:53.949+00\n')
+  })
+
+  test('normalizes timestamp typed parameters before sending them to SQLite', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'timestamp-param-test')
+    await backend.waitReady
+
+    await backend.exec(`
+      CREATE TABLE public.event (
+        id text PRIMARY KEY,
+        "createdAt" timestamptz NOT NULL
+      )
+    `)
+    await backend.exec(`
+      CREATE TABLE public.notification (
+        id text PRIMARY KEY,
+        "seenAt" timestamptz
+      )
+    `)
+
+    await backend.execProtocolRaw(
+      parseMessage(
+        'INSERT INTO public.event (id, "createdAt") VALUES ($1, $2)',
+        'insert_timestamp'
+      )
+    )
+    const insertDescribe = await backend.execProtocolRaw(
+      describeStatement('insert_timestamp')
+    )
+    expect(parameterDescriptionOids(insertDescribe)).toEqual([25, 1184])
+    await backend.execProtocolRaw(
+      bindStatementParams(['e1', 1779746873949], 'insert_timestamp')
+    )
+    await backend.execProtocolRaw(executePortal())
+
+    await backend.execProtocolRaw(
+      parseMessage(
+        'UPDATE public.event SET "createdAt" = $1 WHERE id = $2',
+        'update_timestamp'
+      )
+    )
+    const updateDescribe = await backend.execProtocolRaw(
+      describeStatement('update_timestamp')
+    )
+    expect(parameterDescriptionOids(updateDescribe)).toEqual([1184, 25])
+    await backend.execProtocolRaw(
+      bindStatementParams([1779746874950, 'e1'], 'update_timestamp')
+    )
+    await backend.execProtocolRaw(executePortal())
+
+    await backend.execProtocolRaw(
+      parseMessage(
+        'INSERT INTO public.notification (id, "seenAt") VALUES ($1, $2)',
+        'insert_null_timestamp'
+      )
+    )
+    const nullDescribe = await backend.execProtocolRaw(
+      describeStatement('insert_null_timestamp')
+    )
+    expect(parameterDescriptionOids(nullDescribe)).toEqual([25, 1184])
+    await backend.execProtocolRaw(
+      bindStatementParams(['n1', null], 'insert_null_timestamp')
+    )
+    await backend.execProtocolRaw(executePortal())
+
+    expect(http.params.at(-3)).toEqual(['e1', '2026-05-25 22:07:53.949+00'])
+    expect(http.params.at(-2)).toEqual(['2026-05-25 22:07:54.950+00', 'e1'])
+    expect(http.params.at(-1)).toEqual(['n1', null])
+  })
+
+  test('normalizes boolean parameters before sending them to SQLite', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'boolean-param-test')
+    await backend.waitReady
+
+    await backend.exec(`
+      CREATE TABLE public.flag_probe (
+        id text PRIMARY KEY,
+        enabled boolean NOT NULL
+      )
+    `)
+    await backend.execProtocolRaw(
+      parseMessage('INSERT INTO public.flag_probe (id, enabled) VALUES ($1, $2)')
+    )
+    await backend.execProtocolRaw(bindStatementParams(['f1', false]))
+    await backend.execProtocolRaw(executePortal())
+    await backend.execProtocolRaw(bindStatementParams(['t1', true]))
+    await backend.execProtocolRaw(executePortal())
+
+    expect(http.params.at(-2)).toEqual(['f1', 0])
+    expect(http.params.at(-1)).toEqual(['t1', 1])
+  })
+
+  test('normalizes boolean parameters through text cast chains', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'boolean-text-cast-param-test')
+    await backend.waitReady
+
+    await backend.query(
+      'SELECT id FROM public.flag_probe WHERE enabled = $1::text::boolean OR enabled = $1::text::boolean',
+      ['false']
+    )
+
+    expect(http.params.at(-1)).toEqual([0, 0])
+  })
+
+  test('infers JSON parameters in inserts and ON CONFLICT updates', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'json-param-test')
+    await backend.waitReady
+
+    await backend.exec(`
+      CREATE TABLE public.client_state (
+        id text PRIMARY KEY,
+        "clientSchema" jsonb
+      )
+    `)
+
+    await backend.execProtocolRaw(
+      parseMessage(
+        `INSERT INTO public.client_state (id, "clientSchema")
+         VALUES ($1, $2)
+         ON CONFLICT (id) DO UPDATE SET "clientSchema" = $3`,
+        'json_upsert'
+      )
+    )
+    const describe = await backend.execProtocolRaw(describeStatement('json_upsert'))
+    expect(parameterDescriptionOids(describe)).toEqual([25, 3802, 3802])
+
+    await backend.query(
+      `INSERT INTO public.client_state (id, "clientSchema")
+       VALUES ($1, $2)
+       ON CONFLICT (id) DO UPDATE SET "clientSchema" = $3`,
+      ['cg', { tables: { insert: true } }, { tables: { update: true } }]
+    )
+
+    expect(http.params.at(-1)).toEqual([
+      'cg',
+      '{"tables":{"insert":true}}',
+      '{"tables":{"update":true}}',
+    ])
+  })
+
+  test('returns aliased current_setting catalog values needed by zero-cache', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'current-setting-test')
+    await backend.waitReady
+
+    const result = await (backend as any).handleCatalogQuery(`
+      SELECT current_setting('wal_level') as "walLevel",
+             current_setting('server_version_num') as "version";
+    `)
+
+    expect(result.fields.map((field: any) => field.name)).toEqual(['walLevel', 'version'])
+    expect(result.rows).toEqual([{ walLevel: 'logical', version: '160000' }])
+
+    const rewrittenResult = await (backend as any).handleCatalogQuery(`
+      SELECT 'logical'::text as "walLevel",
+             current_setting('server_version_num') as "version";
+    `)
+
+    expect(rewrittenResult.fields.map((field: any) => field.name)).toEqual([
+      'walLevel',
+      'version',
+    ])
+    expect(rewrittenResult.rows).toEqual([{ walLevel: 'logical', version: '160000' }])
+  })
+
+  test('projects pg_settings expressions from synthesized settings rows', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'pg-settings-test')
+    await backend.waitReady
+
+    const result = await (backend as any).handleCatalogQuery(`
+      SELECT EXTRACT(EPOCH FROM (setting || unit)::interval) * 1000
+        AS "walSenderTimeoutMs"
+      FROM pg_settings
+      WHERE name = 'wal_sender_timeout'
+    `)
+
+    expect(result.fields).toEqual([{ name: 'walSenderTimeoutMs', oid: 701 }])
+    expect(result.rows).toEqual([{ walSenderTimeoutMs: 60000 }])
+  })
+
+  test('returns requested pg_publication rows for zero-cache validation', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'publication-test')
+    await backend.waitReady
+    await backend.exec('CREATE PUBLICATION zero_chat FOR TABLE message')
+
+    const result = await (backend as any).handleCatalogQuery(`
+      SELECT pubname FROM pg_publication WHERE pubname IN ('zero_chat')
+    `)
+
+    expect(result.fields.map((field: any) => field.name)).toEqual(['pubname'])
+    expect(result.rows).toEqual([{ pubname: 'zero_chat' }])
+  })
+
+  test('executes the portal named by extended-protocol Execute', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: ['value'] }))
+    const backend = new DoBackend(http.url, 'postgres', 'portal-execute-test')
+    await backend.waitReady
+    await backend.exec('CREATE PUBLICATION zero_chat FOR TABLE message')
+
+    await backend.execProtocolRaw(
+      parseMessage('SELECT value FROM ordinary WHERE id = $1', 'ordinary')
+    )
+    await backend.execProtocolRaw(
+      bindStatementParams(['ignore'], 'ordinary', 'ordinary_portal')
+    )
+    await backend.execProtocolRaw(
+      parseMessage(
+        'SELECT pubname FROM pg_publication WHERE pubname IN ($1)',
+        'publication'
+      )
+    )
+    await backend.execProtocolRaw(
+      bindStatementParams(['zero_chat'], 'publication', 'publication_portal')
+    )
+
+    const result = await backend.execProtocolRaw(executePortal('publication_portal'))
+
+    expect(messageTypes(result)).toEqual(['T', 'D', 'C'])
+    expect(new TextDecoder().decode(result)).toContain('zero_chat')
+    expect(http.sqls.some((sql) => compactSQL(sql).includes('FROM ordinary'))).toBe(false)
+  })
+
+  test('describes and closes bound portals by portal name', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: ['value'] }))
+    const backend = new DoBackend(http.url, 'postgres', 'portal-describe-test')
+    await backend.waitReady
+
+    await backend.execProtocolRaw(parseMessage('SELECT $1 AS value', 'statement', [25]))
+    await backend.execProtocolRaw(bindStatementParams(['ok'], 'statement', 'portal'))
+
+    expect(messageTypes(await backend.execProtocolRaw(describePortal('portal')))).toEqual(
+      ['T']
+    )
+    expect(messageTypes(await backend.execProtocolRaw(closePortal('portal')))).toEqual([
+      '3',
+    ])
+    expect(messageTypes(await backend.execProtocolRaw(describePortal('portal')))).toEqual(
+      ['n']
+    )
+
+    await backend.execProtocolRaw(bindStatementParams(['ok'], 'statement', 'portal'))
+    expect(
+      messageTypes(await backend.execProtocolRaw(closeStatement('statement')))
+    ).toEqual(['3'])
+    expect(messageTypes(await backend.execProtocolRaw(describePortal('portal')))).toEqual(
+      ['n']
+    )
+  })
+
+  test('returns publication flags with boolean oids for zero-cache schema checks', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'publication-flags-test')
+    await backend.waitReady
+    await backend.exec(`
+      CREATE PUBLICATION zero_chat FOR TABLE message;
+      CREATE PUBLICATION _zero_metadata FOR TABLE "_zero"."clients";
+    `)
+
+    const result = await (backend as any).handleCatalogQuery(`
+      SELECT pubname,pubinsert,pubupdate,pubdelete,pubtruncate FROM pg_publication pb
+      WHERE pb.pubname IN ('zero_chat','_zero_metadata')
+      ORDER BY pubname
+    `)
+
+    expect(result.fields).toEqual([
+      { name: 'pubname', oid: undefined },
+      { name: 'pubinsert', oid: 16 },
+      { name: 'pubupdate', oid: 16 },
+      { name: 'pubdelete', oid: 16 },
+      { name: 'pubtruncate', oid: 16 },
+    ])
+    expect(result.rows).toEqual([
+      {
+        pubname: '_zero_metadata',
+        pubinsert: 't',
+        pubupdate: 't',
+        pubdelete: 't',
+        pubtruncate: 't',
+      },
+      {
+        pubname: 'zero_chat',
+        pubinsert: 't',
+        pubupdate: 't',
+        pubdelete: 't',
+        pubtruncate: 't',
+      },
+    ])
+  })
+
+  test('preserves selected field metadata for empty catalog probes', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'pg-class-probe-test')
+    await backend.waitReady
+
+    const result = await (backend as any).handleCatalogQuery(`
+      SELECT nspname, relname FROM pg_class
+      JOIN pg_namespace ON relnamespace = pg_namespace.oid
+      WHERE nspname = 'chat_0' AND relname = 'versionHistory'
+    `)
+
+    expect(result.rows).toEqual([])
+    expect(result.fields.map((field: any) => field.name)).toEqual(['nspname', 'relname'])
+  })
+
+  test('synthesizes advisory lock catalog calls with one null row', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'advisory-lock-test')
+    await backend.waitReady
+
+    const result = await (backend as any).handleCatalogQuery(`
+      SELECT pg_advisory_xact_lock(hashtext('migrate-schema:chat_0'))
+    `)
+
+    expect(result.fields.map((field: any) => field.name)).toEqual([
+      'pg_advisory_xact_lock',
+    ])
+    expect(result.rows).toEqual([{ pg_advisory_xact_lock: null }])
+  })
+
+  test('synthesizes logical message lag-report probes', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'logical-message-test')
+    await backend.waitReady
+
+    const result = await (backend as any).handleCatalogQuery(`
+      WITH CTE AS (SELECT extract(epoch from now()) * 1000 AS "commitTimeMs")
+      SELECT "commitTimeMs", pg_logical_emit_message(
+        false,
+        'zero/0',
+        json_build_object(
+          'id', 'lag-1'::text,
+          'sendTimeMs', 1::int8,
+          'commitTimeMs', "commitTimeMs"
+        )::text
+      ) as lsn FROM CTE;
+    `)
+
+    expect(result.fields.map((field: any) => field.name)).toEqual(['commitTimeMs', 'lsn'])
+    expect(result.rows[0]).toEqual({
+      commitTimeMs: expect.any(Number),
+      lsn: '0/1',
+    })
+
+    const wire = await backend.execProtocolRaw(
+      msg(
+        0x51,
+        cstr(`
+          WITH CTE AS (SELECT extract(epoch from now()) * 1000 AS "commitTimeMs")
+          SELECT "commitTimeMs", pg_logical_emit_message(
+            false,
+            'zero/0',
+            json_build_object(
+              'id', 'lag-1'::text,
+              'sendTimeMs', 1::int8,
+              'commitTimeMs', "commitTimeMs"
+            )::text
+          ) as lsn FROM CTE;
+        `)
+      )
+    )
+    expect(rowDescriptionOids(wire)).toMatchObject({
+      commitTimeMs: 701,
+      lsn: 25,
+    })
+  })
+
+  test('synthesizes pg_tables from sqlite schema for publication setup', async () => {
+    const http = await startDoHttp((sql) => {
+      if (sql.includes('sqlite_master')) {
+        return {
+          rows: [
+            { name: 'message', sql: 'CREATE TABLE message (id varchar PRIMARY KEY)' },
+            { name: 'user', sql: 'CREATE TABLE user (id varchar PRIMARY KEY)' },
+            {
+              name: 'public_migrations',
+              sql: 'CREATE TABLE public_migrations (id integer PRIMARY KEY)',
+            },
+          ],
+          columns: ['name', 'sql'],
+        }
+      }
+      if (sql.includes('PRAGMA table_info("message")')) {
+        return {
+          rows: [
+            { cid: 0, name: 'id', type: 'varchar', notnull: 1, dflt_value: null, pk: 1 },
+          ],
+          columns: ['cid', 'name', 'type', 'notnull', 'dflt_value', 'pk'],
+        }
+      }
+      return { rows: [], columns: [] }
+    })
+    const backend = new DoBackend(http.url, 'postgres', 'pg-tables-test')
+    await backend.waitReady
+
+    const result = await (backend as any).handleCatalogQuery(`
+      SELECT tablename FROM pg_tables
+      WHERE schemaname = 'public'
+        AND tablename != ALL('{"user","migrations"}')
+    `)
+
+    expect(result.rows).toEqual([{ tablename: 'message' }])
+  })
+
+  test('synthesizes information_schema.columns from parsed DDL metadata', async () => {
+    const http = await startDoHttp((sql) => {
+      if (sql.includes('sqlite_master')) {
+        return {
+          rows: [
+            {
+              name: 'message',
+              sql: 'CREATE TABLE message (id varchar, payload text, enabled integer, tags text)',
+            },
+          ],
+          columns: ['name', 'sql'],
+        }
+      }
+      if (sql.includes('PRAGMA table_info("message")')) {
+        return {
+          rows: [
+            { cid: 0, name: 'id', type: 'varchar', notnull: 1, dflt_value: null, pk: 1 },
+            {
+              cid: 1,
+              name: 'payload',
+              type: 'text',
+              notnull: 0,
+              dflt_value: null,
+              pk: 0,
+            },
+            {
+              cid: 2,
+              name: 'enabled',
+              type: 'integer',
+              notnull: 1,
+              dflt_value: '0',
+              pk: 0,
+            },
+            { cid: 3, name: 'tags', type: 'text', notnull: 0, dflt_value: null, pk: 0 },
+          ],
+          columns: ['cid', 'name', 'type', 'notnull', 'dflt_value', 'pk'],
+        }
+      }
+      return { rows: [], columns: [] }
+    })
+    const backend = new DoBackend(http.url, 'postgres', 'information-schema-test')
+    await backend.waitReady
+    await backend.exec(`
+      CREATE TABLE public.message (
+        id varchar(64) PRIMARY KEY,
+        payload jsonb,
+        enabled boolean NOT NULL DEFAULT false,
+        tags text[]
+      )
+    `)
+
+    const result = await (backend as any).handleCatalogQuery(`
+      SELECT
+          c.table_schema::text AS schema,
+          c.table_name::text AS table,
+          c.column_name::text AS column,
+          c.data_type::text AS "dataType",
+          c.character_maximum_length AS length,
+          c.numeric_precision AS precision,
+          c.numeric_scale AS scale,
+          t.typtype::text AS typtype,
+          t.typname::text AS typename,
+          CASE WHEN t.typelem <> 0 THEN et.typtype::text ELSE NULL END AS "elemTyptype",
+          CASE WHEN t.typelem <> 0 THEN et.typname::text ELSE NULL END AS "elemTypname"
+      FROM information_schema.columns c
+      JOIN pg_catalog.pg_type t ON c.udt_name = t.typname
+      LEFT JOIN pg_catalog.pg_type et ON t.typelem = et.oid
+      JOIN pg_catalog.pg_namespace n ON t.typnamespace = n.oid
+      WHERE (c.table_schema, c.table_name) IN (('public'::text, 'message'::text))
+    `)
+
+    expect(result.rows).toEqual([
+      expect.objectContaining({
+        column: 'id',
+        dataType: 'character varying',
+        length: 64,
+        typtype: 'b',
+        typename: 'varchar',
+        elemTyptype: null,
+      }),
+      expect.objectContaining({
+        column: 'payload',
+        dataType: 'jsonb',
+        typename: 'jsonb',
+      }),
+      expect.objectContaining({
+        column: 'enabled',
+        dataType: 'boolean',
+        typename: 'bool',
+      }),
+      expect.objectContaining({
+        column: 'tags',
+        dataType: 'ARRAY',
+        typename: '_text',
+        elemTyptype: 'b',
+        elemTypname: 'text',
+      }),
+    ])
+  })
+
+  test('tracks parser-backed publication membership without private table lists', async () => {
+    const http = await startDoHttp((sql) => {
+      if (sql.includes('sqlite_master')) {
+        return {
+          rows: [
+            { name: 'message', sql: 'CREATE TABLE message (id text)' },
+            { name: 'account', sql: 'CREATE TABLE account (id text)' },
+          ],
+          columns: ['name', 'sql'],
+        }
+      }
+      if (sql.includes('PRAGMA table_info("message")')) {
+        return {
+          rows: [
+            { cid: 0, name: 'id', type: 'text', notnull: 1, dflt_value: null, pk: 1 },
+          ],
+          columns: ['cid', 'name', 'type', 'notnull', 'dflt_value', 'pk'],
+        }
+      }
+      if (sql.includes('PRAGMA table_info("account")')) {
+        return {
+          rows: [
+            { cid: 0, name: 'id', type: 'text', notnull: 1, dflt_value: null, pk: 1 },
+          ],
+          columns: ['cid', 'name', 'type', 'notnull', 'dflt_value', 'pk'],
+        }
+      }
+      return { rows: [], columns: [] }
+    })
+    const backend = new DoBackend(http.url, 'postgres', 'publication-membership-test')
+    await backend.waitReady
+    await backend.exec('CREATE PUBLICATION zero_chat FOR TABLE message')
+
+    const result = await (backend as any).handleCatalogQuery(`
+      SELECT schemaname, tablename, pubname
+      FROM pg_publication_tables
+      WHERE pubname IN ('zero_chat')
+    `)
+
+    expect(result.rows).toEqual([
+      { schemaname: 'public', tablename: 'message', pubname: 'zero_chat' },
+    ])
+  })
+
+  test('synthesizes zero-cache publication metadata result sets', async () => {
+    const http = await startDoHttp((sql) => {
+      if (sql.includes('sqlite_master')) {
+        return {
+          rows: [
+            { name: 'message', sql: 'CREATE TABLE message (id varchar PRIMARY KEY)' },
+          ],
+          columns: ['name', 'sql'],
+        }
+      }
+      if (sql.includes('PRAGMA table_info("message")')) {
+        return {
+          rows: [
+            { cid: 0, name: 'id', type: 'varchar', notnull: 1, dflt_value: null, pk: 1 },
+            {
+              cid: 1,
+              name: 'deleted',
+              type: 'INTEGER',
+              notnull: 1,
+              dflt_value: '0',
+              pk: 0,
+            },
+          ],
+          columns: ['cid', 'name', 'type', 'notnull', 'dflt_value', 'pk'],
+        }
+      }
+      return { rows: [], columns: [] }
+    })
+    const backend = new DoBackend(http.url, 'postgres', 'publication-metadata-test')
+    await backend.waitReady
+    await backend.exec(`
+      CREATE TABLE message (
+        id varchar PRIMARY KEY,
+        deleted boolean NOT NULL DEFAULT false
+      );
+      CREATE PUBLICATION zero_chat FOR TABLE message;
+    `)
+
+    const results = await (backend as any).handleCatalogQueries(`
+      SELECT schemaname AS "schema", tablename AS "table",
+        json_object_agg(pubname, attnames) AS "publications"
+      FROM pg_publication_tables pb
+      WHERE pb.pubname IN ('zero_chat')
+      GROUP BY schemaname, tablename;
+
+      WITH published_columns AS (
+        SELECT attname FROM pg_attribute
+        JOIN pg_publication_tables pb ON attname = ANY(pb.attnames)
+        WHERE pb.pubname IN ('zero_chat')
+      )
+      SELECT COALESCE(json_agg("table"), '[]'::json) as "tables" FROM published_columns;
+
+      WITH indexed_columns AS (
+        SELECT pg_indexes.indexname FROM pg_indexes
+        JOIN pg_index ON true
+      )
+      SELECT COALESCE(json_agg("index"), '[]'::json) as "indexes" FROM indexed_columns;
+    `)
+
+    expect(results[0].rows).toEqual([
+      {
+        schema: 'public',
+        table: 'message',
+        publications: { zero_chat: ['id', 'deleted'] },
+      },
+    ])
+    expect(results[1].rows[0].tables).toEqual([
+      expect.objectContaining({
+        name: 'message',
+        primaryKey: ['id'],
+        columns: expect.objectContaining({
+          id: expect.objectContaining({ dataType: 'character varying', typeOID: 1043 }),
+          deleted: expect.objectContaining({ dataType: 'boolean', typeOID: 16 }),
+        }),
+      }),
+    ])
+    expect(results[2]).toEqual({
+      rows: [
+        {
+          indexes: [
+            expect.objectContaining({
+              schema: 'public',
+              tableName: 'message',
+              name: 'message_id_pkey',
+              unique: true,
+              isPrimaryKey: true,
+              isImmediate: true,
+              columns: { id: 'ASC' },
+            }),
+          ],
+        },
+      ],
+      fields: [{ name: 'indexes', oid: 114 }],
+    })
+  })
+
+  test('tracks published table writes with parser-derived returning SQL', async () => {
+    const http = await startDoHttp((sql) => {
+      if (compactSQL(sql).includes('RETURNING *')) {
+        return { rows: [{ id: 't1', body: 'hello' }], columns: ['id', 'body'] }
+      }
+      return { rows: [], columns: [] }
+    })
+    const backend = new DoBackend(http.url, 'postgres', 'write-tracking-test')
+    await backend.waitReady
+    await backend.exec('CREATE PUBLICATION zero_chat FOR TABLE task_item')
+
+    const result = await backend.execProtocolRaw(
+      msg(0x51, cstr("INSERT INTO task_item (id, body) VALUES ('t1', 'hello')"))
+    )
+
+    expect(messageTypes(result)).toEqual(['C', 'Z'])
+    const tracked = http.bodies.find((body) => body.track)
+    expect(tracked.track).toEqual({
+      tableName: 'public.task_item',
+      operation: 'INSERT',
+      returnRows: false,
+    })
+    expect(compactSQL(tracked.sql)).toContain('RETURNING *')
+  })
+
+  test('signals replication immediately after tracked writes', async () => {
+    const http = await startDoHttp((sql) => {
+      if (compactSQL(sql).includes('RETURNING *')) {
+        return { rows: [{ id: 't1', body: 'hello' }], columns: ['id', 'body'] }
+      }
+      return { rows: [], columns: [] }
+    })
+    const backend = new DoBackend(http.url, 'postgres', 'write-signal-test')
+    await backend.waitReady
+    await backend.exec('CREATE PUBLICATION zero_chat FOR TABLE task_item')
+
+    const globalObject = globalThis as any
+    const previousWakeup = globalObject.__orez_signal_replication
+    let wakeups = 0
+    globalObject.__orez_signal_replication = () => {
+      wakeups++
+    }
+    try {
+      await backend.query("INSERT INTO task_item (id, body) VALUES ('t1', 'hello')")
+    } finally {
+      if (previousWakeup === undefined) {
+        delete globalObject.__orez_signal_replication
+      } else {
+        globalObject.__orez_signal_replication = previousWakeup
+      }
+    }
+
+    expect(wakeups).toBe(1)
+  })
+
+  test('tracks full published rows while preserving client RETURNING projection', async () => {
+    const http = await startDoHttp((sql) => {
+      const compact = compactSQL(sql)
+      if (compact.includes('RETURNING *')) {
+        return {
+          rows: [{ id: 't1', body: 'hello', __orez_returning_1: 'HELLO' }],
+          columns: ['id', 'body', '__orez_returning_1'],
+        }
+      }
+      return { rows: [], columns: [] }
+    })
+    const backend = new DoBackend(http.url, 'postgres', 'write-returning-test')
+    await backend.waitReady
+    await backend.exec('CREATE TABLE task_item (id TEXT PRIMARY KEY, body TEXT)')
+    await backend.exec('CREATE PUBLICATION zero_chat FOR TABLE task_item')
+
+    const result = await backend.execProtocolRaw(
+      msg(
+        0x51,
+        cstr(
+          `INSERT INTO task_item (id, body)
+           VALUES ('t1', 'hello')
+           RETURNING "id", upper("body") AS "bodyUpper"`
+        )
+      )
+    )
+
+    expect(messageTypes(result)).toEqual(['T', 'D', 'C', 'Z'])
+    expect(rowDescriptionNames(result)).toEqual(['id', 'bodyUpper'])
+    expect(dataRowValues(result)).toEqual([['t1', 'HELLO']])
+
+    const tracked = http.bodies.find((body) => body.track)
+    expect(tracked.track).toEqual({
+      tableName: 'public.task_item',
+      operation: 'INSERT',
+      returnRows: true,
+      rowColumns: ['id', 'body'],
+    })
+    expect(compactSQL(tracked.sql)).toContain('RETURNING *')
+    expect(compactSQL(tracked.sql)).toContain('__orez_returning_1')
+  })
+
+  test('synthesizes primary-key rows for zero-cache relation metadata queries', async () => {
+    const http = await startDoHttp((sql) => {
+      if (sql.includes('sqlite_master')) {
+        return {
+          rows: [{ name: 'server', sql: 'CREATE TABLE server (id varchar PRIMARY KEY)' }],
+          columns: ['name', 'sql'],
+        }
+      }
+      if (sql.includes('PRAGMA table_info("server")')) {
+        return {
+          rows: [
+            { cid: 0, name: 'id', type: 'varchar', notnull: 1, dflt_value: null, pk: 1 },
+            {
+              cid: 1,
+              name: 'name',
+              type: 'varchar',
+              notnull: 1,
+              dflt_value: null,
+              pk: 0,
+            },
+          ],
+          columns: ['cid', 'name', 'type', 'notnull', 'dflt_value', 'pk'],
+        }
+      }
+      return { rows: [], columns: [] }
+    })
+    const backend = new DoBackend(http.url, 'postgres', 'relation-metadata-test')
+    await backend.waitReady
+
+    const result = await backend.query<{
+      kind: string
+      table_schema: string
+      table_name: string
+      column_name: string
+      data_type: string | null
+      ordinal_position: number
+    }>(
+      `SELECT 'pk' AS kind, tc.table_schema, tc.table_name, kcu.column_name, NULL AS data_type, kcu.ordinal_position
+       FROM information_schema.table_constraints tc
+       JOIN information_schema.key_column_usage kcu
+         ON tc.constraint_name = kcu.constraint_name
+         AND tc.table_schema = kcu.table_schema
+       WHERE tc.constraint_type = 'PRIMARY KEY'
+         AND tc.table_schema = ANY($1)
+       UNION ALL
+       SELECT 'col' AS kind, table_schema, table_name, column_name, data_type, ordinal_position
+       FROM information_schema.columns
+       WHERE table_schema = ANY($1)
+       ORDER BY table_schema, table_name, kind, ordinal_position`,
+      [['public']]
+    )
+
+    expect(result.rows).toContainEqual({
+      kind: 'pk',
+      table_schema: 'public',
+      table_name: 'server',
+      column_name: 'id',
+      data_type: null,
+      ordinal_position: 1,
+    })
+    expect(result.rows).toContainEqual({
+      kind: 'col',
+      table_schema: 'public',
+      table_name: 'server',
+      column_name: 'name',
+      data_type: 'character varying',
+      ordinal_position: 2,
+    })
+  })
+
+  test('does not track unpublished public table writes', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'unpublished-write-test')
+    await backend.waitReady
+
+    await backend.execProtocolRaw(
+      msg(0x51, cstr("INSERT INTO private_note (id) VALUES ('n1')"))
+    )
+
+    expect(http.bodies.some((body) => body.track)).toBe(false)
+  })
+
+  test('synthesizes primary and unique index metadata for published tables', async () => {
+    const http = await startDoHttp((sql) => {
+      if (sql.includes('sqlite_master')) {
+        return {
+          rows: [
+            {
+              name: 'account',
+              sql: 'CREATE TABLE account (id text PRIMARY KEY, email text NOT NULL UNIQUE)',
+            },
+          ],
+          columns: ['name', 'sql'],
+        }
+      }
+      if (sql.includes('PRAGMA table_info("account")')) {
+        return {
+          rows: [
+            { cid: 0, name: 'id', type: 'text', notnull: 1, dflt_value: null, pk: 1 },
+            {
+              cid: 1,
+              name: 'email',
+              type: 'text',
+              notnull: 1,
+              dflt_value: null,
+              pk: 0,
+            },
+          ],
+          columns: ['cid', 'name', 'type', 'notnull', 'dflt_value', 'pk'],
+        }
+      }
+      if (sql.includes('PRAGMA index_list("account")')) {
+        return {
+          rows: [
+            {
+              seq: 0,
+              name: 'sqlite_autoindex_account_2',
+              unique: 1,
+              origin: 'u',
+              partial: 0,
+            },
+            {
+              seq: 1,
+              name: 'sqlite_autoindex_account_1',
+              unique: 1,
+              origin: 'pk',
+              partial: 0,
+            },
+          ],
+          columns: ['seq', 'name', 'unique', 'origin', 'partial'],
+        }
+      }
+      if (sql.includes('PRAGMA index_xinfo("sqlite_autoindex_account_2")')) {
+        return {
+          rows: [
+            { seqno: 0, cid: 1, name: 'email', desc: 0, key: 1 },
+            { seqno: 1, cid: -1, name: null, desc: 0, key: 0 },
+          ],
+          columns: ['seqno', 'cid', 'name', 'desc', 'key'],
+        }
+      }
+      if (sql.includes('PRAGMA index_xinfo("sqlite_autoindex_account_1")')) {
+        return {
+          rows: [
+            { seqno: 0, cid: 0, name: 'id', desc: 0, key: 1 },
+            { seqno: 1, cid: -1, name: null, desc: 0, key: 0 },
+          ],
+          columns: ['seqno', 'cid', 'name', 'desc', 'key'],
+        }
+      }
+      return { rows: [], columns: [] }
+    })
+    const backend = new DoBackend(http.url, 'postgres', 'published-index-test')
+    await backend.waitReady
+    await backend.exec('CREATE PUBLICATION zero_chat FOR TABLE account')
+
+    const result = await (backend as any).handleCatalogQuery(`
+      WITH indexed_columns AS (
+        SELECT pg_indexes.indexname FROM pg_indexes
+        JOIN pg_index ON true
+        JOIN pg_publication_tables pb ON true
+        WHERE pb.pubname IN ('zero_chat')
+      )
+      SELECT COALESCE(json_agg("index"), '[]'::json) as "indexes"
+      FROM indexed_columns;
+    `)
+
+    expect(result).toEqual({
+      rows: [
+        {
+          indexes: [
+            expect.objectContaining({
+              schema: 'public',
+              tableName: 'account',
+              name: 'account_id_pkey',
+              unique: true,
+              isPrimaryKey: true,
+              isImmediate: true,
+              columns: { id: 'ASC' },
+            }),
+            expect.objectContaining({
+              schema: 'public',
+              tableName: 'account',
+              name: 'account_email_key',
+              unique: true,
+              isPrimaryKey: false,
+              isImmediate: true,
+              columns: { email: 'ASC' },
+            }),
+          ],
+        },
+      ],
+      fields: [{ name: 'indexes', oid: 114 }],
+    })
+  })
+
+  test('uses parsed ADD COLUMN primary-key metadata when SQLite cannot alter the physical key', async () => {
+    const http = await startDoHttp((sql) => {
+      if (sql.includes('sqlite_master')) {
+        return {
+          rows: [
+            {
+              name: 'appInstall',
+              sql: 'CREATE TABLE "appInstall" ("serverId" text, "creatorId" text, "appId" text, "id" text, PRIMARY KEY ("serverId", "creatorId", "appId"))',
+            },
+          ],
+          columns: ['name', 'sql'],
+        }
+      }
+      if (sql.includes('PRAGMA table_info("appInstall")')) {
+        return {
+          rows: [
+            {
+              cid: 0,
+              name: 'serverId',
+              type: 'text',
+              notnull: 0,
+              dflt_value: null,
+              pk: 1,
+            },
+            {
+              cid: 1,
+              name: 'creatorId',
+              type: 'text',
+              notnull: 0,
+              dflt_value: null,
+              pk: 2,
+            },
+            {
+              cid: 2,
+              name: 'appId',
+              type: 'text',
+              notnull: 0,
+              dflt_value: null,
+              pk: 3,
+            },
+            { cid: 3, name: 'id', type: 'text', notnull: 0, dflt_value: null, pk: 0 },
+          ],
+          columns: ['cid', 'name', 'type', 'notnull', 'dflt_value', 'pk'],
+        }
+      }
+      if (sql.includes('PRAGMA index_list("appInstall")')) {
+        return {
+          rows: [
+            {
+              seq: 0,
+              name: 'sqlite_autoindex_appInstall_1',
+              unique: 1,
+              origin: 'pk',
+              partial: 0,
+            },
+          ],
+          columns: ['seq', 'name', 'unique', 'origin', 'partial'],
+        }
+      }
+      return { rows: [], columns: [] }
+    })
+    const backend = new DoBackend(http.url, 'postgres', 'alter-primary-key-test')
+    await backend.waitReady
+    await backend.exec(`
+      ALTER TABLE "appInstall"
+        ADD COLUMN "id" varchar PRIMARY KEY NOT NULL;
+      CREATE PUBLICATION zero_chat FOR TABLE "appInstall";
+    `)
+
+    const results = await (backend as any).handleCatalogQueries(`
+      WITH published_columns AS (
+        SELECT attname FROM pg_attribute
+        JOIN pg_publication_tables pb ON attname = ANY(pb.attnames)
+        WHERE pb.pubname IN ('zero_chat')
+      )
+      SELECT COALESCE(json_agg("table"), '[]'::json) as "tables" FROM published_columns;
+
+      WITH indexed_columns AS (
+        SELECT pg_indexes.indexname FROM pg_indexes
+        JOIN pg_index ON true
+      )
+      SELECT COALESCE(json_agg("index"), '[]'::json) as "indexes" FROM indexed_columns;
+    `)
+
+    expect(results[0].rows[0].tables).toEqual([
+      expect.objectContaining({
+        name: 'appInstall',
+        primaryKey: ['id'],
+        columns: expect.objectContaining({
+          id: expect.objectContaining({ notNull: true }),
+        }),
+      }),
+    ])
+    expect(results[1].rows[0].indexes).toEqual([
+      expect.objectContaining({
+        tableName: 'appInstall',
+        unique: true,
+        isPrimaryKey: true,
+        columns: { id: 'ASC' },
+      }),
+    ])
+  })
+
+  test('does not convert backend SQL errors into empty result sets', async () => {
+    const http = await startDoHttp(() => new Response('boom', { status: 500 }))
+    const backend = new DoBackend(http.url, 'postgres', 'error-test')
+    await backend.waitReady
+
+    await expect(backend.query('SELECT broken')).rejects.toThrow('HTTP 500: boom')
+  })
+
+  test('flattens public schema table references before sending SQL to DO', async () => {
+    const http = await startDoHttp(() => ({ rows: [{ count: 0 }], columns: ['count'] }))
+    const backend = new DoBackend(http.url, 'postgres', 'schema-flatten-test')
+    await backend.waitReady
+
+    await backend.query('SELECT count(*) FROM public.migrations')
+
+    expect(
+      http.sqls.some((sql) => compactSQL(sql).includes('FROM public_migrations'))
+    ).toBe(true)
+    expect(
+      http.sqls.some((sql) => compactSQL(sql).includes('FROM public.migrations'))
+    ).toBe(false)
+  })
+
+  test('flushes transactional writes before reads so migrations can see DDL', async () => {
+    const http = await startDoHttp((sql) => {
+      if (/select\s+name\s+from\s+public_migrations/i.test(sql)) {
+        return { rows: [], columns: ['name'] }
+      }
+      return { rows: [], columns: [] }
+    })
+    const backend = new DoBackend(http.url, 'postgres', 'transaction-read-test')
+    await backend.waitReady
+
+    await backend.execProtocolRaw(msg(0x51, cstr('BEGIN')))
+    await backend.execProtocolRaw(
+      msg(
+        0x51,
+        cstr(`
+          CREATE TABLE IF NOT EXISTS public.migrations (
+            id SERIAL PRIMARY KEY,
+            name VARCHAR(255) NOT NULL
+          )
+        `)
+      )
+    )
+    await backend.execProtocolRaw(msg(0x51, cstr('SELECT name FROM public.migrations')))
+
+    const createIndex = http.sqls.findIndex((sql) =>
+      /create\s+table\s+if\s+not\s+exists\s+public_migrations/i.test(sql)
+    )
+    const selectIndex = http.sqls.findIndex((sql) =>
+      /select\s+name\s+from\s+public_migrations/i.test(sql)
+    )
+    expect(createIndex).toBeGreaterThanOrEqual(0)
+    expect(selectIndex).toBeGreaterThan(createIndex)
+    await backend.execProtocolRaw(msg(0x51, cstr('ROLLBACK')))
+  })
+
+  test('intercepts parser-recognized transaction variants before DO execution', async () => {
+    // The Durable Object refuses raw BEGIN/SAVEPOINT (it requires the JS-side
+    // transaction API). All PG transaction control statements must be handled
+    // locally and never reach the DO as SQL.
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'transaction-variant-test')
+    await backend.waitReady
+
+    const begin = await backend.execProtocolRaw(
+      msg(0x51, cstr('BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ'))
+    )
+    await backend.execProtocolRaw(msg(0x51, cstr('SAVEPOINT zero_migrate')))
+    await backend.execProtocolRaw(msg(0x51, cstr('RELEASE SAVEPOINT zero_migrate')))
+    await backend.execProtocolRaw(msg(0x51, cstr('COMMIT')))
+
+    expect(messageTypes(begin)).toEqual(['C', 'Z'])
+    const sent = http.sqls.map((sql) => sql.trim().toUpperCase())
+    expect(sent.some((sql) => sql.startsWith('BEGIN'))).toBe(false)
+    expect(sent.some((sql) => sql.startsWith('COMMIT'))).toBe(false)
+    expect(sent.some((sql) => sql.startsWith('SAVEPOINT'))).toBe(false)
+    expect(sent.some((sql) => sql.startsWith('RELEASE'))).toBe(false)
+  })
+
+  test('reports ReadyForQuery transaction status while a transaction is open', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: ['ok'] }))
+    const backend = new DoBackend(http.url, 'postgres', 'transaction-status-test')
+    await backend.waitReady
+
+    const begin = await backend.execProtocolRaw(msg(0x51, cstr('BEGIN')))
+    const select = await backend.execProtocolRaw(msg(0x51, cstr('SELECT 1 AS ok')))
+    const commit = await backend.execProtocolRaw(msg(0x51, cstr('COMMIT')))
+
+    expect(readyForQueryStatuses(begin)).toEqual(['T'])
+    expect(readyForQueryStatuses(select)).toEqual(['T'])
+    expect(readyForQueryStatuses(commit)).toEqual(['I'])
+  })
+
+  test('keeps extended-protocol Sync in transaction state after BEGIN', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(
+      http.url,
+      'postgres',
+      'extended-transaction-status-test'
+    )
+    await backend.waitReady
+
+    await backend.execProtocolRaw(parseMessage('BEGIN'))
+    await backend.execProtocolRaw(bindStatement())
+    await backend.execProtocolRaw(executePortal())
+    const sync = await backend.execProtocolRaw(msg(0x53, new Uint8Array(0)))
+
+    expect(readyForQueryStatuses(sync)).toEqual(['T'])
+    await backend.execProtocolRaw(parseMessage('ROLLBACK'))
+    await backend.execProtocolRaw(bindStatement())
+    await backend.execProtocolRaw(executePortal())
+  })
+
+  test('returns command completion for extended transaction starts', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'extended-begin-test')
+    await backend.waitReady
+
+    await backend.execProtocolRaw(parseMessage('BEGIN'))
+    await backend.execProtocolRaw(bindStatement())
+    const result = await backend.execProtocolRaw(executePortal())
+
+    expect(messageTypes(result)).toEqual(['C'])
+    expect(http.sqls.some((sql) => compactSQL(sql).startsWith('BEGIN'))).toBe(false)
+    await backend.execProtocolRaw(parseMessage('ROLLBACK'))
+    await backend.execProtocolRaw(bindStatement())
+    await backend.execProtocolRaw(executePortal())
+  })
+
+  test('clears the rewrite cache on transaction rollback', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'rewrite-cache-rollback-test')
+    await backend.waitReady
+
+    await backend.exec('SELECT 1')
+    const beforeCount = http.sqls.filter((sql) => compactSQL(sql) === 'SELECT 1').length
+
+    await backend.execProtocolRaw(msg(0x51, cstr('BEGIN')))
+    await backend.execProtocolRaw(msg(0x51, cstr('ROLLBACK')))
+
+    await backend.exec('SELECT 1')
+    // BEGIN / ROLLBACK don't reach the DO; the cache invalidation should
+    // re-issue the SELECT.
+    expect(http.sqls.filter((sql) => compactSQL(sql) === 'SELECT 1').length).toBe(
+      beforeCount + 1
+    )
+  })
+
+  test('snapshots extended transaction writes for rollback', async () => {
+    const http = await startDoHttp((sql) => {
+      if (sql.includes('sqlite_master')) {
+        return { rows: [{ ok: 1 }], columns: ['ok'] }
+      }
+      if (compactSQL(sql).includes('RETURNING *')) {
+        return {
+          rows: [{ clientGroupID: 'cg', clientID: 'client-a', lastMutationID: 1 }],
+          columns: ['clientGroupID', 'clientID', 'lastMutationID'],
+        }
+      }
+      return { rows: [], columns: [] }
+    })
+    const backend = new DoBackend(http.url, 'postgres', 'extended-tx-session-test')
+    await backend.waitReady
+
+    await backend.execProtocolRaw(parseMessage('BEGIN'))
+    await backend.execProtocolRaw(bindStatement())
+    await backend.execProtocolRaw(executePortal())
+
+    await backend.execProtocolRaw(
+      parseMessage(`
+        INSERT INTO "chat_0"."clients" AS current
+          ("clientGroupID", "clientID", "lastMutationID")
+        VALUES ('cg', 'client-a', 1)
+        ON CONFLICT ("clientGroupID", "clientID")
+        DO UPDATE SET "lastMutationID" = current."lastMutationID" + 1
+        RETURNING "lastMutationID"
+      `)
+    )
+    await backend.execProtocolRaw(bindStatement())
+    const result = await backend.execProtocolRaw(executePortal())
+    expect(dataRowValues(result)).toEqual([['1']])
+
+    await backend.execProtocolRaw(parseMessage('ROLLBACK'))
+    await backend.execProtocolRaw(bindStatement())
+    await backend.execProtocolRaw(executePortal())
+
+    expect(
+      http.sqls.some((sql) =>
+        /CREATE TABLE "_orez_tx_.*_chat_0_clients" AS SELECT \* FROM "chat_0_clients"/.test(
+          sql
+        )
+      )
+    ).toBe(true)
+    expect(http.requests.some((url) => url.pathname === '/batch')).toBe(true)
+    expect(
+      http.bodies.some(
+        (body) =>
+          Array.isArray(body.statements) &&
+          body.statements.some((sql: string) =>
+            /INSERT OR REPLACE INTO "chat_0_clients" SELECT \* FROM "_orez_tx_.*_chat_0_clients"/.test(
+              sql
+            )
+          )
+      )
+    ).toBe(true)
+  })
+
+  test('restores rollback snapshots without firing table triggers', async () => {
+    const triggerSQL =
+      'CREATE TRIGGER "clients_hash" AFTER INSERT ON "chat_0_clients" BEGIN SELECT md5(new."clientID"); END'
+    const http = await startDoHttp((sql) => {
+      const compact = compactSQL(sql)
+      if (compact.includes("WHERE type = 'trigger'")) {
+        return {
+          rows: [{ name: 'clients_hash', sql: triggerSQL }],
+          columns: ['name', 'sql'],
+        }
+      }
+      if (sql.includes('sqlite_master')) {
+        return { rows: [{ ok: 1 }], columns: ['ok'] }
+      }
+      if (compact.includes('RETURNING *')) {
+        return {
+          rows: [{ clientGroupID: 'cg', clientID: 'client-a', lastMutationID: 1 }],
+          columns: ['clientGroupID', 'clientID', 'lastMutationID'],
+        }
+      }
+      return { rows: [], columns: [] }
+    })
+    const backend = new DoBackend(
+      http.url,
+      'postgres',
+      'extended-tx-trigger-restore-test'
+    )
+    await backend.waitReady
+
+    await backend.execProtocolRaw(parseMessage('BEGIN'))
+    await backend.execProtocolRaw(bindStatement())
+    await backend.execProtocolRaw(executePortal())
+
+    await backend.execProtocolRaw(
+      parseMessage(`
+        INSERT INTO "chat_0"."clients" AS current
+          ("clientGroupID", "clientID", "lastMutationID")
+        VALUES ('cg', 'client-a', 1)
+        ON CONFLICT ("clientGroupID", "clientID")
+        DO UPDATE SET "lastMutationID" = current."lastMutationID" + 1
+        RETURNING "lastMutationID"
+      `)
+    )
+    await backend.execProtocolRaw(bindStatement())
+    await backend.execProtocolRaw(executePortal())
+
+    await backend.execProtocolRaw(parseMessage('ROLLBACK'))
+    await backend.execProtocolRaw(bindStatement())
+    await backend.execProtocolRaw(executePortal())
+
+    const batch = http.bodies.find(
+      (body) =>
+        Array.isArray(body.statements) &&
+        body.statements.some((sql: string) =>
+          sql.includes('INSERT OR REPLACE INTO "chat_0_clients"')
+        )
+    )
+    expect(batch).toBeTruthy()
+    const statements = batch.statements.map(compactSQL)
+    const dropIndex = statements.indexOf('DROP TRIGGER IF EXISTS "clients_hash"')
+    const insertIndex = statements.findIndex((sql: string) =>
+      sql.includes('INSERT OR REPLACE INTO "chat_0_clients"')
+    )
+    const recreateIndex = statements.indexOf(triggerSQL)
+    expect(dropIndex).toBeGreaterThanOrEqual(0)
+    expect(insertIndex).toBeGreaterThan(dropIndex)
+    expect(recreateIndex).toBeGreaterThan(insertIndex)
+  })
+
+  test('returns command completion for parser-skipped extended statements', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'extended-noop-test')
+    await backend.waitReady
+
+    await backend.execProtocolRaw(
+      parseMessage(`
+        CREATE OR REPLACE FUNCTION chat.set_permissions_hash()
+        RETURNS TRIGGER AS $$
+        BEGIN
+          RETURN NEW;
+        END;
+        $$ LANGUAGE plpgsql
+      `)
+    )
+
+    expect(messageTypes(await backend.execProtocolRaw(describeStatement()))).toEqual([
+      't',
+      'n',
+    ])
+    await backend.execProtocolRaw(bindStatement())
+    const result = await backend.execProtocolRaw(executePortal())
+
+    expect(messageTypes(result)).toEqual(['C'])
+    expect(http.sqls.some((sql) => sql.includes('CREATE OR REPLACE FUNCTION'))).toBe(
+      false
+    )
+  })
+
+  test('rewrites DEFAULT values in inserts by omitting those columns', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'insert-default-test')
+    await backend.waitReady
+
+    await backend.exec(`
+      INSERT INTO reaction(id, value, keyword, "createdAt", "updatedAt")
+        VALUES ('1', 'wave', 'wave', DEFAULT, DEFAULT)
+        ON CONFLICT DO NOTHING;
+    `)
+
+    const sent = compactSQL(http.sqls.at(-1) || '')
+    expect(sent).toContain('INSERT INTO reaction')
+    expect(sent).toContain('id')
+    expect(sent).toContain('value')
+    expect(sent).toContain('keyword')
+    expect(sent).toContain('ON CONFLICT DO NOTHING')
+    expect(sent).not.toContain('DEFAULT')
+    expect(sent).not.toContain('createdAt')
+    expect(sent).not.toContain('updatedAt')
+  })
+
+  test('rewrites json_to_recordset range functions to SQLite json_each', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'json-recordset-test')
+    await backend.waitReady
+
+    await backend.query(
+      `
+        INSERT INTO "chat_0/cvr_queries" (
+          "clientGroupID",
+          "queryHash",
+          "clientAST",
+          "queryName",
+          "queryArgs",
+          "patchVersion",
+          "transformationHash",
+          "transformationVersion",
+          "internal",
+          "deleted"
+        )
+        SELECT
+          "clientGroupID",
+          "queryHash",
+          "clientAST",
+          "queryName",
+          CASE
+            WHEN "queryArgs" IS NULL THEN NULL
+            ELSE "queryArgs"::json
+          END,
+          "patchVersion",
+          "transformationHash",
+          "transformationVersion",
+          "internal",
+          "deleted"
+        FROM json_to_recordset($1) AS x(
+          "clientGroupID" TEXT,
+          "queryHash" TEXT,
+          "clientAST" JSONB,
+          "queryName" TEXT,
+          "queryArgs" TEXT,
+          "patchVersion" TEXT,
+          "transformationHash" TEXT,
+          "transformationVersion" TEXT,
+          "internal" BOOLEAN,
+          "deleted" BOOLEAN
+        )
+        ON CONFLICT ("clientGroupID", "queryHash") DO UPDATE SET
+          "clientAST" = excluded."clientAST",
+          "queryName" = excluded."queryName"
+      `,
+      [
+        JSON.stringify([
+          {
+            clientGroupID: 'cg1',
+            queryHash: 'hash1',
+            clientAST: { table: 'message' },
+            queryName: 'messages',
+            queryArgs: null,
+            patchVersion: '01',
+            transformationHash: 'th',
+            transformationVersion: 'tv',
+            internal: false,
+            deleted: false,
+          },
+        ]),
+      ]
+    )
+
+    const sent = compactSQL(http.sqls.at(-1) || '')
+    expect(sent).toContain('FROM json_each(?)')
+    expect(sent).toContain(`json_extract(value, '$.clientGroupID') AS "clientGroupID"`)
+    expect(sent).toContain('WHERE 1 ON CONFLICT')
+    expect(sent).not.toContain('json_to_recordset')
+  })
+
+  test('infers JSON parameter oid for json_to_recordset inputs', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'json-recordset-oid-test')
+    await backend.waitReady
+
+    await backend.execProtocolRaw(
+      parseMessage(
+        `
+          SELECT *
+          FROM json_to_recordset($1) AS x(
+            "clientAST" JSONB,
+            "deleted" BOOLEAN
+          )
+        `,
+        '',
+        [0]
+      )
+    )
+
+    const describe = await backend.execProtocolRaw(describeStatement())
+
+    expect(parameterDescriptionOids(describe)).toEqual([114])
+  })
+
+  test('normalizes PostgreSQL array literal params used as JSON documents', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'json-param-normalize-test')
+    await backend.waitReady
+
+    await backend.query(
+      `
+        SELECT "clientGroupID"
+        FROM json_to_recordset($1) AS x("clientGroupID" TEXT)
+      `,
+      ['{"{\\"clientGroupID\\":\\"cg1\\"}"}']
+    )
+
+    expect(compactSQL(http.sqls.at(-1) || '')).toContain('FROM json_each(?)')
+    expect(http.params.at(-1)).toEqual(['[{"clientGroupID":"cg1"}]'])
+  })
+
+  test('rewrites Zero timestamp and row JSON helpers for SQLite', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: ['zql_result'] }))
+    const backend = new DoBackend(http.url, 'postgres', 'zql-helper-rewrite-test')
+    await backend.waitReady
+
+    await backend.query(`
+      SELECT row_to_json(zql_root) AS zql_result
+      FROM (
+        SELECT
+          "userPublic_0".id AS id,
+          EXTRACT(EPOCH FROM "userPublic_0"."joinedAt") * 1000 AS "joinedAt"
+        FROM "userPublic" AS "userPublic_0"
+      ) zql_root
+    `)
+
+    const select = compactSQL(http.sqls.at(-1) || '')
+    expect(select).toContain(`"json_object"('id'`)
+    expect(select).toContain(`zql_root.id`)
+    expect(select).toContain(`'joinedAt'`)
+    expect(select).toContain(`zql_root."joinedAt"`)
+    expect(select).toContain(`strftime('%s', "userPublic_0"."joinedAt") * 1000`)
+    expect(select).not.toContain('row_to_json')
+    expect(select).not.toContain('EXTRACT')
+
+    await backend.query(
+      `
+        INSERT INTO "userPublic" ("joinedAt")
+        VALUES (to_timestamp($1::text::numeric / 1000.0) AT TIME ZONE 'UTC')
+      `,
+      [123000]
+    )
+
+    const insert = compactSQL(http.sqls.at(-1) || '')
+    expect(insert).toContain(`datetime(? / 1000.0, 'unixepoch')`)
+    expect(insert).not.toContain('to_timestamp')
+    expect(insert).not.toContain('AT TIME ZONE')
+  })
+
+  test('respects explicit text casts on JSON result expressions', async () => {
+    const http = await startDoHttp(() => ({
+      rows: [{ zql_result: [{ id: 'u1' }] }],
+      columns: ['zql_result'],
+    }))
+    const backend = new DoBackend(http.url, 'postgres', 'zql-text-result-test')
+    await backend.waitReady
+
+    await backend.execProtocolRaw(
+      parseMessage(`
+        SELECT COALESCE(json_agg(row_to_json(zql_root)), '[]'::json)::text AS zql_result
+        FROM (
+          SELECT id
+          FROM "userPublic"
+        ) zql_root
+      `)
+    )
+    await backend.execProtocolRaw(bindStatement())
+    const result = await backend.execProtocolRaw(executePortal())
+
+    expect(rowDescriptionOids(result)).toMatchObject({ zql_result: 25 })
+    expect(dataRowValues(result)).toEqual([[`[{"id":"u1"}]`]])
+  })
+
+  test('flushes simple-protocol transaction writes before extended statements', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'mixed-protocol-test')
+    await backend.waitReady
+
+    await backend.execProtocolRaw(msg(0x51, cstr('BEGIN')))
+    await backend.execProtocolRaw(
+      msg(0x51, cstr('CREATE TABLE reaction (id TEXT PRIMARY KEY)'))
+    )
+    await backend.execProtocolRaw(parseMessage("INSERT INTO reaction(id) VALUES ('1')"))
+    await backend.execProtocolRaw(bindStatement())
+    await backend.execProtocolRaw(executePortal())
+
+    const createIndex = http.sqls.findIndex((sql) =>
+      /create\s+table\s+(if\s+not\s+exists\s+)?reaction/i.test(sql)
+    )
+    const insertIndex = http.sqls.findIndex((sql) =>
+      /insert\s+into\s+reaction/i.test(sql)
+    )
+    expect(createIndex).toBeGreaterThanOrEqual(0)
+    expect(insertIndex).toBeGreaterThan(createIndex)
+    await backend.execProtocolRaw(msg(0x51, cstr('ROLLBACK')))
+  })
+
+  test('sends extended-protocol params as bound DO parameters', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'param-inline-test')
+    await backend.waitReady
+
+    await backend.execProtocolRaw(
+      parseMessage('INSERT INTO docs(id, content) VALUES ($1, $2)')
+    )
+    await backend.execProtocolRaw(
+      bindStatementParams(['doc_start-doc/intro', "body keeps $1 and 'quote'"])
+    )
+    await backend.execProtocolRaw(executePortal())
+
+    const sent = compactSQL(http.sqls.at(-1) || '')
+    expect(sent).toContain('VALUES ( ?, ? )')
+    expect(http.params.at(-1)).toEqual([
+      'doc_start-doc/intro',
+      "body keeps $1 and 'quote'",
+    ])
+    expect(sent).not.toContain("body keeps 'doc_start-doc/intro'")
+  })
+
+  test('rewrites PG ALL array comparisons to SQLite json_each subqueries', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'all-array-test')
+    await backend.waitReady
+
+    await backend.execProtocolRaw(
+      parseMessage(
+        `DELETE FROM search_documents
+         WHERE id LIKE 'doc_start-doc/%'
+           AND type = 'doc'
+           AND id != ALL($1)`
+      )
+    )
+    await backend.execProtocolRaw(
+      bindStatementParams(['{"doc_start-doc/intro","doc_start-doc/api"}'])
+    )
+    await backend.execProtocolRaw(executePortal())
+
+    const sent = compactSQL(http.sqls.at(-1) || '')
+    expect(sent).toContain('NOT (id IN (SELECT value FROM json_each')
+    expect(sent).toContain('json_each(?)')
+    expect(http.params.at(-1)).toEqual(['["doc_start-doc/intro","doc_start-doc/api"]'])
+    expect(sent).not.toContain('ALL')
+  })
+
+  test('rewrites JSONB array element filters to SQLite json_each', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: ['value'] }))
+    const backend = new DoBackend(http.url, 'postgres', 'jsonb-array-elements-test')
+    await backend.waitReady
+
+    await backend.execProtocolRaw(
+      parseMessage(
+        `SELECT value
+         FROM jsonb_array_elements_text($1::text::jsonb)`
+      )
+    )
+    await backend.execProtocolRaw(bindStatementParams(['{"data","chat"}']))
+    await backend.execProtocolRaw(executePortal())
+
+    const sent = compactSQL(http.sqls.at(-1) || '')
+    expect(sent).toContain('FROM json_each(?)')
+    expect(http.params.at(-1)).toEqual(['["data","chat"]'])
+    expect(sent).not.toContain('jsonb_array_elements_text')
+  })
+
+  test('collapses json_each over ARRAY subqueries from plural filters', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: ['id'] }))
+    const backend = new DoBackend(http.url, 'postgres', 'jsonb-array-filter-test')
+    await backend.waitReady
+
+    await backend.execProtocolRaw(
+      parseMessage(
+        `SELECT id
+         FROM app
+         WHERE id IN (
+           SELECT value
+           FROM jsonb_array_elements_text(
+             ARRAY(
+               SELECT value::text
+               FROM jsonb_array_elements_text($1::text::jsonb)
+             )
+           )
+         )`
+      )
+    )
+    await backend.execProtocolRaw(bindStatementParams(['{"data","chat"}']))
+    await backend.execProtocolRaw(executePortal())
+
+    const sent = compactSQL(http.sqls.at(-1) || '')
+    expect(sent).toContain('IN (SELECT value FROM json_each(?))')
+    expect(sent).not.toContain('ARRAY')
+    expect(http.params.at(-1)).toEqual(['["data","chat"]'])
+  })
+
+  test('rewrites PG array column declarations to SQLite text columns', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'array-column-test')
+    await backend.waitReady
+
+    await backend.exec(`
+      CREATE TABLE "chat_0"."shardConfig" (
+        "publications" TEXT[] NOT NULL,
+        "ddlDetection" BOOL NOT NULL
+      );
+    `)
+
+    const sent = compactSQL(
+      sqlContaining(http.sqls, 'CREATE TABLE IF NOT EXISTS "chat_0_shardConfig"')
+    )
+    expect(sent).toContain('CREATE TABLE IF NOT EXISTS "chat_0_shardConfig"')
+    expect(sent).toContain('publications text NOT NULL')
+    expect(sent).not.toContain('text[]')
+  })
+
+  test('rewrites PG array constructors to JSON text literals', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'array-constructor-test')
+    await backend.waitReady
+
+    await backend.exec(`
+      INSERT INTO "chat_0"."shardConfig" ("publications", "ddlDetection")
+      VALUES (ARRAY['zero_chat', '_zero_metadata'], false);
+    `)
+
+    const sent = compactSQL(http.sqls.at(-1) || '')
+    expect(sent).toContain(`'["zero_chat","_zero_metadata"]'`)
+    expect(sent).not.toContain('ARRAY')
+  })
+
+  test('rewrites PG sequences to readable SQLite sequence tables', async () => {
+    const http = await startDoHttp((sql) => {
+      if (compactSQL(sql).startsWith('SELECT')) {
+        return {
+          rows: [{ last_value: 1, is_called: 0 }],
+          columns: ['last_value', 'is_called'],
+        }
+      }
+      return { rows: [], columns: [] }
+    })
+    const backend = new DoBackend(http.url, 'postgres', 'sequence-table-test')
+    await backend.waitReady
+
+    await backend.exec('CREATE SEQUENCE IF NOT EXISTS _orez._zero_watermark')
+    const result = await backend.execProtocolRaw(
+      msg(0x51, cstr('SELECT last_value, is_called FROM _orez._zero_watermark'))
+    )
+
+    const sent = compactSQL(http.sqls.join('; '))
+    expect(sent).toContain('CREATE TABLE IF NOT EXISTS "_orez___zero_watermark"')
+    expect(sent).toContain('INSERT OR IGNORE INTO "_orez___zero_watermark"')
+    expect(rowDescriptionOids(result)).toMatchObject({
+      last_value: 20,
+      is_called: 16,
+    })
+    expect(dataRowValues(result)).toEqual([['1', 'f']])
+  })
+
+  test('sends high-level query params as bound DO parameters', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'query-param-test')
+    await backend.waitReady
+
+    await backend.query(
+      `INSERT INTO _orez._zero_replication_slots (
+        slot_name,
+        restart_lsn,
+        confirmed_flush_lsn
+      ) VALUES ($1, $2, $3)`,
+      ['slot_1', '0/16B6C50', '0/16B6C50']
+    )
+
+    const sent = compactSQL(http.sqls.at(-1) || '')
+    expect(sent).toContain('VALUES ( ?, ?, ? )')
+    expect(sent).not.toContain('$1')
+    expect(http.params.at(-1)).toEqual(['slot_1', '0/16B6C50', '0/16B6C50'])
+  })
+
+  test('returns JSON and boolean type metadata for rewritten SQLite rows', async () => {
+    const http = await startDoHttp((sql) => {
+      if (compactSQL(sql).startsWith('SELECT')) {
+        return {
+          rows: [
+            {
+              publications: '["_chat_metadata_0","zero_chat"]',
+              ddlDetection: 0,
+            },
+          ],
+          columns: ['publications', 'ddlDetection'],
+        }
+      }
+      return { rows: [], columns: [] }
+    })
+    const backend = new DoBackend(http.url, 'postgres', 'json-field-oid-test')
+    await backend.waitReady
+
+    await backend.exec(`
+      CREATE TABLE "_zero"."shardConfig" (
+        "publications" TEXT[] NOT NULL,
+        "ddlDetection" BOOL NOT NULL
+      );
+    `)
+
+    const result = await backend.execProtocolRaw(
+      msg(0x51, cstr('SELECT "publications", "ddlDetection" FROM "_zero_shardConfig"'))
+    )
+
+    expect(messageTypes(result)).toEqual(['T', 'D', 'C', 'Z'])
+    expect(rowDescriptionOids(result)).toMatchObject({
+      publications: 114,
+      ddlDetection: 16,
+    })
+    expect(dataRowValues(result)).toEqual([['["_chat_metadata_0","zero_chat"]', 'f']])
+  })
+
+  test('falls back to zero-cache metadata column types when durable metadata is absent', async () => {
+    const http = await startDoHttp((sql) => {
+      const compact = compactSQL(sql)
+      if (
+        compact.includes('_orez_pg_metadata') ||
+        compact.includes('sqlite_master') ||
+        compact.startsWith('PRAGMA')
+      ) {
+        return { rows: [], columns: [] }
+      }
+      if (compact.startsWith('SELECT')) {
+        return {
+          rows: [
+            {
+              slot: 'slot_1',
+              version: '01',
+              publications: '["_chat_metadata_0","zero_chat"]',
+              ddlDetection: 1,
+            },
+          ],
+          columns: ['slot', 'version', 'publications', 'ddlDetection'],
+        }
+      }
+      return { rows: [], columns: [] }
+    })
+    const backend = new DoBackend(http.url, 'postgres', 'missing-metadata-oid-test')
+    await backend.waitReady
+
+    const result = await backend.execProtocolRaw(
+      msg(
+        0x51,
+        cstr(`
+          SELECT * FROM "chat_0".replicas
+          JOIN "chat_0"."shardConfig" ON true
+          WHERE version = '01'
+        `)
+      )
+    )
+
+    expect(rowDescriptionOids(result)).toMatchObject({
+      publications: 114,
+      ddlDetection: 16,
+    })
+    expect(dataRowValues(result)).toEqual([
+      ['slot_1', '01', '["_chat_metadata_0","zero_chat"]', 't'],
+    ])
+  })
+
+  test('resolves JSON metadata for columns from joined tables', async () => {
+    const http = await startDoHttp((sql) => {
+      if (compactSQL(sql).startsWith('SELECT')) {
+        return {
+          rows: [
+            {
+              slot: 'slot_1',
+              version: '01',
+              publications: '["_chat_metadata_0","zero_chat"]',
+              ddlDetection: 1,
+            },
+          ],
+          columns: ['slot', 'version', 'publications', 'ddlDetection'],
+        }
+      }
+      return { rows: [], columns: [] }
+    })
+    const backend = new DoBackend(http.url, 'postgres', 'join-field-oid-test')
+    await backend.waitReady
+
+    await backend.exec(`
+      CREATE TABLE "chat_0".replicas (
+        "slot" text PRIMARY KEY,
+        "version" text NOT NULL
+      );
+      CREATE TABLE "chat_0"."shardConfig" (
+        "publications" TEXT[] NOT NULL,
+        "ddlDetection" BOOL NOT NULL
+      );
+      CREATE TABLE "chat_0/cdc"."replicationConfig" (
+        "publications" text NOT NULL
+      );
+    `)
+
+    const result = await backend.execProtocolRaw(
+      msg(
+        0x51,
+        cstr(`
+          SELECT * FROM "chat_0".replicas
+          JOIN "chat_0"."shardConfig" ON true
+          WHERE version = '01'
+        `)
+      )
+    )
+
+    expect(rowDescriptionOids(result)).toMatchObject({
+      publications: 114,
+      ddlDetection: 16,
+    })
+    expect(dataRowValues(result)).toEqual([
+      ['slot_1', '01', '["_chat_metadata_0","zero_chat"]', 't'],
+    ])
+
+    await backend.execProtocolRaw(
+      parseMessage(
+        `
+          SELECT * FROM "chat_0".replicas
+          JOIN "chat_0"."shardConfig" ON true
+          WHERE version = $1
+        `,
+        'replica-at-version',
+        [25]
+      )
+    )
+    const described = await backend.execProtocolRaw(
+      describeStatement('replica-at-version')
+    )
+    expect(rowDescriptionOids(described)).toMatchObject({
+      publications: 114,
+      ddlDetection: 16,
+    })
+  })
+
+  test('hydrates persisted PG column metadata for existing DO tables', async () => {
+    const metadataRows: Record<string, unknown>[] = []
+    const http = await startDoHttp((sql) => {
+      const compact = compactSQL(sql)
+      if (compact.startsWith('CREATE TABLE IF NOT EXISTS "_orez_pg_metadata"')) {
+        return { rows: [], columns: [] }
+      }
+      if (compact.startsWith('SELECT kind, key, subkey, value FROM')) {
+        return {
+          rows: metadataRows,
+          columns: ['kind', 'key', 'subkey', 'value'],
+        }
+      }
+      if (compact.startsWith('DELETE FROM "_orez_pg_metadata"')) {
+        metadataRows.length = 0
+        return { rows: [], columns: [] }
+      }
+      if (compact.startsWith('INSERT OR REPLACE INTO "_orez_pg_metadata"')) {
+        return { rows: [], columns: [] }
+      }
+      return { rows: [], columns: [] }
+    })
+
+    const first = new DoBackend(http.url, 'postgres', 'durable-metadata-test')
+    await first.waitReady
+    await first.exec(`
+      CREATE TABLE "chat_0".replicas (
+        "slot" text PRIMARY KEY,
+        "version" text NOT NULL
+      );
+      CREATE TABLE "chat_0"."shardConfig" (
+        "publications" TEXT[] NOT NULL,
+        "ddlDetection" BOOL NOT NULL
+      );
+    `)
+
+    for (const body of http.bodies) {
+      if (
+        typeof body.sql === 'string' &&
+        compactSQL(body.sql).startsWith('INSERT OR REPLACE INTO "_orez_pg_metadata"')
+      ) {
+        const [kind, key, subkey, value] = body.params
+        metadataRows.push({ kind, key, subkey, value })
+      }
+    }
+
+    const second = new DoBackend(http.url, 'postgres', 'durable-metadata-test')
+    await second.waitReady
+    await second.execProtocolRaw(
+      parseMessage(
+        `
+          SELECT * FROM "chat_0".replicas
+          JOIN "chat_0"."shardConfig" ON true
+          WHERE version = $1
+        `,
+        'replica-at-version',
+        [25]
+      )
+    )
+    const described = await second.execProtocolRaw(
+      describeStatement('replica-at-version')
+    )
+
+    expect(rowDescriptionOids(described)).toMatchObject({
+      publications: 114,
+      ddlDetection: 16,
+    })
+  })
+
+  test('repairs internal metadata publication from shardConfig rows', async () => {
+    const http = await startDoHttp((sql) => {
+      const compact = compactSQL(sql)
+      if (compact.startsWith('CREATE TABLE IF NOT EXISTS "_orez_pg_metadata"')) {
+        return { rows: [], columns: [] }
+      }
+      if (compact.startsWith('SELECT kind, key, subkey, value FROM')) {
+        return { rows: [], columns: ['kind', 'key', 'subkey', 'value'] }
+      }
+      if (compact.startsWith('DELETE FROM "_orez_pg_metadata"')) {
+        return { rows: [], columns: [] }
+      }
+      if (compact.startsWith('INSERT OR REPLACE INTO "_orez_pg_metadata"')) {
+        return { rows: [], columns: [] }
+      }
+      if (compact.includes('sqlite_master')) {
+        return {
+          rows: [
+            {
+              name: 'todo_permissions',
+              sql: 'CREATE TABLE todo_permissions (permissions text, hash text)',
+            },
+            {
+              name: 'todo_0_clients',
+              sql: 'CREATE TABLE todo_0_clients (clientGroupID text, clientID text)',
+            },
+            {
+              name: 'todo_0_mutations',
+              sql: 'CREATE TABLE todo_0_mutations (clientGroupID text, mutation text)',
+            },
+            {
+              name: 'todo_0_shardConfig',
+              sql: 'CREATE TABLE todo_0_shardConfig (publications text)',
+            },
+          ],
+          columns: ['name', 'sql'],
+        }
+      }
+      if (compact === 'SELECT publications FROM "todo_0_shardConfig" LIMIT 1') {
+        return {
+          rows: [{ publications: '["_todo_metadata_0","zero_todo"]' }],
+          columns: ['publications'],
+        }
+      }
+      if (compact.includes('PRAGMA table_info("todo_permissions")')) {
+        return {
+          rows: [
+            { cid: 0, name: 'permissions', type: 'text', notnull: 0, pk: 0 },
+            { cid: 1, name: 'hash', type: 'text', notnull: 0, pk: 0 },
+          ],
+          columns: ['cid', 'name', 'type', 'notnull', 'pk'],
+        }
+      }
+      if (compact.includes('PRAGMA table_info("todo_0_clients")')) {
+        return {
+          rows: [
+            { cid: 0, name: 'clientGroupID', type: 'text', notnull: 1, pk: 1 },
+            { cid: 1, name: 'clientID', type: 'text', notnull: 1, pk: 2 },
+          ],
+          columns: ['cid', 'name', 'type', 'notnull', 'pk'],
+        }
+      }
+      if (compact.includes('PRAGMA table_info("todo_0_mutations")')) {
+        return {
+          rows: [
+            { cid: 0, name: 'clientGroupID', type: 'text', notnull: 1, pk: 1 },
+            { cid: 1, name: 'mutation', type: 'text', notnull: 1, pk: 0 },
+          ],
+          columns: ['cid', 'name', 'type', 'notnull', 'pk'],
+        }
+      }
+      return { rows: [], columns: [] }
+    })
+    const backend = new DoBackend(http.url, 'postgres', 'metadata-publication-test')
+    await backend.waitReady
+
+    expect(
+      http.bodies.some(
+        (body) =>
+          body.params?.[0] === 'publication' && body.params?.[1] === '_todo_metadata_0'
+      )
+    ).toBe(true)
+
+    const publications = await (backend as any).handleCatalogQuery(`
+      SELECT pubname FROM pg_publication
+      WHERE pubname IN ('_todo_metadata_0', 'zero_todo')
+    `)
+    expect(publications.rows).toEqual([{ pubname: '_todo_metadata_0' }])
+
+    const publicationTables = await (backend as any).handleCatalogQuery(`
+      SELECT pubname, schemaname, tablename
+      FROM pg_publication_tables
+      WHERE pubname IN ('_todo_metadata_0')
+    `)
+    expect(publicationTables.rows).toEqual(
+      expect.arrayContaining([
+        {
+          pubname: '_todo_metadata_0',
+          schemaname: 'todo',
+          tablename: 'permissions',
+        },
+        {
+          pubname: '_todo_metadata_0',
+          schemaname: 'todo_0',
+          tablename: 'clients',
+        },
+        {
+          pubname: '_todo_metadata_0',
+          schemaname: 'todo_0',
+          tablename: 'mutations',
+        },
+      ])
+    )
+    expect(publicationTables.rows).toHaveLength(3)
+  })
+
+  test('repairing internal metadata publication preserves app publications', async () => {
+    const metadataRows: Record<string, unknown>[] = [
+      {
+        kind: 'publication',
+        key: 'zero_todo',
+        subkey: '',
+        value: JSON.stringify({
+          name: 'zero_todo',
+          allTables: false,
+          schemas: [],
+          tables: [['todo', { table: 'todo', schema: 'public', tableName: 'todo' }]],
+        }),
+      },
+    ]
+    let http: Awaited<ReturnType<typeof startDoHttp>>
+    http = await startDoHttp((sql) => {
+      const compact = compactSQL(sql)
+      if (compact.startsWith('CREATE TABLE IF NOT EXISTS "_orez_pg_metadata"')) {
+        return { rows: [], columns: [] }
+      }
+      if (compact.startsWith('SELECT kind, key, subkey, value FROM')) {
+        return {
+          rows: metadataRows,
+          columns: ['kind', 'key', 'subkey', 'value'],
+        }
+      }
+      if (compact.startsWith('INSERT OR REPLACE INTO "_orez_pg_metadata"')) {
+        const params = http.bodies.at(-1)?.params ?? []
+        const [kind, key, subkey, value] =
+          params.length === 3 ? [params[0], params[1], '', params[2]] : params
+        const existing = metadataRows.findIndex(
+          (row) => row.kind === kind && row.key === key && row.subkey === subkey
+        )
+        const row = { kind, key, subkey, value }
+        if (existing >= 0) metadataRows[existing] = row
+        else metadataRows.push(row)
+        return { rows: [], columns: [] }
+      }
+      if (compact.includes('sqlite_master')) {
+        return {
+          rows: [
+            {
+              name: 'todo_0_shardConfig',
+              sql: 'CREATE TABLE todo_0_shardConfig (publications text)',
+            },
+          ],
+          columns: ['name', 'sql'],
+        }
+      }
+      if (compact === 'SELECT publications FROM "todo_0_shardConfig" LIMIT 1') {
+        return {
+          rows: [{ publications: '["_todo_metadata_0","zero_todo"]' }],
+          columns: ['publications'],
+        }
+      }
+      return { rows: [], columns: [] }
+    })
+    const backend = new DoBackend(http.url, 'postgres', 'metadata-merge-test')
+    await backend.waitReady
+
+    const publications = await (backend as any).handleCatalogQuery(`
+      SELECT pubname FROM pg_publication
+      WHERE pubname IN ('_todo_metadata_0', 'zero_todo')
+      ORDER BY pubname
+    `)
+    expect(publications.rows).toEqual([
+      { pubname: '_todo_metadata_0' },
+      { pubname: 'zero_todo' },
+    ])
+    expect(metadataRows.map((row) => row.key).sort()).toEqual([
+      '_todo_metadata_0',
+      'zero_todo',
+    ])
+  })
+
+  test('infers JSON parameter oids from parsed insert target columns', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'json-param-oid-test')
+    await backend.waitReady
+
+    await backend.exec(`
+      CREATE TABLE "chat_0".replicas (
+        "slot" text PRIMARY KEY,
+        "version" text NOT NULL,
+        "initialSchema" JSON NOT NULL,
+        "initialSyncContext" JSON
+      )
+    `)
+
+    await backend.execProtocolRaw(
+      parseMessage(
+        `INSERT INTO "chat_0".replicas
+          ("slot", "version", "initialSchema", "initialSyncContext")
+         VALUES ($1, $2, $3, $4)`,
+        '',
+        [0, 0, 0, 0]
+      )
+    )
+    const describe = await backend.execProtocolRaw(describeStatement())
+
+    expect(parameterDescriptionOids(describe)).toEqual([25, 25, 114, 114])
+
+    await backend.execProtocolRaw(
+      bindStatementParams(
+        [
+          'slot_1',
+          '0/16B6C50',
+          '{"tables":[{"name":"message"}],"indexes":[]}',
+          '{"requestID":"req_1"}',
+        ],
+        '',
+        'replica_insert'
+      )
+    )
+    await backend.execProtocolRaw(executePortal('replica_insert'))
+
+    expect(compactSQL(http.sqls.at(-1) || '')).toContain('VALUES ( ?, ?, ?, ? )')
+    expect(http.params.at(-1)).toEqual([
+      'slot_1',
+      '0/16B6C50',
+      '{"tables":[{"name":"message"}],"indexes":[]}',
+      '{"requestID":"req_1"}',
+    ])
+  })
+
+  test('infers zero-cache JSON parameter oids without durable metadata', async () => {
+    const http = await startDoHttp((sql) => {
+      const compact = compactSQL(sql)
+      if (
+        compact.includes('_orez_pg_metadata') ||
+        compact.includes('sqlite_master') ||
+        compact.startsWith('PRAGMA')
+      ) {
+        return { rows: [], columns: [] }
+      }
+      return { rows: [], columns: [] }
+    })
+    const backend = new DoBackend(http.url, 'postgres', 'json-param-fallback-test')
+    await backend.waitReady
+
+    await backend.execProtocolRaw(
+      parseMessage(
+        `INSERT INTO "chat_0".replicas
+          ("slot", "version", "initialSchema", "initialSyncContext")
+         VALUES ($1, $2, $3, $4)`,
+        'replica-insert-no-metadata',
+        [0, 0, 0, 0]
+      )
+    )
+    let describe = await backend.execProtocolRaw(
+      describeStatement('replica-insert-no-metadata')
+    )
+    expect(parameterDescriptionOids(describe)).toEqual([0, 0, 114, 114])
+
+    await backend.execProtocolRaw(
+      parseMessage(
+        `UPDATE "chat_0".replicas
+          SET "subscriberContext" = $1
+          WHERE slot = $2`,
+        'replica-update-no-metadata',
+        [0, 0]
+      )
+    )
+    describe = await backend.execProtocolRaw(
+      describeStatement('replica-update-no-metadata')
+    )
+    expect(parameterDescriptionOids(describe)).toEqual([114, 0])
+  })
+
+  test('infers fallback insert params for ON CONFLICT without durable metadata', async () => {
+    const http = await startDoHttp((sql) => {
+      const compact = compactSQL(sql)
+      if (
+        compact.includes('_orez_pg_metadata') ||
+        compact.includes('sqlite_master') ||
+        compact.startsWith('PRAGMA')
+      ) {
+        return { rows: [], columns: [] }
+      }
+      return { rows: [], columns: [] }
+    })
+    const backend = new DoBackend(http.url, 'postgres', 'json-upsert-no-metadata')
+    await backend.waitReady
+
+    await backend.execProtocolRaw(
+      parseMessage(
+        `INSERT INTO "chat_0".replicas
+          ("slot", "version", "initialSchema", "initialSyncContext")
+         VALUES ($1, $2, $3, $4)
+         ON CONFLICT ("slot") DO UPDATE SET "initialSchema" = $5`,
+        'replica-upsert-no-metadata',
+        [0, 0, 0, 0, 0]
+      )
+    )
+    const describe = await backend.execProtocolRaw(
+      describeStatement('replica-upsert-no-metadata')
+    )
+
+    expect(parameterDescriptionOids(describe)).toEqual([0, 0, 114, 114, 114])
+  })
+
+  test('splits Drizzle statement-breakpoint batches and drops PG constraint alters', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'statement-batch-test')
+    await backend.waitReady
+
+    await backend.exec(`
+      CREATE TABLE "parent" ("id" text PRIMARY KEY);
+      --> statement-breakpoint
+      ALTER TABLE "child" ADD CONSTRAINT "child_parent_fk" FOREIGN KEY ("parentId") REFERENCES "public"."parent"("id");
+      --> statement-breakpoint
+      ALTER TABLE "child" ADD PRIMARY KEY("id");
+      --> statement-breakpoint
+      CREATE TABLE "child" ("id" text PRIMARY KEY, "parentId" text);
+    `)
+
+    const sent = http.sqls.join('; ')
+    expect(sent).toContain('CREATE TABLE IF NOT EXISTS parent')
+    expect(sent).toContain('CREATE TABLE IF NOT EXISTS child')
+    expect(sent).not.toContain('ADD CONSTRAINT')
+    expect(sent).not.toContain('statement-breakpoint')
+  })
+
+  test('splits semicolon batches inside Drizzle breakpoint chunks', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'semicolon-batch-test')
+    await backend.waitReady
+
+    await backend.exec(`
+      ALTER TABLE "serverApp" DROP COLUMN "id";
+      ALTER TABLE "serverApp" ADD CONSTRAINT "serverApp_pk" PRIMARY KEY("serverId","creatorId");
+      --> statement-breakpoint
+      INSERT INTO "log" ("message") VALUES ('keeps ; inside strings');
+    `)
+
+    const sent = http.sqls.at(-1) || ''
+    const compact = compactSQL(sent)
+    expect(compact).toContain('ALTER TABLE "serverApp" DROP COLUMN id')
+    expect(compact).toContain(
+      `INSERT INTO log ( message ) VALUES ( 'keeps ; inside strings' )`
+    )
+    expect(sent).not.toContain('ADD CONSTRAINT')
+    expect(sent).not.toContain('PRIMARY KEY("serverId"')
+  })
+
+  test('rewrites btree indexes and drops unsupported PG index methods', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'index-rewrite-test')
+    await backend.waitReady
+
+    await backend.exec(`
+      CREATE INDEX "idx_message_channel" ON "message" USING btree ("channelId","order");
+      --> statement-breakpoint
+      CREATE INDEX "idx_message_search" ON "message" USING gin ("content" gin_trgm_ops);
+    `)
+
+    const sent = http.sqls.at(-1) || ''
+    expect(compactSQL(sent)).toContain(
+      'CREATE INDEX IF NOT EXISTS idx_message_channel ON message ("channelId", "order")'
+    )
+    expect(sent).not.toContain('USING')
+    expect(sent).not.toContain('idx_message_search')
+  })
+
+  test('drops PG null ordering from index elements', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'index-nulls-order-test')
+    await backend.waitReady
+
+    await backend.exec(`
+      CREATE INDEX queries_patch_version
+        ON "chat_0/cvr".queries ("patchVersion" NULLS FIRST);
+    `)
+
+    const sent = compactSQL(http.sqls.at(-1) || '')
+    expect(sent).toContain(
+      'CREATE INDEX IF NOT EXISTS queries_patch_version ON "chat_0/cvr_queries" ("patchVersion")'
+    )
+    expect(sent).not.toContain('NULLS FIRST')
+    expect(sent).not.toContain('"chat_0/cvr".')
+  })
+
+  test('normalizes unsupported ALTER TABLE ADD COLUMN constraints', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'alter-add-column-test')
+    await backend.waitReady
+
+    await backend.exec(
+      'ALTER TABLE "appInstall" ADD COLUMN IF NOT EXISTS "id" varchar PRIMARY KEY NOT NULL DEFAULT md5(random()::text);'
+    )
+
+    const sent = compactSQL(
+      sqlContaining(http.sqls, 'ALTER TABLE "appInstall" ADD COLUMN id varchar')
+    )
+    expect(sent).toContain('ALTER TABLE "appInstall" ADD COLUMN id varchar')
+    expect(sent).not.toContain('IF NOT EXISTS')
+    expect(sent).not.toContain('PRIMARY KEY')
+    expect(sent).not.toContain('NOT NULL')
+    expect(sent).not.toContain('md5')
+  })
+
+  test('tracks parser metadata through table and column renames', async () => {
+    const http = await startDoHttp((sql) => {
+      const compact = compactSQL(sql)
+      if (compact.includes("sqlite_master WHERE type = 'table'")) {
+        return {
+          rows: [{ name: 'app', sql: 'CREATE TABLE "app" ("madeAt" text, meta text)' }],
+          columns: ['name', 'sql'],
+        }
+      }
+      if (compact.includes('PRAGMA table_info("app")')) {
+        return {
+          rows: [
+            {
+              cid: 0,
+              name: 'madeAt',
+              type: 'text',
+              notnull: 0,
+              dflt_value: null,
+              pk: 0,
+            },
+            {
+              cid: 1,
+              name: 'meta',
+              type: 'text',
+              notnull: 0,
+              dflt_value: null,
+              pk: 0,
+            },
+          ],
+          columns: ['cid', 'name', 'type', 'notnull', 'dflt_value', 'pk'],
+        }
+      }
+      return { rows: [], columns: [] }
+    })
+    const backend = new DoBackend(http.url, 'postgres', 'rename-metadata-test')
+    await backend.waitReady
+
+    await backend.exec(`
+      CREATE TABLE "plugin" (
+        "createdAt" timestamp,
+        "meta" jsonb
+      );
+    `)
+    await backend.exec('ALTER TABLE "plugin" RENAME TO "app";')
+    await backend.exec('ALTER TABLE "app" RENAME COLUMN "createdAt" TO "madeAt";')
+
+    const result = await (backend as any).handleCatalogQuery(`
+      SELECT c.column_name::text AS column,
+             c.data_type::text AS "dataType",
+             t.typname::text AS typename
+      FROM information_schema.columns c
+      JOIN pg_catalog.pg_type t ON c.udt_name = t.typname
+      LEFT JOIN pg_catalog.pg_type et ON t.typelem = et.oid
+      JOIN pg_catalog.pg_namespace n ON t.typnamespace = n.oid
+      WHERE (c.table_schema, c.table_name) IN (('public'::text, 'app'::text))
+    `)
+
+    expect(result.rows).toEqual([
+      {
+        column: 'madeAt',
+        dataType: 'timestamp without time zone',
+        typename: 'timestamp',
+      },
+      { column: 'meta', dataType: 'jsonb', typename: 'jsonb' },
+    ])
+  })
+
+  test('tracks ALTER COLUMN TYPE as catalog metadata without SQLite DDL', async () => {
+    const http = await startDoHttp((sql) => {
+      const compact = compactSQL(sql)
+      if (compact.includes("sqlite_master WHERE type = 'table'")) {
+        return {
+          rows: [{ name: 'data', sql: 'CREATE TABLE data (value text)' }],
+          columns: ['name', 'sql'],
+        }
+      }
+      if (compact.includes('PRAGMA table_info("data")')) {
+        return {
+          rows: [
+            {
+              cid: 0,
+              name: 'value',
+              type: 'text',
+              notnull: 0,
+              dflt_value: null,
+              pk: 0,
+            },
+          ],
+          columns: ['cid', 'name', 'type', 'notnull', 'dflt_value', 'pk'],
+        }
+      }
+      return { rows: [], columns: [] }
+    })
+    const backend = new DoBackend(http.url, 'postgres', 'alter-type-metadata-test')
+    await backend.waitReady
+
+    await backend.exec('CREATE TABLE data (value text);')
+    await backend.exec(
+      'ALTER TABLE data ALTER COLUMN value SET DATA TYPE jsonb USING value::jsonb;'
+    )
+
+    const result = await (backend as any).handleCatalogQuery(`
+      SELECT c.column_name::text AS column,
+             c.data_type::text AS "dataType",
+             t.typname::text AS typename
+      FROM information_schema.columns c
+      JOIN pg_catalog.pg_type t ON c.udt_name = t.typname
+      LEFT JOIN pg_catalog.pg_type et ON t.typelem = et.oid
+      JOIN pg_catalog.pg_namespace n ON t.typnamespace = n.oid
+      WHERE (c.table_schema, c.table_name) IN (('public'::text, 'data'::text))
+    `)
+
+    expect(http.sqls.some((sql) => compactSQL(sql).includes('ALTER COLUMN'))).toBe(false)
+    expect(result.rows).toEqual([
+      { column: 'value', dataType: 'jsonb', typename: 'jsonb' },
+    ])
+  })
+
+  test('normalizes pgvector and generated tsvector columns in create table', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'search-table-test')
+    await backend.waitReady
+
+    await backend.exec(`
+      CREATE TABLE IF NOT EXISTS search_documents (
+        id text PRIMARY KEY,
+        title text,
+        content text,
+        search_vector tsvector GENERATED ALWAYS AS (
+          setweight(to_tsvector('english', coalesce(title, '')), 'A')
+        ) STORED,
+        embedding vector(384)
+      );
+    `)
+
+    const sent = compactSQL(
+      sqlContaining(http.sqls, 'CREATE TABLE IF NOT EXISTS search_documents')
+    )
+    expect(sent).toContain('search_vector text')
+    expect(sent).toContain('embedding text')
+    expect(sent).not.toContain('GENERATED')
+    expect(sent).not.toContain('to_tsvector')
+    expect(sent).not.toContain('vector(384)')
+  })
+
+  test('makes create-table statements idempotent for repeated migrations', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'create-table-idempotent-test')
+    await backend.waitReady
+
+    await backend.exec(`
+      CREATE TABLE "privateChatsStats" (
+        "id" text PRIMARY KEY,
+        "createdAt" timestamptz DEFAULT now()
+      );
+    `)
+
+    const sent = compactSQL(
+      sqlContaining(http.sqls, 'CREATE TABLE IF NOT EXISTS "privateChatsStats"')
+    )
+    expect(sent).toContain('CREATE TABLE IF NOT EXISTS "privateChatsStats"')
+    expect(sent).toContain('"createdAt" text DEFAULT CURRENT_TIMESTAMP')
+  })
+
+  test('drops foreign-key constraints while flattening schema-qualified create table DDL', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'cvr-foreign-key-test')
+    await backend.waitReady
+
+    await backend.exec(`
+      CREATE TABLE "chat_0/cvr".rows (
+        "clientGroupID" TEXT,
+        "rowKey" JSONB,
+        PRIMARY KEY ("clientGroupID", "rowKey"),
+        CONSTRAINT fk_rows_client_group
+          FOREIGN KEY("clientGroupID")
+          REFERENCES "chat_0/cvr"."rowsVersion" ("clientGroupID")
+          ON DELETE CASCADE
+      );
+    `)
+
+    const sent = compactSQL(
+      sqlContaining(http.sqls, 'CREATE TABLE IF NOT EXISTS "chat_0/cvr_rows"')
+    )
+    expect(sent).toContain('CREATE TABLE IF NOT EXISTS "chat_0/cvr_rows"')
+    expect(sent).toContain('"rowKey" text')
+    expect(sent).not.toContain('FOREIGN KEY')
+    expect(sent).not.toContain('REFERENCES')
+    expect(sent).not.toContain('"chat_0/cvr".')
+  })
+
+  test('rewrites temporary create-table-as statements to persistent SQLite tables', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'temp-table-as-test')
+    await backend.waitReady
+
+    await backend.exec(`
+      CREATE TEMP TABLE app_id_mapping AS
+      SELECT id AS old_id, uid AS new_id
+      FROM public.app;
+    `)
+
+    const sent = compactSQL(http.sqls.at(-1) || '')
+    expect(sent).toContain('CREATE TABLE app_id_mapping AS SELECT')
+    expect(sent).toContain('FROM app')
+    expect(sent).not.toContain('TEMP')
+  })
+
+  test('normalizes multiline ALTER TABLE ADD COLUMN modifiers', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'multiline-add-column-test')
+    await backend.waitReady
+
+    await backend.exec(`
+      ALTER TABLE "userPublic"
+        ADD COLUMN IF NOT EXISTS "hasOnboarded" BOOLEAN NOT NULL DEFAULT false;
+    `)
+
+    const sent = compactSQL(
+      sqlContaining(
+        http.sqls,
+        'ALTER TABLE "userPublic" ADD COLUMN "hasOnboarded" integer DEFAULT 0'
+      )
+    )
+    expect(sent).toContain(
+      'ALTER TABLE "userPublic" ADD COLUMN "hasOnboarded" integer DEFAULT 0'
+    )
+    expect(sent).not.toContain('IF NOT EXISTS')
+    expect(sent).not.toContain('NOT NULL')
+  })
+
+  test('splits multi-command ALTER TABLE statements for SQLite', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'multi-add-column-test')
+    await backend.waitReady
+
+    await backend.exec(`
+      ALTER TABLE search_documents
+        ADD COLUMN server_id text,
+        ADD COLUMN channel_id text;
+    `)
+
+    const sent = http.sqls.join('; ')
+    expect(compactSQL(sent)).toContain(
+      'ALTER TABLE search_documents ADD COLUMN server_id text'
+    )
+    expect(compactSQL(sent)).toContain(
+      'ALTER TABLE search_documents ADD COLUMN channel_id text'
+    )
+    expect(compactSQL(sent)).not.toContain('server_id text, ADD COLUMN')
+  })
+
+  test('skips ADD COLUMN IF NOT EXISTS when parser metadata finds the column', async () => {
+    const http = await startDoHttp((sql) => {
+      if (sql.toLowerCase().includes('pragma table_info')) {
+        return { rows: [{ name: 'hasOnboarded' }], columns: ['name'] }
+      }
+      return { rows: [], columns: [] }
+    })
+    const backend = new DoBackend(http.url, 'postgres', 'conditional-add-column-test')
+    await backend.waitReady
+
+    await backend.execProtocolRaw(msg(0x51, cstr('BEGIN')))
+    await backend.execProtocolRaw(
+      msg(
+        0x51,
+        cstr(`
+          ALTER TABLE "userPublic"
+            ADD COLUMN IF NOT EXISTS "hasOnboarded" BOOLEAN NOT NULL DEFAULT false;
+        `)
+      )
+    )
+    await backend.execProtocolRaw(msg(0x51, cstr('COMMIT')))
+
+    expect(http.sqls.some((sql) => compactSQL(sql).includes('PRAGMA table_info'))).toBe(
+      true
+    )
+    expect(http.sqls.some((sql) => compactSQL(sql).includes('ADD COLUMN'))).toBe(false)
+  })
+
+  test('skips plain ADD COLUMN when parser metadata finds the column', async () => {
+    const http = await startDoHttp((sql) => {
+      if (sql.toLowerCase().includes('pragma table_info')) {
+        return { rows: [{ name: 'latestMessageOrder' }], columns: ['name'] }
+      }
+      return { rows: [], columns: [] }
+    })
+    const backend = new DoBackend(http.url, 'postgres', 'plain-add-column-test')
+    await backend.waitReady
+
+    await backend.execProtocolRaw(msg(0x51, cstr('BEGIN')))
+    await backend.execProtocolRaw(
+      msg(
+        0x51,
+        cstr(`
+          ALTER TABLE channel
+            ADD COLUMN "latestMessageOrder" varchar;
+        `)
+      )
+    )
+    await backend.execProtocolRaw(msg(0x51, cstr('COMMIT')))
+
+    expect(http.sqls.some((sql) => compactSQL(sql).includes('PRAGMA table_info'))).toBe(
+      true
+    )
+    expect(http.sqls.some((sql) => compactSQL(sql).includes('ADD COLUMN'))).toBe(false)
+  })
+
+  test('skips DROP COLUMN IF EXISTS when parser metadata cannot find the column', async () => {
+    const http = await startDoHttp((sql) => {
+      if (sql.toLowerCase().includes('pragma table_info')) {
+        return { rows: [{ name: 'id' }], columns: ['name'] }
+      }
+      return { rows: [], columns: [] }
+    })
+    const backend = new DoBackend(http.url, 'postgres', 'conditional-drop-column-test')
+    await backend.waitReady
+
+    await backend.execProtocolRaw(msg(0x51, cstr('BEGIN')))
+    await backend.execProtocolRaw(
+      msg(
+        0x51,
+        cstr(`
+          ALTER TABLE search_documents
+            DROP COLUMN IF EXISTS message_order;
+        `)
+      )
+    )
+    await backend.execProtocolRaw(msg(0x51, cstr('COMMIT')))
+
+    expect(http.sqls.some((sql) => compactSQL(sql).includes('PRAGMA table_info'))).toBe(
+      true
+    )
+    expect(http.sqls.some((sql) => compactSQL(sql).includes('DROP COLUMN'))).toBe(false)
+  })
+
+  test('keeps table-qualified column refs while flattening schemas', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'update-from-test')
+    await backend.waitReady
+
+    await backend.exec(`
+      UPDATE thread
+      SET "serverId" = channel."serverId"
+      FROM channel
+      WHERE thread."channelId" = channel.id
+        AND public.thread."deleted" = false;
+    `)
+
+    const sent = compactSQL(http.sqls.at(-1) || '')
+    expect(sent).toContain('channel."serverId"')
+    expect(sent).toContain('thread."channelId" = channel.id')
+    expect(sent).toContain('thread.deleted = 0')
+    expect(sent).not.toContain('channel_id')
+    expect(sent).not.toContain('thread_channelId')
+  })
+
+  test('rewrites PG least and greatest scalar functions to SQLite min and max', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'least-greatest-test')
+    await backend.waitReady
+
+    await backend.exec(`
+      UPDATE "thread"
+      SET "replyCount" = LEAST((SELECT COUNT(*)::INTEGER FROM "message"), 11),
+          "order" = GREATEST("order", 0);
+    `)
+
+    const sent = compactSQL(http.sqls.at(-1) || '')
+    expect(sent).toContain('"replyCount" = min')
+    expect(sent).toContain('"order" = max')
+    expect(sent).not.toContain('LEAST')
+    expect(sent).not.toContain('GREATEST')
+  })
+
+  test('rewrites PG starts_with scalar function to SQLite instr predicate', async () => {
+    const http = await startDoHttp((sql) => {
+      if (sql.includes('instr(')) return { rows: [{ users: 3 }], columns: ['users'] }
+      return { rows: [], columns: [] }
+    })
+    const backend = new DoBackend(http.url, 'postgres', 'starts-with-test')
+    await backend.waitReady
+
+    const result = await backend.query(
+      `SELECT count(*) FILTER (WHERE starts_with("profileID", 'p')) AS users
+       FROM "chat_0/cvr_instances"`
+    )
+
+    expect(result.rows).toEqual([{ users: 3 }])
+    const sent = http.sqls.at(-1) ?? ''
+    expect(sent).not.toContain('starts_with')
+    expect(sent).toContain('instr("profileID", \'p\') = 1')
+  })
+
+  test('rewrites DISTINCT ON selects with a window function for SQLite', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'distinct-on-test')
+    await backend.waitReady
+
+    await backend.exec(`
+      UPDATE "agentConfig" ac
+      SET "systemPrompt" = sub."chatPrompt"
+      FROM (
+        SELECT DISTINCT ON (c."serverId")
+          c."serverId",
+          c."chatPrompt"
+        FROM channel c
+        WHERE c."chatPrompt" IS NOT NULL
+          AND c."chatPrompt" != ''
+        ORDER BY c."serverId", c."updatedAt" DESC
+      ) sub
+      WHERE ac."serverId" = sub."serverId"
+        AND ac.type = 'builtin';
+    `)
+
+    const sent = compactSQL(http.sqls.at(-1) || '')
+    expect(sent).toContain('row_number() OVER')
+    expect(sent).toContain('PARTITION BY c."serverId"')
+    expect(sent).toContain('ORDER BY c."serverId", c."updatedAt" DESC')
+    expect(sent).toContain('_orez_rn = 1')
+    expect(sent).not.toContain('DISTINCT ON')
+  })
+
+  test('strips PostgreSQL row-locking clauses from SELECTs for SQLite', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: ['clientGroupID'] }))
+    const backend = new DoBackend(http.url, 'postgres', 'select-locking-clause-test')
+    await backend.waitReady
+
+    await backend.exec(`
+      SELECT "clientGroupID"
+      FROM "chat_0/cvr_instances"
+      WHERE NOT "deleted"
+      ORDER BY "lastActive" ASC
+      LIMIT 10
+      FOR UPDATE SKIP LOCKED
+    `)
+
+    const sent = compactSQL(http.sqls.at(-1) || '')
+    expect(sent).toContain('ORDER BY "lastActive" ASC')
+    expect(sent).toContain('LIMIT 10')
+    expect(sent).not.toContain('FOR UPDATE')
+    expect(sent).not.toContain('SKIP LOCKED')
+  })
+
+  test('rewrites LIKE with PostgreSQL escape semantics to SQLite like()', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: ['slot'] }))
+    const backend = new DoBackend(http.url, 'postgres', 'like-escape-test')
+    await backend.waitReady
+
+    await backend.query(
+      `
+      SELECT slot_name AS slot
+      FROM _orez._zero_replication_slots
+      WHERE slot_name LIKE $1
+    `,
+      ['chat\\_0\\_%']
+    )
+
+    const sent = compactSQL(http.sqls.at(-1) || '')
+    expect(sent).toContain('"like"(?, slot_name, "char"(92))')
+    expect(sent).not.toContain('slot_name LIKE')
+    expect(http.params.at(-1)).toEqual(['chat\\_0\\_%'])
+  })
+
+  test('rewrites PG JSONB helper functions to SQLite JSON1 equivalents', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'json-function-test')
+    await backend.waitReady
+
+    await backend.exec(`
+      UPDATE task
+      SET "numSteps" = CASE
+        WHEN steps IS NULL THEN 0
+        ELSE jsonb_array_length(steps)
+      END;
+    `)
+
+    const sent = compactSQL(http.sqls.at(-1) || '')
+    expect(sent).toContain('json_array_length(steps)')
+    expect(sent).not.toContain('jsonb_array_length')
+  })
+
+  test('rewrites PG JSONB any-key operator to SQLite JSON1 joins', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'jsonb-any-key-test')
+    await backend.waitReady
+
+    await backend.query(
+      `
+      SELECT *
+      FROM "chat_0/cvr_rows"
+      WHERE
+        "clientGroupID" = $1
+        AND "patchVersion" > $2
+        AND "patchVersion" <= $3
+        AND ("refCounts" IS NULL OR NOT ("refCounts" ?| $4))
+      `,
+      ['cg1', '00:01', '00:02', ['q1', 'q2']]
+    )
+
+    const sent = compactSQL(http.sqls.at(-1) || '')
+    expect(sent).toContain('json_each("refCounts")')
+    expect(sent).toContain('json_each(?)')
+    expect(sent).toContain('obj.key = keys.value')
+    expect(sent).not.toContain('?|')
+    expect(http.params.at(-1)).toEqual(['cg1', '00:01', '00:02', '["q1","q2"]'])
+  })
+
+  test('rewrites JSON object builders and marks their result columns as JSON', async () => {
+    const http = await startDoHttp((sql) => {
+      if (compactSQL(sql).startsWith('SELECT')) {
+        return {
+          rows: [
+            {
+              table: '{"schema":"public","name":"message","metadata":{"rowKey":["id"]}}',
+              columns: '{"payload":{"source":"backfill"}}',
+            },
+          ],
+          columns: ['table', 'columns'],
+        }
+      }
+      return { rows: [], columns: [] }
+    })
+    const backend = new DoBackend(http.url, 'postgres', 'json-object-builder-test')
+    await backend.waitReady
+
+    const result = await backend.execProtocolRaw(
+      msg(
+        0x51,
+        cstr(`
+          SELECT
+            json_build_object(
+              'schema', b."schema",
+              'name', b."table",
+              'metadata', t."metadata"
+            ) AS "table",
+            json_object_agg(b."column", b."backfill") AS "columns"
+          FROM "chat_0/change-streamer_0"."backfilling" AS b
+          LEFT JOIN "chat_0/change-streamer_0"."tableMetadata" AS t
+            ON (b."schema" = t."schema" AND b."table" = t."table")
+          GROUP BY b."schema", b."table", t."metadata"
+        `)
+      )
+    )
+
+    const sent = compactSQL(http.sqls.at(-1) || '')
+    expect(sent).toContain('json_group_object')
+    expect(sent).toContain('json_valid')
+    expect(sent).not.toContain('json_build_object')
+    expect(sent).not.toContain('json_object_agg')
+    expect(rowDescriptionOids(result)).toMatchObject({
+      table: 114,
+      columns: 114,
+    })
+    expect(dataRowValues(result)).toEqual([
+      [
+        '{"schema":"public","name":"message","metadata":{"rowKey":["id"]}}',
+        '{"payload":{"source":"backfill"}}',
+      ],
+    ])
+  })
+
+  test('skips unsupported regexp_replace updates when the target table is empty', async () => {
+    const http = await startDoHttp((sql) => {
+      if (compactSQL(sql).includes('SELECT 1 AS ok FROM "message" LIMIT 1')) {
+        return { rows: [], columns: ['ok'] }
+      }
+      return { rows: [], columns: [] }
+    })
+    const backend = new DoBackend(http.url, 'postgres', 'regexp-empty-update-test')
+    await backend.waitReady
+
+    await backend.execProtocolRaw(msg(0x51, cstr('BEGIN')))
+    await backend.execProtocolRaw(
+      msg(
+        0x51,
+        cstr(`
+          UPDATE message
+          SET content = regexp_replace(content, '<@{([^:}]+):([^:}]+):([^}]+)}>', E'<@{\\\\1%\\\\2%\\\\3}>', 'g')
+          WHERE content LIKE '%<@{%:%:%}%';
+        `)
+      )
+    )
+    await backend.execProtocolRaw(msg(0x51, cstr('COMMIT')))
+
+    expect(
+      http.sqls.some((sql) =>
+        compactSQL(sql).includes('SELECT 1 AS ok FROM "message" LIMIT 1')
+      )
+    ).toBe(true)
+    expect(http.sqls.some((sql) => sql.includes('regexp_replace'))).toBe(false)
+  })
+
+  test('skips CTE backfill inserts when the source table is empty', async () => {
+    const http = await startDoHttp((sql) => {
+      if (compactSQL(sql).includes('SELECT 1 AS ok FROM "messageReaction" LIMIT 1')) {
+        return { rows: [], columns: ['ok'] }
+      }
+      return { rows: [], columns: [] }
+    })
+    const backend = new DoBackend(http.url, 'postgres', 'empty-cte-insert-test')
+    await backend.waitReady
+
+    await backend.execProtocolRaw(msg(0x51, cstr('BEGIN')))
+    await backend.execProtocolRaw(
+      msg(
+        0x51,
+        cstr(`
+          INSERT INTO "messageReactionStats"
+          WITH ranked_reactions AS (
+            SELECT mr."messageId", mr."reactionId"
+            FROM "messageReaction" mr
+          )
+          SELECT "messageId", "reactionId" FROM ranked_reactions;
+        `)
+      )
+    )
+    await backend.execProtocolRaw(msg(0x51, cstr('COMMIT')))
+
+    expect(
+      http.sqls.some((sql) =>
+        compactSQL(sql).includes('SELECT 1 AS ok FROM "messageReaction" LIMIT 1')
+      )
+    ).toBe(true)
+    expect(http.sqls.some((sql) => compactSQL(sql).startsWith('INSERT INTO'))).toBe(false)
+  })
+
+  test('executes zero-cache DELETE RETURNING count CTEs as SQLite deletes', async () => {
+    const http = await startDoHttp((sql) => {
+      if (compactSQL(sql).startsWith('DELETE FROM "todo_0/cdc_changeLog"')) {
+        return {
+          rows: [{ __orez_deleted: 1 }, { __orez_deleted: 1 }],
+          columns: ['__orez_deleted'],
+        }
+      }
+      return { rows: [], columns: [] }
+    })
+    const backend = new DoBackend(http.url, 'zero_cdb', 'delete-count-cte-test')
+    await backend.waitReady
+
+    await backend.execProtocolRaw(
+      parseMessage(`
+        WITH purged AS (
+          DELETE FROM "todo_0/cdc"."changeLog"
+          WHERE watermark < $1
+          RETURNING watermark, pos
+        )
+        SELECT COUNT(*) AS deleted
+        FROM purged;
+      `)
+    )
+    await backend.execProtocolRaw(bindStatementParams(['a1zs3dw2usxs']))
+    const result = await backend.execProtocolRaw(executePortal())
+
+    expect(dataRowValues(result)).toEqual([['2']])
+    expect(compactSQL(http.sqls.at(-1) || '')).toBe(
+      'DELETE FROM "todo_0/cdc_changeLog" WHERE watermark < ? RETURNING 1 AS "__orez_deleted"'
+    )
+    expect(http.params.at(-1)).toEqual(['a1zs3dw2usxs'])
+  })
+
+  test('skips DELETE USING cleanup statements when the target table is empty', async () => {
+    const http = await startDoHttp((sql) => {
+      if (
+        compactSQL(sql).includes(
+          'SELECT 1 AS ok FROM "channelNotificationSetting" LIMIT 1'
+        )
+      ) {
+        return { rows: [], columns: ['ok'] }
+      }
+      return { rows: [], columns: [] }
+    })
+    const backend = new DoBackend(http.url, 'postgres', 'empty-delete-using-test')
+    await backend.waitReady
+
+    await backend.execProtocolRaw(msg(0x51, cstr('BEGIN')))
+    await backend.execProtocolRaw(
+      msg(
+        0x51,
+        cstr(`
+          WITH ranked AS (
+            SELECT ctid, row_number() OVER (
+              PARTITION BY "channelId", "userId"
+              ORDER BY "updatedAt" DESC NULLS LAST, "id" DESC
+            ) AS rn
+            FROM "channelNotificationSetting"
+          )
+          DELETE FROM "channelNotificationSetting" t
+          USING ranked
+          WHERE t.ctid = ranked.ctid
+            AND ranked.rn > 1;
+        `)
+      )
+    )
+    await backend.execProtocolRaw(msg(0x51, cstr('COMMIT')))
+
+    expect(
+      http.sqls.some((sql) =>
+        compactSQL(sql).includes(
+          'SELECT 1 AS ok FROM "channelNotificationSetting" LIMIT 1'
+        )
+      )
+    ).toBe(true)
+    expect(http.sqls.some((sql) => compactSQL(sql).startsWith('WITH ranked'))).toBe(false)
+  })
+
+  test('rewrites TRUNCATE statements to SQLite deletes', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'truncate-rewrite-test')
+    await backend.waitReady
+
+    await backend.exec('TRUNCATE public.data, "apiKey";')
+
+    const sent = compactSQL(http.sqls.at(-1) || '')
+    expect(sent).toContain('DELETE FROM data')
+    expect(sent).toContain('DELETE FROM "apiKey"')
+    expect(sent).not.toContain('TRUNCATE')
+  })
+
+  test('translates simple plpgsql row triggers to SQLite triggers', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'sqlite-trigger-test')
+    await backend.waitReady
+
+    await backend.exec(`
+      CREATE OR REPLACE FUNCTION update_channel_latest_message_order()
+      RETURNS TRIGGER AS $$
+      BEGIN
+        IF NEW.type IS DISTINCT FROM 'draft'
+           AND NEW.deleted = false
+           AND NEW."isThreadReply" = false
+           AND NEW."order" IS NOT NULL THEN
+          UPDATE "channel"
+          SET "latestMessageOrder" = NEW."order"
+          WHERE id = NEW."channelId"
+            AND ("latestMessageOrder" IS NULL OR NEW."order" > "latestMessageOrder");
+        END IF;
+        RETURN NEW;
+      END;
+      $$ LANGUAGE plpgsql;
+
+      DROP TRIGGER IF EXISTS trg_update_channel_latest_message_order ON "message";
+      CREATE TRIGGER trg_update_channel_latest_message_order
+        AFTER INSERT OR UPDATE ON "message"
+        FOR EACH ROW
+        EXECUTE FUNCTION update_channel_latest_message_order();
+    `)
+
+    const sent = http.sqls.map(compactSQL).join('\n')
+    expect(sent).toContain(
+      'DROP TRIGGER IF EXISTS "trg_update_channel_latest_message_order_insert"'
+    )
+    expect(sent).toContain(
+      'CREATE TRIGGER IF NOT EXISTS "trg_update_channel_latest_message_order_insert" AFTER INSERT ON "message"'
+    )
+    expect(sent).toContain(
+      'CREATE TRIGGER IF NOT EXISTS "trg_update_channel_latest_message_order_update" AFTER UPDATE ON "message"'
+    )
+    expect(sent).toContain('UPDATE channel SET "latestMessageOrder" = new."order"')
+    expect(sent).toContain('new.deleted = 0')
+    expect(sent).not.toContain('CREATE OR REPLACE FUNCTION')
+    expect(sent).not.toContain('EXECUTE FUNCTION')
+  })
+
+  test('translates SELECT INTO NEW in plpgsql row triggers', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'sqlite-select-into-trigger-test')
+    await backend.waitReady
+
+    await backend.exec(`
+      CREATE OR REPLACE FUNCTION update_seen_last_order()
+      RETURNS TRIGGER AS $$
+      BEGIN
+        IF NEW."messageId" IS NOT NULL THEN
+          SELECT "order" INTO NEW."lastSeenOrder"
+          FROM "message"
+          WHERE id = NEW."messageId";
+        END IF;
+        RETURN NEW;
+      END;
+      $$ LANGUAGE plpgsql;
+
+      CREATE TRIGGER trg_update_seen_last_order
+        BEFORE INSERT OR UPDATE ON "seen"
+        FOR EACH ROW
+        EXECUTE FUNCTION update_seen_last_order();
+    `)
+
+    const sent = http.sqls.map(compactSQL).join('\n')
+    expect(sent).toContain(
+      'CREATE TRIGGER IF NOT EXISTS "trg_update_seen_last_order_insert" AFTER INSERT ON "seen"'
+    )
+    expect(sent).toContain(
+      'UPDATE "seen" SET "lastSeenOrder" = (SELECT "order" FROM message WHERE id = new."messageId") WHERE rowid = NEW.rowid'
+    )
+  })
+
+  test('translates NEW column assignments in plpgsql row triggers', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(
+      http.url,
+      'postgres',
+      'sqlite-new-assignment-trigger-test'
+    )
+    await backend.waitReady
+
+    await backend.exec(`
+      CREATE OR REPLACE FUNCTION update_task_numsteps()
+      RETURNS TRIGGER AS $$
+      BEGIN
+        IF NEW."steps" IS NULL THEN
+          NEW."numSteps" = 0;
+        ELSE
+          NEW."numSteps" = jsonb_array_length(NEW."steps");
+        END IF;
+        RETURN NEW;
+      END;
+      $$ LANGUAGE plpgsql;
+
+      CREATE TRIGGER task_numsteps_trigger
+        BEFORE INSERT OR UPDATE OF "steps" ON "task"
+        FOR EACH ROW
+        EXECUTE FUNCTION update_task_numsteps();
+    `)
+
+    const sent = http.sqls.map(compactSQL).join('\n')
+    expect(sent).toContain(
+      'CREATE TRIGGER IF NOT EXISTS "task_numsteps_trigger_insert" AFTER INSERT ON "task"'
+    )
+    expect(sent).toContain(
+      'CREATE TRIGGER IF NOT EXISTS "task_numsteps_trigger_update" AFTER UPDATE ON "task"'
+    )
+    expect(sent).toContain(
+      'UPDATE "task" SET "numSteps" = 0 WHERE rowid = NEW.rowid AND (new.steps IS NULL)'
+    )
+    expect(sent).toContain(
+      'UPDATE "task" SET "numSteps" = json_array_length(new.steps) WHERE rowid = NEW.rowid AND (NOT (new.steps IS NULL))'
+    )
+  })
+
+  test('removes update target aliases from compiled SQLite triggers', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(
+      http.url,
+      'postgres',
+      'sqlite-update-alias-trigger-test'
+    )
+    await backend.waitReady
+
+    await backend.exec(`
+      CREATE OR REPLACE FUNCTION sync_user_role_permissions_on_insert()
+      RETURNS TRIGGER AS $$
+      BEGIN
+        UPDATE "userRole" ur SET
+          "canAdmin" = r."canAdmin"
+        FROM "role" r
+        WHERE ur."roleId" = r."id"
+          AND ur."serverId" = NEW."serverId";
+        RETURN NEW;
+      END;
+      $$ LANGUAGE plpgsql;
+
+      CREATE TRIGGER trg_user_role_permission_copy
+        AFTER INSERT ON "userRole"
+        FOR EACH ROW
+        EXECUTE FUNCTION sync_user_role_permissions_on_insert();
+    `)
+
+    const sent = http.sqls.map(compactSQL).join('\n')
+    expect(sent).toContain(
+      'UPDATE "userRole" SET "canAdmin" = r."canAdmin" FROM role AS r WHERE "userRole"."roleId" = r.id'
+    )
+    expect(sent).toContain('"userRole"."serverId" = new."serverId"')
+    expect(sent).not.toContain('UPDATE "userRole" AS ur')
+  })
+
+  test('rewrites md5 trigger expressions to deterministic SQLite-compatible values', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'sqlite-md5-trigger-test')
+    await backend.waitReady
+
+    await backend.exec(`
+      CREATE OR REPLACE FUNCTION set_permissions_hash()
+      RETURNS TRIGGER AS $$
+      BEGIN
+        NEW.hash = md5(NEW.permissions::text);
+        RETURN NEW;
+      END;
+      $$ LANGUAGE plpgsql;
+
+      CREATE TRIGGER on_set_permissions
+        BEFORE INSERT OR UPDATE ON "chat_permissions"
+        FOR EACH ROW
+        EXECUTE FUNCTION set_permissions_hash();
+    `)
+
+    const sent = http.sqls.map(compactSQL).join('\n')
+    expect(sent).toContain(
+      'UPDATE "chat_permissions" SET "hash" = new.permissions WHERE rowid = NEW.rowid'
+    )
+    expect(sent).not.toContain('md5(')
+  })
+
+  test('skips unsupported plpgsql trigger statements instead of throwing', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'sqlite-unsupported-trigger-test')
+    await backend.waitReady
+
+    await backend.exec(`
+      CREATE OR REPLACE FUNCTION unsupported_trigger()
+      RETURNS TRIGGER AS $$
+      BEGIN
+        invalid plpgsql syntax here;
+        RETURN NEW;
+      END;
+      $$ LANGUAGE plpgsql;
+
+      CREATE TRIGGER unsupported_trigger
+        BEFORE INSERT ON "task"
+        FOR EACH ROW
+        EXECUTE FUNCTION unsupported_trigger();
+    `)
+
+    const sent = http.sqls.map(compactSQL).join('\n')
+    expect(sent).not.toContain('CREATE TRIGGER IF NOT EXISTS "unsupported_trigger"')
+  })
+
+  test('skips plpgsql triggers that require PostgreSQL trigger variables', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'sqlite-trigger-variable-test')
+    await backend.waitReady
+
+    await backend.exec(`
+      CREATE OR REPLACE FUNCTION refresh_stats()
+      RETURNS TRIGGER AS $$
+      BEGIN
+        IF TG_OP = 'INSERT' THEN
+          UPDATE stats SET count = count + 1;
+        END IF;
+        RETURN NEW;
+      END;
+      $$ LANGUAGE plpgsql;
+
+      CREATE TRIGGER refresh_stats_insert
+        AFTER INSERT ON "messageReaction"
+        FOR EACH ROW
+        EXECUTE FUNCTION refresh_stats();
+    `)
+
+    const sent = http.sqls.map(compactSQL).join('\n')
+    expect(sent).not.toContain('CREATE TRIGGER IF NOT EXISTS "refresh_stats_insert"')
+    expect(sent).not.toContain('TG_OP')
+  })
+
+  test('rewrites trigger drops for SQLite trigger variants', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'drop-trigger-test')
+    await backend.waitReady
+
+    await backend.exec(
+      'DROP TRIGGER IF EXISTS "messageReactionInsertTrigger" ON "messageReaction";'
+    )
+
+    const sent = http.sqls.map(compactSQL).join('\n')
+    expect(sent).toContain('DROP TRIGGER IF EXISTS "messageReactionInsertTrigger"')
+    expect(sent).toContain('DROP TRIGGER IF EXISTS "messageReactionInsertTrigger_insert"')
+  })
+
+  test('drops event trigger statements because event trigger creation is skipped', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'drop-event-trigger-test')
+    await backend.waitReady
+
+    await backend.exec(`
+      DROP EVENT TRIGGER IF EXISTS chat_ddl_start_0;
+      CREATE EVENT TRIGGER chat_ddl_start_0
+        ON ddl_command_start EXECUTE FUNCTION public._zero_notify_change();
+    `)
+
+    expect(http.sqls.some((sql) => compactSQL(sql).includes('EVENT TRIGGER'))).toBe(false)
+  })
+
+  test('drops function statements because function creation is skipped', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'drop-function-test')
+    await backend.waitReady
+
+    await backend.exec('DROP FUNCTION IF EXISTS "notifyReactionChange"();')
+
+    expect(http.sqls.some((sql) => compactSQL(sql).startsWith('DROP FUNCTION'))).toBe(
+      false
+    )
+  })
+
+  test('drops anonymous DO blocks because they only wrap skipped PG DDL', async () => {
+    const http = await startDoHttp(() => ({ rows: [], columns: [] }))
+    const backend = new DoBackend(http.url, 'postgres', 'do-block-test')
+    await backend.waitReady
+
+    await backend.exec(`
+      DO $$ BEGIN
+        IF NOT EXISTS (
+          SELECT 1 FROM pg_constraint WHERE conname = 'example_constraint'
+        ) THEN
+          ALTER TABLE "example" ADD CONSTRAINT "example_constraint" UNIQUE ("id");
+        END IF;
+      END $$;
+    `)
+
+    expect(http.sqls.some((sql) => compactSQL(sql).startsWith('DO'))).toBe(false)
+  })
+
+  test('no-ops direct calls to functions skipped by parser-backed DDL rewrite', async () => {
+    const http = await startDoHttp((sql) => {
+      if (compactSQL(sql).startsWith('SELECT NULL AS')) {
+        return {
+          rows: [{ refreshMessageReactionStats: null }],
+          columns: ['refreshMessageReactionStats'],
+        }
+      }
+      return { rows: [], columns: [] }
+    })
+    const backend = new DoBackend(http.url, 'postgres', 'skipped-function-call-test')
+    await backend.waitReady
+
+    await backend.exec(`
+      CREATE OR REPLACE FUNCTION "refreshMessageReactionStats"()
+      RETURNS void AS $$
+      BEGIN
+      END;
+      $$ LANGUAGE plpgsql;
+    `)
+    await backend.exec('SELECT "refreshMessageReactionStats"();')
+
+    expect(http.sqls.some((sql) => sql.includes('"refreshMessageReactionStats"()'))).toBe(
+      false
+    )
+    expect(
+      http.sqls.some((sql) =>
+        compactSQL(sql).includes('SELECT NULL AS "refreshMessageReactionStats"')
+      )
+    ).toBe(true)
+  })
+})