@voltro/sql-postgres 0.43.1 → 0.44.0

package/CHANGELOG.md

@@ -39,6 +39,71 @@ _Changes staged for the next release accumulate here (rolled up from
 
 ---
 
+## [0.44.0] — 2026-08-19
+
+### ⚠ BREAKING
+
+- **@voltro/data-transfer, @voltro/cli** — `runImport` returns an `ImportOutcome` instead of the bundle's `Manifest`, and `--mode replace` runs as ONE transaction by default.
+
+  **Why the return type changed.** The summary line counted the rows the BUNDLE carries, not the rows the run wrote. Those differ most exactly where it matters: a bundle directory carries its own resume ledger, so a copied directory imports nothing — correctly, with a warning naming the file to delete — and the run then printed `import complete … rows: 242950` over a target it had not touched. The warning was one line above, which is one line too far for anyone piping the output through `tail -1`. The outcome carries `rowsWritten`, `rowsSkipped` and `fullyResumed`, the CLI reports written-vs-carried, and a fully-skipped run says so on its LAST line.
+
+  Migration: `runImport(...)` now resolves to `{ manifest, tablesWritten, rowsWritten, tablesSkipped, rowsSkipped, fullyResumed }`. Read `.manifest` where you read the manifest before.
+
+  **Why replace is atomic now.** The all-or-nothing guarantee was written for the emptying step, and read — reasonably — as covering the run. A replace that died partway through the LOAD left the target emptied of its old rows and holding part of the new ones, measured on a live instance over sixteen minutes. There is no useful state for a replace to stop in, so it is a default rather than a flag you have to know about. It also closes the window that produced that failure: with the tables emptied and the load uncommitted, a concurrent writer in the application waits instead of inserting a row the bundle is about to insert too.
+
+  `--no-atomic` (CLI) / `atomic: false` (API) opts out. The trade is stated where it bites: every write to those tables waits for the load, and on postgres the bulk `COPY` loader cannot join a transaction it does not own — an atomic run now says that once rather than being quietly slower.
+
+  Two smaller things from the same report: `--mode replace` against a running instance warns about the empty-target window when it is NOT atomic, and the `--target api` upload reports progress per chunk plus a line explaining that the final request stays open for the whole import — sixteen minutes of silence is indistinguishable from a hang, and one operator killed a run that had finished.
+
+  **`voltro update` carries you across this** — codemod `0.44.0/01_import-outcome`.
+
+### Fixed
+
+- **@voltro/sql-mysql, @voltro/sql-postgres, @voltro/sql-sqlite, @voltro/sql-mssql, @voltro/data-transfer** — A write and its write-recorders now succeed or fail together on every SQL dialect, and the data importer's retry is idempotent.
+
+  A recorder (a versioning trail, an audit log) runs on the caller's connection and is ALLOWED to fail — a recorder that throws must take the write down with it, that is its contract. Outside a caller transaction the two were not one unit: the row's statement committed on its own, and the recorder's INSERT ran afterwards as a second autocommit statement. So a recorder that threw left a COMMITTED row behind a write that reported failure. Measured directly: `insert` throws, the row is in the table, and a second attempt at the same row is `ER_DUP_ENTRY` on PRIMARY.
+
+  Anything that retries a failed write then meets its own row. The data importer retries by design — it holds a row whose write failed and tries again once the remaining tables have streamed — so a `--mode replace` that had just emptied a table failed on a duplicate key IN that table. From outside, that is the impossible-looking thing: an import that emptied a table and then failed because something was already in it. Reproduced verbatim, including the table name and `[ER_DUP_ENTRY/1062]`, by putting the old retry back.
+
+  Both ends are closed, and they are independent on purpose:
+
+  - **The cause.** A table that HAS recorders writes inside a transaction now, so the row and the trail commit together or not at all — on mysql, mariadb, postgres, sqlite and mssql, verified by one suite that asks all five the same question. A table with no recorders — the default — takes the direct path unchanged; `recordsTable` is a Map-size check first, so it costs one comparison. - **The defence.** The importer's retry upserts instead of inserting in `replace` mode. That covers every OTHER way a write can land while reporting failure: a driver timeout on a write the server applied, a connection lost after the commit, a concurrent writer inserting the same key. It is sound precisely because the table was emptied by this same run — there is nothing in it that is not ours.
+
+  The test that pinned the divergence went red when the fix landed, exactly as its own note said it would, and is inverted with that note kept.
+
+---
+
+## [0.43.2] — 2026-08-18
+
+### Fixed
+
+- **@voltro/sql-mysql, @voltro/database, @voltro/cli** — The mysql-family binlog reader no longer keeps a table excluded after the very migration that fixed it.
+
+  A UNIQUE on an unbounded text column is a MariaDB hash long-unique, whose hidden `DB_ROW_HASH_n` column the reader can never account for — so the table is held out of binlog capture and the exclusion is reported. `voltro dev` builds its store BEFORE it migrates (kv, cross-replica broadcast and the analytics mirror all need one), so on a boot whose own auto-migration bounds the column, that finding was drawn from a schema that stopped existing about a second later. The exclusion then outlived its cause for the life of the process, and the message — correct when written, and typically the only error line in the boot log — went on describing the pre-migration database.
+
+  Three changes:
+
+  - `DataStore.refreshChangeCaptureExclusions()` (optional; implemented by the mysql-family store) re-runs the probe and re-points the LIVE reader, in both directions — schema work that CREATES the condition now excludes the table immediately instead of after three failed writes. `voltro dev` calls it once, after all its schema work. `voltro serve` needs no equivalent: it builds its store after every schema step and never applies DDL itself. - The definitive message now states its own durability — that it is the schema as read at reader attach, and that applying the remedy does not by itself lift the exclusion. - On a boot that will re-check, the finding is reported as a provisional note rather than as a verdict, so a boot that fixes the condition leaves no error line about it. The note escalates to the full verdict on its own if the re-check never runs. - Two reader fixes the re-check depended on: applying a new exclusion set now WAITS for a reconnect already in flight (it is what applies the set, so resolving before it landed meant the caller's next write hit the old filter), and the reconnect loop no longer keeps resuming from an offset it has just jumped away from — that turned one purged offset into a reconnect every watchdog interval, forever, delivering nothing.
+- **@voltro/data-transfer, @voltro/database, @voltro/sql-mysql, @voltro/sql-postgres, @voltro/sql-sqlite, @voltro/sql-mssql, @voltro/cli** — `voltro data import --mode replace` no longer leaves a target in neither state, and now works against schemas that have foreign keys.
+
+  The delete step ran table by table and stopped at the first refusal, so a run that could not finish left dozens of tables emptied and nothing loaded — and a second attempt destroyed more than the first, because it got further before hitting the same wall. The wall itself was not exotic: MySQL, MariaDB and SQL Server check a foreign key as each ROW is deleted, so a table that references ITSELF cannot be emptied by any ordering of the tables. `createdBy → actors` on the `actors` table is exactly that shape, and it is what an audit mixin on an actor table produces.
+
+  - `DataStore.emptyTables()` (per dialect) empties the whole set as one unit, in one transaction, with referential integrity suspended for the duration — `FOREIGN_KEY_CHECKS` on the mysql family, a multi-table `TRUNCATE` on postgres, `defer_foreign_keys` on sqlite, per-table `NOCHECK`/`WITH CHECK CHECK` on mssql. All-or-nothing on every engine, including under `--atomic`, where it runs on the transaction the import already holds. - A **pre-flight refusal**: if a table OUTSIDE the bundle holds rows referencing one inside it, the import refuses before deleting anything and names the tables, the columns and the row counts. Those rows cannot be restored from the bundle, so forcing it is not an option. An EMPTY outside table blocks nothing. - Table-level failures carry the driver's own reason and code, the way row-level failures already did. `truncate <table> failed: Failed to execute statement` fits every plausible cause equally; the classification that produced `foreign key <name>: … [ER_NO_REFERENCED_ROW_2/1452]` one level down now applies one level up. The word "truncate" is gone from the message too — the step issues DELETE, and naming a statement it does not run sends whoever reads it to reproduce the wrong thing. - A typed refusal reaching the `--target api` transport keeps its text: the admin import endpoint answers `409` with the reason instead of flattening it to `import failed`, on the one transport where the operator has no other way to see it.
+
+  The bulk empty emits no change events, where the per-table loop emitted one per row. An import through `--target api` now asks every live subscription to re-read once it lands — the coarse refresh the framework already uses after a broadcast gap — so neither the missing deletes nor a table the bundle carries EMPTY leaves a subscriber holding rows that are gone. Wired where the route is mounted, which is the one place both boot paths share.
+
+  On postgres the emptying is a `DELETE` per table, not a `TRUNCATE`, and the difference is not performance: postgres refuses `TRUNCATE` on a table with ANY incoming foreign key, rows or not, while the mysql family refuses a DELETE only when rows actually reference the doomed ones. A `TRUNCATE` version made an EMPTY table outside the bundle block a replace on postgres and not on mariadb — one import, refused on one engine and accepted on the other, over a table holding nothing.
+
+  `--target api` also no longer times out on a full bundle. Both api-target calls went through `fetch`, whose undici default gives up after 300 s — a bound on the caller's database size, on a call whose response arrives only when the import does. They wait as long as the instance needs now, stream the body instead of buffering the whole bundle, and take `--timeout <seconds>` when a deadline is wanted. If one is hit, the message says the instance is probably still importing — and gives different advice for `replace` than for the idempotent modes, since re-running the first while it is mid-flight would empty the target under it.
+
+  Two more, found by measuring rather than by reading:
+
+  - **`--atomic` on postgres could not import a bundle that needed the deferred-FK repair at all.** A failed statement aborts the transaction there, and that repair depends on a row whose parent has not loaded yet failing, being held, and being retried — so the first such row poisoned every write after it. Every tolerated write now runs inside a savepoint. Per-row savepoints measured 2.40x the time of none on 5 000 rows, so they are amortised: one savepoint per batch of 200, and a batch that fails rolls back whole and replays row by row. The mysql family and sqlite leave a transaction usable after a failed statement and pay nothing for any of this. - **The replace pre-flight asked the caller's snapshot.** Over `--target api` that is the app's DECLARED schema, which cannot show a table the app stopped declaring but the database still has — and rows in a table nobody declares are exactly the rows nobody is watching. `DataStore.incomingForeignKeys()` reads the live catalog per dialect; the snapshot remains the fallback for stores without one.
+
+  A bundle bigger than one chunk is now uploaded as a series of short requests, so a proxy body cap or an ingress read timeout has nothing large to choke on, and the switch is automatic — the packer's stream is buffered one chunk ahead, so a small bundle is sent exactly as before and nobody has to know in advance which table is the big one. The import still runs ONCE, at the end, over the whole bundle. Resume is byte-exact (`packBundle` is deterministic over a directory, which this package now asserts), guarded by a bundle key so a different bundle under the same upload id is refused rather than spliced into the partial one, and by a contiguity check so a mis-ordered append cannot produce an archive that only fails later during decode. `--chunk-size <mb>` overrides the 16 MiB default.
+
+---
+
 ## [0.43.1] — 2026-08-18
 
 ### Fixed

package/dist/index.d.ts

@@ -379,6 +379,19 @@ export declare class PostgresDataStore implements DataStore {
      * The gap being closed is specific: a plain write's statement commits ITSELF,
      * so the transport fires while this is still awaiting the driver.
      */
+    /**
+     * A write and its write-recorders, as ONE unit — see `MysqlStore.
+     * writeWithRecorders` for the failure this closes.
+     *
+     * Same divergence on this dialect: the row's statement commits on its own and
+     * the recorder's INSERT is a second autocommit statement, so a recorder that
+     * throws leaves a committed row behind a write that reported failure. A caller
+     * that retries then meets its own row.
+     *
+     * Only tables that HAVE a recorder pay for the transaction; `recordsTable` is
+     * a Map-size check first, so the default costs one comparison.
+     */
+    private writeWithRecorders;
     private localWrite;
     insert(table: string, row: Row): Promise<Row>;
     insertMany(table: string, rows: ReadonlyArray<Row>): Promise<ReadonlyArray<Row>>;
@@ -467,6 +480,36 @@ export declare class PostgresDataStore implements DataStore {
      *   - The Exit settles through `settleTransactionExit`, so a typed error
      *     reaches the caller with its `_tag` rather than as a `FiberFailure`.
      */
+    /**
+     * Empty `tables` as one unit — see `DataStore.emptyTables`.
+     *
+     * Postgres needs no integrity switch, because it does not check a foreign key
+     * per deleted ROW: the constraint triggers are queued and run at the END of
+     * the statement. So a single `DELETE FROM t` clears a self-referencing table —
+     * the case that is impossible to order around on the mysql family — and the
+     * caller's children-first order covers the rest.
+     *
+     * `TRUNCATE` would be faster and was the first version of this, and it is
+     * WRONG here for a reason worth recording: postgres refuses `TRUNCATE` on a
+     * table with ANY incoming foreign key, whether or not that key has rows behind
+     * it. The mysql family refuses a DELETE only when rows actually reference the
+     * doomed ones. Keeping `TRUNCATE` would have made an EMPTY table outside the
+     * bundle block a replace on postgres and not on mariadb — the same import
+     * refused on one engine and accepted on the other, for a table holding
+     * nothing. Speed is not worth a divergence an operator cannot predict.
+     */
+    emptyTables(tables: ReadonlyArray<string>): Promise<void>;
+    /** See `DataStore.incomingForeignKeys`. Read from `pg_catalog` rather than
+     *  `information_schema`: the OID joins are the same ones the introspector was
+     *  moved to, and the view's row-per-column-per-privilege shape is what makes
+     *  the information_schema version slow on FK-dense schemas. */
+    incomingForeignKeys(tables: ReadonlyArray<string>): Promise<ReadonlyArray<{
+        from: string;
+        column: string;
+        to: string;
+    }>>;
+    /* Excluded from this release type: runStatementOnTransaction */
+    /* Excluded from this release type: emptyTablesOn */
     transactional<T>(work: (tx: DataStore) => Promise<T>): Promise<T>;
     onChange(listener: (event: ChangeEvent) => void): () => void;
     /** Cross-instance reactivity seam — emit an externally-sourced event to

package/dist/index.js

@@ -1,13 +1,13 @@
 import { PgClient as e, PgClient as t } from "@effect/sql-pg";
-import { Config as n, Duration as r, Effect as i, Fiber as a, Layer as o, ManagedRuntime as s, Metric as c, Redacted as l, Schedule as u, Stream as d } from "effect";
-import f from "pg";
-import { DEFAULT_ACQUIRE_TIMEOUT_MS as p, EagerCardinalityError as m, attachEagerLoads as h, attributionFields as g, attributionKey as ee, beginLocalWrite as te, bulkInsertLimitsFor as ne, chunkRowsForInsert as re, compileEagerJson as ie, compilePredicate as _, compileRawFragment as ae, compileSelect as oe, encodeRowForSchema as v, endLocalWrite as se, externalChangeEvent as ce, hasEagerLoads as le, isTableReactive as y, makeEagerFallbackReporter as ue, observeDbOp as b, raiseChangeListenerCeiling as de, recordsTable as fe, registerPendingAttribution as x, requireTable as S, resolveEchoAttribution as C, runRetryingTransaction as w, runStoreTransaction as T, runWriteRecorders as pe, stampGeneratedId as E, stampGeneratedIds as me, withCapturedAttribution as D } from "@voltro/database";
-import { EventEmitter as he } from "node:events";
-import { createLogger as ge } from "@voltro/logger";
+import { Config as n, Duration as r, Effect as i, Fiber as a, Layer as o, ManagedRuntime as s, Metric as c, Option as l, Redacted as u, Schedule as d, Stream as f } from "effect";
+import p from "pg";
+import { DEFAULT_ACQUIRE_TIMEOUT_MS as m, EagerCardinalityError as h, attachEagerLoads as g, attributionFields as ee, attributionKey as te, beginLocalWrite as ne, bulkInsertLimitsFor as re, chunkRowsForInsert as ie, compileEagerJson as ae, compilePredicate as _, compileRawFragment as oe, compileSelect as se, encodeRowForSchema as v, endLocalWrite as ce, externalChangeEvent as le, hasEagerLoads as ue, isTableReactive as y, makeEagerFallbackReporter as de, observeDbOp as b, raiseChangeListenerCeiling as fe, recordsTable as x, registerPendingAttribution as S, requireTable as C, resolveEchoAttribution as w, runRetryingTransaction as pe, runStoreTransaction as T, runWriteRecorders as me, stampGeneratedId as E, stampGeneratedIds as he, withCapturedAttribution as D } from "@voltro/database";
+import { EventEmitter as ge } from "node:events";
+import { createLogger as _e } from "@voltro/logger";
 import { SqlClient as O, TransactionConnection as k } from "@effect/sql/SqlClient";
 //#region src/sqlLayer.ts
 var A = (e) => {
-	let t = e.acquireTimeoutMs ?? p;
+	let t = e.acquireTimeoutMs ?? m;
 	return t > 0 ? t : void 0;
 }, j = (e) => e ? { rejectUnauthorized: !1 } : !1, M = /^[A-Za-z_][A-Za-z0-9_]*$/, N = (e) => {
 	let t = A(e);
@@ -15,7 +15,7 @@ var A = (e) => {
 		host: n.succeed(e.host),
 		port: n.succeed(e.port),
 		username: n.succeed(e.username),
-		password: n.succeed(l.make(e.password)),
+		password: n.succeed(u.make(e.password)),
 		database: n.succeed(e.database),
 		...e.maxConnections === void 0 ? {} : { maxConnections: n.succeed(e.maxConnections) },
 		...e.ssl === void 0 ? {} : { ssl: n.succeed(j(e.ssl)) },
@@ -28,7 +28,7 @@ var A = (e) => {
 		if (!M.test(t.schema)) throw Error(`DB_SCHEMA '${t.schema}' is not a valid postgres identifier (expected ${M}).`);
 		n = { options: `-c search_path="${t.schema}"` };
 	}
-	let r = A(t), a = i.acquireRelease(i.sync(() => new f.Pool({
+	let r = A(t), a = i.acquireRelease(i.sync(() => new p.Pool({
 		host: t.host,
 		port: t.port,
 		user: t.username,
@@ -83,37 +83,37 @@ var A = (e) => {
 		...n,
 		...t
 	};
-}, L = (e) => P(I(e)), R = /* @__PURE__ */ new Set(["40001", "40P01"]), _e = (e) => {
+}, L = (e) => P(I(e)), ve = /* @__PURE__ */ new Set(["40001", "40P01"]), ye = (e) => {
 	let t = e;
 	for (let e = 0; e < 5 && typeof t == "object" && t; e++) {
 		let e = t.code;
 		if (typeof e == "string") return e;
 		t = t.cause;
 	}
-}, z = (e) => {
-	let t = _e(e);
-	return t !== void 0 && R.has(t);
-}, B = (e) => z(e) ? "retry" : "noRetry", V = c.counter("voltro_cdc_oversized_total", { description: "Change events whose row images exceeded the postgres NOTIFY payload cap, by what re-hydration recovered (rehydrated = row re-read · tombstone = delete, primary key only · unrecovered = content lost to taps)." }), ve = {
-	rehydrated: c.tagged(V, "outcome", "rehydrated"),
-	tombstone: c.tagged(V, "outcome", "tombstone"),
-	unrecovered: c.tagged(V, "outcome", "unrecovered")
-}, H = (e) => {
-	i.runSync(c.increment(ve[e]));
-}, ye = {
+}, R = (e) => {
+	let t = ye(e);
+	return t !== void 0 && ve.has(t);
+}, z = (e) => R(e) ? "retry" : "noRetry", B = c.counter("voltro_cdc_oversized_total", { description: "Change events whose row images exceeded the postgres NOTIFY payload cap, by what re-hydration recovered (rehydrated = row re-read · tombstone = delete, primary key only · unrecovered = content lost to taps)." }), be = {
+	rehydrated: c.tagged(B, "outcome", "rehydrated"),
+	tombstone: c.tagged(B, "outcome", "tombstone"),
+	unrecovered: c.tagged(B, "outcome", "unrecovered")
+}, V = (e) => {
+	i.runSync(c.increment(be[e]));
+}, xe = {
 	rehydrateTimeoutMs: 5e3,
 	rehydrateRetries: 2
-}, U = (e) => {
+}, H = (e) => {
 	let t = process.env[e];
 	if (t === void 0 || t.trim() === "") return;
 	let n = Number(t);
 	return Number.isFinite(n) && n >= 0 ? n : void 0;
-}, W = (e) => {
-	let t = ye, n = e ?? {};
+}, U = (e) => {
+	let t = xe, n = e ?? {};
 	return {
-		rehydrateTimeoutMs: Math.max(1, n.rehydrateTimeoutMs ?? U("VOLTRO_CDC_REHYDRATE_TIMEOUT_MS") ?? t.rehydrateTimeoutMs),
-		rehydrateRetries: Math.max(0, n.rehydrateRetries ?? U("VOLTRO_CDC_REHYDRATE_RETRIES") ?? t.rehydrateRetries)
+		rehydrateTimeoutMs: Math.max(1, n.rehydrateTimeoutMs ?? H("VOLTRO_CDC_REHYDRATE_TIMEOUT_MS") ?? t.rehydrateTimeoutMs),
+		rehydrateRetries: Math.max(0, n.rehydrateRetries ?? H("VOLTRO_CDC_REHYDRATE_RETRIES") ?? t.rehydrateRetries)
 	};
-}, be = (e) => i.suspend(() => {
+}, Se = (e) => i.suspend(() => {
 	let t = e.notification, n = t.id, a = {
 		table: t.table,
 		op: t.op
@@ -127,9 +127,9 @@ var A = (e) => {
 		outcome: "unrecovered",
 		reason: e
 	});
-	if (typeof n != "string" && typeof n != "number") return H("unrecovered"), i.succeed(o("no-key"));
+	if (typeof n != "string" && typeof n != "number") return V("unrecovered"), i.succeed(o("no-key"));
 	if (t.op === "delete") {
-		H("tombstone");
+		V("tombstone");
 		let e = {
 			event: {
 				...a,
@@ -141,12 +141,12 @@ var A = (e) => {
 		};
 		return i.succeed(e);
 	}
-	let s = u.exponential(r.millis(50), 2).pipe(u.intersect(u.recurs(e.tunables.rehydrateRetries)));
+	let s = d.exponential(r.millis(50), 2).pipe(d.intersect(d.recurs(e.tunables.rehydrateRetries)));
 	return e.fetchRow({
 		schema: t.schema,
 		table: t.table,
 		key: n
-	}).pipe(i.retry(s), i.timeout(r.millis(e.tunables.rehydrateTimeoutMs)), i.map((e) => e === null ? (H("unrecovered"), o("row-gone")) : (H("rehydrated"), {
+	}).pipe(i.retry(s), i.timeout(r.millis(e.tunables.rehydrateTimeoutMs)), i.map((e) => e === null ? (V("unrecovered"), o("row-gone")) : (V("rehydrated"), {
 		event: {
 			...a,
 			old: null,
@@ -154,8 +154,8 @@ var A = (e) => {
 			oversized: "rehydrated"
 		},
 		outcome: "rehydrated"
-	})), i.catchAllCause(() => (H("unrecovered"), i.succeed(o("read-failed")))));
-}), xe = (e) => {
+	})), i.catchAllCause(() => (V("unrecovered"), i.succeed(o("read-failed")))));
+}), Ce = (e) => {
 	let t = /* @__PURE__ */ new Set();
 	return (n, r) => {
 		if (r.outcome === "unrecovered") {
@@ -173,25 +173,25 @@ var A = (e) => {
 			note: r.outcome === "tombstone" ? "a delete of an oversized row delivers the primary key only — the pre-image is unrecoverable" : "the re-read returns the row as it is NOW, not the image at commit"
 		}));
 	};
-}, G = ["json"], K = ge({ scope: "voltro:postgres" }), q = async (e) => {
-	let t = e.tracerLayer ? o.mergeAll(e.sqlLayer, e.tracerLayer) : e.sqlLayer, n = s.make(t), r = await n.runPromise(O), i = e.changeStrategy ?? "inline", a = new Se(r, n, i, e.cdcChannel ?? "framework_changes", W({
+}, W = ["json"], G = _e({ scope: "voltro:postgres" }), K = async (e) => {
+	let t = e.tracerLayer ? o.mergeAll(e.sqlLayer, e.tracerLayer) : e.sqlLayer, n = s.make(t), r = await n.runPromise(O), i = e.changeStrategy ?? "inline", a = new we(r, n, i, e.cdcChannel ?? "framework_changes", U({
 		...e.cdcRehydrateTimeoutMs === void 0 ? {} : { rehydrateTimeoutMs: e.cdcRehydrateTimeoutMs },
 		...e.cdcRehydrateRetries === void 0 ? {} : { rehydrateRetries: e.cdcRehydrateRetries }
 	}));
 	return i === "cdc" && await a.startCdcConsumer(), a;
-}, Se = class {
+}, we = class {
 	sql;
 	runtime;
 	changeStrategy;
 	cdcChannel;
 	cdcRehydrate;
-	emitter = new he();
+	emitter = new ge();
 	cdcFiber = null;
 	inflightTxns = 0;
-	reportOversized = xe(K);
-	reportEagerFallback = ue(K);
-	constructor(e, t, n, r, i = W()) {
-		this.sql = e, this.runtime = t, this.changeStrategy = n, this.cdcChannel = r, this.cdcRehydrate = i, de(this.emitter);
+	reportOversized = Ce(G);
+	reportEagerFallback = de(G);
+	constructor(e, t, n, r, i = U()) {
+		this.sql = e, this.runtime = t, this.changeStrategy = n, this.cdcChannel = r, this.cdcRehydrate = i, fe(this.emitter);
 	}
 	txnSpec(e, t, n) {
 		return {
@@ -199,7 +199,7 @@ var A = (e) => {
 			dialect: "postgres",
 			withTransaction: (e) => this.sql.withTransaction(e),
 			runPromiseExit: (e) => this.runtime.runPromiseExit(e),
-			isRetryable: z,
+			isRetryable: R,
 			span: {
 				name: t,
 				attributes: {
@@ -210,7 +210,7 @@ var A = (e) => {
 		};
 	}
 	withNamespace(e) {
-		return e === null ? this : new Ce(this, e);
+		return e === null ? this : new Te(this, e);
 	}
 	async runInNamespace(e, t) {
 		let n = this.sql;
@@ -220,7 +220,7 @@ var A = (e) => {
 				...this.txnSpec("PostgresDataStore.runInNamespace", "store.namespace", "namespace.transaction"),
 				prepare: (t) => i.provideService(n`SET LOCAL search_path TO ${n(e)}`, k, t),
 				work: t,
-				makeView: (e, t) => new J(this, e, t)
+				makeView: (e, t) => new q(this, e, t)
 			});
 		} finally {
 			this.inflightTxns--;
@@ -228,12 +228,12 @@ var A = (e) => {
 	}
 	__postgresReplicationFriend = { runEffect: (e) => this.runtime.runPromise(e) };
 	async executeQuery(e, t, n = null) {
-		let r = oe(e, this.sql, n), a = t ? i.provideService(r, k, t) : r;
+		let r = se(e, this.sql, n), a = t ? i.provideService(r, k, t) : r;
 		return b("postgres", "select", () => this.runtime.runPromise(a));
 	}
 	async executeInsert(e, t, n, r, a) {
 		t = E(e, t);
-		let o = this.sql, s = o`INSERT INTO ${o(e)} ${o.insert(v(t, e, G))} RETURNING *`, c = n ? i.provideService(s, k, n) : s, l = (await this.runtime.runPromise(c))[0];
+		let o = this.sql, s = o`INSERT INTO ${o(e)} ${o.insert(v(t, e, W))} RETURNING *`, c = n ? i.provideService(s, k, n) : s, l = (await this.runtime.runPromise(c))[0];
 		if (!l) throw Error(`PostgresDataStore.insert: no row returned for table '${e}'`);
 		return await this.routeEvent({
 			table: e,
@@ -243,7 +243,7 @@ var A = (e) => {
 		}, r, n, a), l;
 	}
 	async executeUpdate(e, t, n, r, a, o) {
-		let s = this.sql, c = s`UPDATE ${s(e)} SET ${s.update(v(n, e, G))} WHERE ${s("id")} = ${t} RETURNING *`, l = r ? i.provideService(c, k, r) : c, u = (await this.runtime.runPromise(l))[0];
+		let s = this.sql, c = s`UPDATE ${s(e)} SET ${s.update(v(n, e, W))} WHERE ${s("id")} = ${t} RETURNING *`, l = r ? i.provideService(c, k, r) : c, u = (await this.runtime.runPromise(l))[0];
 		return u ? (await this.routeEvent({
 			table: e,
 			op: "update",
@@ -261,7 +261,7 @@ var A = (e) => {
 			if (r) return l(r);
 			this.inflightTxns++;
 			try {
-				return await w({
+				return await pe({
 					...this.txnSpec("PostgresDataStore.upsert", "store.upsert", "upsert.transaction"),
 					body: (e) => l(e)
 				});
@@ -269,7 +269,7 @@ var A = (e) => {
 				this.inflightTxns--;
 			}
 		}
-		let c = n.conflictColumns.map((e) => s`${s(e)}`), l = Object.keys(t).filter((e) => t[e] !== void 0), u = n.update === void 0 ? l.filter((e) => e !== "id" && !n.conflictColumns.includes(e)) : n.update, d = u.length > 0 ? s.csv(u.map((e) => s`${s(e)} = EXCLUDED.${s(e)}`)) : s`${s(n.conflictColumns[0])} = EXCLUDED.${s(n.conflictColumns[0])}`, f = s`INSERT INTO ${s(e)} ${s.insert(v(t, e, G))} ON CONFLICT (${s.csv(c)}) DO UPDATE SET ${d} RETURNING *`, p = r ? i.provideService(f, k, r) : f, m = (await this.runtime.runPromise(p))[0];
+		let c = n.conflictColumns.map((e) => s`${s(e)}`), l = Object.keys(t).filter((e) => t[e] !== void 0), u = n.update === void 0 ? l.filter((e) => e !== "id" && !n.conflictColumns.includes(e)) : n.update, d = u.length > 0 ? s.csv(u.map((e) => s`${s(e)} = EXCLUDED.${s(e)}`)) : s`${s(n.conflictColumns[0])} = EXCLUDED.${s(n.conflictColumns[0])}`, f = s`INSERT INTO ${s(e)} ${s.insert(v(t, e, W))} ON CONFLICT (${s.csv(c)}) DO UPDATE SET ${d} RETURNING *`, p = r ? i.provideService(f, k, r) : f, m = (await this.runtime.runPromise(p))[0];
 		if (!m) throw Error(`PostgresDataStore.upsert: no row returned for table '${e}'`);
 		{
 			let n = t.id !== void 0 && t.id === m.id ? "insert" : "update";
@@ -284,7 +284,7 @@ var A = (e) => {
 	}
 	async executeInsertIgnore(e, t, n, r, a, o) {
 		t = E(e, t);
-		let s = this.sql, c = n.conflictColumns.map((e) => s`${s(e)}`), l = s`INSERT INTO ${s(e)} ${s.insert(v(t, e, G))} ON CONFLICT (${s.csv(c)}) DO NOTHING RETURNING *`, u = r ? i.provideService(l, k, r) : l, d = (await this.runtime.runPromise(u))[0];
+		let s = this.sql, c = n.conflictColumns.map((e) => s`${s(e)}`), l = s`INSERT INTO ${s(e)} ${s.insert(v(t, e, W))} ON CONFLICT (${s.csv(c)}) DO NOTHING RETURNING *`, u = r ? i.provideService(l, k, r) : l, d = (await this.runtime.runPromise(u))[0];
 		if (d) return await this.routeEvent({
 			table: e,
 			op: "insert",
@@ -296,8 +296,8 @@ var A = (e) => {
 		return h[0];
 	}
 	async executeInsertMany(e, t, n, r, a) {
-		if (t = me(e, t), t.length === 0) return [];
-		let o = this.sql, s = t.map((t) => v(t, e, G)), c = re(s, ne("postgres")), l = (t) => o`INSERT INTO ${o(e)} ${o.insert(t)} RETURNING *`, u;
+		if (t = he(e, t), t.length === 0) return [];
+		let o = this.sql, s = t.map((t) => v(t, e, W)), c = ie(s, re("postgres")), l = (t) => o`INSERT INTO ${o(e)} ${o.insert(t)} RETURNING *`, u;
 		if (c.length === 1) {
 			let e = l(c[0]), t = n ? i.provideService(e, k, n) : e;
 			u = await this.runtime.runPromise(t);
@@ -333,7 +333,7 @@ var A = (e) => {
 		}, r, n, a), !0) : !1;
 	}
 	async appendInTxn(e, t, n) {
-		let r = this.sql, a = r`INSERT INTO ${r(e)} ${r.insert(v(t, e, G))}`;
+		let r = this.sql, a = r`INSERT INTO ${r(e)} ${r.insert(v(t, e, W))}`;
 		await this.runtime.runPromise(n ? i.provideService(a, k, n) : a);
 	}
 	async maxInTxn(e, t, n, r) {
@@ -342,9 +342,9 @@ var A = (e) => {
 	}
 	async routeEvent(e, t, n = null, r) {
 		if (e = {
-			...g(r),
+			...ee(r),
 			...e
-		}, fe(e.table) && await pe({
+		}, x(e.table) && await me({
 			append: (e, t) => this.appendInTxn(e, t, n),
 			maxOf: (e, t, r) => this.maxInTxn(e, t, r, n)
 		}, {
@@ -357,7 +357,7 @@ var A = (e) => {
 		}), y(e.table)) {
 			if (this.changeStrategy === "cdc") {
 				let t = (e.op === "delete" ? e.old : e.new)?.id;
-				t != null && x(ee(e.table, e.op, t), {
+				t != null && S(te(e.table, e.op, t), {
 					...e.traceId === void 0 ? {} : { traceId: e.traceId },
 					...e.subjectId === void 0 ? {} : { subjectId: e.subjectId }
 				});
@@ -370,17 +370,17 @@ var A = (e) => {
 		return this.runWithEager(e, null);
 	}
 	raw(e, t) {
-		let n = ae(e, this.sql);
+		let n = oe(e, this.sql);
 		return b("postgres", "raw", () => this.runtime.runPromise(n));
 	}
 	async runWithEager(e, t, n = null) {
-		if (!le(e)) return this.executeQuery(e, t, n);
-		let r = n === null ? ie(e, this.sql, "postgres") : null;
+		if (!ue(e)) return this.executeQuery(e, t, n);
+		let r = n === null ? ae(e, this.sql, "postgres") : null;
 		if (r !== null) try {
 			let e = t ? i.provideService(r.fragment, k, t) : r.fragment, n = await b("postgres", "select", () => this.runtime.runPromise(e));
 			return r.decode(n);
 		} catch (t) {
-			if (t instanceof m) throw t;
+			if (t instanceof h) throw t;
 			this.reportEagerFallback({
 				dialect: "postgres",
 				table: e.table,
@@ -394,7 +394,7 @@ var A = (e) => {
 			reason: "not-compilable"
 		});
 		let a = await this.executeQuery(e, t, n);
-		return h(a, e.eager, e.sourceTable ?? S(e.table), (e) => this.executeQuery(e, t, n));
+		return g(a, e.eager, e.sourceTable ?? C(e.table), (e) => this.executeQuery(e, t, n));
 	}
 	getInternalRunWithEager() {
 		return (e, t) => this.runWithEager(e, t);
@@ -402,40 +402,49 @@ var A = (e) => {
 	async queryInNamespace(e, t) {
 		return this.runWithEager(t, null, e);
 	}
+	async writeWithRecorders(e, t) {
+		let n = [], r = this.sql, a = await this.runtime.runPromise(r.withTransaction(i.flatMap(i.serviceOption(k), (r) => l.isNone(r) ? i.fail(/* @__PURE__ */ Error("PostgresDataStore.write: TransactionConnection missing.")) : i.tryPromise({
+			try: () => e(t, r.value, n),
+			catch: (e) => e
+		}))));
+		for (let e of n) this.emitChange(e);
+		return a;
+	}
 	async localWrite(e, t, n) {
+		let r = (e) => x(t) ? this.writeWithRecorders(n, e) : n(e, null, null);
 		return b("postgres", e, async () => {
-			if (this.changeStrategy !== "cdc") return D(n);
-			te(t);
+			if (this.changeStrategy !== "cdc") return D(r);
+			ne(t);
 			try {
-				return await D(n);
+				return await D(r);
 			} finally {
-				se(t);
+				ce(t);
 			}
 		});
 	}
 	insert(e, t) {
-		return this.localWrite("insert", e, (n) => this.executeInsert(e, t, null, null, n));
+		return this.localWrite("insert", e, (n, r, i) => this.executeInsert(e, t, r, i, n));
 	}
 	insertMany(e, t) {
-		return this.localWrite("insert", e, (n) => this.executeInsertMany(e, t, null, null, n));
+		return this.localWrite("insert", e, (n, r, i) => this.executeInsertMany(e, t, r, i, n));
 	}
 	patchJson(e, t, n, r) {
-		return this.localWrite("update", e, (i) => this.executePatchJson(e, t, n, r, null, null, i));
+		return this.localWrite("update", e, (i, a, o) => this.executePatchJson(e, t, n, r, a, o, i));
 	}
 	update(e, t, n) {
-		return this.localWrite("update", e, (r) => this.executeUpdate(e, t, n, null, null, r));
+		return this.localWrite("update", e, (r, i, a) => this.executeUpdate(e, t, n, i, a, r));
 	}
 	delete(e, t) {
-		return this.localWrite("delete", e, (n) => this.executeDelete(e, t, null, null, n));
+		return this.localWrite("delete", e, (n, r, i) => this.executeDelete(e, t, r, i, n));
 	}
 	async updateMany(e, t, n) {
-		return this.localWrite("update", e, (r) => this.executeUpdateMany(e, t, n, null, null, r));
+		return this.localWrite("update", e, (r, i, a) => this.executeUpdateMany(e, t, n, i, a, r));
 	}
 	async deleteMany(e, t) {
-		return this.localWrite("delete", e, (n) => this.executeDeleteMany(e, t, null, null, n));
+		return this.localWrite("delete", e, (n, r, i) => this.executeDeleteMany(e, t, r, i, n));
 	}
 	async executeUpdateMany(e, t, n, r, a, o) {
-		let s = this.sql, c = _(n.where, s), l = s`UPDATE ${s(e)} SET ${s.update(v(t, e, G))} WHERE ${c} RETURNING *`, u = r ? i.provideService(l, k, r) : l, d = await this.runtime.runPromise(u);
+		let s = this.sql, c = _(n.where, s), l = s`UPDATE ${s(e)} SET ${s.update(v(t, e, W))} WHERE ${c} RETURNING *`, u = r ? i.provideService(l, k, r) : l, d = await this.runtime.runPromise(u);
 		for (let t of d) await this.routeEvent({
 			table: e,
 			op: "update",
@@ -455,10 +464,10 @@ var A = (e) => {
 		return u.length;
 	}
 	upsert(e, t, n) {
-		return this.localWrite("upsert", e, (r) => this.executeUpsert(e, t, n, null, null, r));
+		return this.localWrite("upsert", e, (r, i, a) => this.executeUpsert(e, t, n, i, a, r));
 	}
 	insertIgnore(e, t, n) {
-		return this.localWrite("upsert", e, (r) => this.executeInsertIgnore(e, t, n, null, null, r));
+		return this.localWrite("upsert", e, (r, i, a) => this.executeInsertIgnore(e, t, n, i, a, r));
 	}
 	emitChange(e) {
 		this.emitter.emit("change", e);
@@ -493,13 +502,42 @@ var A = (e) => {
 	getInternalExecuteInsertIgnore() {
 		return this.executeInsertIgnore.bind(this);
 	}
+	async emptyTables(e) {
+		await this.emptyTablesOn(e, null);
+	}
+	async incomingForeignKeys(e) {
+		if (e.length === 0) return [];
+		let t = this.sql;
+		return (await this.runtime.runPromise(t`
+        SELECT child.relname AS from_table, att.attname AS column_name, parent.relname AS to_table
+        FROM pg_constraint c
+        JOIN pg_class child ON child.oid = c.conrelid
+        JOIN pg_class parent ON parent.oid = c.confrelid
+        JOIN LATERAL unnest(c.conkey) AS k(attnum) ON true
+        JOIN pg_attribute att ON att.attrelid = c.conrelid AND att.attnum = k.attnum
+        WHERE c.contype = 'f'
+          AND parent.relname IN ${t.in(e)}
+          AND child.relname NOT IN ${t.in(e)}`)).map((e) => ({
+			from: e.from_table,
+			column: e.column_name,
+			to: e.to_table
+		}));
+	}
+	runStatementOnTransaction(e, t) {
+		return this.runtime.runPromise(i.provideService(this.sql.unsafe(e), k, t));
+	}
+	async emptyTablesOn(e, t) {
+		if (e.length === 0) return;
+		let n = this.sql, r = i.forEach(e, (e) => n`DELETE FROM ${n(e)}`, { discard: !0 }), a = t === null ? n.withTransaction(r) : i.provideService(r, k, t);
+		await this.runtime.runPromise(a);
+	}
 	async transactional(e) {
 		this.inflightTxns++;
 		try {
 			return await T({
 				...this.txnSpec("PostgresDataStore.transactional", "store.transactional", "transaction"),
 				work: e,
-				makeView: (e, t) => new J(this, e, t)
+				makeView: (e, t) => new q(this, e, t)
 			});
 		} finally {
 			this.inflightTxns--;
@@ -516,8 +554,8 @@ var A = (e) => {
 	injectExternalChange(e) {
 		if (!y(e.table)) return;
 		let t = (e.op === "delete" ? e.old : e.new)?.id;
-		C(e.table, e.op, t, (t) => {
-			this.emitter.emit("change", ce(e, t));
+		w(e.table, e.op, t, (t) => {
+			this.emitter.emit("change", le(e, t));
 		});
 	}
 	run(e) {
@@ -527,7 +565,7 @@ var A = (e) => {
 		if (this.inflightTxns > 0) {
 			let t = Date.now() + e;
 			for (; this.inflightTxns > 0 && Date.now() < t;) await new Promise((e) => setTimeout(e, 25));
-			this.inflightTxns > 0 && K.warn("close: grace period expired with in-flight transactions — forcing dispose", {
+			this.inflightTxns > 0 && G.warn("close: grace period expired with in-flight transactions — forcing dispose", {
 				gracePeriodMs: e,
 				inflight: this.inflightTxns
 			});
@@ -552,7 +590,7 @@ var A = (e) => {
 			try {
 				t = JSON.parse(e);
 			} catch (e) {
-				return K.warn("cdc: bad payload", { channel: this.cdcChannel }, e), i.void;
+				return G.warn("cdc: bad payload", { channel: this.cdcChannel }, e), i.void;
 			}
 			if (t.oversized !== !0) {
 				let e = {
@@ -565,7 +603,7 @@ var A = (e) => {
 					this.injectExternalChange(e);
 				});
 			}
-			return y(t.table) ? be({
+			return y(t.table) ? Se({
 				notification: t,
 				fetchRow: ({ schema: e, table: t, key: n }) => this.readRowAsCdcJson(e, t, n),
 				tunables: this.cdcRehydrate
@@ -573,9 +611,9 @@ var A = (e) => {
 				this.reportOversized(t, e), this.injectExternalChange(e.event);
 			})) : i.void;
 		});
-		this.cdcFiber = this.runtime.runFork(e.pipe(d.runForEach(n)));
+		this.cdcFiber = this.runtime.runFork(e.pipe(f.runForEach(n)));
 	}
-}, J = class {
+}, q = class {
 	parent;
 	txn;
 	attr;
@@ -587,6 +625,20 @@ var A = (e) => {
 	query(e) {
 		return this.parent.getInternalRunWithEager()(e, this.txn);
 	}
+	emptyTables(e) {
+		return this.parent.emptyTablesOn(e, this.txn);
+	}
+	async savepoint(e) {
+		let t = `voltro_sp_${++this.savepointCounter}`, n = (e) => this.parent.runStatementOnTransaction(e, this.txn);
+		await n(`SAVEPOINT ${t}`);
+		try {
+			let r = await e();
+			return await n(`RELEASE SAVEPOINT ${t}`), r;
+		} catch (e) {
+			throw await n(`ROLLBACK TO SAVEPOINT ${t}`).catch(() => void 0), await n(`RELEASE SAVEPOINT ${t}`).catch(() => void 0), e;
+		}
+	}
+	savepointCounter = 0;
 	insert(e, t) {
 		return this.parent.getInternalExecuteInsert()(e, t, this.txn, this.events, this.attr);
 	}
@@ -630,7 +682,7 @@ var A = (e) => {
 			this.events.length = 0;
 		}
 	}
-}, Ce = class {
+}, Te = class {
 	parent;
 	namespace;
 	constructor(e, t) {
@@ -684,14 +736,14 @@ var A = (e) => {
 			return r === void 0 ? Promise.reject(/* @__PURE__ */ Error("PostgresNamespaceView.raw: underlying store has no raw()")) : r(e, t);
 		});
 	}
-}, Y = (e) => e.__postgresReplicationFriend ?? null, we = (e, t) => {
+}, J = (e) => e.__postgresReplicationFriend ?? null, Ee = (e, t) => {
 	let [n, r] = e.split("/"), [i, a] = t.split("/");
 	if (!n || !r || !i || !a) throw Error(`postgres LSN compare: invalid format (${e} vs ${t})`);
 	let o = parseInt(n, 16), s = parseInt(r, 16), c = parseInt(i, 16);
 	return o === c ? s - parseInt(a, 16) : o - c;
-}, Te = () => ({
+}, Y = () => ({
 	async capturePrimaryPosition(e) {
-		let t = Y(e);
+		let t = J(e);
 		if (t === null) throw Error("postgresReplicationAdapter: primary is not a PostgresDataStore (missing __postgresReplicationFriend). Pass the postgres store directly.");
 		return t.runEffect(i.gen(function* () {
 			let e = (yield* (yield* O)`SELECT pg_current_wal_lsn()::text AS lsn`)[0]?.lsn;
@@ -699,7 +751,7 @@ var A = (e) => {
 		}));
 	},
 	async probeReplicaPosition(e) {
-		let t = Y(e);
+		let t = J(e);
 		if (t === null) throw Error("postgresReplicationAdapter: replica is not a PostgresDataStore.");
 		return t.runEffect(i.gen(function* () {
 			let e = (yield* (yield* O)`
@@ -709,16 +761,16 @@ var A = (e) => {
 		}));
 	},
 	compare(e, t) {
-		return we(t, e) >= 0 ? "caught-up" : "behind";
+		return Ee(t, e) >= 0 ? "caught-up" : "behind";
 	}
-}), X = (e) => `"${e.replace(/"/g, "\"\"")}"`, Ee = (e) => e.replace(/\\/g, "\\\\").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\v/g, "\\v").replace(/\f/g, "\\f").replace(/[\b]/g, "\\b"), De = (e) => {
+}), X = (e) => `"${e.replace(/"/g, "\"\"")}"`, De = (e) => e.replace(/\\/g, "\\\\").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\v/g, "\\v").replace(/\f/g, "\\f").replace(/[\b]/g, "\\b"), Oe = (e) => {
 	let t = "";
 	for (let n of e) t += n.toString(16).padStart(2, "0");
 	return t;
-}, Z = (e) => `{${e.map((e) => e == null ? "NULL" : Array.isArray(e) ? Z(e) : typeof e == "number" || typeof e == "bigint" ? String(e) : typeof e == "boolean" ? e ? "t" : "f" : `"${(e instanceof Date ? e.toISOString() : String(e)).replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`).join(",")}}`, Q = (e, t) => e == null ? null : typeof e == "string" ? e : typeof e == "number" || typeof e == "bigint" ? String(e) : typeof e == "boolean" ? e ? "t" : "f" : e instanceof Date ? e.toISOString() : e instanceof Uint8Array ? `\\x${De(e)}` : Array.isArray(e) && t === "array" ? Z(e) : JSON.stringify(e), $ = (e, t, n = {}) => t.map((t) => {
+}, Z = (e) => `{${e.map((e) => e == null ? "NULL" : Array.isArray(e) ? Z(e) : typeof e == "number" || typeof e == "bigint" ? String(e) : typeof e == "boolean" ? e ? "t" : "f" : `"${(e instanceof Date ? e.toISOString() : String(e)).replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`).join(",")}}`, Q = (e, t) => e == null ? null : typeof e == "string" ? e : typeof e == "number" || typeof e == "bigint" ? String(e) : typeof e == "boolean" ? e ? "t" : "f" : e instanceof Date ? e.toISOString() : e instanceof Uint8Array ? `\\x${Oe(e)}` : Array.isArray(e) && t === "array" ? Z(e) : JSON.stringify(e), $ = (e, t, n = {}) => t.map((t) => {
 	let r = Q(e[t], n[t]);
-	return r === null ? "\\N" : Ee(r);
-}).join("	"), Oe = class {
+	return r === null ? "\\N" : De(r);
+}).join("	"), ke = class {
 	text;
 	chunks;
 	done;
@@ -749,7 +801,7 @@ var A = (e) => {
 	handleReadyForQuery() {
 		this.settle(void 0);
 	}
-}, ke = (e) => ({
+}, Ae = (e) => ({
 	...e.url ? { connectionString: e.url } : {
 		host: e.host ?? "localhost",
 		port: e.port ?? 5432,
@@ -758,9 +810,9 @@ var A = (e) => {
 		database: e.database ?? "postgres"
 	},
 	...e.ssl === !0 ? { ssl: { rejectUnauthorized: !1 } } : {}
-}), Ae = 65536, je = (e) => {
+}), je = 65536, Me = (e) => {
 	let t, n, r = () => t ? Promise.resolve(t) : (n ??= (async () => {
-		let n = new f.Client(ke(e));
+		let n = new p.Client(Ae(e));
 		return await n.connect(), t = n, n;
 	})(), n);
 	return {
@@ -768,9 +820,9 @@ var A = (e) => {
 		copyInto: async ({ table: e, columns: t, columnTypes: n, rows: i }) => {
 			if (i.length === 0) return 0;
 			let a = await r(), o = `COPY ${X(e)} (${t.map(X).join(", ")}) FROM STDIN`, s = [], c = "";
-			for (let e of i) c += $(e, t, n ?? {}), c += "\n", c.length >= Ae && (s.push(Buffer.from(c, "utf8")), c = "");
+			for (let e of i) c += $(e, t, n ?? {}), c += "\n", c.length >= je && (s.push(Buffer.from(c, "utf8")), c = "");
 			return c.length > 0 && s.push(Buffer.from(c, "utf8")), await new Promise((e, t) => {
-				let n = new Oe(o, s, (n, r) => {
+				let n = new ke(o, s, (n, r) => {
 					n ? t(n) : e(r);
 				});
 				a.query(n);
@@ -781,12 +833,12 @@ var A = (e) => {
 			t = void 0, n = void 0, e && await e.end().catch(() => void 0);
 		}
 	};
-}, Me = {
+}, Ne = {
 	id: "postgres",
 	makeSqlLayer: (e) => L(e),
-	makeStore: (e) => q(e),
+	makeStore: (e) => K(e),
 	compileContains: (e, t, n) => n`${e} ILIKE ${`%${t.replace(/[\\%_]/g, (e) => `\\${e}`)}%`} ESCAPE '\\'`,
-	retryFilter: B
+	retryFilter: z
 };
 //#endregion
-export { e as PgClient, I as connectionFromConfig, $ as encodeCopyRow, Q as encodeCopyValue, je as makePgCopySession, q as makePostgresDataStore, P as makePostgresSqlLayer, L as makePostgresSqlLayerFromConfig, Me as postgresDialect, Te as postgresReplicationAdapter, B as postgresRetryFilter };
+export { e as PgClient, I as connectionFromConfig, $ as encodeCopyRow, Q as encodeCopyValue, Me as makePgCopySession, K as makePostgresDataStore, P as makePostgresSqlLayer, L as makePostgresSqlLayerFromConfig, Ne as postgresDialect, Y as postgresReplicationAdapter, z as postgresRetryFilter };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voltro/sql-postgres",
-  "version": "0.43.1",
+  "version": "0.44.0",
   "description": "PostgreSQL dialect adapter for Voltro's cross-dialect DataStore (LISTEN/NOTIFY reactivity, logical-replication CDC).",
   "keywords": [
     "voltro",
@@ -35,8 +35,8 @@
   "dependencies": {
     "@effect/sql": "^0.52.0",
     "@effect/sql-pg": "^0.53.0",
-    "@voltro/database": "0.43.1",
-    "@voltro/logger": "0.43.1",
+    "@voltro/database": "0.44.0",
+    "@voltro/logger": "0.44.0",
     "pg": "^8.23.0"
   },
   "peerDependencies": {