prisma-pglite-bridge 0.3.0 → 0.3.2

package/dist/index.mjs

@@ -0,0 +1,653 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { PrismaPg } from "@prisma/adapter-pg";
+import { PGlite } from "@electric-sql/pglite";
+import pg from "pg";
+import { Duplex } from "node:stream";
+//#region src/session-lock.ts
+/**
+* Session-level lock for PGlite's single-session model.
+*
+* PGlite runs PostgreSQL in single-user mode — one session shared by all
+* bridges. runExclusive serializes individual operations, but transactions
+* span multiple operations. Without session-level locking, Bridge A's BEGIN
+* and Bridge B's query interleave, corrupting transaction boundaries.
+*
+* The session lock tracks which bridge owns the session. When PGlite enters
+* transaction state (ReadyForQuery status 'T' or 'E'), the owning bridge
+* gets exclusive access until the transaction completes (status returns to 'I').
+*
+* Non-transactional operations from any bridge are allowed when no transaction
+* is active — they serialize naturally through runExclusive.
+*/
+const STATUS_IDLE = 73;
+const STATUS_IN_TRANSACTION = 84;
+const STATUS_FAILED = 69;
+const createBridgeId = () => Symbol("bridge");
+/**
+* Extracts the ReadyForQuery status byte from a response buffer.
+* Scans from the end since RFQ is always the last message.
+* Returns null if no RFQ found.
+*/
+const extractRfqStatus = (response) => {
+	if (response.length < 6) return null;
+	const i = response.length - 6;
+	if (response[i] === 90 && response[i + 1] === 0 && response[i + 2] === 0 && response[i + 3] === 0 && response[i + 4] === 5) return response[i + 5] ?? null;
+	return null;
+};
+var SessionLock = class {
+	owner = null;
+	waitQueue = [];
+	/**
+	* Acquire access to PGlite. Resolves immediately if no transaction is
+	* active or if this bridge owns the current transaction. Queues otherwise.
+	*/
+	async acquire(id) {
+		if (this.owner === null || this.owner === id) return;
+		return new Promise((resolve) => {
+			this.waitQueue.push({
+				id,
+				resolve
+			});
+		});
+	}
+	/**
+	* Update session state based on the ReadyForQuery status byte.
+	* Call after every PGlite response that contains RFQ.
+	*/
+	updateStatus(id, status) {
+		if (status === STATUS_IN_TRANSACTION || status === STATUS_FAILED) this.owner = id;
+		else if (status === STATUS_IDLE) {
+			if (this.owner === id) {
+				this.owner = null;
+				this.drainWaitQueue();
+			}
+		}
+	}
+	/**
+	* Release ownership (e.g., when a bridge is destroyed mid-transaction).
+	*/
+	release(id) {
+		if (this.owner === id) {
+			this.owner = null;
+			this.drainWaitQueue();
+		}
+	}
+	drainWaitQueue() {
+		const waiters = this.waitQueue;
+		this.waitQueue = [];
+		for (const waiter of waiters) waiter.resolve();
+	}
+};
+//#endregion
+//#region src/pglite-bridge.ts
+/**
+* PGlite bridge stream.
+*
+* A Duplex stream that replaces the TCP socket in pg.Client, routing
+* wire protocol messages directly to an in-process PGlite instance.
+*
+* pg.Client writes wire protocol bytes → bridge frames messages →
+* PGlite processes via execProtocolRawStream → bridge pushes responses back.
+*
+* Extended Query Protocol pipelines (Parse→Bind→Describe→Execute→Sync) are
+* concatenated into a single buffer and sent as one atomic execProtocolRawStream
+* call within one runExclusive. This prevents portal interleaving between
+* concurrent bridges AND reduces async overhead (1 WASM call instead of 5).
+*
+* The response from a batched pipeline contains spurious ReadyForQuery messages
+* after each sub-message (PGlite's single-user mode). These are stripped,
+* keeping only the final ReadyForQuery after Sync.
+*/
+const PARSE = 80;
+const BIND = 66;
+const DESCRIBE = 68;
+const EXECUTE = 69;
+const CLOSE = 67;
+const FLUSH = 72;
+const SYNC = 83;
+const TERMINATE = 88;
+const READY_FOR_QUERY = 90;
+const EQP_MESSAGES = new Set([
+	PARSE,
+	BIND,
+	DESCRIBE,
+	EXECUTE,
+	CLOSE,
+	FLUSH
+]);
+/**
+* Strips all intermediate ReadyForQuery messages from a response, keeping
+* only the last one. PGlite's single-user mode emits RFQ after every
+* sub-message; pg.Client expects exactly one after Sync.
+*
+* Operates in-place on the response by building a list of byte ranges to
+* keep, then assembling the result. Returns the original buffer (no copy)
+* if there are 0 or 1 RFQ messages.
+*/
+/** @internal — exported for testing only */
+const stripIntermediateReadyForQuery = (response) => {
+	const rfqPositions = [];
+	let offset = 0;
+	while (offset < response.length) {
+		if (offset + 5 >= response.length) break;
+		if (response[offset] === READY_FOR_QUERY && response[offset + 1] === 0 && response[offset + 2] === 0 && response[offset + 3] === 0 && response[offset + 4] === 5) {
+			rfqPositions.push(offset);
+			offset += 6;
+		} else {
+			const b1 = response[offset + 1];
+			const b2 = response[offset + 2];
+			const b3 = response[offset + 3];
+			const b4 = response[offset + 4];
+			if (b1 === void 0 || b2 === void 0 || b3 === void 0 || b4 === void 0) break;
+			const msgLen = (b1 << 24 | b2 << 16 | b3 << 8 | b4) >>> 0;
+			if (msgLen < 4) break;
+			offset += 1 + msgLen;
+		}
+	}
+	if (rfqPositions.length <= 1) return response;
+	const removeCount = rfqPositions.length - 1;
+	const resultLen = response.length - removeCount * 6;
+	const result = new Uint8Array(resultLen);
+	let src = 0;
+	let dst = 0;
+	let removeIdx = 0;
+	while (src < response.length) {
+		const nextRemove = removeIdx < removeCount ? rfqPositions[removeIdx] ?? response.length : response.length;
+		if (src < nextRemove) {
+			const copyLen = nextRemove - src;
+			result.set(response.subarray(src, src + copyLen), dst);
+			dst += copyLen;
+			src += copyLen;
+		}
+		if (removeIdx < removeCount && src === rfqPositions[removeIdx]) {
+			src += 6;
+			removeIdx++;
+		}
+	}
+	return result;
+};
+/**
+* Concatenates multiple Uint8Array views into one contiguous buffer.
+*/
+const concat = (parts) => {
+	if (parts.length === 1) return parts[0] ?? new Uint8Array(0);
+	const total = parts.reduce((sum, p) => sum + p.length, 0);
+	const result = new Uint8Array(total);
+	let offset = 0;
+	for (const part of parts) {
+		result.set(part, offset);
+		offset += part.length;
+	}
+	return result;
+};
+/**
+* Duplex stream that bridges `pg.Client` to an in-process PGlite instance.
+*
+* Replaces the TCP socket in `pg.Client` via the `stream` option. Speaks
+* PostgreSQL wire protocol directly to PGlite — no TCP, no serialization
+* overhead beyond what the wire protocol requires.
+*
+* Pass to `pg.Client` or use via `createPool()` / `createPgliteAdapter()`:
+*
+* ```typescript
+* const client = new pg.Client({
+*   stream: () => new PGliteBridge(pglite),
+* });
+* ```
+*/
+var PGliteBridge = class extends Duplex {
+	pglite;
+	sessionLock;
+	bridgeId;
+	/** Incoming bytes not yet compacted into buf */
+	pending = [];
+	pendingLen = 0;
+	/** Compacted input buffer for message framing */
+	buf = Buffer.alloc(0);
+	phase = "pre_startup";
+	draining = false;
+	tornDown = false;
+	/** Callbacks waiting for drain to process their data */
+	drainQueue = [];
+	/** Buffered EQP messages awaiting Sync */
+	pipeline = [];
+	pipelineLen = 0;
+	constructor(pglite, sessionLock) {
+		super();
+		this.pglite = pglite;
+		this.sessionLock = sessionLock ?? null;
+		this.bridgeId = createBridgeId();
+	}
+	connect() {
+		setImmediate(() => this.emit("connect"));
+		return this;
+	}
+	setKeepAlive() {
+		return this;
+	}
+	setNoDelay() {
+		return this;
+	}
+	setTimeout() {
+		return this;
+	}
+	ref() {
+		return this;
+	}
+	unref() {
+		return this;
+	}
+	_read() {}
+	_write(chunk, _encoding, callback) {
+		this.pending.push(chunk);
+		this.pendingLen += chunk.length;
+		this.enqueue(callback);
+	}
+	/** Handles corked batches — pg.Client corks during prepared queries (P+B+D+E+S) */
+	_writev(chunks, callback) {
+		for (const { chunk } of chunks) {
+			this.pending.push(chunk);
+			this.pendingLen += chunk.length;
+		}
+		this.enqueue(callback);
+	}
+	_final(callback) {
+		this.sessionLock?.release(this.bridgeId);
+		this.push(null);
+		callback();
+	}
+	_destroy(error, callback) {
+		this.tornDown = true;
+		this.pipeline.length = 0;
+		this.pipelineLen = 0;
+		this.pending.length = 0;
+		this.pendingLen = 0;
+		this.sessionLock?.release(this.bridgeId);
+		const callbacks = this.drainQueue;
+		this.drainQueue = [];
+		for (const cb of callbacks) cb(error);
+		callback(error);
+	}
+	/** Merge pending chunks into buf only when needed for framing */
+	compact() {
+		if (this.pending.length === 0) return;
+		if (this.buf.length === 0 && this.pending.length === 1) this.buf = this.pending[0];
+		else this.buf = Buffer.concat([this.buf, ...this.pending]);
+		this.pending.length = 0;
+		this.pendingLen = 0;
+	}
+	/**
+	* Enqueue a write callback and start draining if not already running.
+	* The callback is NOT called until drain has processed the data.
+	*/
+	enqueue(callback) {
+		this.drainQueue.push(callback);
+		if (!this.draining) this.drain().catch(() => {});
+	}
+	/**
+	* Process all pending data, looping until no new data arrives.
+	* Fires all queued callbacks on completion or error.
+	*/
+	async drain() {
+		if (this.draining) return;
+		this.draining = true;
+		let error = null;
+		try {
+			while (this.pending.length > 0 || this.buf.length > 0) {
+				if (this.tornDown) break;
+				if (this.phase === "pre_startup") await this.processPreStartup();
+				if (this.phase === "ready") await this.processMessages();
+				if (this.pending.length === 0) break;
+			}
+		} catch (err) {
+			error = err instanceof Error ? err : new Error(String(err));
+			this.sessionLock?.release(this.bridgeId);
+		} finally {
+			this.draining = false;
+			const callbacks = this.drainQueue;
+			this.drainQueue = [];
+			for (const cb of callbacks) cb(error);
+		}
+	}
+	/**
+	* Frames and processes the startup message.
+	*
+	* Format: [4 bytes: total length] [4 bytes: protocol version] [key\0value\0 pairs]
+	* No type byte — length includes itself.
+	*/
+	async processPreStartup() {
+		this.compact();
+		if (this.buf.length < 4) return;
+		const len = this.buf.readInt32BE(0);
+		if (this.buf.length < len) return;
+		const message = this.buf.subarray(0, len);
+		this.buf = this.buf.subarray(len);
+		await this.acquireSession();
+		await this.pglite.runExclusive(async () => {
+			await this.execAndPush(message);
+		});
+		this.phase = "ready";
+	}
+	/**
+	* Frames and processes regular wire protocol messages.
+	*
+	* Extended Query Protocol messages (Parse, Bind, Describe, Execute, Close,
+	* Flush) are buffered in `this.pipeline`. When Sync arrives, the entire
+	* pipeline is concatenated and sent to PGlite as one atomic
+	* execProtocolRawStream call within one runExclusive.
+	*
+	* SimpleQuery messages are sent directly (they're self-contained).
+	*/
+	async processMessages() {
+		this.compact();
+		while (this.buf.length >= 5) {
+			const len = 1 + this.buf.readInt32BE(1);
+			if (len < 5 || this.buf.length < len) break;
+			const message = this.buf.subarray(0, len);
+			this.buf = this.buf.subarray(len);
+			const msgType = message[0] ?? 0;
+			if (msgType === TERMINATE) {
+				this.sessionLock?.release(this.bridgeId);
+				this.push(null);
+				return;
+			}
+			if (EQP_MESSAGES.has(msgType)) {
+				this.pipeline.push(message);
+				this.pipelineLen += message.length;
+				continue;
+			}
+			if (msgType === SYNC) {
+				this.pipeline.push(message);
+				this.pipelineLen += message.length;
+				await this.flushPipeline();
+				continue;
+			}
+			await this.acquireSession();
+			await this.pglite.runExclusive(async () => {
+				await this.execAndPush(message);
+			});
+		}
+	}
+	/**
+	* Sends the accumulated EQP pipeline as one atomic operation.
+	*
+	* All buffered messages are concatenated into a single buffer and sent
+	* as one execProtocolRawStream call. This is both correct (prevents
+	* portal interleaving) and fast (1 WASM call + 1 async boundary instead
+	* of 5). Intermediate ReadyForQuery messages are stripped from the
+	* combined response.
+	*/
+	async flushPipeline() {
+		const messages = this.pipeline;
+		const totalLen = this.pipelineLen;
+		this.pipeline = [];
+		this.pipelineLen = 0;
+		let batch;
+		if (messages.length === 1) batch = messages[0] ?? new Uint8Array(0);
+		else {
+			batch = new Uint8Array(totalLen);
+			let offset = 0;
+			for (const msg of messages) {
+				batch.set(msg, offset);
+				offset += msg.length;
+			}
+		}
+		await this.acquireSession();
+		await this.pglite.runExclusive(async () => {
+			const chunks = [];
+			await this.pglite.execProtocolRawStream(batch, { onRawData: (chunk) => chunks.push(chunk) });
+			if (this.tornDown || chunks.length === 0) return;
+			if (chunks.length === 1) {
+				const raw = chunks[0] ?? new Uint8Array(0);
+				this.trackSessionStatus(raw);
+				const cleaned = stripIntermediateReadyForQuery(raw);
+				if (cleaned.length > 0) this.push(cleaned);
+				return;
+			}
+			const combined = concat(chunks);
+			this.trackSessionStatus(combined);
+			const cleaned = stripIntermediateReadyForQuery(combined);
+			if (cleaned.length > 0) this.push(cleaned);
+		});
+	}
+	/**
+	* Sends a message 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).
+	*
+	* Must be called inside runExclusive.
+	*/
+	async execAndPush(message) {
+		let lastChunk = null;
+		await this.pglite.execProtocolRawStream(message, { onRawData: (chunk) => {
+			if (!this.tornDown && chunk.length > 0) {
+				this.push(chunk);
+				lastChunk = chunk;
+			}
+		} });
+		if (lastChunk) this.trackSessionStatus(lastChunk);
+	}
+	async acquireSession() {
+		await this.sessionLock?.acquire(this.bridgeId);
+	}
+	trackSessionStatus(response) {
+		if (!this.sessionLock) return;
+		const status = extractRfqStatus(response);
+		if (status !== null) this.sessionLock.updateStatus(this.bridgeId, status);
+	}
+};
+//#endregion
+//#region src/create-pool.ts
+/**
+* Pool factory — creates a pg.Pool backed by an in-process PGlite instance.
+*
+* Each pool connection gets its own PGliteBridge stream, all sharing the
+* same PGlite WASM instance and SessionLock. The session lock ensures
+* transaction isolation: when one bridge starts a transaction (BEGIN),
+* it gets exclusive PGlite access until COMMIT/ROLLBACK. Non-transactional
+* operations from any bridge serialize through PGlite's runExclusive mutex.
+*/
+const { Client, Pool } = pg;
+/**
+* Creates a pg.Pool where every connection is an in-process PGlite bridge.
+*
+* ```typescript
+* import { createPool } from 'prisma-pglite-bridge';
+* import { PrismaPg } from '@prisma/adapter-pg';
+* import { PrismaClient } from '@prisma/client';
+*
+* const { pool, close } = await createPool();
+* const adapter = new PrismaPg(pool);
+* const prisma = new PrismaClient({ adapter });
+* ```
+*/
+const createPool = async (options = {}) => {
+	const { dataDir, extensions, max = 5 } = options;
+	const ownsInstance = !options.pglite;
+	const pglite = options.pglite ?? new PGlite(dataDir, extensions ? { extensions } : void 0);
+	await pglite.waitReady;
+	const sessionLock = new SessionLock();
+	const BridgedClient = class extends Client {
+		constructor(config) {
+			super({
+				...typeof config === "string" ? { connectionString: config } : config ?? {},
+				user: "postgres",
+				database: "postgres",
+				stream: (() => new PGliteBridge(pglite, sessionLock))
+			});
+		}
+	};
+	const pool = new Pool({
+		Client: BridgedClient,
+		max
+	});
+	const close = async () => {
+		await pool.end();
+		if (ownsInstance) await pglite.close();
+	};
+	return {
+		pool,
+		pglite,
+		close
+	};
+};
+//#endregion
+//#region src/create-pglite-adapter.ts
+/**
+* Creates a Prisma adapter backed by in-process PGlite.
+*
+* No TCP, no Docker, no worker threads — everything runs in the same process.
+* Works for testing, development, seeding, and scripts.
+*
+* ```typescript
+* import { createPgliteAdapter } from 'prisma-pglite-bridge';
+* import { PrismaClient } from '@prisma/client';
+*
+* const { adapter, resetDb } = await createPgliteAdapter();
+* const prisma = new PrismaClient({ adapter });
+*
+* beforeEach(() => resetDb());
+* ```
+*/
+const SNAPSHOT_SCHEMA = "_pglite_snapshot";
+/**
+* Discover the migrations directory via Prisma's config API.
+* Uses the same resolution as `prisma migrate dev` — reads prisma.config.ts,
+* resolves paths relative to config file location.
+*
+* Returns null if @prisma/config is not available or config cannot be loaded.
+*/
+const discoverMigrationsPath = async (configRoot) => {
+	try {
+		const { loadConfigFromFile } = await import("@prisma/config");
+		const { config, error } = await loadConfigFromFile({ configRoot: configRoot ?? process.cwd() });
+		if (error) return null;
+		if (config.migrations?.path) return config.migrations.path;
+		const schemaPath = config.schema;
+		if (schemaPath) return join(dirname(schemaPath), "migrations");
+		return null;
+	} catch {
+		return null;
+	}
+};
+/**
+* Read migration SQL files from a migrations directory in directory order.
+* Returns null if the directory doesn't exist or has no migration files.
+*/
+const tryReadMigrationFiles = (migrationsPath) => {
+	if (!existsSync(migrationsPath)) return null;
+	const dirs = readdirSync(migrationsPath).filter((d) => statSync(join(migrationsPath, d)).isDirectory()).sort();
+	const sqlParts = [];
+	for (const dir of dirs) {
+		const sqlPath = join(migrationsPath, dir, "migration.sql");
+		if (existsSync(sqlPath)) sqlParts.push(readFileSync(sqlPath, "utf8"));
+	}
+	return sqlParts.length > 0 ? sqlParts.join("\n") : null;
+};
+/**
+* Resolve schema SQL. Priority:
+*   1. Explicit `sql` option — use directly
+*   2. Explicit `migrationsPath` — read migration files
+*   3. Auto-discovered migrations (via prisma.config.ts) — read migration files
+*   4. Error — tell the user to generate migration files
+*/
+const resolveSQL = async (options) => {
+	if (options.sql) return options.sql;
+	if (options.migrationsPath) {
+		const sql = tryReadMigrationFiles(options.migrationsPath);
+		if (sql) return sql;
+		throw new Error(`No migration.sql files found in ${options.migrationsPath}. Run \`prisma migrate dev\` to generate migration files.`);
+	}
+	const migrationsPath = await discoverMigrationsPath(options.configRoot);
+	if (migrationsPath) {
+		const sql = tryReadMigrationFiles(migrationsPath);
+		if (sql) return sql;
+	}
+	throw new Error("No migration files found. Run `prisma migrate dev` to generate them, or pass pre-generated SQL via the `sql` option.");
+};
+/**
+* Creates a Prisma adapter backed by an in-process PGlite instance.
+*
+* Applies the schema and returns a ready-to-use adapter + a `resetDb`
+* function for clearing tables between tests.
+*/
+const createPgliteAdapter = async (options = {}) => {
+	const sql = await resolveSQL(options);
+	const { pool, pglite, close: poolClose } = await createPool({
+		dataDir: options.dataDir,
+		extensions: options.extensions,
+		max: options.max
+	});
+	try {
+		await pglite.exec(sql);
+	} catch (err) {
+		throw new Error("Failed to apply schema SQL to PGlite. Check your schema or migration files.", { cause: err });
+	}
+	const adapter = new PrismaPg(pool);
+	let cachedTables = null;
+	let hasSnapshot = false;
+	const discoverTables = async () => {
+		if (cachedTables !== null) return cachedTables;
+		const { rows } = await pglite.query(`SELECT quote_ident(schemaname) || '.' || quote_ident(tablename) AS qualified
+       FROM pg_tables
+       WHERE schemaname NOT IN ('pg_catalog', 'information_schema')
+       AND schemaname != '${SNAPSHOT_SCHEMA}'
+       AND tablename NOT LIKE '_prisma%'`);
+		cachedTables = rows.length > 0 ? rows.map((r) => r.qualified).join(", ") : "";
+		return cachedTables;
+	};
+	const snapshotDb = async () => {
+		await pglite.exec(`DROP SCHEMA IF EXISTS "${SNAPSHOT_SCHEMA}" CASCADE`);
+		await pglite.exec(`CREATE SCHEMA "${SNAPSHOT_SCHEMA}"`);
+		const { rows: tables } = await pglite.query(`SELECT quote_ident(tablename) AS tablename FROM pg_tables
+       WHERE schemaname = 'public'
+       AND tablename NOT LIKE '_prisma%'`);
+		for (const { tablename } of tables) await pglite.exec(`CREATE TABLE "${SNAPSHOT_SCHEMA}".${tablename} AS SELECT * FROM public.${tablename}`);
+		const { rows: seqs } = await pglite.query(`SELECT quote_literal(sequencename) AS name, last_value::text AS value
+       FROM pg_sequences WHERE schemaname = 'public' AND last_value IS NOT NULL`);
+		await pglite.exec(`CREATE TABLE "${SNAPSHOT_SCHEMA}".__sequences (name text, value bigint)`);
+		for (const { name, value } of seqs) await pglite.exec(`INSERT INTO "${SNAPSHOT_SCHEMA}".__sequences VALUES (${name}, ${value})`);
+		hasSnapshot = true;
+	};
+	const resetSnapshot = async () => {
+		hasSnapshot = false;
+		await pglite.exec(`DROP SCHEMA IF EXISTS "${SNAPSHOT_SCHEMA}" CASCADE`);
+	};
+	const resetDb = async () => {
+		const tables = await discoverTables();
+		if (hasSnapshot && tables) {
+			try {
+				await pglite.exec("SET session_replication_role = replica");
+				await pglite.exec(`TRUNCATE TABLE ${tables} CASCADE`);
+				const { rows: snapshotTables } = await pglite.query(`SELECT quote_ident(tablename) AS tablename FROM pg_tables
+           WHERE schemaname = '${SNAPSHOT_SCHEMA}'
+           AND tablename != '__sequences'`);
+				for (const { tablename } of snapshotTables) await pglite.exec(`INSERT INTO public.${tablename} SELECT * FROM "${SNAPSHOT_SCHEMA}".${tablename}`);
+			} finally {
+				await pglite.exec("SET session_replication_role = DEFAULT");
+			}
+			const { rows: seqs } = await pglite.query(`SELECT quote_literal(name) AS name, value::text AS value FROM "${SNAPSHOT_SCHEMA}".__sequences`);
+			for (const { name, value } of seqs) await pglite.exec(`SELECT setval(${name}, ${value})`);
+		} else if (tables) try {
+			await pglite.exec("SET session_replication_role = replica");
+			await pglite.exec(`TRUNCATE TABLE ${tables} CASCADE`);
+		} finally {
+			await pglite.exec("SET session_replication_role = DEFAULT");
+		}
+		await pglite.exec("RESET ALL");
+		await pglite.exec("DEALLOCATE ALL");
+	};
+	return {
+		adapter,
+		pglite,
+		resetDb,
+		snapshotDb,
+		resetSnapshot,
+		close: poolClose
+	};
+};
+//#endregion
+export { PGliteBridge, SessionLock, createPgliteAdapter, createPool };
+
+//# sourceMappingURL=index.mjs.map