@stratal/testing 0.0.27 → 0.1.0

package/dist/mocks/noop-rate-limiter-store.d.mts

@@ -1,5 +1,4 @@
 import { IRateLimiterStore } from "stratal/rate-limiter";
-
 //#region src/mocks/noop-rate-limiter-store.d.ts
 /**
  * Rate-limit store that never persists, so every read misses and every
@@ -11,11 +10,10 @@ import { IRateLimiterStore } from "stratal/rate-limiter";
  * this store via the framework bridge). Suites that want to test limiting
  * behavior can override `RATE_LIMITER_TOKENS.Store` back to a real store.
  */
-declare class NoopRateLimiterStore implements IRateLimiterStore {
+export declare class NoopRateLimiterStore implements IRateLimiterStore {
   get<T = unknown>(_key: string): Promise<T | null>;
   set<T = unknown>(_key: string, _value: T, _ttlSeconds: number): Promise<void>;
   delete(_key: string): Promise<void>;
 }
 //#endregion
-export { NoopRateLimiterStore };
 //# sourceMappingURL=noop-rate-limiter-store.d.mts.map

package/dist/mocks/noop-rate-limiter-store.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"noop-rate-limiter-store.d.mts","names":[],"sources":["../../src/mocks/noop-rate-limiter-store.ts"],"mappings":";;;;;AAYA;;;;;;;;cAAa,oBAAA,YAAgC,iBAAA;EAC3C,GAAA,cAAiB,IAAA,WAAe,OAAA,CAAQ,CAAA;EAIxC,GAAA,cAAiB,IAAA,UAAc,MAAA,EAAQ,CAAA,EAAG,WAAA,WAAsB,OAAA;EAKhE,MAAA,CAAO,IAAA,WAAe,OAAA;AAAA"}
+{"version":3,"file":"noop-rate-limiter-store.d.mts","names":[],"sources":["../../src/mocks/noop-rate-limiter-store.ts"],"mappings":";;;;;;;;;;;;qBAYa,gCAAgC;EAC3C,IAAI,aAAa,eAAe,QAAQ;EAIxC,IAAI,aAAa,cAAc,QAAQ,GAAG,sBAAsB;EAKhE,OAAO,eAAe"}

package/dist/mocks/zenstack-language.d.mts

@@ -6,43 +6,40 @@
  * incompatible with Cloudflare Workers runtime. These exports are only used
  * for schema generation (CLI functionality), not runtime authentication.
  *
- * This mock provides stub implementations to allow tests to run in vitest-pool-workers.
+ * This mock provides stub implementations to allow tests to run in the Workers Vitest integration.
  */
-declare const formatDocument: (content: string) => string;
-declare const loadDocument: (_path: string) => {
+export declare const formatDocument: (content: string) => string;
+export declare const loadDocument: (_path: string) => {
   success: boolean;
   errors: string[];
 };
-declare class ZModelCodeGenerator {
+export declare class ZModelCodeGenerator {
   generate(_model: unknown): string;
 }
-declare const isDataModel: (_item: unknown) => boolean;
-declare const isAttribute: (_item: unknown) => boolean;
-declare const isAbstractDeclaration: (_item: unknown) => boolean;
-declare const isExpression: (_item: unknown) => boolean;
-declare const isLiteralExpr: (_item: unknown) => boolean;
-declare const isArrayExpr: (_item: unknown) => boolean;
-declare const isAttributeArg: (_item: unknown) => boolean;
-declare const isBinaryExpr: (_item: unknown) => boolean;
-declare const isBooleanLiteral: (_item: unknown) => boolean;
-declare const isConfigArrayExpr: (_item: unknown) => boolean;
-declare const isConfigField: (_item: unknown) => boolean;
-declare const isDataField: (_item: unknown) => boolean;
-declare const isDataFieldAttribute: (_item: unknown) => boolean;
-declare const isDataFieldType: (_item: unknown) => boolean;
-declare const isDataModelAttribute: (_item: unknown) => boolean;
-declare const hasAttribute: (_node: unknown, _name?: string) => boolean;
+export declare const isDataModel: (_item: unknown) => boolean;
+export declare const isAttribute: (_item: unknown) => boolean;
+export declare const isAbstractDeclaration: (_item: unknown) => boolean;
+export declare const isExpression: (_item: unknown) => boolean;
+export declare const isLiteralExpr: (_item: unknown) => boolean;
+export declare const isArrayExpr: (_item: unknown) => boolean;
+export declare const isAttributeArg: (_item: unknown) => boolean;
+export declare const isBinaryExpr: (_item: unknown) => boolean;
+export declare const isBooleanLiteral: (_item: unknown) => boolean;
+export declare const isConfigArrayExpr: (_item: unknown) => boolean;
+export declare const isConfigField: (_item: unknown) => boolean;
+export declare const isDataField: (_item: unknown) => boolean;
+export declare const isDataFieldAttribute: (_item: unknown) => boolean;
+export declare const isDataFieldType: (_item: unknown) => boolean;
+export declare const isDataModelAttribute: (_item: unknown) => boolean;
+export declare const hasAttribute: (_node: unknown, _name?: string) => boolean;
 declare const _default: {
-  formatDocument: (content: string) => string;
-  loadDocument: (_path: string) => {
-    success: boolean;
-    errors: string[];
-  };
+  formatDocument: typeof formatDocument;
+  loadDocument: typeof loadDocument;
   ZModelCodeGenerator: typeof ZModelCodeGenerator;
-  isDataModel: (_item: unknown) => boolean;
-  isAttribute: (_item: unknown) => boolean;
-  hasAttribute: (_node: unknown, _name?: string) => boolean;
+  isDataModel: typeof isDataModel;
+  isAttribute: typeof isAttribute;
+  hasAttribute: typeof hasAttribute;
 };
 //#endregion
-export { ZModelCodeGenerator, _default as default, formatDocument, hasAttribute, isAbstractDeclaration, isArrayExpr, isAttribute, isAttributeArg, isBinaryExpr, isBooleanLiteral, isConfigArrayExpr, isConfigField, isDataField, isDataFieldAttribute, isDataFieldType, isDataModel, isDataModelAttribute, isExpression, isLiteralExpr, loadDocument };
+export { _default as default };
 //# sourceMappingURL=zenstack-language.d.mts.map

package/dist/mocks/zenstack-language.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"zenstack-language.d.mts","names":[],"sources":["../../src/mocks/zenstack-language.ts"],"mappings":";;AAWA;;;;AAA8C;AAE9C;;;cAFa,cAAA,GAAkB,OAAe;AAAA,cAEjC,YAAA,GAAgB,KAAA;;;;cAKhB,mBAAA;EACZ,QAAA,CAAS,MAAe;AAAA;AAAA,cAMZ,WAAA,GAAe,KAAc;AAAA,cAC7B,WAAA,GAAe,KAAc;AAAA,cAC7B,qBAAA,GAAyB,KAAc;AAAA,cACvC,YAAA,GAAgB,KAAc;AAAA,cAC9B,aAAA,GAAiB,KAAc;AAAA,cAC/B,WAAA,GAAe,KAAc;AAAA,cAC7B,cAAA,GAAkB,KAAc;AAAA,cAChC,YAAA,GAAgB,KAAc;AAAA,cAC9B,gBAAA,GAAoB,KAAc;AAAA,cAClC,iBAAA,GAAqB,KAAc;AAAA,cACnC,aAAA,GAAiB,KAAc;AAAA,cAC/B,WAAA,GAAe,KAAc;AAAA,cAC7B,oBAAA,GAAwB,KAAc;AAAA,cACtC,eAAA,GAAmB,KAAc;AAAA,cACjC,oBAAA,GAAwB,KAAc;AAAA,cAGtC,YAAA,GAAgB,KAAA,WAAgB,KAAc;AAAA,cAAmB,QAAA;;;;;;;;;iCAAnC,KAAA;AAAA"}
+{"version":3,"file":"zenstack-language.d.mts","names":[],"sources":["../../src/mocks/zenstack-language.ts"],"mappings":";;;;;;;;;;qBAWa,iBAAc;qBAEd,eAAY;EACxB;EACA;;qBAGY;EACZ,SAAS;;qBAMG,cAAW;qBACX,cAAW;qBACX,wBAAqB;qBACrB,eAAY;qBACZ,gBAAa;qBACb,cAAW;qBACX,iBAAc;qBACd,eAAY;qBACZ,mBAAgB;qBAChB,oBAAiB;qBACjB,gBAAa;qBACb,cAAW;qBACX,uBAAoB;qBACpB,kBAAe;qBACf,uBAAoB;qBAGpB,eAAY,gBAAkB"}

package/dist/mocks/zenstack-language.mjs

@@ -6,7 +6,7 @@
 * incompatible with Cloudflare Workers runtime. These exports are only used
 * for schema generation (CLI functionality), not runtime authentication.
 *
-* This mock provides stub implementations to allow tests to run in vitest-pool-workers.
+* This mock provides stub implementations to allow tests to run in the Workers Vitest integration.
 */
 const formatDocument = (content) => content;
 const loadDocument = (_path) => ({

package/dist/mocks/zenstack-language.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"zenstack-language.mjs","names":[],"sources":["../../src/mocks/zenstack-language.ts"],"sourcesContent":["/**\n * Mock for @zenstackhq/language package\n *\n * The @zenstackhq/language package depends on vscode-languageserver which is\n * incompatible with Cloudflare Workers runtime. These exports are only used\n * for schema generation (CLI functionality), not runtime authentication.\n *\n * This mock provides stub implementations to allow tests to run in vitest-pool-workers.\n */\n\n// Main exports from @zenstackhq/language\nexport const formatDocument = (content: string) => content\n\nexport const loadDocument = (_path: string) => ({\n\tsuccess: false,\n\terrors: ['Mock: loadDocument not available in test environment'],\n})\n\nexport class ZModelCodeGenerator {\n\tgenerate(_model: unknown): string {\n\t\treturn ''\n\t}\n}\n\n// AST exports from @zenstackhq/language/ast\nexport const isDataModel = (_item: unknown): boolean => false\nexport const isAttribute = (_item: unknown): boolean => false\nexport const isAbstractDeclaration = (_item: unknown): boolean => false\nexport const isExpression = (_item: unknown): boolean => false\nexport const isLiteralExpr = (_item: unknown): boolean => false\nexport const isArrayExpr = (_item: unknown): boolean => false\nexport const isAttributeArg = (_item: unknown): boolean => false\nexport const isBinaryExpr = (_item: unknown): boolean => false\nexport const isBooleanLiteral = (_item: unknown): boolean => false\nexport const isConfigArrayExpr = (_item: unknown): boolean => false\nexport const isConfigField = (_item: unknown): boolean => false\nexport const isDataField = (_item: unknown): boolean => false\nexport const isDataFieldAttribute = (_item: unknown): boolean => false\nexport const isDataFieldType = (_item: unknown): boolean => false\nexport const isDataModelAttribute = (_item: unknown): boolean => false\n\n// Utils exports from @zenstackhq/language/utils\nexport const hasAttribute = (_node: unknown, _name?: string): boolean => false\n\nexport default {\n\tformatDocument,\n\tloadDocument,\n\tZModelCodeGenerator,\n\tisDataModel,\n\tisAttribute,\n\thasAttribute,\n}\n"],"mappings":";;;;;;;;;;AAWA,MAAa,kBAAkB,YAAoB;AAEnD,MAAa,gBAAgB,WAAmB;CAC/C,SAAS;CACT,QAAQ,CAAC,sDAAsD;AAChE;AAEA,IAAa,sBAAb,MAAiC;CAChC,SAAS,QAAyB;EACjC,OAAO;CACR;AACD;AAGA,MAAa,eAAe,UAA4B;AACxD,MAAa,eAAe,UAA4B;AACxD,MAAa,yBAAyB,UAA4B;AAClE,MAAa,gBAAgB,UAA4B;AACzD,MAAa,iBAAiB,UAA4B;AAC1D,MAAa,eAAe,UAA4B;AACxD,MAAa,kBAAkB,UAA4B;AAC3D,MAAa,gBAAgB,UAA4B;AACzD,MAAa,oBAAoB,UAA4B;AAC7D,MAAa,qBAAqB,UAA4B;AAC9D,MAAa,iBAAiB,UAA4B;AAC1D,MAAa,eAAe,UAA4B;AACxD,MAAa,wBAAwB,UAA4B;AACjE,MAAa,mBAAmB,UAA4B;AAC5D,MAAa,wBAAwB,UAA4B;AAGjE,MAAa,gBAAgB,OAAgB,UAA4B;AAEzE,IAAA,4BAAe;CACd;CACA;CACA;CACA;CACA;CACA;AACD"}
+{"version":3,"file":"zenstack-language.mjs","names":[],"sources":["../../src/mocks/zenstack-language.ts"],"sourcesContent":["/**\n * Mock for @zenstackhq/language package\n *\n * The @zenstackhq/language package depends on vscode-languageserver which is\n * incompatible with Cloudflare Workers runtime. These exports are only used\n * for schema generation (CLI functionality), not runtime authentication.\n *\n * This mock provides stub implementations to allow tests to run in the Workers Vitest integration.\n */\n\n// Main exports from @zenstackhq/language\nexport const formatDocument = (content: string) => content\n\nexport const loadDocument = (_path: string) => ({\n\tsuccess: false,\n\terrors: ['Mock: loadDocument not available in test environment'],\n})\n\nexport class ZModelCodeGenerator {\n\tgenerate(_model: unknown): string {\n\t\treturn ''\n\t}\n}\n\n// AST exports from @zenstackhq/language/ast\nexport const isDataModel = (_item: unknown): boolean => false\nexport const isAttribute = (_item: unknown): boolean => false\nexport const isAbstractDeclaration = (_item: unknown): boolean => false\nexport const isExpression = (_item: unknown): boolean => false\nexport const isLiteralExpr = (_item: unknown): boolean => false\nexport const isArrayExpr = (_item: unknown): boolean => false\nexport const isAttributeArg = (_item: unknown): boolean => false\nexport const isBinaryExpr = (_item: unknown): boolean => false\nexport const isBooleanLiteral = (_item: unknown): boolean => false\nexport const isConfigArrayExpr = (_item: unknown): boolean => false\nexport const isConfigField = (_item: unknown): boolean => false\nexport const isDataField = (_item: unknown): boolean => false\nexport const isDataFieldAttribute = (_item: unknown): boolean => false\nexport const isDataFieldType = (_item: unknown): boolean => false\nexport const isDataModelAttribute = (_item: unknown): boolean => false\n\n// Utils exports from @zenstackhq/language/utils\nexport const hasAttribute = (_node: unknown, _name?: string): boolean => false\n\nexport default {\n\tformatDocument,\n\tloadDocument,\n\tZModelCodeGenerator,\n\tisDataModel,\n\tisAttribute,\n\thasAttribute,\n}\n"],"mappings":";;;;;;;;;;AAWA,MAAa,kBAAkB,YAAoB;AAEnD,MAAa,gBAAgB,WAAmB;CAC/C,SAAS;CACT,QAAQ,CAAC,sDAAsD;AAChE;AAEA,IAAa,sBAAb,MAAiC;CAChC,SAAS,QAAyB;EACjC,OAAO;CACR;AACD;AAGA,MAAa,eAAe,UAA4B;AACxD,MAAa,eAAe,UAA4B;AACxD,MAAa,yBAAyB,UAA4B;AAClE,MAAa,gBAAgB,UAA4B;AACzD,MAAa,iBAAiB,UAA4B;AAC1D,MAAa,eAAe,UAA4B;AACxD,MAAa,kBAAkB,UAA4B;AAC3D,MAAa,gBAAgB,UAA4B;AACzD,MAAa,oBAAoB,UAA4B;AAC7D,MAAa,qBAAqB,UAA4B;AAC9D,MAAa,iBAAiB,UAA4B;AAC1D,MAAa,eAAe,UAA4B;AACxD,MAAa,wBAAwB,UAA4B;AACjE,MAAa,mBAAmB,UAA4B;AAC5D,MAAa,wBAAwB,UAA4B;AAGjE,MAAa,gBAAgB,OAAgB,UAA4B;AAEzE,IAAA,4BAAe;CACd;CACA;CACA;CACA;CACA;CACA;AACD"}

package/dist/storage/index.d.mts

@@ -1,2 +1,2 @@
-import { n as StoredFile, t as FakeStorageService } from "../index-CrHzUDKX.mjs";
+import { n as StoredFile, t as FakeStorageService } from "../index-D7FM6EKp.mjs";
 export { FakeStorageService, type StoredFile };

package/dist/storage/index.mjs

@@ -1,2 +1,2 @@
-import { t as FakeStorageService } from "../storage-DhoxWqyF.mjs";
+import { t as FakeStorageService } from "../storage-BiGamMA8.mjs";
 export { FakeStorageService };

package/dist/{storage-DhoxWqyF.mjs → storage-BiGamMA8.mjs}

@@ -1,8 +1,8 @@
-import { t as __decorate } from "./decorate-B7nr7eBl.mjs";
+import { t as __decorate } from "./decorate-RQD1h28J.mjs";
 import { FileNotFoundError, STORAGE_TOKENS, StorageService } from "stratal/storage";
 import { Transient, inject } from "stratal/di";
 import { expect } from "vitest";
-//#region \0@oxc-project+runtime@0.133.0/helpers/esm/decorateParam.js
+//#region \0@oxc-project+runtime@0.150.0/helpers/esm/decorateParam.js
 function __decorateParam(paramIndex, decorator) {
 	return function(target, key) {
 		decorator(target, key, paramIndex);
@@ -10,6 +10,23 @@ function __decorateParam(paramIndex, decorator) {
 }
 //#endregion
 //#region src/storage/fake-storage.service.ts
+/**
+* Objects per `list` page when a test does not ask for a size.
+*
+* One, so that any listing of two or more objects truncates and a caller who skips the `cursor`
+* loop fails here rather than against a real bucket.
+*/
+const FAKE_LIST_PAGE_SIZE = 1;
+/** Shared by `head` and `list` so a listed object and a headed one cannot drift apart. */
+function toHeadResult(path, file) {
+	return {
+		path,
+		size: file.size,
+		contentType: file.mimeType,
+		uploadedAt: file.uploadedAt,
+		metadata: file.metadata
+	};
+}
 let FakeStorageService = class FakeStorageService extends StorageService {
 	storageManager;
 	options;
@@ -73,6 +90,56 @@ let FakeStorageService = class FakeStorageService extends StorageService {
 		return Promise.resolve(this.files.has(path));
 	}
 	/**
+	* Delete many files from fake storage
+	*/
+	async deleteMany(paths, disk) {
+		this.resolveDisk(disk);
+		for (const path of paths) this.files.delete(path);
+		return Promise.resolve();
+	}
+	/**
+	* Read a file's metadata from fake storage, without its contents
+	*/
+	async head(path, disk) {
+		this.resolveDisk(disk);
+		const file = this.files.get(path);
+		if (!file) return Promise.resolve(null);
+		return Promise.resolve(toHeadResult(path, file));
+	}
+	/**
+	* List files in fake storage, one page at a time
+	*
+	* Truncates after ONE object unless `limit` says otherwise. Real R2 pages at 1000, but no
+	* fixture stores 1000 files — matching that number would return everything in one page and let
+	* a caller who never follows `cursor` pass every test, then undercount against a real bucket.
+	* Paging at one means any listing of two or more objects exercises the loop.
+	*
+	* Pass `limit` to widen the page when a test is asserting page contents rather than the loop.
+	*/
+	async list(options = {}, disk) {
+		this.resolveDisk(disk);
+		const prefix = options.prefix ?? "";
+		const matching = Array.from(this.files.keys()).filter((path) => path.startsWith(prefix)).sort();
+		const start = options.cursor === void 0 ? 0 : matching.indexOf(options.cursor);
+		if (start < 0) return Promise.reject(/* @__PURE__ */ new Error(`Unknown storage list cursor: ${options.cursor ?? ""}`));
+		const limit = options.limit ?? FAKE_LIST_PAGE_SIZE;
+		const page = matching.slice(start, start + limit);
+		const next = matching[start + limit];
+		return Promise.resolve({
+			objects: page.map((path) => {
+				const object = toHeadResult(path, this.files.get(path));
+				if (options.includeMetadata) return object;
+				return {
+					...object,
+					contentType: void 0,
+					metadata: void 0
+				};
+			}),
+			truncated: next !== void 0,
+			cursor: next
+		});
+	}
+	/**
 	* Generate a fake presigned download URL
 	*/
 	getPresignedDownloadUrl(path, expiresIn) {
@@ -96,7 +163,7 @@ let FakeStorageService = class FakeStorageService extends StorageService {
 	async chunkedUpload(body, path, options, disk) {
 		const content = await this.bodyToUint8Array(body);
 		const size = options.size ?? content.length;
-		return this.upload(body, path, {
+		return this.upload(content, path, {
 			...options,
 			size
 		}, disk);
@@ -170,7 +237,7 @@ let FakeStorageService = class FakeStorageService extends StorageService {
 		};
 	}
 	async bodyToUint8Array(body) {
-		if (!body) return new Uint8Array(0);
+		if (!body) return /* @__PURE__ */ 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);
@@ -180,7 +247,7 @@ let FakeStorageService = class FakeStorageService extends StorageService {
 		}
 		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);
+		return /* @__PURE__ */ new Uint8Array(0);
 	}
 };
 FakeStorageService = __decorate([
@@ -191,4 +258,4 @@ FakeStorageService = __decorate([
 //#endregion
 export { FakeStorageService as t };
 
-//# sourceMappingURL=storage-DhoxWqyF.mjs.map
+//# sourceMappingURL=storage-BiGamMA8.mjs.map

package/dist/storage-BiGamMA8.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-BiGamMA8.mjs","names":[],"sources":["../src/storage/fake-storage.service.ts"],"sourcesContent":["import { Transient, inject } from 'stratal/di'\nimport {\n  FileNotFoundError,\n  STORAGE_TOKENS,\n  type StorageManagerService,\n  StorageService,\n  type StreamingBlobPayloadInputTypes,\n  type DownloadResult,\n  type HeadResult,\n  type ListOptions,\n  type ListResult,\n  type PresignedUrlResult,\n  type StorageConfig,\n  type UploadOptions,\n  type UploadResult,\n} from 'stratal/storage'\nimport { expect } from 'vitest'\n\n/**\n * Objects per `list` page when a test does not ask for a size.\n *\n * One, so that any listing of two or more objects truncates and a caller who skips the `cursor`\n * loop fails here rather than against a real bucket.\n */\nconst FAKE_LIST_PAGE_SIZE = 1\n\n/** Shared by `head` and `list` so a listed object and a headed one cannot drift apart. */\nfunction toHeadResult(path: string, file: StoredFile): HeadResult {\n  return {\n    path,\n    size: file.size,\n    contentType: file.mimeType,\n    uploadedAt: file.uploadedAt,\n    metadata: file.metadata,\n  }\n}\n\n/**\n * Stored file representation in memory\n */\nexport interface StoredFile {\n  content: Uint8Array\n  mimeType: string\n  size: number\n  metadata?: Record<string, string>\n  uploadedAt: Date\n}\n\n/**\n * FakeStorageService\n *\n * In-memory storage implementation for testing.\n * Registered by default in TestingModuleBuilder.\n *\n * Similar to Laravel's Storage::fake() - stores files in memory\n * and provides assertion helpers for testing.\n *\n * @example\n * ```typescript\n * // Access via TestingModule\n * module.storage.assertExists('path/to/file.pdf')\n * module.storage.assertMissing('deleted/file.pdf')\n * module.storage.clear() // Reset between tests\n * ```\n */\n@Transient(STORAGE_TOKENS.StorageService)\nexport class FakeStorageService extends StorageService {\n  private files = new Map<string, StoredFile>()\n\n  constructor(\n    @inject(STORAGE_TOKENS.StorageManager)\n    protected readonly storageManager: StorageManagerService,\n    @inject(STORAGE_TOKENS.Options)\n    protected readonly options: StorageConfig\n  ) {\n    super(storageManager, options)\n  }\n\n  /**\n   * Upload content to fake storage\n   */\n  async upload(\n    body: StreamingBlobPayloadInputTypes,\n    relativePath: string,\n    options: UploadOptions,\n    disk?: string\n  ): Promise<UploadResult> {\n    const content = await this.bodyToUint8Array(body)\n    const diskName = this.resolveDisk(disk)\n\n    this.files.set(relativePath, {\n      content,\n      mimeType: options.mimeType ?? 'application/octet-stream',\n      size: options.size,\n      metadata: options.metadata,\n      uploadedAt: new Date(),\n    })\n\n    return {\n      path: relativePath,\n      disk: diskName,\n      fullPath: relativePath,\n      size: options.size,\n      mimeType: options.mimeType ?? 'application/octet-stream',\n      uploadedAt: new Date(),\n    }\n  }\n\n  /**\n   * Download a file from fake storage\n   */\n  download(path: string): Promise<DownloadResult> {\n    const file = this.files.get(path)\n\n    if (!file) {\n      return Promise.reject(new FileNotFoundError(path))\n    }\n\n    return Promise.resolve({\n      toStream: () => new ReadableStream({\n        start(controller) {\n          controller.enqueue(file.content)\n          controller.close()\n        },\n      }),\n      toString: () => Promise.resolve(new TextDecoder().decode(file.content)),\n      toArrayBuffer: () => Promise.resolve(file.content),\n      contentType: file.mimeType,\n      size: file.size,\n      metadata: file.metadata,\n    })\n  }\n\n  /**\n   * Delete a file from fake storage\n   */\n  delete(path: string): Promise<void> {\n    this.files.delete(path)\n    return Promise.resolve()\n  }\n\n  /**\n   * Check if a file exists in fake storage\n   */\n  exists(path: string): Promise<boolean> {\n    return Promise.resolve(this.files.has(path))\n  }\n\n  /**\n   * Delete many files from fake storage\n   */\n  // `async` so an unconfigured disk arrives as a rejected promise, as it does from the real\n  // service. Thrown synchronously it would slip past a caller that chains `.catch()` without\n  // awaiting — a difference in error surface is still a difference the fake exists to avoid.\n  async deleteMany(paths: string[], disk?: string): Promise<void> {\n    this.resolveDisk(disk)\n\n    for (const path of paths) {\n      this.files.delete(path)\n    }\n\n    return Promise.resolve()\n  }\n\n  /**\n   * Read a file's metadata from fake storage, without its contents\n   */\n  async head(path: string, disk?: string): Promise<HeadResult | null> {\n    this.resolveDisk(disk)\n\n    const file = this.files.get(path)\n    if (!file) {\n      return Promise.resolve(null)\n    }\n\n    return Promise.resolve(toHeadResult(path, file))\n  }\n\n  /**\n   * List files in fake storage, one page at a time\n   *\n   * Truncates after ONE object unless `limit` says otherwise. Real R2 pages at 1000, but no\n   * fixture stores 1000 files — matching that number would return everything in one page and let\n   * a caller who never follows `cursor` pass every test, then undercount against a real bucket.\n   * Paging at one means any listing of two or more objects exercises the loop.\n   *\n   * Pass `limit` to widen the page when a test is asserting page contents rather than the loop.\n   */\n  async list(options: ListOptions = {}, disk?: string): Promise<ListResult> {\n    this.resolveDisk(disk)\n\n    const prefix = options.prefix ?? ''\n    // Sorted so pagination is deterministic — an unordered Map iteration would make `cursor`\n    // meaningless and the page boundaries unrepeatable between runs.\n    const matching = Array.from(this.files.keys())\n      .filter((path) => path.startsWith(prefix))\n      .sort()\n\n    const start = options.cursor === undefined ? 0 : matching.indexOf(options.cursor)\n    if (start < 0) {\n      return Promise.reject(new Error(`Unknown storage list cursor: ${options.cursor ?? ''}`))\n    }\n\n    const limit = options.limit ?? FAKE_LIST_PAGE_SIZE\n    const page = matching.slice(start, start + limit)\n    const next = matching[start + limit]\n\n    return Promise.resolve({\n      objects: page.map((path) => {\n        const object = toHeadResult(path, this.files.get(path)!)\n        if (options.includeMetadata) {\n          return object\n        }\n\n        // Dropped unless asked for, because R2 omits them unless asked for. A fake that always\n        // returned them would let a caller read `contentType` off a listing in tests and find it\n        // undefined against a real bucket.\n        return { ...object, contentType: undefined, metadata: undefined }\n      }),\n      truncated: next !== undefined,\n      cursor: next,\n    })\n  }\n\n  /**\n   * Generate a fake presigned download URL\n   */\n  getPresignedDownloadUrl(\n    path: string,\n    expiresIn?: number\n  ): Promise<PresignedUrlResult> {\n    return Promise.resolve(this.createPresignedUrl(path, 'GET', expiresIn))\n  }\n\n  /**\n   * Generate a fake presigned upload URL\n   */\n  getPresignedUploadUrl(\n    path: string,\n    expiresIn?: number\n  ): Promise<PresignedUrlResult> {\n    return Promise.resolve(this.createPresignedUrl(path, 'PUT', expiresIn))\n  }\n\n  /**\n   * Generate a fake presigned delete URL\n   */\n  getPresignedDeleteUrl(\n    path: string,\n    expiresIn?: number\n  ): Promise<PresignedUrlResult> {\n    return Promise.resolve(this.createPresignedUrl(path, 'DELETE', expiresIn))\n  }\n\n  /**\n   * Chunked upload (same as regular upload for fake)\n   */\n  async chunkedUpload(\n    body: StreamingBlobPayloadInputTypes,\n    path: string,\n    options: Omit<UploadOptions, 'size'> & { size?: number },\n    disk?: string\n  ): Promise<UploadResult> {\n    const content = await this.bodyToUint8Array(body)\n    const size = options.size ?? content.length\n\n    // Reuse the already-materialized bytes rather than `body`: a `ReadableStream`\n    // is single-use, so reading it here and again inside `upload` would throw\n    // \"ReadableStream is disturbed\". `content` is a Uint8Array and safe to re-read.\n    return this.upload(content, path, { ...options, size }, disk)\n  }\n\n  // ─────────────────────────────────────────────────────────────────────────\n  // Test Assertion Helpers\n  // ─────────────────────────────────────────────────────────────────────────\n\n  /**\n   * Assert that a file exists at the given path\n   *\n   * @param path - Path to check\n   * @throws AssertionError if file does not exist\n   */\n  assertExists(path: string): void {\n    expect(\n      this.files.has(path),\n      `Expected file to exist at: ${path}\\nStored files: ${this.getStoredPaths().join(', ') || '(none)'}`\n    ).toBe(true)\n  }\n\n  /**\n   * Assert that a file does NOT exist at the given path\n   *\n   * @param path - Path to check\n   * @throws AssertionError if file exists\n   */\n  assertMissing(path: string): void {\n    expect(\n      this.files.has(path),\n      `Expected file NOT to exist at: ${path}`\n    ).toBe(false)\n  }\n\n  /**\n   * Assert storage is empty\n   *\n   * @throws AssertionError if any files exist\n   */\n  assertEmpty(): void {\n    expect(\n      this.files.size,\n      `Expected storage to be empty but found ${this.files.size} files: ${this.getStoredPaths().join(', ')}`\n    ).toBe(0)\n  }\n\n  /**\n   * Assert storage has exactly N files\n   *\n   * @param count - Expected number of files\n   * @throws AssertionError if count doesn't match\n   */\n  assertCount(count: number): void {\n    expect(\n      this.files.size,\n      `Expected ${count} files in storage but found ${this.files.size}`\n    ).toBe(count)\n  }\n\n  /**\n   * Get all stored files (for inspection)\n   */\n  getStoredFiles(): Map<string, StoredFile> {\n    return new Map(this.files)\n  }\n\n  /**\n   * Get all stored file paths\n   */\n  getStoredPaths(): string[] {\n    return Array.from(this.files.keys())\n  }\n\n  /**\n   * Get a specific file by path\n   */\n  getFile(path: string): StoredFile | undefined {\n    return this.files.get(path)\n  }\n\n  /**\n   * Clear all stored files (call in beforeEach for test isolation)\n   */\n  clear(): void {\n    this.files.clear()\n  }\n\n  // ─────────────────────────────────────────────────────────────────────────\n  // Private Helpers\n  // ─────────────────────────────────────────────────────────────────────────\n\n  private createPresignedUrl(\n    path: string,\n    method: 'GET' | 'PUT' | 'DELETE' | 'HEAD',\n    expiresIn = 300\n  ): PresignedUrlResult {\n    const expiresAt = new Date(Date.now() + expiresIn * 1000)\n\n    return {\n      url: `https://fake-storage.test/${path}?method=${method}&expires=${expiresAt.toISOString()}`,\n      expiresIn,\n      expiresAt,\n      method,\n    }\n  }\n\n  private async bodyToUint8Array(body: StreamingBlobPayloadInputTypes | null | undefined): Promise<Uint8Array> {\n    if (!body) {\n      return new Uint8Array(0)\n    }\n\n    if (body instanceof Uint8Array) {\n      return body\n    }\n\n    if (body instanceof ArrayBuffer) {\n      return new Uint8Array(body)\n    }\n\n    if (typeof body === 'string') {\n      return new TextEncoder().encode(body)\n    }\n\n    if (body instanceof Blob) {\n      const buffer = await body.arrayBuffer()\n      return new Uint8Array(buffer)\n    }\n\n    if (body instanceof ReadableStream) {\n      return new Uint8Array(await new Response(body).arrayBuffer())\n    }\n\n    // FormData or URLSearchParams - convert via Response\n    if (body instanceof FormData || body instanceof URLSearchParams) {\n      return new Uint8Array(await new Response(body).arrayBuffer())\n    }\n\n    return new Uint8Array(0)\n  }\n}\n"],"mappings":"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"}

package/dist/test-worker-exports-dCRARYEc.d.mts

@@ -0,0 +1,144 @@
+import { PurgeSpec, WorkersCache } from "stratal/response-cache";
+import { EmailBatchSendResult, EmailSendResult, IEmailProvider, ResolvedEmailMessage } from "stratal/email";
+//#region src/mocks/test-email-provider.d.ts
+/**
+ * In-memory email provider for tests.
+ *
+ * The sync queue provider runs `EmailConsumer` inline on dispatch, which would
+ * otherwise open a real SMTP connection from the test worker. The testing
+ * module builder installs this provider by default (overridable via
+ * `overrideProvider(EMAIL_TOKENS.EmailProviderFactory)`), recording every
+ * message so tests can assert on what was sent.
+ */
+declare class TestEmailProvider implements IEmailProvider {
+  /** Every message handed to the provider, in send order. */
+  readonly sent: ResolvedEmailMessage[];
+  send(message: ResolvedEmailMessage): Promise<EmailSendResult>;
+  sendBatch(messages: ResolvedEmailMessage[]): Promise<EmailBatchSendResult>;
+}
+//#endregion
+//#region src/mocks/test-workers-cache.d.ts
+/**
+ * In-memory stand-in for Cloudflare Workers Caching's `ctx.cache`.
+ *
+ * Neither Miniflare nor workerd populates `ExecutionContext.cache` locally,
+ * which would otherwise leave every `@Cacheable` route in a test serving
+ * uncached and stamped `private, no-store` — so a spec asserting the headers
+ * the route declares would read the ones an unconfigured runtime produces. The
+ * testing module builder installs this by default so those routes are testable
+ * with zero configuration: `@Cacheable` responses carry real
+ * `Cache-Control`/`Cache-Tag` headers, and `@PurgesCache` purges are recorded
+ * rather than skipped.
+ *
+ * Every spec passed to `purge()` is recorded, in call order, for assertion
+ * via `module.cache.purges`. Purges always succeed — this stub only proves an
+ * app's cache configuration is correct, not Workers Caching's own failure
+ * modes (that's covered inside `stratal` itself, against a mocked
+ * `WorkersCache`). Opt out with `Test.createTestingModule({ cache: false })`
+ * to reproduce a runtime where Workers Caching is genuinely unconfigured —
+ * e.g. to test the `ResponseCacheConfigError` boot guard.
+ */
+declare class TestWorkersCache implements WorkersCache {
+  /** Every spec passed to `purge()`, in call order. */
+  readonly purges: PurgeSpec[];
+  purge(spec: PurgeSpec): Promise<{
+    success: boolean;
+  }>;
+}
+//#endregion
+//#region src/mocks/test-worker-exports.d.ts
+/** One `ctx.exports.<Name>.fetch()` the gateway made, recorded for assertion. */
+interface LoopbackCall {
+  /** The export name the gateway dispatched to — `gateway: { entrypoint }`. */
+  entrypoint: string;
+  method: string;
+  url: string;
+  /** The resolved partitions the gateway placed in `ctx.props`. */
+  props: Record<string, unknown>;
+}
+/** Runs a loopback in cached mode. Installed by the testing module builder. */
+type LoopbackHandler = (request: Request, props: Record<string, unknown>) => Promise<Response>;
+/**
+ * In-memory stand-in for `ctx.exports` — the loopback bindings a Worker has to
+ * its own top-level exports.
+ *
+ * Neither Miniflare nor workerd populates `ExecutionContext.exports` for a
+ * `Test.createTestingModule()` app, so without this every consumer that adopts
+ * `ResponseCacheModule.forRoot({ gateway: { entrypoint } })` would have their
+ * whole suite fail on the first request: the gateway's boot verification
+ * throws `ResponseCacheConfigError` the moment it cannot reach the configured
+ * entrypoint. That is the same usability defect {@link TestWorkersCache} fixes
+ * for `ctx.cache`, and it is fixed the same way — installed by default, opt out
+ * with `Test.createTestingModule({ cache: false })`.
+ *
+ * The stub is not inert. A dispatched request is re-run through the *same*
+ * Hono app with an unmarked execution context carrying the gateway's chosen
+ * `props` — exactly what the real cached entrypoint does — so a partitioned
+ * route is genuinely exercised end to end rather than short-circuited. Every
+ * call is recorded, in order, for assertion via `module.gateway.loopbacks`,
+ * mirroring `module.cache.purges`:
+ *
+ * ```typescript
+ * await module.http.get('/dashboard').withHeaders({ ... }).send()
+ * expect(module.gateway.loopbacks).toEqual([
+ *   { entrypoint: 'Cached', method: 'GET', url: '...', props: { user: 'u-1' } },
+ * ])
+ * ```
+ *
+ * An empty `loopbacks` after a request to a partitioned route is itself the
+ * assertion for the fail-closed cases — an unresolved partition, a non-GET, a
+ * route with no `partitionBy` — all of which must run inline.
+ *
+ * Purges forwarded over RPC (`ctx.exports.<Name>.purge(spec)`) land on the same
+ * {@link TestWorkersCache} as a direct `ctx.cache.purge()`, so
+ * `module.cache.purges` reads identically whether or not a gateway is
+ * configured.
+ */
+declare class TestWorkerExports {
+  private readonly cache;
+  /** Every loopback dispatch, in call order. */
+  readonly loopbacks: LoopbackCall[];
+  private handler;
+  private readonly stubs;
+  constructor(cache: TestWorkersCache | undefined);
+  /**
+   * Install the function that actually serves a loopback.
+   *
+   * Set after the `Application` exists, because the handler needs its Hono
+   * app — while the execution context carrying this stub has to be built
+   * before it, to be passed to the constructor.
+   *
+   * @internal
+   */
+  setHandler(handler: LoopbackHandler): void;
+  /**
+   * The object to install as `ctx.exports`.
+   *
+   * A `Proxy` rather than a fixed record because the export name is the
+   * consumer's to choose — the framework only ever sees the string in
+   * `gateway: { entrypoint }`. Answering for every name keeps a typo'd
+   * entrypoint from being caught here, in a stub, instead of in the
+   * consumer's real Wrangler config where it matters; that trade is
+   * deliberate, since a suite failing on a name the test never mentions is
+   * far more confusing than a deploy-time error.
+   *
+   * A typo is meant to be caught earlier still: `gateway.entrypoint` is typed
+   * as `CachedEntrypointName`, so once the consumer has run `wrangler types` a
+   * wrong name is a compile error at the config site — before this stub, and
+   * before deploy. This Proxy is the runtime fallback for projects without
+   * generated types, not the primary guard.
+   */
+  get context(): Record<string, unknown>;
+  /**
+   * A loopback binding, shaped like the real one:
+   * `Fetcher<T> & ((opts: { props }) => Fetcher<T>)`. Both the callable form
+   * (which is how `ctx.props` is chosen) and the direct form are supported,
+   * so whichever the framework uses is genuinely exercised.
+   */
+  private stubFor;
+  private dispatch;
+  private purge;
+}
+//#endregion
+export { TestEmailProvider as i, TestWorkerExports as n, TestWorkersCache as r, LoopbackCall as t };
+//# sourceMappingURL=test-worker-exports-dCRARYEc.d.mts.map

package/dist/test-worker-exports-dCRARYEc.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-worker-exports-dCRARYEc.d.mts","names":[],"sources":["../src/mocks/test-email-provider.ts","../src/mocks/test-workers-cache.ts","../src/mocks/test-worker-exports.ts"],"mappings":";;;;;;;;;;;;cAgBa,6BAA6B;;WAEhC,MAAM;EAEf,KAAK,SAAS,uBAAuB,QAAQ;EAKvC,UAAU,UAAU,yBAAyB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;cCH/C,4BAA4B;;WAE9B,QAAQ;EAEjB,MAAM,MAAM,YAAY;IAAU;;;;;;UCtBnB;;EAEf;EACA;EACA;;EAEA,OAAO;;;KAIG,mBACV,SAAS,SACT,OAAO,4BACJ,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsCA;mBAOkB;;WALpB,WAAW;UAEZ;mBACS;EAEjB,YAA6B,OAAO;;;;;;;;;;EAWpC,WAAW,SAAS;;;;;;;;;;;;;;;;;;MAqBhB,WAAW;;;;;;;UAmBP;UAkBM;UAiBA"}

package/dist/test-workers-cache-D02Pt_dE.mjs

@@ -0,0 +1,183 @@
+//#region src/mocks/test-email-provider.ts
+/**
+* In-memory email provider for tests.
+*
+* The sync queue provider runs `EmailConsumer` inline on dispatch, which would
+* otherwise open a real SMTP connection from the test worker. The testing
+* module builder installs this provider by default (overridable via
+* `overrideProvider(EMAIL_TOKENS.EmailProviderFactory)`), recording every
+* message so tests can assert on what was sent.
+*/
+var TestEmailProvider = class {
+	/** Every message handed to the provider, in send order. */
+	sent = [];
+	send(message) {
+		this.sent.push(message);
+		return Promise.resolve({
+			messageId: `test-${this.sent.length}`,
+			accepted: true
+		});
+	}
+	async sendBatch(messages) {
+		const results = await Promise.all(messages.map((message) => this.send(message)));
+		return {
+			total: results.length,
+			successful: results.length,
+			failed: 0,
+			results
+		};
+	}
+};
+//#endregion
+//#region src/mocks/test-worker-exports.ts
+/**
+* In-memory stand-in for `ctx.exports` — the loopback bindings a Worker has to
+* its own top-level exports.
+*
+* Neither Miniflare nor workerd populates `ExecutionContext.exports` for a
+* `Test.createTestingModule()` app, so without this every consumer that adopts
+* `ResponseCacheModule.forRoot({ gateway: { entrypoint } })` would have their
+* whole suite fail on the first request: the gateway's boot verification
+* throws `ResponseCacheConfigError` the moment it cannot reach the configured
+* entrypoint. That is the same usability defect {@link TestWorkersCache} fixes
+* for `ctx.cache`, and it is fixed the same way — installed by default, opt out
+* with `Test.createTestingModule({ cache: false })`.
+*
+* The stub is not inert. A dispatched request is re-run through the *same*
+* Hono app with an unmarked execution context carrying the gateway's chosen
+* `props` — exactly what the real cached entrypoint does — so a partitioned
+* route is genuinely exercised end to end rather than short-circuited. Every
+* call is recorded, in order, for assertion via `module.gateway.loopbacks`,
+* mirroring `module.cache.purges`:
+*
+* ```typescript
+* await module.http.get('/dashboard').withHeaders({ ... }).send()
+* expect(module.gateway.loopbacks).toEqual([
+*   { entrypoint: 'Cached', method: 'GET', url: '...', props: { user: 'u-1' } },
+* ])
+* ```
+*
+* An empty `loopbacks` after a request to a partitioned route is itself the
+* assertion for the fail-closed cases — an unresolved partition, a non-GET, a
+* route with no `partitionBy` — all of which must run inline.
+*
+* Purges forwarded over RPC (`ctx.exports.<Name>.purge(spec)`) land on the same
+* {@link TestWorkersCache} as a direct `ctx.cache.purge()`, so
+* `module.cache.purges` reads identically whether or not a gateway is
+* configured.
+*/
+var TestWorkerExports = class {
+	cache;
+	/** Every loopback dispatch, in call order. */
+	loopbacks = [];
+	handler;
+	stubs = /* @__PURE__ */ new Map();
+	constructor(cache) {
+		this.cache = cache;
+	}
+	/**
+	* Install the function that actually serves a loopback.
+	*
+	* Set after the `Application` exists, because the handler needs its Hono
+	* app — while the execution context carrying this stub has to be built
+	* before it, to be passed to the constructor.
+	*
+	* @internal
+	*/
+	setHandler(handler) {
+		this.handler = handler;
+	}
+	/**
+	* The object to install as `ctx.exports`.
+	*
+	* A `Proxy` rather than a fixed record because the export name is the
+	* consumer's to choose — the framework only ever sees the string in
+	* `gateway: { entrypoint }`. Answering for every name keeps a typo'd
+	* entrypoint from being caught here, in a stub, instead of in the
+	* consumer's real Wrangler config where it matters; that trade is
+	* deliberate, since a suite failing on a name the test never mentions is
+	* far more confusing than a deploy-time error.
+	*
+	* A typo is meant to be caught earlier still: `gateway.entrypoint` is typed
+	* as `CachedEntrypointName`, so once the consumer has run `wrangler types` a
+	* wrong name is a compile error at the config site — before this stub, and
+	* before deploy. This Proxy is the runtime fallback for projects without
+	* generated types, not the primary guard.
+	*/
+	get context() {
+		return new Proxy({}, {
+			get: (_target, property) => typeof property === "string" ? this.stubFor(property) : void 0,
+			has: () => true,
+			ownKeys: () => [...this.stubs.keys()],
+			getOwnPropertyDescriptor: () => ({
+				enumerable: true,
+				configurable: true
+			})
+		});
+	}
+	/**
+	* A loopback binding, shaped like the real one:
+	* `Fetcher<T> & ((opts: { props }) => Fetcher<T>)`. Both the callable form
+	* (which is how `ctx.props` is chosen) and the direct form are supported,
+	* so whichever the framework uses is genuinely exercised.
+	*/
+	stubFor(entrypoint) {
+		const existing = this.stubs.get(entrypoint);
+		if (existing) return existing;
+		const bound = (props) => ({
+			fetch: (request) => this.dispatch(entrypoint, request, props),
+			purge: (spec) => this.purge(spec)
+		});
+		const stub = Object.assign((options) => bound(options?.props ?? {}), bound({}));
+		this.stubs.set(entrypoint, stub);
+		return stub;
+	}
+	async dispatch(entrypoint, request, props) {
+		this.loopbacks.push({
+			entrypoint,
+			method: request.method,
+			url: request.url,
+			props
+		});
+		if (!this.handler) throw new Error("[stratal:testing] A gateway loopback was dispatched before the testing module finished compiling. This is a bug in @stratal/testing — please report it.");
+		return this.handler(request, props);
+	}
+	async purge(spec) {
+		await this.cache?.purge(spec);
+		return { success: true };
+	}
+};
+//#endregion
+//#region src/mocks/test-workers-cache.ts
+/**
+* In-memory stand-in for Cloudflare Workers Caching's `ctx.cache`.
+*
+* Neither Miniflare nor workerd populates `ExecutionContext.cache` locally,
+* which would otherwise leave every `@Cacheable` route in a test serving
+* uncached and stamped `private, no-store` — so a spec asserting the headers
+* the route declares would read the ones an unconfigured runtime produces. The
+* testing module builder installs this by default so those routes are testable
+* with zero configuration: `@Cacheable` responses carry real
+* `Cache-Control`/`Cache-Tag` headers, and `@PurgesCache` purges are recorded
+* rather than skipped.
+*
+* Every spec passed to `purge()` is recorded, in call order, for assertion
+* via `module.cache.purges`. Purges always succeed — this stub only proves an
+* app's cache configuration is correct, not Workers Caching's own failure
+* modes (that's covered inside `stratal` itself, against a mocked
+* `WorkersCache`). Opt out with `Test.createTestingModule({ cache: false })`
+* to reproduce a runtime where Workers Caching is genuinely unconfigured —
+* e.g. to test the `ResponseCacheConfigError` boot guard.
+*/
+var TestWorkersCache = class {
+	/** Every spec passed to `purge()`, in call order. */
+	purges = [];
+	purge(spec) {
+		this.purges.push(spec);
+		return Promise.resolve({ success: true });
+	}
+};
+//#endregion
+export { TestWorkerExports as n, TestEmailProvider as r, TestWorkersCache as t };
+
+//# sourceMappingURL=test-workers-cache-D02Pt_dE.mjs.map