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

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @codefast/di
 
+## 0.3.16-canary.2
+
+### Patch Changes
+
+- [`1ad2cb7`](https://github.com/codefastlabs/codefast/commit/1ad2cb73a3f6f8bff2b001e9df2f2492efd89aa2) Thanks [@thevuong](https://github.com/thevuong)! - chore: align package config globs
+
+- [`4fda78b`](https://github.com/codefastlabs/codefast/commit/4fda78b20f98646d114cfddb09e66af609a625a2) Thanks [@thevuong](https://github.com/thevuong)! - fix: support Node 26 mirror export verification
+
+- [`1b0df2e`](https://github.com/codefastlabs/codefast/commit/1b0df2e55140c927b7f3ba39ccdcb4cba87ec7ff) Thanks [@thevuong](https://github.com/thevuong)! - refactor(di): clarify contextual names
+
+## 0.3.16-canary.1
+
 ## 0.3.16-canary.0
 
 ## 0.3.15

package/README.md

@@ -181,7 +181,7 @@ Start with `container.bind(key)` and chain a strategy, then optional constraints
 | `.toDynamicAsync(factory)`        | Async factory `(ctx: ResolutionContext) => Promise<Value>`.                                                 |
 | `.toResolved(factory, deps)`      | Factory with a typed dependency tuple; dependencies are resolved in order.                                  |
 | `.toResolvedAsync(factory, deps)` | Like `toResolved`, but the factory returns a `Promise`.                                                     |
-| `.toAlias(targetToken)`           | Redirect resolution to another token; the alias follows the target’s materialization.                       |
+| `.toAlias(targetToken)`           | Redirect resolution to another token; the alias follows the target’s resolution.                            |
 
 ```typescript
 container.bind(AppConfigToken).toConstantValue({ port: 3000 });
@@ -203,7 +203,10 @@ container.bind(DbToken).toDynamicAsync(async (ctx) => {
 
 container
   .bind(UserServiceToken)
-  .toResolved((repo, cfg) => new UserService(repo, cfg), [UserRepository, AppConfigToken] as const);
+  .toResolved((repository, config) => new UserService(repository, config), [
+    UserRepository,
+    AppConfigToken,
+  ] as const);
 
 container
   .bind(MetricsToken)
@@ -268,7 +271,7 @@ Built-in predicates (all from `@codefast/di/constraints`):
 | ----------------------------------- | -------------------------------------------------------------------------- |
 | `whenParentIs(key)`                 | The direct parent binding was registered for `key`.                        |
 | `whenNoParentIs(key)`               | There is no parent, or the parent is not registered for `key`.             |
-| `whenAnyAncestorIs(key)`            | Any ancestor on the materialization stack was registered for `key`.        |
+| `whenAnyAncestorIs(key)`            | Any ancestor on the resolution stack was registered for `key`.             |
 | `whenNoAncestorIs(key)`             | No ancestor was registered for `key`.                                      |
 | `whenParentNamed(name)`             | The immediate parent binding’s slot name is `name`.                        |
 | `whenAnyAncestorNamed(name)`        | Some ancestor’s slot name is `name`.                                       |
@@ -642,7 +645,7 @@ The root entry re-exports the full façade (`package.json` → `"."`). Subpaths
 | `@codefast/di/decorators/injectable`           | `injectable`, `createAutoRegisterRegistry`, `AutoRegisterRegistry`                                                                                                   |
 | `@codefast/di/decorators/lifecycle-decorators` | `postConstruct`, `preDestroy`                                                                                                                                        |
 | `@codefast/di/dependency-graph`                | `buildDependencyGraph`, `ContainerGraphJson`, `GraphOptions`, …                                                                                                      |
-| `@codefast/di/environment`                     | `runWithContainer`, `getActiveContainer`, `DefaultResolutionContext`, `ResolverCallbacks`, `buildMaterializationFrame`                                               |
+| `@codefast/di/environment`                     | `runWithContainer`, `getActiveContainer`, `DefaultResolutionContext`, `ResolverCallbacks`, `buildResolutionFrame`                                                    |
 | `@codefast/di/errors`                          | Full `DiError` hierarchy                                                                                                                                             |
 | `@codefast/di/graph-adapters/cytoscape`        | `toCytoscapeGraph`                                                                                                                                                   |
 | `@codefast/di/graph-adapters/dot`              | `toDotGraph`                                                                                                                                                         |
@@ -656,7 +659,7 @@ The root entry re-exports the full façade (`package.json` → `"."`). Subpaths
 | `@codefast/di/metadata/symbol-metadata-reader` | `SymbolMetadataReader`, `defaultMetadataReader`                                                                                                                      |
 | `@codefast/di/module`                          | `Module`, `AsyncModule`, `SyncModule`, `isSyncModule`, builders                                                                                                      |
 | `@codefast/di/registry`                        | `BindingRegistry`                                                                                                                                                    |
-| `@codefast/di/resolve-options`                 | `injectableSlotToResolveOptions`, `slotKeyToResolveOptions`                                                                                                          |
+| `@codefast/di/resolve-options`                 | `injectionSlotToResolveOptions`, `bindingSlotToResolveOptions`                                                                                                       |
 | `@codefast/di/resolver`                        | `DependencyResolver`                                                                                                                                                 |
 | `@codefast/di/scope`                           | `ScopeManager`                                                                                                                                                       |
 | `@codefast/di/token`                           | `token`, `Token`, `tokenName`, …                                                                                                                                     |

package/dist/binding-select.d.mts

@@ -8,12 +8,12 @@ import { Binding } from "./binding.mjs";
  *
  * @since 0.3.16-canary.0
  */
-declare function selectBinding(bindings: readonly Binding[], hint: ResolveOptions | undefined, ctx: ConstraintContext, tName: string): Binding | undefined;
+declare function selectBinding(bindings: ReadonlyArray<Binding>, hint: ResolveOptions | undefined, ctx: ConstraintContext, tokenDisplayName: string): Binding | undefined;
 /**
  * Select all candidates matching hint + predicates.
  *
  * @since 0.3.16-canary.0
  */
-declare function selectAllBindings(bindings: readonly Binding[], hint: ResolveOptions | undefined, ctx: ConstraintContext): Binding[];
+declare function selectAllBindings(bindings: ReadonlyArray<Binding>, hint: ResolveOptions | undefined, ctx: ConstraintContext): Array<Binding>;
 //#endregion
 export { selectAllBindings, selectBinding };

package/dist/binding-select.mjs

@@ -6,11 +6,11 @@ import { AmbiguousBindingError } from "./errors.mjs";
 *
 * @since 0.3.16-canary.0
 */
-function selectBinding(bindings, hint, ctx, tName) {
+function selectBinding(bindings, hint, ctx, tokenDisplayName) {
 	const candidates = filterBindings(bindings, hint, ctx);
 	if (candidates.length === 0) return;
 	if (candidates.length === 1) return candidates[0];
-	throw new AmbiguousBindingError(tName, candidates.map((c) => c.id));
+	throw new AmbiguousBindingError(tokenDisplayName, candidates.map((c) => c.id));
 }
 /**
 * Select all candidates matching hint + predicates.
@@ -20,10 +20,10 @@ function selectBinding(bindings, hint, ctx, tName) {
 function selectAllBindings(bindings, hint, ctx) {
 	return filterBindings(bindings, hint, ctx, "all");
 }
-function filterBindings(bindings, hint, ctx, mode = "single") {
+function filterBindings(bindings, hint, ctx, selectionMode = "single") {
 	if (hint === void 0) {
 		const resultWithoutHint = [];
-		if (mode === "all") {
+		if (selectionMode === "all") {
 			for (const binding of bindings) if (matchesPredicate(binding, ctx)) resultWithoutHint.push(binding);
 		} else for (const binding of bindings) {
 			const slot = binding.slot;
@@ -32,7 +32,7 @@ function filterBindings(bindings, hint, ctx, mode = "single") {
 		return resultWithoutHint;
 	}
 	const result = [];
-	for (const binding of bindings) if ((mode === "all" ? matchesSlotForResolveAll(binding, hint) : matchesSlot(binding, hint)) && matchesPredicate(binding, ctx)) result.push(binding);
+	for (const binding of bindings) if ((selectionMode === "all" ? matchesSlotForResolveAll(binding, hint) : matchesSlot(binding, hint)) && matchesPredicate(binding, ctx)) result.push(binding);
 	return result;
 }
 function matchesSlotForResolveAll(binding, hint) {

package/dist/binding.d.mts

@@ -7,26 +7,26 @@ import { InjectionDescriptor } from "./decorators/inject.mjs";
 /**
  * @since 0.3.16-canary.0
  */
-interface SlotKey {
+interface BindingSlot {
   readonly name: string | undefined;
   readonly tags: ReadonlyArray<readonly [tag: string, value: unknown]>;
 }
 /**
  * @since 0.3.16-canary.0
  */
-declare function slotKeyEquals(a: SlotKey, b: SlotKey): boolean;
+declare function bindingSlotEquals(left: BindingSlot, right: BindingSlot): boolean;
 /**
  * @since 0.3.16-canary.0
  */
-declare const DEFAULT_SLOT: SlotKey;
+declare const DEFAULT_BINDING_SLOT: BindingSlot;
 /**
  * @since 0.3.16-canary.0
  */
-declare function slotKeyToString(slot: SlotKey): string;
+declare function bindingSlotToString(slot: BindingSlot): string;
 interface BindingBase<Value> {
   readonly id: BindingIdentifier;
   readonly token: Token<Value> | Constructor<Value>;
-  readonly slot: SlotKey;
+  readonly slot: BindingSlot;
   readonly predicate?: (ctx: ConstraintContext) => boolean;
 }
 /**
@@ -64,8 +64,8 @@ interface DynamicAsyncBinding<Value> extends BindingBase<Value> {
  */
 interface ResolvedBinding<Value> extends BindingBase<Value> {
   readonly kind: "resolved";
-  readonly factory: (...args: unknown[]) => Value;
-  readonly deps: readonly InjectionDescriptor[];
+  readonly factory: (...args: Array<unknown>) => Value;
+  readonly deps: ReadonlyArray<InjectionDescriptor>;
   readonly scope: BindingScope;
   readonly onActivation?: ActivationHandler<Value>;
   readonly onDeactivation?: DeactivationHandler<Value>;
@@ -75,8 +75,8 @@ interface ResolvedBinding<Value> extends BindingBase<Value> {
  */
 interface ResolvedAsyncBinding<Value> extends BindingBase<Value> {
   readonly kind: "resolved-async";
-  readonly factory: (...args: unknown[]) => Promise<Value>;
-  readonly deps: readonly InjectionDescriptor[];
+  readonly factory: (...args: Array<unknown>) => Promise<Value>;
+  readonly deps: ReadonlyArray<InjectionDescriptor>;
   readonly scope: BindingScope;
   readonly onActivation?: ActivationHandler<Value>;
   readonly onDeactivation?: DeactivationHandler<Value>;
@@ -121,8 +121,8 @@ interface BindToBuilder<Value> {
   toConstantValue(value: Value): ConstantBindingBuilder<Value>;
   toDynamic(factory: (ctx: ResolutionContext) => Value): BindingBuilder<Value>;
   toDynamicAsync(factory: (ctx: ResolutionContext) => Promise<Value>): BindingBuilder<Value>;
-  toResolved<const Deps extends readonly DependencyKey[]>(factory: (...args: { [K in keyof Deps]: TokenValue<NoInfer<Deps>[K]> }) => Value, deps: Deps): BindingBuilder<Value>;
-  toResolvedAsync<const Deps extends readonly DependencyKey[]>(factory: (...args: { [K in keyof Deps]: TokenValue<NoInfer<Deps>[K]> }) => Promise<Value>, deps: Deps): BindingBuilder<Value>;
+  toResolved<const Deps extends ReadonlyArray<DependencyKey>>(factory: (...args: { [K in keyof Deps]: TokenValue<NoInfer<Deps>[K]> }) => Value, deps: Deps): BindingBuilder<Value>;
+  toResolvedAsync<const Deps extends ReadonlyArray<DependencyKey>>(factory: (...args: { [K in keyof Deps]: TokenValue<NoInfer<Deps>[K]> }) => Promise<Value>, deps: Deps): BindingBuilder<Value>;
   toAlias(target: Token<Value> | Constructor<Value>): AliasBindingBuilder;
 }
 /**
@@ -188,4 +188,4 @@ interface SingletonLifecycleBuilder<Value> {
   id(): BindingIdentifier;
 }
 //#endregion
-export { AliasBinding, AliasBindingBuilder, BindToBuilder, Binding, BindingBuilder, ClassBinding, ConstantBinding, ConstantBindingBuilder, DEFAULT_SLOT, DynamicAsyncBinding, DynamicBinding, PartialBinding, ResolvedAsyncBinding, ResolvedBinding, ScopedBindingBuilder, SingletonBindingBuilder, SingletonLifecycleBuilder, SlotKey, TransientBindingBuilder, generateBindingId, slotKeyEquals, slotKeyToString };
+export { AliasBinding, AliasBindingBuilder, BindToBuilder, Binding, BindingBuilder, BindingSlot, ClassBinding, ConstantBinding, ConstantBindingBuilder, DEFAULT_BINDING_SLOT, DynamicAsyncBinding, DynamicBinding, PartialBinding, ResolvedAsyncBinding, ResolvedBinding, ScopedBindingBuilder, SingletonBindingBuilder, SingletonLifecycleBuilder, TransientBindingBuilder, bindingSlotEquals, bindingSlotToString, generateBindingId };

package/dist/binding.mjs

@@ -2,27 +2,27 @@
 /**
 * @since 0.3.16-canary.0
 */
-function slotKeyEquals(a, b) {
-	if (a.name !== b.name) return false;
-	if (a.tags.length !== b.tags.length) return false;
-	for (const [tagKey, tagValue] of a.tags) if (!b.tags.some(([k, v]) => k === tagKey && Object.is(v, tagValue))) return false;
+function bindingSlotEquals(left, right) {
+	if (left.name !== right.name) return false;
+	if (left.tags.length !== right.tags.length) return false;
+	for (const [tagKey, tagValue] of left.tags) if (!right.tags.some(([otherKey, otherValue]) => otherKey === tagKey && Object.is(otherValue, tagValue))) return false;
 	return true;
 }
 /**
 * @since 0.3.16-canary.0
 */
-const DEFAULT_SLOT = {
+const DEFAULT_BINDING_SLOT = {
 	name: void 0,
 	tags: []
 };
 /**
 * @since 0.3.16-canary.0
 */
-function slotKeyToString(slot) {
+function bindingSlotToString(slot) {
 	if (slot.name === void 0 && slot.tags.length === 0) return "default";
 	const parts = [];
 	if (slot.name !== void 0) parts.push(`name:${slot.name}`);
-	for (const [k, v] of slot.tags) parts.push(`tag:${k}=${String(v)}`);
+	for (const [tagKey, tagValue] of slot.tags) parts.push(`tag:${tagKey}=${String(tagValue)}`);
 	return parts.join(",");
 }
 let _idCounter = 0;
@@ -33,4 +33,4 @@ function generateBindingId() {
 	return String(++_idCounter);
 }
 //#endregion
-export { DEFAULT_SLOT, generateBindingId, slotKeyEquals, slotKeyToString };
+export { DEFAULT_BINDING_SLOT, bindingSlotEquals, bindingSlotToString, generateBindingId };

package/dist/constraints.d.mts

@@ -6,34 +6,50 @@ import { ConstraintContext } from "./types.mjs";
 /**
  * @since 0.3.16-canary.0
  */
-declare function whenParentIs(t: Token<unknown> | Constructor): (ctx: ConstraintContext) => boolean;
+declare function whenParentIs(token: Token<unknown> | Constructor): (constraintContext: ConstraintContext) => boolean;
 /**
  * @since 0.3.16-canary.0
  */
-declare function whenNoParentIs(t: Token<unknown> | Constructor): (ctx: ConstraintContext) => boolean;
+declare function whenNoParentIs(token: Token<unknown> | Constructor): (constraintContext: ConstraintContext) => boolean;
 /**
  * @since 0.3.16-canary.0
  */
-declare function whenAnyAncestorIs(t: Token<unknown> | Constructor): (ctx: ConstraintContext) => boolean;
+declare function whenAnyAncestorIs(token: Token<unknown> | Constructor): (constraintContext: ConstraintContext) => boolean;
 /**
  * @since 0.3.16-canary.0
  */
-declare function whenNoAncestorIs(t: Token<unknown> | Constructor): (ctx: ConstraintContext) => boolean;
+declare function whenNoAncestorIs(token: Token<unknown> | Constructor): (constraintContext: ConstraintContext) => boolean;
 /**
  * @since 0.3.16-canary.0
  */
-declare function whenParentNamed(name: string): (ctx: ConstraintContext) => boolean;
+declare function whenParentNamed(name: string): (constraintContext: ConstraintContext) => boolean;
 /**
  * @since 0.3.16-canary.0
  */
-declare function whenAnyAncestorNamed(name: string): (ctx: ConstraintContext) => boolean;
+declare function whenAnyAncestorNamed(name: string): (constraintContext: ConstraintContext) => boolean;
 /**
  * @since 0.3.16-canary.0
  */
-declare function whenParentTagged(tag: string, value: unknown): (ctx: ConstraintContext) => boolean;
+declare function whenParentTagged(tag: string, value: unknown): (constraintContext: ConstraintContext) => boolean;
 /**
  * @since 0.3.16-canary.0
  */
-declare function whenAnyAncestorTagged(tag: string, value: unknown): (ctx: ConstraintContext) => boolean;
+declare function whenAnyAncestorTagged(tag: string, value: unknown): (constraintContext: ConstraintContext) => boolean;
+/**
+ * Matches when the direct parent slot carries **all** of the given tag pairs.
+ * Equivalent to AND-composing multiple `whenParentTagged` calls but evaluates
+ * in a single predicate invocation — no intermediate closure allocations.
+ *
+ * @since 0.3.16-canary.1
+ */
+declare function whenParentTaggedAll(tags: ReadonlyArray<readonly [tag: string, value: unknown]>): (constraintContext: ConstraintContext) => boolean;
+/**
+ * Matches when at least one ancestor slot carries **all** of the given tag pairs.
+ * Equivalent to AND-composing multiple `whenAnyAncestorTagged` calls but evaluates
+ * in a single predicate invocation — no intermediate closure allocations.
+ *
+ * @since 0.3.16-canary.1
+ */
+declare function whenAnyAncestorTaggedAll(tags: ReadonlyArray<readonly [tag: string, value: unknown]>): (constraintContext: ConstraintContext) => boolean;
 //#endregion
-export { whenAnyAncestorIs, whenAnyAncestorNamed, whenAnyAncestorTagged, whenNoAncestorIs, whenNoParentIs, whenParentIs, whenParentNamed, whenParentTagged };
+export { whenAnyAncestorIs, whenAnyAncestorNamed, whenAnyAncestorTagged, whenAnyAncestorTaggedAll, whenNoAncestorIs, whenNoParentIs, whenParentIs, whenParentNamed, whenParentTagged, whenParentTaggedAll };

package/dist/constraints.mjs

@@ -1,59 +1,87 @@
 import { tokenName } from "./token.mjs";
 //#region src/constraints.ts
-function tokenNameOf(t) {
-	return tokenName(t);
+function tokenNameOf(token) {
+	return tokenName(token);
 }
 /**
 * @since 0.3.16-canary.0
 */
-function whenParentIs(t) {
-	const name = tokenNameOf(t);
-	return (ctx) => ctx.parent !== void 0 && ctx.parent.tokenName === name;
+function whenParentIs(token) {
+	const tokenDisplayName = tokenNameOf(token);
+	return (constraintContext) => constraintContext.parent !== void 0 && constraintContext.parent.tokenName === tokenDisplayName;
 }
 /**
 * @since 0.3.16-canary.0
 */
-function whenNoParentIs(t) {
-	const name = tokenNameOf(t);
-	return (ctx) => ctx.parent === void 0 || ctx.parent.tokenName !== name;
+function whenNoParentIs(token) {
+	const tokenDisplayName = tokenNameOf(token);
+	return (constraintContext) => constraintContext.parent === void 0 || constraintContext.parent.tokenName !== tokenDisplayName;
 }
 /**
 * @since 0.3.16-canary.0
 */
-function whenAnyAncestorIs(t) {
-	const name = tokenNameOf(t);
-	return (ctx) => ctx.ancestors.some((f) => f.tokenName === name);
+function whenAnyAncestorIs(token) {
+	const tokenDisplayName = tokenNameOf(token);
+	return (constraintContext) => constraintContext.ancestors.some((ancestorFrame) => ancestorFrame.tokenName === tokenDisplayName);
 }
 /**
 * @since 0.3.16-canary.0
 */
-function whenNoAncestorIs(t) {
-	const name = tokenNameOf(t);
-	return (ctx) => ctx.ancestors.every((f) => f.tokenName !== name);
+function whenNoAncestorIs(token) {
+	const tokenDisplayName = tokenNameOf(token);
+	return (constraintContext) => constraintContext.ancestors.every((ancestorFrame) => ancestorFrame.tokenName !== tokenDisplayName);
 }
 /**
 * @since 0.3.16-canary.0
 */
 function whenParentNamed(name) {
-	return (ctx) => ctx.parent !== void 0 && ctx.parent.slot.name === name;
+	return (constraintContext) => constraintContext.parent !== void 0 && constraintContext.parent.slot.name === name;
 }
 /**
 * @since 0.3.16-canary.0
 */
 function whenAnyAncestorNamed(name) {
-	return (ctx) => ctx.ancestors.some((f) => f.slot.name === name);
+	return (constraintContext) => constraintContext.ancestors.some((ancestorFrame) => ancestorFrame.slot.name === name);
 }
 /**
 * @since 0.3.16-canary.0
 */
 function whenParentTagged(tag, value) {
-	return (ctx) => ctx.parent !== void 0 && ctx.parent.slot.tags.some(([t, v]) => t === tag && Object.is(v, value));
+	return (constraintContext) => constraintContext.parent !== void 0 && constraintContext.parent.slot.tags.some(([tagKey, tagValue]) => tagKey === tag && Object.is(tagValue, value));
 }
 /**
 * @since 0.3.16-canary.0
 */
 function whenAnyAncestorTagged(tag, value) {
-	return (ctx) => ctx.ancestors.some((f) => f.slot.tags.some(([t, v]) => t === tag && Object.is(v, value)));
+	return (constraintContext) => constraintContext.ancestors.some((ancestorFrame) => ancestorFrame.slot.tags.some(([tagKey, tagValue]) => tagKey === tag && Object.is(tagValue, value)));
+}
+/**
+* Matches when the direct parent slot carries **all** of the given tag pairs.
+* Equivalent to AND-composing multiple `whenParentTagged` calls but evaluates
+* in a single predicate invocation — no intermediate closure allocations.
+*
+* @since 0.3.16-canary.1
+*/
+function whenParentTaggedAll(tags) {
+	return (constraintContext) => {
+		const { parent } = constraintContext;
+		if (parent === void 0) return false;
+		const { tags: parentTags } = parent.slot;
+		return tags.every(([tagKey, tagValue]) => parentTags.some(([otherKey, otherValue]) => otherKey === tagKey && Object.is(otherValue, tagValue)));
+	};
+}
+/**
+* Matches when at least one ancestor slot carries **all** of the given tag pairs.
+* Equivalent to AND-composing multiple `whenAnyAncestorTagged` calls but evaluates
+* in a single predicate invocation — no intermediate closure allocations.
+*
+* @since 0.3.16-canary.1
+*/
+function whenAnyAncestorTaggedAll(tags) {
+	return (constraintContext) => constraintContext.ancestors.some((frame) => {
+		const { tags: frameTags } = frame.slot;
+		return tags.every(([tagKey, tagValue]) => frameTags.some(([otherKey, otherValue]) => otherKey === tagKey && Object.is(otherValue, tagValue)));
+	});
 }
 //#endregion
-export { whenAnyAncestorIs, whenAnyAncestorNamed, whenAnyAncestorTagged, whenNoAncestorIs, whenNoParentIs, whenParentIs, whenParentNamed, whenParentTagged };
+export { whenAnyAncestorIs, whenAnyAncestorNamed, whenAnyAncestorTagged, whenAnyAncestorTaggedAll, whenNoAncestorIs, whenNoParentIs, whenParentIs, whenParentNamed, whenParentTagged, whenParentTaggedAll };

package/dist/constructor-type.d.mts

@@ -8,7 +8,7 @@
  *
  * @since 0.3.16-canary.0
  */
-type Constructor<Value = unknown> = new (...args: never[]) => Value;
+type Constructor<Value = unknown> = new (...args: Array<never>) => Value;
 /**
  * Class constructor as invoked by the resolver after metadata-driven
  * resolution of `unknown[]` dependencies — separate from {@link Constructor},
@@ -16,6 +16,6 @@ type Constructor<Value = unknown> = new (...args: never[]) => Value;
  *
  * @since 0.3.16-canary.0
  */
-type ConstructorInvocation = new (...args: unknown[]) => unknown;
+type ConstructorInvocation = new (...args: Array<unknown>) => unknown;
 //#endregion
 export { Constructor, ConstructorInvocation };

package/dist/container.d.mts

@@ -19,9 +19,9 @@ interface Container {
   unbindAll(): void;
   unbindAllAsync(): Promise<void>;
   rebind<const Value>(token: Token<Value> | Constructor<Value>): BindToBuilder<Value>;
-  load(...modules: SyncModule[]): void;
+  load(...modules: Array<SyncModule>): void;
   loadAsync(...modules: Array<SyncModule | AsyncModule>): Promise<void>;
-  unload(...modules: SyncModule[]): void;
+  unload(...modules: Array<SyncModule>): void;
   unloadAsync(...modules: Array<SyncModule | AsyncModule>): Promise<void>;
   loadAutoRegistered(registry: AutoRegisterRegistry): number;
   onActivation<const Value>(token: Token<Value> | Constructor<Value>, handler: ActivationHandler<Value>): void;
@@ -30,8 +30,8 @@ interface Container {
   resolveAsync<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Promise<Value>;
   resolveOptional<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Value | undefined;
   resolveOptionalAsync<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Promise<Value | undefined>;
-  resolveAll<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Value[];
-  resolveAllAsync<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Promise<Value[]>;
+  resolveAll<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Array<Value>;
+  resolveAllAsync<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Promise<Array<Value>>;
   createChild(): Container;
   dispose(): Promise<void>;
   [Symbol.asyncDispose](): Promise<void>;
@@ -40,7 +40,7 @@ interface Container {
   validate(): void;
   has(token: Token<unknown> | Constructor, hint?: ResolveOptions): boolean;
   hasOwn(token: Token<unknown> | Constructor, hint?: ResolveOptions): boolean;
-  lookupBindings<const Value>(token: Token<Value> | Constructor<Value>): readonly BindingSnapshot[];
+  lookupBindings<const Value>(token: Token<Value> | Constructor<Value>): ReadonlyArray<BindingSnapshot>;
   inspect(): ContainerSnapshot;
   generateDependencyGraph(options?: GraphOptions): ContainerGraphJson;
 }
@@ -49,7 +49,7 @@ interface Container {
  */
 interface ContainerStatic {
   create(): Container;
-  fromModules(...modules: SyncModule[]): Container;
+  fromModules(...modules: Array<SyncModule>): Container;
   fromModulesAsync(...modules: Array<SyncModule | AsyncModule>): Promise<Container>;
 }
 /**