@stratal/testing 0.0.13 → 0.0.15

package/dist/index.mjs

@@ -0,0 +1,1788 @@
+import { env, waitUntil } from "cloudflare:workers";
+import { Application } from "stratal";
+import { LogLevel } from "stratal/logger";
+import { Module } from "stratal/module";
+import { FileNotFoundError, STORAGE_TOKENS, StorageManagerService, StorageService } from "stratal/storage";
+import { DI_TOKENS, Transient, inject } from "stratal/di";
+import { expect } from "vitest";
+import { connectionSymbol } from "@stratal/framework/database";
+import { SEEDER_TOKENS, SeederNotRegisteredError } from "stratal/seeder";
+import { AUTH_SERVICE } from "@stratal/framework/auth";
+import { setSessionCookie } from "better-auth/cookies";
+import { convertSetCookieToCookie } from "better-auth/test";
+import { HttpResponse, HttpResponse as HttpResponse$1, http, http as http$1 } from "msw";
+import { setupServer } from "msw/node";
+//#region src/core/override/provider-override-builder.ts
+/**
+* Fluent builder for provider overrides
+*
+* Provides a NestJS-style API for overriding providers in tests.
+*
+* @example
+* ```typescript
+* const module = await Test.createTestingModule({
+*   imports: [RegistrationModule],
+* })
+*   .overrideProvider(EMAIL_TOKENS.EmailService)
+*   .useValue(mockEmailService)
+*   .compile()
+* ```
+*/
+var ProviderOverrideBuilder = class {
+	constructor(parent, token) {
+		this.parent = parent;
+		this.token = token;
+	}
+	/**
+	* Use a static value as the provider
+	*
+	* The value will be registered directly in the container.
+	*
+	* @param value - The value to use as the provider
+	* @returns The parent TestingModuleBuilder for chaining
+	*/
+	useValue(value) {
+		return this.parent.addProviderOverride({
+			token: this.token,
+			type: "value",
+			implementation: value
+		});
+	}
+	/**
+	* Use a class as the provider
+	*
+	* The class will be registered as a singleton.
+	*
+	* @param cls - The class constructor to use as the provider
+	* @returns The parent TestingModuleBuilder for chaining
+	*/
+	useClass(cls) {
+		return this.parent.addProviderOverride({
+			token: this.token,
+			type: "class",
+			implementation: cls
+		});
+	}
+	/**
+	* Use a factory function as the provider
+	*
+	* The factory receives the container and should return the provider instance.
+	*
+	* @param factory - Factory function that creates the provider
+	* @returns The parent TestingModuleBuilder for chaining
+	*/
+	useFactory(factory) {
+		return this.parent.addProviderOverride({
+			token: this.token,
+			type: "factory",
+			implementation: factory
+		});
+	}
+	/**
+	* Use an existing token as the provider (alias)
+	*
+	* The override token will resolve to the same instance as the target token.
+	*
+	* @param existingToken - The token to alias
+	* @returns The parent TestingModuleBuilder for chaining
+	*
+	* @example
+	* ```typescript
+	* const module = await Test.createTestingModule({
+	*   imports: [MyModule],
+	* })
+	*   .overrideProvider(ABSTRACT_TOKEN)
+	*   .useExisting(ConcreteService)
+	*   .compile()
+	* ```
+	*/
+	useExisting(existingToken) {
+		return this.parent.addProviderOverride({
+			token: this.token,
+			type: "existing",
+			implementation: existingToken
+		});
+	}
+};
+//#endregion
+//#region \0@oxc-project+runtime@0.115.0/helpers/decorateMetadata.js
+function __decorateMetadata(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.115.0/helpers/decorateParam.js
+function __decorateParam(paramIndex, decorator) {
+	return function(target, key) {
+		decorator(target, key, paramIndex);
+	};
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.115.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+//#endregion
+//#region src/storage/fake-storage.service.ts
+var _ref;
+let FakeStorageService = class FakeStorageService extends StorageService {
+	files = /* @__PURE__ */ new Map();
+	constructor(storageManager, options) {
+		super(storageManager, options);
+		this.storageManager = storageManager;
+		this.options = options;
+	}
+	/**
+	* Upload content to fake storage
+	*/
+	async upload(body, relativePath, options, disk) {
+		const content = await this.bodyToUint8Array(body);
+		const diskName = this.resolveDisk(disk);
+		this.files.set(relativePath, {
+			content,
+			mimeType: options.mimeType ?? "application/octet-stream",
+			size: options.size,
+			metadata: options.metadata,
+			uploadedAt: /* @__PURE__ */ new Date()
+		});
+		return {
+			path: relativePath,
+			disk: diskName,
+			fullPath: relativePath,
+			size: options.size,
+			mimeType: options.mimeType ?? "application/octet-stream",
+			uploadedAt: /* @__PURE__ */ new Date()
+		};
+	}
+	/**
+	* Download a file from fake storage
+	*/
+	download(path) {
+		const file = this.files.get(path);
+		if (!file) return Promise.reject(new FileNotFoundError(path));
+		return Promise.resolve({
+			toStream: () => new ReadableStream({ start(controller) {
+				controller.enqueue(file.content);
+				controller.close();
+			} }),
+			toString: () => Promise.resolve(new TextDecoder().decode(file.content)),
+			toArrayBuffer: () => Promise.resolve(file.content),
+			contentType: file.mimeType,
+			size: file.size,
+			metadata: file.metadata
+		});
+	}
+	/**
+	* Delete a file from fake storage
+	*/
+	delete(path) {
+		this.files.delete(path);
+		return Promise.resolve();
+	}
+	/**
+	* Check if a file exists in fake storage
+	*/
+	exists(path) {
+		return Promise.resolve(this.files.has(path));
+	}
+	/**
+	* Generate a fake presigned download URL
+	*/
+	getPresignedDownloadUrl(path, expiresIn) {
+		return Promise.resolve(this.createPresignedUrl(path, "GET", expiresIn));
+	}
+	/**
+	* Generate a fake presigned upload URL
+	*/
+	getPresignedUploadUrl(path, expiresIn) {
+		return Promise.resolve(this.createPresignedUrl(path, "PUT", expiresIn));
+	}
+	/**
+	* Generate a fake presigned delete URL
+	*/
+	getPresignedDeleteUrl(path, expiresIn) {
+		return Promise.resolve(this.createPresignedUrl(path, "DELETE", expiresIn));
+	}
+	/**
+	* Chunked upload (same as regular upload for fake)
+	*/
+	async chunkedUpload(body, path, options, disk) {
+		const content = await this.bodyToUint8Array(body);
+		const size = options.size ?? content.length;
+		return this.upload(body, path, {
+			...options,
+			size
+		}, disk);
+	}
+	/**
+	* Assert that a file exists at the given path
+	*
+	* @param path - Path to check
+	* @throws AssertionError if file does not exist
+	*/
+	assertExists(path) {
+		expect(this.files.has(path), `Expected file to exist at: ${path}\nStored files: ${this.getStoredPaths().join(", ") || "(none)"}`).toBe(true);
+	}
+	/**
+	* Assert that a file does NOT exist at the given path
+	*
+	* @param path - Path to check
+	* @throws AssertionError if file exists
+	*/
+	assertMissing(path) {
+		expect(this.files.has(path), `Expected file NOT to exist at: ${path}`).toBe(false);
+	}
+	/**
+	* Assert storage is empty
+	*
+	* @throws AssertionError if any files exist
+	*/
+	assertEmpty() {
+		expect(this.files.size, `Expected storage to be empty but found ${this.files.size} files: ${this.getStoredPaths().join(", ")}`).toBe(0);
+	}
+	/**
+	* Assert storage has exactly N files
+	*
+	* @param count - Expected number of files
+	* @throws AssertionError if count doesn't match
+	*/
+	assertCount(count) {
+		expect(this.files.size, `Expected ${count} files in storage but found ${this.files.size}`).toBe(count);
+	}
+	/**
+	* Get all stored files (for inspection)
+	*/
+	getStoredFiles() {
+		return new Map(this.files);
+	}
+	/**
+	* Get all stored file paths
+	*/
+	getStoredPaths() {
+		return Array.from(this.files.keys());
+	}
+	/**
+	* Get a specific file by path
+	*/
+	getFile(path) {
+		return this.files.get(path);
+	}
+	/**
+	* Clear all stored files (call in beforeEach for test isolation)
+	*/
+	clear() {
+		this.files.clear();
+	}
+	createPresignedUrl(path, method, expiresIn = 300) {
+		const expiresAt = new Date(Date.now() + expiresIn * 1e3);
+		return {
+			url: `https://fake-storage.test/${path}?method=${method}&expires=${expiresAt.toISOString()}`,
+			expiresIn,
+			expiresAt,
+			method
+		};
+	}
+	async bodyToUint8Array(body) {
+		if (!body) return new Uint8Array(0);
+		if (body instanceof Uint8Array) return body;
+		if (body instanceof ArrayBuffer) return new Uint8Array(body);
+		if (typeof body === "string") return new TextEncoder().encode(body);
+		if (body instanceof Blob) {
+			const buffer = await body.arrayBuffer();
+			return new Uint8Array(buffer);
+		}
+		if (body instanceof ReadableStream) return new Uint8Array(await new Response(body).arrayBuffer());
+		if (body instanceof FormData || body instanceof URLSearchParams) return new Uint8Array(await new Response(body).arrayBuffer());
+		return new Uint8Array(0);
+	}
+};
+FakeStorageService = __decorate([
+	Transient(STORAGE_TOKENS.StorageService),
+	__decorateParam(0, inject(STORAGE_TOKENS.StorageManager)),
+	__decorateParam(1, inject(STORAGE_TOKENS.Options)),
+	__decorateMetadata("design:paramtypes", [typeof (_ref = typeof StorageManagerService !== "undefined" && StorageManagerService) === "function" ? _ref : Object, Object])
+], FakeStorageService);
+//#endregion
+//#region src/core/env/test-env.ts
+/**
+* Get test environment with optional overrides
+*
+* @param overrides - Optional partial env to merge with cloudflare:test env
+* @returns Complete Env object for testing
+*/
+function getTestEnv(overrides) {
+	return {
+		...env,
+		...overrides
+	};
+}
+//#endregion
+//#region src/auth/acting-as.ts
+async function makeSignature(value, secret) {
+	const algorithm = {
+		name: "HMAC",
+		hash: "SHA-256"
+	};
+	const secretBuf = new TextEncoder().encode(secret);
+	const key = await crypto.subtle.importKey("raw", secretBuf, algorithm, false, ["sign"]);
+	const signature = await crypto.subtle.sign(algorithm.name, key, new TextEncoder().encode(value));
+	return btoa(String.fromCharCode(...new Uint8Array(signature)));
+}
+function buildCookieString(name, value, options = {}) {
+	let str = `${name}=${encodeURIComponent(value)}`;
+	if (options.path) str += `; Path=${options.path}`;
+	if (options.httpOnly) str += "; HttpOnly";
+	if (options.secure) str += "; Secure";
+	if (options.sameSite) str += `; SameSite=${options.sameSite}`;
+	if (options.maxAge !== void 0) str += `; Max-Age=${Math.floor(options.maxAge)}`;
+	return str;
+}
+/**
+* ActingAs
+*
+* Creates authentication sessions for testing.
+* Uses Better Auth's internalAdapter to create real database sessions.
+*
+* @example
+* ```typescript
+* const actingAs = new ActingAs(authService)
+* const headers = await actingAs.createSessionForUser({ id: 'user-123' })
+* ```
+*/
+var ActingAs = class {
+	constructor(authService) {
+		this.authService = authService;
+	}
+	async createSessionForUser(user) {
+		const ctx = await this.authService.auth.$context;
+		const secret = ctx.secret;
+		const session = await ctx.internalAdapter.createSession(user.id, void 0, {
+			ipAddress: "127.0.0.1",
+			userAgent: "test-client"
+		});
+		const dbUser = await ctx.internalAdapter.findUserById(user.id);
+		if (!dbUser) throw new Error(`User not found: ${user.id}`);
+		const responseHeaders = new Headers();
+		await setSessionCookie({
+			context: ctx,
+			getSignedCookie: () => null,
+			setSignedCookie: async (name, value, _secret, options = {}) => {
+				const signedValue = `${value}.${await makeSignature(value, secret)}`;
+				responseHeaders.append("Set-Cookie", buildCookieString(name, signedValue, options));
+			},
+			setCookie: (name, value, options = {}) => {
+				responseHeaders.append("Set-Cookie", buildCookieString(name, value, options));
+			}
+		}, {
+			session,
+			user: dbUser
+		}, false);
+		return convertSetCookieToCookie(responseHeaders);
+	}
+};
+//#endregion
+//#region src/core/http/test-response.ts
+/**
+* TestResponse
+*
+* Wrapper around Response with assertion methods.
+*
+* @example
+* ```typescript
+* response
+*   .assertOk()
+*   .assertStatus(200)
+*   .assertJsonPath('data.id', userId)
+* ```
+*/
+var TestResponse = class {
+	jsonData = null;
+	textData = null;
+	constructor(response) {
+		this.response = response;
+	}
+	/**
+	* Get the raw Response object.
+	*/
+	get raw() {
+		return this.response;
+	}
+	/**
+	* Get the response status code.
+	*/
+	get status() {
+		return this.response.status;
+	}
+	/**
+	* Get response headers.
+	*/
+	get headers() {
+		return this.response.headers;
+	}
+	/**
+	* Get the response body as JSON.
+	*/
+	async json() {
+		if (this.jsonData === null) this.jsonData = await this.response.clone().json();
+		return this.jsonData;
+	}
+	/**
+	* Get the response body as text.
+	*/
+	async text() {
+		this.textData ??= await this.response.clone().text();
+		return this.textData;
+	}
+	/**
+	* Assert response status is 200 OK.
+	*/
+	assertOk() {
+		return this.assertStatus(200);
+	}
+	/**
+	* Assert response status is 201 Created.
+	*/
+	assertCreated() {
+		return this.assertStatus(201);
+	}
+	/**
+	* Assert response status is 204 No Content.
+	*/
+	assertNoContent() {
+		return this.assertStatus(204);
+	}
+	/**
+	* Assert response status is 400 Bad Request.
+	*/
+	assertBadRequest() {
+		return this.assertStatus(400);
+	}
+	/**
+	* Assert response status is 401 Unauthorized.
+	*/
+	assertUnauthorized() {
+		return this.assertStatus(401);
+	}
+	/**
+	* Assert response status is 403 Forbidden.
+	*/
+	assertForbidden() {
+		return this.assertStatus(403);
+	}
+	/**
+	* Assert response status is 404 Not Found.
+	*/
+	assertNotFound() {
+		return this.assertStatus(404);
+	}
+	/**
+	* Assert response status is 422 Unprocessable Entity.
+	*/
+	assertUnprocessable() {
+		return this.assertStatus(422);
+	}
+	/**
+	* Assert response status is 500 Internal Server Error.
+	*/
+	assertServerError() {
+		return this.assertStatus(500);
+	}
+	/**
+	* Assert response has the given status code.
+	*/
+	assertStatus(expected) {
+		expect(this.response.status, `Expected status ${expected}, got ${this.response.status}`).toBe(expected);
+		return this;
+	}
+	/**
+	* Assert response status is in the 2xx success range.
+	*/
+	assertSuccessful() {
+		expect(this.response.status >= 200 && this.response.status < 300, `Expected successful status (2xx), got ${this.response.status}`).toBe(true);
+		return this;
+	}
+	/**
+	* Assert JSON response contains the given data.
+	*/
+	async assertJson(expected) {
+		const actual = await this.json();
+		for (const [key, value] of Object.entries(expected)) expect(actual[key], `Expected JSON key "${key}" to be ${JSON.stringify(value)}, got ${JSON.stringify(actual[key])}`).toBe(value);
+		return this;
+	}
+	/**
+	* Assert JSON response has value at the given path.
+	*
+	* @param path - Dot-notation path (e.g., 'data.user.id')
+	* @param expected - Expected value at path
+	*/
+	async assertJsonPath(path, expected) {
+		const json = await this.json();
+		const actual = this.getValueAtPath(json, path);
+		expect(actual, `Expected JSON path "${path}" to be ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`).toBe(expected);
+		return this;
+	}
+	/**
+	* Assert JSON response structure matches the given schema.
+	*/
+	async assertJsonStructure(structure) {
+		const json = await this.json();
+		for (const key of structure) expect(key in json, `Expected JSON to have key "${key}", got keys: ${JSON.stringify(Object.keys(json))}`).toBe(true);
+		return this;
+	}
+	/**
+	* Assert a JSON path exists (value can be anything, including null).
+	*
+	* @param path - Dot-notation path (e.g., 'data.user.id')
+	*/
+	async assertJsonPathExists(path) {
+		const json = await this.json();
+		expect(this.hasValueAtPath(json, path), `Expected JSON path "${path}" to exist`).toBe(true);
+		return this;
+	}
+	/**
+	* Assert a JSON path does not exist.
+	*
+	* @param path - Dot-notation path (e.g., 'data.user.deletedAt')
+	*/
+	async assertJsonPathMissing(path) {
+		const json = await this.json();
+		expect(this.hasValueAtPath(json, path), `Expected JSON path "${path}" to not exist`).toBe(false);
+		return this;
+	}
+	/**
+	* Assert JSON value at path matches a custom predicate.
+	*
+	* @param path - Dot-notation path (e.g., 'data.items')
+	* @param matcher - Predicate function to validate the value
+	*/
+	async assertJsonPathMatches(path, matcher) {
+		const json = await this.json();
+		const value = this.getValueAtPath(json, path);
+		expect(matcher(value), `Expected JSON path "${path}" to match predicate, got ${JSON.stringify(value)}`).toBe(true);
+		return this;
+	}
+	/**
+	* Assert string value at path contains a substring.
+	*
+	* @param path - Dot-notation path (e.g., 'data.message')
+	* @param substring - Substring to search for
+	*/
+	async assertJsonPathContains(path, substring) {
+		const json = await this.json();
+		const value = this.getValueAtPath(json, path);
+		expect(typeof value === "string", `Expected JSON path "${path}" to be a string, got ${typeof value}`).toBe(true);
+		expect(value.includes(substring), `Expected JSON path "${path}" to contain "${substring}", got "${String(value)}"`).toBe(true);
+		return this;
+	}
+	/**
+	* Assert array value at path includes a specific item.
+	*
+	* @param path - Dot-notation path (e.g., 'data.tags')
+	* @param item - Item to search for in the array
+	*/
+	async assertJsonPathIncludes(path, item) {
+		const json = await this.json();
+		const value = this.getValueAtPath(json, path);
+		expect(Array.isArray(value), `Expected JSON path "${path}" to be an array, got ${typeof value}`).toBe(true);
+		expect(value.includes(item), `Expected JSON path "${path}" to include ${JSON.stringify(item)}`).toBe(true);
+		return this;
+	}
+	/**
+	* Assert array length at path equals the expected count.
+	*
+	* @param path - Dot-notation path (e.g., 'data.items')
+	* @param count - Expected array length
+	*/
+	async assertJsonPathCount(path, count) {
+		const json = await this.json();
+		const value = this.getValueAtPath(json, path);
+		expect(Array.isArray(value), `Expected JSON path "${path}" to be an array, got ${typeof value}`).toBe(true);
+		expect(value.length, `Expected JSON path "${path}" to have ${count} items, got ${value.length}`).toBe(count);
+		return this;
+	}
+	/**
+	* Assert multiple JSON paths at once (batch assertion).
+	*
+	* @param expectations - Object mapping paths to expected values
+	*/
+	async assertJsonPaths(expectations) {
+		const json = await this.json();
+		for (const [path, expected] of Object.entries(expectations)) {
+			const actual = this.getValueAtPath(json, path);
+			expect(actual, `Expected JSON path "${path}" to be ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`).toBe(expected);
+		}
+		return this;
+	}
+	/**
+	* Assert response has the given header.
+	*/
+	assertHeader(name, expected) {
+		const actual = this.response.headers.get(name);
+		expect(actual !== null, `Expected header "${name}" to be present`).toBe(true);
+		if (expected !== void 0) expect(actual, `Expected header "${name}" to be "${expected}", got "${actual}"`).toBe(expected);
+		return this;
+	}
+	/**
+	* Assert response does not have the given header.
+	*/
+	assertHeaderMissing(name) {
+		const actual = this.response.headers.get(name);
+		expect(actual, `Expected header "${name}" to be absent, but got "${actual}"`).toBeNull();
+		return this;
+	}
+	/**
+	* Get value at dot-notation path.
+	*/
+	getValueAtPath(obj, path) {
+		const parts = path.split(".");
+		let current = obj;
+		for (const part of parts) {
+			if (current === null || current === void 0) return;
+			current = current[part];
+		}
+		return current;
+	}
+	/**
+	* Check if a path exists in the object (even if value is null/undefined).
+	*/
+	hasValueAtPath(obj, path) {
+		const parts = path.split(".");
+		let current = obj;
+		for (const part of parts) {
+			if (current === null || current === void 0) return false;
+			if (typeof current !== "object") return false;
+			const record = current;
+			if (!(part in record)) return false;
+			current = record[part];
+		}
+		return true;
+	}
+};
+//#endregion
+//#region src/core/http/test-http-request.ts
+/**
+* TestHttpRequest
+*
+* Request builder with fluent API for configuring test HTTP requests.
+*
+* @example
+* ```typescript
+* const response = await module.http
+*   .post('/api/v1/register')
+*   .withBody({ name: 'Test School' })
+*   .withHeaders({ 'X-Custom': 'value' })
+*   .send()
+* ```
+*
+* @example Authenticated request
+* ```typescript
+* const response = await module.http
+*   .get('/api/v1/profile')
+*   .actingAs({ id: user.id })
+*   .send()
+* ```
+*/
+var TestHttpRequest = class {
+	body = null;
+	requestHeaders;
+	actingAsUser = null;
+	constructor(method, path, headers, module, host = null) {
+		this.method = method;
+		this.path = path;
+		this.module = module;
+		this.host = host;
+		this.requestHeaders = new Headers(headers);
+	}
+	/**
+	* Set the request body
+	*/
+	withBody(data) {
+		this.body = data;
+		return this;
+	}
+	/**
+	* Add headers to the request
+	*/
+	withHeaders(headers) {
+		for (const [key, value] of Object.entries(headers)) this.requestHeaders.set(key, value);
+		return this;
+	}
+	/**
+	* Set Content-Type to application/json
+	*/
+	asJson() {
+		this.requestHeaders.set("Content-Type", "application/json");
+		return this;
+	}
+	/**
+	* Authenticate the request as a specific user
+	*/
+	actingAs(user) {
+		this.actingAsUser = user;
+		return this;
+	}
+	/**
+	* Send the request and return response
+	*
+	* Calls module.fetch() - NOT SELF.fetch()
+	*/
+	async send() {
+		await this.applyAuthentication();
+		if (this.body && !this.requestHeaders.has("Content-Type")) this.requestHeaders.set("Content-Type", "application/json");
+		const url = new URL(this.path, `http://${this.host ?? "localhost"}`);
+		const request = new Request(url.toString(), {
+			method: this.method,
+			headers: this.requestHeaders,
+			body: this.body ? JSON.stringify(this.body) : null
+		});
+		return new TestResponse(await this.module.fetch(request));
+	}
+	async applyAuthentication() {
+		if (!this.actingAsUser) return;
+		await this.module.runInRequestScope(async () => {
+			const actingAs = new ActingAs(this.module.get(AUTH_SERVICE));
+			const authHeaders = this.actingAsUser ? await actingAs.createSessionForUser(this.actingAsUser) : new Headers();
+			for (const [key, value] of authHeaders.entries()) this.requestHeaders.set(key, value);
+		});
+	}
+};
+//#endregion
+//#region src/core/http/test-http-client.ts
+/**
+* TestHttpClient
+*
+* Fluent HTTP client for making test requests.
+*
+* @example
+* ```typescript
+* const response = await module.http
+*   .forHost('example.com')
+*   .post('/api/v1/users')
+*   .withBody({ name: 'Test' })
+*   .send()
+*
+* response.assertCreated()
+* ```
+*/
+var TestHttpClient = class {
+	defaultHeaders = new Headers();
+	host = null;
+	constructor(module) {
+		this.module = module;
+	}
+	/**
+	* Set the host for the request
+	*/
+	forHost(host) {
+		this.host = host;
+		return this;
+	}
+	/**
+	* Set default headers for all requests
+	*/
+	withHeaders(headers) {
+		for (const [key, value] of Object.entries(headers)) this.defaultHeaders.set(key, value);
+		return this;
+	}
+	/**
+	* Create a GET request
+	*/
+	get(path) {
+		return this.createRequest("GET", path);
+	}
+	/**
+	* Create a POST request
+	*/
+	post(path) {
+		return this.createRequest("POST", path);
+	}
+	/**
+	* Create a PUT request
+	*/
+	put(path) {
+		return this.createRequest("PUT", path);
+	}
+	/**
+	* Create a PATCH request
+	*/
+	patch(path) {
+		return this.createRequest("PATCH", path);
+	}
+	/**
+	* Create a DELETE request
+	*/
+	delete(path) {
+		return this.createRequest("DELETE", path);
+	}
+	createRequest(method, path) {
+		return new TestHttpRequest(method, path, this.defaultHeaders, this.module, this.host);
+	}
+};
+//#endregion
+//#region src/core/quarry/test-command-result.ts
+/**
+* Fluent assertion wrapper for command results.
+*
+* @example
+* ```typescript
+* const result = await module
+*   .quarry('users:create')
+*   .withInput({ email: 'test@example.com' })
+*   .run()
+*
+* result.assertSuccessful()
+* result.assertOutputContains('User created')
+* ```
+*/
+var TestCommandResult = class {
+	constructor(result) {
+		this.result = result;
+	}
+	get exitCode() {
+		return this.result.exitCode;
+	}
+	get output() {
+		return this.result.output;
+	}
+	get errors() {
+		return this.result.errors;
+	}
+	assertSuccessful() {
+		expect(this.result.exitCode, `Expected exit code 0, got ${this.result.exitCode}. Errors: ${this.result.errors.join(", ")}`).toBe(0);
+		expect(this.result.errors, "Expected no errors").toHaveLength(0);
+		return this;
+	}
+	assertFailed(exitCode) {
+		if (exitCode !== void 0) expect(this.result.exitCode, `Expected exit code ${exitCode}, got ${this.result.exitCode}`).toBe(exitCode);
+		else expect(this.result.exitCode, "Expected non-zero exit code").not.toBe(0);
+		return this;
+	}
+	assertExitCode(code) {
+		expect(this.result.exitCode, `Expected exit code ${code}, got ${this.result.exitCode}`).toBe(code);
+		return this;
+	}
+	assertOutputContains(text) {
+		expect(this.result.output.join("\n"), `Expected output to contain "${text}"`).toContain(text);
+		return this;
+	}
+	assertOutputMissing(text) {
+		expect(this.result.output.join("\n"), `Expected output NOT to contain "${text}"`).not.toContain(text);
+		return this;
+	}
+	assertErrorContains(text) {
+		expect(this.result.errors.join("\n"), `Expected errors to contain "${text}"`).toContain(text);
+		return this;
+	}
+	assertErrorMissing(text) {
+		expect(this.result.errors.join("\n"), `Expected errors NOT to contain "${text}"`).not.toContain(text);
+		return this;
+	}
+};
+//#endregion
+//#region src/core/quarry/test-command-request.ts
+/**
+* Fluent builder for testing Quarry commands.
+*
+* @example
+* ```typescript
+* const result = await module
+*   .quarry('users:create')
+*   .withInput({ email: 'test@example.com', admin: true })
+*   .run()
+*
+* result.assertSuccessful()
+* result.assertOutputContains('User created')
+* ```
+*/
+var TestCommandRequest = class {
+	_input = {};
+	constructor(commandName, module) {
+		this.commandName = commandName;
+		this.module = module;
+	}
+	/**
+	* Set the flat input for the command.
+	*/
+	withInput(input) {
+		this._input = { ...input };
+		return this;
+	}
+	/**
+	* Execute the command and return a TestCommandResult for assertions.
+	*/
+	async run() {
+		return new TestCommandResult(await this.module.application.handleCommand(this.commandName, this._input));
+	}
+};
+//#endregion
+//#region src/core/sse/test-sse-connection.ts
+/**
+* TestSseConnection
+*
+* Live SSE connection wrapper with assertion helpers for testing.
+*
+* @example
+* ```typescript
+* const sse = await module.sse('/streaming/sse').connect()
+* await sse.assertEvent({ event: 'message', data: 'hello', id: '1' })
+* await sse.waitForEnd()
+* ```
+*/
+var TestSseConnection = class {
+	eventQueue = [];
+	eventWaiters = [];
+	streamEnded = false;
+	endWaiters = [];
+	constructor(response) {
+		this.response = response;
+		this.startReading();
+	}
+	/**
+	* Wait for the next SSE event
+	*/
+	async waitForEvent(timeout = 5e3) {
+		if (this.eventQueue.length > 0) return this.eventQueue.shift();
+		if (this.streamEnded) throw new Error("SSE: stream has ended, no more events");
+		return new Promise((resolve, reject) => {
+			const waiter = (event) => {
+				clearTimeout(timer);
+				resolve(event);
+			};
+			const timer = setTimeout(() => {
+				const index = this.eventWaiters.indexOf(waiter);
+				if (index !== -1) this.eventWaiters.splice(index, 1);
+				reject(/* @__PURE__ */ new Error(`SSE: no event received within ${timeout}ms`));
+			}, timeout);
+			this.eventWaiters.push(waiter);
+		});
+	}
+	/**
+	* Wait for the stream to end
+	*/
+	async waitForEnd(timeout = 5e3) {
+		if (this.streamEnded) return;
+		return new Promise((resolve, reject) => {
+			const waiter = () => {
+				clearTimeout(timer);
+				resolve();
+			};
+			const timer = setTimeout(() => {
+				const index = this.endWaiters.indexOf(waiter);
+				if (index !== -1) this.endWaiters.splice(index, 1);
+				reject(/* @__PURE__ */ new Error(`SSE: stream did not end within ${timeout}ms`));
+			}, timeout);
+			this.endWaiters.push(waiter);
+		});
+	}
+	/**
+	* Collect all remaining events until the stream ends
+	*/
+	async collectEvents(timeout = 5e3) {
+		const events = [];
+		if (this.streamEnded) return [...this.eventQueue.splice(0)];
+		return new Promise((resolve, reject) => {
+			const originalDispatch = this.dispatchEvent.bind(this);
+			this.dispatchEvent = (event) => {
+				events.push(event);
+				originalDispatch(event);
+			};
+			const endWaiter = () => {
+				clearTimeout(timer);
+				this.dispatchEvent = originalDispatch;
+				resolve(events);
+			};
+			const timer = setTimeout(() => {
+				this.dispatchEvent = originalDispatch;
+				const index = this.endWaiters.indexOf(endWaiter);
+				if (index !== -1) this.endWaiters.splice(index, 1);
+				reject(/* @__PURE__ */ new Error(`SSE: stream did not end within ${timeout}ms`));
+			}, timeout);
+			events.push(...this.eventQueue.splice(0));
+			this.endWaiters.push(endWaiter);
+		});
+	}
+	/**
+	* Assert that the next event matches the expected partial shape
+	*/
+	async assertEvent(expected, timeout = 5e3) {
+		expect(await this.waitForEvent(timeout)).toMatchObject(expected);
+	}
+	/**
+	* Assert that the next event's data matches the expected string
+	*/
+	async assertEventData(expected, timeout = 5e3) {
+		const event = await this.waitForEvent(timeout);
+		expect(event.data, `Expected SSE data "${expected}", got "${event.data}"`).toBe(expected);
+	}
+	/**
+	* Assert that the next event's data is JSON matching the expected value
+	*/
+	async assertJsonEventData(expected, timeout = 5e3) {
+		const event = await this.waitForEvent(timeout);
+		expect(JSON.parse(event.data)).toEqual(expected);
+	}
+	/**
+	* Access the raw Response
+	*/
+	get raw() {
+		return this.response;
+	}
+	startReading() {
+		const body = this.response.body;
+		if (!body) {
+			this.streamEnded = true;
+			return;
+		}
+		const reader = body.getReader();
+		const decoder = new TextDecoder();
+		let buffer = "";
+		const read = async () => {
+			try {
+				while (true) {
+					const { done, value } = await reader.read();
+					if (done) {
+						if (buffer.trim()) {
+							const event = this.parseEvent(buffer);
+							if (event) this.dispatchEvent(event);
+						}
+						this.streamEnded = true;
+						for (const waiter of this.endWaiters) waiter();
+						this.endWaiters = [];
+						return;
+					}
+					buffer += decoder.decode(value, { stream: true });
+					const parts = buffer.split("\n\n");
+					buffer = parts.pop();
+					for (const part of parts) {
+						if (!part.trim()) continue;
+						const event = this.parseEvent(part);
+						if (event) this.dispatchEvent(event);
+					}
+				}
+			} catch {
+				this.streamEnded = true;
+				for (const waiter of this.endWaiters) waiter();
+				this.endWaiters = [];
+			}
+		};
+		read();
+	}
+	parseEvent(raw) {
+		const lines = raw.split("\n");
+		const dataLines = [];
+		let event;
+		let id;
+		let retry;
+		for (const line of lines) {
+			if (line.startsWith(":")) continue;
+			const colonIndex = line.indexOf(":");
+			if (colonIndex === -1) continue;
+			const field = line.slice(0, colonIndex);
+			const value = line[colonIndex + 1] === " " ? line.slice(colonIndex + 2) : line.slice(colonIndex + 1);
+			switch (field) {
+				case "data":
+					dataLines.push(value);
+					break;
+				case "event":
+					event = value;
+					break;
+				case "id":
+					id = value;
+					break;
+				case "retry": {
+					const parsed = parseInt(value, 10);
+					if (!isNaN(parsed)) retry = parsed;
+					break;
+				}
+			}
+		}
+		if (dataLines.length === 0) return null;
+		const result = { data: dataLines.join("\n") };
+		if (event !== void 0) result.event = event;
+		if (id !== void 0) result.id = id;
+		if (retry !== void 0) result.retry = retry;
+		return result;
+	}
+	dispatchEvent(event) {
+		if (this.eventWaiters.length > 0) this.eventWaiters.shift()(event);
+		else this.eventQueue.push(event);
+	}
+};
+//#endregion
+//#region src/core/sse/test-sse-request.ts
+/**
+* TestSseRequest
+*
+* Builder for SSE connection requests. Follows the TestWsRequest pattern.
+*
+* @example
+* ```typescript
+* const sse = await module.sse('/streaming/sse').connect()
+* await sse.assertEvent({ event: 'message', data: 'hello' })
+* await sse.waitForEnd()
+* ```
+*
+* @example Authenticated SSE
+* ```typescript
+* const sse = await module.sse('/streaming/sse').actingAs({ id: user.id }).connect()
+* ```
+*/
+var TestSseRequest = class {
+	requestHeaders = new Headers();
+	actingAsUser = null;
+	constructor(path, module) {
+		this.path = path;
+		this.module = module;
+	}
+	/**
+	* Add custom headers to the request
+	*/
+	withHeaders(headers) {
+		for (const [key, value] of Object.entries(headers)) this.requestHeaders.set(key, value);
+		return this;
+	}
+	/**
+	* Authenticate the SSE connection as a specific user
+	*/
+	actingAs(user) {
+		this.actingAsUser = user;
+		return this;
+	}
+	/**
+	* Send the request and return a live SSE connection
+	*/
+	async connect() {
+		await this.applyAuthentication();
+		this.requestHeaders.set("Accept", "text/event-stream");
+		const url = new URL(this.path, "http://localhost");
+		const request = new Request(url.toString(), { headers: this.requestHeaders });
+		const response = await this.module.fetch(request);
+		expect(response.status, `Expected status 200, got ${response.status}`).toBe(200);
+		const contentType = response.headers.get("content-type") ?? "";
+		expect(contentType.includes("text/event-stream"), `Expected content-type "text/event-stream", got "${contentType}"`).toBe(true);
+		return new TestSseConnection(response);
+	}
+	async applyAuthentication() {
+		if (!this.actingAsUser) return;
+		await this.module.runInRequestScope(async () => {
+			const actingAs = new ActingAs(this.module.get(AUTH_SERVICE));
+			const authHeaders = this.actingAsUser ? await actingAs.createSessionForUser(this.actingAsUser) : new Headers();
+			for (const [key, value] of authHeaders.entries()) this.requestHeaders.set(key, value);
+		});
+	}
+};
+//#endregion
+//#region src/core/ws/test-ws-connection.ts
+/**
+* TestWsConnection
+*
+* Live WebSocket connection wrapper with assertion helpers for testing.
+*
+* @example
+* ```typescript
+* const ws = await module.ws('/ws/chat').connect()
+* ws.send('hello')
+* await ws.assertMessage('echo:hello')
+* ws.close()
+* await ws.waitForClose()
+* ```
+*/
+var TestWsConnection = class {
+	messageQueue = [];
+	messageWaiters = [];
+	closeEvent = null;
+	closeWaiters = [];
+	constructor(ws) {
+		this.ws = ws;
+		this.ws.addEventListener("message", (event) => {
+			const data = event.data;
+			if (this.messageWaiters.length > 0) this.messageWaiters.shift()(data);
+			else this.messageQueue.push(data);
+		});
+		this.ws.addEventListener("close", (event) => {
+			this.closeEvent = {
+				code: event.code,
+				reason: event.reason
+			};
+			for (const waiter of this.closeWaiters) waiter(this.closeEvent);
+			this.closeWaiters = [];
+		});
+	}
+	/**
+	* Send a message through the WebSocket
+	*/
+	send(data) {
+		this.ws.send(data);
+	}
+	/**
+	* Close the WebSocket connection
+	*/
+	close(code, reason) {
+		this.ws.close(code, reason);
+	}
+	/**
+	* Wait for the next message, returning its data
+	*/
+	async waitForMessage(timeout = 5e3) {
+		if (this.messageQueue.length > 0) return this.messageQueue.shift();
+		return new Promise((resolve, reject) => {
+			const waiter = (data) => {
+				clearTimeout(timer);
+				resolve(data);
+			};
+			const timer = setTimeout(() => {
+				const index = this.messageWaiters.indexOf(waiter);
+				if (index !== -1) this.messageWaiters.splice(index, 1);
+				reject(/* @__PURE__ */ new Error(`WebSocket: no message received within ${timeout}ms`));
+			}, timeout);
+			this.messageWaiters.push(waiter);
+		});
+	}
+	/**
+	* Wait for the connection to close
+	*/
+	async waitForClose(timeout = 5e3) {
+		if (this.closeEvent) return this.closeEvent;
+		return new Promise((resolve, reject) => {
+			const waiter = (event) => {
+				clearTimeout(timer);
+				resolve(event);
+			};
+			const timer = setTimeout(() => {
+				const index = this.closeWaiters.indexOf(waiter);
+				if (index !== -1) this.closeWaiters.splice(index, 1);
+				reject(/* @__PURE__ */ new Error(`WebSocket: connection did not close within ${timeout}ms`));
+			}, timeout);
+			this.closeWaiters.push(waiter);
+		});
+	}
+	/**
+	* Assert that the next message equals the expected value
+	*/
+	async assertMessage(expected, timeout = 5e3) {
+		const data = await this.waitForMessage(timeout);
+		const message = typeof data === "string" ? data : "[ArrayBuffer]";
+		expect(message, `Expected WebSocket message "${expected}", got "${message}"`).toBe(expected);
+	}
+	/**
+	* Assert that the connection closes, optionally with an expected code
+	*/
+	async assertClosed(expectedCode, timeout = 5e3) {
+		const event = await this.waitForClose(timeout);
+		if (expectedCode !== void 0) expect(event.code, `Expected close code ${expectedCode}, got ${event.code}`).toBe(expectedCode);
+	}
+	/**
+	* Access the raw Cloudflare WebSocket
+	*/
+	get raw() {
+		return this.ws;
+	}
+};
+//#endregion
+//#region src/core/ws/test-ws-request.ts
+/**
+* TestWsRequest
+*
+* Builder for WebSocket upgrade requests. Follows the TestHttpRequest pattern.
+*
+* @example
+* ```typescript
+* const ws = await module.ws('/ws/chat').connect()
+* ws.send('hello')
+* await ws.assertMessage('echo:hello')
+* ws.close()
+* ```
+*
+* @example Authenticated WebSocket
+* ```typescript
+* const ws = await module.ws('/ws/chat').actingAs({ id: user.id }).connect()
+* ```
+*/
+var TestWsRequest = class {
+	requestHeaders = new Headers();
+	actingAsUser = null;
+	constructor(path, module) {
+		this.path = path;
+		this.module = module;
+	}
+	/**
+	* Add custom headers to the upgrade request
+	*/
+	withHeaders(headers) {
+		for (const [key, value] of Object.entries(headers)) this.requestHeaders.set(key, value);
+		return this;
+	}
+	/**
+	* Authenticate the WebSocket connection as a specific user
+	*/
+	actingAs(user) {
+		this.actingAsUser = user;
+		return this;
+	}
+	/**
+	* Send the upgrade request and return a live WebSocket connection
+	*/
+	async connect() {
+		await this.applyAuthentication();
+		this.requestHeaders.set("Upgrade", "websocket");
+		this.requestHeaders.set("Connection", "Upgrade");
+		this.requestHeaders.set("Sec-WebSocket-Key", "dGhlIHNhbXBsZSBub25jZQ==");
+		this.requestHeaders.set("Sec-WebSocket-Version", "13");
+		const url = new URL(this.path, "http://localhost");
+		const request = new Request(url.toString(), { headers: this.requestHeaders });
+		const response = await this.module.fetch(request);
+		expect(response.status, `Expected status 101 (Switching Protocols), got ${response.status}`).toBe(101);
+		const ws = response.webSocket;
+		if (!ws) throw new Error("Response did not include a WebSocket connection");
+		ws.accept();
+		return new TestWsConnection(ws);
+	}
+	async applyAuthentication() {
+		if (!this.actingAsUser) return;
+		await this.module.runInRequestScope(async () => {
+			const actingAs = new ActingAs(this.module.get(AUTH_SERVICE));
+			const authHeaders = this.actingAsUser ? await actingAs.createSessionForUser(this.actingAsUser) : new Headers();
+			for (const [key, value] of authHeaders.entries()) this.requestHeaders.set(key, value);
+		});
+	}
+};
+//#endregion
+//#region src/core/testing-module.ts
+/**
+* TestingModule
+*
+* Provides access to the test application, container, HTTP client, and utilities.
+*
+* @example
+* ```typescript
+* const module = await Test.createTestingModule({
+*   modules: [RegistrationModule],
+* }).compile()
+*
+* // Make HTTP requests
+* const response = await module.http
+*   .post('/api/v1/register')
+*   .withBody({ ... })
+*   .send()
+*
+* // Access services
+* const service = module.get(REGISTRATION_TOKENS.RegistrationService)
+*
+* // Database utilities
+* await module.truncateDb()
+* await module.seed(UserSeeder)
+* await module.assertDatabaseHas('user', { email: 'test@example.com' })
+*
+* // Cleanup
+* await module.close()
+* ```
+*/
+var TestingModule = class {
+	_http = null;
+	_requestContainer;
+	constructor(app, env, ctx) {
+		this.app = app;
+		this.env = env;
+		this.ctx = ctx;
+		const mockContext = this.app.createMockRouterContext();
+		this._requestContainer = this.app.container.createRequestScope(mockContext);
+	}
+	/**
+	* Resolve a service from the container
+	*/
+	get(token) {
+		return this._requestContainer.resolve(token);
+	}
+	/**
+	* Get HTTP test client for making requests
+	*/
+	get http() {
+		this._http ??= new TestHttpClient(this);
+		return this._http;
+	}
+	/**
+	* Get fake storage service for assertions
+	*/
+	get storage() {
+		return this.get(STORAGE_TOKENS.StorageService);
+	}
+	/**
+	* Create a WebSocket test request builder for the given path
+	*/
+	ws(path) {
+		return new TestWsRequest(path, this);
+	}
+	/**
+	* Create an SSE test request builder for the given path
+	*/
+	sse(path) {
+		return new TestSseRequest(path, this);
+	}
+	/**
+	* Create a Quarry command test request builder
+	*/
+	quarry(name) {
+		return new TestCommandRequest(name, this);
+	}
+	/**
+	* Get Application instance
+	*/
+	get application() {
+		return this.app;
+	}
+	/**
+	* Get DI Container (request-scoped)
+	*/
+	get container() {
+		return this._requestContainer;
+	}
+	/**
+	* Execute an HTTP request through HonoApp
+	*/
+	async fetch(request) {
+		return this.app.hono.fetch(request, this.env, this.ctx);
+	}
+	/**
+	* Run callback in request scope (for DB operations, service access)
+	*/
+	async runInRequestScope(callback) {
+		const mockContext = this.app.createMockRouterContext();
+		return this.app.container.runInRequestScope(mockContext, callback);
+	}
+	getDb(name) {
+		const token = name ? connectionSymbol(name) : DI_TOKENS.Database;
+		return this._requestContainer.resolve(token);
+	}
+	/**
+	* Truncate all non-prisma tables in the database
+	*/
+	async truncateDb(name) {
+		const db = this.getDb(name);
+		const tables = await db.$queryRaw`
+      SELECT tablename::text as tablename FROM pg_tables
+      WHERE schemaname = current_schema()
+      AND tablename NOT LIKE '_prisma%'
+    `;
+		if (tables.length === 0) return;
+		const tableList = tables.map((t) => `"${t.tablename}"`).join(", ");
+		await db.$executeRawUnsafe(`TRUNCATE ${tableList} RESTART IDENTITY CASCADE`);
+	}
+	/**
+	* Run seeders by class constructor in the request-scoped container
+	*/
+	async seed(...SeederClasses) {
+		const registry = this._requestContainer.resolve(SEEDER_TOKENS.SeederRegistry);
+		for (const SeederClass of SeederClasses) {
+			if (!registry.has(SeederClass)) throw new SeederNotRegisteredError(SeederClass.name);
+			await registry.run(SeederClass, { container: this._requestContainer });
+		}
+	}
+	/**
+	* Assert that a record exists in the database
+	*/
+	async assertDatabaseHas(table, data, name) {
+		expect(await this.getDb(name)[table].findFirst({ where: data }), `Expected ${table} with ${JSON.stringify(data)}`).not.toBeNull();
+	}
+	/**
+	* Assert that a record does not exist in the database
+	*/
+	async assertDatabaseMissing(table, data, name) {
+		expect(await this.getDb(name)[table].findFirst({ where: data }), `Expected ${table} NOT to have ${JSON.stringify(data)}`).toBeNull();
+	}
+	/**
+	* Assert the number of records in a table
+	*/
+	async assertDatabaseCount(table, expected, name) {
+		const actual = await this.getDb(name)[table].count();
+		expect(actual, `Expected ${table} count ${expected}, got ${actual}`).toBe(expected);
+	}
+	/**
+	* Cleanup - call in afterAll
+	*/
+	async close() {
+		await this._requestContainer.dispose();
+		await this.app.shutdown();
+	}
+};
+//#endregion
+//#region src/core/testing-module-builder.ts
+/**
+* Builder for creating test modules with provider overrides
+*/
+var TestingModuleBuilder = class {
+	overrides = [];
+	constructor(config) {
+		this.config = config;
+	}
+	/**
+	* Override a provider with a custom implementation
+	*/
+	overrideProvider(token) {
+		return new ProviderOverrideBuilder(this, token);
+	}
+	/**
+	* Add a provider override (internal use by ProviderOverrideBuilder)
+	*
+	* @internal
+	*/
+	addProviderOverride(override) {
+		this.overrides.push(override);
+		return this;
+	}
+	/**
+	* Merge additional environment bindings
+	*/
+	withEnv(env) {
+		this.config.env = {
+			...this.config.env,
+			...env
+		};
+		return this;
+	}
+	/**
+	* Compile the testing module
+	*
+	* Creates the Application, applies overrides, initializes, and returns TestingModule.
+	*/
+	async compile() {
+		const env = getTestEnv(this.config.env);
+		const ctx = { waitUntil };
+		const allImports = [...Test.getBaseModules(), ...this.config.imports ?? []];
+		const app = new Application({
+			module: this.createTestRootModule({
+				imports: allImports,
+				providers: this.config.providers,
+				controllers: this.config.controllers,
+				consumers: this.config.consumers,
+				jobs: this.config.jobs
+			}),
+			logging: {
+				level: this.config.logging?.level ?? LogLevel.ERROR,
+				formatter: this.config.logging?.formatter ?? "pretty"
+			},
+			env,
+			ctx
+		});
+		app.container.registerSingleton(STORAGE_TOKENS.StorageService, FakeStorageService);
+		for (const override of this.overrides) switch (override.type) {
+			case "value":
+				app.container.registerValue(override.token, override.implementation);
+				break;
+			case "class":
+				app.container.registerSingleton(override.token, override.implementation);
+				break;
+			case "factory":
+				app.container.registerFactory(override.token, override.implementation);
+				break;
+			case "existing":
+				app.container.registerExisting(override.token, override.implementation);
+				break;
+		}
+		await app.initialize();
+		return new TestingModule(app, env, ctx);
+	}
+	/**
+	* Create a test root module with the given options
+	*/
+	createTestRootModule(options) {
+		let TestRootModule = class TestRootModule {};
+		TestRootModule = __decorate([Module(options)], TestRootModule);
+		return TestRootModule;
+	}
+};
+//#endregion
+//#region src/core/test.ts
+/**
+* Test
+*
+* Static class for creating testing modules.
+* Provides a NestJS-style API for configuring test modules.
+*
+* @example
+* ```typescript
+* // In vitest.setup.ts:
+* Test.setBaseModules([CoreModule])
+*
+* // In test files:
+* const module = await Test.createTestingModule({
+*   imports: [RegistrationModule, GeoModule],
+* })
+*   .overrideProvider(EMAIL_TOKENS.EmailService)
+*   .useValue(mockEmailService)
+*   .compile()
+* ```
+*/
+var Test = class {
+	/**
+	* Base modules to include in all test modules
+	* Set once in vitest.setup.ts
+	*/
+	static baseModules = [];
+	/**
+	* Set base modules to include in all test modules
+	* Should be called once in vitest.setup.ts
+	*
+	* @param modules - Modules to include before test-specific modules (e.g., CoreModule)
+	*/
+	static setBaseModules(modules) {
+		this.baseModules = modules;
+	}
+	/**
+	* Get base modules
+	*/
+	static getBaseModules() {
+		return this.baseModules;
+	}
+	/**
+	* Create a testing module builder
+	*
+	* @param config - Configuration with modules and optional env overrides
+	* @returns TestingModuleBuilder for configuring and compiling the module
+	*/
+	static createTestingModule(config) {
+		return new TestingModuleBuilder(config);
+	}
+};
+//#endregion
+//#region src/core/http/mock-fetch.ts
+/**
+* MSW-based fetch mock for declarative HTTP mocking in tests.
+*
+* Replaces the old Cloudflare `fetchMock` (undici MockAgent) with MSW's `setupServer`.
+* Works in both Node.js and workerd test environments.
+*
+* @example
+* ```typescript
+* import { createMockFetch } from '@stratal/testing'
+*
+* const mock = createMockFetch()
+*
+* beforeAll(() => mock.listen())
+* afterEach(() => mock.reset())
+* afterAll(() => mock.close())
+*
+* it('should mock external API', async () => {
+*   mock.mockJsonResponse('https://api.example.com/data', { success: true })
+*
+*   const response = await fetch('https://api.example.com/data')
+*   const json = await response.json()
+*
+*   expect(json.success).toBe(true)
+* })
+* ```
+*/
+var MockFetch = class {
+	server;
+	constructor(handlers = []) {
+		this.server = setupServer(...handlers);
+	}
+	/** Start intercepting. Call in beforeAll/beforeEach. */
+	listen() {
+		this.server.listen({ onUnhandledRequest: "error" });
+	}
+	/** Reset runtime handlers. Call in afterEach. */
+	reset() {
+		this.server.resetHandlers();
+	}
+	/** Stop intercepting. Call in afterAll. */
+	close() {
+		this.server.close();
+	}
+	/** Add runtime handler(s) for a single test. */
+	use(...handlers) {
+		this.server.use(...handlers);
+	}
+	/**
+	* Mock a JSON response.
+	*
+	* @param url - Full URL to mock (e.g., 'https://api.example.com/users')
+	* @param data - JSON data to return
+	* @param options - HTTP method, status code, headers
+	*
+	* @example
+	* ```typescript
+	* mock.mockJsonResponse('https://api.example.com/users', { users: [] })
+	* mock.mockJsonResponse('https://api.example.com/users', { created: true }, { method: 'POST', status: 201 })
+	* ```
+	*/
+	mockJsonResponse(url, data, options = {}) {
+		const handler = http$1[(options.method ?? "GET").toLowerCase()](url, () => HttpResponse$1.json(data, {
+			status: options.status ?? 200,
+			headers: options.headers
+		}));
+		this.server.use(handler);
+	}
+	/**
+	* Mock an error response.
+	*
+	* @param url - Full URL to mock
+	* @param status - HTTP error status code
+	* @param message - Optional error message
+	* @param options - HTTP method, headers
+	*
+	* @example
+	* ```typescript
+	* mock.mockError('https://api.example.com/fail', 401, 'Unauthorized')
+	* mock.mockError('https://api.example.com/fail', 500, 'Server Error', { method: 'POST' })
+	* ```
+	*/
+	mockError(url, status, message, options = {}) {
+		const method = (options.method ?? "GET").toLowerCase();
+		const body = message ? { error: message } : void 0;
+		this.server.use(http$1[method](url, () => HttpResponse$1.json(body, {
+			status,
+			headers: options.headers
+		})));
+	}
+};
+/**
+* Factory function to create a new MockFetch instance
+*
+* @param handlers - Optional initial MSW request handlers
+* @returns A new MockFetch instance
+*
+* @example
+* ```typescript
+* import { createMockFetch } from '@stratal/testing'
+*
+* const mock = createMockFetch()
+*
+* beforeAll(() => mock.listen())
+* afterEach(() => mock.reset())
+* afterAll(() => mock.close())
+* ```
+*/
+function createMockFetch(handlers) {
+	return new MockFetch(handlers);
+}
+//#endregion
+//#region src/errors/test-error.ts
+/**
+* Base error class for all test framework errors.
+* Extends from Error and allows easy identification via `instanceof`.
+*/
+var TestError = class extends Error {
+	constructor(message, cause) {
+		super(message);
+		this.cause = cause;
+		this.name = "TestError";
+		Error.captureStackTrace(this, this.constructor);
+	}
+};
+//#endregion
+//#region src/errors/setup-error.ts
+/**
+* Error thrown when test setup fails.
+* Examples: schema creation failure, migration failure, application bootstrap failure.
+*/
+var TestSetupError = class extends TestError {
+	constructor(message, cause) {
+		super(`Test setup failed: ${message}`, cause);
+	}
+};
+//#endregion
+export { ActingAs, FakeStorageService, HttpResponse, MockFetch, ProviderOverrideBuilder, Test, TestCommandRequest, TestCommandResult, TestError, TestHttpClient, TestHttpRequest, TestResponse, TestSetupError, TestSseConnection, TestSseRequest, TestWsConnection, TestWsRequest, TestingModule, TestingModuleBuilder, createMockFetch, getTestEnv, http };
+
+//# sourceMappingURL=index.mjs.map