prisma-pglite-bridge 1.0.0 → 1.2.0

package/dist/index.cjs

@@ -109,6 +109,38 @@ const EQP_MESSAGES = new Set([
 const MAX_BACKEND_MESSAGE_LENGTH = 1073741824;
 //#endregion
 //#region src/duplex/row-description.ts
+const readUInt32BE = (buf, offset) => {
+	/* c8 ignore start — callers guard fixed-width reads */
+	const b1 = buf[offset] ?? 0;
+	const b2 = buf[offset + 1] ?? 0;
+	const b3 = buf[offset + 2] ?? 0;
+	const b4 = buf[offset + 3] ?? 0;
+	/* c8 ignore stop */
+	return (b1 << 24 | b2 << 16 | b3 << 8 | b4) >>> 0;
+};
+const readUInt16BE = (buf, offset) => {
+	/* c8 ignore start — callers guard fixed-width reads */
+	const b1 = buf[offset] ?? 0;
+	const b2 = buf[offset + 1] ?? 0;
+	/* c8 ignore stop */
+	return b1 << 8 | b2;
+};
+const rowDescriptionNeedsRewrite = (buf, start = 0, end = buf.length) => {
+	if (end - start < 7) return false;
+	const fieldCount = readUInt16BE(buf, start + 5);
+	let p = start + 7;
+	for (let i = 0; i < fieldCount; i++) {
+		while (p < end && buf[p] !== 0) p++;
+		p++;
+		/* c8 ignore next — defense-in-depth: framer caller passes a complete frame */
+		if (p + 18 > end) return false;
+		const tableOID = readUInt32BE(buf, p);
+		p += 6;
+		if (readUInt32BE(buf, p) === 18 && tableOID !== 0 && tableOID < 16384) return true;
+		p += 12;
+	}
+	return false;
+};
 /**
 * Widens any field whose dataTypeOID is 18 ("char") to oid 25 (text) — but
 * only when the field originates from a pg_catalog relation (tableOID is
@@ -121,6 +153,7 @@ const MAX_BACKEND_MESSAGE_LENGTH = 1073741824;
 * fixed-size in place.
 */
 const rewriteRowDescriptionInPlace = (buf) => {
+	if (!rowDescriptionNeedsRewrite(buf)) return;
 	const fieldCount = buf.readInt16BE(5);
 	let p = 7;
 	for (let i = 0; i < fieldCount; i++) {
@@ -150,6 +183,7 @@ const rewriteRowDescriptionInPlace = (buf) => {
 */
 var BackendMessageFramer = class {
 	suppressIntermediateReadyForQuery;
+	rewriteSystemCatalogCharOids;
 	onChunk;
 	onErrorResponse;
 	onReadyForQuery;
@@ -165,6 +199,7 @@ var BackendMessageFramer = class {
 	rowDescOffset = 0;
 	constructor(options) {
 		this.suppressIntermediateReadyForQuery = options.suppressIntermediateReadyForQuery ?? false;
+		this.rewriteSystemCatalogCharOids = options.rewriteSystemCatalogCharOids ?? true;
 		this.onChunk = options.onChunk;
 		this.onErrorResponse = options.onErrorResponse;
 		this.onReadyForQuery = options.onReadyForQuery;
@@ -198,7 +233,7 @@ var BackendMessageFramer = class {
 						if (msgType === 69) this.onErrorResponse?.();
 						if (msgType === 90 && messageLength === 5) {
 							flushPassthrough(offset);
-							if (this.suppressIntermediateReadyForQuery && this.rfqBytesRead === 6) this.dropHeldReadyForQuery();
+							this.dropStaleHeldReadyForQuery();
 							/* c8 ignore next — messageLength === 5 for RFQ; payload is 1 byte */
 							const status = chunk[offset + 5] ?? 0;
 							this.heldRfq[0] = msgType;
@@ -213,12 +248,12 @@ var BackendMessageFramer = class {
 								this.emitReadyForQuery();
 								this.rfqBytesRead = 0;
 							}
-						} else if (msgType === 84) {
+						} else if (msgType === 84 && this.rewriteSystemCatalogCharOids && rowDescriptionNeedsRewrite(chunk, offset, offset + totalLen)) {
 							flushPassthrough(offset);
-							if (this.suppressIntermediateReadyForQuery && this.rfqBytesRead === 6) this.dropHeldReadyForQuery();
+							this.dropStaleHeldReadyForQuery();
 							this.emitRewrittenRowDescription(Buffer.from(chunk.subarray(offset, offset + totalLen)));
 						} else {
-							if (this.suppressIntermediateReadyForQuery && this.rfqBytesRead === 6) this.dropHeldReadyForQuery();
+							this.dropStaleHeldReadyForQuery();
 							if (passthroughStart < 0) passthroughStart = offset;
 						}
 						offset += totalLen;
@@ -226,7 +261,7 @@ var BackendMessageFramer = class {
 					}
 				}
 				flushPassthrough(offset);
-				if (this.suppressIntermediateReadyForQuery && this.rfqBytesRead === 6) this.dropHeldReadyForQuery();
+				this.dropStaleHeldReadyForQuery();
 				/* c8 ignore next — offset < chunk.length guaranteed by outer while */
 				this.messageType = chunk[offset] ?? 0;
 				this.headerBytesRead = 0;
@@ -260,7 +295,7 @@ var BackendMessageFramer = class {
 				if (this.messageType === 69) this.onErrorResponse?.();
 				if (this.isReadyForQueryFrame()) continue;
 				this.dropHeldReadyForQuery();
-				if (this.messageType === 84) {
+				if (this.messageType === 84 && this.rewriteSystemCatalogCharOids) {
 					this.rowDescBuffer = Buffer.alloc(5 + this.payloadBytesRemaining);
 					this.rowDescBuffer[0] = 84;
 					this.rowDescBuffer.set(this.headerScratch, 1);
@@ -310,14 +345,6 @@ var BackendMessageFramer = class {
 			this.rfqBytesRead = 0;
 		}
 	}
-	reset() {
-		this.messageType = void 0;
-		this.headerBytesRead = 0;
-		this.payloadBytesRemaining = 0;
-		this.rfqBytesRead = 0;
-		this.rowDescBuffer = void 0;
-		this.rowDescOffset = 0;
-	}
 	isReadyForQueryFrame() {
 		return this.messageType === 90 && this.payloadBytesRemaining === 1;
 	}
@@ -334,6 +361,11 @@ var BackendMessageFramer = class {
 	dropHeldReadyForQuery() {
 		this.rfqBytesRead = 0;
 	}
+	/** Drop a complete held RFQ once a following frame proves it was an
+	*  intermediate one. No-op unless suppressing and a full RFQ is buffered. */
+	dropStaleHeldReadyForQuery() {
+		if (this.suppressIntermediateReadyForQuery && this.rfqBytesRead === 6) this.dropHeldReadyForQuery();
+	}
 	emitPrefix() {
 		const prefix = new Uint8Array(5);
 		/* c8 ignore next — messageType always set when emitPrefix is called */
@@ -502,6 +534,15 @@ var FrontendMessageBuffer = class {
 * after each sub-message (PGlite's single-user mode). These are stripped,
 * keeping only the final ReadyForQuery after Sync.
 */
+const TERMINATE_MESSAGE = new Uint8Array([
+	88,
+	0,
+	0,
+	0,
+	4
+]);
+const PROTOCOL_CLEANUP_RAW_BYTES = 8 * 1024 * 1024;
+const PROTOCOL_CLEANUP_CALLS = 32;
 /**
 * Duplex stream that bridges `pg.Client` to an in-process PGlite instance.
 *
@@ -529,6 +570,7 @@ var PGliteDuplex = class extends node_stream.Duplex {
 	bridgeId;
 	telemetry;
 	syncToFs;
+	rewriteSystemCatalogCharOids;
 	timeout;
 	duplexId;
 	/** Incoming bytes framed directly from a queued chunk buffer */
@@ -553,6 +595,9 @@ var PGliteDuplex = class extends node_stream.Duplex {
 	/** Memoized rollback so concurrent teardown paths (e.g., `_final` then
 	*  `_destroy`) don't issue duplicate `ROLLBACK` statements. */
 	rollbackPromise;
+	pendingProtocolCleanupBytes = 0;
+	pendingProtocolCleanupCalls = 0;
+	protocolCleanupUnsupported = false;
 	/** Resolves once the stream has fully torn down (post-`_final` rollback,
 	*  post-`_destroy`). Single-shot, mirroring the `'close'` event. */
 	onClose;
@@ -568,6 +613,7 @@ var PGliteDuplex = class extends node_stream.Duplex {
 		this.telemetry = options.telemetry;
 		this.timeout = options.timeout;
 		this.syncToFs = options.syncToFs ?? true;
+		this.rewriteSystemCatalogCharOids = options.rewriteSystemCatalogCharOids ?? true;
 		this.duplexId = Symbol("duplex");
 		this.onClose = new Promise((resolve) => this.once("close", () => resolve()));
 	}
@@ -673,9 +719,7 @@ var PGliteDuplex = class extends node_stream.Duplex {
 		/* c8 ignore next — len === undefined unreachable once length ≥ 4 */
 		if (len === void 0 || this.input.length < len) return;
 		const message = this.input.consume(len);
-		const session = this.acquireSession();
-		if (session) await session;
-		await this.runUnderRunExclusive(async () => {
+		await this.runUntimed(async () => {
 			await this.streamProtocol(message, {
 				detectErrors: false,
 				suppressIntermediateRfq: false
@@ -709,6 +753,13 @@ var PGliteDuplex = class extends node_stream.Duplex {
 			}
 		});
 	}
+	/** Acquire the session, then run `op` under runExclusive without timing —
+	*  the untimed path shared by startup and the no-telemetry query branch. */
+	async runUntimed(op) {
+		const session = this.acquireSession();
+		if (session) await session;
+		await this.runUnderRunExclusive(op);
+	}
 	/**
 	* Frames and processes regular wire protocol messages.
 	*
@@ -766,20 +817,38 @@ var PGliteDuplex = class extends node_stream.Duplex {
 		let batch;
 		/* c8 ignore next 3 — flushPipeline only runs after Sync is appended */
 		if (messages.length === 1) batch = messages[0] ?? new Uint8Array(0);
-		else {
-			const total = messages.reduce((sum, p) => sum + p.length, 0);
-			batch = new Uint8Array(total);
-			let offset = 0;
-			for (const part of messages) {
-				batch.set(part, offset);
-				offset += part.length;
-			}
-		}
+		else batch = this.tryContiguousPipelineBatch(messages) ?? this.concatPipeline(messages);
 		await this.runWithTiming((detectErrors) => this.streamProtocol(batch, {
 			detectErrors,
 			suppressIntermediateRfq: true
 		}));
 	}
+	tryContiguousPipelineBatch(messages) {
+		const first = messages[0];
+		/* c8 ignore next — caller only passes non-empty pipelines */
+		if (first === void 0) return void 0;
+		const buffer = first.buffer;
+		const start = first.byteOffset;
+		let end = start + first.byteLength;
+		for (let i = 1; i < messages.length; i++) {
+			const part = messages[i];
+			/* c8 ignore next — pipeline array has no holes */
+			if (part === void 0) return void 0;
+			if (part.buffer !== buffer || part.byteOffset !== end) return;
+			end += part.byteLength;
+		}
+		return new Uint8Array(buffer, start, end - start);
+	}
+	concatPipeline(messages) {
+		const total = messages.reduce((sum, p) => sum + p.length, 0);
+		const batch = new Uint8Array(total);
+		let offset = 0;
+		for (const part of messages) {
+			batch.set(part, offset);
+			offset += part.length;
+		}
+		return batch;
+	}
 	/**
 	* Acquires the session, runs the op under `pglite.runExclusive`, and
 	* updates internal stats and/or publishes diagnostics events when enabled.
@@ -799,9 +868,7 @@ var PGliteDuplex = class extends node_stream.Duplex {
 		const wantTiming = wantTelemetry || publishQuery || publishLockWait;
 		const detectErrors = wantTelemetry || publishQuery;
 		if (!wantTiming) {
-			const session = this.acquireSession();
-			if (session) await session;
-			await this.runUnderRunExclusive(async () => {
+			await this.runUntimed(async () => {
 				await op(false);
 			});
 			return;
@@ -835,10 +902,8 @@ var PGliteDuplex = class extends node_stream.Duplex {
 		}
 	}
 	/**
-	* Sends a message (or pipelined batch) to PGlite and pushes response
-	* chunks directly to the stream as they arrive. Avoids collecting and
-	* concatenating for large multi-row responses (e.g., findMany 500 rows
-	* = ~503 onRawData chunks).
+	* Sends a message (or pipelined batch) to PGlite and pushes the raw protocol
+	* response to the stream.
 	*
 	* For pipelined Extended Query batches, pass `suppressIntermediateRfq`
 	* so only the final ReadyForQuery reaches the client.
@@ -850,6 +915,7 @@ var PGliteDuplex = class extends node_stream.Duplex {
 		let errSeen = false;
 		const framer = new BackendMessageFramer({
 			suppressIntermediateReadyForQuery: suppressIntermediateRfq,
+			rewriteSystemCatalogCharOids: this.rewriteSystemCatalogCharOids,
 			onChunk: (chunk) => {
 				/* c8 ignore next — race-only: tornDown becomes true mid-stream */
 				if (!this.tornDown && chunk.length > 0) this.push(chunk);
@@ -863,15 +929,47 @@ var PGliteDuplex = class extends node_stream.Duplex {
 			}
 		});
 		await waitPGliteReady(this.pglite, this.timeout);
-		await this.pglite.execProtocolRawStream(message, {
-			syncToFs: this.syncToFs,
-			onRawData: (chunk) => {
-				framer.write(chunk);
+		let rawBytes = 0;
+		let streamFailed = false;
+		try {
+			await this.pglite.execProtocolRawStream(message, {
+				syncToFs: this.syncToFs,
+				onRawData: (chunk) => {
+					rawBytes += chunk.byteLength;
+					framer.write(chunk);
+				}
+			});
+		} catch (err) {
+			streamFailed = true;
+			throw err;
+		} finally {
+			this.pendingProtocolCleanupBytes += rawBytes;
+			this.pendingProtocolCleanupCalls++;
+			if (!this.protocolCleanupUnsupported && (streamFailed || this.pendingProtocolCleanupBytes >= PROTOCOL_CLEANUP_RAW_BYTES || this.pendingProtocolCleanupCalls >= PROTOCOL_CLEANUP_CALLS)) {
+				await this.clearPGliteProtocolMessages();
+				this.pendingProtocolCleanupBytes = 0;
+				this.pendingProtocolCleanupCalls = 0;
 			}
-		});
+		}
 		framer.flush({ dropHeldReadyForQuery: this.tornDown });
 		return !errSeen;
 	}
+	async clearPGliteProtocolMessages() {
+		if (this.protocolCleanupUnsupported) return;
+		const { execProtocolStream } = this.pglite;
+		if (typeof execProtocolStream !== "function") {
+			this.protocolCleanupUnsupported = true;
+			return;
+		}
+		try {
+			await execProtocolStream.call(this.pglite, TERMINATE_MESSAGE, {
+				syncToFs: false,
+				throwOnError: false
+			});
+		} catch {
+			this.protocolCleanupUnsupported = true;
+		}
+	}
 	acquireSession() {
 		return this.sessionLock?.acquire(this.duplexId);
 	}
@@ -1022,17 +1120,12 @@ var SessionLock = class {
 		this.waitQueue = remaining;
 		return cancelled;
 	}
-	/**
-	* Grant ownership to the next waiter, if any.
-	*
-	* @returns `true` if a waiter was unblocked; `false` if the queue was empty.
-	*/
+	/** Grant ownership to the next waiter, if any. */
 	drainWaitQueue() {
 		const next = this.waitQueue.shift();
-		if (!next) return false;
+		if (!next) return;
 		this.owner = next.id;
 		next.resolve();
-		return true;
 	}
 };
 //#endregion
@@ -1109,7 +1202,7 @@ const wrapTypesWithFastArrayParsers = (types) => {
 //#endregion
 //#region src/pool/pg-bridge-client.ts
 var PgBridgeClient = class PgBridgeClient extends pg.default.Client {
-	querySubmissionChain = Promise.resolve();
+	querySubmissionChain;
 	static OptionsKey = Symbol("PgBridgeClientOptions");
 	constructor(config) {
 		const { [PgBridgeClient.OptionsKey]: bridge, ...clientConfig } = config ?? {};
@@ -1123,33 +1216,41 @@ var PgBridgeClient = class PgBridgeClient extends pg.default.Client {
 	}
 	query(...args) {
 		const first = args[0];
-		const callSuper = () => super.query.apply(this, args);
-		if (first === null || first === void 0) return callSuper();
-		if (typeof first.submit === "function") return callSuper();
-		if (isObject(first) && isTypesLike(first.types)) args[0] = {
-			...first,
-			types: wrapTypesWithFastArrayParsers(first.types)
+		const submit = () => {
+			return super.query.apply(this, args);
 		};
-		const prior = this.querySubmissionChain;
-		let signalDone;
-		this.querySubmissionChain = new Promise((resolve) => {
-			signalDone = resolve;
-		});
+		if (first === null || first === void 0) return submit();
+		if (typeof first.submit === "function") return submit();
 		const cbIndex = args.findIndex((arg) => typeof arg === "function");
 		if (cbIndex !== -1) {
 			const origCb = args[cbIndex];
-			args[cbIndex] = (err, res) => {
-				signalDone();
-				origCb(err, res);
-			};
-			prior.then(callSuper).catch((err) => {
-				signalDone();
+			const promiseArgs = args.slice();
+			promiseArgs.splice(cbIndex, 1);
+			try {
+				this.query(...promiseArgs).then((res) => origCb(null, res), (err) => origCb(err, void 0));
+			} catch (err) {
 				origCb(err, void 0);
-			});
+			}
 			return;
 		}
-		const p = prior.then(callSuper);
-		p.then(signalDone, signalDone);
+		if (isObject(first) && isTypesLike(first.types)) args[0] = {
+			...first,
+			types: wrapTypesWithFastArrayParsers(first.types)
+		};
+		const prior = this.querySubmissionChain;
+		let p;
+		if (prior === void 0) try {
+			p = submit();
+		} catch (err) {
+			return Promise.reject(err);
+		}
+		else p = prior.then(submit);
+		let done;
+		const clearChain = () => {
+			if (this.querySubmissionChain === done) this.querySubmissionChain = void 0;
+		};
+		done = p.then(clearChain, clearChain);
+		this.querySubmissionChain = done;
 		return p;
 	}
 };
@@ -1243,16 +1344,7 @@ var PgBridgePool = class extends pg.default.Pool {
 		return super.end().then(cleanup);
 	}
 };
-//#endregion
-//#region src/telemetry/bridge-stats.ts
-/**
-* Maximum number of recent query durations retained for percentile
-* computation. Beyond this window, `recentP50QueryMs`, `recentP95QueryMs`,
-* and `recentMaxQueryMs` reflect only the most recent N queries — lifetime
-* counters (`queryCount`, `totalQueryMs`, `avgQueryMs`) remain complete.
-*/
-const QUERY_DURATION_WINDOW_SIZE = 1e4;
-const QUERY_DURATION_TRIM_THRESHOLD = QUERY_DURATION_WINDOW_SIZE * 2;
+const QUERY_DURATION_TRIM_THRESHOLD = 1e4 * 2;
 const DB_SIZE_QUERY_TIMEOUT_MS = 5e3;
 /**
 * `process.resourceUsage().maxRSS` returns kilobytes on every platform
@@ -1297,7 +1389,7 @@ var BridgeStats = class {
 		this.queryCount += 1;
 		this.totalQueryMs += durationMs;
 		this.queryDurations.push(durationMs);
-		if (this.queryDurations.length > QUERY_DURATION_TRIM_THRESHOLD) this.queryDurations = this.queryDurations.slice(-QUERY_DURATION_WINDOW_SIZE);
+		if (this.queryDurations.length > QUERY_DURATION_TRIM_THRESHOLD) this.queryDurations = this.queryDurations.slice(-1e4);
 		if (!succeeded) this.failedQueryCount += 1;
 	}
 	recordLockWait(durationMs) {
@@ -1373,15 +1465,18 @@ var BridgeStats = class {
 	}
 };
 //#endregion
+//#region src/utils/quote-ident.ts
+/** JS equivalent of PostgreSQL's `quote_ident()`; matches its escaping rules. */
+const quoteIdent = (identifier) => `"${identifier.replace(/"/g, "\"\"")}"`;
+//#endregion
 //#region src/pglite-bridge/snapshot-manager.ts
 const SNAPSHOT_SCHEMA = "_pglite_snapshot";
-const USER_TABLES_WHERE = `schemaname NOT IN ('pg_catalog', 'information_schema')
-       AND schemaname != '${SNAPSHOT_SCHEMA}'
+const SYSTEM_SCHEMA_EXCLUSION = `schemaname NOT IN ('pg_catalog', 'information_schema')
+       AND schemaname != '${SNAPSHOT_SCHEMA}'`;
+const USER_TABLES_WHERE = `${SYSTEM_SCHEMA_EXCLUSION}
        AND tablename NOT LIKE '_prisma%'`;
 const escapeLiteral = (s) => `'${s.replace(/'/g, "''")}'`;
-/** JS equivalent of PostgreSQL's `quote_ident()`; matches its escaping rules. */
-const quoteIdent$1 = (identifier) => `"${identifier.replace(/"/g, "\"\"")}"`;
-const SNAPSHOT_SCHEMA_IDENT = quoteIdent$1(SNAPSHOT_SCHEMA);
+const SNAPSHOT_SCHEMA_IDENT = quoteIdent(SNAPSHOT_SCHEMA);
 const SNAPSHOT_SCHEMA_LITERAL = escapeLiteral(SNAPSHOT_SCHEMA);
 /**
 * Snapshot helpers backing `PGliteBridge`'s `snapshotDb` / `resetDb` /
@@ -1402,32 +1497,30 @@ var SnapshotManager = class {
 	* the `_pglite_snapshot` schema. Replaces any previous snapshot.
 	*/
 	async snapshotDb() {
-		const pglite = this.#pglite;
-		await pglite.exec(`DROP SCHEMA IF EXISTS ${SNAPSHOT_SCHEMA_IDENT} CASCADE`);
+		await this.#pglite.exec(`DROP SCHEMA IF EXISTS ${SNAPSHOT_SCHEMA_IDENT} CASCADE`);
 		try {
-			await pglite.exec("BEGIN");
-			await pglite.exec(`CREATE SCHEMA ${SNAPSHOT_SCHEMA_IDENT}`);
-			const { rows: tables } = await pglite.query(`SELECT schemaname, tablename,
+			await this.#pglite.exec("BEGIN");
+			await this.#pglite.exec(`CREATE SCHEMA ${SNAPSHOT_SCHEMA_IDENT}`);
+			const { rows: tables } = await this.#pglite.query(`SELECT schemaname, tablename,
                 quote_ident(schemaname) || '.' || quote_ident(tablename) AS qualified
          FROM pg_tables
          WHERE ${USER_TABLES_WHERE}`);
-			await pglite.exec(`CREATE TABLE ${SNAPSHOT_SCHEMA_IDENT}.__tables (snap_name text, source_schema text, source_table text)`);
+			await this.#pglite.exec(`CREATE TABLE ${SNAPSHOT_SCHEMA_IDENT}.__tables (snap_name text, source_schema text, source_table text)`);
 			for (const [i, { schemaname, tablename, qualified }] of tables.entries()) {
 				const snapName = `_snap_${i}`;
-				await pglite.exec(`CREATE TABLE ${SNAPSHOT_SCHEMA_IDENT}.${quoteIdent$1(snapName)} AS SELECT * FROM ${qualified}`);
-				await pglite.exec(`INSERT INTO ${SNAPSHOT_SCHEMA_IDENT}.__tables VALUES (${escapeLiteral(snapName)}, ${escapeLiteral(schemaname)}, ${escapeLiteral(tablename)})`);
+				await this.#pglite.exec(`CREATE TABLE ${SNAPSHOT_SCHEMA_IDENT}.${quoteIdent(snapName)} AS SELECT * FROM ${qualified}`);
+				await this.#pglite.exec(`INSERT INTO ${SNAPSHOT_SCHEMA_IDENT}.__tables VALUES (${escapeLiteral(snapName)}, ${escapeLiteral(schemaname)}, ${escapeLiteral(tablename)})`);
 			}
-			const { rows: seqs } = await pglite.query(`SELECT quote_literal(quote_ident(schemaname) || '.' || quote_ident(sequencename)) AS name, last_value::text AS value
+			const { rows: seqs } = await this.#pglite.query(`SELECT quote_literal(quote_ident(schemaname) || '.' || quote_ident(sequencename)) AS name, last_value::text AS value
          FROM pg_sequences
-         WHERE schemaname NOT IN ('pg_catalog', 'information_schema')
-         AND schemaname != '${SNAPSHOT_SCHEMA}'
+         WHERE ${SYSTEM_SCHEMA_EXCLUSION}
          AND last_value IS NOT NULL`);
-			await pglite.exec(`CREATE TABLE ${SNAPSHOT_SCHEMA_IDENT}.__sequences (name text, value bigint)`);
-			for (const { name, value } of seqs) await pglite.exec(`INSERT INTO ${SNAPSHOT_SCHEMA_IDENT}.__sequences VALUES (${name}, ${value})`);
-			await pglite.exec("COMMIT");
+			await this.#pglite.exec(`CREATE TABLE ${SNAPSHOT_SCHEMA_IDENT}.__sequences (name text, value bigint)`);
+			for (const { name, value } of seqs) await this.#pglite.exec(`INSERT INTO ${SNAPSHOT_SCHEMA_IDENT}.__sequences VALUES (${name}, ${value})`);
+			await this.#pglite.exec("COMMIT");
 		} catch (err) {
-			await pglite.exec("ROLLBACK");
-			await pglite.exec(`DROP SCHEMA IF EXISTS ${SNAPSHOT_SCHEMA_IDENT} CASCADE`);
+			await this.#pglite.exec("ROLLBACK");
+			await this.#pglite.exec(`DROP SCHEMA IF EXISTS ${SNAPSHOT_SCHEMA_IDENT} CASCADE`);
 			throw err;
 		}
 		this.#hasSnapshot = true;
@@ -1442,26 +1535,25 @@ var SnapshotManager = class {
 	* sequence values afterwards; otherwise just truncate and `DISCARD ALL`.
 	*/
 	async resetDb() {
-		const pglite = this.#pglite;
 		if (this.#hasSnapshot) await this.#snapshotSchemaExists();
 		const tables = await this.#getTables();
 		if (tables) await this.#withReplicationRoleReplica(async () => {
-			await pglite.exec(`TRUNCATE TABLE ${tables} RESTART IDENTITY CASCADE`);
+			await this.#pglite.exec(`TRUNCATE TABLE ${tables} RESTART IDENTITY CASCADE`);
 			if (!this.#hasSnapshot) return;
-			const { rows: snapshotTables } = await pglite.query(`SELECT quote_ident(snap_name) AS snap_name_ident,
+			const { rows: snapshotTables } = await this.#pglite.query(`SELECT quote_ident(snap_name) AS snap_name_ident,
                   quote_ident(source_schema) || '.' || quote_ident(source_table) AS qualified
            FROM ${SNAPSHOT_SCHEMA_IDENT}.__tables`);
-			for (const { snap_name_ident, qualified } of snapshotTables) await pglite.exec(`INSERT INTO ${qualified} SELECT * FROM ${SNAPSHOT_SCHEMA_IDENT}.${snap_name_ident}`);
-			const { rows: seqs } = await pglite.query(`SELECT quote_literal(name) AS name, value::text AS value FROM ${SNAPSHOT_SCHEMA_IDENT}.__sequences`);
-			for (const { name, value } of seqs) await pglite.exec(`SELECT setval(${name}, ${value})`);
+			for (const { snap_name_ident, qualified } of snapshotTables) await this.#pglite.exec(`INSERT INTO ${qualified} SELECT * FROM ${SNAPSHOT_SCHEMA_IDENT}.${snap_name_ident}`);
+			const { rows: seqs } = await this.#pglite.query(`SELECT quote_literal(name) AS name, value::text AS value FROM ${SNAPSHOT_SCHEMA_IDENT}.__sequences`);
+			for (const { name, value } of seqs) await this.#pglite.exec(`SELECT setval(${name}, ${value})`);
 		});
-		await pglite.exec("DISCARD ALL");
+		await this.#pglite.exec("DISCARD ALL");
 	}
 	async #getTables() {
 		const { rows } = await this.#pglite.query(`SELECT quote_ident(schemaname) || '.' || quote_ident(tablename) AS qualified
        FROM pg_tables
        WHERE ${USER_TABLES_WHERE}`);
-		return rows.length > 0 ? rows.map((row) => row.qualified).join(", ") : "";
+		return rows.map((row) => row.qualified).join(", ");
 	}
 	/**
 	* Self-heal: someone (e.g. `resetSchema`) may drop `_pglite_snapshot`
@@ -1760,7 +1852,8 @@ var PGliteServer = class {
 		socket.duplex = new PGliteDuplex(this.pglite, {
 			sessionLock: this.#sessionLock,
 			timeout: this.#options.timeout,
-			syncToFs: resolveSyncToFs(this.pglite, this.#options.syncToFs)
+			syncToFs: resolveSyncToFs(this.pglite, this.#options.syncToFs),
+			rewriteSystemCatalogCharOids: false
 		});
 		socket.duplex.on("error", () => socket.destroy());
 		socket.once("close", () => {
@@ -1806,16 +1899,43 @@ var PGliteServer = class {
 	}
 };
 //#endregion
+//#region src/schema/pg18-not-null.ts
+const ENGINE_DENYLIST = "contype NOT IN ('p', 'u', 'f')";
+const PATCHED_DENYLIST = "contype NOT IN ('p', 'u', 'f', 'n')";
+const rewritePg18ConstraintsSql = (sql) => {
+	if (!sql.includes("pg_constraint") || !sql.includes(ENGINE_DENYLIST)) return sql;
+	return sql.replace(ENGINE_DENYLIST, PATCHED_DENYLIST);
+};
+/**
+* Proxies (rather than spreads) so class-based adapters keep working: every
+* untouched member is delegated with `this` bound to the original instance,
+* and members added in future @prisma/driver-adapter-utils versions pass
+* through without changes here.
+*/
+const wrapAdapter = (adapter) => new Proxy(adapter, { get(target, prop) {
+	if (prop === "queryRaw") return (query) => target.queryRaw({
+		...query,
+		sql: rewritePg18ConstraintsSql(query.sql)
+	});
+	const value = Reflect.get(target, prop);
+	return typeof value === "function" ? value.bind(target) : value;
+} });
+const wrapFactoryForPg18 = (factory) => new Proxy(factory, { get(target, prop) {
+	if (prop === "connect") return async () => wrapAdapter(await target.connect());
+	if (prop === "connectToShadowDb") return async () => wrapAdapter(await target.connectToShadowDb());
+	const value = Reflect.get(target, prop);
+	return typeof value === "function" ? value.bind(target) : value;
+} });
+//#endregion
 //#region src/schema/index.ts
 const bindAdapter = async (adapter) => {
 	const { bindMigrationAwareSqlAdapterFactory } = await import("@prisma/driver-adapter-utils");
-	return bindMigrationAwareSqlAdapterFactory(adapter);
+	return bindMigrationAwareSqlAdapterFactory(wrapFactoryForPg18(adapter));
 };
 const emptyFilter = () => ({
 	externalTables: [],
 	externalEnums: []
 });
-const quoteIdent = (name) => `"${name.replace(/"/g, "\"\"")}"`;
 /**
 * Drop every non-system schema (and recreate `public`). Issued as raw SQL
 * through the adapter rather than `engine.reset(...)` because the engine only
@@ -1995,7 +2115,7 @@ const hasMigrations = async (pglite) => {
 	const { rows } = await pglite.query(`SELECT to_regclass('public._prisma_migrations') IS NOT NULL AS exists`);
 	if (!rows[0]?.exists) return false;
 	const { rows: applied } = await pglite.query(`SELECT count(*)::int AS count FROM _prisma_migrations WHERE finished_at IS NOT NULL`);
-	return applied[0].count > 0;
+	return (applied[0]?.count ?? 0) > 0;
 };
 /**
 * Returns `true` when the `public` schema contains at least one user table.