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

package/dist/inspector.mjs

@@ -6,6 +6,10 @@ import { tokenName } from "./token.mjs";
 * @since 0.3.16-canary.0
 */
 var Inspector = class {
+	_registry;
+	_scope;
+	_hasParent;
+	_isDisposed;
 	constructor(_registry, _scope, _hasParent, _isDisposed) {
 		this._registry = _registry;
 		this._scope = _scope;
@@ -13,24 +17,22 @@ var Inspector = class {
 		this._isDisposed = _isDisposed;
 	}
 	inspect() {
-		const snapshots = this.allBindingSnapshots();
 		return {
-			ownBindings: snapshots,
-			bindings: snapshots,
+			ownBindings: this.allBindingSnapshots(),
 			cachedSingletonCount: this._scope.getAllSingletons().size,
 			hasParent: this._hasParent,
 			isDisposed: this._isDisposed()
 		};
 	}
 	lookupBindings(token) {
-		return this._registry.getAll(token).map((b) => this._toSnapshot(b));
+		return this._registry.getAll(token).map((binding) => this._toSnapshot(binding));
 	}
 	has(token, hint, parentHas) {
 		const bindings = this._registry.getAll(token);
 		if (bindings.length > 0) if (hint !== void 0) {
 			if (selectBinding(bindings, hint, {
 				resolutionPath: [],
-				materializationStack: [],
+				resolutionStack: [],
 				parent: void 0,
 				ancestors: [],
 				currentResolveHint: hint
@@ -43,7 +45,7 @@ var Inspector = class {
 		if (bindings.length === 0) return false;
 		if (hint !== void 0) return selectBinding(bindings, hint, {
 			resolutionPath: [],
-			materializationStack: [],
+			resolutionStack: [],
 			parent: void 0,
 			ancestors: [],
 			currentResolveHint: hint
@@ -51,20 +53,20 @@ var Inspector = class {
 		return true;
 	}
 	allBindingSnapshots() {
-		return this._registry.allBindings().map((b) => this._toSnapshot(b));
+		return this._registry.allBindings().map((binding) => this._toSnapshot(binding));
 	}
-	_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 };
+	_toSnapshot(binding) {
+		const scope = effectiveBindingScope(binding);
+		const slot = binding.slot.name !== void 0 ? {
+			name: binding.slot.name,
+			tags: binding.slot.tags
+		} : { tags: binding.slot.tags };
 		return {
-			tokenName: tokenName(b.token),
-			kind: b.kind,
+			tokenName: tokenName(binding.token),
+			kind: binding.kind,
 			scope,
 			slot,
-			id: b.id
+			id: binding.id
 		};
 	}
 };

package/dist/lifecycle.d.mts

@@ -12,15 +12,14 @@ 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,4 +1,4 @@
-import { AsyncDeactivationError } from "./errors.mjs";
+import { AsyncActivationError, AsyncDeactivationError } from "./errors.mjs";
 import { tokenName } from "./token.mjs";
 //#region src/lifecycle.ts
 /**
@@ -8,128 +8,121 @@ 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,6 +1,16 @@
 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
  */
@@ -25,5 +35,18 @@ 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

@@ -23,5 +23,18 @@ 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-types.d.mts

@@ -17,14 +17,14 @@ interface ParamMetadata {
  * @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}).
@@ -32,8 +32,8 @@ interface 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

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

@@ -1,39 +1,46 @@
-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];
 	}
 };
 /**

package/dist/module.d.mts

@@ -26,7 +26,7 @@ interface AsyncModule {
  */
 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
@@ -57,6 +57,6 @@ declare const Module: {
 /**
  * @since 0.3.16-canary.0
  */
-declare function isSyncModule(m: SyncModule | AsyncModule): m is SyncModule;
+declare function isSyncModule(module: SyncModule | AsyncModule): module is SyncModule;
 //#endregion
 export { AsyncModule, AsyncModuleBuilder, Module, ModuleBuilder, SyncModule, isSyncModule };

package/dist/module.mjs

@@ -35,8 +35,8 @@ const Module = {
 /**
 * @since 0.3.16-canary.0
 */
-function isSyncModule(m) {
-	return m[SYNC_MODULE_BRAND] === true;
+function isSyncModule(module) {
+	return module[SYNC_MODULE_BRAND] === true;
 }
 //#endregion
 export { AsyncModule, Module, SyncModule, isSyncModule };

package/dist/registry.d.mts

@@ -16,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(token: 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(token: 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;
+  has(token: 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(token: Token<unknown> | Constructor): Array<string>;
   private _indexSimpleTaggedBinding;
   private _deindexSimpleTaggedBinding;
   private _isPurePredicateBinding;