stratal 0.0.20 → 0.0.22

package/dist/{consumer-registry-B7yUNh0q.d.mts.map → consumer-registry-DHQtypr1.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"consumer-registry-B7yUNh0q.d.mts","names":[],"sources":["../src/queue/queue-consumer.ts","../src/queue/consumer-registry.ts"],"mappings":";;AAMA;;;;;UAAiB,YAAA;EAIf;EAFA,EAAA;EAMA;EAJA,SAAA;EAMA;EAJA,IAAA;EAMG;EAJH,OAAA,EAAS,CAAA;EAIK;EAFd,QAAA;IACE,MAAA;IAAA,CACC,GAAA;EAAA;AAAA;;;;;;;;;;;;;;;;;;;UAsBY,cAAA;EAsBQ;;;;;;EAAA,SAfd,YAAA;ECXE;;;;;EDkBX,MAAA,CAAO,OAAA,EAAS,YAAA,CAAa,CAAA,IAAK,OAAA;ECqDD;;;;;;ED7CjC,OAAA,EAAS,KAAA,EAAO,KAAA,EAAO,OAAA,EAAS,YAAA,CAAa,CAAA,IAAK,OAAA;AAAA;;;AAxDpD;;;;;;;;;;;;;;;AAkCA;;;;;;;;;;;;;;;;AAlCA,cC8Ba,gBAAA;EDkBJ;EAAA,QChBC,eAAA;EDwBR;EAAA,QCrBQ,YAAA;EDqBC;;;;;;;ECZT,QAAA,CAAS,QAAA,EAAU,cAAA;;;AAfrB;;;;;;;;EAuCE,YAAA,CAAa,WAAA,WAAsB,cAAA;EAjC3B;;;;;;EAgDR,YAAA,CAAa,WAAA;EAAb;;;;;EASA,eAAA,CAAA;EASiC;;;;;EAAjC,eAAA,CAAA,GAAmB,cAAA;AAAA"}
+{"version":3,"file":"consumer-registry-DHQtypr1.d.mts","names":[],"sources":["../src/queue/queue-consumer.ts","../src/queue/consumer-registry.ts"],"mappings":";;AAMA;;;;;UAAiB,YAAA;EAIf;EAFA,EAAA;EAMA;EAJA,SAAA;EAMA;EAJA,IAAA;EAMG;EAJH,OAAA,EAAS,CAAA;EAIK;EAFd,QAAA;IACE,MAAA;IAAA,CACC,GAAA;EAAA;AAAA;;;;;;;;;;;;;;;;;;;UAsBY,cAAA;EAsBQ;;;;;;EAAA,SAfd,YAAA;ECXE;;;;;EDkBX,MAAA,CAAO,OAAA,EAAS,YAAA,CAAa,CAAA,IAAK,OAAA;ECqDD;;;;;;ED7CjC,OAAA,EAAS,KAAA,EAAO,KAAA,EAAO,OAAA,EAAS,YAAA,CAAa,CAAA,IAAK,OAAA;AAAA;;;AAxDpD;;;;;;;;;;;;;;;AAkCA;;;;;;;;;;;;;;;;AAlCA,cC8Ba,gBAAA;EDkBJ;EAAA,QChBC,eAAA;EDwBR;EAAA,QCrBQ,YAAA;EDqBC;;;;;;;ECZT,QAAA,CAAS,QAAA,EAAU,cAAA;;;AAfrB;;;;;;;;EAuCE,YAAA,CAAa,WAAA,WAAsB,cAAA;EAjC3B;;;;;;EAgDR,YAAA,CAAa,WAAA;EAAb;;;;;EASA,eAAA,CAAA;EASiC;;;;;EAAjC,eAAA,CAAA,GAAmB,cAAA;AAAA"}

package/dist/container-storage-GpNNz79X.mjs

@@ -0,0 +1,52 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region src/errors/application-error.ts
+var ApplicationError = class extends Error {
+	timestamp;
+	constructor(message, cause) {
+		super(message ?? "Internal Server Error", cause !== void 0 ? { cause } : void 0);
+		Object.setPrototypeOf(this, new.target.prototype);
+		this.name = this.constructor.name;
+		this.timestamp = (/* @__PURE__ */ new Date()).toISOString();
+		if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
+	}
+};
+//#endregion
+//#region src/errors/container-not-initialized.error.ts
+var ContainerNotInitializedError = class extends ApplicationError {
+	constructor() {
+		super("Application container has not been initialized");
+	}
+};
+//#endregion
+//#region src/di/container-storage.ts
+/**
+* AsyncLocalStorage for the application container.
+*
+* Set by `Application.initialize()` — all code from that point onward
+* (Stratal handlers, TestingModuleBuilder, standalone functions like `route()`)
+* can access the container without DI or static singletons.
+*/
+const containerStorage = new AsyncLocalStorage();
+/**
+* Get the application container from AsyncLocalStorage.
+*
+* @throws ContainerNotInitializedError if called outside `Application.initialize()` scope
+*/
+function getContainer() {
+	const container = containerStorage.getStore();
+	if (!container) throw new ContainerNotInitializedError();
+	return container;
+}
+/**
+* Run a function within a container context.
+*
+* @param container - The application container to store
+* @param fn - The function to execute with container access
+*/
+function runWithContainer(container, fn) {
+	return containerStorage.run(container, fn);
+}
+//#endregion
+export { ApplicationError as a, ContainerNotInitializedError as i, getContainer as n, runWithContainer as r, containerStorage as t };
+
+//# sourceMappingURL=container-storage-GpNNz79X.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"container-storage-GpNNz79X.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,OAAO,GAAG,KAAA,EAAU;EAEtF,OAAO,eAAe,MAAM,IAAI,OAAO,UAAU;EAEjD,KAAK,OAAO,KAAK,YAAY;EAC7B,KAAK,6BAAY,IAAI,MAAM,EAAC,aAAa;EAGzC,IAAI,MAAM,mBACR,MAAM,kBAAkB,MAAM,KAAK,YAAY;;;;;ACXrD,IAAa,+BAAb,cAAkD,iBAAiB;CACjE,cAAc;EACZ,MAAM,iDAAiD;;;;;;;;;;;;ACO3D,MAAa,mBAAmB,IAAI,mBAA8B;;;;;;AAOlE,SAAgB,eAA0B;CACxC,MAAM,YAAY,iBAAiB,UAAU;CAC7C,IAAI,CAAC,WACH,MAAM,IAAI,8BAA8B;CAE1C,OAAO;;;;;;;;AAST,SAAgB,iBAAoB,WAAsB,IAAgB;CACxE,OAAO,iBAAiB,IAAI,WAAW,GAAG"}

package/dist/{controller.decorator-DQzenvSN.mjs → controller.decorator-DIUazNU7.mjs}

@@ -1,5 +1,6 @@
-import { f as ROUTE_METADATA_KEYS } from "./errors-BdyV5PnY.mjs";
-import { p as Transient } from "./logger-V6Ms3QnQ.mjs";
+import { d as Transient } from "./di-BO1QIb5H.mjs";
+import { n as getMetadata, t as defineMetadata } from "./metadata-BVkc4aUu.mjs";
+import { u as ROUTE_METADATA_KEYS } from "./exception-context-B4kM-M53.mjs";
 //#region src/router/decorators/controller.decorator.ts
 const CONTROLLER_ROUTE_KEY = ROUTE_METADATA_KEYS.CONTROLLER_ROUTE;
 /**
@@ -26,8 +27,8 @@ const CONTROLLER_ROUTE_KEY = ROUTE_METADATA_KEYS.CONTROLLER_ROUTE;
 function Controller(route, options) {
 	return function(target) {
 		Transient()(target);
-		Reflect.defineMetadata(CONTROLLER_ROUTE_KEY, route, target);
-		if (options) Reflect.defineMetadata(ROUTE_METADATA_KEYS.CONTROLLER_OPTIONS, options, target);
+		defineMetadata(CONTROLLER_ROUTE_KEY, route, target);
+		if (options) defineMetadata(ROUTE_METADATA_KEYS.CONTROLLER_OPTIONS, options, target);
 		return target;
 	};
 }
@@ -38,8 +39,7 @@ function Controller(route, options) {
 * @returns Route string or undefined if not set
 */
 function getControllerRoute(target) {
-	const metadataTarget = typeof target === "function" ? target : target.constructor;
-	return Reflect.getMetadata(CONTROLLER_ROUTE_KEY, metadataTarget);
+	return getMetadata(CONTROLLER_ROUTE_KEY, typeof target === "function" ? target : target.constructor);
 }
 /**
 * Get the options from controller class metadata
@@ -49,7 +49,7 @@ function getControllerRoute(target) {
 */
 function getControllerOptions(target) {
 	const metadataTarget = typeof target === "function" ? target : target.constructor;
-	return Reflect.getMetadata(ROUTE_METADATA_KEYS.CONTROLLER_OPTIONS, metadataTarget);
+	return getMetadata(ROUTE_METADATA_KEYS.CONTROLLER_OPTIONS, metadataTarget);
 }
 /**
 * Get the version from controller class metadata
@@ -63,4 +63,4 @@ function getControllerVersion(target) {
 //#endregion
 export { getControllerVersion as i, getControllerOptions as n, getControllerRoute as r, Controller as t };
 
-//# sourceMappingURL=controller.decorator-DQzenvSN.mjs.map
+//# sourceMappingURL=controller.decorator-DIUazNU7.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"controller.decorator-DIUazNU7.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,WAAW,CAAC,OAAO;EAGnB,eAAe,sBAAsB,OAAO,OAAO;EAGnD,IAAI,SACF,eAAe,oBAAoB,oBAAoB,SAAS,OAAO;EAGzE,OAAO;;;;;;;;;AAUX,SAAgB,mBAAmB,QAAoC;CAIrE,OAAO,YAAoB,sBADJ,OAAO,WAAW,aAAa,SAAU,OAAmC,YACnC;;;;;;;;AASlE,SAAgB,qBAAqB,QAA+C;CAClF,MAAM,iBAAiB,OAAO,WAAW,aAAa,SAAU,OAAmC;CACnG,OAAO,YAA+B,oBAAoB,oBAAoB,eAAe;;;;;;;;AAS/F,SAAgB,qBAAqB,QAA8C;CAEjF,OADgB,qBAAqB,OACvB,EAAE"}

package/dist/cron/index.d.mts

@@ -1,15 +1,36 @@
-import { d as ApplicationError } from "../index-D0US0X14.mjs";
-import { n as CronJob, r as RegisteredJob, t as CronManager } from "../cron-manager-BEsH1mjW.mjs";
+import { xr as ApplicationError } from "../index-DEncMcC6.mjs";
+import { n as CronJob, r as RegisteredJob, t as CronManager } from "../cron-manager-CSTIBPcM.mjs";
 import { ScheduledController } from "@cloudflare/workers-types";
 
 //#region src/cron/errors/cron-execution.error.d.ts
+interface CronJobFailure {
+  job: string;
+  error: Error;
+}
+interface SerializedJobFailure {
+  job: string;
+  name: string;
+  code?: number | string;
+  message: string;
+  dbErrorCode?: string;
+  sql?: string;
+}
 /**
- * Error thrown when one or more cron jobs fail execution
+ * Error thrown when one or more cron jobs fail execution.
  *
- * This error aggregates failures from multiple jobs that share the same schedule.
+ * Aggregates failures from multiple jobs that share the same schedule while
+ * preserving each underlying error:
+ * - The originals are kept on `this.failures` for typed access.
+ * - `this.cause` is set to the only failure (1 job) or an `AggregateError`
+ *   wrapping all of them (2+ jobs), so `LoggerService.serializeError` can
+ *   walk the chain and surface every stack/cause.
  */
 declare class CronExecutionError extends ApplicationError {
-  constructor(schedule: string, failedJobsCount: number, jobNames: string);
+  readonly failures: readonly CronJobFailure[];
+  readonly schedule: string;
+  readonly failureCount: number;
+  readonly jobs: SerializedJobFailure[];
+  constructor(schedule: string, failures: CronJobFailure[]);
 }
 //#endregion
 export { CronExecutionError, type CronJob, CronManager, type RegisteredJob, type ScheduledController };

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/cron/errors/cron-execution.error.ts"],"mappings":";;;;;;;;;AAQA;cAAa,kBAAA,SAA2B,gBAAA;cAEtC,QAAA,UACA,eAAA,UACA,QAAA;AAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/cron/errors/cron-execution.error.ts"],"mappings":";;;;;UAEiB,cAAA;EAChB,GAAA;EACA,KAAA,EAAO,KAAA;AAAA;AAAA,UAGE,oBAAA;EACT,GAAA;EACA,IAAA;EACA,IAAA;EACA,OAAA;EACA,WAAA;EACA,GAAA;AAAA;;AARA;;;;;;;;;cAqBY,kBAAA,SAA2B,gBAAA;EAAA,SACvB,QAAA,WAAmB,cAAA;EAAA,SACnB,QAAA;EAAA,SACA,YAAA;EAAA,SACA,IAAA,EAAM,oBAAA;cAEV,QAAA,UAAkB,QAAA,EAAU,cAAA;AAAA"}

package/dist/cron/index.mjs

@@ -1,2 +1,2 @@
-import { n as CronExecutionError, t as CronManager } from "../cron-manager-7Symz_TE.mjs";
+import { n as CronExecutionError, t as CronManager } from "../cron-manager-9bpN9bu4.mjs";
 export { CronExecutionError, CronManager };

package/dist/{cron-manager-7Symz_TE.mjs → cron-manager-9bpN9bu4.mjs}

@@ -1,20 +1,43 @@
-import { H as ApplicationError, k as ERROR_CODES } from "./errors-BdyV5PnY.mjs";
-import { a as __decorate, p as Transient } from "./logger-V6Ms3QnQ.mjs";
+import { a as ApplicationError } from "./container-storage-GpNNz79X.mjs";
+import { d as Transient } from "./di-BO1QIb5H.mjs";
+import { t as __decorate } from "./decorate-HgTKAYK8.mjs";
+import { LOGGER_TOKENS } from "./logger/index.mjs";
+import "./errors-BBZTnjdq.mjs";
 //#region src/cron/errors/cron-execution.error.ts
 /**
-* Error thrown when one or more cron jobs fail execution
+* Error thrown when one or more cron jobs fail execution.
 *
-* This error aggregates failures from multiple jobs that share the same schedule.
+* Aggregates failures from multiple jobs that share the same schedule while
+* preserving each underlying error:
+* - The originals are kept on `this.failures` for typed access.
+* - `this.cause` is set to the only failure (1 job) or an `AggregateError`
+*   wrapping all of them (2+ jobs), so `LoggerService.serializeError` can
+*   walk the chain and surface every stack/cause.
 */
 var CronExecutionError = class extends ApplicationError {
-	constructor(schedule, failedJobsCount, jobNames) {
-		super("errors.cronExecutionFailed", ERROR_CODES.SYSTEM.CRON_EXECUTION_FAILED, {
-			schedule,
-			count: failedJobsCount,
-			jobs: jobNames
-		});
+	failures;
+	schedule;
+	failureCount;
+	jobs;
+	constructor(schedule, failures) {
+		const cause = failures.length === 0 ? void 0 : failures.length === 1 ? failures[0].error : new AggregateError(failures.map((f) => f.error), `${failures.length} cron jobs failed`);
+		super(`${failures.length} cron job(s) failed for schedule "${schedule}"`, cause);
+		this.failures = failures;
+		this.schedule = schedule;
+		this.failureCount = failures.length;
+		this.jobs = failures.map((f) => serializeFailure(f));
 	}
 };
+function serializeFailure({ job, error }) {
+	const out = {
+		job,
+		name: error.name,
+		message: error.message
+	};
+	const maybeCoded = error;
+	if (maybeCoded.code !== void 0) out.code = maybeCoded.code;
+	return out;
+}
 //#endregion
 //#region src/cron/cron-manager.ts
 let CronManager = class CronManager {
@@ -58,7 +81,13 @@ let CronManager = class CronManager {
 	async executeScheduled(controller, container) {
 		const { cron } = controller;
 		const matchingJobs = this.jobs.get(cron) ?? [];
-		if (matchingJobs.length === 0) return;
+		if (matchingJobs.length === 0) {
+			container.resolve(LOGGER_TOKENS.LoggerService).warn("No cron jobs matched scheduled trigger", {
+				incomingCron: cron,
+				registeredSchedules: Array.from(this.jobs.keys())
+			});
+			return;
+		}
 		const errors = [];
 		for (const { jobClass } of matchingJobs) {
 			const jobName = jobClass.name;
@@ -77,10 +106,7 @@ let CronManager = class CronManager {
 				} catch {}
 			}
 		}
-		if (errors.length > 0) {
-			const jobNames = errors.map(({ job, error }) => `${job}: ${error.message}`).join("; ");
-			throw new CronExecutionError(cron, errors.length, jobNames);
-		}
+		if (errors.length > 0) throw new CronExecutionError(cron, errors);
 	}
 	/**
 	* Get all registered jobs for a specific cron expression
@@ -114,4 +140,4 @@ CronManager = __decorate([Transient()], CronManager);
 //#endregion
 export { CronExecutionError as n, CronManager as t };
 
-//# sourceMappingURL=cron-manager-7Symz_TE.mjs.map
+//# sourceMappingURL=cron-manager-9bpN9bu4.mjs.map

package/dist/cron-manager-9bpN9bu4.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cron-manager-9bpN9bu4.mjs","names":[],"sources":["../src/cron/errors/cron-execution.error.ts","../src/cron/cron-manager.ts"],"sourcesContent":["import { ApplicationError } from '../../errors'\n\nexport interface CronJobFailure {\n\tjob: string\n\terror: Error\n}\n\ninterface SerializedJobFailure {\n\tjob: string\n\tname: string\n\tcode?: number | string\n\tmessage: string\n\tdbErrorCode?: string\n\tsql?: string\n}\n\n/**\n * Error thrown when one or more cron jobs fail execution.\n *\n * Aggregates failures from multiple jobs that share the same schedule while\n * preserving each underlying error:\n * - The originals are kept on `this.failures` for typed access.\n * - `this.cause` is set to the only failure (1 job) or an `AggregateError`\n *   wrapping all of them (2+ jobs), so `LoggerService.serializeError` can\n *   walk the chain and surface every stack/cause.\n */\nexport class CronExecutionError extends ApplicationError {\n\tpublic readonly failures: readonly CronJobFailure[]\n\tpublic readonly schedule: string\n\tpublic readonly failureCount: number\n\tpublic readonly jobs: SerializedJobFailure[]\n\n\tconstructor(schedule: string, failures: CronJobFailure[]) {\n\t\tconst cause =\n\t\t\tfailures.length === 0\n\t\t\t\t? undefined\n\t\t\t\t: failures.length === 1\n\t\t\t\t\t? failures[0].error\n\t\t\t\t\t: new AggregateError(failures.map((f) => f.error), `${failures.length} cron jobs failed`)\n\n\t\tsuper(\n\t\t\t`${failures.length} cron job(s) failed for schedule \"${schedule}\"`,\n\t\t\tcause,\n\t\t)\n\n\t\tthis.failures = failures\n\t\tthis.schedule = schedule\n\t\tthis.failureCount = failures.length\n\t\tthis.jobs = failures.map((f) => serializeFailure(f))\n\t}\n}\n\nfunction serializeFailure({ job, error }: CronJobFailure): SerializedJobFailure {\n\tconst out: SerializedJobFailure = {\n\t\tjob,\n\t\tname: error.name,\n\t\tmessage: error.message,\n\t}\n\tconst maybeCoded = error as { code?: number | string }\n\tif (maybeCoded.code !== undefined) out.code = maybeCoded.code\n\treturn out\n}\n","import type { Container } from '../di/container'\nimport { Transient } from '../di/decorators'\nimport { LOGGER_TOKENS } from '../logger/logger.tokens'\nimport type { LoggerService } from '../logger/services/logger.service'\nimport type { CronJob, RegisteredJob } from './cron-job'\nimport { CronExecutionError } from './errors/cron-execution.error'\n\n/**\n * Manages cron job registration and execution\n *\n * CronManager is a singleton service that:\n * - Registers cron job class references from modules\n * - Routes scheduled events to matching jobs\n * - Resolves jobs from a request-scoped container at execution time\n *\n * Jobs are grouped by their cron expression, allowing multiple jobs\n * to run on the same schedule.\n */\n@Transient()\nexport class CronManager {\n\t/**\n\t * Map of cron expressions to registered job entries\n\t * Key: Cron expression (e.g., '0 2 * * *')\n\t * Value: Array of registered jobs (class ref + schedule)\n\t */\n\tprivate jobs = new Map<string, RegisteredJob[]>()\n\n\t/**\n\t * Register a cron job class\n\t *\n\t * Jobs with the same schedule are grouped together and executed\n\t * sequentially when the trigger fires.\n\t *\n\t * @param schedule - Cron expression (e.g., '0 2 * * *')\n\t * @param jobClass - CronJob class constructor (resolved at execution time)\n\t */\n\tregisterJob(schedule: string, jobClass: RegisteredJob['jobClass']): void {\n\t\tconst existing = this.jobs.get(schedule) ?? []\n\t\texisting.push({ schedule, jobClass })\n\t\tthis.jobs.set(schedule, existing)\n\t}\n\n\t/**\n\t * Execute all jobs matching the triggered cron expression\n\t *\n\t * Jobs are resolved from the provided request-scoped container,\n\t * ensuring dependencies (e.g. database) are properly scoped.\n\t *\n\t * Jobs are executed sequentially. If a job fails:\n\t * - Its onError() hook is called (if defined)\n\t * - Execution continues with the next job\n\t * - Errors are collected and thrown as CronExecutionError\n\t *\n\t * @param controller - Cloudflare ScheduledController\n\t * @param container - Request-scoped container to resolve jobs from\n\t */\n\tasync executeScheduled(controller: ScheduledController, container: Container): Promise<void> {\n\t\tconst { cron } = controller\n\t\tconst matchingJobs = this.jobs.get(cron) ?? []\n\n\t\tif (matchingJobs.length === 0) {\n\t\t\tconst logger = container.resolve<LoggerService>(LOGGER_TOKENS.LoggerService)\n\t\t\tlogger.warn('No cron jobs matched scheduled trigger', {\n\t\t\t\tincomingCron: cron,\n\t\t\t\tregisteredSchedules: Array.from(this.jobs.keys()),\n\t\t\t})\n\t\t\treturn\n\t\t}\n\n\t\tconst errors: { job: string; error: Error }[] = []\n\n\t\tfor (const { jobClass } of matchingJobs) {\n\t\t\tconst jobName = jobClass.name\n\n\t\t\ttry {\n\t\t\t\t// Register the job class in the request-scoped container so its\n\t\t\t\t// dependencies are resolved from request scope (not the parent).\n\t\t\t\tcontainer.register(jobClass, jobClass)\n\t\t\t\tconst job = container.resolve<CronJob>(jobClass)\n\t\t\t\tawait job.execute(controller)\n\t\t\t} catch (error) {\n\t\t\t\tconst err = error as Error\n\t\t\t\terrors.push({ job: jobName, error: err })\n\n\t\t\t\t// Try to resolve and call onError if possible\n\t\t\t\ttry {\n\t\t\t\t\tconst job = container.resolve<CronJob>(jobClass)\n\t\t\t\t\tif (job.onError) {\n\t\t\t\t\t\tawait job.onError(err, controller)\n\t\t\t\t\t}\n\t\t\t\t} catch {\n\t\t\t\t\t// If resolution or onError fails, continue\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// If any jobs failed, throw an aggregate error so ExceptionHandler logs\n\t\t// it. The full per-job errors are passed through so cause/stacks survive.\n\t\tif (errors.length > 0) {\n\t\t\tthrow new CronExecutionError(cron, errors)\n\t\t}\n\t}\n\n\t/**\n\t * Get all registered jobs for a specific cron expression\n\t *\n\t * @param schedule - Cron expression\n\t * @returns Array of registered jobs, or empty array if none\n\t */\n\tgetJobsForSchedule(schedule: string): RegisteredJob[] {\n\t\treturn this.jobs.get(schedule) ?? []\n\t}\n\n\t/**\n\t * Get all registered cron expressions\n\t *\n\t * @returns Array of unique cron expressions\n\t */\n\tgetAllSchedules(): string[] {\n\t\treturn Array.from(this.jobs.keys())\n\t}\n\n\t/**\n\t * Get total number of registered jobs across all schedules\n\t *\n\t * @returns Total job count\n\t */\n\tgetTotalJobCount(): number {\n\t\tlet count = 0\n\t\tfor (const jobs of this.jobs.values()) {\n\t\t\tcount += jobs.length\n\t\t}\n\t\treturn count\n\t}\n}\n"],"mappings":";;;;;;;;;;;;;;;;AA0BA,IAAa,qBAAb,cAAwC,iBAAiB;CACxD;CACA;CACA;CACA;CAEA,YAAY,UAAkB,UAA4B;EACzD,MAAM,QACL,SAAS,WAAW,IACjB,KAAA,IACA,SAAS,WAAW,IACnB,SAAS,GAAG,QACZ,IAAI,eAAe,SAAS,KAAK,MAAM,EAAE,MAAM,EAAE,GAAG,SAAS,OAAO,mBAAmB;EAE5F,MACC,GAAG,SAAS,OAAO,oCAAoC,SAAS,IAChE,MACA;EAED,KAAK,WAAW;EAChB,KAAK,WAAW;EAChB,KAAK,eAAe,SAAS;EAC7B,KAAK,OAAO,SAAS,KAAK,MAAM,iBAAiB,EAAE,CAAC;;;AAItD,SAAS,iBAAiB,EAAE,KAAK,SAA+C;CAC/E,MAAM,MAA4B;EACjC;EACA,MAAM,MAAM;EACZ,SAAS,MAAM;EACf;CACD,MAAM,aAAa;CACnB,IAAI,WAAW,SAAS,KAAA,GAAW,IAAI,OAAO,WAAW;CACzD,OAAO;;;;ACzCD,IAAA,cAAA,MAAM,YAAY;;;;;;CAMxB,uBAAe,IAAI,KAA8B;;;;;;;;;;CAWjD,YAAY,UAAkB,UAA2C;EACxE,MAAM,WAAW,KAAK,KAAK,IAAI,SAAS,IAAI,EAAE;EAC9C,SAAS,KAAK;GAAE;GAAU;GAAU,CAAC;EACrC,KAAK,KAAK,IAAI,UAAU,SAAS;;;;;;;;;;;;;;;;CAiBlC,MAAM,iBAAiB,YAAiC,WAAqC;EAC5F,MAAM,EAAE,SAAS;EACjB,MAAM,eAAe,KAAK,KAAK,IAAI,KAAK,IAAI,EAAE;EAE9C,IAAI,aAAa,WAAW,GAAG;GAE9B,UADyB,QAAuB,cAAc,cACxD,CAAC,KAAK,0CAA0C;IACrD,cAAc;IACd,qBAAqB,MAAM,KAAK,KAAK,KAAK,MAAM,CAAC;IACjD,CAAC;GACF;;EAGD,MAAM,SAA0C,EAAE;EAElD,KAAK,MAAM,EAAE,cAAc,cAAc;GACxC,MAAM,UAAU,SAAS;GAEzB,IAAI;IAGH,UAAU,SAAS,UAAU,SAAS;IAEtC,MADY,UAAU,QAAiB,SAC9B,CAAC,QAAQ,WAAW;YACrB,OAAO;IACf,MAAM,MAAM;IACZ,OAAO,KAAK;KAAE,KAAK;KAAS,OAAO;KAAK,CAAC;IAGzC,IAAI;KACH,MAAM,MAAM,UAAU,QAAiB,SAAS;KAChD,IAAI,IAAI,SACP,MAAM,IAAI,QAAQ,KAAK,WAAW;YAE5B;;;EAQV,IAAI,OAAO,SAAS,GACnB,MAAM,IAAI,mBAAmB,MAAM,OAAO;;;;;;;;CAU5C,mBAAmB,UAAmC;EACrD,OAAO,KAAK,KAAK,IAAI,SAAS,IAAI,EAAE;;;;;;;CAQrC,kBAA4B;EAC3B,OAAO,MAAM,KAAK,KAAK,KAAK,MAAM,CAAC;;;;;;;CAQpC,mBAA2B;EAC1B,IAAI,QAAQ;EACZ,KAAK,MAAM,QAAQ,KAAK,KAAK,QAAQ,EACpC,SAAS,KAAK;EAEf,OAAO;;;0BAlHR,WAAW,CAAA,EAAA,YAAA"}

package/dist/{cron-manager-BEsH1mjW.d.mts → cron-manager-CSTIBPcM.d.mts}

@@ -1,18 +1,19 @@
-import { Dr as Container } from "./index-D0US0X14.mjs";
-import { t as Constructor } from "./types-cySNS_lp.mjs";
+import { Y as Container } from "./index-DEncMcC6.mjs";
+import { t as Constructor } from "./types-BaeHi67f.mjs";
 
 //#region src/cron/cron-job.d.ts
 /**
  * Interface for cron jobs that can be registered by modules
  *
  * Cron jobs are executed when Cloudflare triggers match their schedule.
- * Jobs are registered via the module's getCronJobs() method.
+ * The `schedule` property must be declared as a **static** field so the
+ * framework can read it at registration time without instantiating the class.
  *
  * @example
  * ```typescript
  * @Transient()
  * export class DataCleanupJob implements CronJob {
- *   readonly schedule = '0 2 * * *' // Daily at 2 AM UTC
+ *   static schedule = '0 2 * * *' // Daily at 2 AM UTC
  *
  *   constructor(
  *     @inject(LOGGER_TOKENS.LoggerService) private logger: LoggerService,
@@ -36,14 +37,6 @@ interface RegisteredJob {
   jobClass: Constructor<CronJob>;
 }
 interface CronJob {
-  /**
-   * Cron expression that triggers this job
-   *
-   * Must match a cron trigger defined in wrangler.jsonc
-   * @example '0 2 * * *' // Daily at 2 AM UTC
-   * @example '* /15 * * * *' // Every 15 minutes
-   */
-  readonly schedule: string;
   /**
    * Execute the cron job
    *
@@ -128,4 +121,4 @@ declare class CronManager {
 }
 //#endregion
 export { CronJob as n, RegisteredJob as r, CronManager as t };
-//# sourceMappingURL=cron-manager-BEsH1mjW.d.mts.map
+//# sourceMappingURL=cron-manager-CSTIBPcM.d.mts.map

package/dist/cron-manager-CSTIBPcM.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cron-manager-CSTIBPcM.d.mts","names":[],"sources":["../src/cron/cron-job.ts","../src/cron/cron-manager.ts"],"mappings":";;;;;;;AA8BA;;;;;;;;;;AAOA;;;;;;;;;;;;;;;UAPiB,aAAA;EAwBP;EAtBT,QAAA;EAsBuB;EApBvB,QAAA,EAAU,WAAA,CAAY,OAAA;AAAA;AAAA,UAGN,OAAA;;;;ACnBjB;;;ED0BC,OAAA,CAAQ,UAAA,EAAY,mBAAA,GAAsB,OAAA;ECYP;;;;;;;;EDFnC,OAAA,EAAS,KAAA,EAAO,KAAA,EAAO,UAAA,EAAY,mBAAA,GAAsB,OAAA;AAAA;;;;;AAxB1D;;;;;;;;;cCXa,WAAA;EDkBI;;;;;EAAA,QCZR,IAAA;ED6B2B;;;;;;;;;EClBnC,WAAA,CAAY,QAAA,UAAkB,QAAA,EAAU,aAAA;EDkB/B;;;;;;;;;ACpCV;;;;;EAsCO,gBAAA,CAAiB,UAAA,EAAY,mBAAA,EAAqB,SAAA,EAAW,SAAA,GAAY,OAAA;EAAA;;;;;;EAqD/E,kBAAA,CAAmB,QAAA,WAAmB,aAAA;EAzEE;;;;;EAkFxC,eAAA,CAAA;EA9DwD;;;;;EAuExD,gBAAA,CAAA;AAAA"}

package/dist/decorate-HgTKAYK8.mjs

@@ -0,0 +1,16 @@
+//#region \0@oxc-project+runtime@0.129.0/helpers/decorateParam.js
+function __decorateParam(paramIndex, decorator) {
+	return function(target, key) {
+		decorator(target, key, paramIndex);
+	};
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.129.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+//#endregion
+export { __decorateParam as n, __decorate as t };

package/dist/deep-merge-C8NgcXw4.mjs

@@ -0,0 +1,18 @@
+//#region src/i18n/utils/deep-merge.ts
+/**
+* Deep merge two objects. Source values override target at leaf level.
+*/
+function deepMerge(target, source) {
+	const result = { ...target };
+	for (const key of Object.keys(source)) {
+		const targetValue = target[key];
+		const sourceValue = source[key];
+		if (typeof targetValue === "object" && targetValue !== null && !Array.isArray(targetValue) && typeof sourceValue === "object" && sourceValue !== null && !Array.isArray(sourceValue)) result[key] = deepMerge(targetValue, sourceValue);
+		else result[key] = sourceValue;
+	}
+	return result;
+}
+//#endregion
+export { deepMerge as t };
+
+//# sourceMappingURL=deep-merge-C8NgcXw4.mjs.map

package/dist/deep-merge-C8NgcXw4.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"deep-merge-C8NgcXw4.mjs","names":[],"sources":["../src/i18n/utils/deep-merge.ts"],"sourcesContent":["/**\n * Deep merge two objects. Source values override target at leaf level.\n */\nexport function deepMerge(\n  target: Record<string, unknown>,\n  source: Record<string, unknown>,\n): Record<string, unknown> {\n  const result: Record<string, unknown> = { ...target }\n\n  for (const key of Object.keys(source)) {\n    const targetValue = target[key]\n    const sourceValue = source[key]\n\n    if (\n      typeof targetValue === 'object'\n      && targetValue !== null\n      && !Array.isArray(targetValue)\n      && typeof sourceValue === 'object'\n      && sourceValue !== null\n      && !Array.isArray(sourceValue)\n    ) {\n      result[key] = deepMerge(\n        targetValue as Record<string, unknown>,\n        sourceValue as Record<string, unknown>,\n      )\n    } else {\n      result[key] = sourceValue\n    }\n  }\n\n  return result\n}\n"],"mappings":";;;;AAGA,SAAgB,UACd,QACA,QACyB;CACzB,MAAM,SAAkC,EAAE,GAAG,QAAQ;CAErD,KAAK,MAAM,OAAO,OAAO,KAAK,OAAO,EAAE;EACrC,MAAM,cAAc,OAAO;EAC3B,MAAM,cAAc,OAAO;EAE3B,IACE,OAAO,gBAAgB,YACpB,gBAAgB,QAChB,CAAC,MAAM,QAAQ,YAAY,IAC3B,OAAO,gBAAgB,YACvB,gBAAgB,QAChB,CAAC,MAAM,QAAQ,YAAY,EAE9B,OAAO,OAAO,UACZ,aACA,YACD;OAED,OAAO,OAAO;;CAIlB,OAAO"}

package/dist/di/index.d.mts

@@ -1,2 +1,2 @@
-import { Ar as container, Br as PredicateContainer, Dr as Container, Fr as singleton, Hr as ExtensionDecorator, Ir as ConditionalBindingBuilder, Lr as ConditionalBindingBuilderImpl, Mr as inject, Nr as injectable, Or as ContainerOptions, Pr as instancePerContainerCachingFactory, Rr as ConditionalBindingGive, Ur as Scope, Vr as ContainerLike, Wr as WhenOptions, _r as DIToken, cr as runWithContainer, dr as Transient, fr as INJECT_PARAM_METADATA_KEY, gr as CONTAINER_TOKEN, hr as getMethodInjections, jr as delay, kr as DependencyContainer, lr as RequestScopeOperationNotAllowedError, mr as ParamInjection, or as containerStorage, pr as InjectParam, sr as getContainer, ur as ConditionalBindingFallbackError, vr as DI_TOKENS, zr as ConditionalBindingUse } from "../index-D0US0X14.mjs";
-export { CONTAINER_TOKEN, ConditionalBindingBuilder, ConditionalBindingBuilderImpl, ConditionalBindingFallbackError, ConditionalBindingGive, ConditionalBindingUse, Container, ContainerLike, ContainerOptions, DIToken, DI_TOKENS, DependencyContainer, ExtensionDecorator, INJECT_PARAM_METADATA_KEY, InjectParam, ParamInjection, PredicateContainer, RequestScopeOperationNotAllowedError, Scope, Transient, WhenOptions, container, containerStorage, delay, getContainer, getMethodInjections, inject, injectable, instancePerContainerCachingFactory, runWithContainer, singleton };
+import { $ as ConditionalBindingGive, B as Transient, Bn as LazyToken, F as defineMetadata, Fn as ContainerLike, G as InjectParam, H as getInjectionTokens, Hn as lazy, I as getMetadata, In as ExtensionDecorator, J as ContainerError, K as ParamInjection, L as hasMetadata, Ln as InjectionToken, M as containerStorage, N as getContainer, P as runWithContainer, Q as ConditionalBindingBuilderImpl, R as Request, Rn as Scope, U as inject, V as getClassMetadata, Vn as isLazyToken, W as INJECT_PARAM_METADATA_KEY, X as ContainerOptions, Y as Container, Z as ConditionalBindingBuilder, br as DI_TOKENS, et as ConditionalBindingUse, q as getMethodInjections, tt as PredicateContainer, vr as CONTAINER_TOKEN, yr as DIToken, z as Singleton, zn as WhenOptions } from "../index-DEncMcC6.mjs";
+export { CONTAINER_TOKEN, ConditionalBindingBuilder, ConditionalBindingBuilderImpl, ConditionalBindingGive, ConditionalBindingUse, Container, ContainerError, ContainerLike, ContainerOptions, DIToken, DI_TOKENS, ExtensionDecorator, INJECT_PARAM_METADATA_KEY, InjectParam, InjectionToken, LazyToken, ParamInjection, PredicateContainer, Request, Scope, Singleton, Transient, WhenOptions, containerStorage, defineMetadata, getClassMetadata, getContainer, getInjectionTokens, getMetadata, getMethodInjections, hasMetadata, inject, isLazyToken, lazy, runWithContainer };

package/dist/di/index.mjs

@@ -1,3 +1,4 @@
-import { A as Scope, B as ConditionalBindingFallbackError, D as runWithContainer, E as getContainer, F as injectable, I as instancePerContainerCachingFactory, L as singleton, M as container, N as delay, P as inject, R as ConditionalBindingBuilderImpl, T as containerStorage, j as Container, z as RequestScopeOperationNotAllowedError } from "../errors-BdyV5PnY.mjs";
-import { d as CONTAINER_TOKEN, f as DI_TOKENS, g as getMethodInjections, h as InjectParam, m as INJECT_PARAM_METADATA_KEY, p as Transient } from "../logger-V6Ms3QnQ.mjs";
-export { CONTAINER_TOKEN, ConditionalBindingBuilderImpl, ConditionalBindingFallbackError, Container, DI_TOKENS, INJECT_PARAM_METADATA_KEY, InjectParam, RequestScopeOperationNotAllowedError, Scope, Transient, container, containerStorage, delay, getContainer, getMethodInjections, inject, injectable, instancePerContainerCachingFactory, runWithContainer, singleton };
+import { n as getContainer, r as runWithContainer, t as containerStorage } from "../container-storage-GpNNz79X.mjs";
+import { _ as getMethodInjections, a as ContainerError, c as DI_TOKENS, d as Transient, f as getClassMetadata, g as InjectParam, h as INJECT_PARAM_METADATA_KEY, i as ConditionalBindingBuilderImpl, l as Request, m as inject, n as isLazyToken, p as getInjectionTokens, r as lazy, s as CONTAINER_TOKEN, t as Container, u as Singleton, v as Scope } from "../di-BO1QIb5H.mjs";
+import { n as getMetadata, r as hasMetadata, t as defineMetadata } from "../metadata-BVkc4aUu.mjs";
+export { CONTAINER_TOKEN, ConditionalBindingBuilderImpl, Container, ContainerError, DI_TOKENS, INJECT_PARAM_METADATA_KEY, InjectParam, Request, Scope, Singleton, Transient, containerStorage, defineMetadata, getClassMetadata, getContainer, getInjectionTokens, getMetadata, getMethodInjections, hasMetadata, inject, isLazyToken, lazy, runWithContainer };