orez 0.1.36 → 0.1.38

package/dist/worker/shims/postgres.js

@@ -0,0 +1,1181 @@
+// NOTE THIS IS NOT OREZ NODE THIS IS NOT A GOOD REFERENCE BECAUSE ITS OUR EARLY GUESS AT WHAT COULD WORK
+// DO NOT STUDY THIS, THE OTHER STUFF IN SRC IS WHERE YOU EANT TO LOOK
+/**
+ * postgres shim for cloudflare workers.
+ *
+ * wraps a PGlite instance to implement the `postgres` npm package API
+ * that zero-cache uses. enables bundler aliasing so zero-cache talks to
+ * PGlite instead of a real postgres server.
+ *
+ * usage with bundler alias:
+ *   alias: { 'postgres': './src/worker/shims/postgres.js' }
+ *
+ * usage directly:
+ *   import { createPostgresShim } from 'orez/worker/shims/postgres'
+ *   const sql = createPostgresShim(pglite)
+ *   const rows = await sql`SELECT * FROM users WHERE id = ${id}`
+ */
+import { PassThrough } from 'stream';
+import { Mutex } from '../../mutex.js';
+import { handleStartReplication, signalReplicationChange, } from '../../replication/handler.js';
+// debounced signal — matches orez pg-proxy's 8ms debounce.
+// ensures signal fires even during long-running mutagen callbacks.
+let _signalTimer = null;
+function debouncedSignal() {
+    if (_signalTimer)
+        return;
+    _signalTimer = setTimeout(() => {
+        _signalTimer = null;
+        signalReplicationChange();
+    }, 8);
+}
+// -- PostgresError --
+export class PostgresError extends Error {
+    name = 'PostgresError';
+    severity_local;
+    severity;
+    code;
+    position;
+    file;
+    line;
+    routine;
+    detail;
+    hint;
+    schema_name;
+    table_name;
+    column_name;
+    constraint_name;
+    query;
+    parameters;
+    constructor(info) {
+        super(info.message || 'postgres error');
+        this.severity_local = info.severity || 'ERROR';
+        this.severity = info.severity || 'ERROR';
+        this.code = info.code || '00000';
+        this.position = info.position || '';
+        this.file = info.file || '';
+        this.line = info.line || '';
+        this.routine = info.routine || '';
+        this.detail = info.detail;
+        this.hint = info.hint;
+        this.schema_name = info.schema_name;
+        this.table_name = info.table_name;
+        this.column_name = info.column_name;
+        this.constraint_name = info.constraint_name;
+        this.query = info.query || '';
+        this.parameters = info.parameters || [];
+        Object.assign(this, info);
+    }
+}
+// -- Identifier --
+// returned by sql(string) for dynamic identifier escaping
+class Identifier {
+    value;
+    constructor(value) {
+        this.value = escapeIdentifier(value);
+    }
+}
+function escapeIdentifier(str) {
+    return '"' + str.replace(/"/g, '""').replace(/\./g, '"."') + '"';
+}
+function createResultArray(pgliteResult, queryString) {
+    // guard against undefined/null results (e.g. DDL on PGlite proxy)
+    if (!pgliteResult) {
+        const empty = [];
+        empty.count = 0;
+        empty.command = detectCommand(queryString);
+        empty.state = { status: 'idle', pid: 0, secret: 0 };
+        empty.statement = { name: '', string: queryString, types: [], columns: [] };
+        empty.columns = [];
+        return empty;
+    }
+    const rows = pgliteResult.rows;
+    const columns = (pgliteResult.fields || []).map((f, i) => ({
+        name: f.name,
+        type: f.dataTypeID,
+        table: 0,
+        number: i,
+    }));
+    // create a proper array with rows as elements
+    const result = [...rows];
+    // attach metadata
+    const command = detectCommand(queryString);
+    // for SELECT queries affectedRows is 0, use row count instead
+    result.count =
+        command === 'SELECT' || !pgliteResult.affectedRows
+            ? rows.length
+            : pgliteResult.affectedRows;
+    result.command = command;
+    result.state = { status: 'idle', pid: 0, secret: 0 };
+    result.statement = {
+        name: '',
+        string: queryString,
+        types: [],
+        columns,
+    };
+    result.columns = columns;
+    return result;
+}
+function detectCommand(sql) {
+    const trimmed = sql.trimStart().toUpperCase();
+    if (trimmed.startsWith('SELECT'))
+        return 'SELECT';
+    if (trimmed.startsWith('INSERT'))
+        return 'INSERT';
+    if (trimmed.startsWith('UPDATE'))
+        return 'UPDATE';
+    if (trimmed.startsWith('DELETE'))
+        return 'DELETE';
+    if (trimmed.startsWith('CREATE'))
+        return 'CREATE';
+    if (trimmed.startsWith('DROP'))
+        return 'DROP';
+    if (trimmed.startsWith('ALTER'))
+        return 'ALTER';
+    return trimmed.split(/\s/)[0] || 'SELECT';
+}
+// -- multi-statement detection --
+// detects if a query string contains multiple SQL statements.
+// strips string literals and comments first to avoid false positives
+// from semicolons inside quoted strings.
+function hasMultipleStatements(sql) {
+    // strip dollar-quoted strings ($$ ... $$)
+    let stripped = sql.replace(/(\$[a-zA-Z_]*\$)([\s\S]*?)\1/g, '');
+    // strip string literals (single-quoted, with '' escape)
+    stripped = stripped.replace(/'(?:[^']|'')*'/g, '');
+    // strip double-quoted identifiers
+    stripped = stripped.replace(/"(?:[^"]|"")*"/g, '');
+    // strip -- line comments
+    stripped = stripped.replace(/--[^\n]*/g, '');
+    // strip /* block comments */
+    stripped = stripped.replace(/\/\*[\s\S]*?\*\//g, '');
+    // check if there are multiple non-empty statements
+    const statements = stripped
+        .split(';')
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+    return statements.length > 1;
+}
+// -- parameter serialization --
+// convert js values to postgres-compatible parameter values
+function serializeParam(value) {
+    if (value === null || value === undefined)
+        return null;
+    if (value instanceof Identifier)
+        return value; // handled in template assembly
+    if (typeof value === 'bigint')
+        return value.toString();
+    if (typeof value === 'object' &&
+        !(value instanceof Date) &&
+        !Array.isArray(value) &&
+        !ArrayBuffer.isView(value)) {
+        return JSON.stringify(value);
+    }
+    return value;
+}
+// -- template tag to parameterized query conversion --
+// sql`SELECT * FROM foo WHERE id = ${id} AND name = ${name}`
+// becomes: { text: 'SELECT * FROM foo WHERE id = $1 AND name = $2', params: [id, name] }
+function buildQuery(strings, values) {
+    const params = [];
+    let text = '';
+    for (let i = 0; i < strings.length; i++) {
+        text += strings[i];
+        if (i < values.length) {
+            const val = values[i];
+            if (val instanceof Identifier) {
+                // identifiers are inlined (already escaped)
+                text += val.value;
+            }
+            else if (val &&
+                typeof val === 'object' &&
+                '_isHelper' in val &&
+                val._isHelper) {
+                // sql(object) helper — expand based on preceding SQL context
+                const helper = val;
+                const before = text.trimEnd().toUpperCase();
+                if (/\)\s*$/.test(before) ||
+                    /SET\s*$/i.test(before) ||
+                    /DO\s+UPDATE\s+SET\s*$/i.test(before)) {
+                    // UPDATE SET context: col1 = $1, col2 = $2
+                    const { set, params: updateParams } = helper.toUpdate();
+                    // rebase placeholder indices
+                    const rebasedSet = set.replace(/\$(\d+)/g, (_, n) => `$${params.length + Number(n)}`);
+                    text += rebasedSet;
+                    params.push(...updateParams.map(serializeParam));
+                }
+                else {
+                    // INSERT context: (col1, col2) VALUES ($1, $2)
+                    const { columns, values: placeholders, params: insertParams, } = helper.toInsert();
+                    // rebase placeholder indices
+                    const rebasedPlaceholders = placeholders.replace(/\$(\d+)/g, (_, n) => `$${params.length + Number(n)}`);
+                    text += `(${columns}) VALUES (${rebasedPlaceholders})`;
+                    params.push(...insertParams.map(serializeParam));
+                }
+            }
+            else if (val &&
+                typeof val === 'object' &&
+                '_isArrayExpansion' in val &&
+                val._isArrayExpansion) {
+                // sql([1,2,3]) — expand for IN clauses: ($1, $2, $3)
+                const arr = val._values;
+                const placeholders = arr.map((_, j) => `$${params.length + j + 1}`).join(', ');
+                text += `(${placeholders})`;
+                params.push(...arr.map(serializeParam));
+            }
+            else if (Array.isArray(val)) {
+                // raw array in template tag
+                // check context: json_to_recordset etc. need JSON, everything else needs PG array
+                const before = text.trimEnd();
+                const needsJson = /json_to_record(?:set)?|json_(?:array|build|each|populate)\s*\(\s*$/i.test(before) ||
+                    (/\(\s*$/.test(before) &&
+                        /json/i.test(before.slice(Math.max(0, before.length - 40))));
+                if (needsJson) {
+                    params.push(JSON.stringify(val));
+                    text += `$${params.length}::json`;
+                }
+                else {
+                    // PostgreSQL array literal: {val1,val2,...}
+                    const pgArray = `{${val
+                        .map((v) => {
+                        if (v === null || v === undefined)
+                            return 'NULL';
+                        const s = String(v);
+                        // quote if contains special chars
+                        if (s.includes(',') ||
+                            s.includes('"') ||
+                            s.includes('{') ||
+                            s.includes('}') ||
+                            s.includes(' ')) {
+                            return `"${s.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+                        }
+                        return s;
+                    })
+                        .join(',')}}`;
+                    params.push(pgArray);
+                    text += `$${params.length}`;
+                }
+            }
+            else {
+                const serialized = serializeParam(val);
+                params.push(serialized);
+                // add ::json cast for JSON values (PGlite needs explicit type for json_to_recordset etc.)
+                const needsJsonCast = typeof serialized === 'string' &&
+                    typeof val === 'object' &&
+                    val !== null &&
+                    (serialized.startsWith('[') || serialized.startsWith('{'));
+                text += `$${params.length}${needsJsonCast ? '::json' : ''}`;
+            }
+        }
+    }
+    return { text, params };
+}
+// -- pending query --
+// wraps a promise to add .simple(), .readable(), .writable(), .execute(), .describe(), .values(), .raw()
+function createPendingQuery(promise) {
+    const pending = promise;
+    pending.simple = () => pending;
+    pending.execute = () => pending;
+    pending.cancel = () => { };
+    pending.describe = () => Promise.reject(new Error('describe() not supported in worker mode'));
+    pending.values = () => promise.then((rows) => {
+        if (!Array.isArray(rows))
+            return [];
+        return rows.map((row) => Object.values(row));
+    });
+    pending.raw = () => Promise.reject(new Error('raw() not supported in worker mode'));
+    pending.readable = () => {
+        throw new Error('readable() not supported in worker mode');
+    };
+    pending.writable = () => {
+        throw new Error('writable() not supported in worker mode');
+    };
+    pending.forEach = (cb) => promise.then((rows) => {
+        const result = { count: rows.length, command: rows.command || 'SELECT' };
+        for (const row of rows)
+            cb(row, result);
+        return result;
+    });
+    // cursor: returns async iterable yielding batches of rows
+    pending.cursor = (batchSize = 100) => ({
+        [Symbol.asyncIterator]() {
+            let allRows = null;
+            let offset = 0;
+            return {
+                async next() {
+                    if (!allRows) {
+                        const result = await promise;
+                        allRows = Array.isArray(result) ? result : [];
+                    }
+                    if (offset >= allRows.length)
+                        return { done: true, value: undefined };
+                    const batch = allRows.slice(offset, offset + batchSize);
+                    offset += batchSize;
+                    return { done: false, value: batch };
+                },
+            };
+        },
+    });
+    pending.stream = () => {
+        throw new Error('stream() is deprecated, use forEach()');
+    };
+    return pending;
+}
+function getSharedMutex(target) {
+    const existing = target.__orez_mutex;
+    if (existing)
+        return existing;
+    const mutex = new Mutex();
+    target.__orez_mutex = mutex;
+    return mutex;
+}
+// -- raw wire protocol helper --
+// bypasses PGlite's JS mutexes (Fe2/ke2) by calling execProtocolRawSync directly.
+// used for replication protocol queries and external queries that would otherwise
+// deadlock against zero-cache's long-running transaction pool.
+function rawQuery(pglite, sql) {
+    const pg = pglite;
+    if (!pg.execProtocolRawSync)
+        return [];
+    const enc = new TextEncoder();
+    const sqlBytes = enc.encode(sql + '\0');
+    const len = 4 + sqlBytes.length;
+    const msg = new Uint8Array(1 + len);
+    msg[0] = 0x51; // Q message
+    new DataView(msg.buffer).setInt32(1, len);
+    msg.set(sqlBytes, 5);
+    const result = pg.execProtocolRawSync(msg);
+    // parse wire protocol response
+    const rows = [];
+    const fields = [];
+    let pos = 0;
+    const dv = new DataView(result.buffer, result.byteOffset, result.byteLength);
+    while (pos < result.length) {
+        const type = result[pos];
+        const msgLen = dv.getInt32(pos + 1) + 1;
+        if (type === 0x54) {
+            // RowDescription
+            const nFields = dv.getInt16(pos + 5);
+            let fpos = pos + 7;
+            for (let i = 0; i < nFields; i++) {
+                let end = fpos;
+                while (result[end] !== 0)
+                    end++;
+                fields.push(new TextDecoder().decode(result.subarray(fpos, end)));
+                fpos = end + 1 + 18;
+            }
+        }
+        else if (type === 0x44) {
+            // DataRow
+            const nCols = dv.getInt16(pos + 5);
+            const row = {};
+            let cpos = pos + 7;
+            for (let i = 0; i < nCols; i++) {
+                const colLen = dv.getInt32(cpos);
+                cpos += 4;
+                if (colLen === -1) {
+                    row[fields[i]] = null;
+                }
+                else {
+                    row[fields[i]] = new TextDecoder().decode(result.subarray(cpos, cpos + colLen));
+                    cpos += colLen;
+                }
+            }
+            rows.push(row);
+        }
+        else if (type === 0x45) {
+            // ErrorResponse
+            break;
+        }
+        pos += msgLen;
+    }
+    return rows;
+}
+function rawExec(pglite, sql) {
+    const pg = pglite;
+    if (!pg.execProtocolRawSync)
+        return;
+    const enc = new TextEncoder();
+    const sqlBytes = enc.encode(sql + '\0');
+    const len = 4 + sqlBytes.length;
+    const msg = new Uint8Array(1 + len);
+    msg[0] = 0x51;
+    new DataView(msg.buffer).setInt32(1, len);
+    msg.set(sqlBytes, 5);
+    pg.execProtocolRawSync(msg);
+}
+// create a proxy around PGlite that routes query/exec through raw wire protocol
+// this is needed because the replication handler runs continuously and would
+// deadlock against zero-cache's transaction pool if it used the normal PGlite API
+function createRawDbProxy(pg) {
+    if (!pg.execProtocolRawSync)
+        return pg;
+    return new Proxy(pg, {
+        get(target, prop) {
+            if (prop === 'query') {
+                return async (sql, params) => {
+                    // for parameterized queries, fall back to normal query
+                    // (raw protocol doesn't support parameters easily)
+                    if (params?.length)
+                        return target.query(sql, params);
+                    const rows = rawQuery(target, sql);
+                    return { rows, fields: [], affectedRows: 0 };
+                };
+            }
+            if (prop === 'exec') {
+                return async (sql) => {
+                    rawExec(target, sql);
+                    return [];
+                };
+            }
+            if (prop === 'listen') {
+                // skip listen in browser — it's a secondary signal mechanism
+                return async () => async () => { };
+            }
+            if (prop === 'closed')
+                return target.closed;
+            return target[prop];
+        },
+    });
+}
+// -- execute a query, routing multi-statement to exec() --
+// PGlite.query() only handles single statements. multi-statement DDL
+// (schema migrations, etc.) must use exec(). when params are present
+// AND the query is multi-statement, we split and run each individually.
+// intercept replication-related queries that PGlite can't handle natively.
+// these are sent by zero-cache during initialization (wal_level check,
+// replication slot management, etc.) and need fake responses.
+// uses rawQuery/rawExec to bypass PGlite's transaction mutex.
+async function interceptReplicationQuery(text, pglite) {
+    const upper = text.trimStart().toUpperCase();
+    // wal_level check: zero-cache verifies logical replication is enabled
+    if (upper.includes('WAL_LEVEL') &&
+        (upper.includes('CURRENT_SETTING') || upper.startsWith('SHOW'))) {
+        if (upper.includes('VERSION')) {
+            return fakeResult([{ walLevel: 'logical', version: '170004' }], text);
+        }
+        return fakeResult([{ walLevel: 'logical' }], text);
+    }
+    // CREATE_REPLICATION_SLOT: zero-cache creates a slot during initial sync
+    if (upper.includes('CREATE_REPLICATION_SLOT')) {
+        const match = text.match(/CREATE_REPLICATION_SLOT\s+(?:"([^"]+)"|'([^']+)'|(\S+))/i);
+        const slotName = match?.[1] || match?.[2] || match?.[3] || 'zero_slot';
+        const lsn = '0/1000100';
+        try {
+            await pglite.exec(`
+        CREATE TABLE IF NOT EXISTS _orez._zero_replication_slots (
+          slot_name TEXT PRIMARY KEY, restart_lsn TEXT,
+          confirmed_flush_lsn TEXT, wal_status TEXT DEFAULT 'reserved'
+        )
+      `);
+            await pglite.exec(`INSERT INTO _orez._zero_replication_slots (slot_name, restart_lsn, confirmed_flush_lsn)
+         VALUES ('${slotName.replace(/'/g, "''")}', '${lsn}', '${lsn}')
+         ON CONFLICT (slot_name) DO UPDATE SET restart_lsn = '${lsn}'`);
+        }
+        catch { }
+        return fakeResult([
+            {
+                slot_name: slotName,
+                consistent_point: lsn,
+                snapshot_name: '00000003-00000001-1',
+                output_plugin: 'pgoutput',
+            },
+        ], text);
+    }
+    // DROP_REPLICATION_SLOT
+    if (upper.startsWith('DROP_REPLICATION_SLOT')) {
+        return fakeResult([], text, 'DROP_REPLICATION_SLOT');
+    }
+    // pg_replication_slots query
+    if (upper.includes('PG_REPLICATION_SLOTS') && upper.includes('SELECT')) {
+        try {
+            const result = await pglite.query(`SELECT slot_name, restart_lsn as "restartLSN", wal_status as "walStatus"
+         FROM _orez._zero_replication_slots`);
+            return createResultArray(result, text);
+        }
+        catch {
+            return fakeResult([], text);
+        }
+    }
+    // IDENTIFY_SYSTEM
+    if (upper === 'IDENTIFY_SYSTEM' || upper === 'IDENTIFY_SYSTEM;') {
+        return fakeResult([
+            {
+                systemid: '1234567890',
+                timeline: '1',
+                xlogpos: '0/1000100',
+                dbname: 'template1',
+            },
+        ], text);
+    }
+    // ALTER ROLE ... REPLICATION
+    if (upper.startsWith('ALTER ROLE') && upper.includes('REPLICATION')) {
+        return fakeResult([], text, 'ALTER ROLE');
+    }
+    // SET TRANSACTION / SET SESSION / SET LOCAL — PGlite doesn't support SET LOCAL
+    if (upper.startsWith('SET TRANSACTION') ||
+        upper.startsWith('SET SESSION') ||
+        upper.startsWith('SET LOCAL')) {
+        return fakeResult([], text, 'SET');
+    }
+    // pg_settings query (wal_sender_timeout etc.) — not available in PGlite
+    if (upper.includes('PG_SETTINGS') && upper.includes('WAL_SENDER_TIMEOUT')) {
+        return fakeResult([{ walSenderTimeoutMs: 60000 }], text);
+    }
+    // event triggers: PGlite doesn't support them (requires superuser),
+    // and DDL detection isn't needed in browser mode
+    if (upper.includes('EVENT TRIGGER') &&
+        (upper.startsWith('DROP') || upper.startsWith('CREATE'))) {
+        return fakeResult([], text, upper.startsWith('DROP') ? 'DROP' : 'CREATE');
+    }
+    return null;
+}
+function fakeResult(rows, queryString, command) {
+    const columns = rows.length > 0
+        ? Object.keys(rows[0]).map((name, i) => ({ name, type: 25, table: 0, number: i }))
+        : [];
+    const result = [...rows];
+    result.count = rows.length;
+    result.command = command || detectCommand(queryString);
+    result.state = { status: 'idle', pid: 0, secret: 0 };
+    result.statement = { name: '', string: queryString, types: [], columns };
+    result.columns = columns;
+    return result;
+}
+async function executeQuery(executor, text, params, pglite) {
+    // intercept replication-related queries before they reach PGlite
+    if (pglite) {
+        const intercepted = await interceptReplicationQuery(text, pglite);
+        if (intercepted)
+            return intercepted;
+    }
+    // strip FK constraints from CREATE TABLE in browser mode.
+    // without a wrapping transaction, DEFERRABLE can't defer across separate
+    // INSERT statements — zero-cache inserts desires before queries exist.
+    // single-connection browser dev preview doesn't need FK enforcement.
+    if (/FOREIGN\s+KEY/i.test(text) && /CREATE\s+TABLE/i.test(text)) {
+        text = text.replace(/,?\s*(?:CONSTRAINT\s+\w+\s+)?FOREIGN\s+KEY\s*\([^)]*\)\s*REFERENCES\s+[^,(]+(?:\s*\([^)]*\))?(?:\s+ON\s+(?:DELETE|UPDATE)\s+(?:CASCADE|SET\s+NULL|SET\s+DEFAULT|RESTRICT|NO\s+ACTION))*(?:\s+DEFERRABLE[^,)]*)?/gi, '');
+    }
+    const isMulti = hasMultipleStatements(text);
+    if (!isMulti) {
+        // use normal PGlite query — rawQuery breaks transaction state
+        const r = await (params.length > 0
+            ? executor.query(text, params)
+            : executor.query(text));
+        const result = createResultArray(r, text);
+        if (isWriteCommand(text)) {
+            signalReplicationChange();
+            debouncedSignal(); // also fire debounced in case immediate signal is consumed
+        }
+        return result;
+    }
+    // multi-statement: ALWAYS split and run individually
+    if (params.length === 0) {
+        const stmts = splitStatements(text);
+        let lastResult = { rows: [], fields: [], affectedRows: 0 };
+        for (const stmt of stmts) {
+            lastResult = (await executor.query(stmt));
+        }
+        const result = createResultArray(lastResult, text);
+        if (isWriteCommand(text))
+            signalReplicationChange();
+        return result;
+    }
+    // multi-statement WITH params — split and run each statement,
+    // distributing $N params to the correct statement
+    const statements = splitStatements(text);
+    let lastResult = { rows: [], fields: [], affectedRows: 0 };
+    for (const stmt of statements) {
+        // find which $N params this statement references
+        const paramRefs = [...stmt.matchAll(/\$(\d+)/g)].map((m) => Number(m[1]));
+        if (paramRefs.length > 0) {
+            // remap $N to $1, $2, ... for this statement's params
+            const stmtParams = paramRefs.map((n) => params[n - 1]);
+            let remapped = stmt;
+            paramRefs.forEach((origN, i) => {
+                remapped = remapped.replace(new RegExp(`\\$${origN}\\b`), `$${i + 1}`);
+            });
+            lastResult = (await executor.query(remapped, stmtParams));
+        }
+        else {
+            // no params in this statement — can use query() directly
+            lastResult = (await executor.query(stmt));
+        }
+    }
+    const result = createResultArray(lastResult, text);
+    if (isWriteCommand(text))
+        signalReplicationChange();
+    return result;
+}
+const WRITE_COMMANDS = new Set(['INSERT', 'UPDATE', 'DELETE', 'CREATE', 'DROP', 'ALTER']);
+function isWriteCommand(sql) {
+    return WRITE_COMMANDS.has(detectCommand(sql));
+}
+// split SQL into individual statements, respecting string literals
+function splitStatements(sql) {
+    // strip string literals to find real semicolons
+    const literals = [];
+    // dollar-quoted strings first ($$ ... $$ or $tag$ ... $tag$)
+    let stripped = sql.replace(/(\$[a-zA-Z_]*\$)([\s\S]*?)\1/g, (match) => {
+        literals.push(match);
+        return `__LIT${literals.length - 1}__`;
+    });
+    stripped = stripped.replace(/'(?:[^']|'')*'/g, (match) => {
+        literals.push(match);
+        return `__LIT${literals.length - 1}__`;
+    });
+    stripped = stripped.replace(/"(?:[^"]|"")*"/g, (match) => {
+        literals.push(match);
+        return `__LIT${literals.length - 1}__`;
+    });
+    // strip -- comments
+    stripped = stripped.replace(/--[^\n]*/g, '');
+    // strip /* block comments */
+    stripped = stripped.replace(/\/\*[\s\S]*?\*\//g, '');
+    // split on semicolons
+    const parts = stripped
+        .split(';')
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+    // restore literals
+    return parts.map((part) => part.replace(/__LIT(\d+)__/g, (_, i) => literals[Number(i)]));
+}
+// -- sql function factory for a given executor --
+// used both for the top-level sql and for transaction sql
+function createSqlFunction(executor, rootPglite) {
+    function sql(first, ...rest) {
+        // tagged template: sql`SELECT ...`
+        if (first && Array.isArray(first.raw)) {
+            const { text, params } = buildQuery(first, rest);
+            const promise = executeQuery(executor, text, params, rootPglite);
+            return createPendingQuery(promise);
+        }
+        // function call with string: sql('identifier') => Identifier
+        if (typeof first === 'string' && rest.length === 0) {
+            return new Identifier(first);
+        }
+        // sql(object) — helper for dynamic INSERT/UPDATE
+        if (typeof first === 'object' && first !== null && !Array.isArray(first)) {
+            return {
+                _isHelper: true,
+                _data: first,
+                toInsert() {
+                    const keys = Object.keys(first);
+                    const columns = keys.map((k) => '"' + k.replace(/"/g, '""') + '"').join(', ');
+                    const placeholders = keys.map((_, i) => `$${i + 1}`).join(', ');
+                    return { columns, values: placeholders, params: keys.map((k) => first[k]) };
+                },
+                toUpdate() {
+                    const keys = Object.keys(first);
+                    const set = keys
+                        .map((k, i) => `"${k.replace(/"/g, '""')}" = $${i + 1}`)
+                        .join(', ');
+                    return { set, params: keys.map((k) => first[k]) };
+                },
+            };
+        }
+        // sql(array) — parameter expansion for IN clauses
+        // wrap in marker object so buildQuery knows to expand (not serialize as JSON)
+        if (Array.isArray(first)) {
+            return { _isArrayExpansion: true, _values: first };
+        }
+        throw new Error('postgres shim: unsupported sql() call');
+    }
+    return sql;
+}
+// -- COPY TO STDOUT support --
+function createCopyPendingQuery(copyQuery, executor) {
+    // extract the query from COPY (SELECT ...) TO STDOUT or COPY table TO STDOUT
+    let selectQuery;
+    const parenMatch = copyQuery.match(/COPY\s*\(([\s\S]+)\)\s*TO\s+STDOUT/i);
+    if (parenMatch) {
+        selectQuery = parenMatch[1].trim();
+    }
+    else {
+        const tableMatch = copyQuery.match(/COPY\s+("(?:[^"]|"")*"(?:\."(?:[^"]|"")*")*|\S+)\s+TO\s+STDOUT/i);
+        selectQuery = tableMatch ? `SELECT * FROM ${tableMatch[1]}` : 'SELECT 1 WHERE false';
+    }
+    // returns a Node.js Readable stream (via PassThrough) compatible with pipeline()
+    const readablePromise = (async () => {
+        const result = await executor.query(selectQuery);
+        const rows = result.rows;
+        const pt = new PassThrough();
+        // write all rows as TSV-encoded COPY output, using Buffer for stream compatibility
+        const encoder = typeof Buffer !== 'undefined' ? null : new TextEncoder();
+        for (const row of rows) {
+            const values = Object.values(row).map((v) => {
+                if (v === null || v === undefined)
+                    return '\\N';
+                if (typeof v === 'boolean')
+                    return v ? 't' : 'f';
+                if (typeof v === 'object')
+                    return JSON.stringify(v)
+                        .replace(/\\/g, '\\\\')
+                        .replace(/\t/g, '\\t')
+                        .replace(/\n/g, '\\n');
+                return String(v)
+                    .replace(/\\/g, '\\\\')
+                    .replace(/\t/g, '\\t')
+                    .replace(/\n/g, '\\n');
+            });
+            const line = values.join('\t') + '\n';
+            const chunk = encoder ? encoder.encode(line) : Buffer.from(line);
+            pt.push(chunk);
+        }
+        // signal end of stream
+        pt.push(null);
+        return pt;
+    })();
+    const pending = readablePromise;
+    pending.execute = () => pending;
+    pending.simple = () => pending;
+    pending.cancel = () => { };
+    pending.readable = () => readablePromise;
+    pending.writable = () => Promise.resolve(new PassThrough());
+    pending.describe = () => Promise.reject(new Error('not supported'));
+    pending.values = () => Promise.reject(new Error('not supported'));
+    pending.raw = () => Promise.reject(new Error('not supported'));
+    pending.forEach = () => Promise.reject(new Error('not supported'));
+    pending.cursor = () => {
+        throw new Error('not supported');
+    };
+    pending.stream = () => {
+        throw new Error('not supported');
+    };
+    return pending;
+}
+function createReplicationPendingQuery(replicationQuery, db) {
+    const mutex = getSharedMutex(db);
+    const writable = new PassThrough();
+    let started = false;
+    let startPromise = null;
+    let destroyed = false;
+    // use PassThrough — AND expose a direct callback for the pipe to use.
+    // stream-browserify's PassThrough + Duplexify stop flowing after idle,
+    // so we also push data via a callback that the patched pipe() can use.
+    const readable = new PassThrough();
+    // direct data callback — bypasses broken stream plumbing entirely.
+    // registered on globalThis so the patched pipe() can find it regardless
+    // of how many stream wrappers (Duplexify, etc.) sit between.
+    const dataListeners = [];
+    globalThis.__orez_repl_data_push = (fn) => {
+        dataListeners.push(fn);
+    };
+    const start = async () => {
+        if (started)
+            return;
+        started = true;
+        startPromise = handleStartReplication(replicationQuery, {
+            write(chunk) {
+                if (destroyed)
+                    return;
+                // skip CopyBothResponse, unwrap CopyData
+                if (chunk[0] === 0x57)
+                    return;
+                const data = chunk[0] === 0x64 && chunk.length >= 6
+                    ? Buffer.from(chunk.subarray(5))
+                    : Buffer.from(chunk);
+                readable.write(data);
+                // also call pipe handlers directly — stream polyfills are broken in browser
+                const handlers = globalThis.__orez_pipe_handlers;
+                if (handlers && handlers.length > 0) {
+                    ;
+                    globalThis.__orez_repl_bypass_count =
+                        (globalThis.__orez_repl_bypass_count || 0) + 1;
+                }
+                if (handlers) {
+                    for (const fn of handlers) {
+                        try {
+                            fn(data);
+                        }
+                        catch { }
+                    }
+                }
+            },
+            get closed() {
+                return destroyed || writable.destroyed || !!db.closed;
+            },
+        }, db, mutex).catch((err) => {
+            // don't destroy the readable on handler errors — the change-streamer
+            // would reconnect with a new subscription, losing the reference the
+            // producer holds. just log the error and let the handler restart.
+            console.warn('[orez:repl] handler error:', err instanceof Error ? err.message : String(err));
+        });
+        return Promise.resolve();
+    };
+    const pending = Promise.resolve();
+    pending.execute = () => pending;
+    pending.simple = () => pending;
+    pending.cancel = () => {
+        destroyed = true;
+        readable.destroy();
+        writable.destroy();
+    };
+    pending.readable = async () => {
+        await start();
+        return readable;
+    };
+    pending.writable = async () => {
+        await start();
+        return writable;
+    };
+    pending.describe = () => Promise.reject(new Error('not supported'));
+    pending.values = () => Promise.reject(new Error('not supported'));
+    pending.raw = () => Promise.reject(new Error('not supported'));
+    pending.forEach = () => Promise.reject(new Error('not supported'));
+    pending.cursor = () => {
+        throw new Error('not supported');
+    };
+    pending.stream = () => {
+        throw new Error('not supported');
+    };
+    return pending;
+}
+// -- type parsers --
+// pre-populated parsers matching the postgres npm package's type registry.
+function identity(x) {
+    return x;
+}
+function parseFloat_(x) {
+    return parseFloat(x);
+}
+function parseInt_(x) {
+    return parseInt(x, 10);
+}
+function parseBool(x) {
+    return x === 't' || x === 'true';
+}
+function parseJSON(x) {
+    try {
+        return JSON.parse(x);
+    }
+    catch {
+        return x;
+    }
+}
+function makeArrayParser(elementParser) {
+    const fn = (x) => {
+        if (!x || x === '{}')
+            return [];
+        const inner = x.slice(1, -1);
+        return inner.split(',').map((v) => {
+            if (v === 'NULL')
+                return null;
+            return elementParser(v.replace(/^"|"$/g, ''));
+        });
+    };
+    fn.array = true;
+    return fn;
+}
+function buildDefaultParsers() {
+    const p = {};
+    // scalar types
+    p[16] = parseBool; // bool
+    p[17] = identity; // bytea
+    p[20] = identity; // int8 (bigint as string)
+    p[21] = parseInt_; // int2
+    p[23] = parseInt_; // int4
+    p[25] = identity; // text
+    p[26] = parseInt_; // oid
+    p[114] = parseJSON; // json
+    p[700] = parseFloat_; // float4
+    p[701] = parseFloat_; // float8
+    p[1042] = identity; // bpchar
+    p[1043] = identity; // varchar
+    p[1082] = identity; // date
+    p[1083] = identity; // time
+    // timestamps → epoch ms (zero-cache expects number, not string)
+    const parseTimestamp = (val) => {
+        if (typeof val === 'number')
+            return val;
+        const d = Date.parse(val);
+        return isNaN(d) ? val : d;
+    };
+    p[1114] = parseTimestamp; // timestamp
+    p[1184] = parseTimestamp; // timestamptz
+    p[1266] = identity; // timetz
+    p[1700] = identity; // numeric
+    p[2950] = identity; // uuid
+    p[3802] = parseJSON; // jsonb
+    // array types
+    p[1000] = makeArrayParser(parseBool); // bool[]
+    p[1005] = makeArrayParser(parseInt_); // int2[]
+    p[1007] = makeArrayParser(parseInt_); // int4[]
+    p[1009] = makeArrayParser(identity); // text[]
+    p[1016] = makeArrayParser(identity); // int8[]
+    p[1021] = makeArrayParser(parseFloat_); // float4[]
+    p[1022] = makeArrayParser(parseFloat_); // float8[]
+    p[1015] = makeArrayParser(identity); // varchar[]
+    p[1182] = makeArrayParser(identity); // date[]
+    p[1115] = makeArrayParser(identity); // timestamp[]
+    p[1185] = makeArrayParser(identity); // timestamptz[]
+    p[2951] = makeArrayParser(identity); // uuid[]
+    p[199] = makeArrayParser(parseJSON); // json[]
+    p[3807] = makeArrayParser(parseJSON); // jsonb[]
+    return p;
+}
+export function createPostgresShim(pglite, opts) {
+    const sqlFn = createSqlFunction(pglite, pglite);
+    function sql(first, ...rest) {
+        return sqlFn(first, ...rest);
+    }
+    // sql.unsafe(queryString, params?) — raw SQL execution
+    sql.unsafe = (queryString, params) => {
+        const upper = queryString.trimStart().toUpperCase();
+        // START_REPLICATION — expose an in-process duplex stream backed by
+        // orez's replication handler instead of the TCP protocol adapter.
+        if (upper.startsWith('START_REPLICATION')) {
+            return createReplicationPendingQuery(queryString, pglite);
+        }
+        // COPY TO STDOUT — returns readable stream of rows
+        if (upper.startsWith('COPY') && upper.includes('TO STDOUT')) {
+            return createCopyPendingQuery(queryString, pglite);
+        }
+        // strip FK constraints from CREATE TABLE (see executeQuery for why)
+        if (/FOREIGN\s+KEY/i.test(queryString) && /CREATE\s+TABLE/i.test(queryString)) {
+            queryString = queryString.replace(/,?\s*(?:CONSTRAINT\s+\w+\s+)?FOREIGN\s+KEY\s*\([^)]*\)\s*REFERENCES\s+[^,(]+(?:\s*\([^)]*\))?(?:\s+ON\s+(?:DELETE|UPDATE)\s+(?:CASCADE|SET\s+NULL|SET\s+DEFAULT|RESTRICT|NO\s+ACTION))*(?:\s+DEFERRABLE[^,)]*)?/gi, '');
+        }
+        const serializedParams = (params ?? []).map(serializeParam);
+        // multi-statement with no params: split and run each individually
+        // PGliteWorker's execProtocol rejects multi-statement, so always split upfront
+        if (hasMultipleStatements(queryString) && serializedParams.length === 0) {
+            const promise = (async () => {
+                const intercepted = await interceptReplicationQuery(queryString, pglite);
+                if (intercepted)
+                    return intercepted;
+                {
+                    const statements = splitStatements(queryString);
+                    const resultArrays = [];
+                    for (const stmt of statements) {
+                        const r = await pglite.query(stmt);
+                        resultArrays.push(createResultArray(r, stmt));
+                    }
+                    const combined = resultArrays;
+                    combined.count = resultArrays.length;
+                    combined.command = 'SELECT';
+                    combined.state = { status: 'idle', pid: 0, secret: 0 };
+                    combined.statement = { name: '', string: queryString, types: [], columns: [] };
+                    combined.columns = [];
+                    return combined;
+                }
+            })();
+            return createPendingQuery(promise);
+        }
+        const promise = executeQuery(pglite, queryString, serializedParams, pglite);
+        return createPendingQuery(promise);
+    };
+    // sql.begin(options?, callback) — transactions
+    //
+    // BROWSER FIX: don't use pglite.transaction() for the top-level callback.
+    // zero-cache's transaction pool holds the callback open indefinitely
+    // (await dequeue() loop), which permanently holds PGlite's Fe2 mutex
+    // and deadlocks ALL external queries (push handler, pg-query, etc.).
+    //
+    // instead, route queries directly through PGlite — each query acquires
+    // and releases Fe2 independently. this trades transaction atomicity for
+    // Fe2 availability, which is acceptable in the browser dev preview
+    // (PGlite is single-connection so operations are serialized anyway).
+    //
+    // nested begin/savepoint calls still use real pglite.transaction()
+    // since those are short-lived (task-scoped, not pool-scoped).
+    sql.begin = async (optionsOrCb, maybeCb) => {
+        const cb = typeof optionsOrCb === 'function' ? optionsOrCb : maybeCb;
+        // create sql function backed by pglite directly (not a Transaction)
+        // each query acquires/releases Fe2 independently
+        const txSql = createSqlFunction(pglite, pglite);
+        function txSqlFn(first, ...rest) {
+            return txSql(first, ...rest);
+        }
+        // unsafe: routes through pglite directly
+        txSqlFn.unsafe = (queryString, params) => {
+            const upper = queryString.trimStart().toUpperCase();
+            if (upper.startsWith('COPY') && upper.includes('TO STDOUT')) {
+                return createCopyPendingQuery(queryString, pglite);
+            }
+            const serializedParams = (params ?? []).map(serializeParam);
+            if (hasMultipleStatements(queryString) && serializedParams.length === 0) {
+                const promise = (async () => {
+                    const stmts = splitStatements(queryString);
+                    const resultArrays = [];
+                    for (const stmt of stmts) {
+                        const r = await pglite.query(stmt);
+                        resultArrays.push(createResultArray(r, stmt));
+                    }
+                    const combined = resultArrays;
+                    combined.count = resultArrays.length;
+                    combined.command = 'SELECT';
+                    combined.state = { status: 'idle', pid: 0, secret: 0 };
+                    combined.statement = {
+                        name: '',
+                        string: queryString,
+                        types: [],
+                        columns: [],
+                    };
+                    combined.columns = [];
+                    return combined;
+                })();
+                return createPendingQuery(promise);
+            }
+            const promise = executeQuery(pglite, queryString, serializedParams, pglite);
+            return createPendingQuery(promise);
+        };
+        // nested begin: use real pglite.transaction() for atomicity (short-lived)
+        // nested begin: non-transactional (same as top level)
+        // real pglite.transaction() holds Fe2 during async SQLite work in the syncer,
+        // which deadlocks any concurrent PGlite queries. non-transactional avoids this.
+        txSqlFn.begin = async (innerOptOrCb, innerMaybeCb) => {
+            const innerCb = typeof innerOptOrCb === 'function' ? innerOptOrCb : innerMaybeCb;
+            const innerTxSql = createSqlFunction(pglite, pglite);
+            function innerTxSqlFn(first, ...rest) {
+                return innerTxSql(first, ...rest);
+            }
+            innerTxSqlFn.unsafe = txSqlFn.unsafe;
+            innerTxSqlFn.begin = txSqlFn.begin;
+            innerTxSqlFn.savepoint = txSqlFn.savepoint;
+            innerTxSqlFn.end = async () => { };
+            innerTxSqlFn.options = sql.options;
+            innerTxSqlFn.PostgresError = PostgresError;
+            try {
+                const result = await innerCb(innerTxSqlFn);
+                return Array.isArray(result) ? await Promise.all(result) : result;
+            }
+            finally {
+                signalReplicationChange();
+            }
+        };
+        // savepoint at top level: DON'T use pglite.transaction() — same reasoning
+        // as sql.begin(). the callback might be long-running (e.g. setupTriggers).
+        // just run the callback with PGlite-backed sql (each query acquires/releases Fe2).
+        let _savepointIdx = 0;
+        txSqlFn.savepoint = async (nameOrFn, maybeFn) => {
+            const fn = typeof nameOrFn === 'function' ? nameOrFn : maybeFn;
+            return fn(txSqlFn);
+        };
+        txSqlFn.end = async () => { };
+        txSqlFn.options = sql.options;
+        txSqlFn.PostgresError = PostgresError;
+        // use explicit BEGIN/COMMIT/ROLLBACK SQL instead of pglite.transaction().
+        // each statement acquires/releases Fe2 independently, so the mutex is
+        // NOT held during async gaps in the callback — avoiding the deadlock
+        // that pglite.transaction() causes with zero-cache's long-running pool.
+        await pglite.exec('BEGIN');
+        try {
+            const result = await cb(txSqlFn);
+            await pglite.exec('COMMIT');
+            signalReplicationChange(); // signal immediately after commit, don't wait for finally
+            return Array.isArray(result) ? await Promise.all(result) : result;
+        }
+        catch (err) {
+            await pglite.exec('ROLLBACK');
+            throw err;
+        }
+        finally {
+            signalReplicationChange();
+        }
+    };
+    // sql.end() — no-op (PGlite lifecycle managed elsewhere)
+    sql.end = async (_opts) => { };
+    // sql.close() — alias for end
+    sql.close = sql.end;
+    // sql.options — connection metadata
+    sql.options = {
+        host: ['localhost'],
+        port: [5432],
+        database: 'pglite',
+        user: 'pglite',
+        max: opts?.max ?? 1,
+        parsers: buildDefaultParsers(),
+        fetch_types: opts?.fetch_types ?? true,
+        connection: opts?.connection ?? {},
+        ssl: opts?.ssl ?? false,
+        types: opts?.types ?? {},
+        transform: {
+            undefined: undefined,
+            column: { from: undefined, to: undefined },
+            value: { from: undefined, to: undefined },
+            row: { from: undefined, to: undefined },
+        },
+        serializers: {},
+    };
+    // sql.PostgresError — error class
+    sql.PostgresError = PostgresError;
+    // sql.CLOSE / sql.END — sentinel objects
+    sql.CLOSE = {};
+    sql.END = sql.CLOSE;
+    // sql.parameters — server parameters
+    sql.parameters = {
+        application_name: 'pglite-shim',
+        server_version: '17.0',
+    };
+    // sql.types / sql.typed — type helpers
+    sql.typed = (value, oid) => ({ value, type: oid });
+    sql.types = sql.typed;
+    // sql.json — json parameter helper
+    sql.json = (value) => JSON.stringify(value);
+    // sql.array — array parameter helper
+    sql.array = (value, type) => ({ value, type, array: true });
+    // sql.listen — not supported
+    sql.listen = () => {
+        throw new Error('listen() not supported in worker mode');
+    };
+    // sql.notify — not supported
+    sql.notify = () => {
+        throw new Error('notify() not supported in worker mode');
+    };
+    // sql.subscribe — not supported
+    sql.subscribe = () => {
+        throw new Error('subscribe() not supported in worker mode');
+    };
+    // sql.reserve — not supported
+    sql.reserve = () => {
+        throw new Error('reserve() not supported in worker mode');
+    };
+    // sql.file — not supported
+    sql.file = () => {
+        throw new Error('file() not supported in worker mode');
+    };
+    // sql.largeObject — not supported
+    sql.largeObject = () => {
+        throw new Error('largeObject() not supported in worker mode');
+    };
+    return sql;
+}
+// -- default export --
+// matches the `postgres` package's default export shape:
+//   import postgres from 'postgres'
+//   const sql = postgres(url, options)
+//
+// when used as a bundler alias, zero-cache calls postgres(connectionURI, options).
+// we intercept by reading the PGlite instance from globalThis.__orez_pglite.
+function postgres(_urlOrOpts, opts) {
+    // multi-instance routing: if __orez_pglite_instances is set, route by URL
+    const instances = globalThis.__orez_pglite_instances;
+    let pglite;
+    if (instances && typeof _urlOrOpts === 'string') {
+        if (_urlOrOpts.includes('/zero_cvr'))
+            pglite = instances.cvr;
+        else if (_urlOrOpts.includes('/zero_cdb'))
+            pglite = instances.cdb;
+        else
+            pglite = instances.postgres;
+    }
+    else {
+        pglite = globalThis.__orez_pglite;
+    }
+    if (!pglite) {
+        throw new Error('postgres shim: no PGlite instance found. ' +
+            'set globalThis.__orez_pglite or __orez_pglite_instances.');
+    }
+    const resolvedOpts = typeof _urlOrOpts === 'object' ? _urlOrOpts : opts;
+    return createPostgresShim(pglite, resolvedOpts);
+}
+// attach PostgresError and BigInt to the default export (matches postgres package)
+postgres.PostgresError = PostgresError;
+postgres.BigInt = {
+    to: 20,
+    from: [20],
+    parse: (x) => globalThis.BigInt(x),
+    serialize: (x) => x.toString(),
+};
+export default postgres;
+//# sourceMappingURL=postgres.js.map