@codefast/di 0.3.15 → 0.3.16-canary.1

package/dist/lifecycle.d.mts

@@ -5,19 +5,21 @@ import { Binding } from "./binding.mjs";
 import { MetadataReader } from "./metadata/metadata-types.mjs";
 
 //#region src/lifecycle.d.ts
+/**
+ * @since 0.3.16-canary.0
+ */
 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;
+  registerActivation<const Value>(token: Token<Value> | Constructor<Value>, handler: ActivationHandler<Value>): void;
+  hasActivationHandlers<const Value>(token: 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;
+  registerDeactivation<const Value>(token: Token<Value> | Constructor<Value>, handler: DeactivationHandler<Value>): void;
+  runActivation<const Value>(resolutionContext: ResolutionContext, binding: Binding<Value>, instance: Value, metadataReader: MetadataReader): Promise<Value>;
+  runActivationSync<const Value>(resolutionContext: 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 { LifecycleManager };

package/dist/lifecycle.mjs

@@ -1,132 +1,128 @@
-import { AsyncDeactivationError } from "./errors.mjs";
+import { AsyncActivationError, AsyncDeactivationError } from "./errors.mjs";
 import { tokenName } from "./token.mjs";
 //#region src/lifecycle.ts
+/**
+* @since 0.3.16-canary.0
+*/
 var LifecycleManager = class {
 	_activationHooks = /* @__PURE__ */ new Map();
 	_deactivationHooks = /* @__PURE__ */ new Map();
 	_activationVersion = 0;
-	registerActivation(t, handler) {
+	registerActivation(token, handler) {
 		this._activationVersion += 1;
-		let list = this._activationHooks.get(t);
+		let list = this._activationHooks.get(token);
 		if (list === void 0) {
 			list = [];
-			this._activationHooks.set(t, list);
+			this._activationHooks.set(token, list);
 		}
 		list.push(handler);
 	}
-	hasActivationHandlers(t) {
+	hasActivationHandlers(token) {
 		if (this._activationHooks.size === 0) return false;
-		const list = this._activationHooks.get(t);
+		const list = this._activationHooks.get(token);
 		return list !== void 0 && list.length > 0;
 	}
 	get activationVersion() {
 		return this._activationVersion;
 	}
-	registerDeactivation(t, handler) {
-		let list = this._deactivationHooks.get(t);
+	registerDeactivation(token, handler) {
+		let list = this._deactivationHooks.get(token);
 		if (list === void 0) {
 			list = [];
-			this._deactivationHooks.set(t, list);
+			this._deactivationHooks.set(token, list);
 		}
 		list.push(handler);
 	}
-	async runActivation(ctx, binding, instance, metadataReader) {
-		let result = instance;
+	async runActivation(resolutionContext, binding, instance, metadataReader) {
+		let activatedInstance = 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];
+				const method = activatedInstance[methodName];
 				if (typeof method === "function") {
-					const r = method.call(result);
-					if (r instanceof Promise) await r;
+					const hookResult = method.call(activatedInstance);
+					if (hookResult instanceof Promise) await hookResult;
 				}
 			}
 		}
 		if (binding.kind !== "alias" && binding.onActivation !== void 0) {
-			const activated = binding.onActivation(ctx, result);
-			result = activated instanceof Promise ? await activated : activated;
+			const activationResult = binding.onActivation(resolutionContext, activatedInstance);
+			activatedInstance = activationResult instanceof Promise ? await activationResult : activationResult;
 		}
 		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;
+			const activationResult = hook(resolutionContext, activatedInstance);
+			activatedInstance = activationResult instanceof Promise ? await activationResult : activationResult;
 		}
-		return result;
+		return activatedInstance;
 	}
-	runActivationSync(ctx, binding, instance, metadataReader) {
-		let result = instance;
+	runActivationSync(resolutionContext, binding, instance, metadataReader) {
+		let activatedInstance = 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];
+				const method = activatedInstance[methodName];
 				if (typeof method === "function") {
-					if (method.call(result) instanceof Promise) throw new Error(`@postConstruct method '${methodName}' returned a Promise. Use resolveAsync() instead.`);
+					if (method.call(activatedInstance) instanceof Promise) throw new AsyncActivationError(tokenName(binding.token), "postConstruct", methodName);
 				}
 			}
 		}
 		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 activationResult = binding.onActivation(resolutionContext, activatedInstance);
+			if (activationResult instanceof Promise) throw new AsyncActivationError(tokenName(binding.token), "onActivation");
+			activatedInstance = activationResult;
 		}
-		const key = tokenName(binding.token);
+		const tokenDisplayName = 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;
+			const activationResult = hook(resolutionContext, activatedInstance);
+			if (activationResult instanceof Promise) throw new AsyncActivationError(tokenDisplayName, "onActivation");
+			activatedInstance = activationResult;
 		}
-		return result;
+		return activatedInstance;
 	}
 	async runDeactivation(binding, instance, metadataReader) {
-		const key = binding.token;
-		const containerHooks = this._deactivationHooks.get(key);
+		const tokenKey = binding.token;
+		const containerHooks = this._deactivationHooks.get(tokenKey);
 		if (containerHooks !== void 0) for (const hook of containerHooks) {
-			const r = hook(instance);
-			if (r instanceof Promise) await r;
+			const hookResult = hook(instance);
+			if (hookResult instanceof Promise) await hookResult;
 		}
 		if (binding.kind !== "alias" && binding.onDeactivation !== void 0) {
-			const r = binding.onDeactivation(instance);
-			if (r instanceof Promise) await r;
+			const hookResult = binding.onDeactivation(instance);
+			if (hookResult instanceof Promise) await hookResult;
 		}
 		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;
+					const hookResult = method.call(instance);
+					if (hookResult instanceof Promise) await hookResult;
 				}
 			}
 		}
 	}
 	runDeactivationSync(binding, instance, metadataReader) {
-		const tName = tokenName(binding.token);
-		const key = binding.token;
-		const containerHooks = this._deactivationHooks.get(key);
+		const tokenDisplayName = tokenName(binding.token);
+		const tokenKey = binding.token;
+		const containerHooks = this._deactivationHooks.get(tokenKey);
 		if (containerHooks !== void 0) {
-			for (const hook of containerHooks) if (hook(instance) instanceof Promise) throw new AsyncDeactivationError(tName);
+			for (const hook of containerHooks) if (hook(instance) instanceof Promise) throw new AsyncDeactivationError(tokenDisplayName);
 		}
 		if (binding.kind !== "alias" && binding.onDeactivation !== void 0) {
-			if (binding.onDeactivation(instance) instanceof Promise) throw new AsyncDeactivationError(tName);
+			if (binding.onDeactivation(instance) instanceof Promise) throw new AsyncDeactivationError(tokenDisplayName);
 		}
 		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);
+					if (method.call(instance) instanceof Promise) throw new AsyncDeactivationError(tokenDisplayName);
 				}
 			}
 		}
 	}
-	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 { LifecycleManager };

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

@@ -1,11 +1,52 @@
 import { ConstructorMetadata, MutableLifecycleMetadata } from "./metadata-types.mjs";
 
 //#region src/metadata/metadata-keys.d.ts
+/**
+ * Accessor injection entries mirrored from `Symbol.metadata` for toolchains where
+ * resolver reads stable metadata via the same object identity as `context.metadata`.
+ *
+ * @since 0.3.16-canary.0
+ */
+type AccessorInjectionEntryList = Array<{
+  key: string | symbol;
+  descriptor: unknown;
+}>;
+/**
+ * @since 0.3.16-canary.0
+ */
 declare const INJECTABLE_KEY: unique symbol;
+/**
+ * @since 0.3.16-canary.0
+ */
 declare const LIFECYCLE_KEY: unique symbol;
+/**
+ * @since 0.3.16-canary.0
+ */
 declare const INJECT_ACCESSOR_KEY: unique symbol;
+/**
+ * @since 0.3.16-canary.0
+ */
 declare const constructorMetadataMap: WeakMap<object, ConstructorMetadata>;
+/**
+ * @since 0.3.16-canary.0
+ */
 declare const lifecycleMetadataMap: WeakMap<object, MutableLifecycleMetadata>;
+/**
+ * @since 0.3.16-canary.0
+ */
 declare const lifecycleByConstructorMetadataMap: WeakMap<object, MutableLifecycleMetadata>;
+/**
+ * Fallback keyed by the class metadata object (`context.metadata` / `ctor[Symbol.metadata]`).
+ *
+ * @since 0.3.16-canary.0
+ */
+declare const accessorMetadataByMetadataObjectMap: WeakMap<object, AccessorInjectionEntryList>;
+/**
+ * Populated from `@injectable()` after field decorators have written `INJECT_ACCESSOR_KEY`
+ * onto `context.metadata` — same timing as {@link constructorMetadataMap}.
+ *
+ * @since 0.3.16-canary.0
+ */
+declare const accessorMetadataByConstructorMap: WeakMap<object, AccessorInjectionEntryList>;
 //#endregion
-export { INJECTABLE_KEY, INJECT_ACCESSOR_KEY, LIFECYCLE_KEY, constructorMetadataMap, lifecycleByConstructorMetadataMap, lifecycleMetadataMap };
+export { AccessorInjectionEntryList, INJECTABLE_KEY, INJECT_ACCESSOR_KEY, LIFECYCLE_KEY, accessorMetadataByConstructorMap, accessorMetadataByMetadataObjectMap, constructorMetadataMap, lifecycleByConstructorMetadataMap, lifecycleMetadataMap };

package/dist/metadata/metadata-keys.mjs

@@ -1,9 +1,40 @@
 //#region src/metadata/metadata-keys.ts
+/**
+* @since 0.3.16-canary.0
+*/
 const INJECTABLE_KEY = Symbol("di:injectable");
+/**
+* @since 0.3.16-canary.0
+*/
 const LIFECYCLE_KEY = Symbol("di:lifecycle");
+/**
+* @since 0.3.16-canary.0
+*/
 const INJECT_ACCESSOR_KEY = Symbol("di:inject-accessor");
+/**
+* @since 0.3.16-canary.0
+*/
 const constructorMetadataMap = /* @__PURE__ */ new WeakMap();
+/**
+* @since 0.3.16-canary.0
+*/
 const lifecycleMetadataMap = /* @__PURE__ */ new WeakMap();
+/**
+* @since 0.3.16-canary.0
+*/
 const lifecycleByConstructorMetadataMap = /* @__PURE__ */ new WeakMap();
+/**
+* Fallback keyed by the class metadata object (`context.metadata` / `ctor[Symbol.metadata]`).
+*
+* @since 0.3.16-canary.0
+*/
+const accessorMetadataByMetadataObjectMap = /* @__PURE__ */ new WeakMap();
+/**
+* Populated from `@injectable()` after field decorators have written `INJECT_ACCESSOR_KEY`
+* onto `context.metadata` — same timing as {@link constructorMetadataMap}.
+*
+* @since 0.3.16-canary.0
+*/
+const accessorMetadataByConstructorMap = /* @__PURE__ */ new WeakMap();
 //#endregion
-export { INJECTABLE_KEY, INJECT_ACCESSOR_KEY, LIFECYCLE_KEY, constructorMetadataMap, lifecycleByConstructorMetadataMap, lifecycleMetadataMap };
+export { INJECTABLE_KEY, INJECT_ACCESSOR_KEY, LIFECYCLE_KEY, accessorMetadataByConstructorMap, accessorMetadataByMetadataObjectMap, constructorMetadataMap, lifecycleByConstructorMetadataMap, lifecycleMetadataMap };

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

@@ -2,6 +2,9 @@ import { Token } from "../token.mjs";
 import { MetadataReader } from "./metadata-types.mjs";
 
 //#region src/metadata/metadata-reader-token.d.ts
+/**
+ * @since 0.3.16-canary.0
+ */
 declare const MetadataReaderToken: Token<MetadataReader>;
 //#endregion
 export { MetadataReaderToken };

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

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

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

@@ -2,6 +2,9 @@ import { Constructor } from "../constructor-type.mjs";
 import { Token } from "../token.mjs";
 
 //#region src/metadata/metadata-types.d.ts
+/**
+ * @since 0.3.16-canary.0
+ */
 interface ParamMetadata {
   readonly index: number;
   readonly token: Token<unknown> | Constructor;
@@ -10,18 +13,31 @@ interface ParamMetadata {
   readonly name?: string;
   readonly tags?: ReadonlyArray<readonly [string, unknown]>;
 }
+/**
+ * @since 0.3.16-canary.0
+ */
 interface ConstructorMetadata {
-  readonly params: readonly ParamMetadata[];
+  readonly params: ReadonlyArray<ParamMetadata>;
 }
+/**
+ * @since 0.3.16-canary.0
+ */
 interface LifecycleMetadata {
-  readonly postConstruct: readonly string[];
-  readonly preDestroy: readonly string[];
+  readonly postConstruct: ReadonlyArray<string>;
+  readonly preDestroy: ReadonlyArray<string>;
 }
-/** Mutable buckets used while aggregating decorator metadata (same keys as {@link LifecycleMetadata}). */
+/**
+ * Mutable buckets used while aggregating decorator metadata (same keys as {@link LifecycleMetadata}).
+ *
+ * @since 0.3.16-canary.0
+ */
 interface MutableLifecycleMetadata {
-  postConstruct: string[];
-  preDestroy: string[];
+  postConstruct: Array<string>;
+  preDestroy: Array<string>;
 }
+/**
+ * @since 0.3.16-canary.0
+ */
 interface MetadataReader {
   getConstructorMetadata(target: Constructor): ConstructorMetadata | undefined;
   getLifecycleMetadata(target: Constructor): LifecycleMetadata | undefined;

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

@@ -3,6 +3,9 @@ import { InjectionDescriptor } from "../decorators/inject.mjs";
 import { ConstructorMetadata, LifecycleMetadata, MetadataReader } from "./metadata-types.mjs";
 
 //#region src/metadata/symbol-metadata-reader.d.ts
+/**
+ * @since 0.3.16-canary.0
+ */
 declare class SymbolMetadataReader implements MetadataReader {
   getConstructorMetadata(target: Constructor): ConstructorMetadata | undefined;
   getLifecycleMetadata(target: Constructor): LifecycleMetadata | undefined;
@@ -11,6 +14,9 @@ declare class SymbolMetadataReader implements MetadataReader {
     descriptor: InjectionDescriptor;
   }> | undefined;
 }
+/**
+ * @since 0.3.16-canary.0
+ */
 declare const defaultMetadataReader: SymbolMetadataReader;
 //#endregion
 export { SymbolMetadataReader, defaultMetadataReader };

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

@@ -1,38 +1,51 @@
-import { INJECTABLE_KEY, INJECT_ACCESSOR_KEY, LIFECYCLE_KEY, constructorMetadataMap, lifecycleByConstructorMetadataMap, lifecycleMetadataMap } from "./metadata-keys.mjs";
+import { INJECTABLE_KEY, INJECT_ACCESSOR_KEY, LIFECYCLE_KEY, accessorMetadataByConstructorMap, accessorMetadataByMetadataObjectMap, constructorMetadataMap, lifecycleByConstructorMetadataMap, lifecycleMetadataMap } from "./metadata-keys.mjs";
 //#region src/metadata/symbol-metadata-reader.ts
+/**
+* @since 0.3.16-canary.0
+*/
 var SymbolMetadataReader = class {
 	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];
+		const weakMapMetadata = constructorMetadataMap.get(target);
+		if (weakMapMetadata !== void 0) return weakMapMetadata;
+		const metadataDescriptor = Object.getOwnPropertyDescriptor(target, Symbol.metadata);
+		if (metadataDescriptor === void 0) return;
+		const metadataRecord = metadataDescriptor.value;
+		if (!metadataRecord || typeof metadataRecord !== "object" || !Object.hasOwn(metadataRecord, INJECTABLE_KEY)) return;
+		return metadataRecord[INJECTABLE_KEY];
 	}
 	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 lifecycleMetadataByConstructor = lifecycleByConstructorMetadataMap.get(target);
+		if (lifecycleMetadataByConstructor !== void 0) return lifecycleMetadataByConstructor;
+		const metadataDescriptor = Object.getOwnPropertyDescriptor(target, Symbol.metadata);
+		if (metadataDescriptor !== void 0) {
+			const metadataRecord = metadataDescriptor.value;
+			if (metadataRecord && typeof metadataRecord === "object" && Object.hasOwn(metadataRecord, LIFECYCLE_KEY)) return metadataRecord[LIFECYCLE_KEY];
 		}
-		const classMeta = target[Symbol.metadata];
-		if (classMeta !== void 0) {
-			const fromWeakMap = lifecycleMetadataMap.get(classMeta);
-			if (fromWeakMap !== void 0) return fromWeakMap;
+		const classMetadataObject = target[Symbol.metadata];
+		if (classMetadataObject !== void 0) {
+			const weakMapMetadata = lifecycleMetadataMap.get(classMetadataObject);
+			if (weakMapMetadata !== void 0) return weakMapMetadata;
 		}
 	}
 	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 byConstructor = accessorMetadataByConstructorMap.get(target);
+		if (byConstructor !== void 0) return byConstructor;
+		const metadataObject = target[Symbol.metadata];
+		if (metadataObject !== void 0) {
+			const fromWeakMap = accessorMetadataByMetadataObjectMap.get(metadataObject);
+			if (fromWeakMap !== void 0) return fromWeakMap;
+		}
+		const metadataDescriptor = Object.getOwnPropertyDescriptor(target, Symbol.metadata);
+		if (metadataDescriptor === void 0) return;
+		const metadataRecord = metadataDescriptor.value;
+		if (!metadataRecord || typeof metadataRecord !== "object") return;
+		if (!Object.hasOwn(metadataRecord, INJECT_ACCESSOR_KEY)) return;
+		return metadataRecord[INJECT_ACCESSOR_KEY];
 	}
 };
+/**
+* @since 0.3.16-canary.0
+*/
 const defaultMetadataReader = new SymbolMetadataReader();
 //#endregion
 export { SymbolMetadataReader, defaultMetadataReader };

package/dist/module.d.mts

@@ -5,34 +5,58 @@ import { BindToBuilder } from "./binding.mjs";
 //#region src/module.d.ts
 declare const SYNC_MODULE_BRAND: unique symbol;
 declare const ASYNC_MODULE_BRAND: unique symbol;
+/**
+ * @since 0.3.16-canary.0
+ */
 interface SyncModule {
   readonly name: string;
   readonly [SYNC_MODULE_BRAND]: true;
   readonly _setup: (builder: ModuleBuilder) => void;
 }
+/**
+ * @since 0.3.16-canary.0
+ */
 interface AsyncModule {
   readonly name: string;
   readonly [ASYNC_MODULE_BRAND]: true;
   readonly _setup: (builder: AsyncModuleBuilder) => Promise<void>;
 }
+/**
+ * @since 0.3.16-canary.0
+ */
 interface ModuleBuilder {
   bind<const Value>(token: Token<Value> | Constructor<Value>): BindToBuilder<Value>;
-  import(...modules: SyncModule[]): void;
+  import(...modules: Array<SyncModule>): void;
 }
+/**
+ * @since 0.3.16-canary.0
+ */
 interface AsyncModuleBuilder {
   bind<const Value>(token: Token<Value> | Constructor<Value>): BindToBuilder<Value>;
   import(...modules: Array<SyncModule | AsyncModule>): void;
 }
+/**
+ * @since 0.3.16-canary.0
+ */
 declare const SyncModule: {
   create(name: string, setup: (builder: ModuleBuilder) => void): SyncModule;
 };
+/**
+ * @since 0.3.16-canary.0
+ */
 declare const AsyncModule: {
   create(name: string, setup: (builder: AsyncModuleBuilder) => Promise<void>): AsyncModule;
 };
+/**
+ * @since 0.3.16-canary.0
+ */
 declare const Module: {
   create(name: string, setup: (builder: ModuleBuilder) => void): SyncModule;
   createAsync(name: string, setup: (builder: AsyncModuleBuilder) => Promise<void>): AsyncModule;
 };
+/**
+ * @since 0.3.16-canary.0
+ */
 declare function isSyncModule(m: SyncModule | AsyncModule): m is SyncModule;
 //#endregion
 export { AsyncModule, AsyncModuleBuilder, Module, ModuleBuilder, SyncModule, isSyncModule };

package/dist/module.mjs

@@ -1,6 +1,9 @@
 //#region src/module.ts
 const SYNC_MODULE_BRAND = Symbol("di:sync-module");
 const ASYNC_MODULE_BRAND = Symbol("di:async-module");
+/**
+* @since 0.3.16-canary.0
+*/
 const SyncModule = { create(name, setup) {
 	return {
 		name,
@@ -8,6 +11,9 @@ const SyncModule = { create(name, setup) {
 		_setup: setup
 	};
 } };
+/**
+* @since 0.3.16-canary.0
+*/
 const AsyncModule = { create(name, setup) {
 	return {
 		name,
@@ -15,6 +21,9 @@ const AsyncModule = { create(name, setup) {
 		_setup: setup
 	};
 } };
+/**
+* @since 0.3.16-canary.0
+*/
 const Module = {
 	create(name, setup) {
 		return SyncModule.create(name, setup);
@@ -23,6 +32,9 @@ const Module = {
 		return AsyncModule.create(name, setup);
 	}
 };
+/**
+* @since 0.3.16-canary.0
+*/
 function isSyncModule(m) {
 	return m[SYNC_MODULE_BRAND] === true;
 }

package/dist/registry.d.mts

@@ -4,6 +4,9 @@ import { BindingIdentifier } from "./types.mjs";
 import { Binding } from "./binding.mjs";
 
 //#region src/registry.d.ts
+/**
+ * @since 0.3.16-canary.0
+ */
 declare class BindingRegistry {
   private readonly _bindings;
   private readonly _byId;
@@ -13,24 +16,24 @@ declare class BindingRegistry {
   /** Add or replace binding using slot-aware last-wins. */
   add(binding: Binding): void;
   /** Remove all bindings for a token. Returns removed bindings. */
-  removeByToken(t: Token<unknown> | Constructor): Binding[];
+  removeByToken(t: Token<unknown> | Constructor): Array<Binding>;
   /** Remove a specific binding by ID. Returns the removed binding or undefined. */
   removeById(id: BindingIdentifier): Binding | undefined;
   /** Get all bindings for a token. */
-  getAll(t: Token<unknown> | Constructor): readonly Binding[];
+  getAll(t: Token<unknown> | Constructor): ReadonlyArray<Binding>;
   /** Get binding by ID. */
   getById(id: BindingIdentifier): Binding | undefined;
   /** Check if any binding exists for token. */
   has(t: Token<unknown> | Constructor): boolean;
   /** All bindings in the registry. */
-  allBindings(): readonly Binding[];
+  allBindings(): ReadonlyArray<Binding>;
   /** Remove all bindings. Returns all removed. */
-  clear(): readonly Binding[];
+  clear(): ReadonlyArray<Binding>;
   getSimpleNamed(token: Token<unknown> | Constructor, name: string): Binding | undefined;
   getSimpleTagged(token: Token<unknown> | Constructor, tagKey: string, tagValue: unknown): Binding | undefined;
   getFastDefault(token: Token<unknown> | Constructor): Binding | undefined;
   /** Summarize available slot strings for a token (for error messages). */
-  availableSlotStrings(t: Token<unknown> | Constructor): string[];
+  availableSlotStrings(t: Token<unknown> | Constructor): Array<string>;
   private _indexSimpleTaggedBinding;
   private _deindexSimpleTaggedBinding;
   private _isPurePredicateBinding;