@hot-updater/test-utils 1.0.0-rc.16 → 1.0.0-rc.21

package/dist/node.cjs

@@ -36,6 +36,47 @@ let node_net = require("node:net");
 node_net = __toESM(node_net, 1);
 let node_http = require("node:http");
 let execa = require("execa");
+//#region src/d1TestDatabase.ts
+/**
+* A D1 database over `node:sqlite`, answering as D1 does, after it runs
+* `statements`, such as a provider's schema: what a D1 executor's specs
+* run on without Cloudflare. `db` is a database the spec opens, such as
+* `new DatabaseSync(":memory:")`.
+*/
+const createD1TestDatabase = (db, statements = []) => {
+	for (const sql of statements) db.exec(sql);
+	const run = (sql, params) => {
+		const statement = db.prepare(sql);
+		const values = params;
+		return statement.columns().length > 0 ? {
+			success: true,
+			results: statement.all(...values),
+			meta: {}
+		} : {
+			success: true,
+			results: [],
+			meta: { changes: Number(statement.run(...values).changes) }
+		};
+	};
+	/** Runs statements atomically, as `batch` does. */
+	const batch = (statements) => {
+		db.exec("BEGIN IMMEDIATE");
+		try {
+			const results = statements.map(({ sql, params }) => run(sql, params));
+			db.exec("COMMIT");
+			return results;
+		} catch (error) {
+			db.exec("ROLLBACK");
+			throw error;
+		}
+	};
+	return {
+		db,
+		run,
+		batch
+	};
+};
+//#endregion
 //#region ../../node_modules/.pnpm/workspace-tools@0.41.7/node_modules/workspace-tools/lib/graph/getPackageDependencies.js
 var require_getPackageDependencies = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
@@ -20413,6 +20454,167 @@ async function cleanupServer(baseUrl, serverProcess, testDbPath) {
 	} catch {}
 }
 //#endregion
+//#region src/sqlTestExecutors.ts
+/** Test executors for the SQL core; provider executors arrive with D1–D3. */
+const pgliteExecutor = (db) => {
+	const over = (runner) => ({ execute: async ({ sql, params }) => {
+		const result = await runner.query(sql, [...params]);
+		return {
+			rows: result.rows,
+			changes: result.affectedRows ?? 0
+		};
+	} });
+	return {
+		dialect: "postgresql",
+		...over(db),
+		transaction: (fn) => db.transaction((tx) => fn(over(tx)))
+	};
+};
+/** One connection, so statements and transactions run one at a time. */
+const sqliteExecutor = (db) => {
+	let queue = Promise.resolve();
+	const serial = (task) => {
+		const next = queue.then(task);
+		queue = next.catch(() => void 0);
+		return next;
+	};
+	const execute = async ({ sql, params }) => {
+		const statement = db.prepare(sql);
+		const values = params;
+		if (statement.columns().length > 0) return {
+			rows: statement.all(...values),
+			changes: 0
+		};
+		return {
+			rows: [],
+			changes: Number(statement.run(...values).changes)
+		};
+	};
+	return {
+		dialect: "sqlite",
+		execute: (statement) => serial(() => execute(statement)),
+		transaction: (fn) => serial(async () => {
+			db.exec("BEGIN IMMEDIATE");
+			try {
+				const result = await fn({ execute });
+				db.exec("COMMIT");
+				return result;
+			} catch (error) {
+				db.exec("ROLLBACK");
+				throw error;
+			}
+		})
+	};
+};
+/**
+* An executor without interactive transactions, as D1's: writes run as one
+* atomic batch, here in a SQLite transaction that rolls back on any error.
+*/
+const sqliteBatchExecutor = (db) => {
+	const executor = sqliteExecutor(db);
+	return {
+		dialect: "sqlite",
+		execute: executor.execute,
+		transaction: () => {
+			throw new Error("A batch executor has no interactive transactions.");
+		},
+		batch: (statements) => executor.transaction(async (connection) => {
+			const results = [];
+			for (const statement of statements) results.push(await connection.execute(statement));
+			return results;
+		})
+	};
+};
+/** PGlite without interactive transactions, as an RPC applying a batch would be. */
+const pgliteBatchExecutor = (db) => {
+	const executor = pgliteExecutor(db);
+	return {
+		dialect: "postgresql",
+		execute: executor.execute,
+		transaction: () => {
+			throw new Error("A batch executor has no interactive transactions.");
+		},
+		batch: (statements) => executor.transaction(async (connection) => {
+			const results = [];
+			for (const statement of statements) results.push(await connection.execute(statement));
+			return results;
+		})
+	};
+};
+const pgExecutor = (pool) => {
+	const over = (runner) => ({ execute: async ({ sql, params }) => {
+		const result = await runner.query(sql, [...params]);
+		return {
+			rows: result.rows,
+			changes: result.rowCount ?? 0
+		};
+	} });
+	return {
+		dialect: "postgresql",
+		...over(pool),
+		async transaction(fn) {
+			const client = await pool.connect();
+			try {
+				await client.query("BEGIN");
+				const result = await fn(over(client));
+				await client.query("COMMIT");
+				return result;
+			} catch (error) {
+				await client.query("ROLLBACK").catch(() => void 0);
+				throw error;
+			} finally {
+				client.release();
+			}
+		}
+	};
+};
+/** A pooled PostgreSQL batch: one READ COMMITTED transaction per write, as Supabase's apply RPC runs. */
+const pgBatchExecutor = (pool) => {
+	const executor = pgExecutor(pool);
+	return {
+		dialect: "postgresql",
+		execute: executor.execute,
+		transaction: () => {
+			throw new Error("A batch executor has no interactive transactions.");
+		},
+		batch: (statements) => executor.transaction(async (connection) => {
+			const results = [];
+			for (const statement of statements) results.push(await connection.execute(statement));
+			return results;
+		})
+	};
+};
+const mysqlExecutor = (pool) => {
+	const over = (runner) => ({ execute: async ({ sql, params }) => {
+		const [result] = await runner.query(sql, [...params]);
+		return Array.isArray(result) ? {
+			rows: result,
+			changes: 0
+		} : {
+			rows: [],
+			changes: result.affectedRows
+		};
+	} });
+	return {
+		dialect: "mysql",
+		...over(pool),
+		async transaction(fn) {
+			const connection = await pool.getConnection();
+			try {
+				await connection.beginTransaction();
+				const result = await fn(over(connection));
+				await connection.commit();
+				return result;
+			} catch (error) {
+				await connection.rollback().catch(() => void 0);
+				throw error;
+			} finally {
+				connection.release();
+			}
+		}
+	};
+};
+//#endregion
 exports.RELEASE_CATALOG_DOWNLOAD_HASH = RELEASE_CATALOG_DOWNLOAD_HASH;
 exports.RELEASE_CATALOG_MANIFEST_URIS = RELEASE_CATALOG_MANIFEST_URIS;
 exports.RELEASE_CATALOG_STORAGE_FIXTURES = RELEASE_CATALOG_STORAGE_FIXTURES;
@@ -20422,6 +20624,7 @@ exports.assertDockerComposeAvailable = assertDockerComposeAvailable;
 exports.assertDockerDaemonAvailable = assertDockerDaemonAvailable;
 exports.assertEnvFlagEnabled = assertEnvFlagEnabled;
 exports.cleanupServer = cleanupServer;
+exports.createD1TestDatabase = createD1TestDatabase;
 exports.createReleaseCatalogTestStorage = createReleaseCatalogTestStorage;
 exports.createTestDbPath = createTestDbPath;
 exports.findOpenPort = findOpenPort;
@@ -20431,11 +20634,18 @@ exports.hasDockerCompose = hasDockerCompose;
 exports.hasDockerDaemon = hasDockerDaemon;
 exports.killPort = killPort;
 exports.mockReactNativeProjectRoot = mockReactNativeProjectRoot;
+exports.mysqlExecutor = mysqlExecutor;
+exports.pgBatchExecutor = pgBatchExecutor;
+exports.pgExecutor = pgExecutor;
+exports.pgliteBatchExecutor = pgliteBatchExecutor;
+exports.pgliteExecutor = pgliteExecutor;
 exports.releaseCatalogArtifact = releaseCatalogArtifact;
 exports.releaseCatalogDownloadUrl = releaseCatalogDownloadUrl;
 exports.runCheckedCommand = runCheckedCommand;
 exports.spawnRuntime = spawnRuntime;
 exports.spawnServerProcess = spawnServerProcess;
+exports.sqliteBatchExecutor = sqliteBatchExecutor;
+exports.sqliteExecutor = sqliteExecutor;
 exports.startHttpTestServer = startHttpTestServer;
 exports.stopRuntime = stopRuntime;
 exports.waitForHttpOk = waitForHttpOk;

package/dist/node.d.cts

@@ -1,8 +1,36 @@
+import { DatabaseSync } from "node:sqlite";
 import { ChildProcessByStdio } from "node:child_process";
 import { Readable } from "node:stream";
-import { ArtifactInfo } from "@hot-updater/core";
-import { BundleRow, StoragePlugin } from "@hot-updater/plugin-core";
+import { BundleRow, SqlExecutor, StorageAdapter } from "@hot-updater/plugin-core";
+import { ArtifactInfo } from "@hot-updater/protocol";
 import { execa } from "execa";
+import { PGlite } from "@electric-sql/pglite";
+import { Pool } from "mysql2/promise";
+import { Pool as Pool$1 } from "pg";
+//#region src/d1TestDatabase.d.ts
+/** What a D1 statement answers: `results` for a read, `meta.changes` for a write. */
+interface D1TestResult {
+  readonly success: true;
+  readonly results: readonly unknown[];
+  readonly meta: {
+    readonly changes?: number;
+  };
+}
+/**
+ * A D1 database over `node:sqlite`, answering as D1 does, after it runs
+ * `statements`, such as a provider's schema: what a D1 executor's specs
+ * run on without Cloudflare. `db` is a database the spec opens, such as
+ * `new DatabaseSync(":memory:")`.
+ */
+declare const createD1TestDatabase: (db: DatabaseSync, statements?: readonly string[]) => {
+  db: DatabaseSync;
+  run: (sql: string, params: readonly unknown[]) => D1TestResult;
+  batch: (statements: readonly {
+    sql: string;
+    params: readonly unknown[];
+  }[]) => D1TestResult[];
+};
+//#endregion
 //#region src/mockReactNativeProjectRoot.d.ts
 interface MockedReactNativeProjectRoot {
   rootDir: string;
@@ -73,7 +101,7 @@ declare const releaseCatalogArtifact: (bundle: BundleRow) => ArtifactInfo;
 /** Install these storage objects in the test server, independently of its DB. */
 declare const RELEASE_CATALOG_STORAGE_FIXTURES: Readonly<Record<string, string>>;
 /** Storage boundary shared by provider and separately spawned server tests. */
-declare const createReleaseCatalogTestStorage: () => StoragePlugin;
+declare const createReleaseCatalogTestStorage: () => StorageAdapter;
 //#endregion
 //#region src/setupHandlerIntegrationTestSuite.d.ts
 declare const TEST_ADMIN_AUTH_TOKEN = "hot-updater-test-token";
@@ -104,4 +132,21 @@ declare function spawnServerProcess(options: {
  */
 declare function cleanupServer(baseUrl: string, serverProcess: ReturnType<typeof execa> | null, testDbPath: string): Promise<void>;
 //#endregion
-export { MockedReactNativeProjectRoot, RELEASE_CATALOG_DOWNLOAD_HASH, RELEASE_CATALOG_MANIFEST_URIS, RELEASE_CATALOG_STORAGE_FIXTURES, RuntimeChild, RuntimeLogs, SpawnRuntimeOptions, TEST_ADMIN_AUTH_TOKEN, assertCommandAvailable, assertDockerComposeAvailable, assertDockerDaemonAvailable, assertEnvFlagEnabled, cleanupServer, createReleaseCatalogTestStorage, createTestDbPath, findOpenPort, formatRuntimeLogs, hasCommand, hasDockerCompose, hasDockerDaemon, killPort, mockReactNativeProjectRoot, releaseCatalogArtifact, releaseCatalogDownloadUrl, runCheckedCommand, spawnRuntime, spawnServerProcess, startHttpTestServer, stopRuntime, waitForHttpOk, waitForServer };
+//#region src/sqlTestExecutors.d.ts
+/** Test executors for the SQL core; provider executors arrive with D1–D3. */
+declare const pgliteExecutor: (db: PGlite) => SqlExecutor;
+/** One connection, so statements and transactions run one at a time. */
+declare const sqliteExecutor: (db: DatabaseSync) => SqlExecutor;
+/**
+ * An executor without interactive transactions, as D1's: writes run as one
+ * atomic batch, here in a SQLite transaction that rolls back on any error.
+ */
+declare const sqliteBatchExecutor: (db: DatabaseSync) => SqlExecutor;
+/** PGlite without interactive transactions, as an RPC applying a batch would be. */
+declare const pgliteBatchExecutor: (db: PGlite) => SqlExecutor;
+declare const pgExecutor: (pool: Pool$1) => SqlExecutor;
+/** A pooled PostgreSQL batch: one READ COMMITTED transaction per write, as Supabase's apply RPC runs. */
+declare const pgBatchExecutor: (pool: Pool$1) => SqlExecutor;
+declare const mysqlExecutor: (pool: Pool) => SqlExecutor;
+//#endregion
+export { D1TestResult, MockedReactNativeProjectRoot, RELEASE_CATALOG_DOWNLOAD_HASH, RELEASE_CATALOG_MANIFEST_URIS, RELEASE_CATALOG_STORAGE_FIXTURES, RuntimeChild, RuntimeLogs, SpawnRuntimeOptions, TEST_ADMIN_AUTH_TOKEN, assertCommandAvailable, assertDockerComposeAvailable, assertDockerDaemonAvailable, assertEnvFlagEnabled, cleanupServer, createD1TestDatabase, createReleaseCatalogTestStorage, createTestDbPath, findOpenPort, formatRuntimeLogs, hasCommand, hasDockerCompose, hasDockerDaemon, killPort, mockReactNativeProjectRoot, mysqlExecutor, pgBatchExecutor, pgExecutor, pgliteBatchExecutor, pgliteExecutor, releaseCatalogArtifact, releaseCatalogDownloadUrl, runCheckedCommand, spawnRuntime, spawnServerProcess, sqliteBatchExecutor, sqliteExecutor, startHttpTestServer, stopRuntime, waitForHttpOk, waitForServer };

package/dist/node.d.mts

@@ -1,8 +1,36 @@
 import { ChildProcessByStdio } from "node:child_process";
 import { execa } from "execa";
+import { DatabaseSync } from "node:sqlite";
 import { Readable } from "node:stream";
-import { ArtifactInfo } from "@hot-updater/core";
-import { BundleRow, StoragePlugin } from "@hot-updater/plugin-core";
+import { BundleRow, SqlExecutor, StorageAdapter } from "@hot-updater/plugin-core";
+import { ArtifactInfo } from "@hot-updater/protocol";
+import { PGlite } from "@electric-sql/pglite";
+import { Pool } from "mysql2/promise";
+import { Pool as Pool$1 } from "pg";
+//#region src/d1TestDatabase.d.ts
+/** What a D1 statement answers: `results` for a read, `meta.changes` for a write. */
+interface D1TestResult {
+  readonly success: true;
+  readonly results: readonly unknown[];
+  readonly meta: {
+    readonly changes?: number;
+  };
+}
+/**
+ * A D1 database over `node:sqlite`, answering as D1 does, after it runs
+ * `statements`, such as a provider's schema: what a D1 executor's specs
+ * run on without Cloudflare. `db` is a database the spec opens, such as
+ * `new DatabaseSync(":memory:")`.
+ */
+declare const createD1TestDatabase: (db: DatabaseSync, statements?: readonly string[]) => {
+  db: DatabaseSync;
+  run: (sql: string, params: readonly unknown[]) => D1TestResult;
+  batch: (statements: readonly {
+    sql: string;
+    params: readonly unknown[];
+  }[]) => D1TestResult[];
+};
+//#endregion
 //#region src/mockReactNativeProjectRoot.d.ts
 interface MockedReactNativeProjectRoot {
   rootDir: string;
@@ -73,7 +101,7 @@ declare const releaseCatalogArtifact: (bundle: BundleRow) => ArtifactInfo;
 /** Install these storage objects in the test server, independently of its DB. */
 declare const RELEASE_CATALOG_STORAGE_FIXTURES: Readonly<Record<string, string>>;
 /** Storage boundary shared by provider and separately spawned server tests. */
-declare const createReleaseCatalogTestStorage: () => StoragePlugin;
+declare const createReleaseCatalogTestStorage: () => StorageAdapter;
 //#endregion
 //#region src/setupHandlerIntegrationTestSuite.d.ts
 declare const TEST_ADMIN_AUTH_TOKEN = "hot-updater-test-token";
@@ -104,4 +132,21 @@ declare function spawnServerProcess(options: {
  */
 declare function cleanupServer(baseUrl: string, serverProcess: ReturnType<typeof execa> | null, testDbPath: string): Promise<void>;
 //#endregion
-export { MockedReactNativeProjectRoot, RELEASE_CATALOG_DOWNLOAD_HASH, RELEASE_CATALOG_MANIFEST_URIS, RELEASE_CATALOG_STORAGE_FIXTURES, RuntimeChild, RuntimeLogs, SpawnRuntimeOptions, TEST_ADMIN_AUTH_TOKEN, assertCommandAvailable, assertDockerComposeAvailable, assertDockerDaemonAvailable, assertEnvFlagEnabled, cleanupServer, createReleaseCatalogTestStorage, createTestDbPath, findOpenPort, formatRuntimeLogs, hasCommand, hasDockerCompose, hasDockerDaemon, killPort, mockReactNativeProjectRoot, releaseCatalogArtifact, releaseCatalogDownloadUrl, runCheckedCommand, spawnRuntime, spawnServerProcess, startHttpTestServer, stopRuntime, waitForHttpOk, waitForServer };
+//#region src/sqlTestExecutors.d.ts
+/** Test executors for the SQL core; provider executors arrive with D1–D3. */
+declare const pgliteExecutor: (db: PGlite) => SqlExecutor;
+/** One connection, so statements and transactions run one at a time. */
+declare const sqliteExecutor: (db: DatabaseSync) => SqlExecutor;
+/**
+ * An executor without interactive transactions, as D1's: writes run as one
+ * atomic batch, here in a SQLite transaction that rolls back on any error.
+ */
+declare const sqliteBatchExecutor: (db: DatabaseSync) => SqlExecutor;
+/** PGlite without interactive transactions, as an RPC applying a batch would be. */
+declare const pgliteBatchExecutor: (db: PGlite) => SqlExecutor;
+declare const pgExecutor: (pool: Pool$1) => SqlExecutor;
+/** A pooled PostgreSQL batch: one READ COMMITTED transaction per write, as Supabase's apply RPC runs. */
+declare const pgBatchExecutor: (pool: Pool$1) => SqlExecutor;
+declare const mysqlExecutor: (pool: Pool) => SqlExecutor;
+//#endregion
+export { D1TestResult, MockedReactNativeProjectRoot, RELEASE_CATALOG_DOWNLOAD_HASH, RELEASE_CATALOG_MANIFEST_URIS, RELEASE_CATALOG_STORAGE_FIXTURES, RuntimeChild, RuntimeLogs, SpawnRuntimeOptions, TEST_ADMIN_AUTH_TOKEN, assertCommandAvailable, assertDockerComposeAvailable, assertDockerDaemonAvailable, assertEnvFlagEnabled, cleanupServer, createD1TestDatabase, createReleaseCatalogTestStorage, createTestDbPath, findOpenPort, formatRuntimeLogs, hasCommand, hasDockerCompose, hasDockerDaemon, killPort, mockReactNativeProjectRoot, mysqlExecutor, pgBatchExecutor, pgExecutor, pgliteBatchExecutor, pgliteExecutor, releaseCatalogArtifact, releaseCatalogDownloadUrl, runCheckedCommand, spawnRuntime, spawnServerProcess, sqliteBatchExecutor, sqliteExecutor, startHttpTestServer, stopRuntime, waitForHttpOk, waitForServer };

package/dist/node.mjs

@@ -12,6 +12,47 @@ import { execa } from "execa";
 var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
 var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
 //#endregion
+//#region src/d1TestDatabase.ts
+/**
+* A D1 database over `node:sqlite`, answering as D1 does, after it runs
+* `statements`, such as a provider's schema: what a D1 executor's specs
+* run on without Cloudflare. `db` is a database the spec opens, such as
+* `new DatabaseSync(":memory:")`.
+*/
+const createD1TestDatabase = (db, statements = []) => {
+	for (const sql of statements) db.exec(sql);
+	const run = (sql, params) => {
+		const statement = db.prepare(sql);
+		const values = params;
+		return statement.columns().length > 0 ? {
+			success: true,
+			results: statement.all(...values),
+			meta: {}
+		} : {
+			success: true,
+			results: [],
+			meta: { changes: Number(statement.run(...values).changes) }
+		};
+	};
+	/** Runs statements atomically, as `batch` does. */
+	const batch = (statements) => {
+		db.exec("BEGIN IMMEDIATE");
+		try {
+			const results = statements.map(({ sql, params }) => run(sql, params));
+			db.exec("COMMIT");
+			return results;
+		} catch (error) {
+			db.exec("ROLLBACK");
+			throw error;
+		}
+	};
+	return {
+		db,
+		run,
+		batch
+	};
+};
+//#endregion
 //#region ../../node_modules/.pnpm/workspace-tools@0.41.7/node_modules/workspace-tools/lib/graph/getPackageDependencies.js
 var require_getPackageDependencies = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
@@ -20389,4 +20430,165 @@ async function cleanupServer(baseUrl, serverProcess, testDbPath) {
 	} catch {}
 }
 //#endregion
-export { RELEASE_CATALOG_DOWNLOAD_HASH, RELEASE_CATALOG_MANIFEST_URIS, RELEASE_CATALOG_STORAGE_FIXTURES, TEST_ADMIN_AUTH_TOKEN, assertCommandAvailable, assertDockerComposeAvailable, assertDockerDaemonAvailable, assertEnvFlagEnabled, cleanupServer, createReleaseCatalogTestStorage, createTestDbPath, findOpenPort, formatRuntimeLogs, hasCommand, hasDockerCompose, hasDockerDaemon, killPort, mockReactNativeProjectRoot, releaseCatalogArtifact, releaseCatalogDownloadUrl, runCheckedCommand, spawnRuntime, spawnServerProcess, startHttpTestServer, stopRuntime, waitForHttpOk, waitForServer };
+//#region src/sqlTestExecutors.ts
+/** Test executors for the SQL core; provider executors arrive with D1–D3. */
+const pgliteExecutor = (db) => {
+	const over = (runner) => ({ execute: async ({ sql, params }) => {
+		const result = await runner.query(sql, [...params]);
+		return {
+			rows: result.rows,
+			changes: result.affectedRows ?? 0
+		};
+	} });
+	return {
+		dialect: "postgresql",
+		...over(db),
+		transaction: (fn) => db.transaction((tx) => fn(over(tx)))
+	};
+};
+/** One connection, so statements and transactions run one at a time. */
+const sqliteExecutor = (db) => {
+	let queue = Promise.resolve();
+	const serial = (task) => {
+		const next = queue.then(task);
+		queue = next.catch(() => void 0);
+		return next;
+	};
+	const execute = async ({ sql, params }) => {
+		const statement = db.prepare(sql);
+		const values = params;
+		if (statement.columns().length > 0) return {
+			rows: statement.all(...values),
+			changes: 0
+		};
+		return {
+			rows: [],
+			changes: Number(statement.run(...values).changes)
+		};
+	};
+	return {
+		dialect: "sqlite",
+		execute: (statement) => serial(() => execute(statement)),
+		transaction: (fn) => serial(async () => {
+			db.exec("BEGIN IMMEDIATE");
+			try {
+				const result = await fn({ execute });
+				db.exec("COMMIT");
+				return result;
+			} catch (error) {
+				db.exec("ROLLBACK");
+				throw error;
+			}
+		})
+	};
+};
+/**
+* An executor without interactive transactions, as D1's: writes run as one
+* atomic batch, here in a SQLite transaction that rolls back on any error.
+*/
+const sqliteBatchExecutor = (db) => {
+	const executor = sqliteExecutor(db);
+	return {
+		dialect: "sqlite",
+		execute: executor.execute,
+		transaction: () => {
+			throw new Error("A batch executor has no interactive transactions.");
+		},
+		batch: (statements) => executor.transaction(async (connection) => {
+			const results = [];
+			for (const statement of statements) results.push(await connection.execute(statement));
+			return results;
+		})
+	};
+};
+/** PGlite without interactive transactions, as an RPC applying a batch would be. */
+const pgliteBatchExecutor = (db) => {
+	const executor = pgliteExecutor(db);
+	return {
+		dialect: "postgresql",
+		execute: executor.execute,
+		transaction: () => {
+			throw new Error("A batch executor has no interactive transactions.");
+		},
+		batch: (statements) => executor.transaction(async (connection) => {
+			const results = [];
+			for (const statement of statements) results.push(await connection.execute(statement));
+			return results;
+		})
+	};
+};
+const pgExecutor = (pool) => {
+	const over = (runner) => ({ execute: async ({ sql, params }) => {
+		const result = await runner.query(sql, [...params]);
+		return {
+			rows: result.rows,
+			changes: result.rowCount ?? 0
+		};
+	} });
+	return {
+		dialect: "postgresql",
+		...over(pool),
+		async transaction(fn) {
+			const client = await pool.connect();
+			try {
+				await client.query("BEGIN");
+				const result = await fn(over(client));
+				await client.query("COMMIT");
+				return result;
+			} catch (error) {
+				await client.query("ROLLBACK").catch(() => void 0);
+				throw error;
+			} finally {
+				client.release();
+			}
+		}
+	};
+};
+/** A pooled PostgreSQL batch: one READ COMMITTED transaction per write, as Supabase's apply RPC runs. */
+const pgBatchExecutor = (pool) => {
+	const executor = pgExecutor(pool);
+	return {
+		dialect: "postgresql",
+		execute: executor.execute,
+		transaction: () => {
+			throw new Error("A batch executor has no interactive transactions.");
+		},
+		batch: (statements) => executor.transaction(async (connection) => {
+			const results = [];
+			for (const statement of statements) results.push(await connection.execute(statement));
+			return results;
+		})
+	};
+};
+const mysqlExecutor = (pool) => {
+	const over = (runner) => ({ execute: async ({ sql, params }) => {
+		const [result] = await runner.query(sql, [...params]);
+		return Array.isArray(result) ? {
+			rows: result,
+			changes: 0
+		} : {
+			rows: [],
+			changes: result.affectedRows
+		};
+	} });
+	return {
+		dialect: "mysql",
+		...over(pool),
+		async transaction(fn) {
+			const connection = await pool.getConnection();
+			try {
+				await connection.beginTransaction();
+				const result = await fn(over(connection));
+				await connection.commit();
+				return result;
+			} catch (error) {
+				await connection.rollback().catch(() => void 0);
+				throw error;
+			} finally {
+				connection.release();
+			}
+		}
+	};
+};
+//#endregion
+export { RELEASE_CATALOG_DOWNLOAD_HASH, RELEASE_CATALOG_MANIFEST_URIS, RELEASE_CATALOG_STORAGE_FIXTURES, TEST_ADMIN_AUTH_TOKEN, assertCommandAvailable, assertDockerComposeAvailable, assertDockerDaemonAvailable, assertEnvFlagEnabled, cleanupServer, createD1TestDatabase, createReleaseCatalogTestStorage, createTestDbPath, findOpenPort, formatRuntimeLogs, hasCommand, hasDockerCompose, hasDockerDaemon, killPort, mockReactNativeProjectRoot, mysqlExecutor, pgBatchExecutor, pgExecutor, pgliteBatchExecutor, pgliteExecutor, releaseCatalogArtifact, releaseCatalogDownloadUrl, runCheckedCommand, spawnRuntime, spawnServerProcess, sqliteBatchExecutor, sqliteExecutor, startHttpTestServer, stopRuntime, waitForHttpOk, waitForServer };