stratal 0.0.26 → 0.1.0

package/dist/storage-provider.interface-CinHpjl1.d.mts

@@ -0,0 +1,315 @@
+import { infer as __Infer } from "zod/mini";
+//#region src/storage/types.d.ts
+/**
+ * Storage entry configuration
+ * Represents a single storage disk backed by Cloudflare R2
+ */
+interface StorageEntry {
+  disk: string;
+  /** R2Bucket binding name from wrangler.toml */
+  binding: string;
+  root: string;
+}
+/**
+ * Presigned URL configuration
+ */
+interface PresignedUrlConfig {
+  defaultExpiry: number;
+  maxExpiry: number;
+}
+/**
+ * Storage route configuration
+ */
+interface StorageRouteConfig {
+  /** Base path for storage routes. Default: '/storage' */
+  basePath?: string;
+  /** Disable auto-registered storage routes. Default: false */
+  disabled?: boolean;
+}
+/**
+ * Storage configuration used by framework
+ */
+interface StorageConfig {
+  storage: StorageEntry[];
+  defaultStorageDisk: string;
+  presignedUrl: PresignedUrlConfig;
+  /** Config for auto-registered storage routes (presigned URL proxying) */
+  route?: StorageRouteConfig;
+}
+//#endregion
+//#region src/storage/contracts/delete-file.input.d.ts
+declare const deleteFileInputSchema: import("zod/mini").ZodMiniObject<{
+  path: import("zod/mini").ZodMiniString<string>;
+  disk: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
+}, import("zod/v4/core").$strip>;
+type DeleteFileInput = __Infer<typeof deleteFileInputSchema>;
+//#endregion
+//#region src/storage/contracts/download-result.d.ts
+/**
+ * Download Result
+ *
+ * Result of downloading a file from storage.
+ * Includes the file stream and metadata.
+ */
+interface DownloadResult {
+  /**
+   * ReadableStream of file contents
+   */
+  toStream(): undefined | ReadableStream<Uint8Array>;
+  toString(): undefined | Promise<string>;
+  toArrayBuffer(): undefined | Promise<Uint8Array>;
+  /**
+   * MIME type of the file (e.g., 'application/pdf', 'image/png')
+   */
+  contentType: string;
+  /**
+   * Size of the file in bytes
+   */
+  size: number;
+  /**
+   * Custom object metadata (S3-specific)
+   * Key-value pairs stored with the object
+   */
+  metadata?: Record<string, string>;
+}
+//#endregion
+//#region src/storage/contracts/file-exists.input.d.ts
+declare const fileExistsInputSchema: import("zod/mini").ZodMiniObject<{
+  path: import("zod/mini").ZodMiniString<string>;
+  disk: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
+}, import("zod/v4/core").$strip>;
+type FileExistsInput = __Infer<typeof fileExistsInputSchema>;
+//#endregion
+//#region src/storage/contracts/get-presigned-url.input.d.ts
+declare const getPresignedUrlInputSchema: import("zod/mini").ZodMiniObject<{
+  path: import("zod/mini").ZodMiniString<string>;
+  method: import("zod/mini").ZodMiniDefault<import("zod/mini").ZodMiniEnum<{
+    DELETE: "DELETE";
+    GET: "GET";
+    HEAD: "HEAD";
+    PUT: "PUT";
+  }>>;
+  expiresIn: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNumber<number>>;
+  disk: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
+}, import("zod/v4/core").$strip>;
+type GetPresignedUrlInput = __Infer<typeof getPresignedUrlInputSchema>;
+declare const presignedUrlResultSchema: import("zod/mini").ZodMiniObject<{
+  url: import("zod/mini").ZodMiniURL;
+  expiresIn: import("zod/mini").ZodMiniNumber<number>;
+  expiresAt: import("zod/mini").ZodMiniDate<Date>;
+  method: import("zod/mini").ZodMiniEnum<{
+    DELETE: "DELETE";
+    GET: "GET";
+    HEAD: "HEAD";
+    PUT: "PUT";
+  }>;
+}, import("zod/v4/core").$strip>;
+type PresignedUrlResult = __Infer<typeof presignedUrlResultSchema>;
+//#endregion
+//#region src/storage/contracts/head-result.d.ts
+/**
+ * Head Result
+ *
+ * Metadata for a stored object, read without transferring its body.
+ *
+ * The point of `head` over `download` is that the body never moves: asking "how big is this"
+ * for a hundred objects costs a hundred metadata reads rather than a hundred file transfers.
+ */
+interface HeadResult {
+  /**
+   * Path of the object, relative to the disk root — the same form `download`/`delete` accept,
+   * so a result can be fed straight back in without the caller reassembling anything.
+   */
+  path: string;
+  /**
+   * Size of the object in bytes.
+   */
+  size: number;
+  /**
+   * MIME type recorded at upload, when the provider stored one.
+   */
+  contentType?: string;
+  /**
+   * Provider-assigned entity tag, for change detection.
+   */
+  etag?: string;
+  /**
+   * When the object was last written, when the provider reports it.
+   */
+  uploadedAt?: Date;
+  /**
+   * Custom key-value metadata stored alongside the object.
+   */
+  metadata?: Record<string, string>;
+}
+//#endregion
+//#region src/storage/contracts/list-result.d.ts
+/**
+ * Options for listing stored objects.
+ */
+interface ListOptions {
+  /**
+   * Restrict the listing to objects whose path starts with this prefix, relative to the disk
+   * root. Omit to list the whole disk.
+   */
+  prefix?: string;
+  /**
+   * Continue a previous listing. Pass the `cursor` from a truncated `ListResult`.
+   */
+  cursor?: string;
+  /**
+   * Maximum objects to return in this page. Providers impose their own ceiling — R2 caps a
+   * single list at 1000 — so a larger value does not remove the need to follow `cursor`.
+   */
+  limit?: number;
+  /**
+   * Populate `contentType` and `metadata` on each listed object.
+   *
+   * Off by default because it costs page size: R2 returns fewer objects per call when metadata
+   * comes with them, so a listing that only needs paths and sizes pays extra round trips for
+   * fields it never reads. Turn it on when the listing itself has to inspect content types or
+   * custom metadata; leave it off and `head()` the few objects that matter otherwise.
+   */
+  includeMetadata?: boolean;
+}
+/**
+ * One page of a listing.
+ *
+ * **Listing is paginated, and this type makes that impossible to ignore.** A provider returns at
+ * most a page at a time (1000 objects on R2), so code that sums sizes, counts objects, or copies
+ * a prefix MUST loop while `truncated` is true, feeding `cursor` back in. Treating the first page
+ * as the whole set produces an answer that is quietly too small — and looks entirely reasonable,
+ * because nothing failed.
+ */
+interface ListResult {
+  /**
+   * The objects in this page.
+   *
+   * `path`, `size`, `etag` and `uploadedAt` are always populated. `contentType` and `metadata`
+   * are undefined unless the listing asked for them with `includeMetadata`.
+   */
+  objects: HeadResult[];
+  /**
+   * True when more objects match than this page contains. When true, `cursor` is set.
+   */
+  truncated: boolean;
+  /**
+   * Pass to the next `list` call to continue. Undefined when `truncated` is false.
+   */
+  cursor?: string;
+}
+//#endregion
+//#region src/storage/contracts/upload-file.input.d.ts
+/**
+ * Upload options for streaming uploads
+ */
+interface UploadOptions {
+  /**
+   * Size of the content in bytes
+   */
+  size: number;
+  /**
+   * MIME type of the content
+   */
+  mimeType?: string;
+  /**
+   * Custom metadata to store with the object (S3-specific)
+   * Stored as S3 object metadata headers
+   */
+  metadata?: Record<string, string>;
+  /**
+   * Object tagging for lifecycle policies (S3-specific)
+   * Format: key=value (e.g., "Tus-Completed=true")
+   */
+  tagging?: string;
+}
+declare const uploadResultSchema: import("zod/mini").ZodMiniObject<{
+  path: import("zod/mini").ZodMiniString<string>;
+  disk: import("zod/mini").ZodMiniString<string>;
+  fullPath: import("zod/mini").ZodMiniString<string>;
+  size: import("zod/mini").ZodMiniNumber<number>;
+  mimeType: import("zod/mini").ZodMiniString<string>;
+  uploadedAt: import("zod/mini").ZodMiniDate<Date>;
+}, import("zod/v4/core").$strip>;
+type UploadResult = __Infer<typeof uploadResultSchema>;
+//#endregion
+//#region src/storage/providers/storage-provider.interface.d.ts
+/**
+ * Streaming blob payload input types
+ * Represents the types that can be used as the body of an upload operation
+ */
+type StreamingBlobPayloadInputTypes = ReadableStream | ArrayBuffer | ArrayBufferView | string | Blob | null;
+/**
+ * Storage provider interface
+ * Defines the contract for storage implementations (R2, S3, GCS, etc.)
+ */
+interface IStorageProvider {
+  /**
+   * Upload content to storage
+   * @param body - Content to upload (stream, buffer, or string)
+   * @param path - Full path including disk root
+   * @param options - Upload options including size and mime type
+   * @returns Upload result with metadata
+   */
+  upload(body: StreamingBlobPayloadInputTypes, path: string, options: UploadOptions): Promise<UploadResult>;
+  /**
+   * Download a file from storage
+   * @param path - Full path to the file
+   * @returns Download result with stream and metadata
+   */
+  download(path: string): Promise<DownloadResult>;
+  /**
+   * Delete a file from storage
+   * @param path - Full path to the file
+   */
+  delete(path: string): Promise<void>;
+  /**
+   * Delete many files in as few round trips as the provider allows
+   * @param paths - Full paths to delete
+   */
+  deleteMany(paths: string[]): Promise<void>;
+  /**
+   * Check if a file exists in storage
+   * @param path - Full path to the file
+   * @returns True if file exists, false otherwise
+   */
+  exists(path: string): Promise<boolean>;
+  /**
+   * Read an object's metadata without transferring its body
+   * @param path - Full path to the file
+   * @returns Metadata, or null when no object exists at that path
+   */
+  head(path: string): Promise<HeadResult | null>;
+  /**
+   * List objects, one page at a time
+   *
+   * Paginated by the provider. A caller that aggregates across a prefix must follow
+   * `truncated`/`cursor` — see `ListResult`.
+   *
+   * @param options - Prefix, cursor and page limit, with paths full rather than disk-relative
+   * @returns One page of matching objects
+   */
+  list(options: ListOptions): Promise<ListResult>;
+  /**
+   * Generate a presigned URL for temporary access
+   * @param path - Full path to the file
+   * @param method - HTTP method (GET, PUT, DELETE, HEAD)
+   * @param expiresIn - Expiry time in seconds (1-604800)
+   * @returns Presigned URL result
+   */
+  getPresignedUrl(path: string, method: 'GET' | 'PUT' | 'DELETE' | 'HEAD', expiresIn: number): Promise<PresignedUrlResult>;
+  /**
+   * Chunked upload for streaming data without known size
+   * Uses multipart upload under the hood for reliability
+   * @param body - Content to upload (stream or buffer)
+   * @param path - Full path including disk root
+   * @param options - Upload options (mimeType required, size optional)
+   * @returns Upload result with metadata
+   */
+  chunkedUpload(body: StreamingBlobPayloadInputTypes, path: string, options: Omit<UploadOptions, 'size'> & {
+    size?: number;
+  }): Promise<UploadResult>;
+}
+//#endregion
+export { deleteFileInputSchema as _, uploadResultSchema as a, StorageEntry as b, HeadResult as c, getPresignedUrlInputSchema as d, presignedUrlResultSchema as f, DeleteFileInput as g, DownloadResult as h, UploadResult as i, GetPresignedUrlInput as l, fileExistsInputSchema as m, StreamingBlobPayloadInputTypes as n, ListOptions as o, FileExistsInput as p, UploadOptions as r, ListResult as s, IStorageProvider as t, PresignedUrlResult as u, PresignedUrlConfig as v, StorageRouteConfig as x, StorageConfig as y };
+//# sourceMappingURL=storage-provider.interface-CinHpjl1.d.mts.map

package/dist/storage-provider.interface-CinHpjl1.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-provider.interface-CinHpjl1.d.mts","names":[],"sources":["../src/storage/types.ts","../src/storage/contracts/delete-file.input.ts","../src/storage/contracts/download-result.ts","../src/storage/contracts/file-exists.input.ts","../src/storage/contracts/get-presigned-url.input.ts","../src/storage/contracts/head-result.ts","../src/storage/contracts/list-result.ts","../src/storage/contracts/upload-file.input.ts","../src/storage/providers/storage-provider.interface.ts"],"mappings":";;;;;;UAIiB;EAChB;;EAEA;EACA;;;;;UAMgB;EAChB;EACA;;;;;UAMgB;;EAEhB;;EAEA;;;;;UAMgB;EAChB,SAAS;EACT;EACA,cAAc;;EAEd,QAAQ;;;;cCjCI,0CAAqB;;;yBAGhC;KAEU,kBAAkB,eAAa;;;;;;;;;UCH1B;;;;EAIf,wBAAwB,eAAe;EAEvC,wBAAwB;EAExB,6BAA6B,QAAQ;;;;EAKrC;;;;EAKA;;;;;EAMA,WAAW;;;;cC1BA,0CAAqB;;;yBAGhC;KAEU,kBAAkB,eAAa;;;cCH9B,+CAA0B;;;;;;;;;;yBAKrC;KAEU,uBAAuB,eAAa;cAEnC,6CAAwB;;;4CAAxB;;;;;;;yBAKX;KAEU,qBAAqB,eAAa;;;;;;;;;;;UCd7B;;;;;EAKf;;;;EAKA;;;;EAKA;;;;EAKA;;;;EAKA,aAAa;;;;EAKb,WAAW;;;;;;;UCjCI;;;;;EAKf;;;;EAKA;;;;;EAMA;;;;;;;;;EAUA;;;;;;;;;;;UAYe;;;;;;;EAOf,SAAS;;;;EAKT;;;;EAKA;;;;;;;UCtDe;;;;EAIf;;;;EAIA;;;;;EAKA,WAAW;;;;;EAKX;;cAGW,uCAAkB;;;;;;6CAAlB;yBAOX;KAEU,eAAe,eAAa;;;;;;;KCtB5B,iCACR,iBACA,cACA,2BAEA;;;;;UAOa;;;;;;;;EAQf,OAAO,MAAM,gCAAgC,cAAc,SAAS,gBAAgB,QAAQ;;;;;;EAO5F,SAAS,eAAe,QAAQ;;;;;EAMhC,OAAO,eAAe;;;;;EAMtB,WAAW,kBAAkB;;;;;;EAO7B,OAAO,eAAe;;;;;;EAOtB,KAAK,eAAe,QAAQ;;;;;;;;;;EAW5B,KAAK,SAAS,cAAc,QAAQ;;;;;;;;EASpC,gBACE,cACA,2CACA,oBACC,QAAQ;;;;;;;;;EAUX,cACE,MAAM,gCACN,cACA,SAAS,KAAK;IAA2B;MACxC,QAAQ"}

package/dist/storage.error-Ao38Qdjx.mjs

@@ -0,0 +1,7 @@
+import { a as ApplicationError } from "./container-storage-DfF7SXdV.mjs";
+//#region src/storage/storage.error.ts
+var StorageError = class extends ApplicationError {};
+//#endregion
+export { StorageError as t };
+
+//# sourceMappingURL=storage.error-Ao38Qdjx.mjs.map

package/dist/storage.error-Ao38Qdjx.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.error-Ao38Qdjx.mjs","names":[],"sources":["../src/storage/storage.error.ts"],"sourcesContent":["import { ApplicationError } from '../errors'\n\nexport class StorageError extends ApplicationError {}\n"],"mappings":";;AAEA,IAAa,eAAb,cAAkC,iBAAiB,CAAC"}

package/dist/{stratal-D5j_I14G.d.mts → stratal-Bs1_E8GQ.d.mts}

@@ -1,6 +1,5 @@
-import { Sn as HonoApp, ft as Application, pt as ApplicationConfig } from "./index-uybm0bhQ.mjs";
+import { ft as Application, pt as ApplicationConfig, zn as HonoApp } from "./index-B2WtEagR.mjs";
 import { t as StratalEnv } from "./env-ug22bJj7.mjs";
-
 //#region src/stratal.d.ts
 /**
  * Stratal — Hono-style entry point for Cloudflare Workers.
@@ -30,6 +29,17 @@ declare class Stratal<Env extends StratalEnv = StratalEnv> {
    */
   private static _teardownChain;
   constructor(config: ApplicationConfig);
+  /**
+   * The eyeball entrypoint — and, when `stratal/response-cache`'s gateway is
+   * configured, the **gateway**.
+   *
+   * The execution context is marked before it reaches Hono so the dispatch
+   * middleware can tell which of the two entrypoints it is running inside.
+   * `cachedEntrypoint` deliberately does not mark, which is what stops the
+   * cached entrypoint from dispatching back into itself. The mark lives in a
+   * module-private `WeakSet` keyed on this object, so nothing a client sends
+   * can set or clear it. It is a no-op for apps that configure no gateway.
+   */
   fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response>;
   queue(batch: MessageBatch): Promise<void>;
   scheduled(controller: ScheduledController): Promise<void>;
@@ -50,4 +60,4 @@ declare class Stratal<Env extends StratalEnv = StratalEnv> {
 }
 //#endregion
 export { Stratal as t };
-//# sourceMappingURL=stratal-D5j_I14G.d.mts.map
+//# sourceMappingURL=stratal-Bs1_E8GQ.d.mts.map

package/dist/stratal-Bs1_E8GQ.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stratal-Bs1_E8GQ.d.mts","names":[],"sources":["../src/stratal.ts"],"mappings":";;;;;;;;;;;;;;;;;cAoBa,QAAQ,YAAY,aAAa;UACpC;UACA;iBAEO;iBACA;iBACA;;;;;;;iBAOA;EAEf,YAAY,QAAQ;;;;;;;;;;;;EAgDd,MAAM,SAAS,SAAS,KAAK,KAAK,KAAK,mBAAmB,QAAQ;EAMlE,MAAM,OAAO,eAAe;EAK5B,UAAU,YAAY,sBAAsB;MAK9C,QAAQ,QAAQ;EAId,YAAY;;;;;;;;;;SAwBL,sBAAsB,QAAQ;UAkB7B;UAeA"}

package/dist/{stratal-BL6FKUM_.mjs → stratal-CiwNpWy2.mjs}

@@ -1,11 +1,12 @@
-import { b as ROUTER_TOKENS, r as DI_TOKENS, t as Container } from "./di-D7qmrAir.mjs";
-import { n as getContainer, r as runWithContainer, t as containerStorage } from "./container-storage-BmOJ4_Na.mjs";
+import { C as ROUTER_TOKENS, r as DI_TOKENS, t as Container } from "./di-DQ3xbjgf.mjs";
+import { n as getContainer, r as runWithContainer, t as containerStorage } from "./container-storage-DfF7SXdV.mjs";
 import { JsonFormatter, LOGGER_TOKENS, LoggerService, PrettyFormatter } from "./logger/index.mjs";
-import { i as StratalNotInitializedError, o as DefaultExceptionHandler, r as StratalSupersededError } from "./errors-C01O2T-n.mjs";
-import { i as createQueueExceptionContext, n as createCronExceptionContext, t as createCliExceptionContext } from "./exception-context-D-kvney-.mjs";
-import { a as getListenerHandlers } from "./events-BhEQuT1X.mjs";
-import { d as LazyModuleLoader, t as ModuleRegistry } from "./module-registry-NxX5O0Qk.mjs";
-import { t as SEEDER_TOKENS } from "./seeder-registry-DEvCycsT.mjs";
+import { i as StratalNotInitializedError, o as DefaultExceptionHandler, r as StratalSupersededError } from "./errors-CrOXI_y5.mjs";
+import { i as createQueueExceptionContext, n as createCronExceptionContext, t as createCliExceptionContext } from "./exception-context-CdnGTQNF.mjs";
+import { a as getListenerHandlers } from "./events-GtwGEHyT.mjs";
+import { d as LazyModuleLoader, t as ModuleRegistry } from "./module-registry-lkQPDuQe.mjs";
+import { t as SEEDER_TOKENS } from "./seeder-registry-Bo5BgLbC.mjs";
+import { n as markGatewayMode } from "./gateway-mode-0rUaeW3g.mjs";
 //#region src/application.ts
 var Application = class {
 	_container;
@@ -39,10 +40,24 @@ var Application = class {
 	get container() {
 		return this._container;
 	}
+	/** The application's logger (the singleton {@link LoggerService}). */
+	get logger() {
+		return this._container.resolve(LOGGER_TOKENS.LoggerService);
+	}
 	async ensureHono() {
 		await this.initializeRouting();
 		return this.honoApp;
 	}
+	/**
+	* Whether the app registers any HTTP controllers. Cheap (reads the already-
+	* populated registry; no routing built) and only meaningful after
+	* {@link initialize}. The worker entry uses it to decide whether to pre-warm
+	* the routing stack at boot — queue/scheduled-only apps return false and never
+	* build routes they won't serve.
+	*/
+	hasHttpRoutes() {
+		return this.moduleRegistry.getAllControllers().length > 0;
+	}
 	get config() {
 		return this.appConfig;
 	}
@@ -58,7 +73,7 @@ var Application = class {
 		}
 	}
 	async initializeInternal() {
-		const [{ QuarryModule }, { SeederModule }] = await Promise.all([import("./quarry.module-CcGxU2dJ.mjs").then((n) => n.n), import("./seeder.module-CIwQbdN4.mjs").then((n) => n.n)]);
+		const [{ QuarryModule }, { SeederModule }] = await Promise.all([import("./quarry.module-BssRR8f0.mjs").then((n) => n.n), import("./seeder.module-DOoVgTsK.mjs").then((n) => n.n)]);
 		this.moduleRegistry.registerAll([QuarryModule, SeederModule]);
 		this.moduleRegistry.register(this.appConfig.module);
 		await this.moduleRegistry.initialize();
@@ -70,16 +85,18 @@ var Application = class {
 		this.initialized = true;
 	}
 	async registerRoutingServices() {
-		const [{ HonoApp }, { RouteRegistry }, { RouterResolver }, { VersioningService }, { LocalePathService }, { LocaleUrlService }, { RouteRegistrationService }, { Uri }] = await Promise.all([
-			import("./hono-app-COAgmutc.mjs").then((n) => n.n),
-			import("./route-registry-BvLJisvK.mjs").then((n) => n.n),
-			import("./router-resolver-sUV_jTrU.mjs"),
-			import("./versioning.service-CCa2oYMJ.mjs").then((n) => n.n),
-			import("./locale-path.service-CH0CaxwH.mjs").then((n) => n.n),
-			import("./locale-url.service-6bgia24_.mjs").then((n) => n.n),
-			import("./route-registration.service-CDPQKpm4.mjs").then((n) => n.n),
-			import("./uri-iwofWJ_T.mjs").then((n) => n.r)
+		const [{ HonoApp }, { RouteRegistry }, { RouterResolver }, { VersioningService }, { LocalePathService }, { LocaleUrlService }, { RouteRegistrationService }, { Uri }, { RouteMetadataRegistry }] = await Promise.all([
+			import("./hono-app-IhdqL0Fk.mjs").then((n) => n.n),
+			import("./route-registry-DFz9_-N6.mjs").then((n) => n.n),
+			import("./router-resolver-B-dMSMIG.mjs"),
+			import("./versioning.service-DnF_4Lnd.mjs").then((n) => n.n),
+			import("./locale-path.service-BqzDIrgy.mjs").then((n) => n.n),
+			import("./locale-url.service-H8PH6GGh.mjs").then((n) => n.n),
+			import("./route-registration.service-COKBZTsn.mjs").then((n) => n.n),
+			import("./uri-BrOq148R.mjs").then((n) => n.r),
+			import("./route-metadata-QQhbed1i.mjs")
 		]);
+		this._container.register(ROUTER_TOKENS.RouteMetadataRegistry, RouteMetadataRegistry);
 		this._container.register(ROUTER_TOKENS.VersioningService, VersioningService);
 		this._container.register(ROUTER_TOKENS.HonoApp, HonoApp);
 		this._container.register(ROUTER_TOKENS.LocalePathService, LocalePathService);
@@ -99,7 +116,7 @@ var Application = class {
 	*/
 	initializeEventListeners() {
 		this.eventsInitPromise ??= runWithContainer(this._container, async () => {
-			const { EventsModule } = await import("./events-BhEQuT1X.mjs").then((n) => n.n);
+			const { EventsModule } = await import("./events-GtwGEHyT.mjs").then((n) => n.n);
 			await this.moduleRegistry.registerLazy(EventsModule);
 			this.registerEventListeners();
 		});
@@ -129,7 +146,7 @@ var Application = class {
 	initializeQueue() {
 		this.queueInitPromise ??= runWithContainer(this._container, async () => {
 			await this.ensureI18n();
-			const { QueueModule } = await import("./queue.module-CEs4_kEM.mjs").then((n) => n.n);
+			const { QueueModule } = await import("./queue.module-DnAdSbR-.mjs").then((n) => n.n);
 			this.moduleRegistry.register(QueueModule);
 			this.consumerRegistry = this._container.resolve(DI_TOKENS.ConsumerRegistry);
 			await this.registerQueueConsumers();
@@ -144,7 +161,7 @@ var Application = class {
 	*/
 	ensureI18n() {
 		this.i18nInitPromise ??= runWithContainer(this._container, async () => {
-			const { I18nModule } = await import("./i18n.module-B2DvWUPa.mjs").then((n) => n.n);
+			const { I18nModule } = await import("./i18n.module-Bm3xlViA.mjs").then((n) => n.n);
 			await this.moduleRegistry.registerLazy(I18nModule);
 		});
 		return this.i18nInitPromise;
@@ -155,7 +172,7 @@ var Application = class {
 	*/
 	ensureCron() {
 		this.cronInitPromise ??= runWithContainer(this._container, async () => {
-			const { CronModule } = await import("./cron.module-C81HTzR7.mjs").then((n) => n.n);
+			const { CronModule } = await import("./cron.module-Dnyl9sFk.mjs").then((n) => n.n);
 			this.moduleRegistry.register(CronModule);
 			this.cronManager = this._container.resolve(DI_TOKENS.Cron);
 			this.registerCronJobs(this.cronManager);
@@ -353,8 +370,19 @@ var Stratal = class Stratal {
 			console.error("[stratal] Initialization failed:", error);
 		});
 	}
+	/**
+	* The eyeball entrypoint — and, when `stratal/response-cache`'s gateway is
+	* configured, the **gateway**.
+	*
+	* The execution context is marked before it reaches Hono so the dispatch
+	* middleware can tell which of the two entrypoints it is running inside.
+	* `cachedEntrypoint` deliberately does not mark, which is what stops the
+	* cached entrypoint from dispatching back into itself. The mark lives in a
+	* module-private `WeakSet` keyed on this object, so nothing a client sends
+	* can set or clear it. It is a no-op for apps that configure no gateway.
+	*/
 	async fetch(request, env, ctx) {
-		return (await (await this.ensureReady()).ensureHono()).fetch(request, env, ctx);
+		return (await (await this.ensureReady()).ensureHono()).fetch(request, env, markGatewayMode(ctx));
 	}
 	async queue(batch) {
 		return (await this.ensureReady()).handleQueue(batch, batch.queue);
@@ -424,10 +452,15 @@ var Stratal = class Stratal {
 			await app.shutdown();
 			throw new StratalSupersededError(generation);
 		}
+		if (app.hasHttpRoutes()) try {
+			await app.ensureHono();
+		} catch (error) {
+			app.logger.error("[stratal] Eager route registration failed", error instanceof Error ? error : new Error(String(error)));
+		}
 		return app;
 	}
 };
 //#endregion
 export { Application as n, Stratal as t };
 
-//# sourceMappingURL=stratal-BL6FKUM_.mjs.map
+//# sourceMappingURL=stratal-CiwNpWy2.mjs.map

package/dist/stratal-CiwNpWy2.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"stratal-CiwNpWy2.mjs","names":[],"sources":["../src/application.ts","../src/stratal.ts"],"sourcesContent":["import type { CronJob } from './cron/cron-job'\nimport type { CronManager } from './cron/cron-manager'\nimport { Container } from './di/container'\nimport { containerStorage, getContainer, runWithContainer } from './di/container-storage'\nimport { DI_TOKENS } from './di/tokens'\nimport { type StratalEnv } from './env'\nimport { DefaultExceptionHandler } from './errors/default-exception-handler'\nimport { createCliExceptionContext, createCronExceptionContext, createQueueExceptionContext } from './errors/exception-context'\nimport type { ExceptionHandler } from './errors/exception-handler'\nimport type { EventHandler, EventRegistry } from './events'\nimport { getListenerHandlers } from './events'\nimport type { StratalExecutionContext } from './execution-context'\nimport { JsonFormatter, LOGGER_TOKENS, LoggerService, LogLevel, PrettyFormatter } from './logger'\nimport { LazyModuleLoader } from './module/lazy-module-loader'\nimport { ModuleRegistry } from './module/module-registry'\nimport type { DynamicModule, ModuleClass } from './module/types'\nimport type { Command } from './quarry/command'\nimport type { QuarryRegistry } from './quarry/quarry-registry'\nimport type { CommandInput, CommandResult } from './quarry/types'\nimport type { ConsumerRegistry } from './queue/consumer-registry'\nimport type { IQueueConsumer, QueueMessage } from './queue/queue-consumer'\nimport type { QueueManager } from './queue/queue-manager'\nimport type { RouterContext } from './router'\nimport type { HonoApp } from './router/hono-app'\nimport { ROUTER_TOKENS } from './router/router.tokens'\nimport type { TrailingSlashConfig, VersioningOptions } from './router/types'\nimport type { Seeder } from './seeder/seeder'\nimport { SEEDER_TOKENS } from './seeder/seeder-registry'\nimport type { SeederRegistry } from './seeder/seeder-registry'\nimport type { Constructor } from './types'\n\nexport interface ApplicationConfig {\n  module: ModuleClass | DynamicModule\n  logging?: {\n    level?: LogLevel\n    formatter?: 'json' | 'pretty'\n  }\n  versioning?: VersioningOptions\n  trailingSlash?: TrailingSlashConfig\n  exceptionHandler?: Constructor<ExceptionHandler>\n}\n\nexport interface ApplicationOptions extends ApplicationConfig {\n  env: StratalEnv\n  ctx: StratalExecutionContext\n}\n\nexport class Application {\n  private _container: Container\n  private honoApp!: HonoApp\n  private moduleRegistry: ModuleRegistry\n  private consumerRegistry!: ConsumerRegistry\n  private cronManager?: CronManager\n  private quarry!: QuarryRegistry\n  private initialized = false\n\n  // Independently memoized lazy-init promises — each built-in subsystem is\n  // loaded on demand at its trigger point to keep cold start lean.\n  private routingInitPromise: Promise<void> | null = null\n  private eventsInitPromise: Promise<void> | null = null\n  private queueInitPromise: Promise<void> | null = null\n  private i18nInitPromise: Promise<void> | null = null\n  private cronInitPromise: Promise<void> | null = null\n\n  readonly env: StratalEnv\n  private readonly appConfig: ApplicationConfig\n\n  constructor({ env, ctx, ...config }: ApplicationOptions) {\n    this.env = env\n    this.appConfig = config\n\n    this._container = new Container()\n\n    this._container.registerValue(DI_TOKENS.Application, this)\n    this._container.registerValue(DI_TOKENS.CloudflareEnv, env)\n    this._container.registerValue(DI_TOKENS.ExecutionContext, ctx)\n    this._container.registerValue(ROUTER_TOKENS.RouterContext, null)\n\n    this.registerLoggerService()\n    this.registerCoreServices()\n\n    const logger = this._container.resolve<LoggerService>(LOGGER_TOKENS.LoggerService)\n    this.moduleRegistry = new ModuleRegistry(this._container, logger)\n\n    this._container.registerValue(DI_TOKENS.ModuleRegistry, this.moduleRegistry)\n  }\n\n  get container(): Container {\n    return this._container\n  }\n\n  /** The application's logger (the singleton {@link LoggerService}). */\n  get logger(): LoggerService {\n    return this._container.resolve<LoggerService>(LOGGER_TOKENS.LoggerService)\n  }\n\n  async ensureHono(): Promise<HonoApp> {\n    await this.initializeRouting()\n    return this.honoApp\n  }\n\n  /**\n   * Whether the app registers any HTTP controllers. Cheap (reads the already-\n   * populated registry; no routing built) and only meaningful after\n   * {@link initialize}. The worker entry uses it to decide whether to pre-warm\n   * the routing stack at boot — queue/scheduled-only apps return false and never\n   * build routes they won't serve.\n   */\n  hasHttpRoutes(): boolean {\n    return this.moduleRegistry.getAllControllers().length > 0\n  }\n\n  get config(): ApplicationConfig {\n    return this.appConfig\n  }\n\n  async initialize(): Promise<void> {\n    if (this.initialized) {\n      return\n    }\n\n    try {\n      await runWithContainer(this._container, () => this.initializeInternal())\n    } catch (error) {\n      // A failed boot can still hold live resources: every module whose\n      // onInitialize already ran (DB pools, timers) and every container-cached\n      // singleton. Tear them down here so callers never have to special-case\n      // a failed initialize() — shutdown() stays a no-op for it.\n      await this.teardown().catch((teardownError: unknown) => {\n        console.error('[stratal] Teardown after failed initialization also failed:', teardownError)\n      })\n      throw error\n    }\n  }\n\n  private async initializeInternal(): Promise<void> {\n    // Eager subsystem modules — Quarry/Seeder are resolved synchronously\n    // post-init (CLI runner, test harness), so they must be registered before\n    // initialize() completes. Dynamic import keeps application.ts free of static\n    // subsystem imports (uniform with the other built-ins). They load at boot\n    // regardless, so this is for consistency, not cold-start deferral.\n    const [{ QuarryModule }, { SeederModule }] = await Promise.all([\n      import('./quarry/quarry.module'),\n      import('./seeder/seeder.module'),\n    ])\n    this.moduleRegistry.registerAll([QuarryModule, SeederModule])\n\n    // Register the user's root module (traverses imports). Other built-in\n    // subsystems (i18n, queue, cache, openapi, cron, events, router) load on\n    // demand at their trigger points.\n    this.moduleRegistry.register(this.appConfig.module)\n\n    // Initialize all modules (only those with lifecycle hooks)\n    await this.moduleRegistry.initialize()\n\n    // Initialize ExceptionHandler\n    this.initializeExceptionHandler()\n\n    // Register CLI commands + seeders (class refs only; no instantiation)\n    this.registerCommands()\n    this.registerSeeders()\n\n    // Wire event listeners as part of initialization whenever the application\n    // declares any, so emitted events reach their handlers regardless of which\n    // entry point drives the app. Listener wiring otherwise happens lazily only\n    // on the HTTP router (`initializeRouting`) and queue/scheduled/command\n    // (`ensureScopedHandlers`) paths; any code that emits events without going\n    // through one of those — a direct service or repository call, an RPC\n    // entrypoint, or a Durable Object — would dispatch into a registry with no\n    // handlers attached, silently dropping the event. Guarded on there being\n    // listeners so applications with none still skip loading the events\n    // subsystem; `initializeEventListeners` dedups, so any later lazy trigger\n    // becomes a no-op.\n    if (this.moduleRegistry.getAllListeners().length > 0) {\n      await this.initializeEventListeners()\n    }\n\n    // Cron only loads when the app actually declares scheduled jobs\n    if (this.moduleRegistry.getAllJobs().length > 0) {\n      await this.ensureCron()\n    }\n\n    this.initialized = true\n  }\n\n  private async registerRoutingServices(): Promise<void> {\n    const [\n      { HonoApp },\n      { RouteRegistry },\n      { RouterResolver },\n      { VersioningService },\n      { LocalePathService },\n      { LocaleUrlService },\n      { RouteRegistrationService },\n      { Uri },\n      { RouteMetadataRegistry },\n    ] = await Promise.all([\n      import('./router/hono-app'),\n      import('./router/route-registry'),\n      import('./router/router-resolver'),\n      import('./router/services/versioning.service'),\n      import('./router/services/locale-path.service'),\n      import('./router/services/locale-url.service'),\n      import('./router/services/route-registration.service'),\n      import('./router/uri'),\n      import('./router/route-metadata'),\n    ])\n\n    this._container.register(ROUTER_TOKENS.RouteMetadataRegistry, RouteMetadataRegistry)\n    this._container.register(ROUTER_TOKENS.VersioningService, VersioningService)\n    this._container.register(ROUTER_TOKENS.HonoApp, HonoApp)\n    this._container.register(ROUTER_TOKENS.LocalePathService, LocalePathService)\n    this._container.register(ROUTER_TOKENS.LocaleUrlService, LocaleUrlService)\n    this._container.register(ROUTER_TOKENS.RouteRegistry, RouteRegistry)\n    this._container.register(ROUTER_TOKENS.Uri, Uri)\n\n    const routerConfigs = this.moduleRegistry.getAllRouterConfigs()\n    if (routerConfigs.length > 0) {\n      this._container.registerValue(ROUTER_TOKENS.RouterResolver, new RouterResolver(routerConfigs))\n    }\n\n    this._container.register(RouteRegistrationService, RouteRegistrationService)\n  }\n\n  /**\n   * Load the events subsystem and wire listeners. Needed by the HTTP, queue,\n   * and scheduled paths (handlers emit events). Independent of the queue\n   * subsystem so HTTP-only apps never load queue code. EventsModule is\n   * registered before the (possibly empty) listener wiring so `emit()` works\n   * even with zero listeners; dedups against the framework's own load.\n   */\n  private initializeEventListeners(): Promise<void> {\n    this.eventsInitPromise ??= runWithContainer(this._container, async () => {\n      const { EventsModule } = await import('./events/events.module')\n      await this.moduleRegistry.registerLazy(EventsModule)\n      this.registerEventListeners()\n    })\n    return this.eventsInitPromise\n  }\n\n  /**\n   * Wire event and queue handlers for any non-HTTP request scope — queue\n   * batches, scheduled/cron runs, CLI commands, Durable Objects, Workflows,\n   * WorkerEntrypoints — all of which may emit events or dispatch to queues from\n   * arbitrary user code. This is the single source of truth for that wiring:\n   * every non-HTTP entry point routes through it rather than open-coding which\n   * subsystems to init, so a subsystem can't be silently dropped by a future\n   * refactor (the queue half was once lost from the command path that way).\n   *\n   * HTTP (`fetch`) deliberately does NOT use this: a fetch worker only enqueues\n   * to the async Cloudflare queue and never processes consumers inline, so it\n   * skips queue init via `initializeRouting`.\n   */\n  async ensureScopedHandlers(): Promise<void> {\n    await this.initializeEventListeners()\n    await this.initializeQueue()\n  }\n\n  /**\n   * Load the queue subsystem on demand (first queue/scheduled trigger). i18n is\n   * ensured first because the queue registry depends on it.\n   */\n  private initializeQueue(): Promise<void> {\n    this.queueInitPromise ??= runWithContainer(this._container, async () => {\n      await this.ensureI18n()\n      const { QueueModule } = await import('./queue/queue.module')\n      this.moduleRegistry.register(QueueModule as unknown as ModuleClass)\n      this.consumerRegistry = this._container.resolve<ConsumerRegistry>(DI_TOKENS.ConsumerRegistry)\n      await this.registerQueueConsumers()\n    })\n    return this.queueInitPromise\n  }\n\n  /**\n   * Load i18n on demand. Coupled to the request path (Zod validation error maps,\n   * OpenAPI descriptions, queue registry), so it loads before routing/queue\n   * handling. Uses `registerLazy` because I18nModule has an `onInitialize` hook\n   * (configures the Zod error map). Dedups if the app already imported i18n.\n   */\n  private ensureI18n(): Promise<void> {\n    this.i18nInitPromise ??= runWithContainer(this._container, async () => {\n      const { I18nModule } = await import('./i18n/i18n.module')\n      await this.moduleRegistry.registerLazy(I18nModule as unknown as ModuleClass)\n    })\n    return this.i18nInitPromise\n  }\n\n  /**\n   * Load the cron subsystem on demand (first scheduled trigger, or at bootstrap\n   * when the app declares jobs).\n   */\n  private ensureCron(): Promise<CronManager> {\n    this.cronInitPromise ??= runWithContainer(this._container, async () => {\n      const { CronModule } = await import('./cron/cron.module')\n      this.moduleRegistry.register(CronModule)\n      this.cronManager = this._container.resolve<CronManager>(DI_TOKENS.Cron)\n      this.registerCronJobs(this.cronManager)\n    })\n    return this.cronInitPromise.then(() => this.cronManager!)\n  }\n\n  resolve<T>(token: symbol): T {\n    try {\n      return this._container.resolve(token)\n    } catch (error) {\n      const handler = this._container.resolve<ExceptionHandler>(DI_TOKENS.ExceptionHandler)\n      const ctx = createCliExceptionContext('resolve')\n      void handler.handle(error, ctx)\n      throw error\n    }\n  }\n\n  async handleQueue(batch: MessageBatch, queueName: string): Promise<void> {\n    await this.ensureScopedHandlers()\n\n    const firstMessage = batch.messages[0]?.body as QueueMessage | undefined\n    const locale = firstMessage?.metadata?.locale ?? 'en'\n    const mockRouterContext = this.createMockRouterContext(locale)\n\n    await this._container.runInRequestScope(mockRouterContext, async (requestContainer) => {\n      try {\n        const queueManager = requestContainer.resolve<QueueManager>(DI_TOKENS.Queue)\n        await queueManager.processBatch(queueName, batch)\n      } catch (error) {\n        const handler = requestContainer.resolve<ExceptionHandler>(DI_TOKENS.ExceptionHandler)\n        await handler.handle(error, createQueueExceptionContext(queueName))\n        throw error\n      }\n    })\n  }\n\n  async handleScheduled(controller: ScheduledController): Promise<void> {\n    const cronManager = await this.ensureCron()\n    // A scheduled job is a non-HTTP scope that can emit events and dispatch to\n    // queues (timeout/reminder/digest emails) — wire both so dispatches aren't\n    // silently dropped by the sync provider. i18n is ensured independently for\n    // the job execution context. All inits are memoized, so this is idempotent.\n    await this.ensureScopedHandlers()\n    await this.ensureI18n()\n\n    const mockRouterContext = this.createMockRouterContext('en')\n\n    await this._container.runInRequestScope(mockRouterContext, async (requestContainer) => {\n      try {\n        await cronManager.executeScheduled(controller, requestContainer)\n      } catch (error) {\n        const handler = requestContainer.resolve<ExceptionHandler>(DI_TOKENS.ExceptionHandler)\n        await handler.handle(error, createCronExceptionContext())\n        throw error\n      }\n    })\n  }\n\n  createMockRouterContext(locale = 'en'): RouterContext {\n    return {\n      getLocale: () => locale,\n      setLocale: () => { /* no-op */ },\n      // Non-HTTP scopes have no request headers\n      header: () => undefined,\n      // Inside runInRequestScope the active container is the request-scoped child\n      // (set in AsyncLocalStorage); return it so request-scoped providers resolve\n      // against the scope, not the global container.\n      getContainer: () => containerStorage.getStore() ?? this._container,\n    } as unknown as RouterContext\n  }\n\n  async shutdown(): Promise<void> {\n    // A failed initialize() has already torn itself down — only a fully\n    // initialized application owns resources here.\n    if (!this.initialized) return\n    this.initialized = false\n\n    await this.teardown()\n  }\n\n  /** Releases everything boot acquired: module resources, then the container. */\n  private async teardown(): Promise<void> {\n    await this.moduleRegistry.shutdown()\n\n    const logger = this._container.resolve<LoggerService>(LOGGER_TOKENS.LoggerService)\n    logger.info('Disposing container...')\n\n    await this._container.dispose()\n  }\n\n  async handleCommand(name: string, input?: CommandInput): Promise<CommandResult> {\n    // Routing first: commands generate URLs via route() (e.g. tenant:bootstrap\n    // prints tenant URLs / builds email links).\n    await this.initializeRouting()\n    // A CLI command is a non-HTTP scope that can dispatch to queues and emit\n    // events from arbitrary user code (e.g. tenant:bootstrap → email.send /\n    // tenant.geo.seed). Without this the dev/CLI sync provider finds zero\n    // consumers and silently drops every dispatched message. All inits are\n    // memoized, so the events half (already wired by routing) is a no-op here.\n    await this.ensureScopedHandlers()\n    // Resolve QuarryRegistry lazily (deferred from bootstrap)\n    this.quarry ??= this._container.resolve<QuarryRegistry>(DI_TOKENS.Quarry)\n    const mockContext = this.createMockRouterContext('en')\n    return this._container.runInRequestScope(mockContext, async () => {\n      return this.quarry.call(name, input)\n    })\n  }\n\n  private initializeRouting(): Promise<void> {\n    this.routingInitPromise ??= runWithContainer(this._container, async () => {\n      await this.initializeEventListeners()\n      await this.ensureI18n()\n      const { OpenAPIModule } = await import('./openapi')\n      this.moduleRegistry.register(OpenAPIModule as unknown as ModuleClass)\n      await this.registerRoutingServices()\n      this.honoApp = this._container.resolve<HonoApp>(ROUTER_TOKENS.HonoApp)\n      await this.honoApp.configure()\n    })\n    return this.routingInitPromise\n  }\n\n  private registerCommands(): void {\n    this.quarry ??= this._container.resolve<QuarryRegistry>(DI_TOKENS.Quarry)\n    const commands = this.moduleRegistry.getAllCommands()\n    for (const CommandClass of commands) {\n      this.quarry.register(CommandClass as Constructor<Command>)\n    }\n  }\n\n  private registerSeeders(): void {\n    const seeders = this.moduleRegistry.getAllSeeders()\n    if (seeders.length === 0) return\n    const registry = this._container.resolve<SeederRegistry>(SEEDER_TOKENS.SeederRegistry)\n    for (const SeederClass of seeders) {\n      registry.register(SeederClass as Constructor<Seeder>)\n    }\n  }\n\n  private async registerQueueConsumers(): Promise<void> {\n    const consumerClasses = this.moduleRegistry.getAllConsumers()\n    if (consumerClasses.length === 0) return\n\n    // Consumers are resolved fresh per message at dispatch time (see\n    // QueueManager / SyncQueueProvider). Here we only need each consumer's\n    // declared message types; read them from a throwaway instance built inside a\n    // request scope so a consumer that injects request-scoped providers\n    // (@InjectQueue, i18n, auth context, …) doesn't fail to instantiate at boot.\n    const mockContext = this.createMockRouterContext('en')\n    await this._container.runInRequestScope(mockContext, (requestContainer) => {\n      for (const ConsumerClass of consumerClasses) {\n        const consumer = requestContainer.resolve(ConsumerClass) as IQueueConsumer\n        this.consumerRegistry.register(\n          ConsumerClass as Constructor<IQueueConsumer>,\n          consumer.messageTypes,\n        )\n      }\n    })\n  }\n\n  private registerCronJobs(cronManager: CronManager): void {\n    for (const JobClass of this.moduleRegistry.getAllJobs()) {\n      const schedule = (JobClass as unknown as { schedule: string }).schedule\n      if (schedule) {\n        cronManager.registerJob(schedule, JobClass as Constructor<CronJob>)\n      } else {\n        const logger = this._container.resolve<LoggerService>(LOGGER_TOKENS.LoggerService)\n        logger.warn(`Cron job \"${JobClass.name}\" has no static schedule property — skipped`)\n      }\n    }\n  }\n\n  private registerEventListeners(): void {\n    const listeners = this.moduleRegistry.getAllListeners()\n    if (listeners.length === 0) {\n      return\n    }\n\n    const eventRegistry = this._container.resolve<EventRegistry>(DI_TOKENS.EventRegistry)\n\n    for (const ListenerClass of listeners) {\n      const handlers = getListenerHandlers(ListenerClass)\n\n      for (const { methodName, event, options } of handlers) {\n        // Resolve the listener fresh per event from the active scope (events are\n        // emitted inside an HTTP request or runInScope), so request-scoped\n        // listener dependencies bind to the emitting request rather than being\n        // frozen at boot. Listener metadata is read from the class statically —\n        // no instance is created until an event actually fires.\n        const handler: EventHandler = ((...args: unknown[]) => {\n          const instance = getContainer().resolve(ListenerClass) as Record<\n            string,\n            (...a: unknown[]) => unknown\n          >\n          return instance[methodName](...args)\n        }) as EventHandler\n\n        eventRegistry.on(event, handler, options)\n      }\n    }\n  }\n\n  private registerLoggerService(): void {\n    const logLevel = this.appConfig.logging?.level ?? LogLevel.INFO\n    const formatter = this.appConfig.logging?.formatter ?? 'json'\n\n    this._container.registerValue(LOGGER_TOKENS.LogLevelOptions, logLevel)\n\n    this._container\n      .when(() => formatter === 'pretty')\n      .use(LOGGER_TOKENS.Formatter)\n      .give(PrettyFormatter)\n      .otherwise(JsonFormatter)\n\n    this._container.registerSingleton(LOGGER_TOKENS.LoggerService, LoggerService)\n  }\n\n  /**\n   * Bootstrap kernel — registered imperatively because they cannot be expressed\n   * as ordinary module providers: ExceptionHandler is a user-overridable forced\n   * singleton (a module ClassProvider derives scope from the class decorator,\n   * which a user handler may not carry), and LazyModuleLoader is the loader\n   * itself. Subsystem registries (events/cron/quarry/seeder) are modules.\n   */\n  private registerCoreServices(): void {\n    this._container.registerSingleton(\n      DI_TOKENS.ExceptionHandler,\n      (this.appConfig.exceptionHandler ?? DefaultExceptionHandler) as Constructor,\n    )\n    this._container.registerSingleton(DI_TOKENS.LazyModuleLoader, LazyModuleLoader)\n  }\n\n  private initializeExceptionHandler(): void {\n    const handler = this._container.resolve<ExceptionHandler>(DI_TOKENS.ExceptionHandler)\n    handler.register()\n    this.moduleRegistry.configureExceptionHandlers(handler)\n  }\n}\n","import { Application, type ApplicationConfig } from './application'\nimport type { StratalEnv } from './env'\nimport { StratalNotInitializedError, StratalSupersededError } from './errors'\nimport { markGatewayMode } from './response-cache/gateway-mode'\nimport type { HonoApp } from './router/hono-app'\n\n/**\n * Stratal — Hono-style entry point for Cloudflare Workers.\n *\n * Eagerly bootstraps the Application at construction time, dynamically\n * importing `cloudflare:workers` for env and waitUntil.\n *\n * @example\n * ```typescript\n * import { Stratal } from 'stratal'\n * import { AppModule } from './app.module'\n *\n * export default new Stratal({ module: AppModule })\n * ```\n */\nexport class Stratal<Env extends StratalEnv = StratalEnv> {\n  private app: Application | null = null\n  private initPromise: Promise<Application>\n\n  private static _application: Promise<Application> | null = null\n  private static _generation = 0\n  private static _current: Stratal | null = null\n  /**\n   * Serializes generation teardown: each new instance appends the previous\n   * instance's shutdown here, and `prepareApp` awaits the chain before\n   * allocating the new Application. Old and new DI graphs never coexist,\n   * so repeated Vite HMR reloads can't accumulate live object graphs.\n   */\n  private static _teardownChain: Promise<void> = Promise.resolve()\n\n  constructor(config: ApplicationConfig) {\n    this.fetch = this.fetch.bind(this)\n    this.queue = this.queue.bind(this)\n    this.scheduled = this.scheduled.bind(this)\n\n    // Invalidate any in-flight initialization from a previous instance (Vite HMR reload)\n    const generation = ++Stratal._generation\n\n    const previous = Stratal._current\n    Stratal._current = this\n    if (previous) {\n      Stratal._teardownChain = Stratal._teardownChain\n        .then(() => previous.shutdown())\n        .catch((error: unknown) => {\n          console.error('[stratal] Failed to shut down superseded instance:', error)\n        })\n    }\n\n    // Capture the chain as of THIS construction: it contains only strictly\n    // older generations' teardowns. Reading the static inside prepareApp\n    // instead would deadlock when this generation is superseded before its\n    // first await — it would wait on a chain containing its own shutdown,\n    // which waits on this initPromise.\n    const teardownBarrier = Stratal._teardownChain\n\n    this.initPromise = this.prepareApp(config, generation, teardownBarrier)\n    Stratal._application = this.initPromise\n    // A superseded generation rejects; without an awaiter (no in-flight\n    // request during the reload) that would surface as an unhandled rejection.\n    // Anything else is a real bootstrap failure — log it so it isn't invisible\n    // until the first request arrives (awaiters still get the rejection).\n    this.initPromise.catch((error: unknown) => {\n      if (error instanceof StratalSupersededError) return\n      console.error('[stratal] Initialization failed:', error)\n    })\n  }\n\n  /**\n   * The eyeball entrypoint — and, when `stratal/response-cache`'s gateway is\n   * configured, the **gateway**.\n   *\n   * The execution context is marked before it reaches Hono so the dispatch\n   * middleware can tell which of the two entrypoints it is running inside.\n   * `cachedEntrypoint` deliberately does not mark, which is what stops the\n   * cached entrypoint from dispatching back into itself. The mark lives in a\n   * module-private `WeakSet` keyed on this object, so nothing a client sends\n   * can set or clear it. It is a no-op for apps that configure no gateway.\n   */\n  async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {\n    const app = await this.ensureReady()\n    const hono = await app.ensureHono()\n    return hono.fetch(request, env, markGatewayMode(ctx))\n  }\n\n  async queue(batch: MessageBatch): Promise<void> {\n    const app = await this.ensureReady()\n    return app.handleQueue(batch, batch.queue)\n  }\n\n  async scheduled(controller: ScheduledController): Promise<void> {\n    const app = await this.ensureReady()\n    return app.handleScheduled(controller)\n  }\n\n  get hono(): Promise<HonoApp> {\n    return this.ensureReady().then(app => app.ensureHono())\n  }\n\n  async shutdown(): Promise<void> {\n    try { this.app = await this.initPromise } catch { /* ignore */ }\n    if (this.app) {\n      await this.app.shutdown()\n      this.app = null\n    }\n    // If we're still the live generation (explicit shutdown, not supersession),\n    // clear the statics so resolveApplication() throws StratalNotInitializedError\n    // instead of handing out the disposed Application.\n    if (Stratal._current === this) {\n      Stratal._current = null\n      Stratal._application = null\n    }\n  }\n\n  /**\n   * @internal\n   * Resolves the Application instance from the static singleton.\n   * Used by worker base classes (DurableObject, Workflow, WorkerEntrypoint)\n   * to access the DI container without going through Cloudflare RPC.\n   * Generations superseded mid-boot reject with {@link StratalSupersededError};\n   * this retries against the replacing generation so callers always land on\n   * the live Application.\n   */\n  static async resolveApplication(): Promise<Application> {\n    let current = Stratal._application\n    while (current) {\n      try {\n        return await current\n      } catch (error) {\n        // Superseded by a newer generation while booting — its constructor has\n        // already swapped _application; retry against the replacement.\n        if (error instanceof StratalSupersededError && Stratal._application !== current) {\n          current = Stratal._application\n          continue\n        }\n        throw error\n      }\n    }\n    throw new StratalNotInitializedError()\n  }\n\n  private async ensureReady(): Promise<Application> {\n    if (this.app) return this.app\n    try {\n      this.app = await this.initPromise\n      return this.app\n    } catch (error) {\n      if (error instanceof StratalSupersededError) {\n        // This instance was replaced mid-boot (Vite HMR reload) — serve the\n        // request from the generation that replaced it.\n        return Stratal.resolveApplication()\n      }\n      throw error\n    }\n  }\n\n  private async prepareApp(\n    config: ApplicationConfig,\n    generation: number,\n    teardownBarrier: Promise<void>,\n  ): Promise<Application> {\n    const { env, waitUntil } = await import('cloudflare:workers')\n\n    // Let every previous generation finish tearing down before allocating the\n    // new DI graph — concurrent old+new graphs are what leak across reloads.\n    await teardownBarrier\n\n    // After the awaits, check if a newer instance has replaced us (Vite HMR reload)\n    if (generation !== Stratal._generation) {\n      throw new StratalSupersededError(generation)\n    }\n\n    const app = new Application({ ...config, env: env, ctx: { waitUntil } })\n    await app.initialize()\n\n    // Check again after initialization completes\n    if (generation !== Stratal._generation) {\n      await app.shutdown()\n      throw new StratalSupersededError(generation)\n    }\n\n    // Pre-warm the HTTP routing stack as part of boot when the app serves HTTP,\n    // so the first request doesn't pay route registration. Queue/scheduled-only\n    // workers (no controllers) skip it and never build routes they won't use.\n    //\n    // Awaited, not fire-and-forget: Cloudflare Workers only progress async work\n    // while a request is being handled, so a detached `void ensureHono()` would\n    // either stall until the first request adopts it (no pre-warm) or, if it ran\n    // I/O outside a request context, reject — and `initializeRouting` memoizes\n    // that promise, so the first real request would await the poisoned promise\n    // and fail. Awaiting folds routing into the same init chain `fetch()` already\n    // awaits, running in the identical context as the proven `app.initialize()`.\n    //\n    // A routing failure is logged but not rethrown so it only breaks the HTTP\n    // path (the memoized rejection resurfaces per request, as in lazy routing)\n    // without taking down queue/scheduled handlers on a mixed worker.\n    if (app.hasHttpRoutes()) {\n      try {\n        await app.ensureHono()\n      } catch (error) {\n        app.logger.error(\n          '[stratal] Eager route registration failed',\n          error instanceof Error ? error : new Error(String(error)),\n        )\n      }\n    }\n\n    return app\n  }\n}\n"],"mappings":"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"}

package/dist/{tiered-cache.service-Dv3BhxxE.d.mts → tiered-cache.service-Bz8bbvyb.d.mts}

@@ -1,5 +1,4 @@
-import { t as CacheService } from "./cache.service-uElmBtdS.mjs";
-
+import { t as CacheService } from "./cache.service-Dg0Hj0gp.mjs";
 //#region src/cache/services/tiered-cache.service.d.ts
 /**
  * Tiered Cache Service
@@ -65,6 +64,20 @@ declare class TieredCacheService {
   getWithMetadata<Metadata = unknown>(key: string, typeOrOptions: 'arrayBuffer' | KVNamespaceGetOptions<'arrayBuffer'>): Promise<KVNamespaceGetWithMetadataResult<ArrayBuffer, Metadata>>;
   getWithMetadata<Metadata = unknown>(key: string, typeOrOptions: 'stream' | KVNamespaceGetOptions<'stream'>): Promise<KVNamespaceGetWithMetadataResult<ReadableStream, Metadata>>;
   put(key: string, value: string | ArrayBuffer | ArrayBufferView | ReadableStream, options?: KVNamespacePutOptions): Promise<void>;
+  /**
+   * Write-through put that **awaits the durable L2 write** (throwing on
+   * failure) while keeping the isolate-local L1 in lock-step. Use for set-once
+   * values whose loss would be a correctness bug — queue idempotency claims,
+   * failed-job records. The deferred {@link put} is for best-effort caching.
+   *
+   * @throws {CacheError} If the KV write fails.
+   */
+  putDurable(key: string, value: string | ArrayBuffer | ArrayBufferView | ReadableStream, options?: KVNamespacePutOptions): Promise<void>;
+  /**
+   * Mirror a write into the isolate-local L1: cache string values; drop the
+   * entry for binary values, which L1 does not hold.
+   */
+  private writeThroughL1;
   delete(key: string): Promise<void>;
   list<Metadata = unknown>(options?: KVNamespaceListOptions): Promise<KVNamespaceListResult<Metadata>>;
   /** Read a fresh L1 entry, evicting it if expired. Returns `null` on miss. */
@@ -76,4 +89,4 @@ declare class TieredCacheService {
 }
 //#endregion
 export { TieredCacheService as t };
-//# sourceMappingURL=tiered-cache.service-Dv3BhxxE.d.mts.map
+//# sourceMappingURL=tiered-cache.service-Bz8bbvyb.d.mts.map