@warlock.js/core 5.30.0 → 5.32.0

package/esm/tests/test-helpers.d.mts

@@ -7,40 +7,58 @@
 /**
  * Get the test server base URL
  */
-declare function getTestServerUrl(): string;
+export declare function getTestServerUrl(): string;
 /**
  * Simple HTTP request helper for test server
  * Uses native fetch - lightweight, no extra dependencies
  */
-declare function testRequest(path: string, options?: RequestInit): Promise<Response>;
+export declare function testRequest(path: string, options?: RequestInit): Promise<Response>;
+/** The request helpers, bound to one server. */
+export type TestRequestClient = {
+  request(path: string, options?: RequestInit): Promise<Response>;
+  get(path: string, options?: RequestInit): Promise<Response>;
+  post(path: string, body?: unknown, options?: RequestInit): Promise<Response>;
+  put(path: string, body?: unknown, options?: RequestInit): Promise<Response>;
+  patch(path: string, body?: unknown, options?: RequestInit): Promise<Response>;
+  delete(path: string, options?: RequestInit): Promise<Response>;
+};
+/**
+ * Request helpers bound to `baseUrl` (a string, or a function read on every
+ * request). `testGet()` and friends are this, bound to the shared test server;
+ * `createTestHttpServer()` returns one bound to its own port.
+ *
+ * @example
+ * const client = createTestRequestClient("http://127.0.0.1:4100");
+ * await client.post("/posts", { title: "Hello" });
+ */
+export declare function createTestRequestClient(baseUrl: string | (() => string)): TestRequestClient;
 /**
  * GET request helper
  */
-declare function testGet(path: string, options?: RequestInit): Promise<Response>;
+export declare function testGet(path: string, options?: RequestInit): Promise<Response>;
 /**
  * POST request helper
  */
-declare function testPost(path: string, body?: unknown, options?: RequestInit): Promise<Response>;
+export declare function testPost(path: string, body?: unknown, options?: RequestInit): Promise<Response>;
 /**
  * PUT request helper
  */
-declare function testPut(path: string, body?: unknown, options?: RequestInit): Promise<Response>;
+export declare function testPut(path: string, body?: unknown, options?: RequestInit): Promise<Response>;
 /**
  * DELETE request helper
  */
-declare function testDelete(path: string, options?: RequestInit): Promise<Response>;
+export declare function testDelete(path: string, options?: RequestInit): Promise<Response>;
 /**
  * PATCH request helper
  */
-declare function testPatch(path: string, body?: unknown, options?: RequestInit): Promise<Response>;
+export declare function testPatch(path: string, body?: unknown, options?: RequestInit): Promise<Response>;
 /**
  * Parse JSON response with type safety
  */
-declare function parseJsonResponse<T>(response: Response): Promise<T>;
+export declare function parseJsonResponse<T>(response: Response): Promise<T>;
 /**
  * Assert response status and return parsed JSON
  */
-declare function expectJson<T>(response: Response, expectedStatus?: number): Promise<T>;
+export declare function expectJson<T>(response: Response, expectedStatus?: number): Promise<T>;
 //#endregion
-export { expectJson, getTestServerUrl, parseJsonResponse, testDelete, testGet, testPatch, testPost, testPut, testRequest };
 //# sourceMappingURL=test-helpers.d.mts.map

package/esm/tests/test-helpers.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"test-helpers.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/tests/test-helpers.ts"],"mappings":";;AAaA;;;;AAAgC;AA6BhC;;AA7BgC,iBAAhB,gBAAA;;;;;iBA6BM,WAAA,CAAY,IAAA,UAAc,OAAA,GAAS,WAAA,GAAmB,OAAA,CAAQ,QAAA;;;;iBAgD9D,OAAA,CAAQ,IAAA,UAAc,OAAA,GAAS,WAAA,GAAmB,OAAA,CAAQ,QAAA;;;AAhDY;iBAuDtE,QAAA,CACpB,IAAA,UACA,IAAA,YACA,OAAA,GAAS,WAAA,GACR,OAAA,CAAQ,QAAA;;;;iBAWW,OAAA,CACpB,IAAA,UACA,IAAA,YACA,OAAA,GAAS,WAAA,GACR,OAAA,CAAQ,QAAA;;;;iBAOW,UAAA,CAAW,IAAA,UAAc,OAAA,GAAS,WAAA,GAAmB,OAAA,CAAQ,QAAA;;;;iBAO7D,SAAA,CACpB,IAAA,UACA,IAAA,YACA,OAAA,GAAS,WAAA,GACR,OAAA,CAAQ,QAAA;;AA5C6E;AAOxF;iBAgDsB,iBAAA,IAAqB,QAAA,EAAU,QAAA,GAAW,OAAA,CAAQ,CAAA;;;;iBAOlD,UAAA,IAAc,QAAA,EAAU,QAAA,EAAU,cAAA,YAAuB,OAAA,CAAQ,CAAA"}
+{"version":3,"file":"test-helpers.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/tests/test-helpers.ts"],"mappings":";;;;;;;;;wBAagB;;;;;wBA6BM,YAAY,cAAc,UAAS,cAAmB,QAAQ;;YA8CxE;EACV,QAAQ,cAAc,UAAU,cAAc,QAAQ;EACtD,IAAI,cAAc,UAAU,cAAc,QAAQ;EAClD,KAAK,cAAc,gBAAgB,UAAU,cAAc,QAAQ;EACnE,IAAI,cAAc,gBAAgB,UAAU,cAAc,QAAQ;EAClE,MAAM,cAAc,gBAAgB,UAAU,cAAc,QAAQ;EACpE,OAAO,cAAc,UAAU,cAAc,QAAQ;;;;;;;;;;;wBAYvC,wBAAwB,mCAAmC;;;;wBAqBrD,QAAQ,cAAc,UAAS,cAAmB,QAAQ;;;;wBAO1D,SACpB,cACA,gBACA,UAAS,cACR,QAAQ;;;;wBAOW,QACpB,cACA,gBACA,UAAS,cACR,QAAQ;;;;wBAOW,WAAW,cAAc,UAAS,cAAmB,QAAQ;;;;wBAO7D,UACpB,cACA,gBACA,UAAS,cACR,QAAQ;;;;wBAOW,kBAAkB,GAAG,UAAU,WAAW,QAAQ;;;;wBAOlD,WAAW,GAAG,UAAU,UAAU,0BAAuB,QAAQ"}

package/esm/tests/test-helpers.mjs

@@ -23,7 +23,7 @@ function getTestServerUrl() {
 * Uses native fetch - lightweight, no extra dependencies
 */
 async function testRequest(path, options = {}) {
-	return sendRequest(path, options, false);
+	return sendRequest(getTestServerUrl(), path, options, false);
 }
 /**
 * The single place a request is actually built.
@@ -33,8 +33,7 @@ async function testRequest(path, options = {}) {
 * 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();
+async function sendRequest(baseUrl, path, options, serializedJson) {
 	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");
@@ -55,52 +54,66 @@ function jsonBody(body) {
 	return body === void 0 ? void 0 : JSON.stringify(body);
 }
 /**
+* Request helpers bound to `baseUrl` (a string, or a function read on every
+* request). `testGet()` and friends are this, bound to the shared test server;
+* `createTestHttpServer()` returns one bound to its own port.
+*
+* @example
+* const client = createTestRequestClient("http://127.0.0.1:4100");
+* await client.post("/posts", { title: "Hello" });
+*/
+function createTestRequestClient(baseUrl) {
+	const base = () => typeof baseUrl === "function" ? baseUrl() : baseUrl;
+	const send = (method, path, body, options = {}) => sendRequest(base(), path, {
+		...options,
+		method,
+		body: jsonBody(body)
+	}, body !== void 0);
+	return {
+		request: (path, options = {}) => sendRequest(base(), path, options, false),
+		get: (path, options = {}) => sendRequest(base(), path, {
+			...options,
+			method: "GET"
+		}, false),
+		post: (path, body, options) => send("POST", path, body, options),
+		put: (path, body, options) => send("PUT", path, body, options),
+		patch: (path, body, options) => send("PATCH", path, body, options),
+		delete: (path, options = {}) => sendRequest(base(), path, {
+			...options,
+			method: "DELETE"
+		}, false)
+	};
+}
+const sharedServer = createTestRequestClient(getTestServerUrl);
+/**
 * GET request helper
 */
 async function testGet(path, options = {}) {
-	return testRequest(path, {
-		...options,
-		method: "GET"
-	});
+	return sharedServer.get(path, options);
 }
 /**
 * POST request helper
 */
 async function testPost(path, body, options = {}) {
-	return sendRequest(path, {
-		...options,
-		method: "POST",
-		body: jsonBody(body)
-	}, body !== void 0);
+	return sharedServer.post(path, body, options);
 }
 /**
 * PUT request helper
 */
 async function testPut(path, body, options = {}) {
-	return sendRequest(path, {
-		...options,
-		method: "PUT",
-		body: jsonBody(body)
-	}, body !== void 0);
+	return sharedServer.put(path, body, options);
 }
 /**
 * DELETE request helper
 */
 async function testDelete(path, options = {}) {
-	return testRequest(path, {
-		...options,
-		method: "DELETE"
-	});
+	return sharedServer.delete(path, options);
 }
 /**
 * PATCH request helper
 */
 async function testPatch(path, body, options = {}) {
-	return sendRequest(path, {
-		...options,
-		method: "PATCH",
-		body: jsonBody(body)
-	}, body !== void 0);
+	return sharedServer.patch(path, body, options);
 }
 /**
 * Parse JSON response with type safety
@@ -120,5 +133,5 @@ async function expectJson(response, expectedStatus = 200) {
 }
 
 //#endregion
-export { expectJson, getTestServerUrl, parseJsonResponse, testDelete, testGet, testPatch, testPost, testPut, testRequest };
+export { createTestRequestClient, expectJson, getTestServerUrl, parseJsonResponse, testDelete, testGet, testPatch, testPost, testPut, testRequest };
 //# sourceMappingURL=test-helpers.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"test-helpers.mjs","names":[],"sources":["../../../../../../../../packages/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 { getHttpReadyReport } from \"../http/ready-report\";\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\n  // Same-process fallback: a test that boots the HTTP connector directly\n  // (rather than through `startHttpTestServer`'s cross-process channel) never\n  // writes `TEST_SERVER_PORT_ENV_KEY`, so without this the next fallback —\n  // `config.key(\"http.port\", 2031)` — was the only source left, and it holds\n  // the CONFIGURED port, not the bound one. For `http.port: 0` that is `0`,\n  // producing `http://host:0` even though `HttpConnector.start()` had already\n  // recorded the real bound port right here in `ready-report.ts`.\n  const boundPort = getHttpReadyReport()?.port;\n\n  // `config.key`'s default only substitutes for `undefined` — `0` is a\n  // defined configured value, not an absent one — so it cannot be trusted to\n  // paper over an unresolved port 0 either. `boundPort` is read first for\n  // that exact reason.\n  const port = publishedPort || boundPort || 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(\n    path,\n    { ...options, method: \"POST\", body: jsonBody(body) },\n    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 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(\n    path,\n    { ...options, method: \"PATCH\", body: jsonBody(body) },\n    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":";;;;;;;;;;;;;;AAaA,SAAgB,mBAA2B;CAKzC,MAAM,gBAAgB,QAAQ,IAAI;CASlC,MAAM,YAAY,mBAAmB,CAAC,EAAE;CAMxC,MAAM,OAAO,iBAAiB,aAAa,OAAO,IAAI,aAAa,IAAI;CAEvE,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,YACL,MACA;EAAE,GAAG;EAAS,QAAQ;EAAQ,MAAM,SAAS,IAAI;CAAE,GACnD,SAAS,MACX;AACF;;;;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,YACL,MACA;EAAE,GAAG;EAAS,QAAQ;EAAS,MAAM,SAAS,IAAI;CAAE,GACpD,SAAS,MACX;AACF;;;;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":["../../../../../../../../packages/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 { getHttpReadyReport } from \"../http/ready-report\";\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\n  // Same-process fallback: a test that boots the HTTP connector directly\n  // (rather than through `startHttpTestServer`'s cross-process channel) never\n  // writes `TEST_SERVER_PORT_ENV_KEY`, so without this the next fallback —\n  // `config.key(\"http.port\", 2031)` — was the only source left, and it holds\n  // the CONFIGURED port, not the bound one. For `http.port: 0` that is `0`,\n  // producing `http://host:0` even though `HttpConnector.start()` had already\n  // recorded the real bound port right here in `ready-report.ts`.\n  const boundPort = getHttpReadyReport()?.port;\n\n  // `config.key`'s default only substitutes for `undefined` — `0` is a\n  // defined configured value, not an absent one — so it cannot be trusted to\n  // paper over an unresolved port 0 either. `boundPort` is read first for\n  // that exact reason.\n  const port = publishedPort || boundPort || 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(getTestServerUrl(), 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  baseUrl: string,\n  path: string,\n  options: RequestInit,\n  serializedJson: boolean,\n): Promise<Response> {\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/** The request helpers, bound to one server. */\nexport type TestRequestClient = {\n  request(path: string, options?: RequestInit): Promise<Response>;\n  get(path: string, options?: RequestInit): Promise<Response>;\n  post(path: string, body?: unknown, options?: RequestInit): Promise<Response>;\n  put(path: string, body?: unknown, options?: RequestInit): Promise<Response>;\n  patch(path: string, body?: unknown, options?: RequestInit): Promise<Response>;\n  delete(path: string, options?: RequestInit): Promise<Response>;\n};\n\n/**\n * Request helpers bound to `baseUrl` (a string, or a function read on every\n * request). `testGet()` and friends are this, bound to the shared test server;\n * `createTestHttpServer()` returns one bound to its own port.\n *\n * @example\n * const client = createTestRequestClient(\"http://127.0.0.1:4100\");\n * await client.post(\"/posts\", { title: \"Hello\" });\n */\nexport function createTestRequestClient(baseUrl: string | (() => string)): TestRequestClient {\n  const base = () => (typeof baseUrl === \"function\" ? baseUrl() : baseUrl);\n  const send = (method: string, path: string, body: unknown, options: RequestInit = {}) =>\n    sendRequest(base(), path, { ...options, method, body: jsonBody(body) }, body !== undefined);\n\n  return {\n    request: (path, options = {}) => sendRequest(base(), path, options, false),\n    get: (path, options = {}) => sendRequest(base(), path, { ...options, method: \"GET\" }, false),\n    post: (path, body, options) => send(\"POST\", path, body, options),\n    put: (path, body, options) => send(\"PUT\", path, body, options),\n    patch: (path, body, options) => send(\"PATCH\", path, body, options),\n    delete: (path, options = {}) =>\n      sendRequest(base(), path, { ...options, method: \"DELETE\" }, false),\n  };\n}\n\nconst sharedServer = createTestRequestClient(getTestServerUrl);\n\n/**\n * GET request helper\n */\nexport async function testGet(path: string, options: RequestInit = {}): Promise<Response> {\n  return sharedServer.get(path, options);\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 sharedServer.post(path, body, options);\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 sharedServer.put(path, body, options);\n}\n\n/**\n * DELETE request helper\n */\nexport async function testDelete(path: string, options: RequestInit = {}): Promise<Response> {\n  return sharedServer.delete(path, options);\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 sharedServer.patch(path, body, options);\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":";;;;;;;;;;;;;;AAaA,SAAgB,mBAA2B;CAKzC,MAAM,gBAAgB,QAAQ,IAAI;CASlC,MAAM,YAAY,mBAAmB,CAAC,EAAE;CAMxC,MAAM,OAAO,iBAAiB,aAAa,OAAO,IAAI,aAAa,IAAI;CAEvE,OAAO,UADM,OAAO,IAAI,aAAa,WACjB,EAAE,GAAG;AAC3B;;;;;AAMA,eAAsB,YAAY,MAAc,UAAuB,CAAC,GAAsB;CAC5F,OAAO,YAAY,iBAAiB,GAAG,MAAM,SAAS,KAAK;AAC7D;;;;;;;;;AAUA,eAAe,YACb,SACA,MACA,SACA,gBACmB;CACnB,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;;;;;;;;;;AAqBA,SAAgB,wBAAwB,SAAqD;CAC3F,MAAM,aAAc,OAAO,YAAY,aAAa,QAAQ,IAAI;CAChE,MAAM,QAAQ,QAAgB,MAAc,MAAe,UAAuB,CAAC,MACjF,YAAY,KAAK,GAAG,MAAM;EAAE,GAAG;EAAS;EAAQ,MAAM,SAAS,IAAI;CAAE,GAAG,SAAS,MAAS;CAE5F,OAAO;EACL,UAAU,MAAM,UAAU,CAAC,MAAM,YAAY,KAAK,GAAG,MAAM,SAAS,KAAK;EACzE,MAAM,MAAM,UAAU,CAAC,MAAM,YAAY,KAAK,GAAG,MAAM;GAAE,GAAG;GAAS,QAAQ;EAAM,GAAG,KAAK;EAC3F,OAAO,MAAM,MAAM,YAAY,KAAK,QAAQ,MAAM,MAAM,OAAO;EAC/D,MAAM,MAAM,MAAM,YAAY,KAAK,OAAO,MAAM,MAAM,OAAO;EAC7D,QAAQ,MAAM,MAAM,YAAY,KAAK,SAAS,MAAM,MAAM,OAAO;EACjE,SAAS,MAAM,UAAU,CAAC,MACxB,YAAY,KAAK,GAAG,MAAM;GAAE,GAAG;GAAS,QAAQ;EAAS,GAAG,KAAK;CACrE;AACF;AAEA,MAAM,eAAe,wBAAwB,gBAAgB;;;;AAK7D,eAAsB,QAAQ,MAAc,UAAuB,CAAC,GAAsB;CACxF,OAAO,aAAa,IAAI,MAAM,OAAO;AACvC;;;;AAKA,eAAsB,SACpB,MACA,MACA,UAAuB,CAAC,GACL;CACnB,OAAO,aAAa,KAAK,MAAM,MAAM,OAAO;AAC9C;;;;AAKA,eAAsB,QACpB,MACA,MACA,UAAuB,CAAC,GACL;CACnB,OAAO,aAAa,IAAI,MAAM,MAAM,OAAO;AAC7C;;;;AAKA,eAAsB,WAAW,MAAc,UAAuB,CAAC,GAAsB;CAC3F,OAAO,aAAa,OAAO,MAAM,OAAO;AAC1C;;;;AAKA,eAAsB,UACpB,MACA,MACA,UAAuB,CAAC,GACL;CACnB,OAAO,aAAa,MAAM,MAAM,MAAM,OAAO;AAC/C;;;;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-http-server.d.mts

@@ -0,0 +1,66 @@
+import { FastifyInstance } from "../http/server.mjs";
+import { Router } from "../router/router.mjs";
+import { TestRequestClient } from "./test-helpers.mjs";
+import { AuthenticatedTestClient, TestAuthenticableUser } from "./authenticated-test-client.mjs";
+import { AppModuleImporter } from "../loader/app-module-importer.mjs";
+//#region ../../packages/core/src/tests/test-http-server.d.ts
+export type CreateTestHttpServerOptions = {
+  /**
+   * Register routes for this server, exactly as a `routes.ts` would. They are
+   * tagged with a source of their own and removed again by `close()`.
+   */
+  routes?: (router: Router) => unknown;
+  /**
+   * Load the application's modules (`routes.ts`, `main.ts`, events, ...) first,
+   * so the server answers every app route. Needs `setupTest()` to have run in
+   * this worker. Modules load once per process; later servers reuse them.
+   */
+  loadAppModules?: boolean;
+  /**
+   * How app modules are imported when `loadAppModules` is set. Pass
+   * `(file) => import(file)` from the test file, as `setupTest()` takes it, so
+   * app classes are the same ones the test imports.
+   */
+  importModule?: AppModuleImporter;
+  /** Interface to bind. Defaults to `127.0.0.1`. */
+  host?: string;
+};
+export type TestHttpServer = TestRequestClient & {
+  /** `http://127.0.0.1:<port>` */
+  readonly url: string;
+  /** The port the OS assigned. */
+  readonly port: number;
+  /** The Fastify instance, for `inject()` or anything else Fastify offers. */
+  readonly server: FastifyInstance;
+  /** A client for this server, signed in as `user` with a real access token. */
+  actingAs(user: TestAuthenticableUser): Promise<AuthenticatedTestClient>;
+  /** Stop listening and remove the routes `routes` registered. */
+  close(): Promise<void>;
+};
+/**
+ * Start an in-process HTTP server with the production plugins, on a free port.
+ *
+ * @example
+ * const app = await createTestHttpServer({
+ *   routes: (router) => router.post("/echo", ({ request, response }) =>
+ *     response.success({ body: request.all() })),
+ * });
+ *
+ * const response = await app.post("/echo", { name: "Ada" });
+ * expect(response.status).toBe(200);
+ *
+ * await app.close();
+ *
+ * @example
+ * // every app route, with the fakes seeing what the controller did
+ * const app = await createTestHttpServer({
+ *   loadAppModules: true,
+ *   importModule: (file) => import(file),
+ * });
+ *
+ * await app.post("/contact", { email: "ada@example.test", message: "Hi" });
+ * mailFake.assertSent({ to: "support@example.test" });
+ */
+export declare function createTestHttpServer(options?: CreateTestHttpServerOptions): Promise<TestHttpServer>;
+//#endregion
+//# sourceMappingURL=test-http-server.d.mts.map

package/esm/tests/test-http-server.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-http-server.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/tests/test-http-server.ts"],"mappings":";;;;;;YA+BY;;;;;EAKV,UAAU,QAAQ;;;;;;EAMlB;;;;;;EAMA,eAAe;;EAEf;;YAGU,iBAAiB;;WAElB;;WAEA;;WAEA,QAAQ;;EAEjB,SAAS,MAAM,wBAAwB,QAAQ;;EAE/C,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;wBAmEW,qBACpB,UAAS,8BACR,QAAQ"}

package/esm/tests/test-http-server.mjs

@@ -0,0 +1,119 @@
+import { validateCspConfigAtBoot } from "../http/csp.mjs";
+import { router } from "../router/router.mjs";
+import { registerHttpPlugins } from "../http/plugins.mjs";
+import { startHttpServer } from "../http/server.mjs";
+import { setAppModuleImporter } from "../loader/app-module-importer.mjs";
+import { createTestRequestClient } from "./test-helpers.mjs";
+import { actingAs } from "./authenticated-test-client.mjs";
+
+//#region ../../packages/core/src/tests/test-http-server.ts
+/**
+* An HTTP server inside the test process, built the way production builds it.
+*
+* `startHttpTestServer()` runs one server for the whole run, in Vitest's main
+* process. This is the other shape: a server per test file (or per test) in the
+* worker itself, on an OS-assigned port. Two things follow from living in the
+* worker:
+*
+* - Requests run through the REAL stack: the Fastify instance `startHttpServer`
+*   creates, every plugin `registerHttpPlugins` registers in production (rate
+*   limit, CORS, multipart, cookies, ...), and the router's real route
+*   registration. A test cannot pass against a request shape production never
+*   produces, and the plugins' own behaviour (what the rate-limit store is
+*   handed, how a cookie is parsed) is what runs.
+* - The test fakes see everything the request did: mail sent and jobs pushed
+*   by the controller land in this process's `mailFake` / `queueFake`.
+*/
+const APP_MODULES_LOADED_KEY = Symbol.for("warlock.core.testAppModulesLoaded");
+let serverCounter = 0;
+async function loadAppModulesOnce(importModule) {
+	const holder = globalThis;
+	holder[APP_MODULES_LOADED_KEY] ??= (async () => {
+		const { filesOrchestrator } = await import("../dev-server/files-orchestrator.mjs");
+		setAppModuleImporter(importModule);
+		try {
+			await filesOrchestrator.init();
+			await filesOrchestrator.initializeAll();
+			await filesOrchestrator.moduleLoader.loadAll();
+		} finally {
+			setAppModuleImporter(void 0);
+		}
+	})().catch((error) => {
+		holder[APP_MODULES_LOADED_KEY] = void 0;
+		throw error;
+	});
+	await holder[APP_MODULES_LOADED_KEY];
+}
+function boundPort(server) {
+	const address = server.server.address();
+	if (address === null || typeof address === "string") throw new Error("createTestHttpServer(): the server did not report a TCP port after listen().");
+	return address.port;
+}
+/**
+* Start an in-process HTTP server with the production plugins, on a free port.
+*
+* @example
+* const app = await createTestHttpServer({
+*   routes: (router) => router.post("/echo", ({ request, response }) =>
+*     response.success({ body: request.all() })),
+* });
+*
+* const response = await app.post("/echo", { name: "Ada" });
+* expect(response.status).toBe(200);
+*
+* await app.close();
+*
+* @example
+* // every app route, with the fakes seeing what the controller did
+* const app = await createTestHttpServer({
+*   loadAppModules: true,
+*   importModule: (file) => import(file),
+* });
+*
+* await app.post("/contact", { email: "ada@example.test", message: "Hi" });
+* mailFake.assertSent({ to: "support@example.test" });
+*/
+async function createTestHttpServer(options = {}) {
+	const host = options.host ?? "127.0.0.1";
+	const sourceFile = `test-http-server-${++serverCounter}`;
+	if (options.loadAppModules) await loadAppModulesOnce(options.importModule);
+	if (options.routes) {
+		const register = options.routes;
+		await router.withSourceFile(sourceFile, () => register(router));
+	}
+	validateCspConfigAtBoot();
+	const server = startHttpServer();
+	try {
+		await registerHttpPlugins(server);
+		router.scan(server);
+		await server.listen({
+			port: 0,
+			host
+		});
+	} catch (error) {
+		router.removeRoutesBySourceFile(sourceFile);
+		await server.close().catch(() => void 0);
+		throw error;
+	}
+	const port = boundPort(server);
+	const url = `http://${host.includes(":") ? `[${host}]` : host}:${port}`;
+	const client = createTestRequestClient(url);
+	let closed = false;
+	return {
+		...client,
+		url,
+		port,
+		server,
+		actingAs: (user) => actingAs(user, client),
+		close: async () => {
+			if (closed) return;
+			closed = true;
+			router.removeRoutesBySourceFile(sourceFile);
+			await server.close();
+		}
+	};
+}
+
+//#endregion
+export { createTestHttpServer };
+//# sourceMappingURL=test-http-server.mjs.map

package/esm/tests/test-http-server.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-http-server.mjs","names":[],"sources":["../../../../../../../../packages/core/src/tests/test-http-server.ts"],"sourcesContent":["/**\n * An HTTP server inside the test process, built the way production builds it.\n *\n * `startHttpTestServer()` runs one server for the whole run, in Vitest's main\n * process. This is the other shape: a server per test file (or per test) in the\n * worker itself, on an OS-assigned port. Two things follow from living in the\n * worker:\n *\n * - Requests run through the REAL stack: the Fastify instance `startHttpServer`\n *   creates, every plugin `registerHttpPlugins` registers in production (rate\n *   limit, CORS, multipart, cookies, ...), and the router's real route\n *   registration. A test cannot pass against a request shape production never\n *   produces, and the plugins' own behaviour (what the rate-limit store is\n *   handed, how a cookie is parsed) is what runs.\n * - The test fakes see everything the request did: mail sent and jobs pushed\n *   by the controller land in this process's `mailFake` / `queueFake`.\n */\nimport { router } from \"../router/router\";\nimport type { Router } from \"../router/router\";\nimport type { AppModuleImporter } from \"../loader/app-module-importer\";\nimport { setAppModuleImporter } from \"../loader/app-module-importer\";\nimport { validateCspConfigAtBoot } from \"../http/csp\";\nimport { registerHttpPlugins } from \"../http/plugins\";\nimport { type FastifyInstance, startHttpServer } from \"../http/server\";\nimport {\n  type AuthenticatedTestClient,\n  type TestAuthenticableUser,\n  actingAs,\n} from \"./authenticated-test-client\";\nimport { type TestRequestClient, createTestRequestClient } from \"./test-helpers\";\n\nexport type CreateTestHttpServerOptions = {\n  /**\n   * Register routes for this server, exactly as a `routes.ts` would. They are\n   * tagged with a source of their own and removed again by `close()`.\n   */\n  routes?: (router: Router) => unknown;\n  /**\n   * Load the application's modules (`routes.ts`, `main.ts`, events, ...) first,\n   * so the server answers every app route. Needs `setupTest()` to have run in\n   * this worker. Modules load once per process; later servers reuse them.\n   */\n  loadAppModules?: boolean;\n  /**\n   * How app modules are imported when `loadAppModules` is set. Pass\n   * `(file) => import(file)` from the test file, as `setupTest()` takes it, so\n   * app classes are the same ones the test imports.\n   */\n  importModule?: AppModuleImporter;\n  /** Interface to bind. Defaults to `127.0.0.1`. */\n  host?: string;\n};\n\nexport type TestHttpServer = TestRequestClient & {\n  /** `http://127.0.0.1:<port>` */\n  readonly url: string;\n  /** The port the OS assigned. */\n  readonly port: number;\n  /** The Fastify instance, for `inject()` or anything else Fastify offers. */\n  readonly server: FastifyInstance;\n  /** A client for this server, signed in as `user` with a real access token. */\n  actingAs(user: TestAuthenticableUser): Promise<AuthenticatedTestClient>;\n  /** Stop listening and remove the routes `routes` registered. */\n  close(): Promise<void>;\n};\n\nconst APP_MODULES_LOADED_KEY = Symbol.for(\"warlock.core.testAppModulesLoaded\");\n\ntype LoadedHolder = { [APP_MODULES_LOADED_KEY]?: Promise<void> };\n\nlet serverCounter = 0;\n\nasync function loadAppModulesOnce(importModule: AppModuleImporter | undefined): Promise<void> {\n  const holder = globalThis as LoadedHolder;\n\n  holder[APP_MODULES_LOADED_KEY] ??= (async () => {\n    const { filesOrchestrator } = await import(\"../dev-server/files-orchestrator\");\n\n    setAppModuleImporter(importModule);\n\n    try {\n      await filesOrchestrator.init();\n      await filesOrchestrator.initializeAll();\n      await filesOrchestrator.moduleLoader.loadAll();\n    } finally {\n      setAppModuleImporter(undefined);\n    }\n  })().catch((error: unknown) => {\n    // A failed load may be retried by the next server.\n    holder[APP_MODULES_LOADED_KEY] = undefined;\n    throw error;\n  });\n\n  await holder[APP_MODULES_LOADED_KEY];\n}\n\nfunction boundPort(server: FastifyInstance): number {\n  const address = server.server.address();\n\n  if (address === null || typeof address === \"string\") {\n    throw new Error(\"createTestHttpServer(): the server did not report a TCP port after listen().\");\n  }\n\n  return address.port;\n}\n\n/**\n * Start an in-process HTTP server with the production plugins, on a free port.\n *\n * @example\n * const app = await createTestHttpServer({\n *   routes: (router) => router.post(\"/echo\", ({ request, response }) =>\n *     response.success({ body: request.all() })),\n * });\n *\n * const response = await app.post(\"/echo\", { name: \"Ada\" });\n * expect(response.status).toBe(200);\n *\n * await app.close();\n *\n * @example\n * // every app route, with the fakes seeing what the controller did\n * const app = await createTestHttpServer({\n *   loadAppModules: true,\n *   importModule: (file) => import(file),\n * });\n *\n * await app.post(\"/contact\", { email: \"ada@example.test\", message: \"Hi\" });\n * mailFake.assertSent({ to: \"support@example.test\" });\n */\nexport async function createTestHttpServer(\n  options: CreateTestHttpServerOptions = {},\n): Promise<TestHttpServer> {\n  const host = options.host ?? \"127.0.0.1\";\n  const sourceFile = `test-http-server-${++serverCounter}`;\n\n  if (options.loadAppModules) {\n    await loadAppModulesOnce(options.importModule);\n  }\n\n  if (options.routes) {\n    const register = options.routes;\n\n    await router.withSourceFile(sourceFile, () => register(router));\n  }\n\n  validateCspConfigAtBoot();\n\n  const server = startHttpServer();\n\n  try {\n    await registerHttpPlugins(server);\n    router.scan(server);\n    await server.listen({ port: 0, host });\n  } catch (error) {\n    router.removeRoutesBySourceFile(sourceFile);\n    await server.close().catch(() => undefined);\n    throw error;\n  }\n\n  const port = boundPort(server);\n  const url = `http://${host.includes(\":\") ? `[${host}]` : host}:${port}`;\n  const client = createTestRequestClient(url);\n  let closed = false;\n\n  return {\n    ...client,\n    url,\n    port,\n    server,\n    actingAs: (user) => actingAs(user, client),\n    close: async () => {\n      if (closed) return;\n\n      closed = true;\n      router.removeRoutesBySourceFile(sourceFile);\n      await server.close();\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAkEA,MAAM,yBAAyB,OAAO,IAAI,mCAAmC;AAI7E,IAAI,gBAAgB;AAEpB,eAAe,mBAAmB,cAA4D;CAC5F,MAAM,SAAS;CAEf,OAAO,6BAA6B,YAAY;EAC9C,MAAM,EAAE,sBAAsB,MAAM,OAAO;EAE3C,qBAAqB,YAAY;EAEjC,IAAI;GACF,MAAM,kBAAkB,KAAK;GAC7B,MAAM,kBAAkB,cAAc;GACtC,MAAM,kBAAkB,aAAa,QAAQ;EAC/C,UAAU;GACR,qBAAqB,MAAS;EAChC;CACF,EAAC,CAAE,CAAC,CAAC,OAAO,UAAmB;EAE7B,OAAO,0BAA0B;EACjC,MAAM;CACR,CAAC;CAED,MAAM,OAAO;AACf;AAEA,SAAS,UAAU,QAAiC;CAClD,MAAM,UAAU,OAAO,OAAO,QAAQ;CAEtC,IAAI,YAAY,QAAQ,OAAO,YAAY,UACzC,MAAM,IAAI,MAAM,8EAA8E;CAGhG,OAAO,QAAQ;AACjB;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,eAAsB,qBACpB,UAAuC,CAAC,GACf;CACzB,MAAM,OAAO,QAAQ,QAAQ;CAC7B,MAAM,aAAa,oBAAoB,EAAE;CAEzC,IAAI,QAAQ,gBACV,MAAM,mBAAmB,QAAQ,YAAY;CAG/C,IAAI,QAAQ,QAAQ;EAClB,MAAM,WAAW,QAAQ;EAEzB,MAAM,OAAO,eAAe,kBAAkB,SAAS,MAAM,CAAC;CAChE;CAEA,wBAAwB;CAExB,MAAM,SAAS,gBAAgB;CAE/B,IAAI;EACF,MAAM,oBAAoB,MAAM;EAChC,OAAO,KAAK,MAAM;EAClB,MAAM,OAAO,OAAO;GAAE,MAAM;GAAG;EAAK,CAAC;CACvC,SAAS,OAAO;EACd,OAAO,yBAAyB,UAAU;EAC1C,MAAM,OAAO,MAAM,CAAC,CAAC,YAAY,MAAS;EAC1C,MAAM;CACR;CAEA,MAAM,OAAO,UAAU,MAAM;CAC7B,MAAM,MAAM,UAAU,KAAK,SAAS,GAAG,IAAI,IAAI,KAAK,KAAK,KAAK,GAAG;CACjE,MAAM,SAAS,wBAAwB,GAAG;CAC1C,IAAI,SAAS;CAEb,OAAO;EACL,GAAG;EACH;EACA;EACA;EACA,WAAW,SAAS,SAAS,MAAM,MAAM;EACzC,OAAO,YAAY;GACjB,IAAI,QAAQ;GAEZ,SAAS;GACT,OAAO,yBAAyB,UAAU;GAC1C,MAAM,OAAO,MAAM;EACrB;CACF;AACF"}

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

@@ -23,5 +23,5 @@ function getTestLifecycleRegistry() {
 }
 
 //#endregion
-export { getTestLifecycleRegistry };
+export { TEST_LIFECYCLE_REGISTRY_KEY, getTestLifecycleRegistry };
 //# sourceMappingURL=test-lifecycle-state.mjs.map

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

@@ -1,8 +1,8 @@
+import { TestFakesSelection } from "./fakes/test-fakes.mjs";
 import { AppModuleImporter } from "../loader/app-module-importer.mjs";
 import { TestConnectorsSelection } from "./test-connectors-selection.mjs";
-
 //#region ../../packages/core/src/tests/vitest-setup.d.ts
-type TestSetupOptions = {
+export type TestSetupOptions = {
   /**
    * Which connectors to start.
    *
@@ -22,16 +22,26 @@ type TestSetupOptions = {
    * fails. Defaults to native import.
    */
   importModule?: AppModuleImporter;
+  /**
+   * Which test fakes to install once the connectors are up: mail, queue,
+   * cache, storage, clock and ids (see `installTestFakes`).
+   *
+   * Precedence is `explicit option > tests.fakes config > true`, so every fake
+   * is on unless the project or this call opts out. `false` keeps the real
+   * drivers; `{ cache: false }` keeps only the real cache. Teardown restores
+   * them.
+   */
+  fakes?: TestFakesSelection;
 };
 /**
  * Warn — once per process — that app modules are loaded outside Vitest's graph.
  */
-declare function warnMissingImportModule(importModule: AppModuleImporter | undefined): void;
+export declare function warnMissingImportModule(importModule: AppModuleImporter | undefined): void;
 /**
  * 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 class TestLifecycleError extends Error {
+export declare class TestLifecycleError extends Error {
   constructor(message: string);
 }
 /**
@@ -61,7 +71,7 @@ declare class TestLifecycleError extends Error {
  * // bootstrap only — no connectors, whatever config says
  * await setupTest({ connectors: false });
  */
-declare function setupTest(options?: TestSetupOptions): Promise<void>;
+export declare function setupTest(options?: TestSetupOptions): Promise<void>;
 /**
  * Shut the test runtime down and release the lifecycle.
  *
@@ -79,7 +89,7 @@ declare function setupTest(options?: TestSetupOptions): Promise<void>;
  * `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>;
+export declare function teardownTest(): Promise<void>;
 //#endregion
-export { TestLifecycleError, TestSetupOptions, setupTest, teardownTest, warnMissingImportModule };
+export type { TestConnectorsSelection };
 //# 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":["../../../../../../../../packages/core/src/tests/vitest-setup.ts"],"mappings":";;;;KAmDY,gBAAA;EAAA;;;;;;;;EASV,UAAA,GAAa,uBAAA;EAUmB;AAQlC;;;;AAAmF;AAkBnF;;;EA1BE,YAAA,GAAe,iBAAiB;AAAA;;;;iBAQlB,uBAAA,CAAwB,YAA2C,EAA7B,iBAAiB;AAwDvE;;;;AAAA,cAtCa,kBAAA,SAA2B,KAAK;cACxB,OAAA;AAAA;;AAqC+C;AA0DpE;;;;AAA6C;;;;;;;;;;;;;;;;;;;;;iBA1DvB,SAAA,CAAU,OAAA,GAAU,gBAAA,GAAmB,OAAO;;;;;;;;;;;;;;;;;;iBA0D9C,YAAA,IAAgB,OAAO"}
+{"version":3,"file":"vitest-setup.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/tests/vitest-setup.ts"],"mappings":";;;;YAqDY;;;;;;;;;EASV,aAAa;;;;;;;;;;EAUb,eAAe;;;;;;;;;;EAUf,QAAQ;;;;;wBAQM,wBAAwB,cAAc;;;;;qBAkBzC,2BAA2B;EACtC,YAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAqCC,UAAU,UAAU,mBAAmB;;;;;;;;;;;;;;;;;;wBA0DvC,gBAAgB"}

package/esm/tests/vitest-setup.mjs

@@ -6,6 +6,7 @@ import "../connectors/index.mjs";
 import { setAppModuleImporter } from "../loader/app-module-importer.mjs";
 import { filesOrchestrator } from "../dev-server/files-orchestrator.mjs";
 import { loadConfigFiles } from "../config/load-config-files.mjs";
+import { installTestFakes, restoreTestFakes } from "./fakes/test-fakes.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";
@@ -103,7 +104,7 @@ async function setupTest(options) {
 	}
 	setAppModuleImporter(options?.importModule);
 	try {
-		return await startTestRuntime(requested);
+		return await startTestRuntime(requested, options?.fakes);
 	} finally {
 		setAppModuleImporter(void 0);
 	}
@@ -214,7 +215,7 @@ async function awaitSetupWithinBound(attempt, bound, registry) {
 /**
 * Open a new setup attempt and publish it before it runs.
 */
-function startTestRuntime(requested) {
+function startTestRuntime(requested, fakes) {
 	const registry = getTestLifecycleRegistry();
 	let publishEffectiveSelection = () => void 0;
 	let failEffectiveSelection = () => void 0;
@@ -224,7 +225,7 @@ function startTestRuntime(requested) {
 	});
 	effectiveSelection.catch(() => void 0);
 	const bound = armSetupBound(registry);
-	const attempt = Promise.resolve().then(() => runTestRuntimeStartup(requested, publishEffectiveSelection, failEffectiveSelection, bound));
+	const attempt = Promise.resolve().then(() => runTestRuntimeStartup(requested, publishEffectiveSelection, failEffectiveSelection, bound, fakes));
 	attempt.catch(() => void 0);
 	const completion = awaitSetupWithinBound(attempt, bound, registry);
 	registry.state = "starting";
@@ -242,7 +243,7 @@ function startTestRuntime(requested) {
 * 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) {
+async function runTestRuntimeStartup(requested, publishEffectiveSelection, failEffectiveSelection, bound, fakes) {
 	const registry = getTestLifecycleRegistry();
 	try {
 		Application.setEnvironment("test");
@@ -256,6 +257,7 @@ async function runTestRuntimeStartup(requested, publishEffectiveSelection, failE
 		if (!bound.hasExpired()) registry.activeSelection = effectiveSelection;
 		publishEffectiveSelection(effectiveSelection);
 		await startSelectedConnectors(effectiveSelection);
+		await installTestFakes(fakes);
 		if (!bound.hasExpired()) {
 			registry.state = "ready";
 			registry.setupAttempt = void 0;
@@ -292,6 +294,7 @@ async function startSelectedConnectors(selection) {
 * step is attempted independently.
 */
 async function unwindPartialStartup() {
+	await attemptCleanupStep("test fakes", () => restoreTestFakes());
 	await attemptCleanupStep("application shutdown hooks", () => Application.runShutdownHooks());
 	await attemptCleanupStep("connectors shutdown", () => connectorsManager.shutdown());
 }
@@ -312,6 +315,11 @@ async function runTestRuntimeShutdown() {
 	const registry = getTestLifecycleRegistry();
 	let shutdownSucceeded = false;
 	try {
+		try {
+			await restoreTestFakes();
+		} catch (error) {
+			console.error("[vitest-setup] Restoring the test fakes did not complete:", error);
+		}
 		await connectorsManager.shutdown();
 		shutdownSucceeded = true;
 	} finally {