stratal 0.0.26 → 0.1.0

package/dist/workers/index.d.mts

@@ -1,7 +1,70 @@
-import { $ as Container } from "../index-uybm0bhQ.mjs";
+import { $ as Container, hr as PurgeSpec } from "../index-B2WtEagR.mjs";
 import { t as StratalEnv } from "../env-ug22bJj7.mjs";
+import { t as Stratal } from "../stratal-Bs1_E8GQ.mjs";
 import { DurableObject, WorkerEntrypoint, WorkflowEntrypoint } from "cloudflare:workers";
-
+//#region src/workers/cached-entrypoint.d.ts
+/**
+ * What a cached entrypoint instance exposes.
+ *
+ * Extends `Rpc.WorkerEntrypointBranded` because the class {@link cachedEntrypoint}
+ * returns really does extend `WorkerEntrypoint`, which carries that brand — and
+ * `Service<T>` only reads a class's RPC methods when the instance it constructs
+ * is branded. Without it, `wrangler types` emits `Service<typeof Cached>` for a
+ * binding to this entrypoint and the type silently degrades to a bare `Fetcher`
+ * with no `purge`, so every consumer needs a cast to call the one method the
+ * binding exists for.
+ */
+interface CachedEntrypoint extends Rpc.WorkerEntrypointBranded {
+  fetch(request: Request): Promise<Response>;
+  purge(spec: PurgeSpec): Promise<{
+    success: boolean;
+  } | void>;
+}
+/**
+ * The class {@link cachedEntrypoint} returns.
+ *
+ * Named explicitly rather than inferred: the returned class is an anonymous
+ * class *expression*, and `WorkerEntrypoint`'s `ctx`/`env` are `protected`, so
+ * inferring it produces a declaration TypeScript refuses to emit (TS4094).
+ */
+type CachedEntrypointClass<Env extends StratalEnv = StratalEnv> = new (ctx: ExecutionContext, env: Env) => CachedEntrypoint;
+/**
+ * Build the cached entrypoint that `stratal/response-cache`'s gateway forwards
+ * partitioned reads to.
+ *
+ * ```typescript
+ * // src/index.ts
+ * import { Stratal } from 'stratal'
+ * import { cachedEntrypoint } from 'stratal/workers'
+ * import { AppModule } from './app.module'
+ *
+ * const stratal = new Stratal({ module: AppModule })
+ *
+ * export default stratal                       // gateway, cache disabled
+ * export const Cached = cachedEntrypoint(stratal)  // cache enabled
+ * ```
+ *
+ * ```jsonc
+ * // wrangler.jsonc
+ * {
+ *   "compatibility_date": "2026-07-06",
+ *   "compatibility_flags": ["enable_ctx_exports"],
+ *   "cache": { "enabled": true },
+ *   "exports": {
+ *     "default": { "type": "worker", "cache": { "enabled": false } },
+ *     "Cached":  { "type": "worker", "cache": { "enabled": true } },
+ *   },
+ * }
+ * ```
+ *
+ * It runs the **same** `Stratal` instance, and therefore the same Hono app and
+ * the same DI graph, as the default export. The only difference is that its
+ * execution context is never marked by `markGatewayMode`, so the dispatch
+ * middleware is a straight `next()` here — the cached entrypoint never
+ * re-dispatches, and a loopback loop is structurally impossible.
+ */
+export declare function cachedEntrypoint<Env extends StratalEnv = StratalEnv>(stratal: Stratal<Env>): CachedEntrypointClass<Env>;
+//#endregion
 //#region src/workers/run-in-scope.d.ts
 /**
  * Shared helper that creates a request-scoped DI container by accessing the
@@ -9,7 +72,7 @@ import { DurableObject, WorkerEntrypoint, WorkflowEntrypoint } from "cloudflare:
  *
  * Works with Durable Objects, Workflows, and WorkerEntrypoints.
  */
-declare function runInScope<T>(callback: (container: Container) => T | Promise<T>): Promise<T>;
+export declare function runInScope<T>(callback: (container: Container) => T | Promise<T>): Promise<T>;
 //#endregion
 //#region src/workers/stratal-durable-object.d.ts
 /**
@@ -33,7 +96,7 @@ declare function runInScope<T>(callback: (container: Container) => T | Promise<T
  * }
  * ```
  */
-declare abstract class StratalDurableObject<Env extends StratalEnv = StratalEnv> extends DurableObject<Env> {
+export declare abstract class StratalDurableObject<Env extends StratalEnv = StratalEnv> extends DurableObject<Env> {
   protected runInScope<T>(callback: (container: Container) => T | Promise<T>): Promise<T>;
 }
 //#endregion
@@ -58,7 +121,7 @@ declare abstract class StratalDurableObject<Env extends StratalEnv = StratalEnv>
  * }
  * ```
  */
-declare abstract class StratalWorkerEntrypoint<Env extends StratalEnv = StratalEnv> extends WorkerEntrypoint<Env> {
+export declare abstract class StratalWorkerEntrypoint<Env extends StratalEnv = StratalEnv> extends WorkerEntrypoint<Env> {
   protected runInScope<T>(callback: (container: Container) => T | Promise<T>): Promise<T>;
 }
 //#endregion
@@ -83,9 +146,9 @@ declare abstract class StratalWorkerEntrypoint<Env extends StratalEnv = StratalE
  * }
  * ```
  */
-declare abstract class StratalWorkflow<Env extends StratalEnv = StratalEnv, Params = unknown> extends WorkflowEntrypoint<Env, Params> {
+export declare abstract class StratalWorkflow<Env extends StratalEnv = StratalEnv, Params = unknown> extends WorkflowEntrypoint<Env, Params> {
   protected runInScope<T>(callback: (container: Container) => T | Promise<T>): Promise<T>;
 }
 //#endregion
-export { StratalDurableObject, StratalWorkerEntrypoint, StratalWorkflow, runInScope };
+export type { CachedEntrypoint, CachedEntrypointClass };
 //# sourceMappingURL=index.d.mts.map

package/dist/workers/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/workers/run-in-scope.ts","../../src/workers/stratal-durable-object.ts","../../src/workers/stratal-worker-entrypoint.ts","../../src/workers/stratal-workflow.ts"],"mappings":";;;;;;;;;AASA;;iBAAsB,UAAA,IACpB,QAAA,GAAW,SAAA,EAAW,SAAA,KAAc,CAAA,GAAI,OAAA,CAAQ,CAAA,IAC/C,OAAA,CAAQ,CAAA;;;;;AAFX;;;;;;;;;;;;;;;;;;;uBCkBsB,oBAAA,aACR,UAAA,GAAa,UAAA,UACjB,aAAA,CAAc,GAAA;EAAA,UACN,UAAA,IACd,QAAA,GAAW,SAAA,EAAW,SAAA,KAAc,CAAA,GAAI,OAAA,CAAQ,CAAA,IAC/C,OAAA,CAAQ,CAAA;AAAA;;;;;ADvBb;;;;;;;;;;;;;;;;;;uBEgBsB,uBAAA,aACR,UAAA,GAAa,UAAA,UACjB,gBAAA,CAAiB,GAAA;EAAA,UACf,UAAA,IACR,QAAA,GAAW,SAAA,EAAW,SAAA,KAAc,CAAA,GAAI,OAAA,CAAQ,CAAA,IAC/C,OAAA,CAAQ,CAAA;AAAA;;;;;AFrBb;;;;;;;;;;;;;;;;;;uBGgBsB,eAAA,aACR,UAAA,GAAa,UAAA,4BAEjB,kBAAA,CAAmB,GAAA,EAAK,MAAA;EAAA,UACtB,UAAA,IACR,QAAA,GAAW,SAAA,EAAW,SAAA,KAAc,CAAA,GAAI,OAAA,CAAQ,CAAA,IAC/C,OAAA,CAAQ,CAAA;AAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/workers/cached-entrypoint.ts","../../src/workers/run-in-scope.ts","../../src/workers/stratal-durable-object.ts","../../src/workers/stratal-worker-entrypoint.ts","../../src/workers/stratal-workflow.ts"],"mappings":";;;;;;;;;;;;;;;;UAiBiB,yBAAyB,IAAI;EAC5C,MAAM,SAAS,UAAU,QAAQ;EACjC,MAAM,MAAM,YAAY;IAAU;;;;;;;;;;KAUxB,sBAAsB,YAAY,aAAa,mBACzD,KAAK,kBACL,KAAK,QACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAqCW,iBAAiB,YAAY,aAAa,YACxD,SAAS,QAAQ,OAChB,sBAAsB;;;;;;;;;wBC9DH,WAAW,GAC/B,WAAW,WAAW,cAAc,IAAI,QAAQ,KAC/C,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;8BCgBW,qBACpB,YAAY,aAAa,oBACjB,cAAc;YACN,WAAW,GACzB,WAAW,WAAW,cAAc,IAAI,QAAQ,KAC/C,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;8BCPS,wBACpB,YAAY,aAAa,oBACjB,iBAAiB;YACf,WAAW,GACnB,WAAW,WAAW,cAAc,IAAI,QAAQ,KAC/C,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;8BCLS,gBACpB,YAAY,aAAa,YACzB,0BACQ,mBAAmB,KAAK;YACtB,WAAW,GACnB,WAAW,WAAW,cAAc,IAAI,QAAQ,KAC/C,QAAQ"}

package/dist/workers/index.mjs

@@ -1,6 +1,75 @@
-import { r as DI_TOKENS } from "../di-D7qmrAir.mjs";
-import { t as Stratal } from "../stratal-BL6FKUM_.mjs";
+import { r as DI_TOKENS } from "../di-DQ3xbjgf.mjs";
+import { t as Stratal } from "../stratal-CiwNpWy2.mjs";
+import { r as ResponseCacheConfigError } from "../response-cache.error-B4D0zy9W.mjs";
 import { DurableObject, WorkerEntrypoint, WorkflowEntrypoint } from "cloudflare:workers";
+//#region src/workers/cached-entrypoint.ts
+/**
+* Build the cached entrypoint that `stratal/response-cache`'s gateway forwards
+* partitioned reads to.
+*
+* ```typescript
+* // src/index.ts
+* import { Stratal } from 'stratal'
+* import { cachedEntrypoint } from 'stratal/workers'
+* import { AppModule } from './app.module'
+*
+* const stratal = new Stratal({ module: AppModule })
+*
+* export default stratal                       // gateway, cache disabled
+* export const Cached = cachedEntrypoint(stratal)  // cache enabled
+* ```
+*
+* ```jsonc
+* // wrangler.jsonc
+* {
+*   "compatibility_date": "2026-07-06",
+*   "compatibility_flags": ["enable_ctx_exports"],
+*   "cache": { "enabled": true },
+*   "exports": {
+*     "default": { "type": "worker", "cache": { "enabled": false } },
+*     "Cached":  { "type": "worker", "cache": { "enabled": true } },
+*   },
+* }
+* ```
+*
+* It runs the **same** `Stratal` instance, and therefore the same Hono app and
+* the same DI graph, as the default export. The only difference is that its
+* execution context is never marked by `markGatewayMode`, so the dispatch
+* middleware is a straight `next()` here — the cached entrypoint never
+* re-dispatches, and a loopback loop is structurally impossible.
+*/
+function cachedEntrypoint(stratal) {
+	return class StratalCachedEntrypoint extends WorkerEntrypoint {
+		/**
+		* Serve the request from this entrypoint, where Workers Caching is
+		* enabled. `this.ctx` carries the `props` the gateway chose; nothing here
+		* needs to read them — being part of the cache key is their whole job.
+		*/
+		async fetch(request) {
+			return (await stratal.hono).fetch(request, this.env, this.ctx);
+		}
+		/**
+		* Purge entries stored by **this** entrypoint.
+		*
+		* Called over RPC by the gateway, because purges are scoped to the
+		* entrypoint that issues them and mutations run inline in the gateway,
+		* whose cache is disabled. A purge issued there would target the gateway's
+		* own empty cache: it would report success and invalidate nothing, leaving
+		* every cached read stale until its TTL expired. See
+		* `createLoopbackPurgeTarget`, which is what routes the call here.
+		*
+		* @throws {ResponseCacheConfigError} `cache.enabled` is not set for this
+		*   entrypoint, so there is no cache to purge. Loud, because the caller is
+		*   a mutation that has already committed and is relying on this.
+		*/
+		async purge(spec) {
+			const cache = this.ctx.cache;
+			if (!cache) throw new ResponseCacheConfigError("the cached entrypoint has no `ctx.cache`, so a purge forwarded from the gateway has nothing to act on. Set `\"cache\": { \"enabled\": true }` for this entrypoint in your Wrangler `exports` block, use Wrangler >= 4.69.0, and set `compatibility_date` to 2026-07-06 or later.");
+			return cache.purge(spec);
+		}
+	};
+}
+//#endregion
 //#region src/workers/run-in-scope.ts
 /**
 * Shared helper that creates a request-scoped DI container by accessing the
@@ -101,6 +170,6 @@ var StratalWorkflow = class extends WorkflowEntrypoint {
 	}
 };
 //#endregion
-export { StratalDurableObject, StratalWorkerEntrypoint, StratalWorkflow, runInScope };
+export { StratalDurableObject, StratalWorkerEntrypoint, StratalWorkflow, cachedEntrypoint, runInScope };
 
 //# sourceMappingURL=index.mjs.map

package/dist/workers/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../../src/workers/run-in-scope.ts","../../src/workers/stratal-durable-object.ts","../../src/workers/stratal-worker-entrypoint.ts","../../src/workers/stratal-workflow.ts"],"sourcesContent":["import type { Container } from '../di/container'\nimport { Stratal } from '../stratal'\n\n/**\n * Shared helper that creates a request-scoped DI container by accessing the\n * Stratal Application via the static singleton.\n *\n * Works with Durable Objects, Workflows, and WorkerEntrypoints.\n */\nexport async function runInScope<T>(\n  callback: (container: Container) => T | Promise<T>\n): Promise<T> {\n  const app = await Stratal.resolveApplication()\n  await app.ensureScopedHandlers()\n  const mockCtx = app.createMockRouterContext('en')\n  return app.container.runInRequestScope(mockCtx, callback)\n}\n","import { DurableObject } from 'cloudflare:workers'\nimport type { Container } from '../di/container'\nimport { DI_TOKENS } from '../di/tokens'\nimport type { StratalEnv } from '../env'\nimport { runInScope } from './run-in-scope'\n\n/**\n * Base class for Durable Objects with full DI access.\n *\n * Extends Cloudflare's `DurableObject` and provides a `runInScope()` helper\n * that creates a request-scoped container with `DurableObjectState` and\n * `DurableObjectId` tokens registered.\n *\n * @example\n * ```typescript\n * import { StratalDurableObject } from 'stratal/workers'\n *\n * export class Counter extends StratalDurableObject {\n *   async increment() {\n *     return this.runInScope(async (container) => {\n *       const svc = container.resolve(CounterService)\n *       return svc.increment()\n *     })\n *   }\n * }\n * ```\n */\nexport abstract class StratalDurableObject<\n  Env extends StratalEnv = StratalEnv\n> extends DurableObject<Env> {\n  protected async runInScope<T>(\n    callback: (container: Container) => T | Promise<T>\n  ): Promise<T> {\n    return runInScope(async (requestContainer) => {\n      requestContainer.registerValue(DI_TOKENS.DurableObjectState, this.ctx)\n      requestContainer.registerValue(DI_TOKENS.DurableObjectId, this.ctx.id)\n      return callback(requestContainer)\n    })\n  }\n}\n","import { WorkerEntrypoint } from 'cloudflare:workers'\nimport type { Container } from '../di/container'\nimport type { StratalEnv } from '../env'\nimport { runInScope } from './run-in-scope'\n\n/**\n * Base class for Cloudflare WorkerEntrypoints (Service Bindings / RPC) with full DI access.\n *\n * Extends Cloudflare's `WorkerEntrypoint` and provides a `runInScope()` helper\n * that creates a request-scoped DI container.\n *\n * @example\n * ```typescript\n * import { StratalWorkerEntrypoint } from 'stratal/workers'\n *\n * export class AuthRpc extends StratalWorkerEntrypoint {\n *   async verifyToken(token: string) {\n *     return this.runInScope(async (container) => {\n *       const auth = container.resolve(AuthService)\n *       return auth.verify(token)\n *     })\n *   }\n * }\n * ```\n */\nexport abstract class StratalWorkerEntrypoint<\n  Env extends StratalEnv = StratalEnv\n> extends WorkerEntrypoint<Env> {\n  protected runInScope<T>(\n    callback: (container: Container) => T | Promise<T>\n  ): Promise<T> {\n    return runInScope(callback)\n  }\n}\n","import { WorkflowEntrypoint } from 'cloudflare:workers'\nimport type { Container } from '../di/container'\nimport type { StratalEnv } from '../env'\nimport { runInScope } from './run-in-scope'\n\n/**\n * Base class for Cloudflare Workflows with full DI access.\n *\n * Extends Cloudflare's `WorkflowEntrypoint` and provides a `runInScope()` helper\n * that creates a request-scoped DI container.\n *\n * @example\n * ```typescript\n * import { StratalWorkflow } from 'stratal/workers'\n *\n * export class MyWorkflow extends StratalWorkflow<Env, { userId: string }> {\n *   async run(event: WorkflowEvent<{ userId: string }>, step: WorkflowStep) {\n *     await this.runInScope(async (container) => {\n *       const svc = container.resolve(UserService)\n *       await svc.process(event.payload.userId)\n *     })\n *   }\n * }\n * ```\n */\nexport abstract class StratalWorkflow<\n  Env extends StratalEnv = StratalEnv,\n  Params = unknown\n> extends WorkflowEntrypoint<Env, Params> {\n  protected runInScope<T>(\n    callback: (container: Container) => T | Promise<T>\n  ): Promise<T> {\n    return runInScope(callback)\n  }\n}\n"],"mappings":";;;;;;;;;;AASA,eAAsB,WACpB,UACY;CACZ,MAAM,MAAM,MAAM,QAAQ,mBAAmB;CAC7C,MAAM,IAAI,qBAAqB;CAC/B,MAAM,UAAU,IAAI,wBAAwB,IAAI;CAChD,OAAO,IAAI,UAAU,kBAAkB,SAAS,QAAQ;AAC1D;;;;;;;;;;;;;;;;;;;;;;;;ACWA,IAAsB,uBAAtB,cAEU,cAAmB;CAC3B,MAAgB,WACd,UACY;EACZ,OAAO,WAAW,OAAO,qBAAqB;GAC5C,iBAAiB,cAAc,UAAU,oBAAoB,KAAK,GAAG;GACrE,iBAAiB,cAAc,UAAU,iBAAiB,KAAK,IAAI,EAAE;GACrE,OAAO,SAAS,gBAAgB;EAClC,CAAC;CACH;AACF;;;;;;;;;;;;;;;;;;;;;;;ACdA,IAAsB,0BAAtB,cAEU,iBAAsB;CAC9B,WACE,UACY;EACZ,OAAO,WAAW,QAAQ;CAC5B;AACF;;;;;;;;;;;;;;;;;;;;;;;ACRA,IAAsB,kBAAtB,cAGU,mBAAgC;CACxC,WACE,UACY;EACZ,OAAO,WAAW,QAAQ;CAC5B;AACF"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/workers/cached-entrypoint.ts","../../src/workers/run-in-scope.ts","../../src/workers/stratal-durable-object.ts","../../src/workers/stratal-worker-entrypoint.ts","../../src/workers/stratal-workflow.ts"],"sourcesContent":["import { WorkerEntrypoint } from 'cloudflare:workers'\nimport type { StratalEnv } from '../env'\nimport type { PurgeSpec, WorkersCache } from '../execution-context'\nimport { ResponseCacheConfigError } from '../response-cache/errors'\nimport type { Stratal } from '../stratal'\n\n/**\n * What a cached entrypoint instance exposes.\n *\n * Extends `Rpc.WorkerEntrypointBranded` because the class {@link cachedEntrypoint}\n * returns really does extend `WorkerEntrypoint`, which carries that brand — and\n * `Service<T>` only reads a class's RPC methods when the instance it constructs\n * is branded. Without it, `wrangler types` emits `Service<typeof Cached>` for a\n * binding to this entrypoint and the type silently degrades to a bare `Fetcher`\n * with no `purge`, so every consumer needs a cast to call the one method the\n * binding exists for.\n */\nexport interface CachedEntrypoint extends Rpc.WorkerEntrypointBranded {\n  fetch(request: Request): Promise<Response>\n  purge(spec: PurgeSpec): Promise<{ success: boolean } | void>\n}\n\n/**\n * The class {@link cachedEntrypoint} returns.\n *\n * Named explicitly rather than inferred: the returned class is an anonymous\n * class *expression*, and `WorkerEntrypoint`'s `ctx`/`env` are `protected`, so\n * inferring it produces a declaration TypeScript refuses to emit (TS4094).\n */\nexport type CachedEntrypointClass<Env extends StratalEnv = StratalEnv> = new (\n  ctx: ExecutionContext,\n  env: Env,\n) => CachedEntrypoint\n\n/**\n * Build the cached entrypoint that `stratal/response-cache`'s gateway forwards\n * partitioned reads to.\n *\n * ```typescript\n * // src/index.ts\n * import { Stratal } from 'stratal'\n * import { cachedEntrypoint } from 'stratal/workers'\n * import { AppModule } from './app.module'\n *\n * const stratal = new Stratal({ module: AppModule })\n *\n * export default stratal                       // gateway, cache disabled\n * export const Cached = cachedEntrypoint(stratal)  // cache enabled\n * ```\n *\n * ```jsonc\n * // wrangler.jsonc\n * {\n *   \"compatibility_date\": \"2026-07-06\",\n *   \"compatibility_flags\": [\"enable_ctx_exports\"],\n *   \"cache\": { \"enabled\": true },\n *   \"exports\": {\n *     \"default\": { \"type\": \"worker\", \"cache\": { \"enabled\": false } },\n *     \"Cached\":  { \"type\": \"worker\", \"cache\": { \"enabled\": true } },\n *   },\n * }\n * ```\n *\n * It runs the **same** `Stratal` instance, and therefore the same Hono app and\n * the same DI graph, as the default export. The only difference is that its\n * execution context is never marked by `markGatewayMode`, so the dispatch\n * middleware is a straight `next()` here — the cached entrypoint never\n * re-dispatches, and a loopback loop is structurally impossible.\n */\nexport function cachedEntrypoint<Env extends StratalEnv = StratalEnv>(\n  stratal: Stratal<Env>,\n): CachedEntrypointClass<Env> {\n  return class StratalCachedEntrypoint extends WorkerEntrypoint<Env> {\n    /**\n     * Serve the request from this entrypoint, where Workers Caching is\n     * enabled. `this.ctx` carries the `props` the gateway chose; nothing here\n     * needs to read them — being part of the cache key is their whole job.\n     */\n    async fetch(request: Request): Promise<Response> {\n      const hono = await stratal.hono\n      return hono.fetch(request, this.env, this.ctx)\n    }\n\n    /**\n     * Purge entries stored by **this** entrypoint.\n     *\n     * Called over RPC by the gateway, because purges are scoped to the\n     * entrypoint that issues them and mutations run inline in the gateway,\n     * whose cache is disabled. A purge issued there would target the gateway's\n     * own empty cache: it would report success and invalidate nothing, leaving\n     * every cached read stale until its TTL expired. See\n     * `createLoopbackPurgeTarget`, which is what routes the call here.\n     *\n     * @throws {ResponseCacheConfigError} `cache.enabled` is not set for this\n     *   entrypoint, so there is no cache to purge. Loud, because the caller is\n     *   a mutation that has already committed and is relying on this.\n     */\n    async purge(spec: PurgeSpec): Promise<{ success: boolean } | void> {\n      const cache = (this.ctx as unknown as { cache?: WorkersCache }).cache\n\n      if (!cache) {\n        throw new ResponseCacheConfigError(\n          'the cached entrypoint has no `ctx.cache`, so a purge forwarded from the gateway has ' +\n            'nothing to act on. Set `\"cache\": { \"enabled\": true }` for this entrypoint in your ' +\n            'Wrangler `exports` block, use Wrangler >= 4.69.0, and set `compatibility_date` to ' +\n            '2026-07-06 or later.',\n        )\n      }\n\n      return cache.purge(spec)\n    }\n  }\n}\n","import type { Container } from '../di/container'\nimport { Stratal } from '../stratal'\n\n/**\n * Shared helper that creates a request-scoped DI container by accessing the\n * Stratal Application via the static singleton.\n *\n * Works with Durable Objects, Workflows, and WorkerEntrypoints.\n */\nexport async function runInScope<T>(\n  callback: (container: Container) => T | Promise<T>\n): Promise<T> {\n  const app = await Stratal.resolveApplication()\n  await app.ensureScopedHandlers()\n  const mockCtx = app.createMockRouterContext('en')\n  return app.container.runInRequestScope(mockCtx, callback)\n}\n","import { DurableObject } from 'cloudflare:workers'\nimport type { Container } from '../di/container'\nimport { DI_TOKENS } from '../di/tokens'\nimport type { StratalEnv } from '../env'\nimport { runInScope } from './run-in-scope'\n\n/**\n * Base class for Durable Objects with full DI access.\n *\n * Extends Cloudflare's `DurableObject` and provides a `runInScope()` helper\n * that creates a request-scoped container with `DurableObjectState` and\n * `DurableObjectId` tokens registered.\n *\n * @example\n * ```typescript\n * import { StratalDurableObject } from 'stratal/workers'\n *\n * export class Counter extends StratalDurableObject {\n *   async increment() {\n *     return this.runInScope(async (container) => {\n *       const svc = container.resolve(CounterService)\n *       return svc.increment()\n *     })\n *   }\n * }\n * ```\n */\nexport abstract class StratalDurableObject<\n  Env extends StratalEnv = StratalEnv\n> extends DurableObject<Env> {\n  protected async runInScope<T>(\n    callback: (container: Container) => T | Promise<T>\n  ): Promise<T> {\n    return runInScope(async (requestContainer) => {\n      requestContainer.registerValue(DI_TOKENS.DurableObjectState, this.ctx)\n      requestContainer.registerValue(DI_TOKENS.DurableObjectId, this.ctx.id)\n      return callback(requestContainer)\n    })\n  }\n}\n","import { WorkerEntrypoint } from 'cloudflare:workers'\nimport type { Container } from '../di/container'\nimport type { StratalEnv } from '../env'\nimport { runInScope } from './run-in-scope'\n\n/**\n * Base class for Cloudflare WorkerEntrypoints (Service Bindings / RPC) with full DI access.\n *\n * Extends Cloudflare's `WorkerEntrypoint` and provides a `runInScope()` helper\n * that creates a request-scoped DI container.\n *\n * @example\n * ```typescript\n * import { StratalWorkerEntrypoint } from 'stratal/workers'\n *\n * export class AuthRpc extends StratalWorkerEntrypoint {\n *   async verifyToken(token: string) {\n *     return this.runInScope(async (container) => {\n *       const auth = container.resolve(AuthService)\n *       return auth.verify(token)\n *     })\n *   }\n * }\n * ```\n */\nexport abstract class StratalWorkerEntrypoint<\n  Env extends StratalEnv = StratalEnv\n> extends WorkerEntrypoint<Env> {\n  protected runInScope<T>(\n    callback: (container: Container) => T | Promise<T>\n  ): Promise<T> {\n    return runInScope(callback)\n  }\n}\n","import { WorkflowEntrypoint } from 'cloudflare:workers'\nimport type { Container } from '../di/container'\nimport type { StratalEnv } from '../env'\nimport { runInScope } from './run-in-scope'\n\n/**\n * Base class for Cloudflare Workflows with full DI access.\n *\n * Extends Cloudflare's `WorkflowEntrypoint` and provides a `runInScope()` helper\n * that creates a request-scoped DI container.\n *\n * @example\n * ```typescript\n * import { StratalWorkflow } from 'stratal/workers'\n *\n * export class MyWorkflow extends StratalWorkflow<Env, { userId: string }> {\n *   async run(event: WorkflowEvent<{ userId: string }>, step: WorkflowStep) {\n *     await this.runInScope(async (container) => {\n *       const svc = container.resolve(UserService)\n *       await svc.process(event.payload.userId)\n *     })\n *   }\n * }\n * ```\n */\nexport abstract class StratalWorkflow<\n  Env extends StratalEnv = StratalEnv,\n  Params = unknown\n> extends WorkflowEntrypoint<Env, Params> {\n  protected runInScope<T>(\n    callback: (container: Container) => T | Promise<T>\n  ): Promise<T> {\n    return runInScope(callback)\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqEA,SAAgB,iBACd,SAC4B;CAC5B,OAAO,MAAM,gCAAgC,iBAAsB;;;;;;EAMjE,MAAM,MAAM,SAAqC;GAE/C,QAAO,MADY,QAAQ,KAAA,CACf,MAAM,SAAS,KAAK,KAAK,KAAK,GAAG;EAC/C;;;;;;;;;;;;;;;EAgBA,MAAM,MAAM,MAAuD;GACjE,MAAM,QAAS,KAAK,IAA4C;GAEhE,IAAI,CAAC,OACH,MAAM,IAAI,yBACR,kRAIF;GAGF,OAAO,MAAM,MAAM,IAAI;EACzB;CACF;AACF;;;;;;;;;ACvGA,eAAsB,WACpB,UACY;CACZ,MAAM,MAAM,MAAM,QAAQ,mBAAmB;CAC7C,MAAM,IAAI,qBAAqB;CAC/B,MAAM,UAAU,IAAI,wBAAwB,IAAI;CAChD,OAAO,IAAI,UAAU,kBAAkB,SAAS,QAAQ;AAC1D;;;;;;;;;;;;;;;;;;;;;;;;ACWA,IAAsB,uBAAtB,cAEU,cAAmB;CAC3B,MAAgB,WACd,UACY;EACZ,OAAO,WAAW,OAAO,qBAAqB;GAC5C,iBAAiB,cAAc,UAAU,oBAAoB,KAAK,GAAG;GACrE,iBAAiB,cAAc,UAAU,iBAAiB,KAAK,IAAI,EAAE;GACrE,OAAO,SAAS,gBAAgB;EAClC,CAAC;CACH;AACF;;;;;;;;;;;;;;;;;;;;;;;ACdA,IAAsB,0BAAtB,cAEU,iBAAsB;CAC9B,WACE,UACY;EACZ,OAAO,WAAW,QAAQ;CAC5B;AACF;;;;;;;;;;;;;;;;;;;;;;;ACRA,IAAsB,kBAAtB,cAGU,mBAAgC;CACxC,WACE,UACY;EACZ,OAAO,WAAW,QAAQ;CAC5B;AACF"}

package/dist/{zod-wecrEVAs.d.mts → zod-BGisqLs3.d.mts}

@@ -1,9 +1,7 @@
-import { t as index_d_exports } from "./index-HgOLNruQ.mjs";
-import { OpenAPIHono, z, z as z$2 } from "@hono/zod-openapi";
-import { ZodError } from "zod";
+import { t as index_d_exports } from "./index-CAHNCpvr.mjs";
+import { ZodMiniObject as ZodObject, ZodMiniType as ZodType } from "zod/mini";
+import { $ZodError as ZodError, $ZodIssue, $ZodIssueCustom, $ZodRawIssue, GlobalMeta } from "zod/v4/core";
 import { OpenAPIObject, PathItemObject } from "openapi3-ts/oas30";
-import { $ZodIssueCustom, $ZodRawIssue } from "zod/v4/core";
-
 //#region src/i18n/validation/cuid2.d.ts
 /**
  * Default cuid2 shape: 24-32 lowercase-alphanumeric chars, starting with a
@@ -50,10 +48,10 @@ declare const CUID2_REGEX: RegExp;
  * @param options.pattern - Override the shape regex. Defaults to {@link CUID2_REGEX}.
  * @param options.error - Custom error message (string or i18n key) for the regex check.
  */
-declare function cuid2(options?: {
+declare function cuid2$1(options?: {
   pattern?: RegExp;
   error?: string | ((_issue: $ZodRawIssue) => string);
-}): z.ZodCUID2;
+}): import("zod/mini").ZodMiniCUID2;
 //#endregion
 //#region src/i18n/i18n.types.d.ts
 /**
@@ -67,7 +65,7 @@ declare function cuid2(options?: {
  * // Results in: 'auth.login.title'
  * ```
  */
-type DeepKeys<T, Prefix extends string = ''> = T extends object ? { [K in keyof T & string]: T[K] extends object ? DeepKeys<T[K], `${Prefix}${K}.`> : `${Prefix}${K}` }[keyof T & string] : never;
+type DeepKeys<T, Prefix extends string = ''> = T extends object ? { [K in keyof T & string]: T[K] extends object ? DeepKeys<T[K], `${Prefix}${K}.`> : `${Prefix}${K}`; }[keyof T & string] : never;
 /**
  * System message keys - auto-derived from system en messages
  * These are messages used by packages/modules infrastructure
@@ -102,7 +100,7 @@ interface AppMessageNamespaces {}
  * Composed app messages tree, derived from AppMessageNamespaces.
  * Each module contributes one property; the union forms the full tree.
  */
-type AppMessages = { [K in keyof AppMessageNamespaces]: AppMessageNamespaces[K] };
+type AppMessages = { [K in keyof AppMessageNamespaces]: AppMessageNamespaces[K]; };
 /**
  * Auto-derive app keys from AppMessages
  * When AppMessageNamespaces is augmented, this type automatically includes all app message keys
@@ -196,11 +194,6 @@ type ZodCustomIssue = $ZodIssueCustom & {
     [key: string]: unknown;
   };
 };
-declare namespace zod_d_exports {
-  export { CUID2_REGEX, I18nErrorMetadata, OpenAPIHono, OpenAPIObject, PathItemObject, ZodCustomIssue, ZodError, cuid2, z$2 as z };
-}
-import * as import_zod from "zod";
-import * as import__hono_zod_openapi from "@hono/zod-openapi";
 //#endregion
-export { MessageParams as _, z$2 as a, CUID2_REGEX as b, ZodCustomIssue as c, AppMessages as d, DeepKeys as f, MessageKeys as g, MessageKeyPrefix as h, ZodError as i, AppMessageKeys as l, II18nService as m, OpenAPIObject as n, zod_d_exports as o, FilterByPrefix as p, PathItemObject as r, I18nErrorMetadata as s, OpenAPIHono as t, AppMessageNamespaces as u, Prefixes as v, cuid2 as x, SystemMessageKeys as y };
-//# sourceMappingURL=zod-wecrEVAs.d.mts.map
+export { cuid2$1 as S, MessageKeys as _, ZodError as a, SystemMessageKeys as b, I18nErrorMetadata as c, AppMessageNamespaces as d, AppMessages as f, MessageKeyPrefix as g, II18nService as h, PathItemObject as i, ZodCustomIssue as l, FilterByPrefix as m, GlobalMeta as n, ZodObject as o, DeepKeys as p, OpenAPIObject as r, ZodType as s, $ZodIssue as t, AppMessageKeys as u, MessageParams as v, CUID2_REGEX as x, Prefixes as y };
+//# sourceMappingURL=zod-BGisqLs3.d.mts.map

package/dist/zod-BGisqLs3.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod-BGisqLs3.d.mts","names":[],"sources":["../src/i18n/validation/cuid2.ts","../src/i18n/i18n.types.ts","../src/i18n/validation/validation.types.ts"],"mappings":";;;;;;;;;;;;;cAWa,aAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsCR,QAAM;EAAY,UAAU;EAAQ,mBAAmB,QAAQ;uBAA0B;;;;;;;;;;;;;;KC7B7F,SAAS,GAAG,8BAA8B,sBAEjD,WAAW,aAAa,EAAE,oBACzB,SAAS,EAAE,OAAO,SAAS,WACxB,SAAS,aACR;;;;;KAOE,oBAAoB,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;UA0B/B;;;;;KAML,iBAAiB,WAAW,uBAAuB,qBAAqB;;;;;KAMxE,iBAAiB,SAAS;;;;;KAO1B,cAAc,oBAAoB;;;;;;;;;;;;;;KAelC,SAAS,oBAAoB,mBAAmB,cAAc,SACtE,UAAU,QAAQ,SAAS,UAC3B;;;;;KAMQ,eAAe,qBAAqB,yBAC9C,gBAAgB,qBAAqB,OACnC,aAAa,SAAS;;;;;;;;;;;;;;;KAiBd,mBAAmB,SAAS;;;;;KAM5B,gBAAgB;;;;UAKX;;;;;;;;EAQf,EAAE,KAAK,aAAa,SAAS;;;;;;EAO7B;;;;;;;UC3Ie;;;;EAIf,KAAK;;;;EAKL,SAAS;;;;;;KAOC,iBAAiB;EAC3B;IACE,OAAO;KACN"}

package/package.json

@@ -1,10 +1,14 @@
 {
   "name": "stratal",
-  "version": "0.0.26",
+  "version": "0.1.0",
   "description": "A modular Cloudflare Workers framework with dependency injection, queue-based events, and type-safe configuration",
   "type": "module",
+  "sideEffects": false,
   "license": "MIT",
-  "author": "Temitayo Fadojutimi",
+  "author": {
+    "name": "Temitayo Fadojutimi",
+    "url": "https://x.com/adesege_"
+  },
   "homepage": "https://stratal.dev",
   "repository": {
     "type": "git",
@@ -122,6 +126,10 @@
       "types": "./dist/rate-limiter/index.d.mts",
       "import": "./dist/rate-limiter/index.mjs"
     },
+    "./response-cache": {
+      "types": "./dist/response-cache/index.d.mts",
+      "import": "./dist/response-cache/index.mjs"
+    },
     "./router": {
       "types": "./dist/router/index.d.mts",
       "import": "./dist/router/index.mjs"
@@ -168,15 +176,15 @@
   },
   "dependencies": {
     "@hono/swagger-ui": "^0.6.1",
-    "@hono/zod-openapi": "^1.4.0",
-    "@modelcontextprotocol/sdk": "^1.29.0",
-    "@swc-node/register": "^1.11.1",
-    "@swc/core": "^1.15.40",
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "@swc-node/register": "^1.12.1",
+    "@swc/core": "^1.16.2",
     "@swc/helpers": "^0.5.23",
     "clipanion": "^4.0.0-rc.4",
-    "hono": "^4.12.23",
-    "intl-messageformat": "^11.2.7",
-    "zod": "^4.4.3"
+    "hono": "^4.13.8",
+    "intl-messageformat": "^12.1.1",
+    "openapi3-ts": "^4.6.1",
+    "zod": "^4.6.5"
   },
   "peerDependencies": {
     "@react-email/render": ">=2",
@@ -195,21 +203,21 @@
     }
   },
   "devDependencies": {
-    "@cloudflare/vitest-pool-workers": "^0.16.12",
-    "@cloudflare/workers-types": "4.20260603.1",
-    "@react-email/render": "^2.0.8",
-    "@stratal/testing": "workspace:*",
-    "@types/node": "^25.9.1",
-    "@types/react": "^19.2.16",
-    "@types/react-dom": "^19.2.3",
-    "@vitest/coverage-v8": "^4.1.8",
-    "@vitest/runner": "~4.1.8",
-    "@vitest/snapshot": "~4.1.8",
+    "@cloudflare/vitest-plugin": "^1.1.13",
+    "@cloudflare/workers-types": "5.20260919.1",
+    "@react-email/render": "^2.1.0",
+    "@stratal/testing": "0.1.0",
+    "@types/node": "^26.6.2",
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "@vitest/coverage-v8": "^4.1.11",
+    "@vitest/runner": "~4.1.11",
+    "@vitest/snapshot": "~4.1.11",
     "jsonc-parser": "^3.3.1",
-    "react": "^19.2.7",
-    "react-dom": "^19.2.7",
-    "tsdown": "^0.22.1",
-    "typescript": "^6.0.3",
-    "vitest": "~4.1.8"
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0",
+    "tsdown": "^0.23.0",
+    "typescript": "^7.0.2",
+    "vitest": "~4.1.11"
   }
-}
+}

package/dist/cache.service-uElmBtdS.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cache.service-uElmBtdS.d.mts","names":[],"sources":["../src/cache/services/cache.service.ts"],"mappings":";;;;;;AAgDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cACa,YAAA;EAAA,iBAIyC,GAAA;EAAA,iBACI,MAAA;EAAA,QAJhD,EAAA;cAG4C,GAAA,EAAK,UAAA,EACD,MAAA,EAAQ,aAAA;EA2J7D;EAAA,IArJC,SAAA,IAAa,WAAA;EAyML;;;;;;EA/LZ,WAAA,CAAY,EAAA,EAAI,WAAA,GAAc,YAAA;EAhB0B;;;;;;;;EA8BxD,OAAA,CAAQ,IAAA,WAAe,YAAA;EAdvB;;;;;;;;EAgCM,GAAA,CAAI,GAAA,UAAa,aAAA,YAAyB,qBAAA,WAAgC,OAAA;EAC1E,GAAA,0BAA6B,GAAA,UAAa,aAAA,WAAwB,qBAAA,WAAgC,OAAA,CAAQ,aAAA;EAC1G,GAAA,CAAI,GAAA,UAAa,aAAA,kBAA+B,qBAAA,kBAAuC,OAAA,CAAQ,WAAA;EAC/F,GAAA,CAAI,GAAA,UAAa,aAAA,aAA0B,qBAAA,aAAkC,OAAA,CAAQ,cAAA;EAFrF;;;;;;;;EAoCA,eAAA,qBACJ,GAAA,UACA,aAAA,YAAyB,qBAAA,WACxB,OAAA,CAAQ,gCAAA,SAAyC,QAAA;EAC9C,eAAA,8CACJ,GAAA,UACA,aAAA,WAAwB,qBAAA,WACvB,OAAA,CAAQ,gCAAA,CAAiC,aAAA,EAAe,QAAA;EACrD,eAAA,qBACJ,GAAA,UACA,aAAA,kBAA+B,qBAAA,kBAC9B,OAAA,CAAQ,gCAAA,CAAiC,WAAA,EAAa,QAAA;EACnD,eAAA,qBACJ,GAAA,UACA,aAAA,aAA0B,qBAAA,aACzB,OAAA,CAAQ,gCAAA,CAAiC,cAAA,EAAgB,QAAA;EAlDyC;;;;;;;;;;;;;;;;;;;;EAqG/F,GAAA,CACJ,GAAA,UACA,KAAA,WAAgB,WAAA,GAAc,eAAA,GAAkB,cAAA,EAChD,OAAA,GAAU,qBAAA,GACT,OAAA;EA/DA;;;;;;EAgFG,MAAA,CAAO,GAAA,WAAc,OAAA;EA7EM;;;;;;;;;;;;;;;;;;;;;;EA+G3B,IAAA,qBACJ,OAAA,GAAU,sBAAA,GACT,OAAA,CAAQ,qBAAA,CAAsB,QAAA;AAAA"}

package/dist/chunk-BBjsoOtd.mjs

@@ -1,27 +0,0 @@
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
-};
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-//#endregion
-export { __reExport as n, __exportAll as t };

package/dist/command-BvmUAPPQ.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"command-BvmUAPPQ.mjs","names":[],"sources":["../src/quarry/colors.ts","../src/quarry/constants.ts","../src/quarry/errors/command.error.ts","../src/quarry/command.ts"],"sourcesContent":["/** Minimal ANSI color helpers that respect the `NO_COLOR` convention. */\nconst isEnabled = () => typeof process !== 'undefined' ? !process.env.NO_COLOR : true\n\n/** Create an ANSI formatter that wraps text with the given open/close SGR codes. */\nconst code = (open: number, close: number) => (s: string) =>\n  isEnabled() ? `\\x1b[${open}m${s}\\x1b[${close}m` : s\n\nexport const bold = code(1, 22)\nexport const dim = code(2, 22)\nexport const cyan = code(36, 39)\nexport const green = code(32, 39)\nexport const red = code(31, 39)\nexport const yellow = code(33, 39)\nexport const dimWhite = (s: string) =>\n  isEnabled() ? `\\x1b[2;37m${s}\\x1b[22;39m` : s\n","/**\n * Symbol key for storing internal mutable state on Command instances.\n * Keeps internal state hidden from user-facing autocomplete.\n */\nexport const COMMAND_INTERNALS = Symbol.for('stratal:command:internals')\n","/**\n * User-facing command error with a plain English message.\n *\n * Quarry catches this in `call()` and puts the message into `CommandResult.errors`.\n * Does NOT extend `ApplicationError` (which requires i18n keys + error codes).\n * Not routed through ExceptionHandler.\n */\nexport class CommandError extends Error {\n  constructor(message: string) {\n    super(message)\n    this.name = 'CommandError'\n  }\n}\n","import { bold, cyan, dim, green, red, yellow } from './colors'\nimport { COMMAND_INTERNALS } from './constants'\nimport { CommandError } from './errors/command.error'\nimport type { CommandInput, CommandInternals, CommandResult } from './types'\n\n/**\n * Abstract base class for Quarry commands.\n *\n * Subclasses define a static `command` signature string and implement `handle()`.\n *\n * @example\n * ```typescript\n * export class GreetCommand extends Command {\n *   static command = 'greet {name : The name to greet} {--loud}'\n *   static description = 'Greet someone'\n *\n *   async handle(): Promise<void> {\n *     const name = this.string('name')\n *     const loud = this.boolean('loud')\n *     this.info(loud ? `HELLO, ${name.toUpperCase()}!` : `Hello, ${name}!`)\n *   }\n * }\n * ```\n */\nexport abstract class Command {\n  /**\n   * Laravel-style command signature string.\n   *\n   * **Command names:**\n   * - `'greet'` — flat command (`quarry greet`)\n   * - `'task add'` — subcommand hierarchy via spaces (`quarry task add`)\n   * - `'task:add'` — namespaced flat command via colons (`quarry task:add`)\n   *\n   * **Arguments:**\n   * - `{name}` — required argument\n   * - `{name?}` — optional argument\n   * - `{name=default}` — argument with default value\n   * - `{name*}` — array/variadic argument\n   * - `{name : description}` — argument with description\n   *\n   * **Options:**\n   * - `{--flag}` — boolean flag\n   * - `{--name=}` — option that accepts a value\n   * - `{--name=default}` — option with default value\n   * - `{--name=*}` — array option (multiple values)\n   * - `{--A|name}` — option with single-char alias\n   * - `{--name= : description}` — option with description\n   *\n   * @example\n   * ```typescript\n   * // Namespaced flat command: `quarry users:create ...`\n   * static command = 'users:create {email : The user email} {--A|admin} {--R|role= : Assign a role}'\n   *\n   * // Subcommand hierarchy: `quarry users create ...`\n   * static command = 'users create {email : The user email} {--A|admin} {--R|role= : Assign a role}'\n   * ```\n   */\n  static command: string\n  /** Human-readable description */\n  static description?: string\n  /** Alternative command names */\n  static aliases?: string[];\n\n  [COMMAND_INTERNALS]: CommandInternals\n\n  constructor() {\n    this[COMMAND_INTERNALS] = {\n      inputs: {},\n      output: [],\n      errors: [],\n      exitCode: 0,\n      quarry: null,\n    }\n  }\n\n  /**\n   * Implement this method with the command's logic.\n   * Return a number to set the exit code, or void for exit code 0.\n   */\n  // eslint-disable-next-line @typescript-eslint/no-invalid-void-type\n  abstract handle(): number | void | Promise<number | void>\n\n  // ── Input Accessors ──────────────────────────────────────────────\n\n  /**\n   * Get an input value with generic type.\n   */\n  input<T>(name: string): T {\n    return this[COMMAND_INTERNALS].inputs[name] as T\n  }\n\n  /**\n   * Get a string input. Throws CommandError if present but not a string.\n   */\n  string(name: string): string {\n    const value = this[COMMAND_INTERNALS].inputs[name]\n    if (value === undefined || value === null) {\n      return ''\n    }\n    if (typeof value !== 'string') {\n      throw new CommandError(`Input \"${name}\" expected a string, got ${typeof value}`)\n    }\n    return value\n  }\n\n  /**\n   * Get a boolean input. Throws CommandError if present but not a boolean.\n   */\n  boolean(name: string): boolean {\n    const value = this[COMMAND_INTERNALS].inputs[name]\n    if (value === undefined || value === null) {\n      return false\n    }\n    if (typeof value !== 'boolean') {\n      throw new CommandError(`Input \"${name}\" expected a boolean, got ${typeof value}`)\n    }\n    return value\n  }\n\n  /**\n   * Get a number input. Coerces strings to numbers. Throws CommandError on NaN.\n   */\n  number(name: string): number {\n    const value = this[COMMAND_INTERNALS].inputs[name]\n    if (value === undefined || value === null) {\n      return 0\n    }\n    const num = typeof value === 'string' ? Number(value) : value\n    if (typeof num !== 'number' || Number.isNaN(num)) {\n      throw new CommandError(`Input \"${name}\" expected a number, got ${typeof value}`)\n    }\n    return num\n  }\n\n  /**\n   * Get an array input. Throws CommandError if present but not an array.\n   */\n  array(name: string): string[] {\n    const value = this[COMMAND_INTERNALS].inputs[name]\n    if (value === undefined || value === null) {\n      return []\n    }\n    if (!Array.isArray(value)) {\n      throw new CommandError(`Input \"${name}\" expected an array, got ${typeof value}`)\n    }\n    return value as string[]\n  }\n\n  // ── Output Helpers ───────────────────────────────────────────────\n\n  /** Write an informational message to output */\n  info(message: string): void {\n    this[COMMAND_INTERNALS].output.push(cyan(message))\n  }\n\n  /** Write a success message to output */\n  success(message: string): void {\n    this[COMMAND_INTERNALS].output.push(`${green(bold('✔'))} ${green(message)}`)\n  }\n\n  /** Write a warning message to output */\n  warn(message: string): void {\n    this[COMMAND_INTERNALS].output.push(`${yellow(bold('⚠'))} ${yellow(message)}`)\n  }\n\n  /** Write an error message to errors */\n  error(message: string): void {\n    this[COMMAND_INTERNALS].errors.push(red(message))\n  }\n\n  /** Write a plain line to output */\n  line(message?: string): void {\n    this[COMMAND_INTERNALS].output.push(message ?? '')\n  }\n\n  /** Write an empty line to output */\n  newLine(): void {\n    this[COMMAND_INTERNALS].output.push('')\n  }\n\n  /** Write a comment-style line to output */\n  comment(message: string): void {\n    this[COMMAND_INTERNALS].output.push(dim(`// ${message}`))\n  }\n\n  /** Write a formatted table to output */\n  table(headers: string[], rows: string[][]): void {\n    const colWidths = headers.map((h, i) => {\n      const maxRow = rows.reduce((max, row) => Math.max(max, (row[i] ?? '').length), 0)\n      return Math.max(h.length, maxRow)\n    })\n\n    const formatRow = (cells: string[]) =>\n      cells.map((cell, i) => cell.padEnd(colWidths[i])).join('  ')\n\n    this[COMMAND_INTERNALS].output.push(bold(formatRow(headers)))\n    this[COMMAND_INTERNALS].output.push(dim(colWidths.map((w) => '-'.repeat(w)).join('  ')))\n    for (const row of rows) {\n      this[COMMAND_INTERNALS].output.push(formatRow(row))\n    }\n  }\n\n  /** Write an error message and set exit code */\n  fail(message: string, exitCode = 1): void {\n    this[COMMAND_INTERNALS].errors.push(`${red(bold('✖'))} ${red(message)}`)\n    this[COMMAND_INTERNALS].exitCode = exitCode\n  }\n\n  // ── Command Calling ──────────────────────────────────────────────\n\n  /**\n   * Call another command from within this command.\n   * Delegates to Quarry.call() via internal reference.\n   */\n  async call(name: string, input?: CommandInput): Promise<CommandResult> {\n    const internals = this[COMMAND_INTERNALS]\n    if (!internals.quarry) {\n      throw new CommandError('Cannot call commands: Quarry reference not set')\n    }\n    const result = await internals.quarry.call(name, input)\n\n    // Forward child output/errors into parent (like Clipanion context switches)\n    internals.output.push(...result.output)\n    internals.errors.push(...result.errors)\n\n    return result\n  }\n}\n"],"mappings":"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"}

package/dist/command-DoBD2Cwl.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"command-DoBD2Cwl.d.mts","names":[],"sources":["../src/quarry/constants.ts","../src/quarry/command.ts"],"mappings":";;;;;;AAIA;cAAa,iBAAA;;;;AAAb;;;;AAAwE;;;;ACoBxE;;;;;;;;;;uBAAsB,OAAA;EA8LmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAA,OA7JhD,OAAA;EA4HC;EAAA,OA1HD,WAAA;EA+HD;EAAA,OA7HC,OAAA;EAAA,CAEN,iBAAA,GAAoB,gBAAA;;EA4IC;;;;EAAA,SA3Hb,MAAA,oBAA0B,OAAA;EAsIa;;;EA/HhD,KAAA,IAAS,IAAA,WAAe,CAAA;;;;EAOxB,MAAA,CAAO,IAAA;;;;EAcP,OAAA,CAAQ,IAAA;;;;EAcR,MAAA,CAAO,IAAA;;;;EAeP,KAAA,CAAM,IAAA;;EAcN,IAAA,CAAK,OAAA;;EAKL,OAAA,CAAQ,OAAA;;EAKR,IAAA,CAAK,OAAA;;EAKL,KAAA,CAAM,OAAA;;EAKN,IAAA,CAAK,OAAA;;EAKL,OAAA;;EAKA,OAAA,CAAQ,OAAA;;EAKR,KAAA,CAAM,OAAA,YAAmB,IAAA;;EAiBzB,IAAA,CAAK,OAAA,UAAiB,QAAA;;;;;EAWhB,IAAA,CAAK,IAAA,UAAc,KAAA,GAAQ,YAAA,GAAe,OAAA,CAAQ,aAAA;AAAA"}

package/dist/consumer-registry-D3iMTSdy.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"consumer-registry-D3iMTSdy.d.mts","names":[],"sources":["../src/queue/queue-binding.ts","../src/queue/queue-consumer.ts","../src/queue/consumer-registry.ts"],"mappings":";;;;;;;KAwBK,mBAAA,GAAsB,OAAA,eACX,UAAA,GAAa,UAAA,CAAW,CAAA,UAAW,KAAA,GAAQ,CAAA,iBAAkB,UAAA;AAAU;AAWvF;;;;AAEuB;;AAbgE,KAW3E,YAAA,IAAgB,mBAAA,6BAExB,mBAAmB;;;;;;AAnBiB;;;UCXvB,YAAA;EDiBY;ECf3B,EAAA;EDeiD;ECbjD,IAAA;EDa2E;ECX3E,OAAA,EAAS,CAAA;EDUuB;ECRhC,QAAA;IACE,MAAA;IACA,cAAA;IDOY;;;;;;ICAZ,OAAA,GAAU,YAAY;IAAA,CACrB,GAAA;EAAA;AAAA;;;ADYkB;;;;AC9BvB;;;;;;;;;;;;UAwCiB,cAAA;EAvBH;;;AACE;AAsBhB;;EAvBc,SA8BH,YAAA;EAOoB;;;;;EAA7B,MAAA,CAAO,OAAA,EAAS,YAAA,CAAa,CAAA,IAAK,OAAA;EAQgB;;;;;;EAAlD,OAAA,EAAS,KAAA,EAAO,KAAA,EAAO,OAAA,EAAS,YAAA,CAAa,CAAA,IAAK,OAAA;AAAA;;;;UChEnC,oBAAA;EACf,aAAA,EAAe,WAAW,CAAC,cAAA;EAC3B,YAAA;AAAA;;;;;;;;;;;;;;;;;;;AFiBqF;AAWvF;;;;AAEuB;;;;AC9BvB;;;;cCmCa,gBAAA;EDjCX;EAAA,QCmCQ,aAAA;ED/BR;EAAA,QCkCQ,aAAA;EDhCR;EAAA,QCmCQ,iBAAA;EDjCN;;;;;AAQY;AAsBhB;;;;;ECgBE,QAAA,CAAS,aAAA,EAAe,WAAA,CAAY,cAAA,GAAiB,YAAA;EDMrC;;;;;;;;;;ECmBhB,kBAAA,CAAmB,WAAA,WAAsB,WAAA,CAAY,cAAA;ED3B9C;;;;;;ECyCP,YAAA,CAAa,WAAA;EDjCU;;;AAAkC;;EC0CzD,eAAA;;AA1GF;;EAiHE,gBAAA,aAA6B,oBAAA;AAAA"}

package/dist/container-storage-BmOJ4_Na.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"container-storage-BmOJ4_Na.mjs","names":[],"sources":["../src/errors/application-error.ts","../src/errors/container-not-initialized.error.ts","../src/di/container-storage.ts"],"sourcesContent":["export class ApplicationError extends Error {\n  public readonly timestamp: string\n\n  constructor(message?: string, cause?: unknown) {\n    super(message ?? 'Internal Server Error', cause !== undefined ? { cause } : undefined)\n\n    Object.setPrototypeOf(this, new.target.prototype)\n\n    this.name = this.constructor.name\n    this.timestamp = new Date().toISOString()\n\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- captureStackTrace is V8-specific, not always present\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, this.constructor)\n    }\n  }\n}\n","import { ApplicationError } from './application-error'\n\nexport class ContainerNotInitializedError extends ApplicationError {\n  constructor() {\n    super('Application container has not been initialized')\n  }\n}\n","import { AsyncLocalStorage } from 'node:async_hooks'\nimport { ContainerNotInitializedError } from '../errors/container-not-initialized.error'\nimport type { Container } from './container'\n\n/**\n * AsyncLocalStorage for the application container.\n *\n * Set by `Application.initialize()` — all code from that point onward\n * (Stratal handlers, TestingModuleBuilder, standalone functions like `route()`)\n * can access the container without DI or static singletons.\n */\nexport const containerStorage = new AsyncLocalStorage<Container>()\n\n/**\n * Get the application container from AsyncLocalStorage.\n *\n * @throws ContainerNotInitializedError if called outside `Application.initialize()` scope\n */\nexport function getContainer(): Container {\n  const container = containerStorage.getStore()\n  if (!container) {\n    throw new ContainerNotInitializedError()\n  }\n  return container\n}\n\n/**\n * Run a function within a container context.\n *\n * @param container - The application container to store\n * @param fn - The function to execute with container access\n */\nexport function runWithContainer<T>(container: Container, fn: () => T): T {\n  return containerStorage.run(container, fn)\n}\n"],"mappings":";;AAAA,IAAa,mBAAb,cAAsC,MAAM;CAC1C;CAEA,YAAY,SAAkB,OAAiB;EAC7C,MAAM,WAAW,yBAAyB,UAAU,KAAA,IAAY,EAAE,MAAM,IAAI,KAAA,CAAS;EAErF,OAAO,eAAe,MAAM,IAAI,OAAO,SAAS;EAEhD,KAAK,OAAO,KAAK,YAAY;EAC7B,KAAK,6BAAY,IAAI,KAAK,GAAE,YAAY;EAGxC,IAAI,MAAM,mBACR,MAAM,kBAAkB,MAAM,KAAK,WAAW;CAElD;AACF;;;ACdA,IAAa,+BAAb,cAAkD,iBAAiB;CACjE,cAAc;EACZ,MAAM,gDAAgD;CACxD;AACF;;;;;;;;;;ACKA,MAAa,mBAAmB,IAAI,kBAA6B;;;;;;AAOjE,SAAgB,eAA0B;CACxC,MAAM,YAAY,iBAAiB,SAAS;CAC5C,IAAI,CAAC,WACH,MAAM,IAAI,6BAA6B;CAEzC,OAAO;AACT;;;;;;;AAQA,SAAgB,iBAAoB,WAAsB,IAAgB;CACxE,OAAO,iBAAiB,IAAI,WAAW,EAAE;AAC3C"}

package/dist/controller.decorator-YSTPQntu.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"controller.decorator-YSTPQntu.mjs","names":[],"sources":["../src/router/decorators/controller.decorator.ts"],"sourcesContent":["import { Transient } from '../../di/decorators'\nimport { defineMetadata, getMetadata } from '../../di/metadata'\nimport { type Constructor } from '../../types'\nimport { ROUTE_METADATA_KEYS } from '../constants'\nimport { type ControllerOptions } from '../types'\n\nconst CONTROLLER_ROUTE_KEY = ROUTE_METADATA_KEYS.CONTROLLER_ROUTE\n\n/**\n * Base controller decorator for route registration\n *\n * This is the core controller decorator that handles:\n * - Transient scope registration (request-scoped)\n * - Route metadata storage\n * - Controller options (tags, security schemes, hideFromDocs)\n *\n * @param route - Base route for this controller (e.g., '/api/v1/users')\n * @param options - Optional configuration (tags, security schemes, hideFromDocs)\n *\n * @example\n * ```typescript\n * import { Controller } from 'stratal/router'\n *\n * @Controller('/api/v1/users', { tags: ['Users'] })\n * export class UsersController implements IController {\n *   // All routes accessible\n * }\n * ```\n */\nexport function Controller(route: string, options?: ControllerOptions) {\n  return function <T extends Constructor>(target: T) {\n    // Wrap @Transient (handles @injectable and scope metadata)\n    Transient()(target)\n\n    // Store route metadata on the class\n    defineMetadata(CONTROLLER_ROUTE_KEY, route, target)\n\n    // Store options metadata if provided\n    if (options) {\n      defineMetadata(ROUTE_METADATA_KEYS.CONTROLLER_OPTIONS, options, target)\n    }\n\n    return target\n  }\n}\n\n/**\n * Get the route from controller class metadata\n *\n * @param target - Controller class or instance\n * @returns Route string or undefined if not set\n */\nexport function getControllerRoute(target: object): string | undefined {\n  // Check if target is a class constructor (function) or an instance\n  // If class, get metadata from it directly; if instance, get from constructor\n  const metadataTarget = typeof target === 'function' ? target : (target as { constructor: object }).constructor\n  return getMetadata<string>(CONTROLLER_ROUTE_KEY, metadataTarget)\n}\n\n/**\n * Get the options from controller class metadata\n *\n * @param target - Controller class or instance\n * @returns Controller options or undefined if not set\n */\nexport function getControllerOptions(target: object): ControllerOptions | undefined {\n  const metadataTarget = typeof target === 'function' ? target : (target as { constructor: object }).constructor\n  return getMetadata<ControllerOptions>(ROUTE_METADATA_KEYS.CONTROLLER_OPTIONS, metadataTarget)\n}\n\n/**\n * Get the version from controller class metadata\n *\n * @param target - Controller class or instance\n * @returns Version string, array, VERSION_NEUTRAL symbol, or undefined if not set\n */\nexport function getControllerVersion(target: object): ControllerOptions['version'] {\n  const options = getControllerOptions(target)\n  return options?.version\n}\n"],"mappings":";;;;AAMA,MAAM,uBAAuB,oBAAoB;;;;;;;;;;;;;;;;;;;;;;AAuBjD,SAAgB,WAAW,OAAe,SAA6B;CACrE,OAAO,SAAiC,QAAW;EAEjD,UAAU,EAAE,MAAM;EAGlB,eAAe,sBAAsB,OAAO,MAAM;EAGlD,IAAI,SACF,eAAe,oBAAoB,oBAAoB,SAAS,MAAM;EAGxE,OAAO;CACT;AACF;;;;;;;AAQA,SAAgB,mBAAmB,QAAoC;CAIrE,OAAO,YAAoB,sBADJ,OAAO,WAAW,aAAa,SAAU,OAAmC,WACpC;AACjE;;;;;;;AAQA,SAAgB,qBAAqB,QAA+C;CAClF,MAAM,iBAAiB,OAAO,WAAW,aAAa,SAAU,OAAmC;CACnG,OAAO,YAA+B,oBAAoB,oBAAoB,cAAc;AAC9F;;;;;;;AAQA,SAAgB,qBAAqB,QAA8C;CAEjF,OADgB,qBAAqB,MACxB,GAAG;AAClB"}

package/dist/cron-job-NesZRk8F.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cron-job-NesZRk8F.d.mts","names":[],"sources":["../src/cron/cron-job.ts"],"mappings":";;;;;AA8BA;;;;;;;;;AAI8B;AAG9B;;;;;;;;;;;;;;;;UAPiB,aAAA;EAwBmB;EAtBnC,QAAA;EAsByD;EApBzD,QAAA,EAAU,WAAW,CAAC,OAAA;AAAA;AAAA,UAGN,OAAA;;;;;;;EAOhB,OAAA,CAAQ,UAAA,EAAY,mBAAA,GAAsB,OAAA;;;;;;;;;EAU1C,OAAA,EAAS,KAAA,EAAO,KAAA,EAAO,UAAA,EAAY,mBAAA,GAAsB,OAAA;AAAA"}

package/dist/di-D7qmrAir.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"di-D7qmrAir.mjs","names":["g"],"sources":["../src/router/router.tokens.ts","../src/di/container.error.ts","../src/di/conditional-binding-builder.ts","../src/di/types.ts","../src/di/decorators/inject-param.decorator.ts","../src/di/decorators/inject.decorator.ts","../src/di/decorators.ts","../src/di/disposable.ts","../src/di/lazy.ts","../src/di/tokens.ts","../src/di/container.ts"],"sourcesContent":["/**\n * Dependency injection tokens for the router system\n */\nexport const ROUTER_TOKENS = {\n  /**\n   * Token for RouterContext (request-scoped)\n   * Contains Hono context wrapper with helper methods\n   */\n  RouterContext: Symbol.for('stratal:router:context'),\n\n  /**\n   * Token for RouteRegistry (singleton)\n   * Central registry of all application routes — source of truth for route:list, route:types, URL generation\n   */\n  RouteRegistry: Symbol.for('stratal:router:route-registry'),\n\n  /**\n   * Token for VersioningService (singleton)\n   * Resolves version prefixes for route paths\n   */\n  VersioningService: Symbol.for('stratal:router:versioning-service'),\n\n  /**\n   * Token for LocalePathService (singleton)\n   * Resolves locale path variants and computes LocalePathConfig\n   */\n  LocalePathService: Symbol.for('stratal:router:locale-path-service'),\n\n  /**\n   * Token for LocaleUrlService (singleton)\n   * Ergonomic wrapper around the pure locale-url helpers — applies, strips,\n   * and tests locale prefixes against the resolved LocalePathService config.\n   */\n  LocaleUrlService: Symbol.for('stratal:router:locale-url-service'),\n\n  /**\n   * Token for RouterResolver (singleton, may be null)\n   * Internal resolver that computes effective Router config per controller\n   */\n  RouterResolver: Symbol.for('stratal:router:router-resolver'),\n\n  /**\n   * Token for HonoApp (singleton)\n   * The Hono application instance with Stratal-specific setup\n   */\n  HonoApp: Symbol.for('stratal:router:hono-app'),\n\n  /**\n   * Token for Uri (request-scoped)\n   * URL generation service — route URLs, signed URLs, current/previous URL access\n   */\n  Uri: Symbol.for('stratal:router:uri'),\n} as const\n","import { ApplicationError } from '../errors/application-error';\n\nexport class ContainerError extends ApplicationError {\n}\n","import type { Container } from './container'\nimport { ContainerError } from './container.error'\nimport type { InjectionToken, WhenOptions } from './types'\nimport type { Constructor } from '../types'\n\nexport interface PredicateContainer {\n  resolve<T>(token: InjectionToken<T>): T\n  isRegistered<T>(token: InjectionToken<T>): boolean\n}\n\nexport interface ConditionalBindingBuilder {\n  use<T extends object>(token: InjectionToken<T>): ConditionalBindingUse<T>\n}\n\nexport interface ConditionalBindingUse<T extends object> {\n  give(implementation: Constructor<T>): ConditionalBindingGive<T>\n}\n\nexport interface ConditionalBindingGive<T extends object> {\n  otherwise(implementation: Constructor<T>): void\n}\n\nexport class ConditionalBindingBuilderImpl implements ConditionalBindingBuilder {\n  constructor(\n    private readonly container: Container,\n    private readonly predicate: (container: PredicateContainer) => boolean,\n    private readonly options: WhenOptions,\n  ) {}\n\n  use<T extends object>(token: InjectionToken<T>): ConditionalBindingUse<T> {\n    return new ConditionalBindingUseImpl<T>(\n      this.container,\n      this.predicate,\n      this.options,\n      token,\n    )\n  }\n}\n\nclass ConditionalBindingUseImpl<T extends object> implements ConditionalBindingUse<T> {\n  constructor(\n    private readonly container: Container,\n    private readonly predicate: (container: PredicateContainer) => boolean,\n    private readonly options: WhenOptions,\n    private readonly token: InjectionToken<T>,\n  ) {}\n\n  give(trueImpl: Constructor<T>): ConditionalBindingGive<T> {\n    this.registerConditional(trueImpl, undefined)\n\n    return {\n      otherwise: (falseImpl: Constructor<T>) => {\n        this.registerConditional(trueImpl, falseImpl)\n      },\n    }\n  }\n\n  private registerConditional(trueImpl: Constructor<T>, falseImpl: Constructor<T> | undefined): void {\n    const { predicate, container, options, token } = this\n    let cachedResult: boolean | undefined\n\n    // Register both implementations so the container can instantiate them\n    container.register(trueImpl)\n    if (falseImpl) container.register(falseImpl)\n\n    container.registerFactory(token, (c) => {\n      let result: boolean\n      if (options.cache && cachedResult !== undefined) {\n        result = cachedResult\n      } else {\n        result = predicate(c)\n        if (options.cache) cachedResult = result\n      }\n\n      if (result) {\n        return c.resolve(trueImpl as unknown as InjectionToken<T>)\n      }\n\n      if (falseImpl) {\n        return c.resolve(falseImpl as unknown as InjectionToken<T>)\n      }\n\n      const tokenStr = typeof token === 'symbol'\n        ? (token.description ?? 'unknown')\n        : typeof token === 'function'\n          ? token.name\n          : typeof token === 'string'\n            ? token\n            : 'lazy'\n      throw new ContainerError(`No fallback registered for conditional binding \"${tokenStr}\". Use .otherwise() or register a default implementation.`)\n    })\n  }\n}\n","import type { Constructor } from '../types'\nimport type { LazyToken } from './lazy'\n\nexport type InjectionToken<T = unknown> = Constructor<T> | string | symbol | LazyToken<T>\n\nexport enum Scope {\n  Transient = 0,\n  Singleton = 1,\n  Request = 2,\n}\n\nexport interface WhenOptions {\n  cache?: boolean\n}\n\nexport type ExtensionDecorator<T> = (service: T, container: ContainerLike) => T\n\nexport interface ContainerLike {\n  resolve<T>(token: InjectionToken<T>): T\n  /**\n   * Resolves an optional dependency: `undefined` when nothing is registered,\n   * or when a request-scoped provider is requested outside a request scope.\n   */\n  tryResolve<T>(token: InjectionToken<T>): T | undefined\n}\n","import type { InjectionToken } from '../types'\nimport { defineMetadata, getMetadata } from '../metadata'\n\nexport const INJECT_PARAM_METADATA_KEY = Symbol.for('stratal:inject:param')\n\nexport interface ParamInjection {\n  index: number\n  token: InjectionToken\n}\n\nexport function InjectParam<T>(token: InjectionToken<T>): ParameterDecorator {\n  return (target: object, propertyKey: string | symbol | undefined, parameterIndex: number) => {\n    if (propertyKey === undefined) {\n      throw new Error('@InjectParam can only be used on method parameters, not constructor parameters')\n    }\n\n    const existing = getMetadata<ParamInjection[]>(INJECT_PARAM_METADATA_KEY, target, propertyKey) ?? []\n    existing.push({ index: parameterIndex, token })\n    defineMetadata(INJECT_PARAM_METADATA_KEY, existing, target, propertyKey)\n  }\n}\n\nexport function getMethodInjections(target: object, propertyKey: string | symbol): ParamInjection[] {\n  const injections = getMetadata<ParamInjection[]>(INJECT_PARAM_METADATA_KEY, target, propertyKey) ?? []\n  return injections.sort((a, b) => a.index - b.index)\n}\n","import type { InjectionToken } from '../types'\n\ninterface InjectionEntry {\n  token: InjectionToken\n  optional: boolean\n}\n\nconst INJECTION_TOKENS_KEY = Symbol.for('stratal:di:injection-tokens')\nconst g = globalThis as Record<symbol, unknown>\nconst INJECTION_TOKENS: WeakMap<object, Map<number, InjectionEntry>> =\n  (g[INJECTION_TOKENS_KEY] as WeakMap<object, Map<number, InjectionEntry>>) ??\n  (g[INJECTION_TOKENS_KEY] = new WeakMap<object, Map<number, InjectionEntry>>())\n\nexport function inject<T>(\n  token: InjectionToken<T>,\n  options?: { isOptional?: boolean },\n): ParameterDecorator {\n  return (target: object, _propertyKey: string | symbol | undefined, parameterIndex: number) => {\n    let params = INJECTION_TOKENS.get(target)\n    if (!params) {\n      params = new Map()\n      INJECTION_TOKENS.set(target, params)\n    }\n    params.set(parameterIndex, { token, optional: options?.isOptional ?? false })\n  }\n}\n\nexport function getInjectionTokens(target: object): Map<number, InjectionEntry> {\n  const direct = INJECTION_TOKENS.get(target)\n  if (direct && direct.size > 0) return direct\n\n  let proto = Object.getPrototypeOf(target) as object | null\n  while (proto !== null && proto !== Function.prototype) {\n    const inherited = INJECTION_TOKENS.get(proto)\n    if (inherited && inherited.size > 0) return inherited\n    proto = Object.getPrototypeOf(proto) as object | null\n  }\n\n  return new Map<number, InjectionEntry>()\n}\n","import type { InjectionToken } from './types'\nimport { Scope } from './types'\n\nexport {\n  InjectParam,\n  getMethodInjections,\n  type ParamInjection,\n  INJECT_PARAM_METADATA_KEY,\n} from './decorators/inject-param.decorator'\n\nexport { inject, getInjectionTokens } from './decorators/inject.decorator'\n\ninterface ClassMetadata {\n  scope: Scope\n  token?: InjectionToken\n}\n\nconst CLASS_METADATA_KEY = Symbol.for('stratal:di:class-metadata')\nconst g = globalThis as Record<symbol, unknown>\nconst CLASS_METADATA: WeakMap<object, ClassMetadata> =\n  (g[CLASS_METADATA_KEY] as WeakMap<object, ClassMetadata>) ??\n  (g[CLASS_METADATA_KEY] = new WeakMap<object, ClassMetadata>())\n\nfunction scopeDecorator(scope: Scope) {\n  return <T>(token?: InjectionToken<T>) =>\n    <TFunction extends abstract new (...args: never[]) => unknown>(target: TFunction): TFunction => {\n      CLASS_METADATA.set(target, { scope, token })\n      return target\n    }\n}\n\nexport const Singleton = scopeDecorator(Scope.Singleton)\nexport const Request = scopeDecorator(Scope.Request)\nexport const Transient = scopeDecorator(Scope.Transient)\n\nexport function getClassMetadata(target: object): ClassMetadata | undefined {\n  const direct = CLASS_METADATA.get(target)\n  if (direct) return direct\n\n  let proto = Object.getPrototypeOf(target) as object | null\n  while (proto !== null && proto !== Function.prototype) {\n    const inherited = CLASS_METADATA.get(proto)\n    if (inherited) return inherited\n    proto = Object.getPrototypeOf(proto) as object | null\n  }\n\n  return undefined\n}\n","/**\n * Disposal contract for container-managed instances.\n *\n * Singletons (and request-cached instances) that hold live resources —\n * timers, sockets, connection pools, event subscriptions — implement one of\n * these hooks so {@link Container.dispose} can release them on shutdown\n * (e.g. when a Vite HMR reload replaces the running Application).\n *\n * Precedence when multiple hooks are present: `Symbol.asyncDispose`,\n * then `Symbol.dispose`, then `dispose()`.\n */\nexport interface Disposable {\n  dispose?(): void | Promise<void>\n  [Symbol.dispose]?(): void\n  [Symbol.asyncDispose]?(): PromiseLike<void>\n}\n\nexport function isDisposable(instance: unknown): instance is Disposable {\n  if (typeof instance !== 'object' || instance === null) return false\n  const candidate = instance as Disposable\n  return typeof candidate[Symbol.asyncDispose] === 'function'\n    || typeof candidate[Symbol.dispose] === 'function'\n    || typeof candidate.dispose === 'function'\n}\n\n/** Invoke the instance's dispose hook, preferring async > sync > method form. */\nexport async function disposeInstance(instance: Disposable): Promise<void> {\n  const asyncDispose = instance[Symbol.asyncDispose]\n  if (typeof asyncDispose === 'function') {\n    await asyncDispose.call(instance)\n    return\n  }\n  const syncDispose = instance[Symbol.dispose]\n  if (typeof syncDispose === 'function') {\n    syncDispose.call(instance)\n    return\n  }\n  await instance.dispose?.()\n}\n","import type { Constructor } from '../types'\n\nconst LAZY_MARKER = Symbol.for('stratal:lazy')\n\nexport interface LazyToken<T = unknown> {\n  [LAZY_MARKER]: true\n  factory: () => Constructor<T>\n}\n\nexport function lazy<T>(factory: () => Constructor<T>): LazyToken<T> {\n  return { [LAZY_MARKER]: true, factory } as LazyToken<T>\n}\n\nexport function isLazyToken(value: unknown): value is LazyToken {\n  return typeof value === 'object' && value !== null && LAZY_MARKER in value\n}\n","/**\n * Token for the Container instance\n * Used for injecting the Container into services that need dynamic resolution\n */\nexport const CONTAINER_TOKEN = Symbol.for('stratal:di:container')\n\nexport const DI_TOKENS = {\n  // Cloudflare\n  CloudflareEnv: Symbol.for('stratal:cloudflare:env'),\n  ExecutionContext: Symbol.for('stratal:execution:context'),\n\n  // Infrastructure\n  Container: CONTAINER_TOKEN,\n  Application: Symbol.for('stratal:application'),\n  ModuleRegistry: Symbol.for('stratal:module:registry'),\n  LazyModuleLoader: Symbol.for('stratal:lazy-module-loader'),\n  ExceptionHandler: Symbol.for('stratal:exception:handler'),\n  Database: Symbol.for('stratal:database:service'),\n  Queue: Symbol.for('stratal:queue:manager'),\n  ConsumerRegistry: Symbol.for('stratal:consumer:registry'),\n  Cron: Symbol.for('stratal:cron:manager'),\n  EventRegistry: Symbol.for('stratal:event:registry'),\n  Quarry: Symbol.for('stratal:quarry'),\n\n  // Context\n  /**\n   * AuthContext: Use for services that need user authentication (userId).\n   */\n  AuthContext: Symbol.for('stratal:auth:context'),\n\n  // Workers\n  DurableObjectState: Symbol.for('stratal:durable:object:state'),\n  DurableObjectId: Symbol.for('stratal:durable:object:id'),\n} as const\n\nexport type DIToken = typeof DI_TOKENS[keyof typeof DI_TOKENS]\n","import type { RouterContext } from '../router/router-context';\nimport { ROUTER_TOKENS } from '../router/router.tokens';\nimport type { Constructor } from '../types';\nimport { ConditionalBindingBuilderImpl, type ConditionalBindingBuilder, type PredicateContainer } from './conditional-binding-builder';\nimport { containerStorage } from './container-storage';\nimport { ContainerError } from './container.error';\nimport { getClassMetadata } from './decorators';\nimport { getInjectionTokens } from './decorators/inject.decorator';\nimport { disposeInstance, isDisposable } from './disposable';\nimport { isLazyToken, type LazyToken } from './lazy';\nimport { CONTAINER_TOKEN } from './tokens';\nimport { Scope, type ExtensionDecorator, type InjectionToken, type WhenOptions } from './types';\n\ninterface ClassRegistration {\n  kind: 'class'\n  useClass: Constructor\n  scope: Scope\n}\n\ninterface LazyClassRegistration {\n  kind: 'lazy'\n  factory: () => Constructor\n}\n\ninterface ValueRegistration {\n  kind: 'value'\n  value: unknown\n}\n\ninterface FactoryRegistration {\n  kind: 'factory'\n  factory: (container: Container) => unknown\n}\n\ninterface AliasRegistration {\n  kind: 'alias'\n  target: InjectionToken\n}\n\ntype Registration = ClassRegistration | LazyClassRegistration | ValueRegistration | FactoryRegistration | AliasRegistration\n\nfunction tokenToString(token: InjectionToken): string {\n  if (typeof token === 'symbol') return token.description ?? 'Symbol'\n  if (typeof token === 'function') return token.name\n  if (typeof token === 'object' && token !== null && 'factory' in token) return '(lazy)'\n  return String(token)\n}\n\nexport interface ContainerOptions {\n  parent?: Container\n  isRequestScoped?: boolean\n}\n\nexport class Container {\n  private readonly registrations = new Map<InjectionToken, Registration>()\n  private readonly singletons = new Map<InjectionToken, unknown>()\n  private readonly requestCache = new Map<InjectionToken, unknown>()\n  private readonly requestCacheDeps = new Map<InjectionToken, Set<InjectionToken>>()\n  /**\n   * Classes currently being constructed, held on the root so it spans the\n   * global ↔ request-scope boundary. Used to turn an otherwise-opaque stack\n   * overflow on a circular dependency into a clear error naming the cycle.\n   */\n  private readonly resolutionStack: Constructor[] = []\n  private readonly parent: Container | null\n  private readonly isRequestScoped: boolean\n\n  constructor(options: ContainerOptions = {}) {\n    this.parent = options.parent ?? null\n    this.isRequestScoped = options.isRequestScoped ?? false\n\n    if (!this.isRequestScoped) {\n      this.registrations.set(CONTAINER_TOKEN, { kind: 'value', value: this })\n    }\n  }\n\n  // ── Registration ──────────────────────────────────────────────\n\n  register<T extends object>(serviceClass: Constructor<T>): void\n  register<T extends object>(token: InjectionToken<T>, serviceClassOrLazy: Constructor<T> | LazyToken<T>): void\n  register<T extends object>(\n    tokenOrClass: InjectionToken<T> | Constructor<T>,\n    serviceClassOrLazy?: Constructor<T> | LazyToken<T>,\n  ): void {\n    if (serviceClassOrLazy !== undefined && isLazyToken(serviceClassOrLazy)) {\n      const lazyToken = serviceClassOrLazy\n      this.registrations.set(tokenOrClass, {\n        kind: 'lazy',\n        factory: lazyToken.factory,\n      })\n      return\n    }\n\n    let token: InjectionToken<T>\n    let impl: Constructor<T>\n\n    if (serviceClassOrLazy !== undefined) {\n      token = tokenOrClass\n      impl = serviceClassOrLazy\n    } else {\n      token = tokenOrClass as Constructor<T>\n      impl = tokenOrClass as Constructor<T>\n    }\n\n    const meta = getClassMetadata(impl)\n    const scope = meta?.scope ?? Scope.Transient\n    const effectiveToken = (serviceClassOrLazy === undefined && meta?.token) ? meta.token : token\n\n    this.registrations.set(effectiveToken, { kind: 'class', useClass: impl, scope })\n  }\n\n  registerSingleton<T extends object>(serviceClass: Constructor<T>): void\n  registerSingleton<T extends object>(token: InjectionToken<T>, serviceClass: Constructor<T>): void\n  registerSingleton<T extends object>(\n    tokenOrClass: InjectionToken<T> | Constructor<T>,\n    serviceClass?: Constructor<T>,\n  ): void {\n    const impl = serviceClass ?? tokenOrClass as Constructor<T>\n    const meta = getClassMetadata(impl)\n    const token = serviceClass !== undefined\n      ? tokenOrClass\n      : (meta?.token ?? tokenOrClass as Constructor<T>)\n    this.registrations.set(token, { kind: 'class', useClass: impl, scope: Scope.Singleton })\n  }\n\n  registerValue<T>(token: InjectionToken<T>, value: T): void {\n    this.registrations.set(token, { kind: 'value', value })\n    if (this.isRequestScoped) {\n      this.invalidateRequestCache(token)\n    }\n  }\n\n  registerFactory<T>(token: InjectionToken<T>, factory: (container: Container) => T): void {\n    this.registrations.set(token, { kind: 'factory', factory })\n  }\n\n  registerExisting<T>(alias: InjectionToken<T>, target: InjectionToken<T>): void {\n    this.registrations.set(alias, { kind: 'alias', target })\n  }\n\n  // ── Resolution ────────────────────────────────────────────────\n\n  resolve<T>(token: InjectionToken<T>): T {\n    if (isLazyToken(token)) {\n      const realToken = token.factory() as InjectionToken<T>\n      return this.resolve(realToken)\n    }\n\n    // Check request cache (request-scoped containers)\n    if (this.isRequestScoped && this.requestCache.has(token)) {\n      return this.requestCache.get(token) as T\n    }\n\n    // Check local registrations first\n    const reg = this.registrations.get(token)\n    if (reg) return this.resolveRegistration(token, reg) as T\n\n    // Check parent chain — request-scoped containers resolve locally to access request values\n    if (this.parent) {\n      const parentReg = this.parent.findRegistration(token)\n      if (parentReg) {\n        if (this.isRequestScoped) {\n          return this.resolveRegistration(token, parentReg) as T\n        }\n        return this.parent.resolve(token)\n      }\n    }\n\n    // Auto-resolve class constructors: any class with DI decorators can be\n    // instantiated without explicit registration\n    if (typeof token === 'function') {\n      const meta = getClassMetadata(token)\n      const scope = meta?.scope ?? Scope.Transient\n      const classReg: ClassRegistration = { kind: 'class', useClass: token as unknown as Constructor, scope }\n      this.getRoot().registrations.set(token, classReg)\n      return this.resolveClass(token, classReg) as T\n    }\n\n    throw new ContainerError(`No provider for ${tokenToString(token)}. Did you forget to register it?`)\n  }\n\n  tryResolve<T>(token: InjectionToken<T>): T | undefined {\n    const realToken = isLazyToken(token) ? (token.factory() as InjectionToken<T>) : token\n\n    // Only \"nothing is registered\" yields undefined for an optional dependency.\n    // A provider that exists but throws while constructing is a real error and\n    // must surface — swallowing it would silently inject `undefined` and turn a\n    // bug into a baffling downstream failure.\n    if (!this.isResolvable(realToken)) return undefined\n\n    // An optional request-scoped dependency outside a request scope is absent,\n    // not an error — mirrors `@inject(..., { isOptional: true })` semantics.\n    if (!this.isRequestScoped && this.scopeForToken(realToken) === Scope.Request) return undefined\n\n    return this.resolve(realToken)\n  }\n\n  isRegistered<T>(token: InjectionToken<T>): boolean {\n    if (this.registrations.has(token)) return true\n    return this.parent?.isRegistered(token) ?? false\n  }\n\n  /**\n   * Whether a token has anything to resolve to: an explicit registration, or a\n   * bare class constructor (auto-resolvable). Distinct from {@link isRegistered}\n   * so {@link tryResolve} can tell \"no provider\" (→ undefined) apart from\n   * \"provider exists but failed\" (→ rethrow).\n   */\n  private isResolvable(token: InjectionToken): boolean {\n    return typeof token === 'function' || this.isRegistered(token)\n  }\n\n  // ── Conditional ───────────────────────────────────────────────\n\n  when(\n    predicate: (container: PredicateContainer) => boolean,\n    options: WhenOptions = {},\n  ): ConditionalBindingBuilder {\n    return new ConditionalBindingBuilderImpl(this, predicate, options)\n  }\n\n  extend<T>(token: InjectionToken<T>, decorator: ExtensionDecorator<T>): void {\n    const current = this.resolve<T>(token)\n    const decorated = decorator(current, this)\n    this.registerValue(token, decorated)\n  }\n\n  // ── Request Scope ─────────────────────────────────────────────\n\n  async runInRequestScope<T>(\n    routerContext: RouterContext,\n    callback: (requestContainer: Container) => T | Promise<T>,\n  ): Promise<T> {\n    if (this.isRequestScoped) {\n      throw new ContainerError('Cannot call runInRequestScope on a request-scoped container')\n    }\n\n    const requestContainer = this.createRequestScope(routerContext)\n    return await containerStorage.run(requestContainer, () => callback(requestContainer))\n  }\n\n  createRequestScope(routerContext: RouterContext): Container {\n    if (this.isRequestScoped) {\n      throw new ContainerError('Cannot call createRequestScope on a request-scoped container')\n    }\n\n    const child = new Container({ parent: this, isRequestScoped: true })\n    child.registerValue(ROUTER_TOKENS.RouterContext, routerContext)\n    return child\n  }\n\n  // ── Lifecycle ─────────────────────────────────────────────────\n\n  /**\n   * Disposes every container-instantiated instance that implements the\n   * {@link Disposable} contract (singletons and request-cached instances),\n   * then clears all registrations. Value registrations are not disposed —\n   * the container doesn't own them. A failing disposer is logged and\n   * skipped so it can't block the rest of the teardown.\n   *\n   * Instances are disposed in reverse creation order (LIFO): a disposer may\n   * still use dependencies that were constructed before its own instance.\n   */\n  async dispose(): Promise<void> {\n    const seen = new Set<unknown>()\n    for (const instance of [...this.singletons.values(), ...this.requestCache.values()].reverse()) {\n      if (seen.has(instance) || !isDisposable(instance)) continue\n      seen.add(instance)\n      try {\n        await disposeInstance(instance)\n      } catch (error) {\n        console.error('[stratal] Failed to dispose instance during container teardown:', error)\n      }\n    }\n\n    this.registrations.clear()\n    this.singletons.clear()\n    this.requestCache.clear()\n    this.requestCacheDeps.clear()\n  }\n\n  // ── Internal ──────────────────────────────────────────────────\n\n  /**\n   * Transitive constructor dependency tokens of a class, with lazy tokens\n   * unwrapped to the concrete token they resolve to. Recorded when a\n   * request-scoped instance is cached so {@link invalidateRequestCache} can find\n   * dependents.\n   *\n   * The walk follows class/alias registrations through transient intermediaries:\n   * a cached service A that depends on a (non-cached) transient B which depends\n   * on token C must still be invalidated when C is re-registered, even though B\n   * itself is never cached. Value/factory/lazy providers are not traversed —\n   * their dependencies aren't introspectable (factory) or would re-enter a\n   * cycle (lazy). Over-collecting is safe: it only rebuilds extra request-scoped\n   * instances, which is correct.\n   */\n  private collectDependencyTokens(Class: Constructor): Set<InjectionToken> {\n    const deps = new Set<InjectionToken>()\n    const visited = new Set<Constructor>()\n\n    const walk = (cls: Constructor): void => {\n      if (visited.has(cls)) return\n      visited.add(cls)\n      for (const { token } of getInjectionTokens(cls).values()) {\n        const real = isLazyToken(token) ? token.factory() : token\n        deps.add(real)\n        const childClass = this.classForToken(real)\n        if (childClass) walk(childClass)\n      }\n    }\n\n    walk(Class)\n    return deps\n  }\n\n  /** The implementing class for a token, following class/alias registrations. */\n  private classForToken(token: InjectionToken): Constructor | undefined {\n    const reg = this.findRegistration(token)\n    if (reg) {\n      if (reg.kind === 'class') return reg.useClass\n      if (reg.kind === 'alias') return this.classForToken(reg.target)\n      return undefined\n    }\n    // A bare constructor token that is auto-resolvable (carries DI metadata).\n    if (typeof token === 'function' && getClassMetadata(token as Constructor)) {\n      return token as unknown as Constructor\n    }\n    return undefined\n  }\n\n  /**\n   * The effective scope a token would resolve with, following alias\n   * registrations. Bare constructor tokens fall back to their decorator\n   * metadata — the same scope {@link resolve} uses when auto-registering.\n   */\n  private scopeForToken(token: InjectionToken): Scope | undefined {\n    const reg = this.findRegistration(token)\n    if (reg) {\n      if (reg.kind === 'class') return reg.scope\n      if (reg.kind === 'alias') return this.scopeForToken(reg.target)\n      // Same scope derivation `resolveRegistration` uses for lazy registrations\n      if (reg.kind === 'lazy') return getClassMetadata(reg.factory())?.scope ?? Scope.Transient\n      return undefined\n    }\n    if (typeof token === 'function') {\n      return getClassMetadata(token as Constructor)?.scope\n    }\n    return undefined\n  }\n\n  /**\n   * Evict a token from the request cache along with every cached request-scoped\n   * instance that transitively depends on it. Re-registering a value must\n   * rebuild its dependents (so they pick up the new value) while leaving\n   * unrelated cached services intact.\n   */\n  private invalidateRequestCache(token: InjectionToken): void {\n    const invalidated = new Set<InjectionToken>([token])\n\n    let changed = true\n    while (changed) {\n      changed = false\n      for (const [cachedToken, deps] of this.requestCacheDeps) {\n        if (invalidated.has(cachedToken)) continue\n        for (const dep of deps) {\n          if (invalidated.has(dep)) {\n            invalidated.add(cachedToken)\n            changed = true\n            break\n          }\n        }\n      }\n    }\n\n    for (const t of invalidated) {\n      this.requestCache.delete(t)\n      this.requestCacheDeps.delete(t)\n    }\n  }\n\n  private resolveRegistration(token: InjectionToken, reg: Registration): unknown {\n    switch (reg.kind) {\n      case 'value':\n        return reg.value\n\n      case 'alias':\n        return this.resolve(reg.target)\n\n      case 'factory':\n        return reg.factory(this)\n\n      case 'lazy': {\n        const useClass = reg.factory()\n        const scope = getClassMetadata(useClass)?.scope ?? Scope.Transient\n        return this.resolveClass(token, { kind: 'class', useClass, scope })\n      }\n\n      case 'class':\n        return this.resolveClass(token, reg)\n    }\n  }\n\n  private resolveClass(token: InjectionToken, reg: ClassRegistration): unknown {\n    const { useClass, scope } = reg\n\n    // Singleton: check global cache (root or current)\n    if (scope === Scope.Singleton) {\n      const root = this.getRoot()\n      if (root.singletons.has(token)) return root.singletons.get(token)\n      // Always construct against the root container. Constructing against a\n      // request-scoped child would let the singleton permanently capture that\n      // one request's request-scoped dependencies (a captive dependency leaking\n      // state across every later request on the isolate). Resolving a @Request\n      // dependency from root instead throws the request-scope error below,\n      // surfacing the illegal singleton→request dependency loudly.\n      const instance = root.instantiate(useClass)\n      root.singletons.set(token, instance)\n      return instance\n    }\n\n    // Request: cache in the request-scoped container\n    if (scope === Scope.Request) {\n      if (!this.isRequestScoped) {\n        throw new ContainerError(\n          `Cannot resolve request-scoped provider ${tokenToString(token)} outside a request scope. ` +\n            `Resolve it within an HTTP request, or via runInScope()/runInRequestScope() for queues, cron, and other non-HTTP entrypoints.`,\n        )\n      }\n      if (this.requestCache.has(token)) return this.requestCache.get(token)\n      const instance = this.instantiate(useClass)\n      this.requestCache.set(token, instance)\n      this.requestCacheDeps.set(token, this.collectDependencyTokens(useClass))\n      return instance\n    }\n\n    // Transient: always new instance\n    return this.instantiate(useClass)\n  }\n\n  private instantiate(Class: Constructor): unknown {\n    const root = this.getRoot()\n\n    // A class re-entering its own construction is a circular dependency. Detect\n    // it and throw a clear error naming the cycle instead of recursing into a\n    // stack overflow. `lazy()` only defers a forward *reference*, not\n    // resolution, so it cannot break a true runtime cycle — the graph must be\n    // refactored.\n    if (root.resolutionStack.includes(Class)) {\n      const cycle = [...root.resolutionStack, Class].map((c) => c.name).join(' → ')\n      throw new ContainerError(\n        `Circular dependency detected while constructing: ${cycle}. ` +\n          `Break the cycle by extracting the shared dependency, or inject a provider/factory instead of the instance.`,\n      )\n    }\n\n    root.resolutionStack.push(Class)\n    try {\n      const injections = getInjectionTokens(Class)\n\n      // Without reflect-metadata there is no `design:paramtypes` fallback, so every\n      // constructor dependency must carry an explicit @inject. A required parameter\n      // with no entry would otherwise be silently injected as `undefined`; fail loud.\n      if (injections.size === 0) {\n        if (Class.length > 0) {\n          throw new ContainerError(\n            `${Class.name} has ${Class.length} required constructor parameter(s) but none are decorated with @inject. ` +\n              `Every constructor dependency must be explicitly injected.`,\n          )\n        }\n        return new Class()\n      }\n\n      const maxIndex = Math.max(...injections.keys())\n      const args: unknown[] = new Array(maxIndex + 1)\n\n      for (let index = 0; index <= maxIndex; index++) {\n        const entry = injections.get(index)\n        if (!entry) {\n          throw new ContainerError(\n            `${Class.name} is missing @inject on constructor parameter ${index}. ` +\n              `Every constructor dependency must be explicitly injected.`,\n          )\n        }\n        args[index] = entry.optional ? this.tryResolve(entry.token) : this.resolve(entry.token)\n      }\n\n      return new Class(...args)\n    } finally {\n      root.resolutionStack.pop()\n    }\n  }\n\n  findRegistration(token: InjectionToken): Registration | undefined {\n    const local = this.registrations.get(token)\n    if (local) return local\n    return this.parent?.findRegistration(token)\n  }\n\n  /**\n   * The global (non-request-scoped) container at the top of the parent chain.\n   * Lazy module loading registers providers here so singletons persist across\n   * requests even when `load()` is called from within a request scope.\n   */\n  getRootContainer(): Container {\n    return this.getRoot()\n  }\n\n  private getRoot(): Container {\n    if (!this.parent) return this\n    return this.parent.getRoot()\n  }\n}\n"],"mappings":"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"}