@warlock.js/core 4.12.0 → 4.14.0

package/esm/tests/test-helpers.mjs

@@ -20,17 +20,38 @@ function getTestServerUrl() {
 * Uses native fetch - lightweight, no extra dependencies
 */
 async function testRequest(path, options = {}) {
+	return sendRequest(path, options, false);
+}
+/**
+* The single place a request is actually built.
+*
+* `serializedJson` says whether THIS module turned the caller's value into a
+* JSON string. It is the only thing that justifies setting a JSON content type:
+* a `FormData` body carries a multipart boundary the runtime generates, and
+* labelling it `application/json` produces a request no server can parse.
+*/
+async function sendRequest(path, options, serializedJson) {
 	const baseUrl = getTestServerUrl();
 	const url = path.startsWith("/") ? `${baseUrl}${path}` : `${baseUrl}/${path}`;
+	const headers = new Headers(options.headers);
+	if (serializedJson && !headers.has("content-type")) headers.set("content-type", "application/json");
 	return fetch(url, {
 		...options,
-		headers: {
-			"Content-Type": "application/json",
-			...options.headers
-		}
+		headers
 	});
 }
 /**
+* Serialize a body for a JSON request.
+*
+* `undefined` means the caller omitted the argument; every other value —
+* including `false`, `0`, `""` and `null` — is a legal JSON document and must
+* be sent. The old check was `body ? JSON.stringify(body) : undefined`, which
+* dropped all four.
+*/
+function jsonBody(body) {
+	return body === void 0 ? void 0 : JSON.stringify(body);
+}
+/**
 * GET request helper
 */
 async function testGet(path, options = {}) {
@@ -43,21 +64,21 @@ async function testGet(path, options = {}) {
 * POST request helper
 */
 async function testPost(path, body, options = {}) {
-	return testRequest(path, {
+	return sendRequest(path, {
 		...options,
 		method: "POST",
-		body: body ? JSON.stringify(body) : void 0
-	});
+		body: jsonBody(body)
+	}, body !== void 0);
 }
 /**
 * PUT request helper
 */
 async function testPut(path, body, options = {}) {
-	return testRequest(path, {
+	return sendRequest(path, {
 		...options,
 		method: "PUT",
-		body: body ? JSON.stringify(body) : void 0
-	});
+		body: jsonBody(body)
+	}, body !== void 0);
 }
 /**
 * DELETE request helper
@@ -72,11 +93,11 @@ async function testDelete(path, options = {}) {
 * PATCH request helper
 */
 async function testPatch(path, body, options = {}) {
-	return testRequest(path, {
+	return sendRequest(path, {
 		...options,
 		method: "PATCH",
-		body: body ? JSON.stringify(body) : void 0
-	});
+		body: jsonBody(body)
+	}, body !== void 0);
 }
 /**
 * Parse JSON response with type safety

package/esm/tests/test-helpers.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"test-helpers.mjs","names":[],"sources":["../../../../../../../core/src/tests/test-helpers.ts"],"sourcesContent":["/**\n * Warlock.js Test Helpers\n *\n * Utilities for testing Warlock.js applications.\n */\n\nimport { config } from \"../config\";\nimport { TEST_SERVER_PORT_ENV_KEY } from \"./test-server-port-channel\";\n\n/**\n * Get the test server base URL\n */\nexport function getTestServerUrl(): string {\n  // `startHttpTestServer` publishes the port it actually bound. Test workers are\n  // separate processes whose own config resolves `http.port` from `.env`, so\n  // without this a suite started on an explicit port would send every request to\n  // the `.env` port instead of the one the server is listening on.\n  const publishedPort = process.env[TEST_SERVER_PORT_ENV_KEY];\n  const port = publishedPort || config.key(\"http.port\", 2031);\n  const host = config.key(\"http.host\", \"localhost\");\n  return `http://${host}:${port}`;\n}\n\n/**\n * Simple HTTP request helper for test server\n * Uses native fetch - lightweight, no extra dependencies\n */\nexport async function testRequest(path: string, options: RequestInit = {}): Promise<Response> {\n  const baseUrl = getTestServerUrl();\n  const url = path.startsWith(\"/\") ? `${baseUrl}${path}` : `${baseUrl}/${path}`;\n\n  return fetch(url, {\n    ...options,\n    headers: {\n      \"Content-Type\": \"application/json\",\n      ...options.headers,\n    },\n  });\n}\n\n/**\n * GET request helper\n */\nexport async function testGet(path: string, options: RequestInit = {}): Promise<Response> {\n  return testRequest(path, { ...options, method: \"GET\" });\n}\n\n/**\n * POST request helper\n */\nexport async function testPost(\n  path: string,\n  body?: unknown,\n  options: RequestInit = {},\n): Promise<Response> {\n  return testRequest(path, {\n    ...options,\n    method: \"POST\",\n    body: body ? JSON.stringify(body) : undefined,\n  });\n}\n\n/**\n * PUT request helper\n */\nexport async function testPut(\n  path: string,\n  body?: unknown,\n  options: RequestInit = {},\n): Promise<Response> {\n  return testRequest(path, {\n    ...options,\n    method: \"PUT\",\n    body: body ? JSON.stringify(body) : undefined,\n  });\n}\n\n/**\n * DELETE request helper\n */\nexport async function testDelete(path: string, options: RequestInit = {}): Promise<Response> {\n  return testRequest(path, { ...options, method: \"DELETE\" });\n}\n\n/**\n * PATCH request helper\n */\nexport async function testPatch(\n  path: string,\n  body?: unknown,\n  options: RequestInit = {},\n): Promise<Response> {\n  return testRequest(path, {\n    ...options,\n    method: \"PATCH\",\n    body: body ? JSON.stringify(body) : undefined,\n  });\n}\n\n/**\n * Parse JSON response with type safety\n */\nexport async function parseJsonResponse<T>(response: Response): Promise<T> {\n  return response.json() as Promise<T>;\n}\n\n/**\n * Assert response status and return parsed JSON\n */\nexport async function expectJson<T>(response: Response, expectedStatus = 200): Promise<T> {\n  if (response.status !== expectedStatus) {\n    const text = await response.text();\n    throw new Error(`Expected status ${expectedStatus}, got ${response.status}. Body: ${text}`);\n  }\n  return parseJsonResponse<T>(response);\n}\n"],"mappings":";;;;;;;;;;;;;AAYA,SAAgB,mBAA2B;CAMzC,MAAM,OADgB,QAAQ,mCACA,OAAO,IAAI,aAAa,IAAI;CAE1D,OAAO,UADM,OAAO,IAAI,aAAa,WACjB,EAAE,GAAG;AAC3B;;;;;AAMA,eAAsB,YAAY,MAAc,UAAuB,CAAC,GAAsB;CAC5F,MAAM,UAAU,iBAAiB;CACjC,MAAM,MAAM,KAAK,WAAW,GAAG,IAAI,GAAG,UAAU,SAAS,GAAG,QAAQ,GAAG;CAEvE,OAAO,MAAM,KAAK;EAChB,GAAG;EACH,SAAS;GACP,gBAAgB;GAChB,GAAG,QAAQ;EACb;CACF,CAAC;AACH;;;;AAKA,eAAsB,QAAQ,MAAc,UAAuB,CAAC,GAAsB;CACxF,OAAO,YAAY,MAAM;EAAE,GAAG;EAAS,QAAQ;CAAM,CAAC;AACxD;;;;AAKA,eAAsB,SACpB,MACA,MACA,UAAuB,CAAC,GACL;CACnB,OAAO,YAAY,MAAM;EACvB,GAAG;EACH,QAAQ;EACR,MAAM,OAAO,KAAK,UAAU,IAAI,IAAI;CACtC,CAAC;AACH;;;;AAKA,eAAsB,QACpB,MACA,MACA,UAAuB,CAAC,GACL;CACnB,OAAO,YAAY,MAAM;EACvB,GAAG;EACH,QAAQ;EACR,MAAM,OAAO,KAAK,UAAU,IAAI,IAAI;CACtC,CAAC;AACH;;;;AAKA,eAAsB,WAAW,MAAc,UAAuB,CAAC,GAAsB;CAC3F,OAAO,YAAY,MAAM;EAAE,GAAG;EAAS,QAAQ;CAAS,CAAC;AAC3D;;;;AAKA,eAAsB,UACpB,MACA,MACA,UAAuB,CAAC,GACL;CACnB,OAAO,YAAY,MAAM;EACvB,GAAG;EACH,QAAQ;EACR,MAAM,OAAO,KAAK,UAAU,IAAI,IAAI;CACtC,CAAC;AACH;;;;AAKA,eAAsB,kBAAqB,UAAgC;CACzE,OAAO,SAAS,KAAK;AACvB;;;;AAKA,eAAsB,WAAc,UAAoB,iBAAiB,KAAiB;CACxF,IAAI,SAAS,WAAW,gBAAgB;EACtC,MAAM,OAAO,MAAM,SAAS,KAAK;EACjC,MAAM,IAAI,MAAM,mBAAmB,eAAe,QAAQ,SAAS,OAAO,UAAU,MAAM;CAC5F;CACA,OAAO,kBAAqB,QAAQ;AACtC"}
+{"version":3,"file":"test-helpers.mjs","names":[],"sources":["../../../../../../../core/src/tests/test-helpers.ts"],"sourcesContent":["/**\n * Warlock.js Test Helpers\n *\n * Utilities for testing Warlock.js applications.\n */\n\nimport { config } from \"../config\";\nimport { TEST_SERVER_PORT_ENV_KEY } from \"./test-server-port-channel\";\n\n/**\n * Get the test server base URL\n */\nexport function getTestServerUrl(): string {\n  // `startHttpTestServer` publishes the port it actually bound. Test workers are\n  // separate processes whose own config resolves `http.port` from `.env`, so\n  // without this a suite started on an explicit port would send every request to\n  // the `.env` port instead of the one the server is listening on.\n  const publishedPort = process.env[TEST_SERVER_PORT_ENV_KEY];\n  const port = publishedPort || config.key(\"http.port\", 2031);\n  const host = config.key(\"http.host\", \"localhost\");\n  return `http://${host}:${port}`;\n}\n\n/**\n * Simple HTTP request helper for test server\n * Uses native fetch - lightweight, no extra dependencies\n */\nexport async function testRequest(path: string, options: RequestInit = {}): Promise<Response> {\n  return sendRequest(path, options, false);\n}\n\n/**\n * The single place a request is actually built.\n *\n * `serializedJson` says whether THIS module turned the caller's value into a\n * JSON string. It is the only thing that justifies setting a JSON content type:\n * a `FormData` body carries a multipart boundary the runtime generates, and\n * labelling it `application/json` produces a request no server can parse.\n */\nasync function sendRequest(\n  path: string,\n  options: RequestInit,\n  serializedJson: boolean,\n): Promise<Response> {\n  const baseUrl = getTestServerUrl();\n  const url = path.startsWith(\"/\") ? `${baseUrl}${path}` : `${baseUrl}/${path}`;\n\n  // Normalised through `Headers` rather than object-spread: `RequestInit.headers`\n  // may be a record, a `Headers` instance, or a list of `[name, value]` tuples,\n  // and spreading the last two silently produces an object with numeric keys —\n  // the header is simply lost, with no error anywhere.\n  const headers = new Headers(options.headers);\n\n  if (serializedJson && !headers.has(\"content-type\")) {\n    headers.set(\"content-type\", \"application/json\");\n  }\n\n  return fetch(url, { ...options, headers });\n}\n\n/**\n * Serialize a body for a JSON request.\n *\n * `undefined` means the caller omitted the argument; every other value —\n * including `false`, `0`, `\"\"` and `null` — is a legal JSON document and must\n * be sent. The old check was `body ? JSON.stringify(body) : undefined`, which\n * dropped all four.\n */\nfunction jsonBody(body: unknown): string | undefined {\n  return body === undefined ? undefined : JSON.stringify(body);\n}\n\n/**\n * GET request helper\n */\nexport async function testGet(path: string, options: RequestInit = {}): Promise<Response> {\n  return testRequest(path, { ...options, method: \"GET\" });\n}\n\n/**\n * POST request helper\n */\nexport async function testPost(\n  path: string,\n  body?: unknown,\n  options: RequestInit = {},\n): Promise<Response> {\n  return sendRequest(path, { ...options, method: \"POST\", body: jsonBody(body) }, body !== undefined);\n}\n\n/**\n * PUT request helper\n */\nexport async function testPut(\n  path: string,\n  body?: unknown,\n  options: RequestInit = {},\n): Promise<Response> {\n  return sendRequest(path, { ...options, method: \"PUT\", body: jsonBody(body) }, body !== undefined);\n}\n\n/**\n * DELETE request helper\n */\nexport async function testDelete(path: string, options: RequestInit = {}): Promise<Response> {\n  return testRequest(path, { ...options, method: \"DELETE\" });\n}\n\n/**\n * PATCH request helper\n */\nexport async function testPatch(\n  path: string,\n  body?: unknown,\n  options: RequestInit = {},\n): Promise<Response> {\n  return sendRequest(path, { ...options, method: \"PATCH\", body: jsonBody(body) }, body !== undefined);\n}\n\n/**\n * Parse JSON response with type safety\n */\nexport async function parseJsonResponse<T>(response: Response): Promise<T> {\n  return response.json() as Promise<T>;\n}\n\n/**\n * Assert response status and return parsed JSON\n */\nexport async function expectJson<T>(response: Response, expectedStatus = 200): Promise<T> {\n  if (response.status !== expectedStatus) {\n    const text = await response.text();\n    throw new Error(`Expected status ${expectedStatus}, got ${response.status}. Body: ${text}`);\n  }\n  return parseJsonResponse<T>(response);\n}\n"],"mappings":";;;;;;;;;;;;;AAYA,SAAgB,mBAA2B;CAMzC,MAAM,OADgB,QAAQ,mCACA,OAAO,IAAI,aAAa,IAAI;CAE1D,OAAO,UADM,OAAO,IAAI,aAAa,WACjB,EAAE,GAAG;AAC3B;;;;;AAMA,eAAsB,YAAY,MAAc,UAAuB,CAAC,GAAsB;CAC5F,OAAO,YAAY,MAAM,SAAS,KAAK;AACzC;;;;;;;;;AAUA,eAAe,YACb,MACA,SACA,gBACmB;CACnB,MAAM,UAAU,iBAAiB;CACjC,MAAM,MAAM,KAAK,WAAW,GAAG,IAAI,GAAG,UAAU,SAAS,GAAG,QAAQ,GAAG;CAMvE,MAAM,UAAU,IAAI,QAAQ,QAAQ,OAAO;CAE3C,IAAI,kBAAkB,CAAC,QAAQ,IAAI,cAAc,GAC/C,QAAQ,IAAI,gBAAgB,kBAAkB;CAGhD,OAAO,MAAM,KAAK;EAAE,GAAG;EAAS;CAAQ,CAAC;AAC3C;;;;;;;;;AAUA,SAAS,SAAS,MAAmC;CACnD,OAAO,SAAS,SAAY,SAAY,KAAK,UAAU,IAAI;AAC7D;;;;AAKA,eAAsB,QAAQ,MAAc,UAAuB,CAAC,GAAsB;CACxF,OAAO,YAAY,MAAM;EAAE,GAAG;EAAS,QAAQ;CAAM,CAAC;AACxD;;;;AAKA,eAAsB,SACpB,MACA,MACA,UAAuB,CAAC,GACL;CACnB,OAAO,YAAY,MAAM;EAAE,GAAG;EAAS,QAAQ;EAAQ,MAAM,SAAS,IAAI;CAAE,GAAG,SAAS,MAAS;AACnG;;;;AAKA,eAAsB,QACpB,MACA,MACA,UAAuB,CAAC,GACL;CACnB,OAAO,YAAY,MAAM;EAAE,GAAG;EAAS,QAAQ;EAAO,MAAM,SAAS,IAAI;CAAE,GAAG,SAAS,MAAS;AAClG;;;;AAKA,eAAsB,WAAW,MAAc,UAAuB,CAAC,GAAsB;CAC3F,OAAO,YAAY,MAAM;EAAE,GAAG;EAAS,QAAQ;CAAS,CAAC;AAC3D;;;;AAKA,eAAsB,UACpB,MACA,MACA,UAAuB,CAAC,GACL;CACnB,OAAO,YAAY,MAAM;EAAE,GAAG;EAAS,QAAQ;EAAS,MAAM,SAAS,IAAI;CAAE,GAAG,SAAS,MAAS;AACpG;;;;AAKA,eAAsB,kBAAqB,UAAgC;CACzE,OAAO,SAAS,KAAK;AACvB;;;;AAKA,eAAsB,WAAc,UAAoB,iBAAiB,KAAiB;CACxF,IAAI,SAAS,WAAW,gBAAgB;EACtC,MAAM,OAAO,MAAM,SAAS,KAAK;EACjC,MAAM,IAAI,MAAM,mBAAmB,eAAe,QAAQ,SAAS,OAAO,UAAU,MAAM;CAC5F;CACA,OAAO,kBAAqB,QAAQ;AACtC"}

package/esm/tests/test-lifecycle-state.mjs

@@ -0,0 +1,27 @@
+//#region ../core/src/tests/test-lifecycle-state.ts
+/**
+* Where the registry hangs off the runtime context.
+*
+* @internal Exported for specs, which must be able to reach the same slot the
+* implementation uses — a spec that could only reset module state would be
+* testing the very assumption this module rejects. Deliberately not re-exported
+* from `src/tests/index.ts`.
+*/
+const TEST_LIFECYCLE_REGISTRY_KEY = Symbol.for("@warlock.js/core:tests:lifecycle");
+/**
+* Read the runtime context's lifecycle registry, creating it on first use.
+*
+* @internal
+*/
+function getTestLifecycleRegistry() {
+	const host = globalThis;
+	const registry = host[TEST_LIFECYCLE_REGISTRY_KEY];
+	if (registry) return registry;
+	const freshRegistry = { state: "idle" };
+	host[TEST_LIFECYCLE_REGISTRY_KEY] = freshRegistry;
+	return freshRegistry;
+}
+
+//#endregion
+export { getTestLifecycleRegistry };
+//# sourceMappingURL=test-lifecycle-state.mjs.map

package/esm/tests/test-lifecycle-state.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-lifecycle-state.mjs","names":[],"sources":["../../../../../../../core/src/tests/test-lifecycle-state.ts"],"sourcesContent":["/**\n * Lifecycle bookkeeping for the worker test runtime.\n *\n * Owns one thing: WHERE the state lives. `setupTest` / `teardownTest` own what\n * the transitions mean.\n *\n * The storage rule is the defect this module exists to fix. A module-scoped\n * `let` is rebuilt for every test file — measured across `forks|threads` ×\n * `isolate true|false` in `proofs/2026-08-12-nova-vitest-setupfiles-lifetime.md`\n * — while the worker itself, and every socket, pool and timer it holds, can\n * survive that rebuild. State that resets precisely where live resources do not\n * is not a guard; it is a lie about what is running.\n *\n * `globalThis` is the right scope for it: one per process for a fork worker, one\n * per thread for a thread worker, never shared between distinct workers — which\n * is exactly the boundary the resources themselves live inside.\n */\nimport type {\n  RequestedTestConnectors,\n  TestConnectorsSelection,\n} from \"./test-connectors-selection\";\nimport type { TestTimeoutScheduler } from \"./test-setup-timeout\";\n\n/**\n * The transitions the lifecycle serializes through.\n *\n * ```\n * idle -> starting -> ready -> stopping -> idle\n *                                      \\-> poisoned\n * ```\n *\n * `poisoned` is reached when the shutdown layer reports a failure: the runtime\n * is neither up nor provably down, so the next `setupTest` must refuse rather\n * than stack a second runtime on top of leaked resources.\n *\n * @internal No state API is public.\n */\nexport type TestLifecycleState = \"idle\" | \"starting\" | \"ready\" | \"stopping\" | \"poisoned\";\n\n/**\n * The single in-flight setup attempt that concurrent `setupTest` callers share.\n *\n * @internal\n */\nexport type TestSetupAttempt = {\n  /**\n   * What the caller that opened the attempt asked for, before config was read.\n   */\n  readonly requested: RequestedTestConnectors;\n\n  /**\n   * Settles once the attempt has consulted project config, and therefore doubles\n   * as the \"config is readable now\" barrier a later caller needs before it can\n   * resolve its own config-derived selection and compare the two. Rejects with\n   * the startup error when the attempt fails before reaching that point.\n   */\n  readonly effectiveSelection: Promise<TestConnectorsSelection>;\n\n  /**\n   * The attempt itself. Resolves when the runtime is ready, rejects with the\n   * original startup error.\n   */\n  readonly completion: Promise<void>;\n};\n\n/**\n * @internal\n */\nexport type TestLifecycleRegistry = {\n  state: TestLifecycleState;\n  activeSelection?: TestConnectorsSelection;\n  setupAttempt?: TestSetupAttempt;\n  teardownAttempt?: Promise<void>;\n\n  /**\n   * How the setup bound is scheduled. Specs replace it to prove the guard in\n   * milliseconds rather than outliving a real two-minute timeout; production\n   * leaves it unset and gets {@link scheduleRealTimeout}.\n   *\n   * It lives here, on the runtime-context registry, for the same reason the\n   * state does: a spec that could only reach a module-level slot would be\n   * relying on the very rebuild this module exists to survive.\n   */\n  scheduleTimeout?: TestTimeoutScheduler;\n\n  /**\n   * Overrides `tests.setupTimeout` and the default. Internal, for specs — the\n   * public surface stays the `setupTest` / `teardownTest` pair.\n   */\n  setupTimeoutOverride?: number;\n};\n\n/**\n * Where the registry hangs off the runtime context.\n *\n * @internal Exported for specs, which must be able to reach the same slot the\n * implementation uses — a spec that could only reset module state would be\n * testing the very assumption this module rejects. Deliberately not re-exported\n * from `src/tests/index.ts`.\n */\nexport const TEST_LIFECYCLE_REGISTRY_KEY = Symbol.for(\"@warlock.js/core:tests:lifecycle\");\n\ntype TestLifecycleHost = typeof globalThis & {\n  [TEST_LIFECYCLE_REGISTRY_KEY]?: TestLifecycleRegistry;\n};\n\n/**\n * Read the runtime context's lifecycle registry, creating it on first use.\n *\n * @internal\n */\nexport function getTestLifecycleRegistry(): TestLifecycleRegistry {\n  const host = globalThis as TestLifecycleHost;\n  const registry = host[TEST_LIFECYCLE_REGISTRY_KEY];\n\n  if (registry) {\n    return registry;\n  }\n\n  const freshRegistry: TestLifecycleRegistry = { state: \"idle\" };\n\n  host[TEST_LIFECYCLE_REGISTRY_KEY] = freshRegistry;\n\n  return freshRegistry;\n}\n"],"mappings":";;;;;;;;;AAoGA,MAAa,8BAA8B,OAAO,IAAI,kCAAkC;;;;;;AAWxF,SAAgB,2BAAkD;CAChE,MAAM,OAAO;CACb,MAAM,WAAW,KAAK;CAEtB,IAAI,UACF,OAAO;CAGT,MAAM,gBAAuC,EAAE,OAAO,OAAO;CAE7D,KAAK,+BAA+B;CAEpC,OAAO;AACT"}

package/esm/tests/test-setup-timeout.mjs

@@ -0,0 +1,53 @@
+import { config } from "../config/config-getter.mjs";
+import "../config/index.mjs";
+
+//#region ../core/src/tests/test-setup-timeout.ts
+/**
+* Two minutes. Chosen to sit far above any healthy bootstrap and far below the
+* point where a human stops watching — a stuck worker should announce itself
+* while someone is still looking at the terminal.
+*/
+const DEFAULT_TEST_SETUP_TIMEOUT = 12e4;
+/**
+* The real scheduler.
+*
+* `unref` matters: a pending hang guard must never be the reason a worker stays
+* alive after its tests have finished.
+*
+* @internal
+*/
+const scheduleRealTimeout = (timeout, onExpiry) => {
+	const timer = setTimeout(onExpiry, timeout);
+	timer.unref?.();
+	return { cancel: () => clearTimeout(timer) };
+};
+/**
+* Read `tests.setupTimeout`, or `undefined` when the project has not set one.
+*
+* Only meaningful once config files are loaded — before that, every project
+* looks like a project without a `tests` config.
+*
+* @throws when the key is present but is not a positive finite number of
+* milliseconds. Falling back to the default would silently erase a project's
+* configuration, which is the same defect the connector precedence rules out.
+*/
+function readConfiguredSetupTimeout() {
+	const configured = config.get("tests", {})?.setupTimeout;
+	if (configured === void 0) return;
+	if (typeof configured !== "number" || !Number.isFinite(configured) || configured <= 0) throw new Error(`tests.setupTimeout must be a positive number of milliseconds, but it is ${JSON.stringify(configured)}. Remove the key to use the default of ${DEFAULT_TEST_SETUP_TIMEOUT}ms.`);
+	return configured;
+}
+/**
+* The message a caller sees when the bound expires.
+*
+* Names three things, because a hang guard that only says "timed out" sends the
+* reader to the framework's source: what state the lifecycle is stuck in, what
+* bound it exceeded, and how to raise that bound.
+*/
+function describeExpiredSetup(timeout) {
+	return `setupTest() did not finish within ${timeout}ms and is stuck in the "starting" state. The lifecycle is now poisoned: whatever that attempt had already started is not known to be closed, so later setupTest() calls refuse until the Vitest worker is recycled. If your cold start is legitimately slower than this, raise the bound with \`tests.setupTimeout\` in \`src/config/tests.ts\` — milliseconds, default ${DEFAULT_TEST_SETUP_TIMEOUT}.`;
+}
+
+//#endregion
+export { DEFAULT_TEST_SETUP_TIMEOUT, describeExpiredSetup, readConfiguredSetupTimeout, scheduleRealTimeout };
+//# sourceMappingURL=test-setup-timeout.mjs.map

package/esm/tests/test-setup-timeout.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-setup-timeout.mjs","names":[],"sources":["../../../../../../../core/src/tests/test-setup-timeout.ts"],"sourcesContent":["/**\n * The setup bound for the worker test lifecycle.\n *\n * Owns one decision: how long a `setupTest` attempt may run before the\n * lifecycle gives up on it. `vitest-setup.ts` owns what giving up MEANS.\n *\n * This is a HANG GUARD, not a startup-performance deadline. A cold database, a\n * container that has just been started, a first-run migration — all of those are\n * legitimately slow and none of them are a stuck lifecycle. The default is\n * therefore generous on purpose: it exists so that a setup which will never\n * finish fails with a sentence a caller can act on, instead of stranding the\n * lifecycle in `starting` where `teardownTest`'s wait-then-re-enter path spins\n * until the worker dies of heap exhaustion.\n */\nimport type { GenericObject } from \"@mongez/reinforcements\";\nimport { config } from \"../config\";\n\n/**\n * Two minutes. Chosen to sit far above any healthy bootstrap and far below the\n * point where a human stops watching — a stuck worker should announce itself\n * while someone is still looking at the terminal.\n */\nexport const DEFAULT_TEST_SETUP_TIMEOUT = 120_000;\n\n/**\n * A scheduled expiry the lifecycle can cancel when the attempt settles first.\n *\n * @internal\n */\nexport type TestTimeoutHandle = {\n  cancel: () => void;\n};\n\n/**\n * How the lifecycle schedules its expiry.\n *\n * Injectable so a spec can prove the bound in milliseconds instead of outliving\n * a real one — see {@link TestLifecycleRegistry.scheduleTimeout}. Deliberately\n * internal: the public API stays the `setupTest` / `teardownTest` pair.\n *\n * @internal\n */\nexport type TestTimeoutScheduler = (\n  timeout: number,\n  onExpiry: () => void,\n) => TestTimeoutHandle;\n\n/**\n * The real scheduler.\n *\n * `unref` matters: a pending hang guard must never be the reason a worker stays\n * alive after its tests have finished.\n *\n * @internal\n */\nexport const scheduleRealTimeout: TestTimeoutScheduler = (timeout, onExpiry) => {\n  const timer = setTimeout(onExpiry, timeout);\n\n  timer.unref?.();\n\n  return { cancel: () => clearTimeout(timer) };\n};\n\n/**\n * Read `tests.setupTimeout`, or `undefined` when the project has not set one.\n *\n * Only meaningful once config files are loaded — before that, every project\n * looks like a project without a `tests` config.\n *\n * @throws when the key is present but is not a positive finite number of\n * milliseconds. Falling back to the default would silently erase a project's\n * configuration, which is the same defect the connector precedence rules out.\n */\nexport function readConfiguredSetupTimeout(): number | undefined {\n  // `config.get` resolves an absent key to its default, and ITS default is\n  // `null` — not `{}` — so the explicit `{}` is what keeps this from throwing\n  // \"Cannot read properties of null\" on a project with no `src/config/tests.ts`.\n  const testsConfig = config.get<GenericObject>(\"tests\", {});\n  const configured = testsConfig?.setupTimeout as unknown;\n\n  if (configured === undefined) {\n    return undefined;\n  }\n\n  if (typeof configured !== \"number\" || !Number.isFinite(configured) || configured <= 0) {\n    throw new Error(\n      `tests.setupTimeout must be a positive number of milliseconds, but it is ${JSON.stringify(configured)}. Remove the key to use the default of ${DEFAULT_TEST_SETUP_TIMEOUT}ms.`,\n    );\n  }\n\n  return configured;\n}\n\n/**\n * The message a caller sees when the bound expires.\n *\n * Names three things, because a hang guard that only says \"timed out\" sends the\n * reader to the framework's source: what state the lifecycle is stuck in, what\n * bound it exceeded, and how to raise that bound.\n */\nexport function describeExpiredSetup(timeout: number): string {\n  return (\n    `setupTest() did not finish within ${timeout}ms and is stuck in the \"starting\" state. ` +\n    \"The lifecycle is now poisoned: whatever that attempt had already started is not known to be \" +\n    \"closed, so later setupTest() calls refuse until the Vitest worker is recycled. \" +\n    `If your cold start is legitimately slower than this, raise the bound with \\`tests.setupTimeout\\` ` +\n    `in \\`src/config/tests.ts\\` — milliseconds, default ${DEFAULT_TEST_SETUP_TIMEOUT}.`\n  );\n}\n"],"mappings":";;;;;;;;;AAsBA,MAAa,6BAA6B;;;;;;;;;AAiC1C,MAAa,uBAA6C,SAAS,aAAa;CAC9E,MAAM,QAAQ,WAAW,UAAU,OAAO;CAE1C,MAAM,QAAQ;CAEd,OAAO,EAAE,cAAc,aAAa,KAAK,EAAE;AAC7C;;;;;;;;;;;AAYA,SAAgB,6BAAiD;CAK/D,MAAM,aADc,OAAO,IAAmB,SAAS,CAAC,CAC3B,CAAC,EAAE;CAEhC,IAAI,eAAe,QACjB;CAGF,IAAI,OAAO,eAAe,YAAY,CAAC,OAAO,SAAS,UAAU,KAAK,cAAc,GAClF,MAAM,IAAI,MACR,2EAA2E,KAAK,UAAU,UAAU,EAAE,yCAAyC,2BAA2B,IAC5K;CAGF,OAAO;AACT;;;;;;;;AASA,SAAgB,qBAAqB,SAAyB;CAC5D,OACE,qCAAqC,QAAQ,0WAIS,2BAA2B;AAErF"}

package/esm/tests/vitest-setup.d.mts

@@ -1,14 +1,70 @@
-import { ConnectorName } from "../connectors/types.mjs";
+import { TestConnectorsSelection } from "./test-connectors-selection.mjs";
+
 //#region ../core/src/tests/vitest-setup.d.ts
-type TestSetup = {
-  connectors?: boolean | ConnectorName[];
+type TestSetupOptions = {
+  /**
+   * Which connectors to start.
+   *
+   * Precedence is `explicit non-undefined option > tests.connectors config >
+   * true`. Omitting the property, or passing `undefined`, lets project config
+   * apply — so an optional variable that happens to be `undefined` cannot erase
+   * it.
+   */
+  connectors?: TestConnectorsSelection;
 };
 /**
- * Setup function that runs once per worker thread
+ * Raised by the lifecycle itself, never by the runtime it manages — a conflict
+ * between two calls, or a refusal to reuse a runtime that did not close.
  */
-declare function setupTest({
-  connectors
-}: TestSetup): Promise<void>;
+declare class TestLifecycleError extends Error {
+  constructor(message: string);
+}
+/**
+ * Bootstrap the test runtime and start the selected connectors.
+ *
+ * ⚠ Runs once per TEST FILE, not once per worker: `setupFiles` is executed for
+ * every file and its module registry is rebuilt with it, measured across both
+ * pools with isolation on and off. The lifecycle state lives on the runtime
+ * context rather than in this module precisely so that a rebuild cannot hide a
+ * runtime that is still up.
+ *
+ * Repeated calls:
+ *
+ * - concurrent calls with the same effective selection share one startup;
+ * - while ready, the same effective selection is a no-op;
+ * - while starting or ready, a DIFFERENT effective selection rejects and leaves
+ *   the live runtime untouched;
+ * - a failed setup unwinds and returns to idle, so a clean retry is allowed;
+ * - after a successful `teardownTest`, a later setup may use a different
+ *   selection.
+ *
+ * @example
+ * // let project config decide, falling back to the default set
+ * await setupTest();
+ *
+ * @example
+ * // bootstrap only — no connectors, whatever config says
+ * await setupTest({ connectors: false });
+ */
+declare function setupTest(options?: TestSetupOptions): Promise<void>;
+/**
+ * Shut the test runtime down and release the lifecycle.
+ *
+ * - idle is a no-op;
+ * - concurrent calls share one attempt;
+ * - a call made while setup is still running waits for that attempt to settle,
+ *   then closes the runtime if it succeeded;
+ * - the local "ready" state is always cleared, including when shutdown rejects;
+ * - a shutdown rejection is surfaced, never swallowed, and poisons the
+ *   lifecycle — a reported close failure is not proof that anything closed, so
+ *   later `setupTest` calls refuse until the worker is restarted or a retry
+ *   fully succeeds.
+ *
+ * ⚠ Individual connector shutdown failures are caught and logged inside
+ * `connectorsManager.shutdown()`, so they never reach this function and never
+ * poison anything. This lifecycle can only surface what that layer reports.
+ */
+declare function teardownTest(): Promise<void>;
 //#endregion
-export { setupTest };
+export { TestLifecycleError, TestSetupOptions, setupTest, teardownTest };
 //# sourceMappingURL=vitest-setup.d.mts.map

package/esm/tests/vitest-setup.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"vitest-setup.d.mts","names":[],"sources":["../../../../../../../core/src/tests/vitest-setup.ts"],"mappings":";;KAmBK,SAAA;EACH,UAAA,aAAuB,aAAa;AAAA;AAR2B;;;AAAA,iBAc3C,SAAA;EAAY;AAAA,GAAqB,SAAA,GAAS,OAAA"}
+{"version":3,"file":"vitest-setup.d.mts","names":[],"sources":["../../../../../../../core/src/tests/vitest-setup.ts"],"mappings":";;;KAoDY,gBAAA;EAAA;;;;AAS0B;AAOtC;;;EAPE,UAAA,GAAa,uBAAuB;AAAA;;;;AAQF;cADvB,kBAAA,SAA2B,KAAK;cACxB,OAAA;AAAA;;;;;;AAqC+C;AAgDpE;;;;AAA6C;;;;;;;;;;;;;;;;;iBAhDvB,SAAA,CAAU,OAAA,GAAU,gBAAA,GAAmB,OAAO;;;;;;;;;;;;;;;;;;iBAgD9C,YAAA,IAAgB,OAAO"}

package/esm/tests/vitest-setup.mjs

@@ -1,5 +1,3 @@
-import { config } from "../config/config-getter.mjs";
-import "../config/index.mjs";
 import { Application } from "../application/application.mjs";
 import { bootstrap } from "../bootstrap.mjs";
 import { connectorsManager } from "../connectors/connectors-manager.mjs";
@@ -7,30 +5,338 @@ import "../connectors/index.mjs";
 import { warlockConfigManager } from "../warlock-config/warlock-config.manager.mjs";
 import { filesOrchestrator } from "../dev-server/files-orchestrator.mjs";
 import { loadConfigFiles } from "../config/load-config-files.mjs";
+import { describeConnectorsSelection, isSameConnectorsSelection, normalizeConnectorNames, readRequestedConnectors, resolveEffectiveConnectors } from "./test-connectors-selection.mjs";
+import { getTestLifecycleRegistry } from "./test-lifecycle-state.mjs";
+import { DEFAULT_TEST_SETUP_TIMEOUT, describeExpiredSetup, readConfiguredSetupTimeout, scheduleRealTimeout } from "./test-setup-timeout.mjs";
 
 //#region ../core/src/tests/vitest-setup.ts
-let isSetupComplete = false;
 /**
-* Setup function that runs once per worker thread
+* Worker test lifecycle — `setupTest` / `teardownTest`.
+*
+* Implements `contracts/2026-08-12-test-worker-lifecycle.md`. The pair is
+* context-scoped, not "once per worker": Vitest runs `setupFiles` before EVERY
+* test file and rebuilds the module registry each time, so the harness that
+* calls `setupTest` owns pairing it with `teardownTest` in the same runtime
+* context.
+*
+* Ownership, stated once because teardown is wider than it looks:
+*
+* - the runtime assumes exclusive ownership of the process-local
+*   `connectorsManager` for its lifetime;
+* - it owns the framework bootstrap, the application shutdown hooks, and the
+*   connectors it starts — including the `connectors: false` case, where
+*   bootstrap still registers hooks;
+* - teardown is MANAGER-WIDE. `connectorsManager.shutdown()` has no selective
+*   ownership handle, so a lifecycle that started two connectors still closes
+*   every connector the manager holds. Mixing `setupTest` with manual connector
+*   startup in the same process is unsupported for exactly that reason.
+* - HTTP global setup stays separately owned by `startHttpTestServer` /
+*   `stopHttpTestServer`.
 */
-async function setupTest({ connectors = true }) {
-	if (isSetupComplete) return;
+/**
+* Raised by the lifecycle itself, never by the runtime it manages — a conflict
+* between two calls, or a refusal to reuse a runtime that did not close.
+*/
+var TestLifecycleError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "TestLifecycleError";
+	}
+};
+const POISONED_MESSAGE = "setupTest() refuses to start a test runtime: an earlier teardownTest() reported a shutdown failure, so the connectors, ports and pools it owned are not known to be closed. Restart the Vitest worker before setting up again, or call teardownTest() to retry the shutdown — the lifecycle only returns to idle on a fully successful retry.";
+/**
+* Bootstrap the test runtime and start the selected connectors.
+*
+* ⚠ Runs once per TEST FILE, not once per worker: `setupFiles` is executed for
+* every file and its module registry is rebuilt with it, measured across both
+* pools with isolation on and off. The lifecycle state lives on the runtime
+* context rather than in this module precisely so that a rebuild cannot hide a
+* runtime that is still up.
+*
+* Repeated calls:
+*
+* - concurrent calls with the same effective selection share one startup;
+* - while ready, the same effective selection is a no-op;
+* - while starting or ready, a DIFFERENT effective selection rejects and leaves
+*   the live runtime untouched;
+* - a failed setup unwinds and returns to idle, so a clean retry is allowed;
+* - after a successful `teardownTest`, a later setup may use a different
+*   selection.
+*
+* @example
+* // let project config decide, falling back to the default set
+* await setupTest();
+*
+* @example
+* // bootstrap only — no connectors, whatever config says
+* await setupTest({ connectors: false });
+*/
+async function setupTest(options) {
+	const registry = getTestLifecycleRegistry();
+	const requested = readRequestedConnectors(options?.connectors);
+	if (registry.state === "poisoned") throw new TestLifecycleError(POISONED_MESSAGE);
+	if (registry.state === "stopping" && registry.teardownAttempt) {
+		await settled(registry.teardownAttempt);
+		return setupTest(options);
+	}
+	if (registry.state === "ready") {
+		assertReadySelectionMatches(registry.activeSelection, requested);
+		return;
+	}
+	if (registry.state === "starting" && registry.setupAttempt) {
+		const attempt = registry.setupAttempt;
+		await assertPendingSetupMatches(attempt, requested);
+		return attempt.completion;
+	}
+	return startTestRuntime(requested);
+}
+/**
+* Shut the test runtime down and release the lifecycle.
+*
+* - idle is a no-op;
+* - concurrent calls share one attempt;
+* - a call made while setup is still running waits for that attempt to settle,
+*   then closes the runtime if it succeeded;
+* - the local "ready" state is always cleared, including when shutdown rejects;
+* - a shutdown rejection is surfaced, never swallowed, and poisons the
+*   lifecycle — a reported close failure is not proof that anything closed, so
+*   later `setupTest` calls refuse until the worker is restarted or a retry
+*   fully succeeds.
+*
+* ⚠ Individual connector shutdown failures are caught and logged inside
+* `connectorsManager.shutdown()`, so they never reach this function and never
+* poison anything. This lifecycle can only surface what that layer reports.
+*/
+async function teardownTest() {
+	const registry = getTestLifecycleRegistry();
+	if (registry.state === "stopping" && registry.teardownAttempt) return registry.teardownAttempt;
+	if (registry.state === "starting" && registry.setupAttempt) {
+		await settled(registry.setupAttempt.completion);
+		return teardownTest();
+	}
+	if (registry.state === "idle") return;
+	registry.state = "stopping";
+	const attempt = Promise.resolve().then(() => runTestRuntimeShutdown());
+	registry.teardownAttempt = attempt;
+	return attempt;
+}
+/**
+* Arm the hang guard for one setup attempt.
+*
+* Armed at the default BEFORE the attempt runs, because `tests.setupTimeout` is
+* not readable until the attempt has loaded config — and loading config is
+* itself one of the steps that can hang. `rearm` then narrows or widens it the
+* moment config arrives.
+*/
+function armSetupBound(registry) {
+	const schedule = registry.scheduleTimeout ?? scheduleRealTimeout;
+	const armedAt = Date.now();
+	let handle;
+	let expired = false;
+	let closed = false;
+	let expire = () => void 0;
+	const expiry = new Promise((_resolve, reject) => {
+		expire = reject;
+	});
+	expiry.catch(() => void 0);
+	const expireNow = (bound) => {
+		if (closed) return;
+		closed = true;
+		expired = true;
+		handle?.cancel();
+		handle = void 0;
+		expire(new TestLifecycleError(describeExpiredSetup(bound)));
+	};
+	const armFor = (bound, delay) => {
+		if (closed) return;
+		handle?.cancel();
+		if (delay <= 0) {
+			expireNow(bound);
+			return;
+		}
+		handle = schedule(delay, () => expireNow(bound));
+	};
+	const initialBound = registry.setupTimeoutOverride ?? 12e4;
+	armFor(initialBound, initialBound);
+	return {
+		expiry,
+		rearm: (next) => armFor(next, next - (Date.now() - armedAt)),
+		settle: () => {
+			closed = true;
+			handle?.cancel();
+			handle = void 0;
+		},
+		hasExpired: () => expired
+	};
+}
+/**
+* Race one setup attempt against its bound.
+*
+* The losing attempt is NOT cancellable — nothing here can interrupt a bootstrap
+* stuck in a socket connect — so when the bound wins, the lifecycle is poisoned
+* and every later state write from that abandoned attempt is dropped. That
+* dropping happens in `runTestRuntimeStartup`, guarded on `hasExpired()`;
+* without it the still-running attempt would quietly overwrite `poisoned` with
+* `ready` or `idle` and hand the next caller a runtime nobody owns.
+*/
+async function awaitSetupWithinBound(attempt, bound, registry) {
+	try {
+		await Promise.race([attempt, bound.expiry]);
+	} catch (error) {
+		if (bound.hasExpired()) {
+			registry.state = "poisoned";
+			registry.activeSelection = void 0;
+			registry.setupAttempt = void 0;
+		}
+		throw error;
+	} finally {
+		bound.settle();
+	}
+}
+/**
+* Open a new setup attempt and publish it before it runs.
+*/
+function startTestRuntime(requested) {
+	const registry = getTestLifecycleRegistry();
+	let publishEffectiveSelection = () => void 0;
+	let failEffectiveSelection = () => void 0;
+	const effectiveSelection = new Promise((resolve, reject) => {
+		publishEffectiveSelection = resolve;
+		failEffectiveSelection = reject;
+	});
+	effectiveSelection.catch(() => void 0);
+	const bound = armSetupBound(registry);
+	const attempt = Promise.resolve().then(() => runTestRuntimeStartup(requested, publishEffectiveSelection, failEffectiveSelection, bound));
+	attempt.catch(() => void 0);
+	const completion = awaitSetupWithinBound(attempt, bound, registry);
+	registry.state = "starting";
+	registry.setupAttempt = {
+		requested,
+		effectiveSelection,
+		completion
+	};
+	return completion;
+}
+/**
+* The startup attempt itself.
+*
+* On failure: best-effort unwind, reset bookkeeping, rethrow the ORIGINAL error
+* unchanged. A cleanup failure is a secondary diagnostic and never replaces the
+* cause the caller needs to read.
+*/
+async function runTestRuntimeStartup(requested, publishEffectiveSelection, failEffectiveSelection, bound) {
+	const registry = getTestLifecycleRegistry();
 	try {
 		Application.setEnvironment("test");
 		await warlockConfigManager.load();
 		await bootstrap();
 		await filesOrchestrator.init();
 		await loadConfigFiles(true);
-		const connectorsToStart = config.get("tests").connectors || connectors;
-		if (Array.isArray(connectorsToStart)) await connectorsManager.start(connectorsToStart);
-		else await connectorsManager.startWithout(["http"]);
-		isSetupComplete = true;
+		const configuredTimeout = readConfiguredSetupTimeout();
+		if (configuredTimeout !== void 0) bound.rearm(configuredTimeout);
+		const effectiveSelection = resolveEffectiveConnectors(requested);
+		if (!bound.hasExpired()) registry.activeSelection = effectiveSelection;
+		publishEffectiveSelection(effectiveSelection);
+		await startSelectedConnectors(effectiveSelection);
+		if (!bound.hasExpired()) {
+			registry.state = "ready";
+			registry.setupAttempt = void 0;
+		}
 	} catch (error) {
+		failEffectiveSelection(error);
+		await unwindPartialStartup();
+		if (!bound.hasExpired()) {
+			registry.state = "idle";
+			registry.activeSelection = void 0;
+			registry.setupAttempt = void 0;
+		}
 		console.error("[vitest-setup] Failed to setup test environment:", error);
 		throw error;
 	}
 }
+/**
+* `false` means none at all. Everything else starts something: an array starts
+* exactly those, and `true` starts the default set — all but http, which is the
+* global setup's job and shared across every worker.
+*/
+async function startSelectedConnectors(selection) {
+	if (selection === false) return;
+	if (Array.isArray(selection)) {
+		await connectorsManager.start(normalizeConnectorNames(selection));
+		return;
+	}
+	await connectorsManager.startWithout(["http"]);
+}
+/**
+* Best-effort teardown of whatever a failed startup managed to start.
+*
+* Runs while an error is already in flight, so no step here may throw and every
+* step is attempted independently.
+*/
+async function unwindPartialStartup() {
+	await attemptCleanupStep("application shutdown hooks", () => Application.runShutdownHooks());
+	await attemptCleanupStep("connectors shutdown", () => connectorsManager.shutdown());
+}
+/**
+* Run one cleanup step, isolating its failure so the next step still runs.
+*/
+async function attemptCleanupStep(step, run) {
+	try {
+		await run();
+	} catch (error) {
+		console.error(`[vitest-setup] Cleanup after a failed setup did not complete (${step}):`, error);
+	}
+}
+/**
+* The teardown attempt itself.
+*/
+async function runTestRuntimeShutdown() {
+	const registry = getTestLifecycleRegistry();
+	let shutdownSucceeded = false;
+	try {
+		await connectorsManager.shutdown();
+		shutdownSucceeded = true;
+	} finally {
+		registry.activeSelection = void 0;
+		registry.setupAttempt = void 0;
+		registry.teardownAttempt = void 0;
+		registry.state = shutdownSucceeded ? "idle" : "poisoned";
+	}
+}
+/**
+* Reject when a ready runtime was set up with a different selection.
+*/
+function assertReadySelectionMatches(activeSelection, requested) {
+	if (activeSelection === void 0) return;
+	assertSelectionsMatch(activeSelection, resolveEffectiveConnectors(requested));
+}
+/**
+* Reject when an in-flight setup attempt is starting a different selection.
+*/
+async function assertPendingSetupMatches(attempt, requested) {
+	const pending = attempt.requested;
+	if (!pending.isExplicit && !requested.isExplicit) return;
+	if (pending.isExplicit && requested.isExplicit) {
+		assertSelectionsMatch(pending.selection, requested.selection);
+		return;
+	}
+	assertSelectionsMatch(await attempt.effectiveSelection, resolveEffectiveConnectors(requested));
+}
+/**
+* Name both selections: a caller looking at this message has to be able to tell
+* which call to change without reading the framework's source.
+*/
+function assertSelectionsMatch(activeSelection, requestedSelection) {
+	if (isSameConnectorsSelection(activeSelection, requestedSelection)) return;
+	throw new TestLifecycleError(`setupTest() is already using ${describeConnectorsSelection(activeSelection)}, and this call asked for ${describeConnectorsSelection(requestedSelection)}. One test runtime serves one connector selection — call teardownTest() before setting up a different one.`);
+}
+/**
+* Await an attempt for its state transition only, not its result.
+*/
+function settled(attempt) {
+	return attempt.catch(() => void 0);
+}
 
 //#endregion
-export { setupTest };
+export { TestLifecycleError, setupTest, teardownTest };
 //# sourceMappingURL=vitest-setup.mjs.map