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

package/dist/lifecycle.d.mts

@@ -1,56 +1,23 @@
-import { Binding, Constructor, ResolutionContext } from "./binding.mjs";
-import { LifecycleMetadata } from "./metadata/metadata-types.mjs";
+import { Constructor } from "./constructor-type.mjs";
+import { Token } from "./token.mjs";
+import { ActivationHandler, DeactivationHandler, ResolutionContext } from "./types.mjs";
+import { Binding } from "./binding.mjs";
+import { MetadataReader } from "./metadata/metadata-types.mjs";
 
 //#region src/lifecycle.d.ts
-/**
- * Duck-typed Promise check: returns `true` when `value` has a `then` method.
- * Used throughout the lifecycle layer to guard against async return values on sync resolution paths.
- */
-declare function isPromiseLike(value: unknown): value is Promise<unknown>;
-/**
- * Runs `onActivation` synchronously on a newly constructed instance.
- * If the handler returns a Promise during synchronous resolution, throws
- * {@link AsyncResolutionError} — callers must use `resolveAsync` for async activation handlers.
- *
- * Lifecycle ordering: `construct` → `@postConstruct` → **`onActivation`** → cache.
- */
-declare function runActivation(binding: Binding<unknown>, instance: unknown, ctx: ResolutionContext, pathLabels: readonly string[]): unknown;
-/**
- * Reads lifecycle metadata ({@link LifecycleMetadata}) directly from a constructor's
- * `Symbol.metadata` object. Bypasses the {@link MetadataReader} abstraction —
- * used by the scope manager during deactivation when the reader is not available.
- */
-declare function readLifecycleMetadataFromCtor(implementationClass: Constructor<unknown>): LifecycleMetadata | undefined;
-/**
- * Runs the `@postConstruct()` method synchronously if present.
- * Throws {@link AsyncResolutionError} if the method returns a Promise — async lifecycle
- * methods require `resolveAsync`.
- *
- * Lifecycle ordering: `construct` → **`@postConstruct`** → `onActivation` → cache.
- */
-declare function runPostConstruct(implementationClass: Constructor<unknown>, instance: unknown, pathLabels?: string[]): void;
-/**
- * Runs the `@postConstruct()` method, awaiting if it returns a Promise.
- */
-declare function runPostConstructAsync(implementationClass: Constructor<unknown>, instance: unknown): Promise<void>;
-/**
- * Runs the `@preDestroy()` method synchronously if present.
- * Throws if the method returns a Promise — use `disposeAsync()` / `unloadAsync()` for async teardown.
- *
- * Lifecycle ordering: `onDeactivation` → **`@preDestroy`**.
- */
-declare function runPreDestroy(implementationClass: Constructor<unknown>, instance: unknown): void;
-/**
- * Runs the `@preDestroy()` method, awaiting if it returns a Promise.
- *
- * Lifecycle ordering: `onDeactivation` → **`@preDestroy`** (async variant).
- */
-declare function runPreDestroyAsync(implementationClass: Constructor<unknown>, instance: unknown): Promise<void>;
-/**
- * Runs `onActivation`, awaiting if the handler returns a Promise.
- *
- * Lifecycle ordering: `construct` → `@postConstruct` → **`onActivation`** (async variant) → cache.
- */
-declare function runActivationAsync(binding: Binding<unknown>, instance: unknown, ctx: ResolutionContext, _pathLabels: readonly string[]): Promise<unknown>;
+declare class LifecycleManager {
+  private readonly _activationHooks;
+  private readonly _deactivationHooks;
+  private _activationVersion;
+  registerActivation<const Value>(t: Token<Value> | Constructor<Value>, handler: ActivationHandler<Value>): void;
+  hasActivationHandlers<const Value>(t: Token<Value> | Constructor<Value>): boolean;
+  get activationVersion(): number;
+  registerDeactivation<const Value>(t: Token<Value> | Constructor<Value>, handler: DeactivationHandler<Value>): void;
+  runActivation<const Value>(ctx: ResolutionContext, binding: Binding<Value>, instance: Value, metadataReader: MetadataReader): Promise<Value>;
+  runActivationSync<const Value>(ctx: ResolutionContext, binding: Binding<Value>, instance: Value, metadataReader: MetadataReader): Value;
+  runDeactivation<const Value>(binding: Binding<Value>, instance: Value, metadataReader: MetadataReader): Promise<void>;
+  runDeactivationSync<const Value>(binding: Binding<Value>, instance: Value, metadataReader: MetadataReader): void;
+  hasAsyncDeactivation<const Value>(binding: Binding<Value>, instance: Value, _metadataReader: MetadataReader): boolean;
+}
 //#endregion
-export { isPromiseLike, readLifecycleMetadataFromCtor, runActivation, runActivationAsync, runPostConstruct, runPostConstructAsync, runPreDestroy, runPreDestroyAsync };
+export { LifecycleManager };

package/dist/lifecycle.mjs

@@ -1,102 +1,132 @@
-import { AsyncResolutionError } from "./errors.mjs";
-import { CODEFAST_DI_LIFECYCLE_METADATA, decoratorMetadataObjectSymbol } from "./metadata/metadata-keys.mjs";
+import { AsyncDeactivationError } from "./errors.mjs";
+import { tokenName } from "./token.mjs";
 //#region src/lifecycle.ts
-/**
-* Duck-typed Promise check: returns `true` when `value` has a `then` method.
-* Used throughout the lifecycle layer to guard against async return values on sync resolution paths.
-*/
-function isPromiseLike(value) {
-	return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
-}
-/**
-* Runs `onActivation` synchronously on a newly constructed instance.
-* If the handler returns a Promise during synchronous resolution, throws
-* {@link AsyncResolutionError} — callers must use `resolveAsync` for async activation handlers.
-*
-* Lifecycle ordering: `construct` → `@postConstruct` → **`onActivation`** → cache.
-*/
-function runActivation(binding, instance, ctx, pathLabels) {
-	const handler = binding.onActivation;
-	if (handler === void 0) return instance;
-	const bindingLabel = pathLabels[pathLabels.length - 1] ?? "(unknown)";
-	const activationResult = handler(ctx, instance);
-	if (isPromiseLike(activationResult)) throw new AsyncResolutionError(bindingLabel, pathLabels, "onActivation returned a Promise during synchronous resolution");
-	return activationResult;
-}
-/**
-* Reads lifecycle metadata ({@link LifecycleMetadata}) directly from a constructor's
-* `Symbol.metadata` object. Bypasses the {@link MetadataReader} abstraction —
-* used by the scope manager during deactivation when the reader is not available.
-*/
-function readLifecycleMetadataFromCtor(implementationClass) {
-	const metadataObject = implementationClass[decoratorMetadataObjectSymbol()];
-	if (typeof metadataObject !== "object" || metadataObject === null) return;
-	const raw = metadataObject[CODEFAST_DI_LIFECYCLE_METADATA];
-	return typeof raw === "object" && raw !== null ? raw : void 0;
-}
-/**
-* Runs the `@postConstruct()` method synchronously if present.
-* Throws {@link AsyncResolutionError} if the method returns a Promise — async lifecycle
-* methods require `resolveAsync`.
-*
-* Lifecycle ordering: `construct` → **`@postConstruct`** → `onActivation` → cache.
-*/
-function runPostConstruct(implementationClass, instance, pathLabels) {
-	const meta = readLifecycleMetadataFromCtor(implementationClass);
-	if (meta?.postConstruct === void 0) return;
-	const methodName = meta.postConstruct;
-	const lifecycleMethod = instance[methodName];
-	if (typeof lifecycleMethod !== "function") return;
-	if (isPromiseLike(lifecycleMethod.call(instance))) {
-		const labels = pathLabels ?? [];
-		throw new AsyncResolutionError(labels[labels.length - 1] ?? "(unknown)", labels, `@postConstruct() "${methodName}" returned a Promise during synchronous resolution`);
+var LifecycleManager = class {
+	_activationHooks = /* @__PURE__ */ new Map();
+	_deactivationHooks = /* @__PURE__ */ new Map();
+	_activationVersion = 0;
+	registerActivation(t, handler) {
+		this._activationVersion += 1;
+		let list = this._activationHooks.get(t);
+		if (list === void 0) {
+			list = [];
+			this._activationHooks.set(t, list);
+		}
+		list.push(handler);
 	}
-}
-/**
-* Runs the `@postConstruct()` method, awaiting if it returns a Promise.
-*/
-async function runPostConstructAsync(implementationClass, instance) {
-	const meta = readLifecycleMetadataFromCtor(implementationClass);
-	if (meta?.postConstruct === void 0) return;
-	const lifecycleMethod = instance[meta.postConstruct];
-	if (typeof lifecycleMethod !== "function") return;
-	await lifecycleMethod.call(instance);
-}
-/**
-* Runs the `@preDestroy()` method synchronously if present.
-* Throws if the method returns a Promise — use `disposeAsync()` / `unloadAsync()` for async teardown.
-*
-* Lifecycle ordering: `onDeactivation` → **`@preDestroy`**.
-*/
-function runPreDestroy(implementationClass, instance) {
-	const meta = readLifecycleMetadataFromCtor(implementationClass);
-	if (meta?.preDestroy === void 0) return;
-	const methodName = meta.preDestroy;
-	const lifecycleMethod = instance[methodName];
-	if (typeof lifecycleMethod !== "function") return;
-	if (isPromiseLike(lifecycleMethod.call(instance))) throw new Error(`@preDestroy() "${methodName}" returned a Promise during synchronous disposal; use disposeAsync() / unloadAsync().`);
-}
-/**
-* Runs the `@preDestroy()` method, awaiting if it returns a Promise.
-*
-* Lifecycle ordering: `onDeactivation` → **`@preDestroy`** (async variant).
-*/
-async function runPreDestroyAsync(implementationClass, instance) {
-	const meta = readLifecycleMetadataFromCtor(implementationClass);
-	if (meta?.preDestroy === void 0) return;
-	const lifecycleMethod = instance[meta.preDestroy];
-	if (typeof lifecycleMethod !== "function") return;
-	await lifecycleMethod.call(instance);
-}
-/**
-* Runs `onActivation`, awaiting if the handler returns a Promise.
-*
-* Lifecycle ordering: `construct` → `@postConstruct` → **`onActivation`** (async variant) → cache.
-*/
-async function runActivationAsync(binding, instance, ctx, _pathLabels) {
-	const handler = binding.onActivation;
-	if (handler === void 0) return instance;
-	return await handler(ctx, instance);
-}
+	hasActivationHandlers(t) {
+		if (this._activationHooks.size === 0) return false;
+		const list = this._activationHooks.get(t);
+		return list !== void 0 && list.length > 0;
+	}
+	get activationVersion() {
+		return this._activationVersion;
+	}
+	registerDeactivation(t, handler) {
+		let list = this._deactivationHooks.get(t);
+		if (list === void 0) {
+			list = [];
+			this._deactivationHooks.set(t, list);
+		}
+		list.push(handler);
+	}
+	async runActivation(ctx, binding, instance, metadataReader) {
+		let result = instance;
+		if (binding.kind === "class") {
+			const lifecycle = metadataReader.getLifecycleMetadata(binding.target);
+			if (lifecycle?.postConstruct && lifecycle.postConstruct.length > 0) for (const methodName of lifecycle.postConstruct) {
+				const method = result[methodName];
+				if (typeof method === "function") {
+					const r = method.call(result);
+					if (r instanceof Promise) await r;
+				}
+			}
+		}
+		if (binding.kind !== "alias" && binding.onActivation !== void 0) {
+			const activated = binding.onActivation(ctx, result);
+			result = activated instanceof Promise ? await activated : activated;
+		}
+		const containerHooks = this._activationHooks.get(binding.token);
+		if (containerHooks !== void 0) for (const hook of containerHooks) {
+			const activated = hook(ctx, result);
+			result = activated instanceof Promise ? await activated : activated;
+		}
+		return result;
+	}
+	runActivationSync(ctx, binding, instance, metadataReader) {
+		let result = instance;
+		if (binding.kind === "class") {
+			const lifecycle = metadataReader.getLifecycleMetadata(binding.target);
+			if (lifecycle?.postConstruct && lifecycle.postConstruct.length > 0) for (const methodName of lifecycle.postConstruct) {
+				const method = result[methodName];
+				if (typeof method === "function") {
+					if (method.call(result) instanceof Promise) throw new Error(`@postConstruct method '${methodName}' returned a Promise. Use resolveAsync() instead.`);
+				}
+			}
+		}
+		if (binding.kind !== "alias" && binding.onActivation !== void 0) {
+			const activated = binding.onActivation(ctx, result);
+			if (activated instanceof Promise) throw new Error(`onActivation for '${tokenName(binding.token)}' returned a Promise. Use resolveAsync() instead.`);
+			result = activated;
+		}
+		const key = tokenName(binding.token);
+		const containerHooks = this._activationHooks.get(binding.token);
+		if (containerHooks !== void 0) for (const hook of containerHooks) {
+			const activated = hook(ctx, result);
+			if (activated instanceof Promise) throw new Error(`Container-level onActivation for '${key}' returned a Promise. Use resolveAsync() instead.`);
+			result = activated;
+		}
+		return result;
+	}
+	async runDeactivation(binding, instance, metadataReader) {
+		const key = binding.token;
+		const containerHooks = this._deactivationHooks.get(key);
+		if (containerHooks !== void 0) for (const hook of containerHooks) {
+			const r = hook(instance);
+			if (r instanceof Promise) await r;
+		}
+		if (binding.kind !== "alias" && binding.onDeactivation !== void 0) {
+			const r = binding.onDeactivation(instance);
+			if (r instanceof Promise) await r;
+		}
+		if (binding.kind === "class") {
+			const lifecycle = metadataReader.getLifecycleMetadata(binding.target);
+			if (lifecycle?.preDestroy && lifecycle.preDestroy.length > 0) for (const methodName of lifecycle.preDestroy) {
+				const method = instance[methodName];
+				if (typeof method === "function") {
+					const r = method.call(instance);
+					if (r instanceof Promise) await r;
+				}
+			}
+		}
+	}
+	runDeactivationSync(binding, instance, metadataReader) {
+		const tName = tokenName(binding.token);
+		const key = binding.token;
+		const containerHooks = this._deactivationHooks.get(key);
+		if (containerHooks !== void 0) {
+			for (const hook of containerHooks) if (hook(instance) instanceof Promise) throw new AsyncDeactivationError(tName);
+		}
+		if (binding.kind !== "alias" && binding.onDeactivation !== void 0) {
+			if (binding.onDeactivation(instance) instanceof Promise) throw new AsyncDeactivationError(tName);
+		}
+		if (binding.kind === "class") {
+			const lifecycle = metadataReader.getLifecycleMetadata(binding.target);
+			if (lifecycle?.preDestroy && lifecycle.preDestroy.length > 0) for (const methodName of lifecycle.preDestroy) {
+				const method = instance[methodName];
+				if (typeof method === "function") {
+					if (method.call(instance) instanceof Promise) throw new AsyncDeactivationError(tName);
+				}
+			}
+		}
+	}
+	hasAsyncDeactivation(binding, instance, _metadataReader) {
+		if (binding.kind === "alias") return false;
+		if (binding.onDeactivation !== void 0) {
+			if (binding.onDeactivation(instance) instanceof Promise) return true;
+		}
+		return false;
+	}
+};
 //#endregion
-export { isPromiseLike, readLifecycleMetadataFromCtor, runActivation, runActivationAsync, runPostConstruct, runPostConstructAsync, runPreDestroy, runPreDestroyAsync };
+export { LifecycleManager };

package/dist/metadata/metadata-keys.d.mts

@@ -1,28 +1,11 @@
+import { ConstructorMetadata, MutableLifecycleMetadata } from "./metadata-types.mjs";
+
 //#region src/metadata/metadata-keys.d.ts
-/**
- * Well-known property key for constructor injection metadata on `Symbol.metadata`.
- * Written by `@injectable()`, read by `SymbolMetadataReader.getConstructorMetadata()`.
- * The `:v1` suffix is a schema version — bump only when the `ConstructorMetadata` shape changes.
- */
-declare const CODEFAST_DI_CONSTRUCTOR_METADATA = "codefast/di:constructor-metadata:v1";
-/**
- * Well-known property key for accessor-field injection metadata on `Symbol.metadata`.
- * Written by `@inject()` when used as an accessor decorator; read during post-construction
- * property injection by the resolver.
- */
-declare const CODEFAST_DI_ACCESSOR_INJECTIONS = "codefast/di:accessor-injections:v1";
-/**
- * Well-known key for lifecycle method names written by `@postConstruct()` / `@preDestroy()`.
- */
-declare const CODEFAST_DI_LIFECYCLE_METADATA = "codefast/di:lifecycle-metadata:v1";
-/**
- * Returns the runtime symbol used to access TC39 decorator metadata on a class.
- *
- * Prefers the native `Symbol.metadata` when available (Stage 3 decorators); falls back to
- * `Symbol.for("Symbol.metadata")` for Node/runtime versions that polyfill or partially
- * implement the proposal. The fallback key is the de facto convention used by TypeScript
- * and polyfill libraries.
- */
-declare function decoratorMetadataObjectSymbol(): symbol;
+declare const INJECTABLE_KEY: unique symbol;
+declare const LIFECYCLE_KEY: unique symbol;
+declare const INJECT_ACCESSOR_KEY: unique symbol;
+declare const constructorMetadataMap: WeakMap<object, ConstructorMetadata>;
+declare const lifecycleMetadataMap: WeakMap<object, MutableLifecycleMetadata>;
+declare const lifecycleByConstructorMetadataMap: WeakMap<object, MutableLifecycleMetadata>;
 //#endregion
-export { CODEFAST_DI_ACCESSOR_INJECTIONS, CODEFAST_DI_CONSTRUCTOR_METADATA, CODEFAST_DI_LIFECYCLE_METADATA, decoratorMetadataObjectSymbol };
+export { INJECTABLE_KEY, INJECT_ACCESSOR_KEY, LIFECYCLE_KEY, constructorMetadataMap, lifecycleByConstructorMetadataMap, lifecycleMetadataMap };

package/dist/metadata/metadata-keys.mjs

@@ -1,30 +1,9 @@
 //#region src/metadata/metadata-keys.ts
-/**
-* Well-known property key for constructor injection metadata on `Symbol.metadata`.
-* Written by `@injectable()`, read by `SymbolMetadataReader.getConstructorMetadata()`.
-* The `:v1` suffix is a schema version — bump only when the `ConstructorMetadata` shape changes.
-*/
-const CODEFAST_DI_CONSTRUCTOR_METADATA = "codefast/di:constructor-metadata:v1";
-/**
-* Well-known property key for accessor-field injection metadata on `Symbol.metadata`.
-* Written by `@inject()` when used as an accessor decorator; read during post-construction
-* property injection by the resolver.
-*/
-const CODEFAST_DI_ACCESSOR_INJECTIONS = "codefast/di:accessor-injections:v1";
-/**
-* Well-known key for lifecycle method names written by `@postConstruct()` / `@preDestroy()`.
-*/
-const CODEFAST_DI_LIFECYCLE_METADATA = "codefast/di:lifecycle-metadata:v1";
-/**
-* Returns the runtime symbol used to access TC39 decorator metadata on a class.
-*
-* Prefers the native `Symbol.metadata` when available (Stage 3 decorators); falls back to
-* `Symbol.for("Symbol.metadata")` for Node/runtime versions that polyfill or partially
-* implement the proposal. The fallback key is the de facto convention used by TypeScript
-* and polyfill libraries.
-*/
-function decoratorMetadataObjectSymbol() {
-	return typeof Symbol.metadata === "symbol" ? Symbol.metadata : Symbol.for("Symbol.metadata");
-}
+const INJECTABLE_KEY = Symbol("di:injectable");
+const LIFECYCLE_KEY = Symbol("di:lifecycle");
+const INJECT_ACCESSOR_KEY = Symbol("di:inject-accessor");
+const constructorMetadataMap = /* @__PURE__ */ new WeakMap();
+const lifecycleMetadataMap = /* @__PURE__ */ new WeakMap();
+const lifecycleByConstructorMetadataMap = /* @__PURE__ */ new WeakMap();
 //#endregion
-export { CODEFAST_DI_ACCESSOR_INJECTIONS, CODEFAST_DI_CONSTRUCTOR_METADATA, CODEFAST_DI_LIFECYCLE_METADATA, decoratorMetadataObjectSymbol };
+export { INJECTABLE_KEY, INJECT_ACCESSOR_KEY, LIFECYCLE_KEY, constructorMetadataMap, lifecycleByConstructorMetadataMap, lifecycleMetadataMap };

package/dist/metadata/metadata-reader-token.d.mts

@@ -0,0 +1,7 @@
+import { Token } from "../token.mjs";
+import { MetadataReader } from "./metadata-types.mjs";
+
+//#region src/metadata/metadata-reader-token.d.ts
+declare const MetadataReaderToken: Token<MetadataReader>;
+//#endregion
+export { MetadataReaderToken };

package/dist/metadata/metadata-reader-token.mjs

@@ -0,0 +1,5 @@
+import { token } from "../token.mjs";
+//#region src/metadata/metadata-reader-token.ts
+const MetadataReaderToken = token("MetadataReader");
+//#endregion
+export { MetadataReaderToken };

package/dist/metadata/metadata-types.d.mts

@@ -1,79 +1,30 @@
+import { Constructor } from "../constructor-type.mjs";
 import { Token } from "../token.mjs";
-import { Constructor } from "../binding.mjs";
 
 //#region src/metadata/metadata-types.d.ts
-/**
- * Metadata written per `accessor` field decorated with `@inject`; collected into `Symbol.metadata`.
- */
-type AccessorInjectionMetadata = {
-  readonly name: string;
-  readonly token: Token<unknown> | Constructor<unknown>;
-  readonly optional: boolean;
-  readonly resolveHint?: {
-    readonly name?: string;
-    readonly tag?: readonly [tag: string, value: unknown];
-  };
-};
-/**
- * Lifecycle method names written by `@postConstruct()` / `@preDestroy()` into `Symbol.metadata`.
- */
-type LifecycleMetadata = {
-  readonly postConstruct?: string;
-  readonly preDestroy?: string;
-};
-/**
- * Per-parameter injection description collected by `@injectable()`.
- */
-type ParamMetadata = {
+interface ParamMetadata {
   readonly index: number;
-  readonly token: Token<unknown> | Constructor<unknown>;
-  readonly optional: boolean;
-  readonly name?: string;
-  readonly tag?: readonly [tag: string, value: unknown];
-  /**
-   * When true, the parameter receives every binding for `token` as an array (same semantics as
-   * `Container.resolveAll` / `ResolutionContext.resolveAll`), using `name` / `tag` as a filter when set.
-   */
-  readonly all?: boolean;
-};
-/**
- * Resolved form of an `inject()` / `optional()` call: token + optional flag + optional resolve hint.
- * Used both as a deps-array entry in `@injectable()` and as accessor-field injection metadata.
- */
-type InjectionDescriptor<Value = unknown> = {
-  readonly token: Token<Value> | Constructor<Value>;
+  readonly token: Token<unknown> | Constructor;
   readonly optional: boolean;
+  readonly multi: boolean;
   readonly name?: string;
-  readonly tag?: readonly [tag: string, value: unknown]; /** When true, resolve every binding for {@link InjectionDescriptor.token} into an array. */
-  readonly all?: boolean;
-};
-/**
- * Constructor injection shape stored on the class `Symbol.metadata` object.
- */
-type ConstructorMetadata = {
+  readonly tags?: ReadonlyArray<readonly [string, unknown]>;
+}
+interface ConstructorMetadata {
   readonly params: readonly ParamMetadata[];
-};
-/**
- * Abstraction for reading DI metadata without tying callers to `Symbol.metadata` directly.
- * The {@link DependencyResolver} uses this to instantiate `class` bindings and read lifecycle hooks.
- *
- * The default implementation is {@link SymbolMetadataReader}; consumers can supply a custom
- * reader (e.g. backed by a static config object) via `ResolverDependencies.metadataReader`.
- */
-type MetadataReader = {
-  /**
-   * Returns constructor parameter injection metadata for `implementationClass`, or `undefined`
-   * if the class has no own `@injectable()` metadata. When a {@link MetadataReader} is
-   * configured on the container, `undefined` here combined with `arity > 0` on the class
-   * causes {@link MissingMetadataError} during resolution; when no reader is configured, the
-   * resolver instantiates with zero arguments instead (see `DependencyResolver` class binding path).
-   */
-  getConstructorMetadata(implementationClass: Constructor<unknown>): ConstructorMetadata | undefined;
-  /**
-   * Returns lifecycle method names (`@postConstruct` / `@preDestroy`), or `undefined` if none.
-   * Optional: when absent the resolver skips lifecycle hooks entirely.
-   */
-  getLifecycleMetadata?(implementationClass: Constructor<unknown>): LifecycleMetadata | undefined;
-};
+}
+interface LifecycleMetadata {
+  readonly postConstruct: readonly string[];
+  readonly preDestroy: readonly string[];
+}
+/** Mutable buckets used while aggregating decorator metadata (same keys as {@link LifecycleMetadata}). */
+interface MutableLifecycleMetadata {
+  postConstruct: string[];
+  preDestroy: string[];
+}
+interface MetadataReader {
+  getConstructorMetadata(target: Constructor): ConstructorMetadata | undefined;
+  getLifecycleMetadata(target: Constructor): LifecycleMetadata | undefined;
+}
 //#endregion
-export { AccessorInjectionMetadata, ConstructorMetadata, InjectionDescriptor, LifecycleMetadata, MetadataReader, ParamMetadata };
+export { ConstructorMetadata, LifecycleMetadata, MetadataReader, MutableLifecycleMetadata, ParamMetadata };

package/dist/metadata/symbol-metadata-reader.d.mts

@@ -1,32 +1,16 @@
-import { Constructor } from "../binding.mjs";
+import { Constructor } from "../constructor-type.mjs";
+import { InjectionDescriptor } from "../decorators/inject.mjs";
 import { ConstructorMetadata, LifecycleMetadata, MetadataReader } from "./metadata-types.mjs";
 
 //#region src/metadata/symbol-metadata-reader.d.ts
-/**
- * Default {@link MetadataReader} implementation backed by TC39 `Symbol.metadata`.
- *
- * Constructor metadata (`@injectable()`) is read with `Object.hasOwn` to prevent
- * a subclass from silently inheriting a parent's dependency list — each class must
- * declare its own `@injectable()` decorator or be constructed with zero arguments.
- *
- * Lifecycle metadata (`@postConstruct` / `@preDestroy`) *is* inherited through the
- * prototype chain, matching the intent that a parent's lifecycle hook applies to children.
- */
 declare class SymbolMetadataReader implements MetadataReader {
-  /**
-   * Reads constructor param metadata written by `@injectable()`.
-   * Returns `undefined` if no own metadata is present on the class.
-   *
-   * @remarks
-   * Uses `Object.hasOwn` intentionally — TC39 `Symbol.metadata` prototype-chains from
-   * parent to child, so without this guard a subclass without `@injectable()` would
-   * silently inherit the parent's parameter list and inject the wrong dependency count.
-   */
-  getConstructorMetadata(implementationClass: Constructor<unknown>): ConstructorMetadata | undefined;
-  /**
-   * Reads lifecycle method names written by `@postConstruct()` / `@preDestroy()`. Inherits from parent classes.
-   */
-  getLifecycleMetadata(implementationClass: Constructor<unknown>): LifecycleMetadata | undefined;
+  getConstructorMetadata(target: Constructor): ConstructorMetadata | undefined;
+  getLifecycleMetadata(target: Constructor): LifecycleMetadata | undefined;
+  getAccessorMetadata(target: Constructor): Array<{
+    key: string | symbol;
+    descriptor: InjectionDescriptor;
+  }> | undefined;
 }
+declare const defaultMetadataReader: SymbolMetadataReader;
 //#endregion
-export { SymbolMetadataReader };
+export { SymbolMetadataReader, defaultMetadataReader };

package/dist/metadata/symbol-metadata-reader.mjs

@@ -1,51 +1,38 @@
-import { CODEFAST_DI_CONSTRUCTOR_METADATA, CODEFAST_DI_LIFECYCLE_METADATA, decoratorMetadataObjectSymbol } from "./metadata-keys.mjs";
+import { INJECTABLE_KEY, INJECT_ACCESSOR_KEY, LIFECYCLE_KEY, constructorMetadataMap, lifecycleByConstructorMetadataMap, lifecycleMetadataMap } from "./metadata-keys.mjs";
 //#region src/metadata/symbol-metadata-reader.ts
-/**
-* Type guard — returns `true` when `value` has the shape of a {@link ConstructorMetadata} object.
-*/
-function isConstructorMetadata(value) {
-	if (typeof value !== "object" || value === null || !("params" in value)) return false;
-	return Array.isArray(value.params);
-}
-/**
-* Default {@link MetadataReader} implementation backed by TC39 `Symbol.metadata`.
-*
-* Constructor metadata (`@injectable()`) is read with `Object.hasOwn` to prevent
-* a subclass from silently inheriting a parent's dependency list — each class must
-* declare its own `@injectable()` decorator or be constructed with zero arguments.
-*
-* Lifecycle metadata (`@postConstruct` / `@preDestroy`) *is* inherited through the
-* prototype chain, matching the intent that a parent's lifecycle hook applies to children.
-*/
 var SymbolMetadataReader = class {
-	/**
-	* Reads constructor param metadata written by `@injectable()`.
-	* Returns `undefined` if no own metadata is present on the class.
-	*
-	* @remarks
-	* Uses `Object.hasOwn` intentionally — TC39 `Symbol.metadata` prototype-chains from
-	* parent to child, so without this guard a subclass without `@injectable()` would
-	* silently inherit the parent's parameter list and inject the wrong dependency count.
-	*/
-	getConstructorMetadata(implementationClass) {
-		const rawMetadata = implementationClass[decoratorMetadataObjectSymbol()];
-		if (typeof rawMetadata !== "object" || rawMetadata === null) return;
-		const metadataObject = rawMetadata;
-		if (!Object.hasOwn(metadataObject, "codefast/di:constructor-metadata:v1")) return;
-		const raw = metadataObject[CODEFAST_DI_CONSTRUCTOR_METADATA];
-		if (!isConstructorMetadata(raw)) return;
-		return raw;
+	getConstructorMetadata(target) {
+		const fromWeakMap = constructorMetadataMap.get(target);
+		if (fromWeakMap !== void 0) return fromWeakMap;
+		const own = Object.getOwnPropertyDescriptor(target, Symbol.metadata);
+		if (own === void 0) return;
+		const meta = own.value;
+		if (!meta || typeof meta !== "object" || !Object.hasOwn(meta, INJECTABLE_KEY)) return;
+		return meta[INJECTABLE_KEY];
 	}
-	/**
-	* Reads lifecycle method names written by `@postConstruct()` / `@preDestroy()`. Inherits from parent classes.
-	*/
-	getLifecycleMetadata(implementationClass) {
-		const metadataObject = implementationClass[decoratorMetadataObjectSymbol()];
-		if (typeof metadataObject !== "object" || metadataObject === null) return;
-		const raw = metadataObject[CODEFAST_DI_LIFECYCLE_METADATA];
-		if (typeof raw !== "object" || raw === null) return;
-		return raw;
+	getLifecycleMetadata(target) {
+		const byConstructor = lifecycleByConstructorMetadataMap.get(target);
+		if (byConstructor !== void 0) return byConstructor;
+		const own = Object.getOwnPropertyDescriptor(target, Symbol.metadata);
+		if (own !== void 0) {
+			const meta = own.value;
+			if (meta && typeof meta === "object" && Object.hasOwn(meta, LIFECYCLE_KEY)) return meta[LIFECYCLE_KEY];
+		}
+		const classMeta = target[Symbol.metadata];
+		if (classMeta !== void 0) {
+			const fromWeakMap = lifecycleMetadataMap.get(classMeta);
+			if (fromWeakMap !== void 0) return fromWeakMap;
+		}
+	}
+	getAccessorMetadata(target) {
+		const own = Object.getOwnPropertyDescriptor(target, Symbol.metadata);
+		if (own === void 0) return;
+		const meta = own.value;
+		if (!meta || typeof meta !== "object") return;
+		if (!Object.hasOwn(meta, INJECT_ACCESSOR_KEY)) return;
+		return meta[INJECT_ACCESSOR_KEY];
 	}
 };
+const defaultMetadataReader = new SymbolMetadataReader();
 //#endregion
-export { SymbolMetadataReader };
+export { SymbolMetadataReader, defaultMetadataReader };