orez 0.4.73 → 0.5.2

package/dist/pg-proxy-do-backend.js

@@ -1,9 +1,10 @@
 // @ts-nocheck
 import { deparseSync, loadModule, parseSync } from 'pgsql-parser';
 import { TX_MANIFEST_DDL, TX_MANIFEST_TABLE } from './cf-do/tx-journal.js';
-import { RETURNING_INTERNAL_PREFIX } from './do-sql-tracking.js';
+import { isSqlRowMutation, RETURNING_INTERNAL_PREFIX } from './do-sql-tracking.js';
 import { expandDelete, FkCascadeRegistry, recordAlterTableForeignKeys, recordCreateTableForeignKeys, } from './fk-cascade.js';
 import { Mutex } from './mutex.js';
+import { compile as compilePgToSqlite } from './pg-sqlite-compiler/index.js';
 import { foldCountMarkerResult, transformCountedDeleteCte, } from './pg-sqlite-compiler/passes/dml-cte.js';
 import { signalReplicationChange } from './replication/handler.js';
 import { markSQLiteKeywordIdentifiers, restoreSQLiteKeywordIdentifierMarkers, } from './sqlite-keyword-identifiers.js';
@@ -13,7 +14,8 @@ import { markSQLiteKeywordIdentifiers, restoreSQLiteKeywordIdentifierMarkers, }
  * Translates PG wire protocol messages → SQL → DO HTTP API → PG wire protocol responses.
  *
  * Handles PG transactions transparently: BEGIN/COMMIT/ROLLBACK are intercepted
- * and data writes are restored from table snapshots on ROLLBACK.
+ * and data writes are restored from row before-images on ROLLBACK, with table
+ * snapshots retained as a fallback for writes the SQL planner cannot identify.
  */
 const textEncoder = new TextEncoder();
 const textDecoder = new TextDecoder();
@@ -53,6 +55,22 @@ const METADATA_TABLE = '_orez_pg_metadata';
 // publication picks it up quickly, long enough that a genuinely
 // publication-less db doesn't re-query on every write.
 const EMPTY_PUBLICATION_RELOAD_THROTTLE_MS = 1000;
+// All DoBackend instances for one logical database share a durable trigger
+// set. Keep one ordered schema-scan/registration queue per target in this
+// isolate; DDL/publication changes invalidate the reusable result while
+// preserving request order.
+const cdcRegistrationSyncs = new Map();
+function cdcRegistrationState(key) {
+    let state = cdcRegistrationSyncs.get(key);
+    if (!state) {
+        state = { current: null, tail: Promise.resolve() };
+        cdcRegistrationSyncs.set(key, state);
+    }
+    return state;
+}
+function hasCdcRegistrationSync(key) {
+    return !!cdcRegistrationSyncs.get(key)?.current;
+}
 // ── Utilities ─────────────────────────────────────────────────────────────
 function concat(...parts) {
     let total = 0;
@@ -459,7 +477,9 @@ function inferFieldsFromSQL(sql) {
         : extractTopLevelSelectList(sql);
     if (!list || list === '*')
         return [];
-    return splitTopLevelComma(list).map((part) => ({ name: inferFieldName(part) }));
+    return splitTopLevelComma(list).map((part) => ({
+        name: inferFieldName(part),
+    }));
 }
 function columnRefTailName(value) {
     const fields = value?.ColumnRef?.fields;
@@ -1140,9 +1160,6 @@ function isDollarQuoteTagStart(ch) {
 function isDollarQuoteTagPart(ch) {
     return ch === '_' || isAsciiAlpha(ch) || isAsciiDigit(ch);
 }
-function currentTimestampNode() {
-    return { SQLValueFunction: { op: 'SVFOP_CURRENT_TIMESTAMP', typmod: -1 } };
-}
 function isTimestampOid(oid) {
     return oid === PG_TYPE_TIMESTAMP || oid === PG_TYPE_TIMESTAMPTZ;
 }
@@ -2005,8 +2022,6 @@ function rewriteNode(value, context) {
         const sqliteName = SQLITE_FUNCTION_BY_PG_FUNCTION.get(name ?? '');
         if (sqliteName)
             value.FuncCall.funcname = [stringNode(sqliteName)];
-        if (name === 'now')
-            return currentTimestampNode();
         if (name === 'nextval')
             return intConst(1);
         if (name === '_drop_zero_slot' || name === 'pg_drop_replication_slot') {
@@ -2600,7 +2615,9 @@ function normalizeRename(stmt) {
         flattenRangeVar(relation);
         if (to.table !== stmt.newname)
             stmt.newname = to.table;
-        return { schemaMetadataChanges: [{ action: 'renameTable', from: table, to }] };
+        return {
+            schemaMetadataChanges: [{ action: 'renameTable', from: table, to }],
+        };
     }
     if (stmt.renameType === 'OBJECT_COLUMN' && stmt.subname && stmt.newname) {
         flattenRangeVar(relation);
@@ -2805,7 +2822,12 @@ function replaceSchemaSpecsFunctionCalls(sql) {
 }
 function deparseStatement(version, stmt) {
     const quotedByMarker = markSQLiteKeywordIdentifiers(stmt);
-    return stripTrailingSemicolon(restoreSQLiteKeywordIdentifierMarkers(deparseSync({ version, stmts: [{ stmt }] }), quotedByMarker).trim());
+    const proxySql = stripTrailingSemicolon(restoreSQLiteKeywordIdentifierMarkers(deparseSync({ version, stmts: [{ stmt }] }), quotedByMarker).trim());
+    // The proxy owns transport-specific metadata and execution planning, but
+    // pg-to-sqlite is the final authority for PostgreSQL SQL semantics. Running
+    // the deparsed statement through the package compiler here prevents the
+    // proxy from growing a second set of function/type/syntax rewrites.
+    return compilePgToSqlite(proxySql).sql;
 }
 function starTarget() {
     return {
@@ -3065,7 +3087,9 @@ function compileSelectIntoNew(version, select, triggerTable, rowCondition) {
     const targetColumn = rel.relname;
     const cloned = cloneAst(select);
     delete cloned.intoClause;
-    const selectSQL = deparseStatement(version, { SelectStmt: rewriteNode(cloned) });
+    const selectSQL = deparseStatement(version, {
+        SelectStmt: rewriteNode(cloned),
+    });
     return rowUpdateSQL(triggerTable, targetColumn, `(${selectSQL})`, rowCondition);
 }
 function deparseExpressionSQL(version, expr) {
@@ -3865,7 +3889,9 @@ function copySelectSQL(sql) {
                 stringValue(def.arg)?.toLowerCase() === 'binary');
         });
         return {
-            sql: deparseStatement(parsed.version, { SelectStmt: copy.query.SelectStmt }),
+            sql: deparseStatement(parsed.version, {
+                SelectStmt: copy.query.SelectStmt,
+            }),
             binary,
         };
     }
@@ -4673,7 +4699,10 @@ function advisoryLockResult(select) {
         : [{ name: 'pg_advisory_xact_lock', source: 'pg_advisory_xact_lock' }];
     return {
         rows: [Object.fromEntries(projectedFields.map((field) => [field.name, null]))],
-        fields: projectedFields.map((field) => ({ name: field.name, oid: field.oid })),
+        fields: projectedFields.map((field) => ({
+            name: field.name,
+            oid: field.oid,
+        })),
     };
 }
 function logicalEmitMessageResult(select) {
@@ -4741,14 +4770,15 @@ export class DoBackend {
     // connects past the client's connect budget. cache per instance, invalidated
     // on DDL / metadata / publication changes and on rollback.
     publicationTableInfoCache = null;
+    cdcRegistrationDirty = false;
     readyPromise = null;
     operationMutex = new Mutex();
     // Transaction state. The Durable Object refuses raw SQL BEGIN/COMMIT/SAVEPOINT
     // (Cloudflare requires ctx.storage.transaction()), so PG-style multi-call
     // transactions can't ride on SQLite's own transaction machinery. Instead we
-    // emulate rollback by snapshotting each table on its first in-tx write and
-    // restoring it atomically through /batch on ROLLBACK. Atomicity of the
-    // restore itself comes from the DO's /batch transaction.
+    // emulate rollback with CDC row before-images for parsed DML. Unknown writes
+    // fall back to snapshotting the table on its first in-tx write. Both restore
+    // paths run atomically in the DO's storage transaction.
     inTransaction = false;
     txID = null;
     txSnapshot = null;
@@ -5131,6 +5161,7 @@ export class DoBackend {
         // Cached rewrites may reference metadata that the rollback just invalidated.
         this.rewriteCache.clear();
         this.publicationTableInfoCache = null;
+        this.invalidateCdcRegistration();
     }
     clearTransactionState() {
         this.inTransaction = false;
@@ -5170,14 +5201,16 @@ export class DoBackend {
         const shouldSignal = this.txHasTrackedWrite;
         const txID = this.txID;
         // ONE atomic commit point on the backend: promotes pending tracked
-        // changes and clears the tx journal (snapshots + manifest) in a single
+        // changes and clears the tx journal (row images, snapshots, and manifest) in a single
         // storage transaction. read-only transactions skip the round-trip.
         if (txID && (shouldSignal || this.txDataSnapshots.size > 0)) {
             await this.httpClient.post(this.url('/commit-tx'), JSON.stringify({ transactionID: txID }), { 'Content-Type': 'application/json' });
         }
         this.clearTransactionState();
-        if (shouldPersist)
+        if (shouldPersist) {
             await this.persistDurableMetadata();
+            await this.ensureCdcRegistration();
+        }
         if (shouldSignal)
             signalReplicationChange();
     }
@@ -5189,8 +5222,8 @@ export class DoBackend {
         const snapshot = this.txSnapshot;
         const txID = this.txID;
         try {
-            // ONE atomic rollback on the backend: restores snapshotted tables from
-            // the durable tx journal and discards pending tracked changes.
+            // ONE atomic rollback on the backend: restores row before-images and any
+            // fallback table snapshots, then discards pending tracked changes.
             if (txID && (this.txHasTrackedWrite || this.txDataSnapshots.size > 0)) {
                 await this.httpClient.post(this.url('/rollback-tx'), JSON.stringify({ transactionID: txID }), { 'Content-Type': 'application/json' });
             }
@@ -5200,6 +5233,8 @@ export class DoBackend {
                 this.restoreTransactionMetadataSnapshot(snapshot);
             await this.persistDurableMetadata();
             this.clearTransactionState();
+            if (snapshot)
+                await this.ensureCdcRegistration();
         }
     }
     async execProtocolRaw(message, options) {
@@ -5325,7 +5360,13 @@ export class DoBackend {
             return this.buildCopyResponse(result, copySelect.sql, copySelect.binary);
         }
         // Prepare query
-        const rewrittenStatements = this.rewriteSQLStatements(sql);
+        let rewrittenStatements;
+        try {
+            rewrittenStatements = this.rewriteSQLStatements(sql);
+        }
+        catch (err) {
+            return concat(buildErrorResponse(err.message), this.readyForQuery());
+        }
         const rewritten = rewrittenSQLText(rewrittenStatements);
         if (rewritten === '' || rewritten.startsWith('--')) {
             await this.applyStatementMetadata(rewrittenStatements);
@@ -5357,6 +5398,13 @@ export class DoBackend {
     }
     async applyStatementMetadata(statements) {
         let changed = false;
+        let publicationChanged = false;
+        if (statements.some((statement) => statement.isDDL)) {
+            // DROP/CREATE INDEX and DROP TABLE may not carry column metadata deltas,
+            // but they still invalidate both the catalog and persisted trigger set.
+            this.publicationTableInfoCache = null;
+            this.invalidateCdcRegistration();
+        }
         for (const statement of statements) {
             for (const column of statement.schemaColumns ?? []) {
                 let table = this.schemaMetadata.get(column.table);
@@ -5374,6 +5422,7 @@ export class DoBackend {
             for (const change of statement.publicationChanges ?? []) {
                 this.applyPublicationChange(change);
                 changed = true;
+                publicationChanged = true;
             }
             if (statement.fkEdges) {
                 // edges were already added to this.fkRegistry at rewrite time; persist
@@ -5385,6 +5434,7 @@ export class DoBackend {
         }
         if (changed) {
             this.publicationTableInfoCache = null;
+            this.invalidateCdcRegistration();
             // inside an explicit tx we batch the persist to commit time. chat's
             // migrations open one tx and run dozens of DDL statements; persisting
             // after every one was the hot path.
@@ -5392,6 +5442,12 @@ export class DoBackend {
                 this.txMetadataDirty = true;
             else
                 await this.persistDurableMetadata();
+            // Publication membership changes alter which tables may enter the
+            // changefeed. Apply those immediately; ordinary schema changes are
+            // refreshed lazily before the next row write to keep migrations fast.
+            if (publicationChanged && !this.inTransaction) {
+                await this.ensureCdcRegistration();
+            }
         }
     }
     applySchemaMetadataChange(change) {
@@ -5466,36 +5522,121 @@ export class DoBackend {
     }
     trackingForStatement(statement) {
         const tracking = statement.changeTracking;
-        if (!tracking || this.dbName !== 'postgres')
+        if (!tracking)
             return undefined;
+        // zero-cache's CVR/CDB databases use the same emulated PG transactions as
+        // the application database. Their parsed DML needs rollback row images too;
+        // otherwise hot internal tables such as `<shard>/cdc_changeLog` fall back to
+        // a full table copy on every transaction and produce quadratic writes.
+        if (this.dbName !== 'postgres') {
+            return this.inTransaction ? { ...tracking, publish: false } : undefined;
+        }
         const { table } = tracking;
+        let published = false;
         if (table.schema === 'public') {
             const publications = this.publicationNames();
-            if (!publications.length)
-                return undefined;
-            return this.publicationsForTable(table, publications).length ? tracking : undefined;
+            published =
+                publications.length > 0 &&
+                    this.publicationsForTable(table, publications).length > 0;
         }
-        if (table.schema !== 'pg_catalog' &&
+        else if (table.schema !== 'pg_catalog' &&
             table.schema !== 'information_schema' &&
             !table.schema.startsWith('pg_') &&
             !table.schema.startsWith('zero_') &&
             !table.schema.startsWith('_zero') &&
             !table.schema.includes('/') &&
             TRACKED_SHARD_TABLES.has(table.tableName)) {
-            return tracking;
+            published = true;
         }
-        return undefined;
+        if (published)
+            return { ...tracking, publish: true };
+        // PostgreSQL transactions still need row-accurate undo for private and
+        // internal tables. The worker captures the same full before/after images
+        // but marks them rollback-only so they never enter `_zero_changes`.
+        return this.inTransaction ? { ...tracking, publish: false } : undefined;
     }
     trackingRequest(tracking) {
         const rowColumns = this.schemaMetadata.get(tracking.table.table);
         return {
             tableName: `${tracking.table.schema}.${tracking.table.tableName}`,
+            physicalTableName: tracking.table.table,
             operation: tracking.operation,
             returnRows: tracking.returnRows,
             ...(rowColumns ? { rowColumns: [...rowColumns.keys()] } : null),
             ...(this.inTransaction ? { transactionID: this.currentTransactionID() } : null),
+            ...(tracking.publish === false ? { publish: false } : null),
+        };
+    }
+    cdcRegistrationKey() {
+        return this.url('/cdc-registration');
+    }
+    invalidateCdcRegistration() {
+        this.cdcRegistrationDirty = true;
+        const state = cdcRegistrationSyncs.get(this.cdcRegistrationKey());
+        if (state)
+            state.current = null;
+    }
+    cdcRegistrationForInfo(info) {
+        const published = info.schema === 'public' &&
+            this.publicationsForTable(info, this.publicationNames()).length > 0;
+        const trackedShard = info.schema !== 'public' &&
+            info.schema !== 'pg_catalog' &&
+            info.schema !== 'information_schema' &&
+            !info.schema.startsWith('pg_') &&
+            !info.schema.startsWith('zero_') &&
+            !info.schema.startsWith('_zero') &&
+            !info.schema.includes('/') &&
+            TRACKED_SHARD_TABLES.has(info.tableName);
+        if (!published && !trackedShard)
+            return null;
+        return {
+            physicalTableName: info.name,
+            tableName: `${info.schema}.${info.tableName}`,
         };
     }
+    async ensureCdcRegistration() {
+        if (this.dbName !== 'postgres')
+            return;
+        const key = this.cdcRegistrationKey();
+        const state = cdcRegistrationState(key);
+        for (;;) {
+            const forced = this.cdcRegistrationDirty;
+            let pending = state.current;
+            if (forced || !pending) {
+                // Mark this instance's invalidation as scheduled before yielding. If
+                // another invalidation arrives while the request is in flight it sets
+                // the flag again, and the loop queues a fresh authoritative set.
+                this.cdcRegistrationDirty = false;
+                const previous = state.tail;
+                pending = previous
+                    .catch(() => undefined)
+                    .then(async () => {
+                    const infos = await this.publicationTableInfos();
+                    const cdcTables = infos
+                        .map((info) => this.cdcRegistrationForInfo(info))
+                        .filter((registration) => !!registration);
+                    await this.httpClient.post(this.url('/batch'), JSON.stringify({ statements: [], cdcTables }), { 'Content-Type': 'application/json' });
+                });
+                state.tail = pending;
+                state.current = pending;
+            }
+            try {
+                await pending;
+            }
+            catch (error) {
+                if (state.current === pending)
+                    state.current = null;
+                if (forced)
+                    this.cdcRegistrationDirty = true;
+                throw error;
+            }
+            // A different backend may have invalidated or queued a replacement
+            // while this request was in flight. Do not let a caller write until the
+            // newest known registration has also landed.
+            if (state.current === pending && !this.cdcRegistrationDirty)
+                return;
+        }
+    }
     visibleResultForTracking(result, tracking) {
         if (!tracking)
             return result;
@@ -5614,6 +5755,12 @@ export class DoBackend {
         const portal = this.portals.get(portalName);
         if (!portal)
             return buildErrorResponse(`portal "${portalName}" does not exist`);
+        try {
+            this.rejectTransactionalDDL(portal.rewrittenStatements ?? []);
+        }
+        catch (err) {
+            return buildErrorResponse(err.message);
+        }
         if (!portal.sql?.trim()) {
             await this.applyStatementMetadata([
                 {
@@ -5915,14 +6062,28 @@ export class DoBackend {
         const arrayParamNumbers = new Set();
         const jsonParamNumbers = new Set();
         const epochMillisParamNumbers = new Set();
+        // DDL rewriting mutates function/FK metadata before execution and DDL
+        // execution invalidates live caches. While an emulated transaction is
+        // active, rewrite against isolated state so rejecting DDL cannot itself
+        // leak a metadata or cache side effect.
+        const skippedFunctionNames = this.inTransaction
+            ? new Set(this.skippedFunctionNames)
+            : this.skippedFunctionNames;
+        const triggerFunctions = this.inTransaction
+            ? this.cloneTriggerFunctions(this.triggerFunctions)
+            : this.triggerFunctions;
+        const fkRegistry = this.inTransaction
+            ? this.cloneFkCascadeRegistry()
+            : this.fkRegistry;
         const statements = rewriteSQLStatements(sql, {
-            skippedFunctionNames: this.skippedFunctionNames,
-            triggerFunctions: this.triggerFunctions,
+            skippedFunctionNames,
+            triggerFunctions,
             arrayParamNumbers,
             jsonParamNumbers,
             epochMillisParamNumbers,
-            fkRegistry: this.fkRegistry,
+            fkRegistry,
         });
+        this.rejectTransactionalDDL(statements);
         if (this.canCacheRewrite(statements)) {
             this.rememberRewrite(key, statements);
         }
@@ -5931,6 +6092,22 @@ export class DoBackend {
         }
         return statements;
     }
+    cloneFkCascadeRegistry() {
+        const cloned = new FkCascadeRegistry();
+        for (const [parent, child] of this.fkRegistry.entries()) {
+            cloned.add(parent, {
+                ...child,
+                columns: [...child.columns],
+                refColumns: [...child.refColumns],
+            });
+        }
+        return cloned;
+    }
+    rejectTransactionalDDL(statements) {
+        if (this.inTransaction && statements.some((statement) => statement.isDDL)) {
+            throw new Error('DDL statements are not supported inside emulated transactions');
+        }
+    }
     canCacheRewrite(statements) {
         return (statements.length > 0 &&
             statements.every((statement) => statement.sql.trim() &&
@@ -6002,6 +6179,14 @@ export class DoBackend {
     async doExecResult(sql, params, track) {
         if (!sql.trim())
             return { rows: [], columns: [] };
+        if (this.dbName === 'postgres' &&
+            (track ||
+                (this.ready &&
+                    isSqlRowMutation(sql) &&
+                    (this.cdcRegistrationDirty ||
+                        !hasCdcRegistrationSync(this.cdcRegistrationKey()))))) {
+            await this.ensureCdcRegistration();
+        }
         const execSQL = sql;
         let lastErr;
         for (let attempt = 0; attempt < 2; attempt++) {
@@ -6010,6 +6195,9 @@ export class DoBackend {
                     sql: execSQL,
                     ...(params?.length ? { params } : null),
                     ...(track ? { track } : null),
+                    ...(this.inTransaction
+                        ? { transactionID: this.currentTransactionID() }
+                        : null),
                 }), { 'Content-Type': 'application/json' });
                 const result = JSON.parse(resp);
                 const rows = (result.rows ?? result ?? []);
@@ -6025,9 +6213,18 @@ export class DoBackend {
                 if (counted) {
                     return { ...counted, affectedRows: rows.length };
                 }
-                if (track)
+                const hasCaptureCount = Object.hasOwn(result, 'capturedChanges');
+                const capturedChanges = Number(result.capturedChanges ?? 0);
+                if (capturedChanges > 0 ||
+                    (track && track.publish !== false && !hasCaptureCount)) {
                     this.signalTrackedWrite();
-                return { rows, columns, affectedRows: result.affectedRows };
+                }
+                return {
+                    rows,
+                    columns,
+                    affectedRows: result.affectedRows,
+                    capturedChanges,
+                };
             }
             catch (err) {
                 lastErr = err;
@@ -6077,12 +6274,34 @@ export class DoBackend {
         await this.doRawBatch(statements);
         this.txDataSnapshots.set(table, snapshot);
     }
+    async journalTransactionTable(table) {
+        if (!this.inTransaction || this.txDataSnapshots.has(table))
+            return;
+        const txID = this.currentTransactionID();
+        // CDC stores full before/after row images for tracked writes. A manifest
+        // row with an empty snapshot marks the transaction as recoverable without
+        // copying the entire table on every short application transaction.
+        await this.doRawBatch([
+            { sql: TX_MANIFEST_DDL },
+            {
+                sql: `INSERT INTO "${TX_MANIFEST_TABLE}" (tx_id, owner, original, snapshot) VALUES (?, ?, ?, ?)`,
+                params: [txID, this.txOwner, table, ''],
+            },
+        ]);
+        this.txDataSnapshots.set(table, '');
+    }
     async snapshotTransactionWrite(statement) {
         if (!this.inTransaction || !statement.isWrite)
             return;
         const table = statement.writeTable?.table;
-        if (table)
-            await this.snapshotTransactionTable(table);
+        if (!table)
+            return;
+        if (this.trackingForStatement(statement)) {
+            await this.ensureCdcRegistration();
+            await this.journalTransactionTable(table);
+            return;
+        }
+        await this.snapshotTransactionTable(table);
     }
     async doRawBatch(statements) {
         const sqls = statements.filter((statement) => (typeof statement === 'string' ? statement : statement.sql).trim());
@@ -6126,12 +6345,15 @@ export class DoBackend {
         return false;
     }
     async executeRewrittenStatement(statement) {
+        this.rejectTransactionalDDL([statement]);
         if (!statement.sql.trim())
             return { rows: [], columns: [] };
         if (await this.shouldSkipStatement(statement))
             return { rows: [], columns: [] };
-        if (statement.isDDL)
+        if (statement.isDDL) {
             this.publicationTableInfoCache = null;
+            this.invalidateCdcRegistration();
+        }
         await this.snapshotTransactionWrite(statement);
         if (statement.cascadeStatements?.length) {
             await this.runCascadeStatements(statement.cascadeStatements, {});
@@ -6170,11 +6392,30 @@ export class DoBackend {
             if (sqls.length === 0)
                 return;
             const hasTrackedWrite = sqls.some((statement) => typeof statement !== 'string' && Boolean(statement.track));
-            await this.httpClient.post(this.url('/batch'), JSON.stringify({ statements: sqls }), {
-                'Content-Type': 'application/json',
-            });
-            if (hasTrackedWrite)
+            const hasPublishedTrackedWrite = sqls.some((statement) => typeof statement !== 'string' &&
+                Boolean(statement.track) &&
+                statement.track?.publish !== false);
+            const hasRowWrite = sqls.some((statement) => isSqlRowMutation(typeof statement === 'string' ? statement : statement.sql));
+            if (this.dbName === 'postgres' &&
+                (hasTrackedWrite ||
+                    (hasRowWrite &&
+                        (this.cdcRegistrationDirty ||
+                            !hasCdcRegistrationSync(this.cdcRegistrationKey()))))) {
+                await this.ensureCdcRegistration();
+            }
+            const response = await this.httpClient.post(this.url('/batch'), JSON.stringify({ statements: sqls }), { 'Content-Type': 'application/json' });
+            let capturedChanges;
+            try {
+                const parsed = JSON.parse(response);
+                if (Object.hasOwn(parsed, 'capturedChanges')) {
+                    capturedChanges = Number(parsed.capturedChanges ?? 0);
+                }
+            }
+            catch { }
+            if ((capturedChanges ?? 0) > 0 ||
+                (hasPublishedTrackedWrite && capturedChanges === undefined)) {
                 this.signalTrackedWrite();
+            }
             sqls = [];
         };
         for (const statement of statements) {
@@ -6183,8 +6424,10 @@ export class DoBackend {
                 : statement;
             if (!item.sql.trim())
                 continue;
-            if (item.isDDL)
+            if (item.isDDL) {
                 this.publicationTableInfoCache = null;
+                this.invalidateCdcRegistration();
+            }
             if (item.skipIfColumnExists || item.skipIfColumnMissing || item.skipIfTableEmpty) {
                 await flush();
                 if (item.skipIfColumnExists &&
@@ -6202,15 +6445,22 @@ export class DoBackend {
             }
             const tracking = this.trackingForStatement(item);
             const exec = await this.materializePublishedSchemaFunctions(tracking?.returningSQL ?? item.sql, item);
-            sqls.push(tracking
+            const transactionID = this.inTransaction ? this.currentTransactionID() : undefined;
+            const request = tracking
                 ? {
                     sql: exec.sql,
                     ...(exec.params.length ? { params: exec.params } : null),
                     track: this.trackingRequest(tracking),
+                    ...(transactionID ? { transactionID } : null),
                 }
-                : exec.params.length
-                    ? { sql: exec.sql, params: exec.params }
-                    : exec.sql);
+                : exec.params.length || transactionID
+                    ? {
+                        sql: exec.sql,
+                        ...(exec.params.length ? { params: exec.params } : null),
+                        ...(transactionID ? { transactionID } : null),
+                    }
+                    : exec.sql;
+            sqls.push(request);
         }
         await flush();
     }
@@ -6224,12 +6474,16 @@ export class DoBackend {
     }
     async listSqliteTables() {
         const result = await this.doExecResult("SELECT name, sql FROM sqlite_master WHERE type = 'table' ORDER BY name");
-        return result.rows
+        return (result.rows
             .map((row) => ({
             name: String(row.name ?? ''),
             sql: row.sql === null || row.sql === undefined ? null : String(row.sql),
         }))
-            .filter((table) => table.name);
+            // Cloudflare owns _cf_* tables and rejects even PRAGMA introspection.
+            // They are storage implementation details, never PostgreSQL relations.
+            .filter((table) => table.name &&
+            !table.name.toLowerCase().startsWith('_cf_') &&
+            !table.name.toLowerCase().startsWith('sqlite_')));
     }
     tableRefForSqliteTable(name) {
         const metadata = this.schemaMetadata.get(name)?.values().next().value;