@codefast/di 0.3.14-canary.1 → 0.3.14

package/dist/inspector.mjs

@@ -1,96 +1,69 @@
-import { registryKeyLabel } from "./binding-select.mjs";
-import { collectStaticDependencyEdges } from "./dependency-graph.mjs";
+import { effectiveBindingScope } from "./binding-scope.mjs";
+import { selectBinding } from "./binding-select.mjs";
+import { tokenName } from "./token.mjs";
 //#region src/inspector.ts
-/**
-* Maps a binding's scope and cache state to a {@link BindingActivationStatus} label.
-*/
-function activationStatusFor(binding, isCached) {
-	if (binding.scope === "transient") return "transient";
-	return isCached(binding) ? "cached" : "not-cached";
-}
-/**
-* Returns `true` when the label string belongs to a framework-internal registry key.
-*/
-function registryKeyLabelIsInternal(label) {
-	return label.startsWith("CODEFAST_DI_");
-}
-/**
-* Returns `true` when the registry key resolves to an internal framework label.
-*/
-function isInternalRegistryKey(key) {
-	return registryKeyLabelIsInternal(registryKeyLabel(key));
-}
-/**
-* Reads the container's registry and scope-cache state to produce debug snapshots
-* and canonical dependency-graph output (`nodes` + `edges`).
-*
-* Constructed internally by the container; advanced consumers can also construct it
-* directly via the `@codefast/di/inspector` subpath export.
-*/
-var ContainerInspector = class {
-	constructor(ctx) {
-		this.ctx = ctx;
+var Inspector = class {
+	constructor(_registry, _scope, _hasParent, _isDisposed) {
+		this._registry = _registry;
+		this._scope = _scope;
+		this._hasParent = _hasParent;
+		this._isDisposed = _isDisposed;
 	}
-	/**
-	* Collects all registered bindings into a flat, serialisable snapshot.
-	*/
-	getSnapshot() {
-		const bindings = [];
-		const seen = /* @__PURE__ */ new Set();
-		for (const registryKey of this.ctx.collectAllRegistryKeys()) {
-			const list = this.ctx.lookupBindings(registryKey);
-			if (list === void 0 || list.length === 0) continue;
-			const registryLabel = registryKeyLabel(registryKey);
-			for (const binding of list) {
-				if (seen.has(binding.id)) continue;
-				seen.add(binding.id);
-				const row = {
-					registryKeyLabel: registryLabel,
-					bindingId: binding.id,
-					kind: binding.kind,
-					scope: binding.scope,
-					activationStatus: activationStatusFor(binding, (bindingArg) => this.ctx.isBindingCached(bindingArg)),
-					hasConditionalConstraint: binding.constraint !== void 0
-				};
-				bindings.push(binding.moduleId === void 0 ? row : {
-					...row,
-					moduleId: binding.moduleId
-				});
-			}
-		}
-		return { bindings };
+	inspect() {
+		const snapshots = this.allBindingSnapshots();
+		return {
+			ownBindings: snapshots,
+			bindings: snapshots,
+			cachedSingletonCount: this._scope.getAllSingletons().size,
+			hasParent: this._hasParent,
+			isDisposed: this._isDisposed()
+		};
+	}
+	lookupBindings(token) {
+		return this._registry.getAll(token).map((b) => this._toSnapshot(b));
+	}
+	has(token, hint, parentHas) {
+		const bindings = this._registry.getAll(token);
+		if (bindings.length > 0) if (hint !== void 0) {
+			if (selectBinding(bindings, hint, {
+				resolutionPath: [],
+				materializationStack: [],
+				parent: void 0,
+				ancestors: [],
+				currentResolveHint: hint
+			}, tokenName(token)) !== void 0) return true;
+		} else return true;
+		return parentHas?.() ?? false;
+	}
+	hasOwn(token, hint) {
+		const bindings = this._registry.getAll(token);
+		if (bindings.length === 0) return false;
+		if (hint !== void 0) return selectBinding(bindings, hint, {
+			resolutionPath: [],
+			materializationStack: [],
+			parent: void 0,
+			ancestors: [],
+			currentResolveHint: hint
+		}, tokenName(token)) !== void 0;
+		return true;
+	}
+	allBindingSnapshots() {
+		return this._registry.allBindings().map((b) => this._toSnapshot(b));
 	}
-	/**
-	* Builds the canonical JSON graph (`nodes` + `edges`).
-	*/
-	generateDependencyGraph(options) {
-		const hideInternals = options?.hideInternals === true;
-		const snapshot = this.getSnapshot();
-		const visibleNodes = hideInternals ? snapshot.bindings.filter((row) => !registryKeyLabelIsInternal(row.registryKeyLabel)) : [...snapshot.bindings];
-		const allowedBindingIds = new Set(visibleNodes.map((row) => row.bindingId));
-		const edges = [];
-		const edgeSeen = /* @__PURE__ */ new Set();
-		for (const registryKey of this.ctx.collectAllRegistryKeys()) {
-			if (hideInternals && isInternalRegistryKey(registryKey)) continue;
-			const list = this.ctx.lookupBindings(registryKey);
-			if (list === void 0) continue;
-			const pathStart = [registryKeyLabel(registryKey)];
-			for (const consumerBinding of list) {
-				if (hideInternals && !allowedBindingIds.has(consumerBinding.id)) continue;
-				for (const edge of collectStaticDependencyEdges(consumerBinding, (dependencyKey) => this.ctx.lookupBindings(dependencyKey), this.ctx.metadataReader, pathStart)) {
-					if (hideInternals && (!allowedBindingIds.has(edge.fromBindingId) || !allowedBindingIds.has(edge.toBindingId))) continue;
-					const edgeKey = `${edge.fromBindingId}->${edge.toBindingId}:${edge.edgeKind}:${edge.injectHintLabel ?? ""}`;
-					if (edgeSeen.has(edgeKey)) continue;
-					edgeSeen.add(edgeKey);
-					edges.push(edge);
-				}
-			}
-		}
+	_toSnapshot(b) {
+		const scope = effectiveBindingScope(b);
+		const slot = b.slot.name !== void 0 ? {
+			name: b.slot.name,
+			tags: b.slot.tags
+		} : { tags: b.slot.tags };
 		return {
-			nodes: visibleNodes,
-			edges
+			tokenName: tokenName(b.token),
+			kind: b.kind,
+			scope,
+			slot,
+			id: b.id
 		};
 	}
 };
 //#endregion
-export { ContainerInspector };
+export { Inspector };

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 };