stratal 0.0.1

package/dist/di/decorators.js

@@ -0,0 +1,74 @@
+/**
+ * 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().
+ */
+import { injectable } from 'tsyringe';
+// Re-export method parameter injection
+export { InjectParam, getMethodInjections, INJECT_PARAM_METADATA_KEY, } from './decorators/inject-param.decorator';
+/**
+ * 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 }
+ *   ]
+ * })
+ * ```
+ */
+export function Transient(token) {
+    return function (target) {
+        const targetConstructor = target;
+        injectable({ token })(targetConstructor);
+        return target;
+    };
+}
+//# sourceMappingURL=decorators.js.map

package/dist/di/decorators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../../src/di/decorators.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAGrC,uCAAuC;AACvC,OAAO,EACL,WAAW,EACX,mBAAmB,EAEnB,yBAAyB,GAC1B,MAAM,qCAAqC,CAAA;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,MAAM,UAAU,SAAS,CAAI,KAAyB;IACpD,OAAO,UAAwE,MAAiB;QAC9F,MAAM,iBAAiB,GAAG,MAAkD,CAAA;QAC5E,UAAU,CAAI,EAAE,KAAK,EAAE,CAAC,CAAC,iBAAiB,CAAC,CAAA;QAC3C,OAAO,MAAM,CAAA;IACf,CAAC,CAAA;AACH,CAAC"}

package/dist/di/errors/conditional-binding-fallback.error.d.ts

@@ -0,0 +1,16 @@
+import { ApplicationError } from '../../infrastructure/error-handler';
+/**
+ * ConditionalBindingFallbackError
+ *
+ * Thrown when a conditional binding predicate returns false but no fallback
+ * implementation was provided and no existing registration exists for the token.
+ *
+ * This typically indicates a misconfiguration in the DI setup where:
+ * - A `when().use().give()` chain was used without `otherwise()`
+ * - AND the token wasn't previously registered
+ * - AND the predicate evaluated to false at resolution time
+ */
+export declare class ConditionalBindingFallbackError extends ApplicationError {
+    constructor(token: string);
+}
+//# sourceMappingURL=conditional-binding-fallback.error.d.ts.map

package/dist/di/errors/conditional-binding-fallback.error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditional-binding-fallback.error.d.ts","sourceRoot":"","sources":["../../../src/di/errors/conditional-binding-fallback.error.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAA;AAErE;;;;;;;;;;GAUG;AACH,qBAAa,+BAAgC,SAAQ,gBAAgB;gBACvD,KAAK,EAAE,MAAM;CAO1B"}

package/dist/di/errors/conditional-binding-fallback.error.js

@@ -0,0 +1,19 @@
+import { ERROR_CODES } from '../../errors';
+import { ApplicationError } from '../../infrastructure/error-handler';
+/**
+ * ConditionalBindingFallbackError
+ *
+ * Thrown when a conditional binding predicate returns false but no fallback
+ * implementation was provided and no existing registration exists for the token.
+ *
+ * This typically indicates a misconfiguration in the DI setup where:
+ * - A `when().use().give()` chain was used without `otherwise()`
+ * - AND the token wasn't previously registered
+ * - AND the predicate evaluated to false at resolution time
+ */
+export class ConditionalBindingFallbackError extends ApplicationError {
+    constructor(token) {
+        super('errors.conditionalBindingFallback', ERROR_CODES.SYSTEM.INFRASTRUCTURE_ERROR, { token });
+    }
+}
+//# sourceMappingURL=conditional-binding-fallback.error.js.map

package/dist/di/errors/conditional-binding-fallback.error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditional-binding-fallback.error.js","sourceRoot":"","sources":["../../../src/di/errors/conditional-binding-fallback.error.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAC1C,OAAO,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAA;AAErE;;;;;;;;;;GAUG;AACH,MAAM,OAAO,+BAAgC,SAAQ,gBAAgB;IACnE,YAAY,KAAa;QACvB,KAAK,CACH,mCAAmC,EACnC,WAAW,CAAC,MAAM,CAAC,oBAAoB,EACvC,EAAE,KAAK,EAAE,CACV,CAAA;IACH,CAAC;CACF"}

package/dist/di/errors/index.d.ts

@@ -0,0 +1,3 @@
+export * from './conditional-binding-fallback.error';
+export * from './request-scope-operation-not-allowed.error';
+//# sourceMappingURL=index.d.ts.map

package/dist/di/errors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/di/errors/index.ts"],"names":[],"mappings":"AAAA,cAAc,sCAAsC,CAAA;AACpD,cAAc,6CAA6C,CAAA"}

package/dist/di/errors/index.js

@@ -0,0 +1,3 @@
+export * from './conditional-binding-fallback.error';
+export * from './request-scope-operation-not-allowed.error';
+//# sourceMappingURL=index.js.map

package/dist/di/errors/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/di/errors/index.ts"],"names":[],"mappings":"AAAA,cAAc,sCAAsC,CAAA;AACpD,cAAc,6CAA6C,CAAA"}

package/dist/di/errors/request-scope-operation-not-allowed.error.d.ts

@@ -0,0 +1,12 @@
+import { ApplicationError } from '../../infrastructure/error-handler';
+/**
+ * RequestScopeOperationNotAllowedError
+ *
+ * Thrown when attempting to call a method that is not allowed on the current container scope.
+ * - `createRequestScope()` and `runInRequestScope()` can only be called on global containers
+ * - `runWithContextStore()` can only be called on request-scoped containers
+ */
+export declare class RequestScopeOperationNotAllowedError extends ApplicationError {
+    constructor(methodName: string);
+}
+//# sourceMappingURL=request-scope-operation-not-allowed.error.d.ts.map

package/dist/di/errors/request-scope-operation-not-allowed.error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-scope-operation-not-allowed.error.d.ts","sourceRoot":"","sources":["../../../src/di/errors/request-scope-operation-not-allowed.error.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAA;AAErE;;;;;;GAMG;AACH,qBAAa,oCAAqC,SAAQ,gBAAgB;gBAC5D,UAAU,EAAE,MAAM;CAO/B"}

package/dist/di/errors/request-scope-operation-not-allowed.error.js

@@ -0,0 +1,15 @@
+import { ERROR_CODES } from '../../errors';
+import { ApplicationError } from '../../infrastructure/error-handler';
+/**
+ * RequestScopeOperationNotAllowedError
+ *
+ * Thrown when attempting to call a method that is not allowed on the current container scope.
+ * - `createRequestScope()` and `runInRequestScope()` can only be called on global containers
+ * - `runWithContextStore()` can only be called on request-scoped containers
+ */
+export class RequestScopeOperationNotAllowedError extends ApplicationError {
+    constructor(methodName) {
+        super('errors.requestScopeOperationNotAllowed', ERROR_CODES.SYSTEM.INFRASTRUCTURE_ERROR, { methodName });
+    }
+}
+//# sourceMappingURL=request-scope-operation-not-allowed.error.js.map

package/dist/di/errors/request-scope-operation-not-allowed.error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-scope-operation-not-allowed.error.js","sourceRoot":"","sources":["../../../src/di/errors/request-scope-operation-not-allowed.error.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAC1C,OAAO,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAA;AAErE;;;;;;GAMG;AACH,MAAM,OAAO,oCAAqC,SAAQ,gBAAgB;IACxE,YAAY,UAAkB;QAC5B,KAAK,CACH,wCAAwC,EACxC,WAAW,CAAC,MAAM,CAAC,oBAAoB,EACvC,EAAE,UAAU,EAAE,CACf,CAAA;IACH,CAAC;CACF"}

package/dist/di/index.d.ts

@@ -0,0 +1,13 @@
+export * from './tokens';
+export * from './container';
+export * from './decorators';
+export * from './request-context-store';
+export * from './types';
+export * from './conditional-binding-builder';
+export * from './errors';
+export { Container } from './container';
+export { CONTAINER_TOKEN } from './tokens';
+export type { ContainerOptions } from './container';
+export type { ConditionalBindingBuilder, ConditionalBindingUse, ConditionalBindingGive, PredicateContainer } from './conditional-binding-builder';
+export type { WhenOptions, ExtensionDecorator, ContainerLike } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/di/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/di/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA;AACxB,cAAc,aAAa,CAAA;AAC3B,cAAc,cAAc,CAAA;AAC5B,cAAc,yBAAyB,CAAA;AACvC,cAAc,SAAS,CAAA;AACvB,cAAc,+BAA+B,CAAA;AAC7C,cAAc,UAAU,CAAA;AAGxB,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAC1C,YAAY,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAGnD,YAAY,EACV,yBAAyB,EACzB,qBAAqB,EACrB,sBAAsB,EACtB,kBAAkB,EACnB,MAAM,+BAA+B,CAAA;AAEtC,YAAY,EAAE,WAAW,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA"}

package/dist/di/index.js

@@ -0,0 +1,11 @@
+export * from './tokens';
+export * from './container';
+export * from './decorators';
+export * from './request-context-store';
+export * from './types';
+export * from './conditional-binding-builder';
+export * from './errors';
+// Re-export Container as named export for clarity
+export { Container } from './container';
+export { CONTAINER_TOKEN } from './tokens';
+//# sourceMappingURL=index.js.map

package/dist/di/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/di/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA;AACxB,cAAc,aAAa,CAAA;AAC3B,cAAc,cAAc,CAAA;AAC5B,cAAc,yBAAyB,CAAA;AACvC,cAAc,SAAS,CAAA;AACvB,cAAc,+BAA+B,CAAA;AAC7C,cAAc,UAAU,CAAA;AAExB,kDAAkD;AAClD,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA"}

package/dist/di/request-context-store.d.ts

@@ -0,0 +1,122 @@
+import type { DependencyContainer } from 'tsyringe';
+/**
+ * Request context store using AsyncLocalStorage
+ *
+ * Stores and propagates request container across async operations without manual context passing.
+ * This enables transparent access to request-scoped services from any part of the application
+ * during request handling.
+ *
+ * **Cloudflare Workers Compatibility**:
+ * - Requires `nodejs_als` compatibility flag in wrangler.jsonc
+ * - Uses V8's SetContinuationPreservedEmbedderData API (efficient)
+ * - Performance overhead: ~3-4% in typical scenarios
+ *
+ * **Thread Safety**:
+ * - Singleton instance shared across application
+ * - Each request gets isolated storage context
+ * - No context leakage between concurrent requests
+ *
+ * @example
+ * ```typescript
+ * // In router middleware
+ * const store = RequestContextStore.getInstance()
+ * await store.run(requestContainer, async () => {
+ *   // All async operations within this callback have access to requestContainer
+ *   await handleRequest()
+ * })
+ *
+ * // In service (anywhere in the call stack)
+ * const container = RequestContextStore.getInstance().getRequestContainer()
+ * if (container) {
+ *   // We're in request context
+ *   const service = container.resolve(TOKEN)
+ * }
+ * ```
+ */
+export declare class RequestContextStore {
+    private static instance;
+    private readonly storage;
+    /**
+     * Private constructor - use getInstance() instead
+     */
+    private constructor();
+    /**
+     * Get singleton instance
+     *
+     * **Note**: Creates instance on first call. Subsequent calls return same instance.
+     */
+    static getInstance(): RequestContextStore;
+    /**
+     * Run callback within request context
+     *
+     * Container is automatically available to all async operations within the callback,
+     * including nested function calls, promises, timers, and queue handlers.
+     *
+     * @param container - Request-scoped dependency container
+     * @param callback - Async operation to run with context
+     * @returns Result of callback execution
+     *
+     * @example
+     * ```typescript
+     * const result = await store.run(requestContainer, async () => {
+     *   // Context automatically propagates to nested calls
+     *   await processRequest()
+     *   return { success: true }
+     * })
+     * ```
+     */
+    run<T>(container: DependencyContainer, callback: () => T): T;
+    /**
+     * Get current request container
+     *
+     * Returns the container for the current async context, or undefined if not in request context.
+     *
+     * **Use Cases**:
+     * - Request-scoped services resolving from request container
+     * - Services needing conditional logic based on context availability
+     * - Debugging/logging request-specific information
+     * @deprecated Use container instead
+     * @returns Request container if in request context, undefined otherwise
+     *
+     * @example
+     * ```typescript
+     * const container = store.getRequestContainer()
+     * if (container) {
+     *   // Safe to resolve request-scoped services
+     *   const i18n = container.resolve(I18N_TOKENS.I18nService)
+     * } else {
+     *   // Not in request context - use fallback
+     *   console.log('No request context available')
+     * }
+     * ```
+     */
+    getRequestContainer(): DependencyContainer | undefined;
+    /**
+     * Check if currently in request context
+     *
+     * Convenience method for conditional logic based on context availability.
+     *
+     * @returns true if in request context, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (store.hasRequestContext()) {
+     *   // Use request-specific data
+     *   const locale = getLocaleFromContext()
+     * } else {
+     *   // Use default
+     *   const locale = 'en'
+     * }
+     * ```
+     */
+    hasRequestContext(): boolean;
+    /**
+     * Reset singleton instance (for testing only)
+     *
+     * **Warning**: Only use in test cleanup. Never call in production code.
+     *
+     * @internal
+     */
+    static resetInstance(): void;
+}
+//# sourceMappingURL=request-context-store.d.ts.map

package/dist/di/request-context-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-context-store.d.ts","sourceRoot":"","sources":["../../src/di/request-context-store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAA;AAEnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAmC;IAC1D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAwC;IAEhE;;OAEG;IACH,OAAO;IAIP;;;;OAIG;IACH,MAAM,CAAC,WAAW,IAAI,mBAAmB;IAKzC;;;;;;;;;;;;;;;;;;OAkBG;IACH,GAAG,CAAC,CAAC,EAAE,SAAS,EAAE,mBAAmB,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC;IAI5D;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,mBAAmB,IAAI,mBAAmB,GAAG,SAAS;IAItD;;;;;;;;;;;;;;;;;OAiBG;IACH,iBAAiB,IAAI,OAAO;IAI5B;;;;;;OAMG;IACH,MAAM,CAAC,aAAa,IAAI,IAAI;CAG7B"}

package/dist/di/request-context-store.js

@@ -0,0 +1,135 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+/**
+ * Request context store using AsyncLocalStorage
+ *
+ * Stores and propagates request container across async operations without manual context passing.
+ * This enables transparent access to request-scoped services from any part of the application
+ * during request handling.
+ *
+ * **Cloudflare Workers Compatibility**:
+ * - Requires `nodejs_als` compatibility flag in wrangler.jsonc
+ * - Uses V8's SetContinuationPreservedEmbedderData API (efficient)
+ * - Performance overhead: ~3-4% in typical scenarios
+ *
+ * **Thread Safety**:
+ * - Singleton instance shared across application
+ * - Each request gets isolated storage context
+ * - No context leakage between concurrent requests
+ *
+ * @example
+ * ```typescript
+ * // In router middleware
+ * const store = RequestContextStore.getInstance()
+ * await store.run(requestContainer, async () => {
+ *   // All async operations within this callback have access to requestContainer
+ *   await handleRequest()
+ * })
+ *
+ * // In service (anywhere in the call stack)
+ * const container = RequestContextStore.getInstance().getRequestContainer()
+ * if (container) {
+ *   // We're in request context
+ *   const service = container.resolve(TOKEN)
+ * }
+ * ```
+ */
+export class RequestContextStore {
+    static instance = null;
+    storage;
+    /**
+     * Private constructor - use getInstance() instead
+     */
+    constructor() {
+        this.storage = new AsyncLocalStorage();
+    }
+    /**
+     * Get singleton instance
+     *
+     * **Note**: Creates instance on first call. Subsequent calls return same instance.
+     */
+    static getInstance() {
+        RequestContextStore.instance ??= new RequestContextStore();
+        return RequestContextStore.instance;
+    }
+    /**
+     * Run callback within request context
+     *
+     * Container is automatically available to all async operations within the callback,
+     * including nested function calls, promises, timers, and queue handlers.
+     *
+     * @param container - Request-scoped dependency container
+     * @param callback - Async operation to run with context
+     * @returns Result of callback execution
+     *
+     * @example
+     * ```typescript
+     * const result = await store.run(requestContainer, async () => {
+     *   // Context automatically propagates to nested calls
+     *   await processRequest()
+     *   return { success: true }
+     * })
+     * ```
+     */
+    run(container, callback) {
+        return this.storage.run(container, callback);
+    }
+    /**
+     * Get current request container
+     *
+     * Returns the container for the current async context, or undefined if not in request context.
+     *
+     * **Use Cases**:
+     * - Request-scoped services resolving from request container
+     * - Services needing conditional logic based on context availability
+     * - Debugging/logging request-specific information
+     * @deprecated Use container instead
+     * @returns Request container if in request context, undefined otherwise
+     *
+     * @example
+     * ```typescript
+     * const container = store.getRequestContainer()
+     * if (container) {
+     *   // Safe to resolve request-scoped services
+     *   const i18n = container.resolve(I18N_TOKENS.I18nService)
+     * } else {
+     *   // Not in request context - use fallback
+     *   console.log('No request context available')
+     * }
+     * ```
+     */
+    getRequestContainer() {
+        return this.storage.getStore();
+    }
+    /**
+     * Check if currently in request context
+     *
+     * Convenience method for conditional logic based on context availability.
+     *
+     * @returns true if in request context, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (store.hasRequestContext()) {
+     *   // Use request-specific data
+     *   const locale = getLocaleFromContext()
+     * } else {
+     *   // Use default
+     *   const locale = 'en'
+     * }
+     * ```
+     */
+    hasRequestContext() {
+        return this.storage.getStore() !== undefined;
+    }
+    /**
+     * Reset singleton instance (for testing only)
+     *
+     * **Warning**: Only use in test cleanup. Never call in production code.
+     *
+     * @internal
+     */
+    static resetInstance() {
+        RequestContextStore.instance = null;
+    }
+}
+//# sourceMappingURL=request-context-store.js.map

package/dist/di/request-context-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-context-store.js","sourceRoot":"","sources":["../../src/di/request-context-store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAGpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAM,OAAO,mBAAmB;IACtB,MAAM,CAAC,QAAQ,GAA+B,IAAI,CAAA;IACzC,OAAO,CAAwC;IAEhE;;OAEG;IACH;QACE,IAAI,CAAC,OAAO,GAAG,IAAI,iBAAiB,EAAuB,CAAA;IAC7D,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,WAAW;QAChB,mBAAmB,CAAC,QAAQ,KAAK,IAAI,mBAAmB,EAAE,CAAA;QAC1D,OAAO,mBAAmB,CAAC,QAAQ,CAAA;IACrC,CAAC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,GAAG,CAAI,SAA8B,EAAE,QAAiB;QACtD,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAA;IAC9C,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,mBAAmB;QACjB,OAAO,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAA;IAChC,CAAC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,iBAAiB;QACf,OAAO,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,KAAK,SAAS,CAAA;IAC9C,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,aAAa;QAClB,mBAAmB,CAAC,QAAQ,GAAG,IAAI,CAAA;IACrC,CAAC"}

package/dist/di/tokens.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Token for the Container instance
+ * Used for injecting the Container into services that need dynamic resolution
+ */
+export declare const CONTAINER_TOKEN: unique symbol;
+export declare const DI_TOKENS: {
+    readonly CloudflareEnv: symbol;
+    readonly ExecutionContext: symbol;
+    readonly Container: typeof CONTAINER_TOKEN;
+    readonly Application: symbol;
+    readonly ModuleRegistry: symbol;
+    readonly ErrorHandler: symbol;
+    readonly ConnectionManager: symbol;
+    readonly Database: symbol;
+    readonly Queue: symbol;
+    readonly ConsumerRegistry: symbol;
+    readonly Cron: symbol;
+    readonly EventRegistry: symbol;
+    /**
+     * AuthContext: Use for services that need user authentication (userId).
+     */
+    readonly AuthContext: symbol;
+};
+export type DIToken = typeof DI_TOKENS[keyof typeof DI_TOKENS];
+//# sourceMappingURL=tokens.d.ts.map

package/dist/di/tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../../src/di/tokens.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,eAAe,eAA6B,CAAA;AAEzD,eAAO,MAAM,SAAS;;;;;;;;;;;;;IAkBpB;;OAEG;;CAEK,CAAA;AAEV,MAAM,MAAM,OAAO,GAAG,OAAO,SAAS,CAAC,MAAM,OAAO,SAAS,CAAC,CAAA"}

package/dist/di/tokens.js

@@ -0,0 +1,27 @@
+/**
+ * Token for the Container instance
+ * Used for injecting the Container into services that need dynamic resolution
+ */
+export const CONTAINER_TOKEN = Symbol.for('di:Container');
+export const DI_TOKENS = {
+    // Cloudflare
+    CloudflareEnv: Symbol.for('CloudflareEnv'),
+    ExecutionContext: Symbol.for('ExecutionContext'),
+    // Infrastructure
+    Container: CONTAINER_TOKEN,
+    Application: Symbol.for('Application'),
+    ModuleRegistry: Symbol.for('ModuleRegistry'),
+    ErrorHandler: Symbol.for('ErrorHandler'),
+    ConnectionManager: Symbol.for('ConnectionManager'),
+    Database: Symbol.for('DatabaseService'),
+    Queue: Symbol.for('QueueManager'),
+    ConsumerRegistry: Symbol.for('ConsumerRegistry'),
+    Cron: Symbol.for('CronManager'),
+    EventRegistry: Symbol.for('EventRegistry'),
+    // Context
+    /**
+     * AuthContext: Use for services that need user authentication (userId).
+     */
+    AuthContext: Symbol.for('AuthContext'),
+};
+//# sourceMappingURL=tokens.js.map

package/dist/di/tokens.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.js","sourceRoot":"","sources":["../../src/di/tokens.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,MAAM,CAAC,GAAG,CAAC,cAAc,CAAC,CAAA;AAEzD,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,aAAa;IACb,aAAa,EAAE,MAAM,CAAC,GAAG,CAAC,eAAe,CAAC;IAC1C,gBAAgB,EAAE,MAAM,CAAC,GAAG,CAAC,kBAAkB,CAAC;IAEhD,iBAAiB;IACjB,SAAS,EAAE,eAAe;IAC1B,WAAW,EAAE,MAAM,CAAC,GAAG,CAAC,aAAa,CAAC;IACtC,cAAc,EAAE,MAAM,CAAC,GAAG,CAAC,gBAAgB,CAAC;IAC5C,YAAY,EAAE,MAAM,CAAC,GAAG,CAAC,cAAc,CAAC;IACxC,iBAAiB,EAAE,MAAM,CAAC,GAAG,CAAC,mBAAmB,CAAC;IAClD,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC,iBAAiB,CAAC;IACvC,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,cAAc,CAAC;IACjC,gBAAgB,EAAE,MAAM,CAAC,GAAG,CAAC,kBAAkB,CAAC;IAChD,IAAI,EAAE,MAAM,CAAC,GAAG,CAAC,aAAa,CAAC;IAC/B,aAAa,EAAE,MAAM,CAAC,GAAG,CAAC,eAAe,CAAC;IAE1C,UAAU;IACV;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC,GAAG,CAAC,aAAa,CAAC;CAC9B,CAAA"}

package/dist/di/types.d.ts

@@ -0,0 +1,56 @@
+/**
+ * DI Type Definitions
+ *
+ * Core type definitions for the dependency injection system.
+ * Simplified after removing LazyProxy - no more type wrappers needed.
+ */
+import type InjectionToken from 'tsyringe/dist/typings/providers/injection-token';
+/**
+ * Service scope for DI registration
+ *
+ * Maps directly to tsyringe's Lifecycle enum.
+ * Scope is specified at registration time via provider configuration,
+ * not at class decoration time.
+ *
+ * @example
+ * ```typescript
+ * // In module providers:
+ * { provide: MY_TOKEN, useClass: MyService, scope: Scope.Singleton }
+ *
+ * // In Application.ts:
+ * container.register(MY_TOKEN, MyService, Scope.Request)
+ * ```
+ */
+export declare enum Scope {
+    /** New instance per resolution (default) */
+    Transient = 0,
+    /** Single instance shared globally */
+    Singleton = 1,
+    /** New instance per child container (per request) */
+    Request = 3
+}
+/**
+ * Options for conditional binding with `when()` method
+ */
+export interface WhenOptions {
+    /**
+     * Cache predicate result after first evaluation.
+     * When true, the predicate is evaluated once and the result is reused.
+     * When false (default), predicate is evaluated on each resolution.
+     */
+    cache?: boolean;
+}
+/**
+ * Decorator function type for extend() method
+ *
+ * @template T The service type being decorated
+ */
+export type ExtensionDecorator<T> = (service: T, container: ContainerLike) => T;
+/**
+ * Minimal container interface for decorator functions
+ * Avoids circular dependency with Container class
+ */
+export interface ContainerLike {
+    resolve<T>(token: InjectionToken<T>): T;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/di/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/di/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,cAAc,MAAM,iDAAiD,CAAA;AAEjF;;;;;;;;;;;;;;;GAeG;AAEH,oBAAY,KAAK;IACf,4CAA4C;IAC5C,SAAS,IAAsB;IAC/B,sCAAsC;IACtC,SAAS,IAAsB;IAC/B,qDAAqD;IACrD,OAAO,IAA4B;CACpC;AAGD;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB;AAED;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,EAAE,SAAS,EAAE,aAAa,KAAK,CAAC,CAAA;AAE/E;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,CAAC,CAAA;CACxC"}

package/dist/di/types.js

@@ -0,0 +1,34 @@
+/**
+ * DI Type Definitions
+ *
+ * Core type definitions for the dependency injection system.
+ * Simplified after removing LazyProxy - no more type wrappers needed.
+ */
+import { Lifecycle } from 'tsyringe';
+/**
+ * Service scope for DI registration
+ *
+ * Maps directly to tsyringe's Lifecycle enum.
+ * Scope is specified at registration time via provider configuration,
+ * not at class decoration time.
+ *
+ * @example
+ * ```typescript
+ * // In module providers:
+ * { provide: MY_TOKEN, useClass: MyService, scope: Scope.Singleton }
+ *
+ * // In Application.ts:
+ * container.register(MY_TOKEN, MyService, Scope.Request)
+ * ```
+ */
+/* eslint-disable @typescript-eslint/prefer-literal-enum-member -- values must stay in sync with tsyringe Lifecycle */
+export var Scope;
+(function (Scope) {
+    /** New instance per resolution (default) */
+    Scope[Scope["Transient"] = 0] = "Transient";
+    /** Single instance shared globally */
+    Scope[Scope["Singleton"] = 1] = "Singleton";
+    /** New instance per child container (per request) */
+    Scope[Scope["Request"] = 3] = "Request";
+})(Scope || (Scope = {}));
+//# sourceMappingURL=types.js.map

package/dist/di/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/di/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAGpC;;;;;;;;;;;;;;;GAeG;AACH,sHAAsH;AACtH,MAAM,CAAN,IAAY,KAOX;AAPD,WAAY,KAAK;IACf,4CAA4C;IAC5C,2CAA+B,CAAA;IAC/B,sCAAsC;IACtC,2CAA+B,CAAA;IAC/B,qDAAqD;IACrD,uCAAmC,CAAA;AACrC,CAAC,EAPW,KAAK,KAAL,KAAK,QAOhB"}