@codefast/di 0.3.14-canary.0 → 0.3.14-canary.2

package/dist/decorators/inject.d.mts

@@ -1,55 +1,24 @@
+import { Constructor } from "../constructor-type.mjs";
 import { Token } from "../token.mjs";
-import { Constructor, ResolveHint } from "../binding.mjs";
-import { InjectionDescriptor } from "../metadata/metadata-types.mjs";
 
 //#region src/decorators/inject.d.ts
-/**
- * Name/tag hint forwarded to the container when resolving an injected dependency.
- * Alias for {@link ResolveHint}; used as the second parameter of {@link inject} and {@link optional}.
- */
-type InjectOptions = ResolveHint;
-/**
- * Dual-purpose injection helper:
- *
- * **1. As a deps-array entry** — returns an {@link InjectionDescriptor} carrying the token,
- * optional flag (`false`), and any name/tag hint. Used inside `@injectable([...deps])`.
- *
- * ```ts
- * @injectable([inject(Logger, { name: 'file' })])
- * class UserService { constructor(log: Logger) {} }
- * ```
- *
- * **2. As a Stage 3 accessor decorator** — writes accessor-injection metadata into
- * `Symbol.metadata` and returns a no-op sentinel. The container performs the actual
- * injection after construction.
- *
- * ```ts
- * @inject(Logger) accessor logger!: LoggerService;
- * ```
- *
- * @param token - The injection key (token or constructor) to resolve.
- * @param optionsOrContext - Either an {@link InjectOptions} hint or the TC39
- *   `ClassAccessorDecoratorContext` automatically supplied by the runtime.
- */
-declare function inject<Value>(token: Token<Value> | Constructor<Value>, optionsOrContext?: InjectOptions | ClassAccessorDecoratorContext): InjectionDescriptor<Value>;
-/**
- * Same as {@link inject} but marks the dependency as optional (`InjectionDescriptor.optional = true`).
- * During resolution, an unbound token resolves to `undefined` instead of throwing
- * {@link TokenNotBoundError}. Only usable as a deps-array entry (not as an accessor decorator).
- */
-declare function optional<Value>(token: Token<Value> | Constructor<Value>, options?: InjectOptions): InjectionDescriptor<Value>;
-/**
- * Deps-array helper for `@injectable()`: injects **all** bindings registered for `token`
- * (same semantics as {@link Container.resolveAll} / {@link ResolutionContext.resolveAll}).
- * Use for multi-binding — constructor parameter type should be `T[]` (or a readonly array).
- *
- * Optional {@link InjectOptions.name} / `tag` narrow which bindings are collected (unusual; most
- * callers omit options and register disambiguators on each binding instead).
- */
-declare function injectAll<Value>(token: Token<Value> | Constructor<Value>, options?: InjectOptions): InjectionDescriptor<Value>;
-/**
- * Type-guard — returns `true` when `value` is an {@link InjectionDescriptor}.
- */
+interface InjectOptions {
+  name?: string;
+  tags?: ReadonlyArray<readonly [tag: string, value: unknown]>;
+}
+interface InjectionDescriptor<Value = unknown> {
+  readonly token: Token<Value> | Constructor<Value>;
+  readonly optional: boolean;
+  readonly multi: boolean;
+  readonly name?: string;
+  readonly tags?: ReadonlyArray<readonly [string, unknown]>;
+}
+type InjectableDependency<Value = unknown> = Token<Value> | Constructor<Value> | InjectionDescriptor<Value>;
 declare function isInjectionDescriptor(value: unknown): value is InjectionDescriptor;
+declare function normalizeToDescriptor(dep: InjectableDependency): InjectionDescriptor;
+type ClassAccessorDecorator<This, Value> = (target: ClassAccessorDecoratorTarget<This, Value>, context: ClassAccessorDecoratorContext<This, Value>) => ClassAccessorDecoratorResult<This, Value> | void;
+declare function inject<const Value>(t: Token<Value> | Constructor<Value>, options?: InjectOptions): InjectionDescriptor<Value> & ClassAccessorDecorator<unknown, Value>;
+declare function optional<const Value>(t: Token<Value> | Constructor<Value>, options?: InjectOptions): InjectionDescriptor<Value | undefined>;
+declare function injectAll<const Value>(t: Token<Value> | Constructor<Value>, options?: InjectOptions): InjectionDescriptor<Value[]>;
 //#endregion
-export { InjectOptions, inject, injectAll, isInjectionDescriptor, optional };
+export { InjectOptions, InjectableDependency, InjectionDescriptor, inject, injectAll, isInjectionDescriptor, normalizeToDescriptor, optional };

package/dist/decorators/inject.mjs

@@ -1,108 +1,146 @@
-import { InternalError } from "../errors.mjs";
-import { CODEFAST_DI_ACCESSOR_INJECTIONS } from "../metadata/metadata-keys.mjs";
+import { MissingContainerContextError } from "../errors.mjs";
+import { getActiveContainer } from "../environment.mjs";
+import { injectableSlotToResolveOptions } from "../resolve-options.mjs";
+import { INJECT_ACCESSOR_KEY } from "../metadata/metadata-keys.mjs";
 //#region src/decorators/inject.ts
-/**
-* Validates and normalises the `tag` option from {@link InjectOptions}; throws {@link InternalError} on bad input.
-*/
-function normalizeTag(tag) {
-	if (tag === void 0) return;
-	if (!Array.isArray(tag) || tag.length !== 2) throw new InternalError(`@inject tag must be a tuple [tagKey, value] with length 2; received ${String(tag)}`);
-	const [tagName, value] = tag;
-	if (typeof tagName !== "string") throw new InternalError(`@inject tag key must be a string; received ${typeof tagName}`);
-	return [tagName, value];
+function isInjectionDescriptor(value) {
+	if (value === null || value === void 0) return false;
+	const type = typeof value;
+	if (type !== "object" && type !== "function") return false;
+	return "token" in value && "optional" in value && "multi" in value && typeof value.optional === "boolean" && typeof value.multi === "boolean";
+}
+function normalizeToDescriptor(dep) {
+	if (isInjectionDescriptor(dep)) return materializeInjectionDescriptor(dep);
+	return {
+		token: dep,
+		optional: false,
+		multi: false
+	};
 }
 /**
-* Builds an {@link InjectionDescriptor} from a token, optional flag, and raw inject options.
+* Dual-role `inject()` values are functions: [[Function]].name must not be treated as a DI slot name.
+* Only enumerable own `name` / `tags` from `Object.defineProperties` are real injection options.
 */
-function toDescriptor(token, optional, options) {
-	const normalizedTag = normalizeTag(options?.tag);
-	if (options?.name !== void 0) return {
-		token,
-		optional,
-		name: options.name
+function materializeInjectionDescriptor(dep) {
+	if (typeof dep !== "function") return dep;
+	const dualRole = dep;
+	const base = {
+		token: dualRole.token,
+		optional: dualRole.optional,
+		multi: dualRole.multi
 	};
-	if (normalizedTag !== void 0) return {
-		token,
-		optional,
-		tag: normalizedTag
+	const nameDesc = Object.getOwnPropertyDescriptor(dualRole, "name");
+	const tagsDesc = Object.getOwnPropertyDescriptor(dualRole, "tags");
+	const explicitName = nameDesc?.enumerable === true && typeof nameDesc.value === "string" ? nameDesc.value : void 0;
+	const explicitTags = tagsDesc?.enumerable === true ? tagsDesc.value : void 0;
+	if (explicitName !== void 0 && explicitTags !== void 0) return {
+		...base,
+		name: explicitName,
+		tags: explicitTags
 	};
-	return {
-		token,
-		optional
+	if (explicitName !== void 0) return {
+		...base,
+		name: explicitName
 	};
+	if (explicitTags !== void 0) return {
+		...base,
+		tags: explicitTags
+	};
+	return base;
 }
-/**
-* Type guard — returns `true` when `value` is a TC39 `ClassAccessorDecoratorContext` (accessor field).
-*/
-function isAccessorDecoratorContext(value) {
-	return typeof value === "object" && value !== null && "kind" in value && value.kind === "accessor";
+function buildInjectionDescriptor(t, options) {
+	const base = {
+		token: t,
+		optional: false,
+		multi: false
+	};
+	if (options?.name !== void 0 && options.tags !== void 0) return {
+		...base,
+		name: options.name,
+		tags: options.tags
+	};
+	if (options?.name !== void 0) return {
+		...base,
+		name: options.name
+	};
+	if (options?.tags !== void 0) return {
+		...base,
+		tags: options.tags
+	};
+	return base;
 }
-/**
-* Dual-purpose injection helper:
-*
-* **1. As a deps-array entry** — returns an {@link InjectionDescriptor} carrying the token,
-* optional flag (`false`), and any name/tag hint. Used inside `@injectable([...deps])`.
-*
-* ```ts
-* @injectable([inject(Logger, { name: 'file' })])
-* class UserService { constructor(log: Logger) {} }
-* ```
-*
-* **2. As a Stage 3 accessor decorator** — writes accessor-injection metadata into
-* `Symbol.metadata` and returns a no-op sentinel. The container performs the actual
-* injection after construction.
-*
-* ```ts
-* @inject(Logger) accessor logger!: LoggerService;
-* ```
-*
-* @param token - The injection key (token or constructor) to resolve.
-* @param optionsOrContext - Either an {@link InjectOptions} hint or the TC39
-*   `ClassAccessorDecoratorContext` automatically supplied by the runtime.
-*/
-function inject(token, optionsOrContext) {
-	if (isAccessorDecoratorContext(optionsOrContext)) {
-		const ctx = optionsOrContext;
-		const metaRecord = ctx.metadata;
-		const key = CODEFAST_DI_ACCESSOR_INJECTIONS;
-		if (!Array.isArray(metaRecord[key])) metaRecord[key] = [];
-		metaRecord[key].push({
-			name: String(ctx.name),
-			token,
-			optional: false
+function inject(t, options) {
+	const descriptor = buildInjectionDescriptor(t, options);
+	const decoratorFn = (_target, context) => {
+		const meta = context.metadata;
+		if (!Array.isArray(meta[INJECT_ACCESSOR_KEY])) meta[INJECT_ACCESSOR_KEY] = [];
+		meta[INJECT_ACCESSOR_KEY].push({
+			key: context.name,
+			descriptor
 		});
-		return;
-	}
-	return toDescriptor(token, false, optionsOrContext);
-}
-/**
-* Same as {@link inject} but marks the dependency as optional (`InjectionDescriptor.optional = true`).
-* During resolution, an unbound token resolves to `undefined` instead of throwing
-* {@link TokenNotBoundError}. Only usable as a deps-array entry (not as an accessor decorator).
-*/
-function optional(token, options) {
-	return toDescriptor(token, true, options);
+		context.addInitializer(function() {
+			const container = getActiveContainer();
+			if (container === void 0) throw new MissingContainerContextError(String(context.name));
+			const hint = options === void 0 ? void 0 : injectableSlotToResolveOptions({
+				...options.name !== void 0 ? { name: options.name } : {},
+				...options.tags !== void 0 ? { tags: options.tags } : {}
+			});
+			const value = descriptor.optional ? container.resolveOptional(t, hint) : container.resolve(t, hint);
+			context.access.set(this, value);
+		});
+		return {};
+	};
+	const props = {};
+	for (const key of Object.keys(descriptor)) props[key] = {
+		value: descriptor[key],
+		writable: true,
+		enumerable: true,
+		configurable: true
+	};
+	Object.defineProperties(decoratorFn, props);
+	return decoratorFn;
 }
-/**
-* Deps-array helper for `@injectable()`: injects **all** bindings registered for `token`
-* (same semantics as {@link Container.resolveAll} / {@link ResolutionContext.resolveAll}).
-* Use for multi-binding — constructor parameter type should be `T[]` (or a readonly array).
-*
-* Optional {@link InjectOptions.name} / `tag` narrow which bindings are collected (unusual; most
-* callers omit options and register disambiguators on each binding instead).
-*/
-function injectAll(token, options) {
-	return {
-		...toDescriptor(token, false, options),
-		all: true
+function optional(t, options) {
+	const base = {
+		token: t,
+		optional: true,
+		multi: false
+	};
+	if (options?.name !== void 0 && options.tags !== void 0) return {
+		...base,
+		name: options.name,
+		tags: options.tags
+	};
+	if (options?.name !== void 0) return {
+		...base,
+		name: options.name
 	};
+	if (options?.tags !== void 0) return {
+		...base,
+		tags: options.tags
+	};
+	return base;
 }
-/**
-* Type-guard — returns `true` when `value` is an {@link InjectionDescriptor}.
-*/
-function isInjectionDescriptor(value) {
-	if (typeof value !== "object" || value === null) return false;
-	return "token" in value && "optional" in value;
+function injectAll(t, options) {
+	const base = {
+		token: t,
+		optional: false,
+		multi: true
+	};
+	if (options?.name !== void 0 && options.tags !== void 0) return {
+		...base,
+		name: options.name,
+		tags: options.tags
+	};
+	if (options?.name !== void 0) return {
+		...base,
+		name: options.name
+	};
+	if (options?.tags !== void 0) return {
+		...base,
+		tags: options.tags
+	};
+	return base;
 }
 //#endregion
-export { inject, injectAll, isInjectionDescriptor, optional };
+export { inject, injectAll, isInjectionDescriptor, normalizeToDescriptor, optional };

package/dist/decorators/injectable.d.mts

@@ -1,41 +1,20 @@
-import { Token } from "../token.mjs";
-import { BindingScope, Constructor } from "../binding.mjs";
-import { InjectionDescriptor } from "../metadata/metadata-types.mjs";
+import { Constructor } from "../constructor-type.mjs";
+import { BindingScope } from "../types.mjs";
+import { InjectableDependency } from "./inject.mjs";
 
 //#region src/decorators/injectable.d.ts
-/**
- * A single entry in the `deps` array passed to `@injectable()`.
- * Can be a plain token/constructor (resolved with no hint) or an {@link InjectionDescriptor}
- * produced by `inject` / `optional` / `injectAll` when name, tag, optional, or resolve-all
- * semantics are needed.
- */
-type InjectableDependency = Token<unknown> | Constructor<unknown> | InjectionDescriptor<unknown>;
-/**
- * Returns all classes decorated with `@injectable({ autoRegister: true })`.
- * Pass to {@link Container.loadAutoRegistered} or iterate manually to bind them.
- */
-declare function getAutoRegistered(): ReadonlyArray<{
-  implementationClass: Constructor<unknown>;
-  scope: BindingScope;
-}>;
-/**
- * Stage 3 class decorator that writes constructor dependency metadata into `Symbol.metadata`.
- *
- * @param deps - Ordered list of constructor parameters; length must match the class arity.
- * @param autoRegisterOptions - Optional auto-registration flags.
- * @param autoRegisterOptions.autoRegister - When `true`, registers the class in {@link getAutoRegistered} at
- *   class-definition time so {@link Container.loadAutoRegistered} can bind it automatically.
- * @param autoRegisterOptions.scope - Scope used when auto-registering; defaults to `"transient"`.
- *
- * @example
- * ```ts
- * @injectable([Logger, inject(Config, { name: "app" })])
- * class UserService { constructor(log: Logger, cfg: AppConfig) {} }
- * ```
- */
-declare function injectable(deps?: readonly InjectableDependency[], autoRegisterOptions?: {
-  autoRegister?: boolean;
+interface AutoRegisterRegistry {
+  register(target: Constructor, scope: BindingScope): void;
+  entries(): ReadonlyArray<{
+    target: Constructor;
+    scope: BindingScope;
+  }>;
+}
+declare function createAutoRegisterRegistry(): AutoRegisterRegistry;
+interface InjectableOptions {
+  autoRegister?: AutoRegisterRegistry;
   scope?: BindingScope;
-}): <Class extends abstract new (...args: never[]) => unknown>(implementationClass: Class, context: ClassDecoratorContext<Class>) => void;
+}
+declare function injectable(deps?: readonly InjectableDependency[], options?: InjectableOptions): (target: unknown, context: ClassDecoratorContext) => void;
 //#endregion
-export { InjectableDependency, getAutoRegistered, injectable };
+export { AutoRegisterRegistry, type InjectableDependency, InjectableOptions, createAutoRegisterRegistry, injectable };

package/dist/decorators/injectable.mjs

@@ -1,74 +1,55 @@
-import { InternalError } from "../errors.mjs";
-import { CODEFAST_DI_CONSTRUCTOR_METADATA } from "../metadata/metadata-keys.mjs";
-import { isInjectionDescriptor } from "./inject.mjs";
+import { INJECTABLE_KEY, constructorMetadataMap } from "../metadata/metadata-keys.mjs";
+import { normalizeToDescriptor } from "./inject.mjs";
 //#region src/decorators/injectable.ts
-/**
-* Global mutable registry of classes decorated with `@injectable({ autoRegister: true })`.
-* Populated at class-definition time (via `context.addInitializer`), drained by
-* {@link Container.loadAutoRegistered}. Entries accumulate for the lifetime of the process.
-*/
-const AUTO_REGISTER_REGISTRY = [];
-/**
-* Returns all classes decorated with `@injectable({ autoRegister: true })`.
-* Pass to {@link Container.loadAutoRegistered} or iterate manually to bind them.
-*/
-function getAutoRegistered() {
-	return AUTO_REGISTER_REGISTRY;
-}
-/**
-* Normalises a single `@injectable` deps-array entry into the uniform {@link ParamMetadata}
-* shape used by the resolver's constructor-instantiation path.
-*
-* - {@link InjectionDescriptor} entries carry `optional`, `name`, and `tag` fields.
-* - Plain token / constructor entries are wrapped with `optional: false` and no hint.
-*/
-function toParamMetadata(dependency, index) {
-	if (isInjectionDescriptor(dependency)) return {
-		index,
-		token: dependency.token,
-		optional: dependency.optional,
-		name: dependency.name,
-		tag: dependency.tag,
-		all: dependency.all === true ? true : void 0
-	};
+function createAutoRegisterRegistry() {
+	const _entries = [];
 	return {
-		index,
-		token: dependency,
-		optional: false
+		register(target, scope) {
+			_entries.push({
+				target,
+				scope
+			});
+		},
+		entries() {
+			return _entries;
+		}
 	};
 }
-/**
-* Stage 3 class decorator that writes constructor dependency metadata into `Symbol.metadata`.
-*
-* @param deps - Ordered list of constructor parameters; length must match the class arity.
-* @param autoRegisterOptions - Optional auto-registration flags.
-* @param autoRegisterOptions.autoRegister - When `true`, registers the class in {@link getAutoRegistered} at
-*   class-definition time so {@link Container.loadAutoRegistered} can bind it automatically.
-* @param autoRegisterOptions.scope - Scope used when auto-registering; defaults to `"transient"`.
-*
-* @example
-* ```ts
-* @injectable([Logger, inject(Config, { name: "app" })])
-* class UserService { constructor(log: Logger, cfg: AppConfig) {} }
-* ```
-*/
-function injectable(deps = [], autoRegisterOptions) {
-	return (implementationClass, context) => {
-		const declaredArity = implementationClass.length;
-		if (declaredArity !== deps.length) throw new InternalError(`Class "${String(context.name ?? implementationClass.name)}" declares ${String(declaredArity)} constructor parameters but @injectable(...) received ${String(deps.length)} dependency descriptors.`);
-		const payload = { params: deps.map((dependency, index) => toParamMetadata(dependency, index)) };
-		const metadataRecord = context.metadata;
-		metadataRecord[CODEFAST_DI_CONSTRUCTOR_METADATA] = payload;
-		if (autoRegisterOptions?.autoRegister === true) {
-			const scope = autoRegisterOptions.scope ?? "transient";
-			context.addInitializer(function() {
-				AUTO_REGISTER_REGISTRY.push({
-					implementationClass: this,
-					scope
-				});
-			});
+function injectable(deps, options) {
+	return function(target, context) {
+		const constructorMeta = { params: (deps ?? []).map((dep, index) => {
+			const descriptor = normalizeToDescriptor(dep);
+			const base = {
+				index,
+				token: descriptor.token,
+				optional: descriptor.optional,
+				multi: descriptor.multi
+			};
+			if (descriptor.name !== void 0 && descriptor.tags !== void 0) return {
+				...base,
+				name: descriptor.name,
+				tags: descriptor.tags
+			};
+			if (descriptor.name !== void 0) return {
+				...base,
+				name: descriptor.name
+			};
+			if (descriptor.tags !== void 0) return {
+				...base,
+				tags: descriptor.tags
+			};
+			return base;
+		}) };
+		constructorMetadataMap.set(target, constructorMeta);
+		try {
+			const meta = context.metadata;
+			if (meta !== null && typeof meta === "object") meta[INJECTABLE_KEY] = constructorMeta;
+		} catch {}
+		if (options?.autoRegister !== void 0) {
+			const scope = options.scope ?? "transient";
+			options.autoRegister.register(target, scope);
 		}
 	};
 }
 //#endregion
-export { getAutoRegistered, injectable };
+export { createAutoRegisterRegistry, injectable };

package/dist/decorators/lifecycle-decorators.d.mts

@@ -1,25 +1,5 @@
 //#region src/decorators/lifecycle-decorators.d.ts
-/**
- * Stage 3 method decorator: marks a method to be called after the class is instantiated
- * by the container and before the `onActivation` hook runs.
- *
- * Lifecycle order: `new Class(…)` → **`@postConstruct()`** → `onActivation()` → scope cache.
- *
- * Only one method per class may carry this decorator; a second application throws.
- * If the decorated method returns a `Promise` during synchronous resolution,
- * {@link AsyncResolutionError} is thrown — use `Container.resolveAsync()` instead.
- */
-declare function postConstruct(): (target: () => unknown, context: ClassMethodDecoratorContext) => void;
-/**
- * Stage 3 method decorator: marks a method to be called when the container disposes or
- * unloads the owning binding.
- *
- * Lifecycle order: `onDeactivation()` → **`@preDestroy()`**.
- *
- * Only one method per class may carry this decorator; a second application throws.
- * If the decorated method returns a `Promise` during synchronous disposal,
- * an error is thrown — use `Container.disposeAsync()` instead.
- */
-declare function preDestroy(): (target: () => unknown, context: ClassMethodDecoratorContext) => void;
+declare function postConstruct(): (target: unknown, context: ClassMethodDecoratorContext) => void;
+declare function preDestroy(): (target: unknown, context: ClassMethodDecoratorContext) => void;
 //#endregion
 export { postConstruct, preDestroy };

package/dist/decorators/lifecycle-decorators.mjs

@@ -1,45 +1,89 @@
-import { CODEFAST_DI_LIFECYCLE_METADATA } from "../metadata/metadata-keys.mjs";
+import { LIFECYCLE_KEY, lifecycleByConstructorMetadataMap, lifecycleMetadataMap } from "../metadata/metadata-keys.mjs";
 //#region src/decorators/lifecycle-decorators.ts
-/**
-* Stage 3 method decorator: marks a method to be called after the class is instantiated
-* by the container and before the `onActivation` hook runs.
-*
-* Lifecycle order: `new Class(…)` → **`@postConstruct()`** → `onActivation()` → scope cache.
-*
-* Only one method per class may carry this decorator; a second application throws.
-* If the decorated method returns a `Promise` during synchronous resolution,
-* {@link AsyncResolutionError} is thrown — use `Container.resolveAsync()` instead.
-*/
+function appendUniqueMethod(metadata, phase, methodName) {
+	if (!metadata[phase].includes(methodName)) metadata[phase].push(methodName);
+}
+function resolveConstructorFromDecoratorTarget(target) {
+	if (typeof target === "function") return target;
+	if (typeof target === "object" && target !== null) {
+		const ctor = target.constructor;
+		if (typeof ctor === "function") return ctor;
+	}
+}
+function registerByConstructor(target, phase, methodName) {
+	const ctor = resolveConstructorFromDecoratorTarget(target);
+	if (ctor === void 0) return;
+	const ctorExisting = lifecycleByConstructorMetadataMap.get(ctor);
+	if (ctorExisting !== void 0) appendUniqueMethod(ctorExisting, phase, methodName);
+	else lifecycleByConstructorMetadataMap.set(ctor, {
+		postConstruct: phase === "postConstruct" ? [methodName] : [],
+		preDestroy: phase === "preDestroy" ? [methodName] : []
+	});
+}
 function postConstruct() {
-	return (_target, context) => {
-		const metaRecord = context.metadata;
-		const existing = metaRecord["codefast/di:lifecycle-metadata:v1"] ?? {};
-		if (existing.postConstruct !== void 0) throw new Error(`@postConstruct() is already defined as "${existing.postConstruct}" on this class.`);
-		metaRecord[CODEFAST_DI_LIFECYCLE_METADATA] = {
-			...existing,
-			postConstruct: String(context.name)
-		};
+	return function(target, context) {
+		const methodName = String(context.name);
+		registerByConstructor(target, "postConstruct", methodName);
+		const existing = lifecycleMetadataMap.get(context.metadata);
+		if (existing !== void 0) appendUniqueMethod(existing, "postConstruct", methodName);
+		else lifecycleMetadataMap.set(context.metadata, {
+			postConstruct: [methodName],
+			preDestroy: []
+		});
+		context.addInitializer(function() {
+			const targetOrInstance = this;
+			const ctor = typeof targetOrInstance === "function" ? targetOrInstance : targetOrInstance.constructor;
+			const ctorExisting = lifecycleByConstructorMetadataMap.get(ctor);
+			if (ctorExisting !== void 0) appendUniqueMethod(ctorExisting, "postConstruct", methodName);
+			else lifecycleByConstructorMetadataMap.set(ctor, {
+				postConstruct: [methodName],
+				preDestroy: []
+			});
+		});
+		try {
+			const meta = context.metadata;
+			if (meta !== null && typeof meta === "object") {
+				if (!meta[LIFECYCLE_KEY]) meta[LIFECYCLE_KEY] = {
+					postConstruct: [],
+					preDestroy: []
+				};
+				const lifecycle = meta[LIFECYCLE_KEY];
+				appendUniqueMethod(lifecycle, "postConstruct", methodName);
+			}
+		} catch {}
 	};
 }
-/**
-* Stage 3 method decorator: marks a method to be called when the container disposes or
-* unloads the owning binding.
-*
-* Lifecycle order: `onDeactivation()` → **`@preDestroy()`**.
-*
-* Only one method per class may carry this decorator; a second application throws.
-* If the decorated method returns a `Promise` during synchronous disposal,
-* an error is thrown — use `Container.disposeAsync()` instead.
-*/
 function preDestroy() {
-	return (_target, context) => {
-		const metaRecord = context.metadata;
-		const existing = metaRecord["codefast/di:lifecycle-metadata:v1"] ?? {};
-		if (existing.preDestroy !== void 0) throw new Error(`@preDestroy() is already defined as "${existing.preDestroy}" on this class.`);
-		metaRecord[CODEFAST_DI_LIFECYCLE_METADATA] = {
-			...existing,
-			preDestroy: String(context.name)
-		};
+	return function(target, context) {
+		const methodName = String(context.name);
+		registerByConstructor(target, "preDestroy", methodName);
+		const existing = lifecycleMetadataMap.get(context.metadata);
+		if (existing !== void 0) appendUniqueMethod(existing, "preDestroy", methodName);
+		else lifecycleMetadataMap.set(context.metadata, {
+			postConstruct: [],
+			preDestroy: [methodName]
+		});
+		context.addInitializer(function() {
+			const targetOrInstance = this;
+			const ctor = typeof targetOrInstance === "function" ? targetOrInstance : targetOrInstance.constructor;
+			const ctorExisting = lifecycleByConstructorMetadataMap.get(ctor);
+			if (ctorExisting !== void 0) appendUniqueMethod(ctorExisting, "preDestroy", methodName);
+			else lifecycleByConstructorMetadataMap.set(ctor, {
+				postConstruct: [],
+				preDestroy: [methodName]
+			});
+		});
+		try {
+			const meta = context.metadata;
+			if (meta !== null && typeof meta === "object") {
+				if (!meta[LIFECYCLE_KEY]) meta[LIFECYCLE_KEY] = {
+					postConstruct: [],
+					preDestroy: []
+				};
+				const lifecycle = meta[LIFECYCLE_KEY];
+				appendUniqueMethod(lifecycle, "preDestroy", methodName);
+			}
+		} catch {}
 	};
 }
 //#endregion