@jterrazz/test 16.1.0 → 17.0.0

package/dist/route-coverage.global-setup.d.ts

@@ -0,0 +1,42 @@
+import { TestProject } from "vitest/node";
+//#region src/specifications/api/routes/ledger.d.ts
+type Shard = {
+  count: number;
+  index: number;
+};
+declare module 'vitest' {
+  interface ProvidedContext {
+    routesLedger?: string;
+  }
+}
+//#endregion
+//#region src/specifications/api/routes/route-coverage.global-setup.d.ts
+/** Judged only on a whole green run: a shard, a `-t` filter, `--changed` or a failed file is no count. The ratchet is exact both ways; an app with no known route table fails the run. */
+export type RouteProject = {
+  config: {
+    root: string;
+  };
+  globTestFiles: () => Promise<{
+    testFiles: string[];
+  }>;
+  name: string;
+  provide: (key: 'routesLedger', value: string) => void;
+  vitest: {
+    config: {
+      shard?: Shard | undefined;
+      testNamePattern?: RegExp | undefined;
+    };
+    state: {
+      getFailedFilepaths: () => string[];
+      getFiles: () => readonly {
+        filepath: string;
+        projectName?: string | undefined;
+      }[];
+    };
+  };
+};
+export declare function routeCoverageSetup(): string;
+export declare function setupRoutes(project: RouteProject): () => Promise<void>;
+export default function setup(project: TestProject): () => Promise<void>;
+//#endregion
+//# sourceMappingURL=route-coverage.global-setup.d.ts.map

package/dist/route-coverage.global-setup.js

@@ -0,0 +1,2 @@
+import { n as setup, r as setupRoutes, t as routeCoverageSetup } from "./shared-route-coverage.global-setup.js";
+export { setup as default, routeCoverageSetup, setupRoutes };

package/dist/services.d.ts

@@ -0,0 +1,3 @@
+import { C as IsolationStrategy, S as ServiceHandle, a as processService, b as ServiceRecord, c as RedisOptions, d as postgres, i as ProcessOptions, l as redis, n as SeedSource, o as sqlite, r as ProcessHandle, s as SqliteOptions, u as PostgresOptions, w as DatabasePort, y as DatabaseKeys } from "./shared-index.services.js";
+import { n as ContainerPort, t as ContainerOptions } from "./shared-container.port.js";
+export { type ContainerOptions, type ContainerPort, type DatabaseKeys, type DatabasePort, type IsolationStrategy, type PostgresOptions, ProcessHandle, type ProcessOptions, type RedisOptions, type SeedSource, type ServiceHandle, type ServiceRecord, type SqliteOptions, postgres, processService as process, redis, sqlite };

package/dist/services.global-setup.d.ts

@@ -0,0 +1,43 @@
+import { n as ContainerPort, r as ContainerRequest } from "./shared-container.port.js";
+import { ContainerRuntimeClient } from "testcontainers";
+//#region src/services/containers/run-containers.d.ts
+/** Two requests alike (image, port, environment, options) share one container; the run stops them all at teardown. */
+type RunAddress = {
+  host: string;
+  key: string;
+  port: number;
+};
+declare class RunContainers {
+  private readonly started;
+  private readonly create;
+  private readonly ready;
+  /** `ready`'s rejection is the one answer every request gets, and no container is created. */
+  constructor(create: (request: ContainerRequest) => ContainerPort, ready?: () => Promise<void>);
+  acquire(request: ContainerRequest): Promise<RunAddress>;
+  logs(key: string, since?: Date): Promise<string>;
+  stop(): Promise<void>;
+  private start;
+}
+type ServedContainers = {
+  close: () => Promise<void>;
+  url: string;
+};
+declare function serveContainers(containers: RunContainers): Promise<ServedContainers>;
+//#endregion
+//#region src/services/containers/services.global-setup.d.ts
+/** Every project's setup joins the one run's containers. Default images are pulled in the background, so the first file waits on a pull at most once; a project declaring no service needs no Docker. */
+export declare const DOCKER_ABSENT = "no Docker daemon answered";
+/** `connect` stands in for the runtime's own client lookup, so the refusal is reachable without a daemon to stop. */
+export declare function prepareDocker(connect?: () => Promise<ContainerRuntimeClient>): Promise<void>;
+export declare function servicesSetup(): string;
+type RunProject = {
+  provide: (key: 'serviceContainers', value: string) => void;
+};
+type RunSeams = {
+  create: (request: ContainerRequest) => ContainerPort;
+  prepare: () => Promise<void>;
+  serve: typeof serveContainers;
+};
+export default function setup(project: RunProject, seams?: Partial<RunSeams>): Promise<() => Promise<void>>;
+//#endregion
+//# sourceMappingURL=services.global-setup.d.ts.map

package/dist/services.global-setup.js

@@ -0,0 +1,2 @@
+import { i as setup, n as prepareDocker, r as servicesSetup, t as DOCKER_ABSENT } from "./shared-services.global-setup.js";
+export { DOCKER_ABSENT, setup as default, prepareDocker, servicesSetup };

package/dist/services.js

@@ -0,0 +1,597 @@
+import { t as discoverRoot } from "./shared-resolve.js";
+import { n as refusal, t as invariant } from "./shared-refusal.js";
+import { t as pause } from "./shared-pause.js";
+import { n as processService, t as ProcessHandle } from "./shared-process.adapter.js";
+import { n as requireBuiltPeer, t as loadPeer } from "./shared-peer.js";
+import { c as SQLITE_TEMPLATE_DIR } from "./shared-artifacts.js";
+import { t as SERVICE_IMAGES } from "./shared-service-images.js";
+import { closeSync, copyFileSync, existsSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, renameSync, rmSync, statSync, unlinkSync, writeSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { createHash } from "node:crypto";
+import { tmpdir } from "node:os";
+//#region src/services/driver-reason.ts
+/** What a database driver says went wrong: its message, else its code; a refused connection is an `AggregateError` with an empty message and `ECONNREFUSED`. */
+function driverReason(error) {
+	if (error instanceof Error && error.message !== "") return error.message;
+	const code = Reflect.get(new Object(error), "code");
+	return typeof code === "string" && code !== "" ? code : String(error);
+}
+//#endregion
+//#region src/services/postgres/template.ts
+/** An optional peer: a repository that never connects never pays for the import. */
+async function clientConstructor() {
+	return await loadPeer("pg", "postgres()", async () => {
+		return (await import("pg")).Client;
+	});
+}
+async function endQuietly(client) {
+	try {
+		await client?.end();
+	} catch {}
+}
+function withDatabase$1(connectionString, database) {
+	const url = new URL(connectionString);
+	url.pathname = `/${database}`;
+	return url.toString();
+}
+/** Unique among one container's clones and the same on every run, so a clone a crashed run left is dropped by the next worker of that name. */
+function cloneName(base, service, workerId) {
+	return `${base}_${service}_${workerId}`.toLowerCase().replaceAll(/[^a-z0-9_]/gu, "_");
+}
+async function withClient(connectionString, work) {
+	const client = new (await (clientConstructor()))({ connectionString });
+	client.on("error", () => {});
+	await client.connect();
+	try {
+		return await work(client);
+	} finally {
+		await endQuietly(client);
+	}
+}
+/** Named by the script's digest; built under an advisory lock, marked `IS_TEMPLATE` only once the script ran whole, a crash's unmarked one rebuilt. */
+async function buildTemplate(connectionString, sql, initPath) {
+	const template = `template_${createHash("sha256").update(sql).digest("hex").slice(0, 16)}`;
+	return await withClient(connectionString, async (admin) => {
+		await admin.query("SELECT pg_advisory_lock(hashtext($1))", [template]);
+		try {
+			if ((await admin.query("SELECT datistemplate FROM pg_database WHERE datname = $1", [template])).rows[0]?.datistemplate === true) return template;
+			await admin.query(`DROP DATABASE IF EXISTS "${template}" WITH (FORCE)`);
+			await admin.query(`CREATE DATABASE "${template}"`);
+			try {
+				await withClient(withDatabase$1(connectionString, template), async (builder) => {
+					await builder.query(sql);
+				});
+			} catch (error) {
+				await admin.query(`DROP DATABASE IF EXISTS "${template}" WITH (FORCE)`);
+				throw new Error(refusal({
+					fix: `correct ${initPath}: the SQL fails as written`,
+					found: `the postgres init script ${initPath} failed: ${error instanceof Error ? error.message : String(error)}`,
+					read: "docs/reference/services.md#dockerserviceinitsql",
+					why: "A postgres service's template database is built by its init script, run whole."
+				}), { cause: error });
+			}
+			await admin.query(`ALTER DATABASE "${template}" IS_TEMPLATE true`);
+			return template;
+		} finally {
+			await admin.query("SELECT pg_advisory_unlock(hashtext($1))", [template]);
+		}
+	});
+}
+//#endregion
+//#region src/services/postgres/postgres.adapter.ts
+const DISPOSABLE = {
+	command: [
+		"postgres",
+		"-c",
+		"fsync=off",
+		"-c",
+		"synchronous_commit=off",
+		"-c",
+		"full_page_writes=off",
+		"-c",
+		"log_checkpoints=off"
+	],
+	tmpfs: { "/var/lib/postgresql/data": "rw" }
+};
+var PostgresHandle = class {
+	type = "postgres";
+	serviceName = null;
+	defaultPort = 5432;
+	defaultImage;
+	environment;
+	containerOptions = DISPOSABLE;
+	connectionString = "";
+	client = null;
+	template = null;
+	clone = null;
+	constructor(options = {}) {
+		this.defaultImage = options.image ?? SERVICE_IMAGES.postgres;
+		this.environment = {
+			POSTGRES_DB: "test",
+			POSTGRES_PASSWORD: "test",
+			POSTGRES_USER: "test",
+			...options.env
+		};
+	}
+	buildConnectionString(host, port) {
+		return `postgresql://${this.environment.POSTGRES_USER ?? "test"}:${this.environment.POSTGRES_PASSWORD ?? "test"}@${host}:${port}/${this.environment.POSTGRES_DB ?? "test"}`;
+	}
+	createDatabaseAdapter() {
+		return this;
+	}
+	async healthcheck() {
+		if (!this.connectionString) throw invariant("postgres() was healthchecked before it had a connection string");
+		try {
+			const client = new (await (clientConstructor()))({ connectionString: this.connectionString });
+			await client.connect();
+			await client.query("SELECT 1");
+			await client.end();
+		} catch (error) {
+			throw new Error(refusal({
+				fix: "check the container is running and reachable (`docker ps`), and run again",
+				found: `postgres() did not answer its healthcheck: ${driverReason(error)}`,
+				read: "docs/reference/services.md#service-factories",
+				why: "A declared service is handed to the chain once it answers its healthcheck."
+			}), { cause: error });
+		}
+	}
+	async initialize(dockerDir) {
+		const initPaths = [...this.serviceName === null ? [] : [resolve(dockerDir, `${this.serviceName}/init.sql`)], resolve(dockerDir, "postgres/init.sql")];
+		for (const initPath of initPaths) if (existsSync(initPath)) {
+			this.template = await buildTemplate(this.connectionString, readFileSync(initPath, "utf8"), initPath);
+			return;
+		}
+	}
+	async getClient() {
+		if (this.client) return this.client;
+		const client = new (await (clientConstructor()))({ connectionString: this.connectionString });
+		client.on("error", () => {
+			this.client = null;
+		});
+		await client.connect();
+		this.client = client;
+		return client;
+	}
+	async seed(sql) {
+		await (await this.getClient()).query(sql);
+	}
+	async reset() {
+		const client = await this.getClient();
+		const tables = (await client.query(`
+            SELECT tablename FROM pg_tables
+            WHERE schemaname = 'public'
+            AND tablename NOT LIKE '_prisma%'
+        `)).rows.map(({ tablename }) => `"public"."${tablename}"`);
+		if (tables.length > 0) await client.query(`TRUNCATE ${tables.join(", ")} RESTART IDENTITY CASCADE`);
+	}
+	async query(table, columns) {
+		const client = await this.getClient();
+		const columnList = columns.join(", ");
+		return (await client.query(`SELECT ${columnList} FROM "public"."${table}" ORDER BY 1`)).rows.map((row) => columns.map((col) => row[col]));
+	}
+	async columns(table) {
+		return (await (await this.getClient()).query("SELECT column_name FROM information_schema.columns WHERE table_schema = $1 AND table_name = $2 ORDER BY ordinal_position", ["public", table])).rows.map((row) => row.column_name);
+	}
+	isolation() {
+		return {
+			acquire: async (workerId) => {
+				const database = cloneName(this.environment.POSTGRES_DB ?? "test", this.serviceName ?? this.type, workerId);
+				await withClient(this.connectionString, async (admin) => {
+					await admin.query(`DROP DATABASE IF EXISTS "${database}" WITH (FORCE)`);
+					await admin.query(`CREATE DATABASE "${database}" TEMPLATE "${this.template ?? "template1"}"`);
+				});
+				await this.closeClient();
+				this.clone = {
+					container: this.connectionString,
+					database
+				};
+				this.connectionString = withDatabase$1(this.connectionString, database);
+			},
+			reset: async () => {
+				await this.reset();
+			},
+			release: async () => {
+				await this.closeClient();
+				const { clone } = this;
+				if (clone === null) return;
+				this.connectionString = clone.container;
+				this.clone = null;
+				await withClient(this.connectionString, async (admin) => {
+					await admin.query(`DROP DATABASE IF EXISTS "${clone.database}" WITH (FORCE)`);
+				});
+			}
+		};
+	}
+	async closeClient() {
+		const { client } = this;
+		this.client = null;
+		await endQuietly(client);
+	}
+};
+/** Create a PostgreSQL service handle; its record key names the init script folder (`docker/<key>/init.sql`). */
+function postgres(options = {}) {
+	return new PostgresHandle(options);
+}
+//#endregion
+//#region src/services/redis/redis.adapter.ts
+const DATABASES = 256;
+const SERVICES_PER_WORKER = 4;
+const WORKERS = Math.floor(255 / SERVICES_PER_WORKER);
+const PAIR_INDEXES = { command: [
+	"redis-server",
+	"--databases",
+	String(DATABASES)
+] };
+const slots = /* @__PURE__ */ new Map();
+function slotsOf(worker) {
+	const held = slots.get(worker) ?? /* @__PURE__ */ new Map();
+	slots.set(worker, held);
+	return held;
+}
+function takeSlot(held, service) {
+	const pair = held.get(service) ?? {
+		holders: 0,
+		slot: lowestFree(held)
+	};
+	pair.holders += 1;
+	held.set(service, pair);
+	return {
+		free: () => {
+			pair.holders -= 1;
+			if (pair.holders === 0) held.delete(service);
+		},
+		slot: pair.slot
+	};
+}
+function lowestFree(held) {
+	const taken = new Set([...held.values()].map((pair) => pair.slot));
+	let slot = 0;
+	while (taken.has(slot)) slot += 1;
+	return slot;
+}
+async function redisDriver() {
+	return await loadPeer("redis", "redis()", async () => await import("redis"));
+}
+var RedisHandle = class {
+	type = "redis";
+	serviceName = null;
+	defaultPort = 6379;
+	defaultImage;
+	environment = {};
+	containerOptions = PAIR_INDEXES;
+	connectionString = "";
+	dbIndex = 0;
+	/** What this handle holds: its slot's release, and the container's own string it extended. */
+	pair = null;
+	constructor(options = {}) {
+		this.defaultImage = options.image ?? SERVICE_IMAGES.redis;
+	}
+	buildConnectionString(host, port) {
+		return `redis://${host}:${port}`;
+	}
+	createDatabaseAdapter() {
+		return null;
+	}
+	async healthcheck() {
+		if (!this.connectionString) throw invariant("redis() was healthchecked before it had a connection string");
+		try {
+			const { createClient } = await redisDriver();
+			const client = createClient({ url: this.connectionString });
+			await client.connect();
+			await client.ping();
+			client.destroy();
+		} catch (error) {
+			throw new Error(refusal({
+				fix: "check the container is running and reachable (`docker ps`), and run again",
+				found: `redis() did not answer its healthcheck: ${driverReason(error)}`,
+				read: "docs/reference/services.md#service-factories",
+				why: "A declared service is handed to the chain once it answers its healthcheck."
+			}), { cause: error });
+		}
+	}
+	async initialize() {}
+	async reset() {
+		const { createClient } = await redisDriver();
+		const client = createClient({
+			url: this.connectionString,
+			database: this.dbIndex
+		});
+		await client.connect();
+		try {
+			await client.flushDb();
+		} finally {
+			client.destroy();
+		}
+	}
+	isolation() {
+		return {
+			acquire: async (workerId) => {
+				this.letGo();
+				const worker = Number.parseInt(workerId, 10) || 0;
+				const service = this.serviceName ?? this.type;
+				const { free, slot } = takeSlot(slotsOf(workerId), service);
+				if (slot >= SERVICES_PER_WORKER || worker > WORKERS) {
+					free();
+					throw new Error(refusal({
+						fix: slot >= SERVICES_PER_WORKER ? `declare fewer redis services: a worker holds ${SERVICES_PER_WORKER} at once` : `run with fewer workers (--maxWorkers): a container serves ${WORKERS}`,
+						found: `redis: worker ${workerId} has no database index for "${service}"`,
+						read: "docs/reference/services.md#per-worker-isolation",
+						why: "A redis container's indexes are shared out four per worker, so its workers and their services are counted."
+					}));
+				}
+				this.pair = {
+					free,
+					shared: this.connectionString
+				};
+				this.dbIndex = 1 + SERVICES_PER_WORKER * (Math.max(worker, 1) - 1) + slot;
+				this.connectionString = `${this.connectionString}/${this.dbIndex}`;
+				await this.reset();
+			},
+			reset: async () => {
+				await this.reset();
+			},
+			release: async () => {
+				try {
+					await this.reset();
+				} finally {
+					this.letGo();
+				}
+			}
+		};
+	}
+	letGo() {
+		if (this.pair === null) return;
+		this.pair.free();
+		this.connectionString = this.pair.shared;
+		this.pair = null;
+		this.dbIndex = 0;
+	}
+};
+/** Create a Redis service handle, reported under its record key. */
+function redis(options = {}) {
+	return new RedisHandle(options);
+}
+//#endregion
+//#region src/services/sqlite/sqlite-template.ts
+const SQLITE_FILE_HEADER = Buffer.from("SQLite format 3\0");
+function withDescriptor(path, flags, use) {
+	const fd = openSync(path, flags);
+	try {
+		return use(fd);
+	} finally {
+		closeSync(fd);
+	}
+}
+/** Checks the header only: enough to reject a 0-byte or truncated leftover. */
+function isValidSqliteTemplate(path) {
+	try {
+		return withDescriptor(path, "r", (fd) => {
+			const header = Buffer.alloc(SQLITE_FILE_HEADER.length);
+			return readSync(fd, header, 0, header.length, 0) === SQLITE_FILE_HEADER.length && header.equals(SQLITE_FILE_HEADER);
+		});
+	} catch {
+		return false;
+	}
+}
+const PRISMA_PUSH = "npx prisma db push --force-reset";
+/** `--schema` is required: without it Prisma's own discovery ignores the option, and only a machine without a cached template fails. */
+function prismaPushCommand(prismaSchema) {
+	if (prismaSchema === null) return PRISMA_PUSH;
+	return `${PRISMA_PUSH} --schema ${JSON.stringify(resolve(prismaSchema))}`;
+}
+const TEMPLATE_PREFIX = "template";
+const LOCK_STALE_MS = 12e4;
+function schemaBytes(path) {
+	try {
+		if (statSync(path).isDirectory()) return readdirSync(path).toSorted().map((entry) => schemaBytes(join(path, entry))).join("\0");
+		return `${path}\0${readFileSync(path, "utf8")}`;
+	} catch {
+		return `${path}\0<unreadable>`;
+	}
+}
+/** Editing a schema builds a new template: the stale file is header-valid and would never be rebuilt. */
+function sqliteTemplateName(options = {}) {
+	const [source, path] = options.prismaSchema === void 0 ? ["init", options.init] : ["prisma", options.prismaSchema];
+	const fingerprint = path === void 0 ? "empty" : `${source}\0${resolve(path)}\0${schemaBytes(resolve(path))}`;
+	const key = createHash("sha256").update(fingerprint).digest("hex").slice(0, 8);
+	return `${TEMPLATE_PREFIX}-${key}.sqlite`;
+}
+/** Per project, never the OS tmpdir: two checkouts sharing one template inherit each other's schema. */
+function sqliteTemplateDir(root) {
+	const dir = resolve(root, SQLITE_TEMPLATE_DIR);
+	mkdirSync(dir, { recursive: true });
+	return dir;
+}
+/** `wx` creates and claims the file in one syscall: two workers cannot both win and run `prisma db push` on one file. */
+function acquireTemplateLock(lockPath) {
+	try {
+		withDescriptor(lockPath, "wx", (fd) => writeSync(fd, process.pid.toString()));
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "EEXIST") return false;
+		throw error;
+	}
+	return true;
+}
+function releaseTemplateLock(lockPath) {
+	try {
+		unlinkSync(lockPath);
+	} catch {}
+}
+/** A lock that no longer exists is not stale: the waiter retries. */
+function isStaleTemplateLock(lockPath, now = Date.now()) {
+	try {
+		return now - statSync(lockPath).mtimeMs > LOCK_STALE_MS;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/services/sqlite/sqlite.adapter.ts
+let databaseConstructor = null;
+async function loadDatabase() {
+	if (databaseConstructor === null) {
+		const constructor = await loadPeer("better-sqlite3", "sqlite()", async () => {
+			return (await import("better-sqlite3")).default;
+		});
+		requireBuiltPeer("better-sqlite3", "sqlite()", () => {
+			new constructor(":memory:").close();
+		});
+		databaseConstructor = constructor;
+	}
+	return databaseConstructor;
+}
+function database() {
+	if (databaseConstructor === null) throw invariant("sqlite() was read before `initialize()` loaded its driver");
+	return databaseConstructor;
+}
+function openInWal(path) {
+	const db = new (database())(path);
+	db.pragma("journal_mode = WAL");
+	return db;
+}
+const LOCK_POLL_MS = 50;
+const SIDECARS = [
+	"",
+	"-wal",
+	"-shm"
+];
+function removeDatabaseFiles(path) {
+	for (const suffix of SIDECARS) rmSync(`${path}${suffix}`, { force: true });
+}
+function withDatabase(path, use) {
+	const db = new (database())(path);
+	try {
+		use(db);
+	} finally {
+		db.close();
+	}
+}
+var SqliteHandle = class {
+	type = "sqlite";
+	serviceName = null;
+	defaultPort = 0;
+	defaultImage = "";
+	environment = {};
+	connectionString = "";
+	db = null;
+	templatePath = "";
+	workerDbPath = "";
+	initSql;
+	prismaSchema;
+	options;
+	constructor(options = {}) {
+		this.options = options;
+		this.initSql = options.init ?? null;
+		this.prismaSchema = options.prismaSchema ?? null;
+	}
+	buildConnectionString() {
+		return `file:${this.workerDbPath || this.templatePath}`;
+	}
+	createDatabaseAdapter() {
+		return this;
+	}
+	async healthcheck() {}
+	/** One worker builds under an exclusive lock, the others wait: two concurrent `prisma db push` on one file is `database is locked`. */
+	async initialize(_dockerDir, root) {
+		await loadDatabase();
+		const projectRoot = root ?? discoverRoot(process.cwd());
+		this.templatePath = resolve(sqliteTemplateDir(projectRoot), sqliteTemplateName(this.options));
+		const lockPath = `${this.templatePath}.lock`;
+		for (;;) {
+			if (isValidSqliteTemplate(this.templatePath)) break;
+			if (!acquireTemplateLock(lockPath)) {
+				if (isStaleTemplateLock(lockPath)) releaseTemplateLock(lockPath);
+				else await pause(LOCK_POLL_MS);
+				continue;
+			}
+			try {
+				await this.buildTemplate();
+			} finally {
+				releaseTemplateLock(lockPath);
+			}
+			break;
+		}
+		this.connectionString = `file:${this.templatePath}`;
+	}
+	/** Built on a private path, then renamed into place: `prisma db push` writes the header long before the tables exist. */
+	async buildTemplate() {
+		const buildPath = `${this.templatePath}.${process.pid}.building`;
+		removeDatabaseFiles(buildPath);
+		try {
+			await this.writeTemplate(buildPath);
+			renameSync(buildPath, this.templatePath);
+		} finally {
+			removeDatabaseFiles(buildPath);
+		}
+	}
+	async writeTemplate(buildPath) {
+		if (this.prismaSchema !== null) {
+			const { runToCompletion } = await import("./shared-serve.js").then((n) => n.n);
+			runToCompletion(prismaPushCommand(this.prismaSchema), {
+				...process.env,
+				DATABASE_URL: `file:${buildPath}`,
+				PRISMA_USER_CONSENT_FOR_DANGEROUS_AI_ACTION: "yes"
+			});
+			withDatabase(buildPath, (db) => {
+				db.pragma("wal_checkpoint(TRUNCATE)");
+			});
+			return;
+		}
+		const { initSql } = this;
+		withDatabase(buildPath, (db) => {
+			if (initSql !== null) db.exec(readFileSync(initSql, "utf8"));
+			db.exec("VACUUM");
+		});
+	}
+	getDb() {
+		this.db ??= openInWal(this.workerDbPath || this.templatePath);
+		return this.db;
+	}
+	closeDb() {
+		this.db?.close();
+		this.db = null;
+	}
+	async seed(sql) {
+		this.getDb().exec(sql);
+	}
+	async query(table, columns) {
+		const columnList = columns.join(", ");
+		return this.getDb().prepare(`SELECT ${columnList} FROM "${table}" ORDER BY 1`).all().map((row) => columns.map((col) => row[col]));
+	}
+	async columns(table) {
+		return this.getDb().prepare(`PRAGMA table_info("${table}")`).all().map((row) => row.name);
+	}
+	async reset() {
+		const db = this.getDb();
+		const tables = db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE '_prisma%' AND name != 'sqlite_sequence'`).all();
+		for (const { name } of tables) db.exec(`DELETE FROM "${name}"`);
+		if (db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name = 'sqlite_sequence'`).get() !== void 0) db.exec("DELETE FROM sqlite_sequence");
+	}
+	isolation() {
+		return {
+			acquire: async (workerId) => {
+				this.closeDb();
+				this.workerDbPath = resolve(tmpdir(), `test-worker-${workerId}-${process.pid}-${Date.now()}.sqlite`);
+				copyFileSync(this.templatePath, this.workerDbPath);
+				this.connectionString = `file:${this.workerDbPath}`;
+			},
+			reset: async () => {
+				await this.reset();
+			},
+			release: async () => {
+				this.closeDb();
+				removeDatabaseFiles(this.workerDbPath);
+				this.workerDbPath = "";
+				this.connectionString = `file:${this.templatePath}`;
+			}
+		};
+	}
+};
+/** Create a SQLite service handle, isolated per test by file copy. */
+function sqlite(options = {}) {
+	return new SqliteHandle(options);
+}
+//#endregion
+export { ProcessHandle, postgres, processService as process, redis, sqlite };
+
+//# sourceMappingURL=services.js.map