stratal 0.0.13 → 0.0.15

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/cron/cron-job.ts","../../src/cron/cron-manager.ts","../../src/cron/errors/cron-execution.error.ts"],"mappings":";;;;;;AA2BA;;;;;;;;;;;;;;;;;;;;;;;UAAiB,OAAA;;;ACZjB;;;;;WDoBU,QAAA;EC6D6B;;;;;;EDrDtC,OAAA,CAAQ,UAAA,EAAY,mBAAA,GAAsB,OAAA;ECKpC;;;;;;;;EDKN,OAAA,EAAS,KAAA,EAAO,KAAA,EAAO,UAAA,EAAY,mBAAA,GAAsB,OAAA;AAAA;;;;;;AA1B1D;;;;;;;;cCXa,WAAA;EDqCoD;;;;;EAAA,QC/BxD,IAAA;ED+BR;;;;;;;;ECrBA,WAAA,CAAY,GAAA,EAAK,OAAA;;;AAjBlB;;;;;;;;EAiCO,gBAAA,CAAiB,UAAA,EAAY,mBAAA,GAAsB,OAAA;EA1BjD;;;;;;EA0ER,kBAAA,CAAmB,QAAA,WAAmB,OAAA;EAhDmB;;;;;EAyDzD,eAAA,CAAA;EASgB;;;;;EAAhB,gBAAA,CAAA;AAAA;;;;;;ADvFD;;cEnBa,kBAAA,SAA2B,gBAAA;cAEtC,QAAA,UACA,eAAA,UACA,QAAA;AAAA"}

package/dist/cron/index.mjs

@@ -0,0 +1,5 @@
+import "../errors-CtCi1wn6.mjs";
+import "../decorate-D5j-d9_z.mjs";
+import "../logger-BR1-s1Um.mjs";
+import { n as CronExecutionError, t as CronManager } from "../cron-manager-BRh86QCS.mjs";
+export { CronExecutionError, CronManager };

package/dist/cron-manager-BRh86QCS.mjs

@@ -0,0 +1,107 @@
+import { S as ApplicationError, b as ERROR_CODES } from "./errors-CtCi1wn6.mjs";
+import { i as Transient, t as __decorate } from "./decorate-D5j-d9_z.mjs";
+//#region src/cron/errors/cron-execution.error.ts
+/**
+* Error thrown when one or more cron jobs fail execution
+*
+* This error aggregates failures from multiple jobs that share the same schedule.
+*/
+var CronExecutionError = class extends ApplicationError {
+	constructor(schedule, failedJobsCount, jobNames) {
+		super("errors.cronExecutionFailed", ERROR_CODES.SYSTEM.CRON_EXECUTION_FAILED, {
+			schedule,
+			count: failedJobsCount,
+			jobs: jobNames
+		});
+	}
+};
+//#endregion
+//#region src/cron/cron-manager.ts
+let CronManager = class CronManager {
+	/**
+	* Map of cron expressions to jobs
+	* Key: Cron expression (e.g., '0 2 * * *')
+	* Value: Array of jobs matching that expression
+	*/
+	jobs = /* @__PURE__ */ new Map();
+	/**
+	* Register a cron job
+	*
+	* Jobs with the same schedule are grouped together and executed
+	* sequentially when the trigger fires.
+	*
+	* @param job - CronJob instance to register
+	*/
+	registerJob(job) {
+		const existing = this.jobs.get(job.schedule) ?? [];
+		existing.push(job);
+		this.jobs.set(job.schedule, existing);
+	}
+	/**
+	* Execute all jobs matching the triggered cron expression
+	*
+	* Jobs are executed sequentially. If a job fails:
+	* - Its onError() hook is called (if defined)
+	* - Execution continues with the next job
+	* - Errors are collected and logged
+	*
+	* @param controller - Cloudflare ScheduledController
+	*/
+	async executeScheduled(controller) {
+		const { cron } = controller;
+		const matchingJobs = this.jobs.get(cron) ?? [];
+		if (matchingJobs.length === 0) return;
+		const errors = [];
+		for (const job of matchingJobs) {
+			const jobName = job.constructor.name;
+			try {
+				await job.execute(controller);
+			} catch (error) {
+				const err = error;
+				errors.push({
+					job: jobName,
+					error: err
+				});
+				if (job.onError) try {
+					await job.onError(err, controller);
+				} catch {}
+			}
+		}
+		if (errors.length > 0) {
+			const jobNames = errors.map(({ job, error }) => `${job}: ${error.message}`).join("; ");
+			throw new CronExecutionError(cron, errors.length, jobNames);
+		}
+	}
+	/**
+	* Get all registered jobs for a specific cron expression
+	*
+	* @param schedule - Cron expression
+	* @returns Array of jobs for that schedule, or empty array if none
+	*/
+	getJobsForSchedule(schedule) {
+		return this.jobs.get(schedule) ?? [];
+	}
+	/**
+	* Get all registered cron expressions
+	*
+	* @returns Array of unique cron expressions
+	*/
+	getAllSchedules() {
+		return Array.from(this.jobs.keys());
+	}
+	/**
+	* Get total number of registered jobs across all schedules
+	*
+	* @returns Total job count
+	*/
+	getTotalJobCount() {
+		let count = 0;
+		for (const jobs of this.jobs.values()) count += jobs.length;
+		return count;
+	}
+};
+CronManager = __decorate([Transient()], CronManager);
+//#endregion
+export { CronExecutionError as n, CronManager as t };
+
+//# sourceMappingURL=cron-manager-BRh86QCS.mjs.map

package/dist/cron-manager-BRh86QCS.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cron-manager-BRh86QCS.mjs","names":[],"sources":["../src/cron/errors/cron-execution.error.ts","../src/cron/cron-manager.ts"],"sourcesContent":["import { ApplicationError } from '../../errors'\nimport { ERROR_CODES } from '../../errors'\n\n/**\n * Error thrown when one or more cron jobs fail execution\n *\n * This error aggregates failures from multiple jobs that share the same schedule.\n */\nexport class CronExecutionError extends ApplicationError {\n\tconstructor(\n\t\tschedule: string,\n\t\tfailedJobsCount: number,\n\t\tjobNames: string\n\t) {\n\t\tsuper(\n\t\t\t'errors.cronExecutionFailed',\n\t\t\tERROR_CODES.SYSTEM.CRON_EXECUTION_FAILED,\n\t\t\t{\n\t\t\t\tschedule,\n\t\t\t\tcount: failedJobsCount,\n\t\t\t\tjobs: jobNames\n\t\t\t}\n\t\t)\n\t}\n}\n","import { Transient } from '../di/decorators'\nimport type { CronJob } 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 jobs from modules\n * - Routes scheduled events to matching jobs\n * - Handles errors during job execution\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 jobs\n\t * Key: Cron expression (e.g., '0 2 * * *')\n\t * Value: Array of jobs matching that expression\n\t */\n\tprivate jobs = new Map<string, CronJob[]>()\n\n\t/**\n\t * Register a cron job\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 job - CronJob instance to register\n\t */\n\tregisterJob(job: CronJob): void {\n\t\tconst existing = this.jobs.get(job.schedule) ?? []\n\t\texisting.push(job)\n\t\tthis.jobs.set(job.schedule, existing)\n\t}\n\n\t/**\n\t * Execute all jobs matching the triggered cron expression\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 logged\n\t *\n\t * @param controller - Cloudflare ScheduledController\n\t */\n\tasync executeScheduled(controller: ScheduledController): 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\treturn\n\t\t}\n\n\t\tconst errors: { job: string; error: Error }[] = []\n\n\t\tfor (const job of matchingJobs) {\n\t\t\tconst jobName = job.constructor.name\n\n\t\t\ttry {\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// Call job's error handler if defined\n\t\t\t\tif (job.onError) {\n\t\t\t\t\ttry {\n\t\t\t\t\t\tawait job.onError(err, controller)\n\t\t\t\t\t} catch {\n\t\t\t\t\t\t// If onError() itself fails, we just continue\n\t\t\t\t\t\t// The error will be logged by GlobalErrorHandler\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// If any jobs failed, throw an aggregate error\n\t\t// This ensures the error is logged by GlobalErrorHandler\n\t\tif (errors.length > 0) {\n\t\t\tconst jobNames = errors\n\t\t\t\t.map(({ job, error }) => `${job}: ${error.message}`)\n\t\t\t\t.join('; ')\n\n\t\t\tthrow new CronExecutionError(cron, errors.length, jobNames)\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 jobs for that schedule, or empty array if none\n\t */\n\tgetJobsForSchedule(schedule: string): CronJob[] {\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":";;;;;;;;AAQA,IAAa,qBAAb,cAAwC,iBAAiB;CACxD,YACC,UACA,iBACA,UACC;AACD,QACC,8BACA,YAAY,OAAO,uBACnB;GACC;GACA,OAAO;GACP,MAAM;GACN,CACD;;;;;ACNI,IAAA,cAAA,MAAM,YAAY;;;;;;CAMxB,uBAAe,IAAI,KAAwB;;;;;;;;;CAU3C,YAAY,KAAoB;EAC/B,MAAM,WAAW,KAAK,KAAK,IAAI,IAAI,SAAS,IAAI,EAAE;AAClD,WAAS,KAAK,IAAI;AAClB,OAAK,KAAK,IAAI,IAAI,UAAU,SAAS;;;;;;;;;;;;CAatC,MAAM,iBAAiB,YAAgD;EACtE,MAAM,EAAE,SAAS;EACjB,MAAM,eAAe,KAAK,KAAK,IAAI,KAAK,IAAI,EAAE;AAE9C,MAAI,aAAa,WAAW,EAC3B;EAGD,MAAM,SAA0C,EAAE;AAElD,OAAK,MAAM,OAAO,cAAc;GAC/B,MAAM,UAAU,IAAI,YAAY;AAEhC,OAAI;AACH,UAAM,IAAI,QAAQ,WAAW;YACrB,OAAO;IACf,MAAM,MAAM;AACZ,WAAO,KAAK;KAAE,KAAK;KAAS,OAAO;KAAK,CAAC;AAGzC,QAAI,IAAI,QACP,KAAI;AACH,WAAM,IAAI,QAAQ,KAAK,WAAW;YAC3B;;;AAUX,MAAI,OAAO,SAAS,GAAG;GACtB,MAAM,WAAW,OACf,KAAK,EAAE,KAAK,YAAY,GAAG,IAAI,IAAI,MAAM,UAAU,CACnD,KAAK,KAAK;AAEZ,SAAM,IAAI,mBAAmB,MAAM,OAAO,QAAQ,SAAS;;;;;;;;;CAU7D,mBAAmB,UAA6B;AAC/C,SAAO,KAAK,KAAK,IAAI,SAAS,IAAI,EAAE;;;;;;;CAQrC,kBAA4B;AAC3B,SAAO,MAAM,KAAK,KAAK,KAAK,MAAM,CAAC;;;;;;;CAQpC,mBAA2B;EAC1B,IAAI,QAAQ;AACZ,OAAK,MAAM,QAAQ,KAAK,KAAK,QAAQ,CACpC,UAAS,KAAK;AAEf,SAAO;;;0BAxGR,WAAW,CAAA,EAAA,YAAA"}

package/dist/decorate-D5j-d9_z.mjs

@@ -0,0 +1,171 @@
+import { injectable } from "tsyringe";
+//#region src/di/tokens.ts
+/**
+* Token for the Container instance
+* Used for injecting the Container into services that need dynamic resolution
+*/
+const CONTAINER_TOKEN = Symbol.for("stratal:di:container");
+const DI_TOKENS = {
+	CloudflareEnv: Symbol.for("stratal:cloudflare:env"),
+	ExecutionContext: Symbol.for("stratal:execution:context"),
+	Container: CONTAINER_TOKEN,
+	Application: Symbol.for("stratal:application"),
+	ModuleRegistry: Symbol.for("stratal:module:registry"),
+	ErrorHandler: Symbol.for("stratal:error:handler"),
+	Database: Symbol.for("stratal:database:service"),
+	Queue: Symbol.for("stratal:queue:manager"),
+	ConsumerRegistry: Symbol.for("stratal:consumer:registry"),
+	Cron: Symbol.for("stratal:cron:manager"),
+	EventRegistry: Symbol.for("stratal:event:registry"),
+	Quarry: Symbol.for("stratal:quarry"),
+	AuthContext: Symbol.for("stratal:auth:context"),
+	DurableObjectState: Symbol.for("stratal:durable:object:state"),
+	DurableObjectId: Symbol.for("stratal:durable:object:id")
+};
+//#endregion
+//#region src/di/decorators/inject-param.decorator.ts
+/**
+* Metadata key for storing parameter injection information
+*/
+const INJECT_PARAM_METADATA_KEY = Symbol.for("stratal:inject:param");
+/**
+* Mark a method parameter for DI injection
+*
+* The parameter will be resolved from the request-scoped container
+* when the controller method is invoked.
+*
+* @param token - DI token to resolve (class or symbol)
+*
+* @example With class token
+* ```typescript
+* async show(
+*   ctx: RouterContext,
+*   @InjectParam(UserService) userService: UserService
+* ) { }
+* ```
+*
+* @example With symbol token
+* ```typescript
+* async show(
+*   ctx: RouterContext,
+*   @InjectParam(DI_TOKENS.Cache) cache: ICacheService
+* ) { }
+* ```
+*/
+function InjectParam(token) {
+	return (target, propertyKey, parameterIndex) => {
+		if (propertyKey === void 0) throw new Error("@InjectParam can only be used on method parameters, not constructor parameters");
+		const existingInjections = Reflect.getMetadata(INJECT_PARAM_METADATA_KEY, target, propertyKey) ?? [];
+		existingInjections.push({
+			index: parameterIndex,
+			token
+		});
+		Reflect.defineMetadata(INJECT_PARAM_METADATA_KEY, existingInjections, target, propertyKey);
+	};
+}
+/**
+* Get method parameter injections
+*
+* @param target - Controller prototype
+* @param propertyKey - Method name
+* @returns Array of parameter injections sorted by index
+*/
+function getMethodInjections(target, propertyKey) {
+	return (Reflect.getMetadata(INJECT_PARAM_METADATA_KEY, target, propertyKey) ?? []).sort((a, b) => a.index - b.index);
+}
+//#endregion
+//#region src/di/decorators.ts
+/**
+* DI Decorators
+*
+* Provides decorators for dependency injection:
+* - @Transient: Mark classes as injectable (lifecycle controlled at registration)
+* - @InjectParam: Inject dependencies into method parameters
+*
+* Lifecycle (Singleton, Request, Transient) is controlled at registration time
+* via the `scope` property in module providers or Container.register().
+*/
+/**
+* Mark a class as injectable
+*
+* This decorator wraps tsyringe's `@injectable` decorator and optionally
+* associates a token with the class. The actual lifecycle (Singleton, Request,
+* Transient) is determined at registration time, not decoration time.
+*
+* **Lifecycle Control:**
+* - Use `scope: Scope.Singleton` in module providers for singleton
+* - Use `scope: Scope.Request` in module providers for request-scoped
+* - Default is Transient (new instance per resolution)
+*
+* @param token - Optional DI token for service resolution
+*
+* @example Basic usage (no token)
+* ```typescript
+* @Transient()
+* export class UserService {
+*   constructor(@inject(DI_TOKENS.Database) private db: DatabaseService) {}
+* }
+*
+* // In module:
+* @Module({
+*   providers: [UserService]  // Transient by default
+* })
+* ```
+*
+* @example With token
+* ```typescript
+* @Transient(DI_TOKENS.ConnectionManager)
+* export class ConnectionManager implements Disposable {
+*   // ...
+* }
+*
+* // In Application.ts:
+* container.register(DI_TOKENS.ConnectionManager, ConnectionManager, Scope.Request)
+* ```
+*
+* @example Singleton via provider scope
+* ```typescript
+* @Transient()
+* export class ConsumerRegistry {
+*   // ...
+* }
+*
+* // In module:
+* @Module({
+*   providers: [
+*     { provide: DI_TOKENS.ConsumerRegistry, useClass: ConsumerRegistry, scope: Scope.Singleton }
+*   ]
+* })
+* ```
+*/
+function Transient(token) {
+	return function(target) {
+		const targetConstructor = target;
+		injectable({ token })(targetConstructor);
+		return target;
+	};
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.115.0/helpers/decorateMetadata.js
+function __decorateMetadata(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.115.0/helpers/decorateParam.js
+function __decorateParam(paramIndex, decorator) {
+	return function(target, key) {
+		decorator(target, key, paramIndex);
+	};
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.115.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+//#endregion
+export { INJECT_PARAM_METADATA_KEY as a, CONTAINER_TOKEN as c, Transient as i, DI_TOKENS as l, __decorateParam as n, InjectParam as o, __decorateMetadata as r, getMethodInjections as s, __decorate as t };
+
+//# sourceMappingURL=decorate-D5j-d9_z.mjs.map

package/dist/decorate-D5j-d9_z.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorate-D5j-d9_z.mjs","names":[],"sources":["../src/di/tokens.ts","../src/di/decorators/inject-param.decorator.ts","../src/di/decorators.ts"],"sourcesContent":["/**\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  ErrorHandler: Symbol.for('stratal:error: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","/**\n * Method Parameter Injection Decorator\n *\n * Enables DI for controller method parameters. Parameters marked with\n * @InjectParam(token) are resolved from the request-scoped container\n * at method invocation time.\n *\n * @example\n * ```typescript\n * @Route({ response: userSchema })\n * async show(\n *   ctx: RouterContext,\n *   @InjectParam(UserService) userService: UserService,\n *   @InjectParam(CacheService) cache: CacheService\n * ): Promise<Response> {\n *   // userService and cache auto-resolved from request container\n * }\n * ```\n */\nimport type InjectionToken from 'tsyringe/dist/typings/providers/injection-token'\n\n/**\n * Metadata key for storing parameter injection information\n */\nexport const INJECT_PARAM_METADATA_KEY = Symbol.for('stratal:inject:param')\n\n/**\n * Describes a parameter injection\n */\nexport interface ParamInjection {\n  /** Parameter index in the method signature (0-based) */\n  index: number\n  /** DI token to resolve */\n  token: InjectionToken\n}\n\n/**\n * Mark a method parameter for DI injection\n *\n * The parameter will be resolved from the request-scoped container\n * when the controller method is invoked.\n *\n * @param token - DI token to resolve (class or symbol)\n *\n * @example With class token\n * ```typescript\n * async show(\n *   ctx: RouterContext,\n *   @InjectParam(UserService) userService: UserService\n * ) { }\n * ```\n *\n * @example With symbol token\n * ```typescript\n * async show(\n *   ctx: RouterContext,\n *   @InjectParam(DI_TOKENS.Cache) cache: ICacheService\n * ) { }\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 existingInjections: ParamInjection[] =\n      (Reflect.getMetadata(INJECT_PARAM_METADATA_KEY, target, propertyKey) as ParamInjection[] | undefined) ?? []\n\n    existingInjections.push({\n      index: parameterIndex,\n      token,\n    })\n\n    Reflect.defineMetadata(INJECT_PARAM_METADATA_KEY, existingInjections, target, propertyKey)\n  }\n}\n\n/**\n * Get method parameter injections\n *\n * @param target - Controller prototype\n * @param propertyKey - Method name\n * @returns Array of parameter injections sorted by index\n */\nexport function getMethodInjections(target: object, propertyKey: string | symbol): ParamInjection[] {\n  const injections: ParamInjection[] =\n    (Reflect.getMetadata(INJECT_PARAM_METADATA_KEY, target, propertyKey) as ParamInjection[] | undefined) ?? []\n\n  return injections.sort((a, b) => a.index - b.index)\n}\n","/**\n * DI Decorators\n *\n * Provides decorators for dependency injection:\n * - @Transient: Mark classes as injectable (lifecycle controlled at registration)\n * - @InjectParam: Inject dependencies into method parameters\n *\n * Lifecycle (Singleton, Request, Transient) is controlled at registration time\n * via the `scope` property in module providers or Container.register().\n */\nimport { injectable } from 'tsyringe'\nimport type InjectionToken from 'tsyringe/dist/typings/providers/injection-token'\n\n// Re-export method parameter injection\nexport {\n  InjectParam,\n  getMethodInjections,\n  type ParamInjection,\n  INJECT_PARAM_METADATA_KEY,\n} from './decorators/inject-param.decorator'\n\n/**\n * Mark a class as injectable\n *\n * This decorator wraps tsyringe's `@injectable` decorator and optionally\n * associates a token with the class. The actual lifecycle (Singleton, Request,\n * Transient) is determined at registration time, not decoration time.\n *\n * **Lifecycle Control:**\n * - Use `scope: Scope.Singleton` in module providers for singleton\n * - Use `scope: Scope.Request` in module providers for request-scoped\n * - Default is Transient (new instance per resolution)\n *\n * @param token - Optional DI token for service resolution\n *\n * @example Basic usage (no token)\n * ```typescript\n * @Transient()\n * export class UserService {\n *   constructor(@inject(DI_TOKENS.Database) private db: DatabaseService) {}\n * }\n *\n * // In module:\n * @Module({\n *   providers: [UserService]  // Transient by default\n * })\n * ```\n *\n * @example With token\n * ```typescript\n * @Transient(DI_TOKENS.ConnectionManager)\n * export class ConnectionManager implements Disposable {\n *   // ...\n * }\n *\n * // In Application.ts:\n * container.register(DI_TOKENS.ConnectionManager, ConnectionManager, Scope.Request)\n * ```\n *\n * @example Singleton via provider scope\n * ```typescript\n * @Transient()\n * export class ConsumerRegistry {\n *   // ...\n * }\n *\n * // In module:\n * @Module({\n *   providers: [\n *     { provide: DI_TOKENS.ConsumerRegistry, useClass: ConsumerRegistry, scope: Scope.Singleton }\n *   ]\n * })\n * ```\n */\nexport function Transient<T>(token?: InjectionToken<T>) {\n  return function <TFunction extends abstract new (...args: never[]) => unknown>(target: TFunction): TFunction {\n    const targetConstructor = target as unknown as new (...args: unknown[]) => T\n    injectable<T>({ token })(targetConstructor)\n    return target\n  }\n}\n"],"mappings":";;;;;;AAIA,MAAa,kBAAkB,OAAO,IAAI,uBAAuB;AAEjE,MAAa,YAAY;CAEvB,eAAe,OAAO,IAAI,yBAAyB;CACnD,kBAAkB,OAAO,IAAI,4BAA4B;CAGzD,WAAW;CACX,aAAa,OAAO,IAAI,sBAAsB;CAC9C,gBAAgB,OAAO,IAAI,0BAA0B;CACrD,cAAc,OAAO,IAAI,wBAAwB;CACjD,UAAU,OAAO,IAAI,2BAA2B;CAChD,OAAO,OAAO,IAAI,wBAAwB;CAC1C,kBAAkB,OAAO,IAAI,4BAA4B;CACzD,MAAM,OAAO,IAAI,uBAAuB;CACxC,eAAe,OAAO,IAAI,yBAAyB;CACnD,QAAQ,OAAO,IAAI,iBAAiB;CAMpC,aAAa,OAAO,IAAI,uBAAuB;CAG/C,oBAAoB,OAAO,IAAI,+BAA+B;CAC9D,iBAAiB,OAAO,IAAI,4BAA4B;CACzD;;;;;;ACRD,MAAa,4BAA4B,OAAO,IAAI,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;AAoC3E,SAAgB,YAAe,OAA8C;AAC3E,SAAQ,QAAgB,aAA0C,mBAA2B;AAC3F,MAAI,gBAAgB,KAAA,EAClB,OAAM,IAAI,MAAM,iFAAiF;EAGnG,MAAM,qBACH,QAAQ,YAAY,2BAA2B,QAAQ,YAAY,IAAqC,EAAE;AAE7G,qBAAmB,KAAK;GACtB,OAAO;GACP;GACD,CAAC;AAEF,UAAQ,eAAe,2BAA2B,oBAAoB,QAAQ,YAAY;;;;;;;;;;AAW9F,SAAgB,oBAAoB,QAAgB,aAAgD;AAIlG,SAFG,QAAQ,YAAY,2BAA2B,QAAQ,YAAY,IAAqC,EAAE,EAE3F,MAAM,GAAG,MAAM,EAAE,QAAQ,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACfrD,SAAgB,UAAa,OAA2B;AACtD,QAAO,SAAwE,QAA8B;EAC3G,MAAM,oBAAoB;AAC1B,aAAc,EAAE,OAAO,CAAC,CAAC,kBAAkB;AAC3C,SAAO"}

package/dist/di/index.d.mts

@@ -0,0 +1,2 @@
+import { $t as Container, Gt as Transient, Jt as ParamInjection, Kt as INJECT_PARAM_METADATA_KEY, Qt as DI_TOKENS, Ut as RequestScopeOperationNotAllowedError, Wt as ConditionalBindingFallbackError, Xt as CONTAINER_TOKEN, Yt as getMethodInjections, Zt as DIToken, an as injectable, cn as ConditionalBindingBuilder, dn as ConditionalBindingUse, en as ContainerOptions, fn as PredicateContainer, gn as WhenOptions, hn as Scope, in as inject, ln as ConditionalBindingBuilderImpl, mn as ExtensionDecorator, nn as container, on as instancePerContainerCachingFactory, pn as ContainerLike, qt as InjectParam, rn as delay, sn as singleton, tn as DependencyContainer, un as ConditionalBindingGive } from "../index-D69rxo8H.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, delay, getMethodInjections, inject, injectable, instancePerContainerCachingFactory, singleton };

package/dist/di/index.mjs

@@ -0,0 +1,4 @@
+import { _ as ConditionalBindingFallbackError, c as Container, d as inject, f as injectable, g as RequestScopeOperationNotAllowedError, h as ConditionalBindingBuilderImpl, l as container, m as singleton, p as instancePerContainerCachingFactory, s as Scope, u as delay } from "../errors-CtCi1wn6.mjs";
+import { a as INJECT_PARAM_METADATA_KEY, c as CONTAINER_TOKEN, i as Transient, l as DI_TOKENS, o as InjectParam, s as getMethodInjections } from "../decorate-D5j-d9_z.mjs";
+import "../logger-BR1-s1Um.mjs";
+export { CONTAINER_TOKEN, ConditionalBindingBuilderImpl, ConditionalBindingFallbackError, Container, DI_TOKENS, INJECT_PARAM_METADATA_KEY, InjectParam, RequestScopeOperationNotAllowedError, Scope, Transient, container, delay, getMethodInjections, inject, injectable, instancePerContainerCachingFactory, singleton };