@stratal/testing 0.0.0-canary-ff3a406 → 0.0.0-canary-ccb3f17

package/dist/database/index.d.mts

@@ -1,2 +1,2 @@
-import { a as TestDatabaseGlobalSetupOptions, c as createTestDatabaseGlobalSetup, d as deriveDbName, f as deriveTemplateName, i as ISOLATION_ENV_VAR, l as databasePrefix, m as normalizeIsolation, n as DEFAULT_DB_BINDING, o as buildConnectionString, p as dropDatabase, r as DatabaseIsolation, s as createDatabaseFromTemplate, t as BINDING_ENV_VAR, u as deriveAdminConnectionString } from "../index-BIr5nLof.mjs";
-export { BINDING_ENV_VAR, DEFAULT_DB_BINDING, type DatabaseIsolation, ISOLATION_ENV_VAR, type TestDatabaseGlobalSetupOptions, buildConnectionString, createDatabaseFromTemplate, createTestDatabaseGlobalSetup, databasePrefix, deriveAdminConnectionString, deriveDbName, deriveTemplateName, dropDatabase, normalizeIsolation };
+import { a as BINDING_ENV_VAR, c as buildConnectionString, d as deriveAdminConnectionString, f as deriveFileDbName, i as resetWorkerDatabase, l as createTestDatabaseGlobalSetup, m as ensureWorkerDatabase, n as buildTableDiscoverySql, o as DEFAULT_DB_BINDING, p as deriveTemplateName, r as buildTruncateSql, s as TestDatabaseGlobalSetupOptions, t as ResetOptions, u as databasePrefix } from "../index-DUScdrKC.mjs";
+export { BINDING_ENV_VAR, DEFAULT_DB_BINDING, type ResetOptions, type TestDatabaseGlobalSetupOptions, buildConnectionString, buildTableDiscoverySql, buildTruncateSql, createTestDatabaseGlobalSetup, databasePrefix, deriveAdminConnectionString, deriveFileDbName, deriveTemplateName, ensureWorkerDatabase, resetWorkerDatabase };

package/dist/database/index.mjs

@@ -1,2 +1,2 @@
-import { a as createDatabaseFromTemplate, c as deriveAdminConnectionString, d as dropDatabase, f as normalizeIsolation, i as buildConnectionString, l as deriveDbName, n as DEFAULT_DB_BINDING, o as createTestDatabaseGlobalSetup, r as ISOLATION_ENV_VAR, s as databasePrefix, t as BINDING_ENV_VAR, u as deriveTemplateName } from "../database-B02eYKhE.mjs";
-export { BINDING_ENV_VAR, DEFAULT_DB_BINDING, ISOLATION_ENV_VAR, buildConnectionString, createDatabaseFromTemplate, createTestDatabaseGlobalSetup, databasePrefix, deriveAdminConnectionString, deriveDbName, deriveTemplateName, dropDatabase, normalizeIsolation };
+import { a as DEFAULT_DB_BINDING, c as databasePrefix, d as deriveTemplateName, f as ensureWorkerDatabase, i as BINDING_ENV_VAR, l as deriveAdminConnectionString, n as buildTruncateSql, o as buildConnectionString, r as resetWorkerDatabase, s as createTestDatabaseGlobalSetup, t as buildTableDiscoverySql, u as deriveFileDbName } from "../database-DeMI4Igi.mjs";
+export { BINDING_ENV_VAR, DEFAULT_DB_BINDING, buildConnectionString, buildTableDiscoverySql, buildTruncateSql, createTestDatabaseGlobalSetup, databasePrefix, deriveAdminConnectionString, deriveFileDbName, deriveTemplateName, ensureWorkerDatabase, resetWorkerDatabase };

package/dist/{database-B02eYKhE.mjs → database-DeMI4Igi.mjs}

@@ -1,33 +1,23 @@
-import { createHash, randomUUID } from "node:crypto";
+import { createHash } from "node:crypto";
 import { readFileSync, readdirSync, statSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
 //#region src/database/test-database.ts
 /**
 * Test database isolation helpers.
 *
-* Implements database-per-test-file isolation for parallel e2e runs against
+* Implements database-per-worker isolation for parallel e2e runs against
 * Postgres. A migrated **template** database is built once in global setup;
-* each test file clones it instantly via `CREATE DATABASE ... TEMPLATE` and
-* drops it on teardown. See `@stratal/testing/database`.
+* each worker clones it once into a per-worker database that is reused (and
+* reset between tests, not dropped per file). See `@stratal/testing/database`.
 *
 * `pg` is imported dynamically so this module loads without it — consumers
 * that don't use a database never pay the dependency.
 */
-/** Env var that selects the isolation mode (single source of truth). */
-const ISOLATION_ENV_VAR = "STRATAL_TEST_DB_ISOLATION";
 /** Env var carrying the name of the Hyperdrive binding to isolate. */
 const BINDING_ENV_VAR = "STRATAL_TEST_DB_BINDING";
 /** Default Hyperdrive binding name when none is configured. */
 const DEFAULT_DB_BINDING = "DB";
 /**
-* Normalize an isolation value (from an option or env var) to a mode.
-* Anything other than the literal `'database'` resolves to `'shared'` — the
-* default — so parallel isolation is strictly opt-in.
-*/
-function normalizeIsolation(value) {
-	return value === "database" ? "database" : "shared";
-}
-/**
 * Postgres' identifier length limit. Names longer than this are silently
 * truncated by the server, which would cause distinct logical names to collide
 * on the same physical database. We assert against it everywhere a name is
@@ -35,7 +25,7 @@ function normalizeIsolation(value) {
 */
 const MAX_IDENTIFIER_LENGTH = 63;
 /** Quote a Postgres identifier for safe interpolation into DDL. */
-function quoteIdent(name) {
+function quoteIdent$1(name) {
 	return `"${name.replace(/"/g, "\"\"")}"`;
 }
 /** Quote a Postgres string literal for safe interpolation into SQL. */
@@ -47,7 +37,7 @@ function quoteLiteral(value) {
 * instead of a raw module-not-found when database isolation is requested
 * without the dependency installed.
 */
-async function importPg() {
+async function importPg$1() {
 	try {
 		const { default: pg } = await import("pg");
 		return pg;
@@ -83,31 +73,31 @@ function buildConnectionString(base, dbName) {
 	url.pathname = `/${dbName}`;
 	return url.toString();
 }
-/** Length of the random token appended by {@link deriveDbName}. */
-const DB_NAME_TOKEN_LENGTH = 12;
 /** The shared prefix for per-file databases, used as the leak-sweep key. */
 function databasePrefix(base) {
-	const prefix = `${databaseNameOf(base).replace(/[^a-z0-9_]/gi, "_")}_t_`;
-	assertIdentifierLength(`${prefix}${"x".repeat(DB_NAME_TOKEN_LENGTH)}`, "per-file database name");
-	return prefix;
+	return `${databaseNameOf(base).replace(/[^a-z0-9_]/gi, "_")}_f_`;
 }
-/** Name of the migrated template database cloned per file. */
+/** Name of the migrated template database cloned per worker. */
 function deriveTemplateName(base) {
 	const name = `${databaseNameOf(base).replace(/[^a-z0-9_]/gi, "_")}_template`;
 	assertIdentifierLength(name, "template database name");
 	return name;
 }
 /**
-* Generate a unique per-`compile()` database name. Random (not path-based) so
-* it is collision-free across concurrent isolates and multiple modules in the
-* same file, and stays well within Postgres' 63-char identifier limit.
+* Name of the database owned by a single test FILE, keyed by a per-file `token`.
+* Each test file clones the template into its OWN database — no two files ever
+* share one — because `@cloudflare/vitest-pool-workers` isolates per file and can
+* run a worker's files concurrently; per-file databases make cross-file
+* contamination impossible by construction. Asserted against Postgres' 63-char
+* identifier limit (keep the base name short so `_f_<token>` fits).
 */
-function deriveDbName(base) {
-	const token = randomUUID().replace(/-/g, "").slice(0, DB_NAME_TOKEN_LENGTH);
-	return `${databasePrefix(base)}${token}`;
+function deriveFileDbName(base, token) {
+	const name = `${databaseNameOf(base).replace(/[^a-z0-9_]/gi, "_")}_f_${token}`;
+	assertIdentifierLength(name, "per-file database name");
+	return name;
 }
 async function withAdminClient(adminConn, fn) {
-	const client = new (await (importPg())).Client({ connectionString: adminConn });
+	const client = new (await (importPg$1())).Client({ connectionString: adminConn });
 	await client.connect();
 	try {
 		return await fn((sql) => client.query(sql));
@@ -115,43 +105,63 @@ async function withAdminClient(adminConn, fn) {
 		await client.end();
 	}
 }
-const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-/** True for transient errors worth retrying a `CREATE DATABASE ... TEMPLATE`. */
-function isTemplateBusy(error) {
-	const e = error;
-	return e?.code === "55006" || /is being accessed by other users/i.test(e?.message ?? "");
+/** True when the error is Postgres' "duplicate database" (concurrent create). */
+function isDuplicateDatabase(error) {
+	return error?.code === "42P04";
 }
 /**
-* Terminate every backend connected to `dbName` except the caller's own. Used
-* to evict lingering sessions on the template database so `CREATE DATABASE ...
-* TEMPLATE` (which requires the source to have no other connections) succeeds.
+* True for SQLSTATE 55006 ("source database is being accessed by other users") —
+* what `CREATE DATABASE ... TEMPLATE t` raises while another session is using the
+* template (e.g. a concurrent clone of the same template).
 */
-async function terminateConnections(query, dbName) {
-	await query(`SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE datname = ${quoteLiteral(dbName)} AND pid <> pg_backend_pid()`);
+function isTemplateInUse(error) {
+	return error?.code === "55006";
+}
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/** True when a database with `dbName` already exists. */
+async function databaseExists(query, dbName) {
+	const { rows } = await query(`SELECT 1 AS one FROM pg_database WHERE datname = ${quoteLiteral(dbName)}`);
+	return rows.length > 0;
 }
 /**
-* Clone the template database into `dbName`. `CREATE DATABASE ... TEMPLATE`
-* fails (SQLSTATE 55006) if any session is connected to the template, so we
-* proactively terminate lingering template backends before each attempt and
-* retry with exponential backoff while a concurrent clone briefly locks it.
+* Ensure worker database `dbName` exists, cloned from `template`. Idempotent and
+* lock-frugal: it first checks `pg_database`, so the common "already exists" path
+* (every file after a slot's first) never issues `CREATE DATABASE ... TEMPLATE`
+* and never takes the clone lock.
+*
+* The clone is serialized across all workers and processes by one Postgres
+* advisory lock keyed on the template. Postgres permits only one
+* `CREATE DATABASE ... TEMPLATE t` at a time — a concurrent one fails with
+* SQLSTATE 55006. On a fresh run every worker's first compile races to clone the
+* same template, so without this they'd all fire `CREATE ... TEMPLATE` at once
+* and all but one would fail their first file. The lock funnels them one-at-a-
+* time, each blocking *in Postgres* (not busy-waiting) until its turn. A create
+* that still hits a transient 55006 is retried with backoff; one that loses the
+* race for the same name (SQLSTATE 42P04) is treated as success.
 */
-async function createDatabaseFromTemplate(adminConn, dbName, template, attempts = 10) {
-	const sql = `CREATE DATABASE ${quoteIdent(dbName)} TEMPLATE ${quoteIdent(template)}`;
-	for (let attempt = 0; attempt < attempts; attempt++) try {
-		await withAdminClient(adminConn, async (query) => {
-			await terminateConnections(query, template);
-			await query(sql);
-		});
-		return;
-	} catch (error) {
-		if (!isTemplateBusy(error) || attempt === attempts - 1) throw error;
-		const jitter = parseInt(randomUUID().slice(0, 2), 16);
-		await sleep(Math.min(50 * 2 ** attempt, 2e3) + jitter);
-	}
-}
-/** Drop a database, terminating any lingering connections. */
-async function dropDatabase(adminConn, dbName) {
-	await withAdminClient(adminConn, (query) => query(`DROP DATABASE IF EXISTS ${quoteIdent(dbName)} WITH (FORCE)`));
+async function ensureWorkerDatabase(adminConn, dbName, template) {
+	await withAdminClient(adminConn, async (query) => {
+		if (await databaseExists(query, dbName)) return;
+		const lockKey = quoteLiteral(`stratal:worker-db-clone:${template}`);
+		await query(`SELECT pg_advisory_lock(hashtext(${lockKey}))`);
+		try {
+			if (await databaseExists(query, dbName)) return;
+			const create = `CREATE DATABASE ${quoteIdent$1(dbName)} TEMPLATE ${quoteIdent$1(template)}`;
+			for (let attempt = 1;; attempt++) try {
+				await query(create);
+				return;
+			} catch (error) {
+				if (isDuplicateDatabase(error)) return;
+				if (isTemplateInUse(error) && attempt < 5) {
+					await sleep(250 * attempt);
+					continue;
+				}
+				throw error;
+			}
+		} finally {
+			await query(`SELECT pg_advisory_unlock(hashtext(${lockKey}))`);
+		}
+	});
 }
 /**
 * Drop leaked per-file databases matching the prefix while leaving a concurrent
@@ -169,7 +179,7 @@ async function sweepStaleDatabases(adminConn, prefix) {
 	const likePrefix = prefix.replace(/'/g, "''").replace(/[\\%_]/g, (c) => `\\${c}`);
 	await withAdminClient(adminConn, async (query) => {
 		const { rows } = await query(`SELECT d.datname FROM pg_database d WHERE d.datname LIKE '${likePrefix}%' ESCAPE '\\' AND NOT EXISTS (SELECT 1 FROM pg_stat_activity a WHERE a.datname = d.datname)`);
-		for (const { datname } of rows) await query(`DROP DATABASE IF EXISTS ${quoteIdent(datname)} WITH (FORCE)`);
+		for (const { datname } of rows) await query(`DROP DATABASE IF EXISTS ${quoteIdent$1(datname)} WITH (FORCE)`);
 	});
 }
 /**
@@ -236,12 +246,15 @@ function collectSchemaFiles(path) {
 	return [path];
 }
 /**
-* A content-derived fingerprint of the schema source(s) plus the migrate
-* routine. The template is reused across runs while this is unchanged; any edit
-* to a schema file — or to how migration runs — changes it and forces a rebuild.
-* Uses file basenames (not absolute paths) so it is stable across checkouts.
+* A content-derived fingerprint of the schema source(s) plus the migrate and
+* prepare routines. The template is reused across runs while this is
+* unchanged; any edit to a schema file — or to how migration/preparation run
+* — changes it and forces a rebuild. Uses file basenames (not absolute paths)
+* so it is stable across checkouts.
+*
+* @internal exported for fingerprint unit tests
 */
-function computeSchemaFingerprint(schema, migrate) {
+function computeSchemaFingerprint(schema, migrate, prepare) {
 	const roots = Array.isArray(schema) ? schema : [schema];
 	const files = roots.flatMap(collectSchemaFiles).sort();
 	if (files.length === 0) throw new Error(`[stratal-testing] No schema files found for fingerprinting under: ${roots.join(", ")}`);
@@ -253,6 +266,8 @@ function computeSchemaFingerprint(schema, migrate) {
 		hash.update("\0");
 	}
 	hash.update(migrate.toString());
+	hash.update("\0");
+	hash.update(prepare ? prepare.toString() : "");
 	return hash.digest("hex");
 }
 /**
@@ -268,24 +283,23 @@ async function readTemplateFingerprint(query, template) {
 /**
 * Build a Vitest `globalSetup` default export that prepares the test database.
 *
-* - `'shared'` (default): migrates the base database in place (no isolation).
-* - `'database'`: under a Postgres advisory lock (so concurrent setups across
-*   CI shards / multiple e2e projects don't clobber each other), sweeps leaked
-*   per-file databases, then ensures a migrated template exists — ready to be
-*   cloned per test file.
+* Under a Postgres advisory lock (so concurrent setups across CI shards /
+* multiple e2e projects don't clobber each other), sweeps leaked per-worker
+* databases, then ensures a migrated (and optionally prepared) template exists
+* — ready to be cloned per worker.
 *
 * **Template reuse.** The template is fingerprinted from the `schema` source(s)
-* + the `migrate` routine and the fingerprint is stored as the template's
-* database COMMENT. On each run, a matching fingerprint means the schema is
-* unchanged and the existing template is reused as-is — `migrate` runs **only**
-* on the first run after a schema edit (or on a fresh database). The fingerprint
-* is stamped only after a successful migrate, so a match always implies a
-* complete template; there is no force/skip flag — reuse is purely fingerprint-
-* driven.
+* + the `migrate` routine + the `prepare` routine, and the fingerprint is
+* stored as the template's database COMMENT. On each run, a matching
+* fingerprint means nothing has changed and the existing template is reused
+* as-is — `migrate`/`prepare` run **only** on the first run after an edit (or on
+* a fresh database). The fingerprint is stamped only after a successful
+* migrate + prepare, so a match always implies a complete template; there is no
+* force/skip flag — reuse is purely fingerprint-driven.
 *
 * **Concurrency model.** The reuse check + rebuild runs under
 * `pg_advisory_lock(hashtext(<template>))`, so only one process rebuilds the
-* template at a time. The stale-database sweep only drops per-file databases
+* template at a time. The stale-database sweep only drops per-worker databases
 * with **no active connections**, leaving a sibling process's live databases
 * intact. Teardown deliberately does **not** sweep or drop the template: a
 * concurrent process may still be using both, and the next run's setup sweep is
@@ -307,28 +321,81 @@ function createTestDatabaseGlobalSetup(opts) {
 	return async () => {
 		const base = opts.connectionString ?? process.env.DATABASE_URL;
 		if (!base) throw new Error("[stratal-testing] No connection string for test database setup. Set process.env.DATABASE_URL or pass `connectionString`.");
-		if (normalizeIsolation(opts.isolation ?? process.env["STRATAL_TEST_DB_ISOLATION"]) === "shared") {
-			await opts.migrate(base);
-			return;
-		}
-		if (!opts.schema) throw new Error("[stratal-testing] `schema` is required for database isolation. Pass the schema file(s) or directory so the migrated template can be reused across runs when unchanged (and rebuilt when it changes).");
 		const adminConn = deriveAdminConnectionString(base);
 		const template = opts.templateName ?? deriveTemplateName(base);
 		const prefix = databasePrefix(base);
-		const fingerprint = computeSchemaFingerprint(opts.schema, opts.migrate);
+		const fingerprint = computeSchemaFingerprint(opts.schema, opts.migrate, opts.prepare);
 		await withAdvisoryLock(adminConn, template, async () => {
 			await sweepStaleDatabases(adminConn, prefix);
 			if (await withAdminClient(adminConn, (query) => readTemplateFingerprint(query, template)) === fingerprint) return;
 			await withAdminClient(adminConn, async (query) => {
-				await query(`DROP DATABASE IF EXISTS ${quoteIdent(template)} WITH (FORCE)`);
-				await query(`CREATE DATABASE ${quoteIdent(template)}`);
+				await query(`DROP DATABASE IF EXISTS ${quoteIdent$1(template)} WITH (FORCE)`);
+				await query(`CREATE DATABASE ${quoteIdent$1(template)}`);
 			});
-			await opts.migrate(buildConnectionString(base, template));
-			await withAdminClient(adminConn, (query) => query(`COMMENT ON DATABASE ${quoteIdent(template)} IS ${quoteLiteral(fingerprint)}`));
+			const templateConn = buildConnectionString(base, template);
+			await opts.migrate(templateConn);
+			if (opts.prepare) await opts.prepare(templateConn);
+			await withAdminClient(adminConn, (query) => query(`COMMENT ON DATABASE ${quoteIdent$1(template)} IS ${quoteLiteral(fingerprint)}`));
 		});
 	};
 }
 //#endregion
-export { createDatabaseFromTemplate as a, deriveAdminConnectionString as c, dropDatabase as d, normalizeIsolation as f, buildConnectionString as i, deriveDbName as l, DEFAULT_DB_BINDING as n, createTestDatabaseGlobalSetup as o, ISOLATION_ENV_VAR as r, databasePrefix as s, BINDING_ENV_VAR as t, deriveTemplateName as u };
+//#region src/database/reset.ts
+function quoteIdent(ident) {
+	return `"${ident.replace(/"/g, "\"\"")}"`;
+}
+/**
+* Build a single `TRUNCATE ... RESTART IDENTITY CASCADE` (empty when no tables).
+* Takes `{ schema, table }` pairs and quotes each part independently, so a
+* dotted identifier (a legal quoted name, e.g. `"my.table"`) is preserved
+* verbatim rather than mis-split into extra qualifier segments.
+*/
+function buildTruncateSql(tables) {
+	if (tables.length === 0) return "";
+	return `TRUNCATE ${tables.map((t) => `${quoteIdent(t.schema)}.${quoteIdent(t.table)}`).join(", ")} RESTART IDENTITY CASCADE`;
+}
+/**
+* Sentinel meaning "the active search-path schema" (`current_schema()`). A
+* Symbol so it can never collide with a real schema name — a schema literally
+* named `current` is passed through as the string literal `'current'`.
+*/
+const CURRENT_SCHEMA = Symbol("current_schema");
+/**
+* Build the SQL that discovers truncatable tables: every base table in the
+* given schemas ({@link CURRENT_SCHEMA} → `current_schema()`), excluding
+* migration bookkeeping (`_prisma%`) and any caller-supplied preserve patterns.
+* Returns a SELECT of `schemaname, tablename`. Escaping lives here so both reset
+* paths share one implementation.
+*/
+function buildTableDiscoverySql(schemas, preserve) {
+	return `SELECT schemaname::text AS schemaname, tablename::text AS tablename FROM pg_tables WHERE schemaname IN (${[CURRENT_SCHEMA, ...schemas].map((s) => typeof s === "symbol" ? "current_schema()" : `'${s.replace(/'/g, "''")}'`).join(", ")}) AND ${["_prisma%", ...preserve].map((p) => `tablename NOT LIKE '${p.replace(/'/g, "''")}'`).join(" AND ")}`;
+}
+async function importPg() {
+	const { default: mod } = await import("pg");
+	return mod;
+}
+/**
+* Reset a worker database between tests: discover every non-preserved table in
+* the target schemas and truncate them in one statement. Fast because the
+* schema/DDL is baked into the worker DB — reset only clears mutable rows and
+* resets identities. Opens and closes a short-lived direct `pg` connection.
+*/
+async function resetWorkerDatabase(connectionString, opts = {}) {
+	const client = new (await (importPg())).Client({ connectionString });
+	await client.connect();
+	try {
+		const sql = buildTableDiscoverySql(opts.schemas ?? [], opts.preserve ?? []);
+		const { rows } = await client.query(sql);
+		const truncateSql = buildTruncateSql(rows.map((r) => ({
+			schema: r.schemaname,
+			table: r.tablename
+		})));
+		if (truncateSql) await client.query(truncateSql);
+	} finally {
+		await client.end();
+	}
+}
+//#endregion
+export { DEFAULT_DB_BINDING as a, databasePrefix as c, deriveTemplateName as d, ensureWorkerDatabase as f, BINDING_ENV_VAR as i, deriveAdminConnectionString as l, buildTruncateSql as n, buildConnectionString as o, resetWorkerDatabase as r, createTestDatabaseGlobalSetup as s, buildTableDiscoverySql as t, deriveFileDbName as u };
 
-//# sourceMappingURL=database-B02eYKhE.mjs.map
+//# sourceMappingURL=database-DeMI4Igi.mjs.map

package/dist/database-DeMI4Igi.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"database-DeMI4Igi.mjs","names":["quoteIdent","importPg"],"sources":["../src/database/test-database.ts","../src/database/reset.ts"],"sourcesContent":["/**\n * Test database isolation helpers.\n *\n * Implements database-per-worker isolation for parallel e2e runs against\n * Postgres. A migrated **template** database is built once in global setup;\n * each worker clones it once into a per-worker database that is reused (and\n * reset between tests, not dropped per file). See `@stratal/testing/database`.\n *\n * `pg` is imported dynamically so this module loads without it — consumers\n * that don't use a database never pay the dependency.\n */\n\nimport { createHash } from 'node:crypto'\nimport { readFileSync, readdirSync, statSync } from 'node:fs'\nimport { basename, dirname, join, resolve } from 'node:path'\n\nimport type pg from 'pg'\n\n/** Env var carrying the name of the Hyperdrive binding to isolate. */\nexport const BINDING_ENV_VAR = 'STRATAL_TEST_DB_BINDING'\n\n/** Default Hyperdrive binding name when none is configured. */\nexport const DEFAULT_DB_BINDING = 'DB'\n\n/**\n * Postgres' identifier length limit. Names longer than this are silently\n * truncated by the server, which would cause distinct logical names to collide\n * on the same physical database. We assert against it everywhere a name is\n * derived.\n */\nconst MAX_IDENTIFIER_LENGTH = 63\n\n/** Quote a Postgres identifier for safe interpolation into DDL. */\nfunction quoteIdent(name: string): string {\n  return `\"${name.replace(/\"/g, '\"\"')}\"`\n}\n\n/** Quote a Postgres string literal for safe interpolation into SQL. */\nfunction quoteLiteral(value: string): string {\n  return `'${value.replace(/'/g, \"''\")}'`\n}\n\n/**\n * Dynamically import `pg` (an optional peer), surfacing an actionable error\n * instead of a raw module-not-found when database isolation is requested\n * without the dependency installed.\n */\nasync function importPg(): Promise<typeof pg> {\n  try {\n    const { default: pg } = await import('pg')\n    return pg\n  } catch (error) {\n    throw new Error(\n      \"[stratal-testing] `pg` is required for database isolation but is not installed. \" +\n        'Install it: `npm install --save-dev pg` (or `yarn add -D pg`).',\n      { cause: error },\n    )\n  }\n}\n\n/**\n * Assert a derived identifier fits within Postgres' {@link MAX_IDENTIFIER_LENGTH}\n * limit. Throws a clear, actionable error instead of letting the server\n * silently truncate and collide names.\n */\nfunction assertIdentifierLength(name: string, kind: string): void {\n  if (name.length > MAX_IDENTIFIER_LENGTH) {\n    throw new Error(\n      `[stratal-testing] Derived ${kind} \"${name}\" is ${name.length} characters, ` +\n        `exceeding Postgres' ${MAX_IDENTIFIER_LENGTH}-character identifier limit. ` +\n        'Use a shorter base database name so the test-isolation suffix fits.',\n    )\n  }\n}\n\n/** Parse the database name out of a Postgres connection URL. */\nfunction databaseNameOf(connectionString: string): string {\n  const name = new URL(connectionString).pathname.replace(/^\\//, '')\n  return name || 'postgres'\n}\n\n/**\n * Derive an admin connection string pointing at the `postgres` maintenance\n * database. `CREATE`/`DROP DATABASE` cannot run on a connection bound to the\n * target database, so administration always goes through `postgres`.\n */\nexport function deriveAdminConnectionString(connectionString: string): string {\n  const url = new URL(connectionString)\n  url.pathname = '/postgres'\n  return url.toString()\n}\n\n/** Build a connection string identical to `base` but pointing at `dbName`. */\nexport function buildConnectionString(base: string, dbName: string): string {\n  const url = new URL(base)\n  url.pathname = `/${dbName}`\n  return url.toString()\n}\n\n/** The shared prefix for per-file databases, used as the leak-sweep key. */\nexport function databasePrefix(base: string): string {\n  const baseName = databaseNameOf(base).replace(/[^a-z0-9_]/gi, '_')\n  return `${baseName}_f_`\n}\n\n/** Name of the migrated template database cloned per worker. */\nexport function deriveTemplateName(base: string): string {\n  const name = `${databaseNameOf(base).replace(/[^a-z0-9_]/gi, '_')}_template`\n  assertIdentifierLength(name, 'template database name')\n  return name\n}\n\n/**\n * Name of the database owned by a single test FILE, keyed by a per-file `token`.\n * Each test file clones the template into its OWN database — no two files ever\n * share one — because `@cloudflare/vitest-pool-workers` isolates per file and can\n * run a worker's files concurrently; per-file databases make cross-file\n * contamination impossible by construction. Asserted against Postgres' 63-char\n * identifier limit (keep the base name short so `_f_<token>` fits).\n */\nexport function deriveFileDbName(base: string, token: string): string {\n  const baseName = databaseNameOf(base).replace(/[^a-z0-9_]/gi, '_')\n  const name = `${baseName}_f_${token}`\n  assertIdentifierLength(name, 'per-file database name')\n  return name\n}\n\nasync function withAdminClient<T>(adminConn: string, fn: (query: (sql: string) => Promise<unknown>) => Promise<T>): Promise<T> {\n  const pg = await importPg()\n  const client = new pg.Client({ connectionString: adminConn })\n  await client.connect()\n  try {\n    return await fn((sql) => client.query(sql))\n  } finally {\n    await client.end()\n  }\n}\n\n/** True when the error is Postgres' \"duplicate database\" (concurrent create). */\nfunction isDuplicateDatabase(error: unknown): boolean {\n  return (error as { code?: string })?.code === '42P04'\n}\n\n/**\n * True for SQLSTATE 55006 (\"source database is being accessed by other users\") —\n * what `CREATE DATABASE ... TEMPLATE t` raises while another session is using the\n * template (e.g. a concurrent clone of the same template).\n */\nfunction isTemplateInUse(error: unknown): boolean {\n  return (error as { code?: string })?.code === '55006'\n}\n\nconst sleep = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms))\n\n/** True when a database with `dbName` already exists. */\nasync function databaseExists(\n  query: (sql: string) => Promise<unknown>,\n  dbName: string,\n): Promise<boolean> {\n  const { rows } = (await query(\n    `SELECT 1 AS one FROM pg_database WHERE datname = ${quoteLiteral(dbName)}`,\n  )) as { rows: unknown[] }\n  return rows.length > 0\n}\n\n/**\n * Ensure worker database `dbName` exists, cloned from `template`. Idempotent and\n * lock-frugal: it first checks `pg_database`, so the common \"already exists\" path\n * (every file after a slot's first) never issues `CREATE DATABASE ... TEMPLATE`\n * and never takes the clone lock.\n *\n * The clone is serialized across all workers and processes by one Postgres\n * advisory lock keyed on the template. Postgres permits only one\n * `CREATE DATABASE ... TEMPLATE t` at a time — a concurrent one fails with\n * SQLSTATE 55006. On a fresh run every worker's first compile races to clone the\n * same template, so without this they'd all fire `CREATE ... TEMPLATE` at once\n * and all but one would fail their first file. The lock funnels them one-at-a-\n * time, each blocking *in Postgres* (not busy-waiting) until its turn. A create\n * that still hits a transient 55006 is retried with backoff; one that loses the\n * race for the same name (SQLSTATE 42P04) is treated as success.\n */\nexport async function ensureWorkerDatabase(\n  adminConn: string,\n  dbName: string,\n  template: string,\n): Promise<void> {\n  await withAdminClient(adminConn, async (query) => {\n    if (await databaseExists(query, dbName)) return\n\n    const lockKey = quoteLiteral(`stratal:worker-db-clone:${template}`)\n    await query(`SELECT pg_advisory_lock(hashtext(${lockKey}))`)\n    try {\n      // A sibling worker may have cloned it while we waited for the lock.\n      if (await databaseExists(query, dbName)) return\n      const create = `CREATE DATABASE ${quoteIdent(dbName)} TEMPLATE ${quoteIdent(template)}`\n      for (let attempt = 1; ; attempt++) {\n        try {\n          await query(create)\n          return\n        } catch (error) {\n          if (isDuplicateDatabase(error)) return\n          if (isTemplateInUse(error) && attempt < 5) {\n            await sleep(250 * attempt)\n            continue\n          }\n          throw error\n        }\n      }\n    } finally {\n      await query(`SELECT pg_advisory_unlock(hashtext(${lockKey}))`)\n    }\n  })\n}\n\n/**\n * Drop leaked per-file databases matching the prefix while leaving a concurrent\n * process's **live** databases intact.\n *\n * Multiple setups can run at once (CI sharding, several e2e projects). A blanket\n * \"drop everything matching the prefix\" sweep would delete a sibling process's\n * in-flight per-file databases. So we only drop databases that currently have\n * **no active backend connections** — i.e. true leaks from a crashed prior run.\n * A live per-file database always has the test worker's pool connected, so it is\n * skipped. The `WITH (FORCE)` covers the narrow race where a connection appears\n * between the check and the drop.\n */\nasync function sweepStaleDatabases(adminConn: string, prefix: string): Promise<void> {\n  // Escape both the SQL-string quote and the LIKE metacharacters (`\\`, `%`, `_`)\n  // so a prefix containing `_` (a single-char wildcard) can't over-match and drop\n  // an unrelated database. `\\` is the explicit ESCAPE character below.\n  const likePrefix = prefix\n    .replace(/'/g, \"''\")\n    .replace(/[\\\\%_]/g, (c) => `\\\\${c}`)\n  await withAdminClient(adminConn, async (query) => {\n    const { rows } = (await query(\n      `SELECT d.datname FROM pg_database d ` +\n        `WHERE d.datname LIKE '${likePrefix}%' ESCAPE '\\\\' ` +\n        `AND NOT EXISTS (SELECT 1 FROM pg_stat_activity a WHERE a.datname = d.datname)`,\n    )) as { rows: { datname: string }[] }\n    for (const { datname } of rows) {\n      await query(`DROP DATABASE IF EXISTS ${quoteIdent(datname)} WITH (FORCE)`)\n    }\n  })\n}\n\n/**\n * Run `fn` while holding a session-level Postgres advisory lock keyed to\n * `lockKey`, serializing template setup across concurrent processes (CI\n * sharding, multiple e2e projects) so they don't drop/recreate the template out\n * from under each other. The lock is released in `finally`.\n */\nasync function withAdvisoryLock<T>(adminConn: string, lockKey: string, fn: () => Promise<T>): Promise<T> {\n  return withAdminClient(adminConn, async (query) => {\n    await query(`SELECT pg_advisory_lock(hashtext(${quoteLiteral(lockKey)}))`)\n    try {\n      return await fn()\n    } finally {\n      await query(`SELECT pg_advisory_unlock(hashtext(${quoteLiteral(lockKey)}))`)\n    }\n  })\n}\n\n/** Schema source file extensions hashed into the template fingerprint. */\nconst SCHEMA_FILE_RE = /\\.(zmodel|prisma|sql)$/\n\n/** Matches ZModel `import \"...\"` / `import '...'` statements. */\nconst ZMODEL_IMPORT_RE = /^\\s*import\\s+['\"]([^'\"]+)['\"]/gm\n\n/**\n * Follow a ZModel file's `import` graph, collecting the root plus every\n * transitively imported `.zmodel` file — ZenStack supports multi-file schemas,\n * so editing an imported file must invalidate the fingerprint. Import paths\n * resolve relative to the importing file; the `.zmodel` extension is optional.\n * A missing import target is skipped (migration surfaces the real error).\n */\nfunction collectZmodelImports(file: string, seen: Set<string>): void {\n  if (seen.has(file)) return\n  let content: string\n  try {\n    content = readFileSync(file, 'utf8')\n  } catch {\n    return // missing import target — not part of the fingerprint\n  }\n  seen.add(file)\n  for (const [, importPath] of content.matchAll(ZMODEL_IMPORT_RE)) {\n    const target = resolve(dirname(file), importPath)\n    collectZmodelImports(target.endsWith('.zmodel') ? target : `${target}.zmodel`, seen)\n  }\n}\n\n/**\n * Expand a schema path into the concrete files to hash. A directory contributes\n * every schema file in its tree; a single `.zmodel` file contributes its whole\n * `import` graph; any other file contributes itself.\n */\nfunction collectSchemaFiles(path: string): string[] {\n  if (statSync(path).isDirectory()) {\n    const out: string[] = []\n    for (const entry of readdirSync(path, { withFileTypes: true })) {\n      const full = join(path, entry.name)\n      if (entry.isDirectory()) out.push(...collectSchemaFiles(full))\n      else if (SCHEMA_FILE_RE.test(entry.name)) out.push(full)\n    }\n    return out\n  }\n  if (path.endsWith('.zmodel')) {\n    const seen = new Set<string>()\n    collectZmodelImports(path, seen)\n    return [...seen]\n  }\n  return [path]\n}\n\n/**\n * A content-derived fingerprint of the schema source(s) plus the migrate and\n * prepare routines. The template is reused across runs while this is\n * unchanged; any edit to a schema file — or to how migration/preparation run\n * — changes it and forces a rebuild. Uses file basenames (not absolute paths)\n * so it is stable across checkouts.\n *\n * @internal exported for fingerprint unit tests\n */\nexport function computeSchemaFingerprint(\n  schema: string | string[],\n  migrate: TestDatabaseGlobalSetupOptions['migrate'],\n  prepare?: TestDatabaseGlobalSetupOptions['prepare'],\n): string {\n  const roots = Array.isArray(schema) ? schema : [schema]\n  const files = roots.flatMap(collectSchemaFiles).sort()\n  if (files.length === 0) {\n    throw new Error(\n      `[stratal-testing] No schema files found for fingerprinting under: ${roots.join(', ')}`,\n    )\n  }\n  const hash = createHash('sha256')\n  for (const file of files) {\n    hash.update(basename(file))\n    hash.update('\\0')\n    hash.update(readFileSync(file))\n    hash.update('\\0')\n  }\n  hash.update(migrate.toString())\n  hash.update('\\0')\n  hash.update(prepare ? prepare.toString() : '')\n  return hash.digest('hex')\n}\n\n/**\n * Read the template database's stored schema fingerprint (kept as the database\n * COMMENT). Returns `null` when the template does not exist or carries no\n * fingerprint. Database comments are NOT copied by `CREATE DATABASE ...\n * TEMPLATE`, so per-file clones never inherit it.\n */\nasync function readTemplateFingerprint(\n  query: (sql: string) => Promise<unknown>,\n  template: string,\n): Promise<string | null> {\n  const { rows } = (await query(\n    `SELECT shobj_description(oid, 'pg_database') AS fingerprint ` +\n      `FROM pg_database WHERE datname = ${quoteLiteral(template)}`,\n  )) as { rows: { fingerprint: string | null }[] }\n  return rows.length === 0 ? null : rows[0].fingerprint\n}\n\n/** Options for {@link createTestDatabaseGlobalSetup}. */\nexport interface TestDatabaseGlobalSetupOptions {\n  /** Run migrations against the template connection string. */\n  migrate: (connectionString: string) => void | Promise<void>\n  /**\n   * Schema source(s) — file or directory path(s). Contents + `migrate` + `prepare`\n   * are hashed into the template fingerprint; the template is reused across runs\n   * while unchanged. For a ZenStack multi-file schema pass the root `.zmodel`.\n   */\n  schema: string | string[]\n  /**\n   * One-time preparation run against the template **after** migrations (before\n   * the fingerprint is stamped). Bake expensive baseline state here — seed data,\n   * a default tenant schema, reference rows — so every worker database inherits\n   * it via the clone instead of rebuilding it per test.\n   *\n   * The fingerprint hashes this hook's **source text only** — if `prepare` reads\n   * external data files (seed JSON/SQL) at runtime, changing only those files\n   * will NOT invalidate the template. Bump the hook's source (e.g. a version\n   * comment) or drop the template manually when seed data changes.\n   */\n  prepare?: (connectionString: string) => void | Promise<void>\n  /** Base/admin connection string. Defaults to `process.env.DATABASE_URL`. */\n  connectionString?: string\n  /** Template database name. Defaults to `<baseDbName>_template`. */\n  templateName?: string\n}\n\n/**\n * Build a Vitest `globalSetup` default export that prepares the test database.\n *\n * Under a Postgres advisory lock (so concurrent setups across CI shards /\n * multiple e2e projects don't clobber each other), sweeps leaked per-worker\n * databases, then ensures a migrated (and optionally prepared) template exists\n * — ready to be cloned per worker.\n *\n * **Template reuse.** The template is fingerprinted from the `schema` source(s)\n * + the `migrate` routine + the `prepare` routine, and the fingerprint is\n * stored as the template's database COMMENT. On each run, a matching\n * fingerprint means nothing has changed and the existing template is reused\n * as-is — `migrate`/`prepare` run **only** on the first run after an edit (or on\n * a fresh database). The fingerprint is stamped only after a successful\n * migrate + prepare, so a match always implies a complete template; there is no\n * force/skip flag — reuse is purely fingerprint-driven.\n *\n * **Concurrency model.** The reuse check + rebuild runs under\n * `pg_advisory_lock(hashtext(<template>))`, so only one process rebuilds the\n * template at a time. The stale-database sweep only drops per-worker databases\n * with **no active connections**, leaving a sibling process's live databases\n * intact. Teardown deliberately does **not** sweep or drop the template: a\n * concurrent process may still be using both, and the next run's setup sweep is\n * the backstop for any leak.\n *\n * @example\n * ```ts\n * // test/global-setup.ts\n * import { createTestDatabaseGlobalSetup } from '@stratal/testing/database'\n *\n * export default createTestDatabaseGlobalSetup({\n *   schema: schemaPath, // file or directory — reused-when-unchanged fingerprint\n *   migrate: (conn) => execFileSync(zenstackBin, ['db', 'push', '--force-reset', `--schema=${schemaPath}`, '--accept-data-loss'],\n *     { env: { ...process.env, DATABASE_URL: conn }, stdio: 'inherit' }),\n * })\n * ```\n */\nexport function createTestDatabaseGlobalSetup(\n  opts: TestDatabaseGlobalSetupOptions,\n): () => Promise<void> {\n  return async () => {\n    const base = opts.connectionString ?? process.env.DATABASE_URL\n    if (!base) {\n      throw new Error(\n        '[stratal-testing] No connection string for test database setup. Set process.env.DATABASE_URL or pass `connectionString`.',\n      )\n    }\n\n    const adminConn = deriveAdminConnectionString(base)\n    const template = opts.templateName ?? deriveTemplateName(base)\n    const prefix = databasePrefix(base)\n    const fingerprint = computeSchemaFingerprint(opts.schema, opts.migrate, opts.prepare)\n\n    // Serialize template rebuild across concurrent setups so they don't drop or\n    // migrate the template out from under each other.\n    await withAdvisoryLock(adminConn, template, async () => {\n      await sweepStaleDatabases(adminConn, prefix)\n\n      // Reuse the existing template when its stored fingerprint matches — the\n      // schema is unchanged, so the migrated template is ready to clone. Only a\n      // fingerprint mismatch (or a missing template) pays the migration cost.\n      const current = await withAdminClient(adminConn, (query) =>\n        readTemplateFingerprint(query, template),\n      )\n      if (current === fingerprint) return\n\n      await withAdminClient(adminConn, async (query) => {\n        await query(`DROP DATABASE IF EXISTS ${quoteIdent(template)} WITH (FORCE)`)\n        await query(`CREATE DATABASE ${quoteIdent(template)}`)\n      })\n      const templateConn = buildConnectionString(base, template)\n      await opts.migrate(templateConn)\n      if (opts.prepare) await opts.prepare(templateConn)\n      // Stamp the fingerprint only after a successful migrate + prepare, so a\n      // matching fingerprint always implies a complete, ready template. Database\n      // COMMENTs are not copied by CREATE DATABASE ... TEMPLATE, so clones stay\n      // clean.\n      await withAdminClient(adminConn, (query) =>\n        query(`COMMENT ON DATABASE ${quoteIdent(template)} IS ${quoteLiteral(fingerprint)}`),\n      )\n    })\n\n    // No teardown hook: anything destructive here (sweeping per-worker databases\n    // or dropping the template) could clobber a concurrent process that is still\n    // running. The next run's setup sweep (connection-guarded) reclaims leaks.\n  }\n}\n","import type pg from 'pg'\n\n/** Options controlling which tables a per-test reset truncates. */\nexport interface ResetOptions {\n  /** Extra schemas to include beyond `current_schema()` (e.g. a tenant schema). */\n  schemas?: string[]\n  /**\n   * Bare table names or SQL LIKE patterns (matched against `tablename` across\n   * all target schemas) that must survive the reset — reference/seed data baked\n   * into the template. Not schema-qualified: a `schema.table` entry matches a\n   * table literally named `schema.table`, not `table` in `schema`. Migration\n   * bookkeeping (`_prisma%`) is always preserved.\n   */\n  preserve?: string[]\n}\n\nfunction quoteIdent(ident: string): string {\n  return `\"${ident.replace(/\"/g, '\"\"')}\"`\n}\n\n/**\n * Build a single `TRUNCATE ... RESTART IDENTITY CASCADE` (empty when no tables).\n * Takes `{ schema, table }` pairs and quotes each part independently, so a\n * dotted identifier (a legal quoted name, e.g. `\"my.table\"`) is preserved\n * verbatim rather than mis-split into extra qualifier segments.\n */\nexport function buildTruncateSql(tables: { schema: string; table: string }[]): string {\n  if (tables.length === 0) return ''\n  const quoted = tables.map((t) => `${quoteIdent(t.schema)}.${quoteIdent(t.table)}`)\n  return `TRUNCATE ${quoted.join(', ')} RESTART IDENTITY CASCADE`\n}\n\n/**\n * Sentinel meaning \"the active search-path schema\" (`current_schema()`). A\n * Symbol so it can never collide with a real schema name — a schema literally\n * named `current` is passed through as the string literal `'current'`.\n */\nconst CURRENT_SCHEMA = Symbol('current_schema')\n\n/**\n * Build the SQL that discovers truncatable tables: every base table in the\n * given schemas ({@link CURRENT_SCHEMA} → `current_schema()`), excluding\n * migration bookkeeping (`_prisma%`) and any caller-supplied preserve patterns.\n * Returns a SELECT of `schemaname, tablename`. Escaping lives here so both reset\n * paths share one implementation.\n */\nexport function buildTableDiscoverySql(schemas: string[], preserve: string[]): string {\n  const schemaFilter = [CURRENT_SCHEMA, ...schemas]\n    .map((s) => (typeof s === 'symbol' ? 'current_schema()' : `'${s.replace(/'/g, \"''\")}'`))\n    .join(', ')\n  const notLike = ['_prisma%', ...preserve]\n    .map((p) => `tablename NOT LIKE '${p.replace(/'/g, \"''\")}'`)\n    .join(' AND ')\n  return `SELECT schemaname::text AS schemaname, tablename::text AS tablename FROM pg_tables WHERE schemaname IN (${schemaFilter}) AND ${notLike}`\n}\n\nasync function importPg(): Promise<typeof pg> {\n  const { default: mod } = await import('pg')\n  return mod\n}\n\n/**\n * Reset a worker database between tests: discover every non-preserved table in\n * the target schemas and truncate them in one statement. Fast because the\n * schema/DDL is baked into the worker DB — reset only clears mutable rows and\n * resets identities. Opens and closes a short-lived direct `pg` connection.\n */\nexport async function resetWorkerDatabase(connectionString: string, opts: ResetOptions = {}): Promise<void> {\n  const pgMod = await importPg()\n  const client = new pgMod.Client({ connectionString })\n  await client.connect()\n  try {\n    const sql = buildTableDiscoverySql(opts.schemas ?? [], opts.preserve ?? [])\n    const { rows } = await client.query<{ schemaname: string; tablename: string }>(sql)\n    const tables = rows.map((r) => ({ schema: r.schemaname, table: r.tablename }))\n    const truncateSql = buildTruncateSql(tables)\n    if (truncateSql) await client.query(truncateSql)\n  } finally {\n    await client.end()\n  }\n}\n"],"mappings":"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"}

package/dist/{decorate-B7nr7eBl.mjs → decorate-ZDdbRmsv.mjs}

@@ -1,4 +1,4 @@
-//#region \0@oxc-project+runtime@0.133.0/helpers/esm/decorate.js
+//#region \0@oxc-project+runtime@0.140.0/helpers/esm/decorate.js
 function __decorate(decorators, target, key, desc) {
 	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
 	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);

package/dist/feature-flags/index.mjs

@@ -1,2 +1,2 @@
-import { n as FakeFeatureFlagService, t as FEATURE_FLAG_SERVICE_TOKEN } from "../feature-flags-BiLhfSGh.mjs";
+import { n as FakeFeatureFlagService, t as FEATURE_FLAG_SERVICE_TOKEN } from "../feature-flags-BMYurC1B.mjs";
 export { FEATURE_FLAG_SERVICE_TOKEN, FakeFeatureFlagService };

package/dist/{feature-flags-BiLhfSGh.mjs → feature-flags-BMYurC1B.mjs}

@@ -1,4 +1,4 @@
-import { t as __decorate } from "./decorate-B7nr7eBl.mjs";
+import { t as __decorate } from "./decorate-ZDdbRmsv.mjs";
 import { Singleton } from "stratal/di";
 //#region src/feature-flags/fake-feature-flag.service.ts
 /**
@@ -83,4 +83,4 @@ FakeFeatureFlagService = __decorate([Singleton(FEATURE_FLAG_SERVICE_TOKEN)], Fak
 //#endregion
 export { FakeFeatureFlagService as n, FEATURE_FLAG_SERVICE_TOKEN as t };
 
-//# sourceMappingURL=feature-flags-BiLhfSGh.mjs.map
+//# sourceMappingURL=feature-flags-BMYurC1B.mjs.map

package/dist/{feature-flags-BiLhfSGh.mjs.map → feature-flags-BMYurC1B.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"feature-flags-BiLhfSGh.mjs","names":[],"sources":["../src/feature-flags/fake-feature-flag.service.ts"],"sourcesContent":["import { Singleton } from 'stratal/di';\n\n/**\n * Global DI token for the feature-flags service.\n *\n * Mirrors `FEATURE_FLAG_TOKENS.FeatureFlagService` from `@stratal/feature-flags`\n * — `Symbol.for(...)` resolves to the same symbol across packages via the global\n * registry. Declared here so `@stratal/testing` needs no dependency on the\n * optional feature-flags package. Keep this string in sync with\n * `packages/feature-flags/src/feature-flags.tokens.ts`.\n */\nexport const FEATURE_FLAG_SERVICE_TOKEN = Symbol.for('stratal:feature-flags:service')\n\n/** A value a feature flag can resolve to. */\nexport type FlagValue = boolean | string | number | object\n\ninterface FakeFlagDetails<T> {\n  flagKey: string\n  value: T\n  reason: string\n}\n\n/**\n * FakeFeatureFlagService\n *\n * In-memory stand-in for `@stratal/feature-flags`'s request-scoped\n * `FeatureFlagService`, auto-registered by the testing module so feature-gated\n * code resolves without a real Cloudflare Flagship binding (which only exists at\n * runtime). Mirrors the real service's public evaluation surface.\n *\n * Unset flags return the per-call default (or the type's zero value). Configure\n * values with {@link set} / {@link setAll}; access it in tests via\n * `module.featureFlags`.\n *\n * @example\n * ```typescript\n * module.featureFlags.set('new-checkout', true)\n * const enabled = await flags.getBooleanValue('new-checkout') // true\n * ```\n */\n@Singleton(FEATURE_FLAG_SERVICE_TOKEN)\nexport class FakeFeatureFlagService {\n  private readonly flags = new Map<string, FlagValue>()\n\n  // ==================== CONFIGURATION ====================\n\n  /** Set a single flag value. */\n  set(flagKey: string, value: FlagValue): this {\n    this.flags.set(flagKey, value)\n    return this\n  }\n\n  /** Replace all configured flags with the given map. */\n  setAll(flags: Record<string, FlagValue>): this {\n    this.reset()\n    for (const [key, value] of Object.entries(flags)) this.flags.set(key, value)\n    return this\n  }\n\n  /** Clear every configured flag. */\n  reset(): this {\n    this.flags.clear()\n    return this\n  }\n\n  // ==================== EVALUATION ====================\n\n  async get(flagKey: string, defaultValue?: unknown): Promise<unknown> {\n    return Promise.resolve(this.flags.has(flagKey) ? this.flags.get(flagKey) : defaultValue)\n  }\n\n  async getBooleanValue(flagKey: string, defaultValue = false): Promise<boolean> {\n    return this.resolve(flagKey, defaultValue)\n  }\n\n  async getStringValue(flagKey: string, defaultValue = ''): Promise<string> {\n    return this.resolve(flagKey, defaultValue)\n  }\n\n  async getNumberValue(flagKey: string, defaultValue = 0): Promise<number> {\n    return this.resolve(flagKey, defaultValue)\n  }\n\n  async getObjectValue<T extends object>(flagKey: string, defaultValue: T = {} as T): Promise<T> {\n    return this.resolve(flagKey, defaultValue)\n  }\n\n  async getBooleanDetails(flagKey: string, defaultValue = false): Promise<FakeFlagDetails<boolean>> {\n    return this.details(flagKey, await this.getBooleanValue(flagKey, defaultValue))\n  }\n\n  async getStringDetails(flagKey: string, defaultValue = ''): Promise<FakeFlagDetails<string>> {\n    return this.details(flagKey, await this.getStringValue(flagKey, defaultValue))\n  }\n\n  async getNumberDetails(flagKey: string, defaultValue = 0): Promise<FakeFlagDetails<number>> {\n    return this.details(flagKey, await this.getNumberValue(flagKey, defaultValue))\n  }\n\n  async getObjectDetails<T extends object>(flagKey: string, defaultValue: T = {} as T): Promise<FakeFlagDetails<T>> {\n    return this.details(flagKey, await this.getObjectValue(flagKey, defaultValue))\n  }\n\n  /** Returns every configured flag as a `{ key: value }` map. */\n  async all(): Promise<Record<string, FlagValue>> {\n    return Promise.resolve(Object.fromEntries(this.flags))\n  }\n\n  /** Switching Flagship apps is a no-op in the fake. */\n  use(): this {\n    return this\n  }\n\n  /** The binding name this instance targets. */\n  // oxlint-disable-next-line typescript/class-literal-property-style\n  get app(): string {\n    return 'fake'\n  }\n\n  // ==================== INTERNAL ====================\n\n  private resolve<T extends FlagValue>(flagKey: string, defaultValue: T): Promise<T> {\n    return Promise.resolve(this.flags.has(flagKey) ? (this.flags.get(flagKey) as T) : defaultValue)\n  }\n\n  private details<T>(flagKey: string, value: T): FakeFlagDetails<T> {\n    return { flagKey, value, reason: 'fake' }\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAWA,MAAa,6BAA6B,OAAO,IAAI,+BAA+B;AA8B7E,IAAA,yBAAA,MAAM,uBAAuB;CAClC,wBAAyB,IAAI,IAAuB;;CAKpD,IAAI,SAAiB,OAAwB;EAC3C,KAAK,MAAM,IAAI,SAAS,KAAK;EAC7B,OAAO;CACT;;CAGA,OAAO,OAAwC;EAC7C,KAAK,MAAM;EACX,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,KAAK,GAAG,KAAK,MAAM,IAAI,KAAK,KAAK;EAC3E,OAAO;CACT;;CAGA,QAAc;EACZ,KAAK,MAAM,MAAM;EACjB,OAAO;CACT;CAIA,MAAM,IAAI,SAAiB,cAA0C;EACnE,OAAO,QAAQ,QAAQ,KAAK,MAAM,IAAI,OAAO,IAAI,KAAK,MAAM,IAAI,OAAO,IAAI,YAAY;CACzF;CAEA,MAAM,gBAAgB,SAAiB,eAAe,OAAyB;EAC7E,OAAO,KAAK,QAAQ,SAAS,YAAY;CAC3C;CAEA,MAAM,eAAe,SAAiB,eAAe,IAAqB;EACxE,OAAO,KAAK,QAAQ,SAAS,YAAY;CAC3C;CAEA,MAAM,eAAe,SAAiB,eAAe,GAAoB;EACvE,OAAO,KAAK,QAAQ,SAAS,YAAY;CAC3C;CAEA,MAAM,eAAiC,SAAiB,eAAkB,CAAC,GAAoB;EAC7F,OAAO,KAAK,QAAQ,SAAS,YAAY;CAC3C;CAEA,MAAM,kBAAkB,SAAiB,eAAe,OAA0C;EAChG,OAAO,KAAK,QAAQ,SAAS,MAAM,KAAK,gBAAgB,SAAS,YAAY,CAAC;CAChF;CAEA,MAAM,iBAAiB,SAAiB,eAAe,IAAsC;EAC3F,OAAO,KAAK,QAAQ,SAAS,MAAM,KAAK,eAAe,SAAS,YAAY,CAAC;CAC/E;CAEA,MAAM,iBAAiB,SAAiB,eAAe,GAAqC;EAC1F,OAAO,KAAK,QAAQ,SAAS,MAAM,KAAK,eAAe,SAAS,YAAY,CAAC;CAC/E;CAEA,MAAM,iBAAmC,SAAiB,eAAkB,CAAC,GAAqC;EAChH,OAAO,KAAK,QAAQ,SAAS,MAAM,KAAK,eAAe,SAAS,YAAY,CAAC;CAC/E;;CAGA,MAAM,MAA0C;EAC9C,OAAO,QAAQ,QAAQ,OAAO,YAAY,KAAK,KAAK,CAAC;CACvD;;CAGA,MAAY;EACV,OAAO;CACT;;CAIA,IAAI,MAAc;EAChB,OAAO;CACT;CAIA,QAAqC,SAAiB,cAA6B;EACjF,OAAO,QAAQ,QAAQ,KAAK,MAAM,IAAI,OAAO,IAAK,KAAK,MAAM,IAAI,OAAO,IAAU,YAAY;CAChG;CAEA,QAAmB,SAAiB,OAA8B;EAChE,OAAO;GAAE;GAAS;GAAO,QAAQ;EAAO;CAC1C;AACF;qCAxFC,UAAU,0BAA0B,CAAA,GAAA,sBAAA"}
+{"version":3,"file":"feature-flags-BMYurC1B.mjs","names":[],"sources":["../src/feature-flags/fake-feature-flag.service.ts"],"sourcesContent":["import { Singleton } from 'stratal/di';\n\n/**\n * Global DI token for the feature-flags service.\n *\n * Mirrors `FEATURE_FLAG_TOKENS.FeatureFlagService` from `@stratal/feature-flags`\n * — `Symbol.for(...)` resolves to the same symbol across packages via the global\n * registry. Declared here so `@stratal/testing` needs no dependency on the\n * optional feature-flags package. Keep this string in sync with\n * `packages/feature-flags/src/feature-flags.tokens.ts`.\n */\nexport const FEATURE_FLAG_SERVICE_TOKEN = Symbol.for('stratal:feature-flags:service')\n\n/** A value a feature flag can resolve to. */\nexport type FlagValue = boolean | string | number | object\n\ninterface FakeFlagDetails<T> {\n  flagKey: string\n  value: T\n  reason: string\n}\n\n/**\n * FakeFeatureFlagService\n *\n * In-memory stand-in for `@stratal/feature-flags`'s request-scoped\n * `FeatureFlagService`, auto-registered by the testing module so feature-gated\n * code resolves without a real Cloudflare Flagship binding (which only exists at\n * runtime). Mirrors the real service's public evaluation surface.\n *\n * Unset flags return the per-call default (or the type's zero value). Configure\n * values with {@link set} / {@link setAll}; access it in tests via\n * `module.featureFlags`.\n *\n * @example\n * ```typescript\n * module.featureFlags.set('new-checkout', true)\n * const enabled = await flags.getBooleanValue('new-checkout') // true\n * ```\n */\n@Singleton(FEATURE_FLAG_SERVICE_TOKEN)\nexport class FakeFeatureFlagService {\n  private readonly flags = new Map<string, FlagValue>()\n\n  // ==================== CONFIGURATION ====================\n\n  /** Set a single flag value. */\n  set(flagKey: string, value: FlagValue): this {\n    this.flags.set(flagKey, value)\n    return this\n  }\n\n  /** Replace all configured flags with the given map. */\n  setAll(flags: Record<string, FlagValue>): this {\n    this.reset()\n    for (const [key, value] of Object.entries(flags)) this.flags.set(key, value)\n    return this\n  }\n\n  /** Clear every configured flag. */\n  reset(): this {\n    this.flags.clear()\n    return this\n  }\n\n  // ==================== EVALUATION ====================\n\n  async get(flagKey: string, defaultValue?: unknown): Promise<unknown> {\n    return Promise.resolve(this.flags.has(flagKey) ? this.flags.get(flagKey) : defaultValue)\n  }\n\n  async getBooleanValue(flagKey: string, defaultValue = false): Promise<boolean> {\n    return this.resolve(flagKey, defaultValue)\n  }\n\n  async getStringValue(flagKey: string, defaultValue = ''): Promise<string> {\n    return this.resolve(flagKey, defaultValue)\n  }\n\n  async getNumberValue(flagKey: string, defaultValue = 0): Promise<number> {\n    return this.resolve(flagKey, defaultValue)\n  }\n\n  async getObjectValue<T extends object>(flagKey: string, defaultValue: T = {} as T): Promise<T> {\n    return this.resolve(flagKey, defaultValue)\n  }\n\n  async getBooleanDetails(flagKey: string, defaultValue = false): Promise<FakeFlagDetails<boolean>> {\n    return this.details(flagKey, await this.getBooleanValue(flagKey, defaultValue))\n  }\n\n  async getStringDetails(flagKey: string, defaultValue = ''): Promise<FakeFlagDetails<string>> {\n    return this.details(flagKey, await this.getStringValue(flagKey, defaultValue))\n  }\n\n  async getNumberDetails(flagKey: string, defaultValue = 0): Promise<FakeFlagDetails<number>> {\n    return this.details(flagKey, await this.getNumberValue(flagKey, defaultValue))\n  }\n\n  async getObjectDetails<T extends object>(flagKey: string, defaultValue: T = {} as T): Promise<FakeFlagDetails<T>> {\n    return this.details(flagKey, await this.getObjectValue(flagKey, defaultValue))\n  }\n\n  /** Returns every configured flag as a `{ key: value }` map. */\n  async all(): Promise<Record<string, FlagValue>> {\n    return Promise.resolve(Object.fromEntries(this.flags))\n  }\n\n  /** Switching Flagship apps is a no-op in the fake. */\n  use(): this {\n    return this\n  }\n\n  /** The binding name this instance targets. */\n  // oxlint-disable-next-line typescript/class-literal-property-style\n  get app(): string {\n    return 'fake'\n  }\n\n  // ==================== INTERNAL ====================\n\n  private resolve<T extends FlagValue>(flagKey: string, defaultValue: T): Promise<T> {\n    return Promise.resolve(this.flags.has(flagKey) ? (this.flags.get(flagKey) as T) : defaultValue)\n  }\n\n  private details<T>(flagKey: string, value: T): FakeFlagDetails<T> {\n    return { flagKey, value, reason: 'fake' }\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAWA,MAAa,6BAA6B,OAAO,IAAI,+BAA+B;AA8B7E,IAAM,yBAAN,MAAM,uBAAuB;CAClC,wBAAyB,IAAI,IAAuB;;CAKpD,IAAI,SAAiB,OAAwB;EAC3C,KAAK,MAAM,IAAI,SAAS,KAAK;EAC7B,OAAO;CACT;;CAGA,OAAO,OAAwC;EAC7C,KAAK,MAAM;EACX,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,KAAK,GAAG,KAAK,MAAM,IAAI,KAAK,KAAK;EAC3E,OAAO;CACT;;CAGA,QAAc;EACZ,KAAK,MAAM,MAAM;EACjB,OAAO;CACT;CAIA,MAAM,IAAI,SAAiB,cAA0C;EACnE,OAAO,QAAQ,QAAQ,KAAK,MAAM,IAAI,OAAO,IAAI,KAAK,MAAM,IAAI,OAAO,IAAI,YAAY;CACzF;CAEA,MAAM,gBAAgB,SAAiB,eAAe,OAAyB;EAC7E,OAAO,KAAK,QAAQ,SAAS,YAAY;CAC3C;CAEA,MAAM,eAAe,SAAiB,eAAe,IAAqB;EACxE,OAAO,KAAK,QAAQ,SAAS,YAAY;CAC3C;CAEA,MAAM,eAAe,SAAiB,eAAe,GAAoB;EACvE,OAAO,KAAK,QAAQ,SAAS,YAAY;CAC3C;CAEA,MAAM,eAAiC,SAAiB,eAAkB,CAAC,GAAoB;EAC7F,OAAO,KAAK,QAAQ,SAAS,YAAY;CAC3C;CAEA,MAAM,kBAAkB,SAAiB,eAAe,OAA0C;EAChG,OAAO,KAAK,QAAQ,SAAS,MAAM,KAAK,gBAAgB,SAAS,YAAY,CAAC;CAChF;CAEA,MAAM,iBAAiB,SAAiB,eAAe,IAAsC;EAC3F,OAAO,KAAK,QAAQ,SAAS,MAAM,KAAK,eAAe,SAAS,YAAY,CAAC;CAC/E;CAEA,MAAM,iBAAiB,SAAiB,eAAe,GAAqC;EAC1F,OAAO,KAAK,QAAQ,SAAS,MAAM,KAAK,eAAe,SAAS,YAAY,CAAC;CAC/E;CAEA,MAAM,iBAAmC,SAAiB,eAAkB,CAAC,GAAqC;EAChH,OAAO,KAAK,QAAQ,SAAS,MAAM,KAAK,eAAe,SAAS,YAAY,CAAC;CAC/E;;CAGA,MAAM,MAA0C;EAC9C,OAAO,QAAQ,QAAQ,OAAO,YAAY,KAAK,KAAK,CAAC;CACvD;;CAGA,MAAY;EACV,OAAO;CACT;;CAIA,IAAI,MAAc;EAChB,OAAO;CACT;CAIA,QAAqC,SAAiB,cAA6B;EACjF,OAAO,QAAQ,QAAQ,KAAK,MAAM,IAAI,OAAO,IAAK,KAAK,MAAM,IAAI,OAAO,IAAU,YAAY;CAChG;CAEA,QAAmB,SAAiB,OAA8B;EAChE,OAAO;GAAE;GAAS;GAAO,QAAQ;EAAO;CAC1C;AACF;AAxFC,yBAAA,WAAA,CAAA,UAAU,0BAA0B,CAAA,GAAA,sBAAA"}